精华内容
下载资源
问答
  • 对于这些列来说,NA应该作为一个有意义的level,而不是缺失值,但read_csv函数会自动将类似的缺失值理解为缺失值并变为NaN。 看pandas文档中read_csv函数中这两个参数的描述,默认会将’-1.#IND’, ‘1.#QNAN’, ‘1...
  • data = pd.read_csv(path) Traceback (most recent call last): File "C:/Users/arron/PycharmProjects/ML/ML/test.py", line 45, in data = pd.read_csv(path) File "C:\Users\arron\AppData\Local\Continuum\...
  • 今天小编就为大家分享一篇解决pandas使用read_csv()读取文件遇到的问题,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • pandas.read_csv(filePath) 方法来读取csv文件时,可能会出现这种错误: ParserError:Error tokenizing data.C error:Expected 2 fields in line 407,saw 3. 是指在csv文件的第407行数据,期待2个字段,但在第407...
  • 今天小编就为大家分享一篇快速解决pandas.read_csv()乱码的问题,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • Pandas的read_csv和 to_csv函数参数分析详解 1. read_csv read_csv方法定义 pd.read_csv(filepath_or_buffer, sep=',', delimiter=None, header='infer', names=None, index_col=None, usecols=None, ...

    Pandas的read_csv和 to_csv函数参数分析详解

     

     

    1. read_csv

    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)
    
    

    读取文件路径,可以是URL,可用URL类型包括:http, ftp, s3和文件。

    常用参数

    sep :str, default ‘,'
    指定分隔符。如果不指定参数,则会尝试使用逗号分隔。csv文件一般为逗号分隔符。

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

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

    header :int or list of ints, default ‘infer'
    指定行数用来作为列名,数据开始行数。如果文件中没有列名,则默认为0,否则设置为None。对于数据读取有表头和没表头的情况很实用

    header :int or list of ints, default ‘infer'
    指定行数用来作为列名,数据开始行数。如果文件中没有列名,则默认为0,否则设置为None。

    names :  array-like, default None
    用于结果的列名列表,对各列重命名,即添加表头。
    如数据有表头,但想用新的表头,可以设置header=0,names=['a','b']实现表头定制。

    index_col : int or sequence or False, default None
    用作行索引的列编号或者列名,如果给定一个序列则有多个行索引。
    可使用index_col=[0,1]来指定文件中的第1和2列为索引列。

    usecols : array-like, default None
    返回一个数据子集,即选取某几列,不读取整个文件的内容,有助于加快速度和降低内存。
    usecols=[1,2]或usercols=['a','b']

    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
    使用的分析引擎。可以选择C或者是python。C引擎快但是Python引擎功能更加完备。

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

    true_values和false_values :  list, default None
    Values to consider as True or False

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

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

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

    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。

    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解析器中有效)

    日期类型相关参数

    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"

    示例:df=pd.read_csv(file_path,parse_dates=['time1','time2']),
    把time1和time2两列解析为日期格式。
    这里不得不说,很遗憾中文不行,比如‘4月5日'这种格式就不能解析。

     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.

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

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

    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。

    读取多个文件

    #读取多个文件
    
    import pandas
    import glob
    
    for r in glob.glob("test*.csv"):
        csv=pandas.read_csv(r)
        csv.to_csv("test.txt",mode="a+")

     

    2. to_csv

    to_csv方法定义:

    DataFrame.to_csv(path_or_buf=None, sep=', ', na_rep='', float_format=None, columns=None, 
    header=True, index=True, index_label=None, mode='w', encoding=None, compression=None, 
    quoting=None, quotechar='"', line_terminator='\n', chunksize=None, tupleize_cols=None, 
    date_format=None, doublequote=True, escapechar=None, decimal='.')
    

    path_or_buf=None: string or file handle, default None 
    File path or object, if None is provided the result is returned as a string. 
    字符串或文件句柄,默认无文件 
    路径或对象,如果没有提供,结果将返回为字符串。

    sep : character, default ‘,’ 
    Field delimiter for the output file. 
    默认字符 ‘ ,’ 
    输出文件的字段分隔符。

    na_rep : string, default ‘’ 
    Missing data representation 
    字符串,默认为 ‘’ 
    浮点数格式字符串

    float_format : string, default None 
    Format string for floating point numbers 
    字符串,默认为 None 
    浮点数格式字符串

    columns : sequence, optional Columns to write 
    顺序,可选列写入

    header : boolean or list of string, default True 
    Write out the column names. If a list of strings is given it is assumed to be aliases for the column names 
    字符串或布尔列表,默认为true 
    写出列名。如果给定字符串列表,则假定为列名的别名。

    index : boolean, default True 
    Write row names (index) 
    布尔值,默认为Ture 
    写入行名称(索引)

    index_label : string or sequence, or False, default None 
    Column label for index column(s) if desired. If None is given, and header and index are True, then the index names are used. A sequence should be given if the DataFrame uses MultiIndex. If False do not print fields for index names. Use index_label=False for easier importing in R 
    字符串或序列,或False,默认为None 
    如果需要,可以使用索引列的列标签。如果没有给出,且标题和索引为True,则使用索引名称。如果数据文件使用多索引,则应该使用这个序列。如果值为False,不打印索引字段。在R中使用index_label=False 更容易导入索引.

    mode : str 
    模式:值为‘str’,字符串 
    Python写模式,默认“w”

    encoding : string, optional 
    编码:字符串,可选 
    表示在输出文件中使用的编码的字符串,Python 2上默认为“ASCII”和Python 3上默认为“UTF-8”。

    compression : string, optional 
    字符串,可选项 
    表示在输出文件中使用的压缩的字符串,允许值为“gzip”、“bz2”、“xz”,仅在第一个参数是文件名时使用。

    line_terminator : string, default ‘\n’ 
    字符串,默认为 ‘\n’ 
    在输出文件中使用的换行字符或字符序列

    quoting : optional constant from csv module 
    CSV模块的可选常量 
    默认值为to_csv.QUOTE_MINIMAL。如果设置了浮点格式,那么浮点将转换为字符串,因此csv.QUOTE_NONNUMERIC会将它们视为非数值的。

    quotechar : string (length 1), default ‘”’ 
    字符串(长度1),默认“” 
    用于引用字段的字符

    doublequote : boolean, default True 
    布尔,默认为Ture 
    控制一个字段内的quotechar

    escapechar : string (length 1), default None 
    字符串(长度为1),默认为None 
    在适当的时候用来转义sep和quotechar的字符

    chunksize : int or None 
    int或None 
    一次写入行

    tupleize_cols : boolean, default False 
    布尔值 ,默认为False 
    从版本0.21.0中删除:此参数将被删除,并且总是将多索引的每行写入CSV文件中的单独行 
    (如果值为false)将多索引列作为元组列表(如果TRUE)或以新的、扩展的格式写入,其中每个多索引列是CSV中的一行。

    date_format : string, default None 
    字符串,默认为None 
    字符串对象转换为日期时间对象

    decimal: string, default ‘.’ 
    字符串,默认’。’ 
    字符识别为小数点分隔符。例如。欧洲数据使用 ​​’,’

    pandas的to_csv()使用方法

    1.首先查询当前的工作路径:

     

     
    import os
    
    os.getcwd() #获取当前工作路径

    2.to_csv()是DataFrame类的方法,read_csv()是pandas的方法

     

    dt.to_csv() #默认dt是DataFrame的一个实例,参数解释如下

     

    • 路径 path_or_buf: A string path to the file to write or a StringIO
     
    dt.to_csv('Result.csv') #相对位置,保存在getwcd()获得的路径下
    
    dt.to_csv('C:/Users/think/Desktop/Result.csv') #绝对位置

     

    • 分隔符 sep : Field delimiter for the output file (default ”,”)
    dt.to_csv('C:/Users/think/Desktop/Result.csv',sep='?')#使用?分隔需要保存的数据,如果不写,默认是,

     

    • 替换空值 na_rep: A string representation of a missing value (default ‘’)
    dt.to_csv('C:/Users/think/Desktop/Result1.csv',na_rep='NA') #确实值保存为NA,如果不写,默认是空

     

    • 格式 float_format: Format string for floating point numbers
    dt.to_csv('C:/Users/think/Desktop/Result1.csv',float_format='%.2f') #保留两位小数

     

    • 是否保留某列数据 cols: Columns to write (default None)
    dt.to_csv('C:/Users/think/Desktop/Result.csv',columns=['name']) #保存索引列和name列

     

    • 是否保留列名 header: Whether to write out the column names (default True)
    dt.to_csv('C:/Users/think/Desktop/Result.csv',header=0) #不保存列名

     

    • 是否保留行索引 index:  whether to write row (index) names (default True)
    dt.to_csv('C:/Users/think/Desktop/Result1.csv',index=0) #不保存行索引


     

     

    展开全文
  • 03_Pandas读取csv/tsv文件(read_csvread_table) 要将csv和tsv文件读取为pandas.DataFrame格式,可以使用Pandas的函数read_csv()或read_table()。 在此 read_csv()和read_table()之间的区别 读取没有...

    03_Pandas读取csv/tsv文件(read_csv,read_table)

    要将csv和tsv文件读取为pandas.DataFrame格式,可以使用Pandas的函数read_csv()或read_table()。

    在此

    • read_csv()和read_table()之间的区别
    • 读取没有标题的CSV
    • 读取有标题的CSV
    • 读取有index的CSV
    • 指定(选择)要读取的列
    • 跳过(排除)行的读取
    • 通过指定类型dtype进行读取
    • NaN缺失值的处理
    • 读取使用zip等压缩的文件
    • tsv的读取

    对以上的内容进行说明。

    read_csv()和read_table()之间的区别

    函数pd.read_csv()和pd.read_table()的内容相同,只是默认分隔符不同。

    在read_csv()中,定界符为,,在read_table()中,定界符为\ t

    查看源代码,它调用相同的函数。

    read_csv = _make_parser_function('read_csv', sep=',')
    read_csv = Appender(_read_csv_doc)(read_csv)
    
    read_table = _make_parser_function('read_table', sep='\t')
    read_table = Appender(_read_table_doc)(read_table)
    

    如果要读取csv文件(以逗号分隔),使用函数read_csv(),如果要读取tsv文件(以制表符分隔),使用函数read_table()也可以。

    如果既不是逗号也不是制表符,则可以通过参数(sep或delimiter)设置区分符。

    以下,将使用说明read_csv(),但是对read_table也是如此。

    读取没有标题的CSV

    读取以下不带标题的csv文件。

    11,12,13,14
    21,22,23,24
    31,32,33,34
    

    如果未设置任何参数,则将第一行识别为标题并将自动分配列名columns。

    df = pd.read_csv('./data/03/sample.csv')
    print(df)
    #    11  12  13  14
    # 0  21  22  23  24
    # 1  31  32  33  34
    
    print(df.columns)
    # Index(['11', '12', '13', '14'], dtype='object')
    

    如果header = None,则将为列名列分配一个序号。

    df_none = pd.read_csv('./data/03/sample.csv', header=None)
    print(df_none)
    #     0   1   2   3
    # 0  11  12  13  14
    # 1  21  22  23  24
    # 2  31  32  33  34
    

    可以将任意值设置为列名,参数为name=(‘A’,‘B’,‘C’,‘D’)。通过列表或元组指定。

    df_names = pd.read_csv('./data/03/sample.csv', names=('A', 'B', 'C', 'D'))
    print(df_names)
    #     A   B   C   D
    # 0  11  12  13  14
    # 1  21  22  23  24
    # 2  31  32  33  34
    

    读取有标题的CSV

    读取以下带标头的csv文件。

    a,b,c,d
    11,12,13,14
    21,22,23,24
    31,32,33,34
    

    指定标题的行号从0开始,例如header = 0。由于默认值为header = 0,因此如果第一行是header,则可以获得相同的结果。

    df_header = pd.read_csv('./data/03/sample_header.csv')
    print(df_header)
    #     a   b   c   d
    # 0  11  12  13  14
    # 1  21  22  23  24
    # 2  31  32  33  34
    
    df_header_0 = pd.read_csv('./data/03/sample_header.csv', header=0)
    print(df_header_0)
    #     a   b   c   d
    # 0  11  12  13  14
    # 1  21  22  23  24
    # 2  31  32  33  34
    

    使用header进行起始行的读取指定。

    df_header_2 = pd.read_csv('./data/03/sample_header.csv', header=2)
    print(df_header_2)
    #    21  22  23  24
    # 0  31  32  33  34
    

    读取有index的CSV

    读取以下带有标题和索引(标题列)的csv文件。

    ,a,b,c,d
    ONE,11,12,13,14
    TWO,21,22,23,24
    THREE,31,32,33,34
    

    如果未指定任何内容,则不会识别索引列。

    df_header_index = pd.read_csv('./data/03/sample_header_index.csv')
    print(df_header_index)
    #   Unnamed: 0   a   b   c   d
    # 0        ONE  11  12  13  14
    # 1        TWO  21  22  23  24
    # 2      THREE  31  32  33  34
    
    print(df_header_index.index)
    # RangeIndex(start=0, stop=3, step=1)
    

    指定要用作索引的列的列号,从0开始,例如index_col = 0。

    df_header_index_col = pd.read_csv('./data/03/sample_header_index.csv',
    									index_col=0)
    print(df_header_index_col)
    #         a   b   c   d
    # ONE    11  12  13  14
    # TWO    21  22  23  24
    # THREE  31  32  33  34
    
    print(df_header_index_col.index)
    # Index(['ONE', 'TWO', 'THREE'], dtype='object')
    

    指定(选择)要读取的列

    要仅读取特定的列,请使用usecols参数。 指定要在列表中读取的列号。即使只有一列,也要使用列表。

    df_none_usecols = pd.read_csv('./data/03/sample.csv',
    								header=None, usecols=[1, 3])
    print(df_none_usecols)
    #     1   3
    # 0  12  14
    # 1  22  24
    # 2  32  34
    
    df_none_usecols = pd.read_csv('./data/03/sample.csv',
    								header=None, usecols=[2])
    print(df_none_usecols)
    #     2
    # 0  13
    # 1  23
    # 2  33
    

    也可以按列名而不是列号指定。

    df_header_usecols = pd.read_csv('./data/03/sample_header.csv',
    								usecols=['a', 'c'])
    print(df_header_usecols)
    #     a   c
    # 0  11  13
    # 1  21  23
    # 2  31  33
    

    在没有特定列的情况下时,使用匿名函数(lambda表达式)很方便。尤其是当您要从具有许多列的文件中排除少量列并读取它们时,比指定要读取的大量列号要容易得多。

    df_header_usecols = pd.read_csv('./data/03/sample_header.csv', 
                                  usecols=lambda x: x is not 'b')
    print(df_header_usecols)
    #     a   c   d
    # 0  11  13  14
    # 1  21  23  24
    # 2  31  33  34
    
    df_header_usecols = pd.read_csv('./data/03/sample_header.csv', 
                                  usecols=lambda x: x not in ['a', 'c'])
    print(df_header_usecols)
    #     b   d
    # 0  12  14
    # 1  22  24
    # 2  32  34
    

    当与index_col一起使用时,由index_col指定的列也必须由usecols指定。

    df_index_usecols = pd.read_csv('./data/03/sample_header_index.csv',
                                  index_col=0, usecols=[0, 1, 3])
    print(df_index_usecols)
    #         a   c
    # ONE    11  13
    # TWO    21  23
    # THREE  31  33
    

    跳过(排除)行的读取

    skiprows

    要跳过(排除)特定行并读取它们,使用参数skipprows。 如果将整数传递给跳过行,那么将跳过那么多行的文件开头。

    df_none = pd.read_csv('./data/03/sample.csv', header=None)
    print(df_none)
    #     0   1   2   3
    # 0  11  12  13  14
    # 1  21  22  23  24
    # 2  31  32  33  34
    
    df_none = pd.read_csv('./data/03/sample.csv', header=None, skiprows=2)
    print(df_none)
    #     0   1   2   3
    # 0  31  32  33  34
    

    可以指定要跳过的行号列表。与usecols不同,指定要跳过的行,而不是要读取的行。 即使在一行中也要使用列表。

    df_none_skiprows = pd.read_csv('./data/03/sample.csv',
    								header=None, skiprows=[0, 2])
    print(df_none_skiprows)
    #     0   1   2   3
    # 0  21  22  23  24
    
    df_none_skiprows = pd.read_csv('./data/03/sample.csv',
    								header=None, skiprows=[1])
    print(df_none_skiprows)
    #     0   1   2   3
    # 0  11  12  13  14
    # 1  31  32  33  34
    

    仅读取特定行时,使用匿名函数(lambda表达式)会很方便。特别是当您只想从文件中读取多行的特定行时,比指定要跳过的行数要容易得多。

    df_none_skiprows = pd.read_csv('./data/03/sample.csv', header=None,
                               skiprows=lambda x: x not in [0, 2])
    print(df_none_skiprows)
    #     0   1   2   3
    # 0  11  12  13  14
    # 1  31  32  33  34
    

    请注意,如果文件具有标题,则还需要考虑标题行。

    df_header_skiprows = pd.read_csv('./data/03/sample_header.csv', skiprows=[1])
    print(df_header_skiprows)
    #     a   b   c   d
    # 0  21  22  23  24
    # 1  31  32  33  34
    
    df_header_skiprows = pd.read_csv('./data/03/sample_header.csv', skiprows=[0, 3])
    print(df_header_skiprows)
    #    11  12  13  14
    # 0  21  22  23  24
    

    请注意,即使指定了索引,也无法通过行名指定skipprows。

    skipfooter

    要跳过文件的末尾,请使用skipfooter参数。将要跳过的行数指定为整数。 根据环境的不同,会出现以下警告,因此请指定参数engine =‘python’。

    ParserWarning: Falling back to the 'python' engine because the 'c' engine does not support skipfooter; you can avoid this warning by specifying engine='python'.
    
    df_none_skipfooter = pd.read_csv('./data/03/sample.csv', header=None,
    	                           skipfooter=1, engine='python')
    print(df_none_skipfooter)
    #     0   1   2   3
    # 0  11  12  13  14
    # 1  21  22  23  24
    

    nrows

    也可以只阅读前几行。使用参数nrows。 当想检查大文件的数据时很有用。

    df_none_nrows = pd.read_csv('./data/03/sample.csv', header=None, nrows=2)
    print(df_none_nrows)
    #     0   1   2   3
    # 0  11  12  13  14
    # 1  21  22  23  24
    

    通过指定类型dtype进行读取

    在pandas.DataFrame中,为每一列设置类型dtype,可以使用astype()方法对其进行转换(转换)。

    以下文件为例。

    ,a,b,c,d
    ONE,1,"001",100,x
    TWO,2,"020",,y
    THREE,3,"300",300,z
    

    默认情况下,以0开头的数字序列(无论是否带引号)都被视为数字,而不是字符串,并且省略前导零。

    df_default = pd.read_csv('./data/03/sample_header_index_dtype.csv', index_col=0)
    print(df_default)
    #        a    b      c  d
    # ONE    1    1  100.0  x
    # TWO    2   20    NaN  y
    # THREE  3  300  300.0  z
    
    print(df_default.dtypes)
    # a      int64
    # b      int64
    # c    float64
    # d     object
    # dtype: object
    
    print(df_default.applymap(type))
    #                    a              b                c              d
    # ONE    <class 'int'>  <class 'int'>  <class 'float'>  <class 'str'>
    # TWO    <class 'int'>  <class 'int'>  <class 'float'>  <class 'str'>
    # THREE  <class 'int'>  <class 'int'>  <class 'float'>  <class 'str'>
    

    如果要作为包含前导0的字符串进行处理,请指定read_csv()的参数dtype。

    如果在参数dtype中指定了任意数据类型,则包括index_col指定的列在内的所有列都将转换为该类型并读取。例如,如果dtype = str,则所有列都强制转换为字符串。但是,同样在这种情况下,缺少的值是浮点类型。

    df_str = pd.read_csv('./data/03/sample_header_index_dtype.csv',
    						index_col=0,dtype=str)
    print(df_str)
    #        a    b    c  d
    # ONE    1  001  100  x
    # TWO    2  020  NaN  y
    # THREE  3  300  300  z
    
    print(df_str.dtypes)
    # a    object
    # b    object
    # c    object
    # d    object
    # dtype: object
    
    print(df_str.applymap(type))
    #                    a              b                c              d
    # ONE    <class 'str'>  <class 'str'>    <class 'str'>  <class 'str'>
    # TWO    <class 'str'>  <class 'str'>  <class 'float'>  <class 'str'>
    # THREE  <class 'str'>  <class 'str'>    <class 'str'>  <class 'str'>
    

    dtype = object也是如此。

    df_object = pd.read_csv('./data/03/sample_header_index_dtype.csv',
    						index_col=0, dtype=object)
    print(df_object)
    #        a    b    c  d
    # ONE    1  001  100  x
    # TWO    2  020  NaN  y
    # THREE  3  300  300  z
    
    print(df_object.dtypes)
    # a    object
    # b    object
    # c    object
    # d    object
    # dtype: object
    
    print(df_object.applymap(type))
    #                    a              b                c              d
    # ONE    <class 'str'>  <class 'str'>    <class 'str'>  <class 'str'>
    # TWO    <class 'str'>  <class 'str'>  <class 'float'>  <class 'str'>
    # THREE  <class 'str'>  <class 'str'>    <class 'str'>  <class 'str'>
    

    请注意,在参数dtype中指定无法转换的类型将导致错误。在此示例中,将由index_col指定的字符串的索引列转换为整数int类型时发生错误。

    # df_int = pd.read_csv('data/src/sample_header_index_dtype.csv',
    #                      index_col=0, dtype=int)
    # ValueError: invalid literal for int() with base 10: 'ONE'
    

    要在读取后转换pandas.DataFrame的列类型,请在astype()方法中以字典格式指定它。

    df_str_cast = df_str.astype({'a': int})
    print(df_str_cast)
    #        a    b    c  d
    # ONE    1  001  100  x
    # TWO    2  020  NaN  y
    # THREE  3  300  300  z
    
    print(df_str_cast.dtypes)
    # a     int64
    # b    object
    # c    object
    # d    object
    # dtype: object
    

    使用read_csv()进行读取时,可以在字典格式中的参数dtype中指定列类型。将自动选择除指定列以外的其他类型。

    df_str_col = pd.read_csv('./data/03/sample_header_index_dtype.csv',
                         index_col=0, dtype={'b': str, 'c': str})
    print(df_str_col)
    #        a    b    c  d
    # ONE    1  001  100  x
    # TWO    2  020  NaN  y
    # THREE  3  300  300  z
    
    print(df_str_col.dtypes)
    # a     int64
    # b    object
    # c    object
    # d    object
    # dtype: object
    

    不仅可以指定列名,还可以指定列号。注意,在指定索引列时,必须指定包括索引列的列号。

    df_str_col_num = pd.read_csv('./data/03/sample_header_index_dtype.csv',
                         index_col=0, dtype={2: str, 3: str})
    print(df_str_col_num)
    #        a    b    c  d
    # ONE    1  001  100  x
    # TWO    2  020  NaN  y
    # THREE  3  300  300  z
    
    print(df_str_col_num.dtypes)
    # a     int64
    # b    object
    # c    object
    # d    object
    # dtype: object
    

    NaN缺失值的处理

    默认情况下,read_csv()和read_table()将某些值视为缺少的NaN。
    默认情况下,可能的值(例如空字符串”,字符串“ NaN”,“ nan”和null)通常默认为缺少NaN,如下所示:

    By default the following values are interpreted as NaN: ‘’, ‘#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’.
    

    以下文件为例检查操作。

    ,a,b
    ONE,,NaN
    TWO,-,nan
    THREE,null,N/A
    

    特别是,如果您在默认情况下未设置任何参数而进行读取,并使用isnull()方法对其进行了检查,则可以看到除“-”以外的其他非目标均被视为缺失值NaN。

    df_nan = pd.read_csv('./data/03/sample_header_index_nan.csv', index_col=0)
    print(df_nan)
    #          a   b
    # ONE    NaN NaN
    # TWO      - NaN
    # THREE  NaN NaN
    
    print(df_nan.isnull())
    #            a     b
    # ONE     True  True
    # TWO    False  True
    # THREE   True  True
    

    要指定默认值以外的值,将其视为缺失值,使用参数na_values。

    df_nan_set_na = pd.read_csv('./data/03/sample_header_index_nan.csv',
    							index_col=0, na_values='-')
    print(df_nan_set_na)
    #         a   b
    # ONE   NaN NaN
    # TWO   NaN NaN
    # THREE NaN NaN
    
    print(df_nan_set_na.isnull())
    #           a     b
    # ONE    True  True
    # TWO    True  True
    # THREE  True  True
    

    如果在将参数keep_default_na设置为False之后为参数na_values指定值,则仅将为na_values指定的值视为缺失值。除非在na_values中指定,否则默认值不会被视为缺失值。

    df_nan_set_na_no_keep = pd.read_csv('./data/03/sample_header_index_nan.csv',
    									index_col=0, 
    									na_values=['-', 'NaN', 'null'], 
    									keep_default_na=False)
    print(df_nan_set_na_no_keep)
    #          a    b
    # ONE         NaN
    # TWO    NaN  nan
    # THREE  NaN  N/A
    
    print(df_nan_set_na_no_keep.isnull())
    #            a      b
    # ONE    False   True
    # TWO     True  False
    # THREE   True  False
    

    如果参数na_filter设置为False,则无论参数na_values和keep_default_na的规格如何,所有值都将按原样读取,并且不会被视为缺失值。

    df_nan_no_filter = pd.read_csv('./data/03/sample_header_index_nan.csv',
    								index_col=0, na_filter=False)
    print(df_nan_no_filter)
    #           a    b
    # ONE          NaN
    # TWO       -  nan
    # THREE  null  N/A
    
    print(df_nan_no_filter.isnull())
    #            a      b
    # ONE    False  False
    # TWO    False  False
    # THREE  False  False
    

    读取使用zip等压缩的文件

    也可以按原样读取通过zip等压缩的csv文件。

    df_zip = pd.read_csv('./data/03/sample_header.zip')
    print(df_zip)
    #     a   b   c   d
    # 0  11  12  13  14
    # 1  21  22  23  24
    # 2  31  32  33  34
    

    如果扩展名是.gz,.bz2,.zip,.xz,则会自动检测并扩展。如果扩展名不同,请在compression参数中显式指定字符串“ gz”,“ bz2”,“ zip”和“ xz”。
    请注意,仅限压缩单个csv文件。如果压缩多个文件,则会发生错误。

    tsv的读取

    在开始时所写的那样,如果要读取tsv文件(制表符分隔),则可以使用read_table()。

    对于如下文件

        a   b   c   d
    ONE 11  12  13  14
    TWO 21  22  23  24
    THREE   31  32  33  34
    

    参数与read_csv()相同。

    df_tsv = pd.read_table('./data/03/sample_header_index.tsv', index_col=0)
    print(df_tsv)
    #         a   b   c   d
    # ONE    11  12  13  14
    # TWO    21  22  23  24
    # THREE  31  32  33  34
    

    通过read_csv()将制表符\t设置为区别符,也可以读取它。

    df_tsv_sep = pd.read_csv('./data/03/sample_header_index.tsv', 
    							index_col=0, sep='\t')
    print(df_tsv_sep)
    #         a   b   c   d
    # ONE    11  12  13  14
    # TWO    21  22  23  24
    # THREE  31  32  33  34
    
    展开全文
  • 详解pandas的read_csv方法

    千次阅读 2021-02-12 21:10:26
    楔子 使用pandas做数据处理的第一步就是读取数据,数据源...pandas在读取csv文件是通过read_csv这个函数读取的,下面就来看看这个函数都支持哪些不同的参数,看看它们都生得一副什么模样,是三头六臂,还是烈焰红唇。

    楔子

    使用pandas做数据处理的第一步就是读取数据,数据源可以来自于各种地方,csv文件便是其中之一。而读取csv文件,pandas也提供了非常强力的支持,参数有四五十个。这些参数中,有的很容易被忽略,但是在实际工作中却用处很大。比如:

    • 文件读取时设置某些列为时间类型
    • 导入文件, 含有重复列
    • 过滤某些列
    • 每次迭代指定的行数
    • 值替换

    pandas在读取csv文件是通过read_csv这个函数读取的,下面就来看看这个函数都支持哪些不同的参数,看看它们都生得一副什么模样,是三头六臂,还是烈焰红唇。

    read_csv中的参数

    下面都是read_csv中的参数,但是根据功能我们划分为不同的类别。

    以下代码都在jupyter notebook上运行,Python版本为3.8.2。

    基本参数

    filepath_or_buffer

    数据输入的路径:可以是文件路径、可以是URL,也可以是实现read方法的任意对象。这个参数,就是我们输入的第一个参数。

     
     

    import pandas as pd pd.read_csv("girl.csv")

    还可以是一个URL,如果访问该URL会返回一个文件的话,那么pandas的read_csv函数会自动将该文件进行读取。比如:我们用fastapi写一个服务,将刚才的文件返回。

     
     

    pd.read_csv("http://localhost/girl.csv")

    里面还可以是一个 _io.TextIOWrapper,比如:

     
     

    f = open("girl.csv", encoding="utf-8") pd.read_csv(f)

    甚至还可以是一个临时文件:

     
     

    import tempfile import pandas as pd tmp_file = tempfile.TemporaryFile("r+") tmp_file.write(open("girl.csv", encoding="utf-8").read()) tmp_file.seek(0) pd.read_csv(tmp_file)

    支持的格式非常齐全,但是一般情况下,我们还是读取实际的csv文件比较多。

    sep

    读取csv文件时指定的分隔符,默认为逗号。注意:"csv文件的分隔符" 和 "我们读取csv文件时指定的分隔符" 一定要一致。

    比如:上面的girl.csv,我们将其分隔符从逗号改成"\t",如果这个时候还是用默认的逗号分隔符,那么数据读取之后便混为一体。

     
     

    pd.read_csv("girl.csv")

    由于指定的分隔符 和 csv文件采用的分隔符 不一致,因此多个列之间没有分开,而是连在一起了。

    所以,我们需要将分隔符设置成"\t"才可以。

     
     

    pd.read_csv('girl.csv', sep='\t')

    delimiter

    分隔符的另一个名字,与 sep 功能相似。

    delim_whitespace

    0.18 版本后新加参数,默认为 False,设置为 True 时,表示分割符为空白字符,可以是空格、"\t"等等。比如:girl.csv的分隔符是"\t",如果设置delim_whitespace为True的话:

     
     

    pd.read_csv('girl.csv',delim_whitespace=True)

    不管分隔符是什么,只要是空白字符,那么可以通过delim_whitespace=True进行读取。

    header

    设置导入 DataFrame 的列名称,默认为 "infer",注意它与下面介绍的 names 参数的微妙关系。

    names

    • 当names没被赋值时,header会变成0,即选取数据文件的第一行作为列名。
    • 当 names 被赋值,header 没被赋值时,那么header会变成None。如果都赋值,就会实现两个参数的组合功能。

    我们举例说明:

    • 1) names 没有被赋值,header 也没赋值:
     
     

    pd.read_csv('girl.csv',delim_whitespace=True) # 我们说这种情况下,header为变成0,即选取文件的第一行作为表头

    • 2) names 没有被赋值,header 被赋值:
     
     

    pd.read_csv('girl.csv',delim_whitespace=True, header=1) # 不指定names,指定header为1,则选取第二行当做表头,第二行下面的是数据

    • 3) names 被赋值,header 没有被赋值:
     
     

    pd.read_csv('girl.csv', delim_whitespace=True, names=["编号", "姓名", "地址", "日期"])

    我们看到names适用于没有表头的情况,指定names没有指定header,那么header相当于None。一般来说,读取文件会有一个表头的,一般是第一行,但是有的文件只是数据而没有表头,那么这个时候我们就可以通过names手动指定、或者生成表头,而文件里面的数据则全部是内容。所以这里id、name、address、date也当成是一条记录了,本来它是表头的,但是我们指定了names,所以它就变成数据了,表头是我们在names里面指定的

    4) names和header都被赋值:

     
     

    pd.read_csv('girl.csv', delim_whitespace=True, names=["编号", "姓名", "地址", "日期"], header=0)

    这个相当于先不看names,只看header,我们说header等于0代表什么呢?显然是把第一行当做表头,下面的当成数据,好了,然后再把表头用names给替换掉。

    再举个栗子:

     
     

    pd.read_csv('girl.csv', delim_whitespace=True, names=["编号", "姓名", "地址", "日期"], header=3) # header=3,表示第四行当做表头,第四行下面当成数据 # 然后再把表头用names给替换掉,得到如下结果

    所以names和header的使用场景主要如下:

    • 1. csv文件有表头并且是第一行,那么names和header都无需指定;
    • 2. csv文件有表头、但表头不是第一行,可能从下面几行开始才是真正的表头和数据,这个时候指定header即可;
    • 3. csv文件没有表头,全部是纯数据,那么我们可以通过names手动生成表头;
    • 4. csv文件有表头、但是这个表头你不想用,这个时候同时指定names和header。先用header选出表头和数据,然后再用names将表头替换掉,其实就等价于将数据读取进来之后再对列名进行rename;

    index_col

    我们在读取文件之后,生成的DataFrame的索引默认是0 1 2 3...,我们当然可以set_index,但是也可以在读取的时候就指定某个列为索引。

     
     

    pd.read_csv('girl.csv', delim_whitespace=True, index_col="name")

    这里指定"name"作为索引,另外除了指定单个列,还可以指定多个列,比如["id", "name"]。并且我们除了可以输入列的名字之外,还可以输入对应的索引。比如:"id"、"name"、"address"、"date"对应的索引就分别是0、1、2、3。

    usecols

    如果列有很多,而我们不想要全部的列、而是只要指定的列就可以使用这个参数。

     
     

    pd.read_csv('girl.csv', delim_whitespace=True, usecols=["name", "address"])

    mangle_dupe_cols

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

     
     

    # ValueError: Setting mangle_dupe_cols=False is not supported yet

    prefix

    prefix 参数,当导入的数据没有 header 时,设置此参数会自动加一个前缀。比如:

     
     

    pd.read_csv('girl.csv', delim_whitespace=True, header=None)

    我们看到在不指定names的时候,header默认为0,表示以第一行为表头。但如果不指定names、还显式地将header指定为None,那么会自动生成表头0 1 2 3...,因为DataFrame肯定是要有列名(表头)的。那么prefix参数干什么用的呢?

     
     

    pd.read_csv('girl.csv', delim_whitespace=True, header=None, prefix="夏色祭")

    所以prefix就是给这样的列名增加前缀的,个人感觉好像不是很常用,至少本人在工作中从未用过这个参数。

    squeeze

    感觉又是一个没啥卵用的参数,首先我们读取csv文件得到的是一个DataFrame,如果这个文件只有一列、或者我们只获取一列的话,那么得到的还是一个DataFrame。

     
     

    pd.read_csv('girl.csv', delim_whitespace=True, usecols=["name"]) # 这里只选择一列

    如果指定了squeeze参数为True的话,在只有一列的情况下,那么得到就是一个Series。

     
     

    pd.read_csv('girl.csv', delim_whitespace=True, usecols=["name"], squeeze=True)

    squeeze默认是False,当然如果是多列,即使指定squeeze为True,得到的依旧是DataFrame。如果只有一列,那么本来默认还是DataFrame,但是可以通过指定这个参数为True,将其变成Series。话说你们觉得这个参数有用吗?反正我个人觉得用处不大。

    通用解析参数

    dtype

    笔者就曾遇到一件比较尴尬的事情,就是处理地铁人员数据的。工作人员的id都是以0开头的,比如0100012521,这是一个字符串。但是在读取的时候解析成整型了,结果把开头的0给丢了。这个时候我们就可以通过dtype来指定某个列的类型,就是告诉pandas:你在解析的时候不要自以为是,直接按照老子指定的类型进行解析就可以了,我不要你觉得,我要我觉得。

     
     

    df = pd.read_csv('girl.csv', delim_whitespace=True) df["id"] = df["id"] * 3 df

    比如这里的id,默认解析的是整型,如果我们希望它是个字符串呢?

     
     

    df = pd.read_csv('girl.csv', delim_whitespace=True, dtype={"id": str}) df["id"] = df["id"] * 3 df

    我们看到id变成了字符串类型。

    engine

    pandas解析数据时用的引擎,pandas 目前的解析引擎提供两种:c、python,默认为 c,因为 c 引擎解析速度更快,但是特性没有 python 引擎全。如果使用 c 引擎没有的特性时,会自动退化为 python 引擎。

    比如使用分隔符进行解析,如果指定分隔符不是单个字符、或者"\s+",那么c引擎就无法解析了。我们知道如果分隔符为空白字符的话,那么可以指定delim_whitespace=True,但是也可以指定sep=r"\s+"。

     
     

    pd.read_csv('girl.csv', sep=r"\s+")

    如果sep是单个字符,或者字符串\s+,那么C是可以解决的。但如果我们指定的sep比较复杂,这时候引擎就会退化。

     
     

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

    我们看到虽然自动退化,但是弹出了警告,这个时候需要手动的指定engine="python"来避免警告。这里面还用到了encoding参数,这个后面会说,因为引擎一旦退化,在Windows上不指定会读出乱码。这里我们看到sep是可以支持正则的,但是说实话sep这个参数都会设置成单个字符,原因是读取的csv文件的分隔符是单个字符。

    converters

    可以在读取的时候对列数据进行变换:

     
     

    pd.read_csv('girl.csv', sep="\t", converters={"id": lambda x: int(x) + 10})

    将id增加10,但是注意 int(x),在使用converters参数时,解析器默认所有列的类型为 str,所以需要显式类型转换。

    true_values和false_value

    指定哪些值应该被清洗为True,哪些值被清洗为False。

     
     

    pd.read_csv('girl.csv', sep="\t")

    这里增加一个字段result。

     
     

    pd.read_csv('girl.csv', sep="\t", true_values=["对"], false_values=["错"])

    注意这里的替换规则,只有当某一列的数据全部出现在true_values + false_values里面,才会被替换。

     
     

    pd.read_csv('girl.csv', sep="\t", false_values=["错"])

    我们看到"错"并没有被替换成False,原因就是只有一个字段中所有的值都在true_values + false_values中,它们才会被替换,而"对"并没有出现。

     
     

    pd.read_csv('girl.csv', sep="\t", false_values=["错", "对"])

    此时就全部被替换成了False。

    skiprows

    skiprows 表示过滤行,想过滤掉哪些行,就写在一个列表里面传递给skiprows即可。注意的是:这里是先过滤,然后再确定表头,比如:

     
     

    pd.read_csv('girl.csv', sep="\t", skiprows=[0])

    我们把第一行过滤掉了,但是第一行是表头,所以过滤掉之后,第二行就变成表头了。如果过滤掉第二行,那么只相当于少了一行数据,但是表头还是原来的第一行:id、name、address、date、result。

    当然里面除了传入具体的数值,来表明要过滤掉哪些行,还可以传入一个函数。

     
     

    pd.read_csv('girl.csv', sep="\t", skiprows=lambda x: x > 0 and x % 2 == 0)

    由于索引从0开始,凡是索引大于0、并且%2等于0的记录都过滤掉。索引大于0,是为了保证表头不被过滤掉。

    skipfooter

    从文件末尾过滤行,解析引擎退化为 Python。这是因为 C 解析引擎没有这个特性。

     
     

    pd.read_csv('girl.csv', sep="\t", skipfooter=3, encoding="utf-8", engine="python")

    skipfooter接收整型,表示从结尾往上过滤掉指定数量的行,因为引擎退化为python,那么要手动指定engine="python",不然会警告。另外需要指定encoding="utf-8",因为csv存在编码问题,当引擎退化为python的时候,在Windows上读取会乱码。

    nrows

    nrows 参数设置一次性读入的文件行数,它在读入大文件时很有用,比如 16G 内存的PC无法容纳几百 G 的大文件。

     
     

    pd.read_csv('girl.csv', sep="\t", nrows=1)

    很多时候我们只是想看看大文件内部的字段长什么样子,所以这里通过nrows指定读取的行数。

    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,这个是非常常用的,但是用的人不多。

     
     

    pd.read_csv('girl.csv', sep="\t", na_values=["对", "古明地觉"])

    我们看到将"对"和"古明地觉"设置成了NaN,当然我们这里不同的列,里面包含的值都是不相同的。但如果两个列中包含相同的值,而我们只想将其中一个列的值换成NaN该怎么做呢?

     
     

    pd.read_csv('girl.csv', sep="\t", na_values={"name": ["古明地觉", "博丽灵梦"], "result": ["对"]})

    通过字典实现只对指定的列进行替换。

    skip_blank_lines

    skip_blank_lines 默认为 True,表示过滤掉空行,如为 False 则解析为 NaN

    verbose

    打印一些额外信息

    时间处理相关参数

    parse_dates

    指定某些列为时间类型,这个参数一般搭配下面的date_parser使用。

    date_parser

    是用来配合parse_dates参数的,因为有的列虽然是日期,但没办法直接转化,需要我们指定一个解析格式:

     
     

    from datetime import datetime pd.read_csv('girl.csv', sep="\t", parse_dates=["date"], date_parser=lambda x: datetime.strptime(x, "%Y年%m月%d日"))

    infer_datetime_format

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

    分块读入相关参数

    分块读入内存,尤其单机处理大文件时会很有用。

    iterator

    iterator 为 bool类型,默认为False。如果为True,那么返回一个 TextFileReader 对象,以便逐块处理文件。这个在文件很大、内存无法容纳所有数据文件时,可以分批读入,依次处理。

     
     
     
     

    chunksize

    chunksize 整型,默认为 None,设置文件块的大小。

     

     

    compression

    compression 参数取值为 {'infer', 'gzip', 'bz2', 'zip', 'xz', None},默认 'infer',这个参数直接支持我们使用磁盘上的压缩文件。

     
     

    # 直接将上面的girl.csv添加到压缩文件,打包成girl.zip pd.read_csv('girl.zip', sep="\t", compression="zip")

    thousands

    千分位分割符,如 , 或者 .,默认为None。

    encoding

    encoding 指定字符集类型,通常指定为 'utf-8'。根据情况也可能是'ISO-8859-1'

    error_bad_lines和warn_bad_lines

    如果一行包含过多的列,假设csv的数据有5列,但是某一行却有6个数据,显然数据有问题。那么默认情况下不会返回DataFrame,而是会报错。

     
     

    # ParserError: Error tokenizing data. C error: Expected 5 fields in line 5, saw 6

    我们在某一行中多加了一个数据,结果显示错误。因为girl.csv里面有5列,但是有一行却有6个数据,所以报错。

    在小样本读取时,这个错误很快就能发现。但是如果样本比较大、并且由于数据集不可能那么干净,会很容易出现这种情况,那么该怎么办呢?而且这种情况下,Excel基本上是打不开这么大的文件的。这个时候我们就可以将error_bad_lines设置为False(默认为True),意思是遇到这种情况,直接把这一行给我扔掉。同时会设置 warn_bad_lines 设置为True,打印剔除的这行。

     
     

    pd.read_csv('girl.csv', sep="\t", error_bad_lines=False, warn_bad_lines=True)

    以上两参数只能在C解析引擎下使用。

    总结

    以上便是pandas的read_csv函数中绝大部分参数了,而且其中的部分参数也适用于读取其它类型的文件。其实在读取csv文件时所使用的参数就那么几个,很多参数平常都不会用,但至少要了解一下,因为在某些特定的场景下它们是可以很方便地帮我们解决一些问题的。

    当然,read_csv函数中的参数还不止我们上面说的那些,有几个我们还没有介绍到,感兴趣可以自己看一下。但是个人觉得,掌握上面的那些参数的用法的话,其实已经完全够用了

    展开全文
  • 首先我是通过read_csv将数据读入 然后把id列去掉,将date列设置为索引。之后将date列的数据转化为标准格式,代码如下: import pandas as pd air = pd.read_csv(’…/forecast pm25/weather.csv’, index_col=7) air...

    今天在一份时间序列数据的处理过程中发现了一个问题:

    首先我是通过read_csv将数据读入
    然后把id列去掉,将date列设置为索引。之后将date列的数据转化为标准格式,代码如下:

    import pandas as pd
    air = pd.read_csv(’…/forecast pm25/weather.csv’, index_col=7)
    air.head(10)

    在这里插入图片描述
    数据如上。
    接下来去掉ID列,并且date标准化

    weather = air[air.columns.difference([‘id’])]
    weather.index = pd.to_datetime(weather.index)
    weather.head()
    在这里插入图片描述
    以上就是处理好的数据。然后我把它保存成csv

    ex_path = ‘…/forecast pm25/adj_weather.csv’
    weather.to_csv(ex_path)

    然后我用pandas查看导出的数据(问题来了!):
    test_path = ‘…/forecast pm25/adj_weather.csv’
    weather = pd.read_csv(test_path)
    在这里插入图片描述
    数据变成了这样,原来的索引列在to_csv的时候被当做内容保存在了第一列。
    之后我查看下边他的博客才发现
    https://blog.csdn.net/kwame211/article/details/80982840
    原来,to_csv过程中会将原来的索引看作内容保存进去再次直接read_csv就会把原来的索引变为内容,然后自己再加一层索引!所以假如你又直接to_csv那么又会加一层索引进去。所以解决方法是:

    第一种解决方式:不存索引

    df.to_csv(path,index=False,header=False)
    第二种解决方式:声明文件第一列为索引,第一行为列名(默认就是,不必重新申明)

    aa = pd.read_csv(path,index_col=0,header=0)
    两种解决方式任一种都可以解决这种问题

    展开全文
  • 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=...
  • TempData = pd.read_csv('test.csv', encoding='gb2312')) TempData = pd.DataFrame(TempData) TempData.to__csv(‘test.csv’, index=False, sep=',', encoding='gb2312') 由于我的test.csv中本身包含乱码,...
  • python pandas.read_csv()函数详解

    千次阅读 2021-03-24 15:20:19
    这里将更新最新的最全面的read_csv()函数功能以及参数介绍,参考资料来源于官网。 目录pandas库简介csv文件格式简介函数介绍函数原型函数参数以及含义输入返回函数使用实例 pandas库简介 官方网站里详细说明了pandas...
  • 仅为本人学习笔记之用,如有需求,请联系该文原作者。 # parse_dates,date_parser 指定列的日期/时间格式,将文本数据转换为datetime 目录: 第1部分:csv文本文件读写 ... pandas 读csv文件read_csv(1.文本读写...
  • * 由于在做数据处理,数据分析的时候,免不了读取数据或者将数据转换为相应的处理形式,那么,pandas的read_csv和to_csv,就能给我们很大的帮助,接下来,博主,将 read_csv 和 to_csv 两个方法的定义,进行整合,...
  • 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, ...
  • pd.read_csv()参数

    千次阅读 2019-07-05 12:19:05
    df = pd.read_csv('tmp.csv', header=None, parse_dates=[[1, 2], [1, 3]],keep_date_col=True) 默认情况下,解析器会删除组件日期列,但您可以通过“保留日期”列选择保留它们。 df = pd.read_csv('tmp.csv', ...
  • 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...
  • python文件的读写read_csv常用参数

    千次阅读 2019-09-13 14:24:52
    文章目录pandas.read_csv参数理解filepath_or_bufferheadersepdelimiterdelim_whitespacenamesindex_colusecolssqueezeprefixdtypeengineconvertersskiprowsskipfooternrowsparse_dateskeep_date_...
  • pandas read_csv和to_csv的基本使用

    千次阅读 2019-01-24 10:31:38
    read_csv 原始csv如下: id,test 001C8DA7-9969-4C51-A957-89F4C6E4999F,0 00468119-70E6-4C33-9F30-64BC91134253,0 005E0BA1-3B27-40F0-A231-5BAE6246599D,0 007EFD04-DBE6-4B14-A1AA-8A500C1D1EBC,0 008D...
  • 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=...
  • 将路径和文件名字都改成英文的 例如 data=pd.read_csv("linghuigui.csv") print (data) 2.第二种方法是函数里面加一个参数:engine=‘python’ 这样的话路径或者是文件是中文的就没事了 data1=pd.read_csv("岭回归....
  • 被 Pandas read_csv 坑了

    千次阅读 2020-12-20 00:33:49
    被 Pandas read_csv 坑了 – 不怕前路坎坷,只怕从一开始就走错了方向 Pandas 是python的一个数据分析包,纳入了大量库和一些标准的数据模型,提供了高效地操作大型数据集所需的工具。Pandas 就是为解决数据分析任务...
  • 我偶尔会接到把csv导入数据库的任务,我通常都是先用pd.read_csv读取文件数据,接着用df.to_sql导入数据库。有时read_csv会遇到不同的编码问题,我的解决方法通常是把常用的几种编码挨个试一下,哪种结果正确就选择...
  • pandas对csv拆分(to_csv,read_csv)

    千次阅读 2019-05-27 10:18:06
    data1 = pd.read_csv(filename, chunksize=chunksize, sep=',', encoding='gbk') num = 0 for chunk in data1: num += len(chunk) chunksize = round(num / file_num + 1) # 需要存的file head, tail = '...
  • 先看如下代码:path = "../test/test_sort.csv" df = pd.DataFrame([['a','a','a'],['a','a','a'],['a','a','a'],['a','a','a'],['a','a'...aa = pd.read_csv(path) print aa产生结果如下:可以看到,下一...
  • 一般情况下, 我们习惯使用 Pandas 中的 read_csv 函数来读取 CSV 文件, 但当 CSV 文件比较大时, read_csv 的速度会显得有点慢, 这时可以考虑使用 HDF5 格式来存储数据, 下面是两个函数所用时间的对比 通过对比可以...
  • Often, you’ll work with data in CSV files and run into problems at the very beginning. 导入数据是任何数据科学项目的第一步。 通常,您将使用CSV文件中的数据,并在一开始就遇到问题。 Am...
  • read_csv:从文件,url,文件型对象中加载带分隔符的数据,默认分隔符为逗号 read_table:从文件,url,文件型对象中加载带分隔符的数据,默认分隔符为制表符("\t") 实质上是通用的,在实际使用中可以通过对sep参数...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 150,504
精华内容 60,201
关键字:

read_csv