numpy库的使用

起名字真难.

已于 2024-06-07 22:41:08 修改

阅读量569

点赞数 12

文章标签： numpy

于 2024-05-12 22:36:51 首次发布

本文链接：https://blog.csdn.net/2201_75875108/article/details/138764942

版权

一、numpy库的概述

二、创建ndarray

1、使用np.array()

2、使用np.ones(shape, dtype = None, order = 'C')

3、np.zeros(shape,dtype = float, order = 'C')

4、np.full(shape, fill_value, dtype = None, order = ‘C’)

5、np.eye(N, M=None,k=0,dtype=float)

6、np.linspace(start,stop,num=50,endpoint=True,retstep=False,dtype=None)

7、np.arange([start, ]stop,[step,] dtype = None)

8、np.random.randint(low, high= None, size = None, dtype='l')

9、np.random.randn(d0,d1,...,dn)

10、np.randam.normal(loc = 0.0, scale = 1.0,size = None)

11、np.random.random(size = None)

12、np.random.rand(d0,d1,...,dn)

要点：numpy是用于处理含有同种元素的多维数组运算的第三方库

一、numpy库的概述

        Python 标准库中提供了一个array类型，用于保存数组类型数据，然而这个类型不支持多维数据，处理函数也不够丰富，不适合数值运算。因此，Python语言的第三方库numpy 得到了迅速的发展，至今，numpy 已经成为了科学计算事实上的标准库。

        numpy 库处理的最基础的数据类型是由同种元素构成的多维数组，（ndarray），简称“数组”。数组中所有元素的类型必须相同，数组中的元素可以用整数索引，序号从开始。ndarray类型维度（dimensions）叫做轴（axes），轴的个数叫做秩（rank）。一维数组的秩为1，二维数组的秩为2，二维数组相当于由两个一维数组构成。

        由于numpy库中函数较多且名字容易与常用的命名混淆，建议采用如下的方式引用numpy 库：

import numpy as np

其中，as保留字与import 一起使用能够改变后续代码中库的命名空间，有助于提高代码的可读性。简单地说，在程序的后续部分中，np代替numpy。

在数据分析中一切皆数据。

二、创建ndarray

扩展库Numpy 可以把Python 列表、元组、 range 对象等转换为数组，也可以直接生成待定类型的数组，支持数组与标量。数组与数组之间的四则运算，以及布尔运算、函数运算等功能。

1、使用np.array()

①、numpy默认ndarray的所有元素的类型是相同的

②、如果传进来的列表中包含不同的类型，则统一为统一类型，优先级：str > float > int

③、ndarray的常用数据类型（在后面需要指定类型的时候会用到）

int：int8 、int16、int32、int64。

florat：float16、float32、float64。、

str：字符串

# 导入numpy 第三方标准库
import numpy as np

a = np.array([2, 2.2, '2'])
print(a)

"""
输出结果：['2' '2.2' '2']
"""

2、使用np.ones(shape, dtype = None, order = 'C')

创建一个所有元素都为1的多维数组

参数说明：

①.shape：形状

②.dtype = None：元素类型。在这里指定类型的时候np.int16...或者其他上面出现的类型

③.order：{‘C’， ‘F’}，可选，默认值：C是否在内存中已经为主（C-风格）或为主（Fort然风格）顺序存储多维数据一般默认即可。

# 导入numpy 第三方标准库
import numpy as np

a = np.ones(shape=(2, 2), dtype=np.int16)
print(a)

"""
输出结果:
[[1 1]
 [1 1]]
"""

3、np.zeros(shape,dtype = float, order = 'C')

创建一个所有元素都为0的多维数组

参数说明：

①.shape：形状

②.dtype = None：元素类型

# 导入numpy 第三方标准库
import numpy as np

a = np.zeros(shape=(2, 2), dtype=np.int16)
print(a)
# 下面的shape，和dtype:给省略了; 和上面的代码相同
a = np.zeros((2, 2), np.int16)
print(a)

"""
输出结果:
[[0 0]
 [0 0]]
"""

4、np.full(shape, fill_value, dtype = None, order = ‘C’)

创建一个所有元素都为指定元素的多维数组

参数说明：

①.shape：形状

②.fill_value：填充值

③.dtype = None：元素类型

# 导入numpy 第三方标准库
import numpy as np

a = np.full(shape=(2, 2), fill_value=6, dtype=str)
print(a)

"""
输出结果:
[['6' '6']
 ['6' '6']]
"""

5、np.eye(N, M=None,k=0,dtype=float)

对角线为1 其他的位置为0 的二维数组

参数说明：

①.N：行数

②.M：列数

③.k = 0：向右偏移0个位置，主对角线。k也可以等于负数向左偏移。

④.dtype = None：元素类型

注意：在这里输入行数和列数是没有小括号的。

# 导入numpy 第三方标准库
import numpy as np

a = np.eye(3, 2, k=-1, dtype=np.int16)
print(a)

"""
输出结果：
[[0 0]
 [1 0]
 [0 1]]
"""

# 也可以只写N，则M会默认和N相同
a = np.eye(N=3, dtype=np.int16)
print(a)
"""
输出结果：
[[1 0 0]
 [0 1 0]
 [0 0 1]]
"""

6、np.linspace(start,stop,num=50,endpoint=True,retstep=False,dtype=None)

上面这一个比较常用

创建一个等差数列

参数说明：

①. start：开始值

②. stop：结束值

③. num = 50：等差数列中默认有50个数

④. endpoint = True：是否包含结束值，在默认情况下是包含的。

⑤. retstep = False：是否返回等差值（步长）当等于True时会在最后显示步长。

⑥. dtype = None：元素类型

注意：默认的情况下是包含结束值的，一般只会给前三个参数。

# 导入numpy 第三方标准库
import numpy as np

a = np.linspace(1, 5, num=3)
print(a)

"""
输出结果：
[1. 3. 5.]
"""

7、np.arange([start, ]stop,[step,] dtype = None)

创建一个数值范围的数组

和Python中range功能类似

参数说明：

start：开始值（可选）
stop：结束值（不包含）
step：步长（可选）
dtype = None：元素类型

# 导入numpy 第三方标准库
import numpy as np

a = np.arange(1, 5, 2)
print(a)

"""
输出结果:
[1 3]
"""

8、np.random.randint(low, high= None, size = None, dtype='l')

创建一个随机的整数的多维数组

参数说明：

①. low：最小值high = None：

②. 最大值，如果high = None时，生成的数值在[low, high)区间，如果使用high这个值，则生产=成的数值在[low, high]区间。

③. size = None：数组形状，默认只输出一个随机值。

④. dtype = None:元素类型

# 导入numpy 第三方标准库
import numpy as np
a = np.random.randint(1, 20, 5)
print(a)

"""
输出结果：
[ 1 19 14 13  5]
因为是随机的每一次都不会一样。
"""

9、np.random.randn(d0,d1,...,dn)

        创建一个服从标准正态分布的多维数组。

        标准正态分布称为u分布，是以0为均数，以1为标准差的正态分布，记作N（0， 1）标准正态分布，在0左右出现的概率最大，越远离出现的概率越低，

参数说明：

        dn：第n个维度的数值

# 导入numpy 第三方标准库
import numpy as np
a = np.random.randn(2, 2)
print(a)

"""
结果在原点的左右
输出结果：
[[-0.00928067 -0.89980204]
 [ 0.38432625 -0.04058469]]
"""

10、np.randam.normal(loc = 0.0, scale = 1.0,size = None)

创建一个服从正态分布的多维数组

参数说明：

        ①.、loc = 0.0：均值，值对应着正态分布的中心。

        ②、scale：标准差，对应分布的宽度，scale越大，正态分布的曲线越胖，scale越小，曲线越高瘦

        ③、size = None:数组形状

# 导入numpy 第三方标准库
import numpy as np
a = np.random.normal(100, 10, (3, 3))
print(a)

"""
输出结果：
[[ 99.05578725  91.85309708  95.42088503]
 [ 96.97259129 113.00102822  86.52416231]
 [ 91.13560786  83.6749118   87.44230937]]
"""

11、np.random.random(size = None)

创建一个元素为0~1（左闭右开）的随机数的多维数组。

参数说明：

size = None：数组形状。

# 导入numpy 第三方标准库
import numpy as np

a = np.random.random(size = (2, 2))
print(a)

"""
输出结果：
[[0.63589886 0.32039163]
 [0.279946   0.85167285]]
"""

12、np.random.rand(d0,d1,...,dn)

        创建一个元素为0~1（左闭右开）的随机数的多维数组

        和np.random.random(size = None)功能类似，掌握其中一个即可。

参数说明：

         dn: 第n个维度的数值。

# 导入numpy 第三方标准库
import numpy as np

a = np.random.rand(3, 2)
print(a)

"""
输出结果：
[[0.26175765 0.9252808 ]
 [0.96853119 0.16443834]
 [0.83595591 0.44628897]]
"""

三、ndarray的属性

4个重要属性：

①、ndim：维度

②、shape：形状（各维度的长度）

③、size：总长度，表示主数据量

④、dtype：元素类型

import numpy as np

a = np.array([[1, 2], [1, 2]])
print(a)
print(a.ndim)
print(a.shape)
print(a.size)
print(a.dtype)

"""
输出结果：
[[1 2]
 [1 2]]
2
(2, 2)
4
int32
"""

四、Numpy的基本操作

1、Ndarray索引操作

1、一维与列表完全一致多维时同理

2、多维数组：在利用索引取数是可以简化

3、其他的和Python的列表几乎相同，也可以根据下标来更改数组中的数组，唯一的不同是在Ndrray多维数组修改时（看下面代码的例子：就会发现与列表修改的不同）。

import numpy as np

a = np.random.randint(0, 101, (5, 5))
print("原数组 = ", a)
print("把最后一个元素取出来 = ", a[-1][-1])
print("把最后一个元素取出来 = ", a[4][4])
# 简化，简写
print("把最后一个元素取出来 = ", a[-1, -1])
print("把最后一个元素取出来 = ", a[4, 4])


"""
原数组 =  [[86 45 91 13 95]
 [ 1 29 67 67 73]
 [22  9 56 21 67]
 [35 38 41  0 37]
 [84 63 94 76 10]]
把最后一个元素取出来 =  10
把最后一个元素取出来 =  10
把最后一个元素取出来 =  10
把最后一个元素取出来 =  10
"""

# 通过索引来修改数组
a = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
c = np.array(a)
c[0][0] = 10
print(c)

"""
输出结果：
[[[10 10]
  [ 3  4]]

 [[ 5  6]
  [ 7  8]]]
"""

2、Ndarray切片操作

1、一维时与列表完全一致。

2、二维数据：①、取一行，取连续的多行，取不连续的多行。

②、取一列，取连续的多列，取不连续的多列。

③、翻转。

有关取行的代码：

import numpy as np

# a = np.random.randint(0, 5, size=(5, 5))
a = np.array([[1, 4, 4, 0, 1],
              [3, 0, 2, 2, 2],
              [4, 2, 2, 4, 3],
              [4, 3, 0, 2, 2],
              [2, 3, 1, 2, 2]])
print("取一行", a[2])
print("取连续的多行", a[0:2], sep="\n")
print("取不连续的多行", a[[1, 3, 4]], sep='\n')

"""
输出的结果：
取一行 [4 2 2 4 3]
取连续的多行
[[1 4 4 0 1]
 [3 0 2 2 2]]
取不连续的多行
[[3 0 2 2 2]
 [4 3 0 2 2]
 [2 3 1 2 2]]"""

有关取列的代码：

a = np.array([[1, 4, 4, 0, 1],
              [3, 0, 2, 2, 2],
              [4, 2, 2, 4, 3],
              [4, 3, 0, 2, 2],
              [2, 3, 1, 2, 2]])
print("取出第一列", a[:, 0])
print("取出连续的多列", a[:, 0:3],sep='\n')
print("取出不连续的多列", a[:, [0, 2, 4]], sep="\n")

"""
输出的结果：

取出第一列 [1 3 4 4 2]
取出连续的多列
[[1 4 4]
 [3 0 2]
 [4 2 2]
 [4 3 0]
 [2 3 1]]
取出不连续的多列
[[1 4 1]
 [3 2 2]
 [4 2 3]
 [4 0 2]
 [2 1 2]]
"""

数组的翻转

import numpy as np
a = np.array([[1, 2, 3, 4, 5],
              [6, 7, 8, 9, 10],
              [11, 12, 13, 14, 15],
              [16, 17, 18, 19, 20],
              [21, 22, 23, 24, 25]])
print("对行做翻转,上下翻转:", a[::-1], sep='\n')
print("对列做翻转，左右翻转:", a[:, ::-1], sep="\n")
print("整体翻转，翻转180度:", a[::-1][:, ::-1], sep='\n')

"""
对行做翻转,上下翻转:
[[21 22 23 24 25]
 [16 17 18 19 20]
 [11 12 13 14 15]
 [ 6  7  8  9 10]
 [ 1  2  3  4  5]]
对列做翻转，左右翻转:
[[ 5  4  3  2  1]
 [10  9  8  7  6]
 [15 14 13 12 11]
 [20 19 18 17 16]
 [25 24 23 22 21]]
整体翻转，翻转180度:
[[25 24 23 22 21]
 [20 19 18 17 16]
 [15 14 13 12 11]
 [10  9  8  7  6]
 [ 5  4  3  2  1]]
"""

五、Numpy的一些常用函数

        1、Ndarray变形：reshape

        2、Ndarray级联：concatenate/ np.hstack/ np.vstack

        3、Ndarray拆分：np.split

4、copy拷贝：函数创建副本

1、reshape变形

reshape：可是使得数组变形。

reshape: 当一个生成是n维的时候，可以只写n - 1个数，其中一个写成-1，则会自动计算匹配。

import numpy as np

a = np.arange(1, 21)
b1 = np.reshape(a, (4, 5))  # b1和下面的b2的结果是一样的
b2 = a.reshape((4, 5))
print("a = ", a)
print("b1 = ", b1, sep="\n")
print("b2 = ", b2, sep="\n")

"""
输出结果：
a =  [ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20]
b1 = 
[[ 1  2  3  4  5]
 [ 6  7  8  9 10]
 [11 12 13 14 15]
 [16 17 18 19 20]]
b2 = 
[[ 1  2  3  4  5]
 [ 6  7  8  9 10]
 [11 12 13 14 15]
 [16 17 18 19 20]]
"""

2、级联

np.concatenate()

        参数是列表或元组。

        级联的数组维度必须相同。

        可以通过axis参数改变级联的方向。

np.hstack(( , )): 左右合并，左右级联

np.vstack(( , )): 上下合并，上下级联

import numpy as np

a = np.random.randint(0, 100, size=(3, 5))
b = np.random.randint(0, 100, size=(3, 5))

c = np.concatenate((a, b))  # 默认上下合并
d = np.concatenate((a, b), axis=1) #左右和并
print(c)
print(d)
# 左右合并，水平级联
c = np.hstack((a, b))  # 左右和合并
print(c)
# 上下合并，垂直级联
c = np.vstack((a, b))
print(c)

"""
输出结果：
[[72 38 36 99 74]
 [ 8 12  2 21 41]
 [19 15 65 30 88]
 [57 60 47 41 11]
 [72 60 17 31 25]
 [25 50  5 59 10]]
[[72 38 36 99 74 57 60 47 41 11]
 [ 8 12  2 21 41 72 60 17 31 25]
 [19 15 65 30 88 25 50  5 59 10]]
[[72 38 36 99 74 57 60 47 41 11]
 [ 8 12  2 21 41 72 60 17 31 25]
 [19 15 65 30 88 25 50  5 59 10]]
[[72 38 36 99 74]
 [ 8 12  2 21 41]
 [19 15 65 30 88]
 [57 60 47 41 11]
 [72 60 17 31 25]
 [25 50  5 59 10]]
"""

3、切分 / 拆分 / 分割

与级联类似，三个函数完成切分工作：

        np.split()：可以拆分行或者列，axis = 0的时候表示行，1的时候表示列默认的是按照行进行拆分。

        np.vsplit()：按照垂直（拆分行）的方向拆分。

        np.hsplit()：按照水平（拆分列）的反向拆分。

import numpy as np

a = np.random.randint(10, 100, (6, 5))
print("原数组 = ", a)

b = np.vsplit(a, 3)  # 这里的第2个参数，表示拆分为几份， 必须能够使得数组平均拆分
print("平均拆成3份", b)

b = np.vsplit(a, [1, 2, 4])  # 按照第第几条线拆分
print(b)

4、copy 副本/ 复制/ 拷贝

copy() 函数创建副本。

import numpy as np

a = np.array(range(1, 11))
b = a
a[0] = 100
print(b)

# copy: 是一个深拷贝
a = np.array(range(1, 11))
b = a.copy()
a[0] = 100
print(b)

"""
输出的结果：
[100   2   3   4   5   6   7   8   9  10]
[ 1  2  3  4  5  6  7  8  9 10]
"""

六、Numpy聚合操作

np.sum：求和

np.min：最小值

np.max：最大值

np.mean：平均值

np.average：平均值

np.median：中位数

np.percentile：百分位数

np.argmin：最小值对应的下标

np.argmax：最大值对应的下标

np.std：标准差

np.var：方差

np.power：次方，求幂

np.argwhere：按条件查找

1、np.sum 求和

当多维度的时候，可以利用axis = 0， 1...来使得行，或者列求和。

如果当多维数组的时候不加任何属性，则求的是整个数组的和

import numpy as np

a = np.array(range(1, 11))
sun = np.sum(a)
print(sun)

# 二维数组
a = np.array([[1, 1],
              [2, 2],
              [3, 3]])
sun = np.sum(a)
print(sun)

sun = np.sum(a, axis=0)  # 当为0时，每一列的多行求和
print(sun)

sun = np.sum(a, axis=1)  # 当为1时，每一行的多列求和
print(sun)


"""
输出结果：
55
12
[6 6]
[2 4 6]
"""

2、np.min和np.max

import numpy as np

a = np.array([10, 2, 1, 100, 20])
print("最小值", np.min(a))
print("最大值", np.max(a))

print("-" * 20 + "二维数组" + '-' * 20)
a = np.array([[10, 1], [100, 2], [200, 1]])
print("原数组", a)
print("最小值", np.min(a))
print("最大值", np.max(a))
print("axis = 0:", np.max(a, axis=0))
print("axis = 1:", np.max(a, axis=1))

"""
输出结果：
最小值 1
最大值 100
--------------------二维数组--------------------
原数组 [[ 10   1]
 [100   2]
 [200   1]]
最小值 1
最大值 200
axis = 0: [200   2]
axis = 1: [ 10 100 200]
"""

3、np.mean和np.average平均值

起名字真难.

关注

12
点赞
踩
13

收藏

觉得还不错? 一键收藏
1
评论
numpy库的使用

Python 标准库中提供了一个array类型，用于保存数组类型数据，然而这个类型不支持多维数据，处理函数也不够丰富，不适合数值运算。因此，Python语言的第三方库numpy 得到了迅速的发展，至今，numpy 已经成为了科学计算事实上的标准库。numpy 库处理的最基础的数据类型是由同种元素构成的多维数组，（ndarray），简称“数组”。数组中所有元素的类型必须相同，数组中的元素可以用整数索引，序号从开始。
复制链接

扫一扫