目录
例题10-1：创建数组并查看数组属性
构造复杂数组
生成随机数
例题10-2：绘制：随机生成10000数据，服从均值为0，方差为1的正态分布的直方图（间隔个数：50）
通过索引访问数组
数组的迭代
数组间的四则运算
一个数与数组的四则运算
比较运算
逻辑运算
数组的转置
数组的点积运算
NumPy矩阵运算
例题10-4：数组、矩阵之间的线性代数运算
保存一个数组
保存多个数组
例题10-5：编写程序，读取数据，保存在文件.csv中。
例题10-6：读.txt文件
例题10-1：创建数组并查看数组属性
import numpy as np # 导入Numpy库arr1 = np.array([1, 2, 3, 4]) # 创建的一维数组,参数为列表
print("数组的尺寸：", np.shape(arr1)) # (4, ) , 一个元素的元组，表示是一维数组arr2 = np.array([[1, 2, 3, 4], [4, 5, 6, 7], [7, 8, 9, 10]]) # 创建二维数组
print("数组的尺寸：", np.shape(arr2)) # 2个元素的元组: (3, 4)
# 返回二维数组的行数：3
print(arr2.shape[0])
print(arr2.shape[1])运行结果：
构造复杂数组
import numpy as npa = np.arange(5) # a= [0 1 2 3 4]
b = np.tile(a, 2) # 对变量a重复2次：b = [0 1 2 3 4 0 1 2 3 4]
c = np.tile(a, (3, 2)) # 对a 行重复3次，列重复2次# 重复元素: repeat,如:
d = a.repeat(2) # 对变量a里的元素依次重复2次： d= [0 0 1 1 2 2 3 3 4 4]print(b)
print(c)
print(d)运行结果：
生成随机数
import numpy as npnp.random.seed(0)
A = np.random.rand(4) # 生成区间[0,1)上的均匀分布的4个随机浮点数的一维数组
print(A) # [0.5488135 0.71518937 0.60276338 0.54488318]
a = [i for i in range(10)] # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
b = [np.random.choice(a) for i in range(6)] # 每次从 a 中随机返回一个元素，共迭代6次
# [3, 0, 3, 5, 0, 2]
print(b)# 打乱数组顺序
x = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
y = np.random.permutation(x) # x的数据不动，把随机打乱后的数据返给y
np.random.shuffle(x) # 直接随机打乱数组x的数据
print(x)运行结果：
例题10-2：绘制：随机生成10000数据，服从均值为0，方差为1的正态分布的直方图（间隔个数：50）
import numpy as np
import matplotlib.pyplot as pltnp.random.seed(0)
data = np.random.normal(0, 1, 10000)
print(min(data), max(data))
n, bins, patches = plt.hist(data, 50, facecolor='red', edgecolor='white')
plt.grid(True)
plt.show()运行结果：
通过索引访问数组
import numpy as nparr = np.arange(10) # arr = [0 1 2 3 4 5 6 7 8 9]
print(arr[5]) # 首个索引号从0开始，输出：5
print(arr[3:5]) # 索引号从第3个，到第4个，输出：[3 4]
print(arr[:5]) # 索引号从第0个，到第4个，输出：[0 1 2 3 4]
print(arr[-1]) # -1表示数组最后一个元素：9
print(arr[6:-1:2]) # 索引号从第6个，到最后一个，2为步长，表示每隔一个元素：[6 8]
print(arr[5:1:-2]) # 步长为负数时，开始索引号必须大于结束索引号，输出：[5 3]arr = np.array([[1, 2, 3, 4, 5], [4, 5, 6, 7, 8], [7, 8, 9, 10, 11]])
print(arr[2, 3]) # 索引号第2行第3列的元素，输出：10print(arr[0, 3:5]) # 索引号第0行中第3和4列的元素：[4 5]print(arr[1:, 2:]) # 索引号第1行、第2列后面所有元素
print(arr[1:, 2:]) # 索引号第1行、第2列后面所有元素
print(arr[2:]) # 索引号第2行所有列：[ 7 8 9 10 11 ]
print(arr[:, 2]) # 索引号第2列所有行：[ 3 6 9 ]运行结果：
数组的迭代
import numpy as npa = np.arange(2, 8, 2)
for i in a:print(i, end=',') # 2, 4, 6
for i in enumerate(a):print(i, i[0], i[1])运行结果：
数组间的四则运算
import numpy as npx = np.array([1, 2, 3])
y = np.array([4, 5, 6])
z = np.array("1,2,3")
# 数组元素对应相加，结果为：[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]
print(x ** y)
# 注意：
# print(z.dtype)
# print(z.ndim) # z 的数据类型：<U5 ，z 的维数：0
# x + z # 报错 ，数据形状不一样，不能进行运算运行结果：
一个数与数组的四则运算
import numpy as np# np.shape(a)：(3,4 )
a = np.array([[1, 2, 3, 4], [4, 5, 6, 7], [7, 8, 9, 10]])
b = 2 * a
c = b.reshape(4, 3) # 将数组b的形状改为(4,3)，b不动
print(a)
print(b)
print(c)运行结果：
比较运算
import numpy as npx = np.array([1, 3, 5])
y = np.array([2, 3, 4])
print(x < y) # 输出：[ True False False]
print(x >= y) # 输出：[False True True]
print(x == y) # 输出：[False True False]
print(x != y) # 输出：[ True False True]运行结果：
逻辑运算
import numpy as npx = np.array([1, 3, 5])
y = np.array([2, 3, 4])
print(np.all(x == y)) # 输出：False
print(np.all(x != y)) # 输出：False
print(np.any(x != y)) # 输出：True运行结果：
数组的转置
import numpy as np# np.shape(a) = (4,) 表示一维数组
a = np.array([1, 2, 3, 4])
b = np.array([[1, 2, 3, 4], [4, 5, 6, 7], [7, 8, 9, 10]]) # (3,4) 表示二维数组
# 一维数组 a 的转置：np.shape(c) = (4,)
c = np.transpose(a)
# 二维数组 b 的转置：np.shape(d) = (4,3)
d = np.transpose(b)
print(c)
print(d)运行结果：
数组的点积运算
import numpy as npa = np.array([1, 2, 3, 4]) # (4,) 表示一维数组
b = np.array([[1, 2, 3, 4], [4, 5, 6, 7], [7, 8, 9, 10]]) # (3,4) 表示二维数组
e = np.dot(b, a) # (3, 4) 与 (4,) 点积运算
print(np.shape(e), e) # (3,) [30 60 90]
#e = np.dot(a, b) # Error： shapes (4,) and (3,4)运行结果：
NumPy矩阵运算
import numpy as npmatr1 = np.matrix("1 2 3;0 5 6;0 0 9")
matr2 = matr1 * 3 # 矩阵数乘
matr3 = matr1 + matr2 # 矩阵加法
matr4 = matr1 - matr2 # 矩阵减法
matr5 = matr1 * matr2 # 矩阵相乘（乘法）
matrB = np.multiply(matr1, matr2) # 矩阵对应元素相乘
matr6 = matr1.T # 矩阵的转置
matr8 = matr1.H # 矩阵的共轭转置
matr9 = matr1.I # 矩阵的逆运行结果：
例题10-4：数组、矩阵之间的线性代数运算
import numpy as npx = np.array([[1, 2, 3], [0, 1, -1], [1, 0, 0]]) # x 为二维数组：形状为 (3,3)
print(np.linalg.det(x)) # x 对应矩阵的行列式，输出：-5
y = np.linalg.inv(x) # x 对应矩阵的逆(AB=BA=E)，此时的 y 为二维数组：形状为 (3,3)
a = np.dot(x, y) # 数组 x 与 y 做点积运算，等价于两个矩阵相乘
b = np.mat(x)*np.mat(y) # 将数组 x 与 y 转为矩阵，再做矩阵乘法，等价于 np.dot(x,y)
c = x * y # 数组x与y相乘，即两个数组对应元素相乘，注意：不同于np.dot(x,y)
print(a == b) # 完全相同，全为True
d = np.linalg.eigvals(x) # x 对应矩阵的特征值，返回的 d 为列表
# [-1.51154714+0.j 1.75577357+0.47447678j 1.75577357-0.47447678j ]
print(d)
e = np.linalg.eig(x) # x 对应矩阵的特征值及特征向量，返回的 e 为元组
print(e[0], e[1]) # e[0]为 x 的特征值，e[1]为 x 的特征向量
运行结果：
保存一个数组
import numpy as nparr = np.array([[1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, 6]])
# np.save()只能保存一个数组
print(arr)
np.save("save_arr", arr) # 保存时，默认后缀名为npy
load_arr = np.load("save_arr.npy") # 打开时，必须有后缀名 (若没写路径，默认为当前路径下)
print(load_arr) # 返回的是 'numpy.ndarray'运行结果：
保存多个数组
import numpy as np# 将0-19共20个数，生成一个三维数组：（2,2,5）
x = np.array(range(20)).reshape((2, 2, 5))
y = np.array(range(10, 34)).reshape(2, 3, 4)
# 将10-33共24个数，生成一个三维数组：（2,3,4）
print('x:\n', x)
print('y:\n', y)
filename = 'c:\\qun1\\test\\test.npz'
# 写文件，如果不指定key，那么默认key为'arr_0'、'arr_1'，一直排下去。
np.savez(filename, x, key_y=y) # 数组x没有指定键名，访问时用arr_0，数组y指定了键名
c = np.load(filename) # 读文件 ： 多个数组，通过键名访问
print('keys of NpzFile c:\n', c.keys())
print("c['arr_0']:\n", c['arr_0'])
print("c['key_y']:\n", c['key_y'])运行结果：
例题10-5：编写程序，读取数据，保存在文件.csv中。
# 编写程序，将这3个列数据，及对应的年份读取出来，保存在文件“历年总人口、新生人口和死亡人口.csv”中。
import numpy as np
import xlrdwb = xlrd.open_workbook("历年总人口.xls")
sheet = wb.sheet_by_index(0) # 通过索引号0获取整个sheet数据
col_0 = sheet.col_values(0) # 第0列数据，返回一个列表：年度
col_1 = sheet.col_values(1) # 第1列数据，返回一个列表：总人口
# 年份：从第1个元素开始，到最后一个元素
year = col_0[1:]
# 总人口：从第1个元素开始，到最后一个元素
total = col_1[1:]
year = [int(c) for c in year] # 用列表推导式，把每个元素转为整数
total = [int(c) for c in total] # 用列表推导式，把每个元素转为整数wb = xlrd.open_workbook("历年新生人口和死亡人口.xls")
sheet = wb.sheet_by_index(0) # 通过索引号0获取整个sheet数据
col_1 = sheet.col_values(1) # 通过列索引号1获取列内容：出生人口
col_2 = sheet.col_values(2) # 通过列索引号2获取列内容：死亡人口
add = col_1[1:] # 出生人口：从第1个元素开始，到最后一个元素
die = col_2[1:] # 死亡人口：从第1个元素开始，到最后一个元素
add = [int(c[0:-1]) for c in add] # 用列表推导式，把最后一个‘万’字去掉
die = [int(c[0:-1]) for c in die] # 用列表推导式，把最后一个‘万’字去掉
y = np.array(add)-np.array(die) # 将两个列表变成数组相减，生成每年净增人口
m = len(year)arr = np.array(year).reshape(m, 1) # 将年份的列表转为数组，形状调整为：（m，1）
arr = np.insert(arr, 1, values=total, axis=1) # 在第1列后面插入1列
arr = np.insert(arr, 2, values=add, axis=1) # 在第2列后面插入1列
arr = np.insert(arr, 3, values=die, axis=1) # 在第3列后面插入1列
arr = np.insert(arr, 4, values=y, axis=1) # 在第4列后面插入1列file = 'c:\\qun1\\test\\大陆历年总人口、新生人口和死亡人口.csv'
np.savetxt(file, arr, fmt='%i', delimiter=',',comments='', header='年份,总人口,出生人口,死亡人口,净增人口')
x = np.loadtxt(file, dtype=np.int, delimiter=',', skiprows=1)
print(x)运行结果：
例题10-6：读.txt文件
import numpy as npf = np.loadtxt('testSet.txt') # 打开文本文件
print("返回的二维数组f的形状：", np.shape(f))
print(f)运行结果：
