深入理解pandas读取excel,txt,csv文件等命令

发表于

pandas读取文件官方提供的文档

在使用pandas读取文件之前，必备的内容，必然属于官方文档，官方文档查阅地址

pandas.pydata.org/pandas-docs…

文档操作属于pandas里面的Input/Output也就是IO操作，基本的API都在上述网址，接下来本文核心带你理解部分常用的命令

pandas读取txt文件

读取txt文件需要确定txt文件是否符合基本的格式，也就是是否存在\t,,,等特殊的分隔符

一般txt文件长成这个样子

txt文件举例

下面的文件为空格间隔

1
2
3
4
yaml复制代码1 2019-03-22 00:06:24.4463094 中文测试 
2 2019-03-22 00:06:32.4565680 需要编辑encoding 
3 2019-03-22 00:06:32.6835965 ashshsh 
4 2017-03-22 00:06:32.8041945 eggg

读取命令采用 read_csv或者 read_table都可以

1
2
3
4
5
6
7
bash复制代码import pandas as pd
df =  pd.read_table("./test.txt")
print(df)

import pandas as pd
df =  pd.read_csv("./test.txt")
print(df)

但是，注意，这个地方读取出来的数据内容为3行1列的DataFrame类型，并没有按照我们的要求得到3行4列

1
2
3
4
5
6
7
python复制代码import pandas as pd
df =  pd.read_csv("./test.txt")
print(type(df))
print(df.shape)

<class 'pandas.core.frame.DataFrame'>
(3, 1)

read_csv函数

默认: 从文件、URL、文件新对象中加载带有分隔符的数据，默认分隔符是逗号。

上述txt文档并没有逗号分隔，所以在读取的时候需要增加sep分隔符参数

1
ini复制代码df =  pd.read_csv("./test.txt",sep=' ')

参数说明，官方Source : github.com/pandas-dev/…
中文说明以及重点功能案例

参数 中文释义
filepath_or_buffer 可以是URL，可用URL类型包括：http, ftp, s3和文件，本地文件读取实例：file://localhost/path/to/table.csv
sep str类型，默认’,’ 指定分隔符。如果不指定参数，则会尝试使用默认值逗号分隔。分隔符长于一个字符并且不是‘\s+’,将使用python的语法分析器。并且忽略数据中的逗号。正则表达式例子：’\r\t’
delimiter 定界符，备选分隔符（如果指定该参数，则sep参数失效） 一般不用
delimiter_whitespace True or False 默认False, 用空格作为分隔符等价于spe=’\s+’如果该参数被调用，则delimite不会起作用
header 指定第几行作为列名(忽略注解行)，如果没有指定列名，默认header=0; 如果指定了列名header=None
names 指定列名，如果文件中不包含header的行，应该显性表示header=None ，header可以是一个整数的列表，如0,1,3。未指定的中间行将被删除(例如，跳过此示例中的2行)
index_col(案例1) 默认为None 用列名作为DataFrame的行标签，如果给出序列，则使用MultiIndex。如果读取某文件,该文件每行末尾都有带分隔符，考虑使用index_col=False使panadas不用第一列作为行的名称。
usecols 默认None 可以使用列序列也可以使用列名，如 0, 1, 2 or ‘foo’, ‘bar’, ‘baz’ ,使用这个参数可以加快加载速度并降低内存消耗。
squeeze 默认为False, True的情况下返回的类型为Series，如果数据经解析后仅含一行，则返回Series
prefix 自动生成的列名编号的前缀，如： ‘X’ for X0, X1, … 当header =None 或者没有设置header的时候有效
mangle_dupe_cols 默认为True,重复的列将被指定为’X.0’…’X.N’，而不是’X’…’X’。如果传入False，当列中存在重复名称，则会导致数据被覆盖。
dtype 例子： {‘a’: np.float64, ‘b’: np.int32} 指定每一列的数据类型，a,b表示列名
engine 使用的分析引擎。可以选择C或者是python，C引擎快但是Python引擎功能更多一些
converters(案例2) 设置指定列的处理函数，可以用”序号”也可以使用“列名”进行列的指定
true_values / false_values 没有找到实际的应用场景，备注一下，后期完善
skipinitialspace 忽略分隔符后的空格,默认false
skiprows 默认值 None 需要忽略的行数（从文件开始处算起），或需要跳过的行号列表（从0开始）
skipfooter 从文件尾部开始忽略。 (c引擎不支持)
nrows 从文件中只读取多少数据行，需要读取的行数（从文件头开始算起）
na_values 空值定义，默认情况下, ‘#N/A’, ‘#N/A N/A’, ‘#NA’, ‘-1.#IND’, ‘-1.#QNAN’, ‘-NaN’, ‘-nan’, ‘1.#IND’, ‘1.#QNAN’, ‘N/A’, ‘NA’, ‘NULL’, ‘NaN’, ‘n/a’, ‘nan’, ‘null’. 都表现为NAN
keep_default_na 如果指定na_values参数，并且keep_default_na=False，那么默认的NaN将被覆盖，否则添加
na_filter 是否检查丢失值（空字符串或者是空值）。对于大文件来说数据集中没有N/A空值，使用na_filter=False可以提升读取速度。
verbose 是否打印各种解析器的输出信息，例如：“非数值列中缺失值的数量”等。
skip_blank_lines 如果为True，则跳过空行；否则记为NaN。
parse_dates 有如下的操作1. boolean. True -> 解析索引2. list of ints or names. e.g. If 1, 2, 3 -> 解析1,2,3列的值作为独立的日期列；3. list of lists. e.g. If [1, 3] -> 合并1,3列作为一个日期列使用 4. dict, e.g. {‘foo’ : 1, 3} -> 将1,3列合并，并给合并后的列起名为”foo”
infer_datetime_format 如果设定为True并且parse_dates 可用，那么pandas将尝试转换为日期类型，如果可以转换，转换方法并解析。在某些情况下会快5~10倍
keep_date_col 如果连接多列解析日期，则保持参与连接的列。默认为False
date_parser 用于解析日期的函数，默认使用dateutil.parser.parser来做转换。Pandas尝试使用三种不同的方式解析，如果遇到问题则使用下一种方式。1.使用一个或者多个arrays（由parse_dates指定）作为参数；2.连接指定多列字符串作为一个列作为参数；3.每行调用一次date_parser函数来解析一个或者多个字符串（由parse_dates指定）作为参数。
dayfirst DD/MM格式的日期类型
iterator 返回一个TextFileReader 对象，以便逐块处理文件。
chunksize 文件块的大小
compression 直接使用磁盘上的压缩文件。如果使用infer参数，则使用 gzip, bz2, zip或者解压文件名中以‘.gz’, ‘.bz2’, ‘.zip’, or ‘xz’这些为后缀的文件，否则不解压。如果使用zip，那么ZIP包中国必须只包含一个文件。设置为None则不解压。
新版本0.18.1版本支持zip和xz解压
thousands 千分位符号，默认‘，’
decimal 小数点符号，默认‘.’
lineterminator 行分割符，只在C解析器下使用
quotechar 引号，用作标识开始和解释的字符，引号内的分割符将被忽略
quoting 控制csv中的引号常量。可选 QUOTE_MINIMAL (0), QUOTE_ALL (1), QUOTE_NONNUMERIC (2) or QUOTE_NONE (3)
doublequote 双引号，当单引号已经被定义，并且quoting 参数不是QUOTE_NONE的时候，使用双引号表示引号内的元素作为一个元素使用。
escapechar 当quoting 为QUOTE_NONE时，指定一个字符使的不受分隔符限值。
comment 标识着多余的行不被解析。如果该字符出现在行首，这一行将被全部忽略。这个参数只能是一个字符，空行（就像skip_blank_lines=True）注释行被header和skiprows忽略一样。例如如果指定comment=’#’ 解析‘#empty\na,b,c\n1,2,3’ 以header=0 那么返回结果将是以’a,b,c’作为header
encoding 编码方式，指定字符集类型，通常指定为’utf-8’
dialect 如果没有指定特定的语言，如果sep大于一个字符则忽略。具体查看csv.Dialect 文档
error_bad_lines 如果一行包含太多的列，那么默认不会返回DataFrame ，如果设置成false，那么会将改行剔除（只能在C解析器下使用）
warn_bad_lines 如果error_bad_lines =False，并且warn_bad_lines =True 那么所有的“bad lines”将会被输出（只能在C解析器下使用）
low_memory 分块加载到内存，再低内存消耗中解析。但是可能出现类型混淆。确保类型不被混淆需要设置为False。或者使用dtype 参数指定类型。注意使用chunksize 或者iterator 参数分块读入会将整个文件读入到一个Dataframe，而忽略类型（只能在C解析器中有效）
delim_whitespace New in version 0.18.1: Python解析器中有效
memory_map 如果为filepath_or_buffer提供了文件路径，则将文件对象直接映射到内存上，并直接从那里访问数据。使用此选项可以提高性能，因为不再有任何I / O开销，使用这种方式可以避免文件再次进行IO操作
float_precision 指定C引擎应用于浮点值的转换器

该表格部分参考 博客 www.cnblogs.com/datablog/p/… 感谢博主的翻译，O(∩_∩)O哈哈~

案例1

index_col 使用

首先准备一个txt文件，这个文件最大的问题是在每行的末尾多了一个’,’ ，按照提示解释为，如果每行末尾都有分隔符，会出现问题，但是在实际测试的时候发现需要配合names参数，才可以出现效果

1
2
3
bash复制代码goof,1,2,3,ddd,
u,1,3,4,asd,
as,df,12,33,

该表格部分参考 博客 www.cnblogs.com/datablog/p/… 感谢博主的翻译，O(∩_∩)O哈哈~

案例1

index_col 使用

首先准备一个txt文件，这个文件最大的问题是在每行的末尾多了一个’,’ ，按照提示解释为，如果每行末尾都有分隔符，会出现问题，但是在实际测试的时候发现需要配合names参数，才可以出现效果

1
2
3
bash复制代码goof,1,2,3,ddd,
u,1,3,4,asd,
as,df,12,33,

编写如下代码

1
2
3
4
5
bash复制代码df =  pd.read_csv("./demo.txt",header=None,names=['a','b','c','d','e'])
print(df)

df =  pd.read_csv("./demo.txt",header=None,index_col=False,names=['a','b','c','d','e'])
print(df)

其实发现意义还真不是很大，可能文档并没有表述清楚他的具体作用。接下来说一下index_col的常见用途

在读取文件的时候，如果不设置index_col列索引，默认会使用从0开始的整数索引。当对表格的某一行或列进行操作之后，在保存成文件的时候你会发现总是会多一列从0开始的列，如果设置index_col参数来设置列索引，就不会出现这种问题了。

案例2

converters 设置指定列的处理函数，可以用”序号”也可以使用“列名”进行列的指定

1
2
3
4
5
6
7
8
9
kotlin复制代码import pandas as pd

def fun(x):
    return str(x)+"-haha"

df =  pd.read_csv("./test.txt",sep=' ',header=None,index_col=0,converters={3:fun})
print(type(df))
print(df.shape)
print(df)

read_csv函数过程中常见的问题

  1. 有的IDE中利用Pandas的read_csv函数导入数据文件时，若文件路径或文件名包含中文，会报错。
    解决办法
1
2
3
4
ini复制代码import pandas as pd
#df=pd.read_csv('F:/测试文件夹/测试数据.txt')
f=open('F:/测试文件夹/测试数据.txt')
df=pd.read_csv(f)
  1. 排除某些行 使用 参数 skiprows.它的功能为排除某一行。 要注意的是：排除前3行是skiprows=3 排除第3行是skiprows=3
  2. 对于不规则分隔符，使用正则表达式读取文件 文件中的分隔符采用的是空格，那么我们只需要设置sep=” “来读取文件就可以了。当分隔符并不是单个的空格，也许有的是一个空格有的是多个空格时，如果这个时候还是采用sep=” “来读取文件，也许你就会得到一个很奇怪的数据，因为它会将空格也做为数据。 data = pd.read_csv(“data.txt”,sep=”\s+”)
  3. 读取的文件中如果出现中文编码错误 需要设定 encoding 参数
  4. 为行和列添加索引 用参数names添加列索引，用index_col添加行索引

read_csv该命令有相当数量的参数。大多数都是不必要的，因为你下载的大部分文件都有标准格式。

read_table函数

基本用法是一致的，区别在于separator分隔符。

csv是逗号分隔值，仅能正确读入以 “,” 分割的数据，read_table默认是’\t’(也就是tab)切割数据集的

read_fwf 函数

读取具有固定宽度列的文件，例如文件

1
2
3
4
5
复制代码id8141    360.242940   149.910199   11950.7
id1594    444.953632   166.985655   11788.4
id1849    364.136849   183.628767   11806.2
id1230    413.836124   184.375703   11916.8
id1948    502.953953   173.237159   12468.3

read_fwf 命令有2个额外的参数可以设置

colspecs ：

需要给一个元组列表，元组列表为半开区间，[from,to) ,默认情况下它会从前100行数据进行推断。

例子：

1
2
3
ini复制代码import pandas as pd
colspecs = [(0, 6), (8, 20), (21, 33), (34, 43)]
df = pd.read_fwf('demo.txt', colspecs=colspecs, header=None, index_col=0)

widths：

直接用一个宽度列表，可以代替colspecs参数

1
2
ini复制代码widths = [6, 14, 13, 10]
df = pd.read_fwf('demo.txt', widths=widths, header=None)

read_fwf 使用并不是很频繁，可以参照 pandas.pydata.org/pandas-docs… 学习

read_msgpack 函数

pandas支持的一种新的可序列化的数据格式，这是一种轻量级的可移植二进制格式，类似于二进制JSON，这种数据空间利用率高，在写入（序列化）和读取（反序列化）方面都提供了良好的性能。

read_clipboard 函数

读取剪贴板中的数据，可以看作read_table的剪贴板版本。在将网页转换为表格时很有用

这个地方出现如下的BUG

module ‘pandas’ has no attribute ‘compat’

我更新了一下pandas 既可以正常使用了

还有一个比较坑的地方，就是在读取剪切板的时候，如果复制了中文，很容易读取不到数据

解决办法

  1. 打开site-packages\pandas\io\clipboard.py 这个文件需要自行检索
  2. 在 text = clipboard_get() 后面一行 加入这句： text = text.decode(‘UTF-8’)
  3. 保存，然后就可以使用了

read_excel 函数

依旧是官方文档一码当先：pandas.pydata.org/pandas-docs…

参数 中文释义
io 文件类对象 ，pandas Excel 文件或 xlrd 工作簿。该字符串可能是一个URL。URL包括http，ftp，s3和文件。例如，本地文件可写成file://localhost/path/to/workbook.xlsx
sheet_name 默认是sheetname为0，返回多表使用sheetname=0,1，若sheetname=None是返回全表 。注意：int/string返回的是dataframe，而none和list返回的是dict of dataframe，表名用字符串表示，索引表位置用整数表示；
header 指定作为列名的行，默认0，即取第一行，数据为列名行以下的数据；若数据不含列名，则设定 header = None；
names 指定列的名字，传入一个list数据
index_col 指定列为索引列，也可以使用u”strings” ，如果传递一个列表，这些列将被组合成一个MultiIndex。
squeeze 如果解析的数据只包含一列，则返回一个Series
dtype 数据或列的数据类型，参考read_csv即可
engine 如果io不是缓冲区或路径，则必须将其设置为标识io。 可接受的值是None或xlrd
converters 参照read_csv即可
其余参数 基本和read_csv一致

pandas 读取excel文件如果报错，一般处理为

错误为：ImportError: No module named ‘xlrd’

pandas读取excel文件，需要单独的xlrd模块支持 pip install xlrd 即可

read_json 函数

参数 中文释义
path_or_buf 一个有效的JSON文件，默认值为None,字符串可以为URL，例如file://localhost/path/to/table.json
orient （案例1） 预期的json字符串格式，orient的设置有以下几个值：1. ‘split’ : dict like {index -> index, columns -> columns, data -> values}2. ‘records’ : list like {column -> value}, … , {column -> value}3. ‘index’ : dict like {index -> {column -> value}}4. ‘columns’ : dict like {column -> {index -> value}}5. ‘values’ : just the values array
typ 返回的格式(series or frame), 默认是 ‘frame’
dtype 数据或列的数据类型，参考read_csv即可
convert_axes boolean，尝试将轴转换为正确的dtypes，默认值为True
convert_dates 解析日期的列列表；如果为True，则尝试解析类似日期的列，默认值为True参考列标签it ends with ‘_at’,it ends with ‘_time’,it begins with ‘timestamp’,it is ‘modified’,it is ‘date’
keep_default_dates boolean，default True。如果解析日期，则解析默认的日期样列
numpy 直接解码为numpy数组。默认为False；仅支持数字数据，但标签可能是非数字的。还要注意，如果numpy=True，JSON排序MUST
precise_float boolean，默认False。设置为在将字符串解码为双精度值时启用更高精度（strtod）函数的使用。默认值（False）是使用快速但不太精确的内置功能
date_unit string，用于检测转换日期的时间戳单位。默认值无。默认情况下，将检测时间戳精度，如果不需要，则通过’s’，’ms’，’us’或’ns’之一分别强制时间戳精度为秒，毫秒，微秒或纳秒。
encoding json编码
lines 每行将文件读取为一个json对象。

如果JSON不可解析，解析器将产生ValueError/TypeError/AssertionError之一。

案例1

  1. orient=’split’
1
2
3
less复制代码    import pandas as pd
    s = '{"index":[1,2,3],"columns":["a","b"],"data":[[1,3],[2,5],[6,9]]}'
    df = pd.read_json(s,orient='split')
  1. orient=’records’ 成员为字典列表
1
2
3
ini复制代码import pandas as pd
s = '[{"a":1,"b":2},{"a":3,"b":4}]'
df = pd.read_json(s,orient='records')
  1. orient=’index’ 以索引为key,以列字段构成的字典为键值。如： s = ‘{“0”:{“a”:1,”b”:2},”1”:{“a”:2,”b”:4}}’
  2. orient=’columns’ 或者 values 自己推断即可

部分中文翻译，可以参考github> github.com/apachecn/pa…

read_json()常见BUG

读取json文件出现 ValueError: Trailing data ，JSON格式问题

原格式为

1
css复制代码{"a":1,"b":1},{"a":2,"b":2}

调整为

1
css复制代码[{"a":1,"b":1},{"a":2,"b":2}]

或者使用lines参数,并且JSON调整为每行一条数据

1
2
css复制代码{"a":1,"b":1}
{"a":2,"b":2}

若JSON文件中有中文，建议加上encoding参数，赋值’utf-8’，否则会报错

read_html 函数

参数 中文释义
io 接收网址、文件、字符串。网址不接受https，尝试去掉s后爬去
match 正则表达式，返回与正则表达式匹配的表格
flavor 解析器默认为‘lxml’
header 指定列标题所在的行，list为多重索引
index_col 指定行标题对应的列，list为多重索引
skiprows 跳过第n行（序列标示）或跳过n行（整数标示）
attrs 属性，比如 attrs = {‘id’: ‘table’}
parse_dates 解析日期

使用方法，在网页中右键如果发现表格 也就是 table 即可使用

例如： data.stcn.com/2019/0304/1…

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
xml复制代码<table class="..." id="...">
    <thead>
    <tr>
    <th>...</th>
    </tr>
    </thead>
    <tbody>
        <tr>
            <td>...</td>
        </tr>
        <tr>...</tr>
    </tbody>
</table>


<table> : 定义表格
<thead> : 定义表格的页眉
<tbody> : 定义表格的主体
<tr>    : 定义表格的行
<th>    : 定义表格的表头
<td>    : 定义表格单元

常见BUG

出现如下报错 ImportError: html5lib not found, please install it

安装html5lib即可，或者使用参数

1
2
ini复制代码import pandas as pd
df = pd.read_html("http://data.stcn.com/2019/0304/14899644.shtml",flavor ='lxml')

更多参考源码，可以参考 > pandas.pydata.org/pandas-docs…

pandas 的读写函数简表

读取函数 写入函数 解释
read_clipboard to_clipboard 从剪贴板中读取文本并传递给read_table
read_csv to_csv 将CSV（逗号分隔）文件读入DataFrame
read_excel to_excel Excel表格
read_sql to_sql
read_pickle to_pickle
read_json to_json
read_msgpack to_msgpack
read_stata to_stata
read_gbq to_gbq 从Google BigQuery加载数据
read_hdf to_hdf
read_html to_html
read_parquet to_parquet
read_feather to_feather 
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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
python复制代码import pandas as pd
 2 
 3 csvframe = pd.read_csv('pandas_data_test\myCSV_01.csv')
 4 print(csvframe, "\n-----*-----")
 5 csvframe1 = pd.read_table('pandas_data_test\myCSV_01.csv',sep=',')
 6 print(csvframe1, "\n-----*-----")
 7 csvframe2 = pd.read_csv('pandas_data_test\myCSV_02.csv',header=None) # 设置header为无，就不会用数据充当表头，此时添加默认表头
 8 print(csvframe2, "\n-----*-----")
 9 csvframe20 = pd.read_csv('pandas_data_test\myCSV_02.csv',names=['white','red','blue','green','animal']) # 指定表头
10 print(csvframe20, "\n-----*-----")
11 
12 csvframe30 = pd.read_csv('pandas_data_test\myCSV_03.csv')
13 print(csvframe30, "\n-----*-----")
14 csvframe31 = pd.read_csv('pandas_data_test\myCSV_03.csv',index_col=['color','status']) #等级索引
15 print(csvframe31, "\n-----*-----")
16 
17 txtframe4 = pd.read_table('pandas_data_test\ch05_04.txt',sep='\s+') # 根据正则解析
18 print(txtframe4, "\n-----*-----")
19 txtframe5 = pd.read_table('pandas_data_test\ch05_05.txt',sep=r'\D+',header=None,engine='python')
20 print(txtframe5, "\n-----*-----")
21 # 使用skiprows选项，可以排除多余的行。把要排除的行的行号放到数组中，赋给该选项即可。
22 txtframe6 = pd.read_table('pandas_data_test\ch05_06.txt',sep=',',skiprows=[0,1,3,6])
23 print(txtframe6)
24 Out[1]: 25    white  red  blue  green animal
26 0      1    5     2      3    cat
27 1      2    7     8      5    dog
28 2      3    3     6      7  horse
29 3      2    2     8      3   duck
30 4      4    4     2      1  mouse
31 5      4    4     2      1    mou 
32 -----*-----
33    white  red  blue  green animal
34 0      1    5     2      3    cat
35 1      2    7     8      5    dog
36 2      3    3     6      7  horse
37 3      2    2     8      3   duck
38 4      4    4     2      1  mouse
39 5      4    4     2      1    mou 
40 -----*-----
41    0  1  2  3      4
42 0  1  5  2  3    cat
43 1  2  7  8  5    dog
44 2  3  3  6  7  horse
45 3  2  2  8  3   duck
46 4  4  4  2  1  mouse 
47 -----*-----
48    white  red  blue  green animal
49 0      1    5     2      3    cat
50 1      2    7     8      5    dog
51 2      3    3     6      7  horse
52 3      2    2     8      3   duck
53 4      4    4     2      1  mouse 
54 -----*-----
55    color status  iteml  item2  item3
56 0  black     up      3      4      6
57 1  black   down      2      6      7
58 2  white     up      5      5      5
59 3  white   down      3      3      2
60 4  white   left      1      2      1
61 5    red     up      2      2      2
62 6    red   down      1      1      4 
63 -----*-----
64               iteml  item2  item3
65 color status                     
66 black up          3      4      6
67       down        2      6      7
68 white up          5      5      5
69       down        3      3      2
70       left        1      2      1
71 red   up          2      2      2
72       down        1      1      4 
73 -----*-----
74    white  red  blue  green
75 0      1    5     2      3
76 1      2    7     8      5
77 2      3    3     6      7 
78 -----*-----
79    0    1    2
80 0  0  123  122
81 1  1  124  321
82 2  2  125  333 
83 -----*-----
84    white  red  blue  green animal
85 0      1    5     2      3   cat 
86 1      2    7     8      5    dog
87 2      3    3     6      7  horse
88 3      2    2     8      3  duck 
89 4      4    4     2      1  mouse

复制代码

从TXT文件读取部分数据

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
bash复制代码 1 print(csvframe2, "\n-----*-----")
 2 # nrows=2指定要获取的行数，skiprows=[2]删除对应行
 3 csvfram20 = pd.read_csv('pandas_data_test\myCSV_02.csv',skiprows=[2],nrows=2,header=None)
 4 print(csvfram20)
 5 Out[2]: 6    0  1  2  3      4
 7 0  1  5  2  3    cat
 8 1  2  7  8  5    dog
 9 2  3  3  6  7  horse
10 3  2  2  8  3   duck
11 4  4  4  2  1  mouse 
12 -----*-----
13    0  1  2  3    4
14 0  1  5  2  3  cat
15 1  2  7  8  5  dog

复制代码

　　另外一项既有趣又很常用的操作是切分想要解析的文本，然后遍历各个部分，逐一对其执行 某一特定操作。

　　例如，对于一列数字，每隔两行取一个累加起来，最后把和插人到Series对象中„这个小例 子理解起来很简单，

　　　　也没有实际应用价值，但是一旦领会了其原理，你就能将其用到更加复杂的情况。

复制代码

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
ini复制代码 1 csvframe1 = pd.read_table('pandas_data_test\myCSV_01.csv',sep=',')
 2 print(csvframe1, "\n-----*-----")
 3 out = pd.Series()
 4 pieces = pd.read_csv('pandas_data_test\myCSV_01.csv',chunksize=4)  # chunksize参数决定了每部分分割的行数
 5 i = 0
 6 for piece in pieces:
 7     print(piece['white'])
 8     out.at[i] = piece['white'].sum()
 9     i += 1
10 print(out, "\n-----*-----")
11 Out[3]: 12    white  red  blue  green animal
13 0      1    5     2      3    cat
14 1      2    7     8      5    dog
15 2      3    3     6      7  horse
16 3      2    2     8      3   duck
17 4      4    4     2      1  mouse
18 5      4    4     2      1    mou 
19 -----*-----
20 0    1
21 1    2
22 2    3
23 3    2
24 Name: white, dtype: int64
25 4    4
26 5    4
27 Name: white, dtype: int64
28 0    8
29 1    8
30 dtype: int64

复制代码

往CSV文件写入数据

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
python复制代码 1 print(csvframe1)
 2 print(csvframe1.to_csv('pandas_data_test\ch05_07.csv'))
 3 # 使用index和 header选项，把它们的值设置为False,可取消默认写入index和header
 4 print(csvframe1.to_csv('pandas_data_test\ch05_07b.csv',index =False,header=False))
 5 print(csvframe30.to_csv('pandas_data_test\ch05_08.csv'))
 6 # 可以用to_csv()函数的na_rep选项把空字段替换为你需要的值。常用值有NULL、0和NaN
 7 print(csvframe30.to_csv('pandas_data_test\ch05_09.csv',na_rep="空"))
 8 Out[4]: 9    white  red  blue  green animal
10 0      1    5     2      3    cat
11 1      2    7     8      5    dog
12 2      3    3     6      7  horse
13 3      2    2     8      3   duck
14 4      4    4     2      1  mouse
15 5      4    4     2      1    mou
16 None
17 None
18 None
19 None

进入文件夹我们可以看到相应的文件：

　　　

读写HTML文件

复制代码

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
less复制代码 1 frame = pd.DataFrame(np.arange(4).reshape(2,2))
 2 print(frame.to_html())
 3 frame2 = pd.DataFrame( np.random.random((4,4)),index = ['white','black','red','blue1'],columns = ['up','down','right','left'])
 4 s = ['<HTML>']
 5 s.append('<HEAD><TITLE>My DataFrame</TITLE></HEAD>')
 6 s.append(' <B0DY>')
 7 s.append(frame.to_html())
 8 s.append('</BODY></HTML>')
 9 html = ''.join(s)
10 html_file = open('pandas_data_test\myFrame.html','w')
11 html_file.write(html)
12 html_file.close()
13 web_frames = pd.read_html('pandas_data_test\myFrame.html')
14 print(web_frames[0])
15 ranking = pd.read_html('http://www.meccanismocomplesso.org/en/ eccanismo-complesso-sito-2/classifica-punteggio/')
16 print(ranking[0][1:10]) # 输出网页内容的前10行
17 Out[5]: 18 <table border="1" class="dataframe">
19   <thead>
20     <tr style="text-align: right;">
21       <th></th>
22       <th>0</th>
23       <th>1</th>
24     </tr>
25   </thead>
26   <tbody>
27     <tr>
28       <th>0</th>
29       <td>0</td>
30       <td>1</td>
31     </tr>
32     <tr>
33       <th>1</th>
34       <td>2</td>
35       <td>3</td>
36     </tr>
37   </tbody>
38 </table>
39    Unnamed: 0  0  1
40 0           0  0  1
41 1           1  2  3
42     #             Nome   Exp  Livelli
43 1   2            admin  9029      NaN
44 2   3      BrunoOrsini  2124      NaN
45 3   4        Berserker   700      NaN
46 4   5         Dnocioni   543      NaN
47 5   6  albertosallusti   409      NaN
48 6   7              Jon   233      NaN
49 7   8             Mr.Y   180      NaN
50 8   9  michele sisinni   157      NaN
51 9  10           Selina   136      NaN

复制代码

从XML读取数据

　　pandas的所有I/O API函数中，没有专门用来处理XML(可扩展标记语言）格式的。虽然没有， 但这种格式其实

　　　　很重要，因为很多结构化数据都是以XML格式存储的。pandas没有专门的处理函 数也没关系，因为Python

　　　　有很多读写XML格式数据的库（除了pandas)。其中一个库叫作lxml,它在大文件处理方面性能优异，因而从

　　　　众多同类库之中脱颖而出。这 一节将介绍如何用它处理XML文件，以及如何把它和pandas整合起来，以最

　　　　终从XML文件中获 取到所需数据并将其转换为DataFrame对象。

　　XML源文件如下图所示

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
scss复制代码 1 from lxml import objectify
 2 
 3 xml = objectify.parse('pandas_data_test\books.xml')
 4 root = xml.getroot()  # 获取根节点
 5 print(root.Book.Author)
 6 mes1 = root.Book.getchildren()
 7 print("root.Book.getchildren()获取的子标签内容：\n", mes1)
 8 mes2 = root.Book[1].getchildren()  # 取第二个Book标签
 9 print([child.tag for child in mes2])  # 获取子标签
10 print([child.text for child in mes2])  # 获取的子标签内容
11 Out[6]: 12 272103_l_EnRoss, Mark
13 root.Book.getchildren()获取的子标签内容：
14  [' 272103_l_EnRoss, Mark', 'XML Cookbook', 'Computer', 23.56, '2014-22-0l']
15 ['Author', 'Title', 'Genre', 'Price', 'PublishDate']
16 [' 272l03_l_EnBracket, Barbara', 'XML for Dummies', 'Computer', '35.95', '20l4-l2-l6']

复制代码

读写 Microsoft Excel文件

　　read_excel()、to_excel()，能够读取.xls和.xlsx两种类型的文件。

读写JSON数据

read_json()、to_json()

HDF5格式

至此，已学习了文本格式的读写。若要分析大量数据，最好使用二进制格式。Python有多 种二进制数据处理

　　　　工具。HDF5库在这个方面取得了一定的成功。HDF代表等级数据格式（hierarchical data format )。HDF5

　　　　库关注的是HDF5文件的读写，这种文件的数据结构由节点组成，能够存储大量数据集。该库全部用c语言

　　　　开发，提供了python/matlab和Java语言接口。它的迅速扩展得益于开发人 员的广泛使用，还得益于它的效

　　　　率，尤其是使用这种格式存储大量数据，其效率很高。比起其他处理起二进制数据更为简单的格式，HDF5

　　　　支持实时压缩，因而能够利用数据结构中的重复模式压缩文件。目前，Python提供两种操纵HDF5格式数据

　　　　的方法：PyTables和h5py。这两种方法有几点不同，选用哪一种很大程度上取决于具体需求。

　　h5py为HDF5的高级API提供接口。PyTables封装了很多HDF5细节，提供更加灵活的数据容器、索引表、搜索

　　　　功能和其他计算相关的介质。pandas还有一个叫作HDFStore、类似于diet的类，它用PyTables存储pandas

　　　　对象。使用HDF5格式之前，必须导人HDFStore类。

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
scss复制代码 1 from pandas.io.pytables import HDFStore
 2 # 注意这里需要tables这个包，没有请自行安装
 3 frame = pd.DataFrame(np.arange(16).reshape(4,4),index=['white','black1','red','blue'],columns=['up','down','right','left'])
 4 store = HDFStore('pandas_data_test\mydata.h5')
 5 store['obj1'] = frame
 6 frame1 = pd.DataFrame(np.random.rand(16).reshape(4,4),index=['white','black1','red','blue'],columns=['up','down','right','left'])
 7 store['obj2'] = frame1
 8 print(store['obj1'])
 9 print(store['obj2'])
10 Out[7]: 11         up  down  right  left
12 white    0     1      2     3
13 black1   4     5      6     7
14 red      8     9     10    11
15 blue    12    13     14    15
16               up      down     right      left
17 white   0.251269  0.422823  0.619294  0.273534
18 black1  0.593960  0.353969  0.966026  0.104581
19 red     0.964577  0.625644  0.342923  0.638627
20 blue    0.246541  0.997952  0.414599  0.908750
21 Closing remaining open files:pandas_data_test\mydata.h5...done

复制代码

实现对象序列化

****pickle模块实现了一个强大的算法，能够对用Python实现的数据结构进行序列化（pickling) 和反序列化操作。

　　序列化是指把对象的层级结构转换为字节流的过程。序列化便于对象的传输、存储和重建，仅用接收器就能重

　　建对象，还能保留它的所有原始特征。

　　用pandas库实现对象序列化（反序列化）很方便，所有工具都是现成的，无需在Python会话中导入cPickle模

　　块，所有的操作都是隐式进行的。 pandas的序列化格式并不是完全使用ASCII编码。

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
scss复制代码 1 import pickle
 2 data = { 'color': ['white','red'], 'value': [5, 7]}
 3 pickled_data = pickle.dumps(data)
 4 print(pickled_data)
 5 nframe = pickle.loads(pickled_data)
 6 print(nframe)
 7 
 8 # 用pandas序列化
 9 frame = pd.DataFrame(np.arange(16).reshape(4,4), index = ['up','down','left','right'])
10 frame.to_pickle('pandas_data_test\frame.pkl')  # 同json数据类似
11 print(pd.read_pickle('pandas_data_test\frame.pkl'))  # 反序列化，读取数据
12 Out[8]: 13 b'\x80\x03}q\x00(X\x05\x00\x00\x00colorq\x01]q\x02(X\x05\x00\x00\x00whiteq\x03X\x03\x00\x00\x00redq\x04eX\x05\x00\x00\x00valueq\x05]q\x06(K\x05K\x07eu.'
14 {'color': ['white', 'red'], 'value': [5, 7]}
15         0   1   2   3
16 up      0   1   2   3
17 down    4   5   6   7
18 left    8   9  10  11
19 right  12  13  14  15

复制代码

对接数据库

****在很多应用中，所使用的数据来自于文本文件的很少，因为文本文件不是存储数据最有效的方式。

　　数据往往存储于SQL类关系型数据库，作为补充，NoSQL数据库近来也已流行开来。

　　从SQL数据库加载数据，将其转换为DataFrame对象很简单pandas提供的几个函数简化了该过程。

　　pandas.io.sql模块提供独立于数据库、叫作sqlalchemy的统一接口。该接口简化了连接模式， 不管对于

什么类型的数据库，操作命令都只有一套。连接数据库使用create_engine()函数，你可以用它配置驱动器所

需的用户名、密码、端口和数据库实例等所有属性。 数据库URL的典型形式是：

　　　　　　　　　　　　　　　　dialect+driver://username:password@host:port/database

名称的标识名称，例如sqlite，mysql，postgresql，oracle，或mssql。drivername是用于使用全小写字母连接

到数据库的DBAPI的名称。如果未指定，则将导入“默认”DBAPI（如果可用） - 此默认值通常是该后端可用的

最广泛的驱动程序。

复制代码

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
ini复制代码 1 from sqlalchemy import create_engine
 2 
 3 # PostgreSQL数据库
 4 # default
 5 engine = create_engine('postgresql://scott:tiger@localhost/mydatabase')
 6 # pg8000 驱动器
 7 engine = create_engine('postgresql+pg8000://scott:tiger@localhost/mydatabase')
 8 # psycopg2 驱动器
 9 engine = create_engine('postgresql+psycopg2://scott:tiger@localhost/mydatabase')
10 # MySql
11 # default
12 engine = create_engine('mysql://scott:tiger@localhost/foo')
13 
14 # mysql-python 注意驱动器后面的对应关系
15 engine = create_engine('mysql+mysqldb://scott:tiger@localhost/foo')
16 
17 # MySQL-connector-python
18 engine = create_engine('mysql+mysqlconnector://scott:tiger@localhost/foo')
19 # OurSQL
20 engine = create_engine('mysql+oursql://scott:tiger@localhost/foo')
21 # Oracle
22 engine = create_engine('oracle://scott:tiger@127.0.0.1:1521/sidname')
23 
24 engine = create_engine('oracle+cx_oracle://scott:tiger@tnsname')
25 # Microsoft SQL
26 # pyodbc
27 engine = create_engine('mssql+pyodbc://scott:tiger@mydsn')
28 
29 # pymssql
30 engine = create_engine('mssql+pymssql://scott:tiger@hostname:port/dbname')

复制代码

　　SQLite：

　　　　由于SQLite连接到本地文件，因此URL格式略有不同。URL的“文件”部分是数据库的文件名。

　　　　对于相对文件路径，这需要三个斜杠：engine = create_engine(‘sqlite:///foo.db’)

****对于绝对文件路径，三个斜杠后面是绝对路径：

　　　　　 Unix/Mac - 4 initial slashes in total

　　　　　　engine = create_engine(‘sqlite:absolute/path/to/foo.db’)

**Windows

　　　　　　engine = create_engine(‘sqlite:///C:\path\to\foo.db’)

　　　　　　Windows alternative using raw string

　　　　　　engine = create_engine(r’sqlite:///C:\path\to\foo.db’)

　　SQLite3数据读写

****学习使用Python内置的SQLite数据库sqlite3。SQLite3工具实现了简单、 轻量级的DBMS SQL,

　　因此可以内置于用Python语言实现的任何应用。它很实用，你可以在单个文件中创建一个嵌入式数据库。

　　　　若想使用数据库的所有功能而又不想安装真正的数据库，这个工具就是最佳选择。若想在使用真正

　　的数据库之前练习数据库操作，或在单一程序中使用数据库存储数据而无需考虑接口， SQLite3都是不

　　错的选择。

复制代码

1
2
3
4
5
6
7
8
9
10
11
python复制代码 1 from sqlalchemy import create_engine
 2 frame = pd.DataFrame( np.arange(20).reshape(4,5),columns=['white','red','blue','black','green'])
 3 # 连接SQLite3数据库
 4 engine = create_engine('sqlite:///pandas_data_test/foo.db')
 5 # 把DataFrame转换为数据库表。
 6 # to_sql(self, name, con, schema=None, if_exists='fail', index=True,
 7 #                index_label=None, chunksize=None, dtype=None)
 8 frame.to_sql('colors',engine)
 9 
10 # 读取
11 print(pd.read_sql('colors',engine))

复制代码

　　运行结果：

　　

本文转载自: 掘金

开发者博客 – 和开发相关的 这里全都有

0%