精华内容
下载资源
问答
  • pd.read_csv参数详解

    千次阅读 2019-03-31 10:24:54
    pd.read_csv参数详解 转自:https://www.cnblogs.com/datablog/p/6127000.html 参数: filepath_or_buffer : str,pathlib。str, pathlib.Path, py._path.local.LocalPath or any object with a read() method (such...

    pd.read_csv参数详解

    转自:https://www.cnblogs.com/datablog/p/6127000.html
    参数:
    filepath_or_buffer : str,pathlib。str, pathlib.Path, py._path.local.LocalPath or any object with a read() method (such as a file handle or StringIO)
    可以是URL,可用URL类型包括:http, ftp, s3和文件。对于多文件正在准备中
    本地文件读取实例:?/localhost/path/to/table.csv

    sep : str, default ‘,’
    指定分隔符。如果不指定参数,则会尝试使用逗号分隔。分隔符长于一个字符并且不是‘\s+’,将使用python的语法分析器。并且忽略数据中的逗号。正则表达式例子:’\r\t’

    delimiter : str, default None
    定界符,备选分隔符(如果指定该参数,则sep参数失效)

    delim_whitespace : boolean, default False.
    指定空格(例如’ ‘或者’ ‘)是否作为分隔符使用,等效于设定sep=’\s+’。如果这个参数设定为Ture那么delimiter 参数失效。
    在新版本0.18.1支持

    header : int or list of ints, 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表示第一行数据而不是文件的第一行。

    names : array-like, default None
    用于结果的列名列表,如果数据文件中没有列标题行,就需要执行header=None。默认列表中不能出现重复,除非设定参数mangle_dupe_cols=True。

    index_col : int or sequence or False, default None
    用作行索引的列编号或者列名,如果给定一个序列则有多个行索引。
    如果文件不规则,行尾有分隔符,则可以设定index_col=False 来是的pandas不适用第一列作为行索引。

    usecols : array-like, default None
    返回一个数据子集,该列表中的值必须可以对应到文件中的位置(数字可以对应到指定的列)或者是字符传为文件中的列名。例如:usecols有效参数可能是 [0,1,2]或者是 [‘foo’, ‘bar’, ‘baz’]。使用这个参数可以加快加载速度并降低内存消耗。

    as_recarray : boolean, default False
    不赞成使用:该参数会在未来版本移除。请使用pd.read_csv(…).to_records()替代。
    返回一个Numpy的recarray来替代DataFrame。如果该参数设定为True。将会优先squeeze参数使用。并且行索引将不再可用,索引列也将被忽略。

    squeeze : boolean, default False
    如果文件值包含一列,则返回一个Series

    prefix : str, default None
    在没有列标题时,给列添加前缀。例如:添加‘X’ 成为 X0, X1, …

    mangle_dupe_cols : boolean, default True
    重复的列,将‘X’…’X’表示为‘X.0’…’X.N’。如果设定为false则会将所有重名列覆盖。

    dtype : Type name or dict of column -> type, default None
    每列数据的数据类型。例如 {‘a’: np.float64, ‘b’: np.int32}

    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引擎功能更加完备。

    converters : dict, default None
    列转换函数的字典。key可以是列名或者列的序号。

    true_values : list, default None
    Values to consider as True

    false_values : list, default None
    Values to consider as False

    skipinitialspace : boolean, default False
    忽略分隔符后的空白(默认为False,即不忽略).

    skiprows : list-like or integer, default None
    需要忽略的行数(从文件开始处算起),或需要跳过的行号列表(从0开始)。

    skipfooter : int, default 0
    从文件尾部开始忽略。 (c引擎不支持)

    skip_footer : int, default 0
    不推荐使用:建议使用skipfooter ,功能一样。

    nrows : int, default None
    需要读取的行数(从文件头开始算起)。

    na_values : scalar, str, list-like, or dict, default None
    一组用于替换NA/NaN的值。如果传参,需要制定特定列的空值。默认为‘1.#IND’, ‘1.#QNAN’, ‘N/A’, ‘NA’, ‘NULL’, ‘NaN’, ‘nan’`.

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

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

    verbose : boolean, default False
    是否打印各种解析器的输出信息,例如:“非数值列中缺失值的数量”等。

    skip_blank_lines : boolean, default True
    如果为True,则跳过空行;否则记为NaN。

    parse_dates : boolean or list of ints 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"

    infer_datetime_format : boolean, default False
    如果设定为True并且parse_dates 可用,那么pandas将尝试转换为日期类型,如果可以转换,转换方法并解析。在某些情况下会快5~10倍。

    keep_date_col : boolean, default False
    如果连接多列解析日期,则保持参与连接的列。默认为False。

    date_parser : function, default None
    用于解析日期的函数,默认使用dateutil.parser.parser来做转换。Pandas尝试使用三种不同的方式解析,如果遇到问题则使用下一种方式。
    1.使用一个或者多个arrays(由parse_dates指定)作为参数;
    2.连接指定多列字符串作为一个列作为参数;
    3.每行调用一次date_parser函数来解析一个或者多个字符串(由parse_dates指定)作为参数。

    dayfirst : boolean, default False
    DD/MM格式的日期类型

    iterator : boolean, default False
    返回一个TextFileReader 对象,以便逐块处理文件。

    chunksize : int, default None
    文件块的大小, See IO Tools docs for more informationon iterator and chunksize.

    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解压

    thousands : str, default None
    千分位分割符,如“,”或者“."

    decimal : str, default ‘.’
    字符中的小数点 (例如:欧洲数据使用’,‘).

    float_precision : string, default None
    Specifies which converter the C engine should use for floating-point values. The options are None for the ordinary converter, high for the high-precision converter, and round_trip for the round-trip converter.
    指定

    lineterminator : str (length 1), default None
    行分割符,只在C解析器下使用。

    quotechar : str (length 1), optional
    引号,用作标识开始和解释的字符,引号内的分割符将被忽略。

    quoting : int or csv.QUOTE_* instance, default 0
    控制csv中的引号常量。可选 QUOTE_MINIMAL (0), QUOTE_ALL (1), QUOTE_NONNUMERIC (2) or QUOTE_NONE (3)

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

    escapechar : str (length 1), default None
    当quoting 为QUOTE_NONE时,指定一个字符使的不受分隔符限值。

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

    encoding : str, default None
    指定字符集类型,通常指定为’utf-8’. List of Python standard encodings

    dialect : str or csv.Dialect instance, default None
    如果没有指定特定的语言,如果sep大于一个字符则忽略。具体查看csv.Dialect 文档

    tupleize_cols : boolean, default False
    Leave a list of tuples on columns as is (default is to convert to a Multi Index on the columns)

    error_bad_lines : boolean, default True
    如果一行包含太多的列,那么默认不会返回DataFrame ,如果设置成false,那么会将改行剔除(只能在C解析器下使用)。

    warn_bad_lines : boolean, default True
    如果error_bad_lines =False,并且warn_bad_lines =True 那么所有的“bad lines”将会被输出(只能在C解析器下使用)。

    low_memory : boolean, default True
    分块加载到内存,再低内存消耗中解析。但是可能出现类型混淆。确保类型不被混淆需要设置为False。或者使用dtype 参数指定类型。注意使用chunksize 或者iterator 参数分块读入会将整个文件读入到一个Dataframe,而忽略类型(只能在C解析器中有效)

    buffer_lines : int, default None
    不推荐使用,这个参数将会在未来版本移除,因为他的值在解析器中不推荐使用

    compact_ints : boolean, default False
    不推荐使用,这个参数将会在未来版本移除
    如果设置compact_ints=True ,那么任何有整数类型构成的列将被按照最小的整数类型存储,是否有符号将取决于use_unsigned 参数

    use_unsigned : boolean, default False
    不推荐使用:这个参数将会在未来版本移除
    如果整数列被压缩(i.e. compact_ints=True),指定被压缩的列是有符号还是无符号的。
    memory_map : boolean, default False
    如果使用的文件在内存内,那么直接map文件使用。使用这种方式可以避免文件再次进行IO操作。

    展开全文
  • pd.read_csv()参数

    千次阅读 2019-07-05 12:19:05
    但是,如果您希望强制所有数据,不管是哪种类型,那么使用read_csv()的converters参数肯定是值得尝试的。 rom pandas.api.types import CategoricalDtype dtype = CategoricalDtype(['a', 'b', 'd']) # No 'c' pd....
    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)
    
    

     

    展开全文
  • 一、pandas.read_csv常用参数整理 也支持文件的部分导入和选择迭代,更多帮助参见:http://pandas.pydata.org/pandas-docs/stable/io.html 参数: filepath_or_buffer :可以是URL,可用URL类

    pandas.read_csv可以读取CSV(逗号分割)文件、文本类型的文件text、log类型到DataFrame

    一、pandas.read_csv常用参数整理

    也支持文件的部分导入和选择迭代,更多帮助参见:http://pandas.pydata.org/pandas-docs/stable/io.html

    参数:

    • filepath_or_buffer :可以是URL,可用URL类型包括:http, ftp, s3和文件。对于多文件正在准备中本地文件读取。
      实例1:实现图片中文件的读取,注意图片中的所有输入基于英文输入下得到,返回DataFrame文件
      这里写图片描述
    In [1]: import pandas as pd
    #读取out.log文件,其他的参数默认
    In [2]: out = pd.read_csv('out.log')
    
    In [3]: out
    Out[3]:
            book  kook
    0      joke2  dddd
    1      fang3   NaN
    2      test1   NaN
    3      test2   NaN
    4      test3   NaN
    5  1997/10/2   NaN

    实例2:读取股票数据csv文件,返回DataFrame文件

    In [4]: stock = pd.read_csv('000777.csv')
    
    In [5]: stock
    Out[5]:
                date     code  closing   high    low  opening  pre_closing    zde  \
    0      2017/1/20  '000777    21.17  21.29  20.90    20.90        20.86   0.31
    1      2017/1/19  '000777    20.86  21.14  20.82    21.12        21.12  -0.26
    2      2017/1/18  '000777    21.12  21.44  21.09    21.40        21.37  -0.25
    3      2017/1/17  '000777    21.37  21.49  20.75    21.17        21.15   0.22
    4      2017/1/16  '000777    21.15  22.50  20.28    22.50        22.53  -1.38
    5      2017/1/13  '000777    22.53  22.88  22.43    22.71        22.85  -0.32
    6      2017/1/12  '000777    22.85  23.53  22.75    23.41        23.51  -0.66
    • sep如果不指定参数,则会尝试使用逗号分隔。分隔符长于一个字符并且不是‘\s+’,将使用python的语法分析器。并且忽略数据中的逗号。正则表达式例子:’\r\t’。
    In [6]: a = pd.read_csv('out.log',sep = '\s')
    C:/Anaconda3/Scripts/ipython-script.py:1: 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'.
      if __name__ == '__main__':
    #设定空值作为分隔符,','不会分割每一行的数据
    In [7]: a
    Out[7]:
        book,kook
    0  joke2,dddd
    1       fang3
    2       test1
    3       test2
    4       test3
    5   1997/10/2
    #空值的设定两种方式:' ' or '\s'
    In [9]: a = pd.read_csv('out.log',sep = ' ')
    
    In [10]: a
    Out[10]:
        book,kook
    0  joke2,dddd
    1       fang3
    2       test1
    3       test2
    4       test3
    5   1997/10/2
    • delimiter定界符,备选分隔符如果指定该参数,则sep参数失效
    In [13]: a = pd.read_csv('out.log',sep = ', ',delimiter='o')
    #此时sep = ','设定失效
    In [14]: a
    Out[14]:
               b Unnamed: 1  k,k  Unnamed: 3   k
    0          j   ke2,dddd  NaN         NaN NaN
    1      fang3        NaN  NaN         NaN NaN
    2      test1        NaN  NaN         NaN NaN
    3      test2        NaN  NaN         NaN NaN
    4      test3        NaN  NaN         NaN NaN
    5  1997/10/2        NaN  NaN         NaN NaN
    • delim_whitespace指定空格(例如’ ‘或者’ ‘)是否作为分隔符使用,等效于设定sep=’\s+’。如果这个参数设定为True那么delimiter 参数失效。
    In [20]: a = pd.read_csv('out.log',delim_whitespace = True)
    
    In [21]: a
    Out[21]:
        book,kook
    0  joke2,dddd
    1       fang3
    2       test1
    3       test2
    4       test3
    5   1997/10/2
    • header指定行数用来作为列名,数据开始行数如果文件中没有列名,则默认为0【第一行数据】,否则设置为None。如果明确设定 header = 0 就会替换掉原来存在列名。header参数可以是一个list例如:[0,1,3],这个list表示将文件中的这些行作为列标题(意味着每一列有多个标题),介于中间的行将被忽略掉。注意:如果skip_blank_lines=True 那么header参数忽略注释行和空行,所以header=0表示第一行数据而不是文件的第一行。
    In [22]: a = pd.read_csv('out.log',delim_whitespace = True,header = None)
    
    In [23]: a
    Out[23]:
                0
    0   book,kook
    1  joke2,dddd
    2       fang3
    3       test1
    4       test2
    5       test3
    6   1997/10/2
    • names用于结果的列名列表,如果数据文件中没有列标题行,就需要执行 header=None。names属性在header之前运行默认列表中不能出现重复,除非设定参数mangle_dupe_cols=True。
    In [32]: a = pd.read_csv('out.log',names='ko')
    
    In [33]: a
    Out[33]:
               k     o
    0       book  kook
    1      joke2  dddd
    2      fang3   NaN
    3      test1   NaN
    4      test2   NaN
    5      test3   NaN
    6  1997/10/2   NaN
    • index_col :用作行索引的列编号或者列名,如果给定一个序列则有多个行索引。
    In [45]: a = pd.read_csv('out.log',header=None,prefix='XX',index_col=0)
    #指定第一列作为行索引
    In [46]: a
    Out[46]:
                XX1
    XX0
    book       kook
    joke2      dddd
    fang3       NaN
    test1       NaN
    test2       NaN
    test3       NaN
    1997/10/2   NaN
    
    In [47]: a = pd.read_csv('out.log',header=None,prefix='XX',index_col=1)
    #指定第二列作为行索引
    In [48]: a
    Out[48]:
                XX0
    XX1
    kook       book
    dddd      joke2
    NaN       fang3
    NaN       test1
    NaN       test2
    NaN       test3
    NaN   1997/10/2
    • usecols:返回一个数据子集,该列表中的值必须可以对应到文件中的位置(数字可以对应到指定的列)或者是字符传为文件中的列名。例如:usecols有效参数可能是 [0,1,2]或者是 [‘foo’, ‘bar’, ‘baz’]。使用这个参数可以加快加载速度并降低内存消耗。
    • prefix在没有列标题时,也就是header设定为None,给列添加前缀。例如:添加prefix= ‘X’ 使得列名称成为 X0, X1, …
    In [38]: a = pd.read_csv('out.log',header=None,prefix='XX')
    
    In [39]: a
    Out[39]:
             XX0   XX1
    0       book  kook
    1      joke2  dddd
    2      fang3   NaN
    3      test1   NaN
    4      test2   NaN
    5      test3   NaN
    6  1997/10/2   NaN
    • dtype: 每列数据的数据类型。例如 {‘a’: np.float64, ‘b’: np.int32}
    In [49]: a = pd.read_csv('out.log',header=None,prefix='XX',index_col=1,dtype={'XX0':str})
    
    In [50]: a
    Out[50]:
                XX0
    XX1
    kook       book
    dddd      joke2
    NaN       fang3
    NaN       test1
    NaN       test2
    NaN       test3
    NaN   1997/10/2
    
    In [51]: a['XX0'].values
    Out[51]: array(['book', 'joke2', 'fang3', 'test1', 'test2', 'test3', '1997/10/2'], dtype=object)
    
    In [52]: a['XX0'].values[0]
    Out[52]: 'book'
    
    In [53]: type(a['XX0'].values[0])
    Out[53]: str
    • skipinitialspace:忽略分隔符后的空白(默认为False,即不忽略).
    • skiprows :需要忽略的行数(从文件开始处算起),或需要跳过的行号列表(从0开始)。
    In [54]: a = pd.read_csv('out.log',header=None,prefix='XX',index_col=1,skiprows= 1)
    #略去第二行的数据
    In [55]: a
    Out[55]:
                XX0
    XX1
    dddd      joke2
    NaN       fang3
    NaN       test1
    NaN       test2
    NaN       test3
    NaN   1997/10/2
    • nrows :需要读取的行数(从文件头开始算起)。
    In [56]: a = pd.read_csv('out.log',header=None,prefix='XX',index_col=1,skiprows= 1,nrows=4)
    
    In [57]: a
    Out[57]:
            XX0
    XX1
    dddd  joke2
    NaN   fang3
    NaN   test1
    NaN   test2
    • na_values :一组用于替换NA/NaN的值。如果传参,需要制定特定列的空值。默认为‘1.#IND’, ‘1.#QNAN’, ‘N/A’, ‘NA’, ‘NULL’, ‘NaN’, ‘nan’`.
    • keep_default_na:如果指定na_values参数,并且keep_default_na=False,那么默认的NaN将被覆盖,否则添加
    • na_filter是否检查丢失值(空字符串或者是空值)。对于大文件来说数据集中没有空值,设定na_filter=False可以提升读取速度。
    • skip_blank_lines :如果为True,则跳过空行;否则记为NaN。
    展开全文
  • pd.read_csv()常用参数

    千次阅读 2020-07-31 20:59:40
    pd.read_csv() pd.read_csv(filepath_or_buffer, sep=',', delimiter=None, header='infer', names=None, index_col=None, usecols=None, squeeze=False, prefix=None, mangle_dupe_cols=True, dtype=None, engine=...

    pd.read_csv()

    pd.read_csv(filepath_or_buffer, sep=',', delimiter=None, header='infer', names=None, index_col=None, usecols=None, squeeze=False, prefix=None, mangle_dupe_cols=True, dtype=None, engine=None, converters=None, true_values=None, false_values=None, skipinitialspace=False, skiprows=None, 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, iterator=False, chunksize=None, compression='infer', thousands=None, decimal=b'.', lineterminator=None, quotechar='"', quoting=0, escapechar=None, comment=None, encoding=None, dialect=None, tupleize_cols=False, error_bad_lines=True, warn_bad_lines=True, skipfooter=0, skip_footer=0, doublequote=True, delim_whitespace=False, as_recarray=False, compact_ints=False, use_unsigned=False, low_memory=True, buffer_lines=None, memory_map=False, float_precision=None)
    

    1.filepath_or_buffer:(这是唯一一个必须有的参数,其它都是按需求选用的)
    文件所在处的路径

    2.sep:
    指定分隔符,默认为逗号’,’

    3.delimiter : str, default None
    定界符,备选分隔符(如果指定该参数,则sep参数失效)

    4.header:int or list of ints, default ‘infer’
    指定哪一行作为表头。默认设置为0(即第一行作为表头),如果没有表头的话,要修改参数,设置header=None

    5.names:
    指定列的名称,用列表表示。一般我们没有表头,即header=None时,这个用来添加列名就很有用啦!

    6.index_col:
    指定哪一列数据作为行索引,可以是一列,也可以多列。多列的话,会看到一个分层索引

    7.prefix:
    给列名添加前缀。如prefix=“x”,会出来"x1"、“x2”、"x3"酱纸

    8.nrows : int, default None
    需要读取的行数(从文件头开始算起)

    9.encoding:
    乱码的时候用这个就是了,官网文档看看用哪个:
    https://docs.python.org/3/library/codecs.html#standard-encodings

    10.skiprows : list-like or integer, default None
    需要忽略的行数(从文件开始处算起),或需要跳过的行号列表(从0开始)。

    展开全文
  • pd.read_csv() 、to_csv() 之 常用参数

    千次阅读 2019-01-25 23:46:00
    本文简单介绍一下read_csv()和 to_csv()的参数,最常用的拿出来讲,较少用的请转到官方文档看。 一.pd.read_csv() 作用:将csv文件读入并转化为数据框形式。 pd.read_csv(filepath_or_buffer, sep=',', delimiter=...
  • parse_dates参数作用: 将csv中的时间字符串转换成日期格式 1、准备数据 TestTime.csv文件: "name","time","date" 'Bob',21:33:30,2019-10-10 'Jerry',21:30:15,2019-10-10 'Tom',21:25:30,2019-10-10 'Vince',21:...
  • Python||pd.read_csv()函数中parse_dates()参数详解

    万次阅读 多人点赞 2018-11-21 14:12:45
    read_csv()参数列表,官方文档 pandas.read_csv(filepath_or_buffer, sep=', ', delimiter=None, header='infer', names=None, index_col=None, usecols=None, squeeze=False, prefix=None, mangle_dupe_cols=True...
  • pandas.read_csv参数超级详解,好多栗子!

    万次阅读 多人点赞 2018-07-26 12:13:52
    前言:相信很多和我一样初入数据处理的小伙伴们肯定不知道,原来习以为常的read_csv还有这么多方便快捷的骚参数,对,就是相当骚的那种骚   首先放出官方手册:点击打开链接,喜欢看英文原稿的同学可以直接看哦!...
  • pd.read_csv() 和pd.to_csv() 常用参数

    千次阅读 2020-03-24 11:18:47
    一、pd.read_csv() 作用:将csv文件读入并转化为数据框形式。 filepath_or_buffer: Union[str, pathlib.Path, IO[~AnyStr]], sep=',', delimiter=None, header='infer', names=None, index_col=None, usecols=...
  • pd.read_csv() engine参数详解

    千次阅读 2020-04-01 17:39:14
    pd.read_csv() engine参数详解
  • pandas.read_csv(path, sep=’\s+’, engine=‘python’) 正则表达式\s匹配任何空白字符,包括\f,\r,\t,\n,\v,如果文本中有多个分隔符(例如空格和tab同时存在),则可以使用sep=’\s+’,第一个\表示转义。
  • pandas.read_csv() 参数 header整理

    千次阅读 2019-10-16 14:21:44
    pandas.read_csv()官方文档 header:int, list of int, default ‘infer’ 指定行数用来作为列名,数据开始行数。如果文件中没有列名,则默认为0,否则设置为None。如果明确设定header=0 就会替换掉原来存在列名...
  • 原因 读取的路径或者是读取的文件名字有中文 解决方法 1....第二种方法是函数里面加一个参数:engine=‘python’ 这样的话路径或者是文件是中文的就没事了 data1=pd.read_csv("岭回归.csv",engine='python')
  • pd.read_csv用法

    万次阅读 多人点赞 2019-04-17 22:16:39
    pd.read_csv(filepath_or_buffer, sep=’, ‘, delimiter=None, header=’infer’, names=None, index_col=None, usecols=None, squeeze=False, prefix=None, mangle_dupe_cols=True, dtype=None, engine=None, ...
  • pandas.read_csv()参数详解

    万次阅读 多人点赞 2019-05-22 12:04:13
      ... pandas.read_csv 老规矩,官方参数走一波...read_csv(filepath_or_buffer, sep=',', delimiter=None, header='infer', names=None, index_col=None, usecols=None, squeeze=False, prefix=None, mangle_dup...
  • 在使用pd.read_csv()读取表格数据时,有"encoding="参数用来描述表格数据采用的编码方式,比较常用的有utf-8,但有时候还是会报错。示例如下: import pandas as pd file_path = "oracle_log.csv" data = pd.read_...
  • pandas.read_csv() 参数 names整理

    千次阅读 2019-10-17 14:17:25
    pandas 官方文档 names: array-like, default None ...默认列表中不能出现重复,除非设定参数mangle_dupe_cols=True。 Age Gender Education EducationField MaritalStatus ...
  • To instantiate a DataFrame from data with element order preserved use pd.read_csv(data,usecols=['foo', 'bar'])[['foo', 'bar']] for columns in ['foo', 'bar'] order orpd.read_csv(data, usecols=['foo', ...
  • pd.read_csv报错

    2019-08-30 16:12:28
    利用pandas的read_csv常规读入CSV数据。...df=pd.read_csv(path,encoding='utf8',low_memory=False) 报错: 卸载pandas,重装pandas。 再次读取数据,仍报错: 网上查找资料有几个解决方法: 1.把当前路...
  • pandas的pd.read_csv函数,quoting = 3是什么意思? 新建一个test.txt文件,内容如下: 哈哈 haha "haha" "哈哈" "ha ha" "哈 哈" 代码: import pandas as pd t = pd.read_csv('test.txt', header=None, sep...
  • 除了使用xlrd库或者xlwt库进行对excel表格的操作读与写,而且pandas库同样支持...首先是pd.read_excel的参数:函数为: pd.read_excel(io, sheetname=0,header=0,skiprows=None,index_col=None,names=None, arse_
  • pd.read_csv读取csv文件 df.to_json写入到json文件 pd.read_json读取json文件 df.to_html写入到html文件 pd.read_html读取 html文件 df.to_excel 写入到 excel 文件 pd.read_excel 读取 excel 文件 pandas....
  • python用pd.read_csv()方法来读取csv文件

    万次阅读 多人点赞 2020-02-12 21:37:55
    csv文件是一种用,和换行...pandas提供了pd.read_csv()方法可以读取其中的数据并且转换成DataFrame数据帧。python的强大之处就在于他可以把不同的数据库类型,比如txt/csv/.xls/.sql转换成统一的DataFrame格式然后进...
  • Pandas read_csv low_memory and dtype options 敢问这什么鬼? 【stackoverflow经典解答链接】 ...df = pd.read_csv('somefile.csv') 我得到 \Users\Python\Python36\python.exe E:/Python/11...
  • python pd.read_csv/pd.read_table参数详解

    千次阅读 2018-01-21 20:17:00
    转载于:https://www.cnblogs.com/mahailuo/p/8325288.html
  • 关于pd.read_csv() 读数据的注意事项 实验数据:adult.data 编译环境:pycharm 代码编写:Sublime Text3 ...由于在pd.read_csv( '.\\adult.data' ) 里面的参数,并没有指明 header=None,默认就将数据第一行当作数据

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 95,137
精华内容 38,054
关键字:

pd.read_csv参数