python--------numpy模块学习

numpy模块------dtype类 

np.dtype(object, align, copy)

参数为：

• Object：被转换为数据类型的对象。

• Align：如果为true，则向字段添加间隔，使其类似 C 的结构体。

• Copy? 生成dtype对象的新副本，如果为flase，结果是内建数据类型对象的引用。

  import numpy as np 
  dt = np.dtype(np.int32)  
  print dt
  int32
  
  #int8，int16，int32，int64 可替换为等价的字符串 'i1'，'i2'，'i4'，以及其他。  
  import numpy as np 
  
  dt = np.dtype('i4')  
  print dt
  int32
  #以下示例定义名为 student 的结构化数据类型，其中包含字符串字段name，整数字段age和浮点字段marks。 此dtype应用于ndarray对象
  import numpy as np 
  student = np.dtype([('name','S20'),  ('age',  'i1'),  ('marks',  'f4')])  
  print (student)
  [('name', 'S20'), ('age', 'i1'), ('marks', '<f4')])
  a = np.array([('abc',  21,  50),('xyz',  18,  75)], dtype = student)  
  print a
  [('abc', 21, 50.0), ('xyz', 18, 75.0)]

  每个内建类型都有一个唯一定义它的字符代码：

• 'b'：布尔值

• 'i'：符号整数

• 'u'：无符号整数

• 'f'：浮点

• 'c'：复数浮点

• 'm'：时间间隔

• 'M'：日期时间

• 'O'：Python 对象

• 'S', 'a'：字节串

• 'U'：Unicode

• 'V'：原始数据(void)

为什么要定义这个类？

自己的理解是：有的时候我们需要的n维数组中的每一个元素是一个多值组合，类似于结构体形式化的样例，如果没有使用dtype类去定义自己想要的数据类型，则Python不会明白你想要的，他会自动帮你转换为统一类型，看下面例子

#正常情况下的一个举例，数组每个元素都是整型列表
a=np.array([(1,2,3),(4,5,6)])
print(a)
[[1 2 3]
 [4 5 6]]
#如果我们需要的数组中每一个元素都是(字符串，整型，浮点型)，那么结果输出是什么样呢？
a=np.array([("1",2,3.2),("2",3,3.2)])
>>> print(a)
[['1' '2' '3.2']
 ['2' '3' '3.2']]
#python自动都转化成字符串
此时如果定义一个结构化的类型，就可以输出我们需要的数组了
dt=np.dtype([("字符串",'S20'),("整型",'i1'),("浮点型",'<f4')])
a=np.array([("1",2,3.2),("2",3,3.2)],dtype=dt)
print(a)
[(b'1', 2, 3.2) (b'2', 3, 3.2)]

 

 

Numpy 模块------ndarray类

numpy模块中定义的最重要的类是称为 ndarray 的 N 维数组类型。 它描述相同类型的元素集合。 可以使用基于零的索引访问集合中的项目，ndarray中的每个元素是数据类型对象的对象(称为 dtype),这个n维数组的维度叫做轴(axis)，轴的个数叫做秩(rank)

ndarray类的成员变量

ndarray.ndim:数组轴的个数

ndarray.shape:数组的维度,这是一个指示数组在每个维度上大小的整数元组(返回类型为元祖)，也可以作为array()的参数调整数组的形状

ndarray.size:数组元素的总个数，等于shape属性中元组元素的乘积

ndarray.dtype:一个用来描述数组中元素类型的对象，可以通过创造或指定dtype使用标准Python类型

ndarray.itemsize:数组中每个元素的字节大小

 

创建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.	ndimin 指定返回数组的最小维数。

 

import numpy as np
#创建一维数组
a=np.array([1,2,3,4,5,6])
print(a)
[1 2 3 4 5 6]
#创建二维数组
b=np.array([[1,2,3],[4,5,6]])
print(b)
[[1 2 3]
 [4 5 6]]
#创建制定类型的ndarray数组
c=np.array([1,2,3],dtype=complex)
print(c)
[1.+0.j 2.+0.j 3.+0.j]
#先让我们用python的工厂函数type()查看一下b对象的类型，证明它的确是ndarray类对象
print(type(b))
<class 'numpy.ndarray'>
#ndarray类的成员变量举例
print(b.ndim)
2
print(b.shape)
(2, 3)
print(b.size)
6
print(b.dtype)
int64
print(b.itemsize)
8

创建指定维数的随机数组

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]]

 

创建全零数组

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

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

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

# 自定义类型 
import numpy as np 
x = np.zeros((2,2), dtype =  [('x',  'i4'),  ('y',  'i4')])  
print x
[[(0,0)(0,0)]
 [(0,0)(0,0)]]

 

创建全1数组 

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

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

import numpy as np 
x = np.ones([2,2], dtype =  int)  
print x
[[1  1] 
 [1  1]]

 

创建指定数值范围的数组

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

序号	参数及描述
1.	start 范围的起始值，默认为0
2.	stop 范围的终止值(不包含)
3.	step 两个值的间隔，默认为1
4.	dtype 返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。

 

a=np.arange(7,dtype=float)
print(a)
[0. 1. 2. 3. 4. 5. 6.]

arange和Python里面for i in range()的range的参数设定一模一样，可以制定范围，间隔

a=np.arange(2,9,2,dtype=float)
print(a)
[2. 4. 6. 8.]

                  

创建指定个数的数组 

numpy.linespace(start,end,count,dtype,endpoint）

序号	参数及描述
1.	start 范围的起始值，默认为0
2.	stop 范围的终止值(不包含，endpoint指定是否包含终值)
3.	count 元素的个数
4.	dtype 返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型

 a=np.linspace(0,1,10)
 a
array([0.        , 0.11111111, 0.22222222, 0.33333333, 0.44444444,
       0.55555556, 0.66666667, 0.77777778, 0.88888889, 1.        ])

 

 

 

利用函数创建数组

fromfunction(function,shape,dtype)

funtion	def function(x,y): （x,y）分别是以左上角为原点的坐标，x为行坐标，y为列坐标，表示第x行y列。     函数体
shape	数组的形状，整数或整数元组
dtype	返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。

import numpy as np
def f(x,y):
    return 10*x+y
b=np.fromfunction(f,(5,4),dtype=int)
print b

[[ 0  1  2  3]
 [10 11 12 13]
 [20 21 22 23]
 [30 31 32 33]
 [40 41 42 43]]
#x从shape(5,4)中的第一维取值，y从第二维取值，这个例子中x取值为0,1,2,3,4；y的取值为0,1,2,3

 

 

ndarray类的成员函数

1.ndarray.reshape():调整数组大小,返回对应数组

import numpy as np 
a = np.array([[1,2,3],[4,5,6]]) 
b = a.reshape(3,2)  
print b

2.ndarray.resize():resize 函数改变数组自身

b
array([[ 0,  1,  2,  3],
       [10, 11, 12, 13],
       [20, 21, 22, 23],
       [30, 31, 32, 33],
       [40, 41, 42, 43]])
b.resize(2,10)
b
array([[ 0,  1,  2,  3, 10, 11, 12, 13, 20, 21],
       [22, 23, 30, 31, 32, 33, 40, 41, 42, 43]])

3.ndarray.flat()

该函数返回数组上的一维迭代器，行为类似 Python 内建的迭代器

4.ndarray.flatten(order)

order：'C' — 按行，'F' — 按列，'A' — 原顺序，'k' — 元素在内存中的出现顺序。

import numpy as np
a = np.arange(8).reshape(2,4)

print '原数组：'
print a
print '\n'  
# default is column-major

print '展开的数组：'
print a.flatten()
print '\n'  

print '以 F 风格顺序展开的数组：'
print a.flatten(order = 'F')
Python
输出如下：

原数组：
[[0 1 2 3]
 [4 5 6 7]]

展开的数组：
[0 1 2 3 4 5 6 7]

以 F 风格顺序展开的数组：
[0 4 1 5 2 6 3 7]

5.numpy.ndarray.T:数组的转置

import numpy as np
a = np.arange(12).reshape(3,4)

print '原数组：'
print a
print '\n'  

print '转置数组：'
print a.T

6.ndarray.copy():深拷贝函数

numpy------切片和索引、

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

一维 数组可以被索引、切片和迭代，就像 列表 和其它Python序列。

多维 数组可以每个轴有一个索引。这些索引由一个逗号分割的元组给出。

def f(x,y):
...     return 10*x+y

b=np.fromfunction(f,(5,4),dtype=int)
print(b)
[[ 0  1  2  3]
 [10 11 12 13]
 [20 21 22 23]
 [30 31 32 33]
 [40 41 42 43]]

#获取单个元素，传统方法或是多维数组的方法
>>> b[1][2]
12
>>> b[1,2]
12
#获取一行
b[1]
array([10, 11, 12, 13])
b[1,...]
array([10, 11, 12, 13])
b[1,:]
array([10, 11, 12, 13])
#获取一列
b[...,1]
array([ 1, 11, 21, 31, 41])
b[:,1]
array([ 1, 11, 21, 31, 41])

#获取某几行
b[1:3]
array([[10, 11, 12, 13],
       [20, 21, 22, 23]])
#获取全部行的某几列
b[:,1:3]或b[...,1:3]
array([[ 1,  2],
       [11, 12],
       [21, 22],
       [31, 32],
       [41, 42]])

numpy----基本运算

(import numpy as np)

的数组进状对形相同行一下算运(大多数math模块中运算此处都有)

1.  +   ,   -   ,   *   ,  /,   **(不像许多矩阵语言，NumPy中的乘法运算符 * 指示按元素计算,对应元素相乘，返回的数组与输入数组形状相同)

2.np.dot(ndarray1，ndarray2)真正矩阵的乘法

3.指，对，幂函数，三角函数:例如：np.sin()，np.exp()

4.np.min(axis),np.max(axis),np.sum(asix):可以指定轴，0代表一维，1代表二维

5.add(ndarray1，ndarray2) ，substract(ndarray1，ndarray2),multiply(ndarray1，ndarray2),divide(ndarray1，ndarray2)加减乘除

6.np.mean([axis]):返回数组中元素的算数平均值，指定轴方向按轴计算

numpy------广播

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

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

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

如果输入的两个数组的后缘维度(即：从末尾开始算起的维度)的轴长相等或其中一方的长度为1，则认为它们是广播兼容的，广播会在缺失和(或)长度为1的轴上进行，输出数组的shape是输入的数组中各自对应轴的最大值

看着这两句话还是难以理解，这样举个例子来说，array1的shape(3,1)，array2的shape(3,）,array1的后缘推度是1，array2的后缘推度是3，满足规则，可以兼容.输出数组的shape(3,1)

再来些例子

input    (2d array):  5 x 4
input    (1d array):      1
ouput    (2d array):  5 x 4

input      (2d array):  5 x 4
input      (1d array):      4
ouput      (2d array):  5 x 4

input      (3d array):  15 x 3 x 5
input      (3d array):  15 x 1 x 5
ouput      (3d array):  15 x 3 x 5

input      (3d array):  15 x 3 x 5
input      (2d array):       3 x 5
ouput      (3d array):  15 x 3 x 5

input      (3d array):  15 x 3 x 5
input      (2d array):       3 x 1
ouput      (3d array):  15 x 3 x 5

推荐一个我可以看懂的关于numpy广播的博文，十分感谢作者！

numpy------IO

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

• load()和save()函数处理 numPy 二进制文件(带npy扩展名)

• loadtxt()和savetxt()函数处理正常的文本文件

 

1.numpy.save()&&numpy.load()

numpy.save()文件将输入数组存储在具有npy扩展名的磁盘文件中。

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

为了从outfile.npy重建数组，请使用numpy.load()函数。

import numpy as np 
b = np.load('outfile.npy')  
print b
array([1, 2, 3, 4, 5])

save()和load()函数接受一个附加的布尔参数allow_pickles。 Python 中的pickle用于在保存到磁盘文件或从磁盘文件读取之前，对对象进行序列化和反序列化。

2.numpy.savetxt()&&numpy.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

Python

输出如下：

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

Python

savetxt()和loadtxt()数接受附加的可选参数，例如页首，页尾和分隔符

y以上笔记整理参考如下，谢谢 ！

stay hungry!stay foolish!stay healthy!