(转载)numpy基础入门 ——by 黑板客

转载19课时课件(用作自学笔记用途)

如果侵权请联系我email : leidar100@gmail.com

文章底部”作者”不知道如何修改QAQ

import numpy as np

1. 矩阵的创建

a=np.arange(1,5)
a=np.array([1,2,3,4,5])
print a, a.dtype, a.shape, a.size, a.ndim

[1 2 3 4 5] int64 (5,) 5 1


np.arange类似range函数
np.array用来生成矩阵
dtype是数据类型，有int64, complex, uint16等
shape是个元组属性，表示每一维的宽度
size是所有元素个数
ndim是维数

b=np.array([1,2,3],dtype='float16') # int64, complex, uint16......
print b, b.dtype

[ 1.  2.  3.] float16

m=np.array([np.arange(6),np.arange(6)])
print m, m.shape, m.size

[[0 1 2 3 4 5]
 [0 1 2 3 4 5]] (2, 6) 12

# 每一个[]代表一维，比如
# [[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]], 代表矩阵的维度是(2,2,3)
# 其中第一个2，代表最外层的两个[]，第二个2代表第二层[]，第三个3代表最里层的维度。
n=np.array([[1,2,3,4],[5,6,7,8]])
print n, n[0,2], n[1,1]

m=np.array([[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]])
print m.shape

[[1 2 3 4]
 [5 6 7 8]] 3 6
(2, 2, 3)

x=m.ravel()
y=n.flatten()
print x
print y

[ 1  2  3  4  5  6  7  8  9 10 11 12]
[1 2 3 4 5 6 7 8]

ravel()和flatten()看起来效果一样，都是把矩阵展平了。它们的区别在于
ravel()返回的是原有数据的一个映射(view)，没有分配新的存储
flatten()返回的是新的数据
因此如果我们改变它们的值，就可以看出区别

numpy还有一些函数有这样的区别，关键在于判断函数返回是原数据的映射还是返回新的数据。

x[3]=10;y[3]=10
print m
print n
# 看看m，n哪个的值改变了

[[[ 1  2  3]
  [10  5  6]]

 [[ 7  8  9]
  [10 11 12]]]
[[1 2 3 4]
 [5 6 7 8]]

# reshape返回一个view
x=m.reshape(3,4)
# resize直接在当前数据上更改，返回空
y=n.resize(2,4)
print x,y,'\n',n

[[ 1  2  3 10]
 [ 5  6  7  8]
 [ 9 10 11 12]] None 
[[1 2 3 4]
 [0 0 0 0]]

x[2]=10;print x;print m
# 看看m和n哪个改变了，有什么区别

[[ 1  2  3 10]
 [ 5  6  7  8]
 [10 10 10 10]]
[[[ 1  2  3]
  [10  5  6]]

 [[ 7  8 10]
  [10 10 10]]]

m=np.array([np.arange(6),np.arange(6)])
# copy()可以强制返回一个新的数据
x=m.reshape(3,4).copy()
x[2]=10;print x;print m
#看看这次m的值随x改变而改变吗

[[ 0  1  2  3]
 [ 4  5  0  1]
 [10 10 10 10]]
[[0 1 2 3 4 5]
 [0 1 2 3 4 5]]

# linspace返回0,1之间的10个数据，它们之间的间隔自动计算
x=np.linspace(0,1,10)
print x

[ 0.          0.11111111  0.22222222  0.33333333  0.44444444  0.55555556 0.66666667  0.77777778  0.88888889  1.        ]

a = np.arange(10)
np.random.shuffle(a)  # 随机排第一维
print a

a = np.arange(9).reshape((3, 3)) # 随机排第一维，想一想结果是什么
np.random.shuffle(a)
print a

[4 3 6 0 2 8 5 1 9 7]
[[0 1 2]
 [6 7 8]
 [3 4 5]]

# 全0矩阵
a=np.zeros((3,3))
# 全1矩阵
b=np.ones((5,4))
# 单位矩阵
c=np.eye(3)
# 取对角元素
np.diag(a)

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

2. 矩阵的加法

a = np.arange(9).reshape((3, 3))

## 每个元素的broadcast
print a
print a+3

## 行broadcast
print a+np.arange(3)

## 列broadcast
print a+np.arange(3).reshape(3,1)

[[0 1 2]
 [3 4 5]
 [6 7 8]]
[[ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]
[[ 0  2  4]
 [ 3  5  7]
 [ 6  8 10]]
[[ 0  1  2]
 [ 4  5  6]
 [ 8  9 10]]


broadcast广播操作
运算不仅仅作用在某个元素，而是作用在整个矩阵，或者整行，或者整列。
比如
n*m + 1*1 就是将1*1的元素作用在n*m的整个矩阵
n*m + n*1 就是将n*1的元素作用在n*m的每一列
n*m + 1*m 就是将1*m的元素作用在n*m的每一行
乘法类似

a = np.array([[1, 2], [3, 4]])
print np.sum(a,axis=0)
print np.sum(a,axis=1)
print np.mean(a,axis=0)
print np.mean(a,axis=1)
print np.std(a,axis=0) #标准差

#axis=0，就是按第一个维度进行计算，行向量[1,2], [3,4]
#axis=1，就是按第二个维度进行计算，列向量[1,3], [2,4]

[4 6]
[3 7]
[ 2.  3.]
[ 1.5  3.5]
[ 1.  1.]
[[ 6  8 10]
 [12 14 16]]
[[ 3  5  7]
 [15 17 19]]
[[ 3 12]
 [21 30]]

#再拓展到3维
a = np.arange(12).reshape((2,2,3))
print np.sum(a,axis=0) #按第一维度加，结果为2*3矩阵, 可以理解为1*2*3
print np.sum(a,axis=1) #按第二维度加，结果为2*3矩阵, 可以理解为2*1*3
print np.sum(a,axis=2) #按第三维度加，结果为2*2矩阵, 可以理解为2*2*1

[[ 6  8 10]
 [12 14 16]]
[[ 3  5  7]
 [15 17 19]]
[[ 3 12]
 [21 30]]

3. 矩阵的转置

print m.transpose()
print m.T

[[0 0]
 [1 1]
 [2 2]
 [3 3]
 [4 4]
 [5 5]]
[[0 0]
 [1 1]
 [2 2]
 [3 3]
 [4 4]
 [5 5]]

4. 矩阵的乘法

a = np.arange(12).reshape((6, 2))
b = np.arange(10).reshape((2,5))

# 两种矩阵乘法形式
print a.dot(b)
print np.dot(a,b)

[[  5   6   7   8   9]
 [ 15  20  25  30  35]
 [ 25  34  43  52  61]
 [ 35  48  61  74  87]
 [ 45  62  79  96 113]
 [ 55  76  97 118 139]]
[[  5   6   7   8   9]
 [ 15  20  25  30  35]
 [ 25  34  43  52  61]
 [ 35  48  61  74  87]
 [ 45  62  79  96 113]
 [ 55  76  97 118 139]]

## 每个元素broadcast
print a*2

# 行broadcast
print a*[1,2]

# 列broadcast
print a*np.arange(6).reshape(6,1)

5.矩阵的拼接

a = np.arange(9).reshape(3,3)
b = 2 * a
c = np.hstack((a, b))
print a,b
print c

[[0 1 2]
 [3 4 5]
 [6 7 8]] [[ 0  2  4]
 [ 6  8 10]
 [12 14 16]]
[[ 0  1  2  0  2  4]
 [ 3  4  5  6  8 10]
 [ 6  7  8 12 14 16]]

print np.concatenate((a, b), axis=1)

[[ 0  1  2  0  2  4]
 [ 3  4  5  6  8 10]
 [ 6  7  8 12 14 16]]

c=np.vstack((a, b))
c=np.concatenate((a, b), axis=0)

print np.hsplit(a, 3)
print np.vsplit(a,3)

[array([[0],
       [3],
       [6]]), array([[1],
       [4],
       [7]]), array([[2],
       [5],
       [8]])]
[array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])]

6. 矩阵的查找

a = np.arange(12).reshape((3, 4))
b = a%2==0
c = a>4
print b
print c
# 这里也用到了broadcast

[[ True False  True False]
 [ True False  True False]
 [ True False  True False]]
[[False False False False]
 [False  True  True  True]
 [ True  True  True  True]]

a = np.arange(12).reshape((3, 4))
print a
print np.argmax(a)
# 其实是列broadcast，返回每列最大值的idx
print np.argmax(a, axis=0)

# 行broadcast，返回每行最大值的idx
print np.argmax(a, axis=1)

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
11
[2 2 2 2]
[3 3 3]

# np.where支持多个逻辑组合, 得到满足条件的index
idx=np.where((a>3))
print a[idx]

idx=np.where((a>3)&(a<7))
print a[idx]

[ 4  5  6  7  8  9 10 11]
[4 5 6]

7. homework

1. http://www.labri.fr/perso/nrougier/teaching/numpy.100/