小熊带你学Python（七）——数据结构

上一节我们提到列表、元组、字典和集合，但他们都是什么呢？有什么样的结构和使用方法呢，让我们这一节一起来学习。数据结构的使用无非是增删改查，而，我们提到的这四种序列不是都能实现的，我们看下面的对比，先有个大体的印象。

列表：能够增、删、改、查；

元组：能够查、删；

字典：能够增、删、改、查；

集合：能够增、删、查。

数据结构根据能否增删改查可以分为可变数据类型和不可变数据类型。可变数据类型可以对数据进行增删改查，如列表、字典、可变集合等，可变数据类型从本质上是对自身进行的修改，修改后的id与原数据地址是一样的。不可变数据类型，不能进行增删改，如果确需要改变数据，则需要转化成其他的可变数据类型进行增删改后再转化成不可变数据类型，常见的不可变数据类型有数字、字符串、元组、不可变集合。无论是可变数据类型还是不可变数据类型，他们在使用时候又都有自己的一些特性，我们将进行详细研究。

1、列表

列表有以下几个特征：

1、列表数据是有序的，列表的访问和字符串一样，通过索引进行访问，访问方法和字符串一样。

2、列表可以存储不同数据类型的对象。

3、列表内的元素可以重复。

4、列表支持增删改查。

1.1 创建列表

创建列表有两种方法：

1、变量名 = [数据1，数据2，数据3，……]

2、使用list()函数，变量名 = list(数据1，数据2，数据3，……)

列表中取数据与字符串索引的使用方法一样，我们可以通过索引来取一个数据、一段数据以及特定位置、特定步长的数据。列表索引同样分为正向索引、反向索引，使用 变量名 = 列表名[索引]来取特定数据，使用 变量名 = 列表名[起始索引:结束索引:步长]来提取子列表元素。我们看下面的例子：

>>>n_list1 = [1,2,"3","你好","numun"]  #定义列表n_list1
>>>n_list2 = list(4,5,"6","小熊","python")  #定义列表n_list2，但是显示错误，因为list()函数，实质上就是将其他的数据结构转换为列表模式，因此需要双括号
Traceback (most recent call last):
  File "<pyshell#1>", line 1, in <module>
    n_list2 = list(4,5,"6","小熊","python")
TypeError: list expected at most 1 argument, got 5
>>>n_list2 = list((4,5,"6","小熊","python"))  #定义列表n_list2
>>>print(n_list1)  #打印出n_list1
[1, 2, '3', '你好', 'numun']
>>>print(n_list2)  #打印出n_list2
[4, 5, '6', '小熊', 'python']

1.2 列表的增删改查方法

在列表中增加元素方法：

1、列表名.append(数据)，在列表末尾添加数据，每次能够添加一个数据；

2、列表名.extend(数据)，在列表末尾添加一个可迭代对象，如列表等；

3、列表名.insert(索引位置,数据)，在索引的位置添加数据。

我们看下面的例子：

>>>n_list1.append("我是末尾添加的")  #列表n_list1尾添加数据
>>>print(n_list1)    #打印n_list1
[1, 2, '3', '你好', 'numun', '我是末尾添加的']
>>>n_list1.extend(n_list2)   #列表n_list1后添加可迭代对象n_list2
>>>print(n_list1)  #打印n_list1
[1, 2, '3', '你好', 'numun', '我是末尾添加的', 4, 5, '6', '小熊', 'python']
>>>n_list1.insert(0,0)  #在n_list1的0索引位置添加数字0
>>>print(n_list1)  #打印n_list1
[0, 1, 2, '3', '你好', 'numun', '我是末尾添加的', 4, 5, '6', '小熊', 'python']

在列表中删除元素的方法：

1、列表名.pop(索引位置)，删除列表中指定索引元素，并返回该元素的值；

2、del list[索引位置]，删除索引位置的元素，删除元素后面的元素索引全部减1。

我们看下面的例子：

>>>n_list1.pop(6)  #删除索引为6的元素，并返回钙元素得知
'我是末尾添加的'
>>>del n_list1[5]  #删除索引为5的元素
>>>print(n_list1)  #打印n_list1
[0, 1, 2, '3', '你好', 4, 5, '6', '小熊', 'python']

在列表中修改元素的方法：

1、列表名[索引位置] = 数据1，将列表中索引位置的数据赋值为数据1；

2、列表名.reverse()，对列表中的元素进行逆序排列；

3、列表名.sort(reverse=False)，将列表中的元素进行升序排列，如果为True则表示降序排列，省略时默认升序排列。

我们看下面的例子：

>>>n_list1[3] = "我是改变的"  #改变n_list1中索引3处的元素内容
>>>print(n_list1)  #打印n_list1
[0, 1, 2, '我是改变的', '你好', 4, 5, '6', '小熊', 'python']
>>>n_list1.reverse()  #对n_list1进行逆序排列
>>>print(n_list1)  #打印n_list1
['python', '小熊', '6', 5, 4, '你好', '我是改变的', 2, 1, 0]
>>>n_list3 = [2,3,1,0,4,8,9,7,6]  #定义n_list3
>>>n_list3.sort()  #默认对n_list3升序排列
>>>print(n_list3)  #打印n_list3
[0, 1, 2, 3, 4, 6, 7, 8, 9]
>>>n_list3.sort(reverse=True)  #对n_list3降序排列
>>>print(n_list3)  #打印n_list3
[9, 8, 7, 6, 4, 3, 2, 1, 0]

在列表中查询元素的方法：

1、列表名.count(数据)，统计列表中数据出现的次数，返回的是统计的次数值；

2、列表名.index(数据)，查询数据第一次在列表中出现的索引位置，返回的是索引位置值。

我们看下面的例子：

>>>n_list3.extend(n_list2)  #构造一个列表n_list3
>>>print(n_list3)  #打印n_list3
[9, 8, 7, 6, 4, 3, 2, 1, 0, 4, 5, '6', '小熊', 'python']
>>>print(n_list3.count(4))  #打印统计出的n_list3中4出现的次数
2
>>>print(n_list3.index(8))  #打印n_list3中8第一次出现的索引位置
1

我们在日常中还能够遇到二维、三维甚至多维列表，当然，我们要注意区分他们的隶属关系，才能在应用中不出错，特别的二维列表还比较常用，其他的不太常用。

我们看下面的例子：

>>>n_list4 = [[0,0,0],[1,1,1],[2,2,2]]  #构造一个3*3的三维列表
>>>print(n_list4)  #打印n_list4
[[0, 0, 0], [1, 1, 1], [2, 2, 2]]

2、元组

元组有以下几个特征：

1、元组的大小、元素都是只读，不能够改变的。

2、元组的访问也是有序的，能够通过索引进行访问，访问方法和字符串、列表一样。

3、元组中可以存储任意类型的数据。

2.1 创建元组

创建元组的方法有两种：

1、变量名 = （数据1，数据2，……）

2、使用tuple()函数，变量名 = tuple()，可以实现其他数据结构转换为元组类型

元素不允许修改，如果修改将会报错。

元组和列表有相同点和不同点，我们来比较一下：
元组和列表相同与不同相同点 不同点
支持索引访问 元组的访问速度快
可以存放不同数据类型 元组的不可改变使代码更安全
支持运算，支持判断操作，如in、is等 元组不能增、删、改

我们看下面的例子：

>>>n_tuple1 = (1,2,5,3,4,6,9,7,8)  #构造元组n_tuple1
>>>print(n_tuple1)  #打印元组n_tuple1
(1, 2, 5, 3, 4, 6, 9, 7, 8)
>>>n_tuple2 = tuple(('m','n','2'))  #构造元组n_tuple2
>>>print(n_tuple2)  #打印元组n_tuple2
('m', 'n', '2')

2.2 常用的元组使用函数

元组.count(数据1)：统计元组中数据1出现的次数，并返回次数；

元组.index(数据1)：返回数据1第一次出现位置的索引值；

max(元组)：返回能够比较的数据的最大值；

min(元组)：返回能够比较的数据的最小值；

len(元组)：返回元组的长度。

我们看下面的例子：

>>>print(n_tuple1.count(2))  #统计元素2出现的次数
1
>>>print(n_tuple1.index(6))  #返回元素6首次出现的位置
5
>>>print(max(n_tuple1))  #打印n_tuple1中最大值
9
>>>print(min(n_tuple1))  #打印n_tuple1中最小值
1
>>>print(len(n_tuple1))  #打印n_tuple1的长度
9

3、字典字典有以下几个特征：

1、字典中的数据都是成对出现的，通过 键:值的方式，来表示字典中的一个元素。

2、字典中的键是不能重复的，值则是可以重复的。

3、字典中的数据访问，主要通过键来精准访问，如果只是访问值，也是可以的，但不能通过直接的方式精准访问。

4、字典中的键是无法修改的，而数据值是可以修改的。

5、字典中的键和值是一一映射的关系，不能够脱离对方而存在。

3.1 创建字典

创建字典的方法有两种：

1、变量名 = {键1:值1,键2:值2,……}

2、使用dict()函数，变量名 = dict()，可以实现其他数据结构转换为字典类型

第二种方法主要是将包含两个元素的序列对象转换为字典类型。

我们看下面的例子：

>>>n_dict1 = {"001":"张三","002":"李四","003":"王五"}  #创建字典n_dict1
>>>print(n_dict1)  #打印字典n_dict1
{'001': '张三', '002': '李四', '003': '王五'}
>>>n_dict2 = dict([["004","赵六"],["005","于七"],["006","刘八"]])  #通过函数dict()创建字典
>>>print(n_dict2)  #打印字典n_dict2
{'004': '赵六', '005': '于七', '006': '刘八'}

3.2 字典的增删查改方法

1、在字典中查找元素的方法：

字典的数据不能通过索引进行访问，只能通过键来访问对应的数值，当然也就可以通过键添加键值对、删除键值对、修改键值对等。

可以通过访问字典中的键来读取对应的数据，变量名 = 字典[键]，也可通过 字典名.keys()、字典名.values()、字典名.items()来访问字典中所有的键、值、键值对。或者通过for循环来读取字典的数据。

我们看下面的例子：

>>>a = n_dict1["001"]  #读取键为001的值
>>>print(a)  #打印出值
张三
>>>print(n_dict1.keys())  #打印出n_dict1的键
dict_keys(['001', '002', '003'])
>>>print(n_dict1.values())  #打印出n_dict1的值
dict_values(['张三', '李四', '王五'])
>>>print(n_dict1.items())  #打印出n_dict1键值对的值
dict_items([('001', '张三'), ('002', '李四'), ('003', '王五')])
>>>for key in n_dict1:  #使用for循环遍历n_dict1，取出键和值
   		data = n_dict1[key]
    	print('数字为：%s'%key)
    	print('名字为：%s'%data)
数字为：001
名字为：张三
数字为：002
名字为：李四
数字为：003
名字为：王五

2、在字典中添加、修改元素的方法：

添加、修改字典元素都是通过 字典名[键] = 值 来实现，我们可以通过下面的例子来看看：

>>>n_dict1['001'] = '张九'  #对n_dict1中键为001的值改为张久
>>>print(n_dict1)  #打印n_dict1内容
{'001': '张九', '002': '李四', '003': '王五'}
>>>n_dict1['010'] = '张十'  #n_dict1中没有键为010的
>>>print(n_dict1)  #打印n_dict1内容
{'001': '张九', '002': '李四', '003': '王五', '010': '张十'}

3、在字典中删除元素的方法：

字典名.pop(key)：删除并返回指定键对应的值；
del 字典名[key]：删除指定键对应的键值对；
字典名.clear()：清空字典中所有的键值对。

>>>n_dict1.pop('010')  #删除键010对应的键值对，并返回键对应的值
'张十'
>>>print(n_dict1)  #打印n_dict1
{'001': '张九', '002': '李四', '003': '王五'}
>>>del n_dict1['001']  #删除键值为001的键值对
>>>print(n_dict1)  #打印n_dict1
{'002': '李四', '003': '王五'}
>>>n_dict1.clear()  #清空n_dict1
>>>print(n_dict1)  #打印n_dict1
{}

4、集合

集合是用来存储多种数据的一种数据结构，他有几个特点：

1、集合中的元素不能重复，要是唯一的；

2、集合中保存的数据是无序的，但从python3.6后，添加的数据不再是无序添加，而是在现有数据的后面添加；

3、集合支持增删元素；

4、元素类型可以是任意类型。

2.1 集合的创建

创建集合有两种方法：

1、创建空集合，通过函数set()创建，变量名 = set()

2、创建非空集合，变量名 = {数据1，数据2，……}

我们看下面的例子：

>>>n_set1 = set()  #设置空集合
>>>print(n_set1)  #打印n_set1
set()
>>>n_set2 = {'100','200','500','600','700',1000,(1,2,3)}  #定义集合n_set2
>>>print(n_set2)  #打印n_set2
{'500', (1, 2, 3), 1000, '600', '100', '700', '200'}

2.2 集合的运算

集合的运算有几种方法，并、交、差三种运算方式：

运算符为‘|’，计算两个集合的并集，对应函数 集合1.union(集合2)；
运算符为‘&’,计算两个集合的交集，对应函数 集合1.intersection(集合2)；
运算符为‘-’，计算两个集合的差集，对应函数 集合1.difference(集合2)。

我们看下面的例子：

>>>n_set2 = {'100','200','500','600','700',1000,(1,2,3)}  #定义n_set2
>>>print(n_set2)  #打印n_set2
{'500', (1, 2, 3), 1000, '600', '100', '700', '200'}
>>>n_set3 = {'700','600',2000}  #定义n_set3
>>>print(n_set2|n_set3)  #打印通过“|”计算并集
{'500', (1, 2, 3), 1000, '600', '100', '700', 2000, '200'}
>>>print(n_set2.union(n_set3))  #打印通过函数union计算并集
{'500', (1, 2, 3), 1000, '600', '100', '700', 2000, '200'}
>>>print(n_set2&n_set3)  #打印通过“&”计算交集
{'600', '700'}
>>>print(n_set2.intersection(n_set3))  #打印通过函数intersection计算交集
{'600', '700'}
>>>print(n_set2-n_set3)  #打印通过“-”计算差集
{'500', (1, 2, 3), 1000, '100', '200'}
>>>print(n_set2.difference(n_set3))  #打印通过函数difference计算差集
{'500', (1, 2, 3), 1000, '100', '200'}

以上便是数据结构的基本内容，下一节，我们将开始学习函数，编程起步啦！