【Python学习笔记】第六章 容器类型的数据

【Python学习笔记】第六章 容器类型的数据

---

前言

博客已上传为PDF资源，系统没办法直接开源，只有关注帅气的不二程序猿才能下载。（不想关注可以私信或评论，备注资源名称可以获取）

资源链接 （PDF格式）：【Python学习笔记】第六章 容器类型的数据.pdf 378KB

资源链接 （HTML格式）：【Python学习笔记】第六章 容器类型的数据.html 66KB

Python 内置的数据类型如列表、元组、字典和集合等可以容纳多项数据，称他们为容器类型的数据。

---

6.1 序列

序列（sequence） 是一种可迭代的，元素有序的容器类型数据。

序列包括列表 list、 字符串 string、 元组 tuple 和字节序列 bytes 等。

6.1.1 序列的索引操作

序列中的元素都是有序的，每个元素都带有序号，这个序号称为索引。

索引分为正向递增（正值索引）和反向递减（负值索引）两个方法。

我们通过下标运算来访问序列中的元素，用中括号[ ] 来进行索引。

>>>a = 'hello'
>>>a[0] # 第一个元素的索引是0，结果是'h'
'h'
>>>a[4]
'o'
>>>a[-1] # 负值索引，最后一个索引是-1，结果是'o'
'o'

>>>a[5] # 索引超过范围，会发生IndexError错误
Traceback (most recent call last):
  File "", line 1, in <module>
    a[5]
IndexError: string index out of range

>>>max(a) # max()函数用于返回最后一个元素
'o'
>>>min(a) # min()函数用于返回第一个元素
'h'
>>>len(a) # len()函数用来获取序列的长度
5

6.1.2 加和乘操作

加（+）和乘（*）运算符可以用于序列中的元素操作。加（+）运算符可以将两个序列连起来，乘（*）运算符可以将两个序列重复多次。

>>> a = 'Hello'
>>> a * 2
'HelloHello'

>>> a *= 2 # *= 是乘赋运算符，a *= 2 相当于 a = a * 2
>>> a
'HelloHello'

>>> a = 'Hello' + ','
>>> a
'Hello,'

>>> a += 'word' # += 是加赋值运算符， a += 'word' 相当于 a = a + 'word'
>>> a
'Hello,word'

6.1.3 切片操作

序列的切片（slicing） 就是从序列中切分出小的子序列。

切片运算符的语法为 [start : end: step]。 其中 start 是开始索引，end 是结束索引，step 是步长（切片时获取的元素的间隔，可以为正整数，也可以是负整数）

注意：小切片包括 start 位置的元素，但不包括 end 位置的元素，所以 start 或 end 都可以省略。

>>> a = 'hello'
>>> a[1:3]
'el'

>>> a[:3] # 省略了开始索引，默认开始索引是0
'hel'

>>> a[0:3] 
'hel'

>>> a[0:] # 省略了结束索引，默认结束索引是序列的长度
'hello'

>>> a[0:5]
'hello'

>>> a[:] # 省略开始和结束索引，结果和 a[0:5] 一样
'hello'

>>> a[1:-1] # 使用了负值索引
'ell'

下面对字符串变量a进行切片操作 [0:3:2] ， 开始索引为 0 ， 结束索引为 3 ， 步长为 2 。

>>> a = 'hello'
>>> a[1:5] # 省略了步长
'ello'

>>> a[1:5:1]
'ello'

>>> a[1:5:2]
'el'

>>> a[0:3] # 省略了步长
'hel'

>>> a[0:3:2]
'hl'

>>> a[0:3:3]
'h'

>>> a[::-1] # 步长为负值时，从右往左获取元素，这是切片倒置
'olleh'

6.1.4 成员测试

成员测试运算符有两个： in 和 not in , in 用于测试是否包含某一个元素， not in 用于测试是否不包含某个元素。

>>> a = 'hello'
>>> 'e' in a
True

>>> 'E' not in a
True

>>> 'd' in a
False

6.2 列表

列表（list）是一种能可变序列类型，我们可以追加、 插入、 删除和替换列表中的元素。

6.2.1 创建列表

创建列表的两个方法：
1. list(iterable) 函数： 参数iterable是可迭代对象（字符串、 列表、 元组、 集合和字典等）
2. [元素1， 元素2， 元素3，...] ： 指定具体的列表元素，元素之间以逗号分隔，列表元素需要使用中括号括起来。

>>> [20, 10, 50, 30]
[20, 10, 50, 30]

>>> [] # 创建空列表
[]

>>> ['hello', 'stark', 1, 2, 3] # 创建字符串和整数混合列表
['hello', 'stark', 1, 2, 3]

>>> a = [10] # 创建只有一个元素的列表
>>> a
[10]

>>> a = [10,] # 列表的每一个元素后都跟着一个逗号，但经常省略这个逗号
>>> a
[10]

>>> list('hello') # 通过list(iterable)函数创建列表对象，字符串是序列对象，创建的列表对象包含5个字符
['h', 'e', 'l', 'l', 'o']

6.2.2 追加元素

列表是可变的序列对象，列表可以追加元素。
1. 在列表中追加单个元素时，可以使用 append(x) 的方法。
2. 在列表中追加多个元素时，可以使用加（+）运算符或列表的 extend(t) 方法

pop quiz: append(x) 被称为方法， list(iterable) 被称为函数，方法和函数的区别是什么？
pop answer： 方法属于类，通过类或对象调用方法，例如在list.append(x) 中，list 是列表对象； 函数不属于任何类，直接可以调用，例如 list(iterable)。

>>> list = [20, 10, 50, 30]
>>> list.append(80) # 在列表后面追加一个元素，不能同时追加多个元素
>>> list
[20, 10, 50, 30, 80]


>>> list = [20, 30, 40, 50]
>>> t = [1, 2, 3]
>>> list += t # 使用运算符追加多个元素
[20, 30, 40, 50, 1, 2, 3]


>>> list = [20, 30, 40, 50]
>>> list.extend(t) # 使用extend（）方法追加多个元素
>>> list
[20, 30, 40, 50, 1, 2, 3]

6.2.3 插入元素

想向列表里插入元素时，可以使用列表的 list.insert(i, x) 方法， 其中 i 指定索引位置，x 是要插入的元素。

>>> list = [20, 10, 50, 30]
>>> list.insert(2, 70) # 在索引2的位置插入一个元素，新元素的索引位置为2
>>> list
[20, 10, 70, 50, 30]

6.2.4 替换元素

想替换类表中的元素时，将列表下标索引元素放在赋值号（=） 的左边。

>>> list = [20, 30, 40, 50]
>>> list[1] = 80 # 将原来的30 替换成80
>>> list
[20, 80, 40, 50]

6.2.5 删除元素

想在列表中删除元素时，可以使用列表的 list.remove(x) 方法， 如果找到匹配的元素x，则删除该元素，如果找到多个匹配元素就删除第一个匹配元素。

>>> list_1 = [20, 30, 40, 50]
>>> list_2 = [20, 30, 30, 30, 50]
>>> list_1.remove(30)
>>> list_2.remove(30)
>>> list_1 # 删除了一个元素
[20, 40, 50]
>>> list_2 # 匹配后删除了第一个匹配元素
[20, 30, 30, 50]

6.3 元组

元组（tuple）是一种不可变序列类型

6.3.1 创建元组

创建元组时有两种方法
1. tuple（iterable）函数： 参数iterable是可迭代对象（字符串、 列表、 元组、 集合和字典等）
2. （元素1、 元素2、 元素3、···）： 指定具体的元组元素，元素之间可以以逗号分隔。对于元组元素，可以使用小括号括起来，也可以沈列小括号。

>>> 21,23,45,44,55 # 创建一个有5个元素的元组，可以用括号，也可以省略
(21, 23, 45, 44, 55)

>>> ('hello','word') # 创建字符串元组
('hello', 'word')

>>> ('hello','word',1,2,3) # 创建字符串和整数混合的元组
('hello', 'word', 1, 2, 3)

>>> tuple('hello') # 通过tuple（）函数创建元组
('h', 'e', 'l', 'l', 'o')

>>> tuple([21,22,34,55,66]) # 通过tuple（）函数创建元组
(21, 22, 34, 55, 66)

>>> t = 1, # 创建一个元组时，后面的逗号不能省略
>>> t
(1,)

>>> type(t)
<class 'tuple'>

>>> t = (1,) # 创建一个元组时，后面的逗号不能省略
>>> type(t)
<class 'tuple'>

>>> a = () # 可以通过（）创建空元组
>>> type(a)
<class 'tuple'>

6.3.2 元组拆包

创建元组，并将多个数据放到元组中，这个过程被称为元组打包。
与元组打包相反的是元组拆包，就是将元组的元素取出，分别赋值给不通用的变量。

>>> s_id,s_name = (111, '张三')
>>> s_id # 将元组（102，'张三')拆包到两个变量里
111
>>> s_name
'张三'

pop quiz: 例子中元组（111，‘张三’） 两个是不同的数据类型，这种情况是否允许呢？
pop answer： 当然可以，不仅仅是元组，所有容器类型的数据中都可以保存任意类型的数据，只不过通常容器中只保存相同的类型数据。

6.4 集合

集合（set）是一种可迭代的、 无序的、 不能包含重复元素的容器类型数据。
序列中的元素是有序的；但是集合中的元素是无序的，但是元素不能重复。

6.4.1 创建集合

我们可以通过以下两种方式创建集合。
1. set（iterable） 函数： 参数 iterable 是可迭代对象（字符串、 列表、 元组、集合和字典等）。
2. {元素1、 元素2、 元素3、···}： 指定具体的集合元素，元素之间以逗号分隔。对于集合元素，要使用大括号括起来。

>>> set('hello')
{
     'l', 'h', 'e', 'o'}
>>> {
     20, 12, 13, 25, 33}
{
     33, 12, 13, 20, 25}
>>> b = {
     }
>>> type(b)
<class 'dict'>

6.4.2 修改集合

修改合集类似于修改列表，可以向其中插入和删除元素。修改可变集合有以下方法。
1. add(elem)：添加元素，如果元素已经存在就不能添加，不然会出现错误
2. remove(elem)： 删除元素，如果元素不存在，则会出现错误
3. clear(): 清除集合

>>> set = {
     'Stark' , 'Snail' , 'Shift'}
>>> set.add('SiSi') # 添加元素
>>> set
{
     'SiSi', 'Shift', 'Stark', 'Snail'}


>>> set.remove('Shift') # remove()方法删除元素
>>> set
{
     'SiSi', 'Stark', 'Snail'}


>>> 'Shift' in set # 判断是否在集合里
False
>>> set.remove('kk') # 集合里没有‘kk' 然后报错
Traceback (most recent call last):
  File "", line 1, in <module>
    set.remove('kk')
KeyError: 'kk'


>>> set.clear() # 清除集合
>>> set
set()

6.5 字典

字典（dict）是可迭代的、 通过键(key) 来访问元素的可变的容器类型数据。
字典由两部分视图构成： 键视图和值视图。键视图不能包含重复的元素，值视图能。在键视图中，键和值是成对出现的。

6.5.1 创建字典

我们可以通过以下两种方法创建字典：
1. dict() 函数
2. {key1 : value1, key2 : value2, key3 : value3}: 指定具体的字典键值对，键值对之间用逗号分隔，最后用大括号括起来。

# 通过dict()函数创建字典，参数是另外一个字典
>>> dict({
     102:'Stark', 103:'Snail', 104:'SiSi'})
{
     102: 'Stark', 103: 'Snail', 104: 'SiSi'}



# 通过dict()函数创建字典，参数是一个元组，在这个元组中包含三个含有两个元素的元组
>>> dict(((102,'Stark'),(103,'Snail'),(104,'SiSi')))
{
     102: 'Stark', 103: 'Snail', 104: 'SiSi'}



# 通过dict()函数创建字典，参数是一个列表，在这个列表中包含三个只有两个元素的元组
>>> dict([(102,'Stark'),(103,'Snail'),(104,'SiSi')])
{
     102: 'Stark', 103: 'Snail', 104: 'SiSi'}



# 通过zip()函数将两个可迭代对象打包成元组，第一个参数是字典的键，第二个参数是字典的值，他们包含的元素个数相同，并且一一对应
>>> dict(zip([102,103,104],['Stark','Snail','SiSi']))
{
     102: 'Stark', 103: 'Snail', 104: 'SiSi'}


>>> dict1 = {
     102:'Stark' , 103:'Snail' , 104:'SiSi'}
>>> dict1
{
     102: 'Stark', 103: 'Snail', 104: 'SiSi'}

>>> dict1 = {
     } # 字典变空
>>> dict1
{
     }

6.5.2 修改字典

字典可以被修改，但是针对键和值同时操作，对字典的修改包括添加、 替换和删除。

>>> dict1 = {
     102:'Stark' , 103:'Snail' , 104:'SiSi'}
>>> dict1[104] # 通过键返回对应的值
'SiSi'


>>> dict1[105] = 'baby' # 通过105键赋值，添加105：’baby‘ 键值对
>>> dict1
{
     102: 'Stark', 103: 'Snail', 104: 'SiSi', 105: 'baby'}


>>> dict1[105] = 'lovely' # 将105键对应的值替换为'lovely'
>>> dict1
{
     102: 'Stark', 103: 'Snail', 104: 'SiSi', 105: 'lovely'}


>>> dict1.pop(105) # 使用字典的pop（key）方法删除键值对，返回删除的值
'lovely'
>>> dict1
{
     102: 'Stark', 103: 'Snail', 104: 'SiSi'}

6.5.3 访问字典视图

我们可以通过以下三种方式访问字典视图：
1. items()： 返回字典的所有键值对视图
2. keys(): 返回字典键视图
3. values()：返回字典值视图

>>> dict1 = {
     102:'Stark', 103:'Snail', 104:'SiSi'}
>>> dict1.items() # 返回字典的所有键值对视图dict_items
dict_items([(102, 'Stark'), (103, 'Snail'), (104, 'SiSi')])


>>> list(dict1.items()) # dict_items可以使用list() 函数返回键值对列表
[(102, 'Stark'), (103, 'Snail'), (104, 'SiSi')]


>>> dict1.keys() # 返回字典键视图dict_keys
dict_keys([102, 103, 104])


>>> dict1.values() # 返回字典值视图dict_values
dict_values(['Stark', 'Snail', 'SiSi'])


>>> list(dict1.values()) # dict_values可以使用list()函数返回值列表
['Stark', 'Snail', 'SiSi']

---

总结

本章节讲述了序列（列表和元组）、集合和字典这几种容器类型的数据，其中列表和元组属于序列。这几种容器都是可迭代的，下面他们的特点：
1. 序列元素是有序的，其中列表是可变的，元组是不可变的。
2. 集合元素是无需的，而且不能重复。
3. 字典通过键来访问元素，由键视图和值视图构成，键视图不能包含重复的元素。

---

From 小编kk

最近更新慢，因为开学把大部分精力放在学业上。【Python学习笔记】 和 【数据科学笔记】 这两个系列进度稍微慢一点，更多的作业笔记会放在学校的课程上：INFO1110，DATA1002 ，DATA1001（这三门课已经学过，会做大量笔记讲解和经验分享）。

2021S1新学的 DATA2001 和 DESN2000 学Python、 SQL和JavaScript语言，有感兴趣的朋友可以私信联系，一起攻克难关！！！