Numpy

array的简单创建

import numpy as np

arr1 = np.array([[1, 2, 3], [1, 2, 3]]) # list转为array
print(arr1)
print(arr1.shape)  # (2, 3) #元组
"""输出：
[[1 2 3]
 [1 2 3]]
注意：下面的写法会报错，不能直接在代码中通过赋值的方式创建一个array变量
a = [[1 2 3]
 [1 2 3]] """
arr2 = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
print(arr2.shape)  # (12,)
print(arr2.reshape(3, 4))
"""输出：
[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]"""
print(arr2.reshape(2, 2, 3))
"""输出：
[[[ 1  2  3]
  [ 4  5  6]]

 [[ 7  8  9]
  [10 11 12]]]
中间空一行，这只是为了让代码更易读，并不会影响数组的定义或内容。"""

arr3 = np.arange(10)
print(arr3)  # 输出[0 1 2 3 4 5 6 7 8 9]
print(arr3.shape)  # 输出 (10,)

arr4 = np.arange(0, 10, 2.5)  # (0, 10, 2.5)分别是开始、截止、步长，[0. 2.5 5. 7.5]
# 在一个区间内返回等间距数组
arr5 = np.linspace(1, 102, 5)  # [1. 26. 51. 7. 101.]
arr6 = np.linspace(1, 102, 5, endpoint=False)  # [1. 21. 41. 61. 81.]
arr7 = np.logspace(0, 2, 5)  # 10^0 = 1, 10^2 = 100

矩阵创建、矩阵维度

import numpy as np

arr1 = np.zeros((2, 2))
arr2 = np.ones((2, 2))
arr3 = np.identity(3)  # 3阶单位矩阵
arr3_u = np.triu(arr3)  # 上三角矩阵
arr3_l = np.tril(arr3)  # 下三角矩阵
arr3_l2 = np.tril(arr3, k=-1)  # 下三角矩阵，对角线下移1
arr4 = np.eye(3, 5)  # 3阶单位矩阵+append两列零向量
arr5 = np.full((2, 2), 5)
arr6 = np.full((2, 4), [1, 2, 3, 4])  # [1,2,3,4]四个元素与(2, 4)中的4对应
arr7 = np.array([[1, 2, 3], [4, 5, 6]])
arr_like = np.ones_like(arr7)  # 生成一个与数组a形状和数据类型相同的数组，所有元素为1
arr8 = np.array([[[1,2,3]]]) # [[[1 2 3]]，shape是(1, 1, 3)
arr9 = arr8.squeeze() # [1 2 3]，squeeze()方法去掉冗余维度
# .reshape(1,-1)中的1表示表示新数组的第一个维度的大小为1，
# -1：表示新数组的第二个维度的大小由数组的总大小和第一个维度的大小自动计算。
# 具体来说，.reshape(1, -1) 将数组调整为一个行向量（即只有一行的二维数组），其中列数由原数组的大小决定。
# np.swapaxes函数用于交换数组的两个轴(下面是交换轴0和轴1)，
# np.swapaxes需要至少是二维的数组才能交换轴。
print(np.swapaxes(arr9.reshape(1,-1), 0, 1))
"""输出：
[[1]
 [2]
 [3]]
"""
arr10 = np.array([1,2,3,5,6,7])
print(arr10.reshape(2,-1))
print(arr10.flatten()) # [1 2 3 5 6 7]，flatten()方法将一个多维数组展平成一维数组
arr11 = np.array([[1,2,3],[5,6,7]])
print(np.transpose(arr11)) # 转置
print(arr11.transpose()) # 转置，arr10.transpose()等价于arr10.T
"""输出：
[[1 5]
 [2 6]
 [3 7]]
"""

# 1*2*3三维矩阵的转置
mat = np.zeros((1,2,3))
print(mat.shape)
print(mat)
""" 输出：
(1, 2, 3)
[[[0. 0. 0.]
  [0. 0. 0.]]]
"""
mat = mat.transpose(1,0,2)
print(mat.shape)
print(mat)
""" 输出：
(2, 1, 3)
[[[0. 0. 0.]]
"""
mat = mat.transpose()
print(mat.shape)
""" 输出：
 [[0. 0. 0.]]]
(3, 1, 2)
"""

注意：np.transpose(arr)和arr.transpose()在功能上是等价的，都会对数组进行转置操作。

• np.transpose(arr)：这是一个函数调用，需要将数组作为参数传递。
• arr.transpose()：这是一个方法调用，直接在数组对象上调用。

矩阵的拼接

import numpy as np

# 矩阵的拼接
a = np.array((1, 2, 3))   # [1 2 3]
b = np.array((4, 5, 6))  # [4 5 6]

a = a.reshape(1,-1)  # [[1 2 3]]
b = b.reshape(1,-1)  # [[4 5 6]]

print(a.shape, b.shape)  # 输出(1, 3) (1, 3)
print(np.hstack((a, b)))  # 输出[[1 2 3 4 5 6]]
print(np.vstack((a, b))) # 也可以np.vstack((a, b, b))
"""输出：vstack
[[1 2 3]
 [4 5 6]]
"""
print(np.concatenate((a,b,b),axis=0)) # 沿着0轴（行方向）将数组 a、b 和 b 依次拼接在一起。
print(np.concatenate((a,b,b),axis=1))  # 沿着1轴（列方向）
"""输出：
[[1 2 3]
 [4 5 6]
 [4 5 6]]
[[1 2 3 4 5 6 4 5 6]]
"""

数组的选取

import numpy as np

mat =np.arange(9).reshape(3,3)
print(mat)
"""输出
[[0 1 2]
 [3 4 5]
 [6 7 8]]
"""
#选择左上角的2*2矩阵
print(mat[:2,:2])  # 等价于mat[0:2,0:2]
"""输出
[[0 1]
 [3 4]]
"""
#选择第一列
print(mat[:,0]) # 输出 [0 3 6]
print(mat[:,0].shape) # 输出(3,)
#选择第一列和第三列的所有内容
print(mat[:,[0,2]])
"""输出
[[0 2]
 [3 5]
 [6 8]]
"""
# 选择对角线的内容
print(np.diag(mat)) # [0 4 8]，shape是(3,)
# 选择地二行第三列的内容(元素)
print(mat[1,2])  # 输出5
print(mat[1][2])  # 输出5
#选取第一行第一列；第三行第三列
print(mat[[0,2],[0,2]])  #输出[0 8]
print(mat[[0,2], :][:, [0,2]])
"""输出
[[0 2]
 [6 8]]
"""
# np.where用法1—替换值：只保留所有大于4的值，其他的值替换为0
print(np.where(mat>4, mat,0))

# np.where用法2—返回索引：返回所有大于4的值的索引
inds_gt4 = np.where(mat>4)
print(inds_gt4) # 输出索引tuple，(array([1, 2, 2, 2], dtype=int64), array([2, 0, 1, 2], dtype=int64))
print(mat[inds_gt4]) # 输出[5 6 7 8]
print(mat[mat>4]) # 输出[5 6 7 8]
"""
mat > 4：这是一个布尔条件，用于生成一个与mat形状相同的布尔数组。每个元素根据是否满足条件> 4来决定是True还是False。
  [[False, False, False],
   [False, False,  True],
   [ True,  True,  True]]
mat[mat > 4]：使用布尔索引来选择满足条件的元素。布尔索引会返回一个一维数组，包含所有满足条件的元素。
"""

inds_gt4 = np.argwhere(mat>4)
print(inds_gt4)
"""输出索引的list
[[1 2]
 [2 0]
 [2 1]
 [2 2]]
"""

numpy中的常量

import numpy as np
# numpy中常用的常量
print(np.nan)  #空值
print(np.inf)  # 无限
print(np.e)   # e常数
print(np.newaxis)  # 空数轴

x =np.arange(3)
x1 = x[np.newaxis, np.newaxis,:]  # [[[0 1 2]]], shape变为(1,1,3)
# 等价写法
x2 = x.reshape(1,1,-1)  # [[[0 1 2]]], shape变为(1,1,3)
""""
np.newaxis：用于在数组中插入新的轴。 
x1[np.newaxis, np.newaxis, :]：在数组的最前面插入两个新的轴，将一维数组变为三维数组。 
这种方法在需要增加数组的维度以便进行广播或其他操作时非常有用。
"""

单个数组的运算

import numpy as np

# numpy的按位函数运算
mat = np.arange(4).reshape(2,2)
print(mat + 1)  #等 价于np.add(mat, 1)
print(mat - 1)
print(mat * 2) #等价于np.multipl(mat, 2)
print(mat / 2)
print(np.exp(mat))
print(np.sin(mat))
print(np.power(mat,2))

print(np.sum(mat, axis = 0)) # [2 4]， 是沿着0轴（行方向）计算每一列的和
print(np.sum(mat, axis =1))  # [1 5]， 是沿着1轴（列方向）计算每一行的和
print(np.sum(mat)) # 6, 所有的和

mat = np.arange(4).reshape(2,2)
print(np.cumsum(mat, axis =0))  # 计算数组元素的累积和(沿着0轴行方向)
print(np.cumsum(mat)) # 计算累加和，返回一维数组，元素的个数等于mat的元素个数
""" 输出
[[0 1]
 [2 4]]
[0 1 3 6]
"""

数组(向量)之间的运算

import numpy as np

# 数组(向量)之间的运算：按照位置相乘、向量内积、向量外积
vec1 = np.array([1,3])
vec2 = np.array([2,5])
print(vec1*vec2)  # 输出[2 15]，按位置相乘
print(np.dot(vec1,vec2)) # 输出17，矩阵内积
print(vec1 @ vec2)  # 输出17，矩阵内积
print(np.matmul(vec1, vec2)) # 输出17，矩阵内积
print(np.outer(vec1, vec2))  # 矩阵的外积
""" 外积
[[ 2  5]
 [ 6 15]]
"""
# reshape精确定义向量
print(np.matmul(vec1.reshape(1,-1), vec2.reshape(1,-1))) # 输出17，矩阵内积
print(vec1.reshape(1,-1) @ vec2.reshape(1,-1))  # 输出17，矩阵内积

矩阵运算的广播机制(不一定是下面例子的乘法，其他运算也可以)

import numpy as np

# broadcasting: 广播机制
arr1 = np.array([[1,2],[3,4]])
vec1 = np.array([0,2]).reshape(-1,1)
# -1：表示这一维的大小由数组的总大小和其他维度的大小自动计算。
# 1：表示新数组的第二个维度的大小为1。
vec2 = np.array([0,2]).reshape(1,-1)
print(arr1*vec1)
print(arr1*vec2)
""" 
NumPy 支持广播机制，可以在不同形状的数组之间进行元素级别的操作。 
arr1 的形状是 (2, 2)，vec1 的形状是 (2, 1)。 
广播机制会将 vec1 扩展为与 arr1 形状相同的数组，然后进行元素级别的乘法。
vec1如下：
  [[0],
   [2]]
广播机制会将 vec1 扩展为：
  [[0, 0],
   [2, 2]]
元素级别的乘法arr1*vec1得到：
[[0 0]
 [6 8]]
类似地，arr1*vec2得到：
 [[0 4]
 [0 8]]
注：NumPy的广播机制只能扩展维度为1的地方，所以2*2矩阵与4*4矩阵相乘，广播机制不起作用。
"""

numpy的数值类型

import numpy as np

# numpy的数值形式：自动推导
mat = np.arange(4).reshape(2,2)
print(mat.dtype)   # 输出 int32
mat = mat -1.1
print(mat.dtype)  # 输出 float64
mat = mat + (1+1j)
print(mat.dtype)  # 输出 complex128

# numpy的数值形式：强制转换
mat = np.arange(4).reshape(2,2)
mat = mat.astype(np.float64)
print(mat)
""" 输出
[[0. 1.]
 [2. 3.]]
"""
mat = mat.astype(np.int32)
print(mat)
mat = mat.astype(np.bool_)
print(mat)
""" 输出
[[0 1]
 [2 3]]
[[False  True]
 [ True  True]]
"""

Pandas

表格的创建

import pandas as pd

# 将lsit转为表格，并添加header
age = [28, 25, 27, 29]
df = pd.DataFrame(age, columns=['age']) #如果不指定header，那么header默认为0
print(df)
""" 输出
   age
0   28
1   25
2   27
3   29
"""

# 创建表格
workout_dict = {
    "calories": [420, 380, 390, 390],
    "duration": [50, 40, 45, 45],
    "type": ["run", "walk", "walk", "run"]
}
workout = pd.DataFrame(workout_dict)
print(workout)
""" 输出
   calories  duration  type
0       420        50   run
1       380        40  walk
2       390        45  walk
3       390        45   run
"""
# 单独指定索引
workout_a = pd.DataFrame(workout_dict,index=["day1", "day2", "day3", "day4"])
print(workout_a)
""" 输出
      calories  duration  type
day1       420        50   run
day2       380        40  walk
day3       390        45  walk
day4       390        45   run
"""

行索引、列索引、直接重新赋值行索引/列索引、转换回dict字典

import pandas as pd

workout_dict = {
    "calories": [420, 380, 390, 390],
    "duration": [50, 40, 45, 45],
    "type": ["run", "walk", "walk", "run"]
}
workout = pd.DataFrame(workout_dict)

# 列索引、行索引
print(workout["duration"]) # type是
""" 输出
0    50
1    40
2    45
3    45
Name: duration, dtype: int64
"""
print(workout["duration"][1]) # 输出 50
print(workout[["duration"]]) 
# 输出的是表格形式，type是<class 'pandas.core.frame.DataFrame'>
""" 输出
   duration
0        50
1        40
2        45
3        45
"""
print(workout.columns)  
# 输出 Index(['calories', 'duration', 'type'], dtype='object')
print(workout.columns[1])  # 输出 duration
print(workout.columns.tolist())  
# 输出['calories', 'duration', 'type']

print(workout.index)  # 输出 RangeIndex(start=0, stop=4, step=1)
print(workout.index[2])  # 输出 2
print(workout.index.tolist())  # 输出[0, 1, 2, 3]

# 直接重新赋值行索引
workout.index = ["day1", "day2", "day3", "day4"]
print(workout)
""" 输出
      calories  duration  type
day1       420        50   run
day2       380        40  walk
day3       390        45  walk
day4       390        45   run
"""
# 直接重新赋值列名/列索引
workout.columns = ["Calories", "Duration", "Type"]
workout = workout.rename(columns={"Calories": "calories"})
print(workout)
""" 输出
      calories  Duration  Type
day1       420        50   run
day2       380        40  walk
day3       390        45  walk
day4       390        45   run
"""

# 转换回dict字典
workout_dict = workout.to_dict()
print(workout_dict)
""" 输出
{
'calories': {'day1': 420, 'day2': 380, 'day3': 390, 'day4': 390},
'Duration': {'day1': 50, 'day2': 40, 'day3': 45, 'day4': 45},
'Type': {'day1': 'run', 'day2': 'walk', 'day3': 'walk', 'day4': 'run'}
}
"""