Python의 numpy 모듈에 대한 자세한 소개

이 기사는 numpy 모듈과 관련된 문제를 주로 소개하는 python에 대한 관련 지식을 제공합니다. Numpy는 Numerical Python Extensions의 약어로 문자 그대로 Python 수치 계산 확장을 의미합니다. 모든 사람.

추천 학습: python 비디오 튜토리얼

Numpy은 Numerical Python Extensions의 약어로, 문자 그대로 Python 수치 계산 확장을 의미합니다. Numpy는 Numpy를 통해 기본 행렬 계산을 구현하는 Python의 많은 기계 학습 라이브러리에 대한 종속성입니다.

pNumpy

는 고수준, 대규모 행렬 및 벡터 계산을 지원하는 동시에 더욱 풍부한 기능도 제공합니다. 또한 Numpy는 보다 현대적인 프로그래밍 언어인 Python을 기반으로 합니다. Python은 오픈 소스, 무료, 유연성, 배우기 쉽고 우수한 엔지니어링 기능의 특성으로 기술계에서 인기가 높습니다. 머신러닝과 데이터 분석 분야에서요. 1. 배열 유형

numpy의 배열 유형은 문자 그대로 배열을 의미하며, 이는 가장 중요한 속성이 요소라는 것을 의미합니다. 이 데이터 유형을 사용하여 다차원 배열을 구현할 수 있습니다. ㅋㅋㅋ                                  따라서 이 데이터 유형을 통해 1차원 배열을 사용하여 벡터를 표현하고, 2차원 배열을 사용하여 행렬을 표현하는 등 고차원 텐서를 표현할 수 있습니다.

1.1 배열형의 기본 사용법

import numpy as np
# 通过np.array()方法创建一个名为array的array类型，参数是一个list
array = np.array([1, 2, 3, 4])
print(array)
# 结果为：[1 2 3 4]

# 获取array中元素的最大值
print(array.max())
# 结果为：4

# 获取array中元素的最小值
print(array.min())
# 结果为：1

# 获取array中元素的平均值
print(array.mean())
# 结果为：2.5

# 直接将array乘以2，python将每个元素都乘以2
print(array*2)
# 结果为：[2 4 6 8]

print(array+1)
# 结果为：[2 3 4 5]

print(array/2)
# 结果为：[0.5 1.  1.5 2. ]

# 将每一个元素都除以2，得到浮点数表示的结果
print(array % 2)
# 结果为：[1 0 1 0]

array_1 = np.array([1, 0, 2, 0])
# 获取该组数据中元素值最大的那个数据的首个索引，下标从0开始
print(array_1.argmax())
# 结果为：2

위의 코드를 통해 Numpy에서 배열형의 기본 사용법을 이해할 수 있습니다. 우리는 배열이 실제로 목록 매개변수를 전달하여 객체로 인스턴스화되어 데이터를 캡슐화하는 클래스임을 알 수 있습니다.

1.2 고차원 데이터 처리

---

import numpy as np
# 创建一个二维数组，用以表示一个3行2列的矩阵
array = np.array([[1, 2], [3, 4], [5, 6]])
print(array)

# 查看数据的维度属性，下面输出结果（3，2）表示3行2列
print(array.shape)
# 结果为：(3, 2)

# 查看元素个数
print(array.size)
# 结果为：6

# 查看元素最大值的索引
print(array.argmax())
# 结果为：5

# 将shape为（3，2）的array转换为一行表示
print(array.flatten())
# 结果为：[1 2 3 4 5 6]
# 我们可以看到，flatten()方法是将多维数据“压平”为一维数组的过程

#将array数据从shape为（3，2）的形式转为（2，3）的形式
print(array.reshape(2, 3))
'''结果为：
[[1 2 3]
 [4 5 6]]'''

#将array数据从shape为（3，2）的形式转为（1，6）的形式
print(array.reshape(1, 6))
# 结果为：[[1 2 3 4 5 6]]

더 고급 기능은 flatten() 및 reshape() 함수입니다. reshape()가 반환한 결과는 배열 유형이라는 점에 유의해야 합니다.

1.3Numpy는 특별한 유형의 배열 유형을 생성합니다

---

1.3.1 모두 0 또는 모두 1인 배열을 생성합니다.

import numpy as np
# 生成所有元素为
array_zeros = np.zeros((2, 3, 3))
print(array_zeros)
'''结果为：
[[[0. 0. 0.]
  [0. 0. 0.]
  [0. 0. 0.]]

 [[0. 0. 0.]
  [0. 0. 0.]
  [0. 0. 0.]]]
'''
array_ones = np.ones((2, 3, 3))
print(array_ones)
'''结果为：
[[[1. 1. 1.]
  [1. 1. 1.]
  [1. 1. 1.]]

 [[1. 1. 1.]
  [1. 1. 1.]
  [1. 1. 1.]]]
'''
print(array_ones.shape)
# 结果为：(2, 3, 3)

참고: (2, 3, 3)을 다음으로 변경하면 (3, 3)

array_zeros = np.zeros((3, 3))
print(array_zeros)
'''结果为：
[[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]
'''

행 3개와 열 3개로 구성된 배열을 생성합니다.

1.3.2np.arrange() 및 np.linspace()

arange([start,] stop [, step ,], dtype=None, , like=None)

---

주어진 간격 내에서 균일하게 분포된 값을 반환합니다.

반개방 간격 `[start, stop)``(즉, `start`는 포함하지만 `stop`은 제외되는 간격) 내에서 값이 생성됩니다.

정수 인수의 경우 이 함수는 Python의 내장 `range` 함수와 동일하지만 목록 대신 ndarray를 반환합니다. 정수가 아닌 단계 크기(예: 0.1)를 사용하면 결과가 일관되지 않는 경우가 많습니다. 이러한 경우에는 `numpy.linspace`를 사용하는 것이 좋습니다. linspace(start, stop, num=50, Endpoint=True, retstep=False, dtype=None, axis=0)

지정된 시간 간격 내에서 균등하게 분포된 숫자를 반환합니다.

[`start`, `stop`] 간격으로 계산된 "num"개의 균일하게 분포된 샘플을 반환합니다.

start: 시퀀스의 시작 값입니다.

stop:

`endpoint`가 False로 설정되지 않은 경우 시퀀스의 끝 값입니다. 이 경우 시퀀스는 마지막 "num + 1" 균일하게 분포된 샘플을 제외한 모든 샘플로 구성되므로 "stop"은 제외됩니다. 'endpoint'가 False이면 단계 크기가 변경됩니다.

num=50:

생성할 샘플 수입니다. 기본값은 50입니다. 음수가 아니어야 합니다.

endpoint=True:

true인 경우 `stop`이 마지막 샘플입니다. 그렇지 않으면 포함되지 않습니다. 기본값은 true입니다.

retstep=False：如果为 True，则返回 (`samples`, `step`)，其中 `step` 是样本之间的间距。

dtype=None：输出数组的类型。如果 `dtype` 没有给出，数据类型是从 `start` 和 `stop` 推断出来的。推断的 dtype 永远不会是整数；即使参数会产生一个整数数组，也会选择`float`。

因此以下代码就很容易理解了

# 生成一个array，从0递增到10，步长为1
array_arange = np.arange(10)
print(array_arange)
# 结果为：[0 1 2 3 4 5 6 7 8 9]

# 生成一个array，从0递增到10，步长为2
array_arange_1 = np.arange(0, 10, 2)
print(array_arange_1)
# 结果为：[0 2 4 6 8]

# 生成一个array，将0-10等分为5部分
array_linspace = np.linspace(0, 10, 5)
print(array_linspace)
# 结果为：[ 0.   2.5  5.   7.5 10. ]

1.4Numpy基础计算演示

import numpy as np
# 取绝对值
print(np.abs([1, -2, 3, -4]))
# [1 2 3 4]

# 求正弦值
print(np.sin(np.pi/2))
# 1.0

# 求反正切值
print(np.arctan(1))
# 0.7853981633974483

# 求e的2次方
print(np.exp(2))
# 7.38905609893065

# 求2的三次方
print(np.power(2, 3))
# 8

# 求向量[1,2]与[3,4]的点积
print(np.dot([1, 2], [3, 4]))
# 11

# 求开方
print(np.sqrt(4))
# 2.0

# 求和
print(np.sum([1, 2, 3, 4]))
# 10

# 求平均值
print(np.mean([1, 2, 3, 4]))
#2.5 

# 求标准差
print(np.std([1, 2, 3, 4]))
# 1.118033988749895

二、线性代数相关 

        前面我们已经了解到array类型及其基本操作方法，了解array类型可以表示向量、矩阵和多维张量。

        线性代数计算在科学计算领域中非常重要，因此接下来了解以下Numpy提供的线性代数操作

import numpy as np

vector_a = np.array([1, 2, 3])
vector_b = np.array([2, 3, 4])
# 定义两入向量vector_a与vector_b

m = np.dot(vector_a, vector_b)
# 将两个向量相乘，在这里也就是点乘，结果为20
print(m)

n = vector_a.dot(vector_b)
print(n)
# 将vector_a与vector_b相乘，结果为20
o = np.dot(vector_a, vector_b.T)
print(o)

'''
将一个行向量与一个列向量叉乘的结果相当于将两个行向量求点积，这里测试了dot()方法。其中array类型的T()方法表示转置。
测试结果表明:
dot()方法默认对两个向量求点积。对于符合叉乘格式的矩阵，自动进行又乘。'''

# 我们看一下下面这个例子:

matrix_a = np.array([[1, 2], [3, 4]])
# 定义一个2行2列的方阵

matrix_b = np.dot (matrix_a, matrix_a.T)
# 这里将该方阵与其转置叉乘，将结果赋予matrix_b变量
print(matrix_b)
'''结果为:
array([[5，11]，
[11，25]])'''

p = np.linalg.norm([1, 2])
print(p)
# 求一个向量的范数的值，结果为2.2360679774997898
# 如果norm()方法没有指定第2个参数，则默认为求2范数

np.linalg.norm([1, -2], 1)
# 指定第2个参数值为1,即求1范数。我们在前面介绍过,1范数的结果为向量中各元素绝对值之和,结果为3.0

q = np.linalg.norm([1, 2, 3, 4], np. inf)
print(q)
# 求向量的无穷范数,其中np.inf表示正无穷，也就是向量中元素值最大的那个，其结果为4.0

r = np.linalg .norm([1, 2, 3, 4], -np.inf)
print(r)
# 同理,求负无穷范数的结果为1, 也就是向量中元素的最小值

# 求行列式
s = np.linalg.det(matrix_a)
print(s)
# -2.0000000000000004

t = np.trace(matrix_a)
print(t)
# 求矩阵matrix_a的迹,结果为5

u = np.linalg.matrix_rank(matrix_a)
# 求矩阵的秩,结果为2
print(u)

v = vector_a * vector_b
# 使用*符号将两个向量相乘，是将两个向量中的元素分别相乘，也就是我们所讲到的哈达马乘积
print(v)
# [ 2  6 12]

w = vector_a ** vector_b
print(w)
# 使用二元运算符**对两个向量进行操作,结果为array([1, 8, 81]，dtype = int32)
# 表示将向量vector. a中元素对应vector. b中的元素值求幂运算。例如最终结果[1,8,81]可以表示为[1*1,2*2*2,3*3*3*3]

# 求逆矩阵
z = np.linalg.inv(matrix_a)
print(z)
'''
[[-2.   1. ]
 [ 1.5 -0.5]]'''

三、矩阵的高级函数-随机数矩阵

        Numpy除了为我们提供常规的数学计算函数和矩阵相关操作之外，还提供很多功能丰富的模块，随机数模块就是其中一部分。

        利用随机数模块可以生成随机数矩阵，比python自带的随机数模块功能还要强大。

import numpy as np
# 设置随机数种子
np.random.seed()

# 从[1,3）中生成一个整型的随机数，连续生成10个
a = np.random.randint(1, 3, 10)
print(a)
# [1 1 1 2 1 1 1 1 2 2]

# 若要连续产生[1,3}之间的浮点数，可以使用以下方法:
# ①
b = 2*np.random.random(10)+1
print(b)
'''
[2.88458839 2.07004167 2.80814156 1.83247535 2.33649809 2.62763357
 2.0549351  2.33464915 1.70562208 2.66257726]'''
# ②
c = np.random.uniform(1, 3, 10)
print(c)
'''
[1.76967412 1.37703868 2.48838004 1.45986254 2.04487418 2.51107658
 1.25673115 1.31416097 2.56218317 2.90575438]'''

# 生成一个满足正态分布(高斯分布)的矩阵,其维度是4*4
d = np. random.normal(size=(4, 4))
print(d)
'''
[[ 0.76164366  0.11588368  0.49221559 -0.28222691]
 [ 0.47638143 -0.21197541 -1.0776362   0.49241666]
 [ 0.26038756 -0.20406522  1.11210954 -1.191425  ]
 [ 0.58255677  1.84047863 -0.21366512 -0.85425828]]'''

# 随机产生10个n=5、p=0.5的二项分布数据:
e = np.random.binomial(n=5, p=0.5, size=10)
print(e)
# [1 1 5 2 1 2 1 2 1 2]

# 产生一个0到9的序列
data = np.arange(10)
print(data)
# [0 1 2 3 4 5 6 7 8 9]

# 从data数据中随机采集5个样本，采集过程是有放回的
f = np.random.choice(data, 5)
print(f)
# [1 7 3 3 4]

# 从data数据中随机采集5个样本，采集过程是没有放回的
g = np.random.choice(data, 5, replace=False)
print(g)
# [8 9 1 5 0]

# 对data进行乱序
h = np.random.permutation(data)
print(h)
# [8 5 3 9 2 0 4 6 1 7]

# 对data进行乱序，并替换为新的data
np.random.shuffle(data)
print(data)
# [9 7 0 3 8 5 2 1 4 6]

推荐学习：python视频教程

위 내용은 Python의 numpy 모듈에 대한 자세한 소개의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!