本项目来源于和鲸社区，使用转载需要标注来源
- 作者: 和鲸社区
- 来源: 和鲸社区
1. 创建数组
1.1 python中的固定类型数组
import array
L = list(range(10))
# array 为 python 内置数组模块，i 是一个数据类型码表示数据为整型
A = array.array('i', L)
A
array(‘i’, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
1.2 利用np.array从列表创建数组
import numpy as np
import array
np.array([1, 2, 3])
array([1, 2, 3])
# Numpy 要求数组必须包含统一类型的数据，类型不匹配会向上转化
a = np.array([3.0, 2, 5, 1.3])
# 可以用 dtype 明确设置数据类型
b = np.array([1, 2, 3, 4], dtype = 'float')
print(a)
print(b)
type(b)
[3. 2. 5. 1.3]
[1. 2. 3. 4.]
numpy.ndarray
# 嵌套列表构成多维数组
for i in range(2, 5):
print(i)
list1 = [range(i, i + 3) for i in [2, 4, 6]]
c = np.array([range(i, i + 3) for i in [2, 4, 6]])
print('list1:', list1)
print(c)
c
2
3
4
list1: [range(2, 5), range(4, 7), range(6, 9)]
[[2 3 4]
[4 5 6]
[6 7 8]]
array([[2, 3, 4],
[4, 5, 6],
[6, 7, 8]])
1.3 从头创建数组
# 用 np.zeros 创建一个长度为10，值都是整型 0 的数组
np.zeros(10, dtype = int)
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
# 用 np.ones 创建一个3 X 5的浮点型数组，数组值均为1
np.ones((3, 5))
array([[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.]])
# 用 np.full 创建一个3 X 5的浮点型数组，数值指定都为3.14
np.full((3, 5), 3.14)
array([[3.14, 3.14, 3.14, 3.14, 3.14],
[3.14, 3.14, 3.14, 3.14, 3.14],
[3.14, 3.14, 3.14, 3.14, 3.14]])
# 用 np.arange 创建一个线性序列数组，数组值从0开始到20结束（不包含20），步长为2，类似与range函数
np.arange(0, 20, 2)
array([ 0, 2, 4, 6, 8, 10, 12, 14, 16, 18])
a1 = np.random.random()
print('创建一个[0,1)之间的随机数', a1)
a2 = np.random.random(1)
print('创建一个只包含[0,1)之间一个单一元素的数组', a2)
a3 = np.random.random((3, 3))
print('创建一个[0,1)之间随机数组成的3X3的数组\n', a3)
a4 = np.random.random((2, 3, 4))
print('创建一个[0,1)之间随机数组成的2X3X4的数组\n', a4)
a5 = np.random.uniform(5, 7, (2, 2))
print('创建一个[5,7)之间随机浮点数组成的2X2的数组\n', a5)
a6 = np.random.randint(5, 7, (2, 2))
print('创建一个[5,7)之间随机整数组成的2X2的数组\n', a6)
创建一个[0,1)之间的随机数 0.8102908878022143
创建一个只包含[0,1)之间一个单一元素的数组 [0.07272163]
创建一个[0,1)之间随机数组成的3X3的数组
[[0.98219564 0.70228434 0.20386254]
[0.67036231 0.23763668 0.26631442]
[0.48903524 0.27790753 0.03550026]]
创建一个[0,1)之间随机数组成的2X3X4的数组
[[[0.13482054 0.50828042 0.28012405 0.00539217]
[0.07922442 0.24172906 0.90193897 0.74965292]
[0.32379602 0.68188647 0.96230269 0.38706645]]
[[0.9235752 0.99531298 0.1450016 0.30981259]
[0.27329865 0.91720172 0.25683821 0.50721779]
[0.95610102 0.61956015 0.4838605 0.81630015]]]
创建一个[5,7)之间随机浮点数组成的2X2的数组
[[5.20944381 5.57915893]
[5.14358432 6.17279182]]
创建一个[5,7)之间随机整数组成的2X2的数组
[[6 6]
[5 6]]
# 创建一个3 X 3的均值为0，标准差为1，符合正态分布的随机数数组 np.random.normal(均值，标准差，形状)-------正态分布概率密度函数
np.random.normal(0, 1, (3, 3))
array([[-0.00930324, 0.72796689, 0.24147934],
[ 0.62781431, -0.29520327, -0.79034739],
[ 1.01174787, 0.61997339, 1.02310458]])
# 创建一个3 X 3的数组，包含标准正态分布的随机数
np.random.randn(3, 3)
array([[ 0.11286236, -0.00375228, 1.19424147],
[-0.30484875, -0.12745572, 0.16679817],
[ 1.84046383, 1.13722739, -0.3044091 ]])
# 创建一个3X3的单位矩阵
np.eye(3)
array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])
# 创建一个由3个整型数组成的未初始化的数组，数组的值是空间中的任意值
np.empty(3)
array([1., 1., 1.])
2. 数组基础
2.1 数组属性
# 设置随机数生成种子，确保每次程序执行都生成同样的随机数组
np.random.seed(0)
x1 = np.random.randint(10, size = 6)
x2 = np.random.randint(10, size = (3, 4))
x3 = np.random.randint(10, size = (3, 4, 5)) #3层4行5列
x1
array([5, 0, 3, 3, 7, 9])
x2
array([[3, 5, 2, 4],
[7, 6, 8, 8],
[1, 6, 7, 7]])
x3
array([[[8, 1, 5, 9, 8],
[9, 4, 3, 0, 3],
[5, 0, 2, 3, 8],
[1, 3, 3, 3, 7]],
[[0, 1, 9, 9, 0],
[4, 7, 3, 2, 7],
[2, 0, 0, 4, 5],
[5, 6, 8, 4, 1]],
[[4, 9, 8, 1, 1],
[7, 9, 9, 3, 6],
[7, 2, 0, 3, 5],
[9, 4, 4, 6, 4]]])
# 数组维度或秩
print('x3 ndim: ', x3.ndim)
# 数组形状，每个维度的大小
print('x3.shape:', x3.shape)
# 数组总大小 各维度大小的乘积
print('x3.size: ', x3.size)
# 数组数据类型
print('x3.dtype: ', x3.dtype)
# 每个数组元素字节大小
print('x3.itemsize: ', x3.itemsize, 'bytes')
# 数组总字节大小 一般nbytes = intemsize * shape
print('x3.nbytes: ', x3.nbytes, 'bytes')
x3 ndim: 3
x3.shape: (3, 4, 5)
x3.size: 60
x3.dtype: int64
x3.itemsize: 8 bytes
x3.nbytes: 480 bytes
2.2 数组索引
x1
array([5, 0, 3, 3, 7, 9])
print(x1[0])
# 用负值获取数组末尾索引
print(x1[-1])
5
9
x3
array([[[8, 1, 5, 9, 8],
[9, 4, 3, 0, 3],
[5, 0, 2, 3, 8],
[1, 3, 3, 3, 7]],
[[0, 1, 9, 9, 0],
[4, 7, 3, 2, 7],
[2, 0, 0, 4, 5],
[5, 6, 8, 4, 1]],
[[4, 9, 8, 1, 1],
[7, 9, 9, 3, 6],
[7, 2, 0, 3, 5],
[9, 4, 4, 6, 4]]])
# 取第 3 层 第 3 行 第 1 列 的数
x3[2][2][0]
7
# 利用索引修改数组的元素值,浮点数插入整型数组时会自动截短
x3[2][2][0] = 10
print(x3)
x3[2][2][0] = 3.1415
x3
[[[ 8 1 5 9 8]
[ 9 4 3 0 3]
[ 5 0 2 3 8]
[ 1 3 3 3 7]]
[[ 0 1 9 9 0]
[ 4 7 3 2 7]
[ 2 0 0 4 5]
[ 5 6 8 4 1]]
[[ 4 9 8 1 1]
[ 7 9 9 3 6]
[10 2 0 3 5]
[ 9 4 4 6 4]]]
array([[[8, 1, 5, 9, 8],
[9, 4, 3, 0, 3],
[5, 0, 2, 3, 8],
[1, 3, 3, 3, 7]],
[[0, 1, 9, 9, 0],
[4, 7, 3, 2, 7],
[2, 0, 0, 4, 5],
[5, 6, 8, 4, 1]],
[[4, 9, 8, 1, 1],
[7, 9, 9, 3, 6],
[3, 2, 0, 3, 5],
[9, 4, 4, 6, 4]]])
2.3 数组切片
Numpy切片语法同列表，x[start:stop:step],默认start=0, step=1, 索引从0开始左边包含，右边不包含。
# 一维数组切片
x = np.arange(10)
print(x)
print('x[:5]', x[:5])
print('x[5:]', x[5:])
print('x[4:7]', x[4:7])
print('每隔一个元素x[::2]', x[::2])
print('从索引1开始每隔一个元素x[1::2]', x[1::2])
# 步长为负逆序排列
print('所有元素逆序x[::-1]', x[::-1])
print('索引5开始逆序每隔一个元素x[5::-2]', x[5::-2])
[0 1 2 3 4 5 6 7 8 9]
x[:5] [0 1 2 3 4]
x[5:] [5 6 7 8 9]
x[4:7] [4 5 6]
每隔一个元素x[::2] [0 2 4 6 8]
从索引1开始每隔一个元素x[1::2] [1 3 5 7 9]
所有元素逆序x[::-1] [9 8 7 6 5 4 3 2 1 0]
索引5开始逆序每隔一个元素x[5::-2] [5 3 1]
# 多维数组切片
print(x2)
print('取前2行前3列x2[:2, :3]\n', x2[:2, :3])
print('取前3行前1列x2[:3, :1]\n', x2[:3, :1])
print('所有行每隔1列x2[:3, ::2]\n',x2[:3, ::2] )
print('逆序x2[::-1, ::-1]\n', x2[::-1, ::-1])
# 获取单行单列简洁语法
print(':表示空切片x2[:, 0]', x2[:, 0])
print('获取单行时列空切片省略x2[1]=x2[1, :]', x2[1])
[[3 5 2 4]
[7 6 8 8]
[1 6 7 7]]
取前2行前3列x2[:2, :3]
[[3 5 2]
[7 6 8]]
取前3行前1列x2[:3, :1]
[[3]
[7]
[1]]
所有行每隔1列x2[:3, ::2]
[[3 2]
[7 8]
[1 7]]
逆序x2[::-1, ::-1]
[[7 7 6 1]
[8 8 6 7]
[4 2 5 3]]
:表示空切片x2[:, 0] [3 7 1]
获取单行时列空切片省略x2[1]=x2[1, :] [7 6 8 8]
# 数组切片返回的是原数组的视图而不是副本，因此修改数组切片得到的子数组会同时修改原数组的元素值
# 通过copy()函数复制数组,修改复制后的子数组，原数组不会变
print('x2\n', x2)
x2_sub = x2[:2, :2]
x2_sub_copy = x2[:2, :2].copy()
print('子数组x2_sub\n', x2_sub)
x2_sub[0,:] = 9
print('子数组x2_sub\n', x2_sub)
print('修改了子数组后的x2\n', x2)
x2_sub_copy[0,:] = 1
print('子数组x2_sub_copy\n', x2_sub_copy)
print('修改了子数组副本的x2\n', x2)
x2
[[3 5 2 4]
[7 6 8 8]
[1 6 7 7]]
子数组x2_sub
[[3 5]
[7 6]]
子数组x2_sub
[[9 9]
[7 6]]
修改了子数组后的x2
[[9 9 2 4]
[7 6 8 8]
[1 6 7 7]]
子数组x2_sub_copy
[[1 1]
[7 6]]
修改了子数组副本的x2
[[9 9 2 4]
[7 6 8 8]
[1 6 7 7]]
2.4 数组变形
# 将数字1-9放入一个3X3的矩阵，前提是两个数组的大小相同
grid = np.arange(1, 10)
print(grid)
grid_reshape = np.arange(1, 10).reshape(3, 3)
print(grid_reshape)
[1 2 3 4 5 6 7 8 9]
[[1 2 3]
[4 5 6]
[7 8 9]]
x = np.array([1, 2, 3])
# 利用 reshape 或 np.newaxis切片 将一维数组变为二维单行数组
print(x.reshape(1, 3))
print(x[np.newaxis, :])
# 利用 reshape 或 np.newaxis切片 将一维数组变为二维单列数组
print(x.reshape(3, 1))
print(x[:, np.newaxis])
[[1 2 3]]
[[1 2 3]]
[[1]
[2]
[3]]
[[1]
[2]
[3]]
2.5 数组的拼接和分裂
# 一维数组的拼接
x = np.array([1, 2, 3])
y = np.array([3, 2, 1])
z = np.array([99, 99, 99])
print(np.concatenate([x, y, z]))
# 二维数组的拼接, np.concatennate([x, y], axis默认是0沿着行方向对每列操作，1是沿着列方向对每行操作)要求维度相同
grid = np.array([[1, 2, 3],
[4, 5, 6]])
print(np.concatenate([grid, grid]))
print(np.concatenate([grid, grid], axis = 1))
print('np.vstack垂直栈同axis=0\n', np.vstack([x, y, z, grid]))
print('np.hstack水平栈同axis=1\n', np.hstack([grid, grid]))
# np.dstack沿第三个方向拼接数组
[ 1 2 3 3 2 1 99 99 99]
[[1 2 3]
[4 5 6]
[1 2 3]
[4 5 6]]
[[1 2 3 1 2 3]
[4 5 6 4 5 6]]
np.vstack垂直栈同axis=0
[[ 1 2 3]
[ 3 2 1]
[99 99 99]
[ 1 2 3]
[ 4 5 6]]
np.hstack水平栈同axis=1
[[1 2 3 1 2 3]
[4 5 6 4 5 6]]
x = [0, 1, 2, 3, 4, 5, 6, 7, 8]
x1, x2, x3 = np.split(x, [3, 5]) # np.split(x, [索引列表记录断点位置])，N个分裂点得到N+1个数组
print(x1, x2, x3)
y = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
print('沿行方向平均分裂成3个数组\n', np.split(y, 3))
print('沿列方向平均分裂成3个数组\n', np.split(y, 3, axis = 1))
# print('沿行方向平均分裂成3个数组\n', np.split(y, [1, 2]))---------------待解释
grid = np.arange(16).reshape(4, 4)
print(grid)
upper, lower = np.vsplit(grid, [2])
print(upper)
print(lower)
left, right = np.hsplit(grid, [1])
print(left)
print(right)
[0 1 2] [3 4] [5 6 7 8]
沿行方向平均分裂成3个数组
[array([[1, 2, 3]]), array([[4, 5, 6]]), array([[7, 8, 9]])]
沿列方向平均分裂成3个数组
[array([[1],
[4],
[7]]), array([[2],
[5],
[8]]), array([[3],
[6],
[9]])]
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
[[0 1 2 3]
[4 5 6 7]]
[[ 8 9 10 11]
[12 13 14 15]]
[[ 0]
[ 4]
[ 8]
[12]]
[[ 1 2 3]
[ 5 6 7]
[ 9 10 11]
[13 14 15]]
3. Numpy数组的计算：通用函数
一元通用函数对单个输入操作，二元通用函数对两个输入操作
3.1 常用通用函数
数组的运算
x = np.arange(4)
print('x = ', x)
print('x + 5 =', x + 5, np.add(x, 5))
print('x - 5 =', x - 5, np.subtract(x, 5))
print('x * 2 =', x * 2, np.multiply(x, 2))
print('x / 2 =', x / 2, np.divide(x, 2))
print('x // 2 =', x // 2, np.floor_divide(x, 2)) # 取商
print('x % 2 =', x % 2, np.mod(x, 2)) # 取余
print('x ** 2 =', x ** 2, np.power(x, 2))
print('-x =', -x, np.negative(x))
print('-(0.5*x + 1) ** 2 = ', -(0.5*x + 1) ** 2)
x = [0 1 2 3]
x + 5 = [5 6 7 8] [5 6 7 8]
x - 5 = [-5 -4 -3 -2] [-5 -4 -3 -2]
x * 2 = [0 2 4 6] [0 2 4 6]
x / 2 = [0. 0.5 1. 1.5] [0. 0.5 1. 1.5]
x // 2 = [0 0 1 1] [0 0 1 1]
x % 2 = [0 1 0 1] [0 1 0 1]
x ** 2 = [0 1 4 9] [0 1 4 9]
-x = [ 0 -1 -2 -3] [ 0 -1 -2 -3]
-(0.5*x + 1) ** 2 = [-1. -2.25 -4. -6.25]
绝对值
x = np.array([-2, -1, 0, 1, 2])
print(abs(x))
print(np.abs(x))
print(np.absolute(x))
# 复数的绝对值返回该复数的模，即实部和虚部平方和的平方根
y = np.array([3 - 4j, 4 - 3j, 2 + 0j, 0 + 1j])
print(y)
print(abs(y))
[2 1 0 1 2]
[2 1 0 1 2]
[2 1 0 1 2]
[3.-4.j 4.-3.j 2.+0.j 0.+1.j]
[5. 5. 2. 1.]
三角函数和逆三角函数
# numpy.linspace(start, stop, num=50, endpoint=True(stop值包含在数组中), retstep=False, dtype=None, axis=0)
# np.pi = π
theta = np.linspace(0, np.pi, 3)
print('theta = ', theta)
print('sin(theta) = ', np.sin(theta))
print('cos(theta) = ', np.cos(theta))
print('tan(theta) = ', np.tan(theta))
x = [-1, 0, 1]
print('x = ', x)
print('arcsin(x) = ', np.arcsin(x))
print('arccos(x) = ', np.arccos(x))
print('arctan(x) = ', np.arctan(x))
theta = [0. 1.57079633 3.14159265]
sin(theta) = [0.0000000e+00 1.0000000e+00 1.2246468e-16]
cos(theta) = [ 1.000000e+00 6.123234e-17 -1.000000e+00]
tan(theta) = [ 0.00000000e+00 1.63312394e+16 -1.22464680e-16]
x = [-1, 0, 1]
arcsin(x) = [-1.57079633 0. 1.57079633]
arccos(x) = [3.14159265 1.57079633 0. ]
arctan(x) = [-0.78539816 0. 0.78539816]
指数和对数
x = [1, 2, 3]
print('x = ', x)
print('e^x = ', np.exp(x))
print('2^x = ', np.exp2(x))
print('3^x = ', np.power(3, x))
y = [1, 2, 4, 10]
print('y = ', y)
print('ln(x) = ', np.log(x)) # np.log以自然常数（e）为底数的对数
print('log2(x) = ', np.log2(x))
print('log10(x) = ', np.log10(x))
# 特殊版本，当输入值非常小时，用特殊函数给出的值比np.log和np.exp计算更精确
z = [0, 0.001, 0.01, 0.1]
print('exp(z) - 1 = ', np.expm1(z))
print('log(1 + z) = ', np.log1p(z))
x = [1, 2, 3]
e^x = [ 2.71828183 7.3890561 20.08553692]
2^x = [2. 4. 8.]
3^x = [ 3 9 27]
y = [1, 2, 4, 10]
ln(x) = [0. 0.69314718 1.09861229]
log2(x) = [0. 1. 1.5849625]
log10(x) = [0. 0.30103 0.47712125]
exp(z) - 1 = [0. 0.0010005 0.01005017 0.10517092]
log(1 + z) = [0. 0.0009995 0.00995033 0.09531018]
# 专用通用函数
# Gamma函数（广义阶乘）和相关函数
from scipy import special
x = [1, 5, 10]
print('gamma(x) = ', special.gamma(x))
print('ln|gamma(x)| = ', special.gammaln(x))
print('beta(x, 2) = ', special.beta(x, 2))
# 误差函数（高斯积分）实现与逆实现
y = np.array([0, 0.3, 0.7, 1.0])
print('erf(y) = ', special.erf(y))
print('erfc(y) = ', special.erfc(y))
print('erfinv(y) = ', special.erfinv(y))
gamma(x) = [1.0000e+00 2.4000e+01 3.6288e+05]
ln|gamma(x)| = [ 0. 3.17805383 12.80182748]
beta(x, 2) = [0.5 0.03333333 0.00909091]
erf(y) = [0. 0.32862676 0.67780119 0.84270079]
erfc(y) = [1. 0.67137324 0.32219881 0.15729921]
erfinv(y) = [0. 0.27246271 0.73286908 inf]
3.2 高级的通用函数特性
- 指定输出位置：所有通用函数都可以用out参数指定计算结果的存放位置
x = np.arange(5)
y = np.empty(5)
np.multiply(x, 10, out = y)
print(y)
# 将计算结果写入指定数组的每隔一个元素的位置
z = np.zeros(10)
print(z)
print(np.power(2, x, out = z[::2]))
print(z)
[ 0. 10. 20. 30. 40.]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[ 1. 2. 4. 8. 16.]
[ 1. 0. 2. 0. 4. 0. 8. 0. 16. 0.]
- 聚合reduce：所有元素累积
x = np.arange(1, 6)
print('x = ', x)
print('x中所有元素求和：', np.add.reduce(x))
print('x中所有元素求积：', np.multiply.reduce(x))
print('x中所有元素依次求和并展示：', np.add.accumulate(x))
print('x中所有元素依次求积并展示：', np.multiply.accumulate(x))
x = [1 2 3 4 5]
x中所有元素求和： 15
x中所有元素求积： 120
x中所有元素依次求和并展示： [ 1 3 6 10 15]
x中所有元素依次求积并展示： [ 1 2 6 24 120]
- 外积：outer获得两个不同输入数组所有元素对的函数运算结果
x = np.arange(1, 6)
print('x = ', x)
print(np.multiply.outer(x, x))
x = [1 2 3 4 5]
[[ 1 2 3 4 5]
[ 2 4 6 8 10]
[ 3 6 9 12 15]
[ 4 8 12 16 20]
[ 5 10 15 20 25]]
4. 闯关题
五道题环环相扣，缺一不可，最后只需要把最终答案赋值给a1，并运行
Q1：创建数列
利用 arange 函数，创建数组值从 1 开始到 19 结束（不包含 19 ），步长为 1 ，保存为 a 再创建一个从 19 到 49 结束（不包含 49 ），步长为 1 ，保存为 b #输入你的代码，并运行
Q2: 对数列形变
利用reshape函数，将a形变为3×6的数组，保存为A 将b形变为5×6的数组，保存为B
Q3：数组拼接与分裂
利用vstack将A和B数组进行垂直方向拼接，保存为C数组 利用split对C数组在第2行分裂成两部分，将下半部分保存为D
Q4：切片与索引
对D提取第1行所有元素，保存为E
Q5：数组计算
利用multiply.accumulate对E中所有元素依次求积，并保留最后一项作为E中的累计积保存为a1