numpy使用总结

1.numpy概述

numpy（numeric python）是一种开源的数值计算扩展库

牛逼之处在于它能节约计算时间和内存使用

https://numpy.org/doc/stable/reference/[官方文档]

2.numpy数组对象

NumPy 最重要的一个特点是其 N 维数组对象 ndarray，它是一系列同类型数据的集合，以 0 下标为开始进行集合中元素的索引。
ndarray 对象是用于存放同类型元素的多维数组。

import  numpy as np

ndarr = np.arange(24).reshape(2,3,4) # 生成一个三维数组
ndarr

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]]])

type(ndarr) # 查看类型

numpy.ndarray

ndarr.ndim # 查看数组维度个数

ndarr.shape # 查看数组维度

(2, 3, 4)

ndarr.size # 查看元素个数

ndarr.dtype # 查看元素类型

dtype('int32')

np.ones((3,4)) # 创建全0shuzu

array([[1., 1., 1., 1.],[1., 1., 1., 1.],[1., 1., 1., 1.]])

np.empty((3,4)) # 创建全空数组

array([[8.46775816e-312, 2.81617418e-322, 0.00000000e+000,0.00000000e+000],[7.56587583e-307, 6.82116729e-043, 5.59150575e-091,6.40179205e+170],[1.00567909e-047, 5.15973668e-066, 6.48224660e+170,4.93432906e+257]])

np.arange(1,20,5) # 创建一个从1开始，间隔5的数组

array([ 1,  6, 11, 16])

np.array([1,2,3,4],float) # 定义浮点类型

array([1., 2., 3., 4.])

np.ones((2,3),'float64') # 定义浮点类型64位

array([[1., 1., 1.],[1., 1., 1.]])

df1 = np.arange(0,1,0.1)
df1

array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9])

b = np.linspace(0,1,10)
b

array([0.        , 0.11111111, 0.22222222, 0.33333333, 0.44444444,0.55555556, 0.66666667, 0.77777778, 0.88888889, 1.        ])

c = np.linspace(0,1,10,endpoint = False)
c

array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9])

d = np.logspace(0,1,5)
d

array([ 1.        ,  1.77827941,  3.16227766,  5.62341325, 10.        ])

np.empty((2,3),np.int) # 创建一个2*3整型空矩阵，只分配内存

array([[  179652464,         399,           0],[          0,           1, -2147483648]])

np.zeros(4,np.int) # 创建一长度为4，值全为0的矩阵

array([0, 0, 0, 0])

np.full(4,np.pi) # 创一个长度为4，值全为π的矩阵

array([3.14159265, 3.14159265, 3.14159265, 3.14159265])

def func(i):print(i)return i % 4 +1 # 表示取余
np.fromfunction(func,(10,)) # fromfunction第一个参数接收计算函数，第二个参数接收数组的形状。

[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]array([1., 2., 3., 4., 1., 2., 3., 4., 1., 2.])

ndarray的元素具有相同的元素类型。常用的有int（整型），float（浮点型），
complex（复数型）

a = np.array([1,2,3,4],dtype = float)
a.dtype

dtype('float64')

b = np.array([[1,2,3,3],[4,5,6,6],[7,8,9,9]])
b.shape

(3, 4)

b.reshape((2,6)) # 重定义形状

array([[1, 2, 3, 3, 4, 5],[6, 6, 7, 8, 9, 9]])

c = np.arange(10)
c

array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

c[5] # 取第六个元素

c[0:2] # 取第一二个元素

array([0, 1])

c[:-1] # 取前10-1个元素

array([0, 1, 2, 3, 4, 5, 6, 7, 8])

c[1:-1:2] # 从第二个元素开始，到最后前一个元素结束，每间隔2取一个元素

array([1, 3, 5, 7])

c[::-1] # 逆着取

array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])

c[2:4] = 100,1001 # 更改元素
c

array([   0,    1,  100, 1001,    4,    5,    6,    7,    8,    9])

ndarray通过切片产生一个新的数组b，b和a共享同一块数据存储空间。

b = c[3:7]
b == c

C:\Users\kingS\anaconda3\lib\site-packages\ipykernel_launcher.py:2: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.False

a = np.arange(0,60,10).reshape(-1,1)+np.arange(0,6)
a

array([[ 0,  1,  2,  3,  4,  5],[10, 11, 12, 13, 14, 15],[20, 21, 22, 23, 24, 25],[30, 31, 32, 33, 34, 35],[40, 41, 42, 43, 44, 45],[50, 51, 52, 53, 54, 55]])

a1 =  np.arange(0,60,10).reshape(-1,1)
a1.shape

(6, 1)

a[0,3:5]

array([3, 4])

a[2,2:4]

array([22, 23])

a[2::2,::2] # 从第2行开始，每间隔2取的行，再取列，从0列开始间隔2，取列。

array([[20, 22, 24],[40, 42, 44]])

persontype = np.dtype({'names':['name', 'age', 'weight'],
'formats':['S30','i', 'f']})
a = np.array([("Zhang", 32, 75.5), ("Wang", 24, 65.2)],
dtype=persontype)
print(a[0])

(b'Zhang', 32, 75.5)

3.ufunc函数

ufunc是universal function的简称，它是一种能对数组每个元素进
行运算的函数。NumPy的许多ufunc函数都是用C语言实现的，因此
它们的运算速度非常快。

1）四则运算

x = np.linspace(0,2*np.pi,10)
x

array([0.        , 0.6981317 , 1.3962634 , 2.0943951 , 2.7925268 ,3.4906585 , 4.1887902 , 4.88692191, 5.58505361, 6.28318531])

y = np.sin(x)
y

array([ 0.00000000e+00,  6.42787610e-01,  9.84807753e-01,  8.66025404e-01,3.42020143e-01, -3.42020143e-01, -8.66025404e-01, -9.84807753e-01,-6.42787610e-01, -2.44929360e-16])

值得注意的是，对于同等长度的ndarray，np.sin()比math.sin()快
但是对于单个数值，math.sin()的速度则更快。

a = np.arange(0,4)
b = np.arange(1,5)
np.add(a,b) # 加法

array([1, 3, 5, 7])

a+b

array([1, 3, 5, 7])

np.subtract(a,b) # 减法

array([-1, -1, -1, -1])

np.multiply(a,b) # 乘法

array([ 0,  2,  6, 12])

np.divide(a,b) # 除法

array([0.        , 0.5       , 0.66666667, 0.75      ])

np.power(a,b) # 乘方

array([ 0,  1,  8, 81], dtype=int32)

np.array([1,2,3]) < np.array([3,2,1])

array([ True, False, False])

2）自定义ufunc函数

def num_judge(x, a): #对于一个数字如果是3或5的倍数就if x%3 == 0: # 返回0，否则返回a。r = 0elif x%5 == 0:r = 0else:r = areturn r

x = np.linspace(0,10,11)
print(x)
y = np.array([num_judge(t,2) for t in x]) # 列表生成表达式
y

[ 0.  1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]array([0, 2, 2, 0, 2, 0, 0, 2, 2, 0, 0])

numb_judge = np.frompyfunc(num_judge, 2, 1)
numb_judge

<ufunc '? (vectorized)'>

y = numb_judge(x,2) # 因为最后输出的元素类型是object，所以我们还需要把它转换成整型。
y

array([0, 2, 2, 0, 2, 0, 0, 2, 2, 0, 0], dtype=object)

y.astype(np.int)

array([0, 2, 2, 0, 2, 0, 0, 2, 2, 0, 0])

3）广播

什么是广播

使用ufunc对两个数组进行运算时，ufunc函数会对两个数组的对应元素进
行运算。如果数组的形状不相同，就会进行下广播处理。
简而言之，就是向两个数组每一维度上的最大值靠齐。

a = np.arange(0, 60, 10).reshape(-1, 1)
b = np.arange(0, 5)
c = a + b
print(c.shape)
c

(6, 5)array([[ 0,  1,  2,  3,  4],[10, 11, 12, 13, 14],[20, 21, 22, 23, 24],[30, 31, 32, 33, 34],[40, 41, 42, 43, 44],[50, 51, 52, 53, 54]])

ogrid用来生成广播运算所用的数组。

x,y = np.ogrid[:5,:5]

array([[0],[1],[2],[3],[4]])

array([[0, 1, 2, 3, 4]])

4.numpy的函数库

1)随机数方法

from numpy import random as nr

np.set_printoptions(precision = 2) # 只显示两位小数

r1 = nr.rand(4,3)
r1

array([[0.23, 0.71, 0.41],[0.74, 0.68, 0.2 ],[0.62, 0.58, 0.35],[0.61, 0.58, 0.08]])

r2 = nr.poisson(2,(3,4))
r2

array([[3, 1, 2, 2],[2, 3, 0, 1],[0, 1, 1, 2]])

2）常见统计量计算

np.random.seed(1) # 设置随机种子
a = np.random.randint(0,10,size=(4,5))
a

array([[5, 8, 9, 5, 0],[0, 1, 7, 6, 9],[2, 4, 5, 2, 4],[2, 4, 7, 7, 9]])

print(np.sum(a,axis = 1)) # 行求和，对列操作
np.sum(a)

[27 23 17 29]96

print(np.sum(a,axis = 1,keepdims = True)) # 爆出维度不变

[[27][23][17][29]]

3）大小排序

np.sort(a)

array([[0, 5, 5, 8, 9],[0, 1, 6, 7, 9],[2, 2, 4, 4, 5],[2, 4, 7, 7, 9]])

np.sort(a,axis=0)# 默认从升序

array([[0, 1, 5, 2, 0],[2, 4, 7, 5, 4],[2, 4, 7, 6, 9],[5, 8, 9, 7, 9]])

help(np.sort)

Help on function sort in module numpy:sort(a, axis=-1, kind=None, order=None)Return a sorted copy of an array.Parameters----------a : array_likeArray to be sorted.axis : int or None, optionalAxis along which to sort. If None, the array is flattened beforesorting. The default is -1, which sorts along the last axis.kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optionalSorting algorithm. The default is 'quicksort'. Note that both 'stable'and 'mergesort' use timsort or radix sort under the covers and, in general,the actual implementation will vary with data type. The 'mergesort' optionis retained for backwards compatibility... versionchanged:: 1.15.0.The 'stable' option was added.order : str or list of str, optionalWhen `a` is an array with fields defined, this argument specifieswhich fields to compare first, second, etc.  A single field canbe specified as a string, and not all fields need be specified,but unspecified fields will still be used, in the order in whichthey come up in the dtype, to break ties.Returns-------sorted_array : ndarrayArray of the same type and shape as `a`.See Also--------ndarray.sort : Method to sort an array in-place.argsort : Indirect sort.lexsort : Indirect stable sort on multiple keys.searchsorted : Find elements in a sorted array.partition : Partial sort.Notes-----The various sorting algorithms are characterized by their average speed,worst case performance, work space size, and whether they are stable. Astable sort keeps items with the same key in the same relativeorder. The four algorithms implemented in NumPy have the followingproperties:=========== ======= ============= ============ ========kind      speed   worst case    work space   stable=========== ======= ============= ============ ========'quicksort'    1     O(n^2)            0          no'heapsort'     3     O(n*log(n))       0          no'mergesort'    2     O(n*log(n))      ~n/2        yes'timsort'      2     O(n*log(n))      ~n/2        yes=========== ======= ============= ============ ========.. note:: The datatype determines which of 'mergesort' or 'timsort'is actually used, even if 'mergesort' is specified. User selectionat a finer scale is not currently available.All the sort algorithms make temporary copies of the data whensorting along any but the last axis.  Consequently, sorting alongthe last axis is faster and uses less space than sorting alongany other axis.The sort order for complex numbers is lexicographic. If both the realand imaginary parts are non-nan then the order is determined by thereal parts except when they are equal, in which case the order isdetermined by the imaginary parts.Previous to numpy 1.4.0 sorting real and complex arrays containing nanvalues led to undefined behaviour. In numpy versions >= 1.4.0 nanvalues are sorted to the end. The extended sort order is:* Real: [R, nan]* Complex: [R + Rj, R + nanj, nan + Rj, nan + nanj]where R is a non-nan real value. Complex values with the same nanplacements are sorted according to the non-nan part if it exists.Non-nan values are sorted as before... versionadded:: 1.12.0quicksort has been changed to `introsort <https://en.wikipedia.org/wiki/Introsort>`_.When sorting does not make enough progress it switches to`heapsort <https://en.wikipedia.org/wiki/Heapsort>`_.This implementation makes quicksort O(n*log(n)) in the worst case.'stable' automatically chooses the best stable sorting algorithmfor the data type being sorted.It, along with 'mergesort' is currently mapped to`timsort <https://en.wikipedia.org/wiki/Timsort>`_or `radix sort <https://en.wikipedia.org/wiki/Radix_sort>`_depending on the data type.API forward compatibility currently limits theability to select the implementation and it is hardwired for the differentdata types... versionadded:: 1.17.0Timsort is added for better performance on already or nearlysorted data. On random data timsort is almost identical tomergesort. It is now used for stable sort while quicksort is still thedefault sort if none is chosen. For timsort details, refer to`CPython listsort.txt <https://github.com/python/cpython/blob/3.7/Objects/listsort.txt>`_.'mergesort' and 'stable' are mapped to radix sort for integer data types. Radix sort is anO(n) sort instead of O(n log n)... versionchanged:: 1.17.0NaT now sorts to the end of arrays for consistency with NaN.Examples-------->>> a = np.array([[1,4],[3,1]])>>> np.sort(a)                # sort along the last axisarray([[1, 4],[1, 3]])>>> np.sort(a, axis=None)     # sort the flattened arrayarray([1, 1, 3, 4])>>> np.sort(a, axis=0)        # sort along the first axisarray([[1, 1],[3, 4]])Use the `order` keyword to specify a field to use when sorting astructured array:>>> dtype = [('name', 'S10'), ('height', float), ('age', int)]>>> values = [('Arthur', 1.8, 41), ('Lancelot', 1.9, 38),...           ('Galahad', 1.7, 38)]>>> a = np.array(values, dtype=dtype)       # create a structured array>>> np.sort(a, order='height')                        # doctest: +SKIParray([('Galahad', 1.7, 38), ('Arthur', 1.8, 41),('Lancelot', 1.8999999999999999, 38)],dtype=[('name', '|S10'), ('height', '<f8'), ('age', '<i4')])Sort by age, then height if ages are equal:>>> np.sort(a, order=['age', 'height'])               # doctest: +SKIParray([('Galahad', 1.7, 38), ('Lancelot', 1.8999999999999999, 38),('Arthur', 1.8, 41)],dtype=[('name', '|S10'), ('height', '<f8'), ('age', '<i4')])

r = np.abs(np.random.randn(100000))
np.percentile(r, [68.3, 95.4, 99.7])

array([1.01, 2.  , 2.97])

4）统计函数

np.random.seed(42)

a = np.random.randint(0, 8, 10)
a

array([2, 6, 2, 2, 7, 4, 3, 7, 7, 2])

np.unique(a) # 统计唯一元素个数

array([2, 3, 4, 6, 7])

unique有两个参数,return_index=True同时返回原始数组中
的下标,return_inverse=True表示原始数据在新数组的下标

x,index = np.unique(a,return_index=True)
print(x)
index

[2 3 4 6 7]array([0, 6, 5, 1, 4], dtype=int64)

a[index]

array([2, 3, 4, 6, 7])

x, rindex = np.unique(a, return_inverse=True)
print(x)
rindex

[2 3 4 6 7]array([0, 3, 0, 0, 4, 2, 1, 4, 4, 0], dtype=int64)

bincount()对非负整数数组中的各个元素出现的次数进行统
计，返回数组中的第i个元素是整数i出现的次数。

a = np.array([6, 3, 4, 6, 2, 7, 4, 4, 6, 1])
a

array([6, 3, 4, 6, 2, 7, 4, 4, 6, 1])

np.bincount(a) # 0-7八个数，结果有八个，第一个0出现了0次，1出现了1次，倒数第7位是6，出现了3次！

array([0, 1, 1, 1, 3, 0, 3, 1], dtype=int64)

np.arange(5)

array([0, 1, 2, 3, 4])

help(np.bincount)

Help on function bincount in module numpy:bincount(...)bincount(x, weights=None, minlength=0)Count number of occurrences of each value in array of non-negative ints.The number of bins (of size 1) is one larger than the largest value in`x`. If `minlength` is specified, there will be at least this numberof bins in the output array (though it will be longer if necessary,depending on the contents of `x`).Each bin gives the number of occurrences of its index value in `x`.If `weights` is specified the input array is weighted by it, i.e. if avalue ``n`` is found at position ``i``, ``out[n] += weight[i]`` insteadof ``out[n] += 1``.Parameters----------x : array_like, 1 dimension, nonnegative intsInput array.weights : array_like, optionalWeights, array of the same shape as `x`.minlength : int, optionalA minimum number of bins for the output array... versionadded:: 1.6.0Returns-------out : ndarray of intsThe result of binning the input array.The length of `out` is equal to ``np.amax(x)+1``.Raises------ValueErrorIf the input is not 1-dimensional, or contains elements with negativevalues, or if `minlength` is negative.TypeErrorIf the type of the input is float or complex.See Also--------histogram, digitize, uniqueExamples-------->>> np.bincount(np.arange(5))array([1, 1, 1, 1, 1])>>> np.bincount(np.array([0, 1, 1, 3, 2, 1, 7]))array([1, 3, 1, 1, 0, 0, 0, 1])>>> x = np.array([0, 1, 1, 3, 2, 1, 7, 23])>>> np.bincount(x).size == np.amax(x)+1TrueThe input array needs to be of integer dtype, otherwise aTypeError is raised:>>> np.bincount(np.arange(5, dtype=float))Traceback (most recent call last):File "<stdin>", line 1, in <module>TypeError: array cannot be safely cast to required typeA possible use of ``bincount`` is to perform sums overvariable-size chunks of an array, using the ``weights`` keyword.>>> w = np.array([0.3, 0.5, 0.2, 0.7, 1., -0.6]) # weights>>> x = np.array([0, 1, 1, 2, 2, 2])>>> np.bincount(x,  weights=w)array([ 0.3,  0.7,  1.1])

x = np.array([0 , 1, 2, 2, 1, 1, 0])

w = np.array([0.1, 0.3, 0.2, 0.4, 0.5, 0.8, 1.2])

 np.bincount(x, w) # 0 出现了2次，权重=0.1+1.2

array([1.3, 1.6, 0.6])

histogram()对以为数组进行直方图统计，其参数为：
histogram(a, bins=10, range=None, weights=None)
函数返回两个一维数组，hist是每个区间的统计结果,
bin_edges返回区间的边界值。

 a = np.random.rand(100)

 np.histogram(a, bins=5, range=(0, 1))

(array([27, 20, 18, 18, 17], dtype=int64),array([0. , 0.2, 0.4, 0.6, 0.8, 1. ]))

array([0.02, 0.97, 0.83, 0.21, 0.18, 0.18, 0.3 , 0.52, 0.43, 0.29, 0.61,0.14, 0.29, 0.37, 0.46, 0.79, 0.2 , 0.51, 0.59, 0.05, 0.61, 0.17,0.07, 0.95, 0.97, 0.81, 0.3 , 0.1 , 0.68, 0.44, 0.12, 0.5 , 0.03,0.91, 0.26, 0.66, 0.31, 0.52, 0.55, 0.18, 0.97, 0.78, 0.94, 0.89,0.6 , 0.92, 0.09, 0.2 , 0.05, 0.33, 0.39, 0.27, 0.83, 0.36, 0.28,0.54, 0.14, 0.8 , 0.07, 0.99, 0.77, 0.2 , 0.01, 0.82, 0.71, 0.73,0.77, 0.07, 0.36, 0.12, 0.86, 0.62, 0.33, 0.06, 0.31, 0.33, 0.73,0.64, 0.89, 0.47, 0.12, 0.71, 0.76, 0.56, 0.77, 0.49, 0.52, 0.43,0.03, 0.11, 0.03, 0.64, 0.31, 0.51, 0.91, 0.25, 0.41, 0.76, 0.23,0.08])

5) 操作多维数组

a = np.arange(3)
b = np.arange(10, 13)

array([0, 1, 2])

array([10, 11, 12])

v = np.vstack((a,b))
v # 按第一轴连接数组

array([[ 0,  1,  2],[10, 11, 12]])

h = np.hstack((a, b)) # 按第0轴连接数组
h

array([ 0,  1,  2, 10, 11, 12])

c = np.column_stack((a, b)) # 按列连接多个一维数组
c

array([[ 0, 10],[ 1, 11],[ 2, 12]])

a = np.array([6, 3, 7, 4, 6, 9, 2, 6, 7, 4, 3, 7])
b = np.array([ 1, 3, 6, 9, 10])
np.split(a, b) # 按元素位置进行分段

[array([6]),array([3, 7]),array([4, 6, 9]),array([2, 6, 7]),array([4]),array([3, 7])]

a = np.array([1.0, 0, -2, 1])
p = np.poly1d(a)
print (type(p))

<class 'numpy.poly1d'>

p(np.array([1,1,1]))

array([0., 0., 0.])

多项式函数可以进行四则运算，其中运算的列表自动化成多项
式函数。

numpy复习总结，为深度学习打下基础相关推荐

将MNIST手写数字数据集导入NumPy数组（《深度学习入门：基于Python的理论与实现》实践笔记）
将MNIST手写数字数据集导入NumPy数组(<深度学习入门:基于Python的理论与实现>实践笔记) 一.下载MNIST数据集(使用urllib.request.urlretrieve( ...
PyTorch入门-深度学习回顾和PyTorch简介
一.神经网络的复习 1.深度学习 2.神经网络 3.激活函数 4.前向神经网络 5.卷积神经网络 6.循环神经网络二.用PyTorch构建深度学习模型深度学习模型框架 TensorFlow ay/ ...
【深度学习】计算机视觉（一）——认识和基础（上）
文章目录 step1:深度学习和机器学习的概念机器学习深度学习区别? 总结--本质区别 step2:基本语法复习 step3:深度学习常用库 NumPy numpy对象--dtype 介绍: 创 ...
大佬原创 | 深度学习60讲453页pdf下载
关注公众号后台回复深度学习即可下载深度学习60讲作者简介机器学习实验室的号主作为一名统计专业的硕士毕业生,一路从数据分析师进阶到深度学习算法工程师.现于杭州一家AI初创公司担任深度学习算法工 ...
深度学习:知识回收(Lecture1and2)
知识回收~ 回到深度学习(基础知识回收) Lecture 1 数据集处理 Lecture 2 K近邻与朴素贝叶斯 --分类和回归 KNN算法 NB朴素贝叶斯算法复习路线回到深度学习(基础知识回收) ...
深度学习时代，调包侠没有未来，但是这个“包”有
来源:AI科技评论本文长度为2300字,建议阅读5分钟本文为大家介绍了NumPy的现状. 工欲善其事必先利其器~ 今日我"代码之神"把装备拉满,势必要大干一场! 在编程中只会H ...
火爆网络的《神经网络与深度学习》，有人把它翻译成了中文版！
点击上方"AI有道",选择"置顶"公众号重磅干货,第一时间送达今天给大家介绍一本非常好的深度学习入门书籍,就是<Neural Network and ...
手把手教你搭建pytorch深度学习网络
总有人在后台问我,如今 TensorFlow 和 PyTorch 两个深度学习框架,哪个更流行? 就这么说吧,今年面试的实习生,问到常用的深度学习框架时,他们清一色的选择了「PyTorch」. 这并不 ...
《神经网络与深度学习》中文版推荐
推荐一本由美国量⼦物理学家.科学作家 Michael Nielsen编写的非常好的深度学习入门书籍-<Neural Network and Deep Learning>,中文译为<神 ...
深度学习部署--搭建后台服务器
url:https://www.jiqizhixin.com/articles/2018-02-12 https://www.pyimagesearch.com/2018/02/05/deep-lea ...

numpy复习总结，为深度学习打下基础