python基础之基本数据类型
Posted zhowhen
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了python基础之基本数据类型相关的知识，希望对你有一定的参考价值。
Python3中的基本数据类型
变量的赋值：
Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。
变量的赋值用=，=左边是变量名，右边是存储在变量中的值。
如：
1 a = 100 # 整数型 2 b = ‘zhow‘ # 字符串 3 c = 520.0 # 浮点型 4 5 print(a) # print 是输出函数，在屏幕上打印 6 print(b) 7 print(c)
多个变量赋值：
Python可以同时对多个变量赋值：
a = b = c = 1 # 赋值后并没有创建了3个1的整型对象，而是只创建了一个1的整型对象，a，b，c都指向了1的内存地址 x, y, z= ‘小红‘, ‘小明‘, ‘小刚‘ # 把‘小红‘, ‘小明‘, ‘小刚‘对应赋值分配给x, y, z；
基本数据类型
Python3中的基本数据类型有：数字（number），字符串（string），列表（list），元组（tuple），集合（set），字典（dict）
其中可变数据：list，set，dict 不可变数据：number，string，tuple
下面依次介绍：
数字（number）
Python3中支持int，float，bool，complex（复数）
数字支持加（+）减（-）乘（*）除（/）等运算
1 a, b = 10, 3 2 3 c = a + b # 加 4 d = a - b # 减 5 e = a * b # 乘 6 f = a / b # 除 7 g = a // b # 整除 取结果的整数部分，小数丢弃 8 h = a % b # 取余，取a除b的余数
Python还支持复数，复数由实数部分和虚数部分组成，可以用a+bj或者complex（a，b）表示，复数的实部a和虚部b都是浮点型。
字符串（string）
1 # Python中的字符串用单引号 ‘ 或双引号 " 括起来，同时使用反斜杠 转义特殊字符。 2 # 定义name = ‘zhow‘ name = str(‘zhow‘) 3 # 单引号和多引号并没有区别，当需要特别标注时可以交叉使用 4 # 如: msg = "I‘m a good boy!" 5 # 多引号什么作用呢？作用就是多行字符串用多引号 6 msg = """ 7 可怕！为什么七十岁老人被恶毒夫妻推下悬崖却无人制止？ 8 为什么七个上身赤裸的男子殴打妇女却被人拍手叫好？ 9 为什么蛇蝎共处一窝却相安无事？ 10 这一切的背后，到底是道德的沦丧，还是人性的泯灭，亦或是社会的悲哀？ 11 如果你想了解这一切，请收看动画片《葫芦娃》!!! 12 """ 13 msg1 = ‘可怕！为什么七十岁老人被恶毒夫妻推下悬崖却无人制止？‘ 14 ‘为什么七个上身赤裸的男子殴打妇女却被人拍手叫好？‘ 15 ‘为什么蛇蝎共处一窝却相安无事？‘ 16 ‘这一切的背后，到底是道德的沦丧，还是人性的泯灭，亦或是社会的悲哀？‘ 17 ‘如果你想了解这一切，请收看动画片《葫芦娃》‘ 18 19 # 由以上对比发现多引号换行是不需要‘’的
字符串的操作：
1 #优先掌握的操作： 2 #1、按索引取值(正向取+反向取) ：只能取 3 # name = ‘zhowhen‘ 4 # print(name[1]) # h 正向下标从0开始 5 # print(name[-1]) # n 反向下标从-1开始 6 #2、切片(顾头不顾尾，步长) 7 # msg = ‘I love Python!‘ 8 # print(msg[2:6]) # love 9 # print(msg[2:6:2]) # lv 10 # print(msg[-7:-1]) # Python 11 # print(msg[7:-1]) # Python 12 #3、长度len 13 # print(len(msg)) # 14 包括空格，符号 14 #4、成员运算in和not in 返回True False 15 # msg = ‘hello world!‘ 16 # print(‘hello‘ in msg) # True 17 # print(‘python‘ in msg) # False 18 #5、移除空白strip 19 # msg = ‘ ***la la la hello*** ‘ 20 # print(msg.strip()) # ***la la la hello*** 移除左右两边的空格，文章中间的不变 21 # msg = ‘ ***la la la hello*** ‘ 22 # print(msg.strip(‘ *‘)) # la la la hello 组合使用‘ *‘ 移除左右两边的空格和* 23 # mse = ‘*****user******‘ 24 # print(mse.strip(‘*‘)) # user 移除左右两边的* 25 # msg = ‘** * /user is nice */*** *‘ 26 # print(msg.strip(‘* /‘)) # user is nice 27 #6、切分split 返回的结果是一个列表 28 IP= ‘192.168.0.1:8000‘ 29 res = IP.split(‘:‘) 30 print(res) # [‘192.168.0.1‘, ‘8000‘] 31 #7、循环 32 msg = ‘Shit happens,but life goes on‘ 33 for i in msg: # for是用于循环，后续会介绍 34 print(i)
其他常用操作：
1 # 一些常用操作 2 # 1、strip , lstrip , rstrip 去空格，只去左边，只去右边 3 # 2、lower, upper 字符串小写，大写 4 # 3、startswith, endwith 判断字符串开头和结尾的 5 # 4、format的三种用法 6 # 5、split, rsplit 分割， 7 # 6、join，只能连接包含元素全部为字符串类型的列表 8 # 7、replace 替换字符串的某个字符，类似word查找替换 9 # 8、isdigit 判断字符串是否是纯数字 10 # 9、istitle 判断首字母是不是大写
示例：
1 # 1、strip , lstrip , rstrip 2 print(‘***hello***‘.lstrip(‘*‘)) # hello*** 3 print(‘***hello***‘.rstrip(‘*‘)) # ***hello 4 # 2、lower, upper 字符串小写，大写 5 msg = ‘AbandoN‘ 6 print(msg.lower()) # abandon 7 print(msg.upper()) # ABANDON 8 # 3、startswith, endwith 判断字符串开头和结尾的 9 print(msg.startswith(‘a‘)) # False 10 print(msg.startswith(‘A‘)) # True 11 print(msg.endswith(‘N‘)) # True 12 # 4、format的三种用法 13 print("I am {},i‘m {} years old".format(‘zhow‘, 18)) 14 print("I am {name},i‘m {age} years old".format(name=‘zhow‘, age=18)) 15 print("I am {name},i‘m {age} years old".format(**{‘name‘:‘zhow‘, ‘age‘:18})) 16 # 5、split, rsplit 分割， 17 info = ‘1000:2222:3333‘ 18 print(info.split(‘:‘, 1)) # [‘1000‘, ‘2222:3333‘] 默认左边开始等价lsplit 19 print(info.rsplit(‘:‘, 1)) # [‘1000:2222‘, ‘3333‘] 从右边开始 20 # 6、join，只能连接包含元素全部为字符串类型的列表 21 l = ‘d/root/bin/src/bash/start‘ 22 str_2_list = l.split(‘/‘) 23 print(str_2_list) # [‘d‘, ‘root‘, ‘bin‘, ‘src‘, ‘bash‘, ‘start‘] 24 list_2_str = ‘/‘.join(str_2_list) 25 print(list_2_str) # d/root/bin/src/bash/start 26 # 7、replace 替换字符串的某个字符，类似word查找替换 27 mge = ‘xxx call xxx bitch‘ 28 print(mge.replace(‘xxx‘, ‘sb‘)) # sb call sb bitch 29 # 8、isdigit 判断字符串是否是纯数字 30 print(mge.isdigit()) # False 31 # 9、istitle 判断首字母是不是大写 32 a = ‘Abcd Efg‘ 33 print(a.istitle()) # True
补充：
1 # 补充（了解） 2 # 1、find，rfind,index,rindex，count 3 msg = ‘hello zhow world !‘ 4 print(msg.find(‘w‘)) # 9 返回w的起始位置（左边第一个） 5 print(msg.rfind(‘w‘)) # 11 返回最右边的起始位置 6 print(msg.find(‘zhow‘,0,3)) # 没有找到返回 -1 7 print(msg.index(‘zhow‘)) # 没有找到，报错，正常的情况下和find一样 8 print(msg.count(‘w‘)) # 2 w出现的次数 9 # 2、center，ljust,rjust，title 10 print(‘info‘.center(50, ‘=‘)) # =======================info======================= 11 print(‘info‘.ljust(50, ‘=‘)) # info============================================== 12 print(‘info‘.rjust(50, ‘=‘)) # ==============================================info 13 print(‘info‘.zfill(50)) # 0000000000000000000000000000000000000000000000info 14 # 3、expandtabs 把字符串中的 tab 符号(‘ ‘)转为空格，tab 符号(‘ ‘)默认的空格数是 8。 15 print(r‘a b‘) # a b 16 print(‘a b‘) # a b 17 print(‘a b‘.expandtabs(1)) # a b 转换成一个空格 18 # 4、captalize，swapcase,title 19 print(‘abc‘.capitalize()) # 首字母大写 20 print(‘Ab‘.swapcase()) # 字母大小写交互 21 print(‘my name is user‘.title()) # 全部首字母大写 22 # 5、is数字系列,isdigit,isnumeric,isdecimal 23 num1 = b‘4‘ # bytes 24 num2 = u‘4‘ # unicode,python3中无需加u就是unicode 25 num3 = ‘四‘ # 中文数字 26 num4 = ‘Ⅳ‘ # 罗马数字 27 print(num2.isdigit()) # True 检测字符串是否只由数字组成。 28 print(num2.isnumeric()) # True 检测字符串是否只由数字组成。只在Unicode里 29 print(num2.isdecimal()) # True 检查字符串是否只包含十进制字符。 30 num5 = ‘肆‘ 31 print(num5.isnumeric()) # True 32 # 6、is 其他 33 print(‘ ‘.isspace()) # 判断字符串中是否有空格 34 print(‘agaga‘.isalpha()) # 判断字符串中是否全部是字母 35 print(‘agaga123‘.isalnum()) # 判断字符串是否由字母或数字组成
常用操作归纳：
- upper() # 转换字符串中的小写字母为大写。 - title() # 返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())。 - lower() # 转换字符串中所有大写字符为小写。 - split() # 按指定字符或符号分割 - strip() # 删除字符串字符串左右两边的空格或指定字符. - rstrip() # 删除字符串字符串末尾的空格或指定字符. - lstrip() # 截掉字符串左边的空格或指定字符。 - max(str) # 返回字符串 str 中最大的字母。 - min(str) # 返回字符串 str 中最小的字母。 - join(seq) # 以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
列表（list）
# 在[]内用逗号分隔，可以存放n个任意类型的值 # 定义：students = [‘egon‘, ‘alex‘, ‘wupeiqi‘, ] # students=list([‘egon‘,‘alex‘,‘wupeiqi‘,]) # 用于标识：存储多个值的情况，比如一个人有多个爱好 # 多维列表，存放多个学生的信息：姓名，年龄，爱好 students_info = [[‘egon‘, 18, [‘play‘, ]], [‘alex‘, 18, [‘play‘, ‘sleep‘]]] print(students_info[0][2][0]) # play 取出第一个学生的第一个爱好
列表的操作：
1、按索引存取值(正向存取+反向存取)：即可存也可以改；超出索引就会报错 2、切片(顾头不顾尾，步长) 3、长度 4、成员判断运算in和not in 5、追加也插入 6、删除 7、从列表中取走一个元素，相当与删除，但有返回值 8、循环 9、合并
10、排序
示例：
1 list1 = [1, 2, 3, 4, 5, 6] 2 list2 = [‘a‘, ‘b‘, ‘z‘, ‘d‘, ‘e‘, ‘f‘] 3 1、按索引存取值(正向存取+反向存取)：即可存也可以改；超出索引就会报错 4 print(list1[5]) # 6 5 print(list2[-2]) # e 6 2、切片(顾头不顾尾，步长) 7 print(list2[0:3:2]) # [‘a‘, ‘c‘] 8 print(list2[0:3:-1]) # []取空了 9 print(list2[3:0:-1]) # [‘d‘, ‘c‘, ‘b‘] -1代表反向取（由后往前） 10 print(list2[-1::-1]) # [‘f‘, ‘e‘, ‘d‘, ‘c‘, ‘b‘, ‘a‘]列表反转 11 3、长度 12 print(len(list1)) # 6 13 4、成员判断运算in和not in 14 print(‘a‘ in list2) # True 15 print(1 not in list1) # False 16 5、追加也插入 17 list1.append(7) # 最后的位置添加 18 print(list1) # [1, 2, 3, 4, 5, 6, 7] 19 list1.insert(2, 10) # 指定下标位置添加 原来位置的后移 20 print(list1) # [1, 2, 10, 3, 4, 5, 6, 7] 21 6、删除 22 del list2[2] # 删除指定下标的值，不存在报错 23 list1.remove(5) # 删除指定值，不存在报错 24 print(list1) # [1, 2, 3, 4, 6] 25 print(list2) # [‘a‘, ‘b‘, ‘d‘, ‘e‘, ‘f‘] 26 7、从列表中取走一个元素，相当与删除，但有返回值 27 res = list2.pop(2) # 按照索引删除元素并返回 28 resg = list2.pop() # 删除最后一个元素并返回 29 print(res) # c 30 print(resg) # f 31 8、循环 32 for i in list2: 33 print(i) 34 9、合并 35 list2.extend(list1) # 把list1合并到list2中，从后面追加的方式，list1不变 36 print(list2) # [‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘, ‘f‘, 1, 2, 3, 4, 5, 6] 37 10、排序 38 list3 = [‘6‘, ‘5‘, ‘4‘, ‘3‘, ‘2‘, ‘1‘] 39 list3.sort() # 从小到大 40 print(list3) # [‘1‘, ‘2‘, ‘3‘, ‘4‘, ‘5‘, ‘6‘]
带索引的循环：
list1 = [1, 2, 3, 4, 5, 6] for index, item in enumerate(list1): print(index, item)
其他常用操作：
1、反转 2、计数 3、清空 4、复制 5、查看索引
示例：
1 names = [‘aa‘, ‘bb‘, ‘cc‘, ‘bb‘, 1, 2, 3, 4] 2 names.reverse() # 反转 3 print(names) 4 a = names.count(‘bb‘) # 计算个数 5 print(a) 6 names.clear() # 清空列表。相当于把列表的元素全部删除 7 print(names) 8 9 names = [‘aa‘, ‘bb‘, ‘cc‘, ‘bb‘, 1, 2, 3, 4] 10 list1 = names.copy() # 复制 11 # list1 = names[:] # 复制 12 print(list1) 13 print(names.index(‘cc‘))
列表常用操作归纳：
- list.append(obj) # 在列表末尾添加新的对象 - list.count(obj) # 统计某个元素在列表中出现的次数 - list.extend(seq) # 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） - list.index(obj) # 从列表中找出某个值第一个匹配项的索引位置 - list.insert(index, obj)# 将对象插入列表指定位置 - list.pop(obj=list[-1]) # 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值 - list.remove(obj) # 移除列表中某个值的第一个匹配项 - list.reverse() # 反向列表中元素 - list.sort([func])# 对原列表进行排序 reverse=True表示降序 - list.clear() # 清空列表 - list.copy() # 复制列表
元组（tuple）
元祖跟列表类似，称为不可变列表。
元组使用小括号，列表使用方括号。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
tup1 = (‘Google‘, ‘Runoob‘, 1997, 2000); tup2 = (1, 2, 3, 4, 5 ); tup3 = "a", "b", "c", "d"; # 不需要括号也可以 print(type(tup3))
常用方法：
- len(tuple) # 计算元组元素个数。 - max(tuple) # 返回元组中元素最大值。 - min(tuple) # 返回元组中元素最小值。 - tuple(seq) # 将列表转换为元组。
字典（dict）
字典是另一种可变容器模型，且可存储任意类型对象。 字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示： d = { ‘name‘: ‘zhow‘, ‘age‘: 18, ‘hobby‘: [‘beauty‘, ‘travel‘, ‘read‘] ‘company‘: { ‘name‘: ‘oldboy‘, ‘type‘: ‘education‘, ‘emp_num‘: 40 } } 字典的key必须为python中不可变类型，value可以为任意类型对象
常用操作：
1、按key存取值：可改可取,可存 2、长度len 3、成员运算in和not in，判断字典的key 4、删除 5、键keys()，值values()，键值对items() 6、循环 7、变量赋值
示例：
1 d = { 2 ‘name‘: ‘zhow‘, 3 ‘age‘: 18, 4 ‘hobby‘: [‘beauty‘, ‘travel‘, ‘read‘], 5 ‘company‘: { 6 ‘name‘: ‘oldboy‘, 7 ‘type‘: ‘education‘, 8 ‘emp_num‘: 40 9 } 10 } 11 1、按key存取值：可改可取,可存 12 print(d[‘name‘]) # zhow 13 print(d.get(‘name‘)) # zhow 没有不报错为 None 14 print(d[‘hobby‘][1]) # travel 15 print(d[‘company‘][‘name‘]) # oldboy 16 print(d.get(‘company‘).get(‘name‘)) # oldboy 17 2、长度len 18 print(len(d)) 19 3、成员运算in和not in，判断字典的key 20 print(‘name‘ in d) # 判断key是否在字典里 21 4、删除 22 del d[‘age‘] # 删除d中对应的key和值 23 print(d) 24 print(d.popitem()) # 随机删除返回删除的item元组,(‘hobby‘, [‘beauty‘, ‘travel‘, ‘read‘]) 25 print(d.pop(‘aaa‘, None)) # 删除指定的key的值 返回value 没有就返回None 26 print(d) 27 5、键keys()，值values()，键值对items() 28 print(d.keys()) # 类似列表 里面值为一个个key 29 print(d.values()) # 类似列表 里面值为一个个value 30 print(d.items()) # 类似列表 里面值为一个个元组 31 6、循环 32 for k, v in d.items(): 33 print(k, v) 34 for k in d: 35 print(k, d[k]) 36 37 7、变量赋值 38 d[‘girlfriends‘] = {‘苍老师‘, ‘波老师‘, ‘泷泽萝拉‘} 39 print(d) 40 d.update(**{‘girlfriends‘: {‘苍老师‘, ‘波老师‘, ‘泷泽萝拉‘}}) 41 print(d) 42 补充 43 li = [1, 2, 3] 44 x, y, z = li # 将列表的值对应赋给x，y，z 45 print(x, y, z) 46 li2 = [1, 2, 3, 4, 5, 6] 47 x, y, z, *_ = li2 # 将列表前面的值对应赋给x，y，z，多余的以切片的方式赋值给_ 48 print(x, y, z, _) # 1 2 3 [4, 5, 6] 49 m = 10 50 n = 11 51 m, n = 11, 10 52 print(m, n)
字典的其他操作：
1 d.copy()字典浅拷贝 2 d.fromkeys(seq[val]) 创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值 3 d.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
示例：
1 d.copy()字典浅拷贝 2 e = d.copy() 3 print(e) 4 d.fromkeys(seq[val]) 创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值 5 e = {}.fromkeys([‘name‘, ‘age‘, ‘sex‘], ‘初始值‘) 6 print(e) # {‘name‘: ‘初始值‘, ‘age‘: ‘初始值‘, ‘sex‘: ‘初始值‘} 7 d.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default 8 print(d.setdefault(‘name‘, 500)) # key存在，则不改变key对应的值，返回原值 9 print(d) 10 print(d.setdefault(‘g‘, 500)) # key不存在，则增加值，返回增加的值 11 print(d)
字典的两个运用：
1、基于 setdefault 的小例题，用字典统计下面字符串的个数s = ‘hello user user say hello sb sb user sb‘ 2、对列表L=[1,2,2,3,3,4,5,6,6,7]去重
1 # 题一 2 s = ‘hello user user say hello sb sb user sb‘ 3 words = s.split() 4 d = {} 5 for i in words: 6 if i not in d: 7 d[i] = 1 8 else: 9 d[i] += 1 10 print(d) 11 # 优化版 12 # for i in words: 13 # d.setdefault(i, words.count(i)) 14 # print(d) 15 # 题二 16 L = [1, 2, 2, 3, 3, 4, 5, 6, 6, 7] 17 d = {}.fromkeys(L, ‘1‘) 18 print(d) 19 l = list(d.keys()) 20 print(l)
字典常用操作归纳：
1 - popitem() # 随机返回并删除字典中的一对键和值(一般删除末尾对)。 2 - key in dict # 如果键在字典dict里返回true，否则返回false 3 - radiansdict.copy() # 返回一个字典的浅复制 4 - radiansdict.keys() # 以类列表返回一个字典所有的键 5 - radiansdict.items() # 以类列表返回可遍历的(键, 值) 元组数组 6 - radiansdict.clear() # 删除字典内所有元素 7 - radiansdict.values() # 以类列表返回字典中的所有值 8 - radiansdict.fromkeys() # 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值 9 - radiansdict.update(dict2) # 把字典dict2的键/值对更新到dict里 10 - radiansdict.get(key, default=None) # 返回指定键的值，如果值不在字典中返回default值 11 - radiansdict.setdefault(key, default=None) # 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default 12 - pop(key,default) # 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
集合（string）
#集合定义 set1 = {‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘} set2 = set([1, 2, 3, 4, 5]) print(set1) print(set2) # 集合跟字典类似，只有字典的key，没有字典的value ，所以集合也是无序的，无重复元素的
集合操作：
一、集合的运算
# 1、 | 并集 ==> union 包含a，b集合的所有元素，而且不包含其他元素 # 2、 & 交集 ==> intersection 包含的元素a，b都有，而且不包含其他元素 # 3、 - 差集 ==> difference 包含的元素a有b没有 # 4、^ 对称差集 ==> symmetric_difference 包含的元素要么a有b没有，要么b有a没有 # 5、>,>= 父集 ==> issuperset a包含b中所有元素，而且还有其他b中没有的元素 # 6、<,<= 子集 ==> issubset 跟父集相反 # 7、 == 等于运算 ==> a，b里面的元素一样 # 8、判断是否没有共同部分 ==> isdisjoint 有False,没有True
示例：
1 a = {‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘, ‘f‘, ‘g‘} 2 b = {‘1‘, ‘2‘, ‘3‘, ‘4‘, ‘a‘, ‘b‘, ‘d‘} 3 4 # 1、 | 并集 ==> union 包含a，b集合的所有元素，而且不包含其他元素 5 print(a.union(b)) # {‘1‘, ‘2‘, ‘c‘, ‘f‘, ‘e‘, ‘3‘, ‘4‘, ‘g‘, ‘d‘, ‘a‘, ‘b‘} 6 print(a | b) # {‘1‘, ‘2‘, ‘c‘, ‘f‘, ‘e‘, ‘3‘, ‘4‘, ‘g‘, ‘d‘, ‘a‘, ‘b‘} 7 # 2、 & 交集 ==> intersection 包含的元素a，b都有，而且不包含其他元素 8 print(a.intersection(b)) # {‘d‘, ‘a‘, ‘b‘} 9 print(a & b) # {‘d‘, ‘a‘, ‘b‘} 10 # 3、 - 差集 ==> difference 包含的元素a有b没有 11 print(a.difference(b)) # {‘c‘, ‘e‘, ‘g‘, ‘f‘} 12 print(a - b) # {‘c‘, ‘e‘, ‘g‘, ‘f‘} 13 # 4、^ 对称差集 ==> symmetric_difference 包含的元素要么a有b没有，要么b有a没有 14 print(a.symmetric_difference(b)) # {‘2‘, ‘1‘, ‘e‘, ‘f‘, ‘3‘, ‘g‘, ‘4‘, ‘c‘} 15 print(a ^ b) # {‘2‘, ‘1‘, ‘e‘, ‘f‘, ‘3‘, ‘g‘, ‘4‘, ‘c‘} 16 # 5、>,>= 父集 ==> issuperset a包含b中所有元素，而且还有其他b中没有的元素 17 print(a.issuperset(b)) # False 18 print(a >= b) # False 19 # 6、<,<= 子集 ==> issubset 跟父集相反 20 # 7、 == 等于运算 ==> a，b里面的元素一样 21 print(a == b) # False 22 # 8、判断是否没有共同部分 ==> isdisjoint 有False,没有True 23 print(a.isdisjoint(b)) # False
二、集合的方法
1 update 更新原数据 2 add 添加元素 3 discard 删除元素，没有返回值，不存在不报错 4 remove 删除元素，没有返回值，不存在报错 5 pop 随机删除，有返回值 6 clear 清空集合
示例
1 set1 = {‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘, ‘f‘, ‘g‘} 2 update 是否更新原数据 3 set1.update(‘h‘) # 接收单值 4 set1.update({‘i‘, ‘j‘, ‘k‘}) # 接收集合 5 set1.update([‘x‘, ‘y‘, ‘z‘]) # 接收列表（元组） 6 print(set1) 7 add 添加元素 8 set1.add(‘h‘) # 只接收不可变的类型 9 print(set1) 10 discard 删除元素，没有返回值，不存在不报错 11 set1.discard(‘c‘) # 删除元素，无返回值 12 print(set1) 13 remove 删除元素，没有返回值，不存在报错 14 set1.remove(‘h‘) # 删除元素，没有返回值，不存在报错 15 print(set1) 16 pop 随机删除，有返回值 17 res = set1.pop() 18 print(res) 19 print(set1) 20 clear 清空集合 21 set1.clear() 22 print(set1) # set() 23 备注：{}代表的是一个空字典，空集合用set()表示
去重优化：
# 对列表L=[1,2,2,3,3,4,5,6,6,7]去重 L = [1, 2, 2, 3, 3, 4, 5, 6, 6, 7] l = list(set(L)) print(l) # PS:用集合去重，局限性很强 # 1、不能保证原数据类型的顺序 # 2、原数据中包含的元素必须全部为不可变类型
集合常用操作归纳：
- set1 = set({1, 2, ‘barry‘}) # 创建集合
- set2 = {1, 2, ‘barry‘} # 创建集合
- add # 将元素添加到集合中。如果元素已经存在，这不起作用。
- del set1 # 删除集合
- update # 迭代增加
- clear # 删除此集合中的所有元素
- remove # 删除一个元素
- pop # 随机删除一个元素
- issubset # 子集
- issuperset # 父集
- union # 并集。（| 或者 union）
- difference # 差集。（- 或者 difference）
- intersection # 交集。（& 或者 intersection）
- isdisjoint # 如果两个集合有一个交点，则返回Flase
- intersection_update # 用它自己和另一个交集更新一个集合。
- difference_update # 删除另一个集合中本集合所拥有的所有元素
- symmetric_difference # 反交集。 （^ 或者 symmetric_difference）