# 可变与不可变# 可变：在值改变的情况下，id不变，则证明就是在修改原值，即可变类型# 不可变：在值修改的情况下，id也跟着改变，则证明没法修改原值，而是重新申请内存空间。 即不可变类型
一、数字类型（init和float）
# 说明：Python中没有数字类型一说，通常我们所说的数字类型是int和float类型1、int型（整型）
# 用途： # 记录年龄、等级、及各种号码等 # 定义方式： level=10 # level=int(10)# 只能将纯数字字符串类型的数据转为init型>>> res=int('188')
>>> print(res,type(res))
188 <class 'int'>>>> int('aaaaaaaasdfsadf')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: 'aaaaaaaasdfsadf'# 常用操作及内置方法# 算出运算# 比较运算# 总结：# 只能存一个值# 不可变类型 >>> x=10
>>> print(id(x))
1413600448
>>> x=11
>>> print(id(x))
14136004642、float（浮点型）
# 用途 # 记录工资、身高、体重等 # 定义方式 weight=50.2 # weight=float(50.2)# 其他同int型
二、str(字符串类型)
# 用途：记录描述性质的状态，比如名字、爱好等 # 定义方式： 在单引号、双引号、三引号里包含的一串字符 str="'name=fred' age=15" # str=str("'name=fred' age=15")# 强调： # 三引号可多行 # 引号嵌套类的，里面单引号的，外面必须是双引号或三引号# 可以将任意数据类型转换为str类型
1、优先掌握的常用操作及内置方法
1）、按索引取值（正向取&反向取） 只能取，不能存
userinfo='root:x:0:0:root:/root:/bin/bash' print(userinfo[0]) # 索引号是从0开始的 rprint(userinfo[-1])huserinfo[0]='b'TypeError: 'str' object does not support item assignment # str不支持修改原值
2）切片，从一个大的字符串里切除一个子字符串（顾头不顾尾，步长）
userinfo='root:x:0:0:root:/root:/bin/bash' print(userinfo[0:4]) # 步长不指定，默认是1root # 顾头不顾尾：[0:4]只能取到前四个字符，第五个字符没取到 print(userinfo[0:4:2]) # 取出索引0-4，步长为2进行取ro # 只能取到第一个字符和第三个字符，步长为2，中间隔了1个print(userinfo[6:]) # 从第六个字符开始取，到结束:0:0:root:/root:/bin/bash# 倒着切片，注意方向要一致print(userinfo[-1:-5:-1]) # 反向取值，一定要指定步长hsabprint(userinfo[-1::-1]) # 从反向第一个字符到最后一个，步长为1hsab/nib/:toor/:toor:0:0:x:toorprint(userinfo[::-1]) # 也可不指定头和尾，意指字符头到尾hsab/nib/:toor/:toor:0:0:x:toor
3）、切分split：把一个字符串按照某种分隔符切成一个列表
userinfo='root:x:0:0:root:/root:/bin/bash' print(userinfo.split(':')) # 按照冒号切分 ['root', 'x', '0', '0', 'root', '/root', '/bin/bash']# 注意： # split还有一个参数：最大切分次数，默认是-1，字符串中有多少分隔符，切几次 # 从左往右切userinfo='root:x:0:0:root:/root:/bin/bash'
print(userinfo.split(':',1))['root', 'x:0:0:root:/root:/bin/bash']# rsplit # 从右往左切userinfo='root:x:0:0:root:/root:/bin/bash'
print(userinfo.rsplit(':',3))['root:x:0:0', 'root', '/root', '/bin/bash']4）、join 将列表按照某种分隔符组合一个字符串
userinfo=['root', 'x', '0', '0', 'root', '/root', '/bin/bash'] userinfo_join='|'.join(userinfo) # 将userinfo列表按|,组合成一个字符串 print(userinfo_join) root|x|0|0|root|/root|/bin/bash # 组合的结果
5）、len长度
userinfo='root:x:0:0:root:/root:/bin/bash' print(len(userinfo))31 # 长度为31，所以只能到30 （索引是从0开始的，偷笑）
6）、成员运算in和not in，判断一个字符串是否存在于大的字符串
userinfo='root:x:0:0:root:/root:/bin/bash' print('bin' in userinfo) True print('3' in userinfo) False# not in 取反
7）、strip移除字符串左右两边的指定字符
userinfo='root:x:0:0:root:/root:/bin/bash....root' print(userinfo.strip('root')) :x:0:0:root:/root:/bin/bash.... #规则： # 1、从左边开始找指定字符，直到非指定字符为止 # 2、从右边开始找指定字符，直到非指定字符为止# 注意：# 1、strip() 默认是去除字符串左右两边的空格# 2、strip并不是修改原值，而是重新产生一个新值userinfo='root:x:0:0:root:/root:/bin/bash....root'89149536
print(id(userinfo))
userinfo=userinfo.strip('root')(id(userinfo))88587248# 了解（lstrip rstrip）# lstrip 移除字符串左边的指定字符# rstrip 移除字符串右边的指定字符8）、循环
userinfo='ro' for i in userinfo: print(i) r o# 按索引从头到尾循环
for i in range(0,len(userinfo)):
print(userinfo[i])
2、需要掌握的操作及内置方法
1）lower upper
userinfo='root:x' print(userinfo.upper()) #将字符串中的小写字母转换为大写 ROOT:X# lower 将字符串中的大写字母转换为小写2）startswitch endswitch
userinfo='root:x' print(userinfo.startswith('ro')) # 判断字符串是否以指定字符开头 True print(userinfo.endswith('x')) # 判断字符串是否以指定字符结尾 True
3）、format的三种玩法
print('my name is %s my age is %s' %(18,'fred')) # %s的缺点，占位符和值只能按顺序匹配print('my name is {name} my age is {age}'.format(age=18,name='fred')) #format可以不用根据顺序匹配，指定了变量名 print('my name is {} my age is {}'.format(18,'fred')) # 此种方式，和%s意义一行 print('my name is {0}{0}{0} my age is {1}'.format(18,'fred')) # 可以按索引号多次匹配my name is 181818 my age is fred4）、replace
userinfo='root:x:0:0:root:/root:/bin/bash' print(userinfo.replace('root','fred')) # 如果不指定替换次数，默认全部替换 fred:x:0:0:fred:/fred:/bin/bash print(userinfo.replace('root','fred',1)) # 指定替换次数之后，从左往右依次替换N次 fred:x:0:0:root:/root:/bin/bash5）、isdigit
# 判断字符串是否为纯数字print('fred123'.isdigit())
False
print('1929'.isdigit())
True# 只有在字符串中包含的是纯数字的情况下才结果才为True
3、了解的操作及内置方法
1）、find,rfind,index,rindex,count
# find() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果包含子字符串返回开始的索引值，否则返回-1。 # 从左向右检索# 语法： str.find(str, beg=0, end=len(string))# 参数str 指定检索的字符串beg 开始索引号 默认是0end 结束索引号 默认是len(string)# rfind() 返回字符串最后一次出现的位置(从右向左查询)，如果没有匹配项则返回-1。# index() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，该方法与 python find()方法一样，只不过如果str不在 string中会报一个异常# rindex() 返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常，可以指定可选参数[beg:end]设置查找的区间# count() 方法用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置# 注意：find类都是返回索引号
2）、center,ljust,rjust,zfill
print('我是分隔符'.center(50,'*')) **********************我是分隔符***********************print('我是分隔符'.ljust(50,'=')) 我是分隔符=============================================print('我是分隔符'.rjust(50,'0')) 000000000000000000000000000000000000000000000我是分隔符print('我是分隔符'.zfill(50)) 000000000000000000000000000000000000000000000我是分隔符# zfill() === rjust('0')
3)、end
# 指定字符串后面的空格数# 以九九乘法表为例for x in range(1,10):
for y in range(1,x+1):
print('%sX%s=%s' %(x,y,x*y),end=' ')
print()1X1=1
2X1=2 2X2=4 # 字符结尾+2个空格
3X1=3 3X2=6 3X3=9
4X1=4 4X2=8 4X3=12 4X4=16
5X1=5 5X2=10 5X3=15 5X4=20 5X5=25
6X1=6 6X2=12 6X3=18 6X4=24 6X5=30 6X6=36
7X1=7 7X2=14 7X3=21 7X4=28 7X5=35 7X6=42 7X7=49
8X1=8 8X2=16 8X3=24 8X4=32 8X5=40 8X6=48 8X7=56 8X8=64
9X1=9 9X2=18 9X3=27 9X4=36 9X5=45 9X6=54 9X7=63 9X8=72 9X9=81
str总结：
# 1、str为不可变类型 # 2、是有序的（有索引） # 3、只能存一个值
三、list(列表）
# 用途：用于标识多个值，如一个人有多个爱好 # 定义方式：中括号内用逗号隔开多个任意类型的值
userinfo=['bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin'] # userinfo=list(['bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin'])
# list的工作原理：list(items)
# 1、先定义一个空了表
# 2、然后类似调用一个for循环，从items里取出一个值放入空列表中，循环往复直到值取干净为止
1、优先掌握的常用操作及内置方法
1）、按索引存取值、切片（正向反向存取）：即可存可取
userinfo=['bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin'] print(userinfo[0]) bin print(userinfo[0:3]) ['bin', 'x', '1'] print(userinfo[0:5:2]) ['bin', '1', 'bin'] print(userinfo[-1]) /sbin/nologin print(userinfo[-1::-1]) ['/sbin/nologin', '/bin', 'bin', '1', '1', 'x', 'bin'] print(userinfo[-1:-5:-2]) ['/sbin/nologin', 'bin' print(id(userinfo)) 93973280 userinfo[0]='root' # 指定索引号修改原值 print(userinfo[0],id(userinfo)) root 93973280# 注意：此方式只能修改原值，不能新增（list有其独有的新增方法）userinfo=['bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin']IndexError: list assignment index out of range # 超出了list的最大索引号
userinfo[7]='bash'2）、len(长度)
userinfo=['bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin'] print(len(userinfo))73）、成员运算(in && not in)
print('bin' in userinfo) True print('root' not in userinfo) True4)、追加和插入（append && extend && insert ）
# append() 在列表末尾添加新的元素 # insert() 在指定索引号前插入新元素# extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）userinfo=['bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin'] userinfo.append('this is bin user') # 此方法没有返回值，但是会修改源列表 print(userinfo) ['bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin', 'this is bin user'] userinfo.insert(0,'This is first') # 两个参数，索引号，新元素 同样没有返回值看，但是会修改源列表 print(userinfo) ['This is first', 'bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin']userinfo=['bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin']
userinfo1=['root', 'x', '0', '0', 'root', '/root', '/bin/bash']# 如果不指定userinfo1的起始索引、结束索引、步长，默认将userinfo1的所有内容追加到userinfo中
userinfo.extend(userinfo1[0:5:2])
print(userinfo)
['bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin', 'root', '0', 'root']5）、删除
# 方式1：通用型删除（并非列表的独有删除方式） userinfo=['bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin'] print(userinfo) ['bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin'] #删除前 del userinfo[-1] # 次方法没有返回值 print(userinfo) ['bin', 'x', '1', '1', 'bin', '/bin'] #删除后 # 方式2 remove # remove() 函数用于删除列表中某个值的第一个匹配项。 userinfo=['bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin'] userinfo.remove('bin') # 无返回值，userinfo中bin的第一个匹配项 print(userinfo) ['x', '1', '1', 'bin', '/bin', '/sbin/nologin'] # 方式3 pop # pop() 此方法会删除指定索引号对应的元素，并返回该元素的值 userinfo=['bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin'] print(userinfo.pop()) # 默认删除最后一个索引（-1） /sbin/nologin # 返回该元素的值 print(userinfo) ['bin', 'x', '1', '1', 'bin', '/bin'] print(userinfo.pop(0)) # 可指定索引号 bin print(userinfo) ['x', '1', '1', 'bin', '/bin']6）、循环
userinfo=['bin', 'x'] # 根据索引循环（0,len(userinfo)） for i in userinfo: print(i)2、需要掌握的操作
1）count
# count() 用于统计指定元素在列表中出现的次数 userinfo=['bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin'] print(userinfo.count('bin')) 22）、index
# index() 函数用于从列表中找出某个值第一个匹配项的索引位置 userinfo=['bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin'] print(userinfo.index('bin')) 03）sort
# sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数 list1=[5,2,4,8,9,10] list1.sort() # 默认是升序 print(list1) [2, 4, 5, 8, 9, 10] list1.sort(reverse=True) # reverse=True 降序 [10, 9, 8, 5, 4, 2] print(list1)
练习：
# 列表模拟队列 ：先进先出 # 入队： list=[] list.append('first') list.append('second') list.append('third') print(list) ['first', 'second', 'third'] #出队： print(list.pop(0)) print(list.pop(0)) print(list.pop(0)) first second third # 列表模拟堆栈 先进后出 # 入栈 list=[] list.append('first') list.append('second') list.append('third') print(list) ['first', 'second', 'third'] # 出栈 print(list.pop()) print(list.pop()) print(list.pop()) third second first
总结：
# 1、列表类型可以存多个值 # 2、是有序的 # 3、可变类型
四、dict(字典)
# 用途：存多个种类不同的值 # 定义方式：在{}内用逗号隔开多个元素，每个元素都是key:value的形式。key对value有描述性的功能， # value可以是任意类型，而key必须是不可变类型且唯一 # 即字典可以是int float tuple str 通常是字符串类型
d1={'name':'fred','age':18,'commany':'9you'} # d=dict({'name':'fred','age':18,'commany':'9you'})
d2=dict([['nane','fred'],['age',18]]) # dict转换列表
d3=dict(x=1,y=2,z=3) # dict转换元组
d4={}.fromkeys(('name','age','sex'),None) # 初始化字典
1、优先掌握的常用操作及内置方法
1）、按key存取值
d1={'name':'fred','age':18,'commany':'9you'} print(d1['name']) # 按key取值 fred d1['name']='Li' # 按key改值 print(d1) {'name': 'Li', 'age': 18, 'commany': '9you'}# 新增key
d1['weight']=50.4
print(d1)
{'name': 'fred', 'age': 18, 'commany': '9you', 'weight': 50.4}2）、len(长度)
d1={'name':'fred','age':18,'commany':'9you'} print(len(d1)) # dict len统计的是key的个数3）成员运算（判断的是字典的key）
d1={'name':'fred','age':18,'commany':'9you'} print('name' in d1) True4）、删除
# pop()删除指定key# 字典 pop() 方法删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值 d1={'name': 'fred', 'age': 18, 'commany': '9you', 'weight': 50.4} print(d1.pop('sex',None)) # 如果要pop的key不存在，一定要指定默认返回值，否则会报错 None print(d1) {'name': 'fred', 'age': 18, 'commany': '9you', 'weight': 50.4} print(d1.pop('weight')) # 如果key存在，则返回key对应的值 50.4 print(d1) {'name': 'fred', 'age': 18, 'commany': '9you'}# 字典 popitem() 方法随机返回并删除字典中的一对键和值(一般删除末尾对) #如果字典已经为空，却调用了此方法，就报出KeyError异常。 dict={'name': 'fred', 'age': 18, 'commany': '9you', 'weight': 50.4} print(dict.popitem()) # 以元组形式返回一对键和值 ('weight', 50.4) print(dict.popitem()) ('commany', '9you')
5）、修改key对应的value
# update() 如果key存在，则修改其value。 如果key不存在，则新增 该方法，返回值为None dict={'name': 'fred', 'age': 18, 'commany': '9you'} dict.update({'name':'Li'}) print(dict) {'name': 'Li', 'age': 18, 'commany': '9you'} dict.update({'sex':'male'}) print(dict) {'name': 'Li', 'age': 18, 'commany': '9you', 'sex': 'male'} # setdefault() 如果key值存在，则不修改源，并返回key的值 如果key不存在，则新增此key，并返回其对应的值 dict={'name': 'fred', 'age': 18, 'commany': '9you'} print(dict.setdefault('name','Li')) fred print(dict.setdefault('sex','male')) male print(dict) {'name': 'fred', 'age': 18, 'commany': '9you', 'sex': 'male'}6）、keys values items
Python2.7 和 Python3.6 差别
msg_dic={ 'apple':10, 'tesla':100000, 'mac':3000, 'lenovo':30000, 'chicken':10, } print(msg_dic.items()) [('tesla', 100000), ('mac', 3000), ('lenovo', 30000), ('apple', 10), ('chicken', 10)] print(msg_dic.keys()) ['tesla', 'mac', 'lenovo', 'apple', 'chicken'] print(msg_dic.values()) [100000, 3000, 30000, 10, 10] # 总结：python2.7会把字典中所有的key/value/ietms取出来，然后申请的内存空间，调取list功能把这些key/value一次性存进去。浪费了一倍的内存空间 msg_dic={ 'apple':10, 'tesla':100000, } print(msg_dic.items()) dict_items([('apple', 10), ('tesla', 100000)]) print(list(msg_dic.items())) # 将item转换成Python2的存储形式 [('apple', 10), ('tesla', 100000)] print(msg_dic.keys()) print(type(msg_dic.items()),msg_dic.items()) print(list(msg_dic.keys())) # 将keys转换成Python2的存储形式 ['apple', 'tesla'] print(msg_dic.values()) dict_values([10, 100000]) # 将values转换成Python2存储的形式 print(list(msg_dic.values())) [10, 100000] # 总结： # Python3在此处做了优化，一次性取出来太浪费内存空间，那就将items/keys/values存成dict_items/dict_keys/dict_values这种类型，此类型仅占很小的内存空间 # 如果要取对应key/value/items的值 可通过for循环一个个取7）、循环
msg_dic={ 'apple':10, 'tesla':100000, } for key in msg_dic.keys(): print(key) for values in msg_dic.values(): print(values) for key,values in msg_dic.items(): print(key,values)8）、get
info={'name':'lichunke','age':18,'company':'9you'} print(info.get('name')) lichunke #取一个不存在的key，也不会报错，返回一个空值（也可自定义输出），代码容错性高 info={'name':'lichunke','age':18,'company':'9you'} print(info.get('name11111')) None #自定义输出 info={'name':'lichunke','age':18,'company':'9you'} print(info.get('name11111','null')) null
示例
统计s变量中的每个单词出现的个数#1、比较low的做法s='hello alex alex say hello sb sb' words=s.split() #['hello', 'alex', 'alex', 'say', 'hello', 'sb', 'sb'] d={} for word in words: if word not in d: d[word]=1 # 当word第一次出现，它的次数为1，即value为1 else: d[word]+=1 # 当word第二次出现，则它的次数+1 print(d) {'hello': 2, 'alex': 2, 'say': 1, 'sb': 2} 2、骚操作 s='hello alex alex say hello sb sb' words=s.split() d={} for word in words: d.setdefault(word,words.count(word)) # setdefault 如果key不存在，则新增，如果存在，则不修改原值 print(d)
9）、sorted()对字典的value进行排序
''' sorted(): sorted(iterable,key,reverse)，sorted一共有iterable,key,reverse这三个参数 iterable: 可迭代的对象，例如是dict.items() dict.keys() key: 是一个函数，用来选取参与比较的元素 reverse: 则是用来指定排序是降序还是升序，reverse=true 是降序 reverse=false 是升序 默认是false ''' # sorted函数按value值对字典进行排序 # 要对字典的value排序则需要用到key参数，使用lambda表达式的方法: dic = {'www.abc.com': 2, 'hi.abc.com.cn': 1} res1 = sorted(dic.items(), key=lambda x: x[1], reverse=True) # 结果: [('www.abc.com', 2), ('hi.abc.com.cn', 1)] ''' dic.items()实际上是降dic转换为可迭代对象，迭代对象的元素为('www.abc.com',2)、('hi.abc.com.cn',1),items()方法将字段的元素转化为元组 key参数对应的lambda表达式的意思是选取元组中的第二个元素作为比较参数(key=lambda x: x[0],选取第一个元素作为比较对象 lambda x:y中x表示输出参数 也表示lambda函数的返回值 ) 注意: 排序后的返回值是一个list，而原字典中的元素被转换为list中的元组 '''
总结：
# 1、字典是可变类型 # 2、是无序的 # 3、可以存多个值
五、tuple(元组)
# 用途：不可变的列表 # 定义方式：在小括号内用逗号隔开的多个元素 t=('a','b','c') # t=tuple(('a','b','c')) print(type(t)) <class 'tuple'>
常用操作及内置方法：
1）按索引取值（正向+方向）只能取，不能存改
userinfo=('bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin') print(userinfo[0]) bin print(userinfo[0:6:2]) ('bin', '1', 'bin') print(userinfo[::-1]) ('/sbin/nologin', '/bin', 'bin', '1', '1', 'x', 'bin') print(userinfo[:-5:-2]) ('/sbin/nologin', 'bin') userinfo[1]='bin' TypeError: 'tuple' object does not support item assignment # 元组不支持改值
2）len
userinfo=('bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin') print(len(userinfo)) 7
3）成员运算
userinfo=('bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin') print('bin' in userinfo) True print('root' not in userinfo) True
4）循环
userinfo=('bin', 'x') for i in userinfo: print(i) bin x
4）count
userinfo=('bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin') print(userinfo.count('bin')) 2
5）index
userinfo=('bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin') print(userinfo.index('bin')) 0
总结：
# 1、元组是不可变类型 # 2、是有序的 # 3、可以存多个值
六、set(集合)
# 作用：关系运算 去重 # 定义：大括号内逗号分隔开多个元素， #注意： # 每一个元素必须是不可变类型 # 集合内元素不能重复（本身有去重的作用） # 集合元素是无序的 # s={1,2,3,4,6} # s=set({1,2,3,4,6})print(type(s))
<class 'set'>
# 定义空集合： s=set() # 注意不是 s={} 这就成字典了
1、优先掌握的内置方法和常用操作
1）、关系运算
basket={'apple','pear','orange','banana'}
basket1={'peach','pear','fig','grape'}
# 求两个菜篮子里共有的水果,即求两集合的交集
print(basket & basket1)
print(basket.intersection(basket1))
# 求basket里有的水果，在basket1里没有的，即求两个集合的差集 (有方向的)
print(basket - basket1)
print(basket.difference(basket1))
# 反之就是求basket1里有，而basket里没有的
print(basket1 - basket)
print(basket1.difference(basket))
# 求两个菜篮子里的所有水果,即并集
print(basket | basket1)
print(basket.union(basket1))
# 求没有同时在两个篮子里的水果，即对称差集
print(basket ^ basket1)
print(basket.symmetric_difference(basket1))
2）、子集父集
# 注意:只有两个集合存在包含于包含的关系是，才可以进行大小比较 s1={1,2,3,4} s2={1,2} print(s1 >= s2) # s1是s2的父集 print(s1.issuperset(s2)) # 等同于s1 >= s2 print(s2 <= s1) #反过来s2是s1的子集 print(s2.issubset(s1)) #等同于s2 <= s1
3）、删除元素
s={1,2,3,4}
print(s.pop()) # 随机删除,返回被删除的元素
print(s.discard(2)) # 指定元素删除，返回值为None 如果元素不存在，也不报错
print(s.remove(4)) # 指定元素删除，返回值为None，如果元素不存在，则报错
4）、去重
# 去重： # 局限性： # 不能保证原来的元素顺序 # 针对可变类型不能去重 userinfo=['bin', 'x', '1', '1', 'bin', '/bin', '/sbin/nologin'] s1=set(userinfo) print(s1) {'x', 'bin', '/bin', '1', '/sbin/nologin'}
5）、成员运算和len for循环和其他数据类型一样
练习：
# 需求： #1、列表内的元素有可变类型 #2、去重之后要保持原来顺序 info=[ {'name':'egon','age':18}, {'name':'alex','age':73}, {'name':'egon','age':18}, {'name': 'lxx', 'age': 19}, {'name':'egon','age':18}, {'name':'lxx','age':19}, ] s=[] for i in info: if i not in s: s.append(i) info=s print(info)
[{'name': 'egon', 'age': 18}, {'name': 'alex', 'age': 73}, {'name': 'lxx', 'age': 19}]
总结：
# 1、集合是无序的 # 2、是可变的 # 3、可以存多个值 # 可哈希和不可哈希 # 1、可哈希的数据类型为不可变类型 # 2、不可哈希的数据类型为可变类型