一、内置数据结构
1. 列表
1.1 创建列表
list1 = [1, 2, 'aa']
list2 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
list3 = []
print(list1)
print(list2)
print(list3)
1.2 增加元素
list1 = []
# 1. 普通添加元素
list1.append(1)
list1.append(2)
list1.append(3)
print(list1)
# 2. 扩展列表，将新列表的元素添加到当前列表中
list1.extend(['a', 'b', 'c'])
print(list1)
# 3. 指定位置插入元素
list1.insert(0, '---')
print(list1)
1.3 删除元素
list1 = [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
# 1. 删除某个值的第一个匹配项
list1.remove(5)
# 2. 删除最后一个元素
list1.pop()
# 3. 删除指定 index 的元素，如果为 -1、-2 这种，则是删除倒数第 n 个元素
list1.pop(1)
list1.pop(-1)
1.4 修改元素
修改元素，下面演示的内容涉及到地址引用的修改问题。
list1 = [1, 2, 'aa']
list2 = list1
list2[0] = 3
list2[2] = 'bb'
print(list1)
1.5 查找元素
list1 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
# 1. 根据索引查找元素
print(list1[0])
# 2. 根据元素查找索引，若元素不存在则报错
print(list1.index([4, 5, 6]))
# ========================================================================
# [start:end:step] ======>>>>>> [start, end)
list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# 1. 第0个到最后一个
print(list1[0:])
# 2. 第0个到第2个
print(list1[:3])
# 3. 第1个到第1个
print(list1[1:2])
# 4. 第0个到最后一个，间隔为2
print(list1[0::2])
1.6 列表排序
反转列表，改变的是列表本身，无返回值。
list1 = [1, 1, 2, 3, 3, 2, 5, 5, 5]
print(list1)
list1.reverse()
print(list1)
升降排序，改变的是列表本身，无返回值。
# - reverse=False 升序
# - reverse=True 降序
list1 = [1, 1, 2, 3, 3, 2, 5, 5, 5]
print(list1)
list1.sort(reverse=False)
print(list1)
list1.sort(reverse=True)
print(list1)
2. 元组
2.1 创建元组
元组（tuple）被创建后就不能对其进行修改，类似字符串，所以当定义一个tuple时，在定义的时候，tuple 的元素就必须被确定下来。
元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用。
tuple1 = (1,) # 需要加括号，否则括号会被当作运算符使用
tuple2 = (1, 2, 3)
tuple3 = ((1, 2, 3), (1, 2, 3), (1, 2, 3))
2.2 增加元素
因为元组的不可变性，所有不能更新元组。
2.3 删除元素
因为元组的不可变性，所有不能更新元组。
2.4 修改元素
因为元组的不可变性，所有不能更新元组。
但是有一个特殊情况，只要元组中的元素是可变的，就可以直接更改其元素，这是因为元组不可变指的是每个元素的指向不可变。
t1 = (1, 2, 3, [4, 5, 6])
t1[3][0] = 9
print(t1) # (1, 2, 3, [9, 5, 6])
2.5 查找元素
tu = ([1, 2, 3], [4, 5, 6], [7, 8, 9])
# 1. 根据索引查找元素
print(tu[0])
# 2. 根据元素查找索引，若元素不存在则报错
print(tu.index([4, 5, 6]))
# 3. 切片
print(tu[::-1])
print(tu[0:2])
3. 字典
3.1 创建字典
dic1 = {
}
dic2 = {
'a': '11',
'b': '22',
}
dic3 = dict()
dic4 = {
}
3.2 增加元素
dic = {
}
dic['a'] = 1
dic['b'] = 2
dic['b'] = 3
print(dic)
3.3 删除元素
dic = {
'a': 1,
'b': 2,
'c': 3,
}
del dic['a']
dic.pop("b")
print(dic)
3.4 修改元素
dic = {
'a': 1,
'b': 3
}
dic['a'] = '11111'
dic['b'] = 'bbbbb'
print(dic['a'])
print(dic['b'])
3.5 查找元素
dic = {
'a': 1, 'b': 2}
print(dic.get('a'))
print(dic.get('b'))
print(dic.get('c')) # 键'c'不存在，返回None
print(dic['a'])
print(dic['b'])
print(dic['c']) # 键'c'不存在，报错
4. 集合
4.1 创建集合
在创建空集合的时候只能使用 s = set() ，因为 s = {} 创建的是空字典。
s1 = set()
s2 = {
'aa', 'bb', 'aa'}
4.2 增加元素
s1 = {
1, 2, 3}
s1.add("dddd")
print(s1)
4.3 删除元素
# 1. 移除集合中的指定元素，如果元素不存在，则报错
s2 = {
1, 9, 2, 3}
s2.remove(9)
print(s2)
# 2. 移除集合中的指定元素，如果元素不存在，则不做任何操作，不报错
s3 = {
1, 9, 2, 3}
s3.discard(19)
print(s3)
# 3. 随机移除一个元素
s4 = {
1, 2, 3, 4, 5, 'a', '--'}
s4.pop()
s4.pop()
print(s4)
4.4 修改元素
因为集合是无序的，所有不能随机修改元素。
4.5 查找元素
因为集合是无序的，所有不能随机访问元素。
4.6 集合的运算
# 1. 判断两个集合是否不相交
print({
1, 2}.isdisjoint({
2, 3}))
print({
1, 2}.isdisjoint({
6, 3}))
# 2. 返回两个集合的交集
# -- set.intersection(set1, set2 ...)
# -- set1 & set2 返回两个集合的交集
print({
1, 2, 3}.intersection({
5, 6, 7}))
print({
1, 2, 3} & {
3, 4, 5, 6, 7})
# 3. 返回两个集合的并集
# -- set.union(set1, set2...)
# -- set1 | set2
print({
1, 2, 3}.union({
"aaa", 1}))
print({
1, 2, 3} | {
"aaa", 1})
# 4. 判断集合是不是被其他集合包含
# -- set.issubset(set)
# -- set1 <= set2
print({
1, 2, 3}.issubset({
1, 2, 3}))
print({
1, 2, 3} <= {
1, 2, 3})
# 5. 用于判断集合是不是包含其他集合
# -- set.issuperset(set)
# -- set1 >= set2
print({
1, 2, 3}.issuperset({
1, 2, 3}))
print({
1, 2, 3, 4} >= {
1, 2, 3} >= {
1, 2, 3})
print({
1, 2, 3, 4} >= {
1, 2, 9, 3} >= {
1, 2, 3})
5. 容器的其余常用操作
5.1 清空容器
列表
list1 = [1, 2, 3]
print(list1)
list1.clear()
print(list1)
元组
由于元组的不可变性，所有不能更新元组。
字典
dict1 = {
'name': 'jack',
'pass': 'jack123456',
}
print(dict1)
dict1.clear()
print(dict1)
集合
set1 = {
1, 2, 3, 3} # 集合可以自动去重
print(set1)
set1.clear()
print(set1)
5.2 遍历容器
列表
list1 = [1, 1, 2, 3, 3, 2, 5, 5, 5]
for i in list1:
print(i)
元组
tu = (1, 9, 1, 2, 'puuu')
for i in tu:
print(i)
字典
dic = {
'a': 1,
'b': 2,
'c': 3,
}
keys = dic.keys() # 键
values = dic.values() # 值
items = dic.items() # 键值对
for item in items:
print(item)
items = list(items)
print(items[1])
print(items[1][1])
集合，每一次的遍历顺序都不能保证一致
for i in {
'Google', 'Baidu', 'Taobao'}:
print(i)
5.3 容器长度
列表
list1 = [1, 1, 2, 3, 3, 2, 5, 5, 5]
print(len(list1))
元组
tus = (1, 2, 1, 2, 'puuu')
print(len(tus))
字典
dic = {
'a': 1,
'b': 3
}
print(len(dic))
集合
set1 = {
1, 2, 3, 'd', 1, 3}
print(len(set1))
5.4 判断某一元素是否存在容器中
列表
list1 = [1, 1, 2, 3, 3, 2, 5, 5, 5]
print(1 in list1)
print(1 not in list1)
元组
tus = (1, 2, 1, 2, 'puuu')
print(1 in tus)
print(1 not in tus)
字典
dic = {
'a': 1,
'b': 3
}
print('a' in dic)
print('a' not in dic)
集合
set1 = {
1, 2, 3, 'd', 1, 3}
print(1 in set1)
print(1 not in set1)
5.5 统计容器中某一元素的数量
列表
list1 = [1, 1, 2, 3, 3, 2, 5, 5, 5]
print(list1.count(1))
元组
tus = (1, 2, 1, 2, 'puuu')
print(tus.count(1))
字典
元素的数量为 0 或 1。
集合
元素的数量为 0 或 1。
5.6 复制容器
列表
list1 = [1, 2, 3]
list2 = list1
list3 = list1.copy()
list1[0] = 'abc'
print(list2) # ['abc', 2, 3]
print(list3) # [1, 2, 3]
元组
元组无 copy 方法。
字典
dic1 = {
'a': 1,
'b': 2,
}
dic2 = dic1
dic3 = dic1.copy()
dic1['a'] = 6
print(dic2)
print(dic3)
集合
s1 = {
1, 2, 3, 4, 5, 'a', '--'}
s2 = s1
s3 = s1.copy()
s1.remove(1)
print(s2)
print(s3)
5.7 运算符
列表、元组
# 1. 【'=='】只有元素、元素位置都相同时才返回 True
print([1, 2] == [1, 2])
print((1, 2) == (1, 2))
# 2. 【'+'】两个容器合并成一个新的容器
print([1, 2] + [2, 2, 6, 8])
print((1, 2) + (2, 2, 6, 8))
# 3. 【'*'】将容器复制 n 遍，生产新的容器
print((1, 2, 3) * 2)
print([1, 2, 3] * 2)
6. 容器的互相转换
6.1 转换为列表
# 集合-->列表
li1 = list({
1， 2， 3， 4})
# 元组-->列表
li2 = list((1， 2， 3， 4))
# 字典-->列表【把所有的键组成一个列表】
li3 = list({
'a': 1, 'b': 2, 'c': 3, 'd': 4})
6.2 转换为元组
# 集合-->元组
tu1 = tuple({
1， 2， 3， 4})
# 列表-->元组
tu2 = tuple([1， 2， 3， 4])
# 字典-->元组【把所有的键组成一个元组】
tu3 = tuple({
'a': 1, 'b': 2, 'c': 3, 'd': 4})
6.3 转化为集合
# 列表-->集合
se1 = set([1, 2, 3, 4, 4, 5, 5, 6, 6, 6])
# 元组-->集合
se2 = set((1, 2, 3, 4, 4, 5, 5, 6, 6, 6))
# 字典-->集合【把所有的键组成一个集合】
se3 = set({
'a': 1, 'b': 2, 'c': 3, 'd': 4})
6.4 转化为字典
# 元组-->字典
d1 = dict((('apple', 4139), ('peach', 4127), ('cherry', 4098)))
# 列表-->字典
d2 = dict([('apple', 4139), ('peach', 4127), ('cherry', 4098)])
# 集合-->字典
d3 = dict({
('apple', 4139), ('peach', 4127), ('cherry', 4098)})
二、NumPy
NumPy 是 Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。
1. 创建数组
import numpy as np
data = np.array([1, 2, 3, 4, 0])
print(data)
2. 根据原矩阵构 m 行n 列的矩阵
import numpy as np
data = np.array([1, 2, 3, 4, 0])
m = 3
n = 2
data = np.tile(data, (m, n))
print(data)
3. 矩阵相加减
import numpy as np
data = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
temp = [
[1, 1, 1],
[1, 1, 1],
[1, 1, 1],
]
data = np.array(data)
print(data + temp)
print(data - temp)
4. 对矩阵的每一个元素做数学运算
import numpy as np
data = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
data = np.array(data)
print(data ** 2)
print(data ** 0.5)
print(data - 1)
print(data * 10)
5. 矩阵沿着列、行的方向求和
import numpy as np
data = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
data = np.array(data)
print('验着列求和：', data.sum(axis=0))
print('验着行求和：', data.sum(axis=1))
6. 一维数组排序
import numpy as np
data = np.array([1, 6, 8, 9, 2])
print('从小到大排列：', np.sort(data))
print('从大到小排列：', np.sort(data)[::-1])
7. 二维数组排序
import numpy as np
data = [
[7, 8, 9],
[1, 2, 3],
[5, 6, 4],
]
print('按行从小到大排列：\n', np.sort(data, axis=1))
print('按列从小到大排列：\n', np.sort(data, axis=0))
print('按行列从小到大排列：\n', np.sort(np.sort(data, axis=1), axis=0))