使用 `genfromtxt` 导入数据#

NumPy 提供了几个函数来从表格数据创建数组。这里我们重点介绍 genfromtxt 函数。

简而言之，genfromtxt 运行两个主要的循环。第一个循环将文件的每一行转换为一系列字符串。第二个循环将每个字符串转换为适当的数据类型。这种机制比单循环慢，但提供了更大的灵活性。特别是，genfromtxt 能够考虑缺失数据，而其他更快更简单的函数（如 loadtxt）则无法做到这一点。

注意

在给出示例时，我们将使用以下约定

>>> import numpy as np
>>> from io import StringIO

定义输入#

genfromtxt 唯一必需的参数是数据源。它可以是字符串、字符串列表、生成器或具有 read 方法的打开的文件类对象，例如文件或 io.StringIO 对象。如果提供单个字符串，则假定它是本地或远程文件的名称。如果提供字符串列表或返回字符串的生成器，则每个字符串都被视为文件中的一个行。当传递远程文件的 URL 时，文件会自动下载到当前目录并打开。

识别文件类型为文本文件和归档文件。当前，该函数识别 gzip 和 bz2 (bzip2) 归档文件。归档文件的类型由文件的扩展名确定：如果文件名以 '.gz' 结尾，则预期为 gzip 归档文件；如果以 'bz2' 结尾，则假定为 bzip2 归档文件。

将行拆分为列#

`delimiter` 参数#

定义文件并打开以供读取后，genfromtxt 将每个非空行拆分为一系列字符串。空行或注释行将被跳过。delimiter 关键字用于定义拆分方式。

很多时候，单个字符标记列之间的分隔符。例如，逗号分隔值 (CSV) 文件使用逗号 (,) 或分号 (;) 作为分隔符。

>>> data = "1, 2, 3\n4, 5, 6"
>>> np.genfromtxt(StringIO(data), delimiter=",")
array([[1.,  2.,  3.],
       [4.,  5.,  6.]])

另一个常见的分隔符是 "\t"，即制表符。但是，我们不限于单个字符，任何字符串都可以。默认情况下，genfromtxt 假设 delimiter=None，这意味着该行沿空格（包括制表符）拆分，并且连续空格被视为单个空格。

或者，我们可能正在处理固定宽度文件，其中列定义为给定数量的字符。在这种情况下，我们需要将 delimiter 设置为单个整数（如果所有列的大小相同）或整数序列（如果列的大小可以不同）。

>>> data = "  1  2  3\n  4  5 67\n890123  4"
>>> np.genfromtxt(StringIO(data), delimiter=3)
array([[  1.,    2.,    3.],
       [  4.,    5.,   67.],
       [890.,  123.,    4.]])
>>> data = "123456789\n   4  7 9\n   4567 9"
>>> np.genfromtxt(StringIO(data), delimiter=(4, 3, 2))
array([[1234.,   567.,    89.],
       [   4.,     7.,     9.],
       [   4.,   567.,     9.]])

`autostrip` 参数#

默认情况下，当一行分解成一系列字符串时，各个条目不会去除前导或尾随空格。可以通过将可选参数 autostrip 设置为 True 的值来覆盖此行为。

>>> data = "1, abc , 2\n 3, xxx, 4"
>>> # Without autostrip
>>> np.genfromtxt(StringIO(data), delimiter=",", dtype="|U5")
array([['1', ' abc ', ' 2'],
       ['3', ' xxx', ' 4']], dtype='<U5')
>>> # With autostrip
>>> np.genfromtxt(StringIO(data), delimiter=",", dtype="|U5", autostrip=True)
array([['1', 'abc', '2'],
       ['3', 'xxx', '4']], dtype='<U5')

`comments` 参数#

可选参数 comments 用于定义一个字符字符串，该字符串标记注释的开始。默认情况下，genfromtxt 假设 comments='#'。注释标记可能出现在行的任何位置。注释标记（s）后出现的任何字符都将被简单地忽略。

>>> data = """#
... # Skip me !
... # Skip me too !
... 1, 2
... 3, 4
... 5, 6 #This is the third line of the data
... 7, 8
... # And here comes the last line
... 9, 0
... """
>>> np.genfromtxt(StringIO(data), comments="#", delimiter=",")
array([[1., 2.],
       [3., 4.],
       [5., 6.],
       [7., 8.],
       [9., 0.]])

版本 1.7.0 中的新功能：当 comments 设置为 None 时，不会将任何行视为注释。

注意

此行为有一个值得注意的例外：如果可选参数 names=True，则将检查第一行注释以获取名称。

跳过行并选择列#

`skip_header` 和 `skip_footer` 参数#

文件中的标题的存在可能会妨碍数据处理。在这种情况下，我们需要使用 skip_header 可选参数。此参数的值必须为一个整数，该整数对应于在执行任何其他操作之前跳过文件开头的行数。类似地，我们可以使用 skip_footer 属性并将其值设置为 n 来跳过文件的最后 n 行。

>>> data = "\n".join(str(i) for i in range(10))
>>> np.genfromtxt(StringIO(data),)
array([0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.])
>>> np.genfromtxt(StringIO(data),
...               skip_header=3, skip_footer=5)
array([3.,  4.])

默认情况下，skip_header=0 和 skip_footer=0，这意味着不会跳过任何行。

`usecols` 参数#

在某些情况下，我们对数据的所有列都不感兴趣，而只对其中的一些列感兴趣。我们可以使用 usecols 参数选择要导入的列。此参数接受单个整数或整数序列，对应于要导入的列的索引。请记住，按照约定，第一列的索引为 0。负整数的行为与常规 Python 负索引相同。

例如，如果我们只想导入第一列和最后一列，我们可以使用 usecols=(0, -1)。

>>> data = "1 2 3\n4 5 6"
>>> np.genfromtxt(StringIO(data), usecols=(0, -1))
array([[1.,  3.],
       [4.,  6.]])

如果列具有名称，我们还可以通过将它们的名称提供给 usecols 参数（作为字符串序列或逗号分隔字符串）来选择要导入的列。

>>> data = "1 2 3\n4 5 6"
>>> np.genfromtxt(StringIO(data),
...               names="a, b, c", usecols=("a", "c"))
array([(1., 3.), (4., 6.)], dtype=[('a', '<f8'), ('c', '<f8')])
>>> np.genfromtxt(StringIO(data),
...               names="a, b, c", usecols=("a, c"))
    array([(1., 3.), (4., 6.)], dtype=[('a', '<f8'), ('c', '<f8')])

选择数据类型#

控制如何将从文件中读取的字符串序列转换为其他类型的主要方法是设置 dtype 参数。此参数的可接受值为：

单个类型，例如 dtype=float。输出将为 2D 且具有给定的 dtype，除非使用 names 参数（见下文）将名称与每列关联。请注意，dtype=float 是 genfromtxt 的默认值。
类型序列，例如 dtype=(int, float, float)。
逗号分隔字符串，例如 dtype="i4,f8,|U3"。
具有两个键 'names' 和 'formats' 的字典。
元组 (name, type) 的序列，例如 dtype=[('A', int), ('B', float)]。
现有的 numpy.dtype 对象。
特殊值 None。在这种情况下，将根据数据本身确定列的类型（见下文）。

在所有情况下，除了第一个情况外，输出都将是一个具有结构化 dtype 的 1D 数组。此 dtype 具有与序列中的项目一样多的字段。字段名称由 names 关键字定义。

当 dtype=None 时，每列的类型都是根据其数据迭代确定。我们首先检查字符串是否可以转换为布尔值（即，如果字符串与小写形式的 true 或 false 匹配）；然后检查它是否可以转换为整数，然后转换为浮点数，然后转换为复数，最后转换为字符串。

dtype=None 选项是为了方便提供。但是，它比显式设置 dtype 慢得多。

设置名称#

`names` 参数#

处理表格数据时的一种自然方法是为每列分配一个名称。第一种可能性是使用前面提到的显式结构化 dtype。

>>> data = StringIO("1 2 3\n 4 5 6")
>>> np.genfromtxt(data, dtype=[(_, int) for _ in "abc"])
array([(1, 2, 3), (4, 5, 6)],
      dtype=[('a', '<i8'), ('b', '<i8'), ('c', '<i8')])

另一种更简单的可能性是使用 names 关键字以及字符串序列或逗号分隔字符串。

>>> data = StringIO("1 2 3\n 4 5 6")
>>> np.genfromtxt(data, names="A, B, C")
array([(1., 2., 3.), (4., 5., 6.)],
      dtype=[('A', '<f8'), ('B', '<f8'), ('C', '<f8')])

在上面的示例中，我们使用了默认情况下 dtype=float 的事实。通过提供一系列名称，我们强制输出为结构化 dtype。

我们有时可能需要根据数据本身定义列名。在这种情况下，我们必须将 names 关键字的值设置为 True。然后将从第一行（在 skip_header 行之后）读取名称，即使该行已注释掉也是如此。

>>> data = StringIO("So it goes\n#a b c\n1 2 3\n 4 5 6")
>>> np.genfromtxt(data, skip_header=1, names=True)
array([(1., 2., 3.), (4., 5., 6.)],
      dtype=[('a', '<f8'), ('b', '<f8'), ('c', '<f8')])

names 的默认值为 None。如果我们给关键字赋予任何其他值，则新名称将覆盖我们可能使用 dtype 定义的字段名称。

>>> data = StringIO("1 2 3\n 4 5 6")
>>> ndtype=[('a',int), ('b', float), ('c', int)]
>>> names = ["A", "B", "C"]
>>> np.genfromtxt(data, names=names, dtype=ndtype)
array([(1, 2., 3), (4, 5., 6)],
      dtype=[('A', '<i8'), ('B', '<f8'), ('C', '<i8')])

`defaultfmt` 参数#

如果 names=None 但预期结构化 dtype，则名称将使用 NumPy 的标准默认值 "f%i" 定义，从而产生诸如 f0、f1 等名称。

>>> data = StringIO("1 2 3\n 4 5 6")
>>> np.genfromtxt(data, dtype=(int, float, int))
array([(1, 2., 3), (4, 5., 6)],
      dtype=[('f0', '<i8'), ('f1', '<f8'), ('f2', '<i8')])

同样，如果我们没有提供足够的名称来匹配 dtype 的长度，则将使用此默认模板定义缺失的名称。

>>> data = StringIO("1 2 3\n 4 5 6")
>>> np.genfromtxt(data, dtype=(int, float, int), names="a")
array([(1, 2., 3), (4, 5., 6)],
      dtype=[('a', '<i8'), ('f0', '<f8'), ('f1', '<i8')])

我们可以使用 defaultfmt 参数覆盖此默认值，该参数接受任何格式字符串。

>>> data = StringIO("1 2 3\n 4 5 6")
>>> np.genfromtxt(data, dtype=(int, float, int), defaultfmt="var_%02i")
array([(1, 2., 3), (4, 5., 6)],
      dtype=[('var_00', '<i8'), ('var_01', '<f8'), ('var_02', '<i8')])

注意

我们需要记住，仅当预期某些名称但未定义时，才会使用 defaultfmt。

验证名称#

具有结构化dtype的NumPy数组也可以被视为recarray，其中字段可以像访问属性一样被访问。因此，我们需要确保字段名称不包含任何空格或无效字符，或者它不对应于标准属性的名称（如size或shape），否则会使解释器混淆。genfromtxt接受三个可选参数，可以更精细地控制名称

deletechars: 提供一个字符串，组合所有必须从名称中删除的字符。默认情况下，无效字符为~!@#$%^&*()-=+~\|]}[{';: /?.>,<。
excludelist: 提供一个要排除的名称列表，例如return、file、print…如果输入名称之一是此列表的一部分，则会在其后附加下划线字符（'_'）。
case_sensitive: 名称是否区分大小写（case_sensitive=True），转换为大写（case_sensitive=False或case_sensitive='upper'）或转换为小写（case_sensitive='lower'）。

调整转换#

the `converters` 参数#

通常，定义dtype足以定义字符串序列必须如何转换。但是，有时可能需要一些额外的控制。例如，我们可能希望确保格式为YYYY/MM/DD的日期转换为datetime对象，或者像xx%这样的字符串被正确地转换为0到1之间的浮点数。在这种情况下，我们应该使用converters参数定义转换函数。

此参数的值通常是一个字典，其中列索引或列名称作为键，转换函数作为值。这些转换函数可以是实际函数或lambda函数。无论哪种情况，它们都应该只接受一个字符串作为输入，并且只输出所需类型的一个元素。

在下面的示例中，第二列从表示百分比的字符串转换为0到1之间的浮点数

>>> convertfunc = lambda x: float(x.strip("%"))/100.
>>> data = "1, 2.3%, 45.\n6, 78.9%, 0"
>>> names = ("i", "p", "n")
>>> # General case .....
>>> np.genfromtxt(StringIO(data), delimiter=",", names=names)
array([(1., nan, 45.), (6., nan, 0.)],
      dtype=[('i', '<f8'), ('p', '<f8'), ('n', '<f8')])

我们需要记住，默认情况下，dtype=float。因此，第二列需要一个浮点数。但是，字符串' 2.3%'和' 78.9%'无法转换为浮点数，最终得到np.nan。现在让我们使用一个转换器

>>> # Converted case ...
>>> np.genfromtxt(StringIO(data), delimiter=",", names=names,
...               converters={1: convertfunc})
array([(1., 0.023, 45.), (6., 0.789, 0.)],
      dtype=[('i', '<f8'), ('p', '<f8'), ('n', '<f8')])

使用第二列的名称（"p"）作为键而不是其索引（1）可以获得相同的结果

>>> # Using a name for the converter ...
>>> np.genfromtxt(StringIO(data), delimiter=",", names=names,
...               converters={"p": convertfunc})
array([(1., 0.023, 45.), (6., 0.789, 0.)],
      dtype=[('i', '<f8'), ('p', '<f8'), ('n', '<f8')])

转换器还可以用于为缺失的条目提供默认值。在下面的示例中，转换器convert将剥离的字符串转换为相应的浮点数，如果字符串为空则转换为-999。我们需要显式地从字符串中剥离空格，因为默认情况下不会这样做

>>> data = "1, , 3\n 4, 5, 6"
>>> convert = lambda x: float(x.strip() or -999)
>>> np.genfromtxt(StringIO(data), delimiter=",",
...               converters={1: convert})
array([[   1., -999.,    3.],
       [   4.,    5.,    6.]])

使用缺失值和填充值#

我们尝试导入的数据集中可能缺少一些条目。在前面的示例中，我们使用转换器将空字符串转换为浮点数。但是，用户定义的转换器可能很快变得难以管理。

genfromtxt函数提供了另外两种互补机制：missing_values参数用于识别缺失数据，第二个参数filling_values用于处理这些缺失数据。

`missing_values`#

默认情况下，任何空字符串都被标记为缺失。我们还可以考虑更复杂的字符串，例如"N/A"或"???"来表示缺失或无效数据。missing_values参数接受三种类型的值

字符串或逗号分隔的字符串: 此字符串将用作所有列的缺失数据的标记
字符串序列: 在这种情况下，每个项目按顺序与一列关联。
字典: 字典的值是字符串或字符串序列。相应的键可以是列索引（整数）或列名称（字符串）。此外，特殊键None可用于定义适用于所有列的默认值。

`filling_values`#

我们知道如何识别缺失数据，但我们仍然需要为这些缺失条目提供一个值。默认情况下，此值根据下表中预期的dtype确定

预期类型	默认值
`bool`	`False`
`int`	`-1`
`float`	`np.nan`
`complex`	`np.nan+0j`
`string`	`'???'`

我们可以使用filling_values可选参数更精细地控制缺失值的转换。与missing_values一样，此参数接受不同类型的值

单个值: 这将成为所有列的默认值
值序列: 每个条目将成为对应列的默认值
字典: 每个键可以是列索引或列名称，相应的键值应该是一个单一对象。我们可以使用特殊键None定义所有列的默认值。

在下面的示例中，我们假设第一列中缺失的值用"N/A"标记，第三列中缺失的值用"???"标记。如果这些缺失值出现在第一列和第二列中，我们希望将其转换为0，如果出现在最后一列中，则转换为-999

>>> data = "N/A, 2, 3\n4, ,???"
>>> kwargs = dict(delimiter=",",
...               dtype=int,
...               names="a,b,c",
...               missing_values={0:"N/A", 'b':" ", 2:"???"},
...               filling_values={0:0, 'b':0, 2:-999})
>>> np.genfromtxt(StringIO(data), **kwargs)
array([(0, 2, 3), (4, 0, -999)],
      dtype=[('a', '<i8'), ('b', '<i8'), ('c', '<i8')])

`usemask`#

我们可能还想通过构造一个布尔掩码来跟踪缺失数据的出现，在数据缺失的地方使用True条目，否则使用False。为此，我们只需将可选参数usemask设置为True（默认为False）。然后，输出数组将成为MaskedArray。

使用 genfromtxt 导入数据#

定义输入#

将行拆分为列#

delimiter 参数#

autostrip 参数#

comments 参数#