编程本是逆天行，你若不拼怎么赢？

字典相关

字典是Python语言中唯一的映射类型。映射类型对象里哈希值(键，key)和指向的对象(值，value)是一对多的关系，通常被认为是可变的哈希表。

字典对象是可变的，它是一个容器类型，能存储任意个数的Python对象，其中也可包括其他容器类型。

字典类型与序列类型的区别：

1.存取和访问数据的方式不同。

2.序列类型只用数字类型的键(从序列的开始按数值顺序索引)；

3.映射类型可以用其他对象类型作键(如：数字、字符串、元组，一般用字符串作键)，和序列类型的键不同，映射类型的键直接或间接地和存储数据值相关联。

4.映射类型中的数据是无序排列的。这和序列类型是不一样的，序列类型是以数值序排列的。

5.映射类型用键直接“映射”到值。

字典是Python中最强大的数据类型之一。

每个键与值用冒号隔开(:)，每对用逗号分割，整体放在花括号中({})。

键必须独一无二，但值则不必。

值可以取任何数据类型，但必须是不可变的，如字符串，数或元组

大括号是字典，列表是方括号，圆括号是元组。

字典和列表的区别：

列表是有序的对象集和

字典是无序的对象集和

定义一个存储学生信息的字典:

message_dict = {'name' : 'guodong','age' : '21','sex' : 'M','weight' : '140','height' : '180'}print (message_dict)

对字典的各种操作

1.取值，根据索引(key)取值，取值时，索引用中括号括起来

message_dict = {'name' : 'guodong','age' : '21','sex' : 'M','weight' : '140','height' : '180'}# 取字典中索引为name的值print (message_dict['name'])

2：增加/删除

增加：索引使用中括号括起来

message_dict[‘id’] = ‘05’print (message_dict)

删除：索引使用小括号括起来

message_dict.pop(‘id’)print (message_dict)

3：统计键值对的数量

print (len(message_dict))

4：添加字典里面已经存在的元素，会将以前元素内容修改

message_dict[‘age’] = 22print (message_dict)

5：合并字典,如果与原字典键值索引重复，则会被更新

使用 update() 方法，第二个参数合并第一个参数

sex_dict = {'sex':'man',            'grade':4}# 将message_dict字典与sex_dict字典合并message_dict.update(sex_dict)print(message_dict)

字典的遍历

遍历所有的键-值对

可以使用一个 for 循环来遍历字典

Python 字典(Dictionary) items() 函数以列表返回可遍历的(键, 值) 元组数组。

message_dict = {'name' : 'guodong','age' : '21','sex' : 'M','weight' : '140','height' : '180'}for key,value in message_dict.items():  print ("key:" + key)  print ("value:" + value)

遍历字典中的所有键

在不需要使用字典中的值时,方法 keys() 很有用。下面来遍历字典favorite_languages ,并将每个被调查者的名字都打印出来:

Python title() 方法返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写

favorite_languages = {'jen': 'python','sarah': 'c','edward': 'ruby','phil': 'python',}for name in favorite_languages.keys():  print(name) # 输出键  print(name.title()) # 单词首字母大写

遍历字典时,会默认遍历所有的键,因此,

如果将上述代码中的 for name in favorite_languages.keys(): 替换为 for name in favorite_languages: ,

输出将不变。

如果显式地使用方法 keys() 可让代码更容易理解,你可以选择这样做,但如果你愿意,也可省略它。

按顺序遍历字典中的所有键

字典总是明确地记录键和值之间的关联关系,但获取字典的元素时,获取顺序是不可预测的。

这不是问题,因为通常你想要的只是获取与键相关联的正确的值。

要以特定的顺序返回元素,一种办法是在 for 循环中对返回的键进行排序。

为此,可使用函数 sorted() 来获得按特定顺序排列的键列表的副本

favorite_languages = {    'jen' : 'python',    'sarah' : 'c',    'edward' : 'ruby',    'phil' : 'python'}# 使用sorted函数对字典中的键进行排序for name in sorted(favorite_languages):    print (name.title())

遍历字典中的所有值

如果你感兴趣的主要是字典包含的值,可使用方法 values() ,它返回一个值列表,而不包含任何键。

例如,如果我们想获得一个这样的列表,即其中只包含被调查者选择的各种语言,而不包含被调查者的名字,可以这样做:

favorite_languages = {'jen': 'python','sarah': 'c','edward': 'ruby','phil': 'python',}# 使用values方法遍历字典中的所有值for language in favorite_languages.values():    print(language)

这种做法提取字典中所有的值,而没有考虑是否重复。涉及的值很少时,这也许不是问题,

但如果被调查者很多,最终的列表可能包含大量的重复项。

为剔除重复项,可使用集合( set )。集合 类似于列表,但每个元素都必须是独一无二的:

favorite_languages = {'jen': 'python','sarah': 'c','edward': 'ruby','phil': 'python',}# 使用集合set剔除重复项for language in set(favorite_languages.values()):    print(language)

集合相关

set是一个无序且不重复的元素集合。

集合对象是一组无序排列可哈希的值，集合成员可以做字典中的键。集合用in和not in操作符检查成员，以len()內建函数得到集合的基数(大小)，用for循环迭代集合的成员。但是因为集合本身是无序的，不可以为集合创建索引或执行切片(slice)操作，也没有键(keys)可用来获取集合中元素的值。

set和dict一样，只是没有value，相当于dict的key集合，由于dict的key是不重复的，且key是不可变对象因此set也有如下特性：

1 不重复

2 元素为不可变对象

方式一

先初始化再赋值

s = set()s = {11,22,33,44}  #注意在创建空集合的时候只能使用s=set()，因为s={}创建的是空字典

方式二

直接创建

a=set('boy')

方式三

利用list创建

b=set(['y', 'b', 'o','o'])# 打印b结果自动去重：{'y', 'o', 'b'}

方式四

利用dict创建，将会使用dict中的key值作为set的值

c=set({"k1":'v1','k2':'v2'})print(c)#{'k1', 'k2'}

方式五

使用tuple创建

e={('k1', 'k2','k2')}print(e,type(e))# {('k1', 'k2', 'k2')} <class 'set'>

更新(增加)update

se = {11, 22, 33}be = {22,44,55}se.update(be)  # 把se和be合并，得出的值覆盖seprint(se) #{33, 22, 55, 11, 44}se.update([66, 77])  # 可增加迭代项print(se)# {33, 66, 22, 55, 11, 44, 77}

删除discard()、remove()、pop()

se = {11, 22, 33}se.discard(11)se.discard(44)  # 移除不存在的元素不会报错print(se) # {33, 22}se = {11, 22, 33}se.remove(11)se.remove(44)  # 移除不存在的元素会报错print(se)se = {11, 22, 33}se.pop() # 删除最后一个元素33print(se) #{11, 22}

集合操作

交集

intersection, intersection_update，也可以使用a&b

se = {11, 22, 33}be = {22,44,55}temp1 = se.intersection(be)             #取交集，赋给新值print(temp1)  # {22}print(se)  # {11, 22, 33}temp2 = se.intersection_update(be)      #取交集并更新自己print(temp2)  # Noneprint(se)  # {22}print(se&be) # {22}

并集

union，也可以使用a|b

se = {11, 22, 33}be = {22,44,55}temp=se.union(be)   #取并集，并赋新值print(se)       #{33, 11, 22}print(temp)     #{33, 22, 55, 11, 44}print(se|be)   # {33, 22, 55, 11, 44}

差集difference, difference_update，也可以使用a-b

se = {11, 22, 33}be = {22, 55}temp1 = se.difference(be)        #找到se中存在，be中不存在的集合，返回新值print(temp1)        #{33, 11}print(se-be)        # {33, 11}print(se)        #{33, 11, 22}temp2 = se.difference_update(be) #找到se中存在，be中不存在的集合，覆盖掉seprint(temp2)        #Noneprint(se)           #{33, 11}se = {11, 22, 33}  # 移除末尾元素并把移除的元素赋给新值temp = se.pop()print(temp)  # 33print(se) # {11, 22}

包含关系

两个集合之间一般有三种关系，相交、包含、不相交。在Python中分别用下面的方法判断：

set.isdisjoint(s)：判断两个集合是不是不相交

set.issuperset(s)：判断集合是不是包含其他集合，等同于a>=b

set.issubset(s)：判断集合是不是被其他集合包含，等同于a<=b

如果要真包含关系，就用符号操作>和<

se = {11, 22, 33}be = {22}print(se.isdisjoint(be))  #False，判断是否不存在交集(有交集False，无交集True)print(se.issubset(be))    #False，判断se是否是be的子集合print(se <= be)        # Falseprint(se.issuperset(be))   #True，判断se是否是be的父集合print(se >= be) # True

合并   symmetric_difference, symmetric_difference_update

se = {11, 22, 33}be = {22}temp1 = se.symmetric_difference(be)  # 合并不同项，并赋新值print(temp1)    #{33, 11}print(se)       #{33, 11, 22}temp2 = se.symmetric_difference_update(be)  # 合并不同项，并更新自己print(temp2)    #Noneprint(se)             #{33, 11}

集合的转换

集合可以转换为list，tuple以及str

se = set(range(4))li = list(se)tu = tuple(se)st = str(se)print(li,type(li)) # [0, 1, 2, 3] print(tu,type(tu)) # (0, 1, 2, 3) print(st,type(st)) # {0, 1, 2, 3} 

不变集合

Python提供了不能改变元素的集合的实现版本，即不能增加或删除元素，类型名叫frozenset，使用方法如下

a = frozenset("hello")print(a) # frozenset({'e', 'h', 'l', 'o'}

需要注意的是frozenset仍然可以进行集合操作，只是不能用带有update的方法。