pd.read_csv()参数

filepath_or_buffer : various   文件路径
sep 以什么分割
delimiter : str, default None   以什么分割默认为none
delim_whitespace : boolean, default False   Equivalent to setting sep='\s+'
header : int or list of ints, default 'infer'   header=0表示文件的第一行
也可以写header=[1,2,3]当列名   要是没有列名可以这样header=None一般和names用在一起
names 表示用的列名用列表来装，最好不要有重复值，别忘记rename方法
index_col : int or sequence or False, default None  指定那一列作为行的索引，可以是数字可以是列表，要是最后有分隔符的话可以把index_col=False
usecols : list-like or callable, default None    返回给的列表的子集，需要看你自己想要哪一列的数据，如   usecols=[1, 5]只会读取第一和第5列，也可以是自己定义的列名
from pandas.compat import StringIO, BytesIO
data = ('col1,col2,col3\n''a,b,1\n''a,b,2\n''c,d,3')
pd.read_csv(StringIO(data))
squeeze : boolean, default False  解析的数据如果只返回1列则返回Series
prefix : str, default None 在没有标题的时候添加列号的前缀， 你可以这样用header=None, prefix='x'
mangle_dupe_cols : boolean, default True   把重复的列设置为X’, ‘X.1’…’X.N’
dtype : Type name or dict of column -> type, default None
dtype : Type name or dict of column -> type, default None 读取数据的时候设置各个列的不同的类型
可以是这样{'a': str}, str
engine : {'c', 'python'}   支持的引擎，c 的引擎是最快的但是python引擎兼容性更强
converters : dict, default None  在某一列中转换值我的用法是converters={'col1': lambda x: x.upper()}  感觉和apply用起来差不多
true_values : list, default None   把列表中的值设置为True
false_values    把列表中的值设置为False 例如   false_false=['我'] 就会把是‘我’的字全部变为False
skipinitialspace : boolean, default False  跳过分隔符后的空格
skiprows : list-like or integer, default None   跳过开头的几行
pd.read_csv(StringIO(data), skiprows=lambda x: x % 2 != 0)
skipfooter : int, default 0
nrows   用来读取的文件的行数一般用来读取大文件时候用的
memory_map : boolean, default False   如果为filepath_或_缓冲区提供了filepath，请将文件对象直接映射到内存中，并从内存中直接访问数据。使用此选项可以提高性能，因为不再有任何I/O开销。
na_values : scalar, str, list-like, or dict, default None  把什么值设置为Nan比如吧bat设置为Nan值可以这样na_values=['bat]
keep_default_na : boolean, default True

na_filter : boolean, default True  如果=False 前面2项设置无效
在没有na值的文件里面=False可以提高大型文件的读取速度
verbose : boolean, default False
skip_blank_lines : boolean, default True  如果为真，则跳过空行，而不是将其解释为NaN值。
parse_dates : boolean or list of ints or names or list of lists or dict, default False.
If True -> try parsing the index.    会自动分析日期
If [1, 2, 3] -> try parsing columns 1, 2, 3 each as a separate date column.
If [[1, 3]] -> combine columns 1 and 3 and parse as a single date column.
If {'foo': [1, 3]} -> parse columns 1, 3 as date and call result ‘foo’. A fast-path exists for iso8601-formatted dates.
infer_datetime_format : boolean, default False
If True and parse_dates is enabled for a column, attempt to infer the datetime format to speed up the processing.
keep_date_col : boolean, default False
If True and parse_dates specifies combining multiple columns then keep the original columns.
date_parser : function, default None
dayfirst : boolean, default False
DD/MM format dates, international and European format.
iterator : boolean, default False 返回textfileReader对象进行迭代或使用get_chunk（）获取块。
chunksize : int, default None
compression : {'infer', 'gzip', 'bz2', 'zip', 'xz', None}, default 'infer'}
用于动态解压缩磁盘上的数据。如果filepath_或_buffer是分别以“.gz”、“.bz2”、“.zip”或“.xz”结尾的字符串，则使用gzip、bz2、zip或xz，否则不进行解压缩。如果使用“zip”，则zip文件只能包含一个要读取的数据文件。设置为“None”表示无解压缩。
thousands : str, default None  千位分隔符
decimal : str, default '.'
要识别为小数点的字符。例如，使用“，”作为欧洲数据。
float_precision : string, default None
comment : str, default None
encoding : str, default None
error_bad_lines : boolean, default True    是否跳过错误的行  默认是不跳过2
warn_bad_lines : boolean, default True
df['col_1'].apply(type).value_counts()
df2['col_1'] = pd.to_numeric(df2['col_1'], errors='coerce')
最后，如何处理包含混合数据类型的列中的读取取决于您的特定需求。在上面的例子中，如果您想消除数据异常，那么使用to_numeric（）可能是您的最佳选择。但是，如果您希望强制所有数据，不管是哪种类型，那么使用read_csv（）的converters参数肯定是值得尝试的。
rom pandas.api.types import CategoricalDtype
dtype = CategoricalDtype(['a', 'b', 'd'])  # No 'c'
pd.read_csv(StringIO(data), dtype={'col1': dtype}).col1
df['col3'].cat.categories = pd.to_numeric(df['col3'].cat.categories)
pd.read_csv(StringIO(data), usecols=[0, 2, 3])
pd.read_csv(StringIO(data), usecols=lambda x: x.upper() in ['A', 'C'])
pd.read_csv(StringIO(data), usecols=lambda x: x not in ['a', 'c'])
忽略行注释和空行
data = ('\n'
   ....:         'a,b,c\n'
   ....:         '  \n'
   ....:         '# commented line\n'
   ....:         '1,2,3\n'
   ....:         '\n'
   ....:         '4,5,6')
pd.read_csv(StringIO(data), comment='#')
If skip_blank_lines=False, then read_csv will not ignore blank lines:
data = ('a,b,c\n'
   ....:         '\n'
   ....:         '1,2,3\n'
   ....:         '\n'
   ....:         '\n'
   ....:         '4,5,6')
pd.read_csv(StringIO(data), skip_blank_lines=False)
data = ('#comment\n'
   ....:         'a,b,c\n'
   ....:         'A,B,C\n'
   ....:         '1,2,3')
 pd.read_csv(StringIO(data), comment='#', header=1)
data = ('A,B,C\n'
   ....:         '#comment\n'
   ....:         'a,b,c\n'
   ....:         '1,2,3')
pd.read_csv(StringIO(data), comment='#', skiprows=2)
data = ('# empty\n'
   ....:         '# second empty line\n'
   ....:         '# third emptyline\n'
   ....:         'X,Y,Z\n'
   ....:         '1,2,3\n'
   ....:         'A,B,C\n'
   ....:         '1,2.,4.\n'
   ....:         '5.,NaN,10.0\n')
pd.read_csv(StringIO(data), comment='#', skiprows=4, header=1)
当文件在每个数据行的末尾都准备了分隔符时，会出现一些异常情况，这会混淆解析器。若要显式禁用索引列推理并放弃最后一列，请通过index_col=False:
 pd.read_csv(StringIO(data), index_col=False)
 df = pd.read_csv('foo.csv', index_col=0, parse_dates=True)
KORD,19990127, 19:00:00, 18:56:00, 0.8100
KORD,19990127, 20:00:00, 19:56:00, 0.0100
KORD,19990127, 21:00:00, 20:56:00, -0.5900
KORD,19990127, 21:00:00, 21:18:00, -0.9900
KORD,19990127, 22:00:00, 21:56:00, -0.5900
KORD,19990127, 23:00:00, 22:56:00, -0.5900
df = pd.read_csv('tmp.csv', header=None, parse_dates=[[1, 2], [1, 3]])
                  1_2                 1_3     0     4
0 1999-01-27 19:00:00 1999-01-27 18:56:00  KORD  0.81
1 1999-01-27 20:00:00 1999-01-27 19:56:00  KORD  0.01
2 1999-01-27 21:00:00 1999-01-27 20:56:00  KORD -0.59
3 1999-01-27 21:00:00 1999-01-27 21:18:00  KORD -0.99
4 1999-01-27 22:00:00 1999-01-27 21:56:00  KORD -0.59
5 1999-01-27 23:00:00 1999-01-27 22:56:00  KORD -0.59
df = pd.read_csv('tmp.csv', header=None, parse_dates=[[1, 2], [1, 3]],keep_date_col=True)
默认情况下，解析器会删除组件日期列，但您可以通过“保留日期”列选择保留它们。
df = pd.read_csv('tmp.csv', header=None, parse_dates=[[1, 2], [1, 3]],keep_date_col=True)
                  1_2                 1_3     0         1          2          3     4
0 1999-01-27 19:00:00 1999-01-27 18:56:00  KORD  19990127   19:00:00   18:56:00  0.81
1 1999-01-27 20:00:00 1999-01-27 19:56:00  KORD  19990127   20:00:00   19:56:00  0.01
2 1999-01-27 21:00:00 1999-01-27 20:56:00  KORD  19990127   21:00:00   20:56:00 -0.59
3 1999-01-27 21:00:00 1999-01-27 21:18:00  KORD  19990127   21:00:00   21:18:00 -0.99
4 1999-01-27 22:00:00 1999-01-27 21:56:00  KORD  19990127   22:00:00   21:56:00 -0.59
5 1999-01-27 23:00:00 1999-01-27 22:56:00  KORD  19990127   23:00:00   22:56:00 -0.59
请注意，如果要将多个列合并为单个日期列，则必须使用嵌套列表。换言之，parse_dates=[1，2]表示第二列和第三列应分别分析为单独的日期列，parse_dates=[[1，2]]表示两列应分析为单个列。
date_spec = {'nominal': [1, 2], 'actual': [1, 3]}
df = pd.read_csv('tmp.csv', header=None, parse_dates=date_spec)
              nominal              actual     0     4
0 1999-01-27 19:00:00 1999-01-27 18:56:00  KORD  0.81
1 1999-01-27 20:00:00 1999-01-27 19:56:00  KORD  0.01
2 1999-01-27 21:00:00 1999-01-27 20:56:00  KORD -0.59
3 1999-01-27 21:00:00 1999-01-27 21:18:00  KORD -0.99
4 1999-01-27 22:00:00 1999-01-27 21:56:00  KORD -0.59
5 1999-01-27 23:00:00 1999-01-27 22:56:00  KORD -0.59
date_spec = {'nominal': [1, 2], 'actual': [1, 3]}
重要的是要记住，如果要将多个文本列解析为单个日期列，则数据前面会有一个新列。索引列规范基于这组新列，而不是原始数据列：
df = pd.read_csv('tmp.csv', header=None, parse_dates=date_spec,index_col=0)
                             actual     0     4
nominal                                            
1999-01-27 19:00:00 1999-01-27 18:56:00  KORD  0.81
1999-01-27 20:00:00 1999-01-27 19:56:00  KORD  0.01
1999-01-27 21:00:00 1999-01-27 20:56:00  KORD -0.59
1999-01-27 21:00:00 1999-01-27 21:18:00  KORD -0.99
1999-01-27 22:00:00 1999-01-27 21:56:00  KORD -0.59
1999-01-27 23:00:00 1999-01-27 22:56:00  KORD -0.59
可以自己定义时间日期解析函数，以保证数据的灵活性
df = pd.read_csv('tmp.csv', header=None, parse_dates=date_spec,date_parser=pd.io.date_converters.parse_date_time)
              nominal              actual     0     4
0 1999-01-27 19:00:00 1999-01-27 18:56:00  KORD  0.81
1 1999-01-27 20:00:00 1999-01-27 19:56:00  KORD  0.01
2 1999-01-27 21:00:00 1999-01-27 20:56:00  KORD -0.59
3 1999-01-27 21:00:00 1999-01-27 21:18:00  KORD -0.99
4 1999-01-27 22:00:00 1999-01-27 21:56:00  KORD -0.59
5 1999-01-27 23:00:00 1999-01-27 22:56:00  KORD -0.59
If you know the format, use pd.to_datetime(): date_parser=lambda x: pd.to_datetime(x, format=...).
0    2000-01-01 00:00:00+05:00
1    2000-01-01 00:00:00+06:00
df = pd.read_csv(StringIO(content), parse_dates=['a'],date_parser=lambda col: pd.to_datetime(col, utc=True))
0   1999-12-31 19:00:00+00:00
1   1999-12-31 18:00:00+00:00
Name: a, dtype: datetime64[ns, UTC]
请注意，推断日期时间格式对dayFirst敏感。如果dayFirst=true，则猜测“01/12/2011”为12月1日。如果dayFirst=false（默认），则猜测“01/12/2011”为1月12日。
df = pd.read_csv('foo.csv', index_col=0, parse_dates=True,infer_datetime_format=True)
            A  B  C
date               
2009-01-01  a  1  2
2009-01-02  b  3  4
2009-01-03  c  4  5
val = '0.3066101993807095471566981359501369297504425048828125'
data = 'a,b,c\n1,2,{0}'.format(val)
abs(pd.read_csv(StringIO(data), engine='c',float_precision=None)['c'][0] - float(val))
默认情况下，带有千位分隔符的数字将被分析为字符串：
df = pd.read_csv('tmp.csv', sep='|')
         ID      level category
0  Patient1    123,000        x
1  Patient2     23,000        y
2  Patient3  1,234,018        z
pd.read_csv('path_to_file.csv', na_values=[5])
pd.read_csv('path_to_file.csv', keep_default_na=False, na_values=[""])  只有一个空字段才会设置为Nan的值
pd.read_csv('path_to_file.csv', keep_default_na=False, na_values=["NA", "0"])
pd.read_csv('path_to_file.csv', na_values=["Nope"])
类似inf的值将被解析为np.inf（正无穷大），而-inf将被解析为-np.inf（负无穷大）。这些将忽略值的大小写，即inf，也将被解析为np.inf。
某些文件的行格式可能不正确，字段太少或太多。字段太少的行将在尾部字段中填充NA值。字段太多的行将在默认情况下引发错误：
解决方法You can elect to skip bad lines:
# data = ('a,b,c\n''1,2,3\n''4,5,6,7\n''8,9,10')
pd.read_csv(StringIO(data), error_bad_lines=False)
df = pd.read_csv(StringIO(data))
pd.read_csv(StringIO(data), usecols=[0, 1, 2])
Dialect  感觉是解析方法把，我也不懂
import csv
dia = csv.excel()
dia.quoting = csv.QUOTE_NONE
pd.read_csv(StringIO(data), dialect=dia)
pd.read_csv(StringIO(data), skipinitialspace=True)    跳过分隔符后面的空格
data = 'a,b\n"hello, \\"Bob\\", nice to see you",5'
pd.read_csv(StringIO(data), escapechar='\\')
df = pd.read_csv('foo.csv', parse_dates=True)   # 可以自动分析日期
pd.read_csv('mi.csv', header=[0, 1, 2, 3], index_col=[0, 1])
df = pd.read_csv('D:/data/20190704_mvs.csv', sep=None, engine='python', encoding='utf-8')
可以自动的嗅探分割符号
reader = pd.read_csv('tmp.sv', sep='|', iterator=True)
reader.get_chunk(5)