目录
3.4 f-string方法格式化字符串(python3.6)
3.5 使用等号来拼接运算表达式与结果(python3.8)
上一篇:02 Python3基础:变量的定义_卡卡6的博客-CSDN博客
一、Python数据类型简介
Python3 有六种标准的数据类型:
(1)Number(数字):int、float、bool、complex(复数类型)
(2)String(字符串):Python中的字符串用单引号 ' 或双引号 " 括起来,同时使用反斜杠\转义特殊字符(自己套自己的时候)
(3)List(列表):List是 Python 中使用最频繁的数据类型,列表可以完成大多数集合类的数据结构实现
(4)Tuple(元组):元组(tuple)与列表类似,不同之处在于元组的元素不能修改。元组写在小括号 () 里,元素之间用逗号隔开,元组中的元素类型也可以不相同
(5)Set(集合):集合是由一个或数个形态各异的大小整体组成的,构成集合的事物或对象称作元素或是成员
(6)Dictionary(字典):字典(dictionary)是Python内置数据类型
二、Python数据类型
1. 数字数据类型
1.1 Python支持的数值类型
(1)整型(int) 通常被称为是整型或整数,是正或负整数,不带小数点。Python3 整型是没有限制大小的,可以当作 Long 类型使用,所以 Python3 没有 Python2 的 Long 类型。
整数可以使用二进制(0b)、八进制(0o)、十进制、十六进制(0x)来表示。
(2)布尔值只有True、False两种值(真和假),要么是True,要么是False,在Python中,可以直接用True、False表示布尔值(首字母大写)。
(3)浮点型(float) 浮点型由整数部分与小数部分组成,浮点型也可以使用科学计数法表示(2.5e2 = 2.5 x = 250)。
(4)复数( complex) :复数由实数部分和虚数部分构成,可以用a + bj或者complex(a,b)表示, 复数的实部a和虚部b都是浮点型。
示例代码
#!/usr/bin/python3 data1=0b1000010 #二进制 data2=0o102 #八进制 data3=66 #十进制 data4=0x42 #十六进制 float_data=123.456 #浮点数 print ("data1=", data1) print ("data2=", data2) print ("data3=", data3) print ("data4=", data4) print ("float_data=", float_data) |
运行结果:对于整型数据(2/8/16进制),print默认以10进制数打印。
ata1= 66 data2= 66 data3= 66 data4= 66 float_data= 123.456 |
1.2 Python内置数据类型转换方法
Python提供了很多内置数据类型转换方法,如果需要对数据类型做转换,只需要将数据类型作为函数名传参即可。常用的类型转换函数如下:
int(x) | 将x转换为一个整数返回 |
float(x) | 将x转换到一个浮点数 |
complex(x) | 将x转换到一个复数,实数部分为 x,虚数部分为0 |
complex(x, y) | 将x和y转换到一个复数,实数部分为x,虚数部分为y。x和y是数字表达式。 |
hex(x) | 把一个整数转换为十六进制字符串 |
oct(x) | 把一个整数转换为八进制字符串 |
ord(x) | 返回对应的 ASCII 数值或者 Unicode 数值 |
str(x) | 将数字转化为String |
bin(x) | 将一个数字转为二进制字符串 例如: #!/usr/bin/python3 a=0x38 print(bin(a)) 输出结果: 0b111000 |
示例代码
#!/usr/bin/python3 int_data="123" print(int(int_data)) #将字符串转为整数 print(hex(1234)) #将整数1234转换为十六进制字符串 print(oct(1234)) #将整数1234转换为八进制字符串 print(ord('A')) #返回字符对应的ASCII数值 f_data="123.456" print(float(f_data)) #将f_data转换成一个浮点数 data=6789 print(str(data)) #将data转化为String |
运行结果
123 0x4d2 0o2322 65 123.456 6789 |
注:字符串类型要转成对应的数据类型才可以参与数值计算,例子如下:
dat0=0b1010 dat1=0o12 dat2=10 dat3=0xA dat4="20.23" print("dat0", dat0) print("dat1", dat1) print("dat2", dat2) print("dat3", dat3) print("dat4", dat4-0.23) #报错:TypeError: unsupported operand type(s) for -: 'str' and 'float' #print("dat4", float(dat4)-0.23) #结果是20.0 |
2. 字符串类型
2.1 创建字符串
字符串是Python中最常用的数据类型,字符串是以单引号'或双引号"括起来的任意文本,比如:
#!/usr/bin/python3 str1 = 'Hello World!' str2 = "i am python" |
2.2 字符串转义
如果字符串内部包含'和"可以用转义字符\来转义,比如:
#!/usr/bin/python3 str="\"What\'s your name?\"" print(str) |
转义字符\可以转义很多字符,字符\本身也要转义,如果想输出\字符,代码里需要写两个\\,比如:
str="\\" print(str) |
如果字符串里面有很多字符都需要转义,就需要加很多转义符\,为了简化,Python还允许用r'xxxxxxxxxx'表示' xxxxxxxxxx '内部的字符串默认不转义,比如:
#!/usr/bin/python3 str=r'"What is your name?"' print(str) |
2.3 字符串跨行显示
python允许一个字符串跨多行,这个字符串需要用三引号包含起来,字符串中可以包含换行符、制表符以及其他特殊字符。使用这种方法在编写HTML代码或者SQL语句时会特别的方便,不需要频繁的转义。
三引号可以使用''' 或者 """ 表示。 (三个单引号或者三个双引号)
示例代码:
#!/usr/bin/python3 str = """欢迎\n学习Python"编程语言"[\t]""" print(str) |
运行输出:
欢迎 学习Python"编程语言"[ ] |
3. 字符串处理
3.1 提取字符串数据
Python不支持单字符类型,单字符在 Python 中也是作为一个字符串使用,Python可以使用方括号和下标组合来截取指定位置的字符串,取头不取尾,可以理解为数学概念上的区间,如:str[n:m]= [n,m)。缺头表示头为0(为[0, m)),缺尾表示全部取。
实例代码:
#!/usr/bin/python3 str = "欢迎学习Python编程语言" print("str[1]=", str[1]) #取出字符串里的第一个数据 print("str[2:4]=",str[2:4]) #取出字符串里2~4位置的数据 print("str[4:10]=",str[4:10]) #取出4~10之间的数据 print("str[:10]=",str[:10]) #取出0~10之间的数据 print("str[0:]=",str[0:]) #取出全部数据 |
运行结果
str[1]= 迎 str[2:4]= 学习 str[4:10]= Python str[:10]= 欢迎学习Python str[0:]= 欢迎学习Python编程语言 |
注:(1)下标从0开始【跟C语言相似】(2)取头不取尾 (3)尾部省略表示全取,头部省略表示从0开始
3.2 字符串拼接
Python支持截取目标字符串的一部分并与其他字符串拼接,对加号是可重载的,实例代码:
#!/usr/bin/python3 str = "欢迎学习Python编程语言" str = str[:4] +"前端语音" str = str + "信号处理" print(str) |
运行结果:
欢迎学习前端语音信号处理 |
3.3 Python字符串%格式化输出
在许多编程语言中都包含有格式化字符串的功能,比如C语言中的格式化输入输出。Python中内置有对字符串进行格式化的操作% 。
格式化字符串时,Python使用一个字符串作为模板,模板中有格式符,这些格式符为真实值预留位置,并说明真实数值应该呈现的格式,注意前后的对应关系。
示例代码
#!/usr/bin/python3 print("My name is %s" % ("jonn")) print("我每天%d点上班,每天晚上去%s散步!" % (8,"附近公园")) |
代码里的%代表了格式化操作。
运行输出
My name is jonn 我每天8点上班,每天晚上去附近公园散步! |
python字符串格式化符号:
符号 | 描述 |
%c | 格式化字符及其ASCII码 |
%s | 格式化字符串 |
%d | 格式化整数 |
%u | 格式化无符号整型 |
%o | 格式化无符号八进制数 |
%x | 格式化无符号十六进制数 |
%X | 格式化无符号十六进制数(大写) |
%f | 格式化浮点数字,可指定小数点后的精度 |
%e | 用科学计数法格式化浮点数 |
%E | 作用同%e,用科学计数法格式化浮点数 |
%g | %f和%e的简写 |
%G | %f 和 %E 的简写 |
%p | 用十六进制数格式化变量的地址 |
格式化操作符辅助指令:
符号 | 功能 | ||
m.n | m 是显示的最小总宽度,n 是小数点后的位数。m和n可以使用*号代替,使用后面的参数替换,一般用于调节显示。
运行结果
| ||
- | 实现数据左对齐
输出:
| ||
+ | 在正数前面显示加号( + ) print("%d" % (100)) print("%+d" % (100)) print("%+d" % (-100)) 运行结果: 100 +100 -100 | ||
# | 在八进制数前面显示零('0'),在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X') print("%#X" % (0x64)) print("%#X" % (100)) print("%#o" % (100)) 运行结果: 0X64 0X64 0o144 | ||
0 | 表示使用0填充左侧多余空格部分。仅对数值起效。 print("%010d" % (100)) 运行结果: 0000000100 | ||
% | '%%'输出一个单一的'%' print("%d%%" % (99)) 运行结果: 99% | ||
(var) | 映射变量(字典参数) print("%(a)s=%(b)d" % {'a':"data",'b':88}) 输出结果: data=88 |
3.4 f-string方法格式化字符串(python3.6)
f-string是python3.6加入标准库的,称为"格式化字符串文字",是新的格式化字符串的语法。
f-string 格式化字符串以f/F开头,后面跟着字符串,字符串中的表达式用大括号 {} 包起来,它会将变量或表达式计算后的值替换进去。
示例代码:
#!/usr/bin/python3 str=f"{10*100+123}" #填入表达式进行计算 print(str) data="jone" str=f"My name is {data}" #替换变量 print(str) |
运行结果
1123 My name is jone |
3.5 使用等号来拼接运算表达式与结果(python3.8)
在python3.6版本中增加了f-strings,可以使用f前缀更方便的格式化字符串,同时还能进行计算。
在3.8版本中只需要增加一个=符号,就可以拼接运算表达式与结果。示例代码如下:
data1=10 data2=20 str=f"{data1+data2+100}" #python3.6版本 print(str) str=f"{data1+data2+100=}" #python3.8版本 print(str) |
运行结果
130 data1+data2+100=130 |
4. 列表数据类型
4.1 什么是列表
(list)列表是Python内置的一种数据类型。列表是Python中最基本的数据结构,是一种有序的集合,可以随时添加和删除其中的元素,列表中的每个元素都分配一个位置索引,第一个索引是0,第二个索引是1,依此类推。
术语“列表值”指的是列表本身,而不是指列表值之内的那些值,列表中的值也称为“表项”,表项用逗号分隔,列表用左方括号开始,右方括号结束,即[]。
列表的数据项不需要具有相同的类型。
列表是用索引来访问每一个位置的元素,索引是从0开始计算的(类似C语言的数组)。
4.2 创建列表
示例代码
#!/usr/bin/python3 |
运行结果:
list1[0]= 小米 |
注:(1)下标从0开始【跟C语言相似】(2)取头不取尾 (3)尾部省略表示全取,头部省略表示从0开始
4.3 修改与删除操作
对列表的数据项进行修改,通过[]方括号直接定位索引位置赋值修改即可,使用 del 语句可以删除列表指定位置的数据,也可以直接删除整个列表。
示例代码
#!/usr/bin/python3 list1 = ["小米", '华为', 1868, 1666] list2 = [66, 77, 88, 99, 100 ] list3 = ["a", "b", "c", "d"] list1[0]="魅族" #修改列表索引0位置的值 print ("list1[0]=",list1[0]) #输出列表索引0位置的数据 print ("list1[1]=",list1[1]) #输出列表索引1位置的数据 print ("list2[1:2]=",list2[1:2])#输出列表索引1~2位置的数据 print ("list3[:3]=",list2[:3])#输出列表前3个位置的数据 del list1[3] #删除列表索引3位置的数据 del list2[2:4] #删除2~3位置的数据 del list3[3] #删除索引3位置的数据 del list3 #可以直接删除整个列表 print ("list1=",list1) #输出列表1里的全部数据 print ("list2=",list2) #输出列表2里的全部数据 print ("list3=",list3) #输出列表3里的全部数据 |
运行结果:
list1[0]= 魅族 list1[1]= 华为 list2[1:2]= [77] list3[:3]= [66, 77, 88] list1= ['魅族', '华为', 1868] list2= [66, 77, 100] Traceback (most recent call last): File "g:\python编程入门\02bianliang.py", line 16, in <module> print ("list3=",list3) #输出列表3里的全部数据 NameError: name 'list3' is not defined |
4.4 截取与拼接操作
列表对加号可重载。
示例代码
#!/usr/bin/python3 list = ["小米",'华为',1868,1666,111,222,333] print(list[-1]) #打印列表最后一个数据 print(list[-2]) #打印列表倒数第二个数据 print(list[-3]) #打印列表倒数第三个数据 print(list[1:]) #打印第2个数据开始后面的所有数据 list=list+[1,2,3] #列表的拼接 print(list) list=['a','b','c',1,2,3]#列表的拼接 print(list) |
运行结果
33 222 111 ['华为', 1868, 1666, 111, 222, 333] ['小米', '华为', 1868, 1666, 111, 222, 333, 1, 2, 3] ['a', 'b', 'c', 1, 2, 3] |
4.5 列表嵌套及引用
类似于C语言的多维数组一样,使用索引嵌套取值即可。
示例代码
#!/usr/bin/python3 list=[[1,2,3,4], ['a','b','c','d'], [66,77,88,99,100]] print(list[0][0]) print(list[1][0]) print(list[2][2]) print(list[2][5]) print(list) #输出列表里所有数据 |
运行结果:
1 a 88 Traceback (most recent call last): File "g:\python编程入门\02bianliang.py", line 6, in <module> print(list[2][5]) IndexError: list index out of range |
4.6 列表支持的函数与方法
Python包含以下函数:
序号 | 函数 |
1 | len(list)获取列表元素个数 示例: list1=[[1,2,3,4],['a','b','c','d'],[66,77,88,99,100]] list2=["2G","3G","4G","5G"] print(len(list1)) #得到list1的长度,如果是嵌套列表,只是得到列表的数量,返回值为3 print(len(list1[2])) #得到嵌套列表里指定列表的元素数量,返回值为5 print(len(list2)) #得到列表的元素数量,返回值为4 print(len(list2[2])) #得到列表指定元素字符串数量,返回值为2 print(len(list1[2][1])) 运行: 3 5 4 2 Traceback (most recent call last): File "g:\python编程入门\02bianliang.py", line 9, in <module> print(len(list1[2][1])) TypeError: object of type 'int' has no len() |
2 | max(list)返回列表元素最大值,数值类型就是最大值,字符串类型是最大长度。 示例: list1=["123","abcdef","456","7890"] list2=[1,66,88,100,8888] print(max(list1)) #输出结果:abcdef print(max(list2)) #输出结果:8888 |
3 | min(list)返回列表元素最小值,数据类型计算最小值,字符串类型计算最小长度 示例: list1=["123","abcdef","456","7890"] list2=[1,66,88,100,8888] print(min(list1)) #输出结果:123 print(min(list2)) #输出结果:1 |
4 | list(seq)将元组转换为列表,参数就是元组。 示例: buff=(666,"python",'wbyq','jone') #定义一个元组 list1 = list(buff) #转换为列表 print ("列表索引[1]元素:",list1[1]) print ("列表全部元素:",list1) str="Hello World" #定义一个字符串 list2=list(str) #转换为列表 print("列表全部元素:",list2) 运行结果: 列表索引[1]元素: python 列表全部元素: [666, 'python', 'wbyq', 'jone'] 列表全部元素: ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd'] |
Python包含以下方法:
序号 | 方法 |
1 | list.append(obj)在列表末尾添加新的对象 示例: list=['a','b','c'] list.append('d') list.append('e') print ("列表全部元素:",list) 运行结果: 列表全部元素: ['a', 'b', 'c', 'd', 'e'] |
2 | list.count(obj)统计某个元素在列表中出现的次数 示例: list=['666',"666",'wbyq',"python",123,123,123] print ("列表里\"666\"出现的次数:",list.count("666")) print ("列表里\"python\"出现的次数:",list.count("python")) print ("列表里123出现的次数:",list.count(123)) 运行结果: 列表里"666"出现的次数: 2 列表里"python"出现的次数: 1 列表里123出现的次数: 3 |
3 | list.extend(seq)在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表) 示例: list1=[1,2,3,4] list2=['a','b','c','d'] list3=['南昌','成都','绵阳'] list3.extend(list1) #在list3结尾添加list1 list3.extend(list2) #在list3结尾添加list2 print(list3) #输出list3 运行结果: ['南昌', '成都', '绵阳', 1, 2, 3, 4, 'a', 'b', 'c', 'd'] |
4 | list.index(obj)从列表中找出某个值第一个匹配项的索引位置 index()方法语法:list.index(x[, start[, end]]) 参数: x 查找的对象 start 可选,查找的起始位置(下标) end 可选,查找的结束位置(下标) 示例: list=['南昌','成都','绵阳','庐山','鄱阳湖'] print("'绵阳'出现的索引位置:",list.index('绵阳')) #默认从索引位置开始搜索 print("'鄱阳湖'出现的索引位置:",list.index('鄱阳湖',2)) #设置从第2个元素位置开始搜索 print("'庐山'出现的索引位置:",list.index('庐山',2,4))#设置从第2~4个元素位置之间搜索 运行结果: '绵阳'出现的索引位置: 2 '鄱阳湖'出现的索引位置: 4 '庐山'出现的索引位置: 3 |
5 | list.insert(index, obj)将对象插入列表指定位置 示例: list=['南昌','成都','绵阳'] list.insert(0,'自贡') #在第0个索引位置插入数据 list.insert(2,'666') print(list) 运行结果: ['自贡', '南昌', '666', '成都', '绵阳'] |
6 | list.pop([index=-1])移除列表中的一个元素(默认最后一个元素),并且返回该元素的值,参数填要删除数据的索引值 示例: list=['南昌','成都','绵阳',"重庆",'上海','北京'] print('现在列表里的值:',list) print('删除的值:',list.pop(-1)) #填-1默认删除最后的值 print('现在列表里的值:',list) print('删除的值:',list.pop(2)) #删除指定位置的值 print('现在列表里的值:',list) 运行结果: 现在列表里的值: ['南昌', '成都', '绵阳', '重庆', '上海', '北京'] 删除的值: 北京 现在列表里的值: ['南昌', '成都', '绵阳', '重庆', '上海'] 删除的值: 绵阳 现在列表里的值: ['南昌', '成都', '重庆', '上海'] |
7 | list.remove(obj)移除列表中某个值,该方法没有返回值,参数是填具体的值。 示例: list=['南昌','成都','绵阳',"重庆",'上海','北京'] print('现在列表里的值:',list) list.remove('绵阳') #删除指定元素 print('现在列表里的值:',list) list.remove('北京') #删除指定元素 print('现在列表里的值:',list) 运行结果: 现在列表里的值: ['南昌', '成都', '绵阳', '重庆', '上海', '北京'] 现在列表里的值: ['南昌', '成都', '重庆', '上海', '北京'] 现在列表里的值: ['南昌', '成都', '重庆', '上海'] |
8 | list.reverse()反向列表中元素,该方法没有返回值,但是会对列表的元素进行反向排序。 示例: list=['1','2','3','4','5'] print('列表原来的值:',list) list.reverse() #反向排序列表里的元素 print('反向之后的值:',list) 运行结果: 列表原来的值: ['1', '2', '3', '4', '5'] 反向之后的值: ['5', '4', '3', '2', '1'] |
9 | list.sort( key=None, reverse=False)对原列表进行排序 语法: list.sort( key=None, reverse=False) 参数: key是用来进行比较的元素 reverse 表示排序规则,reverse = True 从大到小,reverse = False 从小到大(默认) 示例: list=[123,456,12,34,89,45] print('列表原来的值:',list) list.sort() #默认从小到大排序 print('从小到大排序之后的值:',list) list.sort(reverse = True) #默认从小到大排序 print('从大到小排序之后的值:',list) list=["123","12","1234","1"] print('列表原来的值:',list) list.sort() #默认从小到大排序 print('从小到大排序之后的值:',list) list.sort(reverse = True) #默认从小到大排序 print('从大到小排序之后的值:',list) 运行结果: 列表原来的值: [123, 456, 12, 34, 89, 45] 从小到大排序之后的值: [12, 34, 45, 89, 123, 456] 从大到小排序之后的值: [456, 123, 89, 45, 34, 12] 列表原来的值: ['123', '12', '1234', '1'] 从小到大排序之后的值: ['1', '12', '123', '1234'] 从大到小排序之后的值: ['1234', '123', '12', '1'] |
10 | list.clear()清空列表所有数据 示例: list=[123,456,12,34,89,45] list.clear() print(list) 运行结果: [] |
11 | list.copy()拷贝整个列表:浅层拷贝 示例: list1=[123,456,12,34,89,45] list2=list1.copy() print(list1) print(list2) 运行结果: [123, 456, 12, 34, 89, 45] [123, 456, 12, 34, 89, 45] (1)赋值拷贝也称引用赋值,指向的是同一块内存,所以更改一个,另一个也会发生改变 (2)浅copy():复制一个副本,按道理来说,原值和新复制的变量互不影响。但是浅拷贝也称不完全拷贝,仅限于一维内存拷贝,对于多维的列表,内存是共用的。 示例代码: list1=[123,456,12,34,89,45] list2=list1 #将list1赋值给list2 相当于引用-别名,指向同一块内存。 list3=list1.copy() #将list1拷贝一份给list3,创建一个新的列表 del list1[1] #不影响list3,因为一维列表list1被完全拷贝。 print("list1=",list1) print("list2=",list2) print("list3=",list3) #不会发生改变 list1=[[1,2,3],[4,5,6],[7,8,9]] list2=list1 #将list1赋值给list2 相当于引用-别名 list3=list1.copy() #将list1拷贝一份给list3,创建一个新的列表 del list1[1] #只是删掉list1的引用,不影响list3对内存块的引用 #list1/2/3引用同一个内存块 print("list1=",list1) print("list2=",list2) print("list3=",list3) #不会发生改变 list1=[[1,2,3],[4,5,6],[7,8,9]] list2=list1 #将list1赋值给list2 相当于引用-别名 list3=list1.copy() #将list1拷贝一份给list3,创建一个新的列表 list1[1][1]=666 #修改值 print("list1=",list1) print("list2=",list2) print("list3=",list3) #发生改变,因为对于多维列表,浅拷贝内存是共用的。 运行结果: list1= [123, 12, 34, 89, 45] list2= [123, 12, 34, 89, 45] list3= [123, 456, 12, 34, 89, 45] list1= [[1, 2, 3], [7, 8, 9]] list2= [[1, 2, 3], [7, 8, 9]] list3= [[1, 2, 3], [4, 5, 6], [7, 8, 9]] list1= [[1, 2, 3], [4, 666, 6], [7, 8, 9]] list2= [[1, 2, 3], [4, 666, 6], [7, 8, 9]] list3= [[1, 2, 3], [4, 666, 6], [7, 8, 9]] (3) 深拷贝deepcopy:深拷贝也称“完全内存拷贝”,将多维列表中的内容递归的复制一遍,重新存储到另一块新的内存空间,所以深拷贝就不会出现内存共用的情况。深度拷贝需要导入copy模块 list1=[[1,2,3],[4,5,6],[7,8,9]] list2=list1 #将list1赋值给list2 相当于引用-别名 list3=copy.deepcopy(list1) #深拷贝 list1[1][1]=666 #修改值 print("list1=",list1) print("list2=",list2) print("list3=",list3) #不会发生改变 运行结果: list1= [[1, 2, 3], [4, 666, 6], [7, 8, 9]] list2= [[1, 2, 3], [4, 666, 6], [7, 8, 9]] list3= [[1, 2, 3], [4, 5, 6], [7, 8, 9]] |
5. 元组数据类型
5.1 什么是元组
Python的元组(tuple)与列表类似,不同之处在于元组(tuple)一旦初始化就不能修改,元组使用小括号,而列表使用方括号。
创建元组只需要在括号中添加元素,并使用逗号隔开,当元组中只包含一个元素时,需要在元素后面添加逗号,否则括号会被当作运算符使用。
创建元组示例代码:
tuple1=(12,34,56,78,90) tuple2=('a','b','c','d') tuple3=('python',) tuple4=('wbyq') print(tuple1) print(tuple2) print(tuple3) print("tuple3类型:",type(tuple3)) #元组类型 print("tuple4类型:",type(tuple4)) #不加逗号会识别成字符串类型 |
运行结果
(12, 34, 56, 78, 90) ('a', 'b', 'c', 'd') ('python',) tuple3类型: <class 'tuple'> tuple4类型: <class 'str'> |
5.2 访问元组数据类型
元组可以使用下标索引来访问元组中的值,与列表访问方法一样。
示例代码
tuple1=(12,34,56,78,90) print(tuple1[0]) print(tuple1[:3]) print(tuple1[-1]) print(tuple1[-2]) print(tuple1) |
运行结果
12 (12, 34, 56) 90 78 (12, 34, 56, 78, 90) |
5.3 删除、修改、和组合操作
Python规定元组中的元素值初始化之后就不允许修改和删除,如果想要删除元组也只能对整个元组进行删除。
但是元素不可变有一种特殊情况,当元素是可变对象时。对象内部属性是可以修改的,tuple的不可变限制只是在一个纬度上:元素的类型;tuple的元素所保存的内容(数值或内存地址)是不允许修改的,但地址映射的对象自身是可以修改的。
元组初始化之后,虽然不能对单个元素修改,但是可以对整个元组进行重新赋值修改。
两个以上的元组类型数据可以合成一个新的元组类型数据,不违背原理,这个属于创建一个新的元组类型结构,重新赋值的元组 tup,绑定到新的对象了,不是修改了原来的对象。
删除、合成示例代码:
tuple=(12,34,56,78,90)#tuple[1]=888 无法修改数据、非法操作 #del tuple[1] 无法删除数据、非法操作del数据成员,但是可以删除整个元组 tuple1=(1,2,3,4) tuple2=('a','b','c','d') tuple3=tuple1+tuple2 #组合成一个新的元组数据 print(tuple3) |
运行结果
(1, 2, 3, 4, 'a', 'b', 'c', 'd')
修改示例代码:元组中含有列表
list=[1,2,3,4] tuple=(list,56,78,90) #将列表当做元组的元素 print("tuple源值=",tuple) list[0]=666 #修改列表的数据 list[1]=777 #修改列表的数据 del list[2] #删除列表的数据 print("修改tuple之后的值=",tuple) |
运行结果
tuple源值= ([1, 2, 3, 4], 56, 78, 90) 修改tuple之后的值= ([666, 777, 4], 56, 78, 90) |
5.4 元组的内置函数
序号 | 方法及描述 | 示例代码 |
1 | len(tuple)计算元组元素个数。 | tuple1=(12,34,56,78) tuple2=('python','c++','java','c#','php') print('tuple1元素数量:',len(tuple1)) print('tuple2元素数量:',len(tuple2)) 运行结果: tuple1元素数量: 4 tuple2元素数量: 5 |
2 | max(tuple)返回元组中元素最大值。 | tuple1=(12,34,56,78) tuple2=('python','c++','java','c#','php') print('tuple1元素数量:',max(tuple1)) print('tuple2元素数量:',max(tuple2)) 运行结果: tuple1元素数量: 78 tuple2元素数量: python |
3 | min(tuple)返回元组中元素最小值。 | tuple1=(12,34,56,78) tuple2=('python','c++','java','c#','php') print('tuple1元素数量:',min(tuple1)) print('tuple2元素数量:',min(tuple2)) 运行结果: tuple1元素数量: 12 tuple2元素数量: c# |
4 | tuple(seq)将列表类型转换为元组类型。 | list=[12,34,56,78] tup=tuple(list) print(tup) 运行结果: (12, 34, 56, 78) |
6. 字典数据类型
6.1 创建字典类型数据
字典是Python提供的一种常用数据结构,它用于存放具有映射关系的数据(键-值/key-value),它是一种可变容器模型,可存储任意类型对象,特点是: 元素可以无序,键key必须唯一。
规则:
(1)字典的每个键值对用冒号(:)分割,每个对之间用逗号(,)分割,整个字典包括在花括号({})中 。
(2)字典的创建语法是: data = {key1 : value1, key2 : value2 }
字典里的键key只能是不可变的数据类型(整型,字符串或者是元组),值values可以是任何数据类型。
创建字典实例代码:
#创建字典 data={'小米':1999, '华为':3999, '苹果':6999, 888:'python'} #访问字典里的值 print("data['小米']=", data['小米']) print("data['华为']=", data['华为']) print("data['苹果']=", data['苹果']) print("data[888]=", data[888]) #输出字典里所有键值对 print("data=", data) |
运行结果
data['小米']= 1999 data['华为']= 3999 data['苹果']= 6999 data[888]= python data= {'小米': 1999, '华为': 3999, '苹果': 6999, 888: 'python'} |
6.2 新增、修改、删除字典元素
修改字典的值,使用[]括号指定键的名称直接赋值即可修改。
删除字典可以指定键名称del删除,可以调用clear方法清除字典,可以使用del删除整个字典。
示例代码
# 创建字典 data={'小米':1999,'华为':3999,'苹果':6999,888:'python'} # 修改字典数据值 data['小米']=2999 data['华为']=5999 print("data['小米']=", data['小米']) print("data['华为']=", data['华为']) # 增加新的键值对(追加) data['三星']=7999 data['诺基亚']=1299 # 输出字典里所有键值对 print("字典里所有值:",data) # 删除指定的键 del data['苹果'] print("字典里所有值:",data) data.clear() #清空字典 del data #删除字典 |
运行结果
data['小米']= 2999 data['华为']= 5999 字典里所有值: {'小米': 2999, '华为': 5999, '苹果': 6999, 888: 'python', '三星': 7999, '诺基亚': 1299} 字典里所有值: {'小米': 2999, '华为': 5999, 888: 'python', '三星': 7999, '诺基亚': 1299} |
6.3 字典有哪些特性
(1)字典的值可以是任何的python 对象,既可以是标准的对象,也可以是用户定义的,但键只能是不可变的数据类型(整型,字符串或者是元组)。
data={<键名>:<字典数据值>}
示例代码:
#!/usr/bin/python3 # data={<键>:<数据值>} list=[12,34,56] tuple=(12,34,56) data={list:12345} #这行代码是错误的,列表的数据可变,不能当做键 data={tuple:12345} #代码正确,元组数据不可变,可以当做键 |
运行结果分析:
Traceback (most recent call last): File "g:\python编程入门\02bianliang.py", line 5, in <module> data={list:12345} #这行代码是错误的,列表的数据可变,不能当做键 TypeError: unhashable type: 'list' |
(2)字典的键值是"只读"的,不能对键和值分别进行初始化。
(3)字典支持相互嵌套
示例代码
#!/usr/bin/python3 data={ '南昌': { '华东交通大学': { '计算机与科学技术': 123, '电子信息工程': 456, '汉语言文学': 66, }, '南昌大学': { '计算机与科学技术': 55, '电子信息工程': 128, '汉语言文学': 456, } }, '武汉': { '中南民族大学': { '计算机与科学技术': 56, '电子信息工程': 77, '汉语言文学': 666, }, '华中科技大学': { '计算机与科学技术': 567, '电子信息工程': 345, '汉语言文学': 68, } } }
print("南昌大学专业报考信息:", data['南昌']['南昌大学']) print("华中科技大学'计算机与科学技术'专业报考人数:%d人" % (data['武汉']['华中科技大学']['计算机与科学技术'])) print("中南民族大学'汉语言文学'专业报考人数:%d人" % (data['武汉']['中南民族大学']['汉语言文学'])) |
运行结果
南昌大学专业报考信息: {'计算机与科学技术': 55, '电子信息工程': 128, '汉语言文学': 456} 华中科技大学'计算机与科学技术'专业报考人数:567人 中南民族大学'汉语言文学'专业报考人数:666人 |
6.4 字典内置函数与方法
Python字典包含了以下内置函数:
序号 | 函数及描述 | 实例 |
1 | len(dict) 计算字典元素个数,即键的总数。 | data1={'小红':23,'小明':67} data2={'小米':1999,'华为':8999,'苹果':9000} print('data1中的键值数量:',len(data1)) print('data2中的键值数量:',len(data2)) 运行结果: data1中的键值数量: 2 data2中的键值数量: 3 |
2 | str(dict) 输出字典,以可打印的字符串表示。 | data1={'小红':23,'小明':67} data2={'小米':1999,'华为':8999,'苹果':9000} print('字典data1里的数据:',str(data1)) print('字典data2里的数据:',str(data2)) 运行结果: 字典data1里的数据: {'小红': 23, '小明': 67} 字典data2里的数据: {'小米': 1999, '华为': 8999, '苹果': 9000} |
3 | type(variable) 返回输入的变量类型,如果变量是字典就返回字典类型,如果变量是字符串就返回字符串类型。 | data1={'小红':23,'小明':67} data2={'小米':1999,'华为':8999,'苹果':9000} data3=[12,34,56] data4=1234 data5="str1234" print('data1类型:',type(data1)) print('data2类型:',type(data2)) print('data3类型:',type(data3)) print('data4类型:',type(data4)) print('data5类型:',type(data5)) 运行结果: data1类型: <class 'dict'> data2类型: <class 'dict'> data3类型: <class 'list'> data4类型: <class 'int'> data5类型: <class 'str'> |
Python字典包含了以下内置方法:
序号 | 函数及描述 |
1 | clear()删除字典内所有元素 示例: data={'小红':23,'小明':67} data.clear() #清空所有元素 print("data=",data) 运行结果: data= {} |
2 | copy()返回一个字典的浅复制 示例: data1={'小红':23,'小明':67} data2=data1.copy() #拷贝副本 print(data1) print(data2) 运行结果: {'小红': 23, '小明': 67} {'小红': 23, '小明': 67} |
3 | 字典 fromkeys() 函数用于创建一个新字典,以序列 seq 中元素做字典的键,value 为字典所有键对应的初始值。 语法:dict.fromkeys(seq[, value]) 示例: val=('小米','华为','苹果') #定义键 data=dict.fromkeys(val) #不赋值 print("新的字典=",data) #输出结果 val=('小米','华为','苹果') #定义键 data=dict.fromkeys(val,1900) #赋值 print("新的字典=",data) #输出结果 data=dict.fromkeys(['南昌','成都','北京'],'1890') #赋值 print("新的字典=",data) #输出结果 运行结果: 新的字典= {'小米': None, '华为': None, '苹果': None} 新的字典= {'小米': 1900, '华为': 1900, '苹果': 1900} 新的字典= {'南昌': '1890', '成都': '1890', '北京': '1890'} |
4 | get(key, default=None)返回指定键的值,如果值不在字典中返回default值,default值默认为 None。 示例: val={'小米':1299,'华为':2999,'苹果':6999} #定义键 print(val.get('小米')) print(val.get('三星')) print(val.get('三星','5999')) #填写默认值 运行结果: 1299 None 5999 |
5 | key in dict:in操作符用于判断键是否存在于字典中,如果键在字典 dict 里返回 true,否则返回 false。 而 not in 操作符刚好相反,如果键在字典 dict 里返回 false,否则返回 true。 查询语法: <要查找的键> in/not in <字典名称> 示例: val={'小米':1299,'华为':2999,'苹果':6999} #定义键 if '苹果' in val: print("键 苹果 存在") else : print("键 苹果 不存在") if '三星' in val: print("键 三星 存在") else : print("键 三星 不存在") if '苹果' not in val: print("键 苹果 不存在") else : print("键 苹果 存在") if '三星' not in val: print("键 三星 不存在") else : print("键 三星 存在") 运行结果: 键 苹果 存在 键 三星 不存在 键 苹果 存在 键 三星 不存在 |
6 | items()以列表返回可遍历的(键, 值) 元组数组, 不能直接返回列表,若要返回列表值还需调用list函数。 示例: val={'小米':1299,'华为':2999,'苹果':6999} print("字典的值:",val.items()) print("列表形式:",list(val.items())) 运行结果: 字典的值: dict_items([('小米', 1299), ('华为', 2999), ('苹果', 6999)]) 列表形式: [('小米', 1299), ('华为', 2999), ('苹果', 6999)] |
7 | keys()返回一个迭代器,可以使用 list() 来转换为列表,Python2.x 是直接返回列表 示例: val={'小米':1299,'华为':2999,'苹果':6999} print("字典的值:",val.keys()) print("列表形式:",list(val.keys())) 运行结果: 字典的值: dict_keys(['小米', '华为', '苹果']) 列表形式: ['小米', '华为', '苹果'] |
8 | setdefault(key, default=None)和get()类似, 但如果键不存在于字典中,将会添加键并将值设为default 参数: key 查找的键值。 default 键不存在时,设置的默认键值。 返回值: 如果 key 在 字典中,返回对应的值。如果不在字典中,则插入 key 及设置的默认值 default,并返回 default ,default 默认值为 None。 示例: val={'南昌':"南昌大学",'武汉':"武汉大学",'成都':"成都电子科技大学"} print("字典的全部值:",val) print("'南昌'键的值:",val.setdefault('南昌',None)) print("'武汉'键的值:",val.setdefault('武汉',None)) print("'长沙'键的值:",val.setdefault('长沙',None)) print("'桂林'键的值:",val.setdefault('桂林','桂林电子科技大学')) 运行结果: 字典的全部值: {'南昌': '南昌大学', '武汉': '武汉大学', '成都': '成都电子科技大学'} '南昌'键的值: 南昌大学 '武汉'键的值: 武汉大学 '长沙'键的值: None '桂林'键的值: 桂林电子科技大学 |
9 | update(dict2) 把字典参数 dict2 的 key/value(键/值)对更新到字典dict里 update()方法语法:dict.update(dict2) 示例: dict1={'南昌':"南昌大学",'武汉':"武汉大学",'成都':"成都电子科技大学"} dict2={'桂林':"桂林电子科技大学",'北京':"北京大学",'天津':"南开大学"} print("字典dict1的全部值:",dict1) print("字典dict2的全部值:",dict2) dict1.update(dict2) #更新字典 print("字典dict1更新之后的值:",dict1) 示例: 字典dict1的全部值: {'南昌': '南昌大学', '武汉': '武汉大学', '成都': '成都电子科技大学'} 字典dict2的全部值: {'桂林': '桂林电子科技大学', '北京': '北京大学', '天津': '南开大学'} 字典dict1更新之后的值: {'南昌': '南昌大学', '武汉': '武汉大学', '成都': '成都电子科技大学', '桂林': '桂林电子科技大学', '北京': '北京大学', '天津': '南开大学'} |
10 | values()方法返回一个迭代器,可以使用list()来转换为列表,列表为字典中的所有值。 示例: dict={'南昌':"南昌大学",'武汉':"武汉大学",'成都':"成都电子科技大学"} print("字典所有值为:",list(dict.values())) 运行结果: 字典所有值为: ['南昌大学', '武汉大学', '成都电子科技大学'] |
11 | pop(key[,default])删除字典给定键 key 所对应的值,返回值为被删除的值。如果要删除的 key 不存在,则需要添加默认值,否则会报错。 语法:pop(key[,default]) 参数: key: 要删除的键值 default: 如果没有 key,返回 default 值 示例: dict={'南昌':"南昌大学",'武汉':"武汉大学",'成都':"成都电子科技大学"} print("新字典的值:",dict) print("删除的值:",dict.pop("南昌")) print("删除的值:",dict.pop("成都")) print("删除的值:",dict.pop("桂林","'桂林':NoKey")) print("现在字典的值:",dict) 运行结果: 新字典的值: {'南昌': '南昌大学', '武汉': '武汉大学', '成都': '成都电子科技大学'} 删除的值: 南昌大学 删除的值: 成都电子科技大学 删除的值: '桂林':NoKey 现在字典的值: {'武汉': '武汉大学'} |
12 | popitem()方法随机返回并删除字典中的最后一对键和值。 如果字典已经为空,却调用了此方法,就报出KeyError异常。 示例: dict={'南昌':"南昌大学",'武汉':"武汉大学",'成都':"成都电子科技大学"} print(dict.popitem()) print(dict.popitem()) print(dict.popitem()) print(dict) 运行结果: ('成都', '成都电子科技大学') ('武汉', '武汉大学') ('南昌', '南昌大学') {} |
7. 集合数据类型
7.1 创建集合
(1)集合也是python中的一种基本数据类型,特点是其中的元素都是不重复的,而且是无序的。
集合分为两种:可变集合set和不可变集合frozenset。
(2)可变集合set:创建非空的集合时,参数必是迭代器类型,比如:列表/字典等,然后转换成无序不重复的集合,所以可以用来去重(去掉重复的元素)。
(3)不可变集合frozenset:是不能被改变的,也就是不能插入和删除,类似于元组。
(4)集合是写在花括号{}之间或者set()函数创建集合,用逗号,分隔开。
(5)创建一个空集合必须用set()函数,因为 {} 是用来创建一个空字典。
创建集合示例代码:
#!/usr/bin/python3 set_data1={"Python","C/C++","Java","C#",168,139,"Python","C#"} print(set_data1) #打印的数据支持去重功能 print("set_data1类型:",type(set_data1)) set_data2={} #空括号表示字典类型 print("set_data2类型:",type(set_data2)) set_data3=set({}) #使用set函数创建集合类型 print("set_data3类型:",type(set_data3)) list = ['小米', '华为','华为','小米', 'OPPO'] set_data4=set(list) #使用set函数将列表转为集合类型 print("set_data4类型:",type(set_data4)) print(set_data4) #打印的数据支持去重功能 |
运行结果
{'Java', 'C#', 168, 'C/C++', 'Python', 139} set_data1类型: <class 'set'> set_data2类型: <class 'dict'> set_data3类型: <class 'set'> set_data4类型: <class 'set'> {'华为', 'OPPO', '小米'} |
7.2 操作集合数据
(1) 添加元素
添加元素可以使用add和update方法。语法格式: s.add(x) / s.update( x )
add方法将元素x添加到集合s中,如果元素已存在,则不进行任何操作。
update方法将元素x添加到集合s中,参数可以是列表,元组,字典等。
示例代码:
#!/usr/bin/python3 set_data={"Python","C/C++","Java","C#",168,139,"Python","C#"} set_data.add("Go") set_data.add("Python") #如果元素已存在,则不进行任何操作 print("set_data集合的数据:",set_data) list={'a','b','c'} set_data.update(list) print("set_data集合的数据:",set_data) |
运行结果
set_data集合的数据: {'Python', 'Java', 'C/C++', 'Go', 168, 139, 'C#'} set_data集合的数据: {'Java', 'b', 168, 'a', 139, 'c', 'Python', 'C/C++', 'C#', 'Go'} |
(2) 移除元素
将元素从集合里移除有常见3个方法: s.remove(x)、s.discard(x)、s.pop()
remove将元素x从集合s中移除,如果元素不存在,则会发生错误。
discard移除集合中的元素,如果元素不存在,不会发生错误。
pop方法会对集合进行无序的排列,然后将这个无序排列集合的左面第一个元素进行删除,删除是随机的。
#!/usr/bin/python3 set_data={"Python","C/C++","Java","C#","Python","C#","shell","PHP"} print("原集合数据:",set_data) #set_data.remove("go") #删除"Python"元素,如果元素不存在会报错 set_data.remove("Python") print("现集合数据:",set_data) set_data.discard("Python") #删除"Python"元素,如果元素不存在不会报错 set_data.discard("C#") #删除"Python"元素print("现集合数据:",set_data) set_data.pop() #删除是随机的 print("现集合数据:",set_data) |
运行结果
原集合数据: {'C#', 'C/C++', 'Java', 'shell', 'PHP', 'Python'} 现集合数据: {'C#', 'C/C++', 'Java', 'shell', 'PHP'} 现集合数据: {'Java', 'shell', 'PHP'} |
(3)计算集合元素个数
示例代码
#!/usr/bin/python3 set_data={"Python","C/C++","Java","C#","Python","C#","shell","PHP"} print("原集合数据:",set_data) print("原集合数据个数:",len(set_data)) |
运行结果
原集合数据: {'shell', 'Java', 'C/C++', 'Python', 'C#', 'PHP'} 原集合数据个数: 6 |
(4)判断元素是否在集合中
语法格式如下:x in s
判断元素 x 是否在集合 s 中,存在返回 True,不存在返回 False。
示例代码
set_data={"Python","C/C++","Java","C#","Python","C#","shell","PHP"} print("Python" in set_data) print("wbyq" in set_data) |
运行结果:
True
False
7.3 集合内置的方法
方法 | 描述 |
add() | 为集合添加元素 示例: set_data={"Python","C/C++","Java","C#","C#"} print("set_data集合原数据:",set_data) set_data.add("Go") set_data.add("Python") #如果元素已存在,则不进行任何操作print("set_data集合现数据:",set_data) 输出结果: set_data集合原数据: {'C/C++', 'C#', 'Python', 'Java'} set_data集合现数据: {'C/C++', 'Go', 'C#', 'Python', 'Java'} |
clear() | 移除集合中的所有元素 示例: set_data={"Python","C/C++","Java","C#","C#"} print("set_data集合原数据:",set_data) set_data.clear() #清除集合所有数据 print("set_data集合现数据:",set_data) 输出结果: set_data集合原数据: {'C/C++', 'Python', 'Java', 'C#'} set_data集合现数据: set() |
copy() | 拷贝一个集合 示例: set_data1={"Python","C/C++","Java","C#","C#"} print("set_data1集合数据:",set_data1) set_data2=set_data1.copy() #拷贝集合数据 print("set_data2集合数据:",set_data2) 输出结果: set_data1集合数据: {'Python', 'C#', 'Java', 'C/C++'} set_data2集合数据: {'Python', 'C#', 'Java', 'C/C++'} |
difference() | 用于返回集合的差集,即返回的集合元素包含在第一个集合中,但不包含在第二个集合(方法的参数)中。 示例: x={"Python","C/C++","Java","C#"} y={"Java","PHP","C#"} z=x.difference(y) #返回一个集合,元素包含在集合x,但不在集合y里 print(z) 输出结果: {'C/C++', 'Python'} |
difference_update() | intersection_update() 方法用于获取两个或更多集合中都重叠的元素,即计算交集。 语法格式:set.intersection_update(set1, set2 ... etc) 参数: set1 必需,要查找相同元素的集合 set2 可选,其他要查找相同元素的集合,可以多个,多个使用逗号 , 隔开 示例: a={"Python","C/C++","Java","C#"} b={"Java","PHP","C#"} c={"Python","Java","C#"} a.intersection_update(b,c) #返回多个集合里都存在的数据 print(a) 输出结果: {'C#', 'Java'} |
discard() | 删除集合中指定的元素,如果不存在不会报错。 示例: a={"Python","C/C++","Java","C#"} print("原集合数据:",a) a.discard("Python") print("先集合数据:",a) a.discard("Python") #不存在也不会报错 print("先集合数据:",a) 运行结果: 原集合数据: {'C/C++', 'Python', 'C#', 'Java'} 先集合数据: {'C/C++', 'C#', 'Java'} 先集合数据: {'C/C++', 'C#', 'Java'} |
intersection() | intersection() 方法用于返回两个或更多集合中都包含的元素,即交集。 difference_update()方法是在原集合上修改,intersection()方法是返回一个新集合 语法:set.intersection(set1, set2 ... etc) 参数 set1 必需,要查找相同元素的集合 set2 可选,其他要查找相同元素的集合,可以多个,多个使用逗号 , 隔开 返回值:返回一个新的集合。 示例: a={"Python","C/C++","Java","C#"} b={"Java","PHP","C#"} c={"Python","Java","C#"} d=a.intersection(b,c) #返回多个集合里都存在的数据 print(d) 输出结果: {'C#', 'Java'} |
intersection_update() | intersection_update()方法用于获取两个或更多集合中都重叠的元素,即计算交集。 intersection_update()方法不同于intersection()方法,因为 intersection() 方法是返回一个新的集合,而intersection_update()方法是在原始的集合上移除不重叠的元素。 方法语法:set.intersection_update(set1, set2 ... etc) 参数 set1 必需,要查找相同元素的集合 set2 可选,其他要查找相同元素的集合,可以多个,多个使用逗号 , 隔开 示例: a={"Python","C/C++","Java","C#"} b={"Java","PHP","C#"} c={"Python","Java","C#"} a.intersection_update(b,c) #返回多个集合里都存在的数据 print(a) 输出结果: {'Java', 'C#'} |
isdisjoint() | 判断两个集合是否包含相同的元素,如果没有返回 True,否则返回 False。 示例: a={"Python","C/C++","Java","C#"} b={"Java","PHP","C#"} c={"小米","华为","苹果"} print(a.isdisjoint(b)) #判断b集合中是否有包含集合a的元素,如果不包含返回 True,否则返回 False。 print(a.isdisjoint(c)) #判断c集合中是否有包含集合a的元素,如果不包含返回 True,否则返回 False。 输出结果: False True |
issubset() | issubset() 方法用于判断集合的所有元素是否都包含在指定集合中,如果是则返回 True,否则返回 False 示例: a={"Python","C/C++","Java","C#"} b={"Java","PHP","C#"} c={"Python","C/C++","Java","C#","Android","Linux"} print(a.issubset(b))#判断集合a的所有元素是否都包含在集合b中,如果都包含返回 True,否则返回 False print(a.issubset(c))#判断集合a的所有元素是否都包含在集合c中,如果都包含返回 True,否则返回 False 输出结果: False True |
issuperset() | issuperset() 方法用于判断指定集合的所有元素是否都包含在原始的集合中,如果是则返回 True,否则返回 False 示例: a={"Python","C/C++","Java","C#","C#","Android","Linux"} b={"Java","PHP","C#"} c={"Python","C/C++","Java"} print(a.issuperset(b))#判断集合b的所有元素是否都包含在集合a中,如果都包含返回 True,否则返回 False print(a.issuperset(c))#判断集合c的所有元素是否都包含在集合a中,如果都包含返回 True,否则返回 False 输出结果: False True |
pop() | 随机移除元素 示例: set_data={"Python","C/C++","Java","C#","C#","Android","Linux"} print("现集合数据:",set_data) set_data.pop() #删除是随机的 print("现集合数据:",set_data) set_data.pop() #删除是随机的 print("现集合数据:",set_data) 输出结果: 现集合数据: {'Java', 'C#', 'Linux', 'Android', 'C/C++', 'Python'} 现集合数据: {'C#', 'Linux', 'Android', 'C/C++', 'Python'} 现集合数据: {'Linux', 'Android', 'C/C++', 'Python'} |
remove() | 移除指定元素 该方法不同于 discard() 方法,因为 remove() 方法在移除一个不存在的元素时会发生错误,而 discard() 方法不会 示例: set_data={"Python","C/C++","Java","C#","C#","Android","Linux"} print("现集合数据:",set_data) set_data.remove("Python") print("现集合数据:",set_data) set_data.remove("Java") print("现集合数据:",set_data) 输出结果: 现集合数据: {'Python', 'Java', 'C/C++', 'C#', 'Linux', 'Android'} 现集合数据: {'Java', 'C/C++', 'C#', 'Linux', 'Android'} 现集合数据: {'C/C++', 'C#', 'Linux', 'Android'} |
symmetric_difference() | symmetric_difference() 方法返回两个集合中不重复的元素集合,即会移除两个集合中都存在的元素,返回一个新的集合。 示例: a={"Python","C/C++","Java","C#","C#","Android","Linux"} b={"Java","PHP","C#"} c=a.symmetric_difference(b) print(c) 输出结果: {'Android', 'C/C++', 'Python', 'PHP', 'Linux'} |
symmetric_difference_update() | 移除当前集合中在另外一个指定集合相同的元素,并将另外一个指定集合中不同的元素插入到当前集合中。 示例: a={"Python","C/C++","Java","C#","Android","Linux"} b={"Java","PHP","C#"} print("原a集合数据:",a) print("原b集合数据:",b) #在原始集合 a中移除与 b 集合中的重复元素,并将不重复的元素插入到集合a中 a.symmetric_difference_update(b) print("现a集合数据:",a) 输出结果: 原a集合数据: {'C#', 'C/C++', 'Python', 'Android', 'Java', 'Linux'} 原b集合数据: {'C#', 'PHP', 'Java'} 现a集合数据: {'C/C++', 'Python', 'Android', 'Linux', 'PHP'} |
union() | union()方法返回两个集合的并集,即包含了所有集合的元素,重复的元素只会出现一次。 语法:set.union(set1, set2...) 参数 set1 必需,合并的目标集合 set2 可选,其他要合并的集合,可以多个,多个使用逗号 , 隔开。 示例: a={"Python","C/C++","Java","C#","Android","Linux"} b={"Java","PHP","C#"} c={"X86汇编","ARM汇编"} print("原a集合数据:",a) print("原b集合数据:",b) print("原c集合数据:",c) d=c.union(a,b) #合并所有数据,去除重复 print("新d集合数据:",d) 输出结果: 原a集合数据: {'C/C++', 'C#', 'Linux', 'Android', 'Python', 'Java'} 原b集合数据: {'PHP', 'C#', 'Java'} 原c集合数据: {'X86汇编', 'ARM汇编'} 新d集合数据: {'C/C++', 'C#', 'Linux', 'PHP', 'X86汇编', 'Android', 'Python', 'ARM汇编', 'Java'} |
update() | update() 方法用于修改当前集合,可以添加新的元素或集合到当前集合中,如果添加的元素在集合中已存在,则该元素只会出现一次,重复的会忽略。 示例: #!/usr/bin/python3 a={"Python","C/C++","Java","C#","Android","Linux"} b={"Java","PHP","C#"} list=["Java","C#","Go","SQL"] print("原集合a数据:",a) a.update(b); a.update(list); a.update(["HTML"]); #a.update("MySQL"); #如何直接添加字符串,会将字符串单个字符拆开加入集合 print("现集合a数据:",a) 输出结果: 原集合a数据: {'C/C++', 'Android', 'Java', 'C#', 'Python', 'Linux'} 现集合a数据: {'Go', 'C/C++', 'Android', 'PHP', 'SQL', 'Java', 'C#', 'Python', 'HTML', 'Linux'} |