NumPy 基础知识

数据类型

数组类型之间的转换

NumPy支持比Python更多种类的数字类型。本节显示了哪些可用，以及如何修改数组的数据类型。

支持的原始类型与 C 中的原始类型紧密相关：

由于其中许多都具有依赖于平台的定义，因此提供了一组固定大小的别名：

NumPy数值类型是dtype（数据类型）对象的实例，每个对象都具有独特的特征。使用后导入NumPy

>>> import numpy as np

在dtypes可作为np.bool_，np.float32等等。

上表中未列出的高级类型将在结构化数组中进行探讨。

有5种基本数字类型表示布尔值（bool），整数（int），无符号整数（uint）浮点（浮点数）和复数。名称中带有数字的那些表示该类型的位大小（即，在内存中表示单个值需要多少位）。某些类型（例如 int 和 intp）具有不同的位，取决于平台（例如，32位与64位计算机）。在与寻址原始内存的低级代码（例如C或Fortran）连接时，应考虑这一点。

数据类型可以用作将python数转换为数组标量的函数（请参阅数组标量部分以获得解释），将python数字序列转换为该类型的数组，或作为许多numpy函数或方法接受的dtype关键字的参数。一些例子：

>>> import numpy as np
>>> x = np.float32(1.0)
>>> x
1.0
>>> y = np.int_([1,2,4])
>>> y
array([1, 2, 4])
>>> z = np.arange(3, dtype=np.uint8)
>>> z
array([0, 1, 2], dtype=uint8)

数组类型也可以通过字符代码引用，主要是为了保持与较旧的包（如Numeric）的向后兼容性。有些文档可能仍然引用这些，例如：

>>> np.array([1, 2, 3], dtype='f')
array([ 1.,  2.,  3.], dtype=float32)

我们建议使用dtype对象。

要转换数组的类型，请使用 .astype() 方法（首选）或类型本身作为函数。例如：

>>> z.astype(float)                 
array([  0.,  1.,  2.])
>>> np.int8(z)
array([0, 1, 2], dtype=int8)

注意，在上面，我们使用 Python 的 float对象作为dtype。NumPy的人都知道int是指np.int_，bool意味着np.bool_，这float是np.float_和complex是np.complex_。其他数据类型没有Python等价物。

要确定数组的类型，请查看dtype属性：

>>> z.dtype
dtype('uint8')

dtype对象还包含有关类型的信息，例如其位宽和字节顺序。数据类型也可以间接用于查询类型的属性，例如它是否为整数：

>>> d = np.dtype(int)
>>> d
dtype('int32')
​
>>> np.issubdtype(d, np.integer)
True
​
>>> np.issubdtype(d, np.floating)
False

数组标量

NumPy通常将数组元素作为数组标量返回（带有关联dtype的标量）。数组标量与Python标量不同，但在大多数情况下它们可以互换使用（主要的例外是早于v2.x的Python版本，其中整数数组标量不能作为列表和元组的索引）。有一些例外，例如当代码需要标量的非常特定的属性或者它特定地检查值是否是Python标量时。通常，存在的问题很容易被显式转换数组标量到Python标量，采用相应的Python类型的功能（例如，固定的int，float，complex，str，unicode）。

使用数组标量的主要优点是它们保留了数组类型（Python可能没有匹配的标量类型，例如int16）。因此，使用数组标量可确保数组和标量之间的相同行为，无论值是否在数组内。NumPy标量也有许多与数组相同的方法。

溢出错误

当值需要比数据类型中的可用内存更多的内存时，NumPy数值类型的固定大小可能会导致溢出错误。例如，numpy.power对于64位整数正确计算 100 * 10 * 8，但对于32位整数给出1874919424（不正确）。

>>> np.power(100, 8, dtype=np.int64)
10000000000000000
>>> np.power(100, 8, dtype=np.int32)
1874919424

NumPy和Python整数类型的行为在整数溢出方面存在显着差异，并且可能会使用户期望NumPy整数的行为类似于Python int。与 NumPy 不同，Python 的大小int 是灵活的。这意味着Python整数可以扩展以容纳任何整数并且不会溢出。

NumPy分别提供numpy.iinfoopen in new window并numpy.finfoopen in new window验证NumPy整数和浮点值的最小值或最大值：

>>> np.iinfo(np.int) # Bounds of the default integer on this system.
iinfo(min=-9223372036854775808, max=9223372036854775807, dtype=int64)
>>> np.iinfo(np.int32) # Bounds of a 32-bit integer
iinfo(min=-2147483648, max=2147483647, dtype=int32)
>>> np.iinfo(np.int64) # Bounds of a 64-bit integer
iinfo(min=-9223372036854775808, max=9223372036854775807, dtype=int64)

如果64位整数仍然太小，则结果可能会转换为浮点数。浮点数提供了更大但不精确的可能值范围。

>>> np.power(100, 100, dtype=np.int64) # Incorrect even with 64-bit int
0
>>> np.power(100, 100, dtype=np.float64)
1e+200

扩展精度

Python 的浮点数通常是64位浮点数，几乎等同于 np.float64 。在某些不寻常的情况下，使用更精确的浮点数可能会很有用。这在numpy中是否可行取决于硬件和开发环境：具体地说，x86机器提供80位精度的硬件浮点，虽然大多数C编译器提供这一点作为它们的 long double 类型，MSVC(Windows构建的标准)使 long double 等同于 double (64位)。NumPy使编译器的 long double 作为 np.longdouble 可用(而 np.clongdouble 用于复数)。您可以使用 np.finfo(np.longdouble) 找出 numpy提供了什么。

NumPy不提供比C的 long double 更高精度的dtype；特别是128位IEEE四精度数据类型(FORTRAN的 REAL*16 )不可用。

为了有效地进行内存的校准，np.longdouble通常以零位进行填充，即96或者128位， 哪个更有效率取决于硬件和开发环境；通常在32位系统上它们被填充到96位，而在64位系统上它们通常被填充到128位。np.longdouble被填充到系统默认值；为需要特定填充的用户提供了np.float96和np.float128。尽管它们的名称是这样叫的, 但是np.float96和np.float128只提供与np.longdouble一样的精度, 即大多数x86机器上的80位和标准Windows版本中的64位。

请注意，即使np.longdouble提供比python float更多的精度，也很容易失去额外的精度，因为python通常强制值通过float传递值。例如，%格式操作符要求将其参数转换为标准python类型，因此即使请求了许多小数位，也不可能保留扩展精度。使用值1 + np.finfo(np.longdouble).eps测试你的代码非常有用。

创建数组

另见

数组创建相关API

简介

创建数组有5种常规机制：

1. 从其他Python结构（例如，列表，元组）转换

2. numpy原生数组的创建（例如，arange、ones、zeros等）

3. 从磁盘读取数组，无论是标准格式还是自定义格式

4. 通过使用字符串或缓冲区从原始字节创建数组

5. 使用特殊库函数（例如，random）

本节不包括复制，连接或以其他方式扩展或改变现有数组的方法。它也不会涵盖创建对象数组或结构化数组。这些都包含在他们自己的章节中。

将Python array_like对象转换为Numpy数组

通常，在Python中排列成array-like结构的数值数据可以通过使用array()函数转换为数组。最明显的例子是列表和元组。有关其使用的详细信息，请参阅array()的文档。一些对象可能支持数组协议并允许以这种方式转换为数组。找出对象是否可以使用array()转换为一个数组numpy 数组的简单方法很简单，只要交互式试一下，看看它是否工作！（Python方式）。

例子：

>>> x = np.array([2,3,1,0])
>>> x = np.array([2, 3, 1, 0])
>>> x = np.array([[1,2.0],[0,0],(1+1j,3.)]) # note mix of tuple and lists,
    and types
>>> x = np.array([[ 1.+0.j, 2.+0.j], [ 0.+0.j, 0.+0.j], [ 1.+1.j, 3.+0.j]])

Numpy原生数组的创建

Numpy内置了从头开始创建数组的函数：

zeros(shape)将创建一个用指定形状用0填充的数组。默认的dtype是float64。

>>> np.zeros((2, 3)) array([[ 0., 0., 0.], [ 0., 0., 0.]])

ones(shape)将创建一个用1个值填充的数组。它在所有其他方面与zeros相同。

arange()将创建具有有规律递增值的数组。检查文档字符串以获取有关可以使用的各种方式的完整信息。这里给出几个例子：

>>> np.arange(10)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.arange(2, 10, dtype=np.float)
array([ 2., 3., 4., 5., 6., 7., 8., 9.])
>>> np.arange(2, 3, 0.1)
array([ 2. , 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9])

请注意，关于用户应该注意的最后用法在arange文档字符串中有一些细微的描述。

linspace() 将创建具有指定数量元素的数组，并在指定的开始值和结束值之间平均间隔。例如：

>>> np.linspace(1., 4., 6)
array([ 1. ,  1.6,  2.2,  2.8,  3.4,  4. ])

这个创建函数的优点是可以保证元素的数量以及开始和结束点，对于任意的开始，停止和步骤值，arange()通常不会这样做。

indices() 将创建一组数组（堆积为一个更高维的数组），每个维度一个，每个维度表示该维度中的变化。一个例子说明比口头描述要好得多：

>>> np.indices((3,3))
array([[[0, 0, 0], [1, 1, 1], [2, 2, 2]], [[0, 1, 2], [0, 1, 2], [0, 1, 2]]])
​
print(np.indices((2,4)),np.indices((2,4)).shape)
print(np.indices((1,2,3)),np.indices((1,2,3)).shape)
[[[0 0 0 0]
  [1 1 1 1]]
​
 [[0 1 2 3]
  [0 1 2 3]]] (2, 2, 4)
[[[[0 0 0]
   [0 0 0]]]
​
​
 [[[0 0 0]
   [1 1 1]]]
​
​
 [[[0 1 2]
   [0 1 2]]]] (3, 1, 2, 3)
​

这对于评估常规网格上多个维度的功能特别有用。

从磁盘读取数组

这大概是大数组创建的最常见情况。当然，细节很大程度上取决于磁盘上的数据格式，所以本节只能给出如何处理各种格式的一般指示。

标准二进制格式

各种字段都有数组数据的标准格式。下面列出了那些已知的Python库来读取它们并返回numpy数组（可能有其他可能读取并转换为numpy数组的其他数据，因此请检查最后一节）

HDF5: h5py
FITS: Astropy
​
a=np.arange(1,10,0.01)
np.save('1.npy',a)
b=np.load('1.npy')
print(b)

无法直接读取但不易转换的格式示例是像PIL这样的库支持的格式（能够读取和写入许多图像格式，如jpg，png等）。

常见ASCII格式

逗号分隔值文件（CSV）被广泛使用（以及Excel等程序的导出和导入选项）。有很多方法可以在Python中阅读这些文件。python中有CSV函数和pylab函数（matplotlib的一部分）。

更多通用的ascii文件可以在scipy中使用io软件包读取。

自定义二进制格式

有各种各样的方法可以使用。如果文件具有相对简单的格式，那么可以编写一个简单的 I/O 库，并使用 numpy fromfile() 函数和 .tofile() 方法直接读取和写入numpy数组（尽管介意你的字节序）！如果存在一个读取数据的良好 C 或 C++ 库，可以使用各种技术来封装该库，但这肯定要做得更多，并且需要更多的高级知识才能与C或C++ 接口。

使用特殊库

有些库可用于生成特殊用途的数组，且无法列出所有的这些库。最常见的用途是随机使用许多数组生成函数，这些函数可以生成随机值数组，以及一些实用函数来生成特殊矩阵（例如对角线）。

NumPy与输入输出

使用genfromtxt导入数据

NumPy提供了几个函数来根据表格数据创建数组。我们将重点放在genfromtxt函数上。

In a nutshell, genfromtxt runs two main loops. 第一个循环以字符串序列转换文件的每一行。第二个循环将每个字符串转换为适当的数据类型。这种机制比单一循环慢，但提供了更多的灵活性。特别的, genfromtxt考虑到缺失值的情况, 其他更简单的方法如loadtxt无法做到这点.

注意 举例时，我们将使用以下约定：

>>> import numpy as np
>>> from io import BytesIO

定义输入

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

识别的文件类型是文本文件和档案。目前，该功能可识别gzip和bz2（bzip2）档案。归档文件的类型由文件的扩展名决定：如果文件名以'.gz'结尾，则需要一个gzip归档文件；如果它以'bz2'结尾，则假定bzip2存档。

将行拆分为列

delimiter参数

一旦文件被定义并打开进行读取，genfromtxt会将每个非空行分割为一串字符串。 空的或注释的行只是略过。 delimiter关键字用于定义拆分应该如何进行。

通常，单个字符标记列之间的分隔。例如，逗号分隔文件（CSV）使用逗号（,）或分号（;）作为分隔符：

>>> data = "1, 2, 3\n4, 5, 6"
>>> np.genfromtxt(BytesIO(data), delimiter=",")
array([[ 1.,  2.,  3.],
       [ 4.,  5.,  6.]])
​
# 从文件data.csv中加载数据
#delimiter参数指定了分隔符是逗号
#names参数表示第一行是字段名称
# dtype参数指定加载的数据类型
data = np.genfromtxt('data.csv', delimiter=',', names=True, dtype=None)
​
# 打印加载的数据的字段名称
print(data.dtype.names) 
​
# 访问age这一列
ages = data['age']
​
# 计算age的平均值
average_age = np.mean(ages)
print(average_age)
这个例子演示了几个np.genfromtxt的主要参数用法:
​
delimiter: 指定分隔符,默认是空格
names: 将第一行数据作为字段名称
dtype: 指定加载的数据类型,None表示自动推断
然后我们打印了字段名称,并访问了age这一列的数据,计算了平均年龄。

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

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

>>> data = "  1  2  3\n  4  5 67\n890123  4"
>>> np.genfromtxt(BytesIO(data), delimiter=3)
array([[   1.,    2.,    3.],
       [   4.,    5.,   67.],
       [ 890.,  123.,    4.]])
>>> data = "123456789\n   4  7 9\n   4567 9"
>>> np.genfromtxt(BytesIO(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(BytesIO(data), delimiter=",", dtype="|S5")
array([['1', ' abc ', ' 2'],
       ['3', ' xxx', ' 4']],
      dtype='|S5')
>>> # With autostrip
>>> np.genfromtxt(BytesIO(data), delimiter=",", dtype="|S5", autostrip=True)
array([['1', 'abc', '2'],
       ['3', 'xxx', '4']],
      dtype='|S5')

comments参数

可选参数comments用于定义标记注释开始的字符串。默认情况下，genfromtxt假定comments='#'。评论标记可能发生在线上的任何地方。评论标记之后的任何字符都会被忽略：

>>> 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(BytesIO(data), comments="#", delimiter=",")
[[ 1.  2.]
 [ 3.  4.]
 [ 5.  6.]
 [ 7.  8.]
 [ 9.  0.]]

注意

这种行为有一个明显的例外：如果可选参数names=True，则会检查第一条注释行的名称。

跳过直线并选择列

skip_header和skip_footer参数

文件中存在标题可能会妨碍数据处理。在这种情况下，我们需要使用skip_header可选参数。此参数的值必须是一个整数，与执行任何其他操作之前在文件开头跳过的行数相对应。同样，我们可以使用skip_footer属性跳过文件的最后一行n，并给它一个n的值：

>>> data = "\n".join(str(i) for i in range(10))
>>> np.genfromtxt(BytesIO(data),)
array([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.])
>>> np.genfromtxt(BytesIO(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(BytesIO(data), usecols=(0, -1))
array([[ 1.,  3.],
       [ 4.,  6.]])

如果列有名称，我们也可以通过将它们的名称提供给usecols参数来选择要导入哪些列，可以将其作为字符串序列或逗号分隔字符串：

>>> data = "1 2 3\n4 5 6"
>>> np.genfromtxt(BytesIO(data),
...               names="a, b, c", usecols=("a", "c"))
array([(1.0, 3.0), (4.0, 6.0)],
      dtype=[('a', '>> np.genfromtxt(BytesIO(data),
...               names="a, b, c", usecols=("a, c"))
    array([(1.0, 3.0), (4.0, 6.0)],
          dtype=[('a', ' 
选择数据的类型
 
控制我们从文件中读取的字符串序列如何转换为其他类型的主要方法是设置dtype参数。这个参数的可接受值是：
 

 
 
单一类型，如dtype=float。除非使用names参数将名称与每个列关联（见下文），否则输出将是给定dtype的2D格式。请注意，dtype=float是genfromtxt的默认值。
 
 
 
一系列类型，如dtype =（int， float， double）。
 
 
 
逗号分隔的字符串，例如dtype="i4,f8,|S3"。
 
 
 
一个包含两个键'names'和'formats'的字典。
 
 
 
a sequence of tuples(name, type), such as dtype=[('A', int), ('B', float)].
 
 
 
现有的numpy.dtype对象。
 
 
 
特殊值None。在这种情况下，列的类型将根据数据本身确定（见下文）。
 
 
在所有情况下，除了第一种情况，输出将是一个带有结构化dtype的一维数组。这个dtype与序列中的项目一样多。字段名称由names关键字定义。
 
当dtype=None时，每列的类型由其数据迭代确定。我们首先检查一个字符串是否可以转换为布尔值（也就是说，如果字符串在小写字母中匹配true或false）；然后是否可以将其转换为整数，然后转换为浮点数，然后转换为复数并最终转换为字符串。通过修改StringConverter类的默认映射器可以更改此行为。
 
为方便起见，提供了dtype=None选项。但是，它明显比显式设置dtype要慢。
 
设置名称
 
names参数
 
处理表格数据时的一种自然方法是为每列分配一个名称。如前所述，第一种可能性是使用明确的结构化dtype。
 
>>> data = BytesIO("1 2 3\n 4 5 6")
>>> np.genfromtxt(data, dtype=[(_, int) for _ in "abc"])
array([(1, 2, 3), (4, 5, 6)],
      dtype=[('a', ' 
另一种更简单的可能性是将names关键字与一系列字符串或逗号分隔的字符串一起使用：
 
>>> data = BytesIO("1 2 3\n 4 5 6")
>>> np.genfromtxt(data, names="A, B, C")
array([(1.0, 2.0, 3.0), (4.0, 5.0, 6.0)],
      dtype=[('A', ' 
在上面的例子中，我们使用了默认情况下dtype=float的事实。通过给出一个名称序列，我们强制输出到一个结构化的dtype。
 
我们有时可能需要从数据本身定义列名。在这种情况下，我们必须使用names关键字的值为True。这些名字将从第一行（在skip_header之后）被读取，即使该行被注释掉：
 
>>> data = BytesIO("So it goes\n#a b c\n1 2 3\n 4 5 6")
>>> np.genfromtxt(data, skip_header=1, names=True)
array([(1.0, 2.0, 3.0), (4.0, 5.0, 6.0)],
      dtype=[('a', ' 
names的默认值为None。如果我们给关键字赋予任何其他值，新名称将覆盖我们可能用dtype定义的字段名称：
 
>>> data = BytesIO("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.0, 3), (4, 5.0, 6)],
      dtype=[('A', ' 
defaultfmt参数
 
如果 names=None 的时候，只是预计会有一个结构化的dtype，它的名称将使用标准的NumPy默认值 "f%i"来定义，会产生例如f0，f1等名称：
 
>>> data = BytesIO("1 2 3\n 4 5 6")
>>> np.genfromtxt(data, dtype=(int, float, int))
array([(1, 2.0, 3), (4, 5.0, 6)],
      dtype=[('f0', ' 
同样，如果我们没有提供足够的名称来匹配dtype的长度，缺少的名称将使用此默认模板进行定义：
 
>>> data = BytesIO("1 2 3\n 4 5 6")
>>> np.genfromtxt(data, dtype=(int, float, int), names="a")
array([(1, 2.0, 3), (4, 5.0, 6)],
      dtype=[('a', ' 
我们可以使用defaultfmt参数覆盖此默认值，该参数采用任何格式字符串：
 
>>> data = BytesIO("1 2 3\n 4 5 6")
>>> np.genfromtxt(data, dtype=(int, float, int), defaultfmt="var_%02i")
array([(1, 2.0, 3), (4, 5.0, 6)],
      dtype=[('var_00', ' 
 
 
注意！ 我们需要记住，仅当预期一些名称但未定义时才使用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'）。
 
 
调整转换
 
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(BytesIO(data), delimiter=",", names=names)
array([(1.0, nan, 45.0), (6.0, nan, 0.0)],
      dtype=[('i', ' 
我们需要记住，默认情况下，dtype=float。因此，对于第二列期望浮点数。但是，字符串'2.3%'和'78.9%无法转换为浮点数，我们最终改为使用np.nan。现在让我们使用一个转换器：
 
>>> # Converted case ...
>>> np.genfromtxt(BytesIO(data), delimiter=",", names=names,
...               converters={1: convertfunc})
array([(1.0, 0.023, 45.0), (6.0, 0.78900000000000003, 0.0)],
      dtype=[('i', ' 
通过使用第二列（"p"）作为关键字而不是其索引（1）的名称，可以获得相同的结果：
 
>>> # Using a name for the converter ...
>>> np.genfromtxt(BytesIO(data), delimiter=",", names=names,
...               converters={"p": convertfunc})
array([(1.0, 0.023, 45.0), (6.0, 0.78900000000000003, 0.0)],
      dtype=[('i', ' 
转换器也可以用来为缺少的条目提供默认值。在以下示例中，如果字符串为空，则转换器convert会将已剥离的字符串转换为相应的浮点型或转换为-999。我们需要明确地从空白处去除字符串，因为它并未默认完成：
 
>>> data = "1, , 3\n 4, 5, 6"
>>> convert = lambda x: float(x.strip() or -999)
>>> np.genfromtxt(BytesIO(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确定此值：
 
我们知道如何识别丢失的数据，但我们仍然需要为这些丢失的条目提供一个值。默认情况下，根据此表根据预期的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(BytesIO(data), **kwargs)
array([(0, 2, 3), (4, 0, -999)],
      dtype=[('a', ' 
usemask
 
我们也可能想通过构造一个布尔掩码来跟踪丢失数据的发生，其中True条目缺少数据，否则False。为此，我们只需将可选参数usemask设置为True（默认值为False）。输出数组将成为MaskedArray。
 
快捷方式函数
 
除了 genfromtxtopen in new window 之外，numpy.lib.io模块还提供了几个从 genfromtxtopen in new window 派生的方便函数。这些函数的工作方式与原始函数相同，但它们具有不同的默认值。
 

 
 
recfromtxt - 返回标准 numpy.recarrayopen in new window（如果 usemask=False）或 MaskedRecords数组（如果 usemaske=True）。默认dtype是 dtype=None ，意味着将自动确定每列的类型。
 
 
 
recfromcsv - 类似 recfromtxt，但有默认值 delimiter="," 。
 
 
 
索引
 
另见
 
索引
 
索引相关API
 
数组索引是指使用方括号（[]）来索引数组值。索引有很多选项，它可以为numpy索引提供强大的功能，但是功能会带来一些复杂性和混淆的可能性。本节仅概述了与索引相关的各种选项和问题。除了单个元素索引之外，大多数这些选项的详细信息都可以在相关章节中找到。
 
#赋值与引用
 
以下大多数示例体现在引用数组中的数据时使用索引。分配给数组时，这些示例也可以正常运行的。有关分配的原理具体示例和说明，请参见最后一节。
 
#单个元素索引
 
人们期望的是1-D数组的单元素索引。它的工作方式与其他标准Python序列完全相同。它基于0，并接受从数组末尾开始索引的负索引。
 
>>> x = np.arange(10)
>>> x[2]
2
>>> x[-2]
8
 
与列表和元组不同，numpy数组支持多维数组的多维索引。这意味着没有必要将每个维度的索引分成它自己的一组方括号。
 
>>> x.shape = (2,5) # now x is 2-dimensional
>>> x[1,3]
8
>>> x[1,-1]
9
 
请注意，如果索引索引比维度少的多维数组，则会获得一个子维数组。例如：
 
>>> x[0]
array([0, 1, 2, 3, 4])
 
也就是说，指定的每个索引选择与所选维度的其余部分对应的数组。在上面的示例中，选择0表示长度为5的剩余维度未指定，返回的是该维度和大小的数组。必须注意的是，返回的数组不是原始数据的副本，而是指向内存中与原始数组相同的值。在这种情况下，返回第一个位置（0）的1-D数组。因此，在返回的数组上使用单个索引会导致返回单个元素。那是：
 
>>> x[0][2]
2
 
请注意，尽管第二种情况效率较低，因为在第一个索引之后创建了一个新的临时数组，该索引随后被索引为2：x[0,2] = x[0][2]
 
请注意那些习惯于IDL或Fortran内存顺序的内容，因为它与索引有关。NumPy使用C顺序索引。这意味着最后一个索引通常代表最快速变化的内存位置，与Fortran或IDL不同，其中第一个索引代表内存中变化最快的位置。这种差异代表了混淆的巨大潜力。
 
#其他索引选项
 
可以对数组进行切片和跨步以提取具有相同数量的尺寸但具有与原始尺寸不同的尺寸的数组。切片和跨步的工作方式与列表和元组的工作方式完全相同，只是它们也可以应用于多个维度。一些例子说明了最好的：
 
>>> x = np.arange(10)
>>> x[2:5]
array([2, 3, 4])
>>> x[:-7]
array([0, 1, 2])
>>> x[1:7:2]
array([1, 3, 5])
>>> y = np.arange(35).reshape(5,7)
>>> y[1:5:2,::3]
array([[ 7, 10, 13],
       [21, 24, 27]])
 
请注意，数组切片不会复制内部数组数据，只会生成原始数据的新视图。这与列表或元组切片不同，copy()如果不再需要原始数据，建议使用显式。
 
可以使用其他数组索引数组，以便从数组中选择值列表到新数组中。有两种不同的方法来实现这一点。一个使用一个或多个索引值数组。另一个涉及给出一个正确形状的布尔数组来指示要选择的值。索引数组是一个非常强大的工具，可以避免循环遍历数组中的各个元素，从而大大提高性能。
 
可以使用特殊功能通过索引有效地增加数组中的维数，以便生成的数组获取在表达式或特定函数中使用所需的形状。
 
#索引数组
 
NumPy数组可以使用其他数组（或任何其他可以转换为数组的类似序列的对象，如列表，除元组之外的索引;请参阅本文档末尾的原因）。索引数组的使用范围从简单，直接的案例到复杂的，难以理解的案例。对于索引数组的所有情况，返回的是原始数据的副本，而不是切片获取的视图。
 
索引数组必须是整数类型。数组中的每个值指示要使用的数组中的哪个值代替索引。为了显示：
 
>>> x = np.arange(10,1,-1)
>>> x
array([10,  9,  8,  7,  6,  5,  4,  3,  2])
>>> x[np.array([3, 3, 1, 8])]
array([7, 7, 9, 2])
 
由值3,3,1和8组成的索引数组相应地创建一个长度为4的数组（与索引数组相同），其中每个索引由索引数组在被索引的数组中具有的值替换。
 
允许使用负值，并且与单个索引或切片一样工作：
 
>>> x[np.array([3,3,-3,8])]
array([7, 7, 4, 2])
 
索引值超出范围是错误的：
 
>>> x[np.array([3, 3, 20, 8])]
: index 20 out of bounds 0<=index<9
 
一般来说，使用索引数组时返回的是与索引数组具有相同形状的数组，但索引