NumPy基础知识学习笔记（创建方法，属性，方法，基本操作，基本运算）

最新推荐文章于 2021-12-15 14:26:51 发布

快乐虫

最新推荐文章于 2021-12-15 14:26:51 发布

阅读量113

点赞数

分类专栏： python 文章标签： numpy python

本文链接：https://blog.csdn.net/jason_cdd/article/details/108310253

版权

python 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

NumPy是由Python实现科学计算的开源扩展程序库，最重要的一个特点是具有一个快速而灵活的大数据集容器N维数组对象（即Ndarray），NumPy主要包括以下几点：
1.由实际的数据和描述这些数据的元数据组成的一个强大的N维数组对象ndarray。
2.比较成熟的函数库
3.用于整合C/C++和Fortran代码的工具包
4.实用的线性代数、傅里叶变换和随机数生成函数

文章目录

一、常用的Ndarray创建方法有哪些？

（1）由list创建

In [1]: import numpy as np                                                      

In [2]: m = np.array([[1,2,3],[4,5,6]])                                         

In [3]: m, type(m)                                                              
Out[3]: 
(array([[1, 2, 3],
        [4, 5, 6]]),
 numpy.ndarray)

In [4]: import numpy as np                                                      

In [5]: m2 = np.array([1,3.14,'xxt'])                                           

In [6]: m2, type(m2)                                                            
Out[6]: (array(['1', '3.14', 'xxt'], dtype='<U32'), numpy.ndarray)

（2）由np.ones()函数创建

np.ones(shape, dtype=None, order=‘C’)是由1组成的ndarray，如

n = np.ones(shape=(3, 5), dtype=np.int8)
print(n)

运行结果

[[1 1 1 1 1]
 [1 1 1 1 1]
 [1 1 1 1 1]]

（3）由np.zeros()函数创建

np.zeros(shape, dtype=float, order=‘C’)是由0组成的ndarray，如

p = np.zeros(shape=(2, 3), dtype=np.int8)
print(p)

输出

[[0 0 0]
 [0 0 0]]

（4）由np.full()函数创建

np.full(shape, fill_value, dtype=None, order=‘C’)创建的ndarray的每个值都是一样的，如：

q = np.full(shape=(5, 3), fill_value=5.21)
print(q)

输出

[[5.21 5.21 5.21]
 [5.21 5.21 5.21]
 [5.21 5.21 5.21]
 [5.21 5.21 5.21]
 [5.21 5.21 5.21]]

（5）由np.eye()函数创建

np.eye(N, M=None, k=0, dtype=float)的ndarray对角线为1其他位置为0，如：

l = np.eye(5)
print(l)

输出

[[1. 0. 0. 0. 0.]
 [0. 1. 0. 0. 0.]
 [0. 0. 1. 0. 0.]
 [0. 0. 0. 1. 0.]
 [0. 0. 0. 0. 1.]]

（6）由np.linspace()函数创建

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)得到等分的ndarray元组

k = np.linspace(1, 17, num=8, endpoint=False, retstep=True)
print(k)

输出

(array([ 1.,  3.,  5.,  7.,  9., 11., 13., 15.]), 2.0)

再比如：

k1 = np.linspace(1, 21, num=5, endpoint=False, retstep=True)
print(k1)

输出

(array([ 1.,  5.,  9., 13., 17.]), 4.0)

（7）由np.arange()函数创建

np.arange([start, ]stop, [step, ]dtype=None)，得到的是左闭右开的等差ndarray,如：

h = np.arange(1, 15, step=2)
print(h)

输出

[ 1  3  5  7  9 11 13]

（8）由np.random相关函数创建

np.random.randint(low, high=None, size=None, dtype=‘l’)得到的是随机整数ndarray,如：

r = np.random.randint(-19, 100, size=(2, 3))
print(r)

输出

[[-1 25 47]
 [62  7 87]]

再如，np.random.randn(2,3)得到的是标准正态分布ndarray:

r2 = np.random.randn(2, 3)
print(r2)

输出

[[-1.75994655  0.06129896  1.24847171]
 [-1.12129842 -1.74107121  1.3208108 ]]

二、Ndarry的属性有哪些？

属性	说明
dtype	返回数组元素的类型
ndim	返回数组的维度
shape	返回数组中每个维度的大小，用tuple表示
size	返回数组中元素的个数，等于shape中所有整数的乘积
itemsize	返回数组中每个元素的字节大小
T	返回数组的转置
flat	返回一个数组的迭代器，对flat赋值将导致整个数组的元素被覆盖
real/imag	返回复数数组的实部/虚部
nbytes	返回数组占用的存储空间

例如：

import numpy as np

n = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
print('数据类型： ', type(n))
print('\nNumPy的形状： ', n.shape)
print('\nNumPy的维度：', n.ndim)

输出

数据类型：  <class 'numpy.ndarray'>

NumPy的形状：  (2, 2, 3)

NumPy的维度： 3

三、常用Ndarray方法

方法	解释
astype(dtype)	返回指定元素类型的数组副本
argmax()/argmin()	返回最大值/最小值的索引
copy()	返回数组的深复制
cumprod	返回指定轴的累积
compress()	返回满足条件的元素构成的数组
flatten()	返回将原数组压缩成一维数组的复制
fill(value)	返回将数组元素全部设定为标量值value的数组
mean()/var()/std()	返回数组元素的均值/方差/标准差
max()/min()/ptp()	返回数组的最大值/最小值/取值范围
reshape()	返回重组数组形状（shape)后的数组，不改变原数组元素的个数
resize()	返回给定数组形状(shape)的数组，原数组shape发生改变
ravel()	返回将原数组压缩成一维数组的视图，原数组不改变
sort()	返回按照指定轴或指定算法排序的数组
sum()	返回数组中所有元素的和
take()	返回一个从原数组中根据指定的索引获取对应元素的新数组
tolist()	返回一个列表，注意与直接使用list(array)的区别
view()	返回一个使用相同内存，但使用不同的表示方法的数组

reshape示例：

m = np.array([[1, 2, 3], [4, 5, 6]])

print('reshape: ', m.reshape(3, 2))
print('\nm: ', m)

输出

reshape:  [[1 2]
 [3 4]
 [5 6]]

m:  [[1 2 3]
 [4 5 6]]

resize()示例：

m = np.array([[1, 2, 3], [4, 5, 6]])
m.resize((5, 5), refcheck=False)
print(m)

输出

[[1 2 3 4 5]
 [6 0 0 0 0]
 [0 0 0 0 0]
 [0 0 0 0 0]
 [0 0 0 0 0]]

四、Ndarray的基本操作

（1）索引和切片

创建Ndarray

import numpy as np

n = np.arange(10)**3
nd = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15], [16, 17, 18, 19, 100]])
print('一维数组： ', n)
print('\n多维数组： ', nd)

输出
一维数组：  [  0   1   8  27  64 125 216 343 512 729]

多维数组：  [[  1   2   3   4   5]
 [  6   7   8   9  10]
 [ 11  12  13  14  15]
 [ 16  17  18  19 100]]

（a）一维数组可以被索引、切片和迭代，就像列表和其他python序列一样

n = np.arange(10)**3
print('通过索引获取元素： ', n[2], n[[1, 6]])
print('通过切片获得所需元素： ', n[0:6])
print('通过切片获得苏所需元素： ', n[::-1])

输出

通过索引获取元素：  8 [  1 216]
通过切片获得所需元素：  [  0   1   8  27  64 125]
通过切片获得苏所需元素：  [729 512 343 216 125  64  27   8   1   0]

（b）多维数组每个轴可以有一个索引，这些索引以逗号分隔的元组给出

nd = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15], [16, 17, 18, 19, 100]])
print('通过索引获得元素： ', nd[2], nd[1, 2])
print('通过切片获得元素： ', nd[0:2, 1:3])

输出

通过索引获得元素：  [11 12 13 14 15] 8
通过切片获得元素：  [[2 3]
 [7 8]]

（2）Numpy Array的合并和重构

（a）np.vatack()执行上下合并，np.hstack()执行左右合并

import numpy as np

A = np.array([1, 1, 1])
B = np.array([2, 2, 2])
print('上下合并：\n', np.vstack((A, B)))
print('左右合并：', np.hstack((A, B)))

输出

上下合并：
 [[1 1 1]
 [2 2 2]]
左右合并： [1 1 1 2 2 2]

（b）Concatenate()合并函数，axis=0表示纵向合并，axis=1表示横向合并

C = np.array([[1, 1, 1], [1, 1, 1]])
D = np.array([[2, 2, 2], [2, 2, 2]])

E = np.concatenate((C, D), axis=0)
F = np.concatenate((C, D), axis=1)

print('axis=0纵向合并：\n', E)
print('axis=1横向合并：\n', F)

输出

axis=0纵向合并：
 [[1 1 1]
 [1 1 1]
 [2 2 2]
 [2 2 2]]
axis=1横向合并：
 [[1 1 1 2 2 2]
 [1 1 1 2 2 2]]

（c）使用reshape函数，可以改变Array的结构，即重构array，其中参数是一个tuple

G = np.arange(12)
H = np.arange(12).reshape(3, 4)
print('G数组：\n', G)
print('H数组：\n', H)

输出

G数组：
 [ 0  1  2  3  4  5  6  7  8  9 10 11]
H数组：
 [[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

（3）广播机制

广播机制是对两个形状不同的阵列进行数学计算的处理机制，即把较小的阵列“广播”到较大阵列相同的形状尺寸上，使他们对等，从而可以进行数学计算。

from numpy import array

a = array([[[1, 2, 3], [5, 6, 7]], [[11, 12, 13], [15, 16, 17]]])
b = array([1, 1, 1])
c = array([[1, 1, 1], [2, 2, 2]])

print('a的形状：%s, b的形状：%s, c的形状：%s\n' % (a.shape, b.shape, c.shape))
print('b的轴长是1，可广播：\n', a+b)
print('\na和c的后缘维度都是（2，3）,可广播：\n', a+c)

输出

a的形状：(2, 2, 3), b的形状：(3,), c的形状：(2, 3)

b的轴长是1，可广播：
 [[[ 2  3  4]
  [ 6  7  8]]

 [[12 13 14]
  [16 17 18]]]
  
a和c的后缘维度都是（2，3）,可广播：
 [[[ 2  3  4]
  [ 7  8  9]]

 [[12 13 14]
  [17 18 19]]]

五、NumPy基本运算

最简单的运算就是给数组加上一个标量，然后每个元素都加上这个标量，当然也可以进行减法、乘法和除法运算。

（1）一维数组运算

import numpy as np

a = np.array([10, 20, 30, 40])
b = np.array(4)
c = b**2
g = a/2
d = np.sin(a)
e = np.cos(a)
f = np.tan(a)

print('加法a+b：', a+b, '\n', '减法a-b:', a-b, '\n', '乘c:', c, '\n', '除g:', g)
print('正弦d:', d, '\n', '余弦e:', e)
print('比较b<3:', b<3)

输出

加法a+b： [14 24 34 44] 
 减法a-b: [ 6 16 26 36] 
 乘c: 16 
 除g: [ 5. 10. 15. 20.]
正弦d: [-0.54402111  0.91294525 -0.98803162  0.74511316] 
 余弦e: [-0.83907153  0.40808206  0.15425145 -0.66693806]
比较b<3: False

（2）多维数组运算

import numpy as np

a = np.array([[1, 1, 1, 1], [2, 2, 2, 2]])
b = np.arange(1, 9).reshape(2, 4)

s1 = a + b
s2 = a - b
s3 = a * b
s4 = b / a
s5 = b.dot(a.T)
s6 = a.dot(b.T)

print('加法a+b:\n', s1, '\n', '减法a-b:\n', s2, '\n', '乘法a*b:\n', s3, '\n', '除法a/b:\n', s4)
print('矩阵转置a.T:\n', a.T, '\n', '矩阵转置b.T:\n', b.T)
print('矩阵点乘b.dot(a):\n', s5, '\n', '矩阵点乘a.dot(b):\n', s6)

输出

加法a+b:
 [[ 2  3  4  5]
 [ 7  8  9 10]] 
 减法a-b:
 [[ 0 -1 -2 -3]
 [-3 -4 -5 -6]] 
 乘法a*b:
 [[ 1  2  3  4]
 [10 12 14 16]] 
 除法a/b:
 [[1.  2.  3.  4. ]
 [2.5 3.  3.5 4. ]]
矩阵转置a.T:
 [[1 2]
 [1 2]
 [1 2]
 [1 2]] 
 矩阵转置b.T:
 [[1 5]
 [2 6]
 [3 7]
 [4 8]]
矩阵点乘b.dot(a):
 [[10 20]
 [26 52]] 
 矩阵点乘a.dot(b):
 [[10 26]
 [20 52]]