numpy 笔记
numpy 学习笔记
1 ndarray 数组
1) 属性
ndim
功能: 返回数组的维数，等于秩
import numpy as np
a = np.array([1,2,3],dtype=float)
print(a.ndim)
>>>
1
shape
功能: 数组的维度，返回一个元组，这个元组的长度就是维度的数目，即 ndim 属性(秩)
import numpy as np
a = np.array([1,2,3],dtype=float)
print(a.shape)
>>>
(3,)
itemsize
功能: 以字节的形式返回数组中每一个元素的大小, 如float64 的数组 itemsize 属性值为 8
import numpy as np
a = np.array([1,2,3,4],dtype=float)
print(a.itemsize)
>>>
8
size
功能: 获取元素个数
import numpy as np
a = np.array([1,2,3,4],dtype=float)
print(a.size)
>>>
4
dtype
功能: 获取元素类型
import numpy as np
a = np.array([1,2,3,4],dtype=float)
print(a.dtype)
>>>
float64
2) 创建数组
array()
功能: 构建数组
参数: list + dtype(数据类型)
import numpy as np
a = np.array([1,2,3],dtype=float)
print(a)
>>>
[1. 2. 3.]
asarray()
功能: 将不同的数据类型转换为 ndarray
numpy.asarray 类似 numpy.array，但 numpy.asarray 参数只有三个，比 numpy.array 少两个
import numpy as np
x = [1, 2, 3]
a = np.asarray(x)
print(a)
>>>
[1 2 3]
empty()
功能: 创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组
参数: shape(形状) dtype(数据类型) order(行优先/列优先)
import numpy as np
a = np.empty((2,3),dtype=float)
print(a)
>>>
[[1.19287531e-311 1.19287531e-311 1.19287531e-311]
[1.19287531e-311 1.19287531e-311 1.19287531e-311]]
zeros()
功能: 创建一个指定形状（shape）、数据类型（dtype）且数值为零的数组
参数: shape(形状) dtype(数据类型) order(行优先/列优先)
import numpy as np
a = np.zeros((2,3),dtype=float)
print(a)
>>>
[[0. 0. 0.]
[0. 0. 0.]]
ones()
功能: 创建一个指定形状（shape）、数据类型（dtype）且数值为 1 的数组
参数: shape(形状) dtype(数据类型) order(行优先/列优先)
功能: 创建一个指定形状（shape）、数据类型（dtype）且数值为零的数组
参数: shape(形状) dtype(数据类型) order(行优先/列优先)
import numpy as np
a = np.ones((2,3),dtype=float)
print(a)
>>>
[[1. 1. 1.]
[1. 1. 1.]]
arange()
功能: 根据 start 与 stop 指定的范围以及 step 设定的步长，生成一个 ndarray
参数: start - end step(步长) dtype(数据类型)
import numpy as np
a = np.arange(start=0,stop=5,step=1,dtype=float)
print(a)
>>>
[0. 1. 2. 3. 4.]
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(start=1,stop=10,num=10,endpoint=True,retstep=True,dtype=float)
print(a)
>>>
(array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.]), 1.0)
logspace
功能
创建一个于等比数组
格式
np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)
base 参数意思是取对数的时候 log 的下标。
| 参数 | 描述 |
|---|---|
start | 序列的起始值为：base ** start |
stop | 序列的终止值为：base ** stop。如果endpoint为true，该值包含于数列中 |
num | 要生成的等步长的样本数量，默认为50 |
endpoint | 该值为 true 时，数列中中包含stop值，反之不包含，默认是True。 |
base | 对数 log 的底数。 |
dtype | ndarray 的数据类型 |
import numpy as np
# 默认底数是 10
a = np.logspace(start=0,stop=9,num=10,endpoint=True,base=2,dtype=float)
print(a)
>>>
[ 1. 2. 4. 8. 16. 32. 64. 128. 256. 512.]
3) 索引和切片
slince()
功能: 对简单数组进行切片
import numpy as np
a = np.arange(10)
s = slice(start=2,stop=7,step=2) # 从索引 2 开始到索引 7 停止，间隔为2
print(a[s])
: 分隔符
参数: start - stop - step
import numpy as np
a = np.arange(10)
b = a[2:7:2] # 从索引 2 开始到索引 7 停止，间隔为 2
print(b)
>>>
[2 4 6]
4) 广播
广播(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([1, 2, 3]) print(a + b) >>> [[ 1 2 3] [11 12 13] [21 22 23] [31 32 33]]
5) 迭代数组
NumPy 迭代器对象 numpy.nditer 提供了一种灵活访问一个或者多个数组元素的方式。迭代器最基本的任务的可以完成对数组元素的访问。
-
使用 arange() 函数创建一个 2X3 数组，并使用 nditer 对它进行迭代
import numpy as np a = np.arange(6).reshape(2, 3) print('原始数组是：\n',a) print('迭代输出元素：') for x in np.nditer(a): print(x, end=", ") >>> 原始数组是： [[0 1 2] [3 4 5]] 迭代输出元素： 0, 1, 2, 3, 4, 5, -
nditer 切换行序与列序
import numpy as np a = np.arange(0, 60, 5) a = a.reshape(3, 4) print('以 行序 风格顺序排序：') for x in np.nditer(a, order='C'): print(x, end=", ") print('\n以 列序 风格顺序排序：') for x in np.nditer(a, order='F'): print(x, end=", ") >>> 以 行序 风格顺序排序： 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 以 列序 风格顺序排序： 0, 20, 40, 5, 25, 45, 10, 30, 50, 15, 35, 55, -
修改元素的值
nditer 对象有另一个可选参数 op_flags。 默认情况下，nditer 将视待迭代遍历的数组为只读对象（read-only），为了在遍历数组的同时，实现对数组元素值得修改，必须指定 read-write 或者 write-only 的模式。
import numpy as np a = np.arange(0, 60, 5) a = a.reshape(3, 4) print('原始数组是：') print(a) for x in np.nditer(a, op_flags=['readwrite']): x[...] = 2 * x print('修改后的数组是：') print(a) >>> 原始数组是： [[ 0 5 10 15] [20 25 30 35] [40 45 50 55]] 修改后的数组是： [[ 0 10 20 30] [ 40 50 60 70] [ 80 90 100 110]]
6) 数组操作
reshape()
功能: 调整数组大小,改变数组维度
import numpy as np
a = np.array([1,2,3,4],dtype=float)
b = a.reshape(2,2)
print(b)
>>>
[[1. 2.]
[3. 4.]]
flat()
功能: 迭代数组
import numpy as np
a = np.arange(9).reshape(3, 3)
print('原始数组：')
for row in a:
print(row)
# 对数组中每个元素都进行处理，可以使用flat属性，该属性是一个数组元素迭代器：
print('迭代后的数组：')
for element in a.flat:
print(element,end=',')
>>>
原始数组：
[0 1 2]
[3 4 5]
[6 7 8]
迭代后的数组：
0,1,2,3,4,5,6,7,8,
flatten()
功能: 返回一份数组拷贝，对拷贝所做的修改不会影响原始数组
格式: ndarray.flatten(order='C')
参数: order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'K' -- 元素在内存中的出现顺序。
import numpy as np
a = np.arange(8).reshape(2, 4)
print('原数组：')
print(a)
# 默认按行
print('展开的数组：')
print(a.flatten())
print('以 F 风格顺序展开的数组：')
print(a.flatten(order='F'))
>>>
原数组：
[[0 1 2 3]
[4 5 6 7]]
展开的数组：
[0 1 2 3 4 5 6 7]
以 F 风格顺序展开的数组：
[0 4 1 5 2 6 3 7]
ravel()
功能: 展平的数组元素，顺序通常是"C风格"，返回数组视图（view，有点类似 C/C++引用reference的意味）修改会影响原始数组
格式: numpy.ravel(a, order='C')
参数: order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'K' -- 元素在内存中的出现顺序。
import numpy as np
a = np.arange(8).reshape(2, 4)
print('原数组：')
print(a)
print('调用 ravel 函数之后：')
print(a.ravel())
print('以 F 风格顺序调用 ravel 函数之后：')
print(a.ravel(order='F'))
>>>
原数组：
[[0 1 2 3]
[4 5 6 7]]
调用 ravel 函数之后：
[0 1 2 3 4 5 6 7]
以 F 风格顺序调用 ravel 函数之后：
[0 4 1 5 2 6 3 7]
7) 翻转数组
transpose()
功能
numpy.transpose 函数用于对换数组的维度
格式
numpy.transpose(arr, axes)
参数说明
arr：要操作的数组axes：整数列表，对应维度，通常所有维度都会对换。
import numpy as np
a = np.arange(12).reshape(3, 4)
print('原数组：')
print(a)
print('\n')
print('对换数组：')
print(np.transpose(a))
>>>
原数组：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
对换数组：
[[ 0 4 8]
[ 1 5 9]
[ 2 6 10]
[ 3 7 11]]
8) 修改数组维度
expand_dims()
numpy.expand_dims 函数通过在指定位置插入新的轴来扩展数组形状，函数格式如下:
numpy.expand_dims(arr, axis)
参数说明：
arr：输入数组axis：新轴插入的位置
import numpy as np
x = np.array(([1, 2], [3, 4]))
print(x.shape)
y = np.expand_dims(x,axis=0)
print(y.shape)
z = np.expand_dims(x,axis=1)
print(z.shape)
l = np.expand_dims(x,axis=2)
print(l.shape)
>>>
(2, 2)
(1, 2, 2)
(2, 1, 2)
(2, 2, 1)
squeeze()
numpy.squeeze 函数从给定数组的形状中删除一维的条目，函数格式如下：
numpy.squeeze(arr, axis)
参数说明
arr：输入数组axis：整数或整数元组，用于选择形状中一维条目的子集
import numpy as np
x = np.arange(9).reshape(1,3,3)
print(x.shape)
y = np.squeeze(x,axis=0)
print(y.shape)
>>>
(1, 3, 3)
(3, 3)
9) 连接数组
concatenate()
concatenate 函数用于沿指定轴连接相同形状的两个或多个数组，格式如下：
numpy.concatenate((a1, a2, ...), axis)
参数说明
a1, a2, ...：相同类型的数组axis：沿着它连接数组的轴，默认为 0
import numpy as np
a = np.array([[1, 2], [3, 4]])
print('第一个数组：')
print(a)
b = np.array([[5, 6], [7, 8]])
print('第二个数组：')
print(b)
# 两个数组的维度相同
print('沿轴 0 连接两个数组：')
print(np.concatenate((a, b)))
print('沿轴 1 连接两个数组：')
print(np.concatenate((a, b), axis=1))
>>>
第一个数组：
[[1 2]
[3 4]]
第二个数组：
[[5 6]
[7 8]]
沿轴 0 连接两个数组：
[[1 2]
[3 4]
[5 6]
[7 8]]
沿轴 1 连接两个数组：
[[1 2 5 6]
[3 4 7 8]]
stack()
numpy.stack 函数用于沿新轴连接数组序列，格式如下：
numpy.stack(arrays, axis)
参数说明
arrays相同形状的数组序列axis：返回数组中的轴，输入数组沿着它来堆叠
import numpy as np
a = np.array([[1, 2], [3, 4]])
print('第一个数组：')
print(a)
b = np.array([[5, 6], [7, 8]])
print('第二个数组：')
print(b)
print('沿轴 0 堆叠两个数组：')
print(np.stack((a, b), 0))
print('沿轴 1 堆叠两个数组：')
print(np.stack((a, b), 1))
>>>
第一个数组：
[[1 2]
[3 4]]
第二个数组：
[[5 6]
[7 8]]
沿轴 0 堆叠两个数组：
[[[1 2]
[3 4]]
[[5 6]
[7 8]]]
沿轴 1 堆叠两个数组：
[[[1 2]
[5 6]]
[[3 4]
[7 8]]]
hstack()
numpy.hstack 是 numpy.stack 函数的变体，它通过水平堆叠来生成数组。
import numpy as np
a = np.array([[1, 2], [3, 4]])
print('第一个数组：')
print(a)
b = np.array([[5, 6], [7, 8]])
print('第二个数组：')
print(b)
print('水平堆叠：')
c = np.hstack((a, b))
print(c)
>>>
第一个数组：
[[1 2]
[3 4]]
第二个数组：
[[5 6]
[7 8]]
水平堆叠：
[[1 2 5 6]
[3 4 7 8]]
vstack()
numpy.vstack 是 numpy.stack 函数的变体，它通过垂直堆叠来生成数组。
import numpy as np
a = np.array([[1, 2], [3, 4]])
print('第一个数组：')
print(a)
b = np.array([[5, 6], [7, 8]])
print('第二个数组：')
print(b)
print('竖直堆叠：')
c = np.vstack((a, b))
print(c)
>>>
第一个数组：
[[1 2]
[3 4]]
第二个数组：
[[5 6]
[7 8]]
竖直堆叠：
[[1 2]
[3 4]
[5 6]
[7 8]]
10)分割数组
split()
split 函数沿特定的轴将数组分割为子数组，格式如下：
numpy.split(ary, indices_or_sections, axis)
参数说明：
ary：被分割的数组indices_or_sections：如果是一个整数，就用该数平均切分，如果是一个数组，为沿轴切分的位置（左开右闭）axis：设置沿着哪个方向进行切分，默认为 0，横向切分，即水平方向。为 1 时，纵向切分，即竖直方向。
import numpy as np
a = np.arange(9)
print ('第一个数组：')
print (a)
print ('\n')
print ('将数组分为三个大小相等的子数组：')
b = np.split(a,3)
print (b)
print ('\n')
print ('将数组在一维数组中表明的位置分割：')
b = np.split(a,[4,7])
print (b)
>>>
第一个数组：
[0 1 2 3 4 5 6 7 8]
将数组分为三个大小相等的子数组：
[array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])]
将数组在一维数组中表明的位置分割：
[array([0, 1, 2, 3]), array([4, 5, 6]), array([7, 8])]
hsplit()
numpy.hsplit 函数用于水平分割数组，通过指定要返回的相同形状的数组数量来拆分原数组。
import numpy as np
harr = np.floor(10 * np.random.random((2, 6)))
print ('原array：')
print(harr)
print ('拆分后：')
print(np.hsplit(harr, 3))
>>>
原array：
[[8. 7. 5. 5. 6. 2.]
[6. 3. 5. 7. 3. 2.]]
拆分后：
[array([[8., 7.],
[6., 3.]]),
array([[5., 5.],
[5., 7.]]),
array([[6., 2.],
[3., 2.]])]
vsplit()
vsplit 沿着垂直轴分割，其分割方式与hsplit用法相同。
import numpy as np
a = np.arange(16).reshape(4, 4)
print('第一个数组：')
print(a)
print('竖直分割：')
b = np.vsplit(a, 2)
print(b)
>>>
第一个数组：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
竖直分割：
[array([[0, 1, 2, 3],
[4, 5, 6, 7]]),
array([[ 8, 9, 10, 11],
[12, 13, 14, 15]])]
11) 数组的添加与删除
resize()
resize 函数返回指定大小的新数组。如果新数组大小大于原始大小，则包含原始数组中的元素的副本。
numpy.resize(arr, shape)
参数说明
arr：要修改大小的数组shape：返回数组的新形状
import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6]])
print(a)
print(a.shape)
print ('修改后：')
b = np.resize(a, (3, 2))
print(b)
print(b.shape)
>>>
[[1 2 3]
[4 5 6]]
(2, 3)
修改后：
[[1 2]
[3 4]
[5 6]]
(3, 2)
append()
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('数组：')
print(a)
print('向数组添加元素：')
print(np.append(a, [7, 8, 9]))
print('沿轴 0 添加元素：')
print(np.append(a, [[7, 8, 9]], axis=0))
print('沿轴 1 添加元素：')
print(np.append(a, [[7, 8, 9], [7, 8, 9]], axis=1))
>>>
数组：
[[1 2 3]
[4 5 6]]
向数组添加元素：
[1 2 3 4 5 6 7 8 9]
沿轴 0 添加元素：
[[1 2 3]
[4 5 6]
[7 8 9]]
沿轴 1 添加元素：
[[1 2 3 7 8 9]
[4 5 6 7 8 9]]
insert()
insert 函数在给定索引之前，沿给定轴在输入数组中插入值。
如果值的类型转换为要插入，则它与输入数组不同。 插入没有原地的，函数会返回一个新数组。 此外，如果未提供轴，则输入数组会被展开。
numpy.insert(arr, obj, values, axis)
参数说明
arr：输入数组obj：在其之前插入值的索引values：要插入的值axis：沿着它插入的轴，如果未提供，则输入数组会被展开
import numpy as np
a = np.array([[1, 2], [3, 4], [5, 6]])
print('第一个数组：')
print(a)
print('未传递 Axis 参数。 在删除之前输入数组会被展开。')
print(np.insert(a, 3, [11, 12]))
print('传递了 Axis 参数。 会广播值数组来配输入数组。')
print('沿轴 0 广播：')
print(np.insert(a, 1, [11], axis=0))
print('沿轴 1 广播：')
print(np.insert(a, 1, 11, axis=1))
>>>
第一个数组：
[[1 2]
[3 4]
[5 6]]
未传递 Axis 参数。 在删除之前输入数组会被展开。
[ 1 2 3 11 12 4 5 6]
传递了 Axis 参数。 会广播值数组来配输入数组。
沿轴 0 广播：
[[ 1 2]
[11 11]
[ 3 4]
[ 5 6]]
沿轴 1 广播：
[[ 1 11 2]
[ 3 11 4]
[ 5 11 6]]
delete
numpy.delete 函数返回从输入数组中删除指定子数组的新数组。 与 insert() 函数的情况一样，如果未提供轴参数，则输入数组将展开。
Numpy.delete(arr, obj, axis)
参数说明：
arr：输入数组obj：可以被切片，整数或者整数数组，表明要从输入数组删除的子数组axis：沿着它删除给定子数组的轴，如果未提供，则输入数组会被展开
import numpy as np
a = np.arange(12).reshape(3, 4)
print('第一个数组：')
print(a)
print('未传递 Axis 参数。 在插入之前输入数组会被展开。')
print(np.delete(a, 5))
print('删除第二列：')
print(np.delete(a, 1, axis=1))
print('包含从数组中删除的替代值的切片：')
a = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(np.delete(a, np.s_[::2]))
>>>
第一个数组：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
未传递 Axis 参数。 在插入之前输入数组会被展开。
[ 0 1 2 3 4 6 7 8 9 10 11]
删除第二列：
[[ 0 2 3]
[ 4 6 7]
[ 8 10 11]]
包含从数组中删除的替代值的切片：
[ 2 4 6 8 10]
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([5, 2, 6, 2, 7, 5, 6, 8, 2, 9])
print('第一个数组：')
print(a)
print('第一个数组的去重值：')
u = np.unique(a)
print(u)
print('去重数组的索引数组：')
u, indices = np.unique(a, return_index=True)
print(indices)
print('我们可以看到每个和原数组下标对应的数值：')
print(a)
print('去重数组的下标：')
u, indices = np.unique(a, return_inverse=True)
print(u)
print('下标为：')
print(indices)
print('使用下标重构原数组：')
print(u[indices])
print('返回去重元素的重复数量：')
u, indices = np.unique(a, return_counts=True)
print(u)
print(indices)
>>>
第一个数组：
[5 2 6 2 7 5 6 8 2 9]
第一个数组的去重值：
[2 5 6 7 8 9]
去重数组的索引数组：
[1 0 2 4 7 9]
我们可以看到每个和原数组下标对应的数值：
[5 2 6 2 7 5 6 8 2 9]
去重数组的下标：
[2 5 6 7 8 9]
下标为：
[1 0 2 0 3 1 2 4 0 5]
使用下标重构原数组：
[5 2 6 2 7 5 6 8 2 9]
返回去重元素的重复数量：
[2 5 6 7 8 9]
[3 2 2 1 1 1]
OVER~
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
