numpy

NumPy

NumPy系统是Python的一种开源的数值计算扩展。 ---- 百度百科

import numpy as np    # 导入numpy库:  
np.__version__    # 查看numpy库版本信息   -- 了解
# matplotlib ---- 一种数据可视化的包
import matplotlib.pyplot as plt 

广播机制

【重要】ndarray广播机制的两条规则

• 规则一：为缺失的维度补1

• 规则二：假定缺失元素用已有值填充

import numpy as np    # 导入numpy库:  
np.__version__    # 查看numpy库版本信息   -- 了解
# matplotlib ---- 一种数据可视化的包
import matplotlib.pyplot as plt 

1、创建ndarray（numpy对象）

1、使用np.array()创建 ---- 参数为列表
    例：nd = np.array([1,2,3,4])
    # nd为ndarray类型
    # nd的所有元素类型都是相同的(为了提高运算效率)，优先级：str>float>int
    type(nd)    # 查看nd对象的类型
    nd.dtype    # 查看nd中元素的类型
    nd.shape    # 查看数据的形状
2、使用np的routines函数创建
    1. np.linspace(start,stop,num=50,endpoint=True,retstep=False,dtype=None)
        # start：起始值，stop：结束值，num：数据个数
        # 创建一个线性的ndarray对象，例：
        np.linspace(0,10,num=11)
        # 创建一个从0到10的包含11个数据的线性的ndarray对象
    2. np.arange([start,]stop,[step,],dtype=None)
        # start:起始值（可有可无），stop：结束值，step：步长，dtype：数据类型
        # 创建一个区间为[start，stop)的步长为step且数据类型为dtype的ndarray对象
        np.arange(start=5,stop=10,dtype="float")
    3. np.random.randint(low,high=None,size=None,dtype="1")
        # size为数值时创建一维对象，为数组时创建多维对象
        # 从给定序列选取随机数，创建ndarray对象
        np.random.randint(0,100,size=10)
    4. np.random.randn(d0,d1,……,dn)
        # 得到一个呈正态分布的数据，例：
        np.random.randn(10,2,1)
        # 正态曲线呈钟型，两头低，中间高，左右对称因其曲线呈钟形，因此人们又经常称之为钟形曲线。 ---- 百度百科
    5. np.random.normal(loc=0.0,scale=1.0,size=None)
        # 以loc为准线，从（loc-scale,loc+scale）选取随机数，创建为size的离散型对象（一般会有极少数数据有误差）
        np.random.normal(loc=175,scale=50,size=10)
    6. np.random.random(size=None)
        # 从区间[0,1)选取随机数创建为size的对象
        np.random.random(size=(10,2))
3、# 不常用方法
    1. np.ones(shape,dtype=None,order="C")
        # shape为元组或数字，规定数据的形状，dtype：数据类型
        np.ones((456,730,3),dtype="float")
        np.ones((10,10),dtype="int")
    2. np.zeros(shape,dtype=float,order="C")
        # shape为元组或数字，规定数据的形状，dtype：数据类型
        np.zeros((456,730,3),dtype="float")
    3. np.full(shape,fill_value,dtype=None,order="C")
        # shape为元组或数字，规定数据的形状，fill_value:填充的数据，dtype：数据类型
    4. np.eye(N,M=None,k=0,dype=float)
        # 创建矩阵
        np.eye(5)

2、ndarray的属性

ndim：维度
    np.ndim
shape：形状
    np.shape
size：总长度
    np.size
dtype：元素类型
    np.dtype

3、ndarray的基本操作

1、索引

# 类似于列表
nd = np.random.randint(0,10,size=(4,4))
nd[1][1]或者nd[1,1]
# 可以根据索引修改数据
nd[2,2] = 20

2、切片

# 类似于列表
nd = np.random.randint(0,10,size=(4,4))
nd[-1:]    # 取对象最后一行，列不变
nd[:2,1:3] = np.random.randint(0,30,size = (2,2))
# nd[:2,1:3] -- 取对象的[0,2)行，[1,3)列数据 ，  然后进行赋值
nd[::-1,::]    # 行反转，列不变

3、变形 -- reshape

使用reshape函数，参数是一个tuple
nd4 = np.full(12, fill_value=1024) ---- 1行12列
nd5 = nd4.reshape((3,4)) ---- 3行4列
案例见jupyter day01

4、级联

np.concatenate()
nd1 = np.random.randint(0,10,size = (4,4))
nd2 = np.random.randint(50,100,size = (4,4))
#concatenate:是专门用来numpy 数据进行级联的
#在进行级联的时候，必须精确匹配
#参数  axis=0  轴    轴就代表行或者是列
#当axis = 0 的时候，在行上面进行级联
np.concatenate((nd1, nd2))    # 默认axis=0
#当axis = 1 的时候，在列上面进行级联
np.concatenate([nd1,nd2], axis = 1)
# 维度的变更
    nd3 = np.random.randint(0,10,size = (10,1))
    np.hstack    # 水平级联，把二维的变成一维的
        np.hstack(nd3)
    np.vstack    # 垂直级联，把一维的变成二维的
        np.hstack(nd3)

5、切分

nd = np.random.randint(0,10,size = (5,6))
np.vsplit    # 水平切分
    np.vsplit(nd, [1,4])
np.hsplit    # 垂直切分
    np.hsplit(nd, [1,3,5])
np.split()    #切分
    # 当axis=1时，效果等同于np.hsplit 
    # 当axis=0时，效果等同于np.vsplit

6、副本

所有赋值运算不会为ndarray的任何元素创建副本。对赋值后的对象的操作也对原来的对象生效。

可使用copy()函数创建副本
nd = np.random.randint(0,10,size = 6)
nd_copy = nd.copy()
# 在副本中修改数据，不会影响原来的数据

4、ndarray的聚合操作

nd = np.random.randint(0,10,size = (2,3))
nd.sum()/nd.max()/nd.min()/nd.mean()    # 返回对象的和/最大值/最小值/平均值
nd.sum(axis=1)    # 对象为多维数据时，返回每一行的和
nd.argmin()/nd.argmax()    # 返回对象的最小/大值对应的下标
nd.std()    # 方差  表示数据的离散程度
​
np.sum()/np.max()/np.min()    # 返回数据的和/最大值/最小值
​
np.sum()和np.nansum()的区别：np.nansum()会将空值补零
np.nan 空值， 是一个浮点类型的数据
1+np.nan = np.nan(其他操作类似)
# 系统提供的运算函数
np.add() -- 加法              np.subtract() -- 减法
np.multiply() -- 乘法         np.divide() -- 除法

# 其他聚合操作
Function Name    NaN-safe Version    Description
np.sum       np.nansum       Compute sum of elements
np.prod      np.nanprod      Compute product of elements
np.mean      np.nanmean      Compute mean of elements
np.std       np.nanstd       Compute standard deviation
np.var       np.nanvar       Compute variance
np.min       np.nanmin       Find minimum value
np.max       np.nanmax       Find maximum value
np.argmin    np.nanargmin    Find index of minimum value
np.argmax    np.nanargmax    Find index of maximum value
np.median    np.nanmedian    Compute median of elements
np.percentile    np.nanpercentile    Compute rank-based statistics of elements
np.any       N/A             Evaluate whether any elements are true
np.all       N/A             Evaluate whether all elements are true
np.power 幂运算

# 矩阵操作
# 算术运算符
nd = np.random.randint(0,10,size = (5,5))
nd+3    # nd所有元素＋3，运用了广播机制的效果，其他操作类似
# 系统提供的运算函数
np.add(nd,2) -- 加法           np.subtract() -- 减法
np.multiply() -- 乘法          np.divide() -- 除法
# 矩阵积
nd1 = np.random.randint(0,10,size = (2,2))
nd2  = np.random.randint(0,10,size = (2,1))
np.dot(nd1,nd2)
# 注意：nd2行，必须跟nd1的列相等
# nd1的每一行分别乘以nd2的每一列，得到的是一个（nd1行，nd2列的）二维数组

5、ndarry的排序

nd = np.random.randint(0,80,size = 10)
# 双for循环排序
def sort_nd(nd):
    for i in range(nd.size):
        for j in range(i, nd.size):
            if nd[i]>nd[j]:
                nd[i],nd[j] = nd[j],nd[i]
    return nd
# 一个for循环的排序
def sort_nd2(nd):
    for i in range(nd.size):
        index_min = np.argmin(nd[i:])+i
        nd[i], nd[index_min] = nd[index_min], nd[i]
    return nd
# 解析
# 当i = 0 ,nd[0:]+0  index_min = 3   开始进行交换nd[0],nd[3]  = nd[3],nd[0] 0  放到了第一位，40放到了第三位
# 当i = 1, nd[1:]+1  index_min = 8   .............nd[1],nd[8] = nd[8],nd[1]
# 当i=0时：
    [40, 51, 55,  0, 26, 15, 61, 24,  6, 41]
#当i = 1的时候要操作的数据
    [0, 51, 55,  40, 26, 15, 61, 24,  6, 41]
#当i = 2的时候要操作的数据
    [0, 6, 55,  40, 26, 15, 61, 24,  51, 41]
# 快速排序
np.sort()和ndarray.sort()
np.sort() -- 不改变输入
ndarray.sort() -- 本地处理，不占用空间，但改变输入
# 部分排序
np.partition(a,k)
# 有的时候我们不是对全部数据感兴趣，我们可能只对最小或最大的一部分感兴趣。
    # 当k为正时，我们想要得到最小的k个数
    # 当k为负时，我们想要得到最大的k个数
    nd = np.random.randint(0,1000,size = 500)
    np.partition(nd,-20)
    # 注：得到的是最小的20个数据，但是这20个数据并没有排序