Python 科学计算小白到大白 ----＞numpy

最新推荐文章于 2021-02-09 21:44:27 发布

沃特艾文儿～

最新推荐文章于 2021-02-09 21:44:27 发布

阅读量334

点赞数 4

分类专栏： python 爬虫文章标签： python numpy

本文链接：https://blog.csdn.net/qq_44614115/article/details/108762941

版权

python 同时被 2 个专栏收录

35 篇文章 1 订阅

订阅专栏

爬虫

5 篇文章 0 订阅

订阅专栏

Numpy

α 简介

Numpy 是一个开源的Python科学计算库，在处理大型矩阵方面有着很高的效率（其底层函数有许多是 C 写的），是使用普通Pyhton自行处理矩阵的处理速度所不能比拟的，这也是使用Python进行科学计算基本都是需要以Numpy为基础的原因，以后我们介绍的 scipy， pandas，scikit-Learn ，matplotlib 等都需要其作为支撑.

β 安装 Numpy

β1.在安装 Numpy 之前，首先要确保 Pyhton 已经安装完成，很简单使用cmd敲入pyhton显示而下图即可（版本不同无妨）如果显示不是可运行程序或者批处理文件，请点击这里~

只要显示Pyhton版本即可

β2. 如果您安装了anaconda，那么就说明 Numpy 已经安装好了，如果不相信可以再安装一下.

β3. anaconda 安装 Numpy 的方法（重新打开一个cmd）.

在这里插入图片描述

β4. Pyhton 安装 Numpy 的方法（重新打开一个cmd）.

在这里插入图片描述
大概会变成这个鬼样子。。。

在这里插入图片描述
β5. 如果安装失败可以考虑使用管理员身份运行.

γ 使用 Numpy

Numpy 的一个重要对象是 —— Ndarray 对象

γ.1 与标准库中的 array 的区别

标准库的 array.array 类只能处理一维数据，而对于科学计算来说，处理数据的维度根本不能被其满足.而Numpy 中的 ndarray 属于同质多维数组，可以很好地满足科学计算的需求.

γ.2 Numpy 的数据类型

作为科学计算的专用工具，其数据类型肯定比一般Pyhton中自带的数据类型多，那我们来看一下都有些什么呢,我们可以调用函数进行查阅.

set(np.typeDict.values())

"""
{numpy.bool_,
 numpy.bytes_,
 numpy.complex128,
 numpy.complex128,
 numpy.complex64,
 numpy.datetime64,
 numpy.float16,
 numpy.float32,
 numpy.float64,
 numpy.float64,
 numpy.int16,
 numpy.int32,
 numpy.int32,
 numpy.int64,
 numpy.int8,
 numpy.object_,
 numpy.str_,
 numpy.timedelta64,
 numpy.uint16,
 numpy.uint32,
 numpy.uint32,
 numpy.uint64,
 numpy.uint8,
 numpy.void}
"""

γ.3 Numpy 数组构建以及数据类型转换

import numpy as np

# 创建数组
list1 = [[1,2],[3,4]];
array1 = np.array(list1) # 根据已有列表创建

array2 = np.array([[[1,2],[3,4]],[[5,6],[7,8]]]) # 三维数组
"""
array([[[1, 2],
        [3, 4]],

       [[5, 6],
        [7, 8]]])
"""

# 使用 dtype 指定数据类型
array3 = np.array(5,dtype=int)
"""
array(5)
"""
array4 = np.array(99,dtype=float)
"""
array(5.)
"""

#使用 asype 数据类型转化
array5 = array3.astype(float)

# list 创建 数组
array6 = np.array([12,2,3,4,5])
# tuple 创建 数组
array7 = np.array((1,2,3,5))
# dict 创建 数组
array8 = np.array({'a':1,'b':2})
"""
array({'a': 1, 'b': 2}, dtype=object)
"""

#生成数组全是1的数组
array9 = np.ones((2,3)) # (2,3) 指的是每个维度的数目 二维
"""
array([[1., 1., 1.],
       [1., 1., 1.]])
"""
#生成数组全是1的数组
array10 = np.zeros((2,2,3)) # (2,2,3) 指的是每个维度的数目 三维
"""
array([[[0., 0., 0.],
        [0., 0., 0.]],

       [[0., 0., 0.],
        [0., 0., 0.]]])
"""

array11 = np.zeros_like(array10) # ones_like 或者 zeros_like 分别返回一个和已有数组相同维度的全1或全0数组
"""
array([[[0., 0., 0.],
        [0., 0., 0.]],

       [[0., 0., 0.],
        [0., 0., 0.]]])
"""

γ.4 Numpy 对象的基本操作函数

求矩阵转置

# 求转置的两种方法 对于转置 这里不展开讲解,多维的矩阵转置还需要参考数学方面知识
array2
"""
array([[[1, 2],
        [3, 4]],

       [[5, 6],
        [7, 8]]])
"""
array2.T
array2.transpose()
"""
array([[[1, 5],
        [3, 7]],

       [[2, 6],
        [4, 8]]])
"""

构造数组

构造固定步长的数组
numpy.arange(start, stop, step, dtype)
start : 起始值默认为 0（包括）
stop : 终止值（不包括）
step : 步长默认为 1（每一个相邻数据之间的）
dtype : 指定 ndarray 的数据类型，默认使用输入数据的类型

# 缺省的形式
data1 = np.arange(5)  # 只有一个数据 默认 start 为 0 , step 为 1
"""
array([0, 1, 2, 3, 4])
"""
data2 = np.arange(3,10) # 只有两个数据 默认  step 为 1
"""
array([3, 4, 5, 6, 7, 8, 9])
"""
data3 = np.arange(2,20,3) # 三个数据 start 为 2 step 为 3 stop 为 20
"""
array([ 2,  5,  8, 11, 14, 17])
"""
data4 = np.arange(2,20,3,dtype=float) # 数据与 data3 相等,指定其类型为float
"""
array([ 2.,  5.,  8., 11., 14., 17.])
"""

构造固定数目元素的数组
np.linspace(start,stop, num, endpoint=True, retstep=False, dtype=None)
start : 起始值
stop : 序列的终止值根据 endpoint 来判断是否包含此终点值
num : 要生成的等步长的样本数量默认为 50
endpoint : bool类型如果为True 数列中包含stop 否则不包含（默认为true）
retstep : bool类型如果为 True 数列中会显示间距，反之不显示（默认为false）
dtype : 用来指定 ndarray 的数据类型默认为输入数据的类型

# 缺省的情况
data1 = np.linspace(1,3) # 默认产生50个元素
"""
array([1.        , 1.04081633, 1.08163265, 1.12244898, 1.16326531,
       1.20408163, 1.24489796, 1.28571429, 1.32653061, 1.36734694,
       1.40816327, 1.44897959, 1.48979592, 1.53061224, 1.57142857,
       1.6122449 , 1.65306122, 1.69387755, 1.73469388, 1.7755102 ,
       1.81632653, 1.85714286, 1.89795918, 1.93877551, 1.97959184,
       2.02040816, 2.06122449, 2.10204082, 2.14285714, 2.18367347,
       2.2244898 , 2.26530612, 2.30612245, 2.34693878, 2.3877551 ,
       2.42857143, 2.46938776, 2.51020408, 2.55102041, 2.59183673,
       2.63265306, 2.67346939, 2.71428571, 2.75510204, 2.79591837,
       2.83673469, 2.87755102, 2.91836735, 2.95918367, 3.        ])
"""
data2 = np.linspace(0,2,3,endpoint=True)
"""
array([0., 1., 2.])
"""
data3 = np.linspace(0,2,3,endpoint=False)
"""
array([0.        , 0.66666667, 1.33333333])
"""
data4 = np.linspace(0,2,3) # 缺省情况下默认包括端值（2）
"""
array([0., 1., 2.])
"""
data5 = np.linspace(0,6,3,retstep=True) # 显示间距
"""
(array([0., 3., 6.]), 3.0)
"""

data6 = np.linspace(0,6,3) # 默认不显示间距
"""
array([0., 3., 6.])
"""

numpy 从已有的数组创建数组

# numpy.asarray(a, dtype = None, order = None)
# 与 numpy.array() 相比 参数较少
"""
a : 任意形式的输入参数，可以是列表, 列表的元组, 元组等形式
dtype : 数据类型，可选
order : 可选，有"C"（C语言-row-major）和"F"（Fortran语言-column-major）两个选项,分别代表，行优先和列优先，

这个选项影响其在计算机内存中的存储元素的顺序，而对表现形式无影响
"""
data1 = np.array([[1,2,3],[14,34,56]])

data2 = np.asarray(data1,order= "F")
"""
array([[ 1,  2,  3],
       [14, 34, 56]])
"""
data3 = np.asarray(data1,order = "C")
"""
array([[ 1,  2,  3],
       [14, 34, 56]])
"""


# numpy.frombuffer 用于实现动态数组
# numpy.frombuffer 接受 buffer 输入参数，以流的形式读入转化成 ndarray 对象

# numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)
"""
buffer : 可以是任意对象，会以流的形式读入
dtype : 返回数组的数据类型，可选
count : 读取的数据数量，默认为-1，读取所有数据
offset : 读取的起始位置，默认为0
"""
data4 =  b'Hello World' 
data5 = np.frombuffer(data4, dtype =  'S1')  # dtype = 'S1' 表示 数组包含长度为1的字符串
# [b'H' b'e' b'l' b'l' b'o' b' ' b'W' b'o' b'r' b'l' b'd']

#  np.tile() 把数组沿各个方向复制

array5 = np.array([[1,2],[3,5]])
array6 = np.tile(array5,(2,3)) #  复制两倍与三倍
"""
array([[1, 2, 1, 2, 1, 2],
       [3, 5, 3, 5, 3, 5],
       [1, 2, 1, 2, 1, 2],
       [3, 5, 3, 5, 3, 5]])
"""

函数运算

NumPy 包含大量的各种数学运算的函数,因此对于科学运算比较友好

3.1 算术函数（前提是数组必须具有相同的形状或符合数组广播规则）

### 先讨论形状相同的情况，广播规则之后再说
a = np.arange(10).reshape(2,5)
"""
array([[0, 1, 2, 3, 4],
       [5, 6, 7, 8, 9]])
"""
b = np.arange(1,11,1).reshape(2,5)
"""
array([[ 1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10]])
"""
# np.add(a,b)
# np.subtract(a,b)
# np.multiply(a,b)
# np.divide(a,b)
# 同时也可以使用+-*/进行操作 ，效果一样
a - b
"""
array([[-1, -1, -1, -1, -1],
       [-1, -1, -1, -1, -1]])
"""
a + b
"""
array([[ 1,  3,  5,  7,  9],
       [11, 13, 15, 17, 19]])
"""
a*b
"""
array([[ 0,  2,  6, 12, 20],
       [30, 42, 56, 72, 90]])
"""
a/b
"""
array([[0.        , 0.5       , 0.66666667, 0.75      , 0.8       ],
       [0.83333333, 0.85714286, 0.875     , 0.88888889, 0.9       ]])
"""
np.subtract(a,b)
"""
array([[-1, -1, -1, -1, -1],
       [-1, -1, -1, -1, -1]])
"""
np.add(a,b)
"""
array([[ 1,  3,  5,  7,  9],
       [11, 13, 15, 17, 19]])
"""
np.multiply(a,b)
"""
array([[ 0,  2,  6, 12, 20],
       [30, 42, 56, 72, 90]])
"""
np.divide(a,b)
"""
array([[0.        , 0.5       , 0.66666667, 0.75      , 0.8       ],
       [0.83333333, 0.85714286, 0.875     , 0.88888889, 0.9       ]])
"""

3.2 数学函数

data1 = np.linspace(1,10,5) 
# array([ 1.  ,  3.25,  5.5 ,  7.75, 10.  ])
data2 = np.sin(data1*np.pi/180)  # 求正弦函数
# array([0.01745241, 0.05669279, 0.09584575, 0.13485093, 0.17364818])
data3 = np.arcsin(data2) # 求反正弦函数
# array([0.01745329, 0.0567232 , 0.09599311, 0.13526302, 0.17453293])

# numpy.around(a,decimals) 用于四舍五入,第二个参数用于控制精度

data4 = np.around(data1,1)
# array([ 1. ,  3.2,  5.5,  7.8, 10. ])

3.3 统计函数

# numpy.ndim() 用于计算数组的维度数量
# numpy.shape() 用于计算数组的维度
# numpy.amin() 用于计算数组中的元素沿指定轴的最小值
# numpy.amax() 用于计算数组中的元素沿指定轴的最大值
data = np.array([[3,6,1],[5,6,7],[0,86,3]])
data.ndim  
# 2
data.shape
# (3, 3)
np.amin(data,1) # 第二维度
# array([1, 5, 0])
np.amax(data,0) # 第一维度
# array([ 5, 86,  7])

索引与切片

ndarray对象的内容可以通过索引或切片来访问和修改

# 通过切片进行访问数据

# slice(start,end,step) 切片函数
"""
start : 起始值 默认为 0（包括）
stop : 终止值（不包括）
step : 步长 默认为 1（每一个相邻数据之间的）
"""
data = np.arange(10) 
# array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
index1 = slice(2,10,3)
type(index1)  # slice
data[index1] # array([2, 4, 6, 8])

# 通过冒号分隔切片参数 start : end : step 来进行切片操作
# 缺省情况请参考是上述 np.arange() 函数
data[2:7:2] # array([2, 4, 6])
data[2:] # array([2, 3, 4, 5, 6, 7, 8, 9])
data[1:7] # array([1, 2, 3, 4, 5, 6])


# 对于多维数组
data1 = np.array([[1,2,3],[4,5,6],[7,8,9]])
data1[1:]
"""
array([[4, 5, 6],
       [7, 8, 9]])
"""
# 使用省略号"…"来使选择元组的长度与数组的维度相同,如果在行位置使用省略号
# 它将返回包含行中元素的 ndarray
data1[...,2] # array([3, 6, 9]) 第三列
data1[1,...] # array([4, 5, 6]) 第二行

广播机制（Broadcast）
之前在介绍加减乘除四则运算的时候，我们讨论过需要满足各维度相等或者满足数组广播规则，当各维度相等的时候，四则运算或者其他运算可以正常进行，当运算时2 个数组的形状不同时，numpy 将自动触发广播机制

data1 = np.array([[1,2,4],[5,7,8],[9,10,12]])
data2 = np.array([1,2,3])

np.add(data1,data2)
"""
array([[ 2,  4,  7],
       [ 6,  9, 11],
       [10, 12, 15]])
"""
data3 = np.array([1,2])
data2 + data3
"""
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-116-39139c9a25b7> in <module>
----> 1 data2 + data3

ValueError: operands could not be broadcast together with shapes (3,) (2,) 
"""

广播的规则（菜鸟教程给出）：

1.所有输入数组都向其中形状最长的数组看齐，形状中不足的部分都通过在前面加 1 补齐
2.输出数组的形状是输入数组形状的各个维度上的最大值
3.如果输入数组的某个维度和输出数组的对应维度的长度相同或者其长度为 1 时，这个数组能够用来计算，否则出错
4.当输入数组的某个维度的长度为 1 时，沿着此维度运算时都用此维度上的第一组值

广播机制被触发一般会出现在以下两种情况：
1. 当两个数组的维数相同时，有一个数组的某一维度为1
2. 当两个数组的维数不同时, 后缘维度相等

data1 = np.array([[[1,2,3],[1,2,4],[4,5,6]],[[1,2,3],[1,2,4],[4,5,6]]])
data2 = np.array([[1,2,3]])
data1.ndim # 3
data2.ndim # 2
data1 + data2 # 情况2
"""
array([[[2, 4, 6],
        [2, 4, 7],
        [5, 7, 9]],

       [[2, 4, 6],
        [2, 4, 7],
        [5, 7, 9]]])
"""
data3 = np.array([[1,2,3]])
data1 + data3 # 情况1
"""
array([[[2, 4, 6],
        [2, 4, 7],
        [5, 7, 9]],

       [[2, 4, 6],
        [2, 4, 7],
        [5, 7, 9]]])
"""
data4 = np.array([[1,2]])
data4.ndim # 2 
data1 + data4
"""
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-139-db17f51eb93b> in <module>
     25 """
     26 data4 = np.array([[1,2]])
---> 27 data1 + data4

ValueError: operands could not be broadcast together with shapes (2,3,3) (1,2) 
"""