int8, uint8 - i1, u1 有／无符号的8位整型
int16, uint16 - i2, u2 有／无符号的16位整型
int32, uint32 - i4, u4 有／无符号的32位整型
int64, uint64 - i8, u8 有／无符号的64位整型
float16 - f2 半精度浮点数
float32 - f4 or f 标准的单精度浮点数，与C的float兼容。
float64 - f8 or d 标准的双精度浮点数。与C的double和Python的float兼容。
float128 - f16 or g 扩展精度浮点数
complex64/128/256 -c8/16/32 分别用两个32位，64位或128位浮点数表示的复数。
bool - ? 存储True和False值的布尔类型
object - O Python对象类型
string_ - S 固定长度的字符串类型。S10代表长度为10的字符串。
unicode_ - U 固定长度的unicode类型
# -*- coding: utf-8 -*-
# python2.7
import numpy as np
print '使用普通一维数组生成NumPy一维数组'
data = [6, 7.5, 8, 0, 1]
arr = np.array(data)
print arr
print '打印元素类型'
print arr.dtype
print
print '使用普通二维数组生成NumPy二维数组'
data = [[1, 2, 3, 4], [5, 6, 7, 8]]
arr = np.array(data)
print arr
print '打印数组维度'
print arr.shape
print
print '使用zeros/empty'
print np.zeros(10) # 生成包含10个0的一维数组
print np.zeros((3, 6)) # 生成3*6的二维数组
print np.empty((2, 3, 2)) # 生成2*3*2的三维数组，所有元素未初始化。
print
print '使用arrange生成连续元素'
print np.arange(15) # [0, 1, 2, ..., 14]
# -*- coding: utf-8 -*-
import numpy as np
print '生成数组时指定数据类型'
arr = np.array([1, 2, 3], dtype = np.float64)
print arr.dtype
arr = np.array([1, 2, 3], dtype = np.int32)
print arr.dtype
print
print '使用astype复制数组并转换数据类型'
int_arr = np.array([1, 2, 3, 4, 5])
float_arr = int_arr.astype(np.float)
print int_arr.dtype
print float_arr.dtype
print
print '使用astype将float转换为int时小数部分被舍弃'
float_arr = np.array([3.7, -1.2, -2.6, 0.5, 12.9, 10.1])
int_arr = float_arr.astype(dtype = np.int)
print int_arr
print
print '使用astype把字符串转换为数组，如果失败抛出异常。'
str_arr = np.array(['1.25', '-9.6', '42'], dtype = np.string_)
float_arr = str_arr.astype(dtype = np.float)
print float_arr
print
print 'astype使用其它数组的数据类型作为参数'
int_arr = np.arange(10)
float_arr = np.array([.23, 0.270, .357, 0.44, 0.5], dtype = np.float64)
print int_arr.astype(float_arr.dtype)
print int_arr[0], int_arr[1] # astype做了复制，数组本身不变。
- ndarry 标量之间的计算
• 不用编写循环即可对数据执行批量运算
• 大小相等的数组之间的任何算术运算都会将运算应用到元素级
• 数组与标量的算术运算也会将那个标量值传播到各个元素
# -*- coding: utf-8 -*-
import numpy as np
# 数组乘法／减法，对应元素相乘／相减。
arr = np.array([[1.0, 2.0, 3.0], [4., 5., 6.]])
print arr * arr
print arr - arr
print
# 标量操作作用在数组的每个元素上
arr = np.array([[1.0, 2.0, 3.0], [4., 5., 6.]])
print 1 / arr
print arr ** 0.5 # 开根号
# -*- coding: utf-8 -*-
import numpy as np
# 通过索引访问二维数组某一行或某个元素
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print arr[2]
print arr[0][2]
print arr[0, 2] # 普通Python数组不能用。一个逗号就是一个维度的操作
print
# 对更高维数组的访问和操作
arr = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
print arr[0] # 结果是个2维数组
print arr[1, 0] # 结果是个1维数组
old_values = arr[0].copy() # 复制arr[0]的值
arr[0] = 42 # 把arr[0]所有的元素都设置为同一个值
print arr
arr[0] = old_values # 把原来的数组写回去
print arr
print
print '使用切片访问和操作数组'
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print arr[1:6] # 打印元素arr[1]到arr[5]
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print arr[:2] # 打印第1、2行
print arr[:2, 1:] # 打印第1、2行，第2、3列
print arr[:, :1] # 打印第一列的所有元素
arr[:2, 1:] = 0 # 第1、2行，第2、3列的元素设置为0
print arr
- NumPy的ndarray 布尔型索引
• 布尔型数组的长度必须跟被索引的轴长度一致。
• 可以将布尔型数组跟切片、整数（或整数序列）混合使用
# -*- coding: utf-8 -*-
import numpy as np
import numpy.random as np_random
print '使用布尔数组作为索引'
name_arr = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])
rnd_arr = np_random.randn(7, 4) # 随机7*4数组
print rnd_arr
print name_arr == 'Bob' # 返回布尔数组，元素等于'Bob'为True，否则False。
print rnd_arr[name_arr == 'Bob'] # 利用布尔数组选择行
print rnd_arr[name_arr == 'Bob', :2] # 增加限制打印列的范围
print rnd_arr[~(name_arr == 'Bob')] # 对布尔数组的内容取反
mask_arr = (name_arr == 'Bob') | (name_arr == 'Will') # 逻辑运算混合结果
print rnd_arr[mask_arr]
rnd_arr[name_arr != 'Joe'] = 7 # 先布尔数组选择行，然后把每行的元素设置为7。
print rnd_arr
- 花式索引
• 花式索引（Fancy indexing）是一个NumPy术语，它指的是利用整数数组进
行索引。
• 一次传入多个索引数组会有一点特别。它返回的是一个一维数组，其中的元素
对应各个索引元组。
# -*- coding: utf-8 -*-
import numpy as np
print 'Fancy Indexing: 使用整数数组作为索引'
arr = np.empty((8, 4))
for i in range(8):
arr[i] = i
print arr
print arr[[4, 3, 0, 6]] # 打印arr[4]、arr[3]、arr[0]和arr[6]。
print arr[[-3, -5, -7]] # 打印arr[3]、arr[5]和arr[-7]行
arr = np.arange(32).reshape((8, 4)) # 通过reshape变换成二维数组
print arr[[1, 5, 7, 2], [0, 3, 1, 2]] # 打印arr[1, 0]、arr[5, 3]，arr[7, 1]和arr[2, 2]
print arr[[1, 5, 7, 2]][:, [0, 3, 1, 2]] # 1572行的0312列
print arr[np.ix_([1, 5, 7, 2], [0, 3, 1, 2])] # 可读性更好的写法
- NumPy的ndarray 数组转置和轴对换
• 一维／二维数组转置
• 高维数组轴对换
# -*- coding: utf-8 -*-
import numpy as np
import numpy.random as np_random
print '转置矩阵'
arr = np.arange(15).reshape((3, 5))
print arr
# 设A为m×n阶矩阵（即m行n列），第i 行j 列的元素是a(i,j)，即：A=a(i,j)
# 定义A的转置为这样一个n×m阶矩阵B，满足B=a(j,i)，即 b (i,j)=a (j,i)
# B的第i行第# j列元素是A的第j行第i列元素），记A'=B，装置之后shape可以从后
# 往前读，如，arr的shape为3,5,2,4,arr.T之后shape为4,2,3,5
print arr.T # 把矩阵 A 的行换成同序数的列得到的矩阵,叫做 A 的转置矩阵
print
# 矩阵的点积：
# 两个向量a = [a1, a2,…, an]和b = [b1, b2,…, bn]的点积定义为：
# a·b=a1b1+a2b2+……+anbn。
# 使用[矩阵乘法]并把（纵列）向量当作n×1 [矩阵]，点积还可以写为：
# a·b=a^T*b，这里的a^T指示[矩阵]a的[转置]。
print '转置矩阵做点积'
arr = np_random.randn(6, 3)
print np.dot(arr.T, arr)
print
print '高维矩阵转换'
arr = np.arange(16).reshape((2, 2, 4))
print arr
'''
详细解释：
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]
- 这是个三维数组，三个轴，0,1,2，
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]
arr.transpose((1,0,2))的1,0,2三个数分别代表shape()的三个数的顺序，初始的
shape是（2,2,4），也就是2维的2 x 4矩阵，索引分别是shape的[0],[1],[2]，
arr.transpose((1,0,2))之后，我们的索引就变成了shape[1][0][2],对应shape值是
shape(2,2,4)，所以矩阵形状不变。
与此同时，我们矩阵的索引也发生了类似变化，如arr中的4，索引是arr[0,1,0],arr中
的5是arr[0,1,1]，变成arr2后，4的位置应该是在[1,0,0]，5的位置变成[1,0,1]，同理8
的索引从[1,0,0]变成[0,1,0]。
'''
print arr.transpose((1, 0, 2))
'''
# 转置与交换坐标差不多，都是关于shape以及下标的转换，记住是两种同时转
# arr的shape为（2,2,4），swapaxes（1,2）之后shape变为（2,4,2）
# 同时坐标值的变化也是一样的，比如arr[0][1][2],转换之后它的值就为原始
# 数组的a[0][2][1],交换第一个和第二个坐标
'''
print arr.swapaxes(1, 2) # 直接交换第1和第2个坐标
- ndarray 快速的元素级数组函数
- 一元函数（操作单个ndarry）
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
- 二元函数（操作2个ndarry）
add :将数组中对应的元素相加
subtract: 从第一个数组中减去第二个数组中的元素
multiply: 数组元素相乘
divide, floor_divide: 除法或向下取整除法
power: 对第一个数组中的元素A和第二个数组中对应位置的元素B，计算A^B。
maximum, fmax: 元素级的最大值计算。fmax将忽略NaN。
minimum, fmin: 元素级的最小值计算。fmin将忽略NaN。
mod: 元素级的求模计算
copysign: 将第二个数组中的符号复制给第一个数组中的值
greater, greater_equal, less,less_equal,equal, not_equal:执行元素级的比较，最终产生布尔型数组。
logical_and, logical_or,logical_xor:执行元素级的真值逻辑运算，最终产生布尔型数组。
# -*- coding: utf-8 -*-
import numpy as np
import numpy.random as np_random
print '求平方根'
arr = np.arange(10)
print np.sqrt(arr)
print
print '数组比较'
x = np_random.randn(8)
y = np_random.randn(8)
print x
print y
print np.maximum(x, y)
print
print '使用modf函数把浮点数分解成整数和小数部分'
arr = np_random.randn(7) * 5 # 统一乘5
print np.modf(arr)
# -*- coding: utf-8 -*-
import matplotlib.pyplot as plt
import numpy as np
import pylab
points = np.arange(-5, 5, 0.01) # 生成100个点
xs, ys = np.meshgrid(points, points) # xs, ys互为转置矩阵
print xs
print ys
z = np.sqrt(xs ** 2 + ys ** 2)
print z
# 画图
plt.imshow(z, cmap = plt.cm.gray);
plt.colorbar()
plt.title("Image plot of $\sqrt{x^2 + y^2}$ for a grid of values")
pylab.show()
- 利用ndarry进行数据处理 将条件逻辑表述为数组运算
# -*- coding: utf-8 -*-
import numpy as np
import numpy.random as np_random
'''
关于zip函数的一点解释，zip可以接受任意多参数，然后重新组合成1个tuple列表。
zip([1, 2, 3], [4, 5, 6], [7, 8, 9])
返回结果：[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
'''
print '通过真值表选择元素'
x_arr = np.array([1.1, 1.2, 1.3, 1.4, 1.5])
y_arr = np.array([2.1, 2.2, 2.3, 2.4, 2.5])
cond = np.array([True, False, True, True, False])
result = [(x if c else y) for x, y, c in zip(x_arr, y_arr, cond)] # 通过列表推到实现
print result
print np.where(cond, x_arr, y_arr) # 使用NumPy的where函数
print
print '更多where的例子'
arr = np_random.randn(4, 4)
print arr
print np.where(arr > 0, 2, -2)
print np.where(arr > 0, 2, arr)
print
print 'where嵌套'
cond_1 = np.array([True, False, True, True, False])
cond_2 = np.array([False, True, False, True, False])
# 传统代码如下
result = []
for i in xrange(len(cond)):
if cond_1[i] and cond_2[i]:
result.append(0)
elif cond_1[i]:
result.append(1)
elif cond_2[i]:
result.append(2)
else:
result.append(3)
print result
# np版本代码
result = np.where(cond_1 & cond_2, 0, np.where(cond_1, 1, np.where(cond_2, 2, 3)))
print result
- 利用ndarry进行数据处理 数学和统计方法
sum 对数组中全部或某轴向的元素求和。零长度的数组的sum为0。
mean 算术平均数。零长度的数组的mean为NaN。
std, var 分别为标准差和方差，自由度可调（默认为n）。
min, max 最大值和最小值
argmin 分别为最大值和最小值的索引
cumsum 所有元素的累计和
cumprod 所有元素的累计积
# -*- coding: utf-8 -*-
import numpy as np
import numpy.random as np_random
print '求和，求平均'
arr = np.random.randn(5, 4)
print arr
print arr.mean()
print arr.sum()
print arr.mean(axis = 1) # 对每一行的元素求平均
print arr.sum(0) # 对每一列元素求和，axis可以省略。
print
'''
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]
'''
print 'cunsum和cumprod函数演示'
arr = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
print arr.cumsum(0)
print arr.cumprod(1)
几乎所有的数学统计方法都有一个axis参数，轴的概念，拿sum参数来解释
data = [[[2,4],[1,0]],[[3,4],[4,3]],[[3,4],[2,4]]]
X = np.array(data).reshape(3,2,2),shape为(3,2,2)
X的值为：
[[[2 4]
[1 0]]
[[3 4]
[4 3]]
[[3 4]
[2 4]]]
sum(axis=0)的值为：
[[ 8 12]
[ 7 7]]
sum(axis=2)的值为：
[[6 1]
[7 7]
[7 6]]
设axis=i，则numpy沿着第i个下标变化的方向进行操作,从0开始。
求sum(axis=0):
根据X.shape可以知道第一轴的shape为3，第一个轴的下标最大值为2，
第二轴shape为2，第二轴的最大值为1
最后一个轴的shape为2，最后一轴的最大值为1
第一个轴变化已固定，a[0][][],a[1][][],a[2][][],剩下2轴的变化，都是2个元素，
所以结果是2*2个结果
第一个元素值=a[0][0][0]+a[1][0][0]+a[2][0][0]=2+3+3=8
第二个元素值=a[0][0][1]+a[1][0][1]+a[2][0][1]=4+4+4=12
第三个元素值=a[0][1][0]+a[1][1][0]+a[2][1][0]=1+4+2=7
第四个元素值=a[0][1][1]+a[1][1][1]+a[2][1][1]=0+3+4=7
求sum(axis=2)：
第3个轴变化已固定，a[][][0],a[][][1],a[][][2],剩下2轴的变化，2*3就是6个结果
a[0][0][0]+a[0][0][1]=2+4=6
a[0][1][0]+a[0][1][1]=1+0=1
a[1][0][0]+a[1][0][1]=3+4=7
a[1][1][0]+a[1][1][1]=4+3=7
a[2][0][0]+a[2][0][1]=3+4=7
a[2][1][0]+a[2][1][1]=2+4=6
个人认为，如果没有理解axis的真正含义，很难熟悉的运用numpy进行数据处理
对axis总结为一句话：
设axis=i，则numpy沿着第i个下标变化的方向进行操作,从0开始。
- 使用ndarry进行数据处理 用于bool数组的方法
• sum对True值计数
• any和all测试布尔型数组，对于非布尔型数组，所有非0元素将会被当做True。
# -*- coding: utf-8 -*-
import numpy as np
import numpy.random as np_random
print '对正数求和'
arr = np_random.randn(100)
print (arr > 0).sum() # 为true的元素的个数
print
print '对数组逻辑操作'
bools = np.array([False, False, True, False])
print bools.any() # 有一个为True则返回True
print bools.all() # 有一个为False则返回False
# -*- coding: utf-8 -*-
import numpy as np
import numpy.random as np_random
print '一维数组排序'
arr = np_random.randn(8)
arr.sort()
print arr
print
print '二维数组排序'
arr = np_random.randn(5, 3)
print arr
arr.sort(1) # 对每一行元素做排序
print arr
print '找位置在5%的数字'
large_arr = np_random.randn(1000)
large_arr.sort()
print large_arr[int(0.05 * len(large_arr))]
- 使用ndarry进行数据处理 去重以及其它集合运算
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) 集合的异或，即存在于一个数组中但不同时存在于两个数组中的元素。即(X+Y)-XY并集
# -*- coding: utf-8 -*-
import numpy as np
import numpy.random as np_random
print '用unique函数去重'
names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])
print sorted(set(names)) # 传统Python做法
print np.unique(names)
ints = np.array([3, 3, 3, 2, 2, 1, 1, 4, 4])
print np.unique(ints)
print
print '查找数组元素是否在另一数组'
values = np.array([6, 0, 0, 3, 2, 5, 6])
print np.in1d(values, [2, 3, 6])
- ndarry的输入输出
• 将数组以二进制格式保存到磁盘
• 存取文本文件
# -*- coding: utf-8 -*-
import numpy as np
print '读取csv文件做为数组'
arr = np.loadtxt('array_ex.txt', delimiter = ',')
print arr
print
print '数组文件读写'
arr = np.arange(10)
np.save('some_array', arr)
print np.load('some_array.npy')
print
print '多个数组压缩存储'
np.savez('array_archive.npz', a = arr, b = arr)
arch = np.load('array_archive.npz')
print arch['b']
- 线性代数
- 常用的numpy.linalg函数
diag 以一维数组的形式返回方阵的对角线（或非对角线元素），获将一维数组转换
为方阵（非对角线元素为0）。
dot 矩阵乘法
trace 计算对角线元素的和
det 计算矩阵行列式
eig 计算方阵的特征值和特征向量
inv 计算方阵的逆
pinv 计算矩阵的Moore-Penrose伪逆
qr 计算QR分解
svd 计算奇异值分解
solve 解线性方程Ax = b，其中A为一个方阵。
lstsq 计算Ax = b的最小二乘解
- 矩阵运算参考
# -*- coding: utf-8 -*-
import numpy as np
import numpy.random as np_random
from numpy.linalg import inv, qr
print '矩阵乘法'
'''
- 当矩阵A的列数等于矩阵B的行数时，A与B可以相乘。
- 矩阵C的行数等于矩阵A的行数，C的列数等于B的列数。
- 乘积C的第m行第n列的元素等于矩阵A的第m行的元素与矩阵B的第n列对应元素乘积之和。
'''
x = np.array([[1., 2., 3.], [4., 5., 6.]])
y = np.array([[6., 23.], [-1, 7], [8, 9]])
print x.dot(y)
print np.dot(x, np.ones(3))
x = np_random.randn(5, 5)
print
print '矩阵求逆'
mat = x.T.dot(x)
print inv(mat) # 矩阵求逆
print mat.dot(inv(mat)) # 与逆矩阵相乘，得到单位矩阵。
print
print '矩阵消元'
print mat
q, r = qr(mat)
print q
print r
# TODO: http://docs.scipy.org/doc/numpy/reference/generated/numpy.linalg.qr.html q代表什么矩阵？
- 随机数的生成
seed 确定随机数生成器的种子
permutation 返回一个序列的随机排列或返回一个随机排列的返回
shuffle 对一个序列就地随机乱序
rand 产生均匀分布的样本值
randint 从给定的上下限范围内随机选取整数
randn 产生正态分布（平均值为0，标准差为1）
binomial 产生二项分布的样本值
normal 产生正态（高斯）分布的样本值
beta 产生Beta分布的样本值
chisquare 产生卡方分布的样本值
gamma 产Gamma分布的样本值
uniform 产生在[0, 1]中均匀分布的样本值
# -*- coding: utf-8 -*-
import numpy as np
import numpy.random as np_random
from random import normalvariate
print '正态分布随机数'
samples = np.random.normal(size=(4, 4))
print samples
print '批量按正态分布生成0到1的随机数'
N = 10
print [normalvariate(0, 1) for _ in xrange(N)]
print np.random.normal(size = N) # 与上面代码等价
- 高级应用 数组重塑
• reshape重塑数组
• -1自动推导维度大小
# -*- coding: utf-8 -*-
import numpy as np
print "将一维数组转换为二维数组"
arr = np.arange(8)
print arr.reshape((4, 2))
print arr.reshape((4, 2)).reshape((2, 4)) # 支持链式操作
print
print "维度大小自动推导"
arr = np.arange(15)
print arr.reshape((5, -1))
print
print "获取维度信息并应用"
other_arr = np.ones((3, 5))
print other_arr.shape
print arr.reshape(other_arr.shape)
print
print "高维数组拉平"
arr = np.arange(15).reshape((5, 3))
print arr.ravel()
- 高级应用 数组的拆分和合并
concatenate 最一般化的连接，沿一条轴连接一组数组
vstack, row_stack 以面向行的方式对数组进行堆叠（沿轴0）
hstack, 以面向行的方式对数组进行堆叠（沿轴1）
column_stack 类似于hstack，但是会先将一维数组转换为二维列向量。
dstack 以面向“深度”的方式对数组进行堆叠（沿轴2）
split 沿指定轴在指定的位置拆分数组
hsplit, vsplit, dsplit split的便捷化函数，分别沿着轴0、轴1和轴2进行拆分。
• _r对象
• _c对象
# -*- coding: utf-8 -*-
import numpy as np
import numpy.random as np_random
print '连接两个二维数组'
arr1 = np.array([[1, 2, 3], [4, 5, 6]])
arr2 = np.array([[7, 8, 9], [10, 11, 12]])
print arr1.shape
print np.concatenate([arr1, arr2], axis = 0) # 按行连接
print np.concatenate([arr1, arr2], axis = 1) # 按列连接
print
# 所谓堆叠，参考叠盘子。。。连接的另一种表述
print '垂直stack与水平stack'
print np.vstack((arr1, arr2)) # 垂直堆叠
print np.hstack((arr1, arr2)) # 水平堆叠
print
print '拆分数组'
arr = np_random.randn(5, 5)
print arr
print '水平拆分'
first, second, third = np.split(arr, [1, 3], axis = 0)
print 'first'
print first
print 'second'
print second
print 'third'
print third
print '垂直拆分'
first, second, third = np.split(arr, [1, 3], axis = 1)
print 'first'
print first
print 'second'
print second
print 'third'
print third
print
# 堆叠辅助类
arr = np.arange(6)
arr1 = arr.reshape((3, 2))
arr2 = np_random.randn(3, 2)
print 'r_用于按行堆叠'
print np.r_[arr1, arr2]
print 'c_用于按列堆叠'
print np.c_[np.r_[arr1, arr2], arr]
print '切片直接转为数组'
print np.c_[1:6, -10:-5]
- 高级应用 元素的重复操作
• _tile
• _repeat
# -*- coding: utf-8 -*-
import numpy as np
import numpy.random as np_random
print 'Repeat: 按元素,元素级别的'
arr = np.arange(3)
print arr.repeat(3)
print arr.repeat([2, 3, 4]) # 3个元素，分别复制2, 3, 4次。参数元素个数和数组元素个数要匹配！
print
print 'Repeat，指定轴'
arr = np_random.randn(2, 2)
print arr
print arr.repeat(2, axis = 0) # 按行repeat
print arr.repeat(2, axis = 1) # 按列repeat
print arr.repeat(2, axis = 0) # 按行repeat
print
print 'Tile: 参考贴瓷砖，数组级别的'
print np.tile(arr, 2)
print np.tile(arr, (2, 3)) # 指定每个轴的tile次数
- 高级应用 花式索引的等价函数
• take
• put
# -*- coding: utf-8 -*-
import numpy as np
import numpy.random as np_random
print 'Fancy Indexing例子代码'
arr = np.arange(10) * 100
inds = [7, 1, 2, 6]
print arr[inds]
print
print '使用take'
print arr.take(inds)
print
print '使用put更新内容'
arr.put(inds, 50)
print arr
arr.put(inds, [70, 10, 20, 60])
print arr
print
print 'take，指定轴'
arr = np_random.randn(2, 4)
inds = [2, 0, 2, 1]
print arr
print arr.take(inds, axis = 1) # 按列take
