numpy使用示例

numpy介绍

创建numpy的数

一维数组是什么样子

可以理解为格子纸的一行就是一个一维数据

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

二维数组什么样子

理解为一张格子纸, 多个一维数组构成一个二维数组

 two_arr = np.array([
     [1, 2, 3],
     [4, 5, 6],
     [7, 8, 9]
 ])
 print(two_arr)
 [[1 2 3]  # 三行三列的二维列表
  [4 5 6]
  [7 8 9]]

三维数组什么样子

three_arr = np.array([
    [
        [1, 2, 3],
        [1, 2, 3],
        [1, 2, 3],
        [1, 2, 3],
    ],
    [
        [4, 5, 6],
        [4, 5, 6],
        [4, 5, 6],
        [4, 5, 6],
    ]
])
print(three_arr)
# [[[1 2 3]
#   [1 2 3]
#   [1 2 3]
#   [1 2 3]]
#
#  [[4 5 6]
#   [4 5 6]
#   [4 5 6]
#   [4 5 6]]]

np.array()

传入一个列表, 返回一个数组

li = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
arr = np.array(li)
print(type(arr), arr)
# <class 'numpy.ndarray'> [0 1 2 3 4 5 6 7 8 9]

np.arange(10)

类似于python中的range

arr = np.arange(10)
print(type(arr), arr)
<class 'numpy.ndarray'> [0 1 2 3 4 5 6 7 8 9]
# 和python的range类型, 顾头不顾尾, 支持步长, 和python的range的区别在于, 起始值和步长支持小数
arr = np.arange(1.2, 10.5, 0.5)
print(type(arr), arr)
# <class 'numpy.ndarray'> [ 1.2  1.7  2.2  2.7  3.2  3.7  4.2  4.7  5.2  5.7  6.2  6.7  7.2  7.7 8.2  8.7  9.2  9.7 10.2]

拓展: 将一维数据变成多维数组

前提保证, reshape()中的行和列相乘等于数组中的全部元素的个数

将一维数组转换成二维数组

arr = np.arange(0, 15).reshape(3, 5)
print(arr)
# [[ 0  1  2  3  4]
#  [ 5  6  7  8  9]
#  [10 11 12 13 14]]

将一维数组转换成三维数组

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

print(arr)
# [[[ 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]]]

# 三维数组可以只给出两个数值, 另外一个用-1代替, 自动求剩下一个一个应该是多少
# 比如:arr = np.arange(30).reshape(3, 2, -1)  会自动求出-1位置的数应该是6

np.linspace(0, 10, 5)

把0到10范围的数分成长度为5的数组, 保证每个数之间的差是相等的, 前包后也包

arr = np.linspace(0, 10, 5)
print(type(arr), arr)
# <class 'numpy.ndarray'> [ 0.   2.5  5.   7.5 10. ]

np.zeros(10)

创建全0的数组

arr = np.zeros(10)
print(arr)
# [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
# 默认是float类型, 可以指定dtype, 可以指定创建几维的数据传一个元祖, 比如np.zeros(3,2,5), 就是创建一个3页2行5列的全0数组

np.ones(10)

创建全1的数组

arr = np.ones(10)
print(arr)
# [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
# 默认使用float类型, 可以指定dtype, 可以指定创建几维的数据传一个元祖, 比如np.ones(3,2,5), 就是创建一个3页2行5列的全1数组

np.empty(10)

创建元素为随机的数组

# np.empty(10)的意义: 向内存要一个长度为10的内存, 并不进行赋值, 内存中原本的数据是什么就是什么, 之后可以对这个里面的值进行覆盖, 效率相对高一点
arr = np.empty(10)
print(arr)
# [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]

np.eye(5)

创建单位矩阵, 方形的, 主对角线为1

arr = np.eye(5)  # 类似于np.identity(5)
print(arr)
# [[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.]]

数组的常用方法

多维数组的转置

二维数组: 列转行

two_arr = np.array([
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
    [10, 11, 12]
])
ret = two_arr.T
print(ret)
# 行: 0  列:1
# [[ 1  4  7 10]
#  [ 2  5  8 11]
#  [ 3  6  9 12]]

三维数组的转置

three_arr = np.array([
    [
        [1, 2, 3],
        [4, 5, 6],
        [7, 8, 9],
        [10, 11, 12],
    ],
    [
        [21, 22, 23],
        [24, 25, 26],
        [27, 28, 29],
        [30, 31, 32],
    ]
])
# 页: 0  行:1    列:2
res = three_arr.transpose(0, 2, 1)
print(res)
# [[[ 1  4  7 10]
#   [ 2  5  8 11]
#   [ 3  6  9 12]]
#
#  [[21 24 27 30]
#   [22 25 28 31]
#   [23 26 29 32]]]

矩阵的计算

创建两个矩阵

a1 = np.array([
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
[10, 11, 12]
])

a2 = np.array([
[1, 2, 3],
[4, 5, 6],
[7, 8, 9],
[10, 11, 12]
 ])

加法

两个矩阵的结构一致才能进行加法

a3 = a1 + a2
print(a3)
# [[ 2  4  6]
#  [ 8 10 12]
#  [14 16 18]
#  [20 22 24]]

乘法

两个矩阵相乘, 结构必须满足以下条件才能相乘
矩阵一的结构: 3 x 4   矩阵二的结构: 4 x 3
n(行数) x d(列数)   d(行数) x m(列数)
最后的结果矩阵结构就是n(行) x m(列)

# 矩阵一的结构
# [
#     [1, 2, 3],
#     [4, 5, 6],
#     [7, 8, 9],
#     [10, 11, 12]
# ]

# 矩阵二的结构
# [[ 1  4  7 10]
#  [ 2  5  8 11]
#  [ 3  6  9 12]]

# 相乘的结果是一个3 x 3的矩阵
# 计算过程:
# 矩阵一的第一行和矩阵二的第一列计算,    # 1x1 + 2x2 + 3x3 = 14
# 矩阵一的第一行和矩阵二的第二列计算,    # 1x4 + 2x5 + 3x6 = 32
# 矩阵一的第一行和矩阵二的第三列计算,    # 1x7 + 2x8 + 3x9 = 50
# 矩阵一的第一行和矩阵二的第四列计算,
# 矩阵一的第二行和矩阵二的第一列计算,
# 矩阵一的第二行和矩阵二的第二列计算,
# 矩阵一的第二行和矩阵二的第三列计算,
# 矩阵一的第二行和矩阵二的第四列计算,
# 以此类推

print(a1 @ a2.T)  # 矩阵的乘法用 @
# [[ 14  32  50  68]
#  [ 32  77 122 167]
#  [ 50 122 194 266]
#  [ 68 167 266 365]]

查看一个数组的结构　　arr.shape

一维数组

one_arr = np.array([1, 2, 3, 4])
print(one_arr.shape)
# (4,)

二维数组

a2 = np.array([
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
    [10, 11, 12]
])
print(a2.shape)
# (4, 3)    (行, 列)

三维数组

three_arr = np.array([
    [
        [1, 2, 3],
        [4, 5, 6],
        [7, 8, 9],
        [10, 11, 12],
    ],
    [
        [21, 22, 23],
        [24, 25, 26],
        [27, 28, 29],
        [30, 31, 32],
    ]
])
print(three_arr.shape)
# (2, 4, 3) (页, 行, 列)

获取数组中元素的个数　　arr.size

one_arr = np.array([1, 2, 3, 4, 5])
two_arr = np.array([
    [1, 2, 3, 4],
    [1, 2, 3, 4],
])
three_arr = np.array([
    [
        [1, 2, 3, 4],
        [1, 2, 3, 4],
        [1, 2, 3, 4],
    ],
    [
        [1, 2, 3, 4],
        [1, 2, 3, 4],
        [1, 2, 3, 4],
    ]
])

print(one_arr.size)
print(two_arr.size)
print(three_arr.size)
#
#
#

查看数组是几维的　　arr.ndim

one_arr = np.array([1, 2, 3, 4, 5])
two_arr = np.array([
    [1, 2, 3, 4],
    [1, 2, 3, 4],
])
three_arr = np.array([
    [
        [1, 2, 3, 4],
        [1, 2, 3, 4],
        [1, 2, 3, 4],
    ],
    [
        [1, 2, 3, 4],
        [1, 2, 3, 4],
        [1, 2, 3, 4],
    ]
])

print(one_arr.ndim)
print(two_arr.ndim)
print(three_arr.ndim)
#
#
#

查看数组中的数据的数据类型　　arr.dtype

数组中的元素类型是一致

  two_arr = np.array([

    [1, 2, 3, 4],
    [1, 2, 3, 4],
])

print(two_arr.dtype)
# int32 #默认int类型是int32  最大:2147483647   最小: -2147483648

当数值正好是int32的最大最小的那个数值时, 在对这个属性进行加减, 就会从最大的回退到最小的, 最小的回退到最大的, 这是一个圈

arr = np.array([0, 2 ** 31 - 1])
print(arr)
# [         0 2147483647]   int32最大的数值
ret = arr + 1
print(ret)
# [          1 -2147483648] # 从最大变成了最小

如何解决这个数值太大无法表示的问题?

方法一

定义数组时, 指定大一点的数据类型,指定数据类型为int64, 或更大的object

arr = np.array([0, 2 ** 31 - 1], dtype="int64")
ret = arr + 10
print(ret)
# [        10 2147483657]

方法二

修改已经定义好数据类型的数组, 但是返回新数组, 新数组才是拥有新的数据类型的数组

arr = np.array([0, 2 ** 31 - 1])
new_arr = arr.astype("int64")  # 返回一个数据类型是int64的数组
new_arr = new_arr + 10
print(new_arr)

方法三

使用小数(float), 当要存储的数特别大时, 还可以考虑使用小数(float)的数据类型

小数的计数法不会出现计算机无法表示的问题

arr = np.array([0, 2 ** 200], dtype="float")
ret = arr + 200
print(ret)
# [2.00000000e+02 1.60693804e+60]

注意: 当生成数组时会根据你存储的值的大小动态的使用响应的数据类型, 对数据中的值进行加减时不会在改变, 因为元素的数据类型在存储时已经确定了

常用的数据类型

ndarray数据类型：dtype：
布尔型：bool_
整型：int    int8    int16   int32   int 64
无符号整型：uint8   uint16  uint32  uint64  都是正数, 对int要大, 因为没有了负号
浮点型：float     float16     float32     float64
复数型：complex   complex64   complex128

索引切片

数组索引切片的特点: python的切片会产生新的数据, 修改新数据不会影响元数据
但是在数组中却不是这样的, 切片只是在元数据上做标记, 记录3:10这一段数据B可以拿到, 当对B进行修改时
元数据也会跟着变化, 这样做的目的就是节省时间和空间, 当数据较大时, 对数据进行切片比较快
对切片后的数据使用copy()可以进行拷贝, 修改数据不会再影响元数据
one_arr[0:5].copy()

普通索引

一维数组普通索引

one_arr = np.arange(10)
print(one_arr)
# [0 1 2 3 4 5 6 7 8 9]
# 取前5个
print(one_arr[0:5])
# [0 1 2 3 4]

二维数组普通索引

two_arr = np.arange(15).reshape(3, 5)
print(two_arr)
# [[ 0  1  2  3  4]
#  [ 5  6  7  8  9]
#  [10 11 12 13 14]]

1. 取到第二行第三列的那个数

print(two_arr[2, 3])
#

2. 取第一行

print(two_arr[0,])
# two_arr[行: 列]
# [0 1 2 3 4]

3. 取第一列

print(two_arr[0:,0])    # 所有的行0:    第一列0

4. 从中间去一个长方形

print(two_arr[0:2, 1:4])    # 切片是前包后不包的
# [[1 2 3]
#  [6 7 8]]

布尔型索引

1. 问题: 给出一个数组, 选出数组中所有大于5的数
python列表的做法

li = [random.randint(1, 10) for n in range(10)]
# python列表的做法
# res = list(filter(lambda x: x > 5, li))
# print(res)

数组的做法

arr = np.array(li)
print(arr[arr > 5])

# 为什么这样写?
# 先看看arr > 5的结果是什么
print(arr > 5)
# [ True  True  True  True False False  True  True  True  True]
# 返回一个全是布尔的数组
# 将5和原数组中的值进行比较返回布尔值
# 返回使用这些布尔值进行取值, 将对应位置上是True的值取出了
# arr[ True  True  True  True False False  True  True  True  True]
# 这样就把结果取出来了

2. 问题: 给出一个数组, 选出所有大于5, 并且是偶数的数

print(arr[(arr > 5) & (arr % 2 == 0)])
# 两个条件, 当两个条件都是True时才是True
# 两个条件先分别计算, 得出两个全是布尔值的数组, 然后两个数组进行 & 计算, 在使用得出的结果取原数组中取值
# 注意 and    和   & 的区别
# and: 是python的关键字
# &: 是运算符
# 在这里要使用运算符

3. 问题: 给出一个数组, 选出所有除了大于5以外的数

print(arr[~(arr > 5)])
# 找出大于5的, 然后使用 ~ 取反

4. 问题: 给出一个数组, 计算该数组中大于5的数字占的比重

print((arr[arr > 5]).size / arr.size)
# 计算出大于5的数量, 然后除以全部的数量

花式索引

给出一个数据取出索引为奇数的数值

一维数组

arr = np.arange(10)
print(arr[[1, 3, 5, 7, 9]])
# 索引取值使用一个列表, 会取值和该列表值对应的索引位置的值, 保证列表中的元素都能作为索引, 不大于大最大索引
# [1 3 5 7 9]

二维数组

# 使用花式索引是, 行列不能同时使用花式索引, 例如print(arr[[1, 2], [0, 1]])
arr = np.arange(15).reshape(3, 5)
print(arr)
# [[ 0  1  2  3  4]
#  [ 5  6  7  8  9]
#  [10 11 12 13 14]]
# print(arr[[1, 2], :][:, [0, 1]])
# [[ 5  6]
#  [10 11]]

通用函数

np.abs(arr) 绝对值

arr = np.arange(-5, 10).reshape(3, 5)
print(arr)
# [[-5 -4 -3 -2 -1]
#  [ 0  1  2  3  4]
#  [ 5  6  7  8  9]]
print(np.abs(arr))
# [[5 4 3 2 1]
#  [0 1 2 3 4]
#  [5 6 7 8 9]]

np.sqrt(arr) 开根号

arr = np.arange(1, 16).reshape(3, 5)
print(np.sqrt(arr))
# [[1.         1.41421356 1.73205081 2.         2.23606798]
#  [2.44948974 2.64575131 2.82842712 3.         3.16227766]
#  [3.31662479 3.46410162 3.60555128 3.74165739 3.87298335]]

np.exp() 指数

arr = np.arange(1, 16).reshape(3, 5)
print(np.exp(arr))
# [[2.71828183e+00 7.38905610e+00 2.00855369e+01 5.45981500e+01
#   1.48413159e+02]
#  [4.03428793e+02 1.09663316e+03 2.98095799e+03 8.10308393e+03
#   2.20264658e+04]
#  [5.98741417e+04 1.62754791e+05 4.42413392e+05 1.20260428e+06
#   3.26901737e+06]]

取整

arr = np.array([3.4, 3.3, 4.6, 5.0])
print(np.ceil(arr))  # 向上取整  4.5取5
print(np.floor(arr))  # 向下取整  4.5取4
print(np.trunc(arr))  # 向0取整
print(np.rint(arr))  # 四舍五入取整

np.array()　将数组变成整数部分和小数部分两个数组

将数据分成两个数组, 一个是整数部分, 一个是小数部分, 都会带着各自的符号

arr = np.array([-3.4, 3.3, -4.6, 5.0])
print(np.modf(arr))
# (array([-0.4,  0.3, -0.6,  0. ]), array([-3.,  3., -4.,  5.]))

isnan (not a number)

**各种没有确定值的数据运算会返回nan, 比如对-1开根号
nan不等于任何数, 自己都不等于自己

a = float("nan")
print(a == a)
# False
print(type(a), a)
# <class 'float'> nan

为什么会有nan?

nan常用作表示数据缺失值, 有这个值, 但是暂时不知道的值叫缺失值
因为在array进行计算时, 加入要计算一亿个数, 但是其中有一个数是没有结果的, 正常情况下会报错
那么这次计算就白做了, 但是numpy的array为了让这次计算有效, 就使用了nan

那些情况会产生nan?

arr = np.array([0, 1, 2, 3])
print(arr / arr)
# [nan  1.  1.  1.]
# 因为0/0没有结果, 就用nan代替了

判断一个数组中是否有nan

arr = np.array([0, 1, 2, 3])
res = arr / arr
print(np.isnan(res))
# [ True False False False]
# 数组中的第一个元素就是nan

如何将排除数据中的nan?

print(arr[~np.isnan(res)])  # 通过布尔值索引
# [1 2 3]

如何将数组中的nan改为0?

arr[np.isnan(res)] = 0  # 所有为True的位置写一个0
print(arr)

如何创建一个nan?

print(np.nan)
# nan
print(np.NAN)
# nan

np.isinf()　　无穷大, 无穷小

inf: 无穷大, -inf: 无穷小
自己等于自己

常用的数学统计方法

常用函数

arr = np.arange(10)
print(arr.sum())  # 求和
print(arr.mean())  # 求平局值
print(arr.max())  # 最大值
print(arr.min())  # 最小值
print(arr.var())  # 求方差   [1,2,3,4,5]  平均值:3, ((1-3**2) + (2-3**2) + (3-3**2) + (4-3**2) + (5-3**2)) / 5(长度)
print(arr.std())  # 标准差   等于方差开根号
print(arr.cumsum())  # 前缀和
print(arr.argmin())  # 返回最小数的索引值
print(arr.argmax())  # 返回最大数的索引值

应用示例

1. 估算数组内数值的范围?

arr = np.array([random.uniform(10, 20) for n in range(100)])
print(arr.mean() - 2 * arr.std())  # 平均值 - 标准差
# 9.024533852997003
print(arr.mean() + 2 * arr.std())  # 平均值 + 标准差
# 20.533572296358937

2. 求某一区间的所有数值的和

arr = np.array([1, 2, 3, 7, 6, 5, 10])
a = arr.cumsum()
print(a)
# [ 0  1  3  6 10 15 21 28 36 45]
# 求索引4到索引8之间的所有数值的和 6+5=11
res = a[5] - a[3]  # 顾尾不顾头
print(res)
#

随机数

和python的random用法基本一致, 区别在于可以直接将随机数生成到指定形状的数组中

np.random.random()

print(np.random.random())  # 生产0到1之间的小数
# 还可以生成到数组中
# 生成一维数组
print(np.random.random(10))
# [0.75789864 0.49982257 0.32940952 0.57216004 0.17562665 0.50703461
#  0.36919792 0.20893032 0.09530242 0.66015132]

# 生成二维数组
print(np.random.random((3, 5)))
# [[0.47324357 0.73385845 0.89099074 0.50889891 0.21902953]
#  [0.8889513  0.48389661 0.72072126 0.36994093 0.97653365]
#  [0.38499637 0.82375443 0.52682468 0.7266469  0.19659174]]

其他

print(np.random.randint(10, 20, (3, 5)))  # 生成随机整数
print(np.random.uniform(10, 20, (3, 5)))  # 生成随机小数, 每个数出现的次数大概相同
print(np.random.normal(6, 10))  # 随机小数, 有负数, 正态分布, 中间的数出现的几率大
print(np.random.choice([1, 2, 3, 4, ], 2))  # 给定的形状中随机选择, 可以指定个数

arr = np.arange(10).reshape(2, 5)
np.random.shuffle(arr)  # 打乱给定形状中的数据, 打乱的是元数据
print(arr)