python之数据分析Numpy -4
python之数据分析Numpy
- 一：Numpy 介绍
- 二：功能函数
-
-
- 1，array 数组
- 2，数据类型对象 (dtype)
- 3,NumPy 数组属性
- 4，新建数组
- 5,NumPy 从已有的数组创建数组
- 6，NumPy 切片和索引
- 7,NumPy 广播(Broadcast)
- 8， numpy.nditer 迭代数组
- 9,Numpy 数组操作
- 10,连接数组
- 11,分割数组
- 12,数组元素的添加与删除
-
- 三：NumPy 位运算
- 四：NumPy 字符串函数
- 五,NumPy 数学函数
- 六,NumPy 算术函数
- 七,NumPy 统计函数
- 八,NumPy 排序、条件刷选函数
- 九，NumPy 字节交换
- 十，NumPy 副本、视图
- 十一,NumPy 矩阵库(Matrix)
- !!!-NumPy IO
一：Numpy 介绍
NumPy(Numerical Python) 是 Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。
NumPy 是一个运行速度非常快的数学库，主要用于数组计算，包含：
强大的N维数组对象 ndarray
广播功能函数
整合 C/C++/Fortran 代码的工具
线性代数、傅里叶变换、随机数生成等功能
二：功能函数
1，array 数组
创建多维数组，ndarray,只需调用 NumPy 的 array 函数即可:
numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
....................................
object:数组或嵌套的数列
dtype: 数组元素的数据类型，可选
copy: 对象是否需要复制，可选
order: 创建数组的样式，C为行方向，F为列方向，A为任意方向（默认）
subok: 默认返回一个与基类类型一致的数组
ndmin: 指定生成数组的最小维度
创建数组
a =np.random.randint(4,6,size=(4,4))
print(a)
..............................................
[[5 5 5 5]
[4 5 5 5]
[5 5 4 5]
[5 5 4 5]]
...............................................
b =np.array(a,ndmin =3)
print(b)
............................................
[[[5 5 5 5]
[4 5 5 5]
[5 5 4 5]
[5 5 4 5]]]
..............................................
1,先创建一个二维数组,ndmin =3指定最小维度3，即b 为三维数据
对象 ndarray
以 0 下标为开始进行集合中元素的索引。
用于存放同类型元素的多维数组
每个元素在内存中都有相同存储大小的区域
内容组成：
指向数据（内存或内存映射文件中的一块数据）的指针
数据类型或 dtype，描述在数组中的固定大小值的格子
一个表示数组形状（shape）的元组，表示各维度大小的元组
个跨度元组（stride），其中的整数指的是为了前进到当前维度下一个元素需要"跨过"的字节数
2，数据类型对象 (dtype)
numpy.dtype(object, align, copy)
.......................................
object - 要转换为的数据类型对象
align - 如果为 true，填充字段使其类似 C 的结构体。
copy - 复制 dtype 对象 ，如果为 false，则是对内置数据类型对象的引用
import numpy as np
dt = np.dtype([('age',np.int8)])
a = np.array([(10,),(20,),(30,)], dtype = dt)
print(a['age'])
...................................
[10 20 30]
..................
下面的示例定义一个结构化数据类型 student，包含字符串字段 name，整数字段 age，及浮点字段 marks，并将这个 dtype 应用到 ndarray 对象。
import numpy as np
student = np.dtype([('name','S20'), ('age', 'i1'), ('marks', 'f4')])
print(student)
...........................
('name','S20') 字符串 20字节
('age', 'i1') # int8, int16, int32, int64 四种数据类型可以使用字符串 'i1', 'i2','i4','i8' 代替
('marks', 'f4') 浮点型
........................................
a = np.array([('abc', 21, 50),('xyz', 18, 75)], dtype = student)
print(a)
..................................................
[(b'abc', 21, 50.) (b'xyz', 18, 75.)]
| 属性 | 说明 |
|---|---|
| b | 布尔型 |
| i | (有符号) 整型 |
| u | 无符号整型 intege |
| b | 布尔型 |
| f | 浮点型 |
| c | 复数浮点型 |
| m | timedelta（时间间隔 |
| O | (Python) 对象 |
| S, a | (byte-)字符串 |
| U | Unicode |
| V | 原始数据 (void) |
3,NumPy 数组属性
NumPy 数组的维数称为秩（rank），秩就是轴的数量，即数组的维度，一维数组的秩为 1，二维数组的秩为 2，
每一个线性的数组称为是一个轴（axis），也就是维度（dimensions）。二维数组就是包含2个一维数组，
axis=0，表示沿着第 0 轴进行操作，即对每一列进行操作；axis=1，表示沿着第1轴进行操作，即对每一行进行操作
| 属性 | 说明 |
|---|---|
| ndarray.ndim | 秩，即轴的数量或维度的数量 |
| ndarray.shape | 数组的维度，对于矩阵，n 行 m 列 |
| ndarray.size | 数组元素的总个数，相当于 .shape 中 n*m 的值 |
| ndarray.dtype | ndarray 对象的元素类型 |
| ndarray.itemsize | ndarray 对象中每个元素的大小，以字节为单位 |
| ndarray.flags | ndarray 对象的内存信息 |
| ndarray.real | ndarray元素的实部 |
| ndarray.imag | ndarray 元素的虚部 |
| ndarray.data | 包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性。 |
ndarray.ndim
........................
a = np.arange(1)
print(a.ndim)
.................................
维度
1
.......................
# 现在调整其大小
b = a.reshape(2,4,3)
............................
a = np.array([[1,2,3],[4,5,6]])
print (a.shape)
...........................
(2, 3) #返回元组的长度为数据维度，元组x,y分别代表行于列数
..........................
a = np.array([[1,2,3],[4,5,6]])
a.shape = (3,2)#改变元组的结构
print (a)
.....................
[[1 2]
[3 4]
[5 6]]
....................
ndarray.itemsize 以字节的形式返回数组中每一个元素的大小
................................................
# 数组的 dtype 现在为 float64（八个字节）
y = np.array([1,2,3,4,5], dtype = np.float64)
print (y.itemsize)
........................
8
..............................
ndarray.flags 返回 ndarray 对象的内存信息
................................
| 属性 | 描述 |
|---|---|
| C_CONTIGUOUS | © 数据是在一个单一的C风格的连续段中 |
| F_CONTIGUOUS | (F) 数据是在一个单一的Fortran风格的连续段中 |
| OWNDATA (O) | 数组拥有它所使用的内存或从另一个对象中借用它 |
| WRITEABLE | (W) 数据区域可以被写入，将该值设置为 False，则数据为只读 |
| ALIGNED | (A) 数据和所有元素都适当地对齐到硬件上 |
| UPDATEIFCOPY | (U) 这个数组是其它数组的一个副本，当这个数组被释放时，原数组的内容将被更新 |
4，新建数组
numpy.empty创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组
| 参数 | 描述 |
|---|---|
| shape | 数组形状 |
| dtype | 数据类型，可选 |
| order | 有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序 |
创建新数组
import numpy as np
x = np.empty([3,2], dtype = int)
print (x)
............................
3列2行数组，为int型，内容未初始化，为随机值
........................................
[[1818588027 1868770918]
[1701998701 1869181811]
[ 32110 0]]
...........................
numpy.zeros 创建指定大小的数组，数组元素以 0 来填充,默认为浮点数
numpy.zeros(shape, dtype = float, order = 'C')
| 参数 | 描述 |
|---|---|
| shape | 数组形状 |
| dtype | 数据类型，可选 |
| order | ‘C’ 用于 C 的行数组，或者 ‘F’ 用于 FORTRAN 的列数组 |
import numpy as np
x = np.zeros((2,3),dtype=np.int)
print(x)
......................
创建2行3列默认为0 的int型数组
............................
[[0 0 0]
[0 0 0]]
.....................
自定义数组
# 自定义类型
z = np.zeros((2,2), dtype = [('x', 'f4'), ('y', 'i4')])
print(z)
.......................
[[(0., 0) (0., 0)]
[(0., 0) (0., 0)]]
..........................
numpy.ones
创建指定形状的数组，数组元素以 1 来填充 与numpy.zeros 类似
5,NumPy 从已有的数组创建数组
numpy.asarray :numpy.asarray 类似 numpy.array，但 numpy.asarray 参数只有三个，比 numpy.array 少两个
| 参数 | 描述 |
|---|---|
| a | 任意形式的输入参数，可以是，列表, 列表的元组, 元组, 元组的元组, 元组的列表，多维数组 |
| dtype | 数据类型，可选 |
| order | 可选，有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。 |
均可以列表、元组转换为 ndarray，并可设置数据类型
import numpy as np
x = [1,2,3]
a = np.asarray(x, dtype = float)
print (a)
......................................
[1. 2. 3.]
........................
numpy.fromiter ：从可迭代对象中建立 ndarray 对象，返回一维数组
numpy.fromiter(iterable, dtype, count=-1)
| 参数 | 描述 |
|---|---|
| iterable | 可迭代对象 |
| dtype | 返回数组的数据类型 |
| count | 读取的数据数量，默认为-1，读取所有数据 |
import numpy as np
data = np.random.randint(3,9,size=(4,1))
print(data)
........................
[[7]
[7]
[5]
[7]]
..........................
# 使用迭代器创建 ndarray
x = np.fromiter(data, dtype=float)
print(x)
....................
[7. 7. 5. 7.]
numpy.arange:使用 arange 函数创建数值范围并返回 ndarray 对象
numpy.arange(start, stop, step, dtype)
| 参数 | 描述 |
|---|---|
| start | 起始值，默认为0 |
| stop | 终止值（不包含） |
| step | 步长，默认为1 |
| dtype | 返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。 |
import numpy as np
x = np.arange(10,35,3,dtype =float)
print (x)
.....................
[10. 13. 16. 19. 22. 25. 28. 31. 34.]
.......................
.arange起始10，35止，步长3，数据类型float
numpy.linspace：函数用于创建一个一维数组，数组是一个等差数列构成的
np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
| 参数 | 描述 |
|---|---|
| start | 序列的起始值 |
| stop | 序列的终止值，如果endpoint为true，该值包含于数列中 |
| num | 要生成的等步长的样本数量，默认为50 |
| endpoint | 该值为 true 时，数列中包含stop值，反之不包含，默认是True。 |
| retstep | 如果为 True 时，生成的数组中会显示间距，反之不显示。 |
| dtype | ndarray 的数据类型 |
import numpy as np
a = np.linspace(10, 20, 5, endpoint=False, retstep=True)
print(a)
..................................
(array([10., 12., 14., 16., 18.]), 2.0)
..................
起始数10，终止20，在10到20间列出5个样本，endpoint=False 不包含stop值， retstep=True 显示数组间间距
numpy.logspace：函数用于创建一个于等比数列
np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)
| 参数 | 描述 |
|---|---|
| start | 序列的起始值为：base ** start |
| stop | 序列的终止值为：base ** stop。如果endpoint为true，该值包含于数列中 |
| num | 要生成的等步长的样本数量，默认为50 |
| endpoint | 该值为 true 时，数列中中包含stop值，反之不包含，默认是True。 |
| base | 对数 log 的底数。 |
| dtype | ndarray 的数据类型 |
import numpy as np
a = np.logspace(0,9,10,base=4,dtype=int)
print (a)
....................
[ 1 4 16 64 256 1024 4096 16384 65536 262144]
................................
与上面有所区别的是base=4 底数的参数
6，NumPy 切片和索引
ndarray对象的内容可以通过索引或切片来访问和修改，与 Python 中 list 的切片操作一样。
ndarray 数组可以基于 0 - n 的下标进行索引，切片对象可以通过内置的 slice 函数，并设置 start, stop 及 step 参数进行，从原数组中切割出一个新数组。
a = np.arange(10)
s = slice(2, 7, 2) # 从索引 2 开始到索引 7 停止，间隔为2
print(a[s])
..............................
[2 4 6]
.....................
通过 arange() 函数创建 ndarray 对象。 然后，分别设置起始，终止和步长的参数为 2，7 和 2
.................................................
冒号 : 的解释：如果只放置一个参数，如 [2]，将返回与该索引相对应的单个元素。如果为 [2:]，表示从该索引开始以后的所有项都将被提取。如果使用了两个参数，如 [2:7]，那么则提取两个索引(不包括停止索引)之间的项。
.................................................
b = a[2:7:2] # 从索引 2 开始到索引 7 停止，间隔为 2
c = a[2:7]
d = a[2]
print(b)
print(c)
print(d)
..................................
[2 4 6]
[2 3 4 5 6]
2
....................................................
多维数组使用
........................................................................
import numpy as np
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print (a[...,1]) # 第2列元素
print (a[1,...]) # 第2行元素
print (a[...,1:]) # 第2列及剩下的所有元素
....................................................
[2 4 5]
[3 4 5]
[[2 3]
[4 5]
[5 6]]
NumPy 高级索引:NumPy 比一般的 Python 序列提供更多的索引方式。除了之前看到的用整数和切片的索引外，数组可以由整数数组索引、布尔索引及花式索引
整数数组索引
获取数组中(0,0)，(1,1)和(2,0)位置处的元素
x = np.array([[1, 2], [3, 4], [5, 6]])
y = x[[0, 1, 2], [0, 1, 0]]
print(y)
.........................................
[1 4 5]
....................................................
数组中的四个角的元素。 行索引是 [0,0] 和 [3,3]，而列索引是 [0,2] 和 [0,2]。
import numpy as np
x = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]])
print(x)
print('\n')
rows = np.array([[0, 0], [3, 3]])
cols = np.array([[0, 2], [0, 2]])
y = x[rows, cols]
print(y)
.........................................
x:
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
y:
[[ 0 2]
[ 9 11]]
布尔索引 :布尔索引通过布尔运算（如：比较运算符）来获取符合指定条件的元素的数组
import numpy as np
x = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]])
y= np.array([34,31,231,3,4,63,231])
print (x[x > 5])
print(y[y>50])
................................................................
[ 6 7 8 9 10 11]
[231 63 231]
使用了 ~（取补运算符）来过滤 NaN
import numpy as np
a = np.array([np.nan, 1, 2, np.nan, 3, 4, 5])
print(a[~np.isnan(a)])
....................................................
[1. 2. 3. 4. 5.]
...............................................
从数组中过滤掉非复数元素
a = np.array([1, 2+6j, 5, 3.5+5j])
print (a[np.iscomplex(a)])
.......................................................
[2.0+6.j 3.5+5.j]
...................................................................................
花式索引
花式索引指的是利用整数数组进行索引。
花式索引根据索引数组的值作为目标数组的某个轴的下标来取值。对于使用一维整型数组作为索引，如果目标是一维数组，那么索引的结果就是对应位置的元素；如果目标是二维数组，那么就是对应下标的行。
花式索引跟切片不一样，它总是将数据复制到新数组中。
1、传入顺序索引数组
...........................................................
x = np.arange(32).reshape((8, 4))
print(x)
print(x[[4, 2, 1,7]]) #分别取4, 2, 1,7 行
...............................................
[[16 17 18 19]
[ 8 9 10 11]
[ 4 5 6 7]
[28 29 30 31]]
.............................................................
2、传入倒序索引数组
print (x[[-4,-2,-1,-7]])
..................................................................
[[16 17 18 19]
[24 25 26 27]
[28 29 30 31]
[ 4 5 6 7]]
.......................................
3、传入多个索引数组（要使用np.ix_）
import numpy as np
x = np.arange(32).reshape((8, 4))
print(x)
print(x[np.ix_([1, 5, 7, 2], [0, 3, 1, 2])])
...........................................................
[[ 4 7 5 6]
[20 23 21 22]
[28 31 29 30]
[ 8 11 9 10]]
..........................................................
[1, 5, 7, 2]
[0, 3, 1, 2] #对x数组取两列表组合成元组的位置。
即
[
[（1，0）, （1，3）, （1，1）, （1，2）]
[（5，0）, （5，3）, （5，1）, （5，2）]
[（7，0）, （7，3）, （7，1）, （7，2）]
[（2，0）, （2，3）, （2，1）, （2，2）]
]
np.xi_ 中输入两个列表，则第一个列表存的是待提取元素的行标，第二个列表存的是待提取元素的列标，第一个列表中的每个元素都会遍历第二个列表中的每个值，构成新矩阵的一行元素
7,NumPy 广播(Broadcast)
广播(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]
当运算中的 2 个数组的形状不同时，numpy 将自动触发广播机制
a = np.array([[0, 0, 0],[10, 10, 10],[20, 20, 20],[30, 30, 30]])
b = np.array([1, 2, 3])
print(a + b)
................................................
[[ 1 2 3]
[11 12 13]
[21 22 23]
[31 32 33]]
...........................................
[1, 2, 3]数组分别对a的各行数组进行相加
......................................
b = np.array([1, 2, 3])
bb = np.tile(b, (4, 1)) # 重复 b 的各个维度,
print(bb)
..........................................
[[1 2 3]
[1 2 3]
[1 2 3]
[1 2 3]]
(4, 1) 每个参数赋值1次，共4行
广播的规则:
让所有输入数组都向其中形状最长的数组看齐，形状中不足的部分都通过在前面加 1 补齐。
输出数组的形状是输入数组形状的各个维度上的最大值。
如果输入数组的某个维度和输出数组的对应维度的长度相同或者其长度为 1 时，这个数组能够用来计算，否则出错。
当输入数组的某个维度的长度为 1 时，沿着此维度运算时都用此维度上的第一组值。
8， numpy.nditer 迭代数组
NumPy 迭代器对象 numpy.nditer 提供了一种灵活访问一个或者多个数组元素的方式
import numpy as np
a = np.arange(6).reshape(2,3) #转成2维度数组
print(a)
for x in np.nditer(a): #对传入数组进行迭代，依次输出
print (x, end=", " )
............................................
0, 1, 2, 3, 4, 5,
改变读取方向
a = np.arange(6).reshape(2, 3)
print(a)
for x in np.nditer(a.T):
print(x, end=", ")
print('\n')
for x in np.nditer(a.T.copy(order='C')):
print(x, end=", ")
.......................................................
[[0 1 2]
[3 4 5]]
0, 1, 2, 3, 4, 5,
0, 3, 1, 4, 2, 5,
......................
a 和 a.T 的遍历顺序是一样的,内存中的存储顺序也是一样的，但是 a.T.copy(order = 'C') 的遍历结果是不同的，那是因为它和前两种的存储方式是不一样的，默认是按行访问
控制遍历顺序
for x in np.nditer(a, order=‘F’):Fortran order，即是列序优先；
for x in np.nditer(a.T, order=‘C’):C order，即是行序优先；
a = np.arange(0,30,5)
a = a.reshape(2,3)
print(a) #print( a.copy(order='C') ) 等效 #print( a.copy(order='F') )
..........................................................................
[[ 0 5 10]
[15 20 25]]
................................................
print(a.T) #print( a.T.copy(order='C') ) #print( a.T.copy(order='F') )
.................................................
[[ 0 15]
[ 5 20]
[10 25]]
...........................................................................
修改数组中元素的值
nditer 对象有另一个可选参数 op_flags。 默认情况下，nditer 将视待迭代遍历的数组为只读对象（read-only），为了在遍历数组的同时，实现对数组元素值得修改，必须指定 read-write 或者 write-only 的模式。
import numpy as np
a =np.arange(20,50,5).reshape(2,3)
print(a)
for x in np.nditer(a, op_flags=['readwrite']):
x[...]=2*x
print ('修改后的数组是：')
print (a)
.....................................................................
[[20 25 30]
[35 40 45]]
修改后的数组是：
[[40 50 60]
[70 80 90]]
.................................................
使用外部循环
nditer类的构造器拥有flags参数，它可以接受下列值：
| 参数 | 描述 |
|---|---|
| c_index | 可以跟踪 C 顺序的索引 |
| f_index | 可以跟踪 Fortran 顺序的索引 |
| multi-index | 每次迭代可以跟踪一种索引类型 |
| external_loop | 给出的值是具有多个值的一维数组，而不是零维数组 |
import numpy as np
a =np.arange(20,50,5).reshape(2,3)
print(a)
for x in np.nditer(a, flags = ['external_loop'], order = 'F'):
print (x, end=", " )
...................................................
[[20 25 30]
[35 40 45]]
[20 35], [25 40], [30 45]
.................................
广播迭代
import numpy as np
a = np.arange(16, 32, 2).reshape(2,4)
print(a)
print('第二个数组为：')
b = np.array([1, 2, 3, 4], dtype=int)
print(b)
print('修改后的数组为：')
for x, y in np.nditer([a, b]):
print("%d:%d" % (x, y), end=", ")
..........................................................
[[16 18 20 22]
[24 26 28 30]]
第二个数组为：
[1 2 3 4]
修改后的数组为：
16:1, 18:2, 20:3, 22:4, 24:1, 26:2, 28:3, 30:4,
..................................................
9,Numpy 数组操作
Numpy 中包含了一些函数用于处理数组，大概可分为以下几类：
修改数组形状
翻转数组
修改数组维度
连接数组
分割数组
数组元素的添加与删除
| 函数 | 描述 |
|---|---|
| reshape | 不改变数据的条件下修改形状 |
| flat | 数组元素迭代器 |
| flatten | 返回一份数组拷贝，对拷贝所做的修改不会影响原始数组 |
| ravel | 返回展开数组 |
numpy.reshape
numpy.reshape 函数可以在不改变数据的条件下修改形状，格式如下： numpy.reshape(arr, newshape, order=‘C’)
arr：要修改形状的数组
newshape：整数或者整数数组，新的形状应当兼容原有形状
order：‘C’ – 按行，‘F’ – 按列，‘A’ – 原顺序，‘k’ – 元素在内存中的出现顺序
numpy.ndarray.flat
a = np.arange(4).reshape(2, 2)
print(a)
# 对数组中每个元素都进行处理，可以使用flat属性，该属性是一个数组元素迭代器：
print('迭代后的数组：')
for element in a.flat:
print(element)
.......................................
[[0 1]
[2 3]]
迭代后的数组：
0
1
2
3
............................
numpy.ndarray.flatten
mpy.ndarray.flatten 返回一份数组拷贝，对拷贝所做的修改不会影响原始数组，格式如下：
ndarray.flatten(order='C')
order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'K' -- 元素在内存中的出现顺序。
a = np.arange(4).reshape(2, 2)
print(a)
# 对数组中每个元素都进行处理，可以使用flat属性，该属性是一个数组元素迭代器：
print('迭代后的数组：')
for element in a.flatten(order = 'F'):
print(element)
............................................................
[[0 1]
[2 3]]
迭代后的数组：
0
2
1
3
numpy.ravel
numpy.ravel() 展平的数组元素，顺序通常是"C风格"，返回的是数组视图（view，有点类似 C/C++引用reference的意味），修改会影响原始数组。
该函数接收两个参数：
numpy.ravel(a, order='C')
参数说明：
order：‘C’ – 按行，‘F’ – 按列，‘A’ – 原顺序，‘K’ – 元素在内存中的出现顺序。
a = np.arange(4).reshape(2, 2)
print(a)
print(a.ravel())
print(a.ravel(order = 'F'))
......................................................................
[[0 1]
[2 3]]
[0 1 2 3]
[0 2 1 3]
.....................................
翻转数组
| 函数 | 描述 |
|---|---|
| transpose | 对换数组的维度 |
| ndarray.T 和 self.transpose() | 相同 |
| rollaxis | 向后滚动指定的轴 |
| swapaxes | 对换数组的两个轴 |
numpy.transpose :numpy.ndarray.T 类似 numpy.transpose：
numpy.transpose 函数用于对换数组的维度，格式如下
numpy.transpose(arr, axes)
参数说明:
arr：要操作的数组
axes：整数列表，对应维度，通常所有维度都会对换。
a = np.arange(4).reshape(2, 2)
print(a)
print(np.transpose(a))
....................................
[[0 1]
[2 3]]
[[0 2]
[1 3]]
numpy.rollaxis::numpy.rollaxis 函数向后滚动特定的轴到一个特定位置
numpy.rollaxis(arr, axis, start)
参数说明：
arr：数组
axis：要向后滚动的轴，其它轴的相对位置不会改变
start：默认为零，表示完整的滚动。会滚动到特定位置。
import numpy as np
# 创建了三维的 ndarray
a = np.arange(8).reshape(2, 2, 2)
print('原数组：')
print(a)
...........................................
原数组：
[[[0 1]
[2 3]]
[[4 5]
[6 7]]]
.............................................
print('获取数组中一个值：')
print(np.where(a == 6))
print(a[1, 1, 0]) # 为 6
print('\n')
.......................................
获取数组中一个值：
(array([1], dtype=int64), array([1], dtype=int64), array([0], dtype=int64))
6
.........................................................
# 将轴 2 滚动到轴 0（宽度到深度）
print('调用 rollaxis 函数：')
b = np.rollaxis(a, 2, 0)
print(b)
............................................................
调用 rollaxis 函数：
[[[0 2]
[4 6]]
[[1 3]
[5 7]]]
(array([0], dtype=int64), array([1], dtype=int64), array([1], dtype=int64))
...................................................
# 查看元素 a[1,1,0]，即 6 的坐标，变成 [0, 1, 1]
# 最后一个 0 移动到最前面
print(np.where(b == 6))
print('\n')
............................................
# 将轴 2 滚动到轴 1：（宽度到高度）
print('调用 rollaxis 函数：')
c = np.rollaxis(a, 2, 1)
print(c)
# 查看元素 a[1,1,0]，即 6 的坐标，变成 [1, 0, 1]
# 最后的 0 和 它前面的 1 对换位置
print(np.where(c == 6))
print('\n')
....................................
调用 rollaxis 函数：
[[[0 2]
[1 3]]
[[4 6]
[5 7]]]
(array([1], dtype=int64), array([0], dtype=int64), array([1], dtype=int64))
numpy.swapaxes
numpy.swapaxes 函数用于交换数组的两个轴
numpy.swapaxes(arr, axis1, axis2)
arr：输入的数组
axis1：对应第一个轴的整数
axis2：对应第二个轴的整数
import numpy as np
# 创建了三维的 ndarray
a = np.arange(8).reshape(2,2,2)
print ('原数组：')
print (a)
print ('\n')
...................................................
原数组：
[[[0 1]
[2 3]]
[[4 5]
[6 7]]]
........................
# 现在交换轴 0（深度方向）到轴 2（宽度方向）
print ('调用 swapaxes 函数后的数组：')
print (np.swapaxes(a, 2, 0))
...........................
调用 swapaxes 函数后的数组：
[[[0 4]
[2 6]]
[[1 5]
[3 7]]]
........................................................
10,连接数组
| 函数 | 描述 |
|---|---|
| concatenate | 连接沿现有轴的数组序列 |
| stack | 沿着新的轴加入一系列数组。 |
| hstack | 水平堆叠序列中的数组（列方向） |
| vstack | 竖直堆叠序列中的数组（行方向） |
numpy.concatenate：umpy.concatenate 函数用于沿指定轴连接相同形状的两个或多个数组
numpy.concatenate((a1, a2, …), axis)
参数说明：
a1, a2, …：相同类型的数组
axis：沿着它连接数组的轴，默认为 0
import numpy as np
a = np.array([[1,2],[3,4]])
b = np.array([[5,6],[7,8]])
print(np.concatenate((a,b)))
.............................................
[[1 2]
[3 4]
[5 6]
[7 8]]
...................................
print(np.concatenate((a,b),axis=1))
................................
[[1 2 5 6]
[3 4 7 8]]
numpy.stack :numpy.stack 函数用于沿新轴连接数组序列
numpy.stack(arrays, axis)
参数说明：
arrays相同形状的数组序列
axis：返回数组中的轴，输入数组沿着它来堆叠
print(np.stack((a,b),0))
.....................................................................
沿轴 0 堆叠两个数组
[[[1 2]
[3 4]]
[[5 6]
[7 8]]]#此处为两个数组叠加，并非上面的拼接，这里组成了3维数组
...........................
print (np.stack((a,b),1))
....................................
沿轴 1 堆叠两个数组
[[[1 2]
[5 6]]
[[3 4]
[7 8]]]
#在数组的第二个开始叠加
numpy.hstack
numpy.hstack 是 numpy.stack 函数的变体，它通过水平堆叠来生成数组。
print(np.hstack((a,b)))
..................
[[1 2 5 6]
[3 4 7 8]]#水平拼接
..............
numpy.vstack ：numpy.vstack 是 numpy.stack 函数的变体，它通过垂直堆叠来生成数组。
print(np.vstack((a,b)))
........................................
[[1 2]
[3 4]
[5 6]
[7 8]]
11,分割数组
| 函数 | 数组及操作 |
|---|---|
| split | 将一个数组分割为多个子数组 |
| hsplit | 将一个数组水平分割为多个子数组（按列） |
| vsplit | 将一个数组垂直分割为多个子数组（按行） |
numpy.split
numpy.split 函数沿特定的轴将数组分割为子数组
numpy.split(ary, indices_or_sections, axis)
参数说明：
ary：被分割的数组
indices_or_sections：果是一个整数，就用该数平均切分，如果是一个数组，为沿轴切分的位置（左开右闭）
axis：设置沿着哪个方向进行切分，默认为 0，横向切分，即水平方向。为 1 时，纵向切分，即竖直方向。
import numpy as np
a = np.arange(9)
print(np.split(a,3))#数组分为三个大小相等的子数组
............................
[array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])]
..........................................
print(print(np.split(a,[3,8]))) #按区间分割，左开右闭
.............................
[array([0, 1, 2]), array([3, 4, 5, 6, 7]), array([8])]
axis 为 0 时在水平方向分割，axis 为 1 时在垂直方向分割
import numpy as np
a = np.arange(8).reshape(4,2)
print(a)
........................................................
[[0 1]
[2 3]
[4 5]
[6 7]]
...........................
print(np.split(a,2,1))
...........................
[array([[0],
[2],
[4],
[6]]), array([[1],
[3],
[5],
[7]])]
numpy.hsplit
numpy.hsplit 函数用于水平分割数组，通过指定要返回的相同形状的数组数量来拆分原数组
a = np.arange(12).reshape(3,4)
print(np.hsplit(a,2))
.........................................
[array([[0, 1],
[4, 5],
[8, 9]]), array([[ 2, 3],
[ 6, 7],
[10, 11]])]
numpy.vsplit
numpy.vsplit 沿着垂直轴分割，其分割方式与hsplit用法相同
import numpy as np
a = np.arange(12).reshape(4,3)
print(a)
...................................
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
.................
print(np.vsplit(a,2))
........................
[array([[0, 1, 2],
[3, 4, 5]]), array([[ 6, 7, 8],
[ 9, 10, 11]])]
12,数组元素的添加与删除
| 函数 | 元素及描述 |
|---|---|
| resize | 返回指定形状的新数组 |
| append | 将值添加到数组末尾 |
| insert | 沿指定轴将值插入到指定下标之前 |
| delete | 删掉某个轴的子数组，并返回删除后的新数组 |
| unique | 查找数组内的唯一元素 |
numpy.resize
numpy.resize 函数返回指定大小的新数组。
如果新数组大小大于原始大小，则包含原始数组中的元素的副本
numpy.resize(arr, shape)
参数说明：
arr：要修改大小的数组
shape：返回数组的新形状
import numpy as np
a = np.arange(12).reshape(4,3)
print(np.resize(a,(3,4)))
..................................
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
numpy.append
numpy.append 函数在数组的末尾添加值。 追加操作会分配整个数组，并把原来的数组复制到新数组中。 此外，输入数组的维度必须匹配否则将生成ValueError。
append 函数返回的始终是一个一维数组
numpy.append(arr, values, axis=None)
参数说明：
arr：输入数组
values：要向arr添加的值，需要和arr形状相同（除了要添加的轴）
axis：默认为 None。当axis无定义时，是横向加成，返回总是为一维数组！当axis有定义的时候，分别为0和1的时候。当axis有定义的时候，分别为0和1的时候（列数要相同）。当axis为1时，数组是加在右边（行数要相同）。
import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6]])
print(a)
..........................
[[1 2 3]
[4 5 6]]
................................
b = np.array([[8,9,10]])
print(np.append(a,b))
.....................
[ 1 2 3 4 5 6 8 9 10]#不定义axis时，返回的总为一位数组
................................
print(np.append(a,[[1,2,5],[2,3,6]],axis=0))
....................
[[1 2 3]
[4 5 6]
[1 2 5]
[2 3 6]]#纵向
...................
print(np.append(a,[[1,2,5],[2,3,6]],axis=1))
...............................
[[1 2 3 1 2 5]
[4 5 6 2 3 6]]#横向
numpy.insert
numpy.insert 函数在给定索引之前，沿给定轴在输入数组中插入值。
如果值的类型转换为要插入，则它与输入数组不同。 插入没有原地的，函数会返回一个新数组。 此外，如果未提供轴，则输入数组会被展开
numpy.insert(arr, obj, values, axis)
参数说明：
arr：输入数组
obj：在其之前插入值的索引
values：要插入的值
axis：沿着它插入的轴，如果未提供，则输入数组会被展开
import numpy as np
a = np.arange(9).reshape(3,3)
print(a)
.........................
[[0 1 2]
[3 4 5]
[6 7 8]]
...................................
print(np.insert(a,8,[9,0,1]))
.....................................
[0 1 2 3 4 5 6 7 9 0 1 8] #无axis，作为1为返回
.......................................
print(np.insert(a,2,[9,0,1],axis=0))
...........................
[[0 1 2]
[3 4 5]
[9 0 1]
[6 7 8]] #列数必须匹配
................................................................
print(np.insert(a,2,[9],axis=0))
...............................
[[0 1 2]
[3 4 5]
[9 9 9]
[6 7 8]]#列数参数不够的，全列用相同的补足
........................
print(np.insert(a,2,[9,0,1],axis=1))
................................
[[0 1 9 2]
[3 4 0 5]
[6 7 1 8]]#按列加载
........................
print(np.insert(a,2,[1],axis=1))
........................................
[[0 1 1 2]
[3 4 1 5]
[6 7 1 8]]
numpy.delete
numpy.delete 函数返回从输入数组中删除指定子数组的新数组。 与 insert() 函数的情况一样，如果未提供轴参数，则输入数组将展开
Numpy.delete(arr, obj, axis)
参数说明：
arr：输入数组
obj：可以被切片，整数或者整数数组，表明要从输入数组删除的子数组
axis：沿着它删除给定子数组的轴，如果未提供，则输入数组会被展开
import numpy as np
a = np.arange(9).reshape(3,3)
print(a)
print(np.delete(a,8))
...............................
[0 1 2 3 4 5 6 7]#展开成列表后，删除第8个参数
......................
print(np.delete(a,1,axis=0))#删除第二行
.............................
print(np.delete(a,1,axis=1)) #删除第二列
.................
[[0 2]
[3 5]
[6 8]]
numpy.unique
numpy.unique 函数用于去除数组中的重复元素。
numpy.unique(arr, return_index, return_inverse, return_counts)
arr：输入数组，如果不是一维数组则会展开
return_index：如果为true，返回新列表元素在旧列表中的位置（下标），并以列表形式储
return_inverse：如果为true，返回旧列表元素在新列表中的位置（下标），并以列表形式储
return_counts：如果为true，返回去重数组中的元素在原数组中的出现次数
import numpy as np
a = np.array([1,2,34,5,2,1,5,85])
print(a)
.........................................
[ 1 2 34 5 2 1 5 85] #返回列表
.......................................
print(np.unique(a))
...........................
[ 1 2 5 34 85] #去重
.................................................
u,indices = np.unique(a, return_index = True)
print(u,indices)
...........................................
[ 1 2 5 34 85] [0 1 3 2 7] #去重后返回去重与重组后索引
.......................................
u,indices = np.unique(a, return_inverse = True)
print(u,indices)
print (u[indices])
....................................
[ 1 2 5 34 85] [0 1 3 2 1 0 2 4] #返回去重后与去重数的索引
[ 1 2 34 5 2 1 5 85] #根据索引重组数据
..................................
u,indices = np.unique(a,return_counts = True)
print(u,indices)
................................
[ 1 2 5 34 85] [2 2 2 1 1] #返回重组数据并返回重组后重复数量
三：NumPy 位运算
NumPy “bitwise_” 开头的函数是位运算函数。
NumPy 位运算包括以下几个函数：
| 函数 | 描述 |
|---|---|
| bitwise_and | 对数组元素执行位与操作 |
| bitwise_or | 对数组元素执行位或操作 |
| invert | 按位取反 |
| left_shift | 向左移动二进制表示的位 |
| right_shift | 向右移动二进制表示的位 |
四：NumPy 字符串函数
| 函数 | 描述 |
|---|---|
| add() | 对两个数组的逐个字符串元素进行连接 |
| multiply() | 返回按元素多重连接后的字符串 |
| center() | 居中字符串 |
| capitalize() | 将字符串第一个字母转换为大写 |
| title() | 将字符串的每个单词的第一个字母转换为大写 |
| lower() | 数组元素转换为小写 |
| upper() | 数组元素转换为大写 |
| split() | 指定分隔符对字符串进行分割，并返回数组列表 |
| splitlines() | 返回元素中的行列表，以换行符分割 |
| strip() | 移除元素开头或者结尾处的特定字符 |
| join() | 通过指定分隔符来连接数组中的元素 |
| replace() | 使用新字符串替换字符串中的所有子字符串 |
| decode() | 数组元素依次调用str.decode |
| encode() | 数组元素依次调用str.encode |
numpy.char.add()
numpy.char.add() 函数依次对两个数组的元素进行字符串连接
import numpy as np
print (np.char.add(['hello'],[' xyz']))
print (np.char.add('hello',' xyz'))
................................
['hello xyz']
hello xyz
numpy.char.multiply()
numpy.char.multiply() 函数执行多重连接
import numpy as np
print (np.char.multiply(['hello'],3))
print (np.char.multiply('hello',3))
..........................
['hellohellohello']
hellohellohello
numpy.char.center()
numpy.char.center() 函数用于将字符串居中，并使用指定字符在左侧和右侧进行填充
#str: 字符串，width: 长度，fillchar: 填充字符
print (np.char.center('Runoob', 20,fillchar = '%'))
..............................
%%%%%%%Runoob%%%%%%%
numpy.char.capitalize()
numpy.char.capitalize() 函数将字符串的第一个字母转换为大写：
import numpy as np
print (np.char.capitalize('bunoob'))
......................................
Bunoob
numpy.char.title()
numpy.char.title() 函数将字符串的每个单词的第一个字母转换为大写：
import numpy as np
print(np.char.title('i like you!'))
...........................
I Like You!
numpy.char.lower()
umpy.char.lower() 函数对数组的每个元素转换为小写。它对每个元素调用 str.lower。
import numpy as np
print(np.char.lower(['GKVKHG', 'KGLLL']))# 操作数组
print(np.char.lower('GKVKHG')) #字符串
..................................................
['gkvkhg' 'kglll']
gkvkhg
numpy.char.upper()
numpy.char.upper() 函数对数组的每个元素转换为大写。它对每个元素调用 str.upper
import numpy as np
print(np.char.upper(['nlghjkl', 'fgh hgrf']))# 操作数组
print(np.char.upper('ln lm')) #字符串
...................................................
['NLGHJKL' 'FGH HGRF']
LN LM
numpy.char.split()
numpy.char.split() 通过指定分隔符对字符串进行分割，并返回数组。默认情况下，分隔符为空格
print (np.char.split ('i like runoob?'))
print (np.char.split ('i like runoob?',sep='r'))
............................
['i', 'like', 'runoob?']
['i like ', 'unoob?']
.............................................
print (np.char.split (['i like runoob?','q e']))
print (np.char.split (['i like runoob?','eqqqeeeeeeeeeeeeertyui'],sep='r'))
..................................................................................
[list(['i', 'like', 'runoob?']) list(['q', 'e'])]
[list(['i like ', 'unoob?']) list(['eqqqeeeeeeeeeeeee', 'tyui'])]
numpy.char.splitlines()
numpy.char.splitlines() 函数以换行符作为分隔符来分割字符串，并返回数组
import numpy as np
# 换行符 \n
print(np.char.splitlines('sdafg\nwe'))
print(np.char.splitlines('sdafg\nwe'))
.............................
['sdafg', 'we']
['sdafg', 'we']
numpy.char.strip()
umpy.char.strip() 函数用于移除开头或结尾处的特定字符。
import numpy as np
# 移除字符串头尾的 a 字符
print(np.char.strip(' ashok arunoob ', ' '))
print(np.char.strip([' ashok arunooba ','af ad '], ' '))
# 移除数组元素头尾的 a 字符
print(np.char.strip(['aaaaaasfda', 'aaads', 'java'], 'a'))
..................................
ashok arunoob
['ashok arunooba' 'af ad']
['sfd' 'ds' 'jav']
numpy.char.join()
numpy.char.join() 函数通过指定分隔符来连接数组中的元素或字符串
import numpy as np
# 操作字符串
print(np.char.join(':', 'runoob'))
print(np.char.join(':', ['runoob','as df']))
# 指定多个分隔符操作数组元素
print(np.char.join([':', '-'], ['runoob', 'google']))
........................................
r:u:n:o:o:b
['r:u:n:o:o:b' 'a:s: :d:f']
['r:u:n:o:o:b' 'g-o-o-g-l-e']
numpy.char.replace()
numpy.char.replace() 函数使用新字符串替换字符串中的所有子字符串。
import numpy as np
a = np.char.encode('runoob', 'cp500')
print(a)
.................................
b'\x99\xa4\x95\x96\x96\x82'
...................
a = np.char.encode('runoob')
print(a)
.....................
b'runoob'#字节
五,NumPy 数学函数
NumPy 包含大量的各种数学运算的函数，包括三角函数，算术运算的函数，复数处理函数等。
三角函数
NumPy 提供了标准的三角函数：sin()、cos()、tan()。
arcsin，arccos，和 arctan 函数返回给定角度的 sin，cos 和 tan 的反三角函数。
这些函数的结果可以通过 numpy.degrees() 函数将弧度转换为角度
numpy.around() 函数返回指定数字的四舍五入值。
舍入函数
numpy.around(a,decimals)
参数说明：
a: 数组
decimals: 舍入的小数位数。 默认值为0。 如果为负，整数将四舍五入到小数点左侧的位置```
a = np.array([1.0, 5.55, 123, 0.567, 25.532])
print(np.around(a))
print(np.around(a, decimals=1))
print(np.around(a, decimals=-1))
........................
[ 1. 6. 123. 1. 26.]
[ 1. 5.6 123. 0.6 25.5]
[ 0. 10. 120. 0. 30.]
numpy.floor()
numpy.floor() 返回小于或者等于指定表达式的最大整数，即向下取整。
a = np.array([-1.7, 1.5, -0.2, 0.6, 10])
print(np.floor(a))
.............................
[-2. 1. -1. 0. 10.]
numpy.ceil()
numpy.ceil() 返回大于或者等于指定表达式的最小整数，即向上取整
a = np.array([-1.7, 1.5, -0.2, 0.6, 10])
print(np.ceil(a))
...........................
[-1. 2. -0. 1. 10.]
六,NumPy 算术函数
NumPy 算术函数包含简单的加减乘除: add()，subtract()，multiply() 和 divide()。
需要注意的是数组必须具有相同的形状或符合数组广播规则。
numpy.reciprocal()
numpy.reciprocal() 函数返回参数逐元素的倒数。如 1/4 倒数为 4/1。
numpy.power()
numpy.power() 函数将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂
numpy.mod()
numpy.mod() 计算输入数组中相应元素的相除后的余数。 函数 numpy.remainder() 也产生相同的结果
七,NumPy 统计函数
NumPy 提供了很多统计函数，用于从数组中查找最小元素，最大元素，百分位标准差和方差等。 函数说明如下：
numpy.amin() 和 numpy.amax()
numpy.amin() 用于计算数组中的元素沿指定轴的最小值。
numpy.amax() 用于计算数组中的元素沿指定轴的最大值。
import numpy as np
a = np.array([[3,7,5],[8,4,3],[2,4,9]])
print(a)
..................
[[3 7 5]
[8 4 3]
[2 4 9]]
.................
print(np.amin(a,1))
............................................
[3 3 2]
..........................
print(np.amin(a,0))
[2 4 3]
..........................
print(np.amax(a,1))
[7 8 9]
................................
print(np.amax(a,0))
[8 7 9]
numpy.ptp()
numpy.ptp()函数计算数组中元素最大值与最小值的差（最大值 - 最小值）
import numpy as np
a = np.array([[3,7,5],[8,4,3],[2,4,11]])
print(np.ptp(a))
................................
9 #数据作为一个列表计算
..............
print(np.ptp(a,axis=1))
................................
[4 5 9]
............................
print(np.ptp(a,axis=0))
........................
[6 3 8]
numpy.percentile()
百分位数是统计中使用的度量，表示小于这个值的观察值的百分比。 函数numpy.percentile()接受以下参数
numpy.percentile(a, q, axis)
参数说明：
a: 输入数组
q: 要计算的百分位数，在 0 ~ 100 之间
axis: 沿着它计算百分位数的轴
import numpy as np
a = np.array([[10, 7, 4], [3, 2, 1]])
print(np.percentile(a, 50))
# axis 为 0，在纵列上求
print(np.percentile(a, 50, axis=0))
# axis 为 1，在横行上求
print(np.percentile(a, 50, axis=1))
# 保持维度不变
print(np.percentile(a, 50, axis=1, keepdims=True))
.........................................
3.5
[6.5 4.5 2.5]
[7. 2.]
[[7.]
[2.]]
numpy.median()
numpy.median() 函数用于计算数组 a 中元素的中位数（中值）
a = np.array([[30,65,70],[80,95,10],[50,90,60]])
print (np.median(a))
print (np.median(a, axis = 0))
.........................
3.5
[6.5 4.5 2.5]
numpy.mean()
numpy.mean() 函数返回数组中元素的算术平均值。 如果提供了轴，则沿其计算。
算术平均值是沿轴的元素的总和除以元素的数量。
import numpy as np
a = np.array([[1, 2, 3], [3, 4, 5], [4, 5, 6]])
print(a)
..............................
[[1 2 3]
[3 4 5]
[4 5 6]]
.........................
print(np.mean(a))
print(np.mean(a, axis=0))
print(np.mean(a, axis=1))
.............................
3.6666666666666665
[2.66666667 3.66666667 4.66666667]
[2. 4. 5.]
...................................
numpy.average()
numpy.average() 函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值。
该函数可以接受一个轴参数。 如果没有指定轴，则数组会被展开。
加权平均值即将各数值乘以相应的权数，然后加总求和得到总体值，再除以总的单位数。
考虑数组[1,2,3,4]和相应的权重[4,3,2,1]，通过将相应元素的乘积相加，并将和除以权重的和，来计算加权平均值。
import numpy as np
a = np.array([1, 2, 3, 4])
print(a)
print(np.average(a))
print('\n')
# 不指定权重时相当于 mean 函数
wts = np.array([4, 3, 2, 1])
print(np.average(a, weights=wts))
# 如果 returned 参数设为 true，则返回权重的和
print(np.average([1, 2, 3, 4], weights=[4, 3, 2, 1], returned=True))
.................................
[1 2 3 4]
2.5
2.0
(2.0, 10.0)
标准差 mean
标准差是一组数据平均值分散程度的一种度量。
标准差是方差的算术平方根。
标准差公式如下：
std = sqrt(mean((x - x.mean())**2))
如果数组是 [1，2，3，4]，则其平均值为 2.5。 因此，差的平方是 [2.25,0.25,0.25,2.25]，并且再求其平均值的平方根除以 4，即 sqrt(5/4) ，结果为 1.1180339887498949。
import numpy as np
print(np.std([1, 2, 3, 4]))
................................
1.118033988749895
方差 var
统计中的方差（样本方差）是每个样本值与全体样本值的平均数之差的平方值的平均数，即 mean((x - x.mean())** 2)。
换句话说，标准差是方差的平方根。
import numpy as np
print(np.var([1, 2, 3, 4]))
..................
1.25
八,NumPy 排序、条件刷选函数
NumPy 提供了多种排序的方法。 这些排序函数实现不同的排序算法，每个排序算法的特征在于执行速度，最坏情况性能，所需的工作空间和算法的稳定性。 下表显示了三种排序算法的比较
| 种类 | 速度 | 最坏情况 | 工作空间 | 稳定性 |
|---|---|---|---|---|
| ‘quicksort’（快速排序） | 1 | O(n^2) | 0 | 否 |
| ‘mergesort’（归并排序） | 2 | O(n*log(n)) | ~n/2 | 是 |
| ‘heapsort’（堆排序） | 3 | O(n*log(n)) | 0 | 否 |
numpy.sort()
numpy.sort() 函数返回输入数组的排序副本。函数格式如下：
numpy.sort(a, axis, kind, order)
参数说明：
a: 要排序的数组
axis: 沿着它排序数组的轴，如果没有数组会被展开，沿着最后的轴排序， axis=0 按列排序，axis=1 按行排序
kind: 默认为’quicksort’（快速排序）
order: 如果数组包含字段，则是要排序的字段
a = np.array([[1,3, 7], [9,6, 1]])
print(a)
........................
[[1 3 7]
[9 6 1]]
..............................
print(np.sort(a))
..................................
[[1 3 7]
[1 6 9]]
.................
print(np.sort(a, axis=0))
.....................
[[1 3 1]
[9 6 7]]
....................................
import numpy as np
# 在 sort 函数中排序字段
dt = np.dtype([('name', 'S10'),('age', int)])
a = np.array([("raju",21),("anil",25),("ravi", 17), ("amar",27)], dtype = dt)
print ('我们的数组是：')
print (a)
print ('\n')
print ('按 name 排序：')
print (np.sort(a, order = 'name'))
...........................................
我们的数组是：
[(b'raju', 21) (b'anil', 25) (b'ravi', 17) (b'amar', 27)]
按 name 排序：
[(b'amar', 27) (b'anil', 25) (b'raju', 21) (b'ravi', 17)]
numpy.argsort()
numpy.argsort() 函数返回的是数组值从小到大的索引值
import numpy as np
x = np.array([3, 1, 2])
print(x)
y = np.argsort(x)
print(y)
print(x[y])
.............................
[3 1 2]
[1 2 0]
[1 2 3]
numpy.lexsort()
numpy.lexsort() 用于对多个序列进行排序。把它想象成对电子表格进行排序，每一列代表一个序列，排序时优先照顾靠后的列
import numpy as np
nm = ('raju', 'anil', 'ravi', 'amar')
dv = ('f.y.', 's.y.', 's.y.', 'f.y.')
ind = np.lexsort((dv, nm))
print(ind)
print([nm[i] + ", " + dv[i] for i in ind])
.......................................................
[3 1 0 2]
['amar, f.y.', 'anil, s.y.', 'raju, f.y.', 'ravi, s.y.']
上面传入 np.lexsort 的是一个tuple，排序时首先排 nm，顺序为：amar、anil、raju、ravi 。综上排序结果为 [3 1 0 2]
msort、sort_complex、partition、argpartition
| 函数 | 描述 |
|---|---|
| msort(a) | 数组按第一个轴排序，返回排序后的数组副本。np.msort(a) 相等于 np.sort(a, axis=0)。 |
| sort_complex(a) | 对复数按照先实部后虚部的顺序进行排序。 |
| partition(a, kth[, axis, kind, order]) | 指定一个数，对数组进行分区 |
| argpartition(a, kth[, axis, kind, order]) | 可以通过关键字 kind 指定算法沿着指定轴对数组进行分区 |
numpy.argmax() 和 numpy.argmin()
numpy.argmax() 和 numpy.argmin()函数分别沿给定轴返回最大和最小元素的索引
numpy.nonzero()
numpy.nonzero() 函数返回输入数组中非零元素的索引
numpy.where()
numpy.where() 函数返回输入数组中满足给定条件的元素的索引
numpy.extract()
numpy.extract() 函数根据某个条件从数组中抽取元素，返回满条件的元素
九，NumPy 字节交换
多字节对象都被存储为连续的字节序列。字节顺序，是跨越多字节的程序对象的存储规则。
大端模式：指数据的高字节保存在内存的低地址中，而数据的低字节保存在内存的高地址中，这样的存储模式有点儿类似于把数据当作字符串顺序处理：地址由小向大增加，而数据从高位往低位放；这和我们的阅读习惯一致。
小端模式：指数据的高字节保存在内存的高地址中，而数据的低字节保存在内存的低地址中，这种存储模式将地址的高低和数据位权有效地结合起来，高地址部分权值高，低地址部分权值低。
例如在 C 语言中，一个类型为 int 的变量 x 地址为 0x100，那么其对应地址表达式&x的值为 0x100。且x的四个字节将被存储在存储器的 0x100, 0x101, 0x102, 0x103位置。
numpy.ndarray.byteswap()
numpy.ndarray.byteswap() 函数将 ndarray 中每个元素中的字节进行大小端转换。
十，NumPy 副本、视图
**副本：**一个数据的完整的拷贝，如果我们对副本进行修改，它不会影响到原始数据，物理内存不在同一位置
**视图：**数据的一个别称或引用，通过该别称或引用亦便可访问、操作原有数据，但原有数据不会产生拷贝。如果我们对视图进行修改，它会影响到原始数据，物理内存在同一位置
视图一般发生在：
1、numpy 的切片操作返回原数据的视图。
2、调用 ndarray 的 view() 函数产生一个视图。
副本一般发生在：
Python 序列的切片操作，调用deepCopy()函数。
调用 ndarray 的 copy() 函数产生一个副本。
视图或浅拷贝
ndarray.view() 方会创建一个新的数组对象，该方法创建的新数组的维数更改不会更改原始数据的维数
#改变视图，不改变原数据
import numpy as np
a =np.arange(8).reshape(2,4)
print(a)
................................
[[0 1 2 3]
[4 5 6 7]]
.......................................................
b=a.view()
print(b)
..................................................................
[[0 1 2 3]
[4 5 6 7]]
.........................
b.shape =4,2
print(b)
.....................................................
[[0 1]
[2 3]
[4 5]
[6 7]]
...........................................
print(a)
....................................
[[0 1 2 3]
[4 5 6 7]]
#使用切片创建视图修改数据会影响到原始数组
ndarray.copy()
副本或深拷贝
ndarray.copy() 函数创建一个副本。 对副本数据进行修改，不会影响到原始数据，它们物理内存不在同一位置
a = np.array([[10,10], [2,3], [4,5]])
a = np.array([[10,10], [2,3], [4,5]])
print(a)
b=a.copy()
十一,NumPy 矩阵库(Matrix)
NumPy 中包含了一个矩阵库 numpy.matlib，该模块中的函数返回的是一个矩阵，而不是 ndarray 对象。
一个 的矩阵是一个由行（row）列（column）元素排列成的矩形阵列。
矩阵里的元素可以是数字、符号或数学式。以下是一个由 6 个数字元素构成的 2 行 3 列的矩阵
numpy.transpose
转置矩阵
NumPy 中除了可以使用 numpy.transpose 函数来对换数组的维度，还可以使用 T 属性
matlib.empty()
matlib.empty() 函数返回一个新的矩阵，语法格式为：
numpy.matlib.empty(shape, dtype, order)
参数说明：
shape: 定义新矩阵形状的整数或整数元组
Dtype: 可选，数据类型
order: C（行序优先） 或者 F（列序优先）
numpy.matlib.zeros()
numpy.matlib.zeros() 函数创建一个以 0 填充的矩阵
numpy.matlib.ones()
numpy.matlib.ones()函数创建一个以 1 填充的矩阵
numpy.matlib.eye()
numpy.matlib.eye() 函数返回一个矩阵，对角线元素为 1，其他位置为零。
numpy.matlib.eye(n, M,k, dtype)
参数说明：
n: 返回矩阵的行数
M: 返回矩阵的列数，默认为 n
k: 对角线的索引
dtype: 数据类型
numpy.matlib.identity()
numpy.matlib.identity() 函数返回给定大小的单位矩阵。
单位矩阵是个方阵，从左上角到右下角的对角线（称为主对角线）上的元素均为 1，除此以外全都为 0。
numpy.matlib.rand()
numpy.matlib.rand() 函数创建一个给定大小的矩阵，数据是随机填充的,阵总是二维的，而 ndarray 是一个 n 维数组。 两个对象都是可互换的
之前好多信息只有部分能用到，有些像线性代数我这里也未作抄录与熟悉，下面的NumPy IO 大家还是要知道了解下！
!!!-NumPy IO
功能：
Numpy 可以读写磁盘上的文本数据或二进制数据。
NumPy 为 ndarray 对象引入了一个简单的文件格式：npy。
npy 文件用于存储重建 ndarray 所需的数据、图形、dtype 和其他信息
常用的 IO 函数有：
load() 和 save() 函数是读写文件数组数据的两个主要函数，默认情况下，数组是以未压缩的原始二进制格式保存在扩展名为 .npy 的文件中。
savez() 函数用于将多个数组写入文件，默认情况下，数组是以未压缩的原始二进制格式保存在扩展名为 .npz 的文件中。
loadtxt() 和 savetxt() 函数处理正常的文本文件(.txt 等)
numpy.save()
numpy.save() 函数将数组保存到以 .npy 为扩展名的文件中。
numpy.save(file, arr, allow_pickle=True, fix_imports=True)
参数说明：
file：要保存的文件，扩展名为 .npy，如果文件路径末尾没有扩展名 .npy，该扩展名会被自动加上。
arr: 要保存的数组
allow_pickle: 可选，布尔值，允许使用 Python pickles 保存对象数组，Python 中的 pickle 用于在保存到磁盘文件或从磁盘文件读取之前，对对象进行序列化和反序列化。
fix_imports: 可选，为了方便 Pyhton2 中读取 Python3 保存的数据
import numpy as np
a = np.array([1, 2, 3, 4, 5])
# 保存到 outfile.npy 文件上,文件内容为二进制文件，用工具打开都是乱码
np.save(r'C:\Users\Administrator\Desktop\V1\outfile.npy',a)
#outfile 文件不命名，保存时尾缀会自动补齐
np.save(r'C:\Users\Administrator\Desktop\V1\outfile',a)
读取文件load
import numpy as np
dir =r'C:\Users\Administrator\Desktop\V1\outfile.npy'
data =np.load(dir)
print(data)
...........................
np.savez
numpy.savez() 函数将多个数组保存到以 npz 为扩展名的文件中
numpy.savez(file, *args, **kwds)
参数说明：
file：要保存的文件，扩展名为 .npz，如果文件路径末尾没有扩展名 .npz，该扩展名会被自动加上。
args: 要保存的数组，可以使用关键字参数为数组起一个名字，非关键字参数传递的数组会自动起名为 arr_0, arr_1, … 。
kwds: 要保存的数组使用关键字名称。
import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6]])
b = np.arange(0, 1.0, 0.1)
c = np.sin(b)
# c 使用了关键字参数 sin_array
np.savez("runoob.npz", a, b, sin_array=c)
r = np.load("runoob.npz")
print(r)
print(r.files) # 查看各个数组名称
print(r["arr_0"]) # 数组 a
print(r["arr_1"]) # 数组 b
print(r["sin_array"]) # 数组 c
savetxt()
savetxt() 函数是以简单的文本文件格式存储数据，对应的使用 loadtxt() 函数来获取数据。
np.loadtxt(FILENAME, dtype=int, delimiter=' ')
np.savetxt(FILENAME, a, fmt="%d", delimiter=",")
参数 delimiter 可以指定各种分隔符、针对特定列的转换器函数、需要跳过的行数等。
import numpy as np
a=np.arange(0,10,0.5).reshape(4,-1)
np.savetxt("out.txt",a,fmt="%d",delimiter=",") # 改为保存为整数，以逗号分隔
b = np.loadtxt("out.txt",delimiter=",") # load 时也要指定为逗号分隔
print(b)
....................................................
[[0. 0. 1. 1. 2.]
[2. 3. 3. 4. 4.]
[5. 5. 6. 6. 7.]
[7. 8. 8. 9. 9.]]
python之数据分析Matplotlib
https://blog.csdn.net/weixin_42914706/article/details/115603369