title: ‘初识Pandas系列三:数据读写’
tags:

Pandas的数据读写

Pandas的I/O API是一组read()和write()函数，下面是一个方法列表，包含了这里面的所有readers函数和writer函数。

初识Pandas系列三-数据读写（上） - 图1

CSV的读写

read_csv

基本参数：
  • filepath_or_buffer ：可以是文件路径、URL或者是对象（该对象需要具有read()方法）
  • sep（str） : 分隔符，默认为英文逗号（,），可以忽略这个参数，如果是其它分割方式，则要填写
  • delimiter（str）：sep的替代参数，默认为None
  • delim_whitespace（boolean）: 指定是否将空格 (e.g. ‘ ‘ or ‘\t’ )当作delimiter。 等价于设置 sep=’\s+’。如果这个选项被设置为 True,就不需要给 delimiter 传参。
  • encoding（str）:pandas默认编码是utf-8，如果同样读取默认uft-8的txt或者json格式，则可以忽略这个参数，如果是csv，且数据中有中文时，则要指定encoding=‘gbk’
  • header（int or list of ints）: 指定第一行是否是列名，默认为infer。通常有三种用法，忽略或header=0(表示数据第一行为列名，header=None（表明数据没有列名），常与names搭配使用
  • names（array-like）: 指定列名，通常用一个字符串列表表示，默认为None。当header=0时，用names可以替换掉数据中的第一行作为列名，如果header=None，用names可以增加一行作为列名，如果没有header参数时，用names会增加一行作为列名，原数据的第一行仍然保留
  • usecols（list-like or callable）:一个字符串列表，可以指定读取的列名，默认为None
  • index_col（int, str, sequence of int / str, or False）: 一个字符串列表，指定哪几列作为索引，默认为None。当index_col=False，pandas不再使用首列作为索引。
  • skiprows（ list-like or integer）: 跳过多少行再读取数据，通常是数据不太干净，需要去除掉表头才会用到
  • nrows（int）: 仅读取多少行，后面的处理也都仅限于读取的这些行

更多参数可以参考：https://www.pypandas.cn/docs/user_guide/io.html#csv-%E6%96%87%E6%9C%AC%E6%96%87%E4%BB%B6

举例
  1. data = pd.read_csv('example_wp_log_peyton_manning.csv')
  2. print(data)
  3. """
  4.               ds          y
  5. 0     2007-12-10   9.590761
  6. 1     2007-12-11   8.519590
  7. 2     2007-12-12   8.183677
  8. 3     2007-12-13   8.072467
  9. 4     2007-12-14   7.893572
  10.           ...        ...
  11. 2900  2016-01-16   7.817223
  12. 2901  2016-01-17   9.273878
  13. 2902  2016-01-18  10.333775
  14. 2903  2016-01-19   9.125871
  15. 2904  2016-01-20   8.891374
  16. [2905 rows x 2 columns]
  17. """

header默认为infer，如果设置header=None，会在原来的数据上添加一行，从0开始

  1. data = pd.read_csv('example_wp_log_peyton_manning.csv', header=None, nrows=10)
  2. print(data)
  3. """
  4.             0                 1
  5. 0          ds                 y
  6. 1  2007-12-10  9.59076113897809
  7. 2  2007-12-11  8.51959031601596
  8. 3  2007-12-12  8.18367658262066
  9. 4  2007-12-13  8.07246736935477
  10. 5  2007-12-14   7.8935720735049
  11. 6  2007-12-15  7.78364059622125
  12. 7  2007-12-16  8.41405243249672
  13. 8  2007-12-17  8.82922635473185
  14. 9  2007-12-18  8.38251828808963
  15. """

header=None，配合names对新增的一行进行重命名：

  1. data = pd.read_csv('example_wp_log_peyton_manning.csv', header=None, nrows=10, names=['time', 'value'])
  2. print(data)
  3. """
  4.          time             value
  5. 0          ds                 y
  6. 1  2007-12-10  9.59076113897809
  7. 2  2007-12-11  8.51959031601596
  8. 3  2007-12-12  8.18367658262066
  9. 4  2007-12-13  8.07246736935477
  10. 5  2007-12-14   7.8935720735049
  11. 6  2007-12-15  7.78364059622125
  12. 7  2007-12-16  8.41405243249672
  13. 8  2007-12-17  8.82922635473185
  14. 9  2007-12-18  8.38251828808963
  15. """

如果header=0，默认为数据第一行作为列名，使用names对列名进行修改：

  1. data = pd.read_csv('example_wp_log_peyton_manning.csv', header=0, nrows=10, names=['time', 'value'])
  2. print(data)
  3. """
  4.          time     value
  5. 0  2007-12-10  9.590761
  6. 1  2007-12-11  8.519590
  7. 2  2007-12-12  8.183677
  8. 3  2007-12-13  8.072467
  9. 4  2007-12-14  7.893572
  10. 5  2007-12-15  7.783641
  11. 6  2007-12-16  8.414052
  12. 7  2007-12-17  8.829226
  13. 8  2007-12-18  8.382518
  14. 9  2007-12-19  8.069655
  15. """

设置index_col=0为索引：

  1. data = pd.read_csv('example_wp_log_peyton_manning.csv', index_col=0, nrows=10)
  2. print(data)
  3. """
  4.                    y
  5. ds                  
  6. 2007-12-10  9.590761
  7. 2007-12-11  8.519590
  8. 2007-12-12  8.183677
  9. 2007-12-13  8.072467
  10. 2007-12-14  7.893572
  11. 2007-12-15  7.783641
  12. 2007-12-16  8.414052
  13. 2007-12-17  8.829226
  14. 2007-12-18  8.382518
  15. 2007-12-19  8.069655
  16. """

使用usecols指定读取的列，需要输入一个字符串列表

  1. data = pd.read_csv('example_wp_log_peyton_manning.csv', usecols=['ds'], nrows=10)
  2. print(data)
  3. """
  4.            ds
  5. 0  2007-12-10
  6. 1  2007-12-11
  7. 2  2007-12-12
  8. 3  2007-12-13
  9. 4  2007-12-14
  10. 5  2007-12-15
  11. 6  2007-12-16
  12. 7  2007-12-17
  13. 8  2007-12-18
  14. 9  2007-12-19
  15. """

to_csv

基本参数
  • path_or_buf: 输出的文件名
  • sep（str） : 分隔符，默认为英文逗号（,）
  • na_rep（str）: 缺少值的字符串表示形式，默认为空
  • columns（list-like or callable）: 输出的列
  • header（boolean）: 是否包含列名
  • index（boolean）: 是否包含索引
  • encoding: 数据的编码格式

举例
  1. data = pd.read_csv('example_wp_log_peyton_manning.csv', nrows=10)
  2. data.to_csv('test.csv')
  3. """
  4. ,ds,y
  5. 0,2007-12-10,9.59076113897809
  6. 1,2007-12-11,8.51959031601596
  7. 2,2007-12-12,8.18367658262066
  8. 3,2007-12-13,8.072467369354769
  9. 4,2007-12-14,7.893572073504901
  10. 5,2007-12-15,7.78364059622125
  11. 6,2007-12-16,8.41405243249672
  12. 7,2007-12-17,8.82922635473185
  13. 8,2007-12-18,8.38251828808963
  14. 9,2007-12-19,8.06965530688617
  15. """

设置header=False，index=False，并指定只输出ds列

  1. data = pd.read_csv('example_wp_log_peyton_manning.csv', nrows=10)
  2. data.to_csv('test.csv', header=False, index=False，columns=['ds'])
  3. """
  4. 2007-12-10
  5. 2007-12-11
  6. 2007-12-12
  7. 2007-12-13
  8. 2007-12-14
  9. 2007-12-15
  10. 2007-12-16
  11. 2007-12-17
  12. 2007-12-18
  13. 2007-12-19
  14. """

TXT读写

read_table

基本参数和read_csv类似，其中要注意的是txt格式可能会有多种分割符号，sep用正则表达式'\s+'，可以匹配多种分割符号

to_table

基本参数和to_csv类似，只是输入文件格式由csv改为txt即可

JSON读写

read_json

把JSON字符串读取到pandas对象里会采用很多参数。如果typ没有提供或者为None，解析器将尝试解析DataFrame。 要强制地进行Series解析，请传递参数如typ = series。

  • filepath_or_buffer : 一个有效的JSON字符串或文件句柄/StringIO(在内存中读写字符串)。字符串可以是一个URL。有效的URL格式包括http， ftp， S3和文件。对于文件型的URL, 最好有个主机地址。例如一个本地文件可以是 file://localhost/path/to/table.json 这样的格式。
  • typ ： 要恢复的对象类型（series或者frame），默认“frame”。
  • orient :
    Series:
    • 默认是 index。
    • 允许值为{ split, records, index}。

DataFrame:

  • 默认是 columns。
  • 允许值是{ split, records, index, columns, values, table}。

JSON字符串的格式：

split dict like {index -> [index], columns -> [columns], data -> [values]}
records list like [{column -> value}, … , {column -> value}]
index dict like {index -> {column -> value}}
columns dict like {column -> {index -> value}}
values just the values array
table adhering to the JSON Table Schema
  • dtype： 如果为True，推断dtypes，如果列为dtype的字典，则使用那些；如果为False，则根本不推断dtypes，默认为True，仅适用于数据。 如果需要覆盖特定的dtypes，请将字典传递给dtype
  • convert_axes ： 布尔值，尝试将轴转换为正确的dtypes，默认为True。
  • convert_dates ：一列列表要解析为日期; 如果为True，则尝试解析类似日期的列，默认为True。
  • keep_default_dates ：布尔值，默认为True。 如果解析日期，则解析默认的类似日期的列。
  • numpy ：直接解码为NumPy数组。 默认为False; 虽然标签可能是非数字的，但仅支持数字数据。 另请注意，如果numpy = True，则每个术语的JSON顺序 必须 相同。
  • precise_float ：布尔值，默认为False。 当解码字符串为双值时，设置为能使用更高精度（strtod）函数。 默认（False）快速使用但不精确的内置功能。
  • date_unit ：字符串，用于检测转换日期的时间戳单位。 默认无。 默认情况下，将检测时间戳精度，如果不需要，则传递’s’，’ms’，’us’或’ns’中的一个，以强制时间戳精度分别为秒，毫秒，微秒或纳秒。
  • lines ：读取文件每行作为一个JSON对象。
  • encoding ：用于解码py3字节的编码。
  • chunksize ：当与lines = True结合使用时，返回一个Json读取器（JSONReader），每次迭代读取chunksize行。

举例

  1. json='{"a":-0.1693901033,"b":-1.0981572547,"c":0.89998617,"d":0.4362784716,"e":0.3044175417}'
  2. print(pd.read_json(json,typ='series'))
  3. """
  4. a   -0.169390
  5. b   -1.098157
  6. c    0.899986
  7. d    0.436278
  8. e    0.304418
  9. dtype: float64
  10. """
  11. json='{"a":{"A":1,"B":4},"b":{"A":2,"B":5},"c":{"A":3,"B":6}}'
  12. print(pd.read_json(json))
  13. """
  14.    a  b  c
  15. A  1  2  3
  16. B  4  5  6
  17. """
  19. # 不要转换任何数据
  20. print(pd.read_json(json, dtype=object).dtypes)
  21. """
  22. a    object
  23. b    object
  24. c    object
  25. dtype: object
  26. """
  28. # 指定转换的dtypes：
  29. print(pd.read_json(json, dtype={'a': 'float32'}).dtypes)
  30. """
  31. a    float32
  32. b      int64
  33. c      int64
  34. dtype: object
  35. """

to_json

将一个Series或DataFrame转换成一个有效JSON字符串，Series和DataFrane可以参考Pandas的数据结构

基本参数
  • path_or_buf ： 写入输出的路径名或缓存可以是None ， 在这种情况下会返回一个JSON字符串。
  • orient :
    Series :
    • 默认是 index ；
    • 允许的值可以是{split, records, index}。

DataFrame :

  • 默认是 columns ;
  • 允许的值可以是{split, records, index, columns, values, table}。

JSON字符串的格式：

split dict like {index -> [index], columns -> [columns], data -> [values]}
records list like [{column -> value}, … , {column -> value}]
index dict like {index -> {column -> value}}
columns dict like {column -> {index -> value}}
values just the values array
  • date_format : 字符串，日期类型的转换，’eposh’是时间戳，’iso’是 ISO8601。
  • double_precision : 当要编码的是浮点数值时使用的小数位数，默认是 10。
  • force_ascii : 强制编码字符串为 ASCII , 默认是True。
  • date_unit : 时间单位被编码来管理时间戳 和 ISO8601精度。’s’, ‘ms’, ‘us’ 或’ns’中的一个分别为 秒，毫秒，微秒，纳秒。默认是 ‘ms’。
  • default_handler : 如果一个对象没有转换成一个恰当的JSON格式，处理程序就会被调用。采用单个参数，即要转换的对象，并返回一个序列化的对象。
  • lines ： 如果面向 records ，就将每行写入记录为json。

举例

  1. d = pd.DataFrame.from_dict(dict([('A', [1, 2, 3]), ('B', [4, 5, 6])]), orient='index', columns=['a', 'b', 'c'])
  2. print(d)
  3. """
  4.    a  b  c
  5. A  1  2  3
  6. B  4  5  6
  7. """
  8. json = d.to_json()
  9. print(json)
  10. """
  11. {"a":{"A":1,"B":4},"b":{"A":2,"B":5},"c":{"A":3,"B":6}}
  12. """
  13. s = pd.Series(data=np.random.randn(5), index=['a', 'b', 'c', 'd', 'e'], name='test')
  14. print(s)
  15. """
  16. a   -0.169390
  17. b   -1.098157
  18. c    0.899986
  19. d    0.436278
  20. e    0.304418
  21. Name: test, dtype: float64
  22. """
  23. json = s.to_json()
  24. print(json)
  25. """
  26. {"a":-0.1693901033,"b":-1.0981572547,"c":0.89998617,"d":0.4362784716,"e":0.3044175417}
  27. """
  1. d = pd.DataFrame.from_dict(dict([('A', [1, 2, 3]), ('B', [4, 5, 6])]), orient='index', columns=['a', 'b', 'c'])
  2. print(d)
  3. """
  4.    a  b  c
  5. A  1  2  3
  6. B  4  5  6
  7. """
  8. json = d.to_json()
  9. print(json)
  10. """
  11. {"a":{"A":1,"B":4},"b":{"A":2,"B":5},"c":{"A":3,"B":6}}
  12. """
  14. # 面向列的序列化数据，列标签为主键
  15. print(d.to_json(orient="columns"))
  16. """
  17. {"a":{"A":1,"B":4},"b":{"A":2,"B":5},"c":{"A":3,"B":6}}
  18. """
  20. # 面向索引(行)的序列化数据，索引为主键
  21. print(d.to_json(orient="index"))
  22. """
  23. {"A":{"a":1,"b":2,"c":3},"B":{"a":4,"b":5,"c":6}}
  24. """
  26. # 面向记录的序列化数据，其结果为一列JSON数组，索引标签不包括在内
  27. print(d.to_json(orient="records"))
  28. """
  29. [{"a":1,"b":2,"c":3},{"a":4,"b":5,"c":6}]
  30. """
  32. #面向值是一个概要的选项，它只序列化为嵌套的JSON数组值，列和索引标签不包括在内
  33. print(d.to_json(orient="values"))
  34. """
  35. [[1,2,3],[4,5,6]]
  36. """
  38. #面向切分序列化成一个JSON对象，它包括单项的值、索引和列
  39. print(d.to_json(orient="split"))
  40. """
  41. {"columns":["a","b","c"],"index":["A","B"],"data":[[1,2,3],[4,5,6]]}
  42. """

日期处理

使用ISO日期格式写入：

  1. dfd = pd.DataFrame(np.random.randn(5, 2), columns=list('AB'))
  2. print(dfd)
  3. """
  4.           A         B
  5. 0 -0.257501 -0.797096
  6. 1 -1.787324 -0.797445
  7. 2 -0.968066  0.466573
  8. 3  0.305872  0.795448
  9. 4 -0.568483 -1.584783
  10. """
  12. dfd['date'] = pd.Timestamp('20200101')
  13. print(dfd)
  14. """
  15.           A         B       date
  16. 0 -0.257501 -0.797096 2020-01-01
  17. 1 -1.787324 -0.797445 2020-01-01
  18. 2 -0.968066  0.466573 2020-01-01
  19. 3  0.305872  0.795448 2020-01-01
  20. """
  22. # axis：0按照行名排序；1按照列名排序，ascending：默认True升序排列；False降序排列
  23. dfd = dfd.sort_index(axis=1, ascending=False)
  24. print(dfd)
  25. """        
  26.         date         B         A
  27. 0 2020-01-01 -0.797096 -0.257501
  28. 1 2020-01-01 -0.797445 -1.787324
  29. 2 2020-01-01  0.466573 -0.968066
  30. 3 2020-01-01  0.795448  0.305872
  31. 4 2020-01-01 -1.584783 -0.568483
  33. """
  35. json = dfd.to_json(date_format='iso')
  36. print(json)
  37. """
  38. {"date":{"0":"2020-01-01T00:00:00.000Z","1":"2020-01-01T00:00:00.000Z","2":"2020-01-01T00:00:00.000Z","3":"2020-01-01T00:00:00.000Z","4":"2020-01-01T00:00:00.000Z"},"B":{"0":-0.7970955662,"1":-0.7974451025,"2":0.4665727108,"3":0.7954484653,"4":-1.5847833059},"A":{"0":-0.2575013321,"1":-1.7873236202,"2":-0.9680664354,"3":0.3058715067,"4":-0.5684833982}}
  39. """
  41. # 也可以设置date_unit为微秒单位
  42. json = dfd.to_json(date_format='iso',date_unit='us')
  43. print(json)
  44. """
  45. {"date":{"0":"2020-01-01T00:00:00.000000Z","1":"2020-01-01T00:00:00.000000Z","2":"2020-01-01T00:00:00.000000Z","3":"2020-01-01T00:00:00.000000Z","4":"2020-01-01T00:00:00.000000Z"},"B":{"0":-1.4950061863,"1":0.2840948052,"2":0.7902045128,"3":0.968017663,"4":1.2580812032},"A":{"0":-0.0400243341,"1":-0.2648944433,"2":-1.233445634,"3":-1.1086753596,"4":-2.5585893491}}
  46. """
  48. #设置date_unit为秒单位
  49. json = dfd.to_json(date_format='iso',date_unit='s')
  50. print(json)
  51. """
  52. {"date":{"0":"2020-01-01T00:00:00Z","1":"2020-01-01T00:00:00Z","2":"2020-01-01T00:00:00Z","3":"2020-01-01T00:00:00Z","4":"2020-01-01T00:00:00Z"},"B":{"0":-1.4950061863,"1":0.2840948052,"2":0.7902045128,"3":0.968017663,"4":1.2580812032},"A":{"0":-0.0400243341,"1":-0.2648944433,"2":-1.233445634,"3":-1.1086753596,"4":-2.5585893491}}
  53. """

更多参数的解释和举例https://www.pypandas.cn/docs/user_guide/io.html#json