Python基础语法文章导航：
- Python基础（01初识数据类型&变量）
- Python基础（02条件&循环语句）
- Python基础（03字符串格式化&运算符&进制&编码）
- Python基础（04 基础练习题）
- Python数据类型（day05整型&布尔类型&字符串类型）
- Python数据类型（06列表&元组）
目录
一.集合
集合是一个无序、可变、不允许数据重复的容器。
1.定义
v1={11,22,33,"nice"}-
无序，无法通过索引取值。
-
可变，可以添加和删除元素
v1={11,22,33,44} v1.add(55) print(v1) # {11,22,33,44,55} -
不允许数据重复（上一节的列表是允许重复的）
v1={11,22,33,44} v1.add(22) print(v1) # {11,22,33,44}
根据集合的这些“无序、可变、不允许数据重复”的特点，当想维护一大堆不重复的数据的时候，就可以用到集合。
注意：空集合只能使用v=set()，不能使用v={}（因为这样子是定义的一个空字典，键值对），以下是一些空列表、空元组、空集合、空字典的定义。
v1 = []
v11 = list()
v2 = ()
v22 = tuple()
v3 = set()
v4 = {} # 空字典
v44 = dict()2.独有功能
（1）add()
add()：添加元素，一次只能添加一个。注意：如果要添加的元素是集合中已存在的元素，则跳过该元素，不进行添加。
data1 = {"刘嘉玲", '关之琳', "王祖贤"}
data1.add("郑裕玲")
print(data1) #{'刘嘉玲', '郑裕玲', '王祖贤', '关之琳'}
data2 = set()
data2.add("周杰伦")
data2.add("林俊杰")
print(data2) #{'周杰伦', '林俊杰'}
data3 = {"刘嘉玲", '关之琳', "王祖贤"}
data3.add("周杰伦")
data3.add("林俊杰")
data3.add("王祖贤") #{'林俊杰', '关之琳', '王祖贤', '刘嘉玲', '周杰伦'}
（2）discard()
discard()：删除元素，一次只能删除一个元素。
data = {"刘嘉玲", '关之琳', "王祖贤","张曼⽟", "李若彤"}
data.discard("关之琳")
print(data) #{'李若彤', '王祖贤', '张曼⽟', '刘嘉玲'}（3）intersection()
intersection()：可以取多个集合的交集。
s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s3={"⽪⻓⼭"}
s4={"冯乡⻓"}
s5 = s1.intersection(s2) # 取两个集合的交集
print(s5) # {"⽪⻓⼭"}
s6 = s1.intersection(s2,s4) # 取多个集合的交集
print(s6) # set()
s3 = s1 & s2 & s3 # 取多个集合的交集
print(s3) # {"⽪⻓⼭"}（4）union()
union()：可以取多个集合的并集。
s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s3 = {"程序员"}
s4 = s1.union(s2) # 取两个集合的并集
print(s4)
s5 = s1.union(s2, s3) # 取多个集合的并集
print(s5)
s6 = s1 | s2 # 取两个集合的并集
print(s6)
s7 = s1 | s2 | s3 # 取多个集合的并集
print(s7)
#{'赵四', '⽪⻓⼭', '刘科⻓', '刘能', '冯乡⻓'}
#{'赵四', '⽪⻓⼭', '刘科⻓', '刘能', '冯乡⻓', '程序员'}
#{'赵四', '⽪⻓⼭', '刘科⻓', '刘能', '冯乡⻓'}
#{'赵四', '⽪⻓⼭', '刘科⻓', '刘能', '冯乡⻓', '程序员'}
（5）difference()
difference()：可以取多个集合之间的差集。原理：集合A在前面就以集合A为主导，去看集合B、C...等集合在A集合中没有的元素。
s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s = {"程序员"}
s4 = s1.difference(s2) # 差集，s1中有且s2中没有的值 {"刘能", "赵四"}
s6 = s2.difference(s1) # 差集，s2中有且s1中没有的值 {"刘科⻓", "冯乡⻓"}
s7=s.difference(s2,s1)
s3 = s1 - s2 # 差集，s1中有且s2中没有的值
s5 = s2 - s1 # 差集，s2中有且s1中没有的值
print(s5,s6,s7)
#{'刘科⻓', '冯乡⻓'} {'刘科⻓', '冯乡⻓'} {'程序员'}3.公共功能
（1）减，计算差集
和difference()功能一样。
s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s3 = s1 - s2
s4 = s2 - s1
print(s3)
print(s4)（2）&，计算交集
和intersection()功能一样。
s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s3 = s1 & s2
print(s3)（3）|，计算并集
和union()功能一样。
s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s3 = s1 | s2
print(s3)（4）len()
#计算长度
v = {"刘能", "赵四", "尼古拉斯"}
data = len(v)
print(data)（5）for循环
v = {"刘能", "赵四", "尼古拉斯"}
for item in v:
print(item)4.转换
其他类型如果想要转换为集合类型，可以通过set进行转换，并且如果数据有重复自动剔除。
提示：str/int/list/tuple/dict都可以转换为集合。转换为集合，其实是去重的一个手段，去重之后可以再次还原原数据类型。
#字符串转化成集合，自动去重，每个字符划分成一个集合的元素
v1 = "武沛齐沛"
v2 = set(v1)
print(v2) # {"武","沛","齐"}
#列表转化成集合，自动对列表中的每个元素进行去重
v1 = [11,22,33,11,3,99,22]
v2 = set(v1)
print(v2) # {11,22,33,3,99}
#元组转化成集合，自动对元组中的每个元素进行去重
v1 = (11,22,3,11)
v2 = set(v1)
print(v2) # {11,22,3}
如果你只关心字典中的键或值或键值对，并希望去重，可以将 键或值或键值对 转换为集合。注意，字典的键、键值对 本身是唯一的，因此去重操作对键、键值对 没有实际效果。
#1. 字典转化成集合，去重字典的键
# 示例字典
my_dict = {
'a': 1,
'b': 2,
'c': 3,
'a': 4 # 键 'a' 在字典中只保留一个
}
# 转换为集合（键的集合）
keys_set = set(my_dict.keys())
print(keys_set) # 输出: {'a', 'b', 'c'}
#2. 字典转化成集合，去重字典的值
# 示例字典
my_dict = {
'a': 1,
'b': 2,
'c': 2,
'd': 3
}
# 转换为集合（值的集合）
values_set = set(my_dict.values())
print(values_set) # 输出: {1, 2, 3}
#3. 字典转化成集合，去重字典的键值对，该操作通常不是必要的，因为字典的键值对本身就是唯一的。
# 示例字典
my_dict = {
'a': 1,
'b': 2,
'c': 2,
'd': 1 # 键值对 ('d', 1) 和 ('a', 1) 在集合中也会被认为是重复
}
# 转换为集合（键值对的集合）
items_set = set(my_dict.items())
print(items_set) # 输出: {('a', 1), ('b', 2), ('d', 1)}5.其他
（1）可哈希
集合的元素必须是可哈希的值，即：内部通过哈希函数（hash()）把值转换成一个数字。
可哈希的数据类型：int、float、bool、str、tuple，而list、set、dict是不可哈希的。
总结：集合的元素只能是 int、bool、str、tuple、float 。
#转换成功
v1 = [11,22,33,11,3,99,22]
v2 = set(v1)
print(v2) # {11,22,33,3,99}
#转换失败
v1 = [11,22,["alex","eric"],33]
v2 = set(v1) # 报错
print(v2) （2）查找速度快
因存储原理特殊，集合的查找效率非常高（数据量大了才明显）。
集合的存储原理如下：
（3）对比和嵌套
| 类型 | 是否可变 | 是否有序 | 元素要求 | 是否可哈希 | 转换 | 定义空 |
| list | 是 | 是 | 无 | 否 | list(其他) | v=[]或v=list() |
| tuple | 否（不可修改，可增长） | 是 | 无 | 是 | tuple(其他) | v=()或v=tuple() |
| set | 是 | 否 | 可哈希 | 否 | set(其他) | v=set() |
注意：由于True和False本质上存储的是 1 和 0 ，而集合又不允许重复，所以在整数 0、1和False、True出现在集合中会有如下现象：
v1 = {True, 1}
print(v1) # {True}
v2 = {1, True}
print(v2) # {1}
v3 = {0, False}
print(v3) # {0}
v4 = {False, 0}
print(v4) # {False}二.字典
1.定义
字典是一个 无序、键不重复且元素只能是键值对的 可变的 容器。
#空字典的定义
v1={}
v2=dict()
#字典的定义
info = {
"age":12,
"status":True,
"name":"wupeiqi",
"hobby":['篮球','足球']
}字典中对键值对要求：
-
键：必须可哈希。可哈希的类型：int/bool/str/tuple/float；不可哈希的类型：list/set/dict。（集合）
-
值：任意类型。
#1.合法
data_dict = {
"武沛齐":29,
True:5,
123:5,
(11,22,33):["alex","eric"],
1.25:1
}
print(type(data_dict)) #<class 'dict'>
#2.不合法
# 不合法
v1 = {
[1, 2, 3]: '周杰伦', #键是列表，不可哈希
"age" : 18
}
v2 = {
{1,2,3}: "哈哈哈", #键是集合，不可哈希
'name':"alex"
}
v3 = {
{"k1":123,"k2":456}: '呵呵呵', #键是字典，不可哈希
"age":999
}注意：由于True和False本质上存储的是 1 和 0 ，而字典又不允许键重复，所以在整数 0、1和False、True出现在字典的键中会有如下现象（同集合有一样的逻辑），会自动去重：
data_dict = {
1: 29,
True: 5
}
print(data_dict) # {1: 5}2.独有功能
（1）get()
get()：获取值
info = {
"age":12,
"status":True,
"name":"武沛齐",
"data":None
}
data1 = info.get("name")
print(data1) # 输出：武沛齐
#拓展1
data = info.get("email") # 键不存在，默认返回 None
print(data) #None
#拓展2
data = info.get("hobby",123)
print(data) # 123
print(info) #{'age': 12, 'status': True, 'name': '武沛齐', 'data': None}
#拓展3
#案例
user_list = {
"wupeiqi": "123",
"alex": "uk87",
}
username = input("请输入用户名：")
password = input("请输入密码：")
# None，用户名不存在
# 密码，接下来比较密码
pwd = user_list.get(username)
if not pwd:
print("用户名不存在")
else:
if password == pwd:
print("登录成功")
else:
print("密码错误")
# 写代码的准则：简单的逻辑处理放在前面；复杂的逻辑放在后面。（2）keys()
keys()：获取所有的键，Python3获取到是 高仿列表。最后可通过list()转换成列表进行使用，也可以通过for循环进行循环显示，通过in判断键是否包含在字典中。
info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
data = info.keys()
print(data) # 输出：dict_keys(['age', 'status', 'name', 'email'])
result = list(data)
print(result) #['age', 'status', 'name', 'email']
# 循环
info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
for ele in info.keys():
print(ele)
#age
#status
#name
#email
# 是否存在
info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
# info.keys() # dict_keys(['age', 'status', 'name', 'email'])
if "age" in info.keys():
print("age是字典的键")
else:
print("age不是")（3）values()
values()：获取所有的键，Python3获取到是 高仿列表。最后可通过list()转换成列表进行使用，也可以通过for循环进行循环显示，通过in判断值是否包含在字典中。
info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
data = info.values()
print(data) # 输出：dict_values([12, True, 'wupeiqi', 'xx@live.com'])
print(list(data)) #[12, True, 'wupeiqi', 'xx@live.com']（4）items()
items()：获取所有的键值对，Python3获取到是 高仿列表。最后可通过list()转换成列表进行使用，也可以通过for循环进行循环显示，通过in判断值是否包含在字典中。
info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
data = info.items()
print(data) # 输出 dict_items([ ('age', 12), ('status', True), ('name', 'wupeiqi'), ('email', 'xx@live.com') ])
print(list(data)) #[('age', 12), ('status', True), ('name', 'wupeiqi'), ('email', 'xx@live.com')]
#循环方法1
for item in info.items():
print(item[0],item[1]) # item是一个元组 (键，值)
# age 12
# status True
# name wupeiqi
# email xx@live.com
#循环方法2
for key,value in info.items():
print(key,value) # key代表键，value代表值，将兼职从元组中直接拆分出来了。
# age 12
# status True
# name wupeiqi
# email xx@live.com
#是否包含
info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
data = info.items()
if ('age', 12) in data:
print("在")
else:
print("不在")（5）setdefault()
#设置值
data = {
"name": "武沛齐",
"email": 'xxx@live.com'
}
data.setdefault("age", 18)
print(data) # {'name': '武沛齐', 'email': 'xxx@live.com', 'age': 18}
data.setdefault("name", "alex")
print(data) # {'name': '武沛齐', 'email': 'xxx@live.com', 'age': 18}（6）update()
#更新字典键值对
info = {"age":12, "status":True}
info.update( {"age":14,"name":"武沛齐"} ) # info中没有的键直接添加；有的键则更新值
print(info) # 输出：{"age":14, "status":True,"name":"武沛齐"}（7）pop()
#移除指定键值对
info = {"age":12, "status":True,"name":"武沛齐"}
data = info.pop("age")
print(info) # {"status":True,"name":"武沛齐"}
print(data) # 12（8）popitem()
#按照顺序移除（后进先出，就是移除字典的最后一个键值对）
info = {"age":12, "status":True,"name":"武沛齐"}
data = info.popitem() # ("name","武沛齐" )
print(info) # {"age":12, "status":True}
print(data) # ("name","武沛齐")3.公共功能
（1）求并集，|
v1 = {"k1": 1, "k2": 2}
v2 = {"k2": 22, "k3": 33}
v3 = v1 | v2
print(v3) # {'k1': 1, 'k2': 22, 'k3': 33}（2）len()
info = {"age":12, "status":True,"name":"武沛齐"}
data = len(info)
print(data) # 输出：3（3）in，是否包含
info = {"age": 12, "status": True, "name": "武沛齐"}
# 输出info.items()获取到的 dict_items([ ('age', 12), ('status', True), ('name', 'wupeiqi'), ('email', 'xx@live.com') ])
v1 = ("age", 12) in info.items()
print(v1) #True（4）索引（键）
字典不同于元组和列表，字典的索引是键，而列表和元组则是 0、1、2等数值.
info = { "age":12, "status":True, "name":"武沛齐"}
print( info["age"] ) # 输出：12
print( info["name"] ) # 输出：武沛齐
print( info["status"] ) # 输出：True
print( info["xxxx"] ) # 报错，通过键为索引去获取之后时，键不存在会报错（以后项目开发时建议使用get方法根据键去获取值）
value = info.get("xxxxx") # None
print(value)（5）根据键 修改值 和 添加值 和 删除键值对
通过键可以找到字典中的值，通过键也可以对字典进行添加和更新操作.
#添加
info = {"age":12, "status":True,"name":"武沛齐"}
info["gender"] = "男"
print(info) # 输出： {"age":12, "status":True,"name":"武沛齐","gender":"男"}
#修改
info = {"age":12, "status":True,"name":"武沛齐"}
info["age"] = "18"
print(info) # 输出： {"age":"18", "status":True,"name":"武沛齐"}
#删除
info = {"age":12, "status":True,"name":"武沛齐"}
del info["age"] # 删除info字典中键为age的那个键值对（键不存在则报错）
print(info) # 输出： {"status":True,"name":"武沛齐"}
#删除的扩展，先用in进行判断
info = {"age": 12, "status": True, "name": "武沛齐"}
if "age" in info:
# del info["age"]
data = info.pop("age")
print(info)
print(data)
else:
print("键不存在")（6）for循环
由于字典也属于是容器，内部可以包含多个键值对，可以通过循环对其中的：键、值、键值进行循环；
info = {"age":12, "status":True,"name":"武沛齐"}
for item in info:
print(item) # 所有键
info = {"age":12, "status":True,"name":"武沛齐"}
for item in info.key():
print(item)
info = {"age":12, "status":True,"name":"武沛齐"}
for item in info.values():
print(item)
info = {"age":12, "status":True,"name":"武沛齐"}
for key,value in info.items():
print(key,value)4.转换
v = dict( [ ("k1", "v1"), ["k2", "v2"] ] )
print(v) # { "k1":"v1", "k2":"v2" }
info = { "age":12, "status":True, "name":"武沛齐" }
v1 = list(info) # ["age","status","name"]
v2 = list(info.keys()) # ["age","status","name"]
v3 = list(info.values()) # [12,True,"武沛齐"]
v4 = list(info.items()) # [ ("age",12), ("status",True), ("name","武沛齐") ]5.其他
（1）存储原理
（2）速度快
直接可以通过键去找到对应的值。
info = {
"alex":["肝胆","铁锤"],
"老男孩":["二蛋","缺货"]
}
v1 = info["alex"]
v2 = info.get("alex")（3）嵌套
同定义的点一致。注意元组的元素不可以被替换。
三.浮点型（float）
1.定义
v1 = 3.14
v2 = 9.892. 转化为整数
在类型转换时需要，在浮点型转换为整型时，会将小数部分去掉。
v1 = 3.14
data = int(v1)
print(data) # 33. 想要保留小数点后N位
v1 = 3.1415926
result = round(v1,3)
print(result) # 3.142四.None类型
None是代表内存中的一个空值，在一定程度上可以帮助我们去节省内存。
0
""
[] or list()
() or tuple()
set()
None
{} or dict()if None:
pass
1693
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
