1. NumPy（Numerical Python 的缩写）是一个开源的 Python 库，专门用于科学计算和数据分析。
它提供了支持大型多维数组和矩阵的功能，此外还提供了许多数学函数库，用于执行这些数组上的操作。
2. Numpy运算速度上的优势
import random
import time
import numpy as np
a = []
for i in range(100000000):
a.append(random.random())
#Jupyter Notebook 通过%time魔法方法, 查看当前行的代码运行一次所花费的时间
#原生Python代码进行计算
%time sum1=sum(a) # 耗时： 767 ms
#使用Numpy进行计算
b=np.array(a)
%time sum2=np.sum(b) # 耗时： 161 ms
#效率远高于纯Python代码Numpy底层使用C语言编写，内部解除了GIL(全局解释器锁),
#其对数组的操作速度不受Python解释器的 限制，所以，其效率远高于纯Python代码
#1. 创建ndarray
import numpy as np
score = np.array(
[[80, 89, 86, 67, 79],
[78, 97, 89, 67, 81],
[90, 94, 78, 67, 74],
[91, 91, 90, 67, 69],
[76, 87, 75, 67, 86],
[70, 79, 84, 67, 84],
[94, 92, 93, 67, 64],
[86, 85, 83, 67, 80]])
print(score)
#2. Numpy数组的属性，形状、类型
#1. 属性
ndarray.shape # 数组维度的元组
ndarray.ndim # 数组维数
ndarray.size # 数组中的元素数量
ndarray.itemsize # 一个数组元素的长度（字节）
ndarray.dtype # 数组元素的类型
# import numpy as np
# 创建ndarray
score = np.array(
[[80, 89, 86, 67, 79],
[78, 97, 89, 67, 81],
[90, 94, 78, 67, 74],
[91, 91, 90, 67, 69],
[76, 87, 75, 67, 86],
[70, 79, 84, 67, 84],
[94, 92, 93, 67, 64],
[86, 85, 83, 67, 80]]
)
# 数组维度的元组
print(score.shape) # (8, 5)
# 数组维数
# print(score.ndim) # 2
# 数组中的元素数量
# print(score.size) # 40
# 一个数组元素的长度（字节）
# print(score.itemsize) # 4
# 数组元素的类型
# print(score.dtype) # int32
#2. 形状
a = np.array([[1,2,3],[4,5,6]])
print(a) # 二维数组 (2, 3)
b = np.array([1,2,3,4])
print(b) # 一维数组 (4,)
c = np.array([[[1,2,3],[4,5,6]],[[1,2,3],[4,5,6]]])
print(c) # 三维数组 (2, 2, 3)
#3. 类型
# np.bool 用一个字节存储的布尔类型（True或False） 'b'
# np.int8 一个字节大小，-128 至 127 'i'
# np.int16 整数，-32768 至 32767 'i2'
# np.int32 整数，-2^31 至 2^32 -1 'i4'
# np.int64 整数，-2^63 至 2^63 - 1 'i8'
# np.uint8 无符号整数，0 至 255 'u'
# np.uint16 无符号整数，0 至 65535 'u2'
# np.uint32 无符号整数，0 至 2^32 - 1 'u4'
# np.uint64 无符号整数，0 至 2^64 - 1 'u8'
# np.float16 半精度浮点数：16位，正负号1位，指数5位，精度10位 'f2'
# np.float32 单精度浮点数：32位，正负号1位，指数8位，精度23位 'f4'
# np.float64 双精度浮点数：64位，正负号1位，指数11位，精度52位 'f8'
# np.complex64 复数，分别用两个32位浮点数表示实部和虚部 'c8'
# np.complex128 复数，分别用两个64位浮点数表示实部和虚部 'c16'
# np.object_ python对象 'O'
# np.string_ 字符串 'S'
# np.unicode_ unicode类型 'U'
a = np.array([[1, 2, 3],[4, 5, 6]], dtype=np.float32)
print(a.dtype)
#3. 生成0和1的数组功能函数
np.ones(shape, dtype)
np.ones_like(a, dtype)
np.zeros(shape, dtype)
np.zeros_like(a, dtype)
#1. 生成四行八列的数组 1
import numpy as np
ones = np.ones([4,8]) # 生成四行八列的数组
print(ones)
输出:
[[1. 1. 1. 1. 1. 1. 1. 1.]
[1. 1. 1. 1. 1. 1. 1. 1.]
[1. 1. 1. 1. 1. 1. 1. 1.]
[1. 1. 1. 1. 1. 1. 1. 1.]]
#2. 生成四行八列的数组 0
ones = np.zeros_like(ones)
print(ones)
# 输出
[[0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0.]]
#4. 生成现有的数据
np.array(object, dtype)
np.asarray(a, dtype)
a = np.array([[1,2,3],[4,5,6]])
#从现有的数组当中创建
# a1 = np.array(a) # 深拷贝
#相当于索引的形式，并没有真正的创建一个新的
# a2 = np.asarray(a) # 浅拷贝
#5. 生成固定范围的数组
#1. 创建等差数组- 指定步长
import numpy as np
a1 = np.linspace(0, 100, 11)
print(a1) # [ 0. 10. 20. 30. 40. 50. 60. 70. 80. 90. 100.]
a2 = np.arange(10, 50, 2)
print(a2) # [10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 42 44 46 48]
#2. 创建等比数列
import numpy as np
np.logspace(0, 2, 3) # array([ 1., 10., 100.])
#6. 生成随机数组
#1. 均匀分布的随机数
import numpy as np
# 生成 3x3 的随机数组
uniform_random_array = np.random.rand(3, 3)
print(uniform_random_array)
#2. 生成指定区间的均匀分布随机数组
import numpy as np
# 生成均匀分布在 [1, 10) 区间内的 3x3 随机数组
uniform_random_array = np.random.uniform(1, 10, (3, 3))
print(uniform_random_array)
#3. 正态分布的随机数
import numpy as np
# 生成 3x3 的随机数组
normal_random_array = np.random.randn(3, 3)
print(normal_random_array)
# 生成均值为 5，标准差为 2 的 3x3 随机数组
normal_random_array = np.random.normal(5, 2, (3, 3))
print(normal_random_array)
#4. 整数随机数
import numpy as np
# 生成在 [0, 10) 区间内的 3x3 随机整数数组
integer_random_array = np.random.randint(0, 10, (3, 3))
print(integer_random_array)
#5. 固定随机种子
import numpy as np
# 设置随机种子
np.random.seed(42)
# 生成随机数组
random_array = np.random.rand(3, 3)
print(random_array)
#7. 数组的索引,切片
#1. 一维数组索引
import numpy as np
# 创建一维数组
arr = np.array([1, 2, 3, 4, 5])
# 索引单个元素
print(arr[0]) # 输出: 1
print(arr[4]) # 输出: 5
#2. 二维数组索引
import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# 索引单个元素
print(arr[0, 1]) # 输出: 2
print(arr[2, 2]) # 输出: 9
#3. 一维数组切片
import numpy as np
arr = np.array([1, 2, 3, 4, 5])
# 切片操作
print(arr[1:4]) # 输出: [2 3 4]
print(arr[:3]) # 输出: [1 2 3]
print(arr[2:]) # 输出: [3 4 5]
print(arr[::2]) # 输出: [1 3 5]（步长为 2）
#4. 二维数组切片
import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# 切片操作
print(arr[0:2, 1:3]) # 输出: [[2 3] [5 6]]，选择前两行和第 2、3 列
print(arr[:, 1]) # 输出: [2 5 8]，选择所有行的第 2 列
print(arr[1, :]) # 输出: [4 5 6]，选择第 2 行的所有列
print(arr[::2, ::2]) # 输出: [[1 3] [7 9]]，步长为 2，选择第 1、3 行和第 1、3 列
#5. 一维数组布尔索引
import numpy as np
arr = np.array([1, 2, 3, 4, 5])
# 布尔索引
print(arr[arr > 2]) # 输出: [3 4 5]，选择大于 2 的元素
#6. 二维数组布尔索引
import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# 布尔索引
print(arr[arr > 5]) # 输出: [6 7 8 9]，选择大于 5 的元素
#7. 三维数组索引方式
import numpy as np
a1 = np.array([ [[1,2,3],[4,5,6]], [[12,3,34],[5,6,7]]])
# 索引、切片
print(a1[0, 0, 1]) # 输出: 2
#8. 形状修改
#1. 改变数组形状
import numpy as np
# 创建一维数组
arr = np.arange(1, 13)
print("Original array:")
print(arr)
# 改变数组形状为 3x4
reshaped_arr = arr.reshape((3, 4))
print("\nReshaped array (3x4):")
print(reshaped_arr)
# 改变数组形状为 2x6
reshaped_arr = arr.reshape((2, 6))
print("\nReshaped array (2x6):")
print(reshaped_arr)
#2. 将数组展平成一维
import numpy as np
# 创建二维数组
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# 将数组展平成一维
flattened_arr = arr.flatten()
print("\nFlattened array:")
print(flattened_arr)
#3. 将数组展平成一维
import numpy as np
# 创建二维数组
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# 将数组展平成一维
raveled_arr = arr.ravel()
print("\nRaveled array:")
print(raveled_arr)
#9. 类型转换
#1. 创建一个新的数组，并将数据类型转换为指定的类型
import numpy as np
# 创建一个整数数组
arr = np.array([1, 2, 3, 4, 5])
print("Original array:", arr)
print("Original dtype:", arr.dtype)
# 将整数数组转换为浮点型数组
float_arr = arr.astype(np.float64)
print("\nConverted array:", float_arr)
print("Converted dtype:", float_arr.dtype)
#2. 直接指定数据类型
import numpy as np
# 创建一个整数数组
arr = np.array([1, 2, 3, 4, 5], dtype=np.int32)
print("Original array:", arr)
print("Original dtype:", arr.dtype)
# 创建时指定为浮点型
float_arr = np.array(arr, dtype=np.float64)
print("\nConverted array:", float_arr)
print("Converted dtype:", float_arr.dtype)
#3. 类型转换
import numpy as np
# 创建一个字符串数组
str_arr = np.array(['1.1', '2.2', '3.3', '4.4'])
print("Original array:", str_arr)
print("Original dtype:", str_arr.dtype)
# 将字符串数组转换为浮点型数组
float_arr = str_arr.astype(np.float64)
print("\nConverted array:", float_arr)
print("Converted dtype:", float_arr.dtype)
https://numpy.org/doc/
NumPy 的广播机制允许不同形状的数组进行数学运算，而无需显式地复制数据，极大地提高了计算效率