Utilisation de CSV comme outil d'E/S pour les opérations de lecture et d'écriture dans les pandas de traitement de données Python

Préface

Le de <code>pandas IO API est un ensemble de fonctions reader de niveau supérieur, telles que pandas.read_csv(), qui renverront un pandas code>. pandas 的 IO API 是一组顶层的 reader 函数，比如 pandas.read_csv()，会返回一个 pandas 对象。

而相应的 writer 函数是对象方法，如 DataFrame.to_csv()。

注意：后面会用到 StringIO，请确保导入

# python3
from io import StringIO
# python2
from StringIO import StringIO

1 CSV 和文本文件

读取文本文件的主要函数是 read_csv()

1 参数解析

read_csv() 接受以下常用参数:

1.1 基础

filepath_or_buffer: 变量

• 可以是文件路径、文件 URL 或任何带有 read() 函数的对象

sep: str，默认 ,，对于 read_table 是 t

• 文件分隔符，如果设置为 None，则 C 引擎无法自动检测分隔符，而 Python 引擎可以通过内置的嗅探器工具自动检测分隔符。

• 此外，如果设置的字符长度大于 1，且不是 's+'，那么该字符串会被解析为正则表达式，且强制使用 Python 解析引擎。

• 例如 '\r\t'，但是正则表达式容易忽略文本中的引用数据。

delimiter: str, 默认为 None

• sep 的替代参数，功能一致

1.2 列、索引、名称

header: int 或 list, 默认为 'infer'

• 用作列名的行号，默认行为是对列名进行推断：

• 如果未指定 names 参数其行为类似于 header=0，即从读取的第一行开始推断。

• 如果设置了 names，则行为与 header=None 相同。

• 也可以为 header 设置列表，表示多级列名。如 [0,1,3]，未指定的行（这里是 2）将会被跳过，如果 skip_blank_lines=True，则会跳过空行和注释的行。因此 header=0 并不是代表文件的第一行

names: array-like, 默认为 None

• 需要设置的列名列表，如果文件中不包含标题行，则应显式传递 header=None，且此列表中不允许有重复值。

index_col: int, str, sequence of int/str, False, 默认为 None

• 用作 DataFrame 的索引的列，可以字符串名称或列索引的形式给出。如果指定了列表，则使用 MultiIndex

• 注意：index_col=False 可用于强制 pandas 不要将第一列用作索引。例如，当您的文件是每行末尾都带有一个分隔符的错误文件时。

usecols: 列表或函数, 默认为 None

• 只读取指定的列。如果是列表，则所有元素都必须是位置（即文件列中的整数索引）或字符串，这些字符串必须与 names 参数提供的或从文档标题行推断出的列名相对应。

• 列表中的顺序会被忽略，即 usecols=[0, 1] 等价于 [1, 0]

• 如果是可调用函数，将会根据列名计算，返回可调用函数计算为 True 的名称

In [1]: import pandas as pd
In [2]: from io import StringIO
In [3]: data = "col1,col2,col3\na,b,1\na,b,2\nc,d,3"
In [4]: pd.read_csv(StringIO(data))
Out[4]: 
  col1 col2  col3
0    a    b     1
1    a    b     2
2    c    d     3
In [5]: pd.read_csv(StringIO(data), usecols=lambda x: x.upper() in ["COL1", "COL3"])
Out[5]: 
  col1  col3
0    a     1
1    a     2
2    c     3

使用此参数可以大大加快解析时间并降低内存使用

squeeze: boolean, 默认为 False

• 如果解析的数据只包含一列，那么返回一个 Series

prefix: str, 默认为 None

• 当没有标题时，添加到自动生成的列号的前缀，例如 'X' 表示 X0, X1...

mangle_dupe_cols: boolean, 默认为 True

La fonction writer correspondante est une méthode objet, telle que DataFrame.to_csv(). #🎜🎜##🎜🎜#Remarque : StringIO sera utilisé plus tard, assurez-vous d'importer #🎜🎜#

In [6]: data = "col1,col2,col3\na,b,1\na,b,2\nc,d,3"
In [7]: pd.read_csv(StringIO(data))
Out[7]: 
  col1 col2  col3
0    a    b     1
1    a    b     2
2    c    d     3
In [8]: pd.read_csv(StringIO(data), skiprows=lambda x: x % 2 != 0)
Out[8]: 
  col1 col2  col3
0    a    b     2

#🎜🎜#1 Fichiers CSV et texte #🎜🎜##🎜🎜# lire La fonction principale des fichiers texte est read_csv()#🎜🎜#

1 L'analyse des paramètres

#🎜🎜#read_csv() accepte ce qui suit paramètres communs :# 🎜🎜#

Bases de la 1.1

#🎜🎜#filepath_or_buffer : Variable #🎜🎜#

• # 🎜🎜#Oui Est un chemin de fichier, une URL de fichier ou tout objet avec une fonction read() #🎜🎜#
#🎜🎜##🎜🎜# sep  : str, par défaut ,, pour read_table c'est t#🎜🎜 #
• #🎜🎜#Délimiteur de fichier, s'il est défini sur Aucun, le moteur C ne peut pas détecter automatiquement le délimiteur , et le moteur Python peut détecter automatiquement les délimiteurs via l'outil de renifleur intégré. #🎜🎜#
• #🎜🎜#De plus, si la longueur de caractère définie est supérieure à 1 et n'est pas 's+', alors le La chaîne sera analysée comme une expression régulière, forçant l'utilisation du moteur d'analyse Python. #🎜🎜#
• #🎜🎜#Par exemple '\r\t', mais les expressions régulières ont tendance à ignorer les données de référence dans le texte. #🎜🎜#
#🎜🎜##🎜🎜#delimiter : str, la valeur par défaut est Aucun#🎜🎜#
• #🎜🎜#sep paramètre alternatif, la fonction est la même#🎜🎜#
#🎜🎜#

1.2 Colonne , index , name

#🎜🎜#header : int ou list, la valeur par défaut est 'infer'</ code># 🎜🎜#<ul class=" list-paddingleft-2"><li>#🎜🎜#Le numéro de ligne utilisé comme nom de colonne, le comportement par défaut est de déduire le nom de la colonne : #🎜🎜#</ li><ul class =" list-paddingleft-2" ><li>#🎜🎜#Si le paramètre <code>names n'est pas spécifié, le comportement est similaire à header=0</code >, c'est-à-dire qu'à partir de la première lecture, Line commence l'inférence. #🎜🎜#</li><li>#🎜🎜#Si <code>names est défini, le comportement est le même que header=None. #🎜🎜##🎜🎜#
• #🎜🎜# Vous pouvez également définir une liste pour header afin de représenter les noms de colonnes à plusieurs niveaux. Par exemple, [0,1,3], les lignes non spécifiées (ici 2) seront ignorées. Si skip_blank_lines=True, les lignes vides et les lignes commentées seront ignorées. Donc header=0 ne représente pas la première ligne du fichier#🎜🎜#
#🎜🎜##🎜🎜#names : array- comme , la valeur par défaut est Aucun#🎜🎜#
• #🎜🎜#La liste des noms de colonnes qui doivent être définis , si le fichier ne contient pas de ligne d'en-tête, header=None doit être transmis explicitement et aucune valeur en double n'est autorisée dans cette liste. #🎜🎜#
#🎜🎜##🎜🎜#index_col : int, str, séquence de int/ str, False, la valeur par défaut est Aucun#🎜🎜#
• #🎜🎜# est utilisé as La colonne de l'index du DataFrame, donnée sous forme de nom de chaîne ou d'index de colonne. Si une liste est spécifiée, utilisez MultiIndex#🎜🎜#
• #🎜🎜# Remarque : index_col=False peut être utilisé pour forcer pandas< /code> N'utilisez pas la première colonne comme index. Par exemple, lorsque votre fichier est un mauvais fichier avec un délimiteur à la fin de chaque ligne. #🎜🎜#</li>#🎜🎜##🎜🎜#<code>usecols : liste ou fonction, la valeur par défaut est Aucun#🎜🎜#
  • #🎜🎜#Lire uniquement les colonnes spécifiées. S'il s'agit d'une liste, tous les éléments doivent être soit des positions (c'est-à-dire des indices entiers dans les colonnes du fichier), soit des chaînes qui correspondent aux noms de colonnes fournis par le paramètre names ou déduits de la ligne d'en-tête du document correspondante. #🎜🎜#
  • #🎜🎜#L'ordre dans la liste sera ignoré, c'est-à-dire que usecols=[0, 1] est équivalent à [1, 0]< /code>#🎜🎜#</li><li>#🎜🎜#S'il s'agit d'une fonction appelable, elle sera calculée en fonction du nom de la colonne et du nom de la fonction appelable calculé comme <code> True sera renvoyé#🎜🎜 #
  #🎜🎜#

  compression={'method': 'gzip', 'compresslevel': 1, 'mtime': 1}

  #🎜🎜#L'utilisation de ce paramètre peut considérablement accélérer le temps d'analyse et réduire l'utilisation de la mémoire #🎜🎜##🎜🎜#squeeze  : booléen</code >, la valeur par défaut est <code>False#🎜🎜#
  • #🎜🎜#Si le les données analysées ne contiennent qu'une seule colonne, puis renvoient une Série #🎜🎜#
  #🎜🎜##🎜🎜#prefix : str</code >, la valeur par défaut est <code>Aucun#🎜 🎜#
  • #🎜🎜# Lorsqu'il n'y a pas de titre, le préfixe est ajouté au numéro de colonne généré automatiquement , tel que 'X' signifie X0, X1...#🎜🎜#
  #🎜🎜##🎜🎜# mangle_dupe_cols : booléen</code >, la valeur par défaut est <code>True#🎜🎜#

  • 重复的列将被指定为 'X','X.1'…'X.N'，而不是 'X'... 。如果在列中有重复的名称，传递 False 将导致数据被覆盖

  1.3 常规解析配置

  dtype: 类型名或类型字典（column -> type）, 默认为 None

  • 数据或列的数据类型。例如。 {'a'：np.float64，'b'：np.int32}

  engine: {'c', 'python'}

  • 要使用的解析器引擎。C 引擎更快，而 Python 引擎目前功能更完整

  converters: dict, 默认为 None

  • 用于在某些列中对值进行转换的函数字典。键可以是整数，也可以是列名

  true_values: list, 默认为 None

  • 数据值解析为 True

  false_values: list, 默认为 None

  • 数据值解析为 False

  skipinitialspace: boolean, 默认为 False

  • 跳过分隔符之后的空格

  skiprows: 整数或整数列表, 默认为 None

  • 在文件开头要跳过的行号（索引为 0）或要跳过的行数

  • 如果可调用函数，则对索引应用函数，如果返回 True，则应跳过该行，否则返回 False

  In [6]: data = "col1,col2,col3\na,b,1\na,b,2\nc,d,3"
  In [7]: pd.read_csv(StringIO(data))
  Out[7]: 
    col1 col2  col3
  0    a    b     1
  1    a    b     2
  2    c    d     3
  In [8]: pd.read_csv(StringIO(data), skiprows=lambda x: x % 2 != 0)
  Out[8]: 
    col1 col2  col3
  0    a    b     2

  skipfooter: int, 默认为 0

  • 需要跳过文件末尾的行数（不支持 C 引擎）

  nrows: int, 默认为 None

  • 要读取的文件行数，对于读取大文件很有用

  memory_map: boolean, 默认为 False

  • 如果为 filepath_or_buffer 参数指定了文件路径，则将文件对象直接映射到内存中，然后直接从那里访问数据。使用此选项可以提高性能，因为不再有任何 I/O 开销

  1.4 NA 和缺失数据处理

  na_values: scalar, str, list-like, dict, 默认为 None

  • 需要转换为 NA 值的字符串

  keep_default_na: boolean, 默认为 True

  • 解析数据时是否包含默认的 NaN 值。根据是否传入 na_values，其行为如下

  • keep_default_na=True, 且指定了 na_values, na_values 将会与默认的 NaN 一起被解析

  • keep_default_na=True, 且未指定 na_values, 只解析默认的 NaN

  • keep_default_na=False, 且指定了 na_values, 只解析 na_values 指定的 NaN

  • keep_default_na=False, 且未指定 na_values, 字符串不会被解析为 NaN

  注意：如果 na_filter=False，那么 keep_default_na 和 na_values 参数将被忽略

  na_filter: boolean, 默认为 True

  • 检测缺失值标记（空字符串和 na_values 的值）。在没有任何 NA 的数据中，设置 na_filter=False 可以提高读取大文件的性能

  skip_blank_lines: boolean, 默认为 True

  • 如果为 True，则跳过空行，而不是解释为 NaN 值

  1.5 日期时间处理

  parse_dates: 布尔值、列表或嵌套列表、字典, 默认为 False.

  • 如果为 True -> 尝试解析索引

  • 如果为 [1, 2, 3] -> 尝试将 1, 2, 3 列解析为分隔的日期

  • 如果为 [[1, 3]] -> 将 1, 3 列解析为单个日期列

  • 如果为 {'foo': [1, 3]} -> 将 1, 3 列作为日期并设置列名为 foo

  infer_datetime_format: 布尔值, 默认为 False

  • 如果设置为 True 且设置了 parse_dates，则尝试推断 datetime 格式以加快处理速度

  date_parser: 函数, 默认为 None

  • 用于将字符串序列转换为日期时间实例数组的函数。默认使用 dateutil.parser.parser 进行转换，pandas 将尝试以三种不同的方式调用 date_parser

  • 传递一个或多个数组（parse_dates 定义的列）作为参数;

  • 将 parse_dates 定义的列中的字符串值连接到单个数组中，并将其传递;

  • 使用一个或多个字符串(对应于 parse_dates 定义的列)作为参数，对每一行调用 date_parser 一次。

  dayfirst: 布尔值, 默认为 False

  • DD/MM 格式的日期

  cache_dates: 布尔值, 默认为 True

  • 如果为 True，则使用唯一的、经过转换的日期缓存来应用 datetime 转换。

  • 在解析重复的日期字符串，特别是带有时区偏移量的日期字符串时，可能会显著提高速度。

  1.6 迭代

  iterator: boolean, 默认为 False

  • 返回 TextFileReader 对象以进行迭代或使用 get_chunk() 来获取块

  1.7 引用、压缩和文件格式

  compression: {'infer', 'gzip', 'bz2', 'zip', 'xz', None, dict}, 默认为 'infer'

  • 用于对磁盘数据进行即时解压缩。如果为 "infer"，则如果 filepath_or_buffer 是文件路径且以 ".gz"，".bz2"，".zip" 或 ".xz" 结尾，则分别使用 gzip，bz2，zip 或 xz 解压，否则不进行解压缩。

  • 如果使用 "zip"，则 ZIP 文件必须仅包含一个要读取的数据文件。设置为 None 表示不解压

  • 也可以使用字典的方式，键为 method 的值从 {'zip', 'gzip', 'bz2'} 中选择。例如

  compression={'method': 'gzip', 'compresslevel': 1, 'mtime': 1}

  thousandsstr, 默认为 None

  • 数值在千位的分隔符

  decimal: str, 默认为 '.'

  • 小数点

  float_precision: string, 默认为 None

  • 指定 C 引擎应该使用哪个转换器来处理浮点值。普通转换器的选项为 None，高精度转换器的选项为 high，双向转换器的选项为 round_trip。

  quotechar: str (长度为 1)

  • 用于表示被引用数据的开始和结束的字符。带引号的数据里的分隔符将被忽略

  comment: str, 默认为 None

  • 用于跳过该字符开头的行，例如，如果 comment='#'，将会跳过 # 开头的行

  encoding: str, 默认为 None

  • 设置编码格式

  1.8 错误处理

  error_bad_linesboolean, 默认为 True

  • 默认情况下，字段太多的行（例如，带有太多逗号的 csv 文件）会引发异常，并且不会返回任何 DataFrame。

  • 如果设置为 False，则这些坏行将会被删除

  warn_bad_linesboolean, 默认为 True

  • 如果 error_bad_lines=False 且 warn_bad_lines=True，每个坏行都会输出一个警告

  2. 指定数据列的类型

  您可以指示整个 DataFrame 或各列的数据类型

  In [9]: import numpy as np
  In [10]: data = "a,b,c,d\n1,2,3,4\n5,6,7,8\n9,10,11"
  In [11]: print(data)
  a,b,c,d
  1,2,3,4
  5,6,7,8
  9,10,11
  In [12]: df = pd.read_csv(StringIO(data), dtype=object)
  In [13]: df
  Out[13]: 
     a   b   c    d
  0  1   2   3    4
  1  5   6   7    8
  2  9  10  11  NaN
  In [14]: df["a"][0]
  Out[14]: '1'
  In [15]: df = pd.read_csv(StringIO(data), dtype={"b": object, "c": np.float64, "d": "Int64"})
  In [16]: df.dtypes
  Out[16]: 
  a      int64
  b     object
  c    float64
  d      Int64
  dtype: object

  你可以使用 read_csv() 的 converters 参数，统一某列的数据类型

  In [17]: data = "col_1\n1\n2\n'A'\n4.22"
  In [18]: df = pd.read_csv(StringIO(data), converters={"col_1": str})
  In [19]: df
  Out[19]: 
    col_1
  0     1
  1     2
  2   'A'
  3  4.22
  In [20]: df["col_1"].apply(type).value_counts()
  Out[20]: 
  <class &#39;str&#39;>    4
  Name: col_1, dtype: int64

  或者，您可以在读取数据后使用 to_numeric() 函数强制转换类型

  In [21]: df2 = pd.read_csv(StringIO(data))
  In [22]: df2["col_1"] = pd.to_numeric(df2["col_1"], errors="coerce")
  In [23]: df2
  Out[23]: 
     col_1
  0   1.00
  1   2.00
  2    NaN
  3   4.22
  In [24]: df2["col_1"].apply(type).value_counts()
  Out[24]: 
  <class &#39;float&#39;>    4
  Name: col_1, dtype: int64

  它将所有有效的数值转换为浮点数，而将无效的解析为 NaN

  最后，如何处理包含混合类型的列取决于你的具体需要。在上面的例子中，如果您只想要将异常的数据转换为 NaN，那么 to_numeric() 可能是您的最佳选择。

  然而，如果您想要强制转换所有数据，而无论类型如何，那么使用 read_csv() 的 converters 参数会更好

  注意

  在某些情况下，读取包含混合类型列的异常数据将导致数据集不一致。

  如果您依赖 pandas 来推断列的类型，解析引擎将继续推断数据块的类型，而不是一次推断整个数据集。

  In [25]: col_1 = list(range(500000)) + ["a", "b"] + list(range(500000))
  In [26]: df = pd.DataFrame({"col_1": col_1})
  In [27]: df.to_csv("foo.csv")
  In [28]: mixed_df = pd.read_csv("foo.csv")
  In [29]: mixed_df["col_1"].apply(type).value_counts()
  Out[29]: 
  <class &#39;int&#39;>    737858
  <class &#39;str&#39;>    262144
  Name: col_1, dtype: int64
  In [30]: mixed_df["col_1"].dtype
  Out[30]: dtype(&#39;O&#39;)

  这就导致 mixed_df 对于列的某些块包含 int 类型，而对于其他块则包含 str，这是由于读取的数据是混合类型。

  Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!