标签：port 方法 pytho must lis sorted 哈希函数 object 元素
一、数据类型之字典
字典是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 ^ se2
print(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!‘]
标签：port 方法 pytho must lis sorted 哈希函数 object 元素
原文地址：https://www.cnblogs.com/zgzeng/p/12041248.html
