Python Numpy笔记
Ndarray 对象
N 维数组类型
numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
- copy 可选，默认为true，对象是否被复制。
- order C（按行）、F（按列）或A（任意，默认）。
- subok 默认返回一个与基类类型一致的数组。
- ndimin 指定返回数组的最小维数。
>>> a=np.array([(["-inf"]*5) for i in range(3)],dtype=np.float)
>>> a
array([[-inf, -inf, -inf, -inf, -inf],
[-inf, -inf, -inf, -inf, -inf],
[-inf, -inf, -inf, -inf, -inf]])
>>> type(a)
<class 'numpy.ndarray'>
>>> a.dtype
dtype('float64')
>>> a.shape
(3, 5)
>>> a[0][:-1]
array([-inf, -inf, -inf, -inf])
>>> a[0][-1]=1
>>> a
array([[-inf, -inf, -inf, -inf, 1.],
[-inf, -inf, -inf, -inf, -inf],
[-inf, -inf, -inf, -inf, -inf]])
>>> a[0][:-1]=0
>>> a
array([[ 0., 0., 0., 0., 1.],
[-inf, -inf, -inf, -inf, -inf],
[-inf, -inf, -inf, -inf, -inf]])
# 将列表转换为 ndarray:
>>> x = [1,2,3]
>>> a = np.asarray(x)
>>> a
[1 2 3]
# 将元组转换为 ndarray:
>>> x = (1,2,3)
>>> a = np.asarray(x)
>>> a
[1 2 3]
# 0元素填充
>>> x = np.zeros(5)
[ 0. 0. 0. 0. 0.]
>>> x = np.ones(5)
[ 1. 1. 1. 1. 1.]
数据类型对象 (dtype)
numpy.dtype(object, align, copy)
>>> student = np.dtype([('name','S20'), ('age', np.float), ('marks', np.int8)])
>>> a = np.array([('abc', 21, 50),('xyz', 18, 75)], dtype = student)
>>> a
array([(b'abc', 21., 50), (b'xyz', 18., 75)],
dtype=[('name', 'S20'), ('age', '<f8'), ('marks', 'i1')])
- ‘b’：布尔值
- ‘i’：符号整数
- ‘u’：无符号整数
- ‘f’：浮点
- ‘c’：复数浮点
- ‘m’：时间间隔
- ‘M’：日期时间
- ‘O’：Python 对象
- ‘S’, ‘a’：字节串
- ‘U’：Unicode
- ‘V’：原始数据（void）
函数
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 : 包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性。
range --> arange/ fromiter
import numpy as np
list = range(5)
print list
>>> [0, 1, 2, 3, 4]
import numpy as np
x = np.arange(5, dtype = float)
print x
>>> [0. 1. 2. 3. 4.]
import numpy as np
list = range(5)
it = iter(list)
# 使用迭代器创建 ndarray
x = np.fromiter(it, dtype = float)
print x
>>> [0. 1. 2. 3. 4.]
split --> frombuffer
import numpy as np
s = 'Hello World'
a = np.frombuffer(s, dtype = 'S1')
>>> ['H' 'e' 'l' 'l' 'o' ' ' 'W' 'o' 'r' 'l' 'd']
切片和索引
numpy.linspace(start, stop, num, endpoint, retstep, dtype)
- endpoint : 序列中是否包含stop值，默认为ture
- retstep : 如果为true，返回样例，以及连续数字之间的步长
- dtype : 输出ndarray的数据类型
x = np.linspace(10,20,5)
print(x)
>>>[10. 12.5 15. 17.5 20.]
x = np.linspace(10,20,5, endpoint = False)
print(x)
>>>[10. 12. 14. 16. 18.]
slice(start, stop, num)
a = np.arange(10)
s = slice(2,7,2)
print(a[s])
>>>[2 4 6]
b = a[2:7:2]
print(b)
>>>[2 4 6]
切片还可以包括省略号 …，来使选择元组的长度与数组的维度相同。
import numpy as np
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print (a[...,1]) # 第2列元素
>>>[2 4 5]
print (a[1,...]) # 第2行元素
>>>[3 4 5]
print (a[...,1:]) # 第2列及剩下的所有元素
>>>[[2 3]
[4 5]
[5 6]]
numpy.logscale(start, stop, num, endpoint, base, dtype)
此函数返回一个ndarray对象，其中包含在对数刻度上均匀分布的数字。 刻度的开始和结束端点是某个底数的幂.
base 对数空间的底数，默认为10
a = np.logspace(1,10,num = 10, base = 2)
>>>[ 2. 4. 8. 16. 32. 64. 128. 256. 512. 1024.]
更多索引方式：http://www.runoob.com/numpy/numpy-advanced-indexing.html
数值计算
np.add(a,b),np.subtract(a,b),np.multiply(a,b),np.divide(a,b)
当运算中的 2 个数组的形状不同时，numpy 将自动触发广播机制。如：
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]]
b = np.array([1,2,3])
bb = np.tile(b, (4, 1))
print(bb)
>>>[[1 2 3]
[1 2 3]
[1 2 3]
[1 2 3]]
print(a+bb)
>>>[[ 1 2 3]
[11 12 13]
[21 22 23]
[31 32 33]]
遍历
for x in np.nditer(a, order=‘F’):Fortran order，即是列序优先；
for x in np.nditer(a.T, order=‘C’):C order，即是行序优先；
import numpy as np
a = np.arange(0,60,5).reshape(3,4)
>>>array([[ 0, 5, 10, 15],
[20, 25, 30, 35],
[40, 45, 50, 55]])
for x in np.nditer(a.copy(order='C')):
print (x, end=", " )
>>>0, 1, 2, 3, 4, 5,
for x in np.nditer(a.copy(order='F')):
>>>0, 3, 1, 4, 2, 5,
nditer 对象有另一个可选参数 op_flags。 默认情况下，nditer 将视待迭代遍历的数组为只读对象（read-only），为了在遍历数组的同时，实现对数组元素值得修改，必须指定 read-write 或者 write-only 的模式。
import numpy as np
a = np.arange(0,60,5).reshape(3,4)
>>>[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
for x in np.nditer(a, op_flags=['readwrite']):
x[...]=2*x
>>>[[ 0 10 20 30]
[ 40 50 60 70]
[ 80 90 100 110]]
如果两个数组是可广播的，nditer 组合对象能够同时迭代它们。 假设数组 a 的维度为 3X4，数组 b 的维度为 1X4 ，则使用以下迭代器（数组 b 被广播到 a 的大小）。
import numpy as np
a = np.arange(0,60,5).reshape(3,4)
>>>[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
b = np.array([1, 2, 3, 4], dtype = int)
>>> [1 2 3 4]
for x,y in np.nditer([a,b]):
print ("%d:%d" % (x,y), end=", " )
>>> 0:1, 5:2, 10:3, 15:4, 20:1, 25:2, 30:3, 35:4, 40:1, 45:2, 50:3, 55:4,
数组操作
reshape 不改变数据的条件下修改形状
flat 数组元素迭代器
a = np.arange(8).reshape(4,2)
for row in a:
print (row)
>>>[0 1 2]
[3 4 5]
[6 7 8]
for element in a.flat:
print (element)
0
1
2
3
4
5
6
7
8
ndarray.flatten 返回一份数组拷贝，对拷贝所做的修改不会影响原始数组，格式如下：
numpy.ravel() 展平的数组元素，顺序通常是"C风格"，返回的是数组视图（view，有点类似 C/C++引用reference的意味），修改会影响原始数组。
numpy.ravel(a, order=‘C’)
ndarray.T 对换数组的维度
swapaxes 对换数组的两个轴
现在交换轴 0（深度方向）到轴 2（宽度方向）
print (np.swapaxes(a, 2, 0))
#a[a1][a2][a3]-->a[a3][a2][a1]
>>> import numpy as np
>>> x = np.array([[1], [2], [3]])
>>> y = np.array([4, 5, 6])
>>> b = np.broadcast(x,y)
>>> b
<numpy.broadcast object at 0x000002B2EA710BA0>
>>> r,c = b.iters
>>> r
<numpy.flatiter object at 0x000002B2EACB5BD0>
>>> c
<numpy.flatiter object at 0x000002B2EACC6C40>
>>> print (next(r), next(c))#类似指针操作
1 4
>>> print (next(r), next(c))
1 5
>>> print (next(r), next(c))
1 6
>>> print (next(r), next(c))
2 4
>>> print (next(r), next(c))
2 5
>>> print (next(r), next(c))
numpy.broadcast_to(array, shape, subok)
函数将数组广播到新形状
>>> a = np.arange(4).reshape(1,4)
>>> b=np.broadcast_to(a,(4,4))
>>> b
array([[0, 1, 2, 3],
[0, 1, 2, 3],
[0, 1, 2, 3],
[0, 1, 2, 3]])
numpy.expand_dims(arr, axis)
- arr：输入数组
- axis：新轴插入的位置
numpy.squeeze(arr, axis)
函数从给定数组的形状中删除一维的条目
- arr：输入数组
- axis：整数或整数元组，用于选择形状中一维条目的子集
y = np.squeeze(x,1)
>>> x = np.arange(9).reshape(1,3,3)
>>> x
array([[[0, 1, 2],
[3, 4, 5],
[6, 7, 8]]])
>>> y = np.squeeze(x,0)
>>> y
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
>>> y = np.expand_dims(x, axis = 0)
>>> y
array([[[[0, 1, 2],
[3, 4, 5],
[6, 7, 8]]]])
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]])
>>> np.concatenate((a,b))
array([[1, 2],
[3, 4],
[5, 6],
[7, 8]])
>>> np.concatenate((a,b),axis = 1)
array([[1, 2, 5, 6],
[3, 4, 7, 8]])
numpy.stack(arrays, axis)
沿新轴连接数组序列
- arrays相同形状的数组序列
- axis：返回数组中的轴，输入数组沿着它来堆叠
>>> a = np.array([[1,2],[3,4]])
>>> b = np.array([[5,6],[7,8]])
>>> print (np.stack((a,b),1))
[[[1 2]
[5 6]]
[[3 4]
[7 8]]]
>>> print (np.stack((a,b),0))
[[[1 2]
[3 4]]
[[5 6]
[7 8]]]
>>> print (np.stack((a,b),2))
[[[1 5]
[2 6]]
[[3 7]
[4 8]]]
numpy.hsplit 函数用于水平分割数组
numpy.vsplit 沿着垂直轴分割
>>> a
array([[ 0, 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10, 11]])
>>> np.hsplit(a, 3)
[array([[0, 1],
[6, 7]]), array([[2, 3],
[8, 9]]), array([[ 4, 5],
[10, 11]])]
>>> np.vsplit(a, 2)
[array([[0, 1, 2, 3, 4, 5]]), array([[ 6, 7, 8, 9, 10, 11]])]
numpy.resize(arr, shape)
函数返回指定大小的新数组。
如果新数组大小大于原始大小，则包含原始数组中的元素的副本。
numpy.append(arr, values, axis=None)
>>> a=np.append(a,[[7,8,9]],axis=0)
>>> a = np.array([[1,2,3],[4,5,6]])
>>> print (np.append(a, [7,8,9]))
[1 2 3 4 5 6 7 8 9]
>>> print (np.append(a, [[7,8,9]],axis = 0))
[[1 2 3]
[4 5 6]
[7 8 9]]
>>> print (np.append(a, [[5,5,5],[7,8,9]],axis = 1))
[[1 2 3 5 5 5]
[4 5 6 7 8 9]]
numpy.insert(arr, obj, values, axis)
函数在给定索引之前，沿给定轴在输入数组中插入值
Numpy.delete(arr, obj, axis)
函数返回从输入数组中删除指定子数组的新数组。
- arr：输入数组
- obj：在其之前插入值的索引
- values：要插入的值
- axis：沿着它插入的轴，如果未提供，则输入数组会被展开
>>> a = np.array([[1,2],[3,4],[5,6]])
>>> print (np.insert(a,3,[11,12]))
[ 1 2 3 11 12 4 5 6]
>>> print (np.insert(a,1,[11],axis = 0))
[[ 1 2]
[11 11]
[ 3 4]
[ 5 6]]
>>> print (np.insert(a,1,11,axis = 1))
[[ 1 11 2]
[ 3 11 4]
[ 5 11 6]]
去重
numpy.unique(arr, return_index, return_inverse, return_counts)
函数用于去除数组中的重复元素。
- arr：输入数组，如果不是一维数组则会展开
- return_index：如果为true，返回新列表元素在旧列表中的位置（下标），并以列表形式储
- return_inverse：如果为true，返回旧列表元素在新列表中的位置（下标），并以列表形式储
- return_counts：如果为true，返回去重数组中的元素在原数组中的出现次数
>>> a = np.array([5,2,6,2,7,5,6,8,2,9])
>>> np.unique(a)
array([2, 5, 6, 7, 8, 9])
>>> np.unique(a, return_index = True)
(array([2, 5, 6, 7, 8, 9]), array([1, 0, 2, 4, 7, 9], dtype=int64))
>>> np.unique(a,return_inverse = True)
(array([2, 5, 6, 7, 8, 9]), array([1, 0, 2, 0, 3, 1, 2, 4, 0, 5], dtype=int64))
>>> np.unique(a,return_counts = True)
(array([2, 5, 6, 7, 8, 9]), array([3, 2, 2, 1, 1, 1], dtype=int64))
字符串函数
#连接两个字符串
>>> print (np.char.add(['hello', 'hi'],[' abc', ' xyz']))
['hello abc' 'hi xyz']
#函数执行多重连接。
>>> print (np.char.multiply('Runoob ',3))
Runoob Runoob Runoob
#函数用于将字符串居中，并使用指定字符在左侧和右侧进行填充。
>>> print (np.char.center('Runoob', 20,fillchar = '*'))
*******Runoob*******
#将字符串的第一个字母转换为大写：
>>> print (np.char.capitalize('runoob'))
Runoob
#将字符串的每个单词的第一个字母转换为大写
>>> print (np.char.title('i like runoob'))
I Like Runoob
#对数组的每个元素转换为小写
>>> print (np.char.lower(['RUNOOB','GOOGLE']))
['runoob' 'google']
#对数组的每个元素转换为大写
>>> print (np.char.upper(['runoob','google']))
['RUNOOB' 'GOOGLE']
#通过指定分隔符对字符串进行分割，并返回数组。
>>> print (np.char.split ('www.runoob.com', sep = '.'))
['www', 'runoob', 'com']
#函数以换行符作为分隔符来分割字符串，并返回数组。\n，\r，\r\n 都可用作换行符。
>>> print (np.char.splitlines('i\nlike runoob?'))
['i', 'like runoob?']
#函数用于移除开头或结尾处的特定字符。
>>> print (np.char.strip(['arunooba','admin','java'],'a'))
['runoob' 'dmin' 'jav']
#函数通过指定分隔符来连接数组中的元素或字符串
>>> print (np.char.join([':','-'],['runoob','google']))
['r:u:n:o:o:b' 'g-o-o-g-l-e']
# 函数使用新字符串替换字符串中的所有子字符串。
>>> print (np.char.replace ('i like runoob', 'oo', 'cc'))
i like runccb
# 函数对数组中的每个元素调用 str.encode 函数。 默认编码是 utf-8
#函数对编码的元素进行 str.decode() 解码。
>>> a = np.char.encode('runoob', 'cp500')
>>> a
array(b'\x99\xa4\x95\x96\x96\x82', dtype='|S6')
>>> print (np.char.decode(a,'cp500'))
runoob
舍入函数
>>> a = np.array([1.0, 5.55, 123, 0.567, 25.532])
#函数返回指定数字的四舍五入值。舍入的小数位数。 默认值为0
>>> print (np.around(a))
[ 1. 6. 123. 1. 26.]
>>> print (np.around(a, decimals = 1))
[ 1. 5.6 123. 0.6 25.5]
>>> print (np.floor(a))
[ 1. 5. 123. 0. 25.]
#返回数字的下舍整数。
>>> print (np.floor(a))
[ 1. 5. 123. 0. 25.]
#返回数字的上入整数。
>>> print (np.ceil(a))
[ 1. 6. 123. 1. 26.]
其他运算函数
numpy.reciprocal() 函数返回参数逐元素的倒数。如 1/4 倒数为 4/1。
>>> a = np.array([0.25, 1.33, 1, 100])
>>> print (np.reciprocal(a))
[4. 0.7518797 1. 0.01 ]
numpy.power() 函数将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂。
>>> a = np.array([10,100,1000])
>>> b = np.array([1,2,3])
>>> print (np.power(a,b))
[ 10 10000 1000000000]
numpy.mod() 计算输入数组中相应元素的相除后的余数。 函数 numpy.remainder() 也产生相同的结果。
>>> a = np.array([10,20,30])
>>> b = np.array([3,5,7])
>>> print (np.mod(a,b))
[1 0 2]
统计函数
>>> a = np.array([[10, 7, 4], [3, 2, 1]])
>>> a
array([[10, 7, 4],
[ 3, 2, 1]])
#numpy.amin() 用于计算数组中的元素沿指定轴的最小值。
#numpy.amax() 用于计算数组中的元素沿指定轴的最大值。
>>> print (np.amin(a,1))
[4 1]
>>> print (np.amin(a,0))
[3 2 1]
#numpy.ptp()函数计算数组中元素最大值与最小值的差（最大值 - 最小值）。
>>> print (np.ptp(a))
9
>>> print (np.ptp(a, axis = 1))
[6 2]
numpy.percentile()百分位数是统计中使用的度量，表示小于这个值的观察值的百分比。q: 要计算的百分位数，在 0 ~ 100 之间。
>>> print (np.percentile(a, 50))
3.5
>>> print (np.percentile(a, 50, axis=0))
[6.5 4.5 2.5]
#numpy.median() 函数用于计算数组 a 中元素的中位数（中值）
>>> print (np.median(a))
3.5
>>> print (np.median(a, axis = 0))
[6.5 4.5 2.5]
#numpy.mean() 函数返回数组中元素的算术平均值。
>>> print (np.mean(a))
4.5
#numpy.average() 函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值。
>>> a = np.array([1,2,3,4])
>>> wts = np.array([4,3,2,1])
>>> print (np.average(a,weights = wts))
2.0
#std = sqrt(mean((x - x.mean())**2))
>>> print(np.std(a))
1.118033988749895
#var = mean((x - x.mean())**2)
>>> print(np.var(a))
1.25
NumPy 排序、条件刷选函数
numpy.sort(a, axis, kind, order)
函数返回输入数组的排序副本。
sort_complex(a) 对复数按照先实部后虚部的顺序进行排序。
- a: 要排序的数组
- axis: 沿着它排序数组的轴，如果没有数组会被展开，沿着最后的轴排序， axis=0 按列，axis=1 按行
- kind: 默认为 ‘quicksort’ ('快速排序) ‘mergesort’（归并排序） ‘heapsort’（堆排序）
- order: 如果数组包含字段，则是要排序的字段
#按列排序：
>>> a = np.array([[3,7],[9,1]])
>>> print (np.sort(a, axis = 0, kind='mergesort'))
[[3 1]
[9 7]]
#name排序
>>> dt = np.dtype([('name', 'S10'),('age', int)])
>>> a = np.array([("raju",21),("anil",25),("ravi", 17), ("amar",27)], dtype = dt)
>>> print (np.sort(a, order = 'name'))
[(b'amar', 27) (b'anil', 25) (b'raju', 21) (b'ravi', 17)]
#numpy.argsort() 函数返回的是数组值从小到大的索引值。
>>> a = np.array([[3,7],[9,1]])
>>> print(np.argsort(a))
[[0 1]
[1 0]]
#numpy.lexsort() 用于对多个序列进行排序。
>>> a= [5,4,4,3,2,1]
>>> b= [1,1,2,2,3,3]
>>> i= np.lexsort((a,b))
>>> print([str(a[ii])+str(b[ii]) for ii in i])
['41', '51', '32', '42', '13', '23']
# 将数组 a 中所有元素（包括重复元素）从小到大排列，比第3小的放在前面，大的放在后面
>>> a = np.array([3, 4, 2, 1])
>>> np.partition(a, 3)
array([2, 1, 3, 4])
#numpy.argmax() 和 numpy.argmin()函数分别沿给定轴返回最大和最小元素的索引。
>>> a = np.array([[30,40,70],[80,20,10],[50,90,60]])
>>> print (a.flatten())
[30 40 70 80 20 10 50 90 60]
>>> print (np.argmax(a))
7
#numpy.nonzero() 函数返回输入数组中非零元素的索引。竖着看。
>>>a = np.array([[30,40,0],[0,20,10],[50,0,60]])
>>>print (np.nonzero (a))
(array([0, 0, 1, 1, 2, 2]), array([0, 1, 1, 2, 0, 2]))
#numpy.where() 函数返回输入数组中满足给定条件的元素的索引。
>>> np.where(a == 3)
(array([0], dtype=int64), array([2], dtype=int64))
返回满足条件的
numpy.extract() 函数根据某个条件从数组中抽取元素，返回满条件的元素。
>>> x = np.arange(9.).reshape(3, 3)
>>> condition = np.mod(x,2) == 0
>>> print (np.extract(condition, x))
[0. 2. 4. 6. 8.]
线性代数
- dot 两个数组的点积，即元素对应相乘。
- vdot 两个向量的点积
- inner 两个数组的内积
- matmul 两个数组的矩阵积
- determinant 数组的行列式
- solve 求解线性矩阵方程
- inv 计算矩阵的乘法逆矩阵
I/O
#npz文件导入与保存
>>> import numpy as np
>>> a = np.array([1,2,3,4,5])
>>> np.save('outfile.npy',a)
>>> b = np.load('outfile.npy')
>>> b
array([1, 2, 3, 4, 5])
>> b= np.array([6,7,8,9,10])
np.savez('outfile.npy',a,b)
#txt文件保存与导入
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)
plot函数类似matlab
具体: http://www.runoob.com/numpy/numpy-matplotlib.html
参考资料：
http://www.runoob.com/numpy/
https://blog.csdn.net/a373595475/article/details/79580734
学习笔记，很大一部分是借鉴的，如有错误欢迎指出。
扫一扫
310
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
