Numpy、matplotlib

简介

numpy - numeric python, 即数字化的python；python 支持的数值类型有整型、浮点型、布尔型、和复数型；numpy支持更多的数值类型：

    1. `bool`：布尔类型，1 个字节，值为 True 或 False。

    2. `int`：整数类型，通常为 int64 或 int32 。

    3. `intc`：与 C 里的 int 相同，通常为 int32 或 int64。

    4. `intp`：用于索引，通常为 int32 或 int64。

    5. `int8`：字节（从 -128 到 127）  

       （tinyint  1字节   -2 ^7 ~ 2^7-1   (-128~127)）

    6. `int16`：整数（从 -32768 到 32767） 

       (smallint 2字节 -2 ^15 ~ 2^15-1   (-32768~32765))

    7. `int32`：整数（从 -2147483648 到 2147483647） 

       （int 4字节 -2 ^31~ 2^31-1   (-2147483648~2147483647)）

    8. `int64`：整数（从 -9223372036854775808 到 9223372036854775807）

       （bigint  8字节  -2 ^63 ~ 2^63-1）

    9. `uint8`：无符号整数（从 0 到 255） unsigned

    10. `uint16`：无符号整数（从 0 到 65535）

    11. `uint32`：无符号整数（从 0 到 4294967295）

    12. `uint64`：无符号整数（从 0 到 18446744073709551615）

    13. `float`：float64 的简写。

    14. `float16`：半精度浮点，5 位指数，10 位尾数

    15. `float32`：单精度浮点，8 位指数，23 位尾数

    16. `float64`：双精度浮点，11 位指数，52 位尾数

    17. `complex`：complex128 的简写。

    18. `complex64`：复数，由两个 32 位浮点表示。

    19. `complex128`：复数，由两个 64 位浮点表示。

在 Numpy 中，上面提到的这些数值类型都被归于 dtype（data-type） 对象的实例。

我们可以用 numpy.dtype(object, align, copy) 来指定数值类型。而在数组里面，可以用 dtype= 参数。

---

Ndarray

numpy中最重要的一个形式叫数组ndarray - n个维度(dimension)的数组(array);

认识数组

1. ndarray 具有6个参数：shape、dtype、buffer、offset、strides(数据的步长)、order(以行或者列为主排列顺序)

2. ndarray数组的属性：

   ndim: 数组的维度 nd1.ndim
   shape: 形状(5, 4, 3) nd1.shape
   size： 数组的总长度 nd1.size
   dtype: 查看数据类型 nd1.dtype

创建数组的方法：

1. 使用ndarray方法创建三维数组

   nd1 = np.ndarray(shape=(5, 4, 3), dtype=np.int64)

2. 使用列表或者数组创建矩阵

   nd2 = np.array(list(‘12345’))

3. arange方法创建数组, 在指定范围内创建均匀间隔的数值

   numpy.arange(start, stop, step, dtype=None)
   nd3=np.arange(0,150,step=5,dtype=np.float32)
   将值倒过来：step=-1

4. linespace方法创建数组，在指定的范围内返回指定数量的值，这些值的间隔是均匀的

   numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
   endpoint: 布尔值， 如果为真，则最后一个样本包含在序列内
   restep: 布尔值，如果为真，返回间距

5. ones方法创建全部值为1的多维数组

   numpy.ones(shape, dtype=None, order=’C’)

6. zeros 方法创建 全部值为0的多维数组

   numpy.zeros(shape, dtype=None, order=’C’)

7. full方法可以创建一个使用自定义的值，填满整个数组

   numpy.full(shape,fill_value=num)

8. eye 方法创建多维维数组，特点是k对角线上的值为1，其余值为0

   numpy.eye(N, M=None, k=0, dtype=)
   

   n是数组的行数， m数组的列数， k:对角线索引，默认0指主对角线，大于0往上平移，小于0往下平移

9. 产生随机的数组

   np.random.randint(low=0, high=150, size=(5, 4))
   size 是一个元祖类型, low和high可以省略不写

   np.random.random(size=(456, 730, 3))

10. 元素的值呈现标准的正太分布

    np.random.randn(10, 5)
    没有固定的参数，没多加一个参数，代表多增加一个维度

11. 标准方差，元素的值满足标准方差

    np.random.normal(loc=170, scale=100m, size=50)

    location:定位的值, scale：波动的幅度，size：数据的长度

12. 产生的元素是随机的，没有范围

    np.random.rand(d1, d2,,,dn)
    每一个参数，代表一个维度

13. linspace与logspace

    linspace 是线性生成的，全闭区间

    nd6 = np.linspace(0,150,num=151)

    logspace是线性生成的，并且以什么为底
    num:生成多少个数，base表示的是底数，默认是10为底
    np.log10(100)
    nd7 = np.logspace(0,150,num=151,base=np.e)
    np.logspace(0,150,num=151,base=np.pi)

14. 构建对角矩阵

    np.diag(v, k=0)参数为列表即可
    v可以是一维或二维矩阵
    k小于0，斜线在矩阵的下方，大于0相反
    np.diag([1,2,3], k= 1)

15. 文件I/O创建数组

    csv、dat是一种常用的数据格式化文件类型；

    从文件中读取数据：

    numpy.genfromtxt()
    data1=np.genfromtxt('123.dat')
    
    data2=np.loadtxt('123.dat')
    
    data3=np.mafromtxt('123.dat')
    
    data4=np.ndfromtxt('123.dat')
    
    data5=np.recfromtxt('123.dat')
    

    向文件中保存数据：

    创建一个3 X 3 的二维数组
    M = np.random.rand(3, 3)
    np.savetxt('123.dat', M)
    

    numpy中的原生文件类型：以npy结尾结尾的文件名
    使用 numpy.save 与 numpy.load保存和读取数据：

    np.save('123.npy', M)
    np.load('123.npy')
    

    关于数组的操作：

    ndarray.T 用于数组的转置， 与.transpose()
    
    ndarray.imag 用来输出数组元素的虚部
    
    ndarray.real 用来输出数组元素的虚部
    
    ndarray.itemsize 用来输出一个数组元素所占用的字节数
    
    ndarray.nbytes用来输出数组的所有的元素所占的总的字节数
    
    ndarray.striders: 用来输出每个维度中步进的字节数
    

关于数组的操作

1. 改变数据类型：

   # 把数组nd4的数据类型改成整型，不适用dtype属性改变的默认数据类型
   nd4.astype(np.int)
   

2. 重设数组的形状：

   reshape可以在不改变数组数据的同时，改变数组的形状
   numpy.reshape() 等同于 ndarray.reshape()
   
   nd1 = np.random.randint(0, 150, size=(5, 4))
   
   # 把上面5行4列改成10行2列
   nd1.reshape((10,2))
   

   参数是元祖，改变前后要保证元素总数相等，也可以是单个值，可以是list或者元祖的形式

3. 将数组扁平化， 将任意形状的数组扁平化，变为1维数组

   nd1.ravel()
   

4. 数组之间的级联：

   np.concatenate()
   

   级联的参数是列表： 一定要加中括号，或者小括号
   级联的两个表维度必须相同，形状相似(同行同列、同行不同列、同列不同行)，水平及联时行要相同，垂直级联时列要相同
   级联的方向，默认为0， 表示垂直相连，表示x轴的事情
   1表示水平相连，表示y轴的事情

   可通过axis改变级联的方向，默认为0

   np.concatenate((nd2, nd3), axis=1)
   

   把猫和狗的图片进行合并，级联即合并，切片保证和狗的行列相同

   cat1 = cat[50:350,100:413]
   

   垂直级联
   cat_dog = np.concatenate((cat1,dog))
   水平级联
   cat_dog = np.concatenate((cat1,dog),axis=1)

   级联的方式2：

   函数：填入的参数必须被小括号，或者中括号包着，这两个函数的值也是一个list或者tuple
   hstack()： 水平级联  
   vstack(): 垂直级联
   
   vertical垂直的  horizontal水平的 stack层积
   
       dc=np.hstack((cat1,dog))
       plt.imshow(dc)
   

5. 分割数组：

   numpy.split(array, [index1, index2,…], axis)

   axis默认值是0， 表示垂直级联

   注意： 列表中的参数，第一个值代表 0-index1,第二个index1-index2,还有
   index: , 即两个值可以把一个数组，切成三份

   将猫水平切成三份：
   cat1, cat2, cat3 = np.split(cat, [100, 200])

   plt.imshow(cat1)
   plt.show()
   plt.imshow(cat2)
   plt.show() show是用于帮助图形显示的
   plt.imshow(cat3)
   也可以使用函数vsplit
   将猫垂直切成三份，后面加上参数axis=1

6. 复制数组：

   cat2 = cat.copy()
   查看元素在系统中的编号：id(cat2)
   display(id(cat2),id(cat))

7. 求和：np.sum

   ndarray.sum(axis), axis不写则为所有元素的求和，为0表示列求和， 1表示行求和

   one = np.ones((5, 4))

   求4维矩阵中最后两维的和：

   one_ = np.ones((3,3,3,3))
   
   #axis的值可以是一个元组，最后一维可以用-1来表示，-2可以用
   来表示倒数第二维
   one_.sum(axis=(-1,-2))
   

8. 求数组的最大最小值：np.max/np.min

   cat.max(axis=0)
   cat.min()

9. 数组的平均值：

   cat.mean(axis=0)
   cat5 = cat.mean(axis=2)

10. 去掉三维矩阵中的第三维：

    cat3 = cat.max(axis=2)
    
    cond = nd1.argmax()
    nd2 = nd1.reshape(20)
    nd2[cond]
    

11. argwhere where相当于mysql中的where条件

    index = np.argwhere(nd1<134)
    nd1[index[:,0],index[:,1]]
    

12. 移动数组的轴：

    二维矩阵行变列

    numpy.moveaxis(a, source, destination)
        a：数组。
        source：要移动的轴的原始位置。
        destination：要移动的轴的目标位置。
    

    nd1 = np.array([[1,2,3],[1,2,3],[1,2,3]])
    np.moveaxis(nd1,0,1)

13. 轴交换：

    numpy.swapaxes(a, axis1, axis2)
    a：数组。
    axis1：需要交换的轴 1 位置。
    axis2：需要与轴 1 交换位置的轴 1 位置。
    
    nd1 = np.random.randint(0,100,size=(5,4,3))
    np.swapaxes(nd1,0,2)
    

    transpose 类似于矩阵的转置，它可以将 2 维数组的水平轴和垂直交换。其方法如下：

    numpy.transpose(a, axes=None)
    
    a：数组。
    axis：该值默认为 none，表示转置。如果有值，那么则按照值替换轴。
    np.transpose(nd1)
    

14. 数组循环：

    # tile循环，依赖是行，把每行中的数据循环N次
    np.title(nd, 3)
    
    # repeat循环会先降维，再进行循环 循环每一个元素
    np.repeat(nd, 3)
    
    # 矩阵每个基本元素都执行运算
    nd1 + 3
    np.add(nd1, 10)
    
    np.multiply(nd1, 10)
    np.dot(nd1, 10)
    

15. 矩阵的乘积

    np.dot(nd1, nd2)
    要确保第二个矩阵的行要等于第一个矩阵的列

    三维乘一维：

    nd3 = np.random.randint(0, 10, size=(5,4,3))
    nd4 = np.random.randint(0, 10, size=3)
    np.dot(nd3, nd4)
    

    三维乘二维：

    nd3 = np.random.randint(0, 10, size=(5, 4, 3))
    nd4 = np.random.randint(0, 10, size=(3,4))
    np.dot(nd3, nd4)
    

16. ndarray广播机制：

    规则1: 为缺失的维度补1
    规则2：假定缺失元素用已有值填充
    # 两行三列
    nd1 = np.ones((2,3))
    # 一行三列
    nd2 = np.arange(3)
    # 列相加
    nd1 + nd2
    np.add(nd1, nd2)
    array([[1., 2., 3.],
           [1., 2., 3.]])
    

17. 数组的排序：

    nd = np.random.randint(0, 150, size=10)

    冒泡排序 一维矩阵和列表一样， 循环出每一个元素，并且让该元素，与其它所有元素相比

    for i in range(nd.size):
        for j in range(nd.size-1):
            if nd[i] < nd[j]:
                nd[i],nd[j] = nd[j], nd[i]
    

    用一层循环
    argmin， 封装成函数

    def sort_nd(nd):
        for i in range(nd.size):
            #  为什么+i, 不加上i索引会乱
            min_index = nd[i:].argmin() + i
            nd[i], nd[min_index] = nd[min_index], nd[i]
    
    sort_nd(nd1)
    

    np.sort()与ndarray.sort()都可以，但有区别：

    np.sort()不改变原数组
    ndarray.sort()本地处理，不占用空间，但改变元素组
    
    nd2 = np.random.randint(0, 10, size=10)
    
    np.sort(nd2)
    

    对原数组产生了影响

    nd2.sort()
    

18. 部分排序：

    np.partition(a,k)
    有的时候我们不是对全部数据感兴趣，我们可能只对最小或最大的一部分感兴趣。

    当k为正时，我们想要得到最小的k个数
    当k为负时，我们想要得到最大的k个数

    np.partition(nd3, -5)[-5:]
    np.partition(nd3, 5)[:5]
    np.sort(np.partition(nd3, 5)[:5])
    

---

matplotlib

matplotlib的使用：

import matplotlib.pyplot as plt

# 读取图片 png格式RGB取值范围0-1 jpg是0-255
fish = plt.imread('123.png/jpg')
# 打印图片
plt.imshow(fish)

# 查看图片的大小， 图片是三维数组，第三维表示RGB的值,前两维表示行和列的值，分别对应y和x轴， 坐标原点位于屏幕的左上角
fish.shape

颠倒图片：
上下颠倒：保持列不变，二位数组代表y轴， 所有的行取反，一行代表一个二维数组，一列代表一个一维数组
    fish1 = fish[::-1, :]
    plt.imshow(fish1)
左右颠倒： 保持行不变
    fish1 = fish[:, ::-1]
    plt.imshow(fish1)

# 将RGB的值进行颠倒
fish2 = fish1[:,:, ::-1]

把鱼头换成狗头：

    fish = plt.imread('fish.png')
    dog = plt.imread('dog.jpg')
    plt.imshow(fish[50:150,70:190])
    plt.imshow(dog[50:150,70:190])
    #fish是png           #dog是jpg
    dogface_fish=fish[50:150,70:190] = dog[50:150, 70:190].astype(np.float32)/255

    plt.imshow(fish)


    #生成一张随机的图片，然后替换到鱼的头部
    fish[50:150,70:190]  = np.random.randint(0,255,size=(100,120,3)).astype(np.float32)/255

将彩色图片打印成黑白：plt.imshow(cat2, cmap=’gray’)