numpy总结

numpy

‘Numerical Python’。它是一个由多维数组对象和一组处理数组的例程组成的库。

NumPy通常与 SciPy （Scientific Python）和 Mat-plotlib （绘图库）等软件包一起使用。这种组合广泛用于替代技术计算的流行平台MatLab。

NumPy ndarray对象

NumPy中定义的最重要的对象是名为 ndarray 的N维数组类型。它描述了相同类型的项目的集合。可以使用从零开始的索引来访问集合中的项目。

ndarray中的每个项目在内存中占用相同的块大小。在ndarray每个元素是数据类型的对象（被称为的目的 D型 ）。

从ndarray对象中提取的任何项目（通过切片）由数组标量类型之一的Python对象表示。下图显示了ndarray，数据类型对象（dtype）和数组标量类型之间的关系

ndarray类的一个实例可以通过本教程稍后介绍的不同阵列创建例程来构建。基本的ndarray是使用NumPy中的数组函数创建的，如下所示

numpy.array

它从暴露数组接口的任何对象或任何返回数组的方法创建一个ndarray。

numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)

例：

a = np.array([1, 2, 3], dtype = complex)
a = np.array([[1, 2], [3, 4]])

所述 ndarray 对象由计算机存储器的连续一维段，用每个项映射到在所述存储器块的位置的索引方案组合的。内存块以行主要顺序（C风格）或列主要顺序（FORTRAN或MatLab风格）保存元素。

NumPy数据类型

NumPy数字类型是dtype（数据类型）对象的实例，每个对象都有独特的特征。该dtypes可用作np.bool_，np.float32等

数据类型对象（dtype）

数据类型对象根据以下几个方面描述对应于数组的固定内存块的解释 -

• 数据类型（整型，浮点型或Python对象）
• 数据的大小
• 字节顺序（小端或大端）
• 在结构化类型的情况下，字段的名称，每个字段的数据类型和每个字段占用的存储器块的一部分。
• 如果数据类型是子阵列，则它的形状和数据类型

字节顺序由数据类型前缀’<‘或’>‘决定。’<‘表示编码是小端（最小有效值存储在最小地址中）。’>'表示编码是大端（最高有效字节存储在最小地址中）。

一个dtype对象使用以下语法构造 -

numpy.dtype(object, align, copy)

参数是 -

• Object - 被转换为数据类型对象
• Align - 如果为true，则向该字段添加填充以使其类似于C-struct
• Copy - 制作dtype对象的新副本。 如果为false，则结果是对内置数据类型对象的引用

例1

# using array-scalar type
import numpy as np
dt = np.dtype(np.int32)
print dt

输出如下 -

int32

NumPy数组属性

1.ndarray.shape

这个数组属性返回一个由数组维度组成的元组。它也可以用来调整数组的大小。

a.shape = (3,2)
or
b = a.reshape(3,2)

2.ndarray.ndim

该数组属性返回数组维数。

3.numpy.itemsize

这个数组属性以字节为单位返回数组中每个元素的长度。

4.numpy.flags

以下示例显示标志的当前值。

import numpy as np
x = np.array([1,2,3,4,5])
print x.flags

输出如下 -

C_CONTIGUOUS : True
F_CONTIGUOUS : True
OWNDATA : True
WRITEABLE : True
ALIGNED : True
UPDATEIFCOPY : False

NumPy数组创建

新的 ndarray 对象可以通过以下任何数组创建例程或使用低级别的ndarray构造函数构造。

numpy.empty

它创建一个未初始化的指定形状和dtype数组。它使用以下构造函数 -

numpy.empty(shape, dtype = float, order = 'C')

构造函数采用以下参数。

序号	参数和说明
1	Shape int或int元组中的空数组的形状
2	Dtype 所需的输出数据类型。可选的
3	Order 'C’表示C风格行主阵列，'F’表示FORTRAN风格列主阵列

numpy.zeros

返回指定大小的新数组，填充零。

numpy.ones

返回指定大小和类型的新数组，填充1。

例1

# array of five zeros. Default dtype is float
import numpy as np
x = np.zeros(5)
print x

输出如下 -

[ 0.  0.  0.  0.  0.]

列表中元素后有个点表示是浮点数

例2

import numpy as np
x = np.zeros((5,), dtype = np.int)
print x

现在，输出结果如下 -

[0  0  0  0  0]

python定义元组（tuple）时，如果只含一个元素，要在后面加逗号，否则会被当成数字

来自现有数据的NumPy数组

numpy.asarray

这个函数与numpy.array类似，只是它的参数较少。此例程对于将Python序列转换为ndarray很有用。

numpy.asarray(a, dtype = None, order = None)

a:以任何形式输入数据，如列表，元组列表，元组列表，元组元组或元组元组

例1

# dtype is set
import numpy as np

x = [1,2,3]
a = np.asarray(x, dtype = float)
print a

现在，输出结果如下 -

[ 1.  2.  3.]

例2.

# ndarray from tuple
import numpy as np

x = (1,2,3)
a = np.asarray(x)
print a

其产出将是 -

[1  2  3]

numpy.frombuffer

该函数将缓冲区解释为一维数组。公开缓冲区接口的任何对象都将用作返回 ndarray的 参数。

numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)

构造函数采用以下参数。

Sr.No.	参数和说明
1	buffer 任何公开缓冲区接口的对象
2	dtype 返回的ndarray的数据类型。默认为浮动
3	count 要读取的项目数量，默认值-1表示所有数据
4	offset 读取的起始位置。缺省值是0

以下示例演示使用 frombuffer 函数。

import numpy as np
s = b'Hello World'
a = np.frombuffer(s, dtype = 'S1')	# S1意味着数组包含长度为1的字符串
print a

注意字符串前面必须写个b，表示是bytestring

1. #frombuffer将data以流的形式读入转化成ndarray对象
2. #第一参数为stream,第二参数为返回值的数据类型，第三参数指定从stream的第几位开始读入
3. #data是字符串的时候，Python3默认str是Unicode类型，所以要转成bytestring在原str前加上b

这是它的输出 -

[b'H'  b'e'  b'l'  b'l'  b'o'  b' '  b'W'  b'o'  b'r'  b'l'  b'd']

numpy.fromiter

该函数从任何可迭代对象构建一个 ndarray 对象。这个函数返回一个新的一维数组。

numpy.fromiter(iterable, dtype, count = -1)

在这里，构造函数采用以下参数。

Sr.No.	参数和说明
1	iterable 任何可迭代的对象
2	dtype 结果数组的数据类型
3	count 要从迭代器读取的项目数量。默认值是-1，这意味着所有要读取的数据

例

# obtain iterator object from list
import numpy as np
list = range(5)
it = iter(list)  # 把一个列表(可迭代对象)生成维迭代器

# use iterator to create ndarray
x = np.fromiter(it, dtype = float)
print x

现在，输出结果如下 -

[0.   1.   2.   3.   4.]

Python编码 str&byte

• 文本总是 Unicode，由 str 类型表示。
• 二进制数据则由 bytes 类型表示。

那么什么是 bytes、什么是 Unicode 呢？（参考资料 知乎以及SO）

• 首先计算机能存储的唯一东西就是 bytes。所以为了在计算机中存储东西，我们首先得将其编码（encode），例如将其转化为 bytes。比如：

1. 要想保存音乐，我们首先得用 MP3, WAV 等将其编码
2. 要想保存图片，我们首先得用 PNG, JPEG 等将其编码
3. 要想保存文本，我们首先得用 ASCII, UTF-8 等将其编码

• Unicode 是字符集，不是字符编码。Unicode 把全世界的字符都搜集并且编号了，但是没有规定具体的编码规则。编码规则有 UTF-8、GBK 之类的。

创建 bytes 型数据

使用 Python3 的内置函数 bytes 函数。

class bytes([source[, encoding[, errors]]])

>>> bytes([1,2,3,4,5,6,7,8,9])
b'\x01\x02\x03\x04\x05\x06\x07\x08\t'
>>> bytes("python", 'ascii') # 字符串，编码
b'python'

创建字符串

>>> website = 'http://www.jb51.net/'
>>> type(website)
<class 'str'>
>>> website
'http://www.jb51.net/'

相互转换

string 转化成 bytes 首先需要进行编码（encode），而 encode 是可以使用许多不同的 encodings 的（参考资料 Standard Encodings）。而将 bytes 转化成 string 需要进行解码（decode），解码的 encodings 往往需要根据数据的实际编码情况来设定。

string to bytes

按 utf-8 的方式编码，转成 bytes

>>> website_bytes_utf8 = website.encode(encoding="utf-8")
>>> type(website_bytes_utf8)
<class 'bytes'>
>>> website_bytes_utf8
b'http://www.jb51.net/'

bytes to string

解码成 string，默认不填为utf-8

>>> website_string = website_bytes_utf8.decode()
>>> type(website_string)
<class 'str'>
>>> website_string
'http://www.jb51.net/'

解码成 string，使用 gb2312 的方式

>>> website_string_gb2312 = website_bytes_gb2312.decode("gb2312")
>>> type(website_string_gb2312)
<class 'str'>
>>> website_string_gb2312
'http://www.jb51.net/'

NumPy数组的范围

从数值范围创建一个数组

numpy.arange

该函数返回一个包含给定范围内均匀间隔值的 ndarray 对象。该功能的格式如下

numpy.arange(start, stop, step, dtype)
x = np.arange(10,20,2)

numpy.linspace

该函数与 arange（） 函数类似。在此函数中，不是步长，而是指定间隔之间的均匀间隔值的数量。该功能的用法如下 -

numpy.linspace(start, stop, num, endpoint, retstep, dtype)

序号	参数和说明
1	start 序列的起始值
2	stop 序列的结束值，包括在端点设置为true的序列中
3	num 要生成的均匀间隔样本的数量。默认值是50
4	endpoint 默认情况下为真，因此停止值包含在序列中。如果错误，则不包括在内
5	retstep 如果为true，则返回样本并在连续数字之间步进
6	dtype 输出 ndarray 数据类型

numpy.logspace

该函数返回一个 ndarray 对象，该对象包含在对数刻度上均匀间隔的数字。规模的起止点是基数的指数，通常为10。

numpy.logspace(start, stop, num, endpoint, base, dtype)

以下参数决定了 logspace 函数的输出。

Sr.No.	参数和说明
1	start 序列的起点是基础开始
2	stop 序列的最终值是基地站点
3	num 范围之间的值的数量。默认值是50
4	endpoint 如果为true，则停止是范围中的最后一个值
5	base 日志空间的基础，默认为10
6	dtype 输出数组的数据类型。如果没有给出，则取决于其他输入参数

NumPy索引和切片

可以通过索引或切片来访问和修改ndarray对象的内容，就像Python的内置容器对象一样。

如前所述，ndarray对象中的项遵循从零开始的索引。有三种索引方法可用 - 字段访问，基本切片 和 高级索引 。

基本切片是Python切片为n维的基本概念的扩展。通过给内置 切片 函数提供 start，stop 和 step 参数来构造Python切片对象。该切片对象被传递给数组以提取数组的一部分。

s = slice(2,7,2)
print a[s]

在上面的例子中，一个 ndarray 对象由 arange（） 函数准备。然后分别用开始，停止和步骤值2,7和2定义切片对象。当这个slice对象被传递给ndarray时，它的一部分以索引2开始，最多为7，步长为2。

通过直接向 冒号 对象提供由冒号分隔的切片参数（（start：stop：step）），也可以获得相同的结果。

省略号…

NumPy数组切片可以使用省略号(…), 注意是英文省略号不是中文全角半角省略号, 省略号的作用是在NumPy多维数组指定某些维度后在剩余的维度采取全选操作. 可以只指定前面的维度也可以只指定后面的维度, 也可以既指定前面的维度同时又指定后面的维度, 余下的维度使用省略号进行全选. 注意: python的内置类型列表是不支持省略号全选操作的.

>>>b[:,0,0]

array([0, 12])

>>>b[0]

array([[0, 1, 2, 3],

​ [ 4, 5, 6, 7],

​ [ 8, 9, 10, 11]])

我们还可以这样写，选取第1层楼的所有房间：

>>>b[0,:,:]

array([[0, 1, 2, 3],

​ [ 4, 5, 6, 7],

​ [ 8, 9, 10, 11]])

多个冒号可以用一个省略号（…）来代替，因此上面的代码等价于：

>>>b[0,…]

array([[0, 1, 2, 3],

​ [ 4, 5, 6, 7],

​ [ 8, 9, 10, 11]])

按照定义的理解，它是对 切片 [ : ] 里的 : 的拓展，但是它只能出现一个，就是说你可以，[ : , : , : ],但是[ … , …]就会报错。

NumPy高级索引

可以从ndarray中选择一个非元组序列，整数或布尔数据类型的ndarray对象，或者至少包含一个项目作为序列对象的元组。高级索引始终返回数据的副本。与此相反，切片只呈现一个视图。

有两种高级索引 - 整型 和 布尔型 。

整数索引

该机制有助于根据其无限维索引在数组中选择任意的项目。每个整数数组代表该维度中的索引数量。当索引由与目标ndarray的维度相同数量的整数数组组成时，它变得非常简单。

在以下示例中，选择了从ndarray对象的每一行中指定列的一个元素。因此，行索引包含所有行号，列索引指定要选择的元素。

例1

import numpy as np

x = np.array([[1, 2], [3, 4], [5, 6]])
y = x[[0,1,2], [0,1,0]]
print y

其产出如下 -

[1  4  5]

选择包括第一个数组中的（0,0），（1,1）和（2,0）元素。

高级和基本索引可以通过使用一个slice（:)或省略号（…）与索引数组结合使用。以下示例对列使用slice和高级索引。当切片用于两者时结果相同。但高级索引会导致复制，并可能有不同的内存布局。

布尔数组索引

这种类型的高级索引是在结果对象是布尔操作的结果时使用的，例如比较运算符。

# Now we will print the items greater than 5
print 'The items greater than 5 are:'
print x[x > 5]

在这个例子中，通过使用〜（补数运算符）省略NaN（非数字）元素。

import numpy as np
a = np.array([np.nan, 1,2,np.nan,3,4,5])
print a[~np.isnan(a)]

其产出将是 -

[ 1.   2.   3.   4.   5.]

例3

以下示例显示如何从数组中过滤非复杂元素。

import numpy as np
a = np.array([1, 2+6j, 5, 3.5+5j])
print a[np.iscomplex(a)]

在这里，输出如下 -

[2.0+6.j  3.5+5.j]

NumPy广播

术语 广播 是指在算术运算期间NumPy处理不同形状的数组的能力。数组上的算术运算通常在相应的元素上完成。如果两个阵列具有完全相同的形状，那么这些操作将顺利执行。

1.numpy乘法运算中**"*"是数组元素逐个计算**

2.numpy乘法运算中dot是按照矩阵乘法的规则来运算的

如果两个数组的维数不相同，则元素到元素的操作是不可能的。但是，由于广播能力的原因，在NumPy中仍然可以对非相似形状的阵列进行操作。较小的阵列被 广播 到较大阵列的大小，以便它们具有兼容的形状。

如果满足以下规则，广播是可能的 -

• 具有较小 ndim的 数组在其形状上预置为’1’。
• 输出形状的每个维度中的大小是该维度中输入大小的最大值。
• 如果输入的大小与输出大小匹配或者其值恰好为1，则可以使用输入进行计算。
• 如果输入的维度大小为1，则该维度中的第一个数据条目将用于沿该维度的所有计算。

如果上述规则产生有效结果并且以下情况之一成立，则称一组数据可以 广播 -

• 数组的形状完全相同。
• 数组具有相同的维度数量，每个维度的长度可以是常用长度或1。
• 尺寸太小的阵列可能会将其形状预先设置为长度为1的尺寸，以使上述属性为真。

以下程序显示了广播示例

NumPy遍历数组

NumPy包中包含一个迭代器对象 numpy.nditer 。它是一个有效的多维迭代器对象，可以用它迭代数组。使用Python的标准Iterator接口访问数组的每个元素。

让我们使用 arange() 函数创建一个3X4数组，并使用 nditer 对其进行 迭代

例1

import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)

print 'Original array is:'
print a
print '\n'

print 'Modified array is:'
for x in np.nditer(a):
   print x,

这个程序的输出如下 -

Original array is:
[[ 0 5 10 15]
 [20 25 30 35]
 [40 45 50 55]]

Modified array is:
0 5 10 15 20 25 30 35 40 45 50 55

NumPy数组操作

NumPy包中有几个例程可用于处理ndarray对象中的元素。它们可以分为以下几类 -

改变形状

Sr.No.	形状和说明
1	reshape 给数组赋予新的形状而不更改其数据
2	flat 数组上的一维迭代器
3	flatten 返回折叠为一个维度的数组的副本
4	ravel 返回一个连续的扁平数组

转置操作

Sr.No.	操作和说明
1	transpose 置换数组的维数
2	ndarray.T 与self.transpose()相同
3	rollaxis 向后滚动指定的轴
4	swapaxes 交换数组的两个轴

更改尺寸

Sr.No.	尺寸和说明
1	broadcast 产生一个模仿广播的对象
2	broadcast_to 将数组广播到新的形状
3	expand_dims 扩展数组的形状
4	squeeze 从数组形状中移除一维条目

加入数组

Sr.No.	数组和说明
1	concatenate 沿着现有轴加入一系列阵列
2	stack 沿着一个新的轴加入一系列数组
3	hstack 按顺序堆叠阵列(列明智)
4	vstack 按顺序堆叠数组(按行)

拆分数组

Sr.No.	数组和说明
1	split 将数组拆分成多个子数组
2	hsplit 将数组分成多个子数组(水平方向)
3	vsplit 将数组垂直分割成多个子数组(按行)

添加/删除元素

Sr.No.	元素和说明
1	resize 返回具有指定形状的新数组
2	append 将值附加到数组的末尾
3	insert 在给定索引之前沿给定轴插入值
4	delete 返回一个新数组，其中沿着一个轴的子数组被删除
5	unique 查找数组的独特元素

NumPy二元运算符

以下是NumPy包中可用的按位运算功能。

Sr.No.	操作和说明
1	bitwise_and 计算数组元素的按位与操作
2	bitwise_or 计算数组元素的按位或运算
3	invert 计算按位NOT
4	left_shift 将二进制表示的位向左移位
5	right_shift 将二进制表示的位向右移位

NumPy字符串函数

以下函数用于对dtype numpy.string_或numpy.unicode_的数组执行向量化字符串操作。它们基于Python内置库中的标准字符串函数。

Sr.No.	功能说明
1	add() 返回两个str或Unicode数组的元素方式字符串连接
2	multiply() 以元素方式返回具有多个级联的字符串
3	center() 返回给定字符串的副本，其元素以指定长度的字符串为中心
4	capitalize() 仅返回大写字母的第一个字符的副本
5	title() 返回字符串或unicode的基于元素的标题封装版本
6	lower() 返回元素转换为小写的数组
7	upper() 返回元素转换为大写的数组
8	split() 使用separatordelimiter返回字符串中的单词列表
9	splitlines() 返回元素中的行的列表，并打破行边界
10	strip() 返回删除前导字符和尾随字符的副本
11	join() 返回序列中字符串连接的字符串
12	replace() 返回所有出现的子字符串被新字符串替换的字符串副本
13	decode() 以元素方式调用str.decode
14	encode() 以元素方式调用str.encode

这些函数在字符数组类(numpy.char)中定义。较旧的Numarray软件包包含chararray类。numpy.char类中的上述函数在执行矢量化字符串操作时非常有用。

Numpy数学函数

三角函数

NumPy具有标准的三角函数，可以以弧度返回给定角度的三角比。

例

import numpy as np
a = np.array([0,30,45,60,90])

print 'Sine of different angles:'
# Convert to radians by multiplying with pi/180
print np.sin(a*np.pi/180)

arcsin，arcos 和 arctan 函数返回给定角度的sin，cos和tan的三角函数的倒数。这些函数的结果可以通过 numpy.degrees（）函数 通过将弧度转换为度来验证。

四舍五入的功能

numpy.around（）

这是一个返回四舍五入到所需精度的函数。该功能采用以下参数。

numpy.around(a,decimals)

哪里，

Sr.No.	参数和说明
1	a 输入数据
2	decimals 要舍入的小数位数。默认值为0.如果为负值，则将整数舍入到位于小数点左侧的位置

numpy.floor（）

该函数返回不大于输入参数的最大整数。 标量x 的底部是最大的 整数i ，使得 i <= x。请注意，在Python中，地板总是从0圆整。

numpy.ceil（）

ceil（）函数返回输入值的上限，即 标量x 的最小值是最小的 整数i ，使得 i > = x。

NumPy算术运算

用于执行诸如add（），subtract（），multiply（）和divide（）等算术运算的输入数组必须是相同的形状，或者应符合数组广播规则。

numpy.reciprocal（）

该函数返回参数的倒数，元素wise。对于绝对值大于1的元素，由于Python处理整数除法的方式，结果始终为0。对于整数0，发出溢出警告。

print np.reciprocal(a)

numpy.power（）

该函数将第一个输入数组中的元素作为基础处理，并将其返回为第二个输入数组中相应元素的权力。

a = np.array([10,100,1000])
np.power(a,2)

numpy.mod（）

该函数返回输入数组中相应元素的除法余数。函数 numpy.remainder（） 也会产生相同的结果。

a = np.array([10,20,30])
b = np.array([3,5,7])
np.mod(a,b)

NumPy统计函数

NumPy具有相当多的有用的统计函数，用于从数组中的给定元素中找出最小值，最大值，百分位标准偏差和方差等。功能解释如下 -

numpy.amin（）和numpy.amax（）

这些函数返回给定数组中沿指定轴的元素的最小值和最大值。

a = np.array([[3,7,5],[8,4,3],[2,4,9]])
print np.amax(a, axis = 0)	# 每列最大值
>> [8 7 9]

numpy.ptp（）

轴方向上的最大值与最小值之差

a = np.arange(9).reshape((3,3))
print(a)
# [[0 1 2]
#  [3 4 5]
#  [6 7 8]]

b = np.ptp(a, axis=0)  # axis=0 表示纵向
print(b) # [6 6 6]  # 6-0, 7-1, 8-2
 
c = np.ptp(a, axis=1)  # axis=1 表示横向
print(c) # [2 2 2]  # 2-0, 5-3, 8-6

numpy.percentile（）

作用：找到一组数的分位数值，如四分位数等(具体什么位置根据自己定义)

numpy.percentile(a, q, axis)

哪里，

Sr.No.	参数和说明
1	a 输入数组
2	q 计算的百分位数必须在0-100之间
3	axis 要计算百分位数的轴

1. a : array，用来算分位数的对象，可以是多维的数组
2. q : 介于0-100的float，用来计算是几分位的参数，如四分之一位就是25，如要算两个位置的数就(25,75)
3. axis : 坐标轴的方向，一维的就不用考虑了，多维的就用这个调整计算的维度方向，取值范围0/1
4. out : 输出数据的存放对象，参数要与预期输出有相同的形状和缓冲区长度
5. overwrite_input : bool，默认False，为True时及计算直接在数组内存计算，计算后原数组无法保存
6. interpolation : 取值范围{‘linear’, ‘lower’, ‘higher’, ‘midpoint’, ‘nearest’}
7. 默认liner，比如取中位数，但是中位数有两个数字6和7，选不同参数来调整输出
8. keepdims : bool,默认False,为真时取中位数的那个轴将保留在结果中

>>>a = np.array([[10, 7, 4], [3, 2, 1]])
>>>a
array([[10,  7,  4],
       [ 3,  2,  1]])
>>>np.percentile(a, 50)		# 所有元素的二分之一位数，不考虑轴
3.5
>>>np.percentile(a, 50, axis=0)
array([[ 6.5,  4.5,  2.5]])
>>>np.percentile(a, 50, axis=1)
array([ 7.,  2.])
>>>np.percentile(a, 50, axis=1, keepdims=True)
array([[ 7.],
       [ 2.]])

numpy.median（）

中位数 被定义为将数据样本的高半部分与下半部分分开的值。使用 numpy.median（） 函数，如下面的程序所示。

print 'Applying median() function:'
print np.median(a)
print '\n'  

print 'Applying median() function along axis 0:'
print np.median(a, axis = 0)

numpy.mean（）

算术平均值是沿轴的元素总和除以元素的数量。所述 numpy.mean（） 函数返回数组中元素的算术平均值。如果提到该轴，则会沿着它进行计算。

np.mean(a, axis = 1)

numpy.average（）

加权平均数是由每个组件乘以反映其重要性的因素所产生的平均值。所述 numpy.average（） 函数根据在另一个数组给定各自的重量计算数组中的元素的加权平均。该功能可以有一个轴参数。如果没有指定轴，则数组变平。

考虑一个数组[1,2,3,4]和相应的权重[4,3,2,1]，加权平均值是通过相加元素的乘积和除以权重之和得出的。

加权平均=（1 *4 + 2* 3 + 3 *2 + 4* 1）/（4 + 3 + 2 + 1）

wts = np.array([4,3,2,1])
print np.average(a,weights = wts)

# Returns the sum of weights, if the returned parameter is set to True.
print 'Sum of weights'
print np.average([1,2,3, 4],weights = [4,3,2,1], returned = True)

>> Sum of weights
>> (2.0, 10.0)

标准偏差np.std()

标准偏差是平均偏差平方的平方根。标准差的公式如下 -

std = sqrt(mean(abs(x - x.mean())**2))

如果数组是[1,2,3,4]，那么它的平均值是2.5。因此，平方偏差为[2.25,0.25,0.25,2.25]，平均值除以4即sqrt（5/4）的平方根为1.1180339887498949。

例

import numpy as np
print np.std([1,2,3,4])

方差np.var()

方差是平方偏差的平均值，即 平均值（abs（x - x.mean（））* 2）* 。换句话说，标准偏差是方差的平方根。

例

import numpy as np
print np.var([1,2,3,4])

NumPy排序，搜索和计数功能

分类	速度	最坏的情况下	工作空间	稳定
“快速排序”	1	为O（n ^ 2）	0	没有
“归并”	2	O（N *的log（n））	〜n / 2个	是
“堆排序”	3	O（N *的log（n））	0	没有

类型参数及缩写

类型	字符代码
bool	?, b1
int8	b, i1
uint8	B, u1
int16	h, i2
uint16	H, u2
int32	i, i4
uint32	I, u4
int64	q, i8
uint64	Q, u8
float16	f2, e
float32	f4, f
float64	f8, d
complex64	F4, F
complex128	F8, D
str	a, S（可以在S后面添加数字，表示字符串长度，比如S3表示长度为三的字符串，不写则为最大长度）
unicode	U
object	O
void	V

numpy.sort（）

sort（）函数返回输入数组的有序副本。它有以下参数 -

numpy.sort(a, axis, kind, order)

Sr.No.	参数和说明
1	a 数组进行排序
2	axis 要排序数组的轴。如果没有，则数组将变平，并在最后一个轴上排序
3	kind 默认是快速排序
4	order 如果数组包含字段，则要排序字段的顺序

print np.sort(a, axis = 0)

# Order parameter in sort function
dt = np.dtype([('name', 'S10'),('age', int)])
a = np.array([("raju",21),("anil",25),("ravi", 17), ("amar",27)], dtype = dt)

print 'Order by name:'
print np.sort(a, order = 'name')

numpy.argsort（）

所述 numpy.argsort（） 函数执行输入阵列上的间接排序，沿给定轴，并使用特定种类排序返回的数据的索引的数组。这个索引数组用于构造排序后的数组。

x = np.array([3, 1, 2])
y = np.argsort(x)
print y
print x[y]
>>	[1 2 0]
>>	[1 2 3]

numpy.lexsort（）

numpy.lexsort() 用于对多个序列进行排序。把它想象成对电子表格进行排序，每一列代表一个序列，排序时优先照顾靠后的列。

nm = ('raju','anil','ravi','amar')
dv = ('f.y.', 's.y.', 's.y.', 'f.y.')
ind = np.lexsort((dv,nm))

numpy.argmax（）和numpy.argmin（）

这两个函数分别沿给定的轴返回最大和最小元素的索引。

numpy.nonzero（）

所述 numpy.nonzero（） 函数返回输入数组中的非零元素的索引。

a = np.array([[30,40,0],[0,20,10],[50,0,60]])
(array([0, 0, 1, 1, 2, 2]), array([0, 1, 1, 2, 0, 2]))

numpy.where（）

where（）函数返回满足给定条件的输入数组中元素的索引。

例

x = np.arange(9.).reshape(3, 3)
y = np.where(x > 3) 	# 传入的只有一个条件参数，注意返回的是索引，因此还需要再用它做下标取值
print 'Use these indices to get elements satisfying the condition'
print x[y]

numpy.extract（）

和where函数有一点像，不过extract函数是返回满足条件的元素，而不是元素索引。

print(np.extract(condition,x))	# 直接返回的是元素列表，传入参数是条件和列表

NumPy字节交换

我们已经看到，存储在计算机内存中的数据取决于CPU使用的体系结构。它可能是小端（最低有效位置存储在最小地址中）或大端（最小地址中最高有效字节）。

numpy.ndarray.byteswap（）

**numpy.ndarray.byteswap()**函数在两个表示之间切换:bigendian和little-endian。

NumPy副本和视图

在执行函数时，其中一些返回输入数组的副本，而另一些则返回视图。当内容物理地存储在另一个位置时，它被称为 复制 。另一方面，如果提供了相同内存内容的不同视图，我们将其称为 View 。

没有副本

简单的赋值不会创建数组对象的副本。相反，它使用原始数组的相同id（）来访问它。的 ID（） 返回Python对象的通用标识符，类似于C的指针

而且，任何一方的变化都会反映在另一方面。例如，一个变化的形状也会改变另一个的形状。

b = a

此时id(a)==id(b)

查看或浅拷贝

NumPy有 ndarray.view（） 方法，它是一个新的数组对象，它查看原始数组的相同数据。与之前的情况不同，新阵列的尺寸更改不会更改原始尺寸。

b = a.view()

此时id(a)!=id(b)

深度复制

该 ndarray.copy（） 函数创建深副本。它是数组及其数据的完整副本，并不与原始数组共享。

b = a.copy()

NumPy 矩阵库

NumPy包中包含一个Matrix库 numpy.matlib 。该模块具有返回矩阵而不是ndarray对象的函数。

这部分先跳过，暂时用不到

matlib.empty（）

该 matlib.empty（） 函数返回一个新的矩阵，而不初始化条目。该功能采用以下参数。

numpy.matlib.empty(shape, dtype, order)

Sr.No.	参数和说明
1	shape s int 或元组 int 限定新的矩阵的形状
2	Dtype 可选的。输出的数据类型
3	order C或F

import numpy.matlib
import numpy as np

print np.matlib.empty((2,2))
# filled with random data

NumPy线性代数

NumPy软件包包含 numpy.linalg 模块，提供线性代数所需的所有功能。下表描述了该模块中的一些重要功能。

Sr.No.	功能说明
1	dot 两个阵列的点积
2	vdot 两个向量的点积
3	inner 两个阵列的内积
4	matmul 两个阵列的矩阵乘积
5	determinant 计算数组的行列式
6	solve 求解线性矩阵方程
7	inv 找出矩阵的乘法逆

numpy中的matplotlib

NumPy有一个 numpy.histogram（） 函数，它是数据频率分布的图形表示。相等的水平尺寸的长方形对应于类间隔称为 bin 和 可变高度， 对应于频率。

numpy.histogram（）

numpy.histogram（）函数将输入数组和数组作为两个参数。箱阵列中的连续元素充当每个箱的边界。

hist,bins = np.histogram(a,bins = [0,20,40,60,80,100])

# Matplotlib可以将这个直方图的数字表示转换为图形。pyplot子模块的 plt（）函数 将包含数据和bin数组的数组作为参数并转换为直方图。
plt.hist(a, bins = [0,20,40,60,80,100])
plt.title("histogram")
plt.show()

plot颜色参数

字符	颜色
‘B’	蓝色
‘G’	绿色
‘R’	红
‘C’	青色
‘M’	品红
‘Y’	黄色
‘K’	黑色
‘W’	白色

通过向 plot（） 函数添加格式字符串，可以离散显示值而不是线性图。可以使用格式化字符。

Sr.No.	性格和描述
1	’ - ’ 实线样式
2	’ – ’ 虚线样式
3	’ -. ’ 点划线样式
4	‘：’ 虚线的样式
5	‘.’ 点标记
6	‘,’ 像素标记
7	‘O’ 圆形标记
8	‘V’ Triangle_down标记
9	‘^’ Triangle_up标记
10	’ <’ Triangle_left标记
11	’ >’ Triangle_right标记
12	‘1’ Tri_down标记
13	‘2’ Tri_up标记
14	‘3’ Tri_left标记
15	‘4’ Tri_right标记
16	‘S’ 方形的标记
17	‘P’ 五角大楼标记
18	‘*’ 星标
19	‘H’ Hexagon1标记
20	‘H’ Hexagon2标记
21	‘+’ Plus标记
22	‘X’ X标记
23	‘d’ 钻石标记
24	‘d’ Thin_diamond标记
25	‘|’ Vline标记
26	‘_’ Hline标记

IO与NumPy

ndarray对象可以保存到磁盘文件并从磁盘文件加载。可用的IO功能是 -

• load（） 和 save（） 函数处理 numpy二进制文件（使用 npy 扩展名）
• loadtxt（） 和 savetxt（） 函数处理普通的文本文件

NumPy为ndarray对象引入了一个简单的文件格式。此 .npy 文件存储重建磁盘文件中的ndarray所需的数据，形状，dtype和其他信息，以便即使文件位于具有不同体系结构的另一台计算机上，也能正确检索该阵列。

numpy.save（）

所述 numpy.save（） 文件存储与磁盘文件输入数组 NPY 扩展。

import numpy as np
a = np.array([1,2,3,4,5])
np.save('outfile',a)

要从 outfile.npy 重建数组，请使用 load（） 函数。

import numpy as np
b = np.load('outfile.npy')
print b

它会产生以下输出 -

array([1, 2, 3, 4, 5])

save（）和load（）函数接受一个额外的布尔参数 allow_pickles 。在保存到磁盘文件或从磁盘文件读取数据之前，Python中的pickle用于序列化和反序列化对象。

savetxt（）

以简单文本文件格式存储和检索数组数据是通过 savetxt（） 和 loadtxt（） 函数完成的。

例

import numpy as np

a = np.array([1,2,3,4,5])
np.savetxt('out.txt',a)
b = np.loadtxt('out.txt')
print b

它会产生以下输出 -

[ 1.  2.  3.  4.  5.]

         |

| 19 | ‘H’ Hexagon1标记 |
| 20 | ‘H’ Hexagon2标记 |
| 21 | ‘+’ Plus标记 |
| 22 | ‘X’ X标记 |
| 23 | ‘d’ 钻石标记 |
| 24 | ‘d’ Thin_diamond标记 |
| 25 | ‘|’ Vline标记 |
| 26 | ‘_’ Hline标记 |

IO与NumPy

ndarray对象可以保存到磁盘文件并从磁盘文件加载。可用的IO功能是 -

• load（） 和 save（） 函数处理 numpy二进制文件（使用 npy 扩展名）
• loadtxt（） 和 savetxt（） 函数处理普通的文本文件

NumPy为ndarray对象引入了一个简单的文件格式。此 .npy 文件存储重建磁盘文件中的ndarray所需的数据，形状，dtype和其他信息，以便即使文件位于具有不同体系结构的另一台计算机上，也能正确检索该阵列。

numpy.save（）

所述 numpy.save（） 文件存储与磁盘文件输入数组 NPY 扩展。

import numpy as np
a = np.array([1,2,3,4,5])
np.save('outfile',a)

要从 outfile.npy 重建数组，请使用 load（） 函数。

import numpy as np
b = np.load('outfile.npy')
print b

它会产生以下输出 -

array([1, 2, 3, 4, 5])

save（）和load（）函数接受一个额外的布尔参数 allow_pickles 。在保存到磁盘文件或从磁盘文件读取数据之前，Python中的pickle用于序列化和反序列化对象。

savetxt（）

以简单文本文件格式存储和检索数组数据是通过 savetxt（） 和 loadtxt（） 函数完成的。

例

import numpy as np

a = np.array([1,2,3,4,5])
np.savetxt('out.txt',a)
b = np.loadtxt('out.txt')
print b

它会产生以下输出 -

[ 1.  2.  3.  4.  5.]

savetxt（）和loadtxt（）函数接受附加的可选参数，如页眉，页脚和分隔符。