一、数据类型之字典
字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组。
字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
总结：1.字典是可变无序，且键唯一的数据类型，2.keys的数据类型不能是可变的数据类型，如列表和字典；
1.字典的创建
1.1 创建方法1：
dict1 = {"name": "zgzeng", "age": 23, "password": "xxx"}
print(type(dict1)) # <class ‘dict‘>
1.2 创建方法2：
dict2 = dict((("name", "zgzeng"),))
print(type(dict2)) # <class ‘dict‘>
2.字典的常用操作
2.1 字典增操作
2.1.1 dict[keys]
这种方法，当原字典中有这个key，那么就查询，当没有的时候，就为增操作
name = dict1["name"]
print(name) # zgzeng
dict1["height"] = 183
print(dict1)
dict1 = {‘name‘: ‘zgzeng‘, ‘age‘: 23, ‘password‘: ‘xxx‘, ‘height‘: 183}
2.1.2 setdefault
如果键存在，那么返回字典中原本的值，如果没有，那么增加,setdefault方法既可以作为曾操作，也可以作为查询操作
"""
Insert key with a value of default if key is not in the dictionary.
Return the value for key if key is in the dictionary, else default.
"""
# 如果键存在，那么返回字典中原本的值，如果没有，那么增加
return1 = dict1.setdefault("age")
print(return1) # 23
print(dict1) # {‘name‘: ‘zgzeng‘, ‘age‘: 23, ‘password‘: ‘xxx‘, ‘height‘: 183}
return2 = dict1.setdefault("age", 18)
print(return2) # 23
print(dict1) # {‘name‘: ‘zgzeng‘, ‘age‘: 23, ‘password‘: ‘xxx‘, ‘height‘: 183}
return3 = dict1.setdefault("weight", "55kg")
print(return3) # 55kg
print(dict1) # {‘name‘: ‘zgzeng‘, ‘age‘: 23, ‘password‘: ‘xxx‘, ‘height‘: 183, ‘weight‘: ‘55kg‘}
2.2 字典查询操作
2.2.1 查询字典中所有的键
# 查询所有的键 print(dict1.keys()) # dict_keys([‘name‘, ‘age‘, ‘password‘, ‘height‘, ‘weight‘]) print(type(dict1.keys())) # <class ‘dict_keys‘> print(list(dict1.keys())) # [‘name‘, ‘age‘, ‘password‘, ‘height‘, ‘weight‘]
2.2.2 查询字典中所有的值
# 查询所有的值 print(dict1.values()) # dict_values([‘zgzeng‘, 23, ‘xxx‘, 183, ‘55kg‘]) print(type(dict1.values())) # <class ‘dict_values‘>
2.2.3 查询字典中的键和值
# 查询所有的值和键 print(dict1.items()) # dict_items([(‘name‘, ‘zgzeng‘), (‘age‘, 23), (‘password‘, ‘xxx‘), (‘height‘, 183), (‘weight‘, ‘55kg‘)]) print(type(dict1.items())) # <class ‘dict_items‘> print(list(dict1.items())) # [(‘name‘, ‘zgzeng‘), (‘age‘, 23), (‘password‘, ‘xxx‘), (‘height‘, 183), (‘weight‘, ‘55kg‘)]
2.2.4 通过键来查值 + setdefault
2.3 字典操作改
类似列表的改操作
print(dict1) # {‘name‘: ‘zgzeng‘, ‘age‘: 23, ‘password‘: ‘xxx‘, ‘height‘: 183, ‘weight‘: ‘55kg‘}
dict1["age"] = 24
print(dict1) # {‘name‘: ‘zgzeng‘, ‘age‘: 24, ‘password‘: ‘xxx‘, ‘height‘: 183, ‘weight‘: ‘55kg‘}
通过update修改
类似与列表的批量追加，将字典2添加到字典1中，如果有重复的key，那么字典2中的覆盖字典1中的，如果没有则添加
"""
D.update([E, ]**F) -> None. Update D from dict/iterable E and F.
If E is present and has a .keys() method, then does: for k in E: D[k] = E[k]
If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v
In either case, this is followed by: for k in F: D[k] = F[k]
"""
dict2 = {"name": "zgzeng", "age": 25, "hobby": "code", "drink": "tea"}
dict1 = {‘name‘: ‘zgzeng‘, ‘age‘: 24, ‘password‘: ‘xxx‘, ‘height‘: 183, ‘weight‘: ‘55kg‘}
dict1.update(dict2)
print(dict1) # {‘name‘: ‘zgzeng‘, ‘age‘: 25, ‘password‘: ‘xxx‘, ‘height‘: 183, ‘weight‘: ‘55kg‘, ‘hobby‘: ‘code‘, ‘drink‘: ‘tea‘}
2.4 字典操作删除
2.4.1 指定删除del方法
del dict[key]
print(dict1) # {‘name‘: ‘zgzeng‘, ‘age‘: 25, ‘password‘: ‘xxx‘, ‘height‘: 183, ‘weight‘: ‘55kg‘, ‘hobby‘: ‘code‘, ‘drink‘: ‘tea‘}
del dict1["height"]
print(dict1) # {‘name‘: ‘zgzeng‘, ‘age‘: 25, ‘password‘: ‘xxx‘, ‘weight‘: ‘55kg‘, ‘hobby‘: ‘code‘, ‘drink‘: ‘tea‘}
2.4.2 pop删除
指定删除，并返回该删除的键值对的值
print(dict1) # {‘name‘: ‘zgzeng‘, ‘age‘: 25, ‘password‘: ‘xxx‘, ‘weight‘: ‘55kg‘, ‘hobby‘: ‘code‘, ‘drink‘: ‘tea‘}
# 返回删除值
a = dict1.pop("age")
print(a) # 25
print(dict1) #{‘name‘: ‘zgzeng‘, ‘password‘: ‘xxx‘, ‘weight‘: ‘55kg‘, ‘hobby‘: ‘code‘, ‘drink‘: ‘tea‘}
2.4.3 popitem随机删除
字典是无序的
b = dict1.popitem()
print(b) # (‘drink‘, ‘tea‘)
print(dict1) # {‘name‘: ‘zgzeng‘, ‘password‘: ‘xxx‘, ‘weight‘: ‘55kg‘, ‘hobby‘: ‘code‘}
2.4.4 清空clear
print(dict1) # {‘name‘: ‘zgzeng‘, ‘password‘: ‘xxx‘, ‘weight‘: ‘55kg‘, ‘hobby‘: ‘code‘}
dict1.clear()
print(dict1) # {}
2.4.5 删除整个字典del
内存中没有这个字典了
print(dict1) # {}
del dict1
print(dict1) # NameError: name ‘dict1‘ is not defined
2.4.6 其他操作和方法
fromkeys
# fromkeys
""" Returns a new dict with keys from iterable and values equal to value. """
D = {}
L = [1, 2, 3]
print(D.fromkeys(L)) # {1: None, 2: None, 3: None}
print(D.fromkeys(L, "password")) # {1: ‘password‘, 2: ‘password‘, 3: ‘password‘}
len
# len
D = {
"k1": "v1",
"k2": "v2",
"k3": "v3",
}
print(len(D)) # 3
字典的嵌套
info = {
"China": {
"zgzeng": {"age": 23, "height": 183, "job": "IT", "hobby": ["sport", "music", "coding"]}
}
}
# 如果过了一年，zgzeng又长大了一岁，我们修改他的年纪,并且不喜欢运动喜欢上了打游戏
info["China"]["zgzeng"]["age"] = 24
info["China"]["zgzeng"]["hobby"][0] = "play game"
print(info)
# {‘China‘: {‘zgzeng‘: {‘age‘: 24, ‘height‘: 183, ‘job‘: ‘IT‘, ‘hobby‘: [‘play game‘, ‘music‘, ‘coding‘]}}}
排序sort
列表的排序是通过内容来排序，字母通过asc码表来排序，字典是根据key来排序
字典通过sorted函数来排序
dict3 = {"k1": "v1", "k2": "v2", "k3": "v3"}
print(sorted(dict3.values())) # [‘v1‘, ‘v2‘, ‘v3‘]
print(sorted(dict3)) # [‘k1‘, ‘k2‘, ‘k3‘]
print(sorted(dict3.items())) # [(‘k1‘, ‘v1‘), (‘k2‘, ‘v2‘), (‘k3‘, ‘v3‘)]
字典的遍历
for i in dict3:
print(i, dict3[i])
"""
k1 v1
k2 v2
k3 v3
"""
for i in dict3.items():
print(i)
"""
(‘k1‘, ‘v1‘)
(‘k2‘, ‘v2‘)
(‘k3‘, ‘v3‘)
"""
这两种方法推荐使用第一种来遍历键值对，因为第二种效氯不高
遍历值
for i in dict3.values(): print(i)”“”
v1
v2
v3
““”
二、集合
一个包含唯一元素的可变和无序的集合数据类型
1.集合的创建
# 集合
# 集合的创建1se = {1., 2, False, (), {}, [], " "}print(type(se)) # TypeError: unhashable type: ‘dict‘se = {1, 2, False, (), [], " "}print(type(se)) # TypeError: unhashable type: ‘list‘
se = {1, 2, False, (), " "}
print("se的数据类型是：", type(se)) # se的数据类型是： <class ‘set‘>
se2 = {}
print("se2的数据类型是：", type(se2)) # se2的数据类型是： <class ‘dict‘>
# 注意,当se2中的数据为空的时候，它是一个空字典，并非一个空集合
# 集合的创建2
se3 = set()
print("se3的数据类型是：", type(se3)) # se3的数据类型是： <class ‘set‘>
2.集合（set）的方法
2.1 增
"""
set() -> new empty set object
set(iterable) -> new set object
Build an unordered collection of unique elements.
"""
se.add("hello world!")
print(se) # {‘‘, 1, ‘hello world!‘, ()}
""" Update a set with the union of itself and others. """
se.update("hello")
print(se) # {‘‘, 1, ‘o‘, ‘hello world!‘, (), ‘l‘, ‘e‘, ‘h‘} 集合是无序的且是唯一的
se.update(("hello", "hello world"))
print(se) # {‘‘, 1, ‘o‘, ‘hello‘, ‘hello world!‘, ‘h‘, ‘e‘, ‘l‘, (), ‘hello world‘}
# 两种增加的方法，update将增加的元素拆分，添加到集合中
2.2 删（pop/remove/discard）
pop
"""
Remove and return an arbitrary set element.
Raises KeyError if the set is empty.
"""
se = {1., 2, "hello world!", ()}
a = se.pop()
print(a) # 1.0
print(se) # {2, (), ‘hello world!‘}
se = set()se.pop()print(se) # KeyError: ‘pop from an empty set‘
# 随机删除，有则删除且有返回值，如果集合中没有元素，那么报错
remove
# 指定删除remove和discard
# remove
"""
Remove an element from a set; it must be a member.
If the element is not a member, raise a KeyError.
"""
se = {1., 2, "hello world!", ()}
se.remove(())
print(se) # {1.0, 2, ‘hello world!‘}
se.remove("hello")
print(se) # se.remove("hello") KeyError: ‘hello‘
"""
Remove an element from a set if it is a member.
If the element is not a member, do nothing.
"""
se.discard(2)
print(se) # {1.0, ‘hello world!‘}
se.discard("hello")
print(se) # {1.0, ‘hello world!‘}
# 两种删除方法都是指定删除，不同之处就是当集合中没有需要指定删除的元素的时候，remove方法就会报错，而discard方法不做任何操作
3. 交集、并集、差集
# 交集（&）
se1 = {1, 3, 47, 18, 90, 100}
se2 = {1, 3, 90, 47, "hello world!"}
se3 = se1 & se2
print(se3) # {1, 90, 3, 47}
# 并集（|）
se1 = {1, 3, 47, 18, 90, 100}
se2 = {1, 3, 90, 47, "hello world!"}
se3 = se1 | se2
print(se3) # {1, 3, 100, ‘hello world!‘, 47, 18, 90}
# 差集（-）
se1 = {1, 3, 47, 18, 90, 100}
se2 = {1, 3, 90, 47, "hello world!"}
s3 = se1 - se2
print(s3) # {18, 100}
s4 = se2 - se1
print(s4) # {‘hello world!‘}
# 相对差集（^） se1 = {1, 3, 47, 18, 90, 100}se2 = {1, 3, 90, 47, "hello world!"}s6 = se1 ^ se2print(s6) # {18, 100, ‘hello world!‘}
4. 集合的应用
# 列表去重 li = [1, 3, "hello world!", 4, 9, "hello world!", 45, 2, 1, 5, 9] li3 = list(set(li)) print(li3) # [1, 2, 3, 4, 5, 9, 45, ‘hello world!‘]
原文地址：https://www.cnblogs.com/zgzeng/p/12041248.html
时间： 2024-08-05 18:08:14