Python（数据分析篇）--- Numpy框架【一】矩阵、数组计算

一、 Numpy 矩阵

numpy：计算模块，主要有两种数据类型：数组、矩阵
特点：运算快

在这里，我们使用Jupyter Notebook工具

首先，导入模块

import numpy as np

1、矩阵的创建

mat1 = np.mat("1 2 3; 2 3 4; 1 2 3")
mat1

输出：
    matrix([[1, 2, 3],
            [2, 3, 4],
            [1, 2, 3]])


mat2 = np.mat("2 3; 1 4; 4 2")
mat2

输出：
    matrix([[2, 3],
            [1, 4],
            [4, 2]])

mat3 = np.mat("3 2 4; 1 3 4; 1 2 3")

2、矩阵的计算

1. 矩阵加法计算

print("矩阵加法计算：\n",mat1+mat3)

输出：
    矩阵加法计算：
     [[4 4 7]
     [3 6 8]
     [2 4 6]]

2. 矩阵乘法计算

print("矩阵乘法：\n", mat1*mat2)

输出：
    矩阵乘法：
     [[16 17]
     [23 26]
     [16 17]]
    

3. 矩阵的转置

print("矩阵转置：\n", mat1.T)

输出：
    矩阵转置：
     [[1 2 1]
     [2 3 2]
     [3 4 3]]
    

4. 矩阵的逆矩阵

print('矩阵的逆矩阵：\n',mat3.I)

输出：
    矩阵的逆矩阵：
     [[ 1.  2. -4.]
     [ 1.  5. -8.]
     [-1. -4.  7.]]

5. 矩阵的数乘

print("矩阵数乘：\n", 4*mat3)

输出：
    矩阵数乘：
     [[12  8 16]
     [ 4 12 16]
     [ 4  8 12]]

6. 对应元素相乘的运算

print('对应元素相乘的运算：\n', np.multiply(mat1, mat3))

输出：
    对应元素相乘的运算：
     [[ 3  4 12]
     [ 2  9 16]
     [ 1  4  9]]

3、矩阵的属性

1. 查看矩阵结构

print('矩阵结构：\n', mat1.shape)

输出：
    矩阵结构：
     (3, 3)

2. 查看矩阵的元素个数

print('矩阵的元素个数：\n', mat1.size)

输出：
    矩阵的元素个数：
     9

3. 查看矩阵元素类型

print('矩阵元素类型：\n', mat1.dtype)

输出：
    矩阵元素类型：
     int32

4. 查看矩阵的维度
   不常用，需要注意的是：行向量的维度是1，列向量的维度不为1

print('矩阵的维度：\n', mat1.ndim)

输出：
    矩阵的维度：
     2

二、Numpy 数组

数组的所有运算都是对应元素的运算；

1. 数组的创建

# 一维的数组
arr1 = np.array([1,2,3,4])

# 二维的数组
arr2 = np.array([[1,2,3],[0,1,2],[2,3,1]])
arr2

输出：
    array([[1, 2, 3],
           [0, 1, 2],
           [2, 3, 1]])

# 列向量
arr3 = np.array([[1],[2],[3],[4]])
arr3

输出：
    array([[1],
           [2],
           [3],
           [4]])

2. 数组的属性

矩阵具有的属性，数组都有，并且方法相同

1. 数组结构

print('数组结构：\n', arr1.shape)
# 一维数组时返回数组元素个数
print('数组结构：\n', arr2.shape)
# 返回数组几行几列

输出：
    数组结构：
     (4,)
    数组结构：
     (3, 3)

2. 数组元素的个数

print('数组元素的个数：\n', arr2.size)

输出：
    数组元素的个数：
     9

3. 数组元素的类型

print('数组元素的类型：\n', arr2.dtype)

输出：
    数组元素的类型：
     int32

4. 数组维度
   需要注意的是：和矩阵相同，列向量的维度不为1

print('数组维度：\n', arr1.ndim)
print('数组维度：\n', arr2.ndim)

输出：
    数组维度：
     1
    数组维度：
     2

3. 数组的索引

数组是有索引值的，所以数组也可以像python的字符串一样进行切片操作。

# 一维数组的索引
arr1[::-1]

输出：
    array([4, 3, 2, 1])


# 二维数组的切片
print(arr2)
# arr2[行切片, 列切片]
# arr2[0,1]
# arr2[1,0:2]
# arr2[:2,0:2]
# arr2[::2,::2]
# arr2[1:3,1:3]
arr2[0:2,::2]

输出：
    [[1 2 3]
     [0 1 2]
     [2 3 1]]
    
    array([[1, 3],
           [0, 2]])

重要： 不同行不同列的切片

# arr2[(0,1,2),(0,1,2)] # 取出所有1
arr2[(1,0,1),(0,1,2)]

输出：
    array([0, 2, 2])

重要：通过bool取值
先创建bool值数组

mask = np.array([1,0,1],dtype=np.bool)
print(mask)

输出：
[ True False  True]

再取值

arr2[mask, :2]

输出：
    array([[1, 2],
           [2, 3]])

注意：不要行列同时传入bool值
因为同时传入时，是按照不同行不同列取值

arr2[mask, mask]

输出：
array([1, 1])

4. 特殊函数创建数组

（1）类似于range

arr4 = np.arange(1,10,1)
print(arr4)

输出：
[1 2 3 4 5 6 7 8 9]

（2）等差数列

使用linspace方法创建

# 源码：
np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

参数说明：
start：首项
stop：末项
num：项数
endpoint=True 表示等差数列，在start于stop之间插入n-2个值（n为数值的个数）
endpoint=False 表示等差数列，在start于stop之间插入n-1个值，表示平均分成n份（n为线段的个数）

arr5 = np.linspace(1,5,5) # (首项，末项，项数)
print(arr5)
[ 1.  2.  3.  4.  5.]

（3）等比数列【难点】

使用logspace方法创建，logspace方法使用对数 log_x^y 进行计算

# 源码：
logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)

参数说明：
start：首项的指数
stop：末项的指数
num：项数
base：底数

arr6 = np.logspace(0,2,3)
print(arr6)

输出：
[   1.   10.  100.]

print(np.logspace(1,11,6,base=3))

输出：
[  3.00000000e+00   2.70000000e+01   2.43000000e+02   2.18700000e+03
   1.96830000e+04   1.77147000e+05]

更多内容敬请查看：https://blog.csdn.net/Zachary579/article/details/111594281