第05章 Pandas 入门

 

 

序言

1. 内容介绍

本章详细介绍了Pandas 安装及基本数据结构、Pandas 文件读写、Pandas 数据处理与可视化操作等内容。

2. 理论目标

• 了解Pandas 安装及基本数据结构
• 了解Pandas 文件读写
• 了解Pandas 数据处理与可视化操作

3. 实践目标

• 掌握Pandas 文件读写方法，能完成文档读取和写入
• 掌握Pandas 数据处理与可视化操作，能完成基本数据统计分析与可视化

4. 实践案例

无

5. 内容目录

• 1.Pandas 概述与安装

• 2.Pandas 数据结构

• 3.Pandas 文件操作

• 4.Pandas 数据处理与可视化

---

第1节 Pandas 概述与安装

1. Pandas 概述

Pandas 是一个开放源码的Python 库，为Python 编程语言提供了高性能，易于使用的数据结构和数据分析工具。
在Pandas 之前，Python 主要用于数据迁移和准备，对数据分析的贡献更小。

官网 https://pandas.pydata.org/

 

Pandas 是从Panel Data（面板数据）缩写而来，用于广泛的领域，包括金融，经济，统计，分析等学术和商业领域。

数据分析步骤

1. 加载
2. 准备
3. 操作
4. 模型
5. 分析

Pandas特点

1. 快速高效的DataFrame 对象，具有默认和自定义的索引；
2. 将数据从不同文件格式加载到内存中的数据对象的工具；
3. 丢失数据的数据对齐和综合处理；
4. 重组和摆动日期集；
5. 基于标签的切片，索引和大数据集的子集；
6. 可以删除或插入来自数据结构的列；
7. 按数据分组进行聚合和转换；
8. 高性能合并和数据加入；
9. 时间序列功能。

2. Pandas 安装

安装语法：pip install pandas -i https://pypi.tuna.tsinghua.edu.cn/simple/

---

第2节 Pandas 数据结构

1. 数据结构概述

Pandas 提供两种常用的数据结构：

1. 系列(Series)
2. 数据帧(DataFrame)

这些数据结构构建在Numpy数组之上，这意味着它们很快。

2. 维数和描述

较高维数据结构是其较低维数据结构的容器，DataFrame是Series的容器。

数据结构	维数	描述
系列	1	1D标记均匀数组，大小不变。
数据帧	2	一般2D标记，大小可变的表结构与潜在的异质类型的列。

注： DataFrame被广泛使用，是最重要的数据结构之一。

3. 系列创建与操作

系列(Series)是能够保存任何类型的数据(整数，字符串，浮点数，Python对象等)的一维标记数组，轴标签统称为索引。特征：

1. 均匀数据
2. 尺寸大小不变
3. 数据的值可变

系列创建语法

• pandas.Series( data, index, dtype, copy)
• 参数说明：

• data，数据采取各种形式，如ndarray，list，constants
• index，索引值必须是唯一的和散列的，与数据的长度相同，默认np.arange(n)如果没有索引被传递
• dtype，用于数据类型。如果没有，将推断数据类型
• copy，复制数据，默认为false

创建一个空的系列

import pandas as pd s = pd.Series(dtype = 'float64') ##必须指定类型，否则警告 print(s)

Series([], dtype: float64)

从ndarray创建一个系列

如果数据是ndarray，则传递的索引必须具有相同的长度。

如果没有传递索引值，那么默认的索引将是范围(n)，其中n是数组长度，即[0,1,2,3…. range(len(array))-1]

import pandas as pd import numpy as np data = np.array(['a','b','c','d']) ##默认索引 s = pd.Series(data) print(s)

0    a
1    b
2    c
3    d
dtype: object

import pandas as pd import numpy as np data = np.array(['a','b','c','d']) s = pd.Series(data,index=[100,101,102,103]) ##指定索引 print(s)

100    a
101    b
102    c
103    d
dtype: object

从字典创建一个系列

字典(dict)可以作为输入传递，如果没有指定索引，则按排序顺序取得字典键以构造索引。 如果传递了索引，索引中与标签对应的数据中的值将被拉出。

import pandas as pd import numpy as np data = {'a' : 0., 'b' : 1., 'c' : 2.} s = pd.Series(data) ##默认取字典键作为索引 print(s)

a    0.0
b    1.0
c    2.0
dtype: float64

import pandas as pd import numpy as np data = {'a' : 0., 'b' : 1., 'c' : 2.} s = pd.Series(data,index=['b','c','d','a']) ##指定索引，按指定索引顺序罗列，缺少的元素使用NaN(不是数字)填充 print(s)

b    1.0
c    2.0
d    NaN
a    0.0
dtype: float64

从标量创建一个系列

import pandas as pd import numpy as np s = pd.Series(5) ##默认生成只有一个元素的系列 print(s)

0    5
dtype: int64

import pandas as pd import numpy as np s = pd.Series(5, index=[0, 1, 2, 3]) ##指定索引，标量按索引数量重复 print(s)

0    1
1    1
2    1
3    1
dtype: object

访问系列元素

import pandas as pd s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e']) print(s[0]) ## 索引访问 print(s[0:3]) ## 切片访问 print(s[-3:]) ## 切片访问 print(s['c']) ## 单标签访问 print(s[['a', 'b', 'c']]) ## 多标签访问

1
a    1
b    2
c    3
dtype: int64
c    3
d    4
e    5
dtype: int64
c    3
d    4
e    5
dtype: int64
3
a    1
b    2
c    3
dtype: int64

系列基本功能

编号	属性或方法	描述
1	axes	返回行轴标签列表。
2	dtype	返回对象的数据类型(dtype)。
3	empty	如果系列为空，则返回True。
4	ndim	返回底层数据的维数，默认定义：1。
5	size	返回基础数据中的元素数。
6	values	将系列作为ndarray返回。
7	head()	返回前n行。
8	tail()	返回最后n行。

import pandas as pd import numpy as np s = pd.Series(np.random.randn(4)) print(s.axes) ## axes - 返回行轴标签列表 print(s.dtype) ## dtype - 返回对象的数据类型(dtype) print(s.empty) ## empty - 如果系列为空，则返回True print(s.ndim) ## ndim - 返回底层数据的维数，默认定义：1 print(s.size) ## size - 返回基础数据中的元素数 print(s.values) ## values - 将系列作为ndarray返回 print(s.head(1)) ## head() - 返回前1行 print(s.tail(1)) ## tail() - 返回最后1行

[RangeIndex(start=0, stop=4, step=1)]
float64
False
1
4
[-1.56243449  0.55073091 -0.2908994  -0.7800016 ]
0   -1.562434
dtype: float64
3   -0.780002
dtype: float64

3. 数据帧创建与操作

数据帧(DataFrame)是一个具有异构数据的二维数组，即数据以行和列的表格方式排列。特征：

1. 异构数据
2. 大小可变
3. 数据可变

pandas中的DataFrame可以使用以下构造函数创建

• pandas.DataFrame( data, index, columns, dtype, copy)
• 参数说明：

• data：数据采取各种形式，如:ndarray，series，map，lists，dict，constant和另一个DataFrame。
• index：对于行标签，要用于结果帧的索引是可选缺省值np.arrange(n)，如果没有传递索引值。
• columns：对于列标签，可选的默认语法是 - np.arange(n)。 这只有在没有索引传递的情况下才是这样。
• dtype：每列的数据类型。
• copy：如果默认值为False，则此命令(或任何它)用于复制数据。

创建空数据帧

import pandas as pd df = pd.DataFrame() ##未指定列名 print(df)

Empty DataFrame
Columns: []
Index: []

import pandas as pd df = pd.DataFrame(columns = ['c1', 'c2', 'c3', 'c4', 'c5']) ##指定列名 print(df)

Empty DataFrame
Columns: [c1, c2, c3, c4, c5]
Index: []

从列表创建数据帧

import pandas as pd data = [1,2,3,4,5] df = pd.DataFrame(data) ##单列表 print(df)

   0
0  1
1  2
2  3
3  4
4  5

import pandas as pd data = [['Alex',10],['Bob',12],['Clarke',13]] df = pd.DataFrame(data,columns=['Name','Age']) ##嵌套列表 print(df)

     Name  Age
0    Alex   10
1     Bob   12
2  Clarke   13

import pandas as pd data = [['Alex',10],['Bob',12],['Clarke',13]] df = pd.DataFrame(data,columns=['Name','Age'], dtype='float') ##嵌套列表，指定数据类型 print(df)

     Name   Age
0    Alex  10.0
1     Bob  12.0
2  Clarke  13.0

从字典列表创建数据帧

import pandas as pd data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}] df = pd.DataFrame(data) ##默认索引 print(df)

   a   b     c
0  1   2   NaN
1  5  10  20.0

import pandas as pd data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}] df = pd.DataFrame(data, index=['first', 'second']) ## 指定索引 print(df)

        a   b     c
first   1   2   NaN
second  5  10  20.0

import pandas as pd data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}] df1 = pd.DataFrame(data, index=['first', 'second'], columns=['a', 'b']) ## df1是使用列索引创建的，与字典键相同 print(df1)

        a   b
first   1   2
second  5  10

import pandas as pd data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}] df2 = pd.DataFrame(data, index=['first', 'second'], columns=['a', 'b1']) ## df2使用字典键以外的列索引创建,因此置为NaN print(df2)

        a  b1
first   1 NaN
second  5 NaN

从数组/列表的字典创建数据帧

import pandas as pd data = {'Name':['Tom', 'Jack', 'Steve', 'Ricky'],'Age':[28,34,29,42]} df = pd.DataFrame(data) ##默认索引 print(df)

    Name  Age
0    Tom   28
1   Jack   34
2  Steve   29
3  Ricky   42

import pandas as pd data = {'Name':['Tom', 'Jack', 'Steve', 'Ricky'],'Age':[28,34,29,42]} df = pd.DataFrame(data, index=['rank1','rank2','rank3','rank4']) ##指定索引 print(df)

        Name  Age
rank1    Tom   28
rank2   Jack   34
rank3  Steve   29
rank4  Ricky   42

从系列的字典来创建数据帧

import pandas as pd d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']), 'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])} df = pd.DataFrame(d) print(df)

   one  two
a  1.0    1
b  2.0    2
c  3.0    3
d  NaN    4

列操作-选择

import pandas as pd d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']), 'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])} df = pd.DataFrame(d) print(df ['one']) ## 单列选择 print(df[['one', 'two']]) ## 多列选择

a    1.0
b    2.0
c    3.0
d    NaN
Name: one, dtype: float64

列操作-添加

import pandas as pd d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']), 'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])} df = pd.DataFrame(d) df['three']=pd.Series([10,20,30],index=['a','b','c']) print(df)

   one  two  three
a  1.0    1   10.0
b  2.0    2   20.0
c  3.0    3   30.0
d  NaN    4    NaN

列操作-删除

import pandas as pd d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']), 'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd']), 'three' : pd.Series([10,20,30], index=['a','b','c'])} del df['one'] print(df)

   two  three
a    1   10.0
b    2   20.0
c    3   30.0
d    4    NaN

行操作-索引选择

import pandas as pd d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']), 'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])} df = pd.DataFrame(d) print(df.loc['b']) ##行索引标签选择

one    2.0
two    2.0
Name: b, dtype: float64

import pandas as pd d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']), 'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])} df = pd.DataFrame(d) print(df.iloc[2]) ##行索引整数位置选择

one    3.0
two    3.0
Name: c, dtype: float64

行操作-添加

import pandas as pd df = pd.DataFrame([[1, 2], [3, 4]], columns = ['a','b']) df2 = pd.DataFrame([[5, 6], [7, 8]], columns = ['a','b']) df = df.append(df2) print("注意以下索引是否重复：\n", df)

注意以下索引是否重复：
    a  b
0  1  2
1  3  4
0  5  6
1  7  8

行操作-删除

import pandas as pd df = pd.DataFrame([[1, 2], [3, 4]], columns = ['a','b']) df = df.drop(0) print(df)

   a  b
1  3  4

DataFrame基本功能

编号	属性或方法	描述
1	T	转置行和列。
2	axes	返回一个列，行轴标签和列轴标签作为唯一的成员。
3	dtypes	返回此对象中的数据类型(dtypes)。
4	empty	如果NDFrame完全为空[无项目]，则返回为True; 如果任何轴的长度为0。
5	ndim	轴/数组维度大小。
6	shape	返回表示DataFrame的维度的元组。
7	size	NDFrame中的元素数。
8	values	NDFrame的Numpy表示。
9	head(n)	返回开头前n行。
10	tail(n)	返回最后n行。

import pandas as pd import numpy as np d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Minsu','Jack']), 'Age':pd.Series([25,26,25,23,30,29,23]), 'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])} df = pd.DataFrame(d) print(df.T) ## T - 转置行和列 print(df.axes) ## axes - 返回一个列，行轴标签和列轴标签作为唯一的成员 print(df.dtypes) ## dtypes - 返回此对象中的数据类型(dtypes) print(df.empty) ## empty - 如果NDFrame完全为空[无项目]，则返回为True; 如果任何轴的长度为0 print(df.ndim) ## ndim - 轴/数组维度大小 print(df.shape) ## shape - 返回表示DataFrame的维度的元组 print(df.size) ## size - NDFrame中的元素数 print(df.values) ## values - NDFrame的Numpy表示 print(df.head(5)) ## head() - 返回开头前n行 print(df.tail(5)) ## tail() - 返回最后n行

           0      1      2     3      4      5     6
Name     Tom  James  Ricky   Vin  Steve  Minsu  Jack
Age       25     26     25    23     30     29    23
Rating  4.23   3.24   3.98  2.56    3.2    4.6   3.8
[RangeIndex(start=0, stop=7, step=1), Index(['Name', 'Age', 'Rating'], dtype='object')]
Name       object
Age         int64
Rating    float64
dtype: object
False
2
(7, 3)
21
[['Tom' 25 4.23]
 ['James' 26 3.24]
 ['Ricky' 25 3.98]
 ['Vin' 23 2.56]
 ['Steve' 30 3.2]
 ['Minsu' 29 4.6]
 ['Jack' 23 3.8]]
    Name  Age  Rating
0    Tom   25    4.23
1  James   26    3.24
2  Ricky   25    3.98
3    Vin   23    2.56
4  Steve   30    3.20
    Name  Age  Rating
2  Ricky   25    3.98
3    Vin   23    2.56
4  Steve   30    3.20
5  Minsu   29    4.60
6   Jack   23    3.80

---

第3节 Pandas 文件操作

1. Pandas 操作文件类型

pandas 能够操作的文件格式有很多，以下文件类型为主：

格式类型	数据文件	读取方法	写入方法
text	CSV	read_csv	to_csv
text	JSON	read_json	to_json
text	HTML	read_html	to_html
text	Local clipboard	read_clipboard	to_clipboard
binary	MS Excel	read_excel	to_excel
binary	HDF5 Format	read_hdf	to_hdf
binary	Feather Format	read_feather	to_feather
binary	Parquet Format	read_parquet	to_parquet
binary	Msgpack	read_msgpack	to_msgpack
binary	Stata	read_stata	to_stata
binary	SAS	read_sas	-
binary	Python Pickle Format	read_pickle	to_pickle
SQL	SQL	read_sql	to_sql
SQL	Google Big Query	read_gbq	to_gbq

2. Pandas 操作CSV文件

读取CSV文件常用语法

• pandas.read_csv(filepath_or_buffer, sep, header, names, dtype, nrows, encoding)
• 参数说明：

• filepath_or_buffer：指定文件路径，若只有文件名称，则默认为当前脚本目录
• sep：指定分隔符，默认为逗号分隔“,”
• header：指定行数用来作为列名，数据开始行数。如果文件中没有列名，则默认为0，否则设置为None
• names：用于结果的列名列表，如果数据文件中没有列标题行，就需要执行header=None。默认列表中不能出现重复
• dtype：指定每列数据的数据类型
• nrows：指定需要读取的行数（从文件头开始算起）
• encoding：指定字符集类型，通常指定为’utf-8’

##导入CSV文件 stockdata.csv import pandas as pd df = pd.read_csv("stockdata.csv") print(df.head(5))

           日期    开盘    最高    最低    收盘       成交量          成交额
0  2000/01/04 -0.64 -0.55 -0.67 -0.57   4496000  113946784.0
1  2000/01/05 -0.57 -0.52 -0.62 -0.61   5252800  134465424.0
2  2000/01/06 -0.62 -0.49 -0.63 -0.52   6229600  160059792.0
3  2000/01/07 -0.49 -0.35 -0.51 -0.42  21355300  575751104.0
4  2000/01/10 -0.41 -0.31 -0.44 -0.38  16539700  450453504.0

##导入CSV文件 stockdata.csv import pandas as pd df = pd.read_csv("SH600000.txt") print(df.head(5))

           日期    开盘    最高    最低    收盘       成交量          成交额
0  2000/01/04 -0.64 -0.55 -0.67 -0.57   4496000  113946784.0
1  2000/01/05 -0.57 -0.52 -0.62 -0.61   5252800  134465424.0
2  2000/01/06 -0.62 -0.49 -0.63 -0.52   6229600  160059792.0
3  2000/01/07 -0.49 -0.35 -0.51 -0.42  21355300  575751104.0
4  2000/01/10 -0.41 -0.31 -0.44 -0.38  16539700  450453504.0

##导入CSV文件 stockdata-noheader.csv import pandas as pd df = pd.read_csv("stockdata-noheader.csv", header=None) print(df.head(5))

            0     1     2     3     4         5            6
0  2000/01/04 -0.64 -0.55 -0.67 -0.57   4496000  113946784.0
1  2000/01/05 -0.57 -0.52 -0.62 -0.61   5252800  134465424.0
2  2000/01/06 -0.62 -0.49 -0.63 -0.52   6229600  160059792.0
3  2000/01/07 -0.49 -0.35 -0.51 -0.42  21355300  575751104.0
4  2000/01/10 -0.41 -0.31 -0.44 -0.38  16539700  450453504.0

##导入CSV文件 stockdata-noheader.csv import pandas as pd df = pd.read_csv("stockdata-noheader.csv", header=None, names=['日期', '开盘', '最高', '最低', '收盘', '成交量', '成交额']) print(df.head(5)) print(df.dtypes)

           日期    开盘    最高    最低    收盘       成交量          成交额
0  2000/01/04 -0.64 -0.55 -0.67 -0.57   4496000  113946784.0
1  2000/01/05 -0.57 -0.52 -0.62 -0.61   5252800  134465424.0
2  2000/01/06 -0.62 -0.49 -0.63 -0.52   6229600  160059792.0
3  2000/01/07 -0.49 -0.35 -0.51 -0.42  21355300  575751104.0
4  2000/01/10 -0.41 -0.31 -0.44 -0.38  16539700  450453504.0
日期      object
开盘     float64
最高     float64
最低     float64
收盘     float64
成交量      int64
成交额    float64
dtype: object

##导入CSV文件 stockdata - dtype.csv import pandas as pd df = pd.read_csv("stockdata - dtype.csv") print(df.head(5)) print(df.dtypes)

          日期    开盘    最高    最低    收盘       成交量        成交额  股票代码
0   2000/1/4 -0.64 -0.55 -0.67 -0.57   4496000  113946784  2015
1   2000/1/5 -0.57 -0.52 -0.62 -0.61   5252800  134465424  2015
2   2000/1/6 -0.62 -0.49 -0.63 -0.52   6229600  160059792  2015
3   2000/1/7 -0.49 -0.35 -0.51 -0.42  21355300  575751104  2015
4  2000/1/10 -0.41 -0.31 -0.44 -0.38  16539700  450453504  2015
日期       object
开盘      float64
最高      float64
最低      float64
收盘      float64
成交量       int64
成交额       int64
股票代码      int64
dtype: object

##导入CSV文件 stockdata - dtype.csv import pandas as pd df = pd.read_csv("stockdata - dtype.csv",dtype="str") print(df.head(5)) print(df.dtypes)

          日期     开盘     最高     最低     收盘       成交量        成交额    股票代码
0   2000/1/4  -0.64  -0.55  -0.67  -0.57   4496000  113946784  002015
1   2000/1/5  -0.57  -0.52  -0.62  -0.61   5252800  134465424  002015
2   2000/1/6  -0.62  -0.49  -0.63  -0.52   6229600  160059792  002015
3   2000/1/7  -0.49  -0.35  -0.51  -0.42  21355300  575751104  002015
4  2000/1/10  -0.41  -0.31  -0.44  -0.38  16539700  450453504  002015
日期      object
开盘      object
最高      object
最低      object
收盘      object
成交量     object
成交额     object
股票代码    object
dtype: object

##导入CSV文件 stockdata - dtype.csv import pandas as pd dtypes = {'日期':"str", '开盘':"float64", '最高':"float64", '最低':"float64", '收盘':"float64", '成交量':"int64", '成交额':"float64","股票代码":"str"} df = pd.read_csv("stockdata - dtype.csv",dtype=dtypes) print(df.head(5)) print(df.dtypes)

          日期    开盘    最高    最低    收盘       成交量          成交额    股票代码
0   2000/1/4 -0.64 -0.55 -0.67 -0.57   4496000  113946784.0  002015
1   2000/1/5 -0.57 -0.52 -0.62 -0.61   5252800  134465424.0  002015
2   2000/1/6 -0.62 -0.49 -0.63 -0.52   6229600  160059792.0  002015
3   2000/1/7 -0.49 -0.35 -0.51 -0.42  21355300  575751104.0  002015
4  2000/1/10 -0.41 -0.31 -0.44 -0.38  16539700  450453504.0  002015
日期       object
开盘      float64
最高      float64
最低      float64
收盘      float64
成交量       int64
成交额     float64
股票代码     object
dtype: object

##导入CSV文件 stockdata - dtype.csv，转换日期类型 import pandas as pd import datetime dtypes = {'日期':"str", '开盘':"float64", '最高':"float64", '最低':"float64", '收盘':"float64", '成交量':"int64", '成交额':"float64","股票代码":"str"} df = pd.read_csv("stockdata - dtype.csv",dtype=dtypes) df["日期"] = pd.to_datetime(df['日期'],format='%Y/%m/%d') print(df.head(5)) print(df.dtypes)

          日期    开盘    最高    最低    收盘       成交量          成交额    股票代码
0 2000-01-04 -0.64 -0.55 -0.67 -0.57   4496000  113946784.0  002015
1 2000-01-05 -0.57 -0.52 -0.62 -0.61   5252800  134465424.0  002015
2 2000-01-06 -0.62 -0.49 -0.63 -0.52   6229600  160059792.0  002015
3 2000-01-07 -0.49 -0.35 -0.51 -0.42  21355300  575751104.0  002015
4 2000-01-10 -0.41 -0.31 -0.44 -0.38  16539700  450453504.0  002015
日期      datetime64[ns]
开盘             float64
最高             float64
最低             float64
收盘             float64
成交量              int64
成交额            float64
股票代码            object
dtype: object

写入CSV文件常用语法

• df.to_csv(filepath_or_buffer, sep, header, index, encoding)
• 参数说明：

• filepath_or_buffer：指定文件路径，若只有文件名称，则默认为当前脚本目录
• sep：指定分隔符，默认为逗号分隔“,”
• header：是否导出表头，取值 True/False，默认导出(True)
• index：是否导出行索引，取值 True/False，默认导出(True)
• encoding：指定字符集类型，通常指定为’utf-8’

##导入CSV文件 stockdata.csv import pandas as pd df = pd.read_csv("stockdata.csv") df.to_csv("stockdata - export.csv")

3. Pandas 操作Excel文件

读取Excel文件常用语法

• pandas.read_Excel(filepath_or_buffer, sheet_name, header, names, dtype, nrows)
• 参数说明：

• filepath_or_buffer：指定文件路径，若只有文件名称，则默认为当前脚本目录
• sheet_name：字符串列表或整数列表，默认为0。字符串用于工作表名称,整数用于零索引工作表位置,字符串列表或整数列表用于请求多个工作表，为None时获取所有工作表。
• header：指定行数用来作为列名，数据开始行数。则默认以第一行为列名，若数据从第一行开始则设置为None
• names：用于结果的列名列表，如果数据文件中没有列标题行，就需要执行header=None。默认列表中不能出现重复
• dtype：指定每列数据的数据类型
• nrows：指定需要读取的行数（从文件头开始算起）

##导入Excel 文件 stockdata.xlsx import pandas as pd df = pd.read_excel("stockdata.xlsx") print(df.head(5))

          日期    开盘    最高    最低    收盘       成交量        成交额
0 2000-01-04 -0.64 -0.55 -0.67 -0.57   4496000  113946784
1 2000-01-05 -0.57 -0.52 -0.62 -0.61   5252800  134465424
2 2000-01-06 -0.62 -0.49 -0.63 -0.52   6229600  160059792
3 2000-01-07 -0.49 -0.35 -0.51 -0.42  21355300  575751104
4 2000-01-10 -0.41 -0.31 -0.44 -0.38  16539700  450453504

##导入Excel 文件 stockdata - 2sheet.xlsx import pandas as pd df1 = pd.read_excel("stockdata - 2sheet.xlsx", sheet_name="stockdata1") df2 = pd.read_excel("stockdata - 2sheet.xlsx", sheet_name="stockdata2") print(df1.head(5)) print(df2.head(5))

          日期    开盘    最高    最低    收盘       成交量        成交额
0 2000-01-04 -0.64 -0.55 -0.67 -0.57   4496000  113946784
1 2000-01-05 -0.57 -0.52 -0.62 -0.61   5252800  134465424
2 2000-01-06 -0.62 -0.49 -0.63 -0.52   6229600  160059792
3 2000-01-07 -0.49 -0.35 -0.51 -0.42  21355300  575751104
4 2000-01-10 -0.41 -0.31 -0.44 -0.38  16539700  450453504
          日期    开盘    最高    最低    收盘        成交量           成交额
0 2003-04-28  1.52  2.12  1.50  2.11  187469932  1.512258e+09
1 2003-04-29  1.97  2.09  1.84  1.96   75212876  6.358634e+08
2 2003-04-30  2.00  2.32  2.00  2.18   80122500  7.100635e+08
3 2003-05-12  2.08  2.18  1.85  2.07   36122300  3.088063e+08
4 2003-05-13  2.05  2.06  1.68  1.73   39277696  3.257159e+08

##导入Excel 文件 stockdata-noheader.xlsx import pandas as pd df = pd.read_excel("stockdata-noheader.xlsx", header=None) ##默认第一行为列名，若第一行是数据，则设置 header=None print(df.head(5))

           0     1     2     3     4         5          6
0 2000-01-04 -0.64 -0.55 -0.67 -0.57   4496000  113946784
1 2000-01-05 -0.57 -0.52 -0.62 -0.61   5252800  134465424
2 2000-01-06 -0.62 -0.49 -0.63 -0.52   6229600  160059792
3 2000-01-07 -0.49 -0.35 -0.51 -0.42  21355300  575751104
4 2000-01-10 -0.41 -0.31 -0.44 -0.38  16539700  450453504

##导入Excel 文件 stockdata-noheader.xlsx import pandas as pd df = pd.read_excel("stockdata-noheader.xlsx", header=None, names=['日期', '开盘', '最高', '最低', '收盘', '成交量', '成交额']) ##默认第一行为列名，若第一行是数据，则设置 header=None，指定列名 print(df.head(5))

          日期    开盘    最高    最低    收盘       成交量        成交额
0 2000-01-04 -0.64 -0.55 -0.67 -0.57   4496000  113946784
1 2000-01-05 -0.57 -0.52 -0.62 -0.61   5252800  134465424
2 2000-01-06 -0.62 -0.49 -0.63 -0.52   6229600  160059792
3 2000-01-07 -0.49 -0.35 -0.51 -0.42  21355300  575751104
4 2000-01-10 -0.41 -0.31 -0.44 -0.38  16539700  450453504

##导入Excel 文件 stockdata.xlsx import pandas as pd df = pd.read_excel("stockdata.xlsx", nrows=3) ##指定读入数据行数 print(df.head(5))

          日期    开盘    最高    最低    收盘      成交量        成交额
0 2000-01-04 -0.64 -0.55 -0.67 -0.57  4496000  113946784
1 2000-01-05 -0.57 -0.52 -0.62 -0.61  5252800  134465424
2 2000-01-06 -0.62 -0.49 -0.63 -0.52  6229600  160059792

写入Excel文件常用语法

• df.to_excel(excel_writer, sheet_name, header, index)
• 参数说明：

• excel_writer：文件路径或现有的ExcelWriter
• sheet_name：它是指包含DataFrame的工作表的名称
• header：写出列名。如果给出了字符串列表, 则假定它是列名的别名，默认导出(True)
• index：写入索引，默认导出(True)

##导出Excel 文件 stockdata-export.xlsx import pandas as pd df = pd.read_excel("stockdata.xlsx", nrows=10) df.to_excel("stockdata-export.xlsx")

##导出Excel 文件 文件 stockdata-mutilexport.xlsx，导出多个sheet import pandas as pd df1 = pd.read_excel("stockdata - 2sheet.xlsx", sheet_name="stockdata1") df2 = pd.read_excel("stockdata - 2sheet.xlsx", sheet_name="stockdata2") with pd.ExcelWriter("stockdata-mutilexport.xlsx") as writer: df1.to_excel(writer, sheet_name="1") df2.to_excel(writer, sheet_name="2")

4. Pandas 操作JSON文件

读取JSON文件常用语

• pandas.read_json(filepath_or_buffer, orient)
• 参数说明：

• filepath_or_buffer：指定文件路径，若只有文件名称，则默认为当前脚本目录，或者json格式的字符串
• orient，指定JSON数据格式，具体格式参数如下：

1. split，用来读取由索引、列字段和数据构成的json格式：{index: [index], columns: [columns], data: [values]}，index作为索引, columns作为列名结合data的values组成一个dataframe
2. records，用来读取成员为字典的列表：[{column1: value1, column2: value2}, …, {column1: value1, column2: value2}]，键column为列名，value为列所对应的值，每一个字典成员就构成了dataframe的一行数据
3. index，用来读取以索引为key，以列字段构成的字典为键值的json格式：{index1: {column1: value1, column2: value2}, index2: {column1: value1, column2: value2}}，将key作为dataframe的index，字典中的键和键值构成dataframe的data
4. columns，处理以列为键，对应一个值字典的对象：{column1:{index1: value1, index2: value1}, column2:{index1: value2, index2: value2}}，将column作为列名，index作为索引，value为列的数据，组成一个dataframe
5. values，处理一个嵌套的列表，里面的成员也是列表：[[value1, value2], …, [value1, value2]]

## split，用来读取由索引、列字段和数据构成的json格式：{index: [index], columns: [columns], data: [values]}，index作为索引, columns作为列名结合data的values组成一个dataframe import pandas as pd jsons = '{"index": [1, 2, 3], "columns": ["a", "b"], "data":[[1, 3], [2, 8], [3, 9]]}' df = pd.read_json(jsons, orient='split') print(df)

   a  b
1  1  3
2  2  8
3  3  9

## records，用来读取成员为字典的列表：[{column1: value1, column2: value2}, …, {column1: value1, column2: value2}]，键column为列名，value为列所对应的值，每一个字典成员就构成了dataframe的一行数据 import pandas as pd jsons = '[{"a": 1, "b": 3}, {"a": 2, "b": 6}, {"a": 3, "b": 9}]' df = pd.read_json(jsons, orient='records') print(df)

   a  b
0  1  3
1  2  6
2  3  9

## index，用来读取以索引为key，以列字段构成的字典为键值的json格式：{index1: {column1: value1, column2: value2}, index2: {column1: value1, column2: value2}}，将key作为dataframe的index，字典中的键和键值构成dataframe的data import pandas as pd jsons = '{"0": {"a": 1, "b": 2}, "1": {"a": 9, "b": 11}}' df = pd.read_json(jsons, orient='index') print(df)

   a   b
0  1   2
1  9  11

## columns，处理以列为键，对应一个值字典的对象：{column1:{index1: value1, index2: value1}, column2:{index1: value2, index2: value2}}，将column作为列名，index作为索引，value为列的数据，组成一个dataframe import pandas as pd jsons = '{"a": {"0": 1, "1": 9}, "b": {"0": 2, "1": 11}}' df = pd.read_json(jsons, orient='columns') print(df)

   a   b
0  1   2
1  9  11

##values，处理一个嵌套的列表，里面的成员也是列表：[[value1, value2], …, [value1, value2]] import pandas as pd jsons = '[["a", 1], ["b", 2]]' df = pd.read_json(jsons, orient='values') print(df)

   0  1
0  a  1
1  b  2

## 读取json文件 import pandas as pd with open('test.json', 'r', encoding='utf-8') as f: json_info = f.read() df = pd.read_json(json_info, orient='records') print(df)

   mac           timestamp  volt  temp  \
0    1 2011-06-06 18:53:57   2.5  35.5   
1    2 2011-06-06 18:53:57   2.5  35.5   

                                                 acc  sampletime  
0  [[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3], [...  1307386437  
1  [[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3], [...  1307386437  

写入JSON文件常用语法

• df.to_json(filepath_or_buffer, orient)
• 参数说明：

• filepath_or_buffer：指定文件路径，若只有文件名称，则默认为当前脚本目录，或者json格式的字符串
• orient，指定JSON数据格式，具体格式参数如下：

1. split，用来读取由索引、列字段和数据构成的json格式：{index: [index], columns: [columns], data: [values]}，index作为索引, columns作为列名结合data的values组成一个dataframe
2. records，用来读取成员为字典的列表：[{column1: value1, column2: value2}, …, {column1: value1, column2: value2}]，键column为列名，value为列所对应的值，每一个字典成员就构成了dataframe的一行数据
3. index，用来读取以索引为key，以列字段构成的字典为键值的json格式：{index1: {column1: value1, column2: value2}, index2: {column1: value1, column2: value2}}，将key作为dataframe的index，字典中的键和键值构成dataframe的data
4. columns，处理以列为键，对应一个值字典的对象：{column1:{index1: value1, index2: value1}, column2:{index1: value2, index2: value2}}，将column作为列名，index作为索引，value为列的数据，组成一个dataframe
5. values，处理一个嵌套的列表，里面的成员也是列表：[[value1, value2], …, [value1, value2]]

import pandas as pd jsons = '{"index": [1, 2, 3], "columns": ["a", "b"], "data":[[1, 3], [2, 8], [3, 9]]}' df = pd.read_json(jsons, orient='split') df.to_json("jsonfile.json", orient='split')

5. Pandas 操作MySQL数据

读取MySQL数据常用语法

pandas.read_sql(sql, con, index_col=None, coerce_float=True, params=None, parse_dates=None, columns=None, chunksize=None)

• 参数说明：

• sql：SQL命令字符串
• con：连接sql数据库的engine，一般可以用SQLalchemy或者pymysql之类的包建立
• index_col: 选择某一列作为index
• coerce_float：非常有用，将数字形式的字符串直接以float型读入
• parse_dates：将某一列日期型字符串转换为datetime型数据，与pd.to_datetime函数功能类似。可以直接提供需要转换的列名以默认的日期形式转换，也可以用字典的格式提供列名和转换的日期格式，比如{column_name: format string}（format string："%Y:%m:%H:%M:%S"）。
• columns：要选取的列。一般没啥用，因为在sql命令里面一般就指定要选择的列了
• chunksize：如果提供了一个整数值，那么就会返回一个generator，每次输出的行数就是提供的值的大小。

import pandas as pd import sqlalchemy from sqlalchemy import create_engine # 用sqlalchemy构建数据库链接engine hostid = "localhost" # 数据库主机地，本机MySQL的为localhost username = "root" # 数据库用户名 password = "123456" # 数据库密码 port = "3306" db = "stock" ##mysql+pymysql://{数据库用户名}:{数据库密码}@{数据库主机地址}:{数据库主机端口}/{数据库库名} connect_info = 'mysql+pymysql://{}:{}@{}:{}/{}' engine = create_engine(connect_info.format(str(username), str(password), str(hostid), str(port), str(db))) # sql 命令 sql_cmd = "SELECT * FROM trade limit 5;" df = pd.read_sql(sql=sql_cmd, con=engine) print(df)

  StockId StockName  TradeDate  OpenPrice  HighPrice  LowPrice  ClosePrice  \
0  600000      浦发银行 2000-01-04      -0.64      -0.55     -0.67       -0.57   
1  600000      浦发银行 2000-01-05      -0.57      -0.52     -0.62       -0.61   
2  600000      浦发银行 2000-01-06      -0.62      -0.49     -0.63       -0.52   
3  600000      浦发银行 2000-01-07      -0.49      -0.35     -0.51       -0.42   
4  600000      浦发银行 2000-01-10      -0.41      -0.31     -0.44       -0.38   

     Volume        Money  id  
0   4496000  113946784.0   1  
1   5252800  134465424.0   2  
2   6229600  160059792.0   3  
3  21355300  575751104.0   4  
4  16539700  450453504.0   5  

写入MySQL数据常用语法

to_sql(name, con, schema=None, if_exists='fail', index=True,index_label=None, chunksize=None)

• 参数说明：

• name:指定的是将输入接入数据库当做的哪个表
• con：与数据库链接的方式，推荐使用sqlalchemy的engine类型
• schema: 相应数据库的引擎，不设置则使用数据库的默认引擎，如mysql中的innodb引擎
• if_exists: 当数据库中已经存在数据表时对数据表的操作，有replace替换、append追加，fail则当表存在时提示ValueError。
• index: 对DataFrame的index索引的处理，为True时索引也将作为数据写入数据表
• index_label: 当上一个参数index为True时，设置写入数据表时index的列名称
• chunsize: 设置整数，如20000，一次写入数据时的数据行数量，当数据量很大时，需要设置，否则会链接超时写入失败。

import pandas as pd import sqlalchemy from sqlalchemy import create_engine # 用sqlalchemy构建数据库链接engine hostid = "localhost" # 数据库主机地，本机MySQL的为localhost username = "root" # 数据库用户名 password = "123456" # 数据库密码 port = "3306" db = "stock" ##mysql+pymysql://{数据库用户名}:{数据库密码}@{数据库主机地址}:{数据库主机端口}/{数据库库名} connect_info = 'mysql+pymysql://{}:{}@{}:{}/{}' engine = create_engine(connect_info.format(str(username), str(password), str(hostid), str(port), str(db))) # sql 命令 sql_cmd = "SELECT `StockId`, `StockName`, `TradeDate`, `OpenPrice`, `HighPrice`, `LowPrice`, `ClosePrice`, `Volume`, `Money` FROM trade limit 5;" df = pd.read_sql(sql=sql_cmd, con=engine) # 数据插入表 trade_test tableName = "trade_test" df.to_sql(tableName, con=engine, if_exists="append", index=0)

---

第4节 Pandas 数据处理与可视化

1. Pandas 描述性统计

描述性统计常用函数

序号	函数	描述
1	count()	非空观测数量
2	sum()	所有值之和
3	mean()	所有值的平均值
4	median()	所有值的中位数
5	mode()	值的众数
6	std()	值的标准偏差
7	min()	所有值中的最小值
8	max()	所有值中的最大值
9	abs()	绝对值
10	prod()	数组元素的乘积
11	cumsum()	累计总和
12	cumprod()	累计乘积

##导入Excel 文件 stockdata.xlsx import pandas as pd df = pd.read_excel("stockdata.xlsx")[['开盘', '最高', '最低', '收盘', '成交量', '成交额']].head(10) print(df) print(df.count()) ## 非空观测数量 print(df.sum()) ## 所有值之和 print(df.mean()) ## 所有值的平均值 print(df.median()) ## 所有值的中位数 print(df.mode()) ## 值的模值 print(df.std()) ## 值的标准偏差 print(df.min()) ## 所有值中的最小值 print(df.max()) ## 所有值中的最大值 print(df.abs()) ## 绝对值 print(df.prod()) ## 数组元素的乘积 print(df.cumsum()) ## 累计总和 print(df.cumprod()) ## 累计乘积 print(df.describe()) ## describe()函数是用来计算有关DataFrame列的统计信息的摘要。

     开盘    最高    最低    收盘       成交量        成交额
0 -0.64 -0.55 -0.67 -0.57   4496000  113946784
1 -0.57 -0.52 -0.62 -0.61   5252800  134465424
2 -0.62 -0.49 -0.63 -0.52   6229600  160059792
3 -0.49 -0.35 -0.51 -0.42  21355300  575751104
4 -0.41 -0.31 -0.44 -0.38  16539700  450453504
5 -0.38 -0.37 -0.51 -0.50   9390700  251055904
6 -0.52 -0.52 -0.66 -0.63  35274900  889867328
7 -0.64 -0.61 -0.66 -0.65   7975600  199244304
8 -0.65 -0.64 -0.77 -0.73  17861800  434206080
9 -0.75 -0.70 -0.78 -0.71   8101500  194776960
开盘     10
最高     10
最低     10
收盘     10
成交量    10
成交额    10
dtype: int64
开盘    -5.670000e+00
最高    -5.060000e+00
最低    -6.250000e+00
收盘    -5.720000e+00
成交量    1.324779e+08
成交额    3.403827e+09
dtype: float64
开盘    -5.670000e-01
最高    -5.060000e-01
最低    -6.250000e-01
收盘    -5.720000e-01
成交量    1.324779e+07
成交额    3.403827e+08
dtype: float64
开盘    -5.950000e-01
最高    -5.200000e-01
最低    -6.450000e-01
收盘    -5.900000e-01
成交量    8.746100e+06
成交额    2.251501e+08
dtype: float64
     开盘    最高    最低    收盘       成交量        成交额
0 -0.64 -0.52 -0.66 -0.73   4496000  113946784
1   NaN   NaN -0.51 -0.71   5252800  134465424
2   NaN   NaN   NaN -0.65   6229600  160059792
3   NaN   NaN   NaN -0.63   7975600  194776960
4   NaN   NaN   NaN -0.61   8101500  199244304
5   NaN   NaN   NaN -0.57   9390700  251055904
6   NaN   NaN   NaN -0.52  16539700  434206080
7   NaN   NaN   NaN -0.50  17861800  450453504
8   NaN   NaN   NaN -0.42  21355300  575751104
9   NaN   NaN   NaN -0.38  35274900  889867328
开盘     1.162421e-01
最高     1.292027e-01
最低     1.106797e-01
收盘     1.167904e-01
成交量    9.672281e+06
成交额    2.480013e+08
dtype: float64
开盘    -7.500000e-01
最高    -7.000000e-01
最低    -7.800000e-01
收盘    -7.300000e-01
成交量    4.496000e+06
成交额    1.139468e+08
dtype: float64
开盘    -3.800000e-01
最高    -3.100000e-01
最低    -4.400000e-01
收盘    -3.800000e-01
成交量    3.527490e+07
成交额    8.898673e+08
dtype: float64
     开盘    最高    最低    收盘         成交量          成交额
0  0.64  0.55  0.67  0.57   4496000.0  113946784.0
1  0.57  0.52  0.62  0.61   5252800.0  134465424.0
2  0.62  0.49  0.63  0.52   6229600.0  160059792.0
3  0.49  0.35  0.51  0.42  21355300.0  575751104.0
4  0.41  0.31  0.44  0.38  16539700.0  450453504.0
5  0.38  0.37  0.51  0.50   9390700.0  251055904.0
6  0.52  0.52  0.66  0.63  35274900.0  889867328.0
7  0.64  0.61  0.66  0.65   7975600.0  199244304.0
8  0.65  0.64  0.77  0.73  17861800.0  434206080.0
9  0.75  0.70  0.78  0.71   8101500.0  194776960.0
开盘     2.801354e-03
最高     7.994748e-04
最低     7.835618e-03
收盘     3.062288e-03
成交量    1.986682e+70
成交额    2.394389e+84
dtype: float64
     开盘    最高    最低    收盘        成交量         成交额
0 -0.64 -0.55 -0.67 -0.57    4496000   113946784
1 -1.21 -1.07 -1.29 -1.18    9748800   248412208
2 -1.83 -1.56 -1.92 -1.70   15978400   408472000
3 -2.32 -1.91 -2.43 -2.12   37333700   984223104
4 -2.73 -2.22 -2.87 -2.50   53873400  1434676608
5 -3.11 -2.59 -3.38 -3.00   63264100  1685732512
6 -3.63 -3.11 -4.04 -3.63   98539000  2575599840
7 -4.27 -3.72 -4.70 -4.28  106514600  2774844144
8 -4.92 -4.36 -5.47 -5.01  124376400  3209050224
9 -5.67 -5.06 -6.25 -5.72  132477900  3403827184
         开盘        最高        最低        收盘                  成交量  \
0 -0.640000 -0.550000 -0.670000 -0.570000              4496000   
1  0.364800  0.286000  0.415400  0.347700       23616588800000   
2 -0.226176 -0.140140 -0.261702 -0.180804  -452051001196412928   
3  0.110826  0.049049  0.133468  0.075938 -5509987558482771968   
4 -0.045439 -0.015205 -0.058726 -0.028856 -3115789856807059456   
5  0.017267  0.005626  0.029950  0.014428  2878148941738672128   
6 -0.008979 -0.002925 -0.019767 -0.009090   835305951065014272   
7  0.005746  0.001785  0.013046  0.005908  6074349849552093184   
8 -0.003735 -0.001142 -0.010046 -0.004313 -1218162324121059328   
9  0.002801  0.000799  0.007836  0.003062 -7776408446869438464   

                   成交额  
0            113946784  
1    15321902623996416  
2  -290582269495435264  
3 -3493664344764841984  
4  6883605009410293760  
5  -218899433511714816  
6  2206068926062788608  
7 -7302446058292903936  
8 -2972375754064527360  
9 -6917529027641081856  
              开盘         最高        最低        收盘           成交量           成交额
count  10.000000  10.000000  10.00000  10.00000  1.000000e+01  1.000000e+01
mean   -0.567000  -0.506000  -0.62500  -0.57200  1.324779e+07  3.403827e+08
std     0.116242   0.129203   0.11068   0.11679  9.672281e+06  2.480013e+08
min    -0.750000  -0.700000  -0.78000  -0.73000  4.496000e+06  1.139468e+08
25%    -0.640000  -0.595000  -0.66750  -0.64500  6.666100e+06  1.687391e+08
50%    -0.595000  -0.520000  -0.64500  -0.59000  8.746100e+06  2.251501e+08
75%    -0.497500  -0.400000  -0.53750  -0.50500  1.753128e+07  4.463916e+08
max    -0.380000  -0.310000  -0.44000  -0.38000  3.527490e+07  8.898673e+08

2. pandas 与 SQL 对比

选择指定数据列

select '开盘', '最高', '最低', '收盘' from stockdata;

import pandas as pd dfin = pd.read_excel("stockdata.xlsx") df = dfin[['开盘', '最高', '最低', '收盘']] print(df)

         开盘     最高     最低     收盘
0     -0.64  -0.55  -0.67  -0.57
1     -0.57  -0.52  -0.62  -0.61
2     -0.62  -0.49  -0.63  -0.52
3     -0.49  -0.35  -0.51  -0.42
4     -0.41  -0.31  -0.44  -0.38
...     ...    ...    ...    ...
5005  10.72  10.82  10.54  10.54
5006  10.59  10.64  10.50  10.58
5007  10.61  10.70  10.36  10.47
5008  10.45  10.92  10.43  10.92
5009  10.80  10.92  10.76  10.88

[5010 rows x 4 columns]

显示前五条记录

select * from stockdata limt 5;

import pandas as pd dfin = pd.read_excel("stockdata.xlsx") df = dfin.head(5) print(df)

          日期    开盘    最高    最低    收盘       成交量        成交额
0 2000-01-04 -0.64 -0.55 -0.67 -0.57   4496000  113946784
1 2000-01-05 -0.57 -0.52 -0.62 -0.61   5252800  134465424
2 2000-01-06 -0.62 -0.49 -0.63 -0.52   6229600  160059792
3 2000-01-07 -0.49 -0.35 -0.51 -0.42  21355300  575751104
4 2000-01-10 -0.41 -0.31 -0.44 -0.38  16539700  450453504

按条件选择记录

select * from stockdata where '开盘' > 0;

import pandas as pd dfin = pd.read_excel("stockdata.xlsx") df = dfin[dfin['开盘']>0] print(df)

             日期     开盘     最高     最低     收盘        成交量         成交额
1588 2006-11-22   0.18   0.37   0.06   0.29   44171226   704560896
1589 2006-11-23   0.29   0.41   0.27   0.33   17877754   295932896
1590 2006-11-24   0.29   0.31   0.14   0.21   16607070   266556848
1591 2006-11-27   0.15   0.19   0.02   0.10   17435254   272731776
1592 2006-11-28   0.09   0.20   0.08   0.17   13576886   213859056
...         ...    ...    ...    ...    ...        ...         ...
5005 2021-02-26  10.72  10.82  10.54  10.54   85386093   909298112
5006 2021-03-01  10.59  10.64  10.50  10.58   54746126   578491520
5007 2021-03-02  10.61  10.70  10.36  10.47   74763149   786616704
5008 2021-03-03  10.45  10.92  10.43  10.92  113570860  1224387968
5009 2021-03-04  10.80  10.92  10.76  10.88   75412865   817817152

[3421 rows x 7 columns]

select * from stockdata where '开盘' > 0 and '收盘' > 0;

import pandas as pd dfin = pd.read_excel("stockdata.xlsx") df = dfin[(dfin['开盘']>0) & (dfin['收盘']>0)] print(df)

             日期     开盘     最高     最低     收盘        成交量         成交额
1588 2006-11-22   0.18   0.37   0.06   0.29   44171226   704560896
1589 2006-11-23   0.29   0.41   0.27   0.33   17877754   295932896
1590 2006-11-24   0.29   0.31   0.14   0.21   16607070   266556848
1591 2006-11-27   0.15   0.19   0.02   0.10   17435254   272731776
1592 2006-11-28   0.09   0.20   0.08   0.17   13576886   213859056
...         ...    ...    ...    ...    ...        ...         ...
5005 2021-02-26  10.72  10.82  10.54  10.54   85386093   909298112
5006 2021-03-01  10.59  10.64  10.50  10.58   54746126   578491520
5007 2021-03-02  10.61  10.70  10.36  10.47   74763149   786616704
5008 2021-03-03  10.45  10.92  10.43  10.92  113570860  1224387968
5009 2021-03-04  10.80  10.92  10.76  10.88   75412865   817817152

[3420 rows x 7 columns]

分组统计个数

select '年份',count('开盘') as '交易天数' from (select substr('日期',1,4) as '年份','开盘' from stockdata) t group by '年份';

import pandas as pd dfin = pd.read_excel("stockdata.xlsx") dfin['年份'] = dfin['日期'].astype(str).str[0:4] dfbyYear = dfin.groupby(['年份'])['开盘'].count().reset_index() dfbyYear.columns = ['年份', '交易天数'] print(dfbyYear)

      年份  交易天数
0   2000   237
1   2001   238
2   2002   234
3   2003   234
4   2004   241
5   2005   239
6   2006   193
7   2007   241
8   2008   244
9   2009   243
10  2010   230
11  2011   243
12  2012   242
13  2013   238
14  2014   244
15  2015   230
16  2016   226
17  2017   244
18  2018   243
19  2019   244
20  2020   243
21  2021    39

分组统计个数和平均数

select '年份',count('开盘') as '交易天数',avg('开盘') as '平均开盘价格' from (select substr('日期',1,4) as '年份','开盘' from stockdata) t group by '年份';

import pandas as pd dfin = pd.read_excel("stockdata.xlsx") dfin['年份'] = dfin['日期'].astype(str).str[0:4] dfbyYear = dfin.groupby(['年份']).agg({'开盘':['count', 'mean']}).reset_index() dfbyYear.columns = ['年份', '交易天数', '平均开盘价格'] print(dfbyYear)

      年份  交易天数     平均开盘价格
0   2000   237  -0.799662
1   2001   238  -1.395588
2   2002   234  -1.648419
3   2003   234  -1.628077
4   2004   241  -1.864855
5   2005   239  -2.085649
6   2006   193  -0.927668
7   2007   241   5.300747
8   2008   244   3.648975
9   2009   243   4.574938
10  2010   230   4.588870
11  2011   243   3.572922
12  2012   242   2.808967
13  2013   238   4.137101
14  2014   244   4.664508
15  2015   230   9.663696
16  2016   226  11.092743
17  2017   244  11.520082
18  2018   243  10.007366
19  2019   244  10.844057
20  2020   243  10.110206
21  2021    39  10.186154

表连接 concat方法

pandas.concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False,keys=None, levels=None, names=None, verify_integrity=False,copy=True)

• 参数说明：

• objs：Series，DataFrame或Panel对象的序列或映射。如果传递了dict，则排序的键将用作键参数，除非它被传递，在这种情况下，将选择值（见下文）。任何无对象将被静默删除，除非它们都是无，在这种情况下将引发一个ValueError。
• axis：{0,1，…}，默认为0。沿着连接的轴。
• join：{‘inner’，‘outer’}，默认为“outer”。如何处理其他轴上的索引。outer为联合和inner为交集。
• ignore_index：boolean，default False。如果为True，请不要使用并置轴上的索引值。结果轴将被标记为0，…，n-1。如果要连接其中并置轴没有有意义的索引信息的对象，这将非常有用。注意，其他轴上的索引值在连接中仍然受到尊重。
• join_axes：Index对象列表。用于其他n-1轴的特定索引，而不是执行内部/外部设置逻辑。
• keys：序列，默认值无。使用传递的键作为最外层构建层次索引。如果为多索引，应该使用元组。
• levels：序列列表，默认值无。用于构建MultiIndex的特定级别（唯一值）。否则，它们将从键推断。
• names：list，default无。结果层次索引中的级别的名称。
• verify_integrity：boolean，default False。检查新连接的轴是否包含重复项。这相对于实际的数据串联可能是非常昂贵的。
  copy：boolean，default True。如果为False，请勿不必要地复制数据。

SELECT key, value FROM t1 UNION ALL SELECT key, value FROM t2;

import pandas as pd df1 = pd.DataFrame({'key': ['A', 'B', 'C', 'D'], 'value': [1, 2, 3, 4]}) df2 = pd.DataFrame({'key': ['B', 'C', 'D', 'E'], 'value': [2, 3, 4, 5]}) df = pd.concat([df1, df2]) print(df)

  key  value
0   A      1
1   B      2
2   C      3
3   D      4
0   B      2
1   C      3
2   D      4
3   E      5

表连接 merge方法

pandas.merge(left, right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False)

• 参数说明：

• left，right：表示要合并的两个 DataFrame 对象；
• how：表示如何合并连接，默认为 inner，还有outer、left、right；
• on：指定进行连接的标签或列表，注意此生的标签必须同时存在两个 DataFrame 对象中；
• left_on：左侧DataFrame对象中参与连接的标签或列表；
• right_on：右侧dataFrame对象中参与连接的标签或列表；
• left_index：是否使用左侧DataFrame对象中的索引作为连接的主键；
• right_idnex：是否使用右侧dataFrame对象中的索引作为连接的主键；
• sort：是否对连接结果根据连接关键字进行排序；

select t1.key, t1.value from t1 inner join t2 on t1.key = t2.key;

import pandas as pd df1 = pd.DataFrame({'key': ['A', 'B', 'C', 'D'], 'value': [1, 2, 3, 4]}) df2 = pd.DataFrame({'key': ['B', 'C', 'D', 'E'], 'value': [2, 3, 4, 5]}) df = pd.merge(df1, df2, on=['key'], how='inner') print(df)

  key  value_x  value_y
0   B        2        2
1   C        3        3
2   D        4        4

3. Pandas 数据可视化

Pandas 可使用matplotlib库的plot()方法的简单包装实现绘图

##导入CSV文件 stockdata.csv，转换日期类型 import pandas as pd import datetime df = pd.read_csv("stockdata.csv") df["日期"] = pd.to_datetime(df['日期'],format='%Y/%m/%d') print(df.head(5))

          日期    开盘    最高    最低    收盘       成交量          成交额
0 2000-01-04 -0.64 -0.55 -0.67 -0.57   4496000  113946784.0
1 2000-01-05 -0.57 -0.52 -0.62 -0.61   5252800  134465424.0
2 2000-01-06 -0.62 -0.49 -0.63 -0.52   6229600  160059792.0
3 2000-01-07 -0.49 -0.35 -0.51 -0.42  21355300  575751104.0
4 2000-01-10 -0.41 -0.31 -0.44 -0.38  16539700  450453504.0

绘制折线图

import pandas as pd import numpy as np from matplotlib import pyplot as plt ## 设置正常显示符号 plt.rcParams['font.sans-serif'] = 'SimHei' plt.rcParams['axes.unicode_minus'] = False dfplot = df[['日期', '收盘']] dfplot.set_index('日期', inplace=True) # column 改为 index，inplace=True表示替换原来数据集 dfplot.plot()

绘制条形图

import pandas as pd import numpy as np ## 设置正常显示符号 from matplotlib import pyplot as plt plt.rcParams['font.sans-serif'] = 'SimHei' plt.rcParams['axes.unicode_minus'] = False ## 统计每年交易天数 df['年份'] = df['日期'].astype(str).str[0:4] dfbyYear = df.groupby(['年份'])['开盘'].count().reset_index() dfbyYear.columns = ['年份', '交易天数'] ## column 改为 index，inplace=True表示替换原来数据集 dfbyYear.set_index('年份', inplace=True) dfbyYear.plot.bar()

​ 

绘制直方图

import pandas as pd import numpy as np ## 设置正常显示符号 from matplotlib import pyplot as plt plt.rcParams['font.sans-serif'] = 'SimHei' plt.rcParams['axes.unicode_minus'] = False dfhist = df[['收盘']] dfhist.plot.hist(bins=20) ##设置柱子数量

绘制散点图形

import pandas as pd import numpy as np ## 设置正常显示符号 from matplotlib import pyplot as plt plt.rcParams['font.sans-serif'] = 'SimHei' plt.rcParams['axes.unicode_minus'] = False df.plot.scatter(x='开盘', y='收盘')

---

开始实验

第5节 附录