Numpy基础知识总结

作者: 敬子v | 来源:发表于2023-01-11 21:37 被阅读0次

Numpy库（一）- 数组的创建
NumPy之索引技巧
Numpy札记1_基础知识
NumPy之操控ndarray的形状
NumPy之浅拷贝和深拷贝
numpy、pandas基础
Pytorch机器学习——2 安装和快速上手（一）
Pytorch机器学习——2 安装和快速上手（三）
Pytorch机器学习——2 安装和快速上手（四）
Pytorch机器学习——2 安装和快速上手（二）

数组创建

创建数组的方法：
1. 从其他Python结构转换（例如:列表，元组）
2. 内在的numpy数组创建对象（例如，arange，ones，zeros等）
3. 通过使用字符串或缓冲区从原始字节创建数组
4. 使用特殊库函数（例如，随机）
将Python array_like对象转换为Numpy数组

Python中以类数组结构排列的数字数据可以通过使用array()函数转换为数组。最明显的例子是列表和元组。使用array(深拷贝),asarray（浅拷贝）方法。
```
# python列表创建数组
a = [1,2,3]
b = np.array(a)
b ---> array([1,2,3])
# python元组创建数组
c = (1,2,3)
d = np.array(c)
d ---> array([1,2,3])
```

内在的numpy数组创建

np.ones(shape, dtype=None, order='C')：创建一个填充了具有指定形状的1值的数组。默认的dtype是float64。

ones = np.ones((3,4))
ones ---> array([[1., 1., 1., 1.],
       [1., 1., 1., 1.],
       [1., 1., 1., 1.]])
默认dtype('float64')

np.zeros(shape, dtype=None, order='C'): 创建一个填充了具有指定形状的0值的数组。默认的dtype是float64。

zeros = np.zeros((3,4))
ones ---> array([[0., 0., 0., 0.],
       [0., 0., 0., 0.],
       [0., 0., 0., 0.]])
默认dtype('float64')

np.arange(start,stop,step,dtype): 创建具有定期递增值的数组。

参数	描述
`start`	起始值,默认为`0`
`stop`	终止值（不包含)
`step`	两值的间隔,默认为`1`
`dtype`	数据类型

arange = np.arange(10,20,2)
arange  --->array([10, 12, 14, 16, 18])

arange = np.arange(10,20,2,dtype=np.float64)
arange  --->array([10., 12., 14., 16., 18.])

np.linspace(start, stop, num, endpoint, retstep, dtype): 创建具有指定数量元素的数组，并在指定的开始值和结束值之间平均间隔。

参数	描述
`start`	起始值
`stop`	终止值,如果`endpoint`为`True`,包含`stop`值
`num`	生成的等间隔样例数量,默认`50`
`endpoint`	是否包含`stop`值,默认`True`
`retstep`	如果为`True`，返回样例，以及连续数字之间的步长
`dtype`	数据类型

li = np.linspace(2,20,8)
li --->array([ 2.        ,  4.57142857,  7.14285714,  9.71428571, 12.28571429,
       14.85714286, 17.42857143, 20.        ])

li = np.linspace(2,20,8,retstep=True)
li --->(array([ 2.        ,  4.57142857,  7.14285714,  9.71428571, 12.28571429,
        14.85714286, 17.42857143, 20.        ]), 2.5714285714285716) # 包含样例

np.logspace(start, stop, num, endpoint, base, dtype):此函数返回一个ndarray对象，其中包含在对数刻度上均匀分布的数字。刻度的开始和结束端点是某个底数的幂，通常为 10。

参数	描述
`start`	起始值:`base ** start`
`stop`	终止值:`base ** stop`
`num`	生成的等间隔样例数量,默认`50`
`endpoint`	是否包含`stop`值,默认`True`
`base`	`base`对数空间的底数,默认为`10`
`dtype`	数据类型

# 对数空间为10
log_num = np.logspace(1,2,num=10)
log_num --->array([ 10.        ,  12.91549665,  16.68100537,  21.5443469 ,
        27.82559402,  35.93813664,  46.41588834,  59.94842503,
        77.42636827, 100.        ])
#对数空间为2
log_num = np.logspace(1,2,num=10, base=2)
log_num --->array([2.        , 2.16011948, 2.33305808, 2.5198421 , 2.72158   ,
       2.93946898, 3.1748021 , 3.42897593, 3.70349885, 4.        ])

通过使用字符串或缓冲区从原始字节创建数组

np.frombuffer(buffer, dtype = float, count = -1, offset = 0):此函数将缓冲区解释为一维数组。暴露缓冲区接口的任何对象都用作参数来返回ndarray。

参数	描述
`buffer`	任何暴露缓冲区借口的对象
`dtype`	返回数组的数据类型，默认为`float`
`count`	需要读取的数据数量，默认为`-1`，读取所有数据
`offset`	`offset` 需要读取的起始位置，默认为`0`

s =  b'Hello World' 
a = np.frombuffer(s, dtype =  'S1')  
a --->array([b'H', b'e', b'l', b'l', b'o', b' ', b'W', b'o', b'r', b'l', b'd'],
      dtype='|S1')

np.fromiter(iterable, dtype, count = -1):此函数从任何可迭代对象构建一个ndarray对象，返回一个新的一维数组。

序号	参数及描述
`iterable`	任何可迭代对象
`dtype`	返回数组的数据类型
`count`	需要读取的数据数量，默认为`-1`，读取所有数据

ls = range(5)
it = iter(ls)
x = np.fromiter(it, dtype='i1')
x --->array([0, 1, 2, 3, 4], dtype=int8)

使用特殊库函数（例如，随机random）

使用np.random创建随机数组。

均匀分布

np.random.rand(d0,d1,...,dn):根据给定的维度生成[0, 1)之间的随机数,dn每个维度, 若没有参数，则生成一个数.

np.random.rand() #随机生成一个数
#0.5726008714564191
np.random.rand(2) #随机生成一个一维数组
#array([0.61949677, 0.06182977])
np.random.rand(3,2)
"""array([[0.73937337, 0.34386129],
       [0.89393313, 0.09146219],
       [0.97990048, 0.49450004]])"""

np.random.randint(low,high=None,size=None,dtype='l'):生成取值区间为[low, high)的随机整数，若没有输入参数high则取值区间为[0, low),

low:最小值,

high:最大值,

size:数组维度大小，dtype:np.int

np.random.randint(3,size=3) #生成3个[0,3)之间的整数
#array([2, 0, 1])
np.random.randint(1,5) #size=None,生成一个[1,5)之间随机的一个整数
# 4
np.random.randint(1,5,size=(3,2)) #生成一个二维数组
"""array([[1, 3],
       [1, 2],
       [2, 4]])"""

np.random.uniform(low=0.0, high=1.0, size=None) :生成取值区间为[low,high) 的浮点数,默认取值范围[0,1.0).

low:最小值,float型,

high:最大值，float型,

size:数组维度大小，int型或tuple，

没有参数时，则生成一个数。

np.random.uniform() #随机生成一个0-1.0的随机数
#0.1726402474971156
np.random.uniform(size=(3,2)) #随机生成一个数据是0 - 1.0的二维数组
"""array([[0.72540688, 0.47681299],
       [0.90533783, 0.78988655],
       [0.47050509, 0.55306498]])"""
np.random.uniform(-1,1,size=10) #随机生成一个-1 - 1 的10个数的一维数组
"""array([-0.42469769,  0.66898184,  0.12269022,  0.59821852, -0.47739708,
       -0.85804074,  0.2332269 , -0.18532177, -0.04431914,  0.25257431])"""

正态分布

[图片上传失败...(image-343155-1673530550373)]

np.random.randn(d0,d1,....,dn):从标准正态分布中返回一个(d0d1 …* dn)维样本值.dn每个维度, 若没有参数，则生成一个数

np.random.randn() #随机生成一个数
#-0.6828353877094375
np.random.randn(1) #随机生成一个一维数组
#array([-0.27862247])
np.random.randn(3,2) #随机二维数组的数组
"""array([[-1.22491603,  1.49204094],
       [-0.17640881, -0.81221251],
       [-0.66017166, -0.18555491]])"""

np.random.normal(loc=0.0, scale=1.0, size=None): 从正态分布中返回样本值.

loc：float此概率分布的均值,对应着整个分布的中心centre.

scale：float此概率分布的标准差,对应于分布的宽度，scale越大越矮胖，scale越小，越瘦高

size：int or tuple

输出的shape，默认为None，只输出一个值

np.random.normal()#生成一个随机数，size=None
#-0.11276293905334074
np.random.normal(size=1)#生成一个一维数组
#array([0.20337865])
np.random.normal(1,3,size=(3,2))
"""array([[4.58915271, 3.11798389],
       [3.04339931, 1.13752776],
       [1.64524515, 2.19528162]])
"""

np.random.standard_normal(size=None):返回一个指定形状的标准正态分布的数组

np.random.standard_normal()#生成一个随机数
#-1.0320902045776343
np.random.standard_normal((3,2))
"""array([[-0.32021508,  1.09101575],
       [ 0.79058298,  1.34311915],
       [ 0.80387764,  1.72679853]])"""

知识点补充
1. 均匀分布
  
  是概率统计中的重要分布之一。是对称概率分布，在相同长度间隔的分布概率是等可能的,均匀分布由两个参数a和b定义，它们是数轴上的最小值和最大值，通常缩写为U（a，b）。均匀分布在自然情况下极为罕见，而人工栽培的有一定株行距的植物群落即是均匀分布。
2. 正态分布
  
  正态分布是一种概率分布。正态分布是具有两个参数μ和σ的连续型随机变量的分布，第一参数μ是服从正态分布的随机变量的均值，第二个参数σ是此随机变量的标准差，所以正态分布记作N(μ，σ )。
  
  μ决定了正态分布的位置，与μ越近，被取到的概率就越大，反之越小。σ描述的是正态分布的离散程度。σ越大，数据分布越分散曲线越扁平；σ越小，数据分布越集中曲线越陡峭。[图片上传失败...(image-b3e108-1673530550374)]
  1. 标准差
    
    在概率统计中最常使用作为统计分布程度（statisticaldispersion）上的测量。标准差定义是总体各单位标准值与其平均数离差平方的算术平均数的平方根。它反映组内个体间的离散程度。简单来说，标准差是一组数据平均值分散程度的一种度量。一个较大的标准差，代表大部分数值和其平均值之间差异较大；一个较小的标准差，代表这些数值较接近平均值。
    
    [图片上传失败...(image-5bdce7-1673530550374)]
  2. 方差
    
    在概率论和统计方差衡量随机变量或一组数据时离散程度的度量。概率论中方差用来度量随机变量和其数学期望（即均值）之间的偏离程度。统计中的方差（样本方差）是各个数据分别与其平均数之差的平方的和的平均数
    
    [图片上传失败...(image-93fe36-1673530550374)][图片上传失败...(image-435df9-1673530550374)]

案例

随机生成5组不同日期产品的内径尺寸(mm),一组10个产品。

数量:5*10=50

随机生成产品内径尺寸，服从正态分布,均值25，方差0.2

insider_dimension = np.random.normal(25,0.2,size=(5,10))
insider_dimension
"""array([[24.77932034, 25.09216143, 24.98151027, 25.25425569, 25.06858384,
        24.80284698, 25.36932156, 24.89354909, 24.97998914, 24.95034899],
       [25.36538522, 24.90967666, 24.89776366, 24.99716099, 25.19111566,
        24.95791022, 25.17159946, 24.88894164, 25.2616871 , 24.72602432],
       [24.8335387 , 24.94511824, 25.234648  , 25.02720878, 24.67977384,
        25.39512587, 24.83408903, 24.9939906 , 25.03388191, 25.2789348 ],
       [24.70520956, 24.95986831, 24.61549957, 24.90316804, 25.1648354 ,
        24.82632398, 25.03309053, 24.68034673, 25.27200361, 24.98097997],
       [25.29596002, 24.95591159, 25.38686463, 24.9376919 , 25.04607681,
        25.02220415, 24.99493607, 25.00036926, 25.11806958, 24.77333334]])
"""

Numpy数组形状和类型修改

np.reshape(a,newshape,order='C'):原数组size不变的前提下，改变原数组的形状

参数	描述
a	array_like要重新整形的数组
newshape	`int`或`int的tuple` ，新的形状应该和原始形状兼容如果是整数，则结果将是该长度的1-D数组。一个形状维度可以是`-1`。在这种情况下，从数组的长度和其余维度推断该值
order	{'C', 'F', 'A'} 'C' -- 按行，'F' -- 按列，'A' -- 原顺序。

ndarray.reshape(shape,order='C')：原数组size不变的前提下,返回包含具有新形状的相同数据的数组,与自由函数不同np.reshape，此方法ndarray允许将shape参数的元素作为单独的参数传递。

#ndarray.reshape方法
#随机生成一个数组
arr1 = np.random.rand(3,4)
""" 
array([[0.40919593, 0.53439411, 0.17478334, 0.88506119],
       [0.52465668, 0.40275561, 0.85389365, 0.69344744],
       [0.06308938, 0.24195379, 0.43457003, 0.5855962 ]])
"""
print(arr2.reshape(2,6)) #默认按行
"""
[[0.40919593 0.53439411 0.17478334 0.88506119 0.52465668 0.40275561]
 [0.85389365 0.69344744 0.06308938 0.24195379 0.43457003 0.5855962 ]]
 """
print(arr2.reshape(6,2,order='F')) #按列
"""
[[0.40919593 0.17478334]
 [0.52465668 0.85389365]
 [0.06308938 0.43457003]
 [0.53439411 0.88506119]
 [0.40275561 0.69344744]
 [0.24195379 0.5855962 ]]
"""

# np.reshape函数
np.reshape(arr2,(-1,3)) # -1从数组的长度和其余维度推断该值
"""
array([[0.40919593, 0.53439411, 0.17478334],
       [0.88506119, 0.52465668, 0.40275561],
       [0.85389365, 0.69344744, 0.06308938],
       [0.24195379, 0.43457003, 0.5855962 ]])
"""
#在转换形状的时候，一定要注意元素的个数，不能发生改变！

np.resize(a,new_shape):改变原数组的形状和大小，与reshape不同的是可以改变数组的size。如果新数组大于原始数组，则新数组将填充a的重复副本。

参数	描述
a	array_like要重新整形的数组
new_shape	`int`或`int的tuple`

ndarray.resize(new_shape):就地更改数组的形状和大小，会对原值进行修改并且返回的是None

#ndarray.resize
#缩小数组
a = np.array([[0, 1], [2, 3]])
a.resize(2,1)
"""
array([[0],
       [1]])
       """
#扩展数组 缺少的数据用 0 填充
b = np.array([[0, 1], [2, 3]])
b.resize(2,3)
"""
array([[0, 1, 2],
       [3, 0, 0]])
"""

#np.resize
#缩小数组
a=np.array([[0,1],[2,3]])
np.resize(a(1,2))
# array([[0, 1]])  a的值没有变化

#扩展数组 缺少的数据将由填充原数组的重复副本
b=np.array([[0,1],[2,3]])
np.resize(b,(3,3))
"""
array([[0, 1, 2],
       [3, 0, 1],
       [2, 3, 0]])
"""

.T:将原shape为（n，m）的数组转置为（m，n），把数组的行和列进行互换，一维数组转置不变。

arr3 = np.arange(12).reshape(3,4)
arr3.T
"""
array([[ 0,  4,  8],
       [ 1,  5,  9],
       [ 2,  6, 10],
       [ 3,  7, 11]])
"""

ndarray.astype(type):强制转换为指定的类型。

one = np.ones((3,4))
one
"""
array([[1., 1., 1., 1.],
       [1., 1., 1., 1.],
       [1., 1., 1., 1.]])
"""
one.dtype
#dtype('float64')
one.astype(np.int64)
"""
array([[1, 1, 1, 1],
       [1, 1, 1, 1],
       [1, 1, 1, 1]], dtype=int64)
"""
n1 = np.array(['1','2','3'],dtype=np.string_)
n1.astype(np.int64)
#array([1, 2, 3], dtype=int64)

#如果将浮点数转为整数,那么小数部分会被截断
n2 = np.random.uniform(1,5,size=(3,4))
n2
"""
array([[2.54847297, 1.47540363, 3.19716644, 2.88852565],
       [4.35936498, 4.14153717, 4.28468383, 2.98894034],
       [3.34067248, 2.73983194, 4.21287495, 1.30903491]])
"""
n2.astype(np.int64)
"""
array([[2, 1, 3, 2],
       [4, 4, 4, 2],
       [3, 2, 4, 1]], dtype=int64)
"""

Numpy数组基本索引与切片

ndarray对象的内容可以通过索引或切片来获取和修改，就像 Python 的内置容器对象一样。
一维数组:一维数组比较简单,看起来和python列表很类似。
```
a = np.arange(10)
a ---> array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
#索引
a[0] --->0
a[-1] --->9
#切片
a[2:5] --->array([2, 3, 4])
a[1::2] --->array([1, 3, 5, 7, 9])  #切片参数(start:stop:step)不包括终止索引
#赋值
a[2:5]=88 --->array([ 0,  1, 88, 88, 88,  5,  6,  7,  8,  9])
#copy
#浅copy
b = a[2:5]
b[:] = 666
a ---> array([  0,   1, 666, 666, 666,   5,   6,   7,   8,   9])
#深copy
c = a[2:5].copy()
c[:] = 888
a --->array([  0,   1, 666, 666, 666,   5,   6,   7,   8,   9])
```
深copy新建一个对象重新分配内存地址，复制对象内容。浅copy不重新分配内存地址，内容指向之前的内存地址。浅copy如果对象中有引用其他的对象，如果对这个子对象进行修改，子对象的内容就会发生更改。

数组的切片是原数组的视图，数据并不是被复制，任何对于视图的修改都会反映到原数组，想要复制数组的切片必须显示地复制这个数组，使用copy()函数

二维数组:每个索引值对应的元素不在是一个值，而是一个一维数组

arr1 = np.array([[1,2,3],[4,5,6],[7,8,9]])
#索引
arr1[1] --->array([4, 5, 6]) #获取的一个一维数组
arr1[1][1] ---> 5 #通过递归的方式。获取一个值，第一个索引获取到一维数组，第二个索引获取到值
arr1[1, 1] ---> 5 #使用逗号,分割列表去获取单个元素

#切片
arr1[:2] --->array([[1, 2, 3],
       [4, 5, 6]])  # 数组沿着行进行切片
arr1[:2, :2] ---> array([[1, 2],
       [4, 5]]) #多组切片 获取前两行前两列
arr1[:,:1] --->array([[1],
       [4],
       [7]]) #选取第一列 ，单独一个: 获取整个轴的数组

#切片和索引混合，可以得到低纬度的切片(数组降维)
arr1[1,:2] --->array([4, 5]) #选取第二行,前两列
arr1[:2,0] --->array([1, 4]) #选取第二列，前两行

多维数组

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

       [[ 7,  8,  9],
        [10, 11, 12]],

       [[13, 14, 15],
        [16, 17, 18]]])"""
#索引
arr2[0] --->array([[1, 2, 3],
       [4, 5, 6]]) #获得一个二维数组 获取第1层
arr2[0,0] --->array([1, 2, 3]) #获得一个一维数组 获取第1层的第1行
arr2[0,0,0] ---> 1 #获得一个值

#切片
arr2[:2] ---> array([[[ 1,  2,  3],
        [ 4,  5,  6]],

       [[ 7,  8,  9],
        [10, 11, 12]]]) # 获取前两层
arr2[:2,:1] --->array([[[1, 2, 3]],

       [[7, 8, 9]]]) # 获取前两层，第一行
arr2[:2,:1,:2] --->array([[[1, 2]],

       [[7, 8]]]) # 获取前两层的，第一行的前两列

#切片和索引
arr2[:,1] --->array([[ 4,  5,  6],
       [10, 11, 12],
       [16, 17, 18]]) # 获取所有层的第二行
arr2[:,1,1] --->array([ 5, 11, 17]) #获取所有层的第2行的第2列
arr2[:2,:2,2] --->array([[ 3,  6],
       [ 9, 12]]) #获取所有层的前2行的第3列

Numpy数组广播

广播:广播描述了算法如何在不同形状的数组之间的运算。

Numpy数组算术

arr1 = np.random.randint(10,size=(3,4))
arr1
"""
array([[2, 1, 0, 0],
       [9, 5, 1, 7],
       [8, 1, 5, 4]])
"""

arr1 * 2  #最简单的广播，标量和数组组合,标量值2，被广播给乘法运算中的所有其他元素
"""
array([[ 4,  2,  0,  0],
       [18, 10,  2, 14],
       [16,  2, 10,  8]])
"""

arr1 * arr1 #相同尺寸的数组运算
"""
array([[ 4,  1,  0,  0],
       [81, 25,  1, 49],
       [64,  1, 25, 16]])
"""

#在前面逻辑运算的时候我们已经讲过了，同尺寸的数组可以比较，得到的是一个布尔数组

广播的规则:对于每个结尾维度(从尾部开始),轴的长度都匹配或者相对应的轴一方长度是1，那么则认为可以兼容广播的，广播会在丢失的或在长度为1的轴上进行。

arr1 = np.arange(12).reshape(4,3)
arr1
"""
array([[ 0,  1,  2],
       [ 3,  4,  5],
       [ 6,  7,  8],
       [ 9, 10, 11]])
"""

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

arr3 = arr1 + arr2
arr3
"""
array([[ 1,  3,  5],
       [ 4,  6,  8],
       [ 7,  9, 11],
       [10, 12, 14]])
"""

arr1.shape
(4,3)
arr2.shape
(3,)
#满足我们广播规则,从尾部开始轴的长度匹配,广播是兼容的,广播在丢失的轴上进行。
#案例中丢失的是0轴,按'列'进行广播，一维数组沿0轴进行广播

arr4 = np.arange(1,5).reshape(4,1)
arr4
"""
array([[1],
       [2],
       [3],
       [4]])
"""
arr5 = arr1+arr4
arr5
"""
array([[ 1,  2,  3],
       [ 5,  6,  7],
       [ 9, 10, 11],
       [13, 14, 15]])
"""
arr1,shape
(4,3)
arr5.shape
(4,1)
#满足广播规则,从尾部开始，轴的长度一方为1,广播在缺失的轴上进行广播
#案例中丢失的是1轴,按'行'进行广播沿着轴1对二维数组进行广播

[图片上传失败...(image-63eed1-1673530550374)]

[图片上传失败...(image-5b3114-1673530550374)]

[图片上传失败...(image-94401b-1673530550374)]

总结

操作两个数组，先比较数组的shape：a.维度相等，b.相对应的轴长度为1
所有输入数组都向其中shape最长的数组看齐，shape中不足的部分都通过在前面加1补齐
输出数组的shape是输入数组shape的各个轴上的最大值

Numpy排序和唯一值

sort():排序,和python列表类型类似,Numpy数组可以使用sort方法排序

#一维数组
arr1 = np.random.randn(6)
arr1
"""
array([[18, 21],
       [30, 30],
       [18, 24],
"""
#sort方法进行排序
arr1.sort()
arr1
"""
array([-1.68364397, -1.17897152, -1.10061833, -0.80371391, -0.23651728,
        0.51205633])
"""

#二维
arr2 = np.random.randn(4,3)
arr2
"""
array([[ 0.25385474,  0.37914431,  0.57455817],
       [ 0.72876383,  0.16524266,  2.00815275],
       [ 1.03371677,  1.650364  ,  0.00470761],
       [-1.42358426,  0.89041625, -2.15399045]])
"""
arr2.sort()#默认按行
"""
array([[ 0.25385474,  0.37914431,  0.57455817],
       [ 0.16524266,  0.72876383,  2.00815275],
       [ 0.00470761,  1.03371677,  1.650364  ],
       [-2.15399045, -1.42358426,  0.89041625]])
"""
arr2.sort(axis=0) #指定0轴
arr2
"""
array([[-2.15399045, -1.42358426,  0.57455817],
       [ 0.00470761,  0.37914431,  0.89041625],
       [ 0.16524266,  0.72876383,  1.650364  ],
       [ 0.25385474,  1.03371677,  2.00815275]])
"""
#对于多维数组可以指定axis值，沿着轴对每一个一维数据进行排序

np.unique:返回的是数组中唯一值排序后的数组

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

np.unique(arr3)
#array([1, 2, 3])

arr4 = np.array([[1,2,3],[2,3,4]])
np.unique(arr4)
#array([1, 2, 3, 4])

np.in1d:检查一个数组中的值是否在另外一个数组中，并返回一个布尔数组.

np.in1d(arr3,[1,2])
#array([ True,  True, False,  True,  True, False])
np.in1d(arr4,[1,3])
#array([ True, False,  True, False,  True, False])

Numpy矩阵乘法

场景：

#模拟6位学生成绩（平时成绩0.3和期末成绩0.7）,求总成绩
arr1 = np.random.randint(80,100,size=(6,2))
arr1
"""
array([[88, 91],
       [95, 82],
       [87, 82],
       [97, 97],
       [99, 82],
       [99, 94]])
"""
arr2 =  np.array([0.3,0.7])
arr2
"""
array([0.3, 0.7])
"""
arr1 * arr2 #不符合我们需求
"""
array([[26.4, 63.7],
       [28.5, 57.4],
       [26.1, 57.4],
       [29.1, 67.9],
       [29.7, 57.4],
       [29.7, 65.8]])
"""
arr3 = np.array([[0.3],[0.7]])
"""
array([[0.3],
       [0.7]])
"""
arr1*arr3  #不满足我们数组的广播

#那怎么求了？矩阵乘法

矩阵:矩阵和array的区别,矩阵必须是二维的,但是array可以是多维

np.mat():将数组类型转化为矩阵类型

np.mat(arr1)
"""
matrix([[88, 91],
        [95, 82],
        [87, 82],
        [97, 97],
        [99, 82],
        [99, 94]])
"""

矩阵乘法

(m,p) * (p,n) = (m,n)

[图片上传失败...(image-2b1609-1673530550374)]

np.dot()：

np.dot(arr1,arr3)
"""
array([[90.1],
       [85.9],
       [83.5],
       [97. ],
       [87.1],
       [95.5]])
"""

案例:

"""矩阵A：某公司有四个工厂，分布在不同地区，同时三种产品，产量（单位；t）,矩阵B：第一列表示三种产品的单件利润，第二列表示三种产品的单件体积。求工厂利润和四个工厂产品体积"""
arr1 = np.random.randint(1,5,size=(4,3))
arr1
#四个工厂，三种产品，四行分别代表四个工厂，三列分别代表三种产品的产量
"""
array([[3, 3, 1],
       [4, 2, 4],
       [2, 4, 2],
       [2, 3, 1]])
"""
arr2 = np.random.randint(1,5,size=(3,2))
arr2
"""
array([[4, 3],
       [1, 3],
       [3, 3]])
"""

np.dot(arr1,arr2)
"""
array([[18, 21],
       [30, 30],
       [18, 24],
       [14, 18]])
"""

逻辑运算

比较运算符 >, >=, <, <=, ==, != ，比较运算符，返回的是一个布尔数组。
逻辑运算符与:&, 或:|,非:~

二元通用函数与:logical_and, 或:logical_or, 非:lodical_not

#比较运算符
#向量化
arr1 = np.random.randn(4,3)
arr1
"""
array([[-0.11644283,  0.26881624, -0.636891  ],
       [ 0.41491463,  0.75958032, -0.79139132],
       [-0.65056162, -1.65086047,  0.30840633],
       [ 0.44048015,  2.60792486, -1.2136428 ]])
"""
arr1 < 1
"""
array([[ True,  True,  True],
       [ True,  True,  True],
       [ True,  True,  True],
       [ True, False,  True]])
"""
#数组与数组比较
arr2 = np.random.randn(4,3)
arr2
"""
array([[ 1.07975731,  0.48405982,  0.83102948],
       [ 0.25161364, -0.84813959,  0.30692867],
       [ 0.67593645,  2.11885395,  0.52587073],
       [-0.82323498,  0.87254439, -0.55737282]])
"""
arr1 > arr2
"""
array([[False, False, False],
       [ True,  True, False],
       [False, False, False],
       [ True,  True, False]])
"""

#逻辑运算符
(arr1>-0.5) & (arr1<0.5)
"""
array([[ True,  True, False],
       [ True, False, False],
       [False, False,  True],
       [ True, False, False]])
"""
(arr1>-0.5) | (arr1<0.5)
"""
array([[ True,  True,  True],
       [ True,  True,  True],
       [ True,  True,  True],
       [ True,  True,  True]])
"""
~(arr1>0)
"""
array([[ True, False,  True],
       [False, False,  True],
       [ True,  True, False],
       [False, False,  True]])
"""

#二元通用函数
np.logical_and(arr1>-0.5 , arr1<0.5)
"""
array([[ True,  True, False],
       [ True, False, False],
       [False, False,  True],
       [ True, False, False]])
"""
np.logical_or(arr1>-0.5 , arr1<0.5)
"""
array([[ True,  True,  True],
       [ True,  True,  True],
       [ True,  True,  True],
       [ True,  True,  True]])
"""
np.logical_not(arr1>-0.5)
"""
array([[False, False,  True],
       [False, False,  True],
       [ True,  True, False],
       [False, False,  True]])
"""

np.where(condition, x, y):是三元表达式 x if condition else y的向量化。如果是True,输出x,相反,False，输出y。传递给np.where的数组可以是同等大小的数组，也可以是标量。

#1.
np.where([[True,False], [True,True]],   #condition
             [[1,2], [3,4]],            #x
             [[9,8], [7,6]])            #y
"""
array([[1, 8],
       [3, 4]])
"""
# 2.
np.where(arr1>0) #只有条件 (condition)，没有x和y，则输出满足条件 (即非0) 元素的坐标。这里的坐标以tuple的形式给出，通常原数组有多少维，输出的tuple中就包含几个数组，分别对应符合条件元素的各维坐标。
"""
(array([0, 1, 1, 2, 3, 3], dtype=int64),
 array([1, 0, 1, 2, 0, 1], dtype=int64))
"""
# 3. 典型用法,标量和数组联合，进行值的替换
np.where(arr1>0,1,-1)
"""
array([[-1,  1, -1],
       [ 1,  1, -1],
       [-1, -1,  1],
       [ 1,  1, -1]])
"""

any(),all()方法: 这两个方法可以快速检查布尔数组,any():检查数组中是否至少有一个True, all():检查是否每个值都为True.

(arr1 <1).sum() # True的个数
11

(arr1<1).any()
True

np.all((arr1<1))
False
# 这两个方法同时也可以适用于非布尔数组，非0的 元素就会按True处理

Numpy数组合并,分割,元素重复

np.concatenate

arr1 = np.arange(1,7).reshape(2,3)
arr1
"""
array([[1, 2, 3],
       [4, 5, 6]])
"""

arr2 = np.arange(7,13).reshape(2,3)
arr2
"""
array([[ 7,  8,  9],
       [10, 11, 12]])
"""

np.concatenate((arr1,arr2)) #默认axis=0
"""
array([[ 1,  2,  3],
       [ 4,  5,  6],
       [ 7,  8,  9],
       [10, 11, 12]])
"""
np.concatenate((arr1,arr2),axis=1) #指定axis=1
"""
array([[ 1,  2,  3,  7,  8,  9],
       [ 4,  5,  6, 10, 11, 12]])
"""

np.vstack

np.vstack((arr1,arr2)) #沿着轴0合并数组
"""
array([[ 1,  2,  3],
       [ 4,  5,  6],
       [ 7,  8,  9],
       [10, 11, 12]])
"""

np.hstack

np.hstack((arr1,arr2))  #沿着轴1合并数组
"""
array([[ 1,  2,  3,  7,  8,  9],
       [ 4,  5,  6, 10, 11, 12]])
"""

np.split

arr3 = np.random.randn(5,3)
arr3
"""
array([[-1.62753568,  0.09844282,  0.24826172],
       [-0.51082413,  1.02423446, -0.82945161],
       [ 0.68448996,  0.1510686 ,  1.25115637],
       [ 1.68088646,  0.35070315, -0.74911414],
       [ 1.05348859,  1.28620817,  0.1522841 ]])
"""
np.split(arr3,[1,3]) #默认按 0轴分割， [1,3]表示数组拆分时，按索引位置拆分
"""
[array([[-1.62753568,  0.09844282,  0.24826172]]),
 array([[-0.51082413,  1.02423446, -0.82945161],
        [ 0.68448996,  0.1510686 ,  1.25115637]]),
 array([[ 1.68088646,  0.35070315, -0.74911414],
        [ 1.05348859,  1.28620817,  0.1522841 ]])]
"""

np.split(arr3,[1,2],axis=1) #指定1轴分割
"""
[array([[-1.62753568],
        [-0.51082413],
        [ 0.68448996],
        [ 1.68088646],
        [ 1.05348859]]), array([[0.09844282],
        [1.02423446],
        [0.1510686 ],
        [0.35070315],
        [1.28620817]]), array([[ 0.24826172],
        [-0.82945161],
        [ 1.25115637],
        [-0.74911414],
        [ 0.1522841 ]])]
"""
np.split(arr3,5) # 5表示把数组分割成5组，只能是均等分割
"""
[array([[-1.62753568,  0.09844282,  0.24826172]]),
 array([[-0.51082413,  1.02423446, -0.82945161]]),
 array([[0.68448996, 0.1510686 , 1.25115637]]),
 array([[ 1.68088646,  0.35070315, -0.74911414]]),
 array([[1.05348859, 1.28620817, 0.1522841 ]])]
"""
#ValueError: array split does not result in an equal division,不是均等分割报这个错

np.array_split:和split的区别是，可以不均等分割

np.array_split(arr3,3) 
"""
[array([[-1.62753568,  0.09844282,  0.24826172],
        [-0.51082413,  1.02423446, -0.82945161]]),
 array([[ 0.68448996,  0.1510686 ,  1.25115637],
        [ 1.68088646,  0.35070315, -0.74911414]]),
 array([[1.05348859, 1.28620817, 0.1522841 ]])]
"""

np.hsplit

np.hsplit(arr3,[1,2])
"""
[array([[-1.62753568],
        [-0.51082413],
        [ 0.68448996],
        [ 1.68088646],
        [ 1.05348859]]), array([[0.09844282],
        [1.02423446],
        [0.1510686 ],
        [0.35070315],
        [1.28620817]]), array([[ 0.24826172],
        [-0.82945161],
        [ 1.25115637],
        [-0.74911414],
        [ 0.1522841 ]])]
 """

np.vsplit

np.vsplit(arr3,[1,3])
"""
[array([[-1.62753568,  0.09844282,  0.24826172]]),
 array([[-0.51082413,  1.02423446, -0.82945161],
        [ 0.68448996,  0.1510686 ,  1.25115637]]),
 array([[ 1.68088646,  0.35070315, -0.74911414],
        [ 1.05348859,  1.28620817,  0.1522841 ]])]
"""

repeat：按照给定的次数，对数组的元素进行复制

arr = np.arange(3)
a = arr.repeat(3) #传入一个整数,元素重复相应的次数
a
#array([0, 0, 0, 1, 1, 1, 2, 2, 2])
b = arr.repeat([2,2,3]) #传入一个整数数组,每个元素会重复相应的不同次数
b
#array([0, 0, 1, 1, 2, 2, 2]) 

#多维
arr = np.random.rand(4,3)
arr
"""
array([[0.43173965, 0.26514662, 0.77984414],
       [0.13906945, 0.25396541, 0.77220584],
       [0.57093281, 0.97762641, 0.68158357],
       [0.7133476 , 0.32654828, 0.02919563]])
"""

arr.repeat(2,axis=0) #指定轴0，也可以指定轴1
"""
array([[0.43173965, 0.26514662, 0.77984414],
       [0.43173965, 0.26514662, 0.77984414],
       [0.13906945, 0.25396541, 0.77220584],
       [0.13906945, 0.25396541, 0.77220584],
       [0.57093281, 0.97762641, 0.68158357],
       [0.57093281, 0.97762641, 0.68158357],
       [0.7133476 , 0.32654828, 0.02919563],
       [0.7133476 , 0.32654828, 0.02919563]])
"""

arr.repeat([1,2,3,4],axis=0) #传入整数数组,整数数组长度要和轴的长度匹配
"""
array([[0.43173965, 0.26514662, 0.77984414],
       [0.13906945, 0.25396541, 0.77220584],
       [0.13906945, 0.25396541, 0.77220584],
       [0.57093281, 0.97762641, 0.68158357],
       [0.57093281, 0.97762641, 0.68158357],
       [0.57093281, 0.97762641, 0.68158357],
       [0.7133476 , 0.32654828, 0.02919563],
       [0.7133476 , 0.32654828, 0.02919563],
       [0.7133476 , 0.32654828, 0.02919563],
       [0.7133476 , 0.32654828, 0.02919563]])
"""

arr.repeat([1,2,3],axis=1)
"""
array([[0.43173965, 0.26514662, 0.26514662, 0.77984414, 0.77984414,
        0.77984414],
       [0.13906945, 0.25396541, 0.25396541, 0.77220584, 0.77220584,
        0.77220584],
       [0.57093281, 0.97762641, 0.97762641, 0.68158357, 0.68158357,
        0.68158357],
       [0.7133476 , 0.32654828, 0.32654828, 0.02919563, 0.02919563,
        0.02919563]])
"""

Numpy数学统计运算

基础数组统计方法

方法	描述
sum	总和
mean	平均数
std	标准差
var	方差
min	最小值
max	最大值
argmin	最小值的位置
argmax	最大值的位置

#我们可以调用实例方法,也可以使用顶层的Numpy函数,
arr2 = np.random.randn(4,3)
arr2
"""
array([[ 1.15329974,  2.02817106, -0.12567425],
       [-1.30186382,  0.71690951,  1.42288858],
       [ 0.31400007, -1.16320146,  1.48839135],
       [ 0.34372291, -0.87491238, -1.53228751]])
"""
arr2.sum() #np.sum(arr2)
#2.4694438093171573
arr2.mean()
# 0.20578698410976312
np.argmin(arr2)
# 11
arr2.argmax()
# 1

#指定轴进行运算
#axis:参数用于计算给定轴的统计值,形成一个下降一维度的数组
# axis=1按行 axis=0按列
arr2.max(axis=1)
#array([2.02817106, 1.42288858, 1.48839135, 0.34372291])
arr2.max(axis=0)
#array([1.15329974, 2.02817106, 1.48839135])
np.argmin(arr2,axis=1)
#array([2, 0, 1, 2], dtype=int64)

Numpy库（一）- 数组的创建
1 Numpy预备基础知识： 1.1 Numpy数据类型： 1.2 Numpy数组属性： 1.2.1 各个...
NumPy之索引技巧
系列文章一次性搞定NumPy入门基础知识NumPy之操控ndarray的形状NumPy之浅拷贝和深拷贝NumPy...
Numpy札记1_基础知识
Numpy 基础知识 Numpy的主要对象是同质的多维数组。Numpy中的元素放在[]中，其中的元素通常都是数字，...
NumPy之操控ndarray的形状
系列文章一次性搞定NumPy入门基础知识NumPy之操控ndarray的形状NumPy之浅拷贝和深拷贝概述这...
NumPy之浅拷贝和深拷贝
系列文章一次性搞定NumPy入门基础知识NumPy之操控ndarray的形状NumPy之浅拷贝和深拷贝概述 N...
numpy、pandas基础
数据分析基础知识点 -- numpy and Pandas 1.numpy: 适合处理统一的数值数组数据 -- n...
Pytorch机器学习——2 安装和快速上手（一）
outline PyTorch安装 Jupyter Notebook使用 NumPy基础知识 PyTorch基础知...
Pytorch机器学习——2 安装和快速上手（三）
outline PyTorch安装 Jupyter Notebook使用 NumPy基础知识 PyTorch基础知...
Pytorch机器学习——2 安装和快速上手（四）
outline PyTorch安装 Jupyter Notebook使用 NumPy基础知识 PyTorch基础知...
Pytorch机器学习——2 安装和快速上手（二）
outline PyTorch安装 Jupyter Notebook使用 NumPy基础知识 PyTorch基础知...

Numpy基础知识总结

数组创建

Numpy数组形状和类型修改

Numpy数组基本索引与切片

Numpy数组广播

Numpy排序和唯一值

Numpy矩阵乘法

Numpy数组合并,分割,元素重复

Numpy数学统计运算

相关文章

Numpy库（一）- 数组的创建

NumPy之索引技巧

Numpy札记1_基础知识

NumPy之操控ndarray的形状

NumPy之浅拷贝和深拷贝

numpy、pandas基础

Pytorch机器学习——2 安装和快速上手（一）

Pytorch机器学习——2 安装和快速上手（三）

Pytorch机器学习——2 安装和快速上手（四）

Pytorch机器学习——2 安装和快速上手（二）

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读