在 Python 程序中，我们把单个或多个字符用单引号或者双引号包围起来，就可以表示一个字符串。字符串中的字符可以是特殊符号、英文字母、中文字符、日文的平假名或片假名、希腊字母、Emoji 字符（如：💩、🐷、🀄️）等。

1、转义字符

  我们可以在字符串中使用\来标识转义，也就是说，\后面的字符不再是它原来的意义，列如：\n不是代表字符\和n，而是表示换行；\t也不是表示\和t，而是表示制表符。所以如果字符串本身又包含了'、"、\这些特殊的字符，必须要通过\进行转义处理。

s1 = '\'hello, world!\''s2 = '\\hello, world!\\'print(s1)  # 'hello, world!'print(s2)  # \hello, world!\

2、原始字符串

  Python 中有一种以r或R开头的字符串，这种字符串被称为原始字符串，意思是字符串中的每个字符都是它本来的含义，没有所谓的转义字符。例如，在字符串'hello\n'中，\n表示换行；而在r'hello\n'中，\n不再表示换行，就是字符\和字符n。

3、字符的遍历

  如果希望遍历字符串中的每个字符，可以使用for-in循环，有如下所示的两种方式。

方式一：

s = 'hello'for i inrange(len(s)):print(s[i])

方式二：

s = 'hello'for elem in s:print(elem)

4、字符串的方法

  在 Python 中，我们可以通过字符串类型自带的方法对字符串进行操作和处理，假设我们有名为foo的字符串，字符串有名为bar的方法，那么使用字符串方法的语法是：foo.bar()，这是一种通过对象引用调用对象方法的语法，跟前面使用列表方法的语法是一样的。

4.1 大小写相关操作

  下面的代码演示了和字符串大小写变换相关的方法。

s1 = 'hello, world!'# 字符串首字母大写print(s1.capitalize())  # Hello, world!# 字符串每个单词首字母大写print(s1.title())       # Hello, World!# 字符串变大写print(s1.upper())       # HELLO, WORLD!s2 = 'GOODBYE'# 字符串变小写print(s2.lower())       # goodbye# 检查s1和s2的值print(s1)               # hello, worldprint(s2)               # GOODBYE

说明：由于字符串是不可变类型，使用字符串的方法对字符串进行操作会产生新的字符串，但是原来变量的值并没有发生变化。所以上面的代码中，当我们最后检查s1和s2两个变量的值时，s1和s2 的值并没有发生变化。

4.2 查找操作

  如果想在一个字符串中从前向后查找有没有另外一个字符串，可以使用字符串的find或index方法。在使用find和index方法时还可以通过方法的参数来指定查找的范围，也就是查找不必从索引为0的位置开始。

s = 'hello, world!'print(s.find('or'))      # 8print(s.find('or', 9))   # -1print(s.find('of'))      # -1print(s.index('or'))     # 8print(s.index('or', 9))  # ValueError: substring not found

说明：find方法找不到指定的字符串会返回-1，index方法找不到指定的字符串会引发ValueError错误。

find和index方法还有逆向查找（从后向前查找）的版本，分别是rfind和rindex，代码如下所示。

s = 'hello world!'print(s.find('o'))       # 4print(s.rfind('o'))      # 7print(s.rindex('o'))     # 7# print(s.rindex('o', 8))  # ValueError: substring not found

4.3 性质判断

  可以通过字符串的startswith、endswith来判断字符串是否以某个字符串开头和结尾；还可以用is开头的方法判断字符串的特征，这些方法都返回布尔值，代码如下所示。

s1 = 'hello, world!'print(s1.startswith('He'))   # Falseprint(s1.startswith('hel'))  # Trueprint(s1.endswith('!'))      # Trues2 = 'abc123456'print(s2.isdigit())  # Falseprint(s2.isalpha())  # Falseprint(s2.isalnum())  # True

说明：上面的isdigit用来判断字符串是不是完全由数字构成的，isalpha用来判断字符串是不是完全由字母构成的，这里的字母指的是 Unicode 字符但不包含 Emoji 字符，isalnum用来判断字符串是不是由字母和数字构成的。

4.4 格式化

  在 Python 中，字符串类型可以通过center、ljust、rjust方法做居中、左对齐和右对齐的处理。如果要在字符串的左侧补零，也可以使用zfill方法。

s = 'hello, world'print(s.center(20, '*'))  # ****hello, world****print(s.rjust(20))        #         hello, worldprint(s.ljust(20, '~'))   # hello, world~~~~~~~~print('33'.zfill(5))      # 00033print('-33'.zfill(5))     # -0033

  我们之前讲过，在用print函数输出字符串时，可以用下面的方式对字符串进行格式化。

a = 321b = 123print('%d * %d = %d' % (a, b, a * b))   # 321 * 123 = 39483

  当然，我们也可以用字符串的format方法来完成字符串的格式，代码如下所示。

a = 321b = 123print('{0} * {1} = {2}'.format(a, b, a * b))  # 321 * 123 = 39483

  从 Python 3.6 开始，格式化字符串还有更为简洁的书写方式，就是在字符串前加上f来格式化字符串，在这种以f打头的字符串中，{变量名}是一个占位符，会被变量对应的值将其替换掉，代码如下所示。

a = 321b = 123print(f'{a} * {b} = {a * b}')  # 321 * 123 = 39483

  如果需要进一步控制格式化语法中变量值的形式，可以参照下面的表格来进行字符串格式化操作。

4.5 修剪操作

  字符串的strip方法可以帮我们获得将原字符串修剪掉左右两端指定字符之后的字符串，默认是修剪空格字符。这个方法非常有实用价值，可以用来将用户输入时不小心键入的头尾空格等去掉，strip方法还有lstrip和rstrip两个版本，相信从名字大家已经猜出来这两个方法是做什么用的。

s1 = '   jackfrued@126.com  'print(s1.strip())      # jackfrued@126.coms2 = '~你好，世界~'print(s2.lstrip('~'))  # 你好，世界~print(s2.rstrip('~'))  # ~你好，世界

4.6 替换操作

  如果希望用新的内容替换字符串中指定的内容，可以使用replace方法，代码如下所示。replace方法的第一个参数是被替换的内容，第二个参数是替换后的内容，还可以通过第三个参数指定替换的次数。

s = 'hello, good world'print(s.replace('o', '@'))     # hell@, g@@d w@rldprint(s.replace('o', '@', 1))  # hell@, good world

4.7 拆分与合并

  可以使用字符串的split方法将一个字符串拆分为多个字符串（放在一个列表中），也可以使用字符串的join方法将列表中的多个字符串连接成一个字符串，代码如下所示。

s = 'I love you'words = s.split()print(words)            # ['I', 'love', 'you']print('~'.join(words))  # I~love~you

  需要说明的是，split方法默认使用空格进行拆分，我们也可以指定其他的字符来拆分字符串，而且还可以指定最大拆分次数来控制拆分的效果，代码如下所示。

s = 'I#love#you#so#much'words = s.split('#')print(words)  # ['I', 'love', 'you', 'so', 'much']words = s.split('#', 2) # 拆分两次c = s.split('#', 3)  # 拆分三次print(words)  # ['I', 'love', 'you#so#much']print(c) # ['I', 'love', 'you', 'so#much']

4.8 编码和解码

  Python 中除了字符串str类型外，还有一种表示二进制数据的字节串类型（bytes）。所谓字节串，就是由零个或多个字节组成的有限序列。通过字符串的encode方法，我们可以按照某种编码方式将字符串编码为字节串，我们也可以使用字节串的decode方法，将字节串解码为字符串，代码如下所示。

a = '小明'b = a.encode('utf-8')c = a.encode('gbk')print(b)                  # b'\xe5\xb0\x8f\xe6\x98\x8e'print(c)                  # b'\xd0\xa1\xc3\xf7'print(b.decode('utf-8'))  # 小明print(c.decode('gbk'))    # 小明

  注意，如果编码和解码的方式不一致，会导致乱码问题（无法再现原始的内容）或引发UnicodeDecodeError错误，导致程序崩溃。

4.9 其他方法

  对于字符串类型来说，还有一个常用的操作是对字符串进行匹配检查，即检查字符串是否满足某种特定的模式。例如，一个网站对用户注册信息中用户名和邮箱的检查，就属于模式匹配检查。实现模式匹配检查的工具叫做正则表达式，Python 语言通过标准库中的re模块提供了对正则表达式的支持，我们会在后续的课程中为大家讲解这个知识点。

5、总结

知道如何表示和操作字符串对程序员来说是非常重要的，因为我们经常需要处理文本信息，Python 中操作字符串可以用拼接、索引、切片等运算符，也可以使用字符串类型提供的非常丰富的方法。

四、集合

1、概念

  集合（Set）：集合是一种容器型的数据类型。也就是把一定范围内、确定的、可以区别对待的事物当做一个整体来对待，那么这个整体也就叫做集合，集合中的各个事物称为集合的元素。

集合需要满足以下条件：

1. 无序性：一个集合中，每个元素的地位都是相同的，元素之间是无序的；
2. 互异性：一个集合中，任何两个元素都是不相同的，即元素在集合中只能出现一次；
3. 确定性：给定一个集合和一个任意元素，该元素要么属于这个集合，要么不属于这个集合，二者则其一，不允许有模棱两可的情况出现；  

  Python中的集合和数学上的集合本质上没有啥大的区别，需要特别注意的是无序性和交互性。无序性说明集合中的元素并不像列表中的元素存在某种次序，通过索引运算就能访问任意元素，也就是说明一点集合并不支持索引运算。另外集合的互异性决定了集合中不能有重复元素，这一点，也是区别于列表的地方，我们无法将一个重复的元素添加到一个集合中。集合也支持in 和 not in 运算，这样也就可以确定一个元素是否属于集合，也就是上面的确定性。   

    集合的成员运算在性能上要优于列表的成员运算，这是集合的底层存储特性决定的；

    集合的定义：集合（Set）是Python中的一种内置数据类型，用于存储==无序且唯一的==元素。   特性：

      元素唯一（不允许重复）；      无序（不支持索引访问）；      可动态增删元素（可变类型）；      元素必须是不可变类型（如整数、字符串、元组等）

2、创建

  创建集合，我们通常使用{   }创建，元素之间用,隔开，或者可以使用set()来创建；使用Python内置函数set来创建一个集合，准确的说set并不是一个函数，而是创建集合对象的构造器。   

    用户直接创建集合：

# 定义集合s = {4, 5, 9, 2, 1, 90, 45, 78, 32, 12, 21, 32, True, 1}print(s)"""用户自定义的集合：{4, 5, 9, 2, 1, 90, 45, 78, 32, 12, 21, 32, True, 1}运行结果：{32, 1, 2, 4, 5, 9, 12, 45, 78, 21, 90}"""

  由上，可以看出，《无序且唯一的特点》，因为元素32, 1以及True是重复的元素，而这里的True值为1；     

    列表转换为集合：

# 列表转换为集合 s2 = [43, 54, 23, False, True, 'String', (1, 'Hello', 54), 0, 1]s2 = set(s2)print(s2)"""定义一个列表：[43, 54, 23, False, True, 'String', (1, 'Hello', 54), 0, 1]经过转换后得到的结果：{False, True, 'String', 43, (1, 'Hello', 54), 54, 23}"""

  在上面的代码中，如果我们在列表s2中再嵌套一个列表，再使用set(s2)转换为集合，就会报错，报TypeError: unhashable type: 'list'；  因为列表嵌套列表，列表数据类型是可以修改列表内的元素值，这也体现了集合的一个特性：《元素必须是不可变类型》；

注意：如果要定义一个空的集合，要使用set()，不使用{      }因为{   }直接定义是字典而不是集合；      

列表生成式来创建集合：   

和之前创建列表的生成式一样，可参考【列表生成式语法格式】

# 生成范围1~99的整数，步长为6，且能被3或7整除的集合s = {x for x inrange(1, 100, 6) if x % 3 == 0or x % 7 == 0}print(f"利用列表生成式生成的集合为：{s}。")"""运行结果：利用列表生成式生成的集合为：{49, 91, 7}。"""

  解释：生成1~99内的整数，步长为6，并且能够被3或者7整除的整数。1 ~ 99内，步长为6的整数有[1, 7, 13, 19, 25, 31, 37, 43, 49, 55, 61, 67, 73, 79, 85, 91, 97]，经过x % 3 == 0 or x % 7 == 0筛选后，只有[7,49,91]满足条件，进而输出；

3、集合的基本操作

3.1 添加元素

1. add()
     将元素添加到集合中，如果集合中已经存在这个元素，则不进行任何操作；

s = {1, 4, 2, 5, 0}# 将90添加到集合s中s.add(90)# 将True添加到集合s中，其中True的值为1s.add(True)print(s)"""运行结果：{0, 1, 2, 4, 5, 90}"""

2.update()update()可以添加任意的参数类型，比如字典、列表、元组、字符串类型；

s = {1, 4, 2, 5, 0}# 添加列表元素，将列表中的元素拆分插入s.update([32, 89, 1, 34, 45])print(f"添加列表后的结果：{s}。")# 添加字符串s.update('apple')print(f"添加字符串后的结果：{s}。")# 添加字典元素s.update({'name': '小明', 'gender': '女'})print(f"添加字典后的结果：{s}。")# 添加元组s.update((4, 1, 89, 'banana'))print(f"添加元组后的结果：{s}。")"""运行结果：添加列表后的结果：{0, 1, 2, 32, 4, 5, 34, 45, 89}。添加字符串后的结果：{0, 1, 2, 32, 4, 5, 34, 'p', 45, 'e', 'a', 89, 'l'}。添加字典后的结果：{0, 1, 2, 32, 4, 5, 34, 'p', 'gender', 45, 'e', 'a', 89, 'l', 'name'}。添加元组后的结果：{0, 1, 2, 32, 4, 5, 34, 'p', 'gender', 'banana', 45, 'e', 'a', 89, 'l', 'name'}。"""

3.2 移除元素

1. remove()
     移除集合中存在的元素：

s = {1, 4, 2, 5, 0, 'orange', 'banana', True, (2, 3, 45)}s.remove(1)print(f"移除元素后的结果：{s}。")"""移除元素后的结果：{0, 2, 'banana', 4, 5, (2, 3, 45), 'orange'}。"""

  移除集合中不存在的元素，报错；

1. discard()
   移除集合中的元素，如果存在则移除，不存在不会报错，不进行任何操作；

s = {1, 4, 2, 5, 0, 'orange', 'banana', True, (2, 3, 45)}s.discard(1)print(f"移除元素后的结果：{s}。")s.discard('apple')print(f"如果移除的元素不在集合中：{s}。")"""运行结果：移除元素后的结果：{0, 2, 4, 5, (2, 3, 45), 'orange', 'banana'}。如果移除的元素不在集合中：{0, 2, 4, 5, (2, 3, 45), 'orange', 'banana'}。"""

1. pop()
   随机删除一个元素；

s = {x for x inrange(1, 200, 6) if x % 3 == 0or x % 7 == 0}print(f"利用列表生成式生成的集合为：{s}。")# pop（）方法：print(f"输出集合中任意删除的元素：{s.pop()}。")"""运行结果：利用列表生成式生成的集合为：{133, 7, 175, 49, 91}。输出集合中任意删除的元素：133。利用pop()方法弹出集合中的元素：{7, 175, 49, 91}。"""

1. clear()
   清空集合内的所有元素；

s = {x for x inrange(1, 200, 6) if x % 3 == 0or x % 7 == 0}# 清空集合内的所有元素：s.clear()print(f"使用clear（）方法后，集合中的元素还有：{s}。")"""运行结果：使用clear（）方法后，集合中的元素还有：set()。"""

4、元素的遍历

  我们可以通过len()函数来获得集合中有多少个元素，但是我们不能通过索引运算来遍历集合中的元素，因为集合元素并没有特定的顺序。当然要实现对集合元素的遍历，仍然可以使用for ~ in循环来实现；

s = {x for x inrange(1, 200, 6) if x % 3 == 0or x % 7 == 0}s.update([3, 5, 9, True], 'Hello', "World")# 遍历生成的集合for x in s:print(x, end=' ')"""运行结果：True 3 l 133 5 7 W 9 d 175 r 49 e H o 91 """

  由代码的输出可以看出集合的无序性特点；

5、集合的运算

  Python为集合类型提供了非常丰富的运算，主要包括：成员运算、交集运算、并集运算、差集运算、比较运算（相等性、子集、超集等）。

5.1 成员运算

可以通过成员运算`in` 和 `not in` 检查元素是否在集合中，其结果为布尔型；

s = {x for x inrange(1, 200, 6) if x % 3 == 0or x % 7 == 0}print(14in s)print(21notin s)"""运行结果：FalseTrue"""

5.2 二元运算

  集合的二元运算主要指集合的交集、并集、差集、对称差等运算，这些运算可以通过运算符来实现，也可以通过集合类型的方法来实现，实例如下：

1. 交集：得到两个集合中的公共元素；

# 交集 &  —— 两个集合中的公共元素s1 = {1, 2, 3, 4, 5}s2 = {4, 5, 6, 7, 8}# 进行集合运算：print(s1 & s2)print(s1.intersection(s2))"""运行结果：{4, 5}{4, 5}"""

1. 并集：两个集合中的所有元素；

# 并集 | 两个集合中的所有元素s1 = {1, 2, 3, 4, 5}s2 = {4, 5, 6, 7, 8}print(s1 | s2)print(s1.union(s2))"""运行结果：{1, 2, 3, 4, 5, 6, 7, 8}{1, 2, 3, 4, 5, 6, 7, 8}"""

1. 差集：第一个集合中有，第二个集合中没有的元素；

# 差集 第一个集合中有，第二个集合中没有的元素s1 = {1, 2, 3, 4, 5}s2 = {4, 5, 6, 7, 8}print(s1 - s2)print(s1.difference(s2))print(s2.difference(s1))"""运行结果：{1, 2, 3}{1, 2, 3}{8, 6, 7}"""

1. 对称差：两个集合中不同时包含的元素；

# 对称差 两个集合中不同时包含的元素s1 = {1, 2, 3, 4, 5}s2 = {4, 5, 6, 7, 8}print(s1 ^ s2)print(s1.symmetric_difference(s2))

  通过上面的实例代码可以看出，对两个集合求交集，&运算和intersection()方法的作用是完全相同的，使用运算符的方式显然更直观且代码也更简短。需要特别注意的是，集合的二元运算还可以跟赋值运算一起构成复合赋值运算，比如s1 |= s2  等价于  s1 = s1 | s2，跟|=作用相同的方法是update()，s1 &= s2   等价于  s1 = s1 & s2，跟&=相等的方法是intersection_update()；

# 复合赋值运算s1 = {1, 2, 3, 4, 5}s2 = {4, 5, 6, 7, 8}s1 &= s2print(s1)s1.update(s2)print(s1)"""运行结果：{4, 5}{4, 5, 6, 7, 8}"""

5.3 比较运算

  两个集合可以用==和!=进行相等性判断，如果两个集合中的元素完全相同，那么==比较的结果就是True，否则就是False。如果集合A的任意一个元素都是集合B的元素，那么集合A称为集合B的子集。即对于 ∀a∈A ，均有 a∈B ，则 A⊆B ，A是B的子集，反过来也可以称B是A的超集。如果A是B的子集且A不等于B，那么A就是B的真子集。Python 为集合类型提供了判断子集和超集的运算符，其实就是我们非常熟悉的<、<=、>、>=这些运算符。当然，我们也可以通过集合类型的方法issubset和issuperset来判断集合之间的关系，代码如下所示。

# 集合运算s1 = {1, 3, 5}s2 = {1, 2, 3, 4, 5}s3 = {5, 4, 3, 2, 1}print(f"【s1 > s2】的结果为：{s1 > s2}")print(f"【s1 >= s2】的结果为：{s1 >= s2}")print(f"【s1 < s2】的结果为：{s1 < s2}")print(f"【s1 <= s2】的结果为：{s1 <= s2}")print(f"【s2 == s3】的结果为：{s2 == s3}")# 使用issubset()方法来判断集合之间的关系print(f"【s1.issubset(s2)】的结果为：{s1.issubset(s2)}")print(f"【s2.issubset(s3)】的结果为：{s2.issubset(s3)}")print(f"【s1.issubset(s3)】的结果为：{s1.issubset(s3)}")# 使用issuperset()方法来判断集合之间的关系print(f"【s1.issuperset(s2)】的结果为：{s1.issuperset(s2)}")print(f"【s1.issuperset(s3)】的结果为：{s1.issuperset(s3)}")print(f"【s2.issuperset(s3)】的结果为：{s2.issuperset(s3)}")"""运行结果：【s1 > s2】的结果为：False【s1 >= s2】的结果为：False【s1 < s2】的结果为：True【s1 <= s2】的结果为：True【s2 == s3】的结果为：True【s1.issubset(s2)】的结果为：True【s2.issubset(s3)】的结果为：True【s1.issubset(s3)】的结果为：True【s1.issuperset(s2)】的结果为：False【s1.issuperset(s3)】的结果为：False【s2.issuperset(s3)】的结果为：True"""

1. issubset()
• 作用：检查一个集合是否是另外一个集合的子集；
• 定义：若集合A中的所有元素都包含在集合B中，则A是B的超集；
• 语法：A.issubset(B)或A >= B；
• 返回值：若A是B的超集返回True，否则返回False；
2. issuperset()
• 作用：检查一个集合是否是另外一个集合的超集；
• 定义：若集合B中的所有元素都包含在集合A中，则A是B的子集；
• 语法：A.issubset(B)或A <= B；
• 返回值：若A是B的子集返回True，否则返回False；
3. 关键区别
• 方法参数：issubset()和issuperset()可以接受**可迭代对象（如列表、元组）**作为参数，自动转换为集合后再比较；
• 操作符限制：使用<=或>=时，两边必须是集合；

a = {1, 2, 3, 4, 5}print(f"子集：{a.issubset([1, 2, 3, 4, 5, 7])}")print(f"超集：{a.issuperset([1, 2, 5])}")"""运行结果：子集：True超集：True"""

6、不可变集合

  Python中还有一种不可变类型的集合，名字叫frozenset。set跟frozenset的区别就如同list跟tuple的区别，frozenset由于是不可变类型，能够计算出哈希值，因此可以作为set中的元素。除了不能添加和删除元素，frozenset在其他方面跟set是一样的。下面是简单介绍：

fSet1 = frozenset({1, 2, 3, 4, 5})fSet2 = frozenset(range(1, 8))print(fSet1)print(fSet2)print(f"交集：{fSet2 & fSet1}")print(f"并集：{fSet2 | fSet1}")print(f"差集：{fSet2 - fSet1}")print(f"对称差：{fSet2 ^ fSet1}")print(f"比大小：{fSet2 > fSet1}")"""运行结果：frozenset({1, 2, 3, 4, 5})frozenset({1, 2, 3, 4, 5, 6, 7})交集：frozenset({1, 2, 3, 4, 5})并集：frozenset({1, 2, 3, 4, 5, 6, 7})差集：frozenset({6, 7})对称差：frozenset({6, 7})比大小：True"""

7、总结

• 需要注意的是：
  集合中的元素必须是hashable类型，所谓的hashable类型指的是能够计算出哈希码的数据类型，通常不可变类型都是hashable类型，因为可变类型无法计算出确定的哈希码，所以它们就不能放在集合中；
• 比如：
  我们不能将列表作为集合中的元素；同理，由于集合本身是可变类型，集合不能作为集合中的元素；我们可以集合中嵌套列表（列表中的元素也是列表），但是我们不能创建出嵌套的集合，这是需要注意的。   Python中的集合类型是一种无序容器，不允许有重复的元素，由于底层使用了哈希存储，集合中的元素必须是hashable类型。集合与列表的最大区别就在于集合中的元素没有顺序、所以不能够通过索引运算访问元素、但是集合可以执行交集、并集、差集等二元运算，也可以通过关系运算符检查两个集合是否存在超集、子集等关系。

五、字典

1、背景

  到目前为止，我们已经学了Python中的三种容器类型（列表、元组、集合），但是呢，这三种类型，仍然存在一些无法解决的问题。比如，使用一个变量来存储一个人的多项信息，如姓名、性别、年龄、体重、兴趣爱好、现住址、手机号，这是我们就会发现，我们之前学过的列表、元组和集合就不太友好。

# 用一个变量来存储这些信息：姓名、性别、年龄、体重、兴趣爱好、现住址、手机号、紧急联系人的手机号# 列表存储introduce1 = ['小明', '男', 18, 55.6, ['篮球', '足球', '乒乓球'], '北京市朝阳区', '13812345678', '12345612345']# 元组存储introduce2 = ('小明', '男', 18, 55.6, ['篮球', '足球', '乒乓球'], '北京市朝阳区', '13812345678', '12345612345')# 集合存储introduce3 = {'小明', '男', 18, 55.6, ('篮球', '足球', '乒乓球'), '北京市朝阳区', '13812345678', '12345612345'}

  首先，集合来存储这些信息，肯定是不合适的，因为集合中不能存储重复的元素，如果一个人的年龄和体重恰好相等，那么集合中肯定也就少了一项信息；同理一个人的手机号和紧急联系人的手机号是同一个，那么集合中肯定也就又少一项信息。另一方面，列表和元素虽然都能将这些元素都存储起来，但是当你要访问这些信息的时候，你得知道它们在列表或元组中的什么位置；   

    因此我们就需要字典（dictionary）来将这些关联的信息组装在一起，也就可以帮我们解决Python程序中的真实事物建模问题。   

    字典，想必大家都不陌生，曾经我也是用高价买过一本，如下：

2、概念

  Python中的字典和现实生活中的字典很像，它以键值对（键和值的组合）的形式出现，通过键找到与之对应的值进行操作。就像《新华字典》中，每个（键）都有与之对应的解释（值）一样，每个字和它的解释合在一起就是字典中的一个条目，而字典中通常包含了很多个这个的条目。

3、创建和使用字典

  Python中创建字典可以使用{  }字面量语法，和集合一样都是使用{   }进行包裹，而字典则是使用键值对的形式存在，每个元素由:分隔的两个值构成，:前面是键，后面是值；

xinHua= {'麓': '山脚下','路': '道，往来通行的地方；方面，地区：南～货，外～货；种类：他俩是一～人','蕗': '甘草的别名','潞': '潞水，水名，即今山西省的浊漳河；潞江，水名，即云南省的怒江'}print(f"新华字典：{xinHua}")# 上面的定义，使用字典定义如下introduce4 = {'姓名': '小明','性别': '男','年龄': 18,'体重': 55.6,'兴趣爱好': ['篮球', '足球', '乒乓球'],'地址': '北京市朝阳区','手机号': '13812345678','紧急联系人': '12345612345'    ,}print(f"个人信息：{introduce4}")

    通过上面的实例，可以看出，使用字典来存储个人信息，看起来令人更舒服，也通俗易懂；

  如果可以，我们还可以使用内置函数dict或者字典的生成式语法来创建字典，代码如下：

"""使用内置函数以及字典生成式来创建字典    + 内置函数dict()可以将序列中的元素转换为字典    + 字典生成式语法：{key:value for item in iterable}"""#  内置函数dict()可以将序列中的元素转换为字典introduce5 = dict(姓名='小明', 性别='男', 年龄=18, 体重=55.6, 兴趣爱好=['篮球', '足球', '乒乓球'], 地址='北京市朝阳区', 手机号='13812345678', 紧急联系人='12345612345')print(f"内置函数创建字典：{introduce5}")# 可以通过内置函数中的zip()压缩两个序列并创建字典item1 = dict(zip('ABCDEF', [1, 2, 3, 4, 5, 6]))item2 = dict(zip('ABCDEF', range(3, 90, 15)))print(f"使用zip()创建字典：{item1}\n{item2}")# 使用字典生成式来创建字典item3 = {x: x ** 4for x inrange(1, 20, 3)}print(f"使用字典生成式创建字典：{item3}")"""运算结果：内置函数创建字典：{'姓名': '小明', '性别': '男', '年龄': 18, '体重': 55.6, '兴趣爱好': ['篮球', '足球', '乒乓球'], '地址': '北京市朝阳区', '手机号': '13812345678', '紧急联系人': '12345612345'}使用zip()创建字典：{'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5, 'F': 6}{'A': 3, 'B': 18, 'C': 33, 'D': 48, 'E': 63, 'F': 78}使用字典生成式创建字典：{1: 1, 4: 256, 7: 2401, 10: 10000, 13: 28561, 16: 65536, 19: 130321}"""

4、字典的运算

  对于字典类型来说，成员运算和索引运算肯定是很重要的，前者可以判断知道你的键在或不在字典中，后者可以通过键来访问对应的值或者向字典中添加新的键值对。值得注意的是，字典的索引不同于列表的索引，列表中的元素因为有属于自己的序号，索引列表的索引是一个整数；字典中因为保存的是键值对，所以需要用键去索引对应的值。   

    需要特别注意的是，字典中的键是不可变类型，例如整数（int）、浮点数（float）、字符串（str）、元组（tuple）等类型，这一点跟集合类型对元素的要求是一样的。很明显的一点是，之前学的列表（list）和集合（set）不能作为字典中的值，字典类型本身也不能作为字典中的键，因为字典也是可变类型，但是列表、集合、字典都可以作为字典中的值；

introduce6 = {'姓名': '小明','性别': '男','年龄': 18,'体重': 55.6,'兴趣爱好': {'运动': ['篮球', '足球', '乒乓球'],'音乐': ['流行', '摇滚', '民谣'],'阅读': ['小说', '散文', '诗歌'],'旅游': ['古镇', '城市', '乡村'],'美食': ['清蒸鲈鱼', '番茄拌面', '顿排骨、猪脚'],'动漫': ['完美世界', '火影忍者', '斗破苍穹', '镇魂街', '秦时明月'],'游戏': ['王者荣耀', '绝地求生', '刺激战场'],'其他': ['棋牌', '桌游', '棋类'],    },'地址': '北京市朝阳区','手机号': '13812345678','紧急联系人': '12345612345'    ,}print(f"个人信息：{introduce6}")

4.1 字典的成员运算和索引运算

4.1.1 字典的成员运算

  字典的成员运算也就是包含（in）以及不包含（not in）：

• 语法：key in dict 或者 key not in dict；
• 作用：用来检查一个键是否存在于集合中；
• 返回值：如果键存在，key in dict返回True，否则返回False； key not in dict则相反；

# 成员运算# 借用上节的字典定义【introduce6】print('运动'in introduce6)print('地址'in introduce6)print('音乐'in introduce6['兴趣爱好'])print('game'notin introduce6)

4.1.2 索引运算

  字典的索引运算（dict[key]）:

• 语法：dict[key]；
• 作用：用于获取字典中键对应的值；
• 返回值：如果键存在，返回对应的值；不存在，则会引发KeyError错误；

# 索引运算# 借用上节的字典定义【introduce6】print(introduce6['兴趣爱好'])try:print(introduce6['game'])except KeyError:print('键不存在')