目录
任务2.1
代码2.1 创建数组并查看数组属性
# 创建二维数组
arr2 = np.array([[1, 2, 3, 4],[4, 5, 6, 7], [7, 8, 9, 10]])
print('创建的数组为：\n', arr2)
# 创建二维数组
arr2 = np.array([[1, 2, 3, 4],[4, 5, 6, 7], [7, 8, 9, 10]])
print('创建的数组为：\n', arr2)
print('数组维度为：', arr2.shape) # 查看数组结构数组维度为： (3, 4)
print('数组类型为：', arr2.dtype) # 查看数组类型数组类型为： int32
print('数组元素个数为：', arr2.size) # 查看数组元素个数数组元素个数为： 12
print('数组每个元素大小为：', arr2.itemsize) # 查看数组每个元素大小数组每个元素大小为： 4
代码2-2重新设置数组的shape属性
arr2.shape = 4,3 # 重新设置shape
print('重新设置shape 后的arr2 为：\n', arr2)重新设置shape 后的arr2 为： [[ 1 2 3] [ 4 4 5] [ 6 7 7] [ 8 9 10]]
代码2-3使用arange函数创建数组
print('使用arange函数创建的数组为：\n', np.arange(0,1,0.1))使用arange函数创建的数组为： [0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
代码2-4使用linspace函数创建数组
print('使用linspace函数创建的数组为：\n', np.linspace(0, 1, 12))使用linspace函数创建的数组为： [0. 0.09090909 0.18181818 0.27272727 0.36363636 0.45454545 0.54545455 0.63636364 0.72727273 0.81818182 0.90909091 1. ]
代码2-5使用logspace函数创建等比数列
print('使用logspace函数创建的数组为：\n', np.logspace(0, 2, 20))使用logspace函数创建的数组为： [ 1. 1.27427499 1.62377674 2.06913808 2.6366509 3.35981829 4.2813324 5.45559478 6.95192796 8.8586679 11.28837892 14.38449888 18.32980711 23.35721469 29.76351442 37.92690191 48.32930239 61.58482111 78.47599704 100. ]
代码2-6使用zeros函数创建数组
print('使用zeros函数创建的数组为：\n', np.zeros((2,3)))使用zeros函数创建的数组为： [[0. 0. 0.] [0. 0. 0.]]
代码2-7使用eye函数创建数组
print('使用eye函数创建的数组为：\n', np.eye(3))使用eye函数创建的数组为： [[1. 0. 0.] [0. 1. 0.] [0. 0. 1.]]
代码2-8使用diag函数创建数组
print('使用diag函数创建的数组为：\n', np.diag([1,2,3,4]))使用diag函数创建的数组为： [[1 0 0 0] [0 2 0 0] [0 0 3 0] [0 0 0 4]]
代码2-9使用ones函数创建数组
print('使用ones函数的数组为：\n', np.ones((5,3)))使用ones函数的数组为： [[1. 1. 1.] [1. 1. 1.] [1. 1. 1.] [1. 1. 1.] [1. 1. 1.]]
代码2-10数组的数据类型转换
print('转换结果为：', np.float64(42)) # 整型转换为浮点型转换结果为： 42.0
print('转换结果为：', np.int8(42.0)) # 浮点型转换为整型转换结果为： 42
print('转换结果为：', np.bool(42)) # 整型转换为布尔型转换结果为： True
print('转换结果为：', np.bool(0)) # 整型转换为布尔型转换结果为： False
print('转换结果为：', np.float(True)) # 布尔型转换为浮点型转换结果为： 1.0
print('转换结果为：', np.float(False)) # 布尔型转换为浮点型转换结果为： 0.0
代码 2-11创建数据类型
df = np.dtype([('name', np.str_, 40), ('numitems', np.int64),
('price',np.float64)])
print('数据类型为：\n', df)数据类型为：
[('name', '<U40'), ('numitems', '<i8'), ('price', '<f8')]
代码2-12查看数据类型
print('数据类型为：', df['name'])数据类型为： <U40
print('数据类型为：', np.dtype(df['name']))数据类型为： <U40
代码2-13自定义数组数据
itemz = np.array([('tomatoes', 42, 4.14), ('cabbages', 13, 1.72)],
dtype=df)
print('自定义数据为：', itemz)自定义数据为： [('tomatoes', 42, 4.14) ('cabbages', 13, 1.72)]
代码2-14使用random函数生成随机数
print('生成的随机数组为：\n', np.random.random(100))生成的随机数组为： [0.91009941 0.38971392 0.36651664 0.55228085 0.92861254 0.45650659 0.48869141 0.4330435 0.38950234 0.64523967 0.16870891 0.17985865 0.01497639 0.08234077 0.51486455 0.40770157 0.00955982 0.83913705 0.51148544 0.49882495 0.58877471 0.11001274 0.10941262 0.03026103 0.33737494 0.17337839 0.97962109 0.32665067 0.78753801 0.70543028 0.6413123 0.45475229 0.67101947 0.1121729 0.91150544 0.20102706 0.70580184 0.41808633 0.11117278 0.84714361 0.60862525 0.63719574 0.30261854 0.97130722 0.53375854 0.40871309 0.43649258 0.75927913 0.97695401 0.72504854 0.79898402 0.1163823 0.96072013 0.54791371 0.20541456 0.13956211 0.67475225 0.76754806 0.26586006 0.63771029 0.84982317 0.75541256 0.5325162 0.63723635 0.61404798 0.34595499 0.62540469 0.40829216 0.57923474 0.89820128 0.9261807 0.51075604 0.72329066 0.31961559 0.57673413 0.24374612 0.05329792 0.89017397 0.83048516 0.81839935 0.85868032 0.07458536 0.67628979 0.82324953 0.779021 0.56406122 0.5217467 0.35230849 0.37906655 0.54927848 0.02940487 0.63062026 0.20120026 0.53073772 0.0892534 0.82547203 0.52408316 0.39243274 0.23677769 0.92129089]
代码2-15使用rand函数生成服从均匀分布的随机数
print('生成的随机数组为：\n', np.random.rand(10,5))生成的随机数组为： [[0.26004401 0.90127543 0.4871395 0.34963472 0.15833367] [0.30580265 0.14708818 0.38243072 0.73202472 0.53330933] [0.79158854 0.69741122 0.5542018 0.61665589 0.35036994] [0.775828 0.36414782 0.72841742 0.49730055 0.72517543] [0.65226372 0.52816308 0.05812214 0.6943847 0.30634741] [0.77387524 0.73702271 0.15720394 0.75705873 0.41394823] [0.12574533 0.75515027 0.1770142 0.5172569 0.6477518 ] [0.97658864 0.64671953 0.68923132 0.40047173 0.81832878] [0.97967903 0.3653387 0.01972593 0.89240554 0.73672777] [0.00390053 0.0852122 0.35883258 0.40277924 0.07514376]]
代码2-16使用randn函数生成服从正态分布的随机数
print('生成的随机数组为：\n', np.random.randn(10,5))生成的随机数组为： [[ 0.56490903 0.64932943 -1.35589962 0.73309843 -1.11670959] [ 0.47632879 0.69640015 -0.03136369 0.55809301 1.2892509 ] [ 0.02361408 0.98178568 0.73162593 -0.60879293 -0.9393513 ] [-0.80286376 -0.01762316 1.24876116 -0.09859027 0.45719063] [-1.39213641 -1.18101015 -0.45349273 1.35455062 -1.21581214] [ 0.55088606 0.78031933 -1.09830964 0.5876189 0.15343273] [-0.65986616 0.80286009 -0.39915306 0.34366966 0.80676318] [-0.62761934 1.68307493 1.55653011 -1.5070188 -0.81647124] [-1.09908405 -0.00466503 -1.03002163 -0.63344023 0.59706105] [ 1.01027268 -0.89199252 -0.85573139 1.01025264 0.24545015]]
代码2-17使用randint函数的常用参数及其说明
print('生成的随机数组为：\n', np.random.randint(2, 10, size=[2,5]))
生成的随机数组为： [[2 6 7 3 6] [4 7 2 2 9]]
代码2-18使用索引访问一维数组
arr = np.arange(10)
print('索引结果为：', arr[5]) # 用整数作为下标可以获取数组中的某个元素索引结果为： 5
# 用范围作为下标获取数组的一个切片，包括arr[3]不包括arr[5]
print('索引结果为：', arr[3:5])索引结果为： [3 4]
print('索引结果为：', arr[:5]) # 省略开始下标，表示从arr[0]开始索引结果为： [0 1 2 3 4]
# 下标可以使用负数，-1表示从数组后往前数的第一个元素
print('索引结果为：', arr[-1])索引结果为： 9
arr[2:4] = 100,101
print('索引结果为：', arr) # 下标还可以用来修改元素的值索引结果为： [ 0 1 100 101 4 5 6 7 8 9]
# 范围中的第三个参数表示步长，2表示隔一个元素取一个元素
print('索引结果为：', arr[1:-1:2])索引结果为： [ 1 101 5 7]
print('索引结果为：', arr[5:1:-2]) # 步长为负数时，开始下标必须大于结束下标索引结果为： [ 5 101]
代码2-19使用索引访问多维数组
arr = np.array([[1, 2, 3, 4, 5],[4, 5, 6, 7, 8], [7, 8, 9, 10, 11]])
print('创建的二维数组为：\n', arr)
创建的二维数组为： [[ 1 2 3 4 5] [ 4 5 6 7 8] [ 7 8 9 10 11]]
print('索引结果为：', arr[0,3:5]) # 索引第0行中第3和第4列的元素索引结果为： [4 5]
# 索引第2和第3行中第3列、第4列和第5列的元素
print('索引结果为：\n', arr[1:,2:])索引结果为： [[ 6 7 8] [ 9 10 11]]
print('索引结果为：', arr[:,2]) # 索引第2列的元素索引结果为： [3 6 9]
代码2-20使用整数序列索引和布尔值索引访问多维数组
# 从两个序列的对应位置取出两个整数组成下标：arr[0,1], arr[1,2], arr[2,3]
print('索引结果为：', arr[[0, 1, 2], [1, 2, 3]])索引结果为： [ 2 6 10]
print('索引结果为：\n', arr[1:, (0, 2, 3)]) # 索引第2、3行中第0、2、3列的元素索引结果为： [[ 4 6 7] [ 7 9 10]]
mask = np.array([1, 0, 1], dtype = np.bool)
# mask是一个布尔数组，它索引第1、3行中第2列的元素
print('索引结果为：', arr[mask, 2])索引结果为： [3 9]
代码2-21改变数组形状
arr = np.arange(12) # 创建一维数组
print('创建的一维数组为：', arr)创建的一维数组为： [ 0 1 2 3 4 5 6 7 8 9 10 11]
print('新的一维数组为：\n', arr.reshape(3, 4)) # 设置数组的形状新的一维数组为： [[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]]
print('数组维度为：', arr.reshape(3, 4).ndim) # 查看数组维度数组维度为： 2
代码2-22使用ravel函数展平数组
arr = np.arange(12).reshape(3, 4)
print('创建的二维数组为：\n', arr)创建的二维数组为： [[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]]
print('数组展平后为：', arr.ravel())数组展平后为： [ 0 1 2 3 4 5 6 7 8 9 10 11]
代码2-23使用flatten函数展平数组
print('数组展平为：', arr.flatten()) # 横向展平数组展平为： [ 0 1 2 3 4 5 6 7 8 9 10 11]
print('数组展平为：', arr.flatten('F')) # 纵向展平数组展平为： [ 0 4 8 1 5 9 2 6 10 3 7 11]
代码2-24使用hstack函数实现数组横向组合
arr1 = np.arange(12).reshape(3, 4)
print('创建的数组1为：\n', arr1)创建的数组1为： [[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]]
arr2 = arr1*3
print('创建的数组2为：\n', arr2)
创建的数组2为： [[ 0 3 6 9] [12 15 18 21] [24 27 30 33]]
print('横向组合为：\n', np.hstack((arr1, arr2))) # hstack函数横向组合横向组合为： [[ 0 1 2 3 0 3 6 9] [ 4 5 6 7 12 15 18 21] [ 8 9 10 11 24 27 30 33]]
代码2-25使用hstack函数实现数组纵向组合
print('纵向组合为：\n', np.vstack((arr1, arr2))) # vstack函数纵向组合纵向组合为： [[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11] [ 0 3 6 9] [12 15 18 21] [24 27 30 33]]
代码2-26使用concatenate函数组合数组
print('横向组合为：\n', np.concatenate((arr1, arr2), axis=1)) # concatenate函数横向组合
横向组合为： [[ 0 1 2 3 0 3 6 9] [ 4 5 6 7 12 15 18 21] [ 8 9 10 11 24 27 30 33]]
print('纵向组合为：\n', np.concatenate((arr1, arr2), axis=0)) # concatenate函数纵向组合纵向组合为： [[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11] [ 0 3 6 9] [12 15 18 21] [24 27 30 33]]
代码2-27使用hsplit函数实现数组横向分割
arr = np.arange(16).reshape(4, 4)
print('创建的二维数组为：\n', arr)
创建的二维数组为： [[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11] [12 13 14 15]]
print('横向分割为：\n', np.hsplit(arr, 2)) # hsplit函数横向分割横向分割为：
[array([[ 0, 1],
[ 4, 5],
[ 8, 9],
[12, 13]]), array([[ 2, 3],
[ 6, 7],
[10, 11],
[14, 15]])]
代码2-28使用vsplit函数实现数组纵向分割
print('纵向分割为：\n', np.vsplit(arr, 2)) # vsplit函数纵向分割纵向分割为：
[array([[0, 1, 2, 3],
[4, 5, 6, 7]]), array([[ 8, 9, 10, 11],
[12, 13, 14, 15]])]
代码2-29使用split函数分割数组
print('横向分割为：\n', np.split(arr, 2, axis=1)) # split函数横向分割
横向分割为：
[array([[ 0, 1],
[ 4, 5],
[ 8, 9],
[12, 13]]), array([[ 2, 3],
[ 6, 7],
[10, 11],
[14, 15]])]
print('纵向分割为：\n', np.split(arr, 2, axis=0)) # split函数纵向分割
纵向分割为：
[array([[0, 1, 2, 3],
[4, 5, 6, 7]]), array([[ 8, 9, 10, 11],
[12, 13, 14, 15]])]
任务2.2
代码2-30使用mat函数与matrix函数创建矩阵
import numpy as np # 导入NumPy库
matr1 = np.mat('1 2 3; 4 5 6; 7 8 9') # 使用分号隔开数据
print('创建的矩阵为：\n', matr1)创建的矩阵为： [[1 2 3] [4 5 6] [7 8 9]]
matr2 = np.matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print('创建的矩阵为：\n', matr2)创建的矩阵为： [[1 2 3] [4 5 6] [7 8 9]]
代码2-31使用bmat函数创建矩阵
arr1 = np.eye(3)
print('创建的数组1为：\n', arr1)创建的数组1为： [[1. 0. 0.] [0. 1. 0.] [0. 0. 1.]]
arr2 = 3 * arr1
print('创建的数组2为：\n', arr2)创建的数组2为： [[3. 0. 0.] [0. 3. 0.] [0. 0. 3.]]
print('创建的矩阵为：\n', np.bmat('arr1 arr2; arr1 arr2'))
创建的矩阵为： [[1. 0. 0. 3. 0. 0.] [0. 1. 0. 0. 3. 0.] [0. 0. 1. 0. 0. 3.] [1. 0. 0. 3. 0. 0.] [0. 1. 0. 0. 3. 0.] [0. 0. 1. 0. 0. 3.]]
代码2-32矩阵运算
matr1 = np.mat('1 2 3; 4 5 6; 7 8 9') # 创建矩阵
print('创建的矩阵为：\n', matr1)创建的矩阵为： [[1 2 3] [4 5 6] [7 8 9]]
matr2 = matr1 * 3 # 矩阵与数相乘
print('创建的矩阵为：\n', matr2)创建的矩阵为： [[ 3 6 9] [12 15 18] [21 24 27]]
print('矩阵相加结果为：\n', matr1 + matr2) # 矩阵相加矩阵相加结果为： [[ 4 8 12] [16 20 24] [28 32 36]]
print('矩阵相减结果为：\n', matr1 - matr2) # 矩阵相减矩阵相减结果为： [[ -2 -4 -6] [ -8 -10 -12] [-14 -16 -18]]
print('矩阵相乘结果为：\n', matr1 * matr2) # 矩阵相乘矩阵相乘结果为： [[ 90 108 126] [198 243 288] [306 378 450]]
代码2-33查看矩阵属性
matr3 = np.mat([[6, 2, 1], [1, 5, 2], [3, 4, 8]])
print('矩阵转置结果为：\n', matr3.T) # 转置矩阵转置结果为： [[6 1 3] [2 5 4] [1 2 8]]
print('矩阵的逆矩阵结果为：\n', matr3.H) # 共轭转置矩阵矩阵的逆矩阵结果为： [[6 1 3] [2 5 4] [1 2 8]]
print('矩阵的逆矩阵结果为：\n', matr3.I) # 逆矩阵矩阵的逆矩阵结果为： [[ 0.18079096 -0.06779661 -0.00564972] [-0.01129944 0.25423729 -0.06214689] [-0.06214689 -0.10169492 0.15819209]]
print('矩阵的二维数组结果为：\n', matr3.A) # 返回二维数组的视图矩阵的二维数组结果为： [[6 2 1] [1 5 2] [3 4 8]]
代码2-34数组的四则运算
x = np.array([1, 2, 3])
y = np.array([4, 5, 6])
print('数组相加结果为：', x + y) # 数组相加数组相加结果为： [5 7 9]
print('数组相减结果为：', x - y) # 数组相减数组相减结果为： [-3 -3 -3]
print('数组相乘结果为：', x * y) # 数组相乘数组相乘结果为： [ 4 10 18]
print('数组相除结果为：', x / y) # 数组相除数组相除结果为： [0.25 0.4 0.5 ]
print('数组幂运算结果为：', x ** y) # 数组幂运算数组幂运算结果为： [ 1 32 729]
代码2-35数组的比较运算
x = np.array([1, 3, 5])
y = np.array([2, 3, 4])
print('数组比较结果为：', x < y)数组比较结果为： [ True False False]
print('数组比较结果为：', x > y)数组比较结果为： [False False True]
print('数组比较结果为：', x == y)数组比较结果为： [False True False]
print('数组比较结果为：', x >= y)数组比较结果为： [False True True]
print('数组比较结果为：', x <= y)数组比较结果为： [ True True False]
print('数组比较结果为：', x != y)数组比较结果为： [ True False True]
代码2-36数组的逻辑运算
print('数组逻辑运算结果为：', np.all(x == y)) # np.all表示逻辑and数组逻辑运算结果为： False
print('数组逻辑运算结果为：', np.any(x == y)) # np.any表示逻辑or数组逻辑运算结果为： True
代码2-37一维数组的广播机制
arr1 = np.array([[0, 0, 0], [1, 1, 1], [2, 2, 2], [3, 3, 3]])
print('创建的数组1为：\n', arr1)创建的数组1为： [[0 0 0] [1 1 1] [2 2 2] [3 3 3]]
print('数组1的shape为：', arr1.shape)数组1的shape为： (4, 3)
arr2 = np.array([1, 2, 3])
print('创建的数组2为：', arr2)创建的数组2为： [1 2 3]
print('数组2的shape为：', arr2.shape)数组2的shape为： (3,)
print('数组相加结果为：\n', arr1 + arr2)数组相加结果为： [[1 2 3] [2 3 4] [3 4 5] [4 5 6]]
代码2-38二维数组的广播机制
arr1 = np.array([[0, 0, 0], [1, 1, 1], [2, 2, 2], [3, 3, 3]])
print('创建的数组1为：\n', arr1)创建的数组1为： [[0 0 0] [1 1 1] [2 2 2] [3 3 3]]
print('数组1的shape为：', arr1.shape)数组1的shape为： (4, 3)
arr2 = np.array([1, 2, 3, 4]).reshape((4, 1))
print('创建的数组2为：\n', arr2)创建的数组2为： [[1] [2] [3] [4]]
print('数组2的shape为：', arr2.shape)数组2的shape为： (4, 1)
print('数组相加结果为：\n', arr1 + arr2)数组相加结果为： [[1 1 1] [3 3 3] [5 5 5] [7 7 7]]
任务2.3
代码2-39二进制数据存储
import numpy as np # 导入NumPy库
arr = np.arange(100).reshape(10, 10) # 创建一个数组
np.save('../tmp/save_arr', arr) # 保存数组
print('保存的数组为：\n', 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] [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]]
代码2-40多个数组存储
arr1 = np.array([[1, 2, 3], [4, 5, 6]])
arr2 = np.arange(0, 1.0, 0.1)
np.savez('../tmp/savez_arr', arr1, arr2)
print('保存的数组1为：', arr1)保存的数组1为： [[1 2 3] [4 5 6]]
print('保存的数组2为：', arr2)保存的数组2为： [0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
代码2-41二进制文件读取
# 读取含有单个数组的文件
loaded_data = np.load('../tmp/save_arr.npy')
print('读取的数组为：\n', loaded_data)
读取的数组为： [[ 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]]
# 读取含有多个数组的文件
loaded_data1 = np.load('../tmp/savez_arr.npz')
print('读取的数组1为：\n', loaded_data1['arr_0'])读取的数组1为： [[1 2 3] [4 5 6]]
print('读取的数组2为：', loaded_data1['arr_1'])读取的数组2为： [0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
代码2-42文件存储与读取
arr = np.arange(0, 12, 0.5).reshape(4, -1)
print('创建的数组为：\n', arr)创建的数组为： [[ 0. 0.5 1. 1.5 2. 2.5] [ 3. 3.5 4. 4.5 5. 5.5] [ 6. 6.5 7. 7.5 8. 8.5] [ 9. 9.5 10. 10.5 11. 11.5]]
# fmt='%d'表示保存为整数
np.savetxt('../tmp/arr.txt', arr, fmt='%d', delimiter=',')
# 读入的时候也需要指定逗号分隔
loaded_data = np.loadtxt('../tmp/arr.txt', delimiter=',')
print('读取的数组为：\n', loaded_data)读取的数组为： [[ 0. 0. 1. 1. 2. 2.] [ 3. 3. 4. 4. 5. 5.] [ 6. 6. 7. 7. 8. 8.] [ 9. 9. 10. 10. 11. 11.]]
代码2-43使用genfromtxt函数读取数组
loaded_data = np.genfromtxt('../tmp/arr.txt', delimiter=',')
print('读取的数组为：\n', loaded_data)读取的数组为： [[ 0. 0. 1. 1. 2. 2.] [ 3. 3. 4. 4. 5. 5.] [ 6. 6. 7. 7. 8. 8.] [ 9. 9. 10. 10. 11. 11.]]
代码2-44使用sort函数进行排序
np.random.seed(42) # 设置随机种子
arr = np.random.randint(1, 10, size=10) # 生成随机数组
print('创建的数组为：', arr)创建的数组为： [7 4 8 5 7 3 7 8 5 4]
arr.sort() # 直接排序
print('排序后数组为：', arr)排序后数组为： [3 4 4 5 5 7 7 7 8 8]
np.random.seed(42) # 设置随机种子
arr = np.random.randint(1, 10, size=(3, 3)) # 生成3行3列的随机数组
print('创建的数组为：\n', arr)创建的数组为： [[7 4 8] [5 7 3] [7 8 5]]
arr.sort(axis=1) # 沿着横轴排序
print('排序后数组为：\n', arr)排序后数组为： [[4 7 8] [3 5 7] [5 7 8]]
arr.sort(axis=0) # 沿着纵轴排序
print('排序后数组为：\n', arr)排序后数组为： [[3 5 7] [4 7 8] [5 7 8]]
代码2-45使用argsort函数进行排序
arr = np.array([2, 3 , 6, 8, 0, 7])
print('创建的数组为：', arr)创建的数组为： [2 3 6 8 0 7]
print('排序后数组为：', arr.argsort()) # 返回值为重新排序值的下标
排序后数组为： [4 0 1 2 5 3]
代码2-46使用lexsort函数进行排序
a= np.array([3, 2, 6, 4, 5])
b = np.array([50, 30, 40, 20, 10])
c = np.array([400, 300, 600, 100, 200])
d = np.lexsort((a, b, c)) # lexsort函数只接受一个参数，即（a,b,c）
# 多个键值排序是按照最后一个传入数据计算的
print('排序后数组为：\n', list(zip(a[d], b[d], c[d])))排序后数组为： [(4, 20, 100), (5, 10, 200), (2, 30, 300), (3, 50, 400), (6, 40, 600)]
代码2-47数组内数据去重
names = np.array(['小明', '小黄', '小花', '小明',
'小花', '小兰', '小白'])
print('创建的数组为：', names)创建的数组为： ['小明' '小黄' '小花' '小明' '小花' '小兰' '小白']
print('去重后的数组为：', np.unique(names))去重后的数组为： ['小兰' '小明' '小白' '小花' '小黄']
# 跟np.unique函数等价的Python代码实现过程
print('去重后的数组为：', sorted(set(names)))去重后的数组为： ['小兰', '小明', '小白', '小花', '小黄']
# 创建数值型数据
ints = np.array([1, 2, 3, 4, 4, 5, 6, 6, 7, 8, 8, 9, 10])
print('创建的数组为：', ints)创建的数组为： [ 1 2 3 4 4 5 6 6 7 8 8 9 10]
print('去重后的数组为：', np.unique(ints))
去重后的数组为： [ 1 2 3 4 5 6 7 8 9 10]
代码2-48使用tile函数实现数据重复
arr = np.arange(5)
print('创建的数组为：', arr)创建的数组为： [0 1 2 3 4]
print('重复后数组为：', np.tile(arr, 3)) # 对数组进行重复重复后数组为： [0 1 2 3 4 0 1 2 3 4 0 1 2 3 4]
代码2-49使用repeat函数实现数据重复
np.random.seed(42) # 设置随机种子
arr = np.random.randint(0, 10,size=(3, 3))
print('创建的数组为：\n', arr)创建的数组为： [[6 3 7] [4 6 9] [2 6 7]]
print('重复后数组为：\n', arr.repeat(2, axis=0)) # 按行进行元素重复重复后数组为： [[6 3 7] [6 3 7] [4 6 9] [4 6 9] [2 6 7] [2 6 7]]
print('重复后数组为：\n', arr.repeat(2, axis=1)) # 按列进行元素重复重复后数组为： [[6 6 3 3 7 7] [4 4 6 6 9 9] [2 2 6 6 7 7]]
代码2-50NumPy中常用统计函数的使用
arr = np.arange(20).reshape(4, 5)
print('创建的数组为：\n', arr)创建的数组为： [[ 0 1 2 3 4] [ 5 6 7 8 9] [10 11 12 13 14] [15 16 17 18 19]]
print('数组的和为：', np.sum(arr)) # 计算数组的和
数组的和为： 190
print('数组横轴的和为：', arr.sum(axis=0)) # 沿着横轴计算求和
数组横轴的和为： [30 34 38 42 46]
print('数组纵轴的和为：', arr.sum(axis=1)) # 沿着纵轴计算求和
数组纵轴的和为： [10 35 60 85]
print('数组的均值为：', np.mean(arr)) # 计算数组均值
数组的均值为： 9.5
print('数组横轴的均值为：', arr.mean(axis=0)) # 沿着横轴计算数组均值数组横轴的均值为： [ 7.5 8.5 9.5 10.5 11.5]
print('数组纵轴的均值为：', arr.mean(axis=1)) # 沿着纵轴计算数组均值数组纵轴的均值为： [ 2. 7. 12. 17.]
print('数组的标准差为：', np.std(arr)) # 计算数组标准差
数组的标准差为： 5.766281297335398
print('数组的方差为：', np.var(arr)) # 计算数组方差
数组的方差为： 33.25
print('数组的最小值为：', np.min(arr)) # 计算数组最小值
数组的最小值为： 0
print('数组的最大值为：', np.max(arr)) # 计算数组最大值
数组的最大值为： 19
print('数组的最小元素为：', np.argmin(arr)) # 返回数组最小元素的索引数组的最小元素为： 0
print('数组的最大元素为：', np.argmax(arr)) # 返回数组最大元素的索引数组的最大元素为： 19
代码 2-51cumsum函数和cumprod函数的使用
arr = np.arange(2, 10)
print('创建的数组为：', arr)创建的数组为： [2 3 4 5 6 7 8 9]
print('数组元素的累计和为：', np.cumsum(arr)) # 计算所有元素的累计和数组元素的累计和为： [ 2 5 9 14 20 27 35 44]
print('数组元素的累计积为：\n', np.cumprod(arr)) # 计算所有元素的累计积数组元素的累计积为： [ 2 6 24 120 720 5040 40320 362880]
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
