numpy 模块

目录

0x00 简介
0x01 数据类型
0x02 np的创建函数

  1. np.array()
  2. zeros()
  3. ones()
  4. full()
  5. arange()
  6. linspace()
  7. np.random.random()
  8. np.random.normal()
  9. np.random.randint()
  10. eye()
  11. empty()

0x03 矩阵的属性
0x04 通用函数
0x05 操作函数

  1. 切片
  2. 重塑
  3. 拼接
  4. 分裂

0x06 整体操作函数
0x07 掩码
0x08 排序
0x09 索引
0x10 保存和导入
关于广播/矩阵的适应

0x00 简介

numpy 是 python 数据科学计算的核心，并且计算的速度，比python内部函数+循环来的更加快速。

0x01 数据类型（dtype）

bool_：布尔值
int8：字节（-128～127）
int16：整型（-32768～32767）
int32：整型（-2147483648～2147483647）
int64：整型（-263～263-1）
uint8：无符号整型（0～255）常用表示颜色
uint16：无符号整型（0～2^16-1）
uint32：
uint64：
float16：半精度浮点型（1bit符号，5bit指数，10bit尾数）
float32：单精度浮点型（1bit符号，8bit指数，23bit尾数）
float64：双精度浮点型（1bit符号，11bit指数，52bit尾数）

0x02 np的创建函数

导入库
import numpy as np

np.array()

介绍：自定义创建矩阵/向量
矩阵：含有多组括号[]
向量：只有一组括号[]

  1. 默认数据类型为向上转换(int转float)
In [2]: np.array([3.14,4,2,3])
Out[2]: array([3.14, 4.  , 2.  , 3.  ])
注：int类型的4转为float类型的4.
  1. 自定义参数
In [3]: np.array([3.14,4,2,3],dtype='int8')
Out[3]: array([3, 4, 2, 3], dtype=int8)
  1. 创建多维的函数
In [4]: np.array([range(i,i+3) for i in [0,3,6]],dtype='float32')
Out[4]: 
array([[0., 1., 2.],
       [3., 4., 5.],
       [6., 7., 8.]], dtype=float32)

zeros()

介绍：创建一个元书全是0的矩阵

  1. 创建向量(向量只有一对[]方括号)
In [18]: np.zeros(5,dtype='int8')
Out[18]: array([0, 0, 0, 0, 0], dtype=int8)
  1. 创建零矩阵
In [20]: np.zeros((1,5),dtype='int8')
Out[20]: array([[0, 0, 0, 0, 0]], dtype=int8)
In [21]: np.zeros((3,2),dtype='int8')
Out[21]: 
array([[0, 0],
       [0, 0],
       [0, 0]], dtype=int8)
  1. 创建多维矩阵
In [23]: np.zeros((2,2,2),dtype='int8')
Out[23]: 
array([[[0, 0],
        [0, 0]],

       [[0, 0],
        [0, 0]]], dtype=int8)

ones()

介绍：创建所有元素为1的矩阵
操作同 zeros()

full()

介绍：填充矩阵，由同一个元素进行填充

In [24]: np.full((3,5),'hello')
Out[24]: 
array([['hello', 'hello', 'hello', 'hello', 'hello'],
       ['hello', 'hello', 'hello', 'hello', 'hello'],
       ['hello', 'hello', 'hello', 'hello', 'hello']], dtype='<U5')

arange()

np.arange(start,stop,step)
介绍：作用同python自带的range函数
参数：
start：开始值（默认为0）
stop：结束值
step：步长（默认为1）

  1. 正常情况
In [25]: np.arange(0,20,2)
Out[25]: array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18])
  1. 缺省情况
In [26]: np.arange(10)
Out[26]: 
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9])

linspace()

np.linspace(start,stop,n)
介绍：在start和stop之间平均间隔取n个值
start：开始值
stop：结束值(包含)
n：n个量

In [29]: np.linspace(0,10,9)
Out[29]: array([ 0.  ,  1.25,  2.5 ,  3.75,  5.  ,  6.25,  7.5 ,  8.75, 10.  ])

np.random.random()

简介：[0,1)之间随机取值

In [30]: np.random.random((3,3))
Out[30]: 
array([[0.82228874, 0.1089113 , 0.1042419 ],
       [0.39540648, 0.78447082, 0.93905377],
       [0.81706086, 0.05729816, 0.83167481]])

np.random.normal()

np.random.normal(mean,cov,())
简介：已正态分布的方式随机取值，平均值为mean，方差为cov的()矩阵

In [34]: np.random.normal(0,1,(3,3))
Out[34]: 
array([[-0.88787112,  0.44841522,  1.07864026],
       [-2.09751237,  1.65672209,  1.29646719],
       [-0.82968315,  0.30015648, -1.47379788]])

np.random.randint()

np.random.randint(start,stop,())
简介：在start:stop的范围内随机取整值构成()矩阵

In [36]: np.random.randint(0,10,(5,5))
Out[36]: 
array([[4, 0, 4, 6, 5],
       [2, 5, 9, 5, 0],
       [6, 9, 1, 8, 8],
       [3, 2, 8, 8, 9],
       [5, 3, 0, 6, 7]])

eye()

简介：构建一个单位矩阵E(对角线全部为1，其他全部为0)

In [37]: np.eye(5)
Out[37]: 
array([[1., 0., 0., 0., 0.],
       [0., 1., 0., 0., 0.],
       [0., 0., 1., 0., 0.],
       [0., 0., 0., 1., 0.],
       [0., 0., 0., 0., 1.]])

empty()

简介：用内存垃圾制作一个矩阵

In [39]: np.empty(3)
Out[39]: array([0.00000000e+000, 1.84882922e-316, 6.90270845e-310])

0x03 矩阵的属性

  1. 先创建一个3*4*5的矩阵
In [41]: a3=np.random.randint(0,10,(3,4,5))

In [42]: a3
Out[42]: 
array([[[4, 7, 3, 4, 5],
        [7, 5, 8, 1, 6],
        [6, 4, 4, 1, 0],
        [1, 9, 2, 9, 0]],

       [[3, 6, 3, 8, 4],
        [1, 8, 5, 6, 8],
        [8, 9, 1, 6, 9],
        [8, 0, 8, 8, 4]],

       [[8, 2, 3, 5, 7],
        [6, 6, 4, 2, 5],
        [4, 9, 3, 7, 6],
        [4, 2, 7, 3, 2]]])
  1. 观察属性
矩阵的维度
In [43]: a3.ndim
Out[43]: 3
矩阵的形状
In [44]: a3.shape
Out[44]: (3, 4, 5)
矩阵的元素个数(3*4*5)
In [45]: a3.size
Out[45]: 60
矩阵的元素属性
In [46]: a3.dtype
Out[46]: dtype('int64')
矩阵每个元素所占的空间（64/8）
In [47]: a3.itemsize
Out[47]: 8
矩阵的总体所占的空间
In [48]: a3.nbytes
Out[48]: 480

0x04 通用函数

假设:
A=[0 1 2 3 4]
B=[1 2 3 4 5]

In [3]: A=np.array([0,1,2,3,4])
In [5]: A
Out[5]: array([0, 1, 2, 3, 4])
In [4]: B=np.array([1,2,3,4,5])
In [6]: B
Out[6]: array([1, 2, 3, 4, 5])
  1. 加法（所有元素都进行相加）
所有元素都+5
In [7]: A+5
Out[7]: array([5, 6, 7, 8, 9])
同np.add(A,5)
In [10]: np.add(A,5)
Out[10]: array([5, 6, 7, 8, 9])
  1. 减法
所有元素都-5
In [8]: A-5
Out[8]: array([-5, -4, -3, -2, -1])
同np.sutractb()
In [13]: np.subtract(A,5)
Out[13]: array([-5, -4, -3, -2, -1])
  1. 乘法
所有元素都进行乘法
In [14]: A*5
Out[14]: array([ 0,  5, 10, 15, 20])
同np.multiply(A,5)
In [15]: np.multiply(A,5)
Out[15]: array([ 0,  5, 10, 15, 20])
  1. 除法
所有元素都进行除法
In [16]: A/5
Out[16]: array([0. , 0.2, 0.4, 0.6, 0.8])
同np.divide()
In [17]: np.divide(A,5)
Out[17]: array([0. , 0.2, 0.4, 0.6, 0.8])
  1. 向下取整除法
In [20]: B//5
Out[20]: array([0, 0, 0, 0, 1])
同np.floor_divide()
In [21]: np.floor_divide(B,5)
Out[21]: array([0, 0, 0, 0, 1])
  1. 幂次运算
In [23]: A**2
Out[23]: array([ 0,  1,  4,  9, 16])
同np.power()
In [22]: np.power(A,2)
Out[22]: array([ 0,  1,  4,  9, 16])
  1. 取模运算
In [24]: A%2
Out[24]: array([0, 1, 0, 1, 0])
同np.mod()
In [25]: np.mod(A,2)
Out[25]: array([0, 1, 0, 1, 0])
  1. 绝对值运算
In [26]: np.abs([1,-2,3,-4])
Out[26]: array([1, 2, 3, 4])
  1. 指数运算
    自然底数（e）
In [27]: np.exp(A)
Out[27]: array([ 1.        ,  2.71828183,  7.3890561 , 20.08553692, 54.59815003])
  1. 底数运算
    自然底数ln()
In [30]: np.log(B,10)
Out[30]: array([0.        , 0.69314718, 1.09861229, 1.38629436, 1.60943791])

10为底

In [33]: np.log10(B)
Out[33]: array([0.        , 0.30103   , 0.47712125, 0.60205999, 0.69897   ])

2为底

In [32]: np.log2(B)
Out[32]: array([0.        , 1.        , 1.5849625 , 2.        , 2.32192809])
  1. 遍历执行
    reduce()
    对加法进行累加
In [37]: np.add.reduce(A)
Out[37]: 10
  1. 对中间过程的数据进行显示
In [38]: np.add.accumulate(A)
Out[38]: array([ 0,  1,  3,  6, 10])

0x05 操作函数

假设A=np.arange(16)

In [43]: A=np.arange(16)

In [44]: A
Out[44]: array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15])
  1. 切片
    对A进行切片的结果是一个子表a，子表a是A的一部分，类似C语言中的指针。对a进行操作就会对A产生影响。
a是A的一个子表
In [45]: a=A[1:8]

In [46]: a
Out[46]: array([1, 2, 3, 4, 5, 6, 7])
对a进行修改，就会对A产生影响
In [47]: a[0]=100

In [48]: a
Out[48]: array([100,   2,   3,   4,   5,   6,   7])
A的第2个元素被修改了
In [49]: A
Out[49]: 
array([  0, 100,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,
        13,  14,  15])

如果我们想制作一个副本就用.copy()方法

In [51]: A
Out[51]: array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15])


In [53]: a=A[1:8].copy()
生产副本
In [54]: a
Out[54]: array([1, 2, 3, 4, 5, 6, 7])
修改a
In [55]: a[0]=100

In [56]: a
Out[56]: array([100,   2,   3,   4,   5,   6,   7])
对A不产生影响
In [57]: A
Out[57]: array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15])
  1. 重塑
    a.reshape(shape, order='C')
    将A的元素重新作为一个矩阵
    默认选项
In [59]: A.reshape((4,4))
Out[59]: 
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15]])

列优先

In [66]: A.reshape((4,4),order='F')
Out[66]: 
array([[ 0,  4,  8, 12],
       [ 1,  5,  9, 13],
       [ 2,  6, 10, 14],
       [ 3,  7, 11, 15]])
  1. 拼接
    连接两个可以连接的矩阵
    创建A和B
    默认选项
生成A（矩阵）
In [3]: A=np.arange(16).reshape((4,4))
生成B（矩阵）
In [21]: B=np.array([np.arange(4)])

In [5]: A
Out[5]: 
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15]])
B是一个矩阵
In [22]: B
Out[22]: array([[0, 1, 2, 3]])
按行的方式进行连接
In [18]: np.concatenate([A,B])
Out[18]: 
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15],
       [ 0,  1,  2,  3]])

按列的方式进行连接

In [29]: np.concatenate([A,B.T],axis=1)
Out[29]: 
array([[ 0,  1,  2,  3,  0],
       [ 4,  5,  6,  7,  1],
       [ 8,  9, 10, 11,  2],
       [12, 13, 14, 15,  3]])
  1. 分裂
生成A
In [37]: A=np.array([np.arange(100)]).reshape((10,10))

In [38]: A
Out[38]: 
array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14, 15, 16, 17, 18, 19],
       [20, 21, 22, 23, 24, 25, 26, 27, 28, 29],
       [30, 31, 32, 33, 34, 35, 36, 37, 38, 39],
       [40, 41, 42, 43, 44, 45, 46, 47, 48, 49],
       [50, 51, 52, 53, 54, 55, 56, 57, 58, 59],
       [60, 61, 62, 63, 64, 65, 66, 67, 68, 69],
       [70, 71, 72, 73, 74, 75, 76, 77, 78, 79],
       [80, 81, 82, 83, 84, 85, 86, 87, 88, 89],
       [90, 91, 92, 93, 94, 95, 96, 97, 98, 99]])
分裂向量
In [36]: np.split(np.arange(16),[3,5,8])
Out[36]: 
[array([0, 1, 2]),
 array([3, 4]),
 array([5, 6, 7]),
 array([ 8,  9, 10, 11, 12, 13, 14, 15])]
分裂行
np.vsplit(A,[3,5,8])
In [39]: np.vsplit(A,[3,5,8])
Out[39]: 
[array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9],
        [10, 11, 12, 13, 14, 15, 16, 17, 18, 19],
        [20, 21, 22, 23, 24, 25, 26, 27, 28, 29]]),
 array([[30, 31, 32, 33, 34, 35, 36, 37, 38, 39],
        [40, 41, 42, 43, 44, 45, 46, 47, 48, 49]]),
 array([[50, 51, 52, 53, 54, 55, 56, 57, 58, 59],
        [60, 61, 62, 63, 64, 65, 66, 67, 68, 69],
        [70, 71, 72, 73, 74, 75, 76, 77, 78, 79]]),
 array([[80, 81, 82, 83, 84, 85, 86, 87, 88, 89],
        [90, 91, 92, 93, 94, 95, 96, 97, 98, 99]])]
分裂列
In [41]: np.hsplit(A,[3,5,8])
Out[41]: 
[array([[ 0,  1,  2],
        [10, 11, 12],
        [20, 21, 22],
        [30, 31, 32],
        [40, 41, 42],
        [50, 51, 52],
        [60, 61, 62],
        [70, 71, 72],
        [80, 81, 82],
        [90, 91, 92]]), array([[ 3,  4],
        [13, 14],
        [23, 24],
        [33, 34],
        [43, 44],
        [53, 54],
        [63, 64],
        [73, 74],
        [83, 84],
        [93, 94]]), array([[ 5,  6,  7],
        [15, 16, 17],
        [25, 26, 27],
        [35, 36, 37],
        [45, 46, 47],
        [55, 56, 57],
        [65, 66, 67],
        [75, 76, 77],
        [85, 86, 87],
        [95, 96, 97]]), array([[ 8,  9],
        [18, 19],
        [28, 29],
        [38, 39],
        [48, 49],
        [58, 59],
        [68, 69],
        [78, 79],
        [88, 89],
        [98, 99]])]

0x06 整体操作函数

  1. 求和
    np.sum()
A：
In [44]: A=np.arange(10)

In [45]: A
Out[45]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [54]: np.sum(A)
Out[54]: 45

对一个轴进行求和

In [68]: A=np.array([np.arange(100)]).reshape((10,10))

In [69]: A
Out[69]: 
array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14, 15, 16, 17, 18, 19],
       [20, 21, 22, 23, 24, 25, 26, 27, 28, 29],
       [30, 31, 32, 33, 34, 35, 36, 37, 38, 39],
       [40, 41, 42, 43, 44, 45, 46, 47, 48, 49],
       [50, 51, 52, 53, 54, 55, 56, 57, 58, 59],
       [60, 61, 62, 63, 64, 65, 66, 67, 68, 69],
       [70, 71, 72, 73, 74, 75, 76, 77, 78, 79],
       [80, 81, 82, 83, 84, 85, 86, 87, 88, 89],
       [90, 91, 92, 93, 94, 95, 96, 97, 98, 99]])
以列为基进行求和
In [70]: np.sum(A,axis=1)
Out[70]: array([ 45, 145, 245, 345, 445, 545, 645, 745, 845, 945])
  1. 积
    1.求积
    np.prod
In [71]: A=np.arange(10)

In [72]: A
Out[72]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

In [73]: np.prod(A)
Out[73]: 0

2.以轴求积

In [2]: np.prod(np.arange(100).reshape((10,10)),axis=1)
Out[2]: 
array([                  0,        335221286400,      72684900288000,
          2306992893004800,   29820834418636800,  227991539359584000,
       1233909752121446400, 5227941748053024000,    5769992716765184,
       1193853638847869952])
  1. 平均值
    np.mean()
In [5]: np.mean(np.arange(10))
Out[5]: 4.5
  1. 标准差
    np.std()
In [7]: np.std(np.arange(10))
Out[7]: 2.8722813232690143
  1. 方差
    np.var()
In [6]: np.var(np.arange(10))
Out[6]: 8.25
  1. 最小值
    np.min()
In [9]: np.min(np.arange(10))
Out[9]: 0
  1. 最大值
    np.max()
In [2]: A=np.array(np.arange(10))

In [3]: A
Out[3]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

In [4]: np.max(A)
Out[4]: 9
  1. 最小值下标
    np.argmin()
In [6]: A=np.array([1,9,2,5,7,8,3,4])

In [7]: A
Out[7]: array([1, 9, 2, 5, 7, 8, 3, 4])

In [8]: np.argmin(A)
Out[8]: 0
  1. 最大值下标
    np.argmax()
In [6]: A=np.array([1,9,2,5,7,8,3,4])

In [7]: A
Out[7]: array([1, 9, 2, 5, 7, 8, 3, 4])

In [9]: np.argmax(A)
Out[9]: 1
  1. 中位数
    np.median()
In [6]: A=np.array([1,9,2,5,7,8,3,4])

In [7]: A
Out[7]: array([1, 9, 2, 5, 7, 8, 3, 4])

In [10]: np.median(A)
Out[10]: 4.5
  1. 计算基于元素排序的统计值（百分比）
In [14]: A=np.arange(9)


In [16]: A
Out[16]: array([0, 1, 2, 3, 4, 5, 6, 7, 8])
说明：2在A中的排行为25%
In [15]: np.percentile(A,25)
Out[15]: 2.0

0x07 掩码

当对A中的元素进行比较，比如A>5

In [22]: A=np.arange(10)

In [23]: A
Out[23]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
返回的是一个 bool 值
In [24]: A>5
Out[24]: 
array([False, False, False, False, False, False,  True,  True,  True,
        True])
A>5 等同于np.greater(A,5)
In [26]: np.greater(A,5)
Out[26]: 
array([False, False, False, False, False, False,  True,  True,  True,
        True])
类型为bool
In [31]: (A>5).dtype
Out[31]: dtype('bool')

将得到的 bool 值作为参数（掩码）False 下标的内容不显示

In [25]: A[A>5]
Out[25]: array([6, 7, 8, 9])
或者 A[np.greater(A,5)]
In [27]: A[np.greater(A,5)]
Out[27]: array([6, 7, 8, 9])

同样的，可以判断

==        等同于        np.equal()
!=        等同于          np.not_equal()
<          等同于        np.less()
<=        等同于        np.less_equal()
>          等同于        np.greater()
==        等同于        np.greater_equal()

当然还可以使用与或非（and,or,not)

In [40]: (A>5)&(A<9)
Out[40]: 
array([False, False, False, False, False, False,  True,  True,  True,
       False])

但是如果你用来and的话

In [58]: (A>5)and(A<9)
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-58-498d1efe1fc2> in <module>()
----> 1 (A>5)and(A<9)

ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()

就会报错
原因是这样的。
&表示的是一种运算（只有0和1，True和False）
1&1=1 1&0=0 1|1=11|0=1
但是&&表示一种并联关系

x>5 and x<9         等同于数学中的        5<x<9
In [57]: [(x>4)and(x<9) for x in A]
Out[57]: [False, False, False, False, False, True, True, True, True, False]

其他与掩码相关的函数

  1. 计数函数
In [59]: np.count_nonzero(A>5)
Out[59]: 4
或者用加法来伪装
In [60]: np.sum(A>5)
Out[60]: 4
  1. 判断是否存在True选项
In [61]: np.any(A>5)
Out[61]: True
  1. 是否全部为True选项
In [62]: np.all(A>5)
Out[62]: False

0x08 索引

  1. 假设A为一个向量
In [77]: A=np.arange(0,16,2)

In [78]: A
Out[78]: array([ 0,  2,  4,  6,  8, 10, 12, 14])

以 A 为基础进行索引，并新建一个新的矩阵。
索引为

In [79]: index=np.array([[3,5],[4,1]])

In [81]: index
Out[81]: 
array([[3, 5],
       [4, 1]])

通过索引建立一个矩阵

In [82]: A[index]
Out[82]: 
array([[ 6, 10],
       [ 8,  2]])

发现得到的结果的样子的模仿索引（矩阵）的，而不是模仿原矩阵A（向量）。
当然也可以对高维进行类似操作。

  1. 二维的A
In [83]: A=np.array([np.arange(16)]).reshape(4,4)

In [84]: A
Out[84]: 
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15]])

下标要分为x，和y

In [88]: indx=np.array([[1,2],[2,3]])

In [89]: indy=np.array([[1,2],[2,3]])

In [91]: indx
Out[91]: 
array([[1, 2],
       [2, 3]])

In [92]: indy
Out[92]: 
array([[1, 2],
       [2, 3]])

返回的矩阵

In [94]: A[indx,indy]
Out[94]: 
array([[ 5, 10],
       [10, 15]])
  1. 掩码的实际情况
    制作A
In [100]: A=np.arange(4)

模拟掩码

In [104]: A[[False,True,False,True]]
Out[104]: array([1, 3])

制作掩码配合索引

In [106]: A[np.array([1,0,1,0],dtype=bool)]
Out[106]: array([0, 2])

0x09 排序

随机生成A

In [107]: A=np.random.randn(16)

In [108]: A
Out[108]: 
array([ 0.94530282, -0.141438  , -0.48407457, -0.12291314,  2.16394776,
       -0.29973733,  0.052026  ,  0.02803714, -0.55796317,  1.14545362,
       -0.2746067 , -0.55784318,  0.92600829,  1.64408684,  0.44322179,
       -0.31919027])

对 A 进行排序
np.sort()

In [109]: np.sort(A)
Out[109]: 
array([-0.55796317, -0.55784318, -0.48407457, -0.31919027, -0.29973733,
       -0.2746067 , -0.141438  , -0.12291314,  0.02803714,  0.052026  ,
        0.44322179,  0.92600829,  0.94530282,  1.14545362,  1.64408684,
        2.16394776])

对A的下标进行排序
np.argsort()

In [110]: np.argsort(A)
Out[110]: array([ 8, 11,  2, 15,  5, 10,  1,  3,  7,  6, 14, 12,  0,  9, 13,  4])

利用argsort产生的下标，进行排序

In [111]: A[np.argsort(A)]
Out[111]: 
array([-0.55796317, -0.55784318, -0.48407457, -0.31919027, -0.29973733,
       -0.2746067 , -0.141438  , -0.12291314,  0.02803714,  0.052026  ,
        0.44322179,  0.92600829,  0.94530282,  1.14545362,  1.64408684,
        2.16394776])

部分排序
np.partition(A,3)

前3个是排序的，虽然看上去大部分是排序的
In [113]: np.partition(A,3)
Out[113]: 
array([-0.55796317, -0.55784318, -0.48407457, -0.31919027, -0.29973733,
       -0.2746067 , -0.141438  , -0.12291314,  0.02803714,  1.14545362,
        0.052026  ,  2.16394776,  0.92600829,  1.64408684,  0.44322179,
        0.94530282])

对多维的支持

In [116]: np.partition(np.array([np.random.randn(16)]).reshape((4,4)),2,axis=1)
Out[116]: 
array([[-1.45500322, -0.713915  , -0.36444806,  0.76913556],
       [-1.21572197, -0.88310406, -0.87936904,  2.8281161 ],
       [-0.60106417, -0.53714934,  0.63414093,  1.77827773],
       [-1.56662739, -0.66677067,  1.00912384,  1.30192062]])

0x10 保存和导入

  1. 文件的导入（这个方法不是最佳的文件导入方案，后面的 pd 库有更加好的方案）
    x, y = np.loadtxt(file, delimiter=',', usecols=(0, 2), unpack=True,skiprows=True)
    参数：
    file：文件地址
    delimiter：分隔符
    usecols：使用的列
    unpack：True表示返回的不是矩阵而是列。Flase表示返回的是矩阵。
    skiprows：是否跳过头行
    文件的内容
"x","y"
1,2
3,4
5,6
7,8
9,10

导入文件

In [5]: x, y = np.loadtxt('/home/lee/Desktop/try.csv', delimiter=',', usecols=(0
   ...: ,1), unpack=True,skiprows=True)

In [6]: x
Out[6]: array([1., 3., 5., 7., 9.])

In [7]: y
Out[7]: array([ 2.,  4.,  6.,  8., 10.])
  1. 导出保存
    np.savetxt()
In [8]: A=np.random.randn(25).reshape((5,5))

In [9]: A
Out[9]: 
array([[ 0.51824487, -0.37472096,  1.25555816,  1.71001234,  0.45111468],
       [ 0.47749389, -1.50971983, -0.41145998, -0.02848777,  0.48562952],
       [-0.23624129, -0.15610786, -0.78545659,  0.42037099, -0.66968623],
       [ 0.19242133,  0.06266058, -0.08899911,  0.70829686,  0.00334643],
       [ 0.81126511, -0.16912052,  0.02496709, -1.21912629, -0.13012915]])
导出文件
In [11]: np.savetxt('A.csv',A,delimiter=',')

In [12]: ls
A.csv               Music/              Templates/
Desktop/            np                  Untitled1.ipynb
Documents/          octave-workspace    Untitled2.ipynb
Downloads/          out.avi             Untitled.ipynb
eclipse/            Pictures/           Videos/
eclipse-workspace/  Public/             wineQQ8.9_19990.tar.xz
examples.desktop    readme20170121.txt
geckodriver.log     seaborn-data/

文件的信息

5.182448656943908771e-01,-3.747209575039990859e-01,1.255558157410590514e+00,1.710012343614627062e+00,4.511146824482026307e-01
4.774938862073087598e-01,-1.509719830624739023e+00,-4.114599838018008771e-01,-2.848777188694322574e-02,4.856295168492132386e-01
-2.362412912000312337e-01,-1.561078611462562993e-01,-7.854565876685821735e-01,4.203709870211888022e-01,-6.696862321783216832e-01
1.924213325267559727e-01,6.266058086914759462e-02,-8.899910644144291838e-02,7.082968612937837749e-01,3.346432262475090586e-03
8.112651068338976312e-01,-1.691205155328200371e-01,2.496708527888203896e-02,-1.219126288883054299e+00,-1.301291545407270434e-01

关于广播/矩阵的适应

当矩阵进行加法
比如：
A+1
A+B（A为1行，B只有1列）

In [13]: A=np.array([np.arange(5)])
A只有1行
In [14]: A
Out[14]: array([[0, 1, 2, 3, 4]])

In [15]: B=A.T
B只有1列
In [16]: B
Out[16]: 
array([[0],
       [1],
       [2],
       [3],
       [4]])

进行加法

In [17]: A+1
Out[17]: array([[1, 2, 3, 4, 5]])
A+B似乎有点无法解释
In [18]: A+B
Out[18]: 
array([[0, 1, 2, 3, 4],
       [1, 2, 3, 4, 5],
       [2, 3, 4, 5, 6],
       [3, 4, 5, 6, 7],
       [4, 5, 6, 7, 8]])

本身并不能直接的相加，因为矩阵的运算是有条件的，比如shape要相同。
所以 A+B 的时候，A 和 B 都进行了扩展
A扩展为

array([[0, 1, 2, 3, 4]
       [0, 1, 2, 3, 4]
       [0, 1, 2, 3, 4]
       [0, 1, 2, 3, 4]
       [0, 1, 2, 3, 4]])

B扩展为

array([[0，0，0，0，0],
       [1,1,1,1,1],
       [2,2,2,2,2],
       [3,3,3,3,3],
       [4,4,4,4,4]])

同样A+1的时候，1也被扩展了。
扩展是有严格条件的：

  1. 如果两个矩阵的维度不同，那么小维度的矩阵的shape将在最左边补1。
  2. 如果两个数组的行站在任何一个维度都不匹配，那么数组的现状会沿着维度为1的维度扩展以匹配另外一个数组的形状
  3. 如果来那个个数组的形状在任何一个维度上都不匹配并且没有一个维度为1,那么就会报错。
  4. 重复上述这3条
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 204,590评论 6赞 478
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 86,808评论 2赞 381
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 151,151评论 0赞 337
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,779评论 1赞 277
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,773评论 5赞 367
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,656评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,022评论 3赞 398
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,678评论 0赞 258
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 41,038评论 1赞 299
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,659评论 2赞 321
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,756评论 1赞 330
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,411评论 4赞 321
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,005评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,973评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,203评论 1赞 260
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 45,053评论 2赞 350
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,495评论 2赞 343

推荐阅读更多精彩内容