Python科学计算三大件numpy、pandas、matplotlib一起学_python numpy pandas matplotlib

前言

科学计算三大件：numpy、pandas和matplotlib，基本能搞掂一些常规的科学计算，包括数据表示，数据获取，数据操纵、数据统计和数据可视化。

还有SciPy、scikit-learn

numpy

numpy是一个强大的Python数值计算库，提供了多维数组对象和一系列数学函数，可用于进行数组操作和矩阵运算。在量化交易中，numpy常用于处理数据和进行统计分析，具有高效、简单易用的特点。

import numpy as np

# 生成一个形状为 (3, 4, 5) 的随机张量，其元素值在 [0, 1) 之间
tensor = np.random.rand(3, 4, 5)

# 计算张量的平均值
mean_value = np.mean(tensor)

print("生成的张量:")
print(tensor)
print("张量的平均值：", mean_value)
1
2
3
4
5
6
7
8
9
10
11
'
运行
运行

Pandas

pandas是一个基于NumPy的开源Python库，提供了高效的数据结构和数据分析工具，特别适用于处理结构化数据。它可以方便地进行数据清洗、数据筛选、计算指标等操作，是量化交易的重要工具之一。

• Series是一维数据，默认索引是0, 1, 2, …
• DataFrame是二维数据，当然也可以嵌套成多维。行称为索引(index)，列称为列名(columns)。

a = [1, 2, 3]
myvar = pd.Series(a)
## 也可以指定索引
a = ["Google", "Runoob", "Wiki"]
myvar = pd.Series(a, index = ["x", "y", "z"])
## 用字典初始化
sites = {1: "Google", 2: "Runoob", 3: "Wiki"}
myvar = pd.Series(sites)

data = [['Google', 10], ['Runoob', 12], ['Wiki', 13]]
# 创建DataFrame
df = pd.DataFrame(data, columns=['Site', 'Age'])
## 直接将csv转DataFrame
df = pd.read_csv('nba.csv')
print(df.to_string())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

DataFrame是什么?

DataFrame和数据库表很类似，有列名，相当于数据库字段名称，有索引，相当于行号rowId，当然你可以指定某一列或某几列作为索引。有了索引，你才方便查找某一行。可以指定多个列作为索引，索引能唯一定位某一行的数据。

DataFrame其实就是一堆对象的集合。每一行是一个对象，列是属性名称。DataFrame的操作和数据库操作很类似。

访问DataFrame的列和行的数据: loc[], at[]

下面是如何访问DataFrame的某一列的数据，和某行的数据。
通过loc和iloc函数访问某一行

# 创建一个简单的DataFrame  
df = pd.DataFrame({  
    'A': [1, 2, 3],  
    'B': [4, 5, 6],  
    'C': [7, 8, 9]  
}, index=['a', 'b', 'c'])  
  
# 访问第一列
column = df['A']  
column = df[0]
# 访问标签为'b'的行  
row_b = df.loc['b']  
print(row_b)
# 访问第2行（基于0的索引）  
row_2 = df.iloc[1]  
print(row_2)
# 找到所有列'A'的值大于1的行  
filtered_rows = df[df['A'] > 1]  
print(filtered_rows)
# 获取满足条件的第一行  
first_filtered_row = filtered_rows.iloc[0]  
print(first_filtered_row)

# 使用.at[]或.iat[]访问单个值
# 使用.at[]访问标签为'b'的行中列'A'的值  
value = df.at['b', 'A']  
print(value)  
  
# 使用.iat[]访问第2行（基于0的索引）中第1列的值  
value = df.iat[1, 0]  
print(value)
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

追加数据

## 采用append
new_row = pd.Series([5, 6], index=['A', 'B'])
df = df.append(new_row, ignore_index=True)
## 采用concat
new_row = pd.DataFrame([[5, 6]], columns=['A', 'B'])
df = pd.concat([df, new_row], ignore_index=True)
1
2
3
4
5
6
'
运行
运行

注意：采用append()方法追加数据现在并不推荐使用，因为它在某些情况下可能导致效率低下，并且在Pandas的新版本中可能会被弃用

多列索引

import pandas as pd  
  
# 创建一个简单的DataFrame  
df = pd.DataFrame({  
    'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'],  
    'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'],  
    'C': ['small', 'large', 'large', 'small', 'small', 'large', 'large', 'small'],  
    'D': [1, 2, 2, 3, 3, 4, 5, 6],  
    'E': [2, 4, 5, 5, 6, 6, 8, 9]  
})  
  
# 设置多列索引  
df_multiindex = df.set_index(['A', 'B'])  
  
# 打印设置多列索引后的DataFrame  
print("DataFrame with multi-index:")  
print(df_multiindex)  
  
# 使用多列索引访问某一行  
# 假设我们要访问 'A' 为 'foo' 且 'B' 为 'one' 的行  
row = df_multiindex.loc[('foo', 'one')]  
print("\nRow with index ('foo', 'one'):")  
print(row)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

可以发现，和数据库的索引相比，DataFrame的按索引查找更直观和显式。
上面的输出为:

DataFrame with multi-index:  
             C  D  E  
A   B                 
foo one    small  1  2  
    two    large  2  5  
    three  small  6  9  
bar one    large  2  4  
    three  small  3  5  
    two    large  4  6  
    two    large  5  8  
foo one    large  5  8  
  
Row with index ('foo', 'one'):  
C        small  
D           1  
E           2  
Name: (foo, one), dtype: object
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

我们在pycharm中运行时，使用view as DataFrame能方便地查看DataFrame的结构。

遍历DataFrame

遍历行

使用 iterrows() 遍历每一行

import pandas as pd

# 假设df是你的DataFrame
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})

for index, row in df.iterrows():
    print(f"Index: {index}, Data: {row}")
1
2
3
4
5
6
7

也可以使用 itertuples() 遍历每一行

for row in df.itertuples():
    print(f"Index: {row.Index}, A: {row.A}, B: {row.B}")
1
2

遍历列

for col_name in df.columns:
    print(f"Column Name: {col_name}, Data: {df[col_name]}")
for col_name in df.columns:
    print(f"Column Name: {col_name}, Data: {df[col_name]}")
1
2
3
4

使用 apply() 函数处理每一行或列

# 对每一行应用函数
df.apply(lambda row: print(row), axis=1)  # axis=1 表示按行操作

# 或者，对每一列应用函数
df.apply(lambda col: print(col))        
1
2
3
4
5
'
运行
运行

DataFrame嵌套

你可能需要将一个 DataFrame 作为另一个 DataFrame 的一个列的值。这可以通过几种方式实现，例如使用字典创建 DataFrame，或者使用 apply 方法将一个 DataFrame 嵌套到另一个 DataFrame 中。

import pandas as pd

# 假设我们有两个字典，每个字典代表一个 DataFrame
data1 = {'Column1': [1, 2, 3], 'Column2': ['A', 'B', 'C']}
data2 = {'Column1': [4, 5, 6], 'Column2': ['D', 'E', 'F']}

# 将这些字典转换为 DataFrame
df1 = pd.DataFrame(data1)
df2 = pd.DataFrame(data2)

# 创建一个新 DataFrame，其中包含对这两个 DataFrame 的引用
nested_data = {'DataFrame1': [df1, df2]}
nested_df = pd.DataFrame(nested_data)

# 打印结果
print(nested_df)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

或者使用apply方法：

import pandas as pd

# 创建一个示例 DataFrame
data = {'Column1': [1, 2, 3], 'Column2': ['A', 'B', 'C']}
df = pd.DataFrame(data)

# 定义一个函数，它接受一个行索引和 DataFrame 并返回一个嵌套的 DataFrame
def nest_function(row, df):
    return df.iloc[row:name]

# 使用 apply 方法将函数应用于 DataFrame 的每一行
nested_df = df.apply(lambda row: nest_function(row, df), axis=1)

# 打印结果
print(nested_df)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

DataFrame转换

要将不符合要求的pandas DataFrame数据转换为符合要求的格式，你通常需要执行一些数据清洗和转换操作。这些操作可能包括删除不需要的列、填充缺失值、转换数据类型、重命名列、筛选数据等。以下是一些常见的步骤和示例，帮助你实现这一转换过程：

# 删除不需要的列：
## 使用drop方法删除DataFrame中不需要的列。
df = df.drop(['不需要的列名'], axis=1)

# 填充缺失值：
## 使用fillna方法填充DataFrame中的缺失值。

df = df.fillna(0)  # 使用0填充所有缺失值  
df = df.fillna(method='ffill')  # 使用前一个有效值填充  
df = df.fillna(method='bfill')  # 使用后一个有效值填充

# 转换数据类型：
## 使用astype方法将DataFrame中的列转换为所需的数据类型。

df['列名'] = df['列名'].astype(int)  # 转换为整数类型  
df['列名'] = df['列名'].astype(float)  # 转换为浮点数类型  
df['列名'] = df['列名'].astype(str)  # 转换为字符串类型
# 重命名列：
## 使用rename方法重命名DataFrame中的列。

df = df.rename(columns={'旧列名': '新列名'})
# 筛选数据：
## 使用布尔索引或query方法筛选DataFrame中的数据。

# 使用布尔索引筛选数据  
df = df[df['列名'] > 10]  # 选择'列名'列大于10的行  
  
# 使用query方法筛选数据  
df = df.query('列名 > 10')  # 选择'列名'列大于10的行
# 应用自定义函数：
## 使用apply方法应用自定义函数到DataFrame的列或行。

def custom_function(x):  
    # 自定义函数逻辑  
    return x * 2  
  
df['新列名'] = df['列名'].apply(custom_function)  # 应用函数到列

# 排序数据：
## 使用sort_values方法对DataFrame进行排序。
df = df.sort_values(by='列名')  # 根据'列名'列的值排序

# 重置索引：
## 如果在进行数据清洗和转换后索引变得混乱，可以使用reset_index方法重置索引。
df = df.reset_index(drop=True)  # 重置索引，drop=True表示不保留原索引作为新列
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

这些步骤可以根据你的具体需求进行组合和调整。在转换数据之前，建议先备份原始数据，以防万一转换过程中发生错误导致数据丢失。同时，在每一步转换后，都建议检查DataFrame的内容，确保它符合你的预期

累计

累加cumsum和累乘cumprod主要是用来看数据的变化趋势.
累加是通过流量得到存量，比如每天销售量的多少，得到今年的销售量总量;
累乘是通过变化率来得到存量，比如有每天的数据变动趋势，通过累乘来得到当前的数据;

累加的用法:
通过df.cumsum() 来求df的累计次数;

刷选：loc()、icol()、ix()

用来筛选数据。

• loc(): 左边参数按行的整数值索引，右边按列名
• icol(): 左右都按整数值索引
• ix(): 左边按名称，右边按整数
  现在基本上用iloc和loc已经完全能取代ix，所以ix已经被官方弃用了。

示例：生成以时间戳为索引的DataFrame

import pandas as pd
import numpy as np

# 创建时间索引
date_index = pd.date_range(start='2024-01-01', end='2024-01-10')

# 创建数据
np.random.seed(0)
data = np.random.rand(len(date_index))

# 构建 DataFrame
df = pd.DataFrame(data, index=date_index, columns=['Value'])

# 显示 DataFrame
print(df)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

statsmodels

statsmodels是一个基于Python的统计模型库，可用于进行统计分析和建模。它提供了各种常见的统计模型和方法，如回归分析、时间序列分析、假设检验等，可用于量化交易的策略开发和效果评估。

可视化

Matplotlib

基本绘图库，折线、柱状图、饼状图等。

Seaborn

Seaborn 是一个基于 Matplotlib 的数据可视化库，专注于统计图形的绘制，旨在简化数据可视化的过程。

pyecharts

Echarts 是一个由百度开源的数据可视化，凭借着良好的交互性，精巧的图表设计，得到了众多开发者的认可。而 Python 是一门富有表达力的语言，很适合用于数据处理。当数据分析遇上数据可视化时，pyecharts 诞生了。

pyfolio

pyfolio是由Quantopian开发的Python库，用于对金融投资组合进行绩效和风险分析。 它与Zipline开源回溯测试库配合使用良好。 pyfolio的核心是所谓的“tear sheet ”，它由各种单独的图组成，这些图提供了交易算法性能的全面图像展示

例子

K线图

    import matplotlib.pyplot as plt
    from mpl_finance import candlestick_ohlc

    # 创建一个子图
    fig, ax = plt.subplots()

    # 准备K线数据
    data = [
        (1, 2, 3, 4),  # (开盘价, 最高价, 最低价, 收盘价)
        (2, 3, 4, 5),
        (3, 4, 5, 6),
        # ...
    ]

    # 将K线数据转换为OHLC格式
    ohlc_data = [(i + 1, *d) for i, d in enumerate(data)]

    # 绘制K线图
    candlestick_ohlc(ax, ohlc_data)

    # 设置x轴标签为日期
    ax.set_xticks(range(1, len(data) + 1))
    ax.set_xticklabels(['2021-01-01', '2021-01-02', '2021-01-03', ...])

    # 设置图表标题和轴标签
    ax.set_title('K线图')
    ax.set_xlabel('日期')
    ax.set_ylabel('价格')

    # 显示图表
    plt.show()
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

显示词云

	from wordcloud import WordCloud
    import matplotlib.pyplot as plt

    # 假设我们有一些文本数据
    text = 'Python is a great programming language. Python can be used for data analysis, web development, automation, and more.'

    # 创建一个词云对象
    wordcloud = WordCloud(width=800, height=400, background_color='white').generate(text)

    # 显示词云
    plt.figure(figsize=(10, 5))
    plt.imshow(wordcloud, interpolation='bilinear')
    plt.axis('off')  # 关闭坐标轴
    plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14

SciPy

Scipy 是一个用于数学、科学、工程领域的常用软件包，可以处理最优化、线性代数、积分、插值、拟合、特殊函数、快速傅里叶变换、信号处理、图像处理、常微分方程求解器等。

SciPy 包含的模块有最优化、线性代数、积分、插值、特殊函数、快速傅里叶变换、信号处理和图像处理、常微分方程求解和其他科学与工程中常用的计算。

scikit-learn

scikit-learn是一个流行的Python机器学习库，它提供了丰富的机器学习算法和工具，可用于模型训练、特征选择、交叉验证等任务。在量化交易中，scikit-learn常用于建立和优化机器学习模型，以提高交易策略的预测能力。

相关链接

• NumPy 官网 http://www.numpy.org/
• NumPy 源代码：https://github.com/numpy/numpy
• SciPy 官网：https://www.scipy.org/
• SciPy 源代码：https://github.com/scipy/scipy
• Matplotlib 官网：https://matplotlib.org/
• Matplotlib 源代码：https://github.com/matplotlib/matplotlib
• pyecharts
• https://github.com/datawhalechina/joyful-pandas
• awesome-pandas