numpy继续入门

接上篇结尾的两个函数np.c_,np.r_

首先这两个函数都用于连接两个矩阵，c_为按第二个轴连接，r_为按第一个轴连接，不过这两个函数都存在更高级的用法（暂未吃透，欢迎交流），基本用法实例如下：

c=np.array([[1,2,3],[4,5,6]])
d=np.array([[6,6,6],[6,6,6]])
np.c_[c,d]
'''
 输出为[[1, 2, 3, 6, 6, 6],
           [4, 5, 6, 6, 6, 6]]
'''
np.r_[c,d]
'''
输出为[[1, 2, 3],
           [4, 5, 6],
           [6, 6, 6],
           [6, 6, 6]]
'''

现在讨论c_与r_的高级用法中的第一个参数的意义（ndim>1)，如下所示：

np.c_['1',c,d] #注意此处为c_
'''
当要连接的轴axis=1被强制指定后的输出为：
       [[1, 2, 3, 6, 6, 6],
       [4, 5, 6, 6, 6, 6]]
'''
np.r_['1',c,d]#注意此处为r_
'''
当要连接的轴axis=1被强制指定后的输出为：
      [[1, 2, 3, 6, 6, 6],
       [4, 5, 6, 6, 6, 6]]
上下虽然调用的函数不同，但输出相同
由上述两个例子可知，np.r_或np.c_的第一个参数作用为强制指定连接的axis
'''

接下来讨论r_,c_的第二个参数的作用，如下所示：

np.c_['0,1',c,d]
'''
输出为：
          [[1, 2, 3],
           [4, 5, 6],
           [6, 6, 6],
           [6, 6, 6]]
shape=(4,3) rank=2
'''
>>> np.c_['0,2',c,d]
'''
输出为：
      [[1, 2, 3],
       [4, 5, 6],
       [6, 6, 6],
       [6, 6, 6]]
shape=(4,3) rank=2
'''
>>> np.c_['0,3',c,d]
'''
输出为：
      [[[1],
        [2],
        [3]],

       [[4],
        [5],
        [6]],

       [[6],
        [6],
        [6]],

       [[6],
        [6],
        [6]]]
shape=(4,3,1) rank=3
由上述例子所示，第二个参数强制指定输出矩阵的维度rank,但rank值又不能小于原矩阵。
'''

最后讨论c_,r_的第三个参数，只讨论初级用法，（在更高维情况下该参数的作用尚未完全理解）：

a=np.arange(3)
np.r_['0,2,1',a,a]
'''
输出为:
      [[0, 1, 2],
       [0, 1, 2]]
该二维数组由两个shape=(1,3)的数组组成
'''
np.r_['0,2,0',a,a]
'''
输出为：      
      [[0],
       [1],
       [2],
       [0],
       [1],
       [2]])
该二维数组由两个shape=(3,1)的数组组成，因此在数组a从1d转换为2d的过程中，第三个参数指定了数组a的原始尺寸‘3’在新数组（2d)shape中的位置，(3,1)或者（1,3)
'''

将一个数组拆分成几个较小的数组

a=np.floor(10*np.random.random((2,12)))
print(a)
# a=[[0. 1. 3. 3. 5. 3. 3. 5. 6. 8. 5. 8.]
#      [4. 7. 6. 3. 6. 8. 5. 2. 2. 0. 4. 3.]]

np.hsplit(a,(3,4,5,6)) #沿列切分数组，在元组中的参数代表要切分的列号
'''
[[0., 1., 3.],    [[3.],      [[5.],    [[3.],     [[3., 5., 6., 8., 5., 8.],
[4., 7., 6.]]     [3.]]       [6.]]     [8.]]       [5., 2., 2., 0., 4., 3.]]

'''
np.vsplit(a,2) #沿行切分数组，不在元组中的参数表示要切分出几个数组

# 数组1       [[0., 1., 3., 3., 5., 3., 3., 5., 6., 8., 5., 8.]]
 
#  数组2      [[4., 7., 6., 3., 6., 8., 5., 2., 2., 0., 4., 3.]]

拷贝和视图

当计算和操作数组时，有时会将数据复制到新数组中，有时则不会。

不完全复制

用赋值操作后的数组，在内存中其指向同一个位置。

a = np.arange(12)
b = a
id(a) #a在内存中的位置为1728029775152
id(b) #b在内存中的位置为1728029775152

视图或浅拷贝

不同的数组对象可以共享相同的数据

a=np.arange(3)
c=a.view()
c.flags.owndata #False
a.flags.owndata #True
c.shape=1,3
a.shape #(3,1)a的shape不变
c[0,0]=99
print(c)
'''
c输出为：
      [[99],
       [ 1],
       [ 2]]
a输出为:[99,  1,  2]
a中元素的值会随c改变而改变，但是shape却相互独立
'''

切片数组的改变也会影响原数组

a=np.arange(12).reshape(3,4)
s=a[:,1:3]
s[:]=10 #s的所有元素都赋值为10
print(a)
'''
数组a为：
      [[ 0, 10, 10,  3],
       [ 4, 10, 10,  7],
       [ 8, 10, 10, 11]]
数组a受数组s的影响
'''

深拷贝

该copy方法生成数组及其数据的完整副本

a=np.arange(12).reshape(3,4)
d=a.copy()
id(a) # 1728029965008
id(d) # 1728029976256 a,b在内存中的地址不同

广播（Broadcasting）规则

广播（Broadcasting）描述了 numpy 如何在算术运算期间处理具有不同shape的数组。受某些约束的影响，较小的数组在较大的数组上“广播”，以便它们具有兼容的shape
最简单的广播实例：

a = np.array([1.0, 2.0, 3.0])
b = 2.0
print(a * b)
#输出： array([ 2.,  4.,  6.])

广播的使用需要数组中有一个维度上堆shape是相同的或，其中一个shape是1，如下所示：

x = np.arange(4)
xx = x.reshape(4,1)
 y = np.ones(5)
 z = np.ones((3,4))

x+y #报错，shape不匹配
print(xx+y)
'''
输出为：
       [[1., 1., 1., 1., 1.],
       [2., 2., 2., 2., 2.],
       [3., 3., 3., 3., 3.],
       [4., 4., 4., 4., 4.]]
shape=(4,5)
'''
print(x+z)
'''
输出为：
      [[1., 2., 3., 4.],
       [1., 2., 3., 4.],
       [1., 2., 3., 4.]]
shape=(3,4)
'''

花式索引和索引技巧

NumPy提供比常规Python序列更多的索引功能。除了通过整数和切片进行索引之外，正如我们之前看到的，数组可以由整数数组和布尔数组索引

使用索引数组进行索引

当被索引数组为1维时：

a=np.arange(12)**2
i=np.array([1,1,3,8,5])
print(a[i])   #[ 1  1  9 64 25]
 
j=np.array([[3,4],[9,7]])
print(a[j]) 
#     [[ 9 16]
#     [81 49]]

由上述例子可以看到， 被索引数组(i,j)的shape不变，输出数组元素调用了索引数组a中的元素。

当被索引数组为2维时：

a = np.arange(12).reshape(3,4)
’‘’
a=   [[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]]
‘’‘
i = np.array( [ [0,1],[1,2] ] )
j = np.array( [ [2,1],[3,3] ] )
print(a[i,j])
'''
输出为：
      [[ 2,  5],
       [ 7, 11]]
'''

当a为2维时，a[i,j]输出服从索引数组（i,j）,a[i,j]的各个元素值为数组i,j 相同位置上的元素值在数组a上的映射。索引数组i,j的shape应该相同。

下面讨论当a的索引值参数一个确定一个不确定时的情况

print(a[i,2])
'''
输出为：
      [[ 2,  6],
       [ 6, 10]]
输出数组的shape服从数组 i
输出数组的各个元素值为数组i各个位置上的元素值与数值 2 在数组a上的映射 
'''
print(a[:,j])
'''
输出为：
      [[[ 2,  1],
        [ 3,  3]],
       [[ 6,  5],
        [ 7,  7]],
       [[10,  9],
        [11, 11]]]
a[:,j]中:表示遍历所有的行，因为a有三行，所有遍历三次。第一次遍历a的第一行，遍历第2，1，3，3个元素，得出第一个数组。以此类推。
'''

花式索引部分尚未完结，今天继续

概率论部分

学习了八大分布 中的六个，学不明白，数学真难。