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])
掩码数组

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

>>> 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因此,ab是同一个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
通用功能。快速元素方式数组运算。示例包括addsinlogical_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