Glossary

沿着轴线

对于具有多个维度的数组，定义轴。二维数组具有两个对应的轴：第一个垂直向下横跨行（轴0），第二个水平横跨列（轴1）。

许多操作可以沿着这些轴中的一个发生。例如，我们可以对数组的每一行求和，在这种情况下，我们沿列进行操作，或者轴1：

>>> x = np.arange(12).reshape((3,4))

>>> x
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

>>> x.sum(axis=1)
array([ 6, 22, 38])

数组

数字元素的均匀容器。数组中的每个元素占用固定量的内存（因此是同构的），并且可以是单个类型的数字元素（例如float，int或complex）或组合（例如（float， int， float））。每个数组都有一个关联的数据类型（或dtype），它描述了其元素的数值类型：

>>> x = np.array([1, 2, 3], float)

>>> x
array([ 1.,  2.,  3.])

>>> x.dtype # floating point number, 64 bits of memory per element
dtype('float64')


# More complicated data type: each array element is a combination of
# and integer and a floating point number
>>> np.array([(1, 2.0), (3, 4.0)], dtype=[('x', int), ('y', float)])
array([(1, 2.0), (3, 4.0)],
      dtype=[('x', '<i4'), ('y', '<f8')])

快速元素操作，称为`ufuncs`_，操作数组。

array_like

任何可以解释为ndarray的序列。这包括嵌套列表，元组，标量和现有数组。

属性

可以使用obj.attribute访问的对象的属性（例如，shape）是数组的属性：

>>> x = np.array([1, 2, 3])
>>> x.shape
(3,)

BLAS

基本线性代数子程序

广播

NumPy可以对形状不匹配的数组执行操作：

>>> x = np.array([1, 2])
>>> y = np.array([[3], [4]])

>>> x
array([1, 2])

>>> y
array([[3],
       [4]])

>>> x + y
array([[4, 5],
       [5, 6]])

有关详细信息，请参阅`doc.broadcasting`_。

C命令

请参阅row-major

列优先

如何用一维的计算机存储器处理N维数组的方法。在列优先顺序中，最左边的索引“变化最快”：例如数组：

[[1, 2, 3],
 [4, 5, 6]]

以列优先顺序表示为：

[1, 4, 2, 5, 3, 6]

列优先顺序也称为Fortran顺序，Fortran编程语言使用它。

装饰

转换函数的运算符。例如，可以定义log装饰器以在功能执行时打印调试信息：

>>> def log(f):
...     def new_logging_func(*args, **kwargs):
...         print("Logging call with parameters:", args, kwargs)
...         return f(*args, **kwargs)
...
...     return new_logging_func

现在，当我们定义一个函数时，我们可以使用log来“装饰”它：

>>> @log
... def add(a, b):
...     return a + b

调用add然后得出：

>>> add(1, 2)
Logging call with parameters: (1, 2) {}
3

字典

类似于提供单词及其描述之间的映射的语言字典，Python字典是两个对象之间的映射：

>>> x = {1: 'one', 'two': [1, 2]}

这里，x是将键映射到值的字典，在这种情况下，将整数1映射到字符串“one”，将字符串“two”映射到列表/ t2> 2]。可以使用其相应的键访问这些值：

>>> x[1]
'one'

>>> x['two']
[1, 2]

请注意，词典不以任何特定的顺序存储。此外，大多数可变（参见下面的immutable）对象，例如列表，不能用作键。

有关字典的详细信息，请阅读Python教程。

Fortran顺序

请参见列优先菜单

降维

折叠到一维数组。有关详细信息，请参见`ndarray.flatten`_。

不可变

执行后无法修改的对象称为immutable。两个常见的例子是字符串和元组。

实例

类定义给出了构造对象的蓝图：

>>> class House(object):
...     wall_colour = 'white'

但是，我们必须在存在之前建造房屋：

>>> h = House() # build a house

现在，h被称为House实例。因此，实例是类的特定实现。

可迭代

允许在项目上“步行”（迭代）的序列，通常使用循环，例如：

>>> x = [1, 2, 3]
>>> [item**2 for item in x]
[1, 4, 9]

它通常用于与enumerate ::

>>> keys = ['a','b','c']
>>> for n, k in enumerate(keys):
...     print("Key %d: %s" % (n, k))
...
Key 0: a
Key 1: b
Key 2: c

列表

一个Python容器，可以容纳任意数量的对象或项目。项目不必具有相同的类型，甚至可以是列表本身：

>>> x = [2, 2.0, "two", [2, 2.0]]

列表x包含4个项目，每个项目都可以单独访问：

>>> x[2] # the string 'two'
'two'

>>> x[3] # a list, containing an integer 2 and a float 2.0
[2, 2.0]

也可以使用切片一次选择多个项目：

>>> x[0:2] # or, equivalently, x[:2]
[2, 2.0]

在代码中，数组通常方便地表示为嵌套列表：

>>> np.array([[1, 2], [3, 4]])
array([[1, 2],
       [3, 4]])

有关详细信息，请参阅Python教程中的列表部分。有关映射类型（键值），请参见字典。

面具

布尔数组，用于仅为操作选择某些元素：

>>> x = np.arange(5)
>>> x
array([0, 1, 2, 3, 4])

>>> mask = (x > 2)
>>> mask
array([False, False, False, True,  True], dtype=bool)

>>> x[mask] = -1
>>> x
array([ 0,  1,  2,  -1, -1])

masked数组

抑制由掩码指示的值的数组：

>>> x = np.ma.masked_array([np.nan, 2, np.nan], [True, False, True])
>>> x
masked_array(data = [-- 2.0 --],
             mask = [ True False  True],
       fill_value = 1e+20)


>>> x + [1, 2, 3]
masked_array(data = [-- 4.0 --],
             mask = [ True False  True],
       fill_value = 1e+20)

当对包含缺失或无效条目的数组进行操作时，通常使用掩码数组。

矩阵

在整个操作中保留其二维性质的二维引子。它具有某些特殊操作，例如*（矩阵乘法）和**（矩阵功率）

>>> x = np.mat([[1, 2], [3, 4]])
>>> x
matrix([[1, 2],
        [3, 4]])

>>> x**2
matrix([[ 7, 10],
      [15, 22]])

方法

与对象关联的函数。例如，每个ndarray都有一个称为repeat的方法：

>>> x = np.array([1, 2, 3])
>>> x.repeat(2)
array([1, 1, 2, 2, 3, 3])

ndarray

请参见数组。

记录数组

与`structured data type`_的`ndarray`_，它已经被子类化为np.recarray，其dtype的类型为np.record，类型可以通过属性访问。

参考

如果a是对b的引用，则（a 是 t7> == True。因此，a和b是同一个Python对象的不同名称。

行优先

一种在一维计算机存储器中保存N为数组的方法。在行主顺序中，最右边的索引“变化最快”：例如数组：

[[1, 2, 3],
 [4, 5, 6]]

以行主要顺序表示为：

[1, 2, 3, 4, 5, 6]

行优先顺序也称为C顺序，C编程语言使用它。默认情况下，新Numpy数组按行优先顺序排列。

自

通常在方法签名中看到，self指的是关联类的实例。例如：

>>> class Paintbrush(object):
...     color = 'blue'
...
...     def paint(self):
...         print("Painting the city %s!" % self.color)
...
>>> p = Paintbrush()
>>> p.color = 'red'
>>> p.paint() # self refers to 'p'
Painting the city red!

切片

用于仅从序列中选择某些元素：

>>> x = range(5)
>>> x
[0, 1, 2, 3, 4]

>>> x[1:3] # slice from 1 to 3 (excluding 3 itself)
[1, 2]

>>> x[1:5:2] # slice from 1 to 5, but skipping every second element
[1, 3]

>>> x[::-1] # slice a sequence in reverse
[4, 3, 2, 1, 0]

数组可以具有多个维度，每个维度可以单独切片：

>>> x = np.array([[1, 2], [3, 4]])
>>> x
array([[1, 2],
       [3, 4]])

>>> x[:, 1]
array([2, 4])

结构化数据类型

由其他数据类型组成的数据类型

元组

可以包含任意类型的可变数量类型的序列。元组是不可变的，即，一旦构造，它就不能改变。类似于列表，它可以索引和切片：

>>> x = (1, 'one', [1, 2])
>>> x
(1, 'one', [1, 2])

>>> x[0]
1

>>> x[:2]
(1, 'one')

一个有用的概念是“元组解包”，它允许将变量分配给元组的内容：

>>> x, y = (1, 2)
>>> x, y = 1, 2

这通常在函数返回多个值时使用：

>>> def return_many():
...     return 1, 'alpha', None

>>> a, b, c = return_many()
>>> a, b, c
(1, 'alpha', None)

>>> a
1
>>> b
'alpha'

ufunc

通用功能。快速元素方式数组运算。示例包括add，sin和logical_or。

视图

数据组不拥有其数据，而是引用另一个数组的数据。例如，我们可以创建一个只显示另一个数组的每个第二个元素的视图：

>>> x = np.arange(5)
>>> x
array([0, 1, 2, 3, 4])

>>> y = x[::2]
>>> y
array([0, 2, 4])

>>> x[0] = 3 # changing x changes y as well, since y is a view on x
>>> y
array([3, 2, 4])

包装器

Python是一种高级（高度抽象的，或类似英语的）语言。这种抽象在执行速度上有一个代价，有时需要使用低级语言来执行快速计算。包装器是提供高级和低级语言之间的桥梁的代码，允许例如Python执行用C或Fortran编写的代码。

示例包括ctypes，SWIG和Cython（包装C和C ++）和f2py（包装Fortran）。

Jargon