Python之Numpy库_exponentialmovement类如何在ufunc中使用

一 Numpy介绍

Numpy: 是Numerical Python缩写，即数值Python包，是python进行科学计算的一个基础包。

# 一个具有矢量算术运算和复杂广播能力的快速且节省空间的多维数组：N- dimensional array object（ndarray）

# 用于对整组数据进行快速运算的标准函数：universe function object(ufunc)

# 用于整合c/c++和Fortran代买的工具包

# 实用的线性代数，傅里叶变化和随机数生成函数。Numpy和稀疏矩阵运算包scipy配合使用更加方便

 

二 多维数组对象ndarray

ndarray: N-dimensional array，N维数组的缩写。一种由相同类型的元素组成的多维数组，元素数量是事先指定好的

元素的数据类型由dtype（data-type）对象来指定，每一个ndarray只有一种dtype类型

大小固定，创建好数组时一旦指定好大小，就不会再发生改变

 

 

2.1 ndarray属性

# ndim: 维度数量

# shape: 是一个表示各维度大小的元组，即数组的形状

# dtype: 一个用于说明数组元素数据类型的对象

# size: 元素总个数，即shape中各个数组相乘

import numpy as np

np.array([[1,2,3,4],[3,5,7,9]])

arr.ndim = 2

arr.shape = (2,4)

arr.dtype = dtype('int32')

arr.size = 8

 

 

指定元素数据类型为字符串

arr2 =np.array(['1234','234567','12','566'],dtype='|S')

 

指定保留指定长度的字符串，比如保留字符串长度2位

arr3 =np.array(['1234','234567','12','566'],dtype='|S2')

 

在某些时候可以自动转换类型

arr4 =np.array(['1234','234567','12','566'],dtype='int')

 

2.2 ndarray常见的创建方式

# array函数：接收一个普通的python序列，转换成ndarray

np.array(['1234','234567','12','566'],dtype='|S')

# zeros函数：创建指定长度或者形状的全零数组

np.zeros((2,4))

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

 [ 0.,  0., 0.,  0.]])

# ones函数：创建指定长度或者形状的全1数组

np.ones((3,3))

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

       [1.,  1., 1.],

       [1.,  1., 1.]])

# empty函数：创建一个没有任何具体的数值

np.empty((2,2))

 

2.3 ndarray的其他创建方式

# arange函数：类似于python的range函数，通过指定开始值，终值和步长来创建一维数组，但是不包括终值

指定一个参数，则是逐渐递增

np.arange(5)：array([0, 1, 2, 3, 4])

np.arange(0,16,2)：array([ 0, 2,  4,  6,  8,10, 12, 14])

np.arange(0,16,2).reshape(2,4)：array([[ 0, 2,  4,  6],

       [ 8,10, 12, 14]])

Reshape函数表示重新进行维度变化，size必须等价于原始数据的个数

 

# linspace函数：通过指定开始值，终值和元素个数来创建一维数组，可以通过endpoint关键字指定是否包括终值，缺省值包括

np.linspace(0,100,10)：array([0., 11.11111111, 22.22222222,   33.33333333,44.44444444, 55.55555556,66.66666667, 77.77777778,

88.88888889, 100.])

# logspace函数：和linspace类似，不过他创建等比数列

np.logspace(0,3,5) ：第一个参数代表10的0次方，第二参数代表10的3次方，第三个参数代表从中间取出5个数

array([ 1., 5.62341325, 31.6227766 ,177.827941,1000.])

 

# 使用随机数填充数组，即使用numpy.random模块的random函数，数组所包含的元素数量由参数决定。

np.random.random((2,4))：

array([[ 0.96199503,  0.24559848, 0.57068131,  0.35765634],[0.62837402,  0.23755619,  0.1049836 , 0.20200939]])

 

2.4 改变ndarray的形状

# 我们可以通过reshape函数进行形状的改变，但是注意不能改变元素个数，比如之前的形状是（2,4）,你可以变为（4,2）or（1,8）or(8,1)，但是你不能改变成（2,3）或者（3,3）之类的，因为他们元素总数已经不等于8了

# 使用reshape函数，可以创建一个改变shape的新数组，原数组的shape保持不变；但是他们共享内存空间，因此修改任意一个也会对另外一个产生影响。

# 当指定新数组某个轴的元素为-1的时候，将根据数组元素的个数自动计算此轴的长度，比如本来之前的形状为（3,4）,改变shape之后，为（-1,2）,则会自定根据元素个数3 * 4 = 12 / 2 得到-1的值为6

a5 = np.array([['A','B','C','D'],['E','F','G','H'],['J','K','L','M']])
array([['A', 'B', 'C', 'D'],
       ['E', 'F', 'G', 'H'],
       ['J', 'K', 'L', 'M']],
      dtype='<U1')

a5.shape
(3, 4)
a6 = a5.reshape(-1,2)
array([['A', 'B'],
       ['C', 'D'],
       ['E', 'F'],
       ['G', 'H'],
       ['J', 'K'],
       ['L', 'M']],
      dtype='<U1')
a6.shape
(6,2)

 

 

 

三 Numpy中的数据类型

创建Numpy数组的时候，我们可以通过dtype属性显示指定数据类型，如果不指定，Numpy会自己推断出合适的数据类型，所以一般无需显示指定

Astype方法，可以转换数组的元素数据类型，显示得到一个新的数组

a1 = np.array([1,2,3,4])
a1.dtype
dtype('int32')
a2 = a1.astype(np.float)
a2.dtype
dtype('float64')

# 数值型dtype的类型：一个类名(int,float)后面接着一个用于表示各元素位长的数字

float64: 表示需要占用8个字节，8个字节即64bit

float16：表示需要占用2个字节，2个字节即16bit

float32：表示需要占用4个字节，4个字节即32bit

a1 = np.array(['hadoop','spark','hive','hue'],dtype=np.string_)
a2 = np.array(['12','22','33','44'],dtype=np.int32)
a3 = np.array(['hadoop','spark','hive','hue'],dtype=np.unicode_)
a4 = np.array(['hadoop','spark','hive','hue'],dtype='|S5')

 

 

四 Numpy基本操作

4.1 数组与标量、数组之间的运算

# 数组不用循环，即可对每一个元素进行批量运算，这通常叫做矢量化，即用数组表达式代替循环的做法

a1 = np.array([1,2,3,4,5])
a2 = a1 +2
a3 = a1 -2
a4 = a1 * 2
from __future__ import division
a5 = 1 / a1
a6 = a1 ** 2

 

# 矢量化数组运算性能要比纯python方式快上一两个数量级

# 大小相等的数组之间的任何运算都会将运算应用到元素级

a1 = np.array([[1,2.0],[1.9,3.5]])
a2 = np.array([[3.6,1.2],[2.0,1.5]])
a1 + a2
array([[ 4.6,  3.2],
       [ 3.9,  5. ]])

a1 * a2
array([[ 3.6 ,  2.4 ],
       [ 3.8 ,  5.25]])

 

 

 

 

4.2 数组的矩阵积（matrixproduct）

# 两个二维矩阵满足第一个矩阵的列数与第二个矩阵的行数相同，那么可以进行矩阵乘法，即矩阵积，距阵积不是元素级的运算

 

# 两个矩阵相乘结果所得到的数组中每一个元素为，第一个矩阵中与该元素行号相同元素与第二个矩阵中与该元素列号相同的元素，两两相乘后求和

aparts = np.array([
    [120,60,220],
    [115,23,201],
    [132,48,230]
])

products = np.array([
    [12.34,0.04],
    [204.56,2.34],
    [9.89,0.45]
])
# 求距阵积
aparts.dot(products)
array([[ 15930.2 ,    244.2 ],
       [  8111.87,    148.87],
       [ 13722.46,    221.1 ]])

计算过程:

[120 * 12.34 + 60*204.56+ 220*9.89,120*0.04 +60*2.34+220*0.45]

[115 * 12.34 + 23*204.56+ 201*9.89,115*0.04 +23*2.34+201*0.45]

[132 * 12.34 + 48*204.56+ 230*9.89,132*0.04 +48*2.34+230*0.45]

 

4.3 数组的索引和切片

# 多维数组的索引

# numpy中数组的切片

在各个维度上单独切片，如果某维度保留，则直接使用：不指定起始值和终止值

注意：通过切片获得的新数组是对原数组的一个视图，你新数组元素发生改变，原数组的元素也会发生改变

arr = np.array([
    [
        [2,3,4,5],
        [3,7,8,2]
    ],
    [
        [1,6,41,52],
        [13,17,28,21]
    ],
    [
        [12,43,4,5],
        [13,87,8,2]
    ]
])

# 截取第二个元素
arr[1]
array([[ 1,  6, 41, 52],
       [13, 17, 28, 21]])
# 截取第二个元素中第一个元素
arr[1,0]
array([ 1,  6, 41, 52])
# 截取第二个元素中第一个元素中所有元素
arr[1,0,0:]
array([ 1,  6, 41, 52])
# 截取第二个元素中第一个元素前2个元素
arr[1,0,0:2]
array([1, 6])
# 截取第二个元素中前2-3个元素
arr[1,0,1:3]
array([ 6, 41])

 

# 布尔索引

主要是起一个筛选的作用，比如：

arr = np.arange(6).reshape(2,3)

res = arr > 2

array([[False, False, False],

       [True,  True,  True]], dtype=bool)

 

scores[~((names == ‘Tom’) | (names == ‘Jill’))]

scores[(names ！= ‘Tom’) & (names ！= ‘Jill’))]

不能使用and,or,not

 

# 花式索引

数组[[a.b,c]]：获取数组第a，b,c行数据

arr = np.arange(32).reshape(8,4)

arr[[0,3,4]]

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

       [12,13, 14, 15],

       [16,17, 18, 19]])

 

4.4 数组转置与轴兑换

数组转置函数transpose或者属性T：对于二维数组来说就是行列互换，都返回的是一个视图，但是对于一维数组而言，不会变化

arr = np.arange(12).reshape(3,4)

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

       [4,  5, 6,  7],

       [8,  9, 10, 11]])

arr.transpose() 或者arr.T

array([[ 0, 4,  8],

       [1,  5, 9],

       [2,  6, 10],

       [3,  7, 11]])

 

4.5 通用函数 ufunc

ufunc是一种对ndarray中的数据执行元素级运算的函数，也可以看作是简单函数（接收一个或多个标量值，并产生一个或多个标量值）的矢量化包装器

 

# 常见的一元通用函数：

# 常见的二元通用函数

a1 = np.array([[1,2,-4,8],[-3,12,-10,8]],dtype=np.int32)
np.abs(a1)
array([[ 1,  2,  4,  8],
       [ 3, 12, 10,  8]])

arr1 = np.array([10,8,14,6])
arr2 = np.array([1,2,1,3])

np.add(arr1,arr2)
np.multiply(arr1,arr2)
np.power(arr1,arr2)

 

# np.where 三元表达式

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

arr2 = np.array([2,4,6,8])

arr3 = np.array([True,False,False,True])

np.where(arr3,arr1,arr2)

其实等价于：

arr4 = zip(arr1,arr2,arr3)

result = [ x if bl else y for x,y,bl in arr4]

 

# np.unique函数

求数组中不重复的元素

 

五 数组数据文件读写

5.1 将数组以二进制的格式保存到磁盘

data =np.arange(32).reshape(2,4,4)
np.save('data',data)
np.load('data.npy')

 

5.2 存取文本文件

x = y = z = np.arange(0.0,5.0,1.0)

np.savetxt('test.out', x, delimiter=',')   # X is an array

np.savetxt('test.out', (x,y,z))   # x,y,z equal sized 1D arrays

np.savetxt('test.out', x, fmt='%1.4e')   # use exponential notation