Numpy数组

array([1,2,3])                      # 数值型数组
array(['w','s','q'],dtype = '<U1')    # 字符型数组

array():
    '''
        功能: 创建数组。
        参数: 序列型对象（数组、元组、字符串等）
        返回值: 1维或多维数组。
    '''

import numpy as np      #导包
# 给 array()函数 传入一个**列表**，直接将数据以列表的形式作为一个参数传给array()函数即可。
arr = np.array([5,4,7])
arr

# 给 array()函数 传入一个**元组**，直接将数据以元组的形式作为一个参数传给array()函数即可。
arr = np.array( (5,4,7) )
arr

# 给 array()函数 传入一个**嵌套列表**，直接将数据以嵌套列表的形式作为一个参数传给array()函数即可，这时会生成一个多维数组。
arr = np.array( [ [5,4,7],[7,8,9] ] )
arr                 #这时会生成一个多维数组

arange(start,stop,step):
    '''
        功能: 创建固定范围的随机数组。（生成以start开始以stop结束step为步长的随机序列）
        参数: 
            ① start: 以start开始(包括start这个值)。省略不写时，默认从0开始。
            ② stop: 以stop结束(不包括stop这个值)。
            ③ step: 步长(就是数与数之间的间隔)。省略不写时，默认为1。
        返回值: 数组。
    '''
# 和randint(low,high=None,size=None) 类似    

# 生成以1为开始，15结束，3为步长的随机序列
arr = np.arange(1,15,3)
arr
# 生成以1为开始，15结束，步长为默认值的随机序列(step不写)
arr = np.arange(1,15)
arr
# 生成以15结束，步长为默认值的随机序列。(start不写，step不写)
arr = np.arange(15)
arr

zeros():
    '''
        功能: 生成指定形状全为0的数组
        参数: 
            传入一个具体的值时，会生成相应长度的一个全为0的1维数组。
            传入一对值时(即元组形式)，会生成相应 行、列数 的全为0的多维数组。
        返回值: 全为0的 1维或多维 数组。
    '''    

# 生成长度为3的0数组
np.zeros(3)
# 生成2行3列的0数组
np.zeros((2,3))

ones():
    '''
        功能: 生成指定形状全为1的数组
        参数: 
            传入一个具体的值时，会生成相应长度的一个全为1的 1维数组。
            传入一对值时(即元组形式)，会生成相应 行、列数 的全为1的 多维数组。
        返回值: 全为1的 1维或多维 数组。
    '''   

# 生成长度为3的1数组
np.ones(3)
# 生成2行3列的1数组
np.ones((2,3))

# 单位矩阵就是对角线元素值全为1，其余位置的元素值全为0
eye():
    '''
        功能: 生成对角线元素值全为1，其余位置的元素值全为0 的 正方形矩阵
        参数: 
            传入一个具体的值(即指明正方形边长)。
        返回值: 正方形单位矩阵。
    ''' 

# 生成1个 3*3 的单位矩阵
np.eye(3)

rand():
    '''
        功能: 主要用于生成 (0,1) 之间的随机数组。
        参数: 
            传入一个具体的值时，生成一个对应长度的且值位于 (0,1) 之间的随机数组。
            传入一对值时(注意这里就不是元组形式了)，会生成相应 行、列数 的多维数组(且数组中的值位于 (0,1) 之间)。
        返回值: (0,1) 之间的随机数组。
    ''' 

# 生成长度为3的 值位于 (0,1) 之间的随机数组
np.random.rand(3)
# 生成2行3列的值位于 (0,1) 之间的随机数组
np.random.rand(2,3)

randn():
    '''
        功能: 生成满足正态分布的指定形状数组。
        参数: 
            传入一个具体的值时，生成一个对应长度的 ma满足正态分布的随机数组。
            传入一对值时(注意这里就不是元组形式了)，会生成相应 行、列数 的多维数组(且值满足正态分布)。
        返回值: 满足正态分布的指定形状数组。
    ''' 

# 生成长度为3的 值满足正态分布的随机数组
np.random.randn(3)
# 生成2行3列的 值满足正态分布 的随机数组
np.random.randn(2,3)

# np.arange(start,stop,step)方法类似，用于生成一定范围内的随机数组
randint(low,high=None,size=None):
    '''
        功能: 生成一定范围内的随机数组（即在左闭右开区间生成数组大小为size的均匀分布的整数值）.
        参数: 
            ① low: 以low开始(包括low这个值)。
            ② high=None: 以high结束(不包括high这个值)。有时high参数为空则取值区间为[0,low)
            ③ size=None: 可以是一个值，这时生成的随机数组是1维的，也可以是一对值(元组形式)这时就是多维的。
        返回值: 一定范围内的随机数组。
    ''' 

# 在区间为[1,5)生成长度为10的随机数组
np.random.randint(1,5,10)
# high参数为空
np.random.randint(5,size = 10) #这时你就得使用关键字参数了
# 在区间为[0,5)生成 2行3列 的随机数组
np.random.randint(5,size = (2,3))       # high参数为空，区间[0,low)

choice(a,size = None,replace = None,p = None):
    '''
        功能: 从已知数组中随机选取相应大小的数组。
        参数: 
            ① a: 表示从哪个数组提取，可以是1个数组，也可以是1个整数。
                是1个数组时，表示从该数组中随机采样。
                是1个整数时，表示从range(int)中采样。
                
            ② size=None: 
                是一个具体数值时，生成1维数组；
                是一对值时（元组形式），生成多维数组。
                
            ③ replace=None: 。
            ④ p = None: 
        返回值: 数组。
    ''' 

# 从数组 a 中随机选取3个值组成一个新数组
a = np.array([1,4,7,5,6,9,8,2])
np.random.choice(a,3)

# 从数组 a 中随机选取 2行3列 组成一个新数组
np.random.choice(a,(2,3))

# 当 a 是1个整数时，随机选取3个值组成一个新数组
np.random.choice(5,3)

shuffle():
    '''
        功能: 主要是用来将原数组顺序打乱，类似于扑克牌中的洗牌操作。
        参数: 
            目标数组
        返回值: 数组。
    ''' 

arr = np.arange(10)
arr         # 原数组顺序
# 使用shuffle()方法
np.random.shuffle(arr)  
arr         # 乱序后的数组

arr = np.array([ [1,2,3],[4,5,6],[7,8,9] ])
arr
arr.shape

arr.size

arr.dtype

arr.ndim

arr1 = np.array([5,4,7])
arr1.ndim

arr = np.arange(10) # 也可以写成arange(0,10,1)

# 获取第 5 位的数
arr[5]
# 获取末尾最后一个数数
arr[-1]
# 获取末尾倒数第二个数
arr[-2]

# 获取位置3到5的元素
arr[3:5]
# 获取某个位置之后的所有元素
arr[3:]
# 获取某个位置之前的所有元素
arr[:3]
# 正序位置和倒序位置混用
arr[3:-2]

# 给数组传入某个判断条件，将返回符合该条件的元素

# 获取数组中大于3的元素
arr[ arr > 3 ]

# 要获取某行数据，直接传入这行的位置(即第几行即可)。

# 获取第2行数据
arr[1]

# 要获取某些行数据，直接传入这些行的位置区间即可。

# 获取第2行和第3行数据，（包含第3行）
arr[1:3]

# 获取第3行之前的所有数据，（不包含第3行）
arr[:2]

# 要获取某列数据，直接传入这列的位置(即第几列即可)。

# 获取 所有行 的 第2列 数据
arr[:,1]

# 要获取某些列数据，直接传入这些列的位置区间即可。

# 获取 所有行 第1列到第3列数据，（不包含第3列）
arr[:,0:2]

# 同样也可以获取第3列之前的所有数据，（不包含第3列）
arr[:,:2]
# 获取第2列之后的所有数据，（包含第2列）
arr[:,1:]

# 分别在行位置、列位置处指明要获取行、列的位置数

# 获取第 1 到 2 行，第 2 到 3 列的数据
arr[0:2,1:3]

arr = np.arange(5)

# 查看数组的类型
arr.dtype           # 数据类型是 int32

# 将数组从int转换为float
arr_float = arr.astype(np.float64)
arr_float
arr_float.dtype

# 将数组从int转换为str类型
arr_str = arr.astype(np.string)
arr_str
arr_str.dtype

这个方法之前我们在Pandas也讲过，这是两个库中的两个方法，但本质是一样，Pandas中的某一列其实就是NumPy数组。

isnan():
    '''
        功能: 判断是否有缺失值。
        参数: 待检测数组
        返回值: 某一位置的值为缺失值，则该位置返回True，否则返回False。
    '''

# 创建一个含有缺失值的数组
arr = np.array([5,4,np.nan,7])
arr

# 判断缺失值
np.isnan(arr)

# 用 0 填充
arr[np.isnan(arr)] = 0
arr

unique():
    '''
        功能: 删除重复值。
        参数: 待处理数组。
        返回值: 返回无重复值的数组。
    '''    

arr = np.array([1,2,3,2,1])

np.unique(arr)

reshape():
    '''
        功能: 数组重塑。
        参数: 
            具体数值，转换成几行。
            具体数值，转换成几列。
        返回值: 重塑后的数组。    
    '''

arr = np.arange(1,9,step=1)
arr

# 将数组重塑为 2 行 4 列的多维数组 
arr.reshape(2,4)
# 将数组重塑为 4 行 2 列的多维数组 
arr.reshape(4,2)

# 无论转换为几行几列，只要重塑后数组中值的个数等于1维数组中个数即可。

# 创建多维数组
arr = np.array( [ [1,2,3,4],[5,6,7,8],[9,10,11,12] ] )

# 将数组重塑为 4 行 3 列的多维数组 
arr.reshape(4,3)
# 将数组重塑为 2 行 6 列的多维数组 
arr.reshape(2,6)

# 同样，只要重塑后数组中值的个数等于1维数组中个数即可。

# 数组转置就是将数组的行旋转为列

arr = np.array( [ [1,2,3,4],[5,6,7,8],[9,10,11,12] ] )

arr.T

concatenate():
    '''
        功能: 数组合并。
        参数: 
            ① 将待合并的数组以***列表***的形式传给concatenate。
            ② axis: 指明在 行方向 还是 列方向上进行合并。axis = 1,表示数组在行方向上合并;axis = 0,表示数组在列方向上合并。
        返回值: 合并后的数组。      
    '''
arr1 = np.array( [ [1,2,3],[4,5,6] ] )    
arr2 = np.array( [ [7,8,9],[10,11,12] ] )  

np.concatenate( [arr1,arr2],axis = 1 )

hstack():
    '''
        功能: 数组合并。
        参数: 
            ① 将待合并的数组以***元组***的形式传给hstack。
            # 不需要设置axis参数。
        返回值: 合并后的数组。      
    '''
np.hstack( (arr1,arr2) )    

column_stack():   
    '''
        功能: 数组合并。
        参数: 
            ① 将待合并的数组以***元组***的形式传给hstack。和hstack()方法基本一样
            # 不需要设置axis参数。
        返回值: 合并后的数组。      
    '''
np.column_stack( (arr1,arr2) )   

np.concatenate( [arr1,arr2],axis = 0 )

vstack():       # 与hstack()相对应
    '''
        功能: 数组合并。
        参数: 
            ① 将待合并的数组以***元组***的形式传给hstack。
            # 不需要设置axis参数。
        返回值: 合并后的数组。      
    '''
np.vstack( (arr1,arr2) )    

row_stack():        # 与column_stack()相对应 
    '''
        功能: 数组合并。
        参数: 
            ① 将待合并的数组以***元组***的形式传给vstack。和vstack()方法基本一样
            # 不需要设置axis参数。
        返回值: 合并后的数组。      
    '''
np.row_stack( (arr1,arr2) )   

函数                          说明
abs()                           求取每个元素的绝对值
sqrt()                          求取每个元素的平方根
square()                        求取每个元素的平方
exp()                           计算每个元素的以 e 为底的指数
log()、log10()、log2()、log1p()    分别计算以 e 为底、10为底、2为底的对数，以及log(1+x)
modf()                          适用于浮点数，将小数和整数部分以独立的数组返回
isnan()                         用来判断是否是NaN,返回一个布尔值

括号里参数是待操作的数组.

arr = np.arange(4)  #np.arange(1,4,1)
# 求取各个元素的平方
np.square(arr)

# 求取各个元素的平方跟
np.sqrt(arr)

函数                      说明
sum()                       对数组中全部元素或 某行/列的元素求和
mean()                      求平均值
std()、var()                 分别求标准差和方差
min()、max()                 最小值、最大值
argmin()、argmax()            最小值对应的索引、最大值对应的索引
cumsum()                    所有元素的累计和，结果以数组的形式返回
cumprod()                   所有元素的累计积

arr = np.array( [ [1,2,3],[4,5,6] ] )
1.求和：sum()
# 对整个数组进行求和
arr.sum()
# 对数组的每一行进行求和
arr.sum(axis = 1)
# 对数组的每一列进行求和
arr.sum(axis = 0)

2.求均值：mean()
# 对整个数组进行求均值
arr.mean()
# 对数组的每一行进行求均值
arr.mean(axis = 1)
# 对数组的每一列进行求均值
arr.mean(axis = 0)

3.求最值：
# 对整个数组进行求最大值
arr.max()
# 对数组的每一行进行求最大值
arr.max(axis = 1)
# 对数组的每一列进行求最大值
arr.max(axis = 0)

where(condition,x,y):       
    '''
        功能: 
        参数: 
            ① condition: 条件。
            ② x: 符合条件返回x。
            ③ y: 符合条件返回y。
        返回值: 若条件（condition）为真则返回x，为假则返回y。      
    '''
    
arr = np.array( [55,70,99] )  
np.where(arr>60,"及格",'不及格')

# 若不写x，y，则返回满足条件的值对应的位置
np.where(arr>60)

inld(数组1,数组2):          
    '''
        功能: 包含。
        参数: 
            ① 数组1
            ② 数组2
        返回值: 判断数组1中包含数组2中的哪些值，如果包含则在对应的位置返回True，否则返回False。      
    '''
arr1 = np.array([1,2,3,4])    
arr2 = np.array([1,2,5]) 

np.in1d(arr1,arr2)

intersect1d(数组1,数组2):       
    '''
        功能: 交集。
        参数: 
            ① 数组1
            ② 数组2
        返回值: 返回两个数组中的公共部分。      
    '''
np.intersect1d(arr1,arr2)    

union1d(数组1,数组2):       
    '''
        功能: 并集。
        参数: 
            ① 数组1
            ② 数组2
        返回值: 返回两个数组中所有的元素。      
    '''
np.union1d(arr1,arr2)    

setdiff1d(数组1,数组2):         
    '''
        功能: 差集。
        参数: 
            ① 数组1
            ② 数组2
        返回值: 返回在数组1中存在，但在数组2中不存在的元素。      
    '''
np.setdiff1d(arr1,arr2)