目录

一、建立一个数据火车——列表

1 、创建列表

2、列表元素的获取

3、列表元素的添加

4 、列表元素的删除

5 、列表元素的修改

二、列表的亲兄弟——元组

1、创建元组

2 、元组元素的获取

3、元组和列表的差别

三、数据中的魔术师——字符串

1 、创建字符串

2、字符的获取

3、字符串的处理

4 、字符转义

5、原始字符串

6、多行字符串

7 、列表、元组、字符串的通用操作

8 、列表 、元组、字符串总结

四、索引存储不再麻烦——字典

1 、创建字典

2、字典键值对的添加

3、键值对的获取

4 、字典键值对的删除

5、字典中键值对修改

6、什么时候用字典

五 、比较专一的大火车——集合

1、创建集合

2、集合元素的添加

3 、集合元素的获取

4、集合元素的删除

5、集合的运算

6 、集合运算示例

7 、什么时候用集合

8、获取字典和集合中的元素数量

9、字典和集合大总结

写在最后

前言

Hello ，你好呀，我是灰小猿，一个超会写bug的程序猿！

近期和大家分享总结了关于Python基础进阶的文章“【全网力荐】堪称最易学的Python基础入门教程” ，然后得到了很多小伙伴的支持和肯定 ，但是同时很多刚开始学习的小伙伴在编程的时候还会遇见很多错误，所以就又为大家总结了一篇关于Python常见报错及其解决方案的文章“全网最值得收藏的Python常见报错及其解决方案，再也不用担心遇到BUG了！ ” 。来帮助大家解决在前期学习中遇到的一些bug。感兴趣的小伙伴可以去阅读一下。

之后还会继续和大家分享更多的Python基础及进阶技术 ，大家可以关注我一起学习呀！

今天就继续来和大家分享Python基础入门之后的又一技术：列表 、元组、字符串处理、字典和集合类型 。文章较长，建议先收藏之后慢慢学习！

可能很多小伙伴在其他的编程语言中也见过这几个类型的使用，但是在Python对其的学习绝对会让你不虚此读！！！

我们之前学习了字符串和列表 ，除此之外 Python 中还内置有元组 、字典、集合等常用的数据类型，它们都被用于存放批量数据 。

存放批量数据用列表不就行了吗，为什么还要这么多数据类型？这是因为在不同的场景下 ，对数据的读取和修改效率以及内存使用情况的要求是不一样的，为了满足不同的场景需求，需要以不同的组织形式来存放数据。上面所述的那些数据类型 ，本质上就是不同的数据组织形式，Python 直接为我们提供了它们的现成的实现，我们拿来即可使用 ，轻而易举地获取各种不同的存放、访问和修改数据的能力。

列表 、元祖、字典、集合 、字符串这些数据类型中所存放的一个个单独的数据 ，叫作项（Item）或元素（Element） 。这些数据类型除了可以存放元素以外，还能通过调用对象方法来操作管理其中的元素。

我们来详细学习下这五种内置数据类型。

一、建立一个数据火车——列表

列表是 Python 中非常常用的数据类型 。之前的章节中我们学习过列表的一些基础知识，这个小节将会更深入地介绍列表的各种功能。

列表是用于存放若干元素的有序序列。列表使用方括号（[]）来表示 ，其中的元素写入方括号中，多个元素时用逗号分隔，如 [1, 'go', [0.1, 0.2]] 。它的元素可以是任意数据类型 ，甚至也可以是个列表。

元素之间有顺序关系，每个元素都有自己的位置，每个位置从 0 开始依次标号 ，这个表示位置的数字叫作索引。

列表被创建之后，我们可以对它做很多操作，包括添加元素 ，删除元素，修改元素，查找元素等 。

1、创建列表

  1. 创建空的列表：

    列表 = []

    >>> items = []
    >>> items
    []

  2. 创建包含元素的列表：

    列表 = [元素1, 元素2, ..., 元素N]

    >>> items = [1, 2, 3]
    >>> items
    [1, 2, 3]

2 、列表元素的获取

  1. 通过索引获取元素

    元素 = 列表[索引]

    >>> letters = [‘a’, ‘b’, ‘c’]
    >>> letters[2]
    ’c’

  2. 通过元素获取索引

    这种方式和上面相反 ，首先在列表中寻找元素 ，然后返回元素对应的索引。

    索引 = 列表.index(元素)

    >>> letters = [‘a’, ‘b’, ‘c’]
    >>> letters.index(‘c’)
    2

  3. 查看元素是否存在于列表中

    要想查看元素是否存在于列表中，需要借助 Python 的关键字 in，使用如下：

    布尔值 = 元素 in 列表

    >>> letters = [‘a’, ‘b’, ‘c’]
    >>> ‘a’ in letters
    True
    >>> ‘z’ in letters
    False

  4. 统计元素在列表中的个数

    统计元素在列表中的个数 ，或者说是元素在列表中出现的次数。

    个数 = 列表.count(元素)

    >>> numbers = [1, 2, 2, 3, 4, 5, 5, 7]
    >>> numbers.count(5)
    2

3 、列表元素的添加

我们可以很灵活地向列表添加元素，如以追加的形式向列表末尾添加一个元素；以插入的形式向列表的任意位置插入元素；或者将一个列表中的所有元素批量的添加到另一个列表中 。

  1. 向列表末尾追加元素

    列表.append(元素)

    >>> letters = [‘a’, ‘b’]
    >>> letters.append(‘c’)
    >>> letters
    [‘a’, ‘b’, ‘c’]

  2. 向列表的任意位置插入元素

    列表.insert(索引, 元素)

    >>> letters = [‘a’, ‘b’]

    >>> letters.insert(0, ‘c’)
    >>> letters
    [‘c’, ‘a’, ‘b’]

    >>> letters.insert(2, ‘d’)
    >>> letters
    [‘c’, ‘a’, ‘d’, ‘b’]

  3. 列表末尾追加另一个列表的所有元素

    列表.extend(另一列表)

    >>> letters = [‘a’, ‘b’]
    >>> letters.extend([‘c’, ‘d’, ‘e’])
    >>> letters
    [‘a’, ‘b’, ‘c’, ‘d’, ‘e’]

4、列表元素的删除

删除元素的方式同样很灵活 。

  1. 按索引删除元素

    元素 = 列表.pop(索引)

    pop(索引) 会将索引对应的元素从列表中删除，同时返回这个元素。

    >>> letters = [‘a’, ‘b’, ‘c’]
    >>> letters.pop(0)
    ’a’
    >>> letters
    [‘b’, ‘c’]

    也可以不传递索引 ，这样的话默认删除并返回最后一个元素。

    >>> letters = [‘a’, ‘b’, ‘c’]
    >>> letters.pop()
    ’c’
    >>> letters
    [‘a’, ‘b’]

  2. 按索引删除元素（del 方法)

    删除一个列表元素也可以使用 Python 中的 del 关键字，如下：

    del 列表[索引]

    >>> letters = [‘a’, ‘b’, ‘c’]
    >>> del letters[0]
    >>> letters
    [‘b’, ‘c’]

  3. 直接删除元素

    直接删除元素时，Python 会先在列表中遍历该元素 ，然后将匹配到的第一个元素删除 。

    列表.remove(元素)

    >>> letters = [‘a’, ‘b’, ‘c’]
    >>> letters.remove(‘b’)
    >>> letters
    [‘a’, ‘c’]

  4. 清空所有元素

    清空所有元素即是把列表元素全部删除，最后仅为列表仅为 []。

    列表.clear()

    >>> letters = [‘a’, ‘b’, ‘c’]
    >>> letters.clear()
    >>> letters
    []

5、列表元素的修改

  1. 通过赋值修改列表元素

    列表[索引] = 新元素

    >>> letters = [‘a’, ‘b’, ‘c’]
    >>> letters[2] = 'd’
    >>> letters
    [‘a’, ‘b’, ‘d’]

  2. 反转整个列表

    反转整个列表会将所有的元素倒序排列。

    列表.reverse()

    >>> letters = [‘a’, ‘b’, ‘c’]
    >>> letters.reverse()
    >>> letters
    [‘c’, ‘b’, ‘a’]

  3. 列表元素排序

    列表.sort()

    >>> numbers = [2, 4, 5, 2, 1, 5, 7, 3]
    >>> numbers.sort()
    >>> numbers
    [1, 2, 2, 3, 4, 5, 5, 7]

    也可以通过指定 sort 方法的 reverse 参数来倒序排列 。

    列表.sort(reverse=True)

    >>> numbers = [2, 4, 5, 2, 1, 5, 7, 3]
    >>> numbers.sort(reverse=True)
    >>> numbers
    [7, 5, 5, 4, 3, 2, 2, 1]

 

二 、列表的亲兄弟——元组

元组和列表非常相似，也是用于存放元素的有序序列。它用的圆括号（()）表示 ，元素写入圆括号中，多个元素时用逗号分隔，如 (1, 2, 3)。

元组同样具有索引 ，索引使用方式与列表一致 。其元素同样可以是任意类型。

看起来元组就是披着圆括号外衣的列表嘛！有什么区别？

元组创建完成后 ，便不能向其中添加元素，也不能修改和删除其中的任何一个元素。所以它与列表相比，只能查找元素 ，也就是说只具备读的功能，不具备写的功能 。元组的这一特性叫作不可变（性）（Immutable），而列表是可变的（Mutable）。

1、创建元组

  1. 创建空的元组：

    元组 = ()

    >>> items = ()
    >>> items
    ()

  2. 创建包含多个元素的元组：

    元组 = (元素1, 元素2, ..., 元素N)

    >>> items = (1, 2, 3)
    >>> items
    (1, 2, 3)

  3. 创建只包含一个元素的元组

    只包含一个元素的情况需要单独说明一下 ，因为它的形式与直觉不相符。

    创建只包含一个元素的元组，需要在唯一的那个元素后面加上逗号，如：

    元组 = (元素,)

    >>> items = (1,)
    >>> items
    (1,)

    这是因为 ，如果括号中只有一个元素，那么 Python 会将这个括号当作优先级符号进行处理（像数学中的那样），而不是当作元组 。可以试一下：

    >>> items = (1)
    >>> items
    1
    >>> type(items)
    <class ‘int’>

2、元组元素的获取

  1. 通过索引获取元素

    元素 = 元组[索引]

    >>> letters = (‘a’, ‘b’, ‘c’)
    >>> letters[2]
    ’c’

  2. 通过元素获取索引

    索引 = 元组.index(元素)

    >>> letters = (‘a’, ‘b’, ‘c’)
    >>> letters.index(‘c’)
    2

  3. 查看元素是否存在于元组中

    布尔值 = 元素 in 元组

    >>> letters = (‘a’, ‘b’, ‘c’)
    >>> ‘a’ in letters
    True
    >>> ‘z’ in letters
    False

  4. 统计元素在元组中出现的个数

    个数 = 元组.count(元素)

    >>> numbers = (1, 2, 2, 3, 4, 5, 5, 7)
    >>> numbers.count(5)
    2

3 、元组和列表的差别

我们可以看到 ，元组所具有的操作在使用方式上与和列表非常相似，甚至在一定程度上可以将元组看作是列表的精简版，但它们之间也有明显的差别 。

  • 元组是不可变的（Immutable） ，列表是可变的（Mutable） ，元组在被创建之后，就不能添加、删除和修改元素，而列表可以
  • 一般情况下元组的性能在略高于列表

我们在什么时候用列表 ，什么时候用元组？

列表还是元组，通常性能不是从它们中做选择的主要考虑因素，因为它们之间的性能差异不是很大。我们的选择通常围绕着可变和不可变的特性进行 ，当我们需要添加元素或修改元素时，使用列表；当我们希望所有元素在创建之后便不再改变，可使用元组。

 

三、数据中的魔术师——字符串

字符串也是 Python 中非常常用的内置数据类型 。我们之前学习过字符串的一些内容 ，现在来深入的了解下。

为什么要叫它是数据中的魔术师呢？原因是因为它可以转义成很多你想要的数据类型，接下来往下看你就知道了！

字符串是 Python 中用来存放字符序列的数据类型，其中的元素只能是字符。字符串使用单引号或双引号来表示 ，如 'pick'，"cherry"，通常我们首先使用单引号 。

字符串是有序序列 ，可以使用索引来获取其中某个位置的元素。它是不可变的 ，被创建之后其中的元素（也就是字符）不能被修改和删除。

1 、创建字符串

  1. 创建空字符串（即不包含字符的字符串）：

    字符串 = ''

    >>> string = ''
    >>> string
    ’’

  2. 创建包含元素的字符串：

    字符串 = '若干字符'

    >>> string = 'happy’
    >>> string
    ’happy’

2、字符的获取

  1. 通过索引获取字符

    字符 = 字符串[索引]

    >>> string = ‘happy’
    >>> string[2]
    ’p’

  2. 通过子串获取索引

    所谓子串就是从字符串中截取下来的一部分，可以是一个字符，一部分字符、全部字符 、或空字符串 ，如 'a'、'ppy'、'happy' 、'' 都是 ‘happy’ 的子串 。查找子串时，返回的是子串的第一个字符的索引。

    索引 = 字符串.index(字符)

    >>> string = ‘happy’
    >>> string.index(‘p’)
    2

    >>> string = ‘happy’
    >>> string.index(‘app’)
    1

    当字符或子串不存在时，index 方法将抛出 ValueError 错误。

    也可采用字符串的 find 方法来查找子串 ，使用方式与 index 一致，不同点在于 find 方法未找到子串时返回数字 -1，而不抛异常 。

    >>> string = ‘happy’
    >>> string.find(‘app’)
    1
    >>> string.find(‘z’)
    -1

  3. 查看字符是否存在于字符串中

    查看字符是否存在于字符串中 ，需要借助 Python 的关键字 in，如下：

    布尔值 = 字符 in 字符串

    >>> string = ‘happy’
    >>> ‘a’ in string
    True
    >>> ‘z’ in string
    False

  4. 统计字符在字符串中的个数

    个数 = 字符串.count(字符)

    >>> string = ‘happy’
    >>> string.count(‘p’)
    2

3 、字符串的处理

字符串自带的方法非常多，除了上面介绍的几个之外还有四十多个 ，这是因为字符处理是编程时的一项高频工作。Python 将这些字符处理相关的功能以方法的形式集成在字符串里。

这里列举几个常见的方法：

  • startswith：判断字符串是否以某个子串开头，返回布尔值

    >>> string = ‘happy’
    >>> string.startswith(‘ha’)
    True

  • endswith：判断字符串是否以某个子串结尾，返回布尔值

    >>> string = ‘happy’
    >>> string.endswith(‘y’)
    True

  • replace：将字符串的子串用一个另一个字符串替换 ，返回一个新的字符串

    >>> string = ‘happy’
    >>> string.replace(‘y’, ‘iness’)
    ’happiness’

  • strip：去除字符串前后的空白符号 ，如空格、换行符、制表符，返回一个新的字符串

    >>> string = ’ \t happy \n’
    >>> string.strip()
    ’happy’

  • split：将字符串用某个子串分隔开，分隔后的各个部分放入列表中 ，并返回这个列表

    >>> string = ‘I am happy’
    >>> string.split(’ ')
    [‘I’, ‘am’, ‘happy’]

  • join：将一个序列中的元素用某个字符（串）拼接，组成一个大的字符串，并返回这个字符串

    >>> words = [‘I’, ‘am’, ‘happy’]
    >>> ’ '.join(words)
    ’I am happy’

  • upper：将字符串转化为大写字母形式 ，返回一个新的字符串

    >>> string = ‘happy’
    >>> string.upper()
    ’HAPPY’

  • lower：将字符串转化为小写字母形式，返回一个新的字符串

    >>> string = ‘HAPPY’
    >>> string.lower()
    ’happy’

注意上面的这些字符处理功能，对字符串作处理后都是返回一个新的字符串 ，而不会直接修改原有的字符串 。为什么呢？字符串不可变呀！

4 、字符转义

我们在创建字符串时，有一些字符是没法直接在引号中表示的，如单引号或双引号 ，因为这和表示字符串本身的符号冲突了，如：

>>> string = 'I’m happy’
File “”, line 1
     string = ‘I’m happy’
                   ^
SyntaxError: invalid syntax

抛出 SyntaxError 语法错误异常，因为 Python 将 string = 'I' 看作字符串的赋值 ，而后面的 m happy' 就无法解析了 ，因为不符合任何语法 。

这时就需要使用字符转义了，我们在这类无法直接在字符串中表示的字符前加上 \ 符号，形如 \' ，这样 Python 在解析时就能理解这是嵌入在字符串中的单引号 '：

>>> string = 'I\'m happy’
>>> string
"I’m happy"

像 \' 这样在前面加了反斜杠（\），为了能在字符串中正常表示的字符，叫作转义字符。而这个转化的行为叫作字符转义。

与单引号的用法相同 ，双引号用 \" 来转义 。

字符串中的 \ 用来做字符转义了，那怎么在字符串中表示斜杆 \ 这个字符呢？使用 \\，将斜杆 \ 转义一下。除此之外 ，有一些空白符号也需要用转义字符来表示，因为我们没办法直接在字符串中表示它们，如常见的换行（\n） ，制表符（\t），回车（\r）。

常用的转义字符 含义
\' 单引号
\" 双引号
\\ 反斜杠
\n 换行符
\t 制表符（Tab）
\r 回车

举个例子，如果在字符串使用了 \n ，那么在用 print() 输出字符串的时候 ，这个字符串会被换行输出 。如：

>>> print(‘第一行\n第二行’)
第一行
第二行

使用 \n 换行符使得我们能够在一行的字符串来表示多行的内容。

说明：转义字符虽然在书写时使用了两个字符，但是在程序中它只是一个字符。可以自己来试验下：
>>> len(’\n’)
1
>>> len(’\’’)
1

如果我们就想在字符串中表示 \n 这两个字符，而不是让它表示换行 ，该怎么办？有两种方式：

  1. 使用 \\n，将 \n 前面的反斜杠转义

    >>> print(‘第一行\\n第二行’)
    第一行\n第二行

  2. 使用原始字符串

5、原始字符串

原始字符串就是在字符串的起始引号前加上一个 r 或 R 字母，这样字符串中的内容将不会被转义 ，将按照原样输出 。使用方法：

r'字符串内容'

>> print(r’第一行\n第二行’)
第一行\n第二行

6、多行字符串

我们之前所使用的字符串都被书写成一行，要想让字符串可以跨行书写，写成多行的形式 ，有两种方法：

  1. 字符串的每行末尾使用 \ 续行

    以多行的形式书写字符串，每行的末尾使用 \ 续行。需要注意输出内容为一行。

    string = '第一行\
第二行\
第三行'

    >>> string = '第一行\
    … 第二行\
    … 第三行’
    >>> print(string)
    ‘第一行第二行第三行’

    可以看到这种方式可以让字符串以多行的方式来书写，但是输出内容还是被当作一行 。如果想要输出内容为多行 ，需要在字符串中显式地使用 \n 进行换行。

    >>> string = '第一行\n\
    … 第二行\n\
    … 第三行’
    >>> print(string)
    第一行
    第二行
    第三行

  2. 使用三个单引号或三个双引号来表示字符串

    在 Python 中字符串也可以使用三个单引号或三个双引号来表示字符串，这样字符串中的内容就可以多行书写，并且被多行输出。

    string = '''第一行
第二行
第三行'''

    >>> string = ‘’‘第一行
    … 第二行
    … 第三行’’'
    >>> print(string)
    第一行
    第二行
    第三行

    使用三引号的方式 ，字符串可被多行书写 ，且被多行输出，其中不需要显式地指明 \n 换行 。

7 、列表、元组、字符串的通用操作

我们把列表 、元组、字符串统称为序列 。

  1. 使用 len() 函数获取序列长度

    >>> letters = (‘a’, ‘b’)
    >>> len(letters)
    2

    >>> letters = ‘abcd’
    >>> len(letters)
    4

  2. 获取序列中的一个子序列

    获取序列中的子序列可以使用切片，以 [起始索引:结束索引] 表示。切片其实代表一个索引区间 ，这个区间是一个左闭右开区间，该区间内的所有元素作为子序列被返回。如：

    >>> numbers = (1, 2, 3, 4, 5)
    >>> numbers[0:2]
    (1, 2)

    >>> numbers[2:4]
    (3, 4)

    >>> letters = ‘abcd’
    >>> letters[1:5]
    ’bcd’

  3. 使用 + 符号来拼接两个序列

    >>> letters_1 = (‘a’, ‘b’)
    >>> letters_2 = (‘c’, ‘d’, ‘e’)
    >>> letters_1 + letters_2
    (‘a’, ‘b’, ‘c’, ‘d’, ‘e’)

    >>> letters_1 = ‘ab’
    >>> letters_2 = ‘cde’
    >>> letters_1 + letters_2
    ’abcde’

  4. 使用 * 符号来重复序列中的元素

    >>> letters = (‘a’, ‘b’)
    >>> letters * 3
    (‘a’, ‘b’, ‘a’, ‘b’, ‘a’, ‘b’)

    >>> letters = ‘abcd’
    >>> letters * 2
    ’abcdabcd’

注意上面的操作结果都是返回一个新的序列，不会对修改序列的内部元素 。

8、列表 、元组、字符串总结

列表、元组 、字符串都是有序序列 ，都可以使用索引。

列表和元组中可以存放任意数据类型的元素，而字符串中只能存放字符。

列表是可变的，而元组和字符串是不可变的 。

 

四 、索引存储不再麻烦——字典

字典是一种用来存放若干键值对的数据类型。

什么是键值对呢？键值对就是两个对象 ，其中一个是用来做定位的数据，叫做键（Key），另一个是要存放的数据 ，叫做值（Value）。在字典中，键值对作为一个整体被存放，我们可以通过键来快速获取到对应的值 。

在 Python 中字典用花括号（{}）来表示 ，键值对以 键:值 的方式写入花括号中 ，有多个键值对时用逗号分隔。

如 {'010': 'beijing', '021': 'shanghai'} 便是一个字典，其中包含两个键值对

  • '010': 'beijing'
  • '021': 'shanghai'

使用时，我们可以通过 '010' 快速查询到其对应的值是 'beijing'。这就好比现实中的一本字典一样 ，通过拼音或偏旁来映射一个具体的字词，以此来实现字词的快速查找，而这个拼音或偏旁就相当于 Python 字典的键 ，而字词就相当于 Python 字典的值，它们在字典中是映射关系 。

Python 字典中的键是有要求的，需要是不可变的类型 ，如元组、字符串、数字。而字典中的值可以是任意类型。字典本身是可变的，我们可以向其中添加 、删除、修改键值对 。

因为字典不是序列，更不是有序的 ，所有它没有列表那样的索引，也不能保证每个键值对的存放次序 。

1、创建字典

  1. 创建空的字典

    字典 = {}

    >>> empty_dict = {}
    >>> empty_dict
    {}

  2. 创建包含键值对的字典

    字典 = {键1:值1, 键2:值2, ..., 键N:值N}

    如城市和其对应的电话区号：

    >>> codes = {‘beijing’: ‘010’, ‘shanghai’: ‘021’}
    >>> codes
    {‘beijing’: ‘010’, ‘shanghai’: ‘021’}

2 、字典键值对的添加

  1. 向字典中增加键值对

    字典[键] = 值

    >>> codes = {‘beijing’: ‘010’, ‘shanghai’: ‘021’}
    >>> codes[‘tianjin’] = '022’
    >>> codes
    {‘beijing’: ‘010’, ‘shanghai’: ‘021’, ‘tianjin’: ‘022’}

    使用这种方式时，若字典中没有这个键 ，则会创建这个键值对；若字典中原本已有这个键 ，则是修改键所对应的值。

3、键值对的获取

  1. 通过键获取值

    值 = 字典[键]

    >>> codes = {‘beijing’: ‘010’, ‘shanghai’: ‘021’}
    >>> codes[‘beijing’]
    ‘010’

    注意若键不存在则将抛出 KeyError 异常：

    >>> codes = {‘beijing’: ‘010’, ‘shanghai’: ‘021’}
    >>> codes[‘a’]
    Traceback (most recent call last):
         File “”, line 1, in
    KeyError: ‘a’

  2. 通过键获取值（ get 方法）

    如果通过键获取值时不希望 KeyError 异常抛出，可以使用 get 方法，若键不存在 ，则直接返回 None。

    值 = 字典.get(键)

    >>> codes = {‘beijing’: ‘010’, ‘shanghai’: ‘021’}
    >>> codes.get(‘a’)
    >>>

    返回的 None 代表什么都没有，所以没有任何值显示 。

    也可以给 get 方法传递第二个参数作为默认值，使得键不存在时直接返回默认值。

    值 = 字典.get(键, 默认值)

    >>> codes = {‘beijing’: ‘010’, ‘shanghai’: ‘021’}
    >>> codes.get(‘a’, ‘000’)
    >>> ‘000’

  3. 判断字典中是否包含某个键

    布尔值 = 键 in 字典

    >>> codes = {‘beijing’: ‘010’, ‘shanghai’: ‘021’}
    >>> ‘beijing’ in codes
    True
    >>> ‘guangzhou’ in codes
    False

  4. 获取所有键

    键的列表 = 字典.keys()

    >>> codes = {‘beijing’: ‘010’, ‘shanghai’: ‘021’}
    >>> codes.keys()
    dict_keys([‘beijing’, ‘shanghai’])

    获取到的所有键是以迭代器的形式存在 ，至于什么是迭代器我们将在之后的章节中介绍。在这里我们可以用 list() 函数将迭代器转换为列表 。如下：

    >>> list(codes.keys())
    [‘beijing’, ‘shanghai’]

  5. 获取所有值

    值的列表 = 字典.values()

    >>> codes = {‘beijing’: ‘010’, ‘shanghai’: ‘021’}
    >>> codes.values()
    dict_values([‘010’, ‘021’])

    获取到的所有值是以迭代器的形式存在，我们用 list() 函数将迭代器转换为列表。如下：

    >>> list(codes.values())
    [‘010’, ‘021’]

  6. 获取所有键值对的列表

    值的列表 = 字典.items()

    >>> codes = {‘beijing’: ‘010’, ‘shanghai’: ‘021’}
    >>> codes.items()
    dict_items([(‘beijing’, ‘010’), (‘shanghai’, ‘021’)])

    获取到的所有键值对是以迭代器的形式存在，我们用 list() 函数将迭代器转换为列表。如下：

    >>> list(codes.items())
    [(‘beijing’, ‘010’), (‘shanghai’, ‘021’)]

    列表中的每一个元素是都是二元组（即包含两个元素的元组） ，每个二元组的第一个元素是键，第二个元素是值 。

4、字典键值对的删除

  1. 通过键删除键值对

    可以使用 pop 方法删除一个键值对，并将值返回。

    值 = 字典.pop(键)

    >>> codes = {‘beijing’: ‘010’, ‘shanghai’: ‘021’}
    >>> codes.pop(‘beijing’)
    ’010’
    >>> codes
    {‘shanghai’: ‘021’}

    如果 pop 一个不存在的键 ，则会抛出 KeyError 异常：

    >>> codes.pop(‘a’)
    Traceback (most recent call last):
         File “ ”, line 1, in
    KeyError: ‘a’

    如果你不希望异常抛出，可以传递 pop 方法的第二个参数作为默认值。默认值仅在键不存在时生效，此时方法将直接返回这个默认值 ，且跳过删除操作：

    值 = 字典.pop(键, 默认值)

    >>> codes = {‘beijing’: ‘010’, ‘shanghai’: ‘021’}
    >>> codes.pop(‘guangzhou’, ‘000’)
    ’000’

  2. 通过键删除键值对（del 方法）

    也可以通过关键字 del 来删除键值对 。

    del 字典[键]

    >>> codes = {‘beijing’: ‘010’, ‘shanghai’: ‘021’}
    >>> del codes[‘beijing’]
    >>> codes
    {‘shanghai’: ‘021’}

  3. 随机删除一个键值对

    使用 popitem 随机删除一个键值对 ，并返回这个键值对的二元组，二元组的第一个元素是键，第二个元素是值。

    键值二元组 = 字典.popitem()

    >>> codes = {‘beijing’: ‘010’, ‘shanghai’: ‘021’}
    >>> codes.popitem()
    (‘shanghai’, ‘021’)
    >>> codes
    {‘beijing’: ‘010’}

  4. 清空所有键值对

    键值二元组 = 字典.clear()

    >>> codes = {‘beijing’: ‘010’, ‘shanghai’: ‘021’}
    >>> codes.clear()
    >>> codes
    {}

5 、字典中键值对修改

  1. 修改键对应的值

    字典[键] = 值

    >>> codes = {‘beijing’: ‘010’}
    >>> codes[‘beijing’] = '021’
    >>> codes
    {‘beijing’: ‘021’}

    如果键不存在 ，则创建键值对。

  2. 用字典批量更新键值对

    字典.update(另一字典)

    >>> codes = {‘beijing’: ‘010’, ‘shanghai’: ‘021’}
    >>> codes.update({‘guangzhou’: ‘020’, ‘shanghai’: ‘000’})
    >>> codes
    {‘beijing’: ‘010’, ‘shanghai’: ‘000’, ‘guangzhou’: ‘020’}

    可以看到字典中新增了 'guangzhou': '020' 这个键值对，同时将 'shanghai': '021' 修改为 'shanghai': '000' 。

6、什么时候用字典

字典的显著优势是可以通过键快速地查询数据 。字典中的元素以键值对的形式存在，使用时通过键来获取和修改值 ，由于字典内部的特殊实现，字典通过键获取值的效率非常高。

如果我们希望将批量的数据存放起来，并且在需要时能以很高的执行效率来获取其中某个指定的数据 ，这时就可以使用字典。除此之外，如果我们想在程序中暂时维护一个映射关系，也可以使用字典 ，因为字典本质上就是一个映射关系 。

如，我们可以将城市名和对应的区号保存在字典中，这样就可以通过城市名快速地查询到其区号 ，而不需要进行遍历。

area_codes = {
    '北京': '010',
    '上海': '021',
    '天津': '022',
    '重庆': '023',
    '沈阳': '024',
    '南京': '025',
    '武汉': '027',
    '成都': '028',
}

>>> area_codes[‘成都’]
‘028’
>>> area_codes[‘南京’]
‘025’

 

 

五、比较专一的大火车——集合

集合是一个用于存放批量元素的数据类型 ，它不是有序的，其中的元素没有顺序关系。集合中的元素没有重复，重复的元素将被自动剔除最终只留下一个 。

集合也是用花括号（{}）来表示 ，不同于字典的是，花括号中放的是一个个数据，而不是键值对。

集合是可变的 ，我们可以向其中添加 、删除、修改元素。

1、创建集合

  1. 创建包含元素的集合

    集合 = {元素1, 元素2, 元素N}

    >>> numbers = {1, 2, 3}
    >>> numbers
    {1, 2, 3}

  2. 创建空集合

    集合 = set()

    注意创建空集合不能直接使用 {}，那样是表示空字典，而是使用 set() ，这才表示空集合 。

    >>> empty_set = set()
    >>> empty_set
    set()

2 、集合元素的添加

  1. 向集合中添加一个元素

    集合.add(元素)

    >>> numbers = {1, 2}
    >>> numbers.add(3)
    >>> numbers
    {1, 2, 3}

    向集合中添加重复元素时，会被去重处理。

    >>> numbers = {1, 2}
    >>> numbers.add(2)
    >>> numbers
    {1, 2}

  2. 从另一集合中批量添加元素

    集合.update(另一集合)

    >>> numbers_1 = {1, 2}
    >>> numbers_2 = {2, 3, 4}
    >>> numbers_1.update(numbers_2)
    >>> numbers_1
    {1, 2, 3, 4}

    可以看到，集合numbers_2 中的所有元素被添加到了集合 numbers_1 中 ，并且其中重复的元素被剔除仅保留一份。

3 、集合元素的获取

集合不能像列表那样通过索引来获取元素，也不能像字典那样通过键来获取值，集合没法直接获取到某个指定的元素 。想要获取元素 ，只能通过遍历的方式。

虽然集合不能直接获取到元素 ，但是我们依然可以用 in 关键字来判断元素是否存在于集合中。

  1. 查看元素是否存在于集合中

    布尔值 = 元素 in 集合

    >>> letters = {‘a’, ‘b’, ‘c’}
    >>> ‘a’ in letters
    True
    >>> ‘z’ in letters
    False

4、集合元素的删除

  1. 随机删除一个元素，并返回这个元素

    元素 = 集合.pop()

    使用 pop 方法随机删除一个元素的时候，这个元素会被返回 。

    >>> numbers = {1, 2, 3}
    >>> numbers.pop()
    1
    >>> numbers.pop()
    2
    >>> numbers
    {3}

  2. 删除一个指定的元素

    集合.remove(元素)

    >>> numbers = {1, 2, 3}
    >>> numbers.remove(1)
    >>> numbers
    {2, 3}

    如果要删除的元素不存在 ，则抛出 KeyError 异常：

    >>> numbers = {1, 2, 3}
    >>> numbers.remove(4)
    Traceback (most recent call last):
         File “ ”, line 1, in
    KeyError: 4

  3. 删除一个指定的元素，且不抛出 KeyError 异常

    使用 remove 方法删除一个不存在的元素时，会抛出 KeyError 异常 ，如果我们不想让异常抛出，可以使用 discard 方法 。

    集合.discard(元素)

    >>> numbers = {1, 2, 3}
    >>> numbers.discard(4)
    >>> numbers
    {1, 2, 3}

  4. 清空所有元素

    集合.clear()

    与列表和字典一样，想要清空所有元素 ，可以使用 clear 方法。

    >>> numbers = {1, 2, 3}
    >>> numbers.clear()
    >>> numbers
    set()

    顺便考大家一个问题，为什么元组没有这个方法？因为元组是不可变的！我们不能删除元组的元素，也不能添加和修改元素。

5、集合的运算

看到这里你可能会想 ，集合不就是阉割版的列表嘛？不是的，集合的功能不止于此 。

Python 中的集合和数学中的集合颇为相似，首先集合的所有元素都是唯一的 ，不存在重复；此外集合有子集 、超集的概念 ，也可以进行交集、并集、差集的运算。

  1. 求交集

    可以通过 intersection 方法求多个集合的交集。

    交集 = 集合1.intersection(集合2, 集合3, 集合N)

    >>> numbers_1 = {1, 2, 3}
    >>> numbers_2 = {2, 3, 4}
    >>> numbers_3 = {3, 4, 5}
    >>> numbers_1.intersection(numbers_2, numbers_3)
    {3}

    也可以直接使用与运算符 & 来代替，完全等效：

    交集 = 集合1 & 集合2 & 集合N

    >>> numbers_1 & numbers_2 & numbers_3
    {3}

  2. 求并集

    并集 = 集合1.union(集合2, 集合3, 集合N)

    >>> numbers_1 = {1, 2, 3}
    >>> numbers_2 = {2, 3, 4}
    >>> numbers_3 = {3, 4, 5}
    >>> numbers_1.union(numbers_2, numbers_3)
    {1, 2, 3, 4, 5}

    也可以直接使用或运算符 | 来代替，完全等效：

    并集 = 集合1 | 集合2 | 集合N

    >>> numbers_1 | numbers_2 | numbers_3
    {1, 2, 3, 4, 5}

  3. 求差集

    差集 = 集合1.difference(集合2, 集合3, 集合N)

    >>> numbers_1 = {1, 2, 3}
    >>> numbers_2 = {2, 3, 4}
    >>> numbers_3 = {3, 4, 5}
    >>> numbers_1.difference(numbers_2, numbers_3)
    {1}

    也可以直接使用运算符 - 来代替 ，完全等效：

    差集 = 集合1 - 集合2 - 集合N

    >>> numbers_1 - numbers_2 - numbers_3
    {1}

  4. 判断是否为子集

    布尔值 = 集合1.issubset(集合2)

    判断 集合1 是否为 集合2 的子集 。

    >>> numbers_1 = {2, 3}
    >>> numbers_2 = {1, 2, 3}
    >>> numbers_1.issubset(numbers_2)
    True
    >>> numbers_3 = {3, 4}
    >>> numbers_1.issubset(numbers_3)
    False

  5. 判断是否为超集

    布尔值 = 集合1.issuperset(集合2)

    判断 集合1 是否为 集合2 的子集。

    >>> numbers_1 = {1, 2, 3}
    >>> numbers_2 = {2, 3}
    >>> numbers_1.issuperset(numbers_2)
    True
    >>> numbers_3 = {3, 4}
    >>> numbers_1.issuperset(numbers_3)
    False

6 、集合运算示例

集合运算在编程时有什么用呢？以差集为例举个例子。

假如大学里有一个班，班里同学的花名册是「赵大，钱二 ，孙三，李四，周五 ，吴六，郑七，王八」 。有一天上课 ，老师要求同学们在一张白纸上签到，大家陆续写上了自己的名字，上面有「周五 ，李四 ，王八，赵大，钱二 ，冯九，陈十」。哪些人缺席了呢？

要判断哪些人缺席了，通常的做法时 ，逐一从签到表上取出名字，然后去花名册上寻找并做标记，最终花名册上没被标记的名字便是缺席的。有些麻烦 ，这可苦了助教了 。

我们可以用 Python 集合来快速解决这个问题。将花名册上的名字保存在集合中，将签到表上的名字保存在另一个集合中，然后求一下差集。如下：

>>> 花名册 = {‘赵大’, ‘钱二’, ‘孙三’, ‘李四’, ‘周五’, ‘吴六’, ‘郑七’, ‘王八’}
>>> 签到表 = {‘周五’, ‘李四’, ‘王八’, ‘赵大’, ‘钱二’, ‘冯九’, ‘陈十’}
>>> 花名册 - 签到表
{‘吴六’, ‘孙三’, ‘郑七’}

吴六 ，孙三，郑七没来！

我们用反过来用 签到表 - 花名册 看看：

>>> 签到表 - 花名册
{‘陈十’, ‘冯九’}

还有两个旁听生！

7、什么时候用集合

集合非常重要的一个特性是元素无重复，每个元素都是唯一的 ，重复的元素将被自动剔除（去重） 。

所以如果我们需要存放一系列的数据 ，并且不希望其中出现重复，那么就可以使用集合 。

另外如果想计算两个数据集的交集、并集 、差集，使用集合来承载数据再合适不过了 ，集合自带的集合运算能轻松解决这些问题。

 

8、获取字典和集合中的元素数量

我们可以通过 len() 函数来获取字典中的键值对数量和集合中的元素数量。

>>> codes = {‘beijing’: ‘010’, ‘shanghai’: ‘021’}
>>> len(codes)
2

>>> numbers = {1, 2, 3, 4}
>>> len(numbers)
4

 

9、字典和集合大总结

字典是一种用来存放若干键值对的数据类型，可通过键来快速查找值 。

字典的键需要是不可变的类型，如数字 ，字符串和元组。字典的值可以是任意类型。字典本身是可变的，所以可向其中添加 、修改、删除键值对 。

集合是一个用于存放批量元素的序列。它不是有序的，且元素不会有重复。集合也是可变的 ，我们可以向其中添加、删除 、修改元素 。

 

写在最后

关于Python中常用数据类型的总结就先和大家总结分享到这里，其中有不足或不懂的地方欢迎大家在评论区留言指出。

之后还会继续和大家分享有关Python函数 、迭代、表达式等进阶内容。

欢迎小伙伴们点赞关注博主！

持续为大家带来更多优质干货和技术分享哦！

灰小猿陪您一起进步呀！

本文版权归趣KUAI排www.SEOguruBlog.com 所有,如有转发请注明来出,竞价开户托管,seo优化请联系QQ→61910465