Data structure container

数据结构容器

列表

语法

列表形如[1,2,3,4] [‘小明’,‘小红’,‘小王’]
中括号括起来，里面有多个元素（项），项可以是数字、字符串、布尔，每一项逗号分隔。

创建

1.声明变量时 中括号、项，创建一个非空的列表。
num_list = [1, 2, 3, 4]
2.创建一个空列表，之后再修改
num_list = []
3.类实例化创建
list1 = list()

添加

1.(常用)append() 追加
列表对象.append(新项)，追加一个元素到列表末尾。
list1 = [1,2,3]
list1.append(4) -> [1,2,3,4]
2. insert()
列表对象.insert(索引，新项)，插入到指定下标处。
list1 = [1,2,3]
list1.insert(0, 4) -> [4,1,2,3]
3.列表合并
两个变量都是列表时，可以合并
list1 = [1]
list2 = [2,3]
list1 + list2 -> [1,2,3]
4.批量添加
通过循环获取新项并依次调用append()
list1 =[‘小明’,‘小红’]
for i in [‘小李’,‘小王’,‘小肖’]:
list1.append(i)
list1 - > [‘小明’, ‘小红’, ‘小李’, ‘小王’, ‘小肖’]

删除

1.pop()
列表对象.pop(索引)，删除指定索引的那一项,删除成功后返回删除的内容。
list1 = [1,2,3]
list1.pop(0) -> 1
2.remove()
列表对象.remove(项内容)，根据项的内容删除。
list1 = [‘小明’,‘小红’,‘小青’]
list1.remove(‘小红’)
list1 -> [‘小明’, ‘小青’]
3.(不常用)clear()
列表对象.clear()，清空所有项。
list1 = [‘小明’,‘小红’,‘小青’]
list1.clear()
list1 -> []
4.(不常用)关键字 del
list1 = [‘小明’,‘小红’,‘小青’]
del list1[0]
list1 -> [‘小红’, ‘小青’]

修改

1.根据下标修改
列表对象[索引] = 新值
list1 = [‘小明’,‘小红’,‘小青’]
list1[1] = ‘小王’
list1 -> [‘小明’, ‘小王’, ‘小青’]

访问

1.通过下标（索引 index）访问。
列表中的项以 0，1，2···编号。比如[1,2,3]中的元素1的下标是0。
list1 = [1,2,3]
list1[0] -> 1
list1[-1] -> 3 下标负数表示倒数第几项
2.遍历，访问列表中每一项
for i in [‘小明’,‘小红’,‘小青’]:
print(i)
3.遍历，循环下标。场景 修改。
len(列表对象) 返回的是列表的长度。
list1 = [‘小明’,‘小红’,‘小青’]
for i in range(0, len(list1)):
print(list1[i])

切片

列表对象[起始下标，结束下标+1] 左闭右开区间

list1 = [‘小明’,‘小红’,‘小青’,‘小王’,‘小杨’]
list1[0:2] -> [‘小明’, ‘小红’]
list1[:2] -> [‘小明’, ‘小红’] 简写，从头开始截取，下标0的话可以省略
list1[2:] -> [‘小青’, ‘小王’, ‘小杨’] 简写，截取到末尾，末尾下标省略
list1[1:3] -> [‘小红’, ‘小青’]
list1[-3:-1] -> [‘小青’, ‘小王’] 下标可以为负
list1[4:0] -> [] 注意截取的方向，第一个下标小于第二个下标，否则返回空。
list1[::-1] -> [‘小杨’, ‘小王’, ‘小青’, ‘小红’, ‘小明’]

查找

num_list = [1,2,3,4]
num_list.index(1) -> 0
num_list.index(5) -> 报错ValueError

in 判断，if 条件

num_list = [1,2,3,4]
1 in num_list -> True
场景 与if连用。
if 1 in [1,2,3,4]:
if []: 空列表 if判断为False。

可能出现的错误

num = [1,2,3,4]
num[4]
报错下标越界。IndexError: list index out of range
错误一般发生在收集数据代码逻辑错误，列表本身就位空。

字典

引题

列表表达一组概念，例如student_name_list = [‘小明’,‘小红’,‘小青’]
在表达一个对象不同属性 例如name ‘小明’ age 10 sex ‘男’ height 160 不太擅长。

列表vs字典

很多时候可以通用
列表：每一项都是一类东西。项数不多。占用资源稍微少。适合用列表。
有下标，有顺序的。
字典：一个对象事务的不同属性。项数比较多。占用资源稍多。适合字典。
依赖键名访问，无顺序的。

创建

大括号括住，逗号分隔项，每一项是键值对 键:值，键名一般是字符串类型。
（了解：其他语言也有键值对这种结构，map）
1.（常用）创建一个非空字典
stu1_dict = {‘name’:‘小明’,‘age’:10,‘sex’:‘男’,‘height’:160}
2.创建一个空字典
dict1 = {}
3.类实例化创建
stu_xiaoming_dict = dict()
stu_xiaoming_dict -> {}

stu_xiaoming_dict = dict(name=‘小明’,age=10)
stu_xiaoming_dict -> {‘name’: ‘小明’, ‘age’: 10}

访问

1.（常用）通过键访问值，字典对象[键]
stu_dict = {‘name’: ‘小明’, ‘age’: 10}
stu_dict[‘name’] -> ‘小明’
找不到键名会报错，错误反应严重，适合严谨的情况。
2.对象.get(键名，默认值=None)
stu_dict.get(‘name’) -> ‘小明’
stu_dict.get(‘height’,0) -> 0
找不到键名不会报错，会返回默认值，适合事先知道数据可能取不到，需要默认值的情况。不太严谨。
3.可能的错误：
stu_dict[‘height’] 报错 键错误 KeyError: ‘height’

其他常用方法

1.所有项的值。遍历（不太常用，有时需求会用到）
字典对象.values() 返回值组成的列表
stu_dict = {‘name’:‘小明’,‘age’:10}
stu_dict.values() -> dict_values([‘小明’, 10])
2.所有项的键
字典对象.keys() 返回键组成的列表
stu_dict.keys() -> dict_keys([‘name’, ‘age’])
3.获取所有项
字典对象.items() -> [(‘name’, ‘小明’), (‘age’, 10)]

添加

1.对象[新建] = 新值
stu_dict[‘sex’] = ‘male’
2.声明一个非空字典时用变量去拼
new_value = 160
stu_dict = {‘name’: ‘小明’, ‘age’: 10, ‘sex’: ‘male’, ‘height’: new_value}
等同于stu_dict = dict(name=‘小明’,age=10, height=new_value)

更新

1.（常用）字典对象[键名] = 新值
stu_dict[‘name’] = ‘小红’
stu_dict -> {‘name’: ‘小红’, ‘age’: 10}
2.字典对象.update(key1=value1,key2=value2,…)
stu_dict.update(name=‘小李’,age=12)
stu_dict -> {‘name’: ‘小李’, ‘age’: 12}
（了解：内存原理：键名映射指向了新的值，哈希表，字典查询效率比较高）

删除

1.把值更新成默认值或None
stu_dict = {‘name’:‘小明’,‘age’:10}
stu_dict[‘name’] = None
2.字典对象.pop(键)，删除键值对，删除成功后返回键对应的值。
stu_dict.pop(‘name’) -> ‘小明’
stu_dict -> {‘age’: 10}
3. del 关键字
del stu_dict[‘name’]
4.stu_dict.clear() -> {}

嵌套

列表，字典可以根据需求相互嵌套。
1.列表套列表。二维数组
字典对象.items() 返回值类似与 [[‘name’, ‘小明’], [‘age’, 10]]
二维数组、矩阵。[[1,2,3],[4,5,6],[7,8,9]]
2.列表套字典
students = [
{‘name’:‘小明’,‘age’:10,‘sex’:‘male’},
{‘name’:‘小红’,‘age’:12,‘sex’:‘female’},
{‘name’:‘小李’,‘age’:12,‘sex’:‘male’}
]
3.字典套列表
接口上常见，比如天气预报接口。
weather_info = {
‘success’: ok,
‘status_code’: 200,
‘city_list’: [
{‘name’:‘郑州’, ‘temp’:‘28’, ‘wet’: 30},
{‘name’:‘洛阳’, ‘temp’:‘25’, ‘wet’: 40}
]
}

元组

元组

元组跟列表非常相似，只是元组“不可修改”。
“小括号”括住，每一项逗号分隔，每一项可以是字符串、数字、布尔。
hobby_tuple = (‘打电脑’,‘看电视’,‘逛街’)

场景

列表可以修改，学生列表。
元组不可修改，可以存配置、常量（例如存储地市信息）

创建

provinces = (‘北京’,‘郑州’)

访问

也是通过下标访问
provinces[0] -> ‘北京’

切片

provinces = (‘北京’,‘郑州’,‘广州’)
provinces[:1] -> (‘北京’,)
注意元组切片后会多余一个逗号，可能会影响逻辑。

不可修改

provinces[0] = ‘帝都’
报错元祖的项不能被修改。
TypeError: ‘tuple’ object does not support item assignment

集合

概念

集合：一些元素组成的整体。比如说我们班上的所有同学组成了一个名为314班的集合。
元素：组成集合的个体叫做元素。比如314班级的集合，班上的每一位同学就是一个元素。
属于：一个元素在一个集合里面，称为属于。记作 xxx∈314班集合。
习惯用大写字母表示集合，小写字母表示元素。314班集合记作S，班上学生记作a、b、c,b∈S。
比如我不属于315班集合，记作 我∉315集合。

创建

1.创建空集合
set1 = set()
2.创建非空集合
set1 = {‘a’, ‘b’, ‘c’}
大括号括住，里面每一个元素不是键值对，跟列表类似。

添加

set1 = {‘a’, ‘b’, ‘c’}
set1.add(‘d’)
set1 -> {‘a’, ‘d’, ‘c’, ‘b’} 可以看出集合无序特性

删除

set1 = {‘a’, ‘b’, ‘c’}
1.根据元素值来删除
set1.remove(‘a’)
2.pop
set1.pop() 删除集合中的某一项并返回，如果集合空会报错。
3.clear()
清空集合里所有元素。

列表 vs 集合

列表是有序的。
集合是无序的。集合只关心元素是否出现过，不关心元素顺序。
元素不能重复。
场景：去重。集合之间的关系运算（和、交、并）

去重

set([1,2,3,3,2]) -> {1, 2, 3}

交、并、差、补

1.并集 数学标记∪，程序符号是 | 。注意集合运算用的是自己一套运算符号，不能用and,or之类比较条件的符号。
并集表示一个元素可能属于集合A，或者属于集合B。
set1 = {1,2,3}
set2 = {3,6,7}
set1 | set2 -> {1, 2, 3, 6, 7}

2.交集 数学标记∩，程序符号是 & 。
一个元素既属于集合A又属于集合B。
set1 = {1,2,3}
set2 = {3,6,7}
set1 & set2 -> {3}

3.差集 程序符号 - 。
A-B表示一个元素属于A但不属于集合B
set1 = {1,2,3}
set2 = {3,6,7}
set1 - set2 -> {1, 2}

4.子集 补集
子集。集合B的每一个元素都属于集合A，A包含B，B是A的子集。
补集。在A中，属于A但不属于B，叫B的补集。

列表生成式（语法糖）

要求：会写简单的列表生成式。

需求：1.得到一个列表，[1,2,3,4,5,6,…20]

需求：2.给定列表[1,2,3],分别计算每项元素的平方并返回，返回结果[1,4,9]

第1题普通写法

list1 = []
for i in range(1, 21):
list1.append(i)
print(list1)

列表生成式写法

print([i for i in range(1, 21)])

语法 [变量或表达式 循环表达式 if条件]，解释器会自动把每一次循环的变量作为一项插入到列表当中。
场景：适合比较简单的列表生成，不必刻意使用。

复杂一点的例子。循环表达式后面又跟了if表达式，只有当if条件为True，i才会加入列表。
[i for i in range(1, 21) if i % 2 == 0]
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

[i*i for i in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

(了解)生成器

g = (x for x in range(1, 5))
g.next() # 1
g.next() # 2

数据结构类型转换

数字、字符串转换

int(‘1’) -> 1
float(‘2.5’) -> 2.5
str(1) -> ‘1’

列表、字典、元组、字符串

字典转字符串
student_dict = {‘name’:‘小明’,‘age’:7,‘sex’:‘male’}
str(student_dict) -> “{‘name’: ‘小明’, ‘age’: 7, ‘sex’: ‘male’}”
列表转字符串
str([1,2,3]) -> ‘[1, 2, 3]’
元组转字符串
str((1,2,3)) -> ‘(1, 2, 3)’
字典转列表（不常用）
list(student_dict) -> [‘name’, ‘age’, ‘sex’]
字典转元组（不常用）
tuple(student_dict) -> (‘name’, ‘age’, ‘sex’)
（常用）列表元组互转
name_list = [‘小明’,‘小红’,‘小李’]
tuple(name_list) -> (‘小明’, ‘小红’, ‘小李’)
name_tuple = (‘小明’,‘小红’,‘小李’)
list(name_tuple) -> [‘小明’, ‘小红’, ‘小李’]

zip()（了解）

假设你从数据库或别人提供了两个列表。
第一个列表里全是value。第二个列表全是key。
要求返回前端{‘name’: ‘小明’, ‘age’: 7, ‘sex’: ‘male’}

list1 = [‘小明’, 7, ‘male’]
list2 = [‘姓名’, ‘年龄’, ‘性别’]
1.普通方法来做的话
result = {}
for i in range(0, len(list1)):
result[list2[0]] = list1[0]
print(result)

2.zip(键列表，值列表) 然后再dict转型
dict(zip(list2, list1)) -> {‘姓名’: ‘小明’, ‘年龄’: 7, ‘性别’: ‘male’}

eval() 求···值（常用）

eval(字符串) 把字符串信息当做python表达式来解释运行。
eval(“print(‘hello’)”) -> hello
eval(’[1,2,3]’) -> [1, 2, 3]

枚举

枚举 enumerate 一个一个列出来

场景：循环列表，既想获得索引、又想获得元素内容

1.普通方法

name_list = [‘小明’, ‘小红’, ‘小青’]
for i in range(0, len(name_list)):
print(i, name_list[i])

2.（常用）枚举 enumerate(可被迭代的对象)

for index, name in enumerate(name_list):
print(index, name)

for index, attr in enumerate({‘name’: ‘小明’, ‘age’: 10, ‘sex’: ‘male’}):
print(index, attr)