NumPy（Numerical Python）是Python的一种开源的数值计算扩展。提供多维数组对象，各种派生对象（如掩码数组和矩阵），这种工具可用来存储和处理大型矩阵，比Python自身的嵌套列表（nested list structure)结构要高效的多（该结构也可以用来表示矩阵（matrix）），支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库，包括数学、逻辑、形状操作、排序、选择、输入输出、离散傅立叶变换、基本线性代数，基本统计运算和随机模拟等等。

- 几乎所有从事Python工作的数据分析师都利用NumPy的强大功能。
  - 强大的N维数组
  - 成熟的广播功能
  - 用于整合C/C++和Fortran代码的工具包
  - NumPy提供了全面的数学功能、随机数生成器和线性代数功能

- 安装Python库

- 第一种方式：

  - pip install jupyter -i https://pypi.tuna.tsinghua.edu.cn/simple- pip install numpy -i https://pypi.tuna.tsinghua.edu.cn/simple

- 第二种方式：

- 直接安装[anaconda下载](https://www.anaconda.com/products/individual#Downloads)

- 注意：安装时！！！ 添加一下环境变量~

* 百度网盘链接: https://pan.baidu.com/s/1sQ8LMH6q8ezVUzNjSCtgyQ 提取码: sm7m

- 启动终端

* Windows----> 快捷键：**win + R** ----->输入：**cmd**回车------>命令行出来

- Mac ---->启动终端

- 启动jupyter

- 进入终端输入指令:**jupyter notebook**
  - 在哪里启动jupyter启动，浏览器上的目录，对应哪里，windows默认路径是：**C:\Users\lufengkun**
  - **C:\Users\xxx**

第一部分 基本操作

第一节  数组创建

创建数组的最简单的方法就是使用array函数，将Python下的list转换为ndarray。

```python
import numpy as np
l = [1,3,5,7,9] # 列表
arr = np.array(l) # 将列表转换为NumPy数组
arr # 数据一样，NumPy数组的方法，功能更加强大
# 输出为
# array([1, 3, 5, 7, 9])
```

我们可以利用np中的一些内置函数来创建数组，比如我们创建全0的数组，也可以创建全1数组，全是其他数字的数组，或者等差数列数组，正态分布数组，随机数。

```python
import numpy as np
arr1 = np.ones(10) # 输出为：array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])arr2 = np.zeros(10) # 输出为： array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])arr3 = np.full(shape = [2,3],fill_value=2.718) #shape=[2,3]里面填充值为2.718数
# 输出为：
# array([[2.718, 2.718, 2.718],
#       [2.718, 2.718, 2.718]])arr4 = np.arange(start = 0,stop = 20,step = 2)
# 等差数列 输出为：array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18])arr5 = np.linspace(start =0,stop = 9,num = 10)
# 等差数列 输出为：array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])arr6 = np.random.randint(0,100,size = 10)
# int随机数 输出为：array([ 4,  8, 79, 62, 34, 35,  2, 65, 47, 18])np.random.randint(0,10,size=(3,5))#创建二维数组
#输出为：
array([[6, 8, 8, 4, 2],[4, 6, 7, 4, 1],[9, 4, 4, 2, 0]])np.random.randint(0,10,size=(2,3,5))#创建三维数组
#输出为：
array([[[8, 1, 2, 7, 1],[0, 2, 3, 0, 7],[7, 1, 8, 7, 2]],[[3, 2, 6, 3, 6],[4, 6, 8, 0, 9],[5, 1, 3, 0, 4]]])arr7 = np.random.randn(5)
# 正态分布 输出为：array([ 0.57807872,  0.37922855,  2.37936837, -0.28688769,  0.2882854 ])arr8 = np.random.random(size = 5)
# float 随机数 输出为：array([0.59646412, 0.37960586, 0.38077327, 0.76983539, 0.22689201])np.set_printoptions(suppress=True)#不显示科学计数法np.logspace(0,10,base=2,num=11)#等比数列，0到10，倍数为2，个数11个
#输出为：
array([   1.,    2.,    4.,    8.,   16.,   32.,   64.,  128.,  256.,512., 1024.])```

第二节  查看操作

* jupyter扩展插件（不安装）
  * pip install jupyter_contrib_nbextensions -i https://pypi.tuna.tsinghua.edu.cn/simple
  * pip install jupyter_nbextensions_configurator -i https://pypi.tuna.tsinghua.edu.cn/simple
  * jupyter contrib nbextension install --user
  * jupyter nbextensions_configurator enable --user
  * **退出，重新进入jupyter notebook就可以了**

NumPy的数组类称为ndarray，也被称为别名 array。请注意，numpy.array这与标准Python库类不同array.array，后者仅处理一维数组且功能较少。ndarray对象的重要属性是

1.2.1 数组的轴数、维度

```python
import numpy as np
arr = np.random.randint(0,100,size = (3,4,5))
arr.ndim # 输出 3
```

1.2.2 数组尺寸形状

```python
import numpy as np
arr = np.random.randint(0,100,size = (3,4,5))
arr.shape # 输出 (3,4,5)
```

1.2.3 数组元素的总数

```python
import numpy as np
arr = np.random.randint(0,100,size = (3,4,5))
arr.size # 输出 3*4*5 = 60
```

1.2.4 数据类型

```python
import numpy as np
arr = np.random.randint(0,100,size = (3,4,5))
arr.dtype # 输出 dtype('int64')
```

1.2.5 数组中每个元素的大小（以字节为单位）

```python
import numpy as np
arr = np.random.randint(0,100,size = (3,4,5))
arr.itemsize #输出是 8 ，因为数据类型是int64，64位，一个字节是8位，所以64/8 = 8
```

第三节 文件IO操作

1.3.1 保存数组

save方法保存ndarray到一个npy文件，也可以使用savez将多个array保存到一个.npz文件中

```python
arr=np.arange(0,10,3)
np.save('./tata1',arr)#在当前文件夹下保存arr，取名为tata1
np.load('./tata1.npy')#取出数据#输出为：
array([0, 3, 6, 9])arr2=np.logspace(0,10,base=2,num=11)#创建arr2等比数列
np.savez('./tata2.npz',x=arr,y=arr2)#将arr和arr2两个文件进行保存,x,y名字随取
np.load('./tata2.npz')['x']#读取arr
np.load('./tata2.npz')['y']#读取arr2#输出为：
array([   1.,    2.,    4.,    8.,   16.,   32.,   64.,  128.,  256.,512., 1024.])```

1.3.2 读取

load方法来读取存储的数组，如果是.npz文件的话，读取之后相当于形成了一个key-value类型的变量，通过保存时定义的key来获取相应的array

```python
np.load('x_arr.npy') # 直接加载# 通过key获取保存的数组数据
np.load('some_array.npz')['yarr']
```

1.3.3 读写csv、txt文件

```python
arr = np.random.randint(0,10,size = (3,4))
#储存数组到txt文件
np.savetxt("arr.csv",arr,delimiter=',') # 文件后缀是txt也是一样的
#读取txt文件，delimiter为分隔符，dtype为数据类型
np.loadtxt("arr.csv",delimiter=',',dtype=np.int32)
```

第二部分 数据类型

ndarray的数据类型：

- int: int8、uint8、int16、int32、int64（uint无负数，只去正数）
- float: float16、float32、float64
- str

### array创建时，指定```python
import numpy as np
np.array([1,2,5,8,2],dtype = 'float32')
# 输出 ：array([1., 2., 5., 8., 2.], dtype=float32)
```

### asarray转换时指定```python
import numpy as np
arr = [1,3,5,7,2,9,0]
# asarray 将列表进行变换
np.asarray(arr,dtype = 'float32')
# 输出：array([1., 3., 5., 7., 2., 9., 0.], dtype=float32)
```

### 数据类型转换astype```python
import numpy as np
arr = np.random.randint(0,10,size = 5,dtype = 'int16')
# 输出：array([6, 6, 6, 6, 3], dtype=int16)
# 使用astype进行转换，原来的数组没变，生成了新额数组
arr.astype('float32') # 输出：array([1., 4., 0., 6., 6.], dtype=float32)
```

第三部分 数组运算

### 加减乘除幂运算```python
import numpy as np
arr1 = np.array([1,2,3,4,5])
arr2 = np.array([2,3,1,5,9])
arr1 - arr2 # 减法
arr1 * arr2 # 乘法
arr1 / arr2 # 除法
arr1**arr2 # 两个星号表示幂运算

### 逻辑运算```python
import numpy as np
arr1 = np.array([1,2,3,4,5])
arr2 = np.array([1,0,2,3,5])
arr1 < 5
arr1 >= 5
arr1 == 5
arr1 == arr2
arr1 > arr2
```

### 数组与标量计算数组与标量的算术运算也会将标量值传播到各个元素```python
import numpy as np
arr = np.arange(1,10)
1/arr
arr+5
arr*5
```

### *=、+=、-=操作 某些操作（例如+=和*=）只会修改现有数组，而不是创建一个新数组。```python
import numpy as np
arr1 = np.arange(5)
arr1 +=5
arr1 -=5
arr1 *=5
# arr1 /=5 不支持运算
```

第四部分 复制和视图

在操作数组时，有时会将其数据复制到新数组中，有时不复制。

对于初学者来说，这通常会引起混乱。有以下三种情况

### 完全没有复制```python
import numpy as np
a = np.random.randint(0,100,size = (4,5))
b = a
a is b # 返回True a和b是两个不同名字对应同一个内存对象
b[0,0] = 1024 # 命运共同体
display(a,b)
```

### 查看或浅拷贝不同的数组对象可以共享相同的数据。该view方法创建一个查看相同数据的新数组对象```python
import numpy as np
a = np.random.randint(0,100,size = (4,5))
b = a.view() # 使用a中的数据创建一个新数组对象
a is b # 返回False a和b是两个不同名字对应同一个内存对象
b.base is a # 返回True，b视图的根数据和a一样
b.flags.owndata # 返回False b中的数据不是其自己的
a.flags.owndata # 返回True a中的数据是其自己的
b[0,0] = 1024 # a和b的数据都发生改变
display(a,b)
```

### 深拷贝```python
import numpy as np
a = np.random.randint(0,100,size = (4,5))
b = a.copy()
b is a # 返回False
b.base is a # 返回False
b.flags.owndata # 返回True
a.flags.owndata # 返回True
b[0,0] = 1024 # b改变，a不变，分道扬镳
display(a,b)
```* copy应该在不再需要原来的数组情况下，切片后调用。例如，假设a是一个巨大的中间结果，而最终结果b仅包含的一小部分a，则在b使用切片进行构造时应制作一个深拷贝：```pythonimport numpy as npa = np.arange(1e8)b = a[::1000000].copy() # 每100万个数据中取一个数据del a # 不在需要a，删除占大内存的ab.shape # shape(100,)```

第五部分 索引、切片和迭代

 第一节 基本索引和切片numpy中数组切片是原始数组的视图，这意味着数据不会被复制，视图上任何数据的修改都会反映到原数组上```python
arr = np.array([0,1,2,3,4,5,6,7,8,9])
arr[5] #索引 输出 5
arr[5:8] #切片输出：array([5, 6, 7])
arr[2::2] # 从索引2开始每两个中取一个 输出 array([2, 4, 6, 8])
arr[::3] # 不写索引默认从0开始，每3个中取一个 输出为 array([0, 3, 6, 9])
arr[1:7:2] # 从索引1开始到索引7结束，左闭右开，每2个数中取一个 输出 array([1, 3, 5])
arr[::-1] # 倒序 输出 array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])
arr[::-2] # 倒序 每两个取一个 输出  array([9, 7, 5, 3, 1])
arr[5:8]=12 # 切片赋值会赋值到每个元素上，与列表操作不同
temp = arr[5:8]
temp[1] = 1024
arr # 输出：array([   0,    1,    2,    3,    4,   12, 1024,   12,    8,    9])对于二维数组或者高维数组，我们可以按照之前的知识来索引，当然也可以传入一个以逗号隔开的索引列表来选区单个或多个元素```python
arr2d = np.array([[1,3,5],[2,4,6],[-2,-7,-9],[6,6,6]]) # 二维数组 shape(3,4)
arr2d[0,-1] #索引 等于arr2d[0][-1] 输出 5
arr2d[0,2]  #索引 等于arr2d[0][2] ==  arr2d[0][-1] 输出 5arr2d[:2,-2:] #切片 第一维和第二维都进行切片 等于arr2d[:2][:,1:]
arr2d[:2,1:] #切片 1 == -2 一个是正序，另个一是倒序，对应相同的位置
# 输出：
#array([[3, 5],
#       [4, 6]])arr2=np.random.randint(0,100,size=(3,5))
arr2
#输出：
array([[44, 80, 74, 62, 83],[63, 74, 45, 16, 36],[75, 73, 86, 33, 88]])arr2[0,[2,3]]#第一行，第三四列数据
#输出：
array([74, 62])arr2[[1,2],3:]#获取第二三行，第四五列数据。索引配合切片使用
#输出：
array([[16, 36],[33, 88]])arr2[[1,2]][:,[3,4]]#与上面的方法同样效果，先取出所需行的所有数据，再列索引获取数据
#输出：
array([[16, 36],[33, 88]])arr2[[0,2]][:,[0,2,4]]
#输出：
array([[44, 74, 83],[75, 86, 88]])arr2[2,[0,2,4]]=1024#替换
arr2
#输出：
array([[  44,   80,   74,   62,   83],[  63,   74,   45,   16,   36],[1024,   73, 1024,   33, 1024]])arr=np.random.randint(0,100,size=(4,6))
arr
#输出：
array([[85, 82, 91, 28, 99, 96],[88, 71, 50, 96, 91, 37],[73, 39, 33, 49, 59, 28],[39, 28, 86, 46,  5, 71]])ex=np.ix_([1,2],[1,3,5])#ix_函数获取对应行列值的索引
arr[index]#相当于arr[[1,2]][;,[1,3,5]]
#输出：array([[71, 96, 37],[39, 49, 28]])```

 第二节 花式索引和索引技巧* 整数数组进行索引即花式索引,其和切片不一样，它总是将数据复制到新数组中```python
import numpy as np
#一维
arr1 = np.array([1,2,3,4,5,6,7,8,9,10])
arr2 = arr1[[1,3,3,5,7,7,7]] # 输出 array([2, 4, 4, 6, 8, 8, 8])
arr2[-1] = 1024 # 修改值，不影响arr1
#二维
arr2d = np.array([[1,3,5,7,9],[2,4,6,8,10],[12,18,22,23,37],[123,55,17,88,103]]) #shape(4,5)
arr2d[[1,3]] # 获取第二行和第四行，索引从0开始的所以1对应第二行
# 输出 array([[  2,   4,   6,   8,  10],
#            [123,  55,  17,  88, 103]])
arr2d[([1,3],[2,4])] # 相当于arr2d[1,2]获取一个元素,arr2d[3,4]获取另一个元素
# 输出为 array([  6, 103])
# 选择一个区域
arr2d[np.ix_([1,3,3,3],[2,4,4])] # 相当于 arr2d[[1,3,3,3]][:,[2,4,4]]
arr2d[[1,3,3,3]][:,[2,4,4]]
# ix_()函数可用于组合不同的向量
# 第一个列表存的是待提取元素的行标，第二个列表存的是待提取元素的列标
# 输出为
# array([[  6,  10,  10],
#        [ 17, 103, 103],
#        [ 17, 103, 103],
#        [ 17, 103, 103]])
```* boolean值索引```python
names = np.array(['softpo','Brandon','Will','Michael','Will','Ella','Daniel','softpo','Will','Brandon'])
cond1 = names == 'Will'
cond1
# 输出array([False, False,  True, False,  True, False, False, False,  True, False])
names[cond1] # array(['Will', 'Will', 'Will'], dtype='<U7')
arr = np.random.randint(0,100,size = (10,8)) # 0~100随机数
cond2 = arr > 90
# 找到所有大于90的索引，返回boolean类型的数组 shape(10,8)，大于返回True，否则False
arr[cond2] # 返回数据全部是大于90的
---------------------------------------------------------------------------arr=np.random.randint(0,100,size=20)
arr
#输出：
array([37, 55, 27, 27, 64, 22, 14, 96, 31, 49, 12, 61, 82, 30, 41, 21, 22,72, 68,  0])arr[[3,5,7]]#取出不同索引对应值
#输出：
array([27, 22, 96])cond=arr>60
cond
arr[cond]
#输出：
array([64, 96, 61, 82, 72, 68])#取出小于30或大于80
cond1=arr<30
cond2=arr>80
cond=cond1|cond2#或运算
arr[cond]
#输出：
array([27, 27, 22, 14, 96, 12, 82, 21, 22,  0])arr=np.random.randint(0,100,size=(4,6))
arr
#输出：
array([[85, 82, 91, 28, 99, 96],[88, 71, 50, 96, 91, 37],[73, 39, 33, 49, 59, 28],[39, 28, 86, 46,  5, 71]])index=np.ix_([1,2],[1,3,5])#ix_函数获取对应行列值的索引
arr[index]#相当于arr[[1,2]][;,[1,3,5]]
#输出：array([[71, 96, 37],[39, 49, 28]])nd2=np.random.randint(0,100,size=(3,4))
display(nd2)
#输出：array([[71, 10, 31, 78],[81, 56, 95, 57],[98, 76, 60, 97]])#数据重塑reshape
nd2.reshape(4,3)#重塑顺序，一行一行顺序接龙
#输出：array([[71, 10, 31],[78, 81, 56],[95, 57, 98],[76, 60, 97]])nd2.reshape(-1,6)#2行6列
#其中-1代表x,x的计算过程：x*6=4*3---->x=2
#适合不关心总数的计算
#输出：array([[71, 10, 31, 78, 81, 56],[95, 57, 98, 76, 60, 97]])nd2.reshape(-1)
#输出：array([71, 10, 31, 78, 81, 56, 95, 57, 98, 76, 60, 97])```

第六部分 形状操作

数组变形```python
import numpy as np
arr1 = np.random.randint(0,10,size = (3,4,5))
arr2 = arr1.reshape(12,5) # 形状改变，返回新数组
arr3 = arr1.reshape(-1,5) # 自动“整形”，自动计算
```

数组转置```python
import numpy as np
arr1 = np.random.randint(0,10,size = (3,5)) # shape(3,5)
arr1.T # shape(5,3) 转置
arr2 = np.random.randint(0,10,size = (3,6,4)) # shape(3,6,4)
np.transpose(arr2,axes=(2,0,1)) # transpose改变数组维度 shape(4,3,6)------------------------------------------------------------------
A=np.random.randint(0,10,size=(3,5))
display(A)
#输出：array([[2, 6, 3, 1, 6],[3, 9, 5, 4, 3],[6, 0, 8, 1, 1]])display(A.reshape(5,3))#形状改变
#输出：array([[2, 6, 3],[1, 6, 3],[9, 5, 4],[3, 6, 0],[8, 1, 1]])display(A.T)#转置，行变列，列变行
#输出：array([[2, 3, 6],[6, 9, 0],[3, 5, 8],[1, 4, 1],[6, 3, 1]])np.transpose(A,axes=[1,0])#转置方法2，行变列，列变行
#输出：array([[2, 3, 6],[6, 9, 0],[3, 5, 8],[1, 4, 1],[6, 3, 1]])arr1=np.random.randint(0,10,size=(5,3))
arr2=np.arange(1,4)
display(arr1,arr2)#广播让arr2增加了4份，每一份和每一行相加
#输出：array([[5, 3, 6],[8, 5, 3],[4, 5, 3],[2, 1, 2],[6, 3, 1]])
array([1, 2, 3])arr1+arr2
#输出：array([[6, 5, 9],[9, 7, 6],[5, 7, 6],[3, 3, 5],[7, 5, 4]])arr3=np.random.randint(0,10,size=(4,5))
arr4=arr3.mean(axis=1)#算每一行的平均值
display(arr3,arr4)
#输出：array([[5, 6, 0, 5, 3],[6, 4, 9, 9, 5],[8, 0, 5, 9, 7],[4, 6, 4, 5, 0]])
array([3.8, 6.6, 5.8, 3.8])display(arr4.reshape(4,1))#形状改变后，列数相等，可以广播
arr3-arr4.reshape(4,1)
#输出：array([[3.8],[6.6],[5.8],[3.8]])
Out[141]:
array([[ 1.2,  2.2, -3.8,  1.2, -0.8],[-0.6, -2.6,  2.4,  2.4, -1.6],[ 2.2, -5.8, -0.8,  3.2,  1.2],[ 0.2,  2.2,  0.2,  1.2, -3.8]])import numpy as np
arr1 = np.array([0,1,2,3,4,5,6,7]*3).reshape(3,4,2) #shape(3,4,2)
arr2 = np.array([0,1,2,3,4,5,6,7]).reshape(4,2) #shape(4,2)
arr3 = arr1 + arr2 # arr2数组在0维上复制3份 shape(3,4,2)
arr3
#输出：array([[[ 0,  2],[ 4,  6],[ 8, 10],[12, 14]],[[ 0,  2],[ 4,  6],[ 8, 10],[12, 14]],[[ 0,  2],[ 4,  6],[ 8, 10],[12, 14]]])

 数组堆叠```python
import numpy as np
arr1 = np.array([[1,2,3]])
arr2 = np.array([[4,5,6]])
np.concatenate([arr1,arr2],axis = 0)
# 串联合并shape(2,3) axis = 0表示第一维串联 输出为
# array([[1, 2, 3],
#        [4, 5, 6]])
np.concatenate([arr1,arr2],axis = 1)
# shape(1,6) axis = 1表示第二维串联 输出为：array([[1, 2, 3, 4, 5, 6]])np.hstack((arr1,arr2)) # 水平方向堆叠 输出为：array([[1, 2, 3, 4, 5, 6]])
np.vstack((arr1,arr2))
# 竖直方向堆叠，输出为：
# array([[1, 2, 3],
#        [4, 5, 6]])
```--------------------------------------------------------------------------
arr1=np.random.randint(0,10,size=(3,4))
arr2=np.random.randint(-5,5,size=(3,4))
display(arr1,arr2)
#输出：array([[8, 8, 6, 1],[7, 8, 0, 6],[6, 4, 0, 6]])
array([[ 3, -4, -1, -3],[ 0,  1,  2,  4],[-1,  0, -1, -3]])#合并
np.concatenate([arr1,arr2,arr1])#默认竖式叠加
#输出：array([[ 8,  8,  6,  1],[ 7,  8,  0,  6],[ 6,  4,  0,  6],[ 3, -4, -1, -3],[ 0,  1,  2,  4],[-1,  0, -1, -3],[ 8,  8,  6,  1],[ 7,  8,  0,  6],[ 6,  4,  0,  6]])np.concatenate((arr1,arr2),axis=1)#axis=1,横式叠加
#输出：array([[ 8,  8,  6,  1,  3, -4, -1, -3],[ 7,  8,  0,  6,  0,  1,  2,  4],[ 6,  4,  0,  6, -1,  0, -1, -3]])

split数组拆分```python
import numpy as np
arr = np.random.randint(0,10,size = (6,5)) # shape(6,5)
np.split(arr,indices_or_sections=2,axis = 0) # 在第一维（6）平均分成两份
np.split(arr,indices_or_sections=[2,3],axis = 1) # 在第二维（5）以索引2，3为断点分割成3份np.vsplit(arr,indices_or_sections=3) # 在竖直方向平均分割成3份
np.hsplit(arr,indices_or_sections=[1,4]) # 在水平方向，以索引1，4为断点分割成3份
```
------------------------------------------------------------------------------
nd=np.random.randint(0,100,size=(6,9))
nd
np.split(nd,2)#split将数组拆分两份
#输出：[array([[46, 37, 45, 68, 39, 71, 95, 49,  8],[98,  2, 99, 57, 94, 58, 51, 51,  7],[17, 75, 86, 22, 90, 20, 45, 84, 90]]),array([[33, 56, 92, 24, 74, 66, 31, 13, 61],[ 4, 65, 15, 42, 42, 50,  2, 25, 39],[50, 91, 18, 19, 65, 29,  4, 10,  6]])]np.split(nd,[1,3,5],axis=1)#在指定索引的位置拆分，axis=1竖拆
#输出：[array([[46],[98],[17],[33],[ 4],[50]]),array([[37, 45],[ 2, 99],[75, 86],[56, 92],[65, 15],[91, 18]]),array([[68, 39],[57, 94],[22, 90],[24, 74],[42, 42],[19, 65]]),array([[71, 95, 49,  8],[58, 51, 51,  7],[20, 45, 84, 90],[66, 31, 13, 61],[50,  2, 25, 39],[29,  4, 10,  6]])]

第七部分 广播机制

当两个数组的形状并不相同的时候，我们可以通过扩展数组的方法来实现相加、相减、相乘等操作，这种机制叫做广播（broadcasting）

 一维数组广播![](./images/广播1.png)```python
import numpy as np
arr1 = np.sort(np.array([0,1,2,3]*3)).reshape(4,3) #shape(4,3)
arr2 = np.array([1,2,3]) # shape(3,)
arr3 = arr1 + arr2 # arr2进行广播复制4份 shape(4,3)
arr3
```

 二维数组的广播![](./images/广播2.png)```python
import numpy as np
arr1 = np.sort(np.array([0,1,2,3]*3)).reshape(4,3) # shape(4,3)
arr2 = np.array([[1],[2],[3],[4]]) # shape(4,1)
arr3 = arr1 + arr2 # arr2 进行广播复制3份 shape(4,3)
arr3
```

三维数组广播![](./images/广播3.png)```python
import numpy as np
arr1 = np.array([0,1,2,3,4,5,6,7]*3).reshape(3,4,2) #shape(3,4,2)
arr2 = np.array([0,1,2,3,4,5,6,7]).reshape(4,2) #shape(4,2)
arr3 = arr1 + arr2 # arr2数组在0维上复制3份 shape(3,4,2)
arr3
```![](./images/广播4.png)

第八部分 通用函数

第一节 通用函数：元素级数字函数abs、sqrt、square、exp、log、sin、cos、tan，maxinmum、minimum、all、any、inner、clip、round、trace、ceil、floor```python
import numpy as np
arr1 = np.array([1,4,8,9,16,25])
np.sqrt(arr1) # 开平方
np.square(arr1) # 平方
np.clip(arr1,2,16) # 输出 array([ 2,  4,  8,  9, 16, 16])x = np.array([1,5,2,9,3,6,8])
y = np.array([2,4,3,7,1,9,0])
np.maximum(x,y) # 返回两个数组中的比较大的值
arr2 = np.random.randint(0,10,size = (5,5))
np.inner(arr2[0],arr2) #返回一维数组向量内积
```### 第二节 where函数where 函数，三个参数，条件为真时选择值的数组，条件为假时选择值的数组```python
import numpy as np
arr1 = np.array([1,3,5,7,9])
arr2 = np.array([2,4,6,8,10])
cond = np.array([True,False,True,True,False])
np.where(cond,arr1,arr2) # True选择arr1，False选择arr2的值
# 输出 array([ 1,  4,  5,  7, 10])arr3 = np.random.randint(0,30,size = 20)
np.where(arr3 < 15,arr3,-15) # 小于15还是自身的值，大于15设置成-15
```### 第三节 排序方法np中还提供了排序方法，排序方法是就地排序，即直接改变原数组arr.sort()、np.sort()、arr.argsort()```python
import numpy as np
arr = np.array([9,3,11,6,17,5,4,15,1])
arr.sort() # 直接改变原数组
np.sort(arr) # 返回深拷贝排序结果
arr = np.array([9,3,11,6,17,5,4,15,1])
arr.argsort() # 返回从小到大排序索引 array([8, 1, 6, 5, 3, 0, 2, 7, 4])
```### 第四节 集合运算函数```python
A = np.array([2,4,6,8])
B = np.array([3,4,5,6])
np.intersect1d(A,B) # 交集 array([4, 6])
np.union1d(A,B) # 并集 array([2, 3, 4, 5, 6, 8])
np.setdiff1d(A,B) #差集，A中有，B中没有 array([2, 8])
```### 第五节 数学和统计函数min、max、mean、median、sum、std、var、cumsum、cumprod、argmin、argmax、argwhere、cov、corrcoef```python
import numpy as np
arr1 = np.array([1,7,2,19,23,0,88,11,6,11])
arr1.min() # 计算最小值 0
arr1.argmax() # 计算最大值的索引 返回 6
np.argwhere(arr1 > 20) # 返回大于20的元素的索引
np.cumsum(arr1) # 计算累加和
arr2 = np.random.randint(0,10,size = (4,5))
arr2.mean(axis = 0) # 计算列的平均值
arr2.mean(axis = 1) # 计算行的平均值
np.cov(arr2,rowvar=True) # 协方差矩阵
np.corrcoef(arr2,rowvar=True) # 相关性系数
```
---------------------------------------------------------------------
np.sin(np.pi/2)#sin90度转化
#输出：1.0
np.cos(np.pi/2).round(1)#保留一位小数函数
#输出：0.0
np.sqrt(4)#开平方
#输出：2.0
np.square(4)#求平方函数
#输出：16
#立方函数
def fun(x):return x**3
fun(3)
#输出：27
np.power(3,3)#用power函数可以直接求几的几次方
#输出27
np.log2(64)
#输出：6.0
x = np.array([1,5,2,9,3,6,8])
y = np.array([2,4,3,7,1,9,0])
np.maximum(x,y) # 返回两个数组中的比较大的值
#输出：array([2, 5, 3, 9, 3, 9, 8])display(arr2)
#输出：array([[0, 1],[2, 3],[4, 5],[6, 7]])
np.inner(arr2[0],arr2)#返回一位数组的一位内积
#输出：array([1, 3, 5, 7])
np.power(8,1/3)#用power函数可以算开n次方
输出：2.0a=3.9999
np.ceil(a)#ceil可以到达天花板
输出：4.0np.floor(a)#floor达到地板
3.0arr=np.random.randint(0,30,size=(100))
arr
输出：
array([23, 29,  3, 26, 25, 11,  7,  6,  0, 23,  6,  7, 13, 13,  2, 12, 10,2, 12,  9,  4, 19, 17,  0,  6, 22, 16, 29, 28, 26,  2, 17, 23, 13,11,  7,  8, 26,  9, 17,  7, 20,  4, 22,  1, 22, 18, 11, 15, 15, 15,18, 13, 28, 28, 22, 13,  2, 15, 11, 10, 11,  0,  4, 21, 18, 19, 29,18,  3,  2, 25,  6, 13, 17, 29,  5,  4, 22, 21, 10,  8,  4, 23, 17,10, 10, 23, 10,  1,  2, 10, 19, 15,  7,  4, 19, 13,  2, 22])np.clip(arr,10,20)#clip裁剪函数，小于10的拉高到10，大于20的裁至20
输出：array([20, 20, 10, 20, 20, 11, 10, 10, 10, 20, 10, 10, 13, 13, 10, 12, 10,10, 12, 10, 10, 19, 17, 10, 10, 20, 16, 20, 20, 20, 10, 17, 20, 13,11, 10, 10, 20, 10, 17, 10, 20, 10, 20, 10, 20, 18, 11, 15, 15, 15,18, 13, 20, 20, 20, 13, 10, 15, 11, 10, 11, 10, 10, 20, 18, 19, 20,18, 10, 10, 20, 10, 13, 17, 20, 10, 10, 20, 20, 10, 10, 10, 20, 17,10, 10, 20, 10, 10, 10, 10, 19, 15, 10, 10, 19, 13, 10, 20])

第九部分 线性代数

矩阵乘积```python
#矩阵的乘积
A = np.array([[4,2,3],[1,3,1]]) # shape(2,3)
B = np.array([[2,7],[-5,-7],[9,3]]) # shape(3,2)
np.dot(A,B) # 矩阵运算 A的最后一维和B的第一维必须一致
A @ B # 符号 @ 表示矩阵乘积运算
```### 矩阵其他计算下面可以计算矩阵的逆、行列式、特征值和特征向量、qr分解值，svd分解值```python
#计算矩阵的逆
from numpy.linalg import inv,det,eig,qr,svd
A = np.array([[1,2,3],[2,3,4],[4,5,8]]) # shape(3,3)
inv(t) # 逆矩阵
det(t)#计算矩阵行列式
```## 第十部分 <font color = red>实战</font>-用NumPy分析鸢尾花花萼属性各项指标案列：读取iris数据集中的花萼长度数据（已保存为csv格式）
并对其进行排序、去重，并求出和、累积和、均值、标准差、方差、最小值、最大值。```python
import numpy as np  # 导入类库 numpy
data = np.loadtxt('./iris.csv',delimiter = ',')  # 读取数据文件，data是二维的数组
data.sort(axis = -1)  # 简单排序
print('简单排序后：', data)
print('数据去重后：', np.unique(data)) # 去除重复数据
print('数据求和：', np.sum(data))  # 数组求和
print('元素求累加和', np.cumsum(data))  # 元素求累加和
print('数据的均值：', np.mean(data))  # 均值
print('数据的标准差：', np.std(data))  # 标准差
print('数据的方差：', np.var(data))  # 方差
print('数据的最小值：', np.min(data))  # 最小值
print('数据的最大值：', np.max(data))  # 最大值
```

科学计算模块Numpy-初级 (2)相关推荐

1. 科学计算工具NumPy（1）：ndarray的创建于数据类型

   科学计算工具NumPy(1):ndarray的创建于数据类型 科学计算工具NumPy(2):ndarray的矩阵处理 科学计算工具NumPy(3):ndarray的元素处理 Numpy(Numeric ...

2. numpy不用科学记数发 python_Python科学计算库Numpy常用的函数使用

   林小森博客: Python科学计算库Numpy常用的函数使用 - 林小森​www.linxiaosen.com Numpy具有强大的计算功能,本文介绍Numpy常用的函数,可以有效的提高工作效率. 首 ...

3. AI常用框架和工具丨1. 科学计算库NumPy

   科学计算库NumPy,AI常用框架和工具之一.理论知识结合代码实例,希望对您有所帮助. 文章目录 环境说明 一.NumPy简介 二.数组 2.1 NumPy数组的优势 2.2 ndarray对象 2. ...

4. 【转】5.3 Python的科学计算包 - Numpy

   numpy(Numerical Python extensions)是一个第三方的Python包,用于科学计算.这个库的前身是1995年就开始开发的一个用于数组运算的库.经过了长时间的发展,基本上成了 ...

5. python矩阵运算法则_导数与梯度、矩阵运算性质、科学计算库numpy

   一.实验介绍 1.1 实验内容 虽然在实验一中我想尽量少的引入(会让人放弃继续学习的)数学概念,但我似乎还是失败了.不过这几乎是没有办法的事,要想真正学会深度学习,没有一定的数学基础(高等数学.线性代 ...

6. 唐宇迪学习笔记1：Python环境安装、Pytho科学计算库——Numpy

   目录 一.AI数据分析入门 ​1.案例来源 2.Python环境配置(Python3) Python的安装 Python库安装工具 Jupyter Notebook 二.Python科学计算库--Nu ...

7. 一文带你熟悉简单实用的Python科学计算库NumPy

   Python科学计算库NumPy 安装 数组的创建 array创建 **arange** 创建 **随机数创建** 方法numpy.random.random(size=None) 方法numpy.r ...

8. 科学计算工具NumPy（3）：ndarray的元素处理

   科学计算工具NumPy(1):ndarray的创建于数据类型 科学计算工具NumPy(2):ndarray的矩阵处理 科学计算工具NumPy(3):ndarray的元素处理 元素计算函数 ceil() ...

9. 科学计算工具NumPy（2）：ndarray的矩阵处理

   科学计算工具NumPy(1):ndarray的创建于数据类型 科学计算工具NumPy(2):ndarray的矩阵处理 科学计算工具NumPy(3):ndarray的元素处理 ndarray的矩阵运算 ...

10. numpy 创建加一行_数据科学|可视化图解Python科学计算包Numpy

    文章申明 文章作者:梁斌伟 责任编辑:郭德真 微信编辑:玖蓁 本文转载自公众号 实战统计学 (ID:statrcn) 原文链接:可视化图解Python科学计算包NumPy 作者:梁斌伟 编者按: 你真 ...

最新文章

1. android 记一次富文本加载之路
2. C++ 哪些函数不能声明成虚函数
3. kubesphere devops介绍、访问账密及nfs数据备份同步
4. 用docker安装mysql5-6，并远程连接
5. 細微之處看看mysql與sql server的一些差別
6. android studio adb 命令行,Android Studio如何配置adb以及经常使用命令
7. FluorineFx：视频录制及回放(Flash/AS3环境)
8. 【Flink】Flink classloader.check-leaked-classloader
9. mysql远程定时任务_Linux下定时任务实现mysql自动备份并上传远程ftp
10. L2-018 多项式A除以B（模拟）
11. [论文笔记]DistilBERT, a distilled version of BERT: smaller, faster, cheaper and lighter
12. SharePoint2010内容类型剖析（三）
13. 2017.10.16 模拟赛
14. 深海迷航坐标传送代码_深海迷航代码输入方法
15. [每日一氵] openCV resize函数直接按比例缩放
16. 房地产开发项目管理浅析
17. jquery $.fn 是什么意思
18. win10 c++调用pytorch模型
19. j3455跑mysql_基于J3455搭建NAS
20. Unity 播放声音

热门文章

1. Matlab 图片转gif
2. 地方性自媒体如何运营？微信公众号可以做地方性自媒体吗？
3. 下载并安装windows版本的Redis
4. json 中关于json数组跟json对象的区别
5. matlab中sym(3 4),Matlab中sym 的用法
6. 经典论文解析——YOLOv1——目标检测
7. Java系列： 如何在Eclipse中安装Memory Analyzer插件
8. 台式计算机硬盘英寸,浅谈3.5英寸硬盘与2.5英寸硬盘的区别
9. 【数模之文本文件操作】
10. mysql源生插入数据_php+mysql源生连接数据库和增删改查数据