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)
