pandas中的read_csv参数详解

Posted 2023-04-03 独影月下酌酒

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了pandas中的read_csv参数详解相关的知识，希望对你有一定的参考价值。

1.官网语法

pandas.read_csv(filepath_or_buffer, sep=NoDefault.no_default**,** delimiter=None**,** header='infer’, names=NoDefault.no_default**,** index_col=None**,** usecols=None**,** squeeze=False**,** prefix=NoDefault.no_default**,** mangle_dupe_cols=True**,** dtype=None**,** engine=None**,** converters=None**,** true_values=None**,** false_values=None**,** skipinitialspace=False**,** skiprows=None**,** skipfooter=0**,** nrows=None**,** na_values=None**,** keep_default_na=True**,** na_filter=True**,** verbose=False**,** skip_blank_lines=True**,** parse_dates=False**,** infer_datetime_format=False**,** keep_date_col=False**,** date_parser=None**,** dayfirst=False**,** cache_dates=True**,** iterator=False**,** chunksize=None**,** compression='infer’, thousands=None**,** decimal=’.', lineterminator=None**,** quotechar=’"', quoting=0**,** doublequote=True**,** escapechar=None**,** comment=None**,** encoding=None**,** encoding_errors='strict’, dialect=None**,** error_bad_lines=None**,** warn_bad_lines=None**,** on_bad_lines=None**,** delim_whitespace=False**,** low_memory=True**,** memory_map=False**,** float_precision=None**,** storage_options=None**)**

read_csv()函数在pandas中用来读取文件(逗号分隔符)，并返回DataFrame。

2.参数详解

2.1 filepath_or_buffer(文件)

注：不能为空

filepath_or_buffer: str, path object or file-like object

设置需要访问的文件的有效路径。

可以是URL，可用URL类型包括：http, ftp, s3和文件。

对于多文件正在准备中本地文件读取实例：😕/localhost/path/to/table.csv

# 本地相对路径：
pd.read_csv('data/data.csv') # 注意目录层级
pd.read_csv('data.csv') # 如果文件与代码文件在同目录下
pd.read_csv('data/my/my.data') # CSV 文件扩展名不一定是 csv

# 本地绝对路径：
pd.read_csv('/user/data/data.csv')

2.2 sep(分隔符)

sep: str, default ‘,’

指定分隔符。如果不指定参数，则会尝试使用逗号分隔。分隔符长于一个字符并且不是‘\\s+’,

将使用python的语法分析器。并且忽略数据中的逗号。正则表达式例子：’\\r\\t’

# 数据分隔转化是逗号, 如果是其他可以指定
pd.read_csv(data, sep='\\t') # 制表符分隔 tab
pd.read_table(data) # read_table 默认是制表符分隔 tab
pd.read_csv(data, sep='|') # 制表符分隔 tab
pd.read_csv(data,sep="(?<!a)\\|(?!1)", engine='python') # 使用正则

2.3 delimiter(分隔符)

delimiter: str, default None

定界符，sep的别名。

2.4 header(表头)

header: int, list of int, default ‘infer’

指定行数用来作为列名，数据开始行数。

如果文件中没有列名，则默认为0，否则设置为None。如果明确设定header=0 就会替换掉原来存在

列名。

header参数可以是一个list例如：[0,1,3]，这个list表示将文件中的这些行作为列标题（意味着

每一列有多个标题），介于中间的行将被忽略掉（例如本例中的2；本例中的数据1,2,4行将被作为多

级标题出现，第3行数据将被丢弃，dataframe的数据从第5行开始）。

注意：如果skip_blank_lines=True 那么header参数忽略注释行和空行，所以header=0表示第一

行数据而不是文件的第一行。

# 默认系统会推断，如果指定列名会被忽略
pd.read_csv(data, header=0) # 第一行
pd.read_csv(data, header=None) # 没有表头
pd.read_csv(data, header=[0,1,3]) # 多层索引 MultiIndex

2.5 names(列名)

names: array-like, optional

用于结果的列名列表，如果数据文件中没有列标题行，就需要执行header=None。默认列表中不

能出现重复，除非设定参数mangle_dupe_cols=True。

pd.read_csv(data, names=['列1', '列2']) # 指定列名列表

2.6 index_col(索引列)

index_col: int, str, sequence of int / str, or False, default None

用作行索引的列编号或者列名，如果给定一个序列则有多个行索引。

如果文件不规则，行尾有分隔符，则可以设定index_col=False 来是的pandas不适用第一列作为行

索引。

# 默认为 `None`, 不自动识别索引
pd.read_csv(data, index_col=False) # 不再使用首列作为索引
pd.read_csv(data, index_col=0) # 第几列是索引
pd.read_csv(data, index_col='年份') # 指定列名
pd.read_csv(data, index_col=['a','b']) # 多个索引
pd.read_csv(data, index_col=[0, 3]) # 按列索引指定多个索引

2.7 usecols(使用部分列)

usecols: list-like or callable, optional

返回一个数据子集，该列表中的值必须可以对应到文件中的位置（数字可以对应到指定的列）或者是

字符传为文件中的列名。例如：usecols有效参数可能是 [0,1,2]或者是 [‘foo’, ‘bar’,

‘baz’]。使用这个参数可以加快加载速度并降低内存消耗。

# 读取部分列
pd.read_csv(data, usecols=[0,4,3]) # 按索引只读取指定列，顺序无关
pd.read_csv(data, usecols=['列1', '列5']) # 按列名，列名必须存在
# 指定列顺序，其实是 df 的筛选功能
pd.read_csv(data, usecols=['列1', '列5'])[['列5', '列1']]
# 以下用 callable 方式可以巧妙指定顺序, in 后边的是我们要的顺序
pd.read_csv(data, usecols=lambda x: x.upper() in ['COL3', 'COL1'])

2.8 squeeze(返回序列)

squeeze: bool, default False

如果文件值包含一列，则返回一个Series，如果是多个列依旧还是DataFrame。

# 只取一列会返回一个 Series
pd.read_csv(data, usecols=[0], squeeze=True)
# 如果是两列则还是 df
pd.read_csv(data, usecols=[0, 2], squeeze=True)

2.9 prefix(表头前缀)

prefix: str, optional

在没有列标题时，给列添加前缀。例如：添加‘X’ 成为 X0, X1, …

# 表头为 c_0、c_2
pd.read_csv(data, prefix='c_', header=None)

2.10 mangle_dupe_cols(处理重复列名)

mangle_dupe_cols: bool, default True

重复的列，将‘X’…’X’表示为‘X.0’…’X.N’。如果设定为False则会将所有重名列覆盖。

data = 'a,b,a\\n0,1,2\\n3,4,5'
pd.read_csv(StringIO(data), mangle_dupe_cols=True)
# 表头为 a b a.1
# False 会报 ValueError 错误

2.11 dtype(数据类型)

dtype: Type name or dict of column -> type, optional

每列数据的数据类型。例如 ‘a’: np.float64, ‘b’: np.int32

pd.read_csv(data, dtype=np.float64) # 所有数据均为此数据类型
pd.read_csv(data, dtype='c1':np.float64, 'c2': str) # 指定字段的类型
pd.read_csv(data, dtype=[datetime, datetime, str, float]) # 依次指定

2.12 engine(引擎)

engine: ‘c’, ‘python’, optional

Parser engine to use. The C engine is faster while the python engine is currently more feature-complete.

使用的分析引擎。可以选择C或者是python。C引擎快，但是Python引擎功能更加完备。

2.13 converters(列数据处理)

converters: dict, optional

列转换函数的字典。key可以是列名或者列的序号。

from io import StringIO
data = 'x,y\\na,1\\nb,2'
def foo(p):
    return p+'s'
# x 应用函数, y 使用 lambda
pd.read_csv(StringIO(data), converters='x': foo,
                                        'y': lambda x: x*3)
# 输出：
	x	y
0	as	111
1	bs	222
# 使用列索引
pd.read_csv(StringIO(data),
            converters=0: foo, 1: lambda x: x*3)

2.14 true_values(真值转换)

true_values: list, optional

Values to consider as True 将指定的文本转换为 True, 可以用列表指定多个值。

from io import StringIO
data = ('a,b,c\\n1,Yes,2\\n3,No,4')
pd.read_csv(StringIO(data),
            true_values=['Yes'], false_values=['No'])
# 输出
	a	b	c
0	1	True	2
1	3	False	4

2.15 false_values(假值转换)

false_values: list, optional

Values to consider as False将指定的文本转换为 False, 可以用列表指定多个值。

2.16 skipinitialspace(忽略分隔符后的空白)

skipinitialspace: bool, default False

忽略分隔符后的空白（默认为False，即不忽略）.

data = 'a, b, c\\n 1, 2, 3\\n 4 ,5, 6'
pd.read_csv(StringIO(data), skipinitialspace=True)
# 输出
	a	b	c
0	1	2	3
1	4	5	6

2.17 skiprows(跳过指定行)

skiprows: list-like, int or callable, optional

需要忽略的行数（从文件开始处算起），或需要跳过的行号列表（从0开始）。

# 跳过前2行
pd.read_csv(data, skiprows=2)
# 跳过前2行
pd.read_csv(data, skiprows=range(2))
# 跳过指定行
pd.read_csv(data, skiprows=[24,234,141])
# 跳过指定行
pd.read_csv(data, skiprows=np.array([2, 6, 11]))
# 隔行跳过
pd.read_csv(data, skiprows=lambda x: x % 2 != 0)

2.18 shipfooter(尾部跳过)

skipfooter: int, default 0

从文件尾部开始忽略。 (c引擎不支持)

pd.read_csv(filename, skipfooter=1) # 最后一行不加载

2.19 nrows(读取行数)

nrows: int, optional

需要读取的行数（从文件头开始算起）。一般用于较大的数据文件

pd.read_csv(data, nrows=1000)

2.20 na_values(空值替换)

na_values: scalar, str, list-like, or dict, optional

一组用于替换NA/NaN的值。如果传参，需要制定特定列的空值。默认为‘1.#IND’, ‘1.#QNAN’, ‘N/A’, ‘NA’, ‘NULL’, ‘NaN’, ‘nan’`.

# 5 和 5.0 会被认为 NaN
pd.read_csv(data, na_values=[5])
# ? 会被认为 NaN
pd.read_csv(data, na_values='?')
# 空值为 NaN
pd.read_csv(data, keep_default_na=False, na_values=[""])
# 字符 NA 字符 0 会被认为 NaN
pd.read_csv(data, keep_default_na=False, na_values=["NA", "0"])
# Nope 会被认为 NaN
pd.read_csv(data, na_values=["Nope"])
# a、b、c 均会被认为 NaN 等于 na_values=['a','b','c']
pd.read_csv(data, na_values='abc')
# 指定列的指定值会被认为 NaN
pd.read_csv(data, na_values='c':3, 1:[2,5])

2.21 keep_fault_na(保留默认空值)

keep_default_na: bool, default True

析数据时是否包含默认的NaN值，是否自动识别。

如果指定na_values参数，并且keep_default_na=False，那么默认的NaN将被覆盖，否则添加。

# 不自动识别空值
pd.read_csv(data, keep_default_na=False)

keep_default_na	na_values	逻辑
True	指定	na_values 的配置附加处理
True	未指定	自动识别
False	指定	使用 na_values 的配置
False	未指定	不做处理

注：如果 na_filter 为 False （默认是 True）, 那么 keep_default_na 和 na_values parameters 均无效。

2.22 na_filter(丢失值检查)

na_filter: bool, default True

是否检查丢失值（空字符串或者是空值）。对于大文件来说数据集中没有空值，设定na_filter=False可以提升读取速度。

# boolean, default True
pd.read_csv(data, na_filter=False) # 不检查

2.23 verbose(解析信息)

verbose: bool, default False

是否打印各种解析器的输出信息，例如：“非数值列中缺失值的数量”等。

# 可以看到解析信息
pd.read_csv(data, verbose=True)
# Tokenization took: 0.02 ms
# Type conversion took: 0.36 ms
# Parser memory cleanup took: 0.01 ms

2.24 skip_blank_lines(跳过空行)

skip_blank_lines: bool, default True

如果为True，则跳过空行；否则记为NaN。

# 不跳过空行
pd.read_csv(data, skip_blank_lines=False)

2.25 parse_dates(日期时间解析)

parse_dates: bool or list of int or names or list of lists or dict, default False

boolean. True -> 解析索引
list of ints or names. e.g. If [1, 2, 3] -> 解析1,2,3列的值作为独立的日期列；
list of lists. e.g. If [[1, 3]] -> 合并1,3列作为一个日期列使用
dict, e.g. ‘foo’ : [1, 3] -> 将1,3列合并，并给合并后的列起名为"foo"

pd.read_csv(data, parse_dates=True) # 自动解析日期时间格式
pd.read_csv(data, parse_dates=['年份']) # 指定日期时间字段进行解析
# 将 1、4 列合并解析成名为 时间的 时间类型列
pd.read_csv(data, parse_dates='时间':[1,4])

2.26 infer_datetime_format(自动识别日期时间)

infer_datetime_format: bool, default False

如果设定为True并且parse_dates 可用，那么pandas将尝试转换为日期类型，如果可以转换，转换

方法并解析。在某些情况下会快5~10倍。

pd.read_csv(data, parse_dates=True, infer_datetime_format=True)

2.27 keep_date_col(保留被时间组合列)

keep_date_col: bool, default False

如果有多列解析成一个列，自动会合并到新解析的列，去掉此列，如果设置为 True 则会保留。

pd.read_csv(data, parse_dates=[[1, 2], [1, 3]], keep_date_col=True)

2.28 date_parser(日期时间解析器)

date_parser: function, optional

用于解析日期的函数，默认使用dateutil.parser.parser来做转换。Pandas尝试使用三种不同的方

式解析，如果遇到问题则使用下一种方式。

1.使用一个或者多个arrays（由parse_dates指定）作为参数；

2.连接指定多列字符串作为一个列作为参数；

3.每行调用一次date_parser函数来解析一个或者多个字符串（由parse_dates指定）作为参数。

# 指定时间解析库，默认是 dateutil.parser.parser
date_parser=pd.io.date_converters.parse_date_time
date_parser=lambda x: pd.to_datetime(x, utc=True, format='%d%b%Y')
date_parser = lambda d: pd.datetime.strptime(d, '%d%b%Y')
pd.read_csv(data, parse_dates=['年份'], date_parser=date_parser)

2.29 dayfirst(日期日在前)

dayfirst: bool, default False

DD/MM格式的日期类型,如日期 2000-01-06 如果 dayfirst=True 则会转换成 2000-06-01。

pd.read_csv(data, dayfirst=True, parse_dates=[0])

2.30 cache_dates(日期缓存)

cache_dates: bool, default True

如果为 True，则使用唯一的转换日期缓存来应用 datetime 转换。解析重复的日期字符串时，尤其是带有时区偏移的日期字符串时，可能会大大提高速度。

pd.read_csv(data, cache_dates=False)

2.31 iterator(读取文件对象)

iterator: bool, default False

返回一个TextFileReader 对象，以便逐块处理文件。

pd.read_csv(data, iterator=True)

2.32 chunksize(文件块)

chunksize: int, optional

文件块的大小， See IO Tools docs for more informationon iterator and chunksize.

pd.read_csv(data, chunksize=100000)

# 分片处理大文件
df_iterator=pd.read_csv(file,chunksize=50000)
def process_dataframe(df):
    pass
    return processed_df

for index,df_tmp in enumerate(df_iterator):
    df_processed=process_dataframe(df_tmp)
    if index>0:
       df_processed.to_csv(path)
    else:
       df_processed.to_csv(path,mode='a',header=False)

2.33 compression(压缩)

compression: ‘infer’, ‘gzip’, ‘bz2’, ‘zip’, ‘xz’, None, default ‘infer’

直接使用磁盘上的压缩文件。如果使用infer参数，则使用 gzip, bz2, zip或者解压文件名中以‘.gz’, ‘.bz2’, ‘.zip’, or ‘xz’这些为后缀的文件，否则不解压。如果使用zip，那么ZIP包中国必须只包含一个文件。设置为None则不解压。

新版本0.18.1版本支持zip和xz解压

pd.read_csv('sample.tar.gz', compression='gzip')

2.34 thousands(千分位分隔符)

thousands: str, optional

千分位分割符，如“，”或者“."

pd.read_csv('test.csv', thousands=',') # 逗号分隔

2.35 decimal(小数点)

decimal: str, default ‘.’

字符中的小数点 (例如：欧洲数据使用’，‘).

pd.read_csv(data, decimal=",")

2.36 lineterminator(行结束符)

lineterminator: str (length 1), optional

行分割符，只在C解析器下使用。

data = 'a,b,c~1,2,3~4,5,6'
pd.read_csv(StringIO(data), lineterminator='~')

2.37 quotechar(引号)

quotechar: str (length 1), optional

引号，用作标识开始和结束的字符，引号内的分割符将被忽略。

pd.read_csv(file, quotechar = '"')

2.38 quoting(引号常量)

quoting: int or csv.QUOTE_* instance, default 0

控制csv中的引号常量。可选 QUOTE_MINIMAL (0), QUOTE_ALL (1), QUOTE_NONNUMERIC (2) or QUOTE_NONE (3)

import csv
pd.read_csv('input_file.csv', quoting=csv.QUOTE_NONE)

2.39 doublequote(双引号)

doublequote: bool, default True

双引号，当单引号已经被定义，并且quoting 参数不是QUOTE_NONE的时候，使用双引号表示引号内的元素作为一个元素使用。

import csv
pd.read_csv('data.csv', quotechar='"', doublequote=True, quoting=csv.QUOTE_NONNUMERIC)

2.40 escapechar(不受分隔符限制)

escapechar: str (length 1), optional

当quoting 为QUOTE_NONE时，指定一个字符使的不受分隔符限值。

pd.read_csv(StringIO(data), escapechar='\\\\', encoding='utf-8')

2.41 comment(注释标识)

comment: str, optional

标识着多余的行不被解析。如果该字符出现在行首，这一行将被全部忽略。这个参数只能是一个字符，空行（就像skip_blank_lines=True）注释行被header和skiprows忽略一样。例如如果指定comment=’#’ 解析‘#empty\\na,b,c\\n1,2,3’ 以header=0 那么返回结果将是以’a,b,c’作为header。

s = '# notes\\na,b,c\\n# more notes\\n1,2,3'
pd.read_csv(StringIO(s), sep=',', comment='#', skiprows=1)

2.42 encoding(编码)

encoding: str, optional

指定字符集类型，通常指定为’utf-8’. List of Python standard encodings

pd.read_csv('gairuo.csv', encoding='utf8')
pd.read_csv("gairuo.csv",encoding&#
详解pandas的read_csv()

基于 Python 和 NumPy 开发的 Pandas，在数据分析领域，应用非常广泛。而使用 Pandas 处理数据的第一步往往就是读入数据，比如读写 CSV 文件，而Pandas也提供了强劲的读取支持，参数有 38 个之多。这些参数中，有的容易被忽略，但却在实际工作中用处很大。比如：

文件读取时设置某些列为时间类型
导入文件，含有重复列
过滤某些列
每次迭代读取 10 行

而pandas读取csv文件时通过read_csv函数读取的，下面我们就来好好看看这个函数生得一副什么模样，都有哪些参数。
read_csv中的参数
以下都是read_csv中的参数，但是根据功能我们划分为不同的类别。
基本参数
filepath_or_buffer
数据输入路径，可以是文件路径，也可以是 URL，或者实现 read 方法的任意对象。就是我们输入的第一个参数。
 
In [2]: pd.read_csv(‘https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data‘)
Out[2]:
     5.1  3.5  1.4  0.2     Iris-setosa
0    4.9  3.0  1.4  0.2     Iris-setosa
1    4.7  3.2  1.3  0.2     Iris-setosa
2    4.6  3.1  1.5  0.2     Iris-setosa
3    5.0  3.6  1.4  0.2     Iris-setosa
4    5.4  3.9  1.7  0.4     Iris-setosa
..   ...  ...  ...  ...             ...
144  6.7  3.0  5.2  2.3  Iris-virginica
145  6.3  2.5  5.0  1.9  Iris-virginica
146  6.5  3.0  5.2  2.0  Iris-virginica
147  6.2  3.4  5.4  2.3  Iris-virginica
148  5.9  3.0  5.1  1.8  Iris-virginica

[149 rows x 5 columns]

sep
数据文件的分隔符，默认为逗号。
举例：下面的girl.csv 文件的分割符为 	，如果使用 sep 默认的逗号分隔符，读入后的数据混为一体。
 
In [4]: df = pd.read_csv(‘girl.csv‘)
In [5]: df
Out[5]:
 	  name	age	gender
0     椎名真白	18	女
1     古明地觉	17	女
2     古明地恋	16	女
# 分隔符指定错误，所以多个列的数据连在一块了

sep 必须设置为 ‘	‘，数据分割才会正常。
 
In [1]: df = pd.read_csv(‘girl.csv‘, sep=‘	‘)
In [2]: df
Out[2]:
   name  	age 	gender
0  椎名真白   18      女
1  古明地觉   17      女
2  古明地恋   16      女

delimiter
分隔符的另一个名字，与 sep 功能相似。
delimiter_whitespace
0.18 版本后新加参数，默认为 False，设置为 True 时，表示分割符为空白字符，可以是空格、 	 等。
如下 girl.csv 文件分隔符为	，设置 delim_whitespace 为 True：
 
In [4]: df = pd.read_csv(‘girl.csv‘,delim_whitespace=True)

In [5]: df
Out[5]:
   name  	age 	gender
0  椎名真白   18      女
1  古明地觉   17      女
2  古明地恋   16      女
# 不管分隔符是什么，只要是空白字符，那么可以通过delim_whitespace=True进行读取

header
设置导入 DataFrame 的列名称，默认为 ‘infer‘，注意它与下面介绍的 names 参数的微妙关系。
names
当names没被赋值时，header会变成0，即选取数据文件的第一行作为列名。
当 names 被赋值，header 没被赋值时，那么header会变成None。如果都赋值，就会实现两个参数的组合功能。
我们举例说明


names 没有被赋值，header 也没赋值：
 
In [1]: df = pd.read_csv(‘girl.csv‘, delim_whitespace=True)

In [2]: df
Out[2]:
   name  	age 	gender
0  椎名真白   18      女
1  古明地觉   17      女
2  古明地恋   16      女
# 我们说这种情况下，header为变成0，即选取文件的第一行作为表头



names 没有赋值，header 被赋值
 
In [1]: df = pd.read_csv(‘girl.csv‘, delim_whitespace=True, header=1)

In [2]: df
Out[2]:
   椎名真白  18  女
0  古明地觉  17  女
1  古明地恋  16  女
# 不指定names，指定header为1，则选取第二行当做表头，第二行下面的是数据



names 被赋值，header 没有被赋值
 
In [1]: df = pd.read_csv(‘girl.csv‘, delim_whitespace=True, names=["姓名", "年龄", "性别"])

In [2]: df
Out[2]:
     姓名    年龄      性别
0  name  	 age  	gender
1  椎名真白   18       女
2  古明地觉   17       女
3  古明地恋   16       女    
# 我们看到names适用于没有表头的情况
# 指定names没有指定header，那么header相当于None
# 一般来说，读取文件会有一个表头的，一般是第一行，但是有的文件只是数据而没有表头
# 那么这个时候我们就可以通过names手动指定、或者生成表头，而文件里面的数据则全部是内容
# 所以这里那么name、age、gender也当成是一条记录了，本来它是表头的，但是我们指定了names，所以它就变成数据了，表头是我们在names里面指定的



names和header都被赋值
 
In [1]: df = pd.read_csv(‘girl.csv‘, 
                         delim_whitespace=True, 
                         names=["姓名", "年龄", "性别"],
                         header=0)

In [2]: df
Out[2]:
     姓名  年龄 性别
0  椎名真白  18  女
1  古明地觉  17  女
2  古明地恋  16  女
# 这个相当于先不看names，只看header，我们说header等于0代表什么呢？显然是把第一行当做表头，下面的当成数据
# 好了，然后再把表头用names给替换掉

# 再来看个栗子
In [1]: df = pd.read_csv(‘girl.csv‘, 
                         delim_whitespace=True, 
                         names=["姓名", "年龄", "性别"],
                         header=1)

In [2]: df
Out[2]:
     姓名  年龄 性别
0  古明地觉  17  女
1  古明地恋  16  女
# header=1，表示第二行当做表头，第二行下面当成数据
# 然后再把表头用names给替换掉，就是上面的结果
# 所以一般情况下，有表头并且是第一行，那么names和header都无需指定
# 但是有表头、而表头不是第一行，可能从下面几行开始才是真正的表头和数据，这个是指定header即可
# 如果没有表头，全部是纯数据，那么我们可以通过names手动生成表头
# 而names和header都指定的情况下，一般是有表头但是这个表头你不想用，所以用names来把原来的表头替换掉，其实就等价于读取之后再对列名进行rename



index_col
我们在读取文件之后，生成的索引默认是0 1 2 3...，我们当然可以set_index，但是也可以在读取的时候就指定某个列为索引
 
In [1]: df = pd.read_csv(‘girl.csv‘, delim_whitespace=True, index_col="name")

In [2]: df
Out[2]:
      age gender
name            
椎名真白   18      女
古明地觉   17      女
古明地恋   16      女
# 这里指定"name"作为索引，另外除了指定单个列，还可以指定多个列，比如["name", "age"]
# 并且我们可以输入列的名字，也可以输入对应的索引。比如:name, age, gender，它们对应的索引就是0, 1, 2

usecols
如果列有很多，而我们不想要全部的列、而是只要指定的列就可以使用这个参数。
 
In [1]: df = pd.read_csv(‘girl.csv‘, delim_whitespace=True, usecols=["name", "age"])

In [2]: df
Out[2]:
   name  age
0  椎名真白   18
1  古明地觉   17
2  古明地恋   16
# 这里只要name和age两列

mangle_dupe_cols
实际生产用的数据会很复杂，有时导入的数据会含有重名的列。参数 mangle_dupe_cols 默认为 True，重名的列导入后面多一个 .1。如果设置为 False，会抛出不支持的异常：
 
# ValueError: Setting mangle_dupe_cols=False is not supported yet

prefix
prefix 参数，当导入的数据没有 header 时，设置此参数会自动加一个前缀。比如：
 
In [1]: df = pd.read_csv(‘girl.csv‘, delim_whitespace=True, header=None)

In [2]: df
Out[2]:
      0    	1      	2
0  name  	age  	gender
1  椎名真白   18       女
2  古明地觉   17       女
3  古明地恋   16       女
# 我们看到在不指定names的时候，header默认为0，表示以第一行为表头
# 但如果不指定names、还显式地将header指定为None，那么会自动生成表头0 1 2 3...
# 因为DataFrame肯定是要有列名(表头)的

In [1]: df = pd.read_csv(‘girl.csv‘, delim_whitespace=True, header=None, prefix="xx")

In [2]: df
Out[2]:
      xx0  xx1     xx2
0  name  	age  	gender
1  椎名真白   18       女
2  古明地觉   17       女
3  古明地恋   16       女
# 而prefix就是给这样的列名增加前缀的
# 但感觉不是很常用

通用解析参数
dtype
笔者就曾遇到一件比较尴尬的事情，就是处理地铁人员数据的。工作人员的id都是以0开头的，比如0100012521，这是一个字符串。但是在读取的时候解析成整型了，结果把开头的0给丢了。这个时候我们就可以通过dtype来指定某个列的类型，就是告诉pandas你在解析的时候按照我指定的类型进行解析。
 
In [1]: df = pd.read_csv(‘girl.csv‘, delim_whitespace=True, dtype={"age": str})

In [2]: df
Out[2]:
   name age gender
0  椎名真白  18      女
1  古明地觉  17      女
2  古明地恋  16      女
# 这里就表示要把age解析成字符串

engine
pandas解析数据时用的引擎，Pandas 目前的解析引擎提供两种：C、Python，默认为 C，因为 C 引擎解析速度更快，但是特性没有 Python 引擎全。如果使用 C 引擎没有的特性时，会自动退化为 Python 引擎。
比如使用分隔符进行解析，如果指定分隔符不是单个字符、或者"s+"，那么C引擎就无法解析了。我们知道如果分隔符为空白字符的话，那么可以指定delim_whitespace=True，但是也可以指定sep=r"s+"。
 
In [1]: df = pd.read_csv(‘girl.csv‘, sep=r"s+")

In [2]: df
Out[2]:
   name age gender
0  椎名真白  18      女
1  古明地觉  17      女
2  古明地恋  16      女
# 如果sep是单个字符，或者字符串s+，那么C是可以解决的。
# 但如果我们指定的sep比较复杂，这时候引擎就会退化。

# 我们指定的s{0}相当于没指定，s+s{0}在结果上等同于s+。
# 但是它不是单个字符，也不是s+，因此此时的C引擎就无法解决了，而是会退化为python引擎
In [1]: df = pd.read_csv(‘girl.csv‘, sep=r"s+s{0}", encoding="utf-8")

In [2]: df
Out[2]:
ParserWarning: Falling back to the ‘python‘ engine 
    because the ‘c‘ engine does not support regex separators (separators > 1 char and different from ‘s+‘ are interpreted as regex); 
	you can avoid this warning by specifying engine=‘python‘.
    
   name  age gender
0  椎名真白   18      女
1  古明地觉   17      女
2  古明地恋   16      女
# 我们看到虽然自动退化，但是弹出了警告，这个时候需要手动的指定engine="python"来避免警告
# 这里面还用到了encoding参数，这个后面会说，因为引擎一旦退化，在Windows上不指定会读出乱码
# 这里我们看到sep是可以支持正则的，但是说实话sep这个参数都会设置成单个字符
# 基本上在生成文件的时候，分隔符不会复杂到读取的时候需要使用正则来分隔的。

converters
可以在读取的时候对列数据进行变换
 
In [1]: df = pd.read_csv(‘girl.csv‘, sep="	", converters={"age": lambda x: int(x) + 10})

In [2]: df
Out[2]:
   name  age gender
0  椎名真白   28      女
1  古明地觉   27      女
2  古明地恋   26      女    

看到少女们都长了10岁，完成对 age 列的数据加 10，注意 int(x)，此处解析器默认所有列的类型为 str，所以需要显式类型转换。
true_values和false_value
指定哪些值应该被清洗为True，哪些值被清洗为False。这两位老铁需要成对出现，只出现一个没有效果。但是说实话，这个不常用
 
In [1]: df = pd.read_csv(‘girl.csv‘, sep="	")

In [2]: df
Out[2]:
   name  	age   gender 对错
0  椎名真白   18      女  对
1  古明地觉   17      女  错
2  古明地恋   16      女  对    
# 加了一个字段

In [1]: df = pd.read_csv(‘girl.csv‘, sep="	", true_values=["对"], false_values=["错"])

In [2]: df
Out[2]:
   name  	age   gender  对错
0  椎名真白   18      女   True
1  古明地觉   17      女  False
2  古明地恋   16      女   True    

skiprows
skiprows 过滤行，想过滤掉哪些行，就写在一个列表里面传递给skiprows即可。注意的是：这里是先过滤，然后再确定表头，比如：
 
In [1]: df = pd.read_csv(‘girl.csv‘, sep="	", skiprows=[0])

In [2]: df
Out[2]:
   椎名真白  18  女  对
0  古明地觉  17  女  错
1  古明地恋  16  女  对
# 我们把第一行过滤掉了，但是第一行是表头
# 所以过滤掉之后，第二行就变成表头了

# 这里过滤第二行
In [1]: df = pd.read_csv(‘girl.csv‘, sep="	", skiprows=[1])

In [2]: df
Out[2]:
   name  	age   gender 对错
0  古明地觉   17      女  错
1  古明地恋   16      女  对    

里面除了传入具体的数值，来表明要过滤掉哪一行，还可以传入一个函数
 
In [1]: df = pd.read_csv(‘girl.csv‘, sep="	", skiprows=lambda x: x > 0 and x % 2 == 0)

In [2]: df
Out[2]:
   name  	age   gender 对错
0  椎名真白   18      女  对
1  古明地恋   16      女  对  
# 由于索引从0开始，凡是索引大于0、并且%2等于0的记录都过滤掉
# 索引大于0，是为了保证表头不被过滤掉 

skipfooter
从文件末尾过滤行，解析引擎退化为 Python。这是因为 C 解析引擎没有这个特性。
 
In [1]: df = pd.read_csv(‘girl.csv‘, sep="	", skipfooter=1, encoding="utf-8", engine="python")

In [2]: df
Out[2]:
   name  	age   gender 对错
0  椎名真白   18      女  对
1  古明地觉   17      女  错   
# skipfooter接收整型，表示从结尾往上过滤掉指定数量的行
# 因为引擎退化为python，那么要手动指定engine="python"，不然会警告
# 另外需要指定encoding="utf-8"，因为csv存在编码问题，当引擎退化为python的时候，在Windows上读取会乱码

nrows
nrows 参数设置一次性读入的文件行数，它在读入大文件时很有用，比如 16G 内存的PC无法容纳几百 G 的大文件。
low_memory
这个看起来是和内存有关的，但其实它是和数据类型相关的。在解释这个原因之前，我们还要先从DataFrame的数据类型说起。
我们知道得到DataFrame的每一列都是有类型的，那么在读取csv的时候，pandas也是要根据数据来判断每一列的类型的。但pandas主要是靠"猜"的方法，因为在读取csv的时候是分块读取的，每读取一块的时候，会根据数据来判断每一列是什么类型；然后再读取下一块，会再对类型进行一个判断，得到每一列的类型，如果得到的结果和上一个块得到结果不一样，那么就会发出警告，提示有以下的列存在多种数据类型：
 
DtypeWarning: Columns (1,5,8,......) have mixed types. Specify dtype option on import or set low_memory=False.

而为了保证正常读取，那么会把类型像大的方向兼容，比如第一个块的user_id解释成整型，但是第二个块发现user_id有的值无法解析成整型的，那么类型整体就会变成字符串，于是pandas提示该列存在混合类型。而一旦设置low_memory=False，那么pandas在读取csv的时候就不分块读了，而是直接将文件全部读取到内存里面，这样只需要对整体进行一次判断，就能得到每一列的类型。但是这种方式也有缺陷，一旦csv过大，就会内存溢出。
但是从数据库读取就不用担心了，因为数据库是规定了每一列的类型的。如果是从数据库读取得到的DataFrame，那么每一列的数据类型和数据库表中的类型是一致的。
还有，我们在上面介绍了dtype，这个是我们手动规定类型。那么pandas就会按照我们规定的类型去解析指定的列，但是一旦无法解析就会报错。
memory_map
如果你知道python的一个模块mmap，那么你肯定很好理解。如果使用的数据在内存里，那么直接进行映射即可，不会再次进行IO操作。默认为False
空值处理相关参数
na_values
na_values 参数可以配置哪些值需要处理成 NaN，这个是非常常用的，但是用的人不多。
 
df = pd.read_csv(‘girl.csv‘)
print(df)
"""
      name  age gender
0  mashiro   18      女
1        #   17      女
2   koishi   16      #
"""

# 将#全部换成NaN
df = pd.read_csv(‘girl.csv‘, na_values=["#"])
print(df)
"""
      name  age gender
0  mashiro   18      女
1      NaN   17      女
2   koishi   16    NaN
"""

# 也可以指定多个值
df = pd.read_csv(‘girl.csv‘, na_values=["#", "mashiro"])
print(df)
"""
     name  age gender
0     NaN   18      女
1     NaN   17      女
2  koishi   16    NaN
"""

# 也可以只对指定的列进行替换
df = pd.read_csv(‘girl.csv‘, na_values={"name": ["#"], "gender": ["女"]})
print(df)
"""
      name  age gender
0  mashiro   18    NaN
1      NaN   17    NaN
2   koishi   16      #
"""

keep_default_na 是和 na_values 搭配的，如果前者为 True，则 na_values 被解析为 Na/NaN 的字符除了用户设置外，还包括默认值。默认为True
skip_blank_lines
skip_blank_lines 默认为 True，则过滤掉空行，如为 False 则解析为 NaN
verbose
打印一些重要信息
时间处理相关参数
parse_dates
指定某些列为时间类型。
 
df = pd.read_csv("xx.csv", parse_dates=["column"])

date_parser
date_parser 参数定制某种时间类型，详细使用过程总结如下。因为有些格式虽然是日期，但不是那种可以直接转换的样子：比如‘2018-01-01‘。可能是这种类型：‘2018年1月1日‘，这个时候我们就需要手动来定制解析的规则
 
df = pd.read_csv("xx.csv", parse_dates=["column"], date_parser=lambda x: pd.datetime.strptime(x, "%Y年%m月%d日"))

infer_datetime_format
infer_datetime_format 参数默认为 False。如果设定为 True 并且 parse_dates 可用，那么 Pandas 将尝试转换为日期类型，如果可以转换，转换方法并解析，在某些情况下会快 5~10 倍。
分块读入相关参数
分块读入内存，尤其单机处理大文件时会很有用。
iterator
iterator 取值 boolean，默认为False。如果为True，那么返回一个 TextFileReader 对象，以便逐块处理文件。这个在文件很大时，内存无法容纳所有数据文件，此时分批读入，依次处理。
 
# 此时返回一个类似于迭代器的对象
chunk = pd.read_csv(‘girl.csv‘, iterator=True)
# 调用get_chunk，里面传入整型，来读取指定的行数
print(chunk.get_chunk(1))
"""
      name  age gender
0  mashiro   18      女
"""
print(chunk.get_chunk(2))
"""
     name  age gender
1       #   17      女
2  koishi   16      #
"""
try:
    print(chunk.get_chunk(2))
except StopIteration:
    print("文件读取完毕")  # 文件读取完毕

# 文件总共三行，所以读完之后，再读就溢出了
# 如果还剩下1行，但是我们指定读取100，那么也不会报错
# 不够指定的行数，那么有多少返回多少

chunksize
chunksize 整型，默认为 None，设置文件块的大小。
 
chunk = pd.read_csv(‘girl.csv‘, chunksize=2)
# 还是返回一个类似于迭代器的对象
print(chunk)  # <pandas.io.parsers.TextFileReader object at 0x00000258C41B2CD0>

# 调用get_chunk，如果不指定行数，那么就是默认的chunksize
print(chunk.get_chunk())
"""
      name  age gender
0  mashiro   18      女
1        #   17      女
"""
# 但也可以指定
print(chunk.get_chunk(1))
"""
     name  age gender
2  koishi   16      #
"""
try:
    print(chunk.get_chunk(2))
except StopIteration:
    print("文件读取完毕")  # 文件读取完毕

格式和压缩相关参数
compression
compression 参数取值为 {‘infer’, ‘gzip’, ‘bz2’, ‘zip’, ‘xz’, None}，默认 ‘infer’，直接使用磁盘上的压缩文件。
如果使用 infer 参数，则使用 gzip、bz2、zip 或者解压文件名中以 ‘.gz’、‘.bz2’、‘.zip’ 或 ‘xz’ 这些为后缀的文件，否则不解压。
如果使用 zip，那么 ZIP 包中必须只包含一个文件。设置为 None 则不解压。
 
# 直接将上面的girl.csv添加到压缩文件，打包成girl.zip
df = pd.read_csv(‘girl.zip‘, compression="zip")
print(df)
"""
      name  age gender
0  mashiro   18      女
1        #   17      女
2   koishi   16      #
"""
# 会自动解包，读取文件，但是如果没有compression参数，那么就会报错了
# UnicodeDecodeError: ‘utf-8‘ codec can‘t decode byte 0xce in position 0: invalid continuation byte

thousands
千分位分割符，如 , 或者 .，默认为None
encoding
encoding 指定字符集类型，通常指定为 ‘utf-8‘。根据情况也可能是ISO-8859-1
error_bad_lines和warn_bad_lines
如果一行包含过多的列，假设csv的数据有3列，但是某一行却有4个数据，显然数据有问题。那么默认情况下不会返回DataFrame，而是会报错。
 
# pandas.errors.ParserError: Error tokenizing data. C error: Expected 3 fields in line 3, saw 4

我们在某一行中多加了一个数据，结果显示错误。因为girl.csv里面有三列，但是有一行却有四个数据，所以报错。
在小样本读取时，这个错误很快就能发现。但是如果样本比较大、并且由于数据集不可能那么干净、很容易出现这种情况，那么该怎么办呢？而且这种情况下，Excel基本上是打不开这么大的文件的。这个时候我们就可以将error_bad_lines设置为False(默认为True)，意思是遇到这种情况，直接把这一行给我扔掉。同时会设置 warn_bad_lines 设置为True，打印剔除的这行。
 
df = pd.read_csv(‘girl.csv‘, error_bad_lines=False, warn_bad_lines=True)
print(df)
"""
      name  age gender
0  mashiro   18      女
1   koishi   16      #

b‘Skipping line 3: expected 3 fields, saw 4
‘
"""

以上两参数只能在C解析引擎下使用。
总结
pandas在读取csv的时候支持的参数是很多的，其中部分参数也适用于读取其它类型的文件。这些参数虽然很多平常都不会用，但是还是要了解，因为read_csv的其它参数是可以很方便地解决某些问题的。
 
原文：https://www.cnblogs.com/traditional/p/12514914.html
以上是关于pandas中的read_csv参数详解的主要内容，如果未能解决你的问题，请参考以下文章 
 Pandas总结第二节 Pandas 的数据读取_pd.read_csv()的使用详解（非常全面，推荐收藏）
 Python Pandas——Read_csv详解
 为啥 Pandas 在 read_csv 时会导致 ZeroDivisionError
 Python Pandas 中的引擎 read_csv
 pandas使用read_csv函数读取csv数据设置parse_dates参数将csv数据中的指定字段数据列解析为时间日期对象
 2000字详解 当Pandas遇上超大规模的数据集该如何处理呢？