python之numpy

python之numpy

1.numpy概述

1.1 numpy介绍

numpy是python的第三方库，其支持大量高维度数组和矩阵的运算，NumPy包的核心是ndarray对象；

科学计算功能：

• 一个强大的N维数组对象 ndarray
• 广播功能函数
• 整合 C/C++/Fortran 代码的工具
• 线性代数、傅里叶变换、随机数生成，微积分求解等功能

1.2 numpy与Scipy概述

NumPy 通常与 SciPy(Scientific Python)和 Matplotlib(绘图库)一起使用，这种组合替代于MatLab。

1.3 numpy与python list的对比

相似：

• Storing Data 可存储数据
• Mutable 数据可更新
• Can be indexed 可索引搜索
• Slicing Operation 可分片

区别：

• List 可以存储不同的数据类型对象，Numpy Array存储的都是同类型数据对象，默认类型str>float>int
• Operation 快速操作
• List是内置结构，Numpy需要特别安装
• NumpyArray是C语言写的。可以比List操作快10-100倍。适合大数据分析

2.创建ndarray对象

2.1 导入Numpy库，命名为np：

import numpy as np

2.2 查看版本

np.__version__

3.创建数组：

NumPy 的主要对象是多维数组 Ndarray。在 NumPy 中维度 Dimensions 叫做轴 Axes，轴的个数叫做秩 Rank。注意，numpy.array 和 Python 标准库 array.array 并不相同，前者更为强大，这也就是我们学习 NumPy 的重要原因之一。

3.1 使用array()创建数组

利用Array()可以从一个列表或元组创建一个Numpy数组

通过列表创建一个一维数组：

# numpy.array(object,dtype=None,copy=True,order=None,subok=False,ndmin=0)
# object : 是数组或嵌套的数列
# dtype : 是数组元素的数据类型，可选，默认为浮点型
#  copy : 是设置是否需要复制，默认需要
# order : 创建数组的样式，c代表行方向，f代表列方向，a代表任意方向
np.array([1, 2, 3])

• 上方数组是一个秩为 1 的数组，因为它只有一个轴，而轴的长度为 3。

通过列表创建一个二维数组：

np.array([1,2,3],[4,5,6])

3.2 使用arange()创建一维等差数组

# arange([start,] stop[, step,], dtype=None) 类似于range方法，step是步长的意思
np.arange(5)

3.3 使用zero创建一个二维全0数组

shape, dtype=float, order='C'
np.zero((3,4))

3.4 使用ones创建一个三维全1数组

np.ones(shape, dtype=None, order='C')
np.ones((3,4,5))

3.5 使用empty创建一个内容随机的数组

内容取决于内存的状态

empty(shape, dtype=float, order='C')
np.empty((3,4))

3.6 使用eye创建单位矩阵（二维数组）

np.eye(3)

3.7 使用linspace创建一个ndarray对象

# np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
np.linspace(1,30,num=50) # 按照给定的数据区间和num个数，形成等差数列

3.8 使用random随机数生成ndarray对象

# randint(low, high=None, size=None, dtype='l')
np.random.randint(1,100,size=(2,5))  # 生成1到100的随机数，两行五列

3.9 注意：

1.arange 和 linspace 都是生成随机数列，有什么不同吗？

• arange()类似于内置函数range()，通过指定开始值、终值和步长创建表示等差数列的一维数组，注意得到的结果数组不包含终值。
• linspace()通过指定开始值、终值和元素个数创建表示等差数列的一维数组，可以通过endpoint参数指定是否包含终值，默认值为True，即包含终值。

2.numpy默认ndarray的所有元素的类型是相同的,如果传进来的列表中包含不同的类型,则统一为同一类型,优先级:str>float>int

# 如果既有字符串，又有数字，按照优先级，统一为字符串
b = np.array(["你好帅",2,3,4])
b,b.dtype

# 同理，统一为float
c = np.array([4,23.4,12.4])
c,c.dtype

4.ndarray的基本操作

4.1 使用shape查看矩阵的大小形状

arr = np.random.randint(1,100,size=(4,5))
print(arr.shape) # (4,5)  各维度的大小(行数，列数)
print('当前数组是'+str(arr.ndim)+'维的')    # 当前数组是2维的
print(f'当前数组的尺寸是{arr.shape}')       # 当前数组的尺寸是(4, 5)

4.2 使用index的索引

• NumPy或Numeric Python是用于在均匀n维数组上进行计算的软件包。在numpy中，尺寸称为轴。
• 和列表中的索引类似，矩阵中的索引正向从0开始计数，最大尺寸为总数-1；反向索引从-1开始；
• Slicing切片功能也和列表相似，只是扩展到更高维度；

import  numpy as np

list1 =[1,2,3,4,5,6]
list2=[10,9,8,7,6,5]

# Ndarray索引
a1 = np.array(list1)
a2 = np.array(list2)
print(a1*a2)      # [10 18 24 28 30 30]
print(a1[2])      # 3
print(a1[np.array([2,1,0])])  # [3 2 1] 注意array里面的中括号

# Ndarray切片   
a3 = np.arange(10)
print(a3[3:])     # [3 4 5 6 7 8 9]
print(a3[:6])     # [0 1 2 3 4 5]
print(a3[0:9:2])  # [0 2 4 6 8]

print("*"*50)
a3 = np.array([[0,1,2],[3,4,5],[6,7,8]])
print(f'最中间的数据是{a3[1,1]}')      # 最中间的数据是4
print(f'最下方的三组数据是{a3[2:]}')    # 最下方的三组数据是[[6 7 8]]
print(a3)
'''[[0 1 2]
    [3 4 5]
    [6 7 8]]'''
print(a3[::-1])  # 倒取行
'''[[6 7 8]
     [3 4 5]
     [0 1 2]]'''
print(a3[:,::-1])  # 倒取列
'''[[2 1 0]
     [5 4 3]
     [8 7 6]]'''
print(a3[::-1,::-1])  # 倒取行和列
'''[[8 7 6]
     [5 4 3]
     [2 1 0]]'''
# 不加逗号，代表取行，加了逗号，逗号前是行，逗号后是列


# numpy的逻辑索引

import  numpy as np
a = np.array([[1,-2,3],[4,-5,6]])
print(a.shape)   # (2, 3)
print(a.ndim)    # 2
print(a)
'''[[ 1 -2  3]
    [ 4 -5  6]]'''
print(a[a>0])   # [1 3 4 6]
print(a[a<0])   # [-2 -5]
print(a[a<0]*2) # [ -4 -10]

4.3.数学运算

​ 两个数组的需形状相同，不同时会触发广播机制。

• NumPy包含大量的各种数学运算。 NumPy提供标准的三角函数，算术运算功能，处理复数 等。
• NumPy的标量计算功能，常规的代数运算都可以实现。
• NumPy的矩阵运算特性，支持同尺寸矩阵的各种数学运算

# 一维数组的基本运算
a = np.array([10, 20, 30, 40, 50])   # [10 20 30 40 50]
b = np.arange(1, 6)  #[1 2 3 4 5]

print(arr+3)  # [13, 23, 33, 43, 53]   标量计算
print(a+b)    # [11 22 33 44 55]       矩阵计算
print(a*b)    # [ 10  40  90 160 250]
print(a/b)    # [10. 10. 10. 10. 10.]
print(a-b)    # [ 9 18 27 36 45]

# 二维数组的运算
A = np.array([[10,20],
              [30,40]])
B = np.array([[1,2],
              [3,4]])

print(A*B)   '''[[ 10  40]
                  [ 90 160]]'''

????? # 矩阵乘法运算（注意与上题的区别）：
m = np.dot(A,B)
print(m)   '''[[ 70 100]
                 [150 220]]'''

(3, )  一行三列

4.4.广播功能（Broadcast）

广播（broadcasting）指的是不同形状的数组之间的算术运算的执行方式。

'''
广播的规则
规则1：如果两个数组的维度不相同，那么小维度数组的形状将会在最左边补1.
规则2：如果两个数组的形状在任何一个维度上都不匹配，那么数组的形状会沿着维度为1扩展以匹配另外一个数组的形状。
规则3：如果两个数组的形状在任何一个维度上都不匹配并且没有任何一个维度为1,那么会引起异常。
'''

举例一：

a = np.array([[2,4,3],[3,6,7]])
b = np.array([3,4,5]) 
c = a + b
#两个数组的形状为 a.shape=(2,3),b.shape=(3,)
#根据规则1,数组b的维度更小，所以在其左边补1,变为b.shape -> (1,3), a.shape -> (2,3)
#根据规则2,第一个维度不匹配，因此扩展这个维度以匹配数组：b.shape ->(2,3), a.shape -> (2,3)
#现在两个数组的形状匹配了，可以看到它们的最终形状都为c.shape -> (2,3):
print(c) 
    '''[[ 5  8  8]
         [ 6 10 12]]'''

举例二：

a1 = np.array([0,1,2])
b1 = np.array([[0],[1],[2]])
c1=a1+b1
#两个数组的形状为 a1.shape=(3,),b1.shape=(3,1)
#根据规则1,数组a1的维度更小，所以在其左边补1,变为a1.shape -> (1,3), b1.shape -> (3,1)
#根据规则2,第一个维度不匹配，因此扩展这个维度以匹配数组：a1.shape ->(3,3), b1.shape -> (3,3)
#现在两个数组的形状匹配了，可以看到它们的最终形状都为c1.shape -> (3,3):
print(c1)
    '''[[0 1 2]
        [1 2 3]
        [2 3 4]]'''

4.5 使用**reshape()和resize()**对Narry的变形

# reshape():在不改变原数组数据的情况下，将它reshape成一个新的维度。
# 默认order = c,"C" 读/索引顺序是横向的，“F”读/索引顺序是纵向的。
# 如果给定的数组数据和需要reshape的形状不符合时，将会报错。

a = np.arange(8)
b = a.reshape(2,4)            # 默认order = c,"C" 读/索引顺序是横向的
''' [[0 1 2 3]
     [4 5 6 7]]'''

b1 = a.reshape(2,4,order='F')  # “F”读/索引顺序是纵向的。  
''' [[0 2 4 6]
      [1 3 5 7]]'''    
b2 = a.reshape(4,-1)  # "-1"根据需求自我调整维度
''' [[0 1]
      [2 3]
      [4 5]
      [6 7]]'''

# resize:给定一个数组，和特定维度，将会返回一个给定维度形式的新数组。
# resize 可以放大或者缩小原数组的形状：放大时，将会copy原数组中的值对新数组进行填充；缩小时，直接丢弃多余元素。
a = np.arange(9)
print(a)
'''[0 1 2 3 4 5 6 7 8] ''' 
b = np.resize(a,(2,3)) # 缩小时
print(b)
'''[[0 1 2]
    [3 4 5]]'''
b1 = np.resize(a,(6,3)) # 放大时
print(b1)
''' [[0 1 2]
      [3 4 5]
      [6 7 8]
      [0 1 2]'''

4.6 使用ravel()和flatten()将多维数组扁平化

'''
多维度变一维，两者的区别在于返回拷贝（copy）还是返回视图（view）;
flatten()返回一份拷贝，需要分配新的内存空间，对拷贝所做的修改不会影响原始矩阵，该函数只能适用 于numpy对象，即array或者matrix。（常用）
ravel()返回的是视图（view），会影响原始矩阵。'''

flatten是numpy.ndarray.flatten的一个函数，返回一个折叠成一维的数组。
import  numpy as np

a = np.arange(9).reshape(3,3)
print(a)
'''[[0 1 2]
    [3 4 5]
    [6 7 8]]'''
b = a.ravel()
print(b)
''' [0 1 2 3 4 5 6 7 8] '''
c = a.flatten()
print(c)
''' [0 1 2 3 4 5 6 7 8] '''

4.7 使用Transpose和swapaxes对Narry的转置

# transpose 按照多维数组的轴的索引进行变换，简单而言就是把行和列进行对换。
# swapaxes 只接受两个参数，即表示需要转换的两个轴的索引，所以在三维以上的情况下， transpose方法更灵活一些。

import  numpy as np

a = np.arange(9).reshape(3,3)
print(a)
'''[[0 1 2]
    [3 4 5]
    [6 7 8]]'''
b = a.transpose()        # b = a.transpose() = b = a.T
print(b) 
'''[[0 3 6]
    [1 4 7]
    [2 5 8]]'''
b1 = np.swapaxes(a,1,0)   # swapaxes 只接受两个参数
print(b1)
'''[[0 3 6]
    [1 4 7]
    [2 5 8]]'''

4.8 Numpy的Splitting Stack和Concat

# concat在已有的维度上进行拼接,能够一次完成多个数组的拼接.
# stack在新的维度上进行拼接
# split把一个数组从左到右按顺序切分

# concat
import  numpy as np
arr1 = np.array([[2,4],[3,6]])
arr2 = np.array([[3,5],[7,9]])
res = np.concatenate((arr1,arr2),axis = 0)  # 沿垂直方向叠加，加在行上
print(res)
'''[[2 4]
    [3 6]
    [3 5]
    [7 9]]'''
res = np.concatenate((arr1,arr2),axis = 1)  # 沿水平方向叠加，加在列上
print(res)
'''[[2 4 3 5]
    [3 6 7 9]]'''
res = np.concatenate((arr1,arr2),axis = None) # 直接扁平化
print(res)
'''[2 4 3 6 3 5 7 9]'''

# stack在新的维度上进行拼接
import  numpy as np
arr1 = np.array([[2,4],[3,6]])
arr2 = np.array([[3,5],[7,9]])
res = np.vstack((arr1,arr2))  # 沿垂直方向叠加，加在行上  同函数np.row_stack((arr1,arr2))
print(res)
'''[[2 4]
    [3 6]
    [3 5]
    [7 9]]'''
res = np.hstack((arr1,arr2))  # 沿水平方向叠加，加在列上 同函数np.column_stack((arr1,arr2))
print(res)
'''[[2 4 3 5]
    [3 6 7 9]]'''

# split把一个数组从左到右按顺序切分

import  numpy as np
arr = np.arange(9).reshape(3,3)
print(arr)
'''[[0 1 2]
     [3 4 5]
     [6 7 8]]'''
a = np.hsplit(arr,3)  # 沿横向轴拆分 axis=1 同 a = np.split(arr,3,axis=1) 
print(a)
'''[array([[0],
         [3],
         [6]]), array([[1],
         [4],
         [7]]), array([[2],
         [5],
         [8]])]'''
b = np.vsplit(arr,3)  # 沿纵向轴拆分 axis=0 同 b = np.split(arr,3,axis=0) 
print(b)
'''[array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])]'''

4.9 Numpy的Append Insert和Delete

# np.append(arr,values,axis=None)中，axis是可选参数。如果不设置axis，则np.append() 返回的结果返回将arr和values展平再进行拼接。

# np.append(arr,values,axis=None
import  numpy as np
arr = np.array([[2,4],[3,6]])


arr1 = np.append(arr,[77,99])             # 展平再进行拼接
print(arr1)
'''[ 2  4  3  6 77 99]'''
arr2 = np.append(arr,[[77,99]],axis = 0)  # 沿垂直方向叠加，加在行上
print(arr2)
'''[[ 2  4]
    [ 3  6]
    [77 99]]'''
arr3 = np.append(arr,[[77],[99]],axis = 1)  # 沿水平方向叠加，加在列上 重点关注下77和99的格式。
print(arr3)
'''[[ 2  4 77]
    [ 3  6 99]]'''

# np.insert(arr,obj,values,axis)和np.append()用法类似，但np.insert()的用法更灵活。 np.append()新增的数据只能在每行每列的最后，其位置是规定的。而np.insert()添加的位置 是可以指定的(由参数obj确定)。np.insert()中的axis的作用于np.append()中的作用相同，但 其在进行插入的时候，对arr和values的维度不再有限制。

import  numpy as np
arr = np.array([[2,4],[3,6]])

arr1 = np.insert(arr,1,[77,22,11])
print(arr1)
'''[ 2 77 22 11  4  3  6]'''
arr2 = np.insert(arr,1,[77,22],axis = 0) # 沿垂直方向，加在行上
print(arr2)
'''[[ 2  4]
     [77 22]
     [ 3  6]]'''
arr3 = np.insert(arr,1,[77,22],axis = 1)  # 沿水平方向，加在列上
print(arr3)
'''[[ 2 77  4]
    [ 3 22  6]]'''

# np.delete(arr,obj,asix)函数实现按照axis和obj对arr进行元素删除的功能。如果没有设置axis, 则对arr进行flatten之后再删除
import  numpy as np

arr = np.array([[2,4],[3,6]])
print(arr)
'''[[2 4]
   [3 6]]'''

arr1 = np.delete(arr,1)   # 扁平化之后删除
print(arr1)
'''[2 3 6]'''
arr2 = np.delete(arr,1,axis = 0)   # 沿垂直方向，删在行上
print(arr2)
'''[[2 4]]'''
arr3 = np.delete(arr,1,axis = 1)   # 沿水平方向，删在列上
print(arr3)
'''[[2]
    [3]]'''

4.10 Numpy的Matrix介绍

''' 
1.NumPy函数库中存在两种不同的数据类型(矩阵matrix和数组array)，都可以用于处理行、列表示的数字元素。
  虽然它们看起来很相似，但是在这两个数据类型上执行相同的数学运算 可能得到不同的结果，
  其中NumPy函数库中的matrix与MATLAB中matrices等价。
2.numpy模块中的矩阵对象为numpy.matrix，包括矩阵数据的处理，矩阵的计算，以及基本的 统计功能，转置，可逆性等等，
  包括对复数的处理，均在matrix对象中。
3.matrix是array的分支，matrix和array在很多时候都是通用的，但官方建议如果两个可以通用， 那就选择array，
  因为array更灵活，速度更快，很多人把二维的array也翻译成矩阵。'''


import  numpy as np
# numpy. ndarray
a = np.array([[1,2],[4,5]])
b = np.array([[10,20],[40,50]])
print(type(a))   # <class 'numpy.ndarray'>
print(a*b)
'''[[ 10  40]
     [160 250]]'''
print(a.dot(b))  # 同 matrix 的乘法
'''[[ 90 120]
    [240 330]]'''

# numpy.matrix
a = np.matrix([[1,2],[4,5]])
b = np.matrix([[10,20],[40,50]])
print(type(a))  # <class 'numpy.matrix'>
print(a*b)      # 矩阵想乘
'''[[ 90 120]
    [240 330]]'''

矩阵的乘法：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nwLuZpvR-1628330152849)(/Users/yuanyuandemac/Library/Application Support/typora-user-images/image-20210807002651651.png)]

4.11 Numpy的Matrix常用功能

''' 
1.Numpy的反矩阵和矩阵幂
1)反矩阵和矩阵相乘等于单位矩阵，矩阵A的逆矩阵(有时称为倒数矩阵)是矩阵A ^(-1)， 使得 AA ^(-1)= I，(I)是单位矩阵
2)矩阵幂对于方矩阵𝐴和正整数𝑘，通过反复将此矩阵自身相乘k次数来定义

2.Numpy的矩阵方程求解和Det
1)Solve功能用于求解矩阵对应的解。
2)Det行列式不是个"式"!它是个数!不要被行列式里的"式"字误导了，矩阵的行列式不是一个
式子，它是一个数字，是一个按行列式计算规则(只是乘和加运算)计算出来的数值。
3)Det这个数值有什么意义?对于二阶矩阵，它就是一个面积、对于三阶矩阵，它就是一个体积、 对于n维矩阵，它就是n维立体的体积。
'''

import  numpy as np

# numpy 的反矩阵
a = np.matrix('1 2;3 4')
print(a)
'''[[1 2]
     [3 4]]'''
b = np.linalg.inv(a) # 反矩阵
print(b)
'''[[-2.   1. ]
   [ 1.5 -0.5]]'''
print(a.dot(b))      # 单位矩阵
'''[[1.0000000e+00 0.0000000e+00]
     [8.8817842e-16 1.0000000e+00]]'''


# numpy 的幂矩阵
b = np.linalg.matrix_power(a,2)  # 结果同print(a.dot(a))
print(b)
'''[[ 7 10]
     [15 22]]''' 

b = np.linalg.matrix_power(a,0)  # 单位矩阵
print(b)
'''[[1 0]
    [0 1]]'''
b = np.linalg.matrix_power(a,-1)  # 反向矩阵
print(b)
'''[[-2.   1. ]
   [ 1.5 -0.5]]'''
print(a.dot(b))                   # 结果为单位矩阵
'''[[1.0000000e+00 0.0000000e+00]
   [8.8817842e-16 1.0000000e+00]]'''

# Numpy的solve求解矩阵解

print("*"*40)
a = np.array([[1,2],[3,4]])
b = np.array([10,16])
c = np.linalg.solve(a,b)
print(c)   # [-4.  7.]

# Numpy的Det的计算
a = np.array([[0,4],[4,0]])              # 求面积
b = np.linalg.det(a)
print(b)  # -15.999999999999998  负号代表方向

a = np.array([[0,0,4],[0,4,0],[4,0,0]])   # 求体积
print(np.linalg.det(a))   # -63.99999999999998  负号代表方向

反向矩阵计算公式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mYi8qiUB-1628330152850)(/Users/yuanyuandemac/Library/Application Support/typora-user-images/image-20210807005103274.png)]

4.12 ndarray的聚合操作

import  numpy as np

a = np.array([[1,2,3],[4,5,6]])
print(a)

print(a.sum())         # 21
print(a.sum(axis=0))   # [5 7 9] 对列进行聚合求和
print(a.sum(axis=1))   # [6 15]

print(a.max())          # 6
print(a.max(axis=0))    # [4 5 6]
print(a.max(axis=1))    # [3 6]

print(a.mean(axis=0))   # [2.5 3.5 4.5]
print(a.min(axis=0))    # [1 2 3]

5.错题集

5.3（10分） 以下哪个选项符合这段函数的输出结果？

import numpy as npa = np.repeat(np.arange(5).reshape([1,-1]),10,axis = 0)+10.0 b = np.random.randint(5, size= a.shape)c = np.argmin(a*b, axis=1)b = np.zeros(a.shape)b[np.arange(b.shape[0]), c] = 1print b

A.Hello World!

B.一个 shape = (5,10) 的随机整数矩阵

C.一个 shape = (5,10) 的 one-hot 矩阵

D.一个 shape = (10,5) 的 one-hot 矩阵

正确答案：D

解析：D、"第3行说明b是矩阵，排除a 第5行说明矩阵b形状和a相同，第2行说明a的形状是（10，5） 第4行用向量c储存矩阵ab每行最大的数的索引 第5、6行将矩阵b转化为one-hot矩阵，ab每行最大的数处取1 "

5.6 单选题 （10分） 以下哪个选项符合这段函数的输出结果？x = np.array([[1, 2], [3, 4], [4, 5]])y = x[[0,1,2], [0,1,0]]print(y)

A.[1 5 6]

B.[1 4 4]

C.[2 3 4]

D.[1 2 3]

正确答案：B

5.7 单选题 （10分） 以下哪个选项正确的描述了数组a的数据类型？a = zeros(5)

A.array

B.integer

C.float

D.char

正确答案：C