一、如何安装numpy
原生的Python安装：在cmd里面输入pip install numpy
可以用pip list 查看是否安装成功
安装后导入这个库：import numpy as np
import numpy as np
二、ndarray的创建
numpy中的核心对象是ndarray；ndarray可以看成数组，类似于R语言的向量或者矩阵。nmpy里面所有的函数都是围绕ndarry展开的。ndarray对维数没有限制从[ ]内到外分别是第0轴，第1轴，第2轴。
numpy为ndarray提供了便利的操作函数，而且性能优越，完爆Python 的list，因此在数值计算，机器学习，人工智能，神经网络等领域广泛应用。numpy几乎是Python 生态系统的数值计算的基石，例如Scipy，Pandas，Scikit-learn，Keras等出色的包都基于numpy。
1、通过python list创建 array
b = np.array([[1,2,3,4],[5,6,7,8]])
# [[1 2 3 4], [5 6 7 8]]
2、numpy提供了专门用于生成ndarray的函数，提高创建ndarray的速度
# 通过 arange()方法产生数组
a = np.arange(0,1,0.1) # start=0 end=1 step=0.1(间隔)
# [0.,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9]
# 创建等差数列 linspace()
b = np.linspace(2.0, 3.0, num=5)
# [ 2. , 2.25, 2.5 , 2.75, 3. ]
# 二维数组
c = np.array([[1,2,3,4],[5,6,7,8]])
# [[1 2 3 4], [5 6 7 8]]
# 二维全0矩阵
d = np.zeros([2,3])
# [[0. 0. 0.], [0. 0. 0.]]
e = np.empty((2,3), np.int) # 创建2*3的整型空矩阵,只分配内存
f = np.ones((2,3), np.int) # 创建2*3的整型值为全部为1的矩阵
# [[1 1 1], [1 1 1]]
g = np.full(4, np.pi) # 创建长度为4，值为全部为pi的矩阵
# [3.14159265 3.14159265 3.14159265 3.14159265]
h = np.eye(2, dtype=int) # 创建2*2单位矩阵（对角线是1)
# [[1 0], [0 1]]
# 自定义函数产生ndarray
def func(i):
return i % 4 + 1
np.fromfunction(func, (10,)) # fromfunction第一个参数接收计算函数，第二个参数接收数组的形状
# [1., 2., 3., 4., 1., 2., 3., 4., 1., 2.]
三、numpy索引
1、切片索引
numpy数组的切片索引，不会复制内部数组数据，仅创建原始数据的新视图，以引用方式访问数据。
切片索引的要点：
①切片索引适用于有规律的查找指定位置的元素（元素位置位于等差序列）
②当切片的数量少于数组维度时，缺失的维度索引被认为是一个完整切片，省略与使用“ : ”或“ … ”等价。
一维数组切片索引
a = np.arange(10)
# [0,1,2,3,4,5,6,7,8,9]
a[::-1] # 逆序 [9,8,7,6,5,4,3,2,1,0]
a[5] # 5
a[3:5] # [3,4]
a[:5] # 从索引0开始取5个元素 [0,1,2,3,4]
a[:-1] # 从最后一个索引开始向前取所有的元素[0,1,2,3,4,5,6,7,8]
a[1:-1:2] # 从索引1开始到最后一个结束，每2个取一个[1,3,5,7]
a[5:1:-2] # [5,3]
a[...] # 索引全部元素，与a[:]等价
# 可以通过切片的对ndarray中的元素进行更改
a[2:4] = 100,101
# [0 1 100 101 4 5 6 7 8 9]
# ndarray通过切片产生一个新的数组b，b和a共享同一块数据存储空间
a = np.array([0,1,100,101,4,5,6,7,8,9])
b = a[3:7]
# [101 4 5 6]
b[2] = -10
# [101 4 -10 6]
a
# [0 1 100 101 4 -10 6 7 8 9]
# 如果想改变这种情况，我们可以用整数数组索引对数组元素切片
b = a[[3,3,-3,8]]
# [100,101,7,8]
b[2] = 100
# [101,101,100,8]
a
# [0 1 100 101 4 -10 6 7 8 9]
二维数组切片索引
# 多维数组同样适用上述索引提取方法
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
a[1:]
# [[3 4 5], [4 5 6]]
# 切片还可以包括省略号"…",来使选择元组的长度与数组的维度相同。如果在行位置使用省略号，它将返回包含行中元素的ndarray
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print (a[...,1]) # 第2列元素
# [2 4 5]
print (a[1,...]) # 第2行元素
# [3 4 5]
print (a[...,1:]) # 第2列及剩下的所有元素
# [[2 3], [4 5], [5 6]]
2、高级索引
numpy 比一般的 Python 序列提供更多的索引方式。除了用整数和切片的索引外，数组可以由整数数组索引、布尔索引及花式索引创立原数组的副本。
整数数组索引
x = np.array([[1, 2], [3, 4], [5, 6]])
y = x[[0,1,2], [0,1,0]] # 获取数组中(0,0)，(1,1)和(2,0)位置处的元素
# [1 4 5]
a = np.array([[1,2,3], [4,5,6],[7,8,9]])
b = a[1:3, 1:3]
# [[5 6], [8,9]]
c = a[1:3,[1,2]]
# [[5 6], [8,9]]
d = a[...,1:]
# [[1 2], [5 6], [8,9]]
布尔索引
布尔索引通过布尔运算（如：比较运算符）来获取符合指定条件的元素的数组
x = np.array([[ 0, 1, 2],[ 3, 4, 5],[ 6, 7, 8],[ 9, 10, 11]])
# 现在打印出大于 5 的元素
b = x[x > 5]
print('大于5的元素是:{}'.format(b))
# 大于 5 的元素是：[ 6 7 8 9 10 11]
# 使用了 ~（取补运算符）来过滤 NaN。
a = np.array([np.nan, 1, 2, np.nan, 3, 4, 5])
rint (a[~np.isnan(a)])
# [ 1. 2. 3. 4. 5.]
花式索引
花式索引指的是利用整数数组进行索引。
花式索引根据索引数组的值作为目标数组的某个轴的下标来取值。对于使用一维整型数组作为索引，如果目标是一维数组，那么索引的结果就是对应位置的元素；如果目标是二维数组，那么就是对应下标的行。
花式索引跟切片不一样，它总是将数据复制到新数组中。
x=np.arange(32).reshape((8,4)) # 传入倒序索引
print (x[[4,2,1,7]]) print (x[[-4,-2,-1,-7]])
[[16 17 18 19] [[16 17 18 19]
[ 8 9 10 11] [24 25 26 27]
[ 4 5 6 7] [28 29 30 31]
[28 29 30 31]] [ 4 5 6 7]]
x=np.arange(32).reshape((8,4))
print(x[np.ix_([1,5,7,2],[0,3,1,2])]) # 输出4*4矩阵
# 其元素分别是
# x[1,0] x[1,3] x[1,1] x[1,2]
# x[5,0] x[5,3] x[5,1] x[5,2]
# x[7,0] x[7,3] x[7,1] x[7,2]
# x[2,0] x[2,3] x[2,1] x[2,2]
# 相当于：
y=np.array([[x[1,0], x[1,3], x[1,1], x[1,2]],
[x[5,0], x[5,3], x[5,1], x[5,2]],
[x[7,0] ,x[7,3], x[7,1], x[7,2]],
[x[2,0], x[2,3], x[2,1], x[2,2]]])
"""
[[ 4 7 5 6]
[20 23 21 22]
[28 31 29 30]
[ 8 11 9 10]]
"""
numpy广播
广播(Broadcast)是 numpy 对不同形状(shape)的数组进行数值计算的方式， 对数组的算术运算通常在相应的元素上进行。
如果两个数组 a 和 b 形状相同，即满足 a.shape == b.shape，那么 a*b 的结果就是 a 与 b 数组对应位相乘。这要求维数相同，且各维度的长度相同。
# 当运算中的 2 个数组的形状不同时，numpy 将自动触发广播机制。
a = np.array([1,2,3])
b = np.array([[0, 0, 0], [10,10,10], [20,20,20], [30,30,30]])
c = a + b
print(c)
# [[ 1 2 3], [11 12 13], [21 22 23], [31 32 33]]
四、ufunc函数
ufunc是universal function的简称，它是一种能对数组每个元素进行运算的函数。numpy的许多ufunc函数都是用C实现的，因此它们的运算速度非常快。
对于等长度的ndarray，np.sin()比math.sin()要快，但是对于单个数值，math.sin()比较快。
算术运算符
a = np.arange(0,4) # [0 1 2 3]
b = np.arange(1,5) # [1 2 3 4]
np.add(a,b)
# [1 3 5 7]
a+b
# [1 3 5 7]
np.substract(a,b) # 减法
np.multiply(a,b) # 乘法
np.divide(a,b) # 如果两个数字都为正数，则为整数除法
np.power(a,b) # 乘方
比较运算符
使用==，>对两个数组进行比较，会返回一个布尔数组，每一个元素都是对应元素的比较结果。
a = np.array([1,2,3]) < np.array([3,2,1])
print(a)
# [True False False]
布尔运算在Numpy中也有对应的ufunc函数
| 表达式 | ufunc函数 |
|---|---|
| y = x1 == x2 | equal(x1, x2[, y]) |
| y = x1 != x2 | not_equal(x1, x2[, y]) |
| y = x1 < x2 | less(x1, x2[, y]) |
| y = x1 <= x2 | not_equak(x1, x2[, y]) |
| y = x1 > x2 | greater(x1, x2[, y]) |
| y = x1 >= x2 | greater_equal(x1, x2[, y]) |
五、numpy函数
随机数
numpy提供了大量对于数组运算的函数。可以简化逻辑，提高运算速度。
numpy产生随机数的模块在random里面，其中有大量的分布。
from numpy import random as nr
np.set_printoptions(precision=2) # 显示小数点后两位
r1 = nr.rand(4,3) r2 = nr.poisson(2.0,(4,3))
[[0.41 0.45 0.56] [[1 2 3]
[0.77 0.49 0.85] [5 3 0]
[0.18 0.88 0.62] [5 2 0]
[0.6 0. 0.89]] [3 1 1]]
求和，平均值，方差
| 函数名 | 功能 |
|---|---|
| sum | 求和 |
| average | 加权平均数 |
| var | 方差 |
| mean | 期望 |
| std | 标准差 |
| product | 连乘积 |
a np.sum(a,axis=1) #行 np.sum(a,axis=0) #列
____________ ___________________ ___________________
[[6,3,7,4,6], [26,28,24,18] [22,13,27,18,16]
[9,2,6,7,4],
[3,7,7,2,5],
[4,1,7,5,1]]
# keepdims可以保持原来数组的维数
np.sum(a, 1, keepdims = True) np.sum(a, 0, keepdims = True)
[[26] [22,13,27,18,16]
[28]
[24]
[18]]
大小与排序
numpy在排序等方面常用的函数如下：
| 函数名 | 功能 | 函数名 | 功能 |
|---|---|---|---|
| min | 最小值 | max | 最大值 |
| ptp | 极差 | argmin | 最小值下标 |
| minium | 二元最小值 | maxinum | 二元最大值 |
| sort | 数组排序 | argsort | 数组排序下标 |
| percentile | 分位数 | median | 中位数 |
min,max都有axis，out，keepdims等参数
a = np.array([1，3，5，7])
b = np.array([2,4,6])
np.maxinum(a[None,:],b[:,None]) # maxinum返回两组矩阵广播计算后的结果
[[2 3 5 7],
[4 4 5 7],
[6 6 6 7]]
sort()对数组进行排序会改变数组排序的内容，返回一个新的数组。axis的默认值是-1，即按最终轴进行排序。axis=0对每列上的值进行排序。
a = np.array([
[4, 7, 4, 5],
[2, 7, 3, 5],
[6, 6, 6, 7]])
b = np.sort(a)
print(b)
[[4 4 5 7]
[2 3 5 7]
[6 6 6 7]]
a = np.array([
[4, 7, 4, 5],
[2, 7, 3, 5],
[6, 6, 6, 7]])
b = np.sort(a, axis=0)
print(b)
[[2 6 3 5]
[4 7 4 5]
[6 7 6 7]]
扫一扫
9083
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
