• 第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/

    04c97dec1405fd717867589beebb4d19.png

    第2节 Pandas 数据结构

    1. 数据结构概述

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

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

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

    2. 维数和描述

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

    数据结构维数描述
    系列11D标记均匀数组，大小不变。
    数据帧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) 

    1. 0    a
    2. 1    b
    3. 2    c
    4. 3    d
    5. 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) 

    1. 100    a
    2. 101    b
    3. 102    c
    4. 103    d
    5. dtype: object

    从字典创建一个系列

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

     

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

    1. a    0.0
    2. b    1.0
    3. c    2.0
    4. 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) 

    1. b    1.0
    2. c    2.0
    3. d    NaN
    4. a    0.0
    5. dtype: float64

    从标量创建一个系列

     

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

    1. 0    5
    2. dtype: int64
     

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

    1. 0    1
    2. 1    1
    3. 2    1
    4. 3    1
    5. 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. 1
    2. a    1
    3. b    2
    4. c    3
    5. dtype: int64
    6. c    3
    7. d    4
    8. e    5
    9. dtype: int64
    10. c    3
    11. d    4
    12. e    5
    13. dtype: int64
    14. 3
    15. a    1
    16. b    2
    17. c    3
    18. dtype: int64

    系列基本功能

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

    1. [RangeIndex(start=0, stop=4, step=1)]
    2. float64
    3. False
    4. 1
    5. 4
    6. [-1.56243449  0.55073091 -0.2908994  -0.7800016 ]
    7. 0   -1.562434
    8. dtype: float64
    9. 3   -0.780002
    10. 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) 

    1. Empty DataFrame
    2. Columns: []
    3. Index: []
     

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

    1. Empty DataFrame
    2. Columns: [c1, c2, c3, c4, c5]
    3. Index: []

    从列表创建数据帧

     

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

    1.    0
    2. 0  1
    3. 1  2
    4. 2  3
    5. 3  4
    6. 4  5
     

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

    1.      Name  Age
    2. 0    Alex   10
    3. 1     Bob   12
    4. 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) 

    1.      Name   Age
    2. 0    Alex  10.0
    3. 1     Bob  12.0
    4. 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) 

    1.    a   b     c
    2. 0  1   2   NaN
    3. 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) 

    1.         a   b     c
    2. first   1   2   NaN
    3. 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) 

    1.         a   b
    2. first   1   2
    3. 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) 

    1.         a  b1
    2. first   1 NaN
    3. second  5 NaN

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

     

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

    1.     Name  Age
    2. 0    Tom   28
    3. 1   Jack   34
    4. 2  Steve   29
    5. 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) 

    1.         Name  Age
    2. rank1    Tom   28
    3. rank2   Jack   34
    4. rank3  Steve   29
    5. 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) 

    1.    one  two
    2. a  1.0    1
    3. b  2.0    2
    4. c  3.0    3
    5. 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']]) ## 多列选择 

    1. a    1.0
    2. b    2.0
    3. c    3.0
    4. d    NaN
    5. 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) 

    1.    one  two  three
    2. a  1.0    1   10.0
    3. b  2.0    2   20.0
    4. c  3.0    3   30.0
    5. 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) 

    1.    two  three
    2. a    1   10.0
    3. b    2   20.0
    4. c    3   30.0
    5. 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']) ##行索引标签选择 

    1. one    2.0
    2. two    2.0
    3. 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]) ##行索引整数位置选择 

    1. one    3.0
    2. two    3.0
    3. 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) 

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

    行操作-删除

     

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

    1.    a  b
    2. 1  3  4

    DataFrame基本功能

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

    1.            0      1      2     3      4      5     6
    2. Name     Tom  James  Ricky   Vin  Steve  Minsu  Jack
    3. Age       25     26     25    23     30     29    23
    4. Rating  4.23   3.24   3.98  2.56    3.2    4.6   3.8
    5. [RangeIndex(start=0, stop=7, step=1), Index(['Name', 'Age', 'Rating'], dtype='object')]
    6. Name       object
    7. Age         int64
    8. Rating    float64
    9. dtype: object
    10. False
    11. 2
    12. (7, 3)
    13. 21
    14. [['Tom' 25 4.23]
    15.  ['James' 26 3.24]
    16.  ['Ricky' 25 3.98]
    17.  ['Vin' 23 2.56]
    18.  ['Steve' 30 3.2]
    19.  ['Minsu' 29 4.6]
    20.  ['Jack' 23 3.8]]
    21.     Name  Age  Rating
    22. 0    Tom   25    4.23
    23. 1  James   26    3.24
    24. 2  Ricky   25    3.98
    25. 3    Vin   23    2.56
    26. 4  Steve   30    3.20
    27.     Name  Age  Rating
    28. 2  Ricky   25    3.98
    29. 3    Vin   23    2.56
    30. 4  Steve   30    3.20
    31. 5  Minsu   29    4.60
    32. 6   Jack   23    3.80

    第3节 Pandas 文件操作

    1. Pandas 操作文件类型

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

    格式类型数据文件读取方法写入方法
    textCSVread_csvto_csv
    textJSONread_jsonto_json
    textHTMLread_htmlto_html
    textLocal clipboardread_clipboardto_clipboard
    binaryMS Excelread_excelto_excel
    binaryHDF5 Formatread_hdfto_hdf
    binaryFeather Formatread_featherto_feather
    binaryParquet Formatread_parquetto_parquet
    binaryMsgpackread_msgpackto_msgpack
    binaryStataread_statato_stata
    binarySASread_sas-
    binaryPython Pickle Formatread_pickleto_pickle
    SQLSQLread_sqlto_sql
    SQLGoogle Big Queryread_gbqto_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)) 

    1.            日期    开盘    最高    最低    收盘       成交量          成交额
    2. 0  2000/01/04 -0.64 -0.55 -0.67 -0.57   4496000  113946784.0
    3. 1  2000/01/05 -0.57 -0.52 -0.62 -0.61   5252800  134465424.0
    4. 2  2000/01/06 -0.62 -0.49 -0.63 -0.52   6229600  160059792.0
    5. 3  2000/01/07 -0.49 -0.35 -0.51 -0.42  21355300  575751104.0
    6. 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)) 

    1.            日期    开盘    最高    最低    收盘       成交量          成交额
    2. 0  2000/01/04 -0.64 -0.55 -0.67 -0.57   4496000  113946784.0
    3. 1  2000/01/05 -0.57 -0.52 -0.62 -0.61   5252800  134465424.0
    4. 2  2000/01/06 -0.62 -0.49 -0.63 -0.52   6229600  160059792.0
    5. 3  2000/01/07 -0.49 -0.35 -0.51 -0.42  21355300  575751104.0
    6. 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)) 

    1.             0     1     2     3     4         5            6
    2. 0  2000/01/04 -0.64 -0.55 -0.67 -0.57   4496000  113946784.0
    3. 1  2000/01/05 -0.57 -0.52 -0.62 -0.61   5252800  134465424.0
    4. 2  2000/01/06 -0.62 -0.49 -0.63 -0.52   6229600  160059792.0
    5. 3  2000/01/07 -0.49 -0.35 -0.51 -0.42  21355300  575751104.0
    6. 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) 

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

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

    1.           日期    开盘    最高    最低    收盘       成交量        成交额  股票代码
    2. 0   2000/1/4 -0.64 -0.55 -0.67 -0.57   4496000  113946784  2015
    3. 1   2000/1/5 -0.57 -0.52 -0.62 -0.61   5252800  134465424  2015
    4. 2   2000/1/6 -0.62 -0.49 -0.63 -0.52   6229600  160059792  2015
    5. 3   2000/1/7 -0.49 -0.35 -0.51 -0.42  21355300  575751104  2015
    6. 4  2000/1/10 -0.41 -0.31 -0.44 -0.38  16539700  450453504  2015
    7. 日期       object
    8. 开盘      float64
    9. 最高      float64
    10. 最低      float64
    11. 收盘      float64
    12. 成交量       int64
    13. 成交额       int64
    14. 股票代码      int64
    15. 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) 

    1.           日期     开盘     最高     最低     收盘       成交量        成交额    股票代码
    2. 0   2000/1/4  -0.64  -0.55  -0.67  -0.57   4496000  113946784  002015
    3. 1   2000/1/5  -0.57  -0.52  -0.62  -0.61   5252800  134465424  002015
    4. 2   2000/1/6  -0.62  -0.49  -0.63  -0.52   6229600  160059792  002015
    5. 3   2000/1/7  -0.49  -0.35  -0.51  -0.42  21355300  575751104  002015
    6. 4  2000/1/10  -0.41  -0.31  -0.44  -0.38  16539700  450453504  002015
    7. 日期      object
    8. 开盘      object
    9. 最高      object
    10. 最低      object
    11. 收盘      object
    12. 成交量     object
    13. 成交额     object
    14. 股票代码    object
    15. 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) 

    1.           日期    开盘    最高    最低    收盘       成交量          成交额    股票代码
    2. 0   2000/1/4 -0.64 -0.55 -0.67 -0.57   4496000  113946784.0  002015
    3. 1   2000/1/5 -0.57 -0.52 -0.62 -0.61   5252800  134465424.0  002015
    4. 2   2000/1/6 -0.62 -0.49 -0.63 -0.52   6229600  160059792.0  002015
    5. 3   2000/1/7 -0.49 -0.35 -0.51 -0.42  21355300  575751104.0  002015
    6. 4  2000/1/10 -0.41 -0.31 -0.44 -0.38  16539700  450453504.0  002015
    7. 日期       object
    8. 开盘      float64
    9. 最高      float64
    10. 最低      float64
    11. 收盘      float64
    12. 成交量       int64
    13. 成交额     float64
    14. 股票代码     object
    15. 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) 

    1.           日期    开盘    最高    最低    收盘       成交量          成交额    股票代码
    2. 0 2000-01-04 -0.64 -0.55 -0.67 -0.57   4496000  113946784.0  002015
    3. 1 2000-01-05 -0.57 -0.52 -0.62 -0.61   5252800  134465424.0  002015
    4. 2 2000-01-06 -0.62 -0.49 -0.63 -0.52   6229600  160059792.0  002015
    5. 3 2000-01-07 -0.49 -0.35 -0.51 -0.42  21355300  575751104.0  002015
    6. 4 2000-01-10 -0.41 -0.31 -0.44 -0.38  16539700  450453504.0  002015
    7. 日期      datetime64[ns]
    8. 开盘             float64
    9. 最高             float64
    10. 最低             float64
    11. 收盘             float64
    12. 成交量              int64
    13. 成交额            float64
    14. 股票代码            object
    15. 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)) 

    1.           日期    开盘    最高    最低    收盘       成交量        成交额
    2. 0 2000-01-04 -0.64 -0.55 -0.67 -0.57   4496000  113946784
    3. 1 2000-01-05 -0.57 -0.52 -0.62 -0.61   5252800  134465424
    4. 2 2000-01-06 -0.62 -0.49 -0.63 -0.52   6229600  160059792
    5. 3 2000-01-07 -0.49 -0.35 -0.51 -0.42  21355300  575751104
    6. 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)) 

    1.           日期    开盘    最高    最低    收盘       成交量        成交额
    2. 0 2000-01-04 -0.64 -0.55 -0.67 -0.57   4496000  113946784
    3. 1 2000-01-05 -0.57 -0.52 -0.62 -0.61   5252800  134465424
    4. 2 2000-01-06 -0.62 -0.49 -0.63 -0.52   6229600  160059792
    5. 3 2000-01-07 -0.49 -0.35 -0.51 -0.42  21355300  575751104
    6. 4 2000-01-10 -0.41 -0.31 -0.44 -0.38  16539700  450453504
    7.           日期    开盘    最高    最低    收盘        成交量           成交额
    8. 0 2003-04-28  1.52  2.12  1.50  2.11  187469932  1.512258e+09
    9. 1 2003-04-29  1.97  2.09  1.84  1.96   75212876  6.358634e+08
    10. 2 2003-04-30  2.00  2.32  2.00  2.18   80122500  7.100635e+08
    11. 3 2003-05-12  2.08  2.18  1.85  2.07   36122300  3.088063e+08
    12. 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)) 

    1.            0     1     2     3     4         5          6
    2. 0 2000-01-04 -0.64 -0.55 -0.67 -0.57   4496000  113946784
    3. 1 2000-01-05 -0.57 -0.52 -0.62 -0.61   5252800  134465424
    4. 2 2000-01-06 -0.62 -0.49 -0.63 -0.52   6229600  160059792
    5. 3 2000-01-07 -0.49 -0.35 -0.51 -0.42  21355300  575751104
    6. 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)) 

    1.           日期    开盘    最高    最低    收盘       成交量        成交额
    2. 0 2000-01-04 -0.64 -0.55 -0.67 -0.57   4496000  113946784
    3. 1 2000-01-05 -0.57 -0.52 -0.62 -0.61   5252800  134465424
    4. 2 2000-01-06 -0.62 -0.49 -0.63 -0.52   6229600  160059792
    5. 3 2000-01-07 -0.49 -0.35 -0.51 -0.42  21355300  575751104
    6. 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)) 

    1.           日期    开盘    最高    最低    收盘      成交量        成交额
    2. 0 2000-01-04 -0.64 -0.55 -0.67 -0.57  4496000  113946784
    3. 1 2000-01-05 -0.57 -0.52 -0.62 -0.61  5252800  134465424
    4. 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) 

    1.    a  b
    2. 1  1  3
    3. 2  2  8
    4. 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) 

    1.    a  b
    2. 0  1  3
    3. 1  2  6
    4. 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) 

    1.    a   b
    2. 0  1   2
    3. 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) 

    1.    a   b
    2. 0  1   2
    3. 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) 

    1.    0  1
    2. 0  a  1
    3. 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) 

    1.    mac           timestamp  volt  temp  \
    2. 0    1 2011-06-06 18:53:57   2.5  35.5   
    3. 1    2 2011-06-06 18:53:57   2.5  35.5   
    4.  
    5.                                                  acc  sampletime  
    6. 0  [[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3], [...  1307386437  
    7. 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) 

    1.   StockId StockName  TradeDate  OpenPrice  HighPrice  LowPrice  ClosePrice  \
    2. 0  600000      浦发银行 2000-01-04      -0.64      -0.55     -0.67       -0.57   
    3. 1  600000      浦发银行 2000-01-05      -0.57      -0.52     -0.62       -0.61   
    4. 2  600000      浦发银行 2000-01-06      -0.62      -0.49     -0.63       -0.52   
    5. 3  600000      浦发银行 2000-01-07      -0.49      -0.35     -0.51       -0.42   
    6. 4  600000      浦发银行 2000-01-10      -0.41      -0.31     -0.44       -0.38   
    7.  
    8.      Volume        Money  id  
    9. 0   4496000  113946784.0   1  
    10. 1   5252800  134465424.0   2  
    11. 2   6229600  160059792.0   3  
    12. 3  21355300  575751104.0   4  
    13. 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 描述性统计

    描述性统计常用函数

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

    ##导入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列的统计信息的摘要。 

    1.      开盘    最高    最低    收盘       成交量        成交额
    2. 0 -0.64 -0.55 -0.67 -0.57   4496000  113946784
    3. 1 -0.57 -0.52 -0.62 -0.61   5252800  134465424
    4. 2 -0.62 -0.49 -0.63 -0.52   6229600  160059792
    5. 3 -0.49 -0.35 -0.51 -0.42  21355300  575751104
    6. 4 -0.41 -0.31 -0.44 -0.38  16539700  450453504
    7. 5 -0.38 -0.37 -0.51 -0.50   9390700  251055904
    8. 6 -0.52 -0.52 -0.66 -0.63  35274900  889867328
    9. 7 -0.64 -0.61 -0.66 -0.65   7975600  199244304
    10. 8 -0.65 -0.64 -0.77 -0.73  17861800  434206080
    11. 9 -0.75 -0.70 -0.78 -0.71   8101500  194776960
    12. 开盘     10
    13. 最高     10
    14. 最低     10
    15. 收盘     10
    16. 成交量    10
    17. 成交额    10
    18. dtype: int64
    19. 开盘    -5.670000e+00
    20. 最高    -5.060000e+00
    21. 最低    -6.250000e+00
    22. 收盘    -5.720000e+00
    23. 成交量    1.324779e+08
    24. 成交额    3.403827e+09
    25. dtype: float64
    26. 开盘    -5.670000e-01
    27. 最高    -5.060000e-01
    28. 最低    -6.250000e-01
    29. 收盘    -5.720000e-01
    30. 成交量    1.324779e+07
    31. 成交额    3.403827e+08
    32. dtype: float64
    33. 开盘    -5.950000e-01
    34. 最高    -5.200000e-01
    35. 最低    -6.450000e-01
    36. 收盘    -5.900000e-01
    37. 成交量    8.746100e+06
    38. 成交额    2.251501e+08
    39. dtype: float64
    40.      开盘    最高    最低    收盘       成交量        成交额
    41. 0 -0.64 -0.52 -0.66 -0.73   4496000  113946784
    42. 1   NaN   NaN -0.51 -0.71   5252800  134465424
    43. 2   NaN   NaN   NaN -0.65   6229600  160059792
    44. 3   NaN   NaN   NaN -0.63   7975600  194776960
    45. 4   NaN   NaN   NaN -0.61   8101500  199244304
    46. 5   NaN   NaN   NaN -0.57   9390700  251055904
    47. 6   NaN   NaN   NaN -0.52  16539700  434206080
    48. 7   NaN   NaN   NaN -0.50  17861800  450453504
    49. 8   NaN   NaN   NaN -0.42  21355300  575751104
    50. 9   NaN   NaN   NaN -0.38  35274900  889867328
    51. 开盘     1.162421e-01
    52. 最高     1.292027e-01
    53. 最低     1.106797e-01
    54. 收盘     1.167904e-01
    55. 成交量    9.672281e+06
    56. 成交额    2.480013e+08
    57. dtype: float64
    58. 开盘    -7.500000e-01
    59. 最高    -7.000000e-01
    60. 最低    -7.800000e-01
    61. 收盘    -7.300000e-01
    62. 成交量    4.496000e+06
    63. 成交额    1.139468e+08
    64. dtype: float64
    65. 开盘    -3.800000e-01
    66. 最高    -3.100000e-01
    67. 最低    -4.400000e-01
    68. 收盘    -3.800000e-01
    69. 成交量    3.527490e+07
    70. 成交额    8.898673e+08
    71. dtype: float64
    72.      开盘    最高    最低    收盘         成交量          成交额
    73. 0  0.64  0.55  0.67  0.57   4496000.0  113946784.0
    74. 1  0.57  0.52  0.62  0.61   5252800.0  134465424.0
    75. 2  0.62  0.49  0.63  0.52   6229600.0  160059792.0
    76. 3  0.49  0.35  0.51  0.42  21355300.0  575751104.0
    77. 4  0.41  0.31  0.44  0.38  16539700.0  450453504.0
    78. 5  0.38  0.37  0.51  0.50   9390700.0  251055904.0
    79. 6  0.52  0.52  0.66  0.63  35274900.0  889867328.0
    80. 7  0.64  0.61  0.66  0.65   7975600.0  199244304.0
    81. 8  0.65  0.64  0.77  0.73  17861800.0  434206080.0
    82. 9  0.75  0.70  0.78  0.71   8101500.0  194776960.0
    83. 开盘     2.801354e-03
    84. 最高     7.994748e-04
    85. 最低     7.835618e-03
    86. 收盘     3.062288e-03
    87. 成交量    1.986682e+70
    88. 成交额    2.394389e+84
    89. dtype: float64
    90.      开盘    最高    最低    收盘        成交量         成交额
    91. 0 -0.64 -0.55 -0.67 -0.57    4496000   113946784
    92. 1 -1.21 -1.07 -1.29 -1.18    9748800   248412208
    93. 2 -1.83 -1.56 -1.92 -1.70   15978400   408472000
    94. 3 -2.32 -1.91 -2.43 -2.12   37333700   984223104
    95. 4 -2.73 -2.22 -2.87 -2.50   53873400  1434676608
    96. 5 -3.11 -2.59 -3.38 -3.00   63264100  1685732512
    97. 6 -3.63 -3.11 -4.04 -3.63   98539000  2575599840
    98. 7 -4.27 -3.72 -4.70 -4.28  106514600  2774844144
    99. 8 -4.92 -4.36 -5.47 -5.01  124376400  3209050224
    100. 9 -5.67 -5.06 -6.25 -5.72  132477900  3403827184
    101.          开盘        最高        最低        收盘                  成交量  \
    102. 0 -0.640000 -0.550000 -0.670000 -0.570000              4496000   
    103. 1  0.364800  0.286000  0.415400  0.347700       23616588800000   
    104. 2 -0.226176 -0.140140 -0.261702 -0.180804  -452051001196412928   
    105. 3  0.110826  0.049049  0.133468  0.075938 -5509987558482771968   
    106. 4 -0.045439 -0.015205 -0.058726 -0.028856 -3115789856807059456   
    107. 5  0.017267  0.005626  0.029950  0.014428  2878148941738672128   
    108. 6 -0.008979 -0.002925 -0.019767 -0.009090   835305951065014272   
    109. 7  0.005746  0.001785  0.013046  0.005908  6074349849552093184   
    110. 8 -0.003735 -0.001142 -0.010046 -0.004313 -1218162324121059328   
    111. 9  0.002801  0.000799  0.007836  0.003062 -7776408446869438464   
    112.  
    113.                    成交额  
    114. 0            113946784  
    115. 1    15321902623996416  
    116. 2  -290582269495435264  
    117. 3 -3493664344764841984  
    118. 4  6883605009410293760  
    119. 5  -218899433511714816  
    120. 6  2206068926062788608  
    121. 7 -7302446058292903936  
    122. 8 -2972375754064527360  
    123. 9 -6917529027641081856  
    124.               开盘         最高        最低        收盘           成交量           成交额
    125. count  10.000000  10.000000  10.00000  10.00000  1.000000e+01  1.000000e+01
    126. mean   -0.567000  -0.506000  -0.62500  -0.57200  1.324779e+07  3.403827e+08
    127. std     0.116242   0.129203   0.11068   0.11679  9.672281e+06  2.480013e+08
    128. min    -0.750000  -0.700000  -0.78000  -0.73000  4.496000e+06  1.139468e+08
    129. 25%    -0.640000  -0.595000  -0.66750  -0.64500  6.666100e+06  1.687391e+08
    130. 50%    -0.595000  -0.520000  -0.64500  -0.59000  8.746100e+06  2.251501e+08
    131. 75%    -0.497500  -0.400000  -0.53750  -0.50500  1.753128e+07  4.463916e+08
    132. 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) 

    1.          开盘     最高     最低     收盘
    2. 0     -0.64  -0.55  -0.67  -0.57
    3. 1     -0.57  -0.52  -0.62  -0.61
    4. 2     -0.62  -0.49  -0.63  -0.52
    5. 3     -0.49  -0.35  -0.51  -0.42
    6. 4     -0.41  -0.31  -0.44  -0.38
    7. ...     ...    ...    ...    ...
    8. 5005  10.72  10.82  10.54  10.54
    9. 5006  10.59  10.64  10.50  10.58
    10. 5007  10.61  10.70  10.36  10.47
    11. 5008  10.45  10.92  10.43  10.92
    12. 5009  10.80  10.92  10.76  10.88
    13.  
    14. [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) 

    1.           日期    开盘    最高    最低    收盘       成交量        成交额
    2. 0 2000-01-04 -0.64 -0.55 -0.67 -0.57   4496000  113946784
    3. 1 2000-01-05 -0.57 -0.52 -0.62 -0.61   5252800  134465424
    4. 2 2000-01-06 -0.62 -0.49 -0.63 -0.52   6229600  160059792
    5. 3 2000-01-07 -0.49 -0.35 -0.51 -0.42  21355300  575751104
    6. 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) 

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

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

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

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

    1.   key  value
    2. 0   A      1
    3. 1   B      2
    4. 2   C      3
    5. 3   D      4
    6. 0   B      2
    7. 1   C      3
    8. 2   D      4
    9. 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) 

    1.   key  value_x  value_y
    2. 0   B        2        2
    3. 1   C        3        3
    4. 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)) 

    1.           日期    开盘    最高    最低    收盘       成交量          成交额
    2. 0 2000-01-04 -0.64 -0.55 -0.67 -0.57   4496000  113946784.0
    3. 1 2000-01-05 -0.57 -0.52 -0.62 -0.61   5252800  134465424.0
    4. 2 2000-01-06 -0.62 -0.49 -0.63 -0.52   6229600  160059792.0
    5. 3 2000-01-07 -0.49 -0.35 -0.51 -0.42  21355300  575751104.0
    6. 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()

    9b16d7cde579716bf7380a6d433db41d.png

    绘制条形图

     

    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()

    ​ 

    928c92b0311485adfe20c36c4354401b.png

    绘制直方图

     

    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) ##设置柱子数量

    faa3cb8aa647fe0ef1d8f51ac23d7212.png

    绘制散点图形

     

    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='收盘')

    afea03500efbdce594acdc064537e084.png

    开始实验

    第5节 附录

     

     

  • 相关阅读:
    ubuntu给终端加代理服务器
    [Linux 基础] linux基础指令（1）
    第一个ARM程序裸板点灯
    隧道代理-
    针对pycharm中keras问题，求解答
    目标检测 YOLOv5 - 模型的输出
    点灯科技实现 “ESP8266-01/01s + 继电器” 远程开关
    条件随机场与概率无向图因子分解参数化形式（一）
    LeakCanary 源码详解（3）
    01-http协议概述
  • 原文地址：https://blog.csdn.net/a1234556667/article/details/126447445