运算符
算数运算
比较运算
赋值运算
逻辑运算
数据类型
常用的数据类型：数字（整形，长整型，浮点型，复数），字符串，列表，元组，字典，集合
1整形
整数类型的范围是2**32，其中包含正数和负数（2的31次方个正和2的31次方的个负数）
PS:查看一个数据的类型使用type(数据)方法
#int（整型） 在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647 在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807 #long（长整型） 注意：在Python3里不再有long类型了，全都是int >>> a= 2**64 >>> type(a) #type()是查看数据类型的方法 <type 'long'> >>> b = 2**60 >>> type(b) <type 'int'> #complex复数型 >>> x=1-2j >>> x.imag -2.0 >>> x.real 1.0 其他数据类型（了解部分）
2浮点型
浮点类型就是带小数点的，多余的位数会四舍五入
a=2.5555 b=1.545 type(a) float #float代表浮点数 print(round(a,2)) print(round(b,2)) #round(float,2) #小数点精确的最后一位必须为偶数
3字符串
name = 'alex' #str类的对象 v = name.capitalize() #首字母大写 print(v) name = 'AleX' v = name.casefold() #转换成小写，应用更广，英文、德语等 v = name.lower() #转换小写，主要是英文，跟upper()相反 print(v) name ='alex' v =name.center(20,'*') print(v) name = "aniefnaodoiwjcaanoenfaiw" v = name.count('a',12,15) #计算传入参数的个数 # 起始位置（索引） # 结束位置（索引） print(v) name = 'alex' # 是否以ex结尾 v1 = name.endswith('ex') print(v1) # 是否以al开头 v2 = name.startswith('al') print(v2) 找到制表符 ，进行替换（包含前面的值） name = "a1 e x alex uu kkk" v = name.expandtabs(20) # 的tab变成20倍 print(v) 找到指定子序列的索引位置，不存在返回-1 name = 'alex' v = name.find('l') # print(v) 找索引，不存在则报错 v = name.index('a') name = '我是%s,xxxx' %a tp1 = "我是:{0};年龄:{2};性别:{1}" v= tp1.format('李杰',19,'都行') # v = tp1.format("alex",19,'ok') print(v) tp1 = "我是:{name};年龄:{age};性别:{gender}" v = tp1.format(name='alex',age=19,gender='any') print(v) tp1 = "我是:{name};年龄:{age};性别:{gender}" # v = tp1.format_map('name'='alex','age'=19,'gender'='any') v = tp1.format_map({'name':'alex', 'age':19, 'gender':'any'}) #在format_map中传入的为字典形式 print(v) name = 'alex8好' v = name.isalnum() #判断是否是字母字数汉字，不能包含特殊字符 print(v) v2 = name.isalpha() print(v2) 判断是否是数字 num = '123' v1 =num.isdecimal() #123 v2 =num.isdigit() #123，② v3 =num.isnumeric() #123 ，二，② print(v1,v2,v3) n ='class' v =n.isidentifier() print(v) 是否全部是小写或大写 name = 'ALEx' v = name.isupper() #islower() print(v) 全部转换成大写（小写） 比如验证码 name = 'alex' v = name.upper() #name.lower() print(v) 是否包含隐含的字符类 name = "钓鱼要钓刀鱼， 刀鱼要到岛上钓" v =name.isprintable() print(v) 是否全部是空格 name ='alex' v = name.isspace() print(v) 元素拼接(元素字符串) ***** 必须会 name = 'alex' # v = "_".join(name) #内部循环每个元素 # print(v) #打印结果 a_l_e_x for i in ['海峰','杠娘','李杰']: print(i) name_list = ['海峰','杠娘','李杰'] #元素只能是字符串，不能是数字 v = "搞".join(name_list) print(v) 左右填充 center,rjust,ljust name ='alex' v = name.ljust(20,'*') print(v) 对应关系 + 翻译 name = 'anwoidwoidhawoidhwaoihofeiowiiejaoiej' m = str.maketrans('aeiou','12345') #对应关系 v = name.translate(m) print(v) 分割，保留分割的元素 应用：计算器 content = '李泉SB刘康' v = content.split('SB') v = content.partition('SB') print(v) 替换 content = '李泉SB刘康SB刘浩SB打好' v = content.replace('SB',"love",1) #替换次数为1 print(v) 可指定分割符 name ='alex ' v = name.strip() #去除空白, , print(v) 大小写转换 name = 'Alex' v =name.swapcase() print(v) 填充0的个数 name = 'alex' v =name.zfill(20) print(v) v1 = 'alex' v2 = 'eric' v = v1 + v2 #执行v1的__add__功能 print(v) 字符串功能总结：(常用） name = 'alex' name.upper() name.lower() name.split() name.find() name.strip() name.startswith() name.format() name.replace() 'alex'.join(['a','bb']) ####额外功能： name[0] name[0:3] name[0:3:2] len(name) for循环,每个元素是一个字符
4列表
列表由一系统按特定顺序排列的元素组成，在python中用[]表示列表，并用逗号分隔中间的元素
执行功能； 1.追加 user_list = ['李泉','刘一','刘康','豆豆','小龙'] # 可变类型 user_list.append('刘铭') print(user_list) 2. 清空 user_list = ['李泉','刘一','刘康','豆豆','小龙'] # 可变类型 user_list.clear() print(user_list) 3. 拷贝(浅拷贝) user_list = ['李泉','刘一','刘康','豆豆','小龙'] # 可变类型 v = user_list.copy() print(v) print(user_list) 4. 计数 user_list = ['李泉','刘一','李泉','刘康','豆豆','小龙'] # 可变类型 v = user_list.count('李泉') print(v) 5. 扩展原列表 user_list = ['李泉','刘一','李泉','刘康','豆豆','小龙'] # 可变类型 user_list.extend(['郭少龙','郭少霞']) print(user_list) 6. 查找元素索引，没有则报错 user_list = ['李泉','刘一','李泉','刘康','豆豆','小龙'] # 可变类型 v = user_list.index('小龙') print(v) 7. 删除并且获取元素 - 索引 user_list = ['李泉','刘一','李泉','刘康','豆豆','小龙'] # 可变类型 v = user_list.pop(1) #删除索引位置1的内容 print(v) print(user_list) 8. 删除 - 值 user_list = ['李泉','刘一','李泉','刘康','豆豆','小龙'] # 可变类型 user_list.remove('刘一') print(user_list) 9. 翻转 user_list = ['李泉','刘一','李泉','刘康','豆豆','小龙'] # 可变类型 user_list.reverse() print(user_list) sort排序 直接修改原内容 nums = [11,22,3,4,7,8] print(nums) v1 = nums.sort() print(nums) #排序从小到大 nums.sort(reverse=True) #排序从大到小 print(nums) for i in range(10,0,-1): #倒序 print(i) li = ['eric','alex','tony'] for i in range(0,len(li)): ele = li[i] print(ele) li = ['eric','alex','tony'] for i,ele in enumerate(li,1): #默认i从0开始，写上1则从1开始 print(i,ele) v = input('请输入商品序列号：') v = int(v) item = li[v-1] print(item)
5元组
不能修改的值称为不可变的，不可变的列表称为元组，在python中用()来标识
####元组:tuple *** 不可被修改的列表，不可变类型 user_tuple=('alex','eric','seven','alex') # v = user_tuple[0] #计数 v = user_tuple.count('alex') print(v) #获取值的第一个索引位置 v = user_tuple.index('eric') print(v) ###额外 for i in user_tuple: print(i) v = user_tuple[0:2] print(v) user_tuple=('alex','eric','seven',['chentai','liuhao','james'],'alex') #元组整体不能被修改，元组内的列表可以修改 user_tuple[3][1]='kobe' print(user_tuple) user_tuple=['alex','eric','seven',('chentai','liuhao','james'),'alex'] user_tuple[3]='abc' print(user_tuple) #####元组最后，加逗号 (pay attention) li = ('alex',) print(li)
6字典
一系列的键值对称为字典，在python中用{}来标识，一个键值，一个有效值，key-value形式表示
#####字典：dict dic = {'k1':'v1','k2':'v2'} #清空 dic.clear() #浅拷贝 v = dic.copy() #效果相同，但是get不会报错，默认返回值None(111) v = dic.get('k1',111) v =dic['k1'] #删除并获取对应的value值 v =dic.pop('k1') #随机删除键值对，并获取到删除的键值 k,v =dic.popitem() #('k2':'v2') #增加，如果主键存在则不增加 dic.setdefault('k3','v3') print(dic) dic.setdefault('k2','111') print(dic) #批量增加或修改 dic.update({'k3':'v3','k1':'v24'}) print(dic) print(v) dic = dic.fromkeys(['k1','k2','k3'],123) dic['k1'] = 'ahsiwhi' print(dic) dic =dic.fromkeys(['k1','k2','k3'],[1,]) { k1:123123, #[1,2] k2:123123, #[1,] k3:123123 #fromkeys在生成字典的时候，k1、k2、k3对应的内存地址相同，k1对应的value改变，其他的也跟着改变 dic['k1'].append(222) print(dic) #####额外： 字典可以嵌套 字典key 必须是不可变类型(元组） dic = { 'k1':'v1', 'k2':[1,2,3], (1,2):'111', True:'11a', 1:'a', False:'abc' } print(dic) key 不可变 True,1
7集合
包含多个元素，中间用逗号(,)分割，标识为{}，自带去重功能
主要遵循三个原则
1每个元素必须是不可变类型(可hash,可作为字典的key)
2没有重复的元素
3无序
#####set:集合 s1 = {'alex','eric','tony','kobe','kobe23'} s2 = {'alex','eric','tony','jame'} v = s1.difference(s2) #s1中有s2中没有 print(v) v = s2.difference(s1) #s2存在s1不存在 print(v) v = s1.symmetric_difference(s2) #差集，取两者中的不同 print(v) v= s1.intersection(s2) #交集 v=s1.union(s2) #并集 ####s1中存在，s2中不存在，然后对s1情况，然后在重新赋值 v = s1.difference_update(s2) s1.discard('alex') #移除 s1.update({'alex','123123','fff'}) #更新增加 print(s1) ####额外的 v=s1[0] #不支持索引取值 print(v) s1 = {'alex','eric',(1,2,3)} #集合里只能有元组，不支持列表，集合 for i in s1: print(i)
数据类型总结
数字
字符串
集合：无序，即无序存索引相关信息
元组：有序，需要存索引相关信息，不可变
列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改
按存值个数区分
| 标量／原子类型 | 数字，字符串 |
| 容器类型 | 列表，元组，字典 |
按可变不可变区分
| 可变 | 列表，字典 |
| 不可变 | 数字，字符串，元组 |
按访问顺序区分
| 直接访问 | 数字 |
| 顺序访问（序列类型） | 字符串，列表，元组 |
| key值访问（映射类型） | 字典 |
帮助查看
help(sorted)
类型转换 通过运用类型转换的函数，直接转换
1 十六进制转换十进制 int()函数
In:int('a',16) //base是16，意思'a'是一个16进制的字符串
Out:10
2十进制转换十六进制 hex()函数
In:hex(12)
Out:'0xc'
3字符串转换十进制 int()
In:hex(10)
Out:'0xa'
In:eval(hex(10))
Out:10
4字典转换成列表 dic.items()
In:dic={'a':1,'b':2}
In:dic.items()
Out:[('a',1),('b',2)]
5列表转换成字典 dict(list)
#列表必须由两个元素的列表或元组组成
In:l1=dic.items()
In:dict(l1)
Out:{'a':1,'b':2}
In:l2=['abc',123,('c',60)]
In:dict(l2)
6将纯数字的字符串或数字转换成长整型 long() #在python3中取消了long ，将long的功能整合在了int内
In:help(long)
In:long(12)
Out:12L
7 将纯数字的字符串或者数字转换成浮点数 float()
In:help(float)
In:float(12)
Out:12.0
In:float('12.0')
Out:12.0
8把数字转换成复数 complex()
In:complex(10)
Out:(10+0j)
In:complex('10')
OutL:(10+0k)
9把对象转换成字符串 str()
In:str(12)
Out:'12'
In:str('abc')
Out:'abc'
In:str(('a',1))
Out:"('a',1)"
In:str([range(5)])
Out:[[0, 1, 2, 3, 4]]
In:print(str({'x':1,'y':2}))
Out:{'y': 2, 'x': 1}
10把可迭代对象转换成列表
In:list('abc')
Out:['a','b','c']
In:list((1,2,3))
Out:[1,2,3]
11把可迭代对象转换成元组
In:tuple('123')
Out:('1', '2', '3')
In:tuple(range(5))
Out:(0,1,2,3,4)