Python从0到0.1_（numpy）

目录

基本属性

 数据类型的补充说明

支持元素修改

创建多维数组

切片

传统的切片方式

花式切片

一维（两种）

多维

计算

常用方法和内置函数 

四项原则

形状必须匹配

逐元素依次计算

作用于整个数组，除非指定某一方向

nan 与任何值进行计算，得到的结果依旧是 nan，采用忽略 nan 的函数

---

一个用于科学计算的库

最主要的就是多维数组

基本属性

import numpy as np
a = np.array([1, 2, 3, 4])
b = np.array([[1, 2, 3, 4],
             [11, 12, 13, 14]])
print(type(a))
print(a.dtype)      # 数组 a 中的元素类型

print(a.shape)      # 数组每一维的元素个数
print(b.shape)

print(a.ndim)       # 数组的维度
print(b.ndim)

print(a.size)       # 数组所有元素个数
print(a.nbytes)     # 数组所占内存空间大小

# 结果
'''
<class 'numpy.ndarray'>
int32       # 不同操作系统类型表示不一致
(4,)        
(2, 4)
1
2
4
16
'''

 数据类型的补充说明

numpy 对数据类型十分严格，即一个多维数组中的元素类型需要保持一致

见元素修改中的代码

支持元素修改

为了节省内存，在切片中修改，在总的数组中也会改变

索引方式不同于二维列表，要注意！！！

import numpy as np
a = np.array([[1, 2, 3, 4.0],   
             [11, 12, 13, 14]])                # 这里的 4.0 是一个浮点数
print(a.dtype)       # 数据类型的示意
a[0, 0] = 999        # 不同的索引方式             
print(a)

'''
float64
[[999.   2.   3.   4.]
 [ 11.  12.  13.  14.]]
'''

创建多维数组

import numpy as np
# 一维
a = np.array([1, 2, 3, 4], dtype="int32")     # 也可以不指定元素类型

# 二维
b = np.array([[1, 2, 3, 4],
             [11, 12, 13, 14]])

# 二维的另一种创建方式
c = np.arange(25).reshape(5, 5)

print(a)
print(b)
print(c)

# 结果
'''
[1 2 3 4]
[[ 1  2  3  4]
 [11 12 13 14]]
[[ 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]]
'''

切片

传统的切片方式

import numpy as np
a = np.arange(25).reshape(5, 5)
print(a)
print("")
print(a[:, 3])      # 输出第四列，基本的切片方式和列表相似，负数也相似
print("")
print(a[1::2, :])   # 输出第二、四行

'''
[[ 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]]

[ 3  8 13 18 23]

[[ 5  6  7  8  9]
 [15 16 17 18 19]]
'''

花式切片

一维（两种）

使用 mask 来进行切片，要求 mask 是bool类型的数组，并且形式上要和操作数组一致

1. 位运算符很重要

2.  mask 的构建方式很多，灵活运用

import numpy as np
a = np.array([1, 7, 3, 5, 4, 6, 2])
b = np.array([11, 12, 13, 14, 15, 16, 17])
# 选出所有大于三小于八的数
# print(3 < a < 8) 或 print(a > 3 and a < 8) 都是错误的
# 切片操作过程中 按位操作 很重要，例如 &, ^, |, ~
print((a > 3) & (a < 8))       # 注意这里运算符的优先级
# 如果想多次使用，就用一个变量将这个切片方式保存
mask = (a > 3) & (a < 8)
print(a[mask])
# 如果只想用一次
print(a[(a > 3) & (a < 8)])

# 这里的 mask 是一个bool类型的数组，我们可以自己定义来选取任意我们需要的数
# 但是格式要与原数组一致
mask1 = np.array([1, 0, 1, 1, 0, 1, 1], dtype="bool")
print(np.nonzero(mask1))     # 显示不是0（不是FALSE）的位置
print(a[mask1])

'''
[False  True False  True  True  True False]
[7 5 4 6]
[7 5 4 6]
(array([0, 2, 3, 5, 6], dtype=int32),)
[1 3 5 6 2]
'''

使用给定位置切片

import numpy as np
a = np.array([1, 7, 3, 5, 4, 6, 2])
b = np.array([11, 12, 13, 14, 15, 16, 17])
# 如果我想选取出第0，第3，第4号位置的元素，位置信息作为列表
print(a[[0, 3, 4]])      # 注意，这里把位置放到列表中然后进行切片操作

'''
[1 5 4]
'''

多维

import numpy as np
a = np.arange(25).reshape(5, 5)
print(a)
# 显示所有被三整除的数
print(a[a % 3 == 0])
# 按位置选取元素，如选出 1，7，13
c = a[[0, 1, 2],
      [1, 2, 3]]            # 第一个列表表示横坐标，第二个列表纵坐标，默认从0开始
print(c)

# 选出第三，第四行，第0列，第1列，第三列（默认从零开始）
print(a[3:, [0, 1, 3]])

# 选出 7，17，22
mask = np.array([0, 1, 0, 1, 1], dtype="bool")
print(a[mask, 2])       # print(a[mask, [2]]) 列表中只有一个元素，可以省略[]


'''
[[ 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]]
[ 0  3  6  9 12 15 18 21 24]
[ 1  7 13]
[[15 16 18]
 [20 21 23]]
[ 7 17 22]
'''

这里的输出形式是一维的，可以按照原数组的样式输出，例如不能被三整除的用nan表示

nan在numpy中表示空缺数据，它的数据类型是浮点型

import numpy as np
a = np.arange(25).reshape(5, 5)
print(a)
# 显示所有被三整除的数
print(np.where(a % 3 == 0, a, np.nan))    # 如果整除，显示该数字，否则为nan
                                          # 这里可以任意修改你想要的输出情况

'''
[[ 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]]
[[ 0. nan nan  3. nan]        # 由于保持数据类型的一致性，所以有小数点，表明浮点型
 [nan  6. nan nan  9.]
 [nan nan 12. nan nan]
 [15. nan nan 18. nan]
 [nan 21. nan nan 24.]]
'''

# 第二种办法
import numpy as np
a = np.arange(25).reshape(5, 5)
print(a)
# 显示所有被三整除的数
b = np.empty_like(a, dtype="float")   # 建造一个类似于a的空数组
b.fill(np.nan)
mask = a % 3 == 0
b[mask] = a[mask]
print(b)

c = b.fill(np.nan)

此时的 c 是 None，返回值是空

类似于： a = a.append("a")

此时的 a 是 None  （血的教训，折腾了半个小时） 

计算

常用方法和内置函数 

import numpy as np
a = np.array([1, 2, 3, 4])
print(a.max())      # 求最大值   或者 print(np.max(a))   methods 和 function
print(a.min())
print(a.sum())
print(a.ptp())      # max-min
print(a.argmax())   # location of the maximum
print(a.argmin())   # location of the minimum
print(a.mean())     # 平均值
print(np.log(a))    # 以 e 为底
print(np.exp(a))    # e 的幂

'''
4
1
10
3
3
0
2.5
[0.         0.69314718 1.09861229 1.38629436]
[ 2.71828183  7.3890561  20.08553692 54.59815003]
'''

四项原则

形状必须匹配

这里的匹配不要求一模一样

第一种是完全一样的形状，按位运算即可

第二种触发广播机制

关于第二种情况：

当两个数组的对应维度的长度相同，或者长度为1时，算作匹配（没有当前维度则忽略）

import numpy as np
a = np.arange(24).reshape(2, 3, 4)
b = np.arange(2).reshape(2, 1, 1)
c = a + b

import numpy as np
a = np.arange(24).reshape(2, 3, 4)
b = np.arange(6).reshape(2, 3, 1)
c = a + b

import numpy as np
a = np.arange(24).reshape(2, 3, 4)
b = np.arange(3).reshape(3, 1)
c = a + b

逐元素依次计算

作用于整个数组，除非指定某一方向

维度表示的优先级

一维：行

二维：行，列

三维，深度，行，列

新出现的维度总是最前面

import numpy as np
a = np.array([[1, 2, 3],
             [1, 2, 3]])

b = np.sum(a, axis=0)    # 控制计算方向
print(b.shape)
print(b)

c = np.sum(a, axis=1)
print(c.shape)
print(c)

'''
(3,)
[2 4 6]
(2,)
[6 6]
'''

# 具体可以先输出shape，再判断是否正确

nan 与任何值进行计算，得到的结果依旧是 nan，采用忽略 nan 的函数

import numpy as np
a = np.array([1, 2, np.nan, 4])
print(np.nansum(a))
print(np.nanmean(a))
print(np.nanmax(a))
print(np.nanmin(a))

'''
7.0
2.3333333333333335
4.0
1.0
'''
# 由于 nan，整个数组的类型是浮点型，所以结果都是浮点型