[人工智能自学] Python包学习-numpy
由于我并非该专业，我在学习之前google了几个比较靠前的人工智能学习路径：
https://github.com/tangyudi/Ai-Learn
https://github.com/apachecn/ai-roadmap/blob/master/ai-union-201904/README.md
https://marlous.github.io/2019/01/18/%E4%BA%BA%E5%B7%A5%E6%99%BA%E8%83%BD%EF%BC%88AI%EF%BC%89%E7%9B%B8%E5%85%B3%E5%AD%A6%E4%B9%A0%E8%B7%AF%E5%BE%84%E3%80%81%E8%B5%84%E6%96%99%E6%95%B4%E7%90%86/
本贴为自学笔记，来源均会在后续贴出。
使用方法：与其挨个看不如把大框架抛到ai里让它给你讲。。。
NumPy
参考的教程：
- https://www.runoob.com/numpy/numpy-tutorial.html
- https://numpy123.com/article/basics/python_numpy_tutorial/
- https://github.com/whyscience/CS231n-Note-Translation_CN/blob/master/CS231n%201%EF%BC%9APython%20Numpy%E6%95%99%E7%A8%8B.md
主要参考菜鸟教程的numpy教材。
ndarray
N 维数组对象 ndarray，它是一系列同类型数据的集合
ndarray 对象是用于存放同类型元素的多维数组。
ndarray 中的每个元素在内存中都有相同存储大小的区域。
一个指向数据（内存或内存映射文件中的一块数据）的指针。
数据类型或 dtype，描述在数组中的固定大小值的格子。
一个表示数组形状（shape）的元组，表示各维度大小的元组。
一个跨度元组（stride），其中的整数指的是为了前进到当前维度下一个元素需要"跨过"的字节数。
创建一个 ndarray：
numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
object参数
必填参数，用于指定要转换为numpy数组的数据。可以是列表、元组等序列类型，也可以是其他的numpy数组等。
一维的数组：
import numpy as np
a = np.array([1,2,3])
print (a)
结果：
[1 2 3]
import Numpy as np
array = np.arange(20)
array
结果：
array([0, 1, 2, 3, 4,
5, 6, 7, 8, 9,
10, 11, 12, 13, 14,
15, 16, 17, 18, 19])
多维：
# 多于一个维度
import numpy as np
a = np.array([[1, 2], [3, 4]])
print (a)
结果：
[[1 2]
[3 4]]
dtype参数
import numpy as np
a = [1, 2, 3]
np_array_float = np.array(a, dtype = float)
print(np_array_float)
结果：
[1. 2. 3.]
copy参数
默认值为True，表示对object进行复制。如果设置为False，在某些情况下（例如object本身就是一个numpy数组），可能会直接使用原始数据而不进行复制，这可以节省内存，但可能会导致意外的修改。
TRUE：
import numpy as np
a = np.array([1, 2, 3])
b = np.array(a, copy=True)
a[0]=10
print(b)
结果：
[1 2 3]
FALSE:
import numpy as np
a = np.array([1, 2, 3])
b = np.array(a, copy=False)
a[0]=10
print(b)
结果：
[10 2 3]
order参数
用于指定数组在内存中的存储顺序。
常见的值有’C’（按行存储，C - style）和’F’（按列存储，Fortran - style）
import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6]], order='C')
print(a)
结果：
[[1 2 3]
[4 5 6]]
ndmin运用
用于指定返回的数组的最小维数
import numpy as np
a = [1, 2, 3]
np_array_ndmin_2 = np.array(a, ndmin = 2)
print(np_array_ndmin_2)
[[1 2 3]]
数组属性
NumPy 数组的维数称为秩（rank），秩就是轴的数量，即数组的维度，一维数组的秩为 1，二维数组的秩为 2，以此类推。
在 NumPy中，每一个线性的数组称为是一个轴（axis），也就是维度（dimensions）。比如说，二维数组相当于是两个一维数组，其中第一个一维数组中每个元素又是一个一维数组。所以一维数组就是 NumPy 中的轴（axis），第一个轴相当于是底层数组，第二个轴是底层数组里的数组。而轴的数量——秩，就是数组的维数。
求维度数量/rank ndim
import numpy as np
a = np.arange(24)
print (a.ndim) # a 现只有一个维度
# 现在调整其大小
b = a.reshape(2,4,3) # b 现在拥有三个维度
print (b.ndim)
结果：
1
3
维度 shape
a = np.array([[1,2,3],[4,5,6]])
print (a.shape)
结果：
(2, 3)
调整数组大小 shape/reshape
shape 两种作用
a = np.array([[1,2,3],[4,5,6]])
a.shape = (3,2)
print (a)
结果：
[[1 2]
[3 4]
[5 6]]
返回数组中每一个元素的大小itemsize
例如，一个元素类型为 float64 的数组 itemsize 属性值为 8(float64 占用 64 个 bits，每个字节长度为 8，所以 64/8，占用 8 个字节），又如，一个元素类型为 complex32 的数组 item 属性为 4（32/8）
import numpy as np
# 数组的 dtype 为 int8（一个字节）
x = np.array([1,2,3,4,5], dtype = np.int8)
print (x.itemsize)
# 数组的 dtype 现在为 float64（八个字节）
y = np.array([1,2,3,4,5], dtype = np.float64)
print (y.itemsize)
结果：
1
8
.flags 返回 ndarray 对象的内存信息
x = np.array([1,2,3,4,5])
print (x.flags)
C_CONTIGUOUS : True
F_CONTIGUOUS : True
OWNDATA : True
WRITEABLE : True
ALIGNED : True
WRITEBACKIFCOPY : False
UPDATEIFCOPY : False
创建数组
创建一个指定形状（shape）、数据类型（dtype）且未初始化empty
numpy.empty(shape, dtype = float, order = 'C')
创建空数组：
x = np.empty([3,2], dtype = int)
print (x)
结果：
[[ 6917529027641081856 5764616291768666155]
[ 6917529027641081859 -5764598754299804209]
[ 4497473538 844429428932120]]
从 Python 序列创建数组
直接将 Python 列表转换为numpy数组
import numpy as np
my_list = [1, 2, 3, 4, 5]
np_array = np.array(my_list)
print(np_array)
结果：
[1 2 3 4 5]
元组也可以
创建特定形状和数据类型的数组
np.zeros
zero_array = np.zeros((3, 4), dtype = float)
print(zero_array)
[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]
np.ones
创建一个形状为(2, 3)的全一数组，数据类型为int
one_array = np.ones((2, 3), dtype = int)
print(one_array)
[[1 1 1]
[1 1 1]]
np.full
创建一个形状为(3, 3)的数组，所有元素都是5
full_array = np.full((3, 3), 5)
print(full_array)
[[5 5 5]
[5 5 5]
[5 5 5]]
创建具有一定规律的数组
等差数列
创建一个从0开始，以2为步长，到10结束（不包括10）的数组。
arange_array = np.arange(0, 10, 2)
print(arange_array)
[0 2 4 6 8]
等比数列
np.geomspace（几何级数）或np.logspace（对数级数）函数。
例如，np.geomspace创建一个从1到1000的等比数列，包含4个元素
从已有的数组创建新数组
切片创建
original_array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
sliced_array = original_array[1:3, 0:2]
print(sliced_array)
[[4 5]
[7 8]]
复制创建
copied_array = np.copy(original_array)
print(copied_array)
[[1 2 3]
[4 5 6]
[7 8 9]]
创建随机数组
均匀分布随机数组
np.random.rand函数可以创建一个指定形状的数组，数组元素服从[0, 1)区间上的均匀分布。例如，创建一个形状为(2, 3)的均匀分布随机数组
rand_array = np.random.rand(2, 3)
print(rand_array)
[[0.123456 0.789101 0.456789]
[0.765432 0.234567 0.987654]]
正态分布随机数组
使用np.random.randn函数可以创建一个指定形状的数组，数组元素服从标准正态分布（均值为0，标准差为1）。例如，创建一个形状为(3, 3)的正态分布随机数组。
randn_array = np.random.randn(3, 3)
print(randn_array)
[[ 0.123 -0.456 0.789]
[-1.234 0.567 -0.890]
[ 0.987 -0.123 0.456]]
从数值范围创建数组
numpy.arange(start, stop, step, dtype)
广播(Broadcast)
numpy 对不同形状(shape)的数组进行数值计算的方式， 对数组的算术运算通常在相应的元素上进行。
如果两个数组 a 和 b 形状相同，即满足 a.shape == b.shape，那么 a*b 的结果就是 a 与 b 数组对应位相乘。这要求维数相同，且各维度的长度相同。
import numpy as np
a = np.array([1,2,3,4])
b = np.array([10,20,30,40])
c = a * b
print (c)
[ 10 40 90 160]
如果维度地长度不同，则触发广播机制
4x3 的二维数组与长为 3 的一维数组相加，等效于把数组 b 在二维上重复 4 次再运算
import numpy as np
a = np.array([[ 0, 0, 0],
[10,10,10],
[20,20,20],
[30,30,30]])
b = np.array([0,1,2])
print(a + b)
[[ 0 1 2]
[10 11 12]
[20 21 22]
[30 31 32]]
广播的规则:
- 让所有输入数组都向其中形状最长的数组看齐，形状中不足的部分都通过在前面加 1 补齐。
- 输出数组的形状是输入数组形状的各个维度上的最大值。
- 如果输入数组的某个维度和输出数组的对应维度的长度相同或者其长度为 1 时，这个数组能够用来计算，否则出错。
- 当输入数组的某个维度的长度为 1 时，沿着此维度运算时都用此维度上的第一组值。
NumPy 字节交换
在计算机存储数据时，数据的字节顺序（Byte Order）有两种常见的方式：大端序（Big - endian）和小端序（Little - endian）。大端序是指数据的高位字节存于低地址，小端序则是数据的低位字节存于低地址。numpy中的字节交换主要是用于在这两种字节顺序之间进行转换。
dtype对象的newbyteorder方法
用于创建一个新的数据类型对象，其字节顺序与原数据类型对象不同。它接受一个参数，可以是’<‘（小端序）、’>‘（大端序）、’=‘（字节顺序不变）、’|'（非字节交换）
import numpy as np
a = np.array([1, 2, 3], dtype='>i4') # 创建一个大端序的32位整数数组
print(a.dtype)
b = a.dtype.newbyteorder('<')
print(b)
i4
<i4
numpy.ndarray.byteswap函数
import numpy as np
a = np.array([1, 2, 3], dtype='int16')
print("Before byteswap:", a)
a.byteswap(True)
print("After byteswap:", a)
Before byteswap: [1 2 3]
After byteswap: [256 512 768]