Python之Pandas使用知识汇总

一、Pandas简介
二、环境
三、使用
- 3.1 数据结构
- - 3.1.1 Series
  - 3.1.2 Dataframe
- 3.2 索引对象
- 3.3 读写文本格式数据
- - 3.3.1 读取文本格式数据
  - 3.3.2 逐块读取文本文件
  - 3.3.3 数据写出
  - 3.3.4 手工处理分隔符格式
- 3.4 读取Excel文件
- 3.5 数据类型和访问的相关处理
参考

一、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'] = 6print("\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: int641 数组的值
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: int644 数组的索引
obj2.index= Index(['d', 'b', 'a', 'c'], dtype='object')5 索引a的值
obj2['a']= -56 输出给定的索引值
obj2[['c', 'a', 'd']]=c    3
a   -5
d    6
dtype: int647 数组元素大于0的索引及其值
obj2[obj2 > 0]=d    6
b    7
c    3
dtype: int648 数组元素乘以2
obj2 * 2=d    12
b    14
a   -10
c     6
dtype: int649 数组元素的自然对数
np.exp(obj2)=d     403.428793
b    1096.633158
a       0.006738
c      20.085537
dtype: float6410 是否有索引b
'b' in obj2= True是否有索引e
'e' in obj2= False11 由索引数组创建series数组
obj3=Ohio      35000
Texas     71000
Oregon    16000
Utah       5000
dtype: int6412 更改索引顺序，无索引则丢失数据
obj4=California        NaN
Ohio          35000.0
Oregon        16000.0
Texas         71000.0
dtype: float6413 元素为空的判断
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: boolobj3=Ohio      35000
Texas     71000
Oregon    16000
Utah       5000
dtype: int64obj4=California        NaN
Ohio          35000.0
Oregon        16000.0
Texas         71000.0
dtype: float6414 series数组合并，索引相同求和，不同添加
obj3 + obj4=California         NaN
Ohio           70000.0
Oregon         32000.0
Texas         142000.0
Utah               NaN
dtype: float6415 添加series数组的名称和索引
obj4=state
California        NaN
Ohio          35000.0
Oregon        16000.0
Texas         71000.0
Name: population, dtype: float6416 更改索引值
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.91 指定行索引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  NaN2 列索引
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: object4 索引为year的行索引及其值（第二种表达）
frame2.year=one      2000
two      2001
three    2002
four     2001
five     2002
Name: year, dtype: int645 行索引为three的列索引及其值
frame2.ix['three']=year     2002
state    Ohio
pop       3.6
debt      NaN
Name: three, dtype: object6 根据列索引插入值
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.57 根据列索引插入元素
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.0val=two    -1.2
four   -1.5
five   -1.7
dtype: float648 根据列索引插入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.79 插入列索引作为判断另外一列元素是否满足条件
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    False10 根据列索引删除列，打印列索引名
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.513 dataframe转置
frame3.T=2001  2002  2000
Nevada   2.4   2.9   NaN
Ohio     1.7   3.6   1.514 根据索引创建dataframe数组
DataFrame(pdata)=Ohio  Nevada
2001   1.7     2.4
2002   3.6     2.915 dataframe数组添加列名和行名
frame3=state  Nevada  Ohio
year
2001      2.4   1.7
2002      2.9   3.6
2000      NaN   1.516 只打印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= Falseobj2=0    1.5
1   -2.5
2    0.0
dtype: float64frame3=Nevada  Ohio
2001     2.4   1.7
2002     2.9   3.6
2000     NaN   1.53 列索引判断
'Ohio' in frame3.columns= True4 行索引判断
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     foo2 sep拆分字符序列
ex1=a   b   c   d message
0  1   2   3   4   hello
1  5   6   7   8   world
2  9  10  11  12     foo3 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    foo4 names列名
ex2=a   b   c   d message
0  1   2   3   4   hello
1  5   6   7   8   world
2  9  10  11  12     foo5 指定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       2b          3       4c          5       6d          7       8
two  a          9      10b         11      12c         13      14d         15      166 打开成列表，读取列表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.1004917 skiprows忽略行
ex4=a   b   c   d message
0  1   2   3   4   hello
1  5   6   7   8   world
2  9  10  11  12     fooresult=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     foo8 判断
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    False9 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     foo10 索引替换值为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   Q3 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     foo1 指定分隔符
|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|foo2 不替换分隔符
,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,foo3 不展示列名和行名
one,1,2,3.0,4,
two,5,6,,8,world
three,9,10,11.0,12,foo4 不使用行索引，使用列索引
a,b,c
1,2,3.0
5,6,
9,10,11.0dates=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: int325 尝试将字符转化为日期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_MINIMALwith 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= 02 由指定索引获取工作簿
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_sheet3 工作簿列数
sheet_1.ncols= 84 工作簿行数
sheet_1.nrows= 85 指定索引工作簿值
cl.value= 16 数据类型
cl.ctype= 17 索引取值
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 sqlite3query = """
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.descriptionDataFrame(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   33type(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     foo1 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

Python之Pandas使用知识汇总（持续更新）相关推荐

html css js知识整理,Html+Css+Js实用知识汇总(持续更新中...)
Html篇基本概念: html:超文本标记语言(Hyper Text Markup Language) html5:下一代的html xhtml:更严谨更纯净的html 表头网站标题 //页面编码 ...
Unity学习知识和链接汇总-持续更新
Unity学习知识和链接汇总-持续更新 Unity Scripting Reference- https://docs.unity3d.com/Manual/index.html gitee http ...
【教程汇总+持续更新】Unity游戏开发从入门到入坟
新的一年,本该在年前整理的年终总结被拖到了年后开工.去年大量时间投入在Catlike教程的翻译上,截止目前位置,教程的进度已经完全追平原作者. 去年还有一部分是断断续续的更新SLG实战教程,但遗憾的是 ...
python基础知识资料-学习Python列表的基础知识汇总
千里之行,始于足下.要练成一双洞悉一切的眼睛,还是得先把基本功扎扎实实地学好.今天,本喵带大家仔细温习一下Python的列表.温故而知新,不亦说乎. 当然,温习的同时也要发散思考,因为有些看似无关紧要 ...
pwn学习总结（四）—— 堆基础知识（持续更新）
pwn学习总结(四)-- 堆基础知识(持续更新) 前言 chunk 使用中(分配后) 空闲中(释放后) 堆块大小空间复用 bins fastbin unsorted bin small bin 前言 ...
pwn学习总结（二） —— 基础知识（持续更新）
pwn学习总结(二) -- 基础知识(持续更新) Canary PLT表&GOT表格式化字符串漏洞 GCC编译参数 ASLR 危险函数输入流 syscall条件 shellcode 其它 ...
【帆软报表】使用技巧及常见问题汇总-持续更新
[帆软报表]使用技巧及常见问题汇总-持续更新 1.重复与冻结设置,做用:冻结区域模板-重复与冻结设置 2.单元格有效小数设置选中单元格-格式-数字-#0.00 3.图表中有效小数设置图表属性表- ...
iOS精品资源汇总(持续更新)
文章目录引言 I.iOS自定义视图相关热门资源 1.1 <用户协议及隐私政策>弹框 1.2 电子签名 1.3 商品详情页 1.4 上传图片视图的封装[支持删除和添加] 1.5 查看风险商 ...
关于keil的一些基础知识（持续更新）
#关于keil的一些基础知识(持续更新) 1.数据类型转换 (1)写程序的时候需要将一个32位16进制数值转换到10进制显示在TF屏上,由于基础比较烂,一直没有想明白,写了各种复杂的类型转换.. 代码 ...

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