python数据类型
不可变：整形、布尔值、字符串、元组 可变：列表、字典、集合
整形（int）
定义
在编程中，经常使用数字来记录游戏得分、表示可视化数据、存储Web应用信息等
number = 10 age = 99 # 可以通过type查看下到底是什么类型 print( type(number) )
常用方法
无
转换为整形
在项目开发和面试题中经常会出现一些 “字符串” 和 布尔值 转换为 整型的情况。
# 布尔值转整型
n1 = int(True) # True转换为整数 1
n2 = int(False) # False转换为整数 0
# 字符串转整型
v1 = int("186",base=10) # 把字符串看成十进制的值，然后再转换为 十进制整数，结果：v1 = 186
v2 = int("0b1001",base=2) # 把字符串看成二进制的值，然后再转换为 十进制整数，结果：v1 = 9 (0b表示二进制)
v3 = int("0o144",base=8) # 把字符串看成八进制的值，然后转换为 十进制整数，结果：v1 = 100 (0o表示八进制)
v4 = int("0x59",base=16) # 把字符串看成十六进制的值，然后转换为 十进制整数，结果：v1 = 89 （0x表示十六进制）
其他
在python2.x中跟整数相关的数据类型有两种：int(整型)、long（长整型），他们都是整数只不过能表示的值范围不同。
-
int，可表示的范围：-9223372036854775808～9223372036854775807
-
long，整数值超出int范围之后自动会转换为long类型（无限制）。
在python3.x中去除了long只剩下：int（整型），并且 int 长度不在限制。
布尔值（bool）
定义
布尔值，其实就是 “真”、“假” 两个值的统称。即True、False
常用方法
无
转换为布尔值
在以后的项目开发中，会经常使用其他类型转换为布尔值的情景，此处只要记住一个规律即可。
整数0、空字符串、空列表、空元祖、空字典、空集合转换为布尔值时均为False，其他均为True
空字符换表示方法：mes = '' 或 mes = str()
空列表表示方法：mes = [] 或 mes = list()
空字典表示方法：mes = {} 或 mes = dict()
空元组表示方法：mes = () 或 mes = tuple()
空集合表示方法： mes = set()
其他
如果在 if 、while 条件后面写一个值当做条件时，他会默认转换为布尔类型，然后再做条件判断。
字符串（str）
定义
字符串，我们平时会用他来表示文本信息。
字符串的表示：
v1 = "包治百病" v2 = '包治百病' v3 = "包'治百病" v4 = '包"治百病' v5 = """ 吵架都是我的错，` 因为大家打不过。` """ # 三个引号，可以支持多行/换行表示一个字符串，其他的都只能在一行中表示一个字符串。`
常用方法
Python中给属于字符串的所有的值都提供了一些功能（方法），从而可以快速对字符串进行一些方便的操作。
注意：这是字符串类型独有的功能，其他类型中没有此功能。
-
转换大写 upper（）
name = 'william' print(name.upper())
# 输出结果：WILLIAM -
转换小写 lower（）
name = 'WILLIAM' print(name.lower())
# 输出结果：william -
首字母大写 title（）
name = 'william' print(name.title())
#输出结果：William -
去除两端空白、制表符（\t）、换行符(\n) strip（）去除左侧空白、制表符（\t）、换行符(\n) lstrip（）去除右侧空白、制表符（\t）、换行符(\n) rstrip（）
name = '\twilliam\n' print(name.strip()) #输出结果：william print(name.lstrip()) #输出结果：william\n（代表还有下一行） print(name.rstrip()) #输出结果： william
-
替代 replace（）
message = 'alex is a pig' print(message.replace('pig', 'dog'))
#输出结果:alex is a dog -
字符串分割，得到一个列表 split（）
meaasge = 'alex+william+eric+james' print(message.split('+')) # 输出结果：['alex', 'william', 'eric', 'james'] -
是否按照某字符开头结尾，结果是布尔值 startswith（）endswith（）
meaaasge = 'james is gota' print(message.startswith('ja')) #输出结果:True print(message.endswith('ta')) #输出结果:True
print(message.endswith('ja')) #输出结果:False -
字符串格式化
'''
# 1.在整型中支持整型之间的加减乘除，在字符串中则支持字符串的 加、乘。
字符串拼接（相加）格式： “字符串A” + “字符串B” ，要求字符串只能和字符拼接。
字符串相乘格式： 整型 * “字符串”，效果就是让此字符串重新出现多少次，要求必须是整型和字符串相乘。
'''
# 两个字符串 "金角" + "你是大王吧" 相加（一般称字符串相加为字符串拼接），并使用print输出# 代码内部会先做字符串拼接，再调用print输出凭借后结果print( "金角"+"你是大王吧" )# 整型和字符串拼接（错误，不支持）print( 5+"乔碧萝" )# 整型和字符串相乘，得到字符串 "小逼崽子小逼崽子小逼崽子"print( 3*"小逼崽子" )# 2.format
name = "{0}的爱好有很多，例如有：{1}、{2} 等"
data = name.format("老王","篮球","足球")
print(data) #输出结果：老王的爱好有很多，例如有：篮球、足球等
# 3.占位符：%s
# 示例1：
data = "我叫%s，今年%s岁" %("william",18)
print(data)# 输出：我叫william，今年18岁'''
代码解析过程：
-
现有一个含有特殊
%s的字符串 【”我叫%s，今年%s岁”】； -
在字符串后面紧跟 %(“替换第一个%s位置”,”替换第二个%s的位置”)，就会把字符串中的特殊%s替换，最终得到替换的字符串【”我叫wupeiqi，今年18岁”】;
-
将这个已被替换完成字符串赋值给data，输出data就得到结果了。
注意：一般称字符串中的
%s叫占位符，而占位符被替换的过程叫字符串格式化。'''
# 示例2：
name = "王哥"
message = "Alex今天不在家，%s你什么时候过来？" %(name)
print(message)# 输出：Alex今天不在家，王哥你什么时候过来？# 示例3：
name = "王哥"
template = "Alex今天不在家，%s你什么时候过来？"
message = template %(name)
print(message)# 输出：Alex今天不在家，王哥你什么时候过来？# 示例4：
user = input("请输入用户名：")
address = input("请输入地点：")
action = input("请输入行为：")
data = "%s在%s，一直在%s。" %(user,address,action)
print(data)# 4. 占位符：%%
'''
上面通过 %s 占位符可以实现格式化，但如果想要在页面上输出输出百分比的话，就比较难搞了，例如：
# 正确message = "兄弟们，这个片我已经下载 90 %了，马上就可以开看了啊。print(message)
# 报错message = "兄弟们，这个片我已经下载 %s %了，马上就可以开看了啊。" %(99,)print(message)
# 正确message = "兄弟们，这个片我已经下载 %s %%了，马上就可以开看了啊。" %(99,)print(message)在字符串格式化时，如果想要输出
%,则必须写两个%%才能正确输出%。写在最后，关于字符串格式化还有其他方式（如：format/f-string），但为了让初学者更好掌握，在此不再一一进行赘述，因为 %s基本上就可以完成所有的字符串格式化的任务，目前只要掌握 %s 就行。
'''
# 5. f字符串格式化（py3.6以上特有）
# 填充字符串
msg = f"你好{'william'}"
print(msg)
# 填充变量
name = 'williams'
msg = f"你好{name}"
print(msg)
#填充计算公式
msg = f"{35+15}"
print(msg)
#填充表达式
a = 10
b = 20
msg = f"{a if a > b else b}"print(msg)
-
-
判断是否是数字，结果是布尔值 isdigit（）、 isdecimal（）（推荐使用，只能判断是否是十进制0-9） isnumeric（）
age = '15' print(age.isdecimal()) # 输出结果:True
-
encode和decode分别按指定编码对字符串编码和解码 decode（）encode（）
message = '中' print(message.encode('utf-8')) #输出结果：b'\xe4\xb8\xad' message = b'\xe4\xb8\xad' print(message.decode('utf-8')) #输出结果：中 -
字符串拼接 join（）
data_list = ["中国","小日本"] result = "干掉".join(data_list) print(result) #输出结果：中国干掉小日本（通过`干掉`把列表中的值拼接起来）
-
查看字符个数count
data = 'deepre' print(data.count('e')) # 3 -
判断是否为字母 isalpha（）
s = 'a1' for i in s: print(i.isalpha()) -
判断是否是字母、数字的组合 isalnum()
s = 'a1' for i in s: print(i.isalnum())
转换为字符串
以后的python开发中经常的用是：数字转为字符串类型。
number = 888 data = str(number) print(type(number),type(data))
# 输出结果：<class 'int'> <class 'str'>
其他
字符串除了有上述那些字符串独有的功能以外，还有一个其他“公共的功能”，某些其他的类型也具有的功能。
-
获取字符串长度
name = 'alex' print(len(name)) #输出结果：4
-
索引,索引，获取字符串中某个字符的值。
name = "来做点py交易" print( name[0] ) # 输出 来 print( name[1] ) # 输出 做 print( name[6] ) # 输出 易 （默认索引是从0向后逐步向后增加，索引超出最大范围会报错） print( name[-1] ) # 输出 易 （如果索引为负值，则表示从后向前，-1表示最后一个） print( name[-3] ) # 输出 y print( name[len(name)-1]) # 输出 易 # 案例：循环字符串的所有字符 content = "长江以北晓峰最美山海关以外晓峰最帅" index = 0 while index < len(content): char = content[index] print(char) index += 1 # 案例：循环字符串的所有字符 content = "你瞅啥" index = -1 while index >= - len(content): char = content[index] print(char) index -= 1 -
切片,获取字符串中n连续的字符的值。
name = "你是风儿我是沙。不，我不是沙而是你爸" print( name[0:2] ) # 输出：你是 （根据索引 `前`按开区间 `后`按闭区间，即：前取后不取） print( name[2:5] ) # 输出：风儿我 print( name[2:]) # 输出：风儿我是沙。不，我不是沙而是你爸（后面不写表示到最后） print( name[:6]) # 输出：你是风儿我是（前面不是表示从头开始） print( name[2:-1]) # 输出：风儿我是沙。不，我不是沙而是你 print( name[2:-2]) # 输出：风儿我是沙。不，我不是沙而是 print( name[0:len(name)]) # 输出：你是风儿我是沙。不，我不是沙而是你爸
-
步长,跳步取值
name = "生活不是电影，生活比电影苦" print( name[ 0:5:2 ] ) # 输出：生不电 【前两个值表示区间范围，最有一个值表示步长】 print( name[ :8:2 ] ) # 输出：生不电，活 【区间范围的前面不写则表示起始范围为0开始】 print( name[ 2::3 ] ) # 输出：不影活影 【区间范围的后面不写则表示结束范围为最后】 print( name[ ::2 ] ) # 输出：生不电，活电苦 【区间范围不写表示整个字符串】 print( name[ 8:1:-1 ] ) # 输出：活生，影电是不 【倒序】 print( name[ ::-1 ] ) # 输出：苦影电比活生，影电是不活生 【倒序】
-
for循环
想要循环显示字符串的每个字符， while循环 + 索引 可以实现，通过for循环则可以更方便的实现。 content = "三分天注定，七分靠滤镜" for item in content: print(item) # 案例：判断用输入的值中有多少个字符 `a`(不区分大小写，即：A、a) total_count = 0 content = input("请输入内容：") for char in content: if char.upper() == 'A': total_count += 1 message = "您输入的内容中A/a共有{}个".format(total_count) # 案例：break和continue也可以应用在for循环中 data = "像我这样优秀的人,本该灿烂过一生" for item in data: print(item) if item == "人": break
列表（list）
定义
可以把列表当做是一个有序的容器，在里面可以放很多的元素。元素可重复
user_list = ["铁锤","钢弹","弹头"] number_list = [98,88,666,12,-1] data_list = [1,True,"王帅齐"]
常用方法
-
追加，在原列表尾部追加元素 append()
num = [1, 2, 3] num.append(4) print(num) #输出结果：[1, 2, 3, 4]
-
插入，在原列表指定索引位置插入元素 insert()
num = [1, 2, 3] num.insert(0, 4) print(num) #输出结果：[4, 1, 2, 3]
-
在原列表中根据索引踢除某个元素 pop()
num = [1, 2, 3] num.pop() print(num) #输出结果：[ 1, 2] 不指定索引，剔除列表最后一个元素 num = [1, 2, 3] num.pop(1) print(num) #输出结果：[ 1, 3]
-
在原列表中根据值删除（从左到右找到第一个删除） remove()
num = [1, 2, 3] num.remove(2) print(num) #输出结果：[ 1, 3]
-
清空原列表 clear()
num = [1, 2, 3] num.clear() print(num) #输出结果：[]
-
扩展，一个列表中的元素添加另外一个列表。 extend()
num1 = [1, 2, 3] num2 = [4, 5, 6] num1.extend(num2) print(num1) #输出结果：[1, 2, 3, 4, 5, 6]
-
对列表进行排序 sort() 数字列表从小到大，字符串列表按字母a-z排序
num = [6, 8, 1, 2] num.sort() print(num) #输出结果：[1, 2, 6, 8]
-
反转原列表 reverse()
num = [6, 8, 1, 2] num.reverse() print(num) #输出结果：[2, 1, 8, 6]
转换为列表
如果想要让某些元素转换为列表类型，一般需要通过list强转，他的内部其实就是循环每个元素，再将元素追加到列表中。 所以，想要转换为列表类型有要求：必须可以被循环的元素才能转换为列表。整形、布尔值不可以，其他均可。
message = "我猜你的枪里没有子弹" data = list(message) print(data) # 输出结果：["我","猜","你","的","枪","里","没","有","子","弹"]
其他
-
获取列表长度 len()
num = [1, 2, 3, 6] print(len(num)) # 输出结果：4
-
索引
user_list = ['william', 'eric', 'alex'] print( user_list[0] ) # 输出结果：william print( user_list[1] ) # 输出结果：eric print( user_list[2] ) # 输出结果：alex
-
根据索引删除 del
user_list = ['william', 'eric', 'alex'] del user_list[1] # 删除eric del user_list[1] # 删除alex print(user_list) # 输出结果：['william']
-
根据索引替换
user_list = ['william', 'eric', 'alex'] user_list[0] = 'james' print(user_list) # 输出结果：['james', 'eric', 'alex']
-
切片
user_list = ['william', 'eric', 'alex', 'james'] print(user_list[0:2]) # 输出结果： ['william', 'eric'] print( user_list[1:] ) # 输出结果： ['eric', 'alex', 'james'] print( user_list[:-1] ) # 输出结果： ['william', 'eric', 'alex']
-
步长
user_list = ['william', 'eric', 'alex', 'james', 'paul'] print( user_list[1:4:2] ) # 输出结果：['eric', 'james'] print( user_list[0::2] ) # 输出结果：['william', 'alex', 'paul'] print( user_list[1::2] ) # 输出结果：['eric', 'james'] print( user_list[4:1:-1] ) # 输出结果：['paul', 'james', 'alex']
-
for循环
user_list = ['william', 'eric', 'alex', 'james', 'paul'] for item in user_list: print(item) user_list = ['william', 'eric', 'alex', 'james', 'paul'] for item in user_list: if item == 'alex': continue print(item)
嵌套
列表属于容器，内部可以存放各种数据，所以他也支持列表的嵌套，如：
data = [ "谢广坤",["海燕","赵本山"],True,[11,22,33,44],"宋小宝" ]
对于嵌套的值，可以根据之前学习的索引知识点来进行学习，例如：
data = [ "谢广坤",["海燕","赵本山"],True,[11,22,33,44],"宋小宝" ]
print( data[0] )
print( data[1] )
print( data[0][2] )
print( data[1][-1] )
data.append(666)
print(data)
del data[-2]
print(data)
data[1].append("谢大脚")
print(data)
元组（tuple）
定义
元组也是一个容器，里面可以存放各种数据（和列表相似），但他有一个特殊的特点：元组的元素不允许添加、不允许修改、不允许删除，只能读。
一般用于存储一些在程序中不应该被修改的一系列值。
v1 = (11,22,33,)
v2 = ("william","Alex",)
v3 = ("william",)
注意：建议在元组的最后多加一个逗号，用于标识他是一个元组。
3.5.2 常用方法
无
3.5.3 转换为元组
其他类型可以转换为元组，一般可以被循环的元素才能转换
name = "王帅齐"
data = tuple(name)
print(data) # 输出 ("王","帅","齐")
name = ["王帅齐",18,"pythonav"]
data = tuple(name)
print(data) # 输出 ("王帅齐",18,"pythonav")
3.5.4其他
元组和列表非常相似，但由于元组的子元素无法修改的特点，所有在元组都没有修改、删除、添加的操作，只有读操作。
-
获取元组长度
num = (1, 2, 3, 6,) print(len(num)) # 输出结果：4
-
索引
user_list = ('william', 'eric', 'alex') print( user_list[0] ) # 输出结果：william print( user_list[1] ) # 输出结果：eric print( user_list[2] ) # 输出结果：alex -
切片
user_list = ('william', 'eric', 'alex', 'james') print(user_list[0:2]) # 输出结果： ('william', 'eric') print( user_list[1:] ) # 输出结果： ('eric', 'alex', 'james')
print( user_list[:-1] ) # 输出结果： ('william', 'eric', 'alex') -
步长
user_list = ('william', 'eric', 'alex', 'james', 'paul') print( user_list[1:4:2] ) # 输出结果：('eric', 'james') print( user_list[0::2] ) # 输出结果：('william', 'alex', 'paul') print( user_list[1::2] ) # 输出结果：('eric', 'james') print( user_list[4:1:-1] ) # 输出结果：('paul', 'james', 'alex') -
for循环
user_list = ('william', 'eric', 'alex', 'james', 'paul') for item in user_list: print(item) user_list = ('william', 'eric', 'alex', 'james', 'paul') for item in user_list: if item == 'alex': continue print(item)
字典（dict）
定义
字典也可以当做是个容器，在内部可以存放数据。相比较于元组和列表，字典的元素必须是键值对。
注意：在Python3.6x字典就是有序了，之前的字典都是无需。
info = {"age":12, "status":True, "name":"williams","hobby":['篮球','足球']}
# 例如： "age":12 称为一个键值对。
注意：字典的键有特殊要求，即：必须可哈希`。 目前为止学到的可哈希的类型：int/bool/str/tuple；不可哈希的类型：list/dict/set
# 合法
dic = {123: 456,
True: 999,
"id": 1,
"name": 'sylar',
"age": 18,
"stu": ['帅哥', '美⼥'],
(1, 2, 3): '麻花藤'}
print(dic[123])
print(dic[True])
print(dic['id'])
print(dic['stu'])
print(dic[(1, 2, 3)])
# 不合法
# dic = {[1, 2, 3]: '周杰伦'} # list是不可哈希的. 不能作为key
# dic = {{1: 2}: "哈哈哈"} # dict是不可哈希的. 不能作为key
# dic = {{1, 2, 3}: '呵呵呵'} # set是不可哈希的, 不能作为key
3.6.2 常用方法
-
所有的键
info = {"age":12, "status":True, "name":"williams","email":"xx@live.com"} data = info.keys() # 获取字典的所有的键，返回一个`高仿的`列表，存放的都是字典中的key。 print(data) # 输出：dict_keys(['age', 'status', 'name', 'email']) info = {"age":12, "status":True, "name":"williams","email":"xx@live.com"} for ele in info.keys(): print(ele)注意：在Python2.x中 字典.keys()直接获取到的是列表，而Python3.x中返回的是高仿列表，这个高仿的列表可以被循环显示。
-
所有的值
info = {"age":12, "status":True, "name":"williams","email":"xx@live.com"} data = info.values() print(data) # 输出：dict_values([12, True, 'williams', 'xx@live.com']) info = {"age":12, "status":True, "name":"williams","email":"xx@live.com"} for ele in info.values(): print(ele)注意：在Python2.x中 字典.values()直接获取到的是列表，而Python3.x中返回的是高仿列表，这个高仿的列表可以被循环显示。
-
所有的键值对
info = {"age":12, "status":True, "name":"williams","email":"xx@live.com"} data = info.items() print(data) # 输出 dict_items([('age', 12), ('status', True), ('name', 'williams'), ('email', 'xx@live.com')]) info = {"age":12, "status":True, "name":"williams","email":"xx@live.com"} for item in info.items(): print(item) # item是一个元组 (键，值) info = {"age":12, "status":True, "name":"williams","email":"xx@live.com"} for key,value in info.items(): print(key,value) # key代表键，value代表值，将兼职从元组中直接拆分出来了。 -
更新字典的键值对
fo = {"age":12, "status":True} info.update({"age":14,"name":"williams"}) # info中没有的键直接添加；有的键则更新值 print(info) # 输出：{"age":14, "status":True,"name":"williams"} -
移除字典的键值对
info = {"age":12, "status":True,"name":"williams"} data = info.pop("age") print(info) # {'status': True, 'name': 'williams'} print(data) # 12 -
根据键获取对应的值
info = {"age":12, "status":True,"name":"williams"} data = info.get("name",None) # 根据name为键去info字典中获取对应的值，如果不存在则返回None，存在则返回值。 print(data) # 输出：williams
转换为字典
由于字典的每一个元素是键值对，所以想要转换为字典的必须要有个特定的格式才能转换成功
v = dict([("k1","v1"),("k2","v2")])
print(v) # 输出：{'k2': 'v2', 'k1': 'v1'}
v = dict([ ["k1","v1"], ["k2","v2"] ])
print(v) # 输出：{'k2': 'v2', 'k1': 'v1'}
两个长度相等的list转换成字典，用zip函数
list1 = ['序号', '部门', '人数', '平均年龄', '备注']
list2 = ['1', 'python', '30', '26', '单身狗']
dict1 = dict(zip(list1, list2))
print(dict1) # 输出:{'序号': '1', '部门': 'python', '人数': '30', '平均年龄': '26', '备注': '单身狗'}
子元素必须包含两个元素，从而将值对应给字典的键、值。
创建字典的方式
1.直接创建
dic = {'k2': 'v2', 'k1': 'v1'}
2.字典推导式
dic = {k: 1 for k in range(3)}
3.dict（）
print(dict(one=1, two=2)) # {'one': 1, 'two': 2}
其他
-
获取字典长度
info = {"age":12, "status":True,"name":"williams"} data = len(info) print(data) # 输出：3 -
索引(键)
字典不同于元组和列表，字典的索引是键，而列表和元组则是 0、1、2等数值。
info = {"age":12, "status":True,"name":"williams"} print(info["age"]) # 输出：12 print(info["name"]) # 输出：williams print(info["status"]) # 输出：True print(info["xxxx"]) # 报错，通过键为索引去获取之后时，键不存在会报错（以后建议使用get方法根据键去获取值）提示：字典根据键的查找速度非常快，远远大于列表或元组通过索引查找的速度，因为字典内部是基于hash存储。
-
根据键 修改值 和 添加值 和 删除键值对
info = {"age":12, "status":True,"name":"williams"} info["gender"] = "男" # gender键在字典中不存在，则自动在字典中新添加一个键值对 print(info) # 输出： {"age":12, "status":True,"name":"williams","gender":"男"} info["age"] = "18" # age键在info字典中已存在，则更新键对应的值 print(info) # 输出： {"age":18, "status":True,"name":"williams"} del info["age"] # 删除info字典中键为age的那个键值对（键不存在则报错） print(info) # 输出： {"status":True,"name":"williams"} -
for循环
由于字典也属于是容器，内部可以包含多个键值对，可以通过循环对其中的：键、值、键值进行循环；
info = {"age":12, "status":True,"name":"williams"} for item in info.key(): print(item) for item in info.values(): print(item) for key,value in info.items(): print(key,value) -
字典嵌套
list/tuple/dict/set类型中可以包含子元素，所以他们的内容就可以进行数据的嵌套。但在嵌套和对内部数据操作时要注意：元组子元素不能变、不可哈希的list、dict、set不能做字典的键，也不能做集合的子元素
dic = { 'name':'汪峰', 'age':48, 'wife':[{'name':'国际章','age':38}], 'children':['第一个熊孩子','第二个熊孩子'] } """ 1. 获取汪峰的妻子名字 d1 = dic['wife'][0]['name'] print(d1) 2. 获取汪峰的孩子们 d2 = dic['children'] print(d2) 3. 获取汪峰的第一个孩子 d3 = dic['children'][0] print(d3) 4. 汪峰的媳妇姓名变更为 章子怡 dic['wife'][0]['name] = "章子怡" print(dic) 5. 汪峰再娶一任妻子 dic['wife'].append({"name":"铁锤","age":19}) print(dic) 6. 给汪峰添加一个爱好：吹牛逼 dic['hobby'] = "吹牛逼" print(dic) 7. 删除汪峰的年龄 del dic['age'] 或 dic.pop('age') print(dic) """
集合（set）
定义
集合与元组和列表相似都用于做容器，在内部可以放一些子元素，但集合有三特殊特点： 子元素不重复、子元素必须可哈希、无序.
提示：目前可哈希的数据类型 int/str/bool/tuple;不可哈希的类型dict/list/set 。
v1= {1,2,99,18}
v2 = {"williams","Alex","老妖","Egon"}
v3 = {1,True,"world",(11,22,33)}
集合与字典虽然都是用{}括号，但字典内部是键值对，而集合内部直接是值。
常用方法
-
添加元素
data = {"刘嘉玲", '关之琳', "王祖贤"} data.add("郑裕玲") print(data) # {'郑裕玲', '王祖贤', '刘嘉玲', '关之琳'} data = set() data.add("周杰伦") data.add("林俊杰") print(data) # {'林俊杰', '周杰伦'} -
删除元素
data = {"刘嘉玲", '关之琳', "王祖贤","张曼⽟", "李若彤"} data.discard("关之琳") print(data) # {'刘嘉玲', '李若彤', '王祖贤', '张曼⽟'} -
交集
s1 = {"刘能", "赵四", "⽪⻓⼭"} s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"} s3 = s1 & s2 # 方式一：取两个集合的交集 s4 = s1.intersection(s2)) # 方式二：取两个集合的交集 print(s3,s4) -
并集
s1 = {"刘能", "赵四", "⽪⻓⼭"} s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"} s3 = s1 | s2 # 方式一：取两个集合的并集 s4 = s1.union(s2)) # 方式二：取两个集合的并集 print(s3,s4) -
差集
s1 = {"刘能", "赵四", "⽪⻓⼭"} s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"} s3 = s1 - s2 # 方式一：差集，s1中有且s2中没有的值 s4 = s1.difference(s2) # 方式二：差集，s1中有且s2中没有的值 print(s3,s4) s5 = s2 - s1 # 方式一：差集，s2中有且s1中没有的值 s6 = s2.difference(s1) # 方式一：差集，s2中有且s1中没有的值 print(s5,s6)
转换为集合
其他类型如果想要转换为集合类型，可以通过set进行转换，并且如果数据有重复自动剔除。
提示：int/list/tuple/dict都可以转换为集合。
v1 = [11,22,33,11,3,99,22]
v2 = set(v1)
print(v2) # {11,22,33,3,99}
v1 = "王帅齐"
v2 = set(v1)
print(v2) # {"王","帅","齐"}
v1 = (11,22,3,11)
v2 = set(v1)
print(v2) # {11,22,3}
v1 = {"age":12, "status":True,"name":"williams"}
print( set(v1.keys()) ) # 输出：{'status', 'name', 'age'
}print( set(v1.values()) ) # 输出：{'status', 'name', 'age'}
print( set(v1.items()) ) # 输出：{('age', 12), ('status', True), ('name', 'williams')}
其他
-
索引/切片/步长 集合中没有提供 索引/切片/步长 这些功能，因为他无需，所以无法使用索引操作。
-
获取集合长度
v = {"刘能", "赵四", "尼古拉斯") data = len(v) print(data) # 3 -
for循环
v = {"刘能", "赵四", "尼古拉斯") for item in v: print(item)
浙公网安备 33010602011771号