spearous
4/28/2016 - 2:31 AM
python.numpy
import numpy as np
#数组形式：[[]]
[[1, 2, 3, 4], [1, 2, 3, 4]]
#创建数组
a = np.array([1, 2, 3, 4]) #创建一维数组方法一
b = np.array((5, 6, 7, 8)) #创建一维数组方法二
c = np.array([[1, 2, 3, 4], [4, 5, 6, 7], [7, 8, 9, 10]]) #创建二维数组
a.shape #数组A的形状；返回一个元组
a.dype #数组A的类型
c.shape = 4, 3 #修改数组的形状，c从（3,4）变为（4,3）
c.shape = 2, -1 #设置某个轴元素个数为-1时，将自动计算此轴的长度
d = a.reshape((2, 2)) #创建指定形状的新数组，等价于d = a.reshape(2, 2);数组a和d共享数据存储空间，修改其中一个另一个也发生改变
a[1] = 200
print d #共享存储空间~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
e = np.array([1, 2, 3, 4], dtype=np.float) #创建64bit的双精度浮点类型的数组：e = np.array([1, 2, 3, 4], dtype=float)
f = np.array([5, 6, 7, 8], dtype=np.complex) #创建128bit的双精度复数类型：f = np.array([5, 6, 7, 8], dtype=complex)
g = np. array([4, 5, 6, 7], dtype=np.int) #创建32bit的长整型数组：g = np. array([4, 5, 6, 7], dtype=np.int)
h = np.arange(0, 10, 1) #开始值，终值，步长的等差数列的一维数组；不包含终值
i = np.linspace(0, 9, 10) #开始值，终值，元素个数的等差数列的一维数组；默认包含终值
i = np.linspace(0, 9, 10, endpoint=False) #不包含终值
j = np.logspace(0, 2, 5) #开始值0表示10的0次方，终值2表示10的2次方；5表示元素个数
j = np.logspace(0, 11, 12, base=2) #基数默认值为10,；base=2进行修改；默认包含终值即endpoint=True
np.empty((2, 3), np.int) #只分配内存，不对其进行初始化，所以a=np.empty((2, 3), np.int)是错误的
k = np.zeros(4, np.float) #数组元素初始化为0；元素类型默认为np.float；同理 np.ones()
l = np.zeros_like(a) #创建与参数数组a的形状以及类型相同的数组；等价于 l = np.zeros(a.shape, a.dtype)；同理 np.ones_like()
m = 'wangshuaiyu'
n = np.fromstring(m, dtype=np.int8) #字符串实际是一个字节序列，每个字符占一个字节;fromstring得到的数组是每个字符的ASCII编码
n = np.fromstring(m, dtype=np.int16) #如果创建16int的整数数组，则相邻的字节表示一个整数
def func(i):
return i%4+1
o = np.fromfunction(func, (10, )) #第一参数为计算每个数组元素的函数，第二参数指定数组的形状；第二个参数必须是一个序列；此例第二个参数是长度为1的元祖（10，）
def func2(i, j):
return (i+1)*(j+1)
p = np.fromfunction(func2, (9, 9)) #i and j 初始值为0；a[i, j] = func(i, j)
#一维数组---下标1-6
a = np.arange(10) #等价于a = np.arange(0, 10, 1)，不包含终值。。。。。。。。。。。。
a[5] #整数下标1
a[3:5] #切片下标2
a[:5] #从第一个开始
a[:-1] #除了最后一个
a[::-1] #倒序
a[2:4] = 100, 101 #下标可以用来修改元素的值
b = a[3:7] #与列表不同的是，通过切片获取的新数组是原始数组的一个视图，它与原始数组共享同一块存储空间~~~~~~~~
a = np.arange(10, 1, -1)
#x[[]]：整数列表下标3：将使用列表中的每个元素作为下标
b = a[[3, 3, 1, 8]] #使用列表作为下标得到的数组不和原始数组共享数据~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
a[[3, 5, 1]] = -1, -2, -3 #整数列表下标也可以用来修改元素的值
#x[np.array([])]：整数数组下标4：将得到一个形状和下标数组相同的新数组
c = a[np.array([3, 3, 1, 8])] #整数数组下标为一维时
d = a[np.array([[3, 3, 1, 8], [3, 3, -3, 8]])] #整数数组下标为二维时
#x[[True, False]]：布尔列表下标5：TRUE=1, FALSE=0
a = np.arange(5, 0, -1) #不包含终值的。。。。。。。。。。。。。。。。。。。。。。。。
e = a[[True, False, True, False, True]] #等价于e = a[[1, 0, 1, 0, 1]]
#x[np.array([True, False])]：布尔数组下标6：布尔数组长度不够时，不够的部分都当作false
f = a[np.array([True, False, True, True])] #等价于 f = a[[0, 2, 3]]
#布尔数组下标：gan jue hao shi yong de yang zi
x = np.random.rand(10) #长度为10，元素值为0-1的随机数组
x > 0.5 #返回布尔数组：数组x中的每个元素和0.5进行大小比较，得到一个布尔数组，True表示x中对应的值大于0.5
x[x > 0.5] #返回满足条件的数组：利用布尔数组下标得到数组x中大于0.5的元素的数组
#多维数组：numpy采用元祖作为数组的下标，元祖中的每个元素和数组的每个轴对应
#创建多维数组
a = np.arange(0, 60, 10).reshape(-1, 1) + np.arange(0, 6)
b = a[0, 3:5] #数组b是a的视图，共享数据，修改b中元素数组a中对应元素也被修改~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#多维数组--元祖下标7：a[1, 2] eq：a[(1, 2)]，都是使用（1,2）作为数组a的下标
a[1, 2] #整数，整数：ne：a[1:2,2:3]：eq：a[(1,),(2,)]
a[4:, 4:] #切片，切片
a[(0, 1, 2, 3), (1, 2, 3, 4)] #元祖，元祖：eq：a[0,1] a[1,2] a[2,3] a[3,4]
a[0, 3:5] #整数，切片
a[:, 2] #切片，整数：eq: a[:,(2)]
a[3:, [0, 2, 5]] #切片，列表
a[[0, 2, 5], 3:] #列表，切片
a[:, (2,)] #切片，元祖
a[(2,), :] #元祖，切片
a[1:2] #切片：result：[[10 11 12 13 14 15]]
a[1:2, ] #同上
a[1] #整数：result：[10 11 12 13 14 15]
a[1, ] #同上
a[[1]] #列表：result：[[10 11 12 13 14 15]]
a[[1], ] #同上
mask = np.array([1, 0, 1, 0, 0, 1], dtype=np.bool)
a[mask, 2] #布尔
#规则一：当下标的长度小于数组的维数时，则剩余的各轴所对应的下标为“：”，即选取它们的所有数据
a[[1,2]] eq. a[[1,2], :]
#规则二：多维数组--整数数组下标8：当所有轴都用形状相同整数数组作为下标时，得到的数组和下标数组的维数相同
import numpy as np
a = np.array([1, 2, 3, 4])
b =[1, 2, 3, 4]
c = np.array([[1, 2], [3, 4]])
print a #一维整数数组
print b #整数列表
print c #二维整数数组
x = np.array([[0, 1], [2, 3]])
y = np.array([[-1, -2], [-3, -4]])
print a[x, y]
print a[(0, 1, 2, 3), (-1, -2, -3, -4)].reshape(2, 2)
[[ 5 14]
[23 32]]
[[ 5 14]
[23 32]]
#an example0
#整数数组例子
palette = np.array([[0, 0, 0], [255, 0, 0], [0, 255, 0], [0, 0, 255], [255, 255, 255]]) #调色板数组
image = np.array([[0, 1, 2, 0], [0, 3, 4, 0]]) #图像数组
print palette[image]
[[[ 0 0 0]
[255 0 0]
[ 0 255 0]
[ 0 0 0]]
[[ 0 0 0]
[ 0 0 255]
[255 255 255]
[ 0 0 0]]]
#an example1
import numpy as np
a = np.arange(0, 60, 10).reshape(-1, 1) + np.arange(0, 6)
print a[1]
print a[1, ]
print a[1, 1]
print a[1, (1)]
print a[1, (1,)]
print a[1, [1]]
print a[1, 1:2]
print a[[1]] #print a[[0, 1, 3, 2]]
print a[[1], ]
print a[[1], [1]] #print a[idx] 其中 idx=np.array([[0, 1, 3, 2], [0, 2, 1, 0]])
print a[[1], 1]
print a[[1], (1)]
print a[[1], (1,)]
print a[[1], 1:2]
print a[(1,)]
print a[(1,), ]
print a[(1,), (1,)]
print a[(1,), 1]
print a[(1,), (1)]
print a[(1,), [1]]
print a[(1,), 1:2]
print a[1:2]
print a[1:2, ]
print a[1:2, 1:2]
print a[1:2, 1]
print a[1:2, (1)]
print a[1:2, (1,)]
print a[1:2, [1]]
result:
[10 11 12 13 14 15]
[10 11 12 13 14 15]
11
11
[11]
[11]
[11]
[[10 11 12 13 14 15]]
[[10 11 12 13 14 15]]
[11]
[11]
[11]
[11]
[[11]]
[10 11 12 13 14 15]
[[10 11 12 13 14 15]]
[11]
[11]
[11]
[11]
[[11]]
[[10 11 12 13 14 15]]
[[10 11 12 13 14 15]]
[[11]]
[11]
[11]
[[11]]
[[11]]
#an example2
import numpy as np
a = np.arange(0, 60, 10).reshape(-1, 1) + np.arange(0, 6)
print a[:, 2]
print a[:, (2,)]
result:
[ 2 12 22 32 42 52]
[[ 2]
[12]
[22]
[32]
[42]
[52]]
#an example3
idx = slice(None, None, 2), slice(2, None) #将下标元祖保存起来用同一个元祖存取多个数组
a[idx] #等价于a[::2, 2:]
a[idx][idx] #等价于a[::2,2:][::2,2:]
idx = np.s_[::2, 2:] #创建数组下标
#自己定义s_类
class S(object):
def __getitem__(self, index):
return index
print S()[::2, 2:]
#
#结构数组
persontype = np.dtype({
'names':['name', 'age', 'weight'],
'formats':['S32', 'i', 'f']
}, align=True)
a = np.array([("zhang", 32, 75.5), ("wang", 24, 65.2)], dtype=persontype)
print a
#temp
1.建立矩阵
a1=np.array([1,2,3],dtype=int) #建立一个一维数组，数据类型是int。也可以不指定数据类型，使用默认。几乎所有的数组建立函数都可以指定数据类型，即dtype的取值。
a2=np.array([[1,2,3],[2,3,4]]) #建立一个二维数组。此处和MATLAB的二维数组（矩阵）的建立有很大差别。
同样，numpy中也有很多内置的特殊矩阵：
b1=np.zeros((2,3)) #生成一个2行3列的全0矩阵。注意，参数是一个tuple：(2,3)，所以有两个括号。完整的形式为：zeros(shape,dtype=)。相同的结构，有ones()建立全1矩阵。empty()建立一个空矩阵，使用内存中的随机值来填充这个矩阵。
b2=identity(n) #建立n*n的单位阵，这只能是一个方阵。
b3=eye(N,M=None,k=0) #建立一个对角线是1其余值为0的矩阵，用k指定对角线的位置。M默认None。
此外，numpy中还提供了几个like函数，即按照某一个已知的数组的规模（几行几列）建立同样规模的特殊数组。这样的函数有zeros_like()、empty_like()、ones_like()，它们的参数均为如此形式：zeros_like(a,dtype=)，其中，a是一个已知的数组。
c1=np.arange(2,3,0.1) #起点，终点，步长值。含起点值，不含终点值。
c2=np.linspace(1,4,10) #起点，终点，区间内点数。起点终点均包括在内。同理，有logspace()函数
d1=np.linalg.companion(a) #伴随矩阵
d2=np.linalg.triu()/tril() #作用同MATLAB中的同名函数
e1=np.random.rand(3,2) #产生一个3行2列的随机数组。同一空间下，有randn()/randint()等多个随机函数
fliplr()/flipud()/rot90() #功能类似MATLAB同名函数。
xx=np.roll(x,2) #roll()是循环移位函数。此调用表示向右循环移动2位。
2.数组的特征信息
先假设已经存在一个N维数组X了，那么可以得到X的一些属性，这些属性可以在输入X和一个.之后，按tab键查看提示。这里明显看到了Python面向对象的特征。
X.flags #数组的存储情况信息。
X.shape #结果是一个tuple，返回本数组的行数、列数、……
X.ndim #数组的维数，结果是一个数
X.size #数组中元素的数量
X.itemsize #数组中的数据项的所占内存空间大小
X.dtype #数据类型
X.T #如果X是矩阵，发挥的是X的转置矩阵
X.trace() #计算X的迹
np.linalg.det(a) #返回的是矩阵a的行列式
np.linalg.norm(a,ord=None) #计算矩阵a的范数
np.linalg.eig(a) #矩阵a的特征值和特征向量
np.linalg.cond(a,p=None) #矩阵a的条件数
np.linalg.inv(a) #矩阵a的逆矩阵
3.矩阵分解
常见的矩阵分解函数，numpy.linalg均已经提供。比如cholesky()/qr()/svd()/lu()/schur()等。某些算法为了方便计算或者针对不同的特殊情况，还给出了多种调用形式，以便得到最佳结果。
4.矩阵运算
np.dot(a,b)用来计算数组的点积；vdot(a,b)专门计算矢量的点积，和dot()的区别在于对complex数据类型的处理不一样；innner(a,b)用来计算内积；outer(a,b)计算外积。
专门处理矩阵的数学函数在numpy的子包linalg中定义。比如np.linalg.logm(A)计算矩阵A的对数。可见，这个处理和MATLAB是类似的，使用一个m后缀表示是矩阵的运算。在这个空间内可以使用的有cosm()/sinm()/signm()/sqrtm()等。其中常规exp()对应有三种矩阵形式：expm()使用Pade近似算法、expm2()使用特征值分析算法、expm3()使用泰勒级数算法。在numpy中，也有一个计算矩阵的函数：funm(A,func)。
5.索引
numpy中的数组索引形式和Python是一致的。如：
x=np.arange(10)
print x[2] #单个元素，从前往后正向索引。注意下标是从0开始的。
print x[-2] #从后往前索引。最后一个元素的下标是-1
print x[2:5] #多个元素，左闭右开，默认步长值是1
print x[:-7] #多个元素，从后向前，制定了结束的位置，使用默认步长值
print x[1:7:2] #指定步长值
x.shape=(2,5) #x的shape属性被重新赋值，要求就是元素个数不变。2*5=10
print x[1,3] #二维数组索引单个元素，第2行第4列的那个元素
print x[0] #第一行所有的元素
y=np.arange(35).reshape(5,7) #reshape()函数用于改变数组的维度
print y[1:5:2,::2] #选择二维数组中的某些符合条件的元素
#fuck the world
import numpy as np
#1
a = np.array([(1, 2, 3, 4), (1, 2, 3, 4)])
print a
b = np.array([[1, 2, 3, 4], [1, 2, 3, 4]])
print b
#2