目录

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

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，那么在用 print() 输出字符串的时候，这个字符串会被换行输出。如：

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

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

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

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

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

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

2. 使用原始字符串

5、原始字符串

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

r'字符串内容'