机器学习基础学习笔记【三】

1. Numpy介绍

1.1 Numpy

• 用于科学计算。强大的科学计算功能依赖2个基本对象：多维数组对象ndarray和通用函数
  ufunc
• 使用pip install numpy命令安装Numpy，在jupyter中安装，需要在pip前添加！。

1.2 Pandas

• 用于数据分析。
• 建立在Numpy之上，可以使Numpy为中心的应用变得简单
• 提供了2种基本的数据结构：序列（Series）和数据框（DataFrame）

1.3 Matplotlib

• 是Python的一个可视化模块，它让用户可以方便地制作线条图、饼图、柱状图及其他专业图
  形

1.4 Scikit-learn

是基于python的机器学习模块，基本功能主要分为6个部分：分类、回归、聚类、数据降维、模型选择和数据预处理
sk-learn自带一些经典的数据集，如用于分类的iris和digits数据集，用于回归分析的boston house prices数据集等。

2.Numpy数据类型

• int8、int16、int32、int64这4种数据类型可以使用字符串i1、i2、i4、i8表示。
• 

2.1 数据类型对象（dtype）

• 一般作为array()函数的一个参数，用于指定array数据项的数据类型，参数值用引号括上
• 同时也可以获得数组元素的数据类型

import numpy as np 
na1=np.array(5,dtype='float32') # 查看ndarray、数据类型及数据项类型 
print(na1,type(na1),na1.dtype) # 查看变量的数据、数据元素个数，维数等信息 
print(na1.data,na1.size,na1.ndim) # 注意，单个标量是0维、加上一层中括号是1维……

5.0 <class 'numpy.ndarray'> float32 
<memory at 0x000001ECDEFEFE00> 1 0

2.2.astype()方法 修改数据类型

import numpy as np 
na=np.array(5,dtype='i2') 
print(na.dtype) 
print(na.astype('i4').dtype) 
print(na.astype(np.float32).dtype)

int16 
int32 
float32

3.Numpy数组属性

3.1 常用术语

• 轴（axis），即数组的维度，坐标
• 秩（Rank），维度的数目，即轴的数量，一维数组的秩是1
• 坐标系（axes），后面matplotlib中用到
• 比如[1,2,3]是一维数组，有1个轴、秩为1，轴的长度是3

# 使用axis参数设置当前轴 
import numpy as np 
arr=np.array([[0,1,2],[3,4,5]]) 
print(arr) 
print(arr.sum(axis=0)) 
print(arr.sum(axis=1))

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

3.2 基本属性

1. nddarray.ndim：秩，即数组维的维数。返回int
2. ndarray.shape：数组的尺寸，对一个n行m列的矩阵，shape值为（n，m）。返回tuple
3. ndarray.size：数组中元素的总个数，其值为ndarray.shape中n×m。返回int
4. ndarray.dtype：每个元素的类型，可以是np.int32、np.int16、np.float64等。返回data-type
5. ndarray.itemsize：每个元素所占字节大小。相当于ndarray.dtype.itemsize。返回int
6. ndarray.data：指向数据内存

import numpy as np 
a=np.array(((1,2,3,4,5),(6,7,8,9,0)),dtype=np.int32) 
print(a) 
print(a.ndim) 
print(a.shape) 
print(a.size) 
print(a.dtype) 
print(a.itemsize) 
print(a.data)

[[1 2 3 4 5]
 [6 7 8 9 0]] 
2
(2, 5) 
10
int32 
4
<memory at 0x000002096EBBFEE0>

3.2.1 .ndim属性

【秩，轴的数量，维度的数量】

• .reshape()方法可以将数组变形重构，调整各维度的大小。不会改变原数组。需将新数组赋值给一个变量
• .resize()方法类似reshape()方法，resize()直接对原数组操作，所以会改变原数组。是对原数组的一个操作。
• .reshape()方法中，可以指定某些参数值，剩下的参数可以赋值为-1，则系统根据给出的参数自己计算未给出的参数值

import numpy as np 
arr=np.array([1,2,3,4,5,6]) 
print('原数组为：') 
print(arr) b=arr.reshape(2,3) 
print('原数组为：') 
print(arr) 
print('b数组为') 
print(b) # resize()是对原数组的一个操作
arr.resize(3,2) 
print('原数组为：') 
print(arr) 
c=arr.reshape(2,-1) 
print('原数组为：') 
print(arr) 
print('c数组为') 
print(c)

原数组为： 
[1 2 3 4 5 6] 
原数组为： 
[1 2 3 4 5 6] 
b数组为 
[[1 2 3] 
 [4 5 6]] 
原数组为： 
 [[1 2] 
  [3 4] 
  [5 6]] 
原数组为： 
[[1 2]
 [3 4]
  [5 6]] 
 c数组为 
 [[1 2 3]
  [4 5 6]]

3.2.2 .shape属性

• 可以返回数组的各维度的大小，结果是一个元组
• 也可以通过给其赋值，改变数组的维度大小，同.resize()，都是直接对原数组操作

import numpy as np
a=np.array([[1,2,3],[4,5,6]]) 
print('数组a为') 
print(a) 
print('数组a的维度为：') 
print(a.shape) 
a.shape=(3,2) 
print('数组a为：') 
print(a)

数组a为 
[[1 2 3]
 [4 5 6]] 
数组a的维度为： 
(2, 3) 
数组a为：
[[1 2]
 [3 4]
 [5 6]]

3.2.3 .size属性

• 结果是整数，等于数组元素的总个数
• 其值等于.shape属性中的n×m。

3.3 创建特殊数组

3.3.1 .empty()函数

• 类似.array()函数，创建一个指定形状、数据类型的空数组
• 这个数组==没有初始化，其内容为空，==数组元素值不确定，因为所用空间没有初始化

import numpy as np 
a=np.empty(3,dtype=int) 
print(a)

[3014704 49 5177420]

3.3.2 .zeros()函数、ones()函数

• 类似array()函数，创建一个指定形状、数据类型的全0或全1的数组
• 参数可以是1个数，也可以是1个元组
• 参数是一个数，创建的是1维数组
• 参数是一个元组，根据元组中元素的个数创建相应维数的数组

import numpy as np 
a=np.ones(5) 
print(a) 
b=2*np.ones((5,1)) 
print(b) 
c=np.zeros((3,2)) 
print(c)

[1. 1. 1. 1. 1.]
 [[2.] 
  [2.] 
  [2.] 
  [2.] 
  [2.]] 
 [[0. 0.]
  [0. 0.]
  [0. 0.]]

3.3.3 产生数列的函数

• python中提供了range()函数，Numpy中arange()和linspace()函数用来生成一系列数

1. Python中的range()函数，生成等差数列

• 通过指定开始值、终值和步长，可以创建一系列数【注意：生成的不是列表，也不是数组】
• 如果只设置1个参数，则默认从0开始，步长为1，步长需要为整数
• 这些数中不包括终值

arange()函数,创建等差数列

• 功能与range()函数类似，生成的是数组
• 起始和终止数值及步长可以不为整数

# 构造二维数组 
import numpy as np 
d=np.array([np.arange(1,3),np.arange(4,6)]) 
print(d)

[[1 2]
 [4 5]]

linspace()函数

• 通过指定开始值、终值和数组元素的个数，可以创建数组。
• 生成的数组默认包括终值。

import numpy as np 
a=np.linspace(3,10,5) 
print(a)

[ 3. 4.75 6.5 8.25 10. ]

3.4 生成随机数数组

函数	描述
seed(n)	确定随机数生成器的种子，种子确定后生成的都是一样的
random()	产生0~1之间的随机浮点数。参数设置：1）无参数；2）1个数；3）一个元组
rand(d0,d1,…dn)	产生0~1之间的符合均匀分布的随机浮点数。参数设置：1）无参数；2）1个数；3）多个数
randn(d0,d1,…dn)	产生符合标准正态分布的浮点数，标准正态分布就是期望为0，方差为1的正态分布。参数设置：1）无参数；2）1个数；3）多个数
normal(loc,scale,size)	基于给定的均值和方差，随机产生一组正态分布的浮点数。参数loc决定均值，参数scale决定标准差，参数size决定数量。参数设置中，前2个为期望和方差，size值：1）无参数；2)1个数；3）一个元组
randint(low[,high,size,dtype])	产生[low,high]之间的随机整数。参数设置：1）1个数；2）2个数；3）3个数；4）2个数加一个元组

3.4.1 . random()函数生成随机小数

# 无参数，生成1个随机小数 
import numpy as np 
a=np.random.random() 
print('无参数，生成一个随机小数：\n',a) # 1个参数是数字，生成一维数组，数组中元素个数是参数值 
b=np.random.random(3) 
print('参数是一个数，生成一维数组构成的随机小数：\n',b) # 1个参数是元组，生成多维数组 
c=np.random.random((2,3,4)) 
print('参数是一个元组，生成多维数组构成的随机小数：\n',c)

无参数，生成一个随机小数： 0.04309735620499444 
参数是一个数，生成一维数组构成的随机小数： [0.87991517 0.76324059 0.87809664] 
参数是一个元组，生成多维数组构成的随机小数： 
[[[0.41750914 0.60557756 0.51346663 0.59783665] 
[0.26221566 0.30087131 0.02539978 0.30306256] 
[0.24207588 0.55757819 0.56550702 0.47513225]]
[[0.29279798 0.06425106 0.97881915 
0.33970784] [0.49504863 0.97708073 
0.44077382 0.31827281] [0.51979699 
0.57813643 0.85393375 0.06809727]]]

3.4.2 . rand()函数

• rand(d0,d1…,dn)函数用来生成符合均匀分布的随机小数，范围[0,1)
• randn(d0,d1…,dn)函数用来生成符合正态分布的随机小数，数据主要在区间（-1，1）附近

# 无参数，生成1个随机小数 
import numpy as np 
a=np.random.rand() 
print(a) # 1个参数，生成一维数组，数组中元素个数是参数值 
b=np.random.rand(3) 
print(b) # 多个参数，生成多维数组 
b=np.random.rand(2,3,4) 
print(b)

0.037094413234407875 
[0.35065639 0.56319068 0.29972987] 
[[[0.51233415 0.67346693 0.15919373 0.05047767] 
 [0.33781589 0.10806377 0.17890281 0.8858271 ]
 [0.36536497 0.21876935 0.75249617 0.10687958]] 
 [[0.74460324 0.46978529 0.59825567 0.14762019]
  [0.18403482 0.64507213 0.04862801 0.24861251]
  [0.54240852 0.22677334 0.38141153 0.92223279]]]

3.4.3 randint()函数

# 1个参数，生成1个0~该参数间的随机整数 
import numpy as np 
a=np.random.randint(5) 
print(a) # 2个参数，生成1个0参数间的随机整数 
b=np.random.randint(3,10) 
print(b) # 3个参数，第3个参数是1个数，生成一维数组 
b=np.random.randint(3,10,3) 
print(b) # 3个参数，第3个参数是元组，生成多维数组 
b=np.random.randint(3,10,(2,3)) 
print(b)

3
9
[5 4 7] 
[[4 4 6]
 [9 4 3]]

3.4.4 choice()函数

• 从给定的一维数组中随机抽取元素构成数组【一维或多维】numpy.random.choice(a,size=None,p=None)
• 参数a可以是一个整数或者一个序列。当a是一个数时，则产生np.arange(a)的序列
• 参数size指定抽取的数据的结果。如果是一个数，则随机抽取指定个数的元素组成一维数
  组。如果是一个元组，则生成元组指定形状的多维数组。
• 参数p用于指定a中元素被抽中的概率，其长度与参数a的长度需要一致；参数p为概率，p里的数据之和应为1

# 参数a为一个整数，size也是整数，指定各数被抽中的几率 
a=np.random.choice(5,3,p=(0.8,0.2,0,0,0)) 
print(a)

[0 0 1]

3.5 切片、迭代和索引

3.5.1索引

• 索引用来获取数组中的数据。下标从0开始，最后一个元素的下标是-1
• 获取单个元素，结果是一个数
• 获取罗列出索引的多个元素，需要将各索引用[]括上，结果是一维数组。
• 数组的索引可以分成2类：一维数组的索引和二维数组的索引。

# 二维数组 
import numpy as np 
a=np.arange(12).reshape(3,-1) 
print('原数组：\n',a) 
# 获取单个元素 
print('获取单个元素:\n',a[-1,3]) 
# 获取多个非连续元素，获取0行2列和1行3列数据 
print('获取多个非连续元素:\n',a[[0,1],[2,3]]) 
# 获取一行 
print('获取一行：\n',a[2]) 
# 获取多行，并重新排序。也称作花式索引 
print('获取多行，并重新排序:\n',a[[2,0]])
# 获取一列 
print('获取一列：\n',a[:,2]) 
# 获取多列 
print('获取多列：\n',a[:,[0,2]]) 
# 获取多行多列 
print('获取多行多列：\n',a[1:,1:])

原数组： 
[[ 0 1 2 3]
 [ 4 5 6 7]
 [ 8 9 10 11]] 
获取单个元素: 
11 
获取多个非连续元素:
[2 7] 
获取一行： 
[ 8 9 10 11] 
获取多行，并重新排序: 
[[ 8 9 10 11]
 [ 0 1 2 3]] 
获取一列： 
[ 2 6 10] 
获取多列： 
[[ 0 2]
 [ 4 6]
 [ 8 10]] 
获取多行多列： 
[[ 5 6 7]
 [ 9 10 11]] 
获取不连续的多个元素： 
[ 1 10]

3.5.2 切片

• 切片是指取数据序列对象的连续的一部分的操作
• 同一维度之间用冒号分隔，各维度之间用逗号分隔
• 同一维度之间的冒号可有1个，也可有2个。
• 第1个参数是起始索引，第2个参数是结束索引，第3个参数是步长
• 省略起始索引或结束索引表示从头开始或到结尾为止。省略步长则步长是1

import numpy as np 
arr=np.arange(24).reshape(4,-1) 
print(arr) 
arr1=arr[1:,:3] 
print(arr1)

[[ 0 1 2 3 4 5]
 [ 6 7 8 9 10 11]
 [12 13 14 15 16 17] 
 [18 19 20 21 22 23]] 
 [[ 6 7 8]
  [12 13 14] 
  [18 19 20]]

• 切片的本质是传入一个连续的列表
• 获取非连续列表即通过传入相应索引获得相应位置的元素，构成一维数组

3.5.3 迭代

• 通过for循环实现迭代，当维数多于一维时，迭代操作使用嵌套的for循环
• .flat是一个数组元素迭代器，给出的是数组展平后的存储地址
• 要对数组中每个元素进行迭代时可以使用该属性

import numpy as np 
a=np.arange(9).reshape(3,3) 
print('原数组为：') 
print(a) 
print('原数组各行为：') 
for row in a: 
	print(row) 
print('迭代数组元素：') 
print('数组展平后的起始地址为：\n',a.flat) 
for ele in a.flat: 
	print(ele,end=',')

原数组为： 
[[0 1 2]
 [3 4 5] 
 [6 7 8]] 
原数组各行为： 
 [0 1 2]
  [3 4 5] 
  [6 7 8] 
迭代数组元素： 
数组存储的起始地址为：
<numpy.flatiter object at 0x0000011D5C1E2560> 
0,1,2,3,4,5,6,7,8,

• .ravel()方法用于展开数组元素，将多维ndarray转换成一维ndarray。
• 横向按行展开，不会影响原数组
• .flatten()方法，也可以展平ndarray，但是该方法可以选择横向或纵向展平
• 默认为横向展平，设置参数‘f’实现纵向展平，不会影响原数组

3.6 组合、分割、搜索

3.6.1 组合ndarray

• 有些数据是分布在不同的文件中的，需要垂直纵向组合到一起
• 有些数据的特征分布在不同文件中，需要水平横向组合到一起
• Numpy中提供了横向组合、纵向组合函数
• 分别使用hstack（cloumn_stack）、vstack(row_stack)、concatenate、dstack函数完成

1. 横向组合np.hstack((data1,data2))、np.column_stack((data1,data2))

• 参数是1个元组，需要组合的数组为元组的元素
• 要求合并的各数组要有相同的行数

2.纵向组合np.vstack((data1,data2))、np.row_stack((data1,data2))

• 参数是1个元组，需要组合的数组为元组的元素
• 要求合并的各数组要有相同的列数

3 横向组合和纵向组合np.concatenate((data1,data2),axis=0/1)

• 参数有2个，第1个参数是由需要组合的数组构成的元组
• 第2个参数用于设定沿着哪个轴进行组合。axis=1表示横向组合【横向扩大】，axis=0表示纵向组合【纵向扩大】

3.6.2 分割ndarray

• 目的是将一个数组拆分为多个数组
• Numpy中可以使用hsplit、vsplit、split函数实现横向分割、纵向分割
• 通过这些函数可以将数组分成相同大小的子ndarray，也可以根据位置分割为目标形状
• 分割后的数组维度与原ndarray相同，即若原数组是二维，分割得到的也是二维数组

3.6.2.1 横向分割np.hsplit()函数

分割得到的是多个数组组成的元组，可以拆包成单个数组。

• 参数类型有2种，一种是单个数，表示平均拆成多少个数组，另一种是元组，元组的元素拆分的数组的列下标值
• hsplit(data,n)表示横向将原数组平均分成n个。所以，数组的列数应该是能够被n整除。
• hsplit(data,(m,n,x…))表示在下标m、n、x……等处进行分割，获得的子数组个数是参数的值+1。下标所在列归属下一个数组。

# 平均分 
import numpy as np 
arr1=np.arange(12).reshape(-1,3) 
print('原数组1：\n',arr1) 
print('-'*20) 
arr2,arr3,arr4=np.hsplit(arr1,3) 
print('分割后的1：\n',arr2) 
print('-'*20) 
print('分割后的2：\n',arr3) 
print('-'*20) 
print('分割后的3：\n',arr4)

原数组1：
 [[ 0 1 2]
  [ 3 4 5] 
  [ 6 7 8] 
  [ 9 10 11]] 
-------------------- 
分割后的1： 
  [[0]
   [3] 
   [6] 
   [9]] 
-------------------- 
分割后的2： 
  [[ 1] 
   [ 4] 
   [ 7] 
   [10]] 
-------------------- 
分割后的3： 
  [[ 2] 
   [ 5] 
   [ 8] 
   [11]]

3.6.2.2 纵向分割np.vsplit()函数

• 分割得到的是多个数组组成的元组，可以拆包成单个数组。
• 参数类型有2种，一种是单个数，表示平均拆成多少个数组，另一种是元组，元组的元素拆分的数组的行下标值
• vsplit(data,n)表示纵向将原数组平均分成n个。所以，数组的行数应该是能够被n整除。
• vsplit(data,(m,n,x…))表示在下标m、n、x……等处进行分割，获得的子数组个数是参数的值+1。下标所在列归属下一个数组

3.6.2.3 横向分割和纵向分割np.split()函数

• 参数设置有2种情况。
• 参数分别是要拆分的数组，平均分割的份数【整数】和沿着哪个轴分割
• 参数分别是要拆分的数组，指定分割点的位置【列号组成的元组】和沿着哪个轴分割
• 沿着哪个轴:
  • axis=0为纵向分割【纵向变小】
  • axis=1为横向分割【横向变小】

# 横向平均分割【横向变小】 
import numpy as np 
arr1=np.arange(12).reshape(3,-1) 
print('原数组1：\n',arr1) 
print('-'*20) 
arr2,arr3=np.split(arr1,2,axis=1) 
print('分割后1：\n',arr2) 
print('-'*20) 
print('分割后2：\n',arr3)

原数组1： 
[[ 0 1 2 3]
 [ 4 5 6 7] 
 [ 8 9 10 11]] 
-------------------- 
 分割后1：
  [[0 1]
   [4 5] 
   [8 9]]
-------------------- 
分割后2：
[[ 2 3]
 [ 6 7] 
 [10 11]]

3.6.2.4 横向或纵向不平均分割np.array_split()函数

• 参数设置类似split()函数

3.6.3 搜索

• Numpy提供了一些在ndarray内实施搜索的函数，包括用于找最大值、最小值以及满足给定条件的元素的函数。

1. 使用==np.argmax()和np.argmin()==函数

• 可以求最大值和最小值的索引
  np.argmax(array,axis=不指定/0/1)
  np.argmin(array,axis=不指定/0/1)
• axis省略，则将数组按照行排列，从0开始编号，返回满足条件的元素的索引，得到的是一个整数
• axis=0，按照列进行搜索，找出各列中满足条件的元素的索引,得到由各列索引组成的一维数组，各列索引都是从0开始
• axis=1，按照行进行搜索，找出各行中满足条件的元素的索引，得到由各行索引组成的一维数组，各行索引都是从0开始

import numpy as np 
arr1=np.array([[1,2,3],[4,8,0],[9,5,6],[13,10,11]]) 
print('原数组：\n',arr1) 
print('-'*20) 
print('最大元素索引',np.argmax(arr1)) 
print('-'*20) 
print('各列最大索引',np.argmax(arr1,axis=0)) 
print('-'*20) 
print('各行最大索引',np.argmax(arr1,axis=1))

原数组： 
[[ 1 2 3]
 [ 4 8 0] 
 [ 9 5 6] 
 [13 10 11]] 
-------------------- 
最大元素索引 
9 
-------------------- 
各列最大索引 
[3 3 3] 
-------------------- 
各行最大索引 
[2 1 0 0]

3.6.3.1 np.where()函数

• 返回输入的ndarray中满足给定条件的元素的索引np.where(condition,x,y)

• 情况1：只有condition【判断条件】，无参数x和y。如：np.where(arr>5)

• 输出满足条件的元素的下标，结果是多个数组组成的元组

• 可以将数组拆包得到多个数组，第1个数组元素为对应的是满足条件的元素所在的行号

• 第2个数组的元素为对应的是满足条件的元素所在的列号，第3个数组为层……

• 情况2：满足条件时，取第1个数组中对应的元素，不满足条件时，取第2个数组中对应的元素。如：np.where(arr1>5,arr1,arr2)

• 输出满足条件的元素，结果是1个数组，数组维度同原数组

• 数组中的元素取自arr1和arr2

3.6.3.2 np.extract()函数

• 返回值为一维数组，数组元素由输入的ndarray中满足给定条件的元素组成np.extract(condition,arr)

4.Numpy计算

4.1 算术运算

运算符	函数格式	说明
+	np.add(x,y)	ndarray x中各元素与y中个元素求和，返回值为ndarray
-	np.substract(x,y)	ndarray x中各元素与y中个元素求差，返回值为ndarray
*	np.multiply(x,y)	ndarray x中各元素与y中个元素求积，返回值为ndarray
/	np.divide(x,y)	ndarray x中各元素与y中个元素求商，返回值为ndarray
**	np.power(x,y)	ndarray x中各元素与y中个元素求幂，返回值为ndarray

• 除了基础的四则运算之外，Numpy还提供了其他数学运算函数，例如：

1.np.negative(x)：求ndarray x中各元素的相反数
2.np.sqrt(x)：求ndarray x中各元素的平方根
3.np.absolute(x)：求ndarray x中各元素的绝对值
4.np.fabs(x)：求ndarray x中各元素的绝对值

4.2 统计运算

• 常用的统计函数【方法】
• 作为函数，将数组作为参数，调用方式是np.max()
• 作为方法，用数组进行调用。
• 

4.3 数学函数

4.3.1 三角函数

• 这些函数都可以传入列表类型参数，自动对列表中的各个元素进行计算，不需要写循环
• 正弦函数等：np.sin()、np.cos()、np.tan()
• 反正弦函数等：np.arcsin()、np.arccos()、np.arctan()
• 弧度和角度转换：np.degrees()是将弧度转换为角度，np.radians()是将角度转换为弧度

4.3.1 约数

• 包括四舍五入、向0取整、向上取整和向下整
• 四舍五入：np.around(arr,decimals=0/1/2…)，参数arr为数组，decimals决定精度
• 四舍五入取整：np.rint(arr)
• 向0取整：np.fix()
• 向下取整：np.floor()
• 向上取整：np.ceil()

4.4 广播

• 两个相同尺寸的数组可以直接进行四则运算，同位置的元素进行计算
• 不同尺寸的数据可以通过扩展，扩展成相同尺寸的数组进行计算，这种机制叫做广播
• 广播的前提——两个数组必须可以转化成维度大小一模一样的才可以运算：
• 规则1：如果两个数组的维度不相同，那么小维度数组的形状将会在最左边补1，然后再扩展。比如形状为(3,2,4)和(2,4)相加，则第2个在左边补1扩展为(1,2,4)，再扩展成(3,2,4)。
• 规则2：如果两个数组的形状在任何一个维度上都不匹配，那么数组的形状会沿着维度为1扩展以匹配另外一个数组的形状。
• 规则3：如果两个数组的形状在任何一个维度上都不匹配并且没有任何一个维度为1,那么会引起异常。

广播的方法：

1. 如果2个数组的后缘维度(从末尾开始算起的维度)的轴长度相符或其中一方的长度为1，则认为它们是广播兼容的。【即2个数组维数不同，但是它们的后缘维度的轴长相符；数组维度相同，其中有个轴为1】
2. 广播会在缺失维度和(或)轴长度为1的维度上进行。

• 方法1：数组维度不同，后缘维度的轴长相符
  • arr1的shape为（4,3），arr2的shape为（3，）。前者是二维的，而后者是一维的，维度不同。
  • 它们的后缘维度相等，arr1的第二维轴长度为3，arr2的第一维轴长也是3。
  • arr2的shape在左边加1，变成(1,3)则维度相同了。然后沿着0轴扩展变成形状为(4,3)。
• 方法2：数组维度相同，其中有一个轴为1，不为1的轴的值与另一个数组的对应轴 的值相等
  • arr1的shape为（4,3），arr2的shape为（4,1），它们都是二维的
  • 但是第二个数组在1轴上的长度为1，所以，可以在1轴上面进行广播
  • 两个数组的维度要保证相等，其中有一个轴的长度为1，这样就会沿着长度为1的轴进行扩展。

4.5 删除重复数据

• 使用函数np.unique(data,axis=0/1)

4.6 Numpy 读取外部数据文件，并进行处理

• numpy是无法直接判断出由数值与字符混合组成的数组中的数值型数据的，因为由数值类型
• 和字符类型组成的numpy数组已经不是数值类型的数组了，而是dtype=‘<U21’。

5. 使用Numpy处理图像