核心数据结构

pandas最核心的就是Series和DataFrame两个数据结构。

名称 维度 说明
Series 1维 带有标签的同构类型数组
DataFrame 2维 表格结构，带有标签，大小可变，且可以包含异构的数据列

DataFrame可以看做是Series的容器，即：一个DataFrame中可以包含若干个Series。

series

由于Series是一堆结构的数据，我们可以直接通过数组来创建这种数据，像这样：

import pandas as pd

import numpy as np

series1 = pd.Series([1, 2, 3, 4])

print("series1:\n{}\n".format(series1))

# series1:

# 0    1

# 1    2

# 2    3

# 3    4

# dtype: int64
  • 输出的最后一行是Series中数据的类型，这里的数据都是int64类型的。
  • 数据在第二列输出，第一列是数据的索引

我们分别打印出Series中的数据和索引

print("series1.values: {}\n".format(series1.values))

print("series1.index: {}\n".format(series1.index))

# series1.values: [1 2 3 4]

# series1.index: RangeIndex(start=0, stop=4, step=1)

我们可以指定索引的类型，例如字符串

series2 = pd.Series([1, 2, 3, 4, 5, 6, 7],

index=["C", "D", "E", "F", "G", "A", "B"])

print("series2:\n{}\n".format(series2))

print("E is {}\n".format(series2["E"]))

# series2:

# C    1

# D    2

# E    3

# F    4

# G    5

# A    6

# B    7

# dtype: int64

# E is 3

DataFrame

通过Numpy接口来创建一个4x4的矩阵，以此来创建DataFrame

 import pandas as pd

 import numpy as np

 df1 = pd.DataFrame(np.arange(16).reshape(4,4))

 print("df1:\n{}\n".format(df1))

 # df1:

 #     0   1   2   3

 # 0   0   1   2   3

 # 1   4   5   6   7

 # 2   8   9  10  11

 # 3  12  13  14  15

默认的索引和列名都是[0,N-1]的形式，同样我们可以指定列名和索引，

 import pandas as pd

 import numpy as np

 df2 = pd.DataFrame(np.arange(16).reshape(4,4),

 columns=["column1", "column2", "column3", "column4"],

 index=["a", "b", "c", "d"])

 print("df2:\n{}\n".format(df2))

 # df2:

 #    column1  column2  column3  column4

 # a        0        1        2        3

 # b        4        5        6        7

 # c        8        9       10       11

 # d       12       13       14       15

我们也可以指定结构来创建DataFrame

 import pandas as pd

 import numpy as np

 df3 = pd.DataFrame({"note" : ["C", "D", "E", "F", "G", "A", "B"],

     "weekday": ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]})

 print("df3:\n{}\n".format(df3))

 # df3:

 #   note weekday

 # 0    C     Mon

 # 1    D     Tue

 # 2    E     Wed

 # 3    F     Thu

 # 4    G     Fri

 # 5    A     Sat

 # 6    B     Sun

注意：

  • DataFrame的不同列可以是不同的数据类型

  • 如果以Series数组来创建DataFrame，每个Series将成为一行，而不是一列

 import pandas as pd

 import numpy as np

 noteSeries = pd.Series(["C", "D", "E", "F", "G", "A", "B"],

     index=[1, 2, 3, 4, 5, 6, 7])

 weekdaySeries = pd.Series(["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"],

     index=[1, 2, 3, 4, 5, 6, 7])

 df4 = pd.DataFrame([noteSeries, weekdaySeries])

 print("df4:\n{}\n".format(df4))

 # df4:

 #      1    2    3    4    5    6    7

 # 0    C    D    E    F    G    A    B

 # 1  Mon  Tue  Wed  Thu  Fri  Sat  Sun

我们还可以“添加”或“删除”列数据

 import pandas as pd

 import numpy as np

 df3 = pd.DataFrame({"note" : ["C", "D", "E", "F", "G", "A", "B"],

                     "weekday": ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]})

 df3["No."] = pd.Series([1, 2, 3, 4, 5, 6, 7])

 print("df3:\n{}\n".format(df3))

 del df3["weekday"]

 print("df3:\n{}\n".format(df3))

 # df3:

 #   note weekday  No.

 # 0    C     Mon    1

 # 1    D     Tue    2

 # 2    E     Wed    3

 # 3    F     Thu    4

 # 4    G     Fri    5

 # 5    A     Sat    6

 # 6    B     Sun    7

 # df3:

 #   note  No.

 # 0    C    1

 # 1    D    2

 # 2    E    3

 # 3    F    4

 # 4    G    5

 # 5    A    6

 # 6    B    7

index对象与数据访问

同样可以通过索引来获取DataFrame的行和列

 print("df3.columns\n{}\n".format(df3.columns))

 print("df3.index\n{}\n".format(df3.index))

 # df3.columns

 # Index(['note', 'No.'], dtype='object')

 # df3.index

 # RangeIndex(start=0, stop=7, step=1)

注意：

  • Index并非集合，因此其中可以包含重复的数据

  • Index对象的值是不可以改变，因此可以通过它安全的访问数据

DataFrane提供了下面两个操作符来访问其中的数据

  • loc：通过行和列的索引来访问数据

  • iloc：通过行和列的下标来访问数据

 print("Note C, D is:\n{}\n".format(df3.loc[[0, 1], "note"]))

 print("Note C, D is:\n{}\n".format(df3.iloc[[0, 1], 0]))

 # Note C, D is:

 # 0    C

 # 1    D

 # Name: note, dtype: object

 # Note C, D is:

 # 0    C

 # 1    D

 # Name: note, dtype: object

第一行代码访问了行索引为0和1，列索引为“note”的元素，第二行代码访问了行下标为0和1对于df3来说，行索引和行下标刚好是一样的，所以这里都是0和1，但它们却是不同的含义），列下标为0的元素。

文件操作

读取Excel文件

注：要读取Excel文件，还需要安装另外一个库;xlrd

pip install xlrd

 import pandas as pd

 import numpy as np

 df1 = pd.read_excel("data/test.xlsx")

 print("df1:\n{}\n".format(df1))

 # df1:

 #    C  Mon

 # 0  D  Tue

 # 1  E  Wed

 # 2  F  Thu

 # 3  G  Fri

 # 4  A  Sat

 # 5  B  Sun

读取csv文件

 C,Mon

 D,Tue

 E,Wed

 F,Thu

 G,Fri

 A,Sat

第一个CSV文件内容

 C|Mon

 D|Tue

 E|Wed

 F|Thu

 G|Fri

 A|Sat

第二个CSV文件的内容

读取CSV文件

 import pandas as pd

 import numpy as np

 df2 = pd.read_csv("data/test1.csv")

 print("df2:\n{}\n".format(df2))

 # df3 = pd.read_csv("data/test2.csv", sep="|")

 # print("df3:\n{}\n".format(df3))

我们可以发现，第二个CSV文件并不是通过逗号分隔的，我们通常指定分隔符的方式来读取这个文件。

read_csv支持非常多的参数用来调整读取的参数

参数 说明
path 文件路径
sep或者delimiter 字段分隔符
header 列名的行数，默认是0（第一行）
index_col 列号或名称用作结果中的行索引
names 结果的列名称列表
skiprows 从起始位置跳过的行数
na_values 代替NA的值序列
comment 以行结尾分隔注释的字符
parse_dates 尝试将数据解析为datetime。默认为False
keep_date_col 如果将列连接到解析日期，保留连接的列。默认为False。
converters 列的转换器
dayfirst 当解析可以造成歧义的日期时，以内部形式存储。默认为False
data_parser 用来解析日期的函数
nrows 从文件开始读取的行数
iterator 返回一个TextParser对象，用于读取部分内容
chunksize 指定读取块的大小
skip_footer 文件末尾需要忽略的行数
verbose 输出各种解析输出的信息
encoding 文件编码
squeeze 如果解析的数据只包含一列，则返回一个Series
thousands 千数量的分隔符

详细的read_csv函数说明请参见这里：pandas.read_csv

处理无效值

主要有两种处理方法：直接忽略这些无效值；或者将无效值替换成有效值。

我们先创建一个包含无效值的数据结构。然后通过pandas.isna函数来确认哪些值是无效的：

 import pandas as pd

 import numpy as np

 df = pd.DataFrame([[1.0, np.nan, 3.0, 4.0],

                   [5.0, np.nan, np.nan, 8.0],

                   [9.0, np.nan, np.nan, 12.0],

                   [13.0, np.nan, 15.0, 16.0]])

 print("df:\n{}\n".format(df));

 print("df:\n{}\n".format(pd.isna(df)))

 # df:

 #       0   1     2     3

 # 0   1.0 NaN   3.0   4.0

 # 1   5.0 NaN   NaN   8.0

 # 2   9.0 NaN   NaN  12.0

 # 3  13.0 NaN  15.0  16.0

 # df:

 #        0     1      2      3

 # 0  False  True  False  False

 # 1  False  True   True  False

 # 2  False  True   True  False

 # 3  False  True  False  False

忽略无效值

我们可以通过pandas.DataFrame.dropna函数抛弃无效值

 import pandas as pd

 import numpy as np

 df = pd.DataFrame([[1.0, np.nan, 3.0, 4.0],

                   [5.0, np.nan, np.nan, 8.0],

                   [9.0, np.nan, np.nan, 12.0],

                   [13.0, np.nan, 15.0, 16.0]])

 print("df.dropna():\n{}\n".format(df.dropna()));

 # df.dropna():

 # Empty DataFrame

 # Columns: [0, 1, 2, 3]

 # Index: []

对于原先的结构，当无效值全部被抛弃之后，将不再是一个有效的DataFrame，所以才会是以上结果

我们也可以选择抛弃整列都是无效值的那一列：

 import pandas as pd

 import numpy as np

 df = pd.DataFrame([[1.0, np.nan, 3.0, 4.0],

                   [5.0, np.nan, np.nan, 8.0],

                   [9.0, np.nan, np.nan, 12.0],

                   [13.0, np.nan, 15.0, 16.0]])

 print("df.dropna(axis=1,how='all'):\n{}\n".format(df.dropna(axis=1, how='all')));

 # df.dropna(axis=1, how='all'):

 #       0     2     3

 # 0   1.0   3.0   4.0

 # 1   5.0   NaN   8.0

 # 2   9.0   NaN  12.0

 # 3  13.0  15.0  16.0

注：axis=1表示列的轴。how可以取值’any’或者’all’，默认是前者。

替换无效值

我们也可以通过fillna函数将无效值替换成为有效值

 import pandas as pd

 import numpy as np

 df = pd.DataFrame([[1.0, np.nan, 3.0, 4.0],

                   [5.0, np.nan, np.nan, 8.0],

                   [9.0, np.nan, np.nan, 12.0],

                   [13.0, np.nan, 15.0, 16.0]])

 print("df:\n{}\n".format(df));

 print("df.fillna(1):\n{}\n".format(df.fillna(1)));

 # df:

 #       0   1     2     3

 # 0   1.0 NaN   3.0   4.0

 # 1   5.0 NaN   NaN   8.0

 # 2   9.0 NaN   NaN  12.0

 # 3  13.0 NaN  15.0  16.0

 # df.fillna(1):

 #       0    1     2     3

 # 0   1.0  1.0   3.0   4.0

 # 1   5.0  1.0   1.0   8.0

 # 2   9.0  1.0   1.0  12.0

 # 3  13.0  1.0  15.0  16.0

将无效值全部替换成同样的数据可能意义不大，因此我们可以指定不同的数据来进行填充。为了便于操作，在填充之前，我们可以先通过rename方法修改行和列的名称：

 import pandas as pd

 import numpy as np

 df = pd.DataFrame([[1.0, np.nan, 3.0, 4.0],

                   [5.0, np.nan, np.nan, 8.0],

                   [9.0, np.nan, np.nan, 12.0],

                   [13.0, np.nan, 15.0, 16.0]])

 print("df:\n{}\n".format(df));

 print("df:\n{}\n".format(pd.isna(df)))

 df.rename(index={0: 'index1', 1: 'index2', 2: 'index3', 3: 'index4'},

           columns={0: 'col1', 1: 'col2', 2: 'col3', 3: 'col4'},

           inplace=True);

 df.fillna(value={'col2': 2}, inplace=True)  # 把第2列的空值变成2

 df.fillna(value={'col3': 7}, inplace=True)  # 把第3列的空值变成7

 print("df:\n{}\n".format(df));

 # df:

 #       0   1     2     3

 # 0   1.0 NaN   3.0   4.0

 # 1   5.0 NaN   NaN   8.0

 # 2   9.0 NaN   NaN  12.0

 # 3  13.0 NaN  15.0  16.0

 # df:

 #        0     1      2      3

 # 0  False  True  False  False

 # 1  False  True   True  False

 # 2  False  True   True  False

 # 3  False  True  False  False

 # df:

 #         col1  col2  col3  col4

 # index1   1.0   2.0   3.0   4.0

 # index2   5.0   2.0   7.0   8.0

 # index3   9.0   2.0   7.0  12.0

 # index4  13.0   2.0  15.0  16.0

处理字符串

Series的str字段包含了一系列的函数用来处理字符串。并且，这些函数会自动处理无效值。

 import pandas as pd

 s1 = pd.Series(['', '2 ', ' 3 ', '', '']);

 print("s1.str.rstrip():\n{}\n".format(s1.str.lstrip()))

 print("s1.str.strip():\n{}\n".format(s1.str.strip()))

 print("s1.str.isdigit():\n{}\n".format(s1.str.isdigit()))

 # s1.str.rstrip():

 # 0     1

 # 1    2

 # 2    3

 # 3     4

 # 4     5

 # dtype: object

 # s1.str.strip():

 # 0    1

 # 1    2

 # 2    3

 # 3    4

 # 4    5

 # dtype: object

 # s1.str.isdigit():

 # 0    False

 # 1    False

 # 2    False

 # 3     True

 # 4     True

 # dtype: bool

我们还能对字符串进行大写、小写、以及字符串长度的处理。

 import pandas as pd

 s2 = pd.Series(['Stairway to Heaven', 'Eruption', 'Freebird',

                     'Comfortably Numb', 'All Along the Watchtower'])

 print("s2.str.lower():\n{}\n".format(s2.str.lower()))

 print("s2.str.upper():\n{}\n".format(s2.str.upper()))

 print("s2.str.len():\n{}\n".format(s2.str.len()))

 # s2.str.lower():

 # 0          stairway to heaven

 # 1                    eruption

 # 2                    freebird

 # 3            comfortably numb

 # 4    all along the watchtower

 # dtype: object

 # s2.str.upper():

 # 0          STAIRWAY TO HEAVEN

 # 1                    ERUPTION

 # 2                    FREEBIRD

 # 3            COMFORTABLY NUMB

 # 4    ALL ALONG THE WATCHTOWER

 # dtype: object

 # s2.str.len():

 # 0    18

 # 1     8

 # 2     8

 # 3    16

 # 4    24

 # dtype: int64

参考文献

https://paul.pub/pandas-tutorial/

最新文章

  1. Linux系统中用DNW向ARM开发板下载程序
  2. 转载一篇React native的props的用法
  3. 最小生成树 prime poj1287
  4. Make Notepad++ auto close HTML/XML tags after the slash(the Dreamweaver way)
  5. win7(X64)+VS2013+OpenCV3.1环境配置
  6. 【CodeForces 651B】Beautiful Paintings 排序+贪心
  7. CommandLine 和 Options
  8. 24种设计模式--命令模式【Command Pattern】
  9. Shell上传文件到ftp
  10. 运用 BoxLayout 进行 Swing 控件布局
  11. Java 生成本文文件的时候，Dos格式转成Unix格式
  12. Access denied for user: 'root@localhost' (Using password: YES)
  13. 实时 Django 终于来了 —— Django Channels 入门指南
  14. webpack 图片的打包
  15. Python后台开发Django（ 模板 与 值匹配 ）
  16. [Swift]LeetCode155. 最小栈 | Min Stack
  17. 【原创】canvas裁剪上传图片异步提交
  18. supervisor来自动化部署，集成git
  19. 安装ubuntu18.04.1
  20. HDU 4540 线性DP

热门文章

  1. Android -- 图片处理， 画画板，缩放，旋转，平移，镜面，倒影，图片合成，颜色处理
  2. Docker和k8s的区别与介绍
  3. Struts2基本使用（二）--配置文件简述
  4. memcache+php实现页面访问的加速
  5. 基于spec评论——王者荣耀交流协会的PSP DAILY作品
  6. I.MX6 PWM buzzer driver hacking with Demo test
  7. Linux的发行版之间的联系和区别
  8. Codeforces 1009C： Annoying Present
  9. 《DSP using MATLAB》示例Example 9.9
  10. mongodb启用Profiling定位问题