一、数据类型
1.数据类型有哪些
1.整型 int 2.浮点型 float 3.字符串 str 4.布尔型 bool 5.列表 list 6.元组 tuple 7.字典 dict
2.查看数据类型使用type()
eg:age = 18
type(age)
基本上会用内置函数instance()去判断类型
#查看数据类型 age = 18 gender = 'boy' print(type(age))#int print(isinstance(gender,str))#True print(isinstance(gender,int))#False
3.数据类型的转换
int、float→str
str(123) #'123'
str(12.3) #'12.3'
int →float
float(123) #123.0
int、float、str→bool
bool(123) #True
bool(12.3) # True (非o就是True ,o/空就是False)
bool('1') #True
str→int /float （只有数字型字符串：才可以转换为int/float ）
str='123' print(type(int(str))) #int
str='123' print(type(float(str))) #float
float→int / str
int(1.8)是1 ，直接留整数部分，小数部分舍去
❤重点讲解bool()
为0或者空，bool()都是false,
①print（bool(1)）#True
print(bool(0)) #False
print(bool(-1)) #True
②print(bool(''' ''')) #True 不是空字符串，三引号里面有空格，可以参照‘’‘ helloworld’‘’ != '''hello world'''
print(bool('''''')) #False
二、运算符
1.算术运算符 + - * / ** % //
a = 2 b = 4 print(a + b) print(b - a) print(a * b) print(b / a) #2.0
加法+ 可以实现字符串的拼接 列表的相加
#加法 字符串的拼接 str_1='hello' str_2=' pyhton' print(str_1 + str_2) #hello pyhton
#加法 列表的相加 list_1 = [1,2,3] list_2 = [4,5,6] print(list_1 + list_2) #[1, 2, 3, 4, 5, 6]
乘法* 可以实现对 字符串 列表 元组 字典 等的多次输出
str_2='pyhton' list_2 = [4,5,6] print(str_2 * 3) # pyhtonpyhtonpyhton print(list_2 * 2) #[4, 5, 6, 4, 5, 6]
❤重点讲解除法 /
①除法：两个int型的数相除，结果会类型转化，为float
②除数不能为0
a = 10 b = 3 print(a/b)#3.3333
幂运算：**
print(5**-2)#1/25
整除：//
整除，即只留商，舍去余数
print(25/2)#12,
模运算（取余运算）：%
print（25/2）#1 返回结果是余数
print（5/3）#2
模运算运用：
经常用来判断奇偶性，余数为0是偶数，余数为1是奇数
2.赋值运算符
变量的定义就是典型的赋值运算
a = 5 #将5赋值给变量
x += 1 #x = x + 1
y -= 4 #y = y - 4
3.比较运算符 > >= < <= != == 6种
即：比较左右两边的值的大小 == ！= ，返回的结果是bool(True False)
a = 5 b = 8 print(a > b) #False print(a != b) #True
print('get' == 'GET')# False python区分大小写
print(False == 0) # True python 0 等同于false 1 等同于True
print(False == [])# []空列表是false,但是不能等同于
4.逻辑运算符 and or not （结果对应True、False）
and（且）:同时为真，才是真（只要有一个是false,结果就是false,并且）
a = 5 b = 8 print(a > b and b < 10)#False print(a < b and b < 10)#True
or (或)：有一个为真，就是真（全假才是假）
a = 5 b = 8 print(a > b or b < 10)#True print(a < b or b < 10)#True print(a > b or b > 10)#False 全假才是假
not(非)：专门取非运算
print(not False)#True
分不清楚优先级，可以用括号 括起来
5.成员关系运算符 in、 not in （返回的结果是bool : True False）
c = 'vip members include lili,lucy,polo' print('lili' in c)
list_3 = [1,2,3,['hello','python',4,5,6]]
print('python' in list_3[3]) #True
6.优先级总结
以下从左到右：高到低
幂运算** → + -（正负号）→ 算术运算符 → 比较运算符 → 逻辑运算符
三 、字符串
1.什么是字符串
引号括起来的数据类型就是字符串（引号可以是单引号、双引号、三引号（单三引号、双三引号，没区别））
a = 'hello python' print(a)
s_2 = "world"
s_3 = '''lemon'''
s_4 = """best"""
print(type(s_1))
三引号可以表示多行字符串
b = '''人之初，性本善 性相近，习相远 。。。。。 。。。。。''' print(b)
灵活拷问1：
三引号什么时候用来做注释？什么时候用来做字符串？
代码后面需要用到的，就是字符串
不需要使用，用来解释代码的就是注释
灵活拷问2：
1).引号嵌套的时候 单引号只能嵌套双引号 双引号只能嵌套单引号 三引号没有区别
2).三引号可以做多行注释的作用
3).三引号可以保持字符串的格式 双引号需要依赖连接符来连接换行（\）
2.字符串的操作 增删改查
①什么是成员运算符 in 、 not in
c = 'vip members include lili,lucy,polo' print('lili' in c)
②字符串的索引
1）python字符串的取值原理：索引 字符串里面的每个字符都是有下标的，并且是从索引值0（位置1）开始的
下标 == 索引值
2）索引取值方向
正序索引：从0开始
反序索引:从-1开始（从尾巴开始索引）
3）怎么取：字符串名[索引值]
str_1='python' print(str_1[3]) #h print(str_1[-2]) #o
4)索引超出范围 会报错indexerror
str_1 = 'hello' print(str_1[8])
报错：
print(str_1[8])
IndexError: string index out of range
③字符串的切片
切片操作：可以从字符串中获取子字符串（原字符串的一部分）
分片的定义：一对 方括号 起始偏移量start 终止偏移量end 可选的步长 step 来定义一个切片
格式：[start:end:step]
Start:开始的索引值
End:结束的索引值
Step：步长，取值之间的间隔 默认值是1（默认是1的时候，可以不写）
特点：取头不取尾
举例：
s = 'hello python lemon'
print(s[::])#利用切片，实现字符串的复制
print(s[:18])
print(s[0:])
print(s[6:12])#12-6=6,有6个元素，6,7,8,9,10,11----→取头不取尾------正序
print(s[-12:-6])#-----反序
***字符串切片的常规操作***
1).[ : ]---利用切片来复制字符串，
2).[start : ] :从start提取到结尾
3).[ : end]: 从开头提取到end
4).[start : end] :从start取到end
❤提示：end-start 是正、是负
step 是正 是负
判断切片能否正常输出结果：end-start 与step 符号（+ -）相同，就可以正常输出结果
不相同：不报错，也没有输出结果
④字符串的格式化输出
方式1： %d % s % f →占坑
print('''===个人信息===
address：%s
age:%d
salary:%f
''')
结果：
===个人信息===
address：%s
age:%d
salary:%f
上述没有具体格式输出，继续如下
print('''===个人信息===
address：%s
age:%d
salary:%f
''' % ('中央大街',18,23456.89))#按照对应的顺序复制，并做格式化输出
总结：
%S 这个坑位 可以放任意数据（字符串 整数 浮点）
%d %f 只能放数字
❤方式2: 字符串.format()
{ }:占坑
print('''===个人信息===
address：{}
age:{}
salary:{}
''' .format ('中央大街',18,23456.89))
结果：
===个人信息===
address：中央大街
age:18
salary:23456.89
format()：格式化输出，是Python2.6新增的格式化字符串的方法，把传统的%替换为{}来实现格式化输出（%：格式化操作符），相对于老版的%格式方法，有很多的优点。
优点：
1.format()不需要理会数据类型的问题；在%方法中%s只能替代字符串类型。
2.单个参数可以多次输出，参数顺序可以不相同。
3.填充方式十分灵活，对齐方式十分强大。
4.官方推荐使用的方式
format()后面的内容，填入大括号{}中（其中{}花括号表示replacement字段），format（）可以接受2种参数：位置参数、变量（关键字）参数，均传递到replacement字段。
按位置参数
1）.参数按照位置的顺序填充到字符串中，第一个参数是0，然后是1,2,3.......
>>> '{0} love {1}.{2}'.format('I','Fishc','com') #前面的字符串调用format（）方法
'I love Fishc.com'
>>> '{1} love {0}.{2}'.format('I','Fishc','com') #注意位置的替换
'Fishc love I.com'
>>>
2）.不输入数字，直接按照顺序来填充
>>> '{} love {}.{}'.format('I','Fishc','com')
'I love Fishc.com'
>>>
>>> #需要输出{}，可以用{{}}，即{}对自己转义
>>> '{{{0} love {1}}}'.format('I','you')
'{I love you}'
>>>
>>> #一个位置参数可以使用2次
>>> '{{{1} love {0}.{1}}}'.format('fishc','I')
'{I love fishc.I}'
>>>
按关键字参数
>>> #按照关键字参数，format()中要具体写明参数对应的值
>>> '{a} love {b}.{c}'.format('I','Fishc','com')
Traceback (most recent call last):
File "<pyshell#8>", line 1, in <module>
'{a} love {b}.{c}'.format('I','Fishc','com')
KeyError: 'a'
>>> '{a} love {b}.{c}'.format(a = 'I',b = 'Fishc',c = 'com')
'I love Fishc.com'
>>>
综合位置参数、关键字参数（位置参数必须在关键字的前面，否则就是错误的）
>>> #综合 位置参数和关键字参数
>>> '{0} love {b}.{c}'.format('I',b = 'Fishc',c = 'com')
'I love Fishc.com'
>>> '{a} love {b}.{0}'.format(a = 'I',b = 'Fishc','com')
SyntaxError: positional argument follows keyword argument
>>>
总结：
1) { }的个数最好跟format后面括号里面的数据个数保持一致，如果不一致，{}的个数要比数据少
2) Format()括号里面的数据是有索引的，也是从0开始，可以在{ }中指定取值的索引
3) { }里面的要是给定索引值，必须全部都给索引值，不能有的给索引值，有的不给！！！！！！
4) 关键字索引：传参比较多的时候使用，是比较方便的
⑤、字符串中最常用的方法
1.find（）
解释：可以在一个较长的字符串中查找子串，返回子串所在位置的最左端索引（第一次出现的子串），如果没有找到则返回-1.
>>> 'I love Fishc.com'.find('com')
13
>>> title = 'I love fishc.com'
>>> title.find('fishc')
7
>>> title.find('hello')#找不到返回-1
-1
>>>
注意：如果返回值是0，不是布尔型的0，而是在索引位置0找到了子串。例如：
>>> namestr = '$$$ Get Rich Now!$$$'
>>> namestr.find('$$$')
0
>>>
index()函数查找，返回索引值
namestr = '$$$ Get Rich Now!$$$' b = namestr.index('Get') print(b) #4
index()如果找不到，就会报错，（valueerror）
find()添加起始点跟结束点参数
>>> namestr
'$$$ Get Rich Now!$$$'
>>> namestr.find('!$$',1)#只提供起始点
16
>>> namestr.find('!$$')
16
>>> namestr.find('Rich',0,7) #索引位置起始点0，结束点位置7之间没有找到子串
-1
>>>
index(),find()都是找字符串的索引，注意区别：
1.相同点，都是查找索引值
2.不同点：在查找不对目标串的情况下，find()会返回-1，index()是报错-valueerror:substring not found
2.join() 字符串拼接的高级用法
解释：用来连接序列中的元素，是字符串中很重要的方法，是split()方法的逆方法。
注意：需要被连接的序列元素都必须是字符串!!
my_list = ['hello','python','lemon'] print(','.join(my_list)) #hello,python,lemon print(type(','.join(my_list))) #str
dirs = '','user','bin','env' print('C:' + '\\'.join(dirs)) #C:\user\bin\env
3.split()-----返回的结构是列表
解释：将字符串分割成序列，是join()的逆方法。
>>> 'This is a good idea!'.replace('is','ez')
'Thez ez a good idea!'
>>> '1+2+3+4+5'.split('+')
['1', '2', '3', '4', '5']>>> 'I love Fishc.com'.split(' ')
['I', 'love', 'Fishc.com']
>>>
4.lower()
解释：返回字符串的小写字母版。
>>> title = 'I love Fishc.com'
>>> title.lower()
'i love fishc.com'
>>>
5.replace()
解释：返回某字符串的所有匹配项均被替换之后得到的字符串。
>>> 'This is a good idea!'.replace('is','ez') #可以理解为查找并替换
'Thez ez a good idea!'
>>>
6.strip()
解释：（1）不加参数是除去字符串两侧的空格（不含字符串中间的空格）
（2）加参数，是除去两侧的需要去掉的字符
>>> ' I love Fishc.com '.strip()#不加参数
'I love Fishc.com'
>>>
加参数，只会去除字符串两侧的字符，对字符串中间没有影响.
7.count() 查找字符的次数
namelist = "I love you ,but you don't love me." b = namelist.count('you') print(b) #2
