python 字典类型和集合类型_python基础数据类型之字典+集合

一、数据类型之字典

字典是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)) #

1.2 创建方法2：

dict2 = dict((("name", "zgzeng"),))print(type(dict2)) #

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())) #

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())) #

2.2.3 查询字典中的键和值

#查询所有的值和键

print(dict1.items()) #dict_items([('name', 'zgzeng'), ('age', 23), ('password', 'xxx'), ('height', 183), ('weight', '55kg')])

print(type(dict1.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) #{}

deldict1print(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"] = 24info["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 indict3:print(i, dict3[i])"""k1 v1

k2 v2

k3 v3"""

for i indict3.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的数据类型是：

se2={}print("se2的数据类型是：", type(se2)) #se2的数据类型是： #注意,当se2中的数据为空的时候，它是一个空字典，并非一个空集合

#集合的创建2

se3 =set()print("se3的数据类型是：", type(se3)) #se3的数据类型是：

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 &se2print(se3) #{1, 90, 3, 47}

#并集(|)

se1 = {1, 3, 47, 18, 90, 100}

se2= {1, 3, 90, 47, "hello world!"}

se3= se1 |se2print(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 -se2print(s3) #{18, 100}

s4 = se2 -se1print(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!']

总结：

"""list：有序、可变、可重复

tuple:有序、不可变、可重复

dict:无序、可变、key必须是唯一的

set：无序、用不重复，应用于去重"""