Python之Pandas使用知识汇总（持续更新）

一、Pandas简介

Pandas是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。Pandas 纳入了大量库和一些标准的数据模型，提供了高效地操作大型数据集所需的工具。pandas提供了大量能使我们快速便捷地处理数据的函数和方法，给Python提供强大而高效的数据分析环境。
Pandas是python的一个数据分析包，最初由AQR Capital Management于2008年4月开发，并于2009年底开源出来，目前由专注于Python数据包开发的PyData开发team继续开发和维护，属于PyData项目的一部分。
Pandas最初被作为金融数据分析工具而开发出来，因此，pandas为时间序列分析提供了很好的支持。
Pandas的名称来自于面板数据（panel data）和python数据分析（data analysis）。panel data是经济学中关于多维数据集的一个术语，在Pandas中也提供了panel的数据类型。

二、环境

Pandas是Python的一个外部资源包，所以其使用需要在Python的使用环境下，有关Python的安装，可以查看这里Python相关安装汇总（持续更新）。

三、使用

3.1 数据结构

3.1.1 Series

Series是Pandas中的一维数据结构，类似于Python中的列表和Numpy中的Ndarray，不同之处在于：Series是一维的，能存储不同类型的数据，有一组索引与元素对应。因为Series可以保存不同的数据类型，使得Pandas在处理表格和混杂类型的数据方面有着广泛的应用。
用例：

import numpy as np
import pandas as pd
from pandas import Series, DataFrame

# Series
obj = Series([4, 7, -5, 3])
print("Series有索引的一维数组\n\robj=\n\r", obj)
print("\n\r1 数组的值\n\robj.values=", obj.values)
print("\n\r2 数组的索引\n\robj.index=", obj.index)

obj2 = Series([4, 7, -5, 3], index=['d', 'b', 'a', 'c'])
print("\n\r3 指定索引的数组\n\robj2=\n\r", obj2)
print("\n\r4 数组的索引\n\robj2.index=", obj2.index)
print("\n\r5 索引a的值\n\robj2['a']=", obj2['a'])

obj2['d'] = 6

print("\n\r6 输出给定的索引值\n\robj2[['c', 'a', 'd']]=\n\r", obj2[['c', 'a', 'd']])
print("\n\r7 数组元素大于0的索引及其值\n\robj2[obj2 > 0]=\n\r", obj2[obj2 > 0])
print("\n\r8 数组元素乘以2\n\robj2 * 2=\n\r", obj2 * 2)
print("\n\r9 数组元素的自然对数\n\rnp.exp(obj2)=\n\r", np.exp(obj2))

print("\n\r10 是否有索引b\n\r'b' in obj2=", 'b' in obj2)
print("\n\r是否有索引e\n\r'e' in obj2=", 'e' in obj2)

sdata = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000}
obj3 = Series(sdata)
print("\n\r11 由索引数组创建series数组\n\robj3=\n\r", obj3)

states = ['California', 'Ohio', 'Oregon', 'Texas']
obj4 = Series(sdata, index=states)
print("\n\r12 更改索引顺序，无索引则丢失数据\n\robj4=\n\r", obj4)

print("\n\r13 元素为空的判断\n\risnull(obj4)=\n\r", pd.isnull(obj4))
print("\n\r元素不为空的判断\n\rnotnull(obj4)=\n\r", pd.notnull(obj4))
print("\n\r元素为空的判断的另一种表达\n\robj4.isnull()=\n\r", obj4.isnull())

print("\n\robj3=\n\r", obj3)
print("\n\robj4=\n\r", obj4)
print("\n\r14 series数组合并，索引相同求和，不同添加\n\robj3 + obj4=\n\r", obj3 + obj4)

obj4.name = 'population'
obj4.index.name = 'state'
print("\n\r15 添加series数组的名称和索引\n\robj4=\n\r", obj4)

obj.index = ['Bob', 'Steve', 'Jeff', 'Ryan']
print("\n\r16 更改索引值\n\robj=\n\r", obj)

结果：

Series有索引的一维数组
obj=
 0    4
1    7
2   -5
3    3
dtype: int64

1 数组的值
obj.values= [ 4  7 -5  3]

2 数组的索引
obj.index= RangeIndex(start=0, stop=4, step=1)

3 指定索引的数组
obj2=
 d    4
b    7
a   -5
c    3
dtype: int64

4 数组的索引
obj2.index= Index(['d', 'b', 'a', 'c'], dtype='object')

5 索引a的值
obj2['a']= -5

6 输出给定的索引值
obj2[['c', 'a', 'd']]=
 c    3
a   -5
d    6
dtype: int64

7 数组元素大于0的索引及其值
obj2[obj2 > 0]=
 d    6
b    7
c    3
dtype: int64

8 数组元素乘以2
obj2 * 2=
 d    12
b    14
a   -10
c     6
dtype: int64

9 数组元素的自然对数
np.exp(obj2)=
 d     403.428793
b    1096.633158
a       0.006738
c      20.085537
dtype: float64

10 是否有索引b
'b' in obj2= True

是否有索引e
'e' in obj2= False

11 由索引数组创建series数组
obj3=
 Ohio      35000
Texas     71000
Oregon    16000
Utah       5000
dtype: int64

12 更改索引顺序，无索引则丢失数据
obj4=
 California        NaN
Ohio          35000.0
Oregon        16000.0
Texas         71000.0
dtype: float64

13 元素为空的判断
isnull(obj4)=
 California     True
Ohio          False
Oregon        False
Texas         False
dtype: bool

元素不为空的判断
notnull(obj4)=
 California    False
Ohio           True
Oregon         True
Texas          True
dtype: bool

元素为空的判断的另一种表达
obj4.isnull()=
 California     True
Ohio          False
Oregon        False
Texas         False
dtype: bool

obj3=
 Ohio      35000
Texas     71000
Oregon    16000
Utah       5000
dtype: int64

obj4=
 California        NaN
Ohio          35000.0
Oregon        16000.0
Texas         71000.0
dtype: float64

14 series数组合并，索引相同求和，不同添加
obj3 + obj4=
 California         NaN
Ohio           70000.0
Oregon         32000.0
Texas         142000.0
Utah               NaN
dtype: float64

15 添加series数组的名称和索引
obj4=
 state
California        NaN
Ohio          35000.0
Oregon        16000.0
Texas         71000.0
Name: population, dtype: float64

16 更改索引值
obj=
 Bob      4
Steve    7
Jeff    -5
Ryan     3
dtype: int64

3.1.2 Dataframe

Dataframe是同时具有行索引和列索引的表格型数据结构

类型	说明
二维ndarray	数据矩阵，还可以传入行标和列标
由数组、列表或元组组成的字典	每个序列会变成DataFrame的一列。所有有序的长度必须相同
NumPy的结构化/记录数组	类似于“由数组组成的字典”
由Series组成的字典	每个Series会成为一列。如果没有显式指定索引，则各Series的索引会被合并成结果的行索引
由字典组成的字典	各内层字典会成为一列。键会被合并成结果的行索引，跟“由Series组成的字典”的情况一样
由列表或元组组成的列表	类似于“二维ndarray”
另一个DataFrame	该DataFrame的索引将会被沿用，除非显式指定了其他索引
NumPy的MaskedArray	类似于“二维ndarray”的情况，只是掩码值在结果DataFrame会变成NA/缺失值

用例：

import numpy as np
from pandas import Series, DataFrame

#dataframe
data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada'],
        'year': [2000, 2001, 2002, 2001, 2002],
        'pop': [1.5, 1.7, 3.6, 2.4, 2.9]}
frame = DataFrame(data)
print("dataframe表格型数组结构\n\rframe=\n\r", frame)

DataFrame(data, columns=['year', 'state', 'pop'])

frame2 = DataFrame(data, columns=['year', 'state', 'pop', 'debt'],
                   index=['one', 'two', 'three', 'four', 'five'])
print("\n\r1 指定行索引index和列索引columns的dataframe数组\n\rframe2=\n\r", frame2)
print("\n\r2 列索引\n\rframe2.columns=", frame2.columns)
print("\n\r3 索引为state的行索引及其值\n\rframe2['state']=\n\r", frame2['state'])
print("\n\r4 索引为year的行索引及其值（第二种表达）\n\rframe2.year=\n\r", frame2.year)
print("\n\r5 行索引为three的列索引及其值\n\rframe2.ix['three']=\n\r", frame2.ix['three'])

frame2['debt'] = 16.5
print("\n\r6 根据列索引插入值\n\rframe2=\n\r", frame2)

frame2['debt'] = np.arange(5.)
print("\n\r7 根据列索引插入元素\n\rframe2=\n\r", frame2)

val = Series([-1.2, -1.5, -1.7], index=['two', 'four', 'five'])
print("\n\rval=\n\r", val)

frame2['debt'] = val
print("\n\r8 根据列索引插入series数组值\n\rframe2=\n\r", frame2)

frame2['eastern'] = frame2.state == 'Ohio'
print("\n\r9 插入列索引作为判断另外一列元素是否满足条件\n\rframe2=\n\r", frame2)

del frame2['eastern']
print("\n\r10 根据列索引删除列，打印列索引名\n\rframe2.columns=\n\r", frame2.columns)

pop = {'Nevada': {2001: 2.4, 2002: 2.9},
       'Ohio': {2000: 1.5, 2001: 1.7, 2002: 3.6}}
frame3 = DataFrame(pop)
print("\n\r12 创建dataframe另一种表达\n\rframe3=\n\r", frame3)
print("\n\r13 dataframe转置\n\rframe3.T=\n\r", frame3.T)

DataFrame(pop, index=[2001, 2002, 2003])
pdata = {'Ohio': frame3['Ohio'][:-1],
         'Nevada': frame3['Nevada'][:2]}
print("\n\r14 根据索引创建dataframe数组\n\rDataFrame(pdata)=\n\r", DataFrame(pdata))

frame3.index.name = 'year'; frame3.columns.name = 'state'
print("\n\r15 dataframe数组添加列名和行名\n\rframe3=\n\r", frame3)
print("\n\r16 只打印dataframe元素\n\rframe3.values=\n\r", frame3.values)
print("\n\r17 只打印dataframe元素\n\rframe2.values=\n\r", frame2.values)

结果：

dataframe表格型数组结构
frame=
     state  year  pop
0    Ohio  2000  1.5
1    Ohio  2001  1.7
2    Ohio  2002  3.6
3  Nevada  2001  2.4
4  Nevada  2002  2.9

1 指定行索引index和列索引columns的dataframe数组
frame2=
       year   state  pop debt
one    2000    Ohio  1.5  NaN
two    2001    Ohio  1.7  NaN
three  2002    Ohio  3.6  NaN
four   2001  Nevada  2.4  NaN
five   2002  Nevada  2.9  NaN

2 列索引
frame2.columns= Index(['year', 'state', 'pop', 'debt'], dtype='object')

3 索引为state的行索引及其值
frame2['state']=
 one        Ohio
two        Ohio
three      Ohio
four     Nevada
five     Nevada
Name: state, dtype: object

4 索引为year的行索引及其值（第二种表达）
frame2.year=
 one      2000
two      2001
three    2002
four     2001
five     2002
Name: year, dtype: int64

5 行索引为three的列索引及其值
frame2.ix['three']=
 year     2002
state    Ohio
pop       3.6
debt      NaN
Name: three, dtype: object

6 根据列索引插入值
frame2=
        year   state  pop  debt
one    2000    Ohio  1.5  16.5
two    2001    Ohio  1.7  16.5
three  2002    Ohio  3.6  16.5
four   2001  Nevada  2.4  16.5
five   2002  Nevada  2.9  16.5

7 根据列索引插入元素
frame2=
        year   state  pop  debt
one    2000    Ohio  1.5   0.0
two    2001    Ohio  1.7   1.0
three  2002    Ohio  3.6   2.0
four   2001  Nevada  2.4   3.0
five   2002  Nevada  2.9   4.0

val=
 two    -1.2
four   -1.5
five   -1.7
dtype: float64

8 根据列索引插入series数组值
frame2=
        year   state  pop  debt
one    2000    Ohio  1.5   NaN
two    2001    Ohio  1.7  -1.2
three  2002    Ohio  3.6   NaN
four   2001  Nevada  2.4  -1.5
five   2002  Nevada  2.9  -1.7

9 插入列索引作为判断另外一列元素是否满足条件
frame2=
        year   state  pop  debt  eastern
one    2000    Ohio  1.5   NaN     True
two    2001    Ohio  1.7  -1.2     True
three  2002    Ohio  3.6   NaN     True
four   2001  Nevada  2.4  -1.5    False
five   2002  Nevada  2.9  -1.7    False

10 根据列索引删除列，打印列索引名
frame2.columns=
 Index(['year', 'state', 'pop', 'debt'], dtype='object')

12 创建dataframe另一种表达
frame3=
       Nevada  Ohio
2001     2.4   1.7
2002     2.9   3.6
2000     NaN   1.5

13 dataframe转置
frame3.T=
         2001  2002  2000
Nevada   2.4   2.9   NaN
Ohio     1.7   3.6   1.5

14 根据索引创建dataframe数组
DataFrame(pdata)=
       Ohio  Nevada
2001   1.7     2.4
2002   3.6     2.9

15 dataframe数组添加列名和行名
frame3=
 state  Nevada  Ohio
year               
2001      2.4   1.7
2002      2.9   3.6
2000      NaN   1.5

16 只打印dataframe元素
frame3.values=
 [[2.4 1.7]
 [2.9 3.6]
 [nan 1.5]]

17 只打印dataframe元素
frame2.values=
 [[2000 'Ohio' 1.5 nan]
 [2001 'Ohio' 1.7 -1.2]
 [2002 'Ohio' 3.6 nan]
 [2001 'Nevada' 2.4 -1.5]
 [2002 'Nevada' 2.9 -1.7]]

3.2 索引对象

类

类	说明
Index	最泛化的Index对象，将轴标签表示为一个由Python对象组成的NumPy数组
Int64Index	针对整数的特殊Index
MultiIndex	"层次化"索引对象，表示单个轴上的多层索引。可以看做由元组组成的数组
DatetimeIndex	存储纳秒级时间戳（用NumPy的datetime64类型表示）
PeriodIndex	针对Period数据（时间间隔）的特殊Index

方法

方法	说明
append	连接另一个Index对象，产生一个新的Index
diff	计算差集，并得到一个Index
intersection	计算交集
union	计算并集
isin	计算一个指示各值是否都包含在参数集合中的布尔型数组
delete	删除索引i处的元素，并得到新的Index
drop	删除传入的值，并得到新的Index
insert	将元素插入到索引i处，并得到新的Index
is_monotonic	当各元素均大于等于前一个元素时，返回True
is_unique	当Index没有重复值时，返回True
unique	计算Index中唯一值的数组

用例：

import numpy as np
from pandas import Series, DataFrame
import pandas as pd

#索引对象
obj = Series(range(3), index=['a', 'b', 'c'])
index = obj.index
print("\n\r索引对象\n\rindex=\n\r", index)
print("\n\r1 指定索引\n\rindex[1:]=\n\r", index[1:])

# index[1] = 'd' # 不允许改变索引

index = pd.Index(np.arange(1, 4))
print("\n\r创建索引\n\rindex=", index)
obj2 = Series([1.5, -2.5, 0], index=pd.Index(np.arange(3)))
print("\n\r2 索引判断\n\robj2.index is index=", obj2.index is index)
print("\n\robj2=\n\r", obj2)

pop = {'Nevada': {2001: 2.4, 2002: 2.9},
       'Ohio': {2000: 1.5, 2001: 1.7, 2002: 3.6}}
frame3 = DataFrame(pop)
print("\n\rframe3=\n\r", frame3)
print("\n\r3 列索引判断\n\r'Ohio' in frame3.columns=", 'Ohio' in frame3.columns)
print("\n\r4 行索引判断\n\r2003 in frame3.index=", 2003 in frame3.index)

结果：

索引对象
index=
 Index(['a', 'b', 'c'], dtype='object')

1 指定索引
index[1:]=
 Index(['b', 'c'], dtype='object')

创建索引
index= Int64Index([1, 2, 3], dtype='int64')

2 索引判断
obj2.index is index= False

obj2=
 0    1.5
1   -2.5
2    0.0
dtype: float64

frame3=
       Nevada  Ohio
2001     2.4   1.7
2002     2.9   3.6
2000     NaN   1.5

3 列索引判断
'Ohio' in frame3.columns= True

4 行索引判断
2003 in frame3.index= False

3.3 读写文本格式数据

3.3.1 读取文本格式数据

一些用于把表格型数据读取为DataF然而对象的函数

函数	说明
read_csv	从文件、URL、文件型对象中加载带分隔符的数据。默认分隔符为逗号
read_table	从文件、URL、文件型对象中加载带分隔符的数据。默认分隔符为制表符（“\t”）
read_fwf	读取定宽列格式数据（也即没有分隔符）
read_clipboard	读取剪贴板中的数据，可以看做read_table的剪贴板版。在将网页转换为表格时有用

函数选项
包括以下几种类型：索引，类型推断和数据转换，日期解析，迭代，不规整数据问题

参数	说明
path	表示文件系统位置、URL、文件型对象的字符串
sep或delimiter	用于对行中各字段进行拆分的字符序列或正则表达式
header	用作列名的行号。默认为0（第一行），如果没有header行就应该设置None
index_col	用作行索引的列编号或列名。可以是单个名称/数字或由多个名称/数字组成的列表（层次化索引）
names	用于结果的列名列表，结合header=None
skiprows	需要忽略的行数（从文件开始处算起），或需要跳过的行号列表（从0开始）
na_values	一组用于替换NA的值
comment	用于将注释信息从行尾拆分出去的字符（一个或多个）
parse_dates	尝试将数据解析为日期，默认为False。如果为True，则尝试解析所有列。此外，还可以指定需要解析的一组列号或列名。如果列表的元素为列表或元组，就会将多个列组合到一起再进行日期解析工作（例如，日期/时间分别位于两个列中）
keep_date_col	如果连接多列解析日期，则保持参与连接的列。默认为False.
converters	由列号/列名跟函数之间的映射关系组成的字典。例如，{‘foo’:f}会对foo列的所有值应用函数f
dayfirst	当解析有歧义的日期时，将其看做国际格式（例如，6/6/2019为June,6,2019）。默认为False
date_parser	用于解析日期的函数
nrows	需要读取的行数（从文件开始处算起）
iterator	返回一个TextParser以便逐块读取文件
chunksize	文件块的大小（用于迭代）
skip_footer	需要忽略的行数（从文件末尾处算起）
verbose	打印各种解析器输出信息，比如“非数值列中确实值得数量”等
encoding	用于Unicode的文本编码格式。例如“utf-8”表示用UTF-8编码的文本
squeeze	如果数据经解析后仅含一列，则返回Series
thousands	千分位分隔符，如“,”或“.”

用例：

import numpy as np
from pandas import Series, DataFrame
import pandas as pd

# 读取文本格式数据
df = pd.read_csv('ex1.csv的路径')
print("1 read_csv的使用\n\rdf=\n\r", df)

print("\n\r2 sep拆分字符序列\n\rex1=\n\r", pd.read_table('ex1.csv的路径', sep=','))
print("\n\r3 header列名行号，None不使用\n\rex2=\n\r", pd.read_csv('ex2.csv的路径', header=None))
print("\n\r4 names列名\n\rex2=\n\r", pd.read_csv('ex2.csv的路径', names=['a', 'b', 'c', 'd', 'message']))

names = ['a', 'b', 'c', 'd', 'message']
print("\n\r5 指定index_col行索引的列编号\n\rex2=\n\r", pd.read_csv('ex2.csv的路径', names=names, index_col='message'))

parsed = pd.read_csv('csv_mindex.csv的路径', index_col=['key1', 'key2'])
print("\n\r同时取多个作为行索引\n\rex2=\n\r", parsed)

list(open('ex3.txt的路径'))
result = pd.read_table('ex3.txt的路径', sep='\s+')
print("\n\r6 打开成列表，读取列表read_table\n\rresult=\n\r", result)
print("\n\r7 skiprows忽略行\n\rex4=\n\r", pd.read_csv('ex4.csv的路径', skiprows=[0, 2, 3]))

result = pd.read_csv('ex5.csv的路径')
print("\n\rresult=\n\r", result)
print("\n\r8 判断\n\risnull(result)=\n\r", pd.isnull(result))

result = pd.read_csv('ex5.csv的路径', na_values=['NULL'])
print("\n\r9 na_values替换na的值\n\rex2=\n\r", result)

sentinels = {'message': ['foo', 'NA'], 'something': ['two']}
print("\n\r10 索引替换值为NaN\n\rex2=\n\r", pd.read_csv('ex5.csv的路径', na_values=sentinels))

结果：

1 read_csv的使用
df=
    a   b   c   d message
0  1   2   3   4   hello
1  5   6   7   8   world
2  9  10  11  12     foo

2 sep拆分字符序列
ex1=
    a   b   c   d message
0  1   2   3   4   hello
1  5   6   7   8   world
2  9  10  11  12     foo

3 header列名行号，None不使用
ex2=
    0   1   2   3      4
0  1   2   3   4  hello
1  5   6   7   8  world
2  9  10  11  12    foo

4 names列名
ex2=
    a   b   c   d message
0  1   2   3   4   hello
1  5   6   7   8   world
2  9  10  11  12     foo

5 指定index_col行索引的列编号
ex2=
          a   b   c   d
message               
hello    1   2   3   4
world    5   6   7   8
foo      9  10  11  12

同时取多个作为行索引
ex2=
            value1  value2
key1 key2                
one  a          1       2
     b          3       4
     c          5       6
     d          7       8
two  a          9      10
     b         11      12
     c         13      14
     d         15      16

6 打开成列表，读取列表read_table
result=
             A         B         C
aaa -0.264438 -1.026059 -0.619500
bbb  0.927272  0.302904 -0.032399
ccc -0.264273 -0.386314 -0.217601
ddd -0.871858 -0.348382  1.100491

7 skiprows忽略行
ex4=
    a   b   c   d message
0  1   2   3   4   hello
1  5   6   7   8   world
2  9  10  11  12     foo

result=
   something  a   b     c   d message
0       one  1   2   3.0   4     NaN
1       two  5   6   NaN   8   world
2     three  9  10  11.0  12     foo

8 判断
isnull(result)=
    something      a      b      c      d  message
0      False  False  False  False  False     True
1      False  False  False   True  False    False
2      False  False  False  False  False    False

9 na_values替换na的值
ex2=
   something  a   b     c   d message
0       one  1   2   3.0   4     NaN
1       two  5   6   NaN   8   world
2     three  9  10  11.0  12     foo

10 索引替换值为NaN
ex2=
   something  a   b     c   d message
0       one  1   2   3.0   4     NaN
1       NaN  5   6   NaN   8   world
2     three  9  10  11.0  12     NaN

3.3.2 逐块读取文本文件

• 只读取几行-nrows
• 逐块读取文件-chunksize
  用例：

from pandas import Series
import pandas as pd

#逐行读取文本文件
result = pd.read_csv('ex6.csv的路径')
print("\n\r1 read_csv的使用\n\rresult=\n\r", result)
print("\n\r2 指定读取行nrows\n\rresult=\n\r", pd.read_csv('ex6.csv的路径', nrows=5))
chunker = pd.read_csv('ex6.csv的路径', chunksize=1000)
print("\n\r3 chunksize逐块读取\n\rchunker=\n\r", chunker)

tot = Series([])
for piece in chunker:
    tot = tot.add(piece['key'].value_counts(), fill_value=0)

tot = tot.sort_values(ascending=False)
print("\n\r4 逐行索引读取\n\rresult=\n\r", tot)
print("\n\r选择输出\n\rresult=\n\r", tot[:10])

结果：

1 read_csv的使用
result=
            one       two     three      four key
0     0.467976 -0.038649 -0.295344 -1.824726   L
1    -0.358893  1.404453  0.704965 -0.200638   B
2    -0.501840  0.659254 -0.421691 -0.057688   G
3     0.204886  1.074134  1.388361 -0.982404   R
4     0.354628 -0.133116  0.283763 -0.837063   Q
...        ...       ...       ...       ...  ..
9995  2.311896 -0.417070 -1.409599 -0.515821   L
9996 -0.479893 -0.650419  0.745152 -0.646038   E
9997  0.523331  0.787112  0.486066  1.093156   K
9998 -0.362559  0.598894 -1.843201  0.887292   G
9999 -0.096376 -1.012999 -0.657431 -0.573315   0

[10000 rows x 5 columns]

2 指定读取行nrows
result=
         one       two     three      four key
0  0.467976 -0.038649 -0.295344 -1.824726   L
1 -0.358893  1.404453  0.704965 -0.200638   B
2 -0.501840  0.659254 -0.421691 -0.057688   G
3  0.204886  1.074134  1.388361 -0.982404   R
4  0.354628 -0.133116  0.283763 -0.837063   Q

3 chunksize逐块读取
chunker=
 <pandas.io.parsers.TextFileReader object at 0x000000000BAF7BC8>

4 逐行索引读取
result=
 E    368.0
X    364.0
L    346.0
O    343.0
Q    340.0
M    338.0
J    337.0
F    335.0
K    334.0
H    330.0
V    328.0
I    327.0
U    326.0
P    324.0
D    320.0
A    320.0
R    318.0
Y    314.0
G    308.0
S    308.0
N    306.0
W    305.0
T    304.0
B    302.0
Z    288.0
C    286.0
4    171.0
6    166.0
7    164.0
8    162.0
3    162.0
5    157.0
2    152.0
0    151.0
9    150.0
1    146.0
dtype: float64

选择输出
result=
 E    368.0
X    364.0
L    346.0
O    343.0
Q    340.0
M    338.0
J    337.0
F    335.0
K    334.0
H    330.0
dtype: float64

3.3.3 数据写出

DataFrame的to_csv方法
用例：

import numpy as np
from pandas import Series
import pandas as pd
import sys

#文件写出
data = pd.read_csv('ex5.csv的地址')
print("文件写出\n\rdata=\n\r", data)
data.to_csv('out.csv保存地址')
print("\n\r1 指定分隔符")
data.to_csv(sys.stdout, sep='|')
print("\n\r2 不替换分隔符")
data.to_csv(sys.stdout, na_rep='NULL')
print("\n\r3 不展示列名和行名")
data.to_csv(sys.stdout, index=False, header=False)
print("\n\r4 不使用行索引，使用列索引")
data.to_csv(sys.stdout, index=False, columns=['a', 'b', 'c'])

dates = pd.date_range('1/1/2000', periods=7)
ts = Series(np.arange(7), index=dates)
print("\n\rdates=\n\r", dates)
print("\n\rts=\n\r", ts)
ts.to_csv('tseries.csv保存地址')

# Series.from_csv('tseries.csv', parse_dates=True)
print("\n\r5 尝试将字符转化为日期")
print(pd.read_csv('tseries.csvd的地址', parse_dates=True))

结果：

文件写出
data=
   something  a   b     c   d message
0       one  1   2   3.0   4     NaN
1       two  5   6   NaN   8   world
2     three  9  10  11.0  12     foo

1 指定分隔符
|something|a|b|c|d|message
0|one|1|2|3.0|4|
1|two|5|6||8|world
2|three|9|10|11.0|12|foo

2 不替换分隔符
,something,a,b,c,d,message
0,one,1,2,3.0,4,NULL
1,two,5,6,NULL,8,world
2,three,9,10,11.0,12,foo

3 不展示列名和行名
one,1,2,3.0,4,
two,5,6,,8,world
three,9,10,11.0,12,foo

4 不使用行索引，使用列索引
a,b,c
1,2,3.0
5,6,
9,10,11.0

dates=
 DatetimeIndex(['2000-01-01', '2000-01-02', '2000-01-03', '2000-01-04',
               '2000-01-05', '2000-01-06', '2000-01-07'],
              dtype='datetime64[ns]', freq='D')

ts=
 2000-01-01    0
2000-01-02    1
2000-01-03    2
2000-01-04    3
2000-01-05    4
2000-01-06    5
2000-01-07    6
Freq: D, dtype: int32

5 尝试将字符转化为日期
   2000-01-01  0
0  2000-01-02  1
1  2000-01-03  2
2  2000-01-04  3
3  2000-01-05  4
4  2000-01-06  5
5  2000-01-07  6

3.3.4 手工处理分隔符格式

参数	说明
delimiter	用于分隔字段的单字符字符串。默认为“，”
lineterminator	用于写操作的行结束符，默认为“\n\r”。读操作将忽略此选项，它能认出跨平台的行结束符
quotechar	用于带有特殊字符（如分隔符）的字段的引用符号。默认为“ " ”
quoting	引用约定。可选值包括csv.QUOTE_ALL（引用所有字段）、csv.QUOTE_MINIMAL（引用带有诸如分隔符之类特殊字符的字段）、csv.QUOTE_NONNUMERIC以及csv.QUOTE_NON（不引用）。默认为QUOTE_MINIMAL
skipinitialspace	忽略分隔符后面的空白符。默认为False
doublequote	如何处理字段内的引用符号。如果未Ture，则双写。
escapechar	用于对分隔符进行转义的字符串（如果quoting被设置为csv.QUOTE_NONE的话）。默认禁用

用例：

import pandas as pd
import csv

#手工处理分隔符格式
f = open('ex7.csv的地址')
reader = csv.reader(f)
print("\n\r直接读取\n\rreader=", reader)

print("\n\r逐行打印reader")
for line in reader:
    print("\n\r", line)

lines = list(csv.reader(open('ex7.csv的地址')))
print("\n\r数组方式打印\n\rlines=", lines)

header, values = lines[0], lines[1:]
print("\n\rheader=", header)
print("\n\rvalues=", values)
data_dict = {h: v for h, v in zip(header, zip(*values))}
print("\n\r字典\n\rdata_dict=", data_dict)

class my_dialect(csv.Dialect):
    lineterminator = '\n'
    delimiter = ';'
    quotechar = '"'
    quoting = csv.QUOTE_MINIMAL

with open('mydata.csv', 'w') as f:
    writer = csv.writer(f, dialect=my_dialect)
    writer.writerow(('one', 'two', 'three'))
    writer.writerow(('1', '2', '3'))
    writer.writerow(('4', '5', '6'))
    writer.writerow(('7', '8', '9'))
    
print("\n\r分隔效果\n\r", pd.read_table('mydata.csv', sep=';'))

结果：

直接读取
reader= <_csv.reader object at 0x000000000BAF1AC8>

逐行打印reader

 ['a', 'b', 'c']

 ['1', '2', '3']

 ['1', '2', '3', '4']

数组方式打印
lines= [['a', 'b', 'c'], ['1', '2', '3'], ['1', '2', '3', '4']]

header= ['a', 'b', 'c']

values= [['1', '2', '3'], ['1', '2', '3', '4']]

字典
data_dict= {'a': ('1', '1'), 'b': ('2', '2'), 'c': ('3', '3')}
<_io.TextIOWrapper name='mydata.csv' mode='w' encoding='cp936'>

分隔效果
    one  two  three
0    1    2      3
1    4    5      6
2    7    8      9

3.4 读取Excel文件

• 处理Excel的基本库：xlrd(读取)、xlwt(写入)
• 基本电子表格交互：生成工作簿、从工作簿中读取数据、使用OpenPyxl、使用pandas读写
  用例：

import numpy as np
import pandas as pd
import xlrd, xlwt

#生成xls工作薄
path = '前缀地址'

wb = xlwt.Workbook()
wb.add_sheet('first_sheet', cell_overwrite_ok=True)
print("\n\r1 获取工作簿\n\rwb=", wb.get_active_sheet())

ws_1 = wb.get_sheet(0)
print("\n\r2 由指定索引获取工作簿\n\rws_1=", ws_1)

ws_2 = wb.add_sheet('second_sheet')
print("\n\r3 由专有词获取工作簿\n\rws_2=", ws_2)

data = np.arange(1, 65).reshape((8, 8))
print("\n\rdata=\n\r", data)

ws_1.write(0, 0, 100)

for c in range(data.shape[0]):
    # print(c)
    for r in range(data.shape[1]):
        # print(r)
        # print(data[c, r])
        ws_1.write(r, c, str(data[c, r]))
        ws_2.write(r, c, str(data[r, c]))

wb.save(path + 'workbook.xls')

# 生成xlsx工作薄(2010以后)

# 从工作薄中读取
book = xlrd.open_workbook(path + 'workbook.xls')
print("\n\r从工作薄中读取\n\r1 open_workbook打开工作簿\n\rbook=", book)
print("\n\r2 工作簿名称\n\rsheet_names=", book.sheet_names())

sheet_1 = book.sheet_by_name('first_sheet')
sheet_2 = book.sheet_by_index(1)
print("\n\rsheet_1=", sheet_1)
print("\n\rsheet_2.name=", sheet_2.name)
print("\n\r3 工作簿列数\n\rsheet_1.ncols=", sheet_1.ncols)
print("\n\r4 工作簿行数\n\rsheet_1.nrows=", sheet_1.nrows)

cl = sheet_1.cell(0, 0)
print("\n\r5 指定索引工作簿值\n\rcl.value=", cl.value)
print("\n\r6 数据类型\n\rcl.ctype=", cl.ctype)

print("\n\r7 索引取值\n\rsheet_2.row(3)=", sheet_2.row(3))
print("\n\rsheet_2.col(3)=", sheet_2.col(3))
print("\n\rsheet_1.col_values(3, start_rowx=3, end_rowx=7)=", sheet_1.col_values(3, start_rowx=3, end_rowx=7))
print("\n\rsheet_1.row_values(3, start_colx=3, end_colx=7)=", sheet_1.row_values(3, start_colx=3, end_colx=7))

#使用pandas读取
xls_file=pd.ExcelFile(path + 'workbook.xls')
table=xls_file.parse('first_sheet')
print("\n\r使用pandas读取\n\rExcelFile打开excl\n\rxls_file=", xls_file)
print("\n\rxls解析获取table\n\rtable=\n\r", table)

结果：

1 获取工作簿
wb= 0

2 由指定索引获取工作簿
ws_1= <xlwt.Worksheet.Worksheet object at 0x000000000BC9AC48>

3 由专有词获取工作簿
ws_2= <xlwt.Worksheet.Worksheet object at 0x000000000BC9ACC8>

data=
 [[ 1  2  3  4  5  6  7  8]
 [ 9 10 11 12 13 14 15 16]
 [17 18 19 20 21 22 23 24]
 [25 26 27 28 29 30 31 32]
 [33 34 35 36 37 38 39 40]
 [41 42 43 44 45 46 47 48]
 [49 50 51 52 53 54 55 56]
 [57 58 59 60 61 62 63 64]]

从工作薄中读取
1 open_workbook打开工作簿
book= <xlrd.book.Book object at 0x000000000BCA3388>

2 工作簿名称
sheet_names= ['first_sheet', 'second_sheet']

sheet_1= <xlrd.sheet.Sheet object at 0x000000000BCD1A48>

sheet_2.name= second_sheet

3 工作簿列数
sheet_1.ncols= 8

4 工作簿行数
sheet_1.nrows= 8

5 指定索引工作簿值
cl.value= 1

6 数据类型
cl.ctype= 1

7 索引取值
sheet_2.row(3)= [text:'25', text:'26', text:'27', text:'28', text:'29', text:'30', text:'31', text:'32']

sheet_2.col(3)= [text:'4', text:'12', text:'20', text:'28', text:'36', text:'44', text:'52', text:'60']

sheet_1.col_values(3, start_rowx=3, end_rowx=7)= ['28', '29', '30', '31']

sheet_1.row_values(3, start_colx=3, end_colx=7)= ['28', '36', '44', '52']

使用pandas读取
ExcelFile打开excl
xls_file= <pandas.io.excel._base.ExcelFile object at 0x000000000BCD30C8>

xls解析获取table
table=
    1   9  17  25  33  41  49  57
0  2  10  18  26  34  42  50  58
1  3  11  19  27  35  43  51  59
2  4  12  20  28  36  44  52  60
3  5  13  21  29  37  45  53  61
4  6  14  22  30  38  46  54  62
5  7  15  23  31  39  47  55  63
6  8  16  24  32  40  48  56  64

3.5 数据类型和访问的相关处理

涉及数据类型：JOSON、二进制数据格式、HDF5。
访问形式：web、sql
JOSON（JavaScript Object Notation），是通过HTTP请求在Web浏览器和其他应用程序直接发送数据的标准格式之一。
用例：

from pandas import DataFrame
import pandas as pd
import json

# JSON数据
obj = """
{"name": "Wes",
 "places_lived": ["United States", "Spain", "Germany"],
 "pet": null,
 "siblings": [{"name": "Scott", "age": 25, "pet": "Zuko"},
              {"name": "Katie", "age": 33, "pet": "Cisco"}]
}
"""

result = json.loads(obj)
print("-------------------------------------------------------------------")
print("\n\rJSON数据\n\r1 loads字符串转换字典\n\rresult=", result)
print("\n\rtype(result)=", type(result))

asjson = json.dumps(result)
print("\n\r2 dumps字典转换字符串\n\rasjson=", asjson)
print("\n\rtype(asjson)=", type(asjson))

siblings = DataFrame(result['siblings'], columns=['name', 'age'])
print("\n\r3 取数据输出dataframe\n\rsiblings=\n\r", siblings)
print("\n\rtype(siblings)=", type(siblings))


# 二进制数据格式
# pickle
frame = pd.read_csv('C:/Users/60055144/Desktop/data/ex1.csv')
print("-------------------------------------------------------------------")
print("\n\r二进制数据格式\n\rframe=\n\r", frame)
frame.to_pickle('C:/Users/60055144/Desktop/frame_pickle')

print("\n\r1 read_pickle\n\rwb=", pd.read_pickle('C:/Users/60055144/Desktop/frame_pickle'))

# HDF5格式
# store = pd.HDFStore('mydata.h5')
# store['obj1'] = frame
# store['obj1_col'] = frame['a']
# print("\n\rHDF5格式\n\rHDFStore\n\rstore=", store)
# print("\n\rstore['obj1']=", store['obj1'])
#
# store.close()
# pd.os.remove('mydata.h5')

# 使用HTML和Web API
import requests
url = 'https://api.github.com/repos/pydata/pandas/milestones/28/labels'
resp = requests.get(url)
print("-------------------------------------------------------------------")
print("\n\r使用HTML和Web API\n\rresp=", resp)

data=json.loads(resp.text)
print("\n\rdata=", data)

issue_labels = DataFrame(data)
print("\n\rissue_labels=\n\r", issue_labels)


# 使用数据库
import sqlite3

query = """
CREATE TABLE test
(a VARCHAR(20), b VARCHAR(20),
 c REAL,        d INTEGER
);"""

con = sqlite3.connect(':memory:')
con.execute(query)
con.commit()

data = [('Atlanta', 'Georgia', 1.25, 6),
        ('Tallahassee', 'Florida', 2.6, 3),
        ('Sacramento', 'California', 1.7, 5)]
stmt = "INSERT INTO test VALUES(?, ?, ?, ?)"

con.executemany(stmt, data)
con.commit()

cursor = con.execute('select * from test')
rows = cursor.fetchall()
print("-------------------------------------------------------------------")
print("\n\r使用数据库\n\rrows=", rows)

cursor.description

DataFrame(rows, columns=list(zip(*cursor.description))[0])

import pandas.io.sql as sql
print("\n\rcon=\n\r", sql.read_sql('select * from test', con))

结果：

JSON数据
1 loads字符串转换字典
result= {'name': 'Wes', 'places_lived': ['United States', 'Spain', 'Germany'], 'pet': None, 'siblings': [{'name': 'Scott', 'age': 25, 'pet': 'Zuko'}, {'name': 'Katie', 'age': 33, 'pet': 'Cisco'}]}

type(result)= <class 'dict'>

2 dumps字典转换字符串
asjson= {"name": "Wes", "places_lived": ["United States", "Spain", "Germany"], "pet": null, "siblings": [{"name": "Scott", "age": 25, "pet": "Zuko"}, {"name": "Katie", "age": 33, "pet": "Cisco"}]}

type(asjson)= <class 'str'>

3 取数据输出dataframe
siblings=
     name  age
0  Scott   25
1  Katie   33

type(siblings)= <class 'pandas.core.frame.DataFrame'>

二进制数据格式
frame=
    a   b   c   d message
0  1   2   3   4   hello
1  5   6   7   8   world
2  9  10  11  12     foo

1 read_pickle
wb=    a   b   c   d message
0  1   2   3   4   hello
1  5   6   7   8   world
2  9  10  11  12     foo
-------------------------------------------------------------------

使用HTML和Web API
resp= <Response [200]>

data= [{'id': 76811, 'node_id': 'MDU6TGFiZWw3NjgxMQ==', 'url': 'https://api.github.com/repos/pandas-dev/pandas/labels/Bug', 'name': 'Bug', 'color': 'e10c02', 'default': False}, {'id': 76812, 'node_id': 'MDU6TGFiZWw3NjgxMg==', 'url': 'https://api.github.com/repos/pandas-dev/pandas/labels/Enhancement', 'name': 'Enhancement', 'color': '4E9A06', 'default': False}, {'id': 127681, 'node_id': 'MDU6TGFiZWwxMjc2ODE=', 'url': 'https://api.github.com/repos/pandas-dev/pandas/labels/Refactor', 'name': 'Refactor', 'color': 'FCE94F', 'default': False}, {'id': 129350, 'node_id': 'MDU6TGFiZWwxMjkzNTA=', 'url': 'https://api.github.com/repos/pandas-dev/pandas/labels/Build', 'name': 'Build', 'color': '75507B', 'default': False}, {'id': 134699, 'node_id': 'MDU6TGFiZWwxMzQ2OTk=', 'url': 'https://api.github.com/repos/pandas-dev/pandas/labels/Docs', 'name': 'Docs', 'color': '3465A4', 'default': False}, {'id': 211840, 'node_id': 'MDU6TGFiZWwyMTE4NDA=', 'url': 'https://api.github.com/repos/pandas-dev/pandas/labels/Timeseries', 'name': 'Timeseries', 'color': 'AFEEEE', 'default': False}, {'id': 233160, 'node_id': 'MDU6TGFiZWwyMzMxNjA=', 'url': 'https://api.github.com/repos/pandas-dev/pandas/labels/Groupby', 'name': 'Groupby', 'color': '729FCF', 'default': False}, {'id': 2301354, 'node_id': 'MDU6TGFiZWwyMzAxMzU0', 'url': 'https://api.github.com/repos/pandas-dev/pandas/labels/Data%20IO', 'name': 'Data IO', 'color': '06909A', 'default': False}, {'id': 2413328, 'node_id': 'MDU6TGFiZWwyNDEzMzI4', 'url': 'https://api.github.com/repos/pandas-dev/pandas/labels/Visualization', 'name': 'Visualization', 'color': '8AE234', 'default': False}, {'id': 2822098, 'node_id': 'MDU6TGFiZWwyODIyMDk4', 'url': 'https://api.github.com/repos/pandas-dev/pandas/labels/Indexing', 'name': 'Indexing', 'color': '0b02e1', 'default': False}, {'id': 2822342, 'node_id': 'MDU6TGFiZWwyODIyMzQy', 'url': 'https://api.github.com/repos/pandas-dev/pandas/labels/Missing-data', 'name': 'Missing-data', 'color': 'd7e102', 'default': False}, {'id': 8935311, 'node_id': 'MDU6TGFiZWw4OTM1MzEx', 'url': 'https://api.github.com/repos/pandas-dev/pandas/labels/Performance', 'name': 'Performance', 'color': 'a10c02', 'default': False}, {'id': 13098779, 'node_id': 'MDU6TGFiZWwxMzA5ODc3OQ==', 'url': 'https://api.github.com/repos/pandas-dev/pandas/labels/Reshaping', 'name': 'Reshaping', 'color': '02d7e1', 'default': False}, {'id': 31404521, 'node_id': 'MDU6TGFiZWwzMTQwNDUyMQ==', 'url': 'https://api.github.com/repos/pandas-dev/pandas/labels/Dtypes', 'name': 'Dtypes', 'color': 'e102d8', 'default': False}, {'id': 32933285, 'node_id': 'MDU6TGFiZWwzMjkzMzI4NQ==', 'url': 'https://api.github.com/repos/pandas-dev/pandas/labels/Admin', 'name': 'Admin', 'color': 'DDDDDD', 'default': False}, {'id': 35818298, 'node_id': 'MDU6TGFiZWwzNTgxODI5OA==', 'url': 'https://api.github.com/repos/pandas-dev/pandas/labels/API%20Design', 'name': 'API Design', 'color': 'AD7FA8', 'default': False}, {'id': 42670965, 'node_id': 'MDU6TGFiZWw0MjY3MDk2NQ==', 'url': 'https://api.github.com/repos/pandas-dev/pandas/labels/Error%20Reporting', 'name': 'Error Reporting', 'color': 'ffa0ff', 'default': False}, {'id': 47223669, 'node_id': 'MDU6TGFiZWw0NzIyMzY2OQ==', 'url': 'https://api.github.com/repos/pandas-dev/pandas/labels/Numeric', 'name': 'Numeric', 'color': '006b75', 'default': False}, {'id': 47229171, 'node_id': 'MDU6TGFiZWw0NzIyOTE3MQ==', 'url': 'https://api.github.com/repos/pandas-dev/pandas/labels/IO%20CSV', 'name': 'IO CSV', 'color': '5319e7', 'default': False}, {'id': 47232590, 'node_id': 'MDU6TGFiZWw0NzIzMjU5MA==', 'url': 'https://api.github.com/repos/pandas-dev/pandas/labels/IO%20SQL', 'name': 'IO SQL', 'color': '5319e7', 'default': False}, {'id': 48070600, 'node_id': 'MDU6TGFiZWw0ODA3MDYwMA==', 'url': 'https://api.github.com/repos/pandas-dev/pandas/labels/CI', 'name': 'CI', 'color': 'a2bca7', 'default': False}, {'id': 49094459, 'node_id': 'MDU6TGFiZWw0OTA5NDQ1OQ==', 'url': 'https://api.github.com/repos/pandas-dev/pandas/labels/Internals', 'name': 'Internals', 'color': 'fbca04', 'default': False}, {'id': 49597148, 'node_id': 'MDU6TGFiZWw0OTU5NzE0OA==', 'url': 'https://api.github.com/repos/pandas-dev/pandas/labels/Timedelta', 'name': 'Timedelta', 'color': '5319e7', 'default': False}, {'id': 53181044, 'node_id': 'MDU6TGFiZWw1MzE4MTA0NA==', 'url': 'https://api.github.com/repos/pandas-dev/pandas/labels/Frequency', 'name': 'Frequency', 'color': '0052cc', 'default': False}, {'id': 57186974, 'node_id': 'MDU6TGFiZWw1NzE4Njk3NA==', 'url': 'https://api.github.com/repos/pandas-dev/pandas/labels/Windows', 'name': 'Windows', 'color': 'fbca04', 'default': False}, {'id': 57296398, 'node_id': 'MDU6TGFiZWw1NzI5NjM5OA==', 'url': 'https://api.github.com/repos/pandas-dev/pandas/labels/Algos', 'name': 'Algos', 'color': 'eb6420', 'default': False}, {'id': 60458168, 'node_id': 'MDU6TGFiZWw2MDQ1ODE2OA==', 'url': 'https://api.github.com/repos/pandas-dev/pandas/labels/Timezones', 'name': 'Timezones', 'color': '5319e7', 'default': False}, {'id': 60635328, 'node_id': 'MDU6TGFiZWw2MDYzNTMyOA==', 'url': 'https://api.github.com/repos/pandas-dev/pandas/labels/Period', 'name': 'Period', 'color': 'eb6420', 'default': False}, {'id': 71268330, 'node_id': 'MDU6TGFiZWw3MTI2ODMzMA==', 'url': 'https://api.github.com/repos/pandas-dev/pandas/labels/MultiIndex', 'name': 'MultiIndex', 'color': '207de5', 'default': False}, {'id': 78527356, 'node_id': 'MDU6TGFiZWw3ODUyNzM1Ng==', 'url': 'https://api.github.com/repos/pandas-dev/pandas/labels/Categorical', 'name': 'Categorical', 'color': 'e11d21', 'default': False}]

issue_labels=
           id                   node_id  ...   color default
0      76811      MDU6TGFiZWw3NjgxMQ==  ...  e10c02   False
1      76812      MDU6TGFiZWw3NjgxMg==  ...  4E9A06   False
2     127681      MDU6TGFiZWwxMjc2ODE=  ...  FCE94F   False
3     129350      MDU6TGFiZWwxMjkzNTA=  ...  75507B   False
4     134699      MDU6TGFiZWwxMzQ2OTk=  ...  3465A4   False
5     211840      MDU6TGFiZWwyMTE4NDA=  ...  AFEEEE   False
6     233160      MDU6TGFiZWwyMzMxNjA=  ...  729FCF   False
7    2301354      MDU6TGFiZWwyMzAxMzU0  ...  06909A   False
8    2413328      MDU6TGFiZWwyNDEzMzI4  ...  8AE234   False
9    2822098      MDU6TGFiZWwyODIyMDk4  ...  0b02e1   False
10   2822342      MDU6TGFiZWwyODIyMzQy  ...  d7e102   False
11   8935311      MDU6TGFiZWw4OTM1MzEx  ...  a10c02   False
12  13098779  MDU6TGFiZWwxMzA5ODc3OQ==  ...  02d7e1   False
13  31404521  MDU6TGFiZWwzMTQwNDUyMQ==  ...  e102d8   False
14  32933285  MDU6TGFiZWwzMjkzMzI4NQ==  ...  DDDDDD   False
15  35818298  MDU6TGFiZWwzNTgxODI5OA==  ...  AD7FA8   False
16  42670965  MDU6TGFiZWw0MjY3MDk2NQ==  ...  ffa0ff   False
17  47223669  MDU6TGFiZWw0NzIyMzY2OQ==  ...  006b75   False
18  47229171  MDU6TGFiZWw0NzIyOTE3MQ==  ...  5319e7   False
19  47232590  MDU6TGFiZWw0NzIzMjU5MA==  ...  5319e7   False
20  48070600  MDU6TGFiZWw0ODA3MDYwMA==  ...  a2bca7   False
21  49094459  MDU6TGFiZWw0OTA5NDQ1OQ==  ...  fbca04   False
22  49597148  MDU6TGFiZWw0OTU5NzE0OA==  ...  5319e7   False
23  53181044  MDU6TGFiZWw1MzE4MTA0NA==  ...  0052cc   False
24  57186974  MDU6TGFiZWw1NzE4Njk3NA==  ...  fbca04   False
25  57296398  MDU6TGFiZWw1NzI5NjM5OA==  ...  eb6420   False
26  60458168  MDU6TGFiZWw2MDQ1ODE2OA==  ...  5319e7   False
27  60635328  MDU6TGFiZWw2MDYzNTMyOA==  ...  eb6420   False
28  71268330  MDU6TGFiZWw3MTI2ODMzMA==  ...  207de5   False
29  78527356  MDU6TGFiZWw3ODUyNzM1Ng==  ...  e11d21   False

[30 rows x 6 columns]
-------------------------------------------------------------------

使用数据库
rows= [('Atlanta', 'Georgia', 1.25, 6), ('Tallahassee', 'Florida', 2.6, 3), ('Sacramento', 'California', 1.7, 5)]

con=
              a           b     c  d
0      Atlanta     Georgia  1.25  6
1  Tallahassee     Florida  2.60  3
2   Sacramento  California  1.70  5

参考

以上为个人整理总结的知识，如有遗漏或错误欢迎留言指出、点评，如要引用，请联系通知，未经允许谢绝转载。
[1]: https://baijiahao.baidu.com/s?id=1606423705612438940&wfr=spider&for=pc
[2]:https://baike.baidu.com/item/pandas/17209606?fr=aladdin