Python学习——Numpy

Numpy

Ndarray 对象

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

序号	参数及描述
1.	object 任何暴露数组接口方法的对象都会返回一个数组或任何（嵌套）序列。
2.	dtype 数组的所需数据类型，可选。
3.	copy 可选，默认为true，对象是否被复制。
4.	order C（按行）、F（按列）或A（任意，默认）。
5.	subok 默认情况下，返回的数组被强制为基类数组。 如果为true，则返回子类。
6.	ndmin 指定返回数组的最小维数。

# 多于一个维度  
import numpy as np 
a = np.array([[1,  2],  [3,  4]])  
print(a)

[[1, 2] 
 [3, 4]]
 

 # 最小维度  
import numpy as np 
a = np.array([1,2,3,4,5], ndmin =  2)  
print(a)

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

可以看到结果是2维的

 # dtype 参数  
import numpy as np 
a = np.array([1,  2,  3], dtype = complex)  
print (a)

[1.+0.j 2.+0.j 3.+0.j]

NumPy 数字类型是dtype（数据类型）对象的实例，每个对象具有唯一的特征。 这些类型可以是np.bool_，np.float32等

数据类型对象 (dtype)

数据类型对象描述了对应于数组的固定内存块的解释，取决于以下方面：

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

字节顺序取决于数据类型的前缀<或>。 <意味着编码是小端（最小有效字节存储在最小地址中）。 >意味着编码是大端（最大有效字节存储在最小地址中）。

语法构造：

numpy.dtype(object, align, copy)

• Object：被转换为数据类型的对象。
• Align：如果为true，则向字段添加间隔，使其类似 C 的结构体。
• Copy：生成dtype对象的新副本，如果为flase，结果是内建数据类型对象的引用。

#int8，int16，int32，int64 可替换为等价的字符串 'i1'，'i2'，'i4'，以及其他。  
import numpy as np 
 
dt = np.dtype('i4')  
print dt 

结构化数据类型的使用

这里声明了字段名称和相应的标量数据类型。

# 首先创建结构化数据类型。  
import numpy as np 
dt = np.dtype([('age',np.int8)])  
print dt #输出[('age', 'i1')]

# 现在将其应用于 ndarray 对象  
import numpy as np 
 
dt = np.dtype([('age',np.int8)]) 
a = np.array([(10,),(20,),(30,)], dtype = dt) #试了一下，没有逗号也是可以的
print (a) #输出 [(10,) (20,) (30,)]
##访问 age 列的内容 
print(a['age']) #输出 [10 20 30]

更复杂一点的

定义名为 student 的结构化数据类型，其中包含字符串字段name，整数字段age和浮点字段marks。 此dtype应用于ndarray对象。

import numpy as np 
student = np.dtype([('name','S20'),  ('age',  'i1'),  ('marks',  'f4')])  
a = np.array([('abc',  21,  50),('xyz',  18,  75)], dtype = student) 
print(a) #输出 [(b'abc', 21, 50.) (b'xyz', 18, 75.)]
print(a['name'],a['age'],a['marks']) #输出 [b'abc' b'xyz'] [21 18] [50. 75.]

#想输出第二个学生的所有信息
print(a[1]) ##输出(b'xyz', 18, 75.)
#想输出第二个学生的姓名
print(a[1]['name'])  ##输出b'xyz'

输出前面有b，很奇怪不知道是啥

• 'b'：布尔值
• 'i'：符号整数
• 'u'：无符号整数
• 'f'：浮点
• 'c'：复数浮点
• 'm'：时间间隔
• 'M'：日期时间
• 'O'：Python 对象
• 'S', 'a'：字节串
• 'U'：Unicode
• 'V'：原始数据（void）

创建数组

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

序号	参数及描述
1.	Shape 空数组的形状，整数或整数元组
2.	Dtype 所需的输出数组类型，可选
3.	Order 'C'为按行的 C 风格数组，'F'为按列的 Fortran 风格数组

import numpy as np 
x = np.empty([3,2], dtype =  int)  
print x
##输出
[[22649312    1701344351] 
 [1818321759  1885959276] 
 [16779776    156368896]]

3行2列，元素为随机值

生成0

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

# 含有 5 个 0 的数组，默认类型为 float  
import numpy as np 
x = np.zeros(5)  
print (x)

生成1

numpy.ones(shape, dtype = None, order = 'C')

numpy.frombuffer

此函数将缓冲区解释为一维数组。 暴露缓冲区接口的任何对象都用作参数来返回ndarray。

序号	参数及描述
1.	buffer 任何暴露缓冲区借口的对象
2.	dtype 返回数组的数据类型，默认为float
3.	count 需要读取的数据数量，默认为-1，读取所有数据
4.	offset 需要读取的起始位置，默认为0

import numpy as np 
x = np.array("dsf")
s =  b'Hello World'
a = np.frombuffer(s, dtype =  'S1') 
print(x)
print(a)
print(a[0])

##输出
dsf
[b'H' b'e' b'l' b'l' b'o' b' ' b'W' b'o' b'r' b'l' b'd']
b'H'

s字符串前面需要加上b

可以看到这个函数的作用就是能把读入的字符串也分割成数组

numpy.arange

numpy.arange(start, stop, step, dtype)

numpy.linspace

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

序号	参数及描述
1.	start 序列的起始值
2.	stop 序列的终止值，如果endpoint为true，该值包含于序列中
3.	num 要生成的等间隔样例数量，默认为50
4.	endpoint 序列中是否包含stop值，默认为ture
5.	retstep 如果为true，返回样例，以及连续数字之间的步长
6.	dtype 输出ndarray的数据类型序号

切片和索引

import numpy as np
a = np.arange(10)
s = slice(2,7,2)   #start end step
print a[s]
##等价于
b = a[2:7:2]

广播

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

如果两个数组的维数不相同，则元素到元素的操作是不可能的。 然而，在 NumPy 中仍然可以对形状不相似的数组进行操作，因为它拥有广播功能。 较小的数组会广播到较大数组的大小，以便使它们的形状可兼容。

如果满足以下规则，可以进行广播：

• ndim较小的数组会在前面追加一个长度为 1 的维度。
• 输出数组的每个维度的大小是输入数组该维度大小的最大值。
• 如果输入在每个维度中的大小与输出大小匹配，或其值正好为 1，则在计算中可它。
• 如果输入的某个维度大小为 1，则该维度中的第一个数据元素将用于该维度的所有计算。

如果上述规则产生有效结果，并且满足以下条件之一，那么数组被称为可广播的。

• 数组拥有相同形状。
• 数组拥有相同的维数，每个维度拥有相同长度，或者长度为 1。
• 数组拥有极少的维度，可以在其前面追加长度为 1 的维度，使上述条件成立。

import numpy as np 
a = np.array([[0.0,0.0,0.0],[10.0,10.0,10.0],[20.0,20.0,20.0],[30.0,30.0,30.0]]) 
b = np.array([1.0,2.0,3.0])  
print  '第一个数组：'  
print a 
print  '\n'  
print  '第二个数组：'  
print b 
print  '\n'  
print  '第一个数组加第二个数组：'  
print a + b

 ##输出 
第一个数组：
[[ 0. 0. 0.]
 [ 10. 10. 10.]
 [ 20. 20. 20.]
 [ 30. 30. 30.]]
 
第二个数组：
[ 1. 2. 3.]
 
第一个数组加第二个数组：
[[ 1. 2. 3.]
 [ 11. 12. 13.]
 [ 21. 22. 23.]
 [ 31. 32. 33.]]
 

留意输出的第二行至第四行，他们也都加上了

统计函数

最大值最小值

import numpy as np 
a = np.array([[3,7,5],[8,4,3],[2,4,9]])   
print (np.amin(a,1))  #输出[3 3 2]
print (np.amin(a,0))  #输出[2 4 3]

可以看出1是按行，0是按列

中值

np.median(a, axis =  0) 

平均值

np.mean(a, axis =  0) 

标准差

np.std([1,2,3,4])

方差

np.var([1,2,3,4])

排序 搜索 计数函数

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

序号	参数及描述
1.	a 要排序的数组
2.	axis 沿着它排序数组的轴，如果没有数组会被展开，沿着最后的轴排序
3.	kind 默认为'quicksort'（快速排序）
4.	order 如果数组包含字段，则是要排序的字段

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

结构体排序，按姓名字段排序

numpy.where()

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

 
import numpy as np 
x = np.arange(9.).reshape(3,  3)  
print  '我们的数组是：'  
print x 
print  '大于 3 的元素的索引：' 
y = np.where(x >  3)  
print y 
print  '使用这些索引来获取满足条件的元素：'  
print x[y]

numpy.extract()

extract()函数返回满足任何条件的元素。

 
import numpy as np 
x = np.arange(9.).reshape(3,  3)  
print  '我们的数组是：'  
print x 
# 定义条件 
condition = np.mod(x,2)  ==  0  
print  '按元素的条件值：'  
print condition 
print  '使用条件提取元素：'  
print np.extract(condition, x)

 
我们的数组是：
[[ 0. 1. 2.]
 [ 3. 4. 5.]
 [ 6. 7. 8.]]
 
按元素的条件值：
[[ True False True]
 [False True False]
 [ True False True]]
 
使用条件提取元素：
[ 0. 2. 4. 6. 8.]
 

Matplotlib

Matplotlib 是 Python 的绘图库。 它可与 NumPy 一起使用，提供了一种有效的 MatLab 开源替代方案。 它也可以和图形工具包一起使用，如 PyQt 和 wxPython。

包导入

from matplotlib import pyplot as plt

常用操作汇总

生成3*3随机矩阵，输出最大值最小值

x=np.random.random((3,3))
x.max()
x.min()

构造一个5*5的矩阵，令其值为1，并在最外层加上一圈0

x=np.ones((5,5))
x

Out[96]:

array([[1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1.]])

In [97]:

x=np.pad(x,pad_width=1,mode='constant',constant_values=0)
x

Out[97]:

array([[0., 0., 0., 0., 0., 0., 0.],
       [0., 1., 1., 1., 1., 1., 0.],
       [0., 1., 1., 1., 1., 1., 0.],
       [0., 1., 1., 1., 1., 1., 0.],
       [0., 1., 1., 1., 1., 1., 0.],
       [0., 1., 1., 1., 1., 1., 0.],
       [0., 0., 0., 0., 0., 0., 0.]])

构建一个shape为(6,7,8)的矩阵，并找到第100个元素的索引值

np.unravel_index(100,(6,7,8))

对一个5*5矩阵做归一化操作

x=np.random.random((5,5))
x_max=x.max()
x_min=x.min()
x=(x-x_min)/(x_max-x_min)  ##归一化的公式
x

找两个数组中相同的值

In [100]:

z1=np.random.randint(0,10,10)
z2=np.random.randint(0,10,10)
print(z1)
print(z2)
print(np.intersect1d(z1,z2)) ##！！
[2 6 6 9 2 3 0 6 1 1]
[2 4 9 0 8 3 2 2 2 8]
[0 2 3 9]

构造一个数组，让它不能被改变

z=np.zeros(5)
z.flags.writeable=False

打印大数据的部分值，全部值

In [113]:

np.set_printoptions(threshold=None)
z=np.zeros((20,20))
z

Out[113]:

array([[0., 0., 0., ..., 0., 0., 0.],
       [0., 0., 0., ..., 0., 0., 0.],
       [0., 0., 0., ..., 0., 0., 0.],
       ...,
       [0., 0., 0., ..., 0., 0., 0.],
       [0., 0., 0., ..., 0., 0., 0.],
       [0., 0., 0., ..., 0., 0., 0.]])

这样就实现了打印部分值的效果，默认是打印全部值

但是我设置一次后之后打印的全变了，我如果想要设置为打印全部呢

np.set_printoptions(threshold=np.inf)

找到一个数组中,最接近一个数的索引}

In [130]:

z=np.arange(100)
v=np.random.uniform(0,100)
print(v)
index=(np.abs(v-z)).argmin()
print(z[index])
68.5910028821209
69

打印数组元素位置坐标和数值

In [131]:

z=np.arange(9).reshape(3,3)
for index,value in np.ndenumerate(z):
    print(index,value)
(0, 0) 0
(0, 1) 1
(0, 2) 2
(1, 0) 3
(1, 1) 4
(1, 2) 5
(2, 0) 6
(2, 1) 7
(2, 2) 8

矩阵按某一列进行排序

In [134]:

z = np.random.randint(0,10,(3,3))
print(z)
print(z[z[:,1].argsort()])
[[9 6 0]
 [5 7 3]
 [9 1 9]]
 
[[9 1 9]
 [9 6 0]
 [5 7 3]]

可以发现矩阵按第二列进行排序，行也是跟着发生变化的

交换矩阵中的两行

In [138]:

z=np.arange(25).reshape(5,5)
z[[0,1]]=z[[1,0]]
z

Out[138]:

array([[ 5,  6,  7,  8,  9],
       [ 0,  1,  2,  3,  4],
       [10, 11, 12, 13, 14],
       [15, 16, 17, 18, 19],
       [20, 21, 22, 23, 24]])

找到一个数组中最常见出现的数字

In [141]:

z=np.random.randint(0,10,50)
print(z)
print(np.bincount(z).argmax())

参考资料：https://www.jianshu.com/p/57e3c0a92f3a