0、numpy：
- 在计算机中会把数学当中的矩阵叫做数组，在很多应用中的表格也就是通过矩阵表示的，所以numpy广泛用于机器学习，数据分析，和图像处理领域。
1、numpy常用方法和函数：
- 前言：在使用numpy创建数组之前必须先导入模块：import numpy as np
- 创建一维数组：arr1 = np.array([1, 2, 3])
- 创建二维数组：arr4 = np.array([[1, 2], [3, 4]])
- 查看数组维度：arr4.ndim
- 查看元素数量：arr4.size
- 查看元素形状：arr4.shape
- 查询元素的数据类型：arr4.dtype
- 查看对象的数据类：type(arr4)
- astype()生成新数组，原数组不变：arr5.astype(float)
- 创建指定维度和数据类型的空数组：np.empty([2, 3], dtype=int)
- 三个元素通过零填充：np.zeros(3)
- 三个元素通过1填充：np.ones(3)
- 创建指定维度和指定值填充的数组（3维通过8填充）：np.full([3, 3], 8)
- 创建指定步长的一维数组：np.arange(1, 12, 1) //array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
- 7500-10000，6等分，结束点包含（等差数组）：np.linspace(7500, 10000, 6)
- 以2为底数，从2的1次方到2的10次方，5个元素：np.logspace(1, 10, 5, base=2)
- [0, 1)的一维数组，5个元素，小数：np.random.rand(5)
- [0, 1)的二维数组，2行5列，小数：np.random.rand(2, 5)
- [0, 10)的二维数组，2行3列，小数：np.random.uniform(0, 10, [2, 3])
- 满足正态分布的一维数组，100个元素，均值为0，标准差为1：np.random.normal(0, 1, 100)
- [1, 3)的一维数组，10个元素，整数：np.random.randint(1, 3, 10)
- [0, 5)的二维数组，2行5列，整数：np.random.randint(0, 5, size=[2, 5])
- 随机种子：作用是重复运行代码而数值不变，必须与随机函数在同一单元格
np.random.seed(2)
np.random.randint(1, 10, 3)
- 打乱数组：arr = np.array([1, 2, 3, 4, 5])；np.random.shuffle(arr)
- nan表示缺失值：arr = np.array([1, 2, np.nan, 4])
- 查看缺失值：np.isnan(arr)
//array([False, False, True, False])
- 填充缺失值：arr[np.isnan(arr)] = 0
//array([1., 2., 0., 4.])
- 删除重复值：
arr = np.array([1, 2, 2, 3, 3, 3, 4])
np.unique(arr)
//array([1, 2, 3, 4])
- 通过列表创建数组：
lst2 = [[1, 2], [3, 4]]
np.asarray(lst2)
- 通过字符串创建数组（这种方法是首先将字符串转为列表，然后把列表转为数组，直接将字符串转数组则数组中只有一个元素）：
string = ‘python’
np.asarray(list(string))
- 通过可迭代对象创建数组：
it = iter([1, 2, 3, 4, 5])
np.fromiter(it, dtype=int)
- 以指定值填充：
np.full_like([[1, 2], [3, 4]], 6)
//array([[6, 6],[6, 6]]) 二维数组
- 数组四则运算：+、-、*、/、**、这些运算都是两个形状相同的数组进行的对应元素之间的运算
- 数组取整：//
- 取余/取模：%
- 求相反数：-数组名
- 求倒数：1/数组名
- 比较运算：>=、==、<=、！=、这些运算都是两个形状相同的数组进行的对应元素之间的运算
- 标量运算：数组中每个元素和数值之间的运算（数组名 运算符号 数值）
- 集合运算：求a和b的交集（np.intersect1d(a, b)）、求a和b元素的并集（np.union1d(a, b)）、a数组的每个元素是否包含在b数组内（np.in1d(a, b)）这里的1d代表1维、差集，a数组减去b数组的元素（np.setdiff1d(a, b)）；不要求数组和b数组形状一样，集合运算只是两个数组元素的集合之间的运算。
2、数组切片：
- 前言：列表也能切片，但是列表的计算性能没有数组好。
2.1、一维数组切片规则：正向索引从0开始，反向索引从-1开始，索引是左闭右开的
- 切片操作：arr[start:stop:step]
start，开始值
stop，结束值
step，步长值
arr = np.array([1, 2, 3, 4])
arr[0:2] #array([1, 2])
arr = np.arange(10) #array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
arr[::-1] #array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])
2.2、二维数组切片规则：
arr = np.array(
[[0, 1, 2, 3],
[4, 5, 6, 7],
[8, 9, 10, 11]]) # 创建二维数组
lst = [[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]] # 创建二维列表
arr[1] # array([4, 5, 6, 7])
lst[1][2] # 6
# 二维数组切片
# 逗号前面表示行操作
# 逗号后面表示列操作
arr[:2, 1:]
# array([[1, 2, 3],
# [5, 6, 7]])
3、数组重塑（需要掌握）：
3.1、reshape重塑：reshape(行数, 列数)
# 一维数组
arr1 = np.arange(6) # array([0, 1, 2, 3, 4, 5])
arr1.reshape(2, 3) # array([[0, 1, 2],[3, 4, 5]])
# 将n个一维数组重塑为n行数组
arr1.reshape(-1, 1) # 相当于arr1.reshape(6, 1)
# 二维师叔祖
arr2 = np.array(
[[0, 1, 2],
[3, 4, 5]])
arr10 = arr2.reshape(3, 2) #array([[0, 1], [2, 3], [4, 5]])
# 将高维数组重塑为一维数组叫做扁平化
arr2.reshape(-1) # array([0, 1, 2, 3, 4, 5])
3.2、resize重塑
- 重塑前后的元素个数可以不一致
- 重塑后会修改原数组
- 重塑后比原尺寸小：自动截断
- 重塑后比原尺寸大：以0填充
3.3、行列转置
arr6 = np.arange(12).reshape(3, 4)
'''
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
'''
# transpose
arr6.T # T是数组的一个性质
'''
array([[ 0, 4, 8],
[ 1, 5, 9],
[ 2, 6, 10],
[ 3, 7, 11]])
'''
arr6.transpose() # transpose是一个函数
'''
array([[ 0, 4, 8],
[ 1, 5, 9],
[ 2, 6, 10],
[ 3, 7, 11]])
'''
4、数组的增删改查：
4.1、合并数组：将多个数组合并为一个数组
n1 = np.array(
[[1, 2],
[3, 4],
[5, 6]])
n2 = np.array(
[[10, 20],
[30, 40],
[50, 60]])
# 左右合并
np.hstack((n1, n2))
np.column_stack((n1, n2))
'''
array([[ 1, 2, 10, 20],
[ 3, 4, 30, 40],
[ 5, 6, 50, 60]])
'''
# 上下合并
np.vstack((n1, n2))
np.row_stack((n1, n2))
'''
array([[ 1, 2],
[ 3, 4],
[ 5, 6],
[10, 20],
[30, 40],
[50, 60]])
'''
4.2、拆分数组：将一个数组拆分为多个子数组
n3 = np.arange(24).reshape(6, 4)
'''
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23]])
'''
# 左右拆分
np.hsplit(n3, 2)
# np.hsplit(n3, 2)[0] # 拆分的第一部分
# np.hsplit(n3, 2)[1] # 拆分的第二部分
'''
[array([[ 0, 1],
[ 4, 5],
[ 8, 9],
[12, 13],
[16, 17],
[20, 21]]),
array([[ 2, 3],
[ 6, 7],
[10, 11],
[14, 15],
[18, 19],
[22, 23]])]
'''
# 上下拆分
np.vsplit(n3, 2)
# np.vsplit(n3, 2)[0]
# np.vsplit(n3, 2)[1]
'''
[array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]]),
array([[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23]])]
'''
4.3、新增数据
aa = np.arange(6).reshape(2, 3)
'''
array([[0, 1, 2],
[3, 4, 5]])
'''
# axis=0: 行
# axis=1: 列
np.append(aa, [[6, 7, 8]], axis=0)
'''
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
'''
np.append(aa, [[10], [20]], axis=1)
'''
array([[ 0, 1, 2, 10],
[ 3, 4, 5, 20]])
'''
4.4、删除数据
ad = np.arange(6).reshape(2, 3)
'''
array([[0, 1, 2],
[3, 4, 5]])
'''
np.delete(ad, 1, axis=0)
'''
array([[0, 1, 2]])
'''
np.delete(ad, 0, axis=1)
'''
array([[1, 2],
[4, 5]])
'''
# 还可以删除多行或者多列
np.delete(ad, [0,1], axis=1)
'''
array([[2],
[5]])
'''
4.5、修改数组和条件判断
a1 = np.arange(6).reshape(2, 3)
# 修改行
a1[1] = [0, 0, 0]
# 修改列
a1[:, 1] = [0, 0]
# 修改0行1列的元素值为2
a1[0:,1] = 2
# 条件判断
np.where(a1 > 1, 6, 9)
'''
array([[9, 9, 6],
[6, 6, 6]])
'''
# 筛选大于1的元素
a1[np.where(a1 > 1)]
# array([2, 3, 4, 5])
4.6、数组赋值/视图/复制/深拷贝
# 数组赋值(相当于起了别名，没有拷贝，is是身份运算)
a = np.arange(10)
b = a
b is a # True
a[0] = 8
b # array([8, 1, 2, 3, 4, 5, 6, 7, 8, 9])
# 视图（快捷方式，浅拷贝，不同的数组对象共享同一数据）
a = np.arange(10)
c = a.view()
c is a # False
a[0] = 8 # array([8, 1, 2, 3, 4, 5, 6, 7, 8, 9])
# 数组复制（浅拷贝、不同的对象和数据）
a = np.arange(10)
d = a.copy()
d is a # False
a[0] = 8
d # array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
# python中深拷贝只有一种
import copy
d = copy.deepcopy(a)
- 在Python中，复制一个变量有两种方式：深拷贝和浅拷贝。当使用浅拷贝（shallow copy）时，创建的新对象与原始对象共享内存，也就是说，如果修改其中一个对象，另一个对象也会改变。而使用深拷贝（deep copy）时，完全复制一份独立的对象，包含了对象及其所有子对象的完整拷贝，修改其中任意一个对象，都不会对其他对象产生影响。数组复制的浅拷贝虽然修改一个对象，另一个对象不会发生改变，原因不是复制了一份独立的对象，而是在独立对象之上做了封装。如下：
总结：以上知识都是numpy中的一些常用方法，做笔记方便日后补充和查找。
