python中的numpy库有什么优缺点_如何最简单、通俗地理解Python的numpy库？

目录：

一、笔记

二、我的自学路线

三、笔记目录

一、笔记

1) numpy 概念

① numpy是Python语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。

② numpy是一个运行速度非常快的数学库，主要用于数组计算，包含：1. 一个强大的N维数组对象 ndarry

2. 广播功能函数

3. 整合 C/C++/Fortran 代码的工件

③ Anaconda自带numpy库，纯python开发环境要安装numpy库，用anaconda的原因是因为它自带了大多数我们常用的包了。

④ numpy最重要的一个特点是其N维"数组"对象ndarry，它是一系列 "同类型数据" 的集合，以0下标为开始进行集合中元素的索引。

⑤ ndarray对象是用于存放同类型元素的多维数组。

⑥ ndarray中每个元素在内存中都有相同存储大小的区域。

import numpy as np

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

print(a)

print(a.ndim) # ndarry维度

print(a.shape) # ndarry形状

print(a.size) # ndarry元素个数

print(a.dtype) # ndarry元素类型

运行结果：

[[1 2 3]

[4 5 6]]

2

(2, 3)

6

int32

import numpy as np

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

print(a)

print(a.ndim) # ndarry维度跟最外层括号[]有关

# 第一个括号去掉，有一个元素，所以第一维为1，第二个括号去掉有两个元素，所以第二维为2

print(a.shape)

print(a.size)

print(a.dtype) # a中元素为int32

运行结果：

[[[1 2 3]

[4 5 6]]]

3

(1, 2, 3)

6

int32

import numpy as np

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

print(a) # 当不同长度时，np.array会将里面的数组转换为列表

print(a.ndim) # 只有两维，存的的是两个列表，所以减少一维

print(a.shape)

print(a.size)

print(a.dtype) # a中元素为对象了

运行结果：

[[list([1, 2, 3, 8]) list([4, 5, 6])]]

2

(1, 2)

2

object

import numpy as np

a = np.array([[[1,2.0,3],[4,5,6]]]) # 有一个浮点型 2.0

print(a) # 全部变为浮点型了

print(a.ndim)

print(a.shape)

print(a.size)

print(a.dtype) # 变为浮点型数据了

运行结果：

[[[1. 2. 3.]

[4. 5. 6.]]]

3

(1, 2, 3)

6

float64

2) numpy 数据类型

① 创建numpy数组的时候可以通过属性dtype显示指定数据的类型。

② 在不指定数据类型的情况下，numpy会自动推断出适合的数据类型。

③ 如果需要更改一个已经存在的数组的数据类型，可以通过astype方法进行修改从而得到一个新数组。

a2 = np.array([1,2,3,4]) # 自动推断出合适的数据类型，里面无浮点数，变为int32

print(a2.dtype)

a3 = a2.astype(float) # astype得到的是一个新数组，原数组没有改变。

print(a2.dtype)

print(a2)

print(a3.dtype)

print(a3)

运行结果：

int32

int32

[1 2 3 4]

float64

[1. 2. 3. 4.]

3) numpy 常用方法

① arange()函数：类似python的range函数，通过指定开始值、终值和步长来创建一个一维数组，注意：最终创建的数组不包含终值。

② linspace()函数：通过指定开始值、终值和元素个数来创建一个一维数组，数组的数据元素符合等差数列，可以通过endpoint关键字指定是否包含终值，默认包含终值。

③ logspace()函数：和linspace函数类似，不过创建的是等比数列数组。

④ random()函数：创建0-1之间的随机元素，数组包含的元素数量由参数决定。

import numpy as np

x = np.empty([3,2],dtype = np.int) # 产生3行2列的二维数组，数组中每个元素都是随机数

x

运行结果：

array([[ 757935392, 757935405],

[ 170732845, 538976288],

[ 540680291, 1634890337]])

# 创建数组的时候，可以用列表或者元组指定它的形状

x = np.zeros((5,),dtype = np.int) # 等价于 x = np.zeros([5],dtype = np.int)

x # array是数组的意思，表示x是一个一维数组，数组里面每个元素都是0

运行结果：

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

# 把一个数组转换为numpy,如果长度不相等，则存储的是元组对象

b = [(1,2,3),(4,5)]

a = np.asarray(b)

print(a.dtype) # 变成对象了

a

运行结果：

object

array([(1, 2, 3), (4, 5)], dtype=object)

# 如果长度相等，则把里面的元组转换为ndarray

b = [(1,3),(4,5)]

a = np.asarray(b)

a

运行结果：

array([[1, 3],

[4, 5]])

b = np.asarray([1,2,3,4]).reshape(2,2)

b.shape

运行结果：

(2, 2)

a = np.asarray([1,2,3,4,5,6,7,8,9,10,11,12]).reshape((-1,2,3)) # -1表示自动的，也就是所有的元素除以2除以3后的数据

b = np.asarray([1,2,3,4,5,6,7,8,9,10,11,12]).reshape((2,-1))

c = np.asarray([1,2,3,4,5,6,7,8,9,10,11,12]).reshape((2,-1,2))

print(a)

print(b)

print(c)

运行结果：

[[[ 1 2 3]

[ 4 5 6]]

[[ 7 8 9]

[10 11 12]]]

[[ 1 2 3 4 5 6]

[ 7 8 9 10 11 12]]

[[[ 1 2]

[ 3 4]

[ 5 6]]

[[ 7 8]

[ 9 10]

[11 12]]]

x = np.arange(5, dtype = float)

x # 产生一个0-4的浮点型数组

运行结果：

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

q = np.linspace(0,10,7)

print(q) # 数组里有点.的的原因是linspace方法默认返回的数据类型是浮点型

print(q.astype('int32')) # q的复制品变为int32型

print(q) # q并没有变化

运行结果：

[ 0. 1.66666667 3.33333333 5. 6.66666667 8.33333333

10. ]

[ 0 1 3 5 6 8 10]

[ 0. 1.66666667 3.33333333 5. 6.66666667 8.33333333

10. ]

4) numpy 修改形状

① 对于一个已经存在的ndarray数组对象而言，可以通过修改形状相关的参数/方法从而改变数组的形状。

② 直接使用reshape函数创建一个改变尺寸的新数组，原数组的shape保持不变，但是新数组和原数组共享一个内存空间，也就是修改任何一个数组中的值都会对另外一个产生影响，另外要求新数组的元素个数和原数组一致。

a = np.arange(10)

b = a[-3] # 索引获得的数值

c = a[7:8] # 切片获得的是数组

print(b)

print(c)

运行结果：

7

[7]

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

print(a.ndim)

b = a[2,2] # 用一次索引降低一个维度

print(b.ndim) # 用了两次索引，0维，为一个值

c = a[1:,2]

print(c)

print(c.ndim) # 用了一次索引，1维，为一维数组

d = a[1:,:2] # 中括号能触发魔术方法

print(d)

print(d.ndim) # 没有用索引，2维，为二维数组

运行结果：

2

0

[6 9]

1

[[4 5]

[7 8]]

2

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

print(x)

y = x[1:3,[1,2]]

print(y)

print(y.ndim)

z = x[[1,2],1:3]

print(z)

print(z.ndim)

m = x[1:3,1:3]

print(m)

print(m.ndim)

n = x[[1,2],[1,2]] # 都是数组时，取的是值，数组维数为一维

print(n)

print(n.ndim)

运行结果：

[[1 2 3]

[4 5 6]

[7 8 9]]

[[5 6]

[8 9]]

2

[[5 6]

[8 9]]

2

[[5 6]

[8 9]]

2

[5 9]

1

import numpy as np

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

print(a)

print(a.ndim)

b = a[1:3,[1,2]]

print(b)

print(b.ndim)

c = a[[1,2],[1,2]]

print(c)

print(c.ndim)

运行结果：

[[1 2 3]

[4 5 6]

[7 8 9]]

2

[[5 6]

[8 9]]

2

[5 9]

1

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

print(a[...,1]) # 取第二列

print(a[1,...]) # 取第二行

print(a[2]) # 取第三行

# ...表示不进行任何操作，和冒号:一样的意思

运行结果：

[2 5 8]

[4 5 6]

[7 8 9]

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

print(x)

# 数组，数组 → 取行和列中对应元素，维度为1维

y = x[[0,1,2],[0,1,0]] # [0,1,2] 取的每行的所有，即第0行、第1行、第2行 此方法相对切片可以得到任意位置

print(y)

运行结果：

[[1 2]

[3 4]

[5 6]]

[1 4 5]

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

print(x)

# 切片，数组 → 取行对应元素，维度不变

y = x[1:3,[0,1]] # 取第0列、第1列元素

z = x[1:3,[0,1,0]] # 取第0列、第1列、第0列元素

print(y)

print(z)

运行结果：

[[1 2]

[3 4]

[5 6]]

[[3 4]

[5 6]]

[[3 4 3]

[5 6 5]]

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

y = x[[True,True,False]] # 取第0行、第1行，第3行不取

print(y)

y # 相对print(y)，用y就有逗号

运行结果：

[[1 2] [3 4]]

array([[1, 2],

[3, 4]])

x = np.arange(32).reshape((8,4))

print(x)

x[[-4,-2,-1,-7]] # 取-4列、-2列、-1列、-7列的数组

运行结果：

[[ 0 1 2 3]

[ 4 5 6 7]

[ 8 9 10 11]

[12 13 14 15]

[16 17 18 19]

[20 21 22 23]

[24 25 26 27]

[28 29 30 31]]

array([[16, 17, 18, 19],

[24, 25, 26, 27],

[28, 29, 30, 31],

[ 4, 5, 6, 7]])

5) numpy 广播

① 广播是numpy对不同形状的数组进行数值计算的方式。

② 如果两个数组a和b形状相同，即满足 a.shape == b.shape,那么 a*b的结果就是 a与b数组对应位相乘。这要求维数相同，且各维度的长度相同。

③ 广播就是 a.shape != b.shape，但是数组a和b能进行运算，数组a通过广播与数组b兼容。

④ 数组a和b能进行运算有两点情况：1. 要么两个数组的维度相同。

2. 要么先比较最右边维度，看是否有一个为1，为1再看左边两个数组的维度是否相同或者为1。

⑤ 多个维度，只看最短的维度是否触发广播机制

6) numpy 转置

① 转置时重塑的一种特殊形式，它返回的是源数据的 视图(不会进行任何赋值操作)。

② 数组不仅有transpose方法，还有一个特殊的T属性。

import numpy as np

arr = np.arange(15).reshape((3,5))

print(arr)

# 方法一：

print(arr.T) # 用数组的T方法进行转置

# 方法二：

print(np.transpose(arr)) # 用transpose方法一进行转置

# 方法三：

print(arr.transpose(1,0)) # 用transpose方法二进行转置

print(arr) # 源数据没有变化

运行结果：

[[ 0 1 2 3 4]

[ 5 6 7 8 9]

[10 11 12 13 14]]

[[ 0 5 10]

[ 1 6 11]

[ 2 7 12]

[ 3 8 13]

[ 4 9 14]]

[[ 0 5 10]

[ 1 6 11]

[ 2 7 12]

[ 3 8 13]

[ 4 9 14]]

[[ 0 5 10]

[ 1 6 11]

[ 2 7 12]

[ 3 8 13]

[ 4 9 14]]

[[ 0 1 2 3 4]

[ 5 6 7 8 9]

[10 11 12 13 14]]

import numpy as np

arr = np.arange(120).reshape((2,3,4,5))

print(arr)

print(arr.shape)

print(arr.T) # 默认将第一个维度和第二个维度进行转换

print(arr.T.shape) # 第一个维度到最后一个维度，第二个维度到倒数第二个维度

运行结果：

[[[[ 0 1 2 3 4]

[ 5 6 7 8 9]

[ 10 11 12 13 14]

[ 15 16 17 18 19]]

[[ 20 21 22 23 24]

[ 25 26 27 28 29]

[ 30 31 32 33 34]

[ 35 36 37 38 39]]

[[ 40 41 42 43 44]

[ 45 46 47 48 49]

[ 50 51 52 53 54]

[ 55 56 57 58 59]]]

[[[ 60 61 62 63 64]

[ 65 66 67 68 69]

[ 70 71 72 73 74]

[ 75 76 77 78 79]]

[[ 80 81 82 83 84]

[ 85 86 87 88 89]

[ 90 91 92 93 94]

[ 95 96 97 98 99]]

[[100 101 102 103 104]

[105 106 107 108 109]

[110 111 112 113 114]

[115 116 117 118 119]]]]

(2, 3, 4, 5)

[[[[ 0 60]

[ 20 80]

[ 40 100]]

[[ 5 65]

[ 25 85]

[ 45 105]]

[[ 10 70]

[ 30 90]

[ 50 110]]

[[ 15 75]

[ 35 95]

[ 55 115]]]

[[[ 1 61]

[ 21 81]

[ 41 101]]

[[ 6 66]

[ 26 86]

[ 46 106]]

[[ 11 71]

[ 31 91]

[ 51 111]]

[[ 16 76]

[ 36 96]

[ 56 116]]]

[[[ 2 62]

[ 22 82]

[ 42 102]]

[[ 7 67]

[ 27 87]

[ 47 107]]

[[ 12 72]

[ 32 92]

[ 52 112]]

[[ 17 77]

[ 37 97]

[ 57 117]]]

[[[ 3 63]

[ 23 83]

[ 43 103]]

[[ 8 68]

[ 28 88]

[ 48 108]]

[[ 13 73]

[ 33 93]

[ 53 113]]

[[ 18 78]

[ 38 98]

[ 58 118]]]

[[[ 4 64]

[ 24 84]

[ 44 104]]

[[ 9 69]

[ 29 89]

[ 49 109]]

[[ 14 74]

[ 34 94]

[ 54 114]]

[[ 19 79]

[ 39 99]

[ 59 119]]]]

(5, 4, 3, 2)

import numpy as np

arr = np.arange(120).reshape((2,3,4,5))

arr.transpose(0,3,2,1).shape # 原本是arr.transpose(0,1,2,3) 因此指定第二个轴和第四个轴进行交换

运行结果：

(2, 5, 4, 3)

import numpy as np

arr = np.arange(120).reshape((2,3,4,5))

arr.swapaxes(1,3).shape # 跟 arr.transpose(0,3,2,1).shape 等价，swapaxes方法直接填写第一轴和第三轴即可

运行结果：

(2, 5, 4, 3)

# 元素0可表示为arr[0][0][0]，元素6可表示为 arr[0][1][2] # 去掉一层括号，看它在哪个位置

arr = np.arange(24).reshape((2,3,4))

print(arr)

print(arr.transpose((1,0,2))) # 表示将轴1和0位置互换，轴2不变，即代表将轴0和1对换，轴2不变，亦即将arr[x][y][z]中x和y位置互换，整个数组将变换

print(arr.swapaxes(1,2)) # 表示将轴1和轴2位置互换，轴0不变

运行结果：

[[[ 0 1 2 3]

[ 4 5 6 7]

[ 8 9 10 11]]

[[12 13 14 15]

[16 17 18 19]

[20 21 22 23]]]

[[[ 0 1 2 3]

[12 13 14 15]]

[[ 4 5 6 7]

[16 17 18 19]]

[[ 8 9 10 11]

[20 21 22 23]]]

[[[ 0 4 8]

[ 1 5 9]

[ 2 6 10]

[ 3 7 11]]

[[12 16 20]

[13 17 21]

[14 18 22]

[15 19 23]]]

# 矩阵线性代数相乘

arr = np.arange(6).reshape((2,3))

np.dot(arr.T,arr)

运行结果：

array([[ 9, 12, 15],

[12, 17, 22],

[15, 22, 29]])

6) numpy 数组合并

arr1 = np.arange(6).reshape((2,3))

print(arr)

print(np.hstack((arr1,arr1))) # 水平方向合并

print(np.vstack((arr1,arr1))) # 垂直方向合并

print(np.concatenate((arr1,arr1),axis = 1)) # 指定对x轴进行拼接

print(np.concatenate((arr1,arr1),axis = 0)) # 指定对y轴进行拼接

运行结果：

[[0 1 2]

[3 4 5]]

[[0 1 2 0 1 2]

[3 4 5 3 4 5]]

[[0 1 2]

[3 4 5]

[0 1 2]

[3 4 5]]

[[0 1 2 0 1 2]

[3 4 5 3 4 5]]

[[0 1 2]

[3 4 5]

[0 1 2]

[3 4 5]]

arr1 = np.arange(24).reshape((2,3,4))

print(arr1.shape)

print(np.concatenate((arr1,arr1),axis = 1).shape) # 对第二个维度进行拼接

print(np.concatenate((arr1,arr1),axis = 0).shape) # 对第一个维度进行拼接

print(np.concatenate((arr1,arr1),axis = 2).shape) # 对第三个维度进行拼接

运行结果：

(2, 3, 4)

(2, 6, 4)

(4, 3, 4)

(2, 3, 8)

6) numpy 聚合函数

① 聚合函数是对一组值(例如一个数组)进行操作，返回一个单一值作为结果的函数。

② 聚合函数也可以指定对某个具体的轴进行数据聚合操作；常用的聚合操作有：平均值、最大值、最小值、方差等待。

import numpy as np

arr1 = np.array([[1,-2],[3,4]])

print(np.abs(arr1)) # 取绝对值

print(np.sqrt(arr1)) # 负数不能开根号

print(np.isnan(arr1))

运行结果：

[[1 2]

[3 4]]

[[1. nan]

[1.73205081 2. ]]

[[False False]

[False False]]

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

print(arr1)

print(np.amin(arr1,0)) # 取列中最小的元素，等价 print(np.amin(arr1,axis = 0))

print(np.amin(arr1,1)) # 取行中最小的元素，等价 print(np.amin(arr1,axis = 1))

运行结果：

[[ 1 -2 4]

[ 3 4 5]

[ 2 5 6]]

[ 1 -2 4]

[-2 3 2]

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

y = np.argsort(x)

print(y) # 返回的是排序后 y 的索引

运行结果：

[1 2 0]

import numpy as np

x = np.arange(9,).reshape(3,3)

y = np.where(x>5) # 第一个数组为第一个轴的索引，第二个数组为第二个轴的索引

print(y) # 获得索引

print(x[y]) # 获得索引对应的值

运行结果：

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

[6 7 8]

二、我的自学路线

01 安装Python编辑器 [ 整理完 ]

02 Python编译器快捷键 [ 整理完 ]

03 Python基础 [ 整理完 ]

04 Python难点 [ 整理完 ]

05 Python常用的库 [ 整理完 ]

06 爬虫 [ 整理ing ]

07 NLP [ 看视频ing ]

三、笔记目录

1) Python 编辑器

2) Python 基础

03) Python 难点

04) Python 常用的库

( ……更多笔记，见专栏 )

"♥我的笔记，希望对你有帮助♥"