import numpy as np
data=[1,2,3]
arr=np.array(data)	#将列表转为numpy.ndarray  np.array([2,4])
print arr       	#[1 2 3]
print data      	#[1,2,3]
print type(arr) 	#<type 'numpy.ndarray'>
print arr.dtype 	#int32

z = np.zeros((8,8),dtype=int)
arr=np.random.randn(8,4)
arr.ndim  #维度 arr.dtype.name #类型名 a.size 元素总数
arr.astype(np.float) #astype做了复制，并转换数据类型，数组本身不变，使用astype将float转换为int时小数部分被舍弃
str_arr = np.array(['1.25', '-9.6', '42'], dtype = np.string_)
float_arr = str_arr.astype(dtype = np.float)

a = np.array([4, 3, 1, 2])
j = np.argsort(a)  #[2 3 1 0]   a[j] #[1 2 3 4]  返回的是排序后的元素在之前的顺序的下标列表

#归一化，将矩阵规格化到0～1，即最小的变成0，最大的变成1，最小与最大之间的等比缩放
z = 10*np.random.random((5,5))
print z
zmin,zmax = z.min(),z.max()
z = (z-zmin)/(zmax-zmin)
print z

#生成0~10之间均匀分布的11个数，包括0和10
z = np.linspace(0,10,11,endpoint=True,retstep=True) #(array([  0.,   1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.,   9.,  10.]), 1.0)

vector = numpy.array([5, 10, 15, 20])
vector == 10  #array([False,  True, False, False], dtype=bool)

matrix = numpy.array([[5, 10, 15],[20, 25, 30],[35, 40, 45],[2,3,4]])
second_column_25 = (matrix[:,1] == 25)
print second_column_25   #[False  True False False]
print(matrix[second_column_25, :])   #[[20 25 30]]

world_alcohol = numpy.genfromtxt("world_alcohol.txt", delimiter=",")

多维转换方式一样，但是多了arr.shpe输出维数元组(2L,3L),
arr.reshape()注意几个[]嵌套   
np.zeros(n)  np.ones((3,4,5)) np.empty((4,6))

#判断二维矩阵中有没有一整列数为0？
z = np.random.randint(0,3,(2,4))  从0、1、2构成两行4列二位数组[[1 0 2 0],[0 0 2 1]]
z.any(axis=0)  #[True False  True  True]

np.random.randint(2, size=10) #array([1, 0, 0, 0, 1, 1, 0, 0, 1, 0])
np.random.randint(5, size=(2, 4)) #array([[4, 0, 2, 1],[3, 2, 2, 0]])


operation: arr*arr、arr - arr、1/arr、arr ** 0.5  #每个元素对应计算

索引：arr1[1][2]、arr2[1,2] 、arr[:2]、arr[:2, 1:]、arr[:2, 1:] = 0，
逗号两边是维度的变化，冒号两边是同一维度的起终位置
a[[0,1]] = a[[1,0]] 交换其中的两行
arr[0].copy()，复制的不随原数据的变化而变化

布尔索引：arr=[[1,2,3],[2,3,6]]
arr == 2  返回[[False True False] [True False False]] 
arr[arr == 2]  即返回[2 2]  还可以逻辑运算如 arr[-(arr == 2) |(arr == 2)]

数组索引(花式索引)：
arr=np.arange(32).reshape((8,4))
arr[[4, 3, 0, 6]] # 打印arr[4]、arr[3]、arr[0]和arr[6]
arr[[-3, -5, -7]] # 打印arr[-3]、arr[-5]和arr[-7]行
arr[[1,-5,7,2],[0,3,1,2]] #arr[1, 0]、arr[5, 3]，arr[7, 1]和arr[2, 2]
arr[[1,-5,7,2]][:,[0,3,1,2]] # 1572行的0312列
arr[np.ix_([1, 5, 7, 2], [0, 3, 1, 2])]  # 可读性更好的写法，同上

转置与点积：
arr.T 转置  np.dot(arr.T, arr)#点积

高维矩阵转换：
arr = np.arange(16).reshape((2, 2, 4))
arr数组的内容为
- a[0][0] = [0, 1, 2, 3]
- a[0][1] = [4, 5, 6, 7]
- a[1][0] = [8, 9, 10, 11]
- a[1][1] = [12, 13, 14, 15]
transpose的参数为坐标，正常顺序为(0, 1, 2, ... , n - 1)，
现在传入的为(1, 0, 2)代表a[x][y][z] = a[y][x][z]，第0个和第1个坐标互换。
- a'[0][0] = a[0][0] = [0, 1, 2, 3]
- a'[0][1] = a[1][0] = [8, 9, 10, 11]
- a'[1][0] = a[0][1] = [4, 5, 6, 7]
- a'[1][1] = a[1][1] = [12, 13, 14, 15]
print arr.transpose((1, 0, 2)) #返回变换后的数组，arr不变
print arr.swapaxes(1, 2)  # 直接交换第1和第2个坐标，arr不变

from numpy import pi   
np.linspace( 0, 2*pi, 5 )从0 到2pi分成5个数,起始确定了中间3个数，列表

NumPy的ndarray 快速的元素级数组函数
• 一元函数
类型 说明
abs, fabs 计算整数、浮点数或复数的绝对值。对于非复数值，可以使用更快的fabs。
sqrt 计算各元素的平方根。相当于arr ** 0.5
sqare 计算各元素的平方。相当于arr ** 2
exp 计算各元素的e^x
log, log10, log2, log1p 分别为自然对数、底数为10的log、底数为2的log和log(1 + x)。
sign 计算各元素的正负号：1（正数）、0（零）、－1（负数）。
ceil 计算各元素的ceiling值，即大于等于该值的最小整数。
floor 计算各元素的floor值，即小于等于该值的最小整数。
rint 将各元素值四舍五入到最接近的整数，保留dtype。
modf 将数组的小数部分与整数部分以两个独立数组的形式返还。
isnan 返回一个表示“哪些值是NaN（这不是一个数字）”的布尔型数组
isfinite, isinf 分别返回一个表示“哪些元素是有限的（非inf，非NaN）”或“哪些元素是
无穷的”的布尔型数组
cos, cosh, sin, sinh, tan, tanh 普通型或双曲型三角函数
arccos, arccosh, arcsin, arcsinh,
arctan, arctanh
反三角函数
logical_not 计算各元素not x的真值。相当于-arr。
NumPy的ndarray 快速的元素级数组函数

• 二元函数 I
类型 说明
add 将数组中对应的元素相加
subtract 从第一个数组中减去第二个数组中的元素
multiply 数组元素相乘
divide, floor_divide 除法或向下取整除法
power 对第一个数组中的元素A和第二个数组中对应位置的元素B，计算A^B。
maximum, fmax 元素级的最大值计算。fmax将忽略NaN。
minimum, fmin 元素级的最小值计算。fmin将忽略NaN。
mod 元素级的求模计算

• 例子代码: universal_functions.py
类型 说明
copysign 将第二个数组中的符号复制给第一个数组中的值
greater, greater_equal, less,
less_equal,equal, not_equal
执行元素级的比较，最终产生布尔型数组。
logical_and, logical_or,
logical_xor
执行元素级的真值逻辑运算，最终产生布尔型数组。

用数组表达式代替循环的做法，通常被称为矢量化。arange、meshgrid
矢量化数组运算要比等价的纯Python方式快上一两个数量级

np.where(cond, x_arr, y_arr)当condition为True时，返回 x ， 否则返回 y
np.abs(z-a).argmin()   z为数组，a为数，找出数组中与给定值最接近的数

利用数组进行数据处理 数学和统计方法
• 数学和统计方法
类型 说明
sum() 对数组中全部或某轴向的元素求和。零长度的数组的sum为0。
mean() 算术平均数。零长度的数组的mean为NaN。
std(), var() 分别为标准差和方差，自由度可调（默认为n）。
min(), max() 最大值和最小值
argmin() 分别为最大值和最小值的索引
cumsum() 所有元素的累计和
cumprod() 所有元素的累计积

利用数组进行数据处理 数学和统计方法
• cumsum和cumprod的解释
cumsum:
- 按列操作：a[i][j] += a[i - 1][j]
- 按行操作：a[i][j] *= a[i][j - 1]
cumprod:
- 按列操作：a[i][j] += a[i - 1][j]
- 按行操作：a[i][j] *= a[i][j - 1]
• 带axis参数的统计函数
arr.mean(axis = 1)  # 对每一行的 元素求平均
arr.sum(0)  # 对每一列元素求和，axis可以省略。

利用数组进行数据处理 用于布尔型数组的方法
• sum对True值计数 (arr > 0).sum()
• any和all测试布尔型数组，对于非布尔型数组，所有非0元素将会被当做True。
arr= np.array([False, False, True, False])
print arr.any() # 有一个为True则返回True
print arr.all() # 有一个为False则返回False

利用数组进行数据处理 排序
• 直接排序  在原数组上排序
• 指定轴排序
一维数组排序:arr.sort()
二维数组排序：arr.sort(1) # 对每一行元素做排序
找位置在5%的数字：arr.sort()   arr[int(0.05 * len(arr))]

利用数组进行数据处理 去重以及其它集合运算
• 去重以及其它集合运算
用unique函数去重
names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])
print sorted(set(names))  # 传统Python做法['Bob', 'Joe', 'Will']
print np.unique(names)     #['Bob' 'Joe' 'Will']
ints = np.array([3, 3, 3, 2, 2, 1, 1, 4, 4])
print np.unique(ints)   #[1 2 3 4]

print '查找数组元素是否在另一数组'
values = np.array([6, 0, 0, 3, 2, 5, 6])
print np.in1d(values, [2, 3, 6])    #[ True False False  True  True False  True]

unique(x) 计算x中的唯一元素，并返回有序结果。
intersect1d(x, y) 计算x和y中的公共元素，并返回有序结果。
union1d(x, y) 计算x和y的并集，并返回有序结果。
in1d(x, y) 得到一个表述"x的元素是否包含于y"的布尔型数组
setdiff1d(x, y) 集合的差，即元素在x中且不在y中
setxor1d(x, y) 集合的异或，即存在于一个数组中但不同时存在于两个数组中的元素。

数组文件的输入输出
• 将数组以二进制格式保存到磁盘
• 存取文本文件
读取csv文件做为数组  arr = np.loadtxt('array.txt', delimiter = ',') #arr 为数组
数组文件读写：np.save('some_array', arr)
print np.load('some_array.npy')

多个数组压缩存储：np.savez('array_archive.npz', a = arr, b = arr)
arch = np.load('array_archive.npz')
print arch['b']

线性代数
• 常用的numpy.linalg函数 
diag 以一维数组的形式返回方阵的对角线（或非对角线元素），获将一维数组转换
为方阵（非对角线元素为0）。
dot 矩阵乘法   #mat.dot(inv(mat)) # 与逆矩阵相乘，得到单位矩阵。
trace 计算对角线元素的和
det 计算矩阵行列式
eig 计算方阵的特征值和特征向量
inv 计算方阵的逆  #inv(mat)  # 矩阵求逆
pinv 计算矩阵的Moore-Penrose伪逆
qr 计算QR分解
svd 计算奇异值分解
solve 解线性方程Ax = b，其中A为一个方阵。
lstsq 计算Ax = b的最小二乘解

随机数生成
• 部分numpy.random函数
seed 确定随机数生成器的种子
permutation 返回一个序列的随机排列或返回一个随机排列的返回
shuffle 对一个序列就地随机乱序
rand 产生均匀分布的样本值
randint 从给定的上下限范围内随机选取整数
randn 产生正态分布（平均值为0，标准差为1）
binomial 产生二项分布的样本值
normal 产生正态（高斯）分布的样本值
beta 产生Beta分布的样本值
chisquare 产生卡方分布的样本值
gamma 产Gamma分布的样本值
uniform 产生在[0, 1]中均匀分布的样本值
正态分布随机数：np.random.normal(size=(4, 4))
批量按正态分布生成0到1的随机数：N = 10
print[normalvariate(0, 1) for _ in xrange(N)]
print np.random.normal(size = N)  # 与上面代码等价

高级应用 数组重塑
• reshape重塑数组
• -1自动推导维度大小
arr.reshape((4, 2)).reshape((2, 4)) # 支持链式操作
维度大小自动推导 arr.reshape((5, -1))
高维数组拉平变一维  arr.ravel()

高级应用 数组的合并和拆分
• 数组连接函数
类型 说明
concatenate 最一般化的连接，沿一条轴连接一组数组
vstack, row_stack 以面向行的方式对数组进行堆叠（沿轴0）
hstack, 以面向行的方式对数组进行堆叠（沿轴1）
column_stack 类似于hstack，但是会先将一维数组转换为二维列向量。
dstack 以面向“深度”的方式对数组进行堆叠（沿轴2）
split 沿指定轴在指定的位置拆分数组
hsplit, vsplit, dsplit split的便捷化函数，分别沿着轴0、轴1和轴2进行拆分

高级应用 数组的合并和拆分
np.concatenate([arr1, arr2], axis = 0)  # 按行连接 
np.concatenate([arr1, arr2], axis = 1)  # 按列连接

np.vstack((arr1, arr2)) # 垂直堆叠  同上按行
np.hstack((arr1, arr2)) # 水平堆叠  同上按列

r_用于按行堆叠  np.r_[arr1, arr2]   同上按行
c_用于按列堆叠  np.c_[arr1, arr2]   同上按列

first, second, third = np.split(arr, [1, 3], axis = 0)#水平拆分 0行一个,1、2行一个，3..行一个
first, second, third = np.split(arr, [1, 3], axis = 1)#垂直拆分

高级应用 元素的重复操作
• _tile
• _repeat
arr = np.arange(3)
arr.repeat(3)   #[0,0,0,1,1,1,2,2,2]
arr.repeat([2, 3, 4]) # 3个元素，分别复制2, 3, 4次。长度要匹配！

Repeat指定轴'
arr.repeat(2, axis = 0) # 按行repeat 每行下面再复制行
arr.repeat(2, axis = 1) # 按列repeat 每列右边再复制列

np.tile(arr, 2)     #将arr重复2次
np.tile(arr, (2, 3))  # 指定每个轴的tile次数，即行重复两次，列重复三次

高级应用 花式索引的等价函数
• take
• put
arr = np.arange(10) * 100
inds = [7, 1, 2, 6]
arr.take(inds)  =  arr[inds]  #[700 100 200 600]
使用put更新内容：
arr.put(inds, 50) #更换制定位置的数，即将上面的数都换成50
arr.put(inds, [70, 10, 20, 60])
take，指定轴：
arr = np_random.randn(2, 4)
inds = [2, 0, 2, 1]
print arr.take(inds, axis = 1)  # 按列take 拿到第2,0,2,1列的数据矩阵

例题分析 距离矩阵计算
给定m × n阶矩阵X，满足X = [x1
, x2
, ... xn]，这里第i列向量是m维向量。
求n × n矩阵，使得Dij = ||xi - xj||2

例题分析 距离矩阵计算
• 方法1：标准方法计算Dij
• D[i, j] = numpy.linalg.norm(X[:, i], X[:, j) ** 2
• 方法2：利用dot计算Dij
• d = X[:, i] - X[:, j]
• D[i, j] = numpy.dot(d, d)

例题分析 距离矩阵计算
• 方法3：减少dot调用次数
• Dij = (xi - xj)T(xi - xj) = xiTxi - 2xiTxj + xjTxj
• G = numpy.dot(X.T, X)
• Dij = Gii - 2Gij + Gjj

例题分析 距离矩阵计算
• 方法4：利用重复操作替代外部循环
• 在方法3的基础上，将D表达为H + K - 2G
• Hij = Gii, Kij = Gjj
• H = numpy.title(np.diag(G), (n, 1))
• K = HT
• D = H + HT - 2G

import numpy as np
import numpy.linalg as la
import time

X = np.array([range(0, 500), range(500, 1000)])
m, n = X.shape

t = time.time()
D = np.zeros([n, n])
for i in xrange(n):
    for j in xrange(i + 1, n):
        D[i, j] = la.norm(X[:, i] - X[:, j]) ** 2
        D[j, i] = D[i, j]
print time.time() - t

t = time.time()
D = np.zeros([n, n])
for i in xrange(n):
    for j in xrange(i + 1, n):
        d = X[:, i] - X[:, j]
        D[i, j] = np.dot(d, d)
        D[j, i] = D[i, j]
print time.time() - t

t = time.time()
G = np.dot(X.T, X)
D = np.zeros([n, n])
for i in xrange(n):
    for j in xrange(i + 1, n):
        D[i, j] = G[i, i] - G[i, j] * 2 + G[j,j]
        D[j, i] = D[i, j]
print time.time() - t

t = time.time()
G = np.dot(X.T, X)
H = np.tile(np.diag(G), (n, 1))
D = H + H.T - G * 2
print time.time() - t