AskPython-博客中文翻译-六-
AskPython 博客中文翻译(六)
numpy ediff 1d–数组中连续元素之间的差异
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-ediff1d
在本文中,我们理解并实现了 NumPy 函数numpy.ediff1d()
,因为 NumPy 是一个数组处理包 numpy.ediff1d()用于计算数组元素之间的差。
Numpy.ediff1d()是什么?
在 python 中使用numpy.ediff1d()
来计算给定数组元素之间的连续差。
我们可以通过to_begin
提到预置值,它在一个数组的开始预置一个值,同样我们可以通过to_end
在一个数组的结尾附加一个值。
这些值可以包含多个要前置或附加的元素。
ediff1d()的语法
numpy.ediff1d(ary, to_end=None, to_begin=None)
参数
| 参数 | 描述 | 必需/可选 |
| ary: array_like | 输入数组 | 需要 |
| to_end:数组 _like | 这些是要追加到包含差异的数组末尾的数字。 | 可选择的 |
| to_begin:类似数组 | 这些数字将被添加到包含差值的数组的开头。 | 可选择的 |
Numpy -ediff1d syntax paramter
返回值
返回一个数组,其中包含:
- 在数组中预先考虑和追加值(如果给定的话)。
- 数组元素之间的连续差。
ediff1d()方法的示例
导入 numpy 库并声明和打印数组。
import numpy as np
arr=np.array([10,20,30,40,50])
print("Input array: \n",arr)
Input array:
[10 20 30 40 50]
示例 1:实现numpy.ediff1d()
下面的代码使用 np.ediff1d()函数来计算给定数组“arr”中每个元素之间的差。
x=np.ediff1d(arr)
print ("Output array: \n",x)
输出是一个数组,包含给定数组中每个元素之间的差。在这种情况下,输出数组包含四个元素,每个元素的值都等于 10。
输出:
Output array:
[10 10 10 10]
例 2 : 将元素前置和追加到输出中。
这段代码创建了一个带有附加开始和结束值的输出数组。它使用 NumPy ediff1d 函数来实现这一点,该函数接受一个数组(在本例中为 arr)并将 to_begin 和 to_end 值(在本例中为 1 和 100)相加。
y=np.ediff1d(arr,to_begin=[1],to_end=[100])
print ("Output array with begin and end value: \n",y)
输出:
Output array with begin and end value:
[ 1 10 10 10 10 100]
示例 3:预先计划和附加多个元素到输出
下面的代码使用 numpy.ediff1d()函数来计算数组(arr)中元素之间的差。to_begin 和 to_end 参数用于在输出数组中预先计划和追加元素。
z=np.ediff1d(arr, to_begin=[0,1], to_end=[90,100])
print ("Output array with multiple begin and end value: \n",z)
在这种情况下,输出数组将以值 1 开始,以值 100 结束。结果存储在变量 y 中,并打印到控制台。
输出:
Output array with multiple begin and end value:
[ 0 1 10 10 10 10 90 100]
例 4:返回的数组总是 1D。
这段代码使用 NumPy 库来计算二维数组中每个元素之间的差。二维数组存储在名为“w”的变量中。然后使用 NumPy ediff1d()函数计算数组中每个元素之间的差异。
w = [[1, 2, 4], [1, 6, 24]]
print ("Input array: \n",w)
print("Output array: \n",np.ediff1d(w))
ediff1d()函数的输出是一个一维数组,包含数组中每个元素之间的差异。在此示例中,输出数组包含差 1、2、-3、5 和 18。
输出计算为:
- 2 – 1 = 1
- 4 – 2 = 2
- 1 – 4 = -3
- 6 – 1 = 5
- 24 – 6 = 18
输出:
Input array:
[[1, 2, 4], [1, 6, 24]]
Output array:
[ 1 2 -3 5 18]
结论
我们已经理解并实现了带有和不带有可选参数的numpy.ediff1d()
函数,即to_end
和to_begin
具有单个或多个元素作为它们的值。numpy.ediff1d()
用于返回一个由输入数组元素的连续差值组成的数组。
参考
https://HET . as . ute xas . edu/HET/Software/Numpy/reference/generated/Numpy . ediff 1d . html
NumPy empty 和 empty_like
原文:https://www.askpython.com/python-modules/numpy/numpy-empty-and-empty_like
在本文中,我们将尝试理解 Python 中 NumPy 的 empty()函数和 empty_like()函数。
Python 包 NumPy 用于操作数组。使用 NumPy 可以在一个数组上执行许多数学运算。它提供了一个庞大的高级数学函数库来处理这些数组和矩阵,并提供了强大的数据结构来确保使用数组和矩阵进行高效计算。
2005 年,特拉维斯·奥列芬特开发了 NumPy。您可以免费使用它,因为它是一个开源项目。
NumPy 空是什么?
由numpy.empty()
函数返回的指定形状和类型的新数组没有初始化任何条目。具有指定形状、数据类型和顺序的未初始化(任意)数据数组是该函数的结果。对象数组将以 None 值开始。
还要记住,由于empty
不会将数组值变为零,所以它会比[zeros](https://www.askpython.com/python-modules/numpy/numpy-zeros)
快一点。但是,它要求用户手动设置数组中的每个值,因此必须小心使用。
句法
numpy.empty(shape, dtype=float, order='C', like=None)
因素
- 形状:整数或整数元组
- 需要
- 空数组的形状,例如:
(4, 2)
或 4。
- dtype:数据类型,
- 可选择的
- 数组所需的输出数据类型
- 默认设置为 numpy.float64
- 顺序:{'C ',' F'}
- 可选择的
- 在内存中存储多维数据时,使用列优先(Fortran 风格)还是行优先(C 风格)的顺序
- 默认设置为“C”
- like: array_like
- 可选择的
- 为了能够创建非 NumPy 数组,提供了引用对象。如果符合数组函数协议,则结果将由传入的类似数组的函数决定。在这种情况下,它确保创建的数组对象与作为参数提供的对象兼容。
返回:具有指定顺序、形状和数据类型的任意(未初始化)数据的集合/数组。对象数组将以 None 值开始。
Numpy empty()的实现
在实现该函数之前,请确保在 IDE 中导入 NumPy 包。要导入包,请运行以下代码行
import numpy as np
1.将整数作为形状参数传递
np.empty(4)
默认情况下,会考虑所有其他参数。
Implementation 1
2.将元组作为形状参数传递
np.empty((3,3))
默认情况下,会考虑所有其他参数。
Implementation 2
3.分配其他参数
np.empty((2,3), dtype=int, order='F')
np.empty((3,2), dtype=np.float16, order='C')
Implementation 3
NumPy empty_like 是什么?
与 empty()类似,该函数也创建一个数组,但不初始化值。创建的新数组的形状和数据类型与给定(原型)数组的形状和数据类型相同。
返回的数组不由该函数初始化;使用[zeros_like](https://www.askpython.com/python-modules/numpy/numpy-zeros_like)
或 ones_like
来代替它。与实际设置数组值的例程相比,它可能要快一点。
Numpy empty_like()的语法
numpy.empty_like(prototype, dtype=None, order='K', subok=True, shape=None)
因素
- 原型 : 阵列状
- 需要
- 返回数组的属性由原型的形状和数据类型定义。
- 数据类型 : 数据类型
- 可选择的
- 覆盖结果的数据类型。
- 顺序:{'C ',' F ',' A '或' K'}
- 可选择的
- 哪个顺序–C 表示 C 风格,F 表示 Fortran 风格,如果原型是 Fortran 连续的,A 表示 F,否则为 C。k 代表非常类似于原型的布局。
- subok: bool
- 可选择的
- 如果为真,新形成的数组将利用原型的子类类型;否则,将使用基类数组。通常设置为 True。
- 形状:整数或整数序列
- 可选择的
- 覆盖结果的形状。如果 order='K '并且维数保持不变,将尝试保持顺序;否则,将推断出 order='C '。
实现 Numpy empty_like()
1.仅提供原型
x = ([9,8,7],
[6,5,4],
[3,2,1])
np.empty_like(x)
Implementation 4
2.分配其他参数
y = ([1.2, 2.4, 3.6],
[2.1, 4.2, 6.3])
np.empty_like(y, dtype=int, order='K')
z = ([2.1, 3.2, 4.1],
[4.2, 5.3, 6.1])
np.empty_like(z, order = 'C', subok = False, shape = (3,3))
Implementation 5
Implementation 6
摘要
我们知道 NumPy 中的 empty()函数有助于构建任何空数组,而无需初始化值。用户可以使用这个函数指定数组的形状、顺序和数据类型。
类似地,empty_like 也创建一个没有初始化的数组,类似于所提供的原型。
参考
https://numpy . org/doc/stable/reference/generated/numpy . empty . html
https://numpy . org/doc/stable/reference/generated/numpy . empty _ like . html
Numpy Exmp1:完整指南
原文:https://www.askpython.com/python-modules/numpy/numpy-exmp1
欧拉数,也称为“e”,是一个重要的数学常数,以 18 世纪数学家莱昂哈德·欧拉的名字命名。据估计,这个数字的精确度超过一万亿位,是数学计算中的一个重要工具。
2.718281828459045……
Euler’s number
末尾的点表示数字的个数继续&这提供了一个推论,即‘e’属于无理数的范畴。我们将首先使用下面的代码导入 numpy 库。
在本文中,我们将探索欧拉数的历史以及如何在 Numpy Exmp1()函数中使用它。
import numpy as np
此后,我们将通过下面的每一节进一步探索 expm1( ) 函数。
- exp m1()函数的语法
- 为什么用 expm1(x) 而不用 exp(x)-1 ?
- 在标量上使用exp m1()
- 在 N 维数组上使用exp m1()
expm1()函数的语法
expm1( ) 的功能类似于 exp( ) 函数,其中“e”被提升到给定数字的幂,然后从中减去一(1)。下面是 expm1( ) 函数的语法,该函数包含其运行所需的强制和可选输入。
numpy.expm1(x, out=None, *, where=True, dtype=None)
在哪里,
- x—N 维数组或标量,其幂为 e
- out—一个可选的构造,默认情况下设置为 none ,但可用于将结果存储在所需的数组中,该数组的长度与输出的长度相同
- ***–kwargs 或 keyword argument,这是一个可选结构,用于将关键字可变长度的参数传递给函数
- 其中—一个可选构造,当设置为真(默认设置)时,用于计算给定位置的通用函数(ufunc ),当设置为假时,不计算
- dtype—可选结构,用于指定正在使用的数据类型
为什么用 expm1(x)而不用 exp(x)-1?
您可能想知道为什么需要构建一个特定的函数来从指数中删除一个,而不是使用已经可用的函数 exp( ) &从中删除一个!(即) exp(x)-1。
让我们这样做,并找出是否有任何可观察到的差异。
x = 1.5
np.exp(x)-1
np.expm1(x)
以下是上述代码的结果。
Results when x=1.5
嗯,看起来一切都很好,两个结果是同义的。但是,如果我们稍微减少‘x’并部署相同的功能会怎么样呢?那些能够返回相同的结果吗?让我们来了解一下!
x = 0.0001
np.exp(x)-1
np.expm1(x)
Results when x=0.0001
现在结果不一样了吧?布哈阿哈阿哈阿哈!(阴险的笑声)
这背后的主要原因是,任何接近“0”的数字的指数都将非常接近“1”。因此, exp(x)-1 在返回结果时似乎不太准确,Python 的 numpy 库中提供了一个专用函数 expm1( ) 。
在标量上使用 expm1()
您还可以通过给 expm1( ) 函数分配一个负数来查找结果。这将依次返回等价的 exp(x),回报它&,然后从中删除‘1’。对于那些想直接看到结果的人来说,它们就在这里!
a = -10
b = 0.000000009
np.expm1(a)
np.expm1(b)
Using expm1( ) on Scalars
在 N 维数组上使用 expm1()
expm1( ) 函数在应用于如下所示的 N 维数组时也适用。
ar1 = np.array([[1, 8, 0.09],
[5.007, -3.303, 2]])
np.expm1(ar1)
Using expm1( ) on N-Dimensional Arrays
结论
既然我们已经到了本文的结尾,希望它已经详细阐述了如何使用来自 numpy 库中的 expm1( ) 函数。这里有另一篇文章详细介绍了 Python 中 numpy 库中 nextafter( ) 函数的用法。AskPython 中还有许多其他有趣且信息量大的文章,可能会对那些希望提高 Python 水平的人有很大帮助。恭喜
NumPy exp–完整指南
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-exp
你好,欢迎来到 Numpy exp 教程。在本教程中,我们将学习 NumPy exp()方法,也将看到许多关于该方法的例子。让我们开始吧!
什么是 NumPy exp?
NumPy 中的exp
方法是一个返回输入数组所有元素的指数的函数。这意味着它为输入数组中的每个 x 计算 e^x 。这里, e 是欧拉常数,其值约为 2.718281。
可以说 np.exp(i) 约等于 ei** ,其中' ** '为幂算子。我们将在本教程的下一节看到这个函数的例子。
NumPy exp 方法的语法
numpy.exp(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
| 参数 | 描述 | 必需/可选 |
| x | 输入数组/值。 | 需要 |
| 在外 | 放置结果的替代输出数组。默认情况下,会创建一个新数组。 | 可选择的 |
| 在哪里 | 接受一个类似数组的对象。在为真的位置,out
数组将被设置为ufunc
结果。在其他地方,out
数组将保持其原始值。 | 可选择的 |
| **kwargs | 对于其他只有关键字的参数 | 可选择的 |
返回:一个数组,包含 x 的逐元素指数。如果 x 是标量,那么结果也是标量。
使用 Numpy exp()方法
让我们通过不同的例子来看看如何使用 numpy exp 方法。
1.使用 numpy exp()计算标量值的指数
import numpy as np
# positive scalar
a = 6
ans = np.exp(a)
print("a =", a)
print("Exponential =", ans)
输出:
a = 6
Exponential = 403.4287934927351
答案被计算为 e6,即(2.718281)6 = 403 . 49326363831
import numpy as np
# negative scalar
a = -6
ans = np.exp(a)
print("a =", a)
print("Exponential of the array =", ans)
输出:
a = -6
Exponential of the array = 0.0024787521766663585
在这种情况下,由于 a 是负数,a 的指数是(e)^(-6),即 1/(e)^6 = 1/(2.718281)^6 = 0.0024787521766663585。
2.使用 numpy exp()计算一维数组的指数
import numpy as np
a = [0, 3, -2, 1]
ans = np.exp(a)
print("a =", a)
print("Exponential of the array =", ans)
输出:
a = [0, 3, -2, 1]
Exponential of the array = [ 1\. 20.08553692 0.13533528 2.71828183]
这里,结果数组包含输入数组中每个值的 e 的指数。也就是说,和按输入值的顺序包含值 e0、e3、e^-2 和 e^1。
3.使用 numpy exp()计算二维数组的指数
import numpy as np
a = [[2, -4, 1],
[0, 1, 5]]
ans = np.exp(a)
print("a =\n", a)
print("Exponential of the array =\n", ans)
输出:
a =
[[2, -4, 1], [0, 1, 5]]
Exponential of the array =
[[7.38905610e+00 1.83156389e-02 2.71828183e+00]
[1.00000000e+00 2.71828183e+00 1.48413159e+02]]
与上面的例子类似,结果数组按顺序包含输入数组中每个值的 e 的指数。
4.使用 numpy exp()绘制 np.exp()的图形
现在让我们使用 Python 中的 Matplotlib 库来绘制np.exp()
函数相对于一些输入值的图形。
import numpy as np
import matplotlib.pyplot as plt
# input
x = np.linspace(0, 5, 100)
# output
y = np.exp(x)
# changing the size of figure to 8x8
plt.figure(figsize=(8, 8))
display(plt.plot(x, y))
plt.grid()
# title of the graph
plt.title("Graph of e^x")
plt.xlabel("x")
plt.ylabel("e^x")
输出:
Graph Of Exponential
在这个例子中,我们创建了一个从 0 到 5 的均匀分布的数组( x ),总共有 100 个值。然后将这个数组传递给np.exp()
函数,存储在 y 的结果中,最后我们绘制 y v/s x 的图形,得到上面的图作为结果。
摘要
仅此而已!在本教程中,我们学习了 Numpy exp 方法,并使用该方法练习了不同类型的示例。如果你想了解更多关于 NumPy 的信息,请随意浏览我们的 NumPy 教程。
参考
NumPy exp2–完整指南
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-exp2
嘿各位,你们都计算过类似于 2 的 4 次方或者 2 的 1 次方之类的东西吗?例如,为了计算 2 的 4 次方,我们通常将 2 乘以 4 次。那是一个乏味的任务,对吗?所有这些乘法过程花费了大量的时间。嗯,我们可以在几分之一秒内得到输出,甚至不需要经历很长的过程,听起来很令人兴奋🙂
这就是 Python NumPy 库发挥作用的地方。在本文中,我们将了解如何使用 NumPy exp2 函数来计算 2 的不同次方。
没有别的事了,让我们开始吧。
什么是 NumPy exp2?
NumPy exp2 是 NumPy 库的一个数学函数,它计算 2^x ,其中 x 是传递给函数的输入数。简单的定义!现在,让我们深入研究一下如何在 Python 程序中使用这个函数。让我们从函数的语法开始。
也读作:NumPy exp-完整指南
NumPy exp2 的语法
numpy.exp2(a)
始终关注 NumPy 库的任何函数的语法,因为这将使您更容易编写代码。在语法中,输入 a
可以是单个数字,也可以是数字的 NumPy 数组。
使用 NumPy exp2
现在,让我们写一些代码来更好地理解它。
具有单一编号的 NumPy exp2
import numpy as np
print("2**3 is :",np.exp2(3))
print("2**7 is :",np.exp2(7))
print("2**10 is :",np.exp2(10))
print("2**(-2) is :",np.exp2(-2))
输出
2**3 is : 8.0
2**7 is : 128.0
2**10 is : 1024.0
2**(-2) is : 0.25
在上面的例子中,我们将一个数字作为输入传递给了 np.exp2()
函数。该函数的输出是一个浮点数。
看看使用函数计算 2 的幂有多简单🙂
带有 NumPy 数组的 NumPy exp2
现在让我们传递一个 NumPy 数组作为函数的输入。
import numpy as np
a = np.array((-2 , 0 , 4 ))
exp2_values = np.exp2(a)
print("Input Array :\n",a)
print("Exp2 Values for each element of the Array :\n",exp2_values)
输出
Input Array :
[-2 0 4]
Exp2 Values for each element of the Array :
[ 0.25 1\. 16\. ]
注意:函数 np.exp2()
返回一个与输入数组维数相同的 NumPy 数组。
在上面的例子中,NumPy 数组 a 作为参数传递给 np.exp2()
函数。使用**np.exp2()**
函数计算输入数组中每个元素的 exp2 值。该函数的输出也是一个 NumPy 数组,它存储在变量 exp2_values 中。
在接下来的几行中,我们使用了 print 语句来分别打印输入数组和输出数组。
到目前为止,您已经学会了如何使用单个数字和 NumPy 数字数组的函数。现在,让我们看看如何使用 Python Matplotlib 库绘制函数。
NumPy exp2 的图表
import numpy as np
import matplotlib.pyplot as plt
a = np.array((1 , 2 , 3 , 4 , 5))
b = np.exp2(a)
plt.plot(a , b , color = "green" , marker = "o")
plt.title("numpy.exp2()")
plt.xlabel("X-axis")
plt.ylabel("Y-axis")
plt.show()
输出
NumPy Exp2 Graph
在上面的代码中,在前两行,我们导入了 NumPy 和 Matplotlib 库,这样我们就可以使用它们的功能。
接下来,我们创建了一个变量 a
来存储 NumPy 数组,该数组作为输入传递给 np.exp2()函数。类似地,变量**b**
存储 np.exp2() 函数的输出数组。
在接下来的几行中,我们使用了 Matplotlib 库的函数来绘制函数的图形。让我们理解每一行及其目的。
**plt.plot()**
函数使用来绘制带四个参数的 np.exp2()
函数。
-
第个参数是数字的 NumPy 数组,绘制在 X 轴(横轴)上。
-
第二个参数是
**np.exp2()**
函数的输出,绘制在 Y 轴(垂直轴)上。 -
第三个参数是绘图的颜色。
-
第四个参数是标记值,用指定的标记强调每个点。有不同类型的标记可用于表示曲线上的点。
-
plt.title()
为剧情设置标题的值。这里的标题是 numpy.exp2()。 -
plt.xlabel()
和plt.ylabel()
分别设置横轴和纵轴的名称。 -
plt.show()
用于显示剧情。
就这样,我们完成了示例以及 NumPy exp2 函数的图形。
摘要
在本文中,我们学习了如何使用 NumPy exp2 函数计算 2 的幂。我们使用了单个数字和 NumPy 数字数组的函数。我们还绘制了 NumPy exp2 函数的图形。
请务必查看参考资料部分给出的链接。继续学习,继续探索更多话题这里。
参考
num py documentation–num py exp 2
NumPy 眼功能:完全指南
NumPy 是一个流行的科学计算 Python 库,它提供了对数组和矩阵的高效操作。NumPy 中有用的函数之一是eye
函数,它允许用户创建特定大小的单位矩阵。单位矩阵是一个主对角线上为 1,其他地方为 0 的方阵。
在本文中,我们将详细探讨eye
函数,包括它的语法、参数以及如何在各种场景中使用它的例子。
无论您是 NumPy 的新手还是有经验的用户,本文都将提供使用eye
函数的全面指南。
numpy.eye()是什么?
Numpy.eye()用于返回一个二维数组,对角线上的值为 1,其他位置的值为 0。可选参数 k 决定对角线是主对角线、上对角线还是下对角线。主对角线用 0 k (默认)表示,上对角线用正 k、表示,下对角线用负 k、表示
句法
numpy.eye(N, M=None, k=0, dtype=<class 'float'>, order='C', like=None)
因素
- N : int
- 需要
- 输出数组中的行数。
- M: int
- 可选择的
- 输出数组中的列数,如果没有,则默认设置为 N,因此形成一个对称矩阵。
- k: int
- 可选择的
- 主对角线由索引值 0 表示,上对角线由正值表示,下对角线由负值表示。
- 数据类型 : 数据类型
- 可选择的
- 返回数组的数据类型。
- 顺序:{'C ',' F'}
- 可选择的
- 应该使用哪种顺序——行优先(C 风格)还是列优先(Fortran 风格)——将输出存储在内存中?
- like: array_like
- 可选择的
- 可以使用引用对象创建非 NumPy 数组。如果符合数组函数协议,则结果将由 as like 中提供的数组 like 确定。在这种情况下,它确保创建的数组对象与作为参数提供的对象兼容。
Numpy.eye()的实现
在使用这个函数之前,请确保在 IDE 中导入 NumPy 包。要导入 NumPy 包,请运行以下代码行。
import numpy as np
示例 1:只传递“n”参数,因此形成一个单位数组
np.eye(3)
Example 1
示例 2:传递“n”和“m”参数
np.eye(3,4)
Example 2
示例 3:传递“k”参数
# k = 2, diagonal 2 steps forward the default diagonal
np.eye(4,4,2)
# k = -1,diagonal 1 step downard the default diagonal
np.eye(4,4,-1)
Example 3
结论
NumPy eye
是在科学计算中创建单位矩阵的一种有用方法。它使用简单,有多种参数,允许用户自定义矩阵的大小和类型。
通过理解eye
函数的语法和参数,以及使用它的一些常见陷阱和技巧,您可以在自己的项目中自信而有效地使用eye
函数。
无论您是在机器学习、线性代数还是任何其他领域使用矩阵,eye
函数都可以成为您的 NumPy 工具包中一个有价值的补充。因此,它是数字图书馆中一个非常重要的功能。
参考
https://numpy . org/doc/stable/reference/generated/numpy . eye . html
Numpy fabs-按元素计算绝对值。
原文:https://www.askpython.com/python-modules/numpy/numpy-fabs
Python 中的 NumPy fabs 函数是处理数字的有用工具。它本质上与数学中的模函数相同,用于计算特定数字或数值数组的绝对值。它对 NumPy 特别有用,因为它与 ndarrays 一起工作。
基本上,numpy fabs()函数返回数值数据的正数值。但是,它不能处理复杂的值——对于这些值,您可以使用 abs()函数。总而言之,这是掌握你的数字的好方法!
numpy.fabs()的语法
numpy fabs 函数如下所示:
numpy.fabs(a, /, out=None, *, where=True, casting='same_kind',
order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'fabs'>
上面的函数返回数组中元素的正/绝对值。
参数
- a:array _ like->要计算绝对值的数值的数组。如果 a 是一个标量值,那么返回的数组,即 b,也将是一个标量值。
- out:ndarray, None,(此参数可选 )- >存储结果时,可以在此参数中指定一个位置。形状必须与输入数组相同。如果没有提供它,或者我们把它赋值为 NONE,那么就创建并返回一个新的数组。
- 其中:*array _ like,(此参数可选 )* - >对于其中的位置,where==TRUE,out 数组将返回 ufunc 结果。在其他任何地方,out 数组将保持其原始值。如果 where 参数为 true,则通用函数值将被更改,如果为 false 或未指定,则只有输出保留返回值。要了解 python 中通用函数(ufunc)的更多信息,点击这里。****
- 【kwargs】:(该参数也是可选的) - >涉及关键字的自变量在该参数中指定。****
返回值
numpy.fabs()函数返回一个数组,例如“b”,在标量输入的情况下,它是一个标量。它是一个包含输入数组中所有给定数字数据的正数值的数组。返回类型总是 float 。
Numpy.fabs()的示例
让我们看一些关于如何实现和使用 numpy fabs()函数的例子。
示例 1–使用 Numpy 计算绝对值
第一个是返回单个元素的绝对值。这段代码使用 numpy 模块计算数字-9 的绝对值,并将结果存储在变量 n 中。fabs()函数用于计算任意数字的绝对值。最后,使用 print()函数打印结果。
**#importing required module
import numpy as py
n=py.fabs(-9) #using the fab function and storing the result in a variable
print(n) #printing the result**
输出:
**9.0**
示例 2–将现有数组传递给 Numpy.fabs()
现在,让我们取一个包含现有值的数组。该代码使用 numpy 模块来导入 fabs 函数。该函数将一个数字列表作为输入,并返回一个数字数组,其中包含列表中每个数字的绝对值。然后,代码打印出数字列表,并显示列表中每个数字的绝对值。
**#importing required module
import numpy as py
n=[-1.3,-8.6,50.0,-4,-67.55,69.1,0] #pre-defined array
s=py.fabs(n) #using the fabs function
print(s) #printing the result**
上述代码的输出类似于下面所示:
**[1.3 ,8.6 ,50\. ,4\. ,67.55 ,69.1 ,0.]**
示例 3–传递用户输入数组
现在,我们来看另一个例子,数组将成为用户输入。因此,我们需要从用户那里提取输入,然后找到用户定义的数组中所有元素的绝对值。下面给出的是我们将如何去做。
**import numpy as py #importing required modules
n=eval(input("enter required values separated by a comma=")) #take user input
n=py.array(n) #convert user input into an array
s=py.fabs(n) #using the fabs() function
print(s) #displaying the result**
上述代码的输出将如下所示:
**enter required values separated by a comma=-1.9,-5.4,-8.0,-33.33 #enter required input
[ 1.9 5.4 8\. 33.33]**
示例 4–2D 阵列上的 Numpy fabs 功能
您也可以通过以下方式在 2d 阵列上使用 fabs 功能。这段代码导入 NumPy 模块,创建一个名为“n”的负数 2D 数组,然后使用 numpy fabs 函数计算数组中元素的绝对值,并将它们存储在数组“s”中。最后,它打印数组中元素的绝对值。
**import numpy as py #import required module
n=[[-1.2,-6.7],[-4.6,-9.1],[-6.9,-2.2]] #initializing 2D array
s=py.fabs(n) #compute absolute value
print("the absolute value of the 2D array is")
print(s) #display the output**
输出如下所示:
**the absolute value of the 2D array is
[[1.2 6.7]
[4.6 9.1]
[6.9 2.2]]**
结论:
numpy fabs()函数对于 numpy 用户来说是一个非常有用的工具,可以快速方便地找到任何数字、数组或矩阵的绝对值。它对于处理大型数值数组特别有用,因为它可以快速计算数组中每一项的绝对值。这使得处理复杂的数字和数据集更加容易。总而言之,这是一个很好的方法来掌握你的数字,并让他们在检查中!
Numpy 修复:如何四舍五入到最近的整数?
近似值——在一个精确到第 n 个十进制数字的世界里,确实有理由认为近似值仍然有效。事实上,大自然在执行事情时并不十分精确,而是在一个“范围”内做事情。当开始进行数据分析时,情况也是如此。
数据科学家自己可能会对他们的模型在交付结果方面有多精确感到骄傲,但他们也永远无法否认这样一个事实,即他们的整个模型是建立在近似假设的基础上的!
亦读: Numpy。Divide()–如何在 Python 中使用 Numpy Divide?
在本文中,我们将探索 Python 的 NumPy 库中可用的一个这样的函数,它将帮助人们将任何给定的数字舍入到最接近零的整数。这意味着任何给定的数,无论它有多少位小数,都将被四舍五入成整数,不会留下任何小数值。
正在研究的函数是 numpy.fix( ) ,在使用示例数据进行演示之前,让我们先了解一下它的语法。
numpy.fix()的语法
下面是 numpy.fix( ) 函数的语法。
numpy.fix(x, out=None)
在哪里,
- x–可以是单个数字,也可以是要舍入的数字数组
- out–可选特性,可用于将结果值存储在与输入维数相同的指定数组中,如果指定的话。
需要注意的是, numpy.fix( ) 函数的输出是以浮点数的形式返回的。
我们应该使用下面的代码导入 numpy 库。
import numpy as np
用 numpy.fix()舍入一个数字
在导入了 numpy 库之后,应该使用下面的代码将所需的数字舍入到最接近零的整数。
import numpy as np
np.fix(3.14159365)
Rounding Off A Single Number
那些观察力敏锐的人现在可能已经发现,上图中被四舍五入的数字属于无理数的范畴。如果你到现在还没猜到,那就是π(π)的前八位小数!
显示的结果只有“3.0”,这意味着无论小数的计数是多少,都只能得到小数为零的结果,并保持其整数部分不变。
也读作:Numpy . Subtract():Python 中如何用 NumPy 减去数字?
用 numpy.fix()舍入数字数组
现在让我们开始对数组中的一组数字进行舍入。我们将从构建一个类似下面给出的数组开始。
ar = [[12.6, 3.4, 2.3],
[4.5, 7.6, 78.5]]
一旦完成,我们将使用下面的代码部署要使用的 fix( ) 函数。
np.fix(ar)
运行上面的代码会导致下面的结果。
Rounding Off An Array
在 numpy.fix()方法上使用 Out 选项
本节将演示如何使用本文前面描述的 out 选项对数字进行四舍五入。由于存储输出的规定应该与输入具有相同的维数,因此在涉及多个数字的情况下,应该为变量分配一个具有相同输入维数的数组。
如果数组与上一节中使用的相同,那么它有 2 行 3 列,这使我们将输出数组设置为空,如下所示,这样它可以被结果的值替换。
rr = np.empty([2,3])
然后在使用 fix( ) 函数时,将“rr”分配给 out 选项,如下所示。
np.fix(ar, out=rr)
运行上面的代码会得到下面的结果。
Output Array Assigned
要验证输出数组是否被更新,可以使用 print( ) 函数。
Viewing The Output Array
结论
既然我们已经到了本文的结尾,希望它已经详细说明了如何使用 Python 中的 numpy.fix( ) 函数将任意给定的数字四舍五入到最接近的整数。这里有另一篇文章详细介绍了如何在 Python 中使用 numpy 将角度转换成弧度。AskPython 中还有许多其他有趣的&同样丰富的文章,可能对那些希望提高 Python 水平的人有很大帮助。当你享受这些的时候,再见!
NumPy float_power
原文:https://www.askpython.com/python-modules/numpy/numpy-float_power
你好,欢迎来到这个关于 Numpy float_power 的教程。在本教程中,我们将学习 NumPy float_power() 方法,也将看到许多关于这个方法的例子。让我们开始吧!
也读作: NumPy 幂——将另一个数提升到 的幂
什么是 NumPy float_power?
NumPy 中的float_power()
方法是一个函数,它返回一个数组,该数组是通过对一个数组中的元素进行与第二个数组中的值相对应的幂来计算的。
如果 x1 和 x2 是两个数组,那么float_power(x1, x2)
按元素计算输出,即通过将 x1 中的每个值提高到 x2 中相应位置的值。正如函数本身的名字所暗示的,它的默认返回类型是 float。我们将在本教程的下一节看到这个函数的例子。
NumPy float_power 语法
numpy.float_power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
| 参数 | 描述 | 必需/可选 |
| x1 (array_like) | 基本数组。 | 需要 |
| x2(类似数组) | 幂/指数数组。 | 需要 |
| 在外 | 放置结果的替代输出数组。它必须具有与预期输出相同的形状。 | 可选择的 |
| 在哪里 | 接受一个类似数组的对象。在为真的位置,out
数组将被设置为ufunc
结果。在其他地方,out
数组将保持其原始值。 | 可选择的 |
返回:
一个数组,包含 x 1 提升到 x2 的结果,按元素排序。如果 x1 和 x2 是标量,那么结果也是标量。
Numpy float_power()的示例
现在让我们进入例子,理解float_power
方法实际上是如何工作的。
当两个输入都是标量时
import numpy as np
a = 5
b = 3
# using the float_power method
ans = np.float_power(a, b)
print("a = ", a, "\nb =", b)
print("Result = ", ans)
输出:
a = 5
b = 3
Result = 125.0
一个简单的例子,结果计算如下
5^3 = 125
当一个输入是标量而另一个是一维数组时
import numpy as np
a = [0, -2, 4, -6, 8]
b = 3
# using the float_power method
ans = np.float_power(a, b)
print("a = ", a, "\nb =", b)
print("Result = ", ans)
输出:
a = [0, -2, 4, -6, 8]
b = 3
Result = [ 0\. -8\. 64\. -216\. 512.]
这里,数组 a 中的每个元素被提升到幂 b 并且输出被计算为
ans[0] = a[0] ^ b = 0 ^ 3 = 0
ans[1] = a[1] ^ b = -2 ^ 3 = -8
ans[2] = a[2] ^ b = 4 ^ 3 = 64
ans[3] = a[3] ^ b = -6 ^ 3 = -216
ans[4] = a[4] ^ b = 8 ^ 3 = 512
从输出中,我们可以看到该函数也处理负值。
当两个输入阵列都是一维时
import numpy as np
a = [3, 1, 4, 2.5]
b = [0, 2, 2.7, 4]
# using the float_power method
ans = np.float_power(a, b)
print("a = ", a, "\nb =", b)
print("Result = ", ans)
输出:
a = [3, 1, 4, 2.5]
b = [0, 2, 2.7, 4]
Result = [ 1\. 1\. 42.22425314 39.0625 ]
这里, a 中的每个元素被提升到 b 中相应元素的幂,输出被计算为:
ans[0] = a[0] ^ b[0] = 3 ^ 0 = 1
ans[1] = a[1] ^ b[1] = 1 ^ 2 = 1
ans[2] = a[2] ^ b[2] = 4 ^ 2.7 = 42.22425314
ans[3] = a[3] ^ b[3] = 2.5 ^ 4 = 39.0625
注意偶数浮点数是由float_power()
方法处理的。
当两个输入阵列都是二维时
import numpy as np
a = [[1, 2], [6, 3]]
b = [[2, 5], [2, 3]]
# using the float_power method
ans = np.float_power(a, b)
print("a = ", a, "\nb =", b)
print("Result = \n", ans)
输出:
a = [[1, 2], [6, 3]]
b = [[2, 5], [2, 3]]
Result =
[[ 1\. 32.]
[36\. 27.]]
类似于上面的例子,
ans[0][0] = a[0][0] ^ b[0][0] = 1 ^ 2 = 1
ans[0][1] = a[0][1] ^ b[0][1] = 2 ^ 5 = 32
ans[1][0] = a[1][0] ^ b[1][0] = 6 ^ 2 = 36
ans[1][1] = a[1][1] ^ b[1][1] = 3 ^ 3 = 27
结论
仅此而已!在本教程中,我们学习了 Numpy float_power 方法,并使用相同的方法练习了不同类型的示例。
如果你想了解更多关于 NumPy 的知识,请随意浏览我们的 NumPy 教程。
参考
NumPy floor _ divide–完整指南
原文:https://www.askpython.com/python-modules/numpy/numpy-floor-divide
大家好,欢迎来到这个关于 Numpy floor_divide 的教程。在本教程中,我们将学习 NumPy floor_divide() 方法,也将看到许多关于相同的例子。让我们开始吧!
推荐阅读——Numpy 楼
什么是 NumPy floor_divide?
Python 中的 floor 运算符用//
表示。NumPy floor_divide
运算符是//
和%
的组合,然后开始余数或 mod 运算符。简化的方程式是a = a%b + b*(a//b)
。
NumPy floor_divide()
方法返回小于或等于输入除法的最大整数。输入可以是两个数组,也可以是一个数组和一个标量。
我们将在本教程的下一节看到每个例子。
NumPy floor_divide 的语法
numpy.floor_divide(x1, x2, out=None)
| 参数 | 描述 | 必需/可选 |
| x1 | 输入(分子) | 需要 |
| x2 | 输入(分母) | 需要 |
| 在外 | 放置结果的替代输出数组。它必须具有与预期输出相同的形状和长度。 | 可选择的 |
返回:
一个 n 维数组 y ,y=(x1/x2)
。如果 x1 和 x2 都是标量,那么 y 就是标量。
NumPy floor_divide 示例
现在让我们看几个例子来更好地理解这个函数。
当除数是标量时
一维数组
import numpy as np
a = 5
arr = [12, 15, 10, 6]
ans = np.floor_divide(arr, a)
print("a =", a)
print("Result =", ans)
输出:
a = 5
Result = [2 3 2 1]
floor_divide
方法通过将列表中的每个元素除以 a 并计算其最低值来计算输出。这里,12/5 = 2.4,floor(2.4)= 2;15/5 = 3,楼层(3)= 3;10/5 = 2,楼层(2) = 2,6/5 = 1.2,楼层(1.2) = 1。
因此,得到的数组是[2,3,2,1]。
//运算符可以用作 ndarrays 上 numpy.floor_divide 的简写。
import numpy as np
a = 5
arr = np.array([12, 15, 10, 6])
ans = arr // a
print("a =", a)
print("Result =", ans)
输出:
a = 5
Result = [2 3 2 1]
二维数组
import numpy as np
a = 5
arr = [[12, 15], [0, 36]]
ans = np.floor_divide(arr, a)
print("a =", a)
print("Result =\n", ans)
输出:
a = 5
Result =
[[2 3]
[0 7]]
与一维数组类似,这里每个元素都除以 a ,然后计算其底值,并存储在结果数组中。
- 结果[0][0] =下限(12/5) =下限(2.4) = 2
- 结果[0][1] =下限(15/5) =下限(3) = 3
- 结果[1][0] =下限(0/5) =下限(0) = 0
- 结果[1][1] =下限(36/5) =下限(7.2) = 7
2 个数组/列表的除法
import numpy as np
arr1 = [10, 20, 30, 40]
arr2 = [4, 3, 6, 5]
ans = np.floor_divide(arr1, arr2)
print("Array 1 =", arr1)
print("Array 2 =", arr2)
print("Result =", ans)
输出:
Array 1 = [10, 20, 30, 40]
Array 2 = [4, 3, 6, 5]
Result = [2 6 5 8]
在这种情况下,对两个数组中的相应元素执行除法和取整运算。
- 结果[0] =arr1[0]/arr2[0] =下限(10/4) =下限(2.5) = 2
- 结果[1] =arr1[1]/arr2[1] =下限(20/3) =下限(6.666) = 6
- 结果[2] =arr1[2]/arr2[2] =下限(30/6) =下限(5) = 5
- 结果[3] =arr1[3]/arr2[3] =下限(40/5) =下限(8) = 8
当数组包含负元素时
到目前为止,我们已经看到了所有元素都是正数的例子。现在让我们看看numpy.floor_divide()
方法如何处理负值。
import numpy as np
arr1 = [16, 5, -30, 18]
arr2 = [8, -5, 7, 10]
ans = np.floor_divide(arr1, arr2)
print("Array 1 =", arr1)
print("Array 2 =", arr2)
print("Result =", ans)
输出:
Array 1 = [16, 5, -30, 18]
Array 2 = [8, -5, 7, 10]
Result = [ 2 -1 -5 1]
- 结果[0]= arr 1[0]/arr 2[0]= floor(16/8)= floor(2)= 2
- 结果[1]= arr 1[1]/arr 2[1]= floor(5/-5)= floor(-1)=-1
- 结果[2] =arr1[2]/arr2[2] =下限(-30/7) =下限(-4.2857) = -5
- 结果[3] =arr1[3]/arr2[3] =下限(18/10) =下限(1.8) = 1
结论
仅此而已!在本教程中,我们学习了 Numpy floor_divide 方法,并使用该方法练习了不同类型的示例。如果你想了解更多关于 NumPy 的信息,请随意浏览我们的 NumPy 教程。
参考
numpy floor–返回输入的楼层,按元素排序
原文:https://www.askpython.com/python-modules/numpy/numpy-floor
今天我们将学习如何获取输入元素的底值!这意味着我们将逐个元素地处理数据。我们将理解函数如何处理数组或矩阵形式的输入。我们还将了解它在所有输入情况下的实现。我们将让函数传递其域内外的所有类型的输入。最后,我们将看到它在图中的表示。
什么是 NumPy?
当我们将要学习numpy
楼层功能时,让我们了解什么是NumPy
。 NumPy 是一个 Python 库,它提供了处理数组的方法。它提供了一些类似数学函数的功能。唯一的区别是语法。让我们稍微理论一下。
标量 x 的底是最大的整数 y,这样 y <= x. it is dented as 。让我们看看下面的例子。
- -2.365 的地板是-3。
- 2.365 的底是 2。
- 任何整数的底数都与该数相同。
现在我们将看看如何在我们的代码片段中实现同样的功能。为了实现这个函数,我们使用了 NumPy.floor()函数。
实现 Numpy.floor()方法
Numpy 库支持这个函数。要使用它,我们需要导入它的依赖项,即 NumPy 库。让我们看看下面的语法。
import numpy
numpy.floor(x, out=None, where=True, casting='same_kind', order='K', subok : [bool, datatype])
上述代码片段中使用的参数如下:
- x: 它可以是包含弧度值的变量,也可以是包含某个值的数组
- out: 存储结果的位置。如果提供了,它必须具有与输入 x 相似的形状。如果没有提供或没有提供,则返回新的值或结果。这是可选的。
- 当条件为真时,我们必须得到我们的结果或输出;当条件为假时,我们将得不到任何结果。这是可选的。y 默认其值为真。
- casting='same_kind': 表示只允许 float64 到 float32 的值或结果。该函数在此范围或数据类型中呼喊 cast 值。
- order = 'K': 它总是以 K 排序的形式产生一个输出数组。(注意:有四种类型的订单:{‘K’,‘C’,‘F’,‘A’})。这是可选的。
- subok:【bool,datatype】是否生成结果的子类。如果为真,则提供子类的名称。它返回一个与给定数组具有相同形状和类型的数组。也是可选的。
这个函数的定义域是一组实数。该范围是整数的集合。我们将通过传递单值、数组和复数来尝试我们的函数。
步骤 1:导入数字
首先,我们需要导入所需的模块,即 Numpy 模块。
import numpy
步骤 2:向 numpy.floor()方法传递值
在这一步中,我们将如下实现我们的功能。
import numpy
#Passing single value in our function
a = numpy.floor(0.366)
print(a)
#output
0.0
#passing multiple values in the form of array
import math
input = numpy.array([-2.35, 0, 0.36, 1, 5.69, math.pi, 5/2, 5%3])
b = numpy.floor(input)
print(b)
#output
[-3\. 0\. 0\. 1\. 5\. 3\. 2\. 2.]
#passing complex number
import cmath
x=5
y=6
z=complex(x,y)
c = numpy.floor(z)
print(c)
#output
TypeError: ufunc 'floor' not supported for the input types, and the inputs could not be safely coerced to any supported types according to the casting rule ''safe''
你可以在上面的步骤中看到,我们实现了我们的方法三次。可以看到 floor 函数给出了传递单值、数组和无理数函数(math.pi
)的结果。但是在传递复数的情况下,它抛出一个错误“ufunc 'floor'
不支持输入类型”,这表明函数NumPy.floor()
不支持输入数据类型。
在图形上绘制 numpy.floor()
在下面的代码片段中,我们创建了空数组 x[]和 y[]。使用 while 循环,我们已经将输入值从-3.99 开始加载到 x[]数组中,从 4.00 开始按顺序增加 0.01。在 floor 函数实现之后,我们将各自的结果加载到 y[]数组中。使用 x[]和 y[]数组,我们使用matplotlib.pyplot
库及其支持方法绘制了我们的图表。
import matplotlib.pyplot as plt
import numpy
x=[]
y=[]
i=-3.99
while (i<4.00):
x.append(i)
y.append(numpy.floor(i))
i=i+0.01
plt.xlabel("x axis - input")
plt.ylabel("y axis - output = (numpy.floor(input))")
plt.grid(linestyle='-', linewidth=0.5,color='red')
plt.plot(x,y, linewidth=3, color = 'black')
plt.show()
结论
Numpy floor 是一个按元素返回输入的下限的函数。该函数对于向下舍入到最接近的整数很有用。在本文中,我们介绍了如何使用 NumPy floor 函数,以及如何将它应用于不同的数据类型。
NumPy fmin–数组元素的最小元素数
原文:https://www.askpython.com/python-modules/numpy/numpy-fmin
大家好,欢迎来到这个关于 Numpy fmin 的教程。在本教程中,我们将学习 NumPy fmin() 方法,也将看到许多关于这个方法的例子。让我们开始吧!
什么是 NumPy fmin?
fmin()
是 NumPy 中的一个函数,它比较两个数组并返回一个包含这两个数组的元素最小值的数组。
NumPy fmin 的语法
让我们来看看fmin()
函数的语法。
numpy.fmin(x1, x2, out=None)
| 参数 | 描述 | 必需/可选 |
| x1 | 输入数组 1。 | 需要 |
| x2 | 输入数组 2。 | 需要 |
| 在外 | 放置结果的替代输出数组。它必须具有与预期输出相同的形状。 | 可选择的 |
返回:
包含 x1 和 x2 的元素最大值的新数组。
- 如果 x1 和 x2 都是标量,那么输出也是标量。
- 如果 x1 或 x2 中的任何一个包含 NaN 值,则该逐元素比较的输出是非 NaN 值。
- 如果比较中的两个元素都是 NaN,则 NaN 作为最小元素返回。
例子
现在让我们看几个例子来更好地理解fmin()
函数。
当两个输入都是标量时
import numpy as np
a = 2
b = 6
# using fmin function to calculate the element-wise minimum
ans = np.fmin(a, b)
print("a =", a, "\nb =", b)
print("Result =", ans)
输出:
a = 2
b = 6
Result = 2
因为 2<6,所以 2 是这里的最小元素。
一维数组的逐元素最小值
import numpy as np
a = [5, 3, -5, 8, -2]
b = [1, 8, -2, 12, -13]
# using fmin function to calculate the element-wise minimum
ans = np.fmin(a, b)
print("a =", a, "\nb =", b)
print("Result =", ans)
输出:
a = [5, 3, -5, 8, -2]
b = [1, 8, -2, 12, -13]
Result = [ 1 3 -5 8 -13]
生成的数组计算如下:
ans[0] = min(a[0], b[0]) = min(5, 1) = 1
ans[1] = min(a[1], b[1]) = min(3, 8) = 3
ans[2] = min(a[2], b[2]) = min(-5, -2) = -5
ans[3] = min(a[3], b[3]) = min(8, 12) = 8
ans[4] = min(a[4], b[4]) = min(-2, -13) = -13
二维数组的逐元素最小值
import numpy as np
a = [[13, 8], [10, 7]]
b = [[5, 15], [30, 4]]
# using fmin function to calculate the element-wise minimum
ans = np.fmin(a, b)
print("a =", a, "\nb =", b)
print("Result =\n", ans)
输出:
a = [[13, 8], [10, 7]]
b = [[5, 15], [30, 4]]
Result =
[[ 5 8]
[10 4]]
这里,两个输入数组都是 2×2 数组,因此得到的数组也是 2×2 数组,计算如下:
ans[0][0] = min(a[0][0], b[0][0]) = min(13, 5) = 5
ans[0][1] = min(a[0][1], b[0][1]) = min(8, 15) = 8
ans[1][0] = min(a[1][0], b[1][0]) = min(10, 30) = 10
ans[1][1] = min(a[1][1], b[1][1]) = min(7, 4) = 4
包含 nan 的数组的逐元素最小值
现在让我们看看numpy.fmin()
方法是如何处理 nan 的。
import numpy as np
a = [4, 3, 10, np.nan, np.nan]
b = [2, np.nan, 5, 8, np.nan]
# using fmin function to calculate the element-wise minimum
ans = np.fmin(a, b)
print("a =", a, "\nb =", b)
print("Result =", ans)
输出:
a = [4, 3, 10, nan, nan]
b = [2, nan, 5, 8, nan]
Result = [ 2\. 3\. 5\. 8\. nan]
这里,
ans[0] = min(a[0], b[0]) = min(4, 2) = 2
ans[1] = min(a[1], b[1]) = min(3, nan) = 3
ans[2] = min(a[2], b[2]) = min(10, 5) = 5
ans[3] = min(a[3], b[3]) = min(nan, 8) = 8
ans[4] = min(a[4], b[4]) = min(nan, nan) = nan
在上面的数组中,索引 1 和 3 处的元素之一是 nan,因此最小值是非 NaN 值。此外,两个输入数组中索引 4 处的元素都是 NaN,因此得出的最小值也是 NaN,如本教程前面所述。
摘要
仅此而已!在本教程中,我们学习了 Numpy fmin 方法,并使用相同的方法练习了不同类型的示例。
如果你想了解更多关于 NumPy 的信息,请随意浏览我们的 NumPy 教程。
参考
NumPy fmod()–返回除法运算的元素余数。
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-fmod
NumPy 是“数值 Python”的缩写,是一个主要用于数组和多维矩阵的基础包。这个开源包提供了广泛的函数来对数组或矩阵执行全面的数学运算。
一个这样的函数是fmod(
,它以逐个元素的方式提供除法余数。通过该函数获得的余数与其被除数 (x1) 具有相同的符号。
这个函数的工作方式与 C 库中的 fmod()函数完全相同。它也可以与 Matlab(TM) rem
函数相媲美,并且不能与 Python 模数运算符 x1 % x2 相混淆(这是通过 NumPy 中的 mod()函数实现的)。)在本文中,让我们彻底理解 Python 中fmod()
函数的语法和用例。
为什么要用 fmod()。
fmod()函数用于计算给定数组中元素的余数。所需的参数包括两个整数数组或元组——第一个被视为被除数,第二个被视为除数。约定约束负被除数和除数的模运算的结果。
在 fmod 的情况下,结果的符号是被除数,而在余数的情况下,结果的符号是除数。Matlab(TM) rem
函数和 fmod 函数是等效的。
Numpy fmod()的语法
numpy.fmod(x1, x2, /, out=None, *, where=True)
因素
- x1: array_like ,必选
- 被视为被除数的数组
- x2: array_like,必需
- 被视为除数的数组
- out: ndarray、None 或 ndarray 和 None 的元组,可选
- 一个保存结果的地方。如果提供的话,它必须有一个输入广播到的形状。在没有任何输入或没有输入的情况下,返回一个新分配的数组。元组的长度(仅作为关键字参数可用)必须与输出的数量相匹配。
- 其中:array_like,可选
- 这种情况出现在输入上。在条件为真的点上,ufunc 结果将被设置为 out 数组。外部数组将在所有其他地方保持其初始值。应该注意的是,如果条件为假,由缺省 out=None 形成的未初始化 out 数组中的位置将继续未初始化。
- **kwargs , Optional
- 对于其他只有关键字的参数
Numpy fmod()的实现
在实现该函数之前,请确保在 IDE 中导入 NumPy 包。为此,请在您的 IDE 中运行以下代码行。
import numpy as np
让我们以最简单的方式,通过提供两个必需的参数——被除数数组和除数数组,尝试按元素返回余数。还要注意,在第二个例子中,除数是单一整数,因此对于被除数数组的所有元素都是相同的。
x1 = ([2,-4,11])
x2 = ([1,3,5])
ans = np.fmod(x1, x2)
print(x1)
print(x2)
print(ans)
y1 = ([9,8,7,6,5,4])
y2 = np.fmod(y1,2)
print(y1)
print(y2)
输出
Example
让我们用另一组简单的例子来理解 fmod()函数中的符号约定。
z1 = [-5, 6, 11]
z2 = [2, 3, -4]
z3 = np.fmod(z1, z2)
print(z3)
第一个元素的结果是负的,因为被除数是负的,但在第三个元素的情况下,结果仍然是正的,因为被除数是正的,因此我们可以得出结论,除数的符号确实影响输出的符号,它完全取决于被除数。
输出
Example
在下一个示例中, ones() 用于创建一个数组,其中所有元素都被赋值为“1”。注意,即使是零也被赋予了一个负号,只是因为被除数被赋予了一个负号。
w1 = np.full((1,3),[-5, 9, 0])
w2 = np.ones((1,3))
w3 = np.fmod(w1,w2)
print(w3)
输出
Example
摘要
NumPy 包是为处理数组和多维矩阵而构建的。fmod()是获得 x1 (被除数)除以 x2 (除数)的余数的直接方法。如果 x1 和 x2 都是标量,这就是一个标量。
参考
https://numpy . org/doc/stable/reference/generated/numpy . fmod . html
NumPy fmax–数组元素的最大元素数
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-fmx
你好,欢迎来到这个关于 Numpy fmax 的教程。在本教程中,我们将学习 NumPy fmax() 方法,也将看到许多关于这个方法的例子。让我们开始吧!
什么是 NumPy fmax?
fmax()
是 NumPy 中的一个函数,它比较两个数组并返回一个包含这两个数组的元素最大值的数组。
NumPy fmax 的语法
让我们来看看fmax()
函数的语法。
numpy.fmax(x1, x2, out=None)
| 参数 | 描述 | 必需/可选 |
| x1 | 输入数组 1。 | 需要 |
| x2 | 输入数组 2。 | 需要 |
| 在外 | 放置结果的替代输出数组。它必须具有与预期输出相同的形状。 | 可选择的 |
返回:
包含 x1 和 x2 的元素最大值的新数组。
- 如果 x1 和 x2 都是标量,那么输出也是标量。
- 如果 x1 或 x2 中的任何一个包含 NaN 值,则该逐元素比较的输出是非 NaN 值。
- 如果比较中的两个元素都是 NaN,则返回第一个 NaN。
使用 NumPy fmax 的示例
现在让我们看几个例子来更好地理解fmax()
函数。
当两个输入都是标量时使用 NumPy fmax
import numpy as np
a = 15
b = 8
# using fmax function to calculate the element-wise maximum
ans = np.fmax(a, b)
print("a =", a, "\nb =", b)
print("Result =", ans)
输出:
a = 15
b = 8
Result = 15
既然 15>8,那么答案就是 15。
一维数组的元素最大值
import numpy as np
a = [2, 36, 1, 5, 10]
b = [6, 3 ,48, 2, 18]
# using fmax function to calculate the element-wise maximum
ans = np.fmax(a, b)
print("a =", a, "\nb =", b)
print("Result =", ans)
输出:
a = [2, 36, 1, 5, 10]
b = [6, 3, 48, 2, 18]
Result = [ 6 36 48 5 18]
生成的数组计算如下:
ans[0] = max(a[0], b[0]) = max(2, 6) = 6
ans[1] = max(a[1], b[1]) = max(36, 3) = 36
ans[2] = max(a[2], b[2]) = max(1, 48) = 48
ans[3] = max(a[3], b[3]) = max(5, 2) = 5
ans[4] = max(a[4], b[4]) = max(10, 18) = 18
二维数组的元素最大值
import numpy as np
a = [[6, -8, 4], [2, 21, 16]]
b = [[-5, -12, 1], [0, 10, 27]]
# using fmax function to calculate the element-wise maximum
ans = np.fmax(a, b)
print("a =", a, "\nb =", b)
print("Result =\n", ans)
输出:
a = [[6, -8, 4], [2, 21, 16]]
b = [[-5, -12, 1], [0, 10, 27]]
Result =
[[ 6 -8 4]
[ 2 21 27]]
这里,两个输入数组都是 2×3 数组,因此结果数组也是 2×3 数组,计算如下:
ans[0][0] = max(a[0][0], b[0][0]) = max(6, -5) = 6
ans[0][1] = max(a[0][1], b[0][1]) = max(-8, -12) = -8
ans[0][2] = max(a[0][2], b[0][2]) = max(4, 1) = 4
ans[1][0] = max(a[1][0], b[1][0]) = max(2, 0) = 2
ans[1][1] = max(a[1][1], b[1][1]) = max(21, 10) = 21
ans[1][2] = max(a[1][2], b[1][2]) = max(16, 27) = 27
包含 nan 的数组的元素最大值
import numpy as np
a = [8, np.nan, 5, 3]
b = [0, np.nan, np.nan, -6]
# using fmax function to calculate the element-wise maximum
ans = np.fmax(a, b)
print("a =", a, "\nb =", b)
print("Result =", ans)
输出:
a = [8, nan, 5, 3]
b = [0, nan, nan, -6]
Result = [ 8\. nan 5\. 3.]
这里,
ans[0] = max(a[0], b[0]) = max(8, 0) = 8
现在,a[1]和 b[1]都是 NaN,所以这些中的最大值也作为 NaN 返回。
ans[1] = NaN
a[2] = 5,b[2] = NaN,因此最大值是非 NaN 值,即 5。
ans[2] = 5
ans[3] = max(a[3], b[3]) = max(3, -6) = 3
结论
仅此而已!在本教程中,我们学习了 Numpy fmax 方法,并使用相同的方法练习了不同类型的示例。
如果你想了解更多关于 NumPy 的信息,请随意浏览我们的 NumPy 教程。
参考
NumPy full()函数
原文:https://www.askpython.com/python-modules/numpy/numpy-full
在本文中,我们将尝试理解 Python 中 NumPy 包的 full()函数。
NumPy 是一个流行的科学计算 Python 库,它提供了处理大型多维数组和数字数据矩阵的工具。NumPy 提供的函数之一是full()
,它返回给定形状和类型的新数组,用填充值填充。
函数允许你创建一个任意大小和形状的数组,并用指定的值填充它。当您需要创建特定大小和类型的数组作为其他数据的占位符时,或者当您希望用默认值初始化数组时,这可能会很有用。
full()
函数是一种简单有效的方法,通过一次函数调用就可以创建和填充数组。
NumPy 中的 full()函数是什么?
该函数用于创建给定形状和类型的新数组。数组的值用参数中传递的fill_value
初始化。还可以提供新数组的数据类型,以及它在参数中的顺序。
NumPy full()的语法
numpy.full(shape, fill_value, dtype=None, order='C', like=None)
因素
- 形状:整数或整数序列
- 需要
- 新数组的维数;可以是单个整数,也可以是整数元组。
- fill_value:标量或数组 _like
- 需要
- 要添加到新数组的值
- dtype:数据类型
- 可选择的
- 新数组中元素的数据类型;默认=无,表示
np.array(fill_value).dtype
。
- 顺序:{'C ',' F'}
- 可选择的
- 应该使用哪种顺序存储多维数据——C 语言还是 Fortran 语言——连续(按行或按列)
- like: array_like
- 可选择的
- 为了能够生成不是 NumPy 数组的数组,提供了引用对象。如果符合数组函数协议,则结果将由 as like 中提供的数组 like 确定。在这种情况下,它确保创建的数组对象与作为参数提供的对象兼容。
NumPy full()的实现
在实现该函数之前,请确保在 IDE 中导入 NumPy 包。为此,请运行以下代码行。
import numpy as np
例 1。仅传递必需的参数
让我们创建一个具有特定大小和形状的数组,并填充一个常量值
#one dimentional array
np.full(2,4)
#two dimentional array with singular element
np.full((2,3),4)
#two dimentional array with multiple element
np.full((2,3),[1,2,3])
Example 1
例 2。传递其他参数
现在让我们创建一个具有特定大小和数据类型的数组,其中填充了一个常数值。
np.full((3,3), [2,4,6], dtype=np.float16)
np.full((3,2), [2.8,1.9], dtype=int, order='F')
np.full((3,3), [1+2j], dtype=complex)
Example 2
结论
NumPy 包使得使用数组更加容易。full()函数是返回给定形状和类型的新数组的简单方法,用 fill_value 填充。
参考
https://numpy . org/doc/stable/reference/generated/numpy . full . html
NumPy full_like()函数——返回一个与给定数组具有相同形状和类型的完整数组
原文:https://www.askpython.com/python-modules/numpy/numpy-full_like
NumPy 是一个强大的、广泛使用的 Python 科学计算库。它提供了许多处理数字数据和数组的函数和工具,包括full_like()
函数。这个函数允许你创建一个新的数组,它的形状和数据类型与给定的数组相同,但是填充了一个特定的值。
这在许多情况下都很有用,例如当您需要创建某种形状和类型的数组来保存占位符或默认值时。在本文中,我们将详细探讨full_like()
函数的用法和语法,并提供如何在实践中使用它的例子。
也读作: NumPy full()函数
NumPy 中的 full_like()是什么?
full_like()
是 NumPy 库中的一个函数,它创建一个与给定数组具有相同形状和数据类型的新数组,但用指定的值填充。它接受两个必需的参数:
a
:用作新数组的形状和数据类型模板的数组。fill_value
:填充新数组的值。
Numpy full_like()的语法
numpy.full_like(a, fill_value, dtype=None, order='K', subok=True, shape=None)
因素
- 答:数组 _like
- 需要
- 返回数组的这些相同特征是由。
- fill_value: array_like
- 需要
- 新数组中用来初始化元素的值。
- dtype:数据类型
- 可选择的
- 覆盖结果的数据类型。
- 顺序:{'C ',' F ',' A '或' K'}
- 可选择的
- 更改结果的内存布局。“C”代表 C 阶,“F”代表 F 阶,“A”代表 C,除非“A”是 Fortran 连续的。“K”表示与 a 非常相似的布局。
- subok: bool
- 可选择的
- 如果为 True,新生成的数组将使用的子类类型;否则,将使用基类数组。通常设置为 True。
- 形状:int 或整数序列
- 可选择的
- 改变结果的形式。如果 order='K '并且维度数量保持不变,将尝试保持顺序;否则,假定 order='C '。
Numpy full_like()的实现
在实现该函数之前,请确保在 IDE 中导入 NumPy 包。为此,请在您的 IDE 中运行以下代码行。
import numpy as np
例 1。仅传递必需的参数
x = ([1,2,3],[4,4,6])
print(x)
print("\n")
np.full_like(x, 3)
y = ([1,2,3],
[4,5,6])
print(y)
print("\n")
np.full_like(y,([9,8,7],[6,5,4]))
Example 1
例 2。传递其他参数
w = ([1,2,3],[4,5,6],[7,8,9])
print(w)
print("\n")
np.full_like(w, 5, dtype=np.float16, order='C')
z = ([1,2,3],[4,5,6])
print(z)
print("\n")
np.full_like(z, (1+3j), dtype = float, order='F')
Example 2
示例 3:用 numpy.full_like()将所有内容放在一起
下面是一个更完整的使用 numpy.full_like()方法的例子,包括所有不同的使用方法。
import numpy as np
# Create a random array of integers from 0 to 9
a = np.random.randint(10, size=(2, 3, 4))
print(f"Original array: \n{a}")
# Create a new array of zeros with the same shape and data type as a
b = np.full_like(a, 0)
print(f"Array of zeros with same shape and data type as a: \n{b}")
# Create a new array of ones with the same shape and data type as a
c = np.full_like(a, 1, dtype=np.float64)
print(f"Array of ones with same shape and data type as a, but with data type float64: \n{c}")
# Create a new array with the same shape and data type as a, but filled with the maximum value of a's data type
d = np.full_like(a, np.amax(a))
print(f"Array with same shape and data type as a, filled with the maximum value of a's data type: \n{d}")
# Create a new array with the same shape and data type as a, but filled with the minimum value of a's data type
e = np.full_like(a, np.amin(a))
print(f"Array with same shape and data type as a, filled with the minimum value of a's data type: \n{e}")
输出
Original array:
[[[2 9 7 3]
[9 8 6 4]
[1 0 8 9]]
[[3 9 9 7]
[0 8 0 3]
[5 5 4 3]]]
Array of zeros with same shape and data type as a:
[[[0 0 0 0]
[0 0 0 0]
[0 0 0 0]]
[[0 0 0 0]
[0 0 0 0]
[0 0 0 0]]]
Array of ones with same shape and data type as a, but with data type float64:
[[[1\. 1\. 1\. 1.]
[1\. 1\. 1\. 1.]
[1\. 1\. 1\. 1.]]
[[1\. 1\. 1\. 1.]
[1\. 1\. 1\. 1.]
[1\. 1\. 1\. 1.]]]
Array with same shape and data type as a, filled with the maximum value of a's data type:
[[[9 9 9 9]
[9 9 9 9]
[9 9 9 9]]
[[9 9 9 9]
[9 9 9 9]
[9 9 9 9]]]
Array with same shape and data type as a, filled with the minimum value of a's data type:
[[[0 0 0 0]
[0 0 0 0]
[0 0 0 0]]
[[0 0 0 0]
[0 0 0 0]
[0 0 0 0]]]
结论
总之,NumPy 中的full_like()
函数是创建新数组的有用工具,这些新数组具有与给定数组相同的形状和数据类型,但填充了特定的值。这在许多情况下都很有用,例如当您需要创建某种形状和类型的数组来保存占位符或默认值时。无论您是在科学计算中处理数字数据,还是仅仅需要在 Python 脚本中操作数组,full_like()
函数都是您工具箱中的宝贵补充。
参考
https://numpy . org/doc/stable/reference/generated/numpy . full _ like . html
NumPy gcd–返回两个数字的最大公约数
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-gcd
正如我们在前面的练习中看到的, NumPy 的 lcm 函数对于寻找两个或更多数字的最小公倍数非常有用,如果我们想要两个或更多数字的最大公约数呢?这就是 numpy gcd 函数发挥作用的地方。两个或多个数的最大公约数(GCD)是能整除这两个数的最大公因数。
什么是 NumPy gcd?
两个整数的最大公约数(GCD)是两个整数均分的最大整数。例如,16 和 24 的 GCD 是 8,因为 8 是 16 和 24 的最大整数。
NumPy gcd 是一个数学函数,计算给予 nunpy.gcd()
函数的输入数字的 gcd 值。
NumPy gcd 的语法
让我们来看看函数的语法。
numpy.gcd(x1 , x2)
输入的 x1
、 x2
不能是负数。
这里,**x1**
和**x2**
是输入的数字,可以是单个数字或者是一个 NumPy 数组数字。 numpy.gcd()
函数计算输入数字的 GCD(最大公约数)。
注意:数字不能是浮点数。
让我们写一些代码来更好地理解这个函数。
使用 NumPy gcd
两个整数的最大公约数可以用 NumPy 的 gcd 函数来计算。它是这样工作的:
单一数字的数量 gcd
import numpy as np
print("The GCD of 12 and 46 is:",np.gcd(12 , 46))
print("The GCD of 12 and 24 is:",np.gcd(12 , 24))
print("The GCD of 25 and 50 is:",np.gcd(25 , 50))
print("The GCD of 5 and 100 is:",np.gcd(5 , 100))
print("The GCD of 17 and 87 is:",np.gcd(17 , 87))
输出
The GCD of 12 and 46 is: 2
The GCD of 12 and 24 is: 12
The GCD of 25 and 50 is: 25
The GCD of 5 and 100 is: 5
The GCD of 17 and 87 is: 1
在上面的代码片段中,我们使用 import
语句导入了 NumPy 库。
在接下来的几行中,我们使用 np.gcd()
函数来计算数字的 GCD。注意我们得到两个数的 GCD 有多快,这就是 Python NumPy 库的强大之处🙂
我们先来了解一下 25 和 50 的 GCD 是怎么算出来的。我们可以观察到 25 和 50 相除的最大数是 25。所以,25 和 50 的 GCD 是 25,这也是由 np.gcd()
函数产生的输出。
现在,让我们看看如何计算一组数字的 GCD。
单个数数组的个数 gcd
在这里,我们将找到单个 NumPy 数组中所有元素的 gcd。
import numpy as np
a = np.array((3, 6, 24, 56, 79, 144))
gcd_value = np.gcd.reduce(a)
print("Input Array:\n",a)
print("The GCD value of the elements of the array is:",gcd_value)
输出
Input Array:
[ 3 6 24 56 79 144]
The GCD value of the elements of the array is: 1
为了找到单个 NumPy 数组的所有元素的 GCD,使用了 reduce
函数,该函数将 gcd
方法应用于数组的每个元素。
该功能的其余工作是相同的。
可以计算两个 NumPy 数组的 GCD 吗?让我们看看🙂
两个数字数组的 gcd
import numpy as np
a = np.array((12 , 24 , 99))
b = np.array((44 , 66 , 27))
c = np.gcd(a , b)
print("Array 1:\n",a)
print("Array 2:\n",b)
print("GCD values:\n",c)
输出
Array 1:
[12 24 99]
Array 2:
[44 66 27]
GCD values:
[4 6 9]
太神奇了!我们刚刚计算了两个 NumPy 数组的 GCD。
这里, np.gcd()
函数选取两个数组中相同位置的元素,并计算它们的 GCD。例如,在上面的代码片段中,选择了 12 和 44,并计算了它们的 GCD。类似地,计算两个数组的下一个元素及其 GCD。
np.gcd()
的输出是一个 NumPy 数组,存储在上面代码片段中的变量 c
中。
这就是关于 NumPy gcd 函数的全部内容。
摘要
在本文中,我们学习了函数的语法,并练习了不同类型的示例,使我们的理解更加清晰。这些 NumPy 函数使用起来非常简单,你知道这就是 NumPy 库的强大之处。它有很多数学函数,当我们对大量数据进行数学计算时,这些函数使事情变得简单。
在这里继续探索关于其他 Python 主题的精彩文章。
参考
num py documentation–num py gcd
Numpy 渐变:返回 N 维数组的渐变
原文:https://www.askpython.com/python-modules/numpy/numpy-gradient
讨厌打破这一点,但数学是令人厌倦的!这比你能想到的要强烈得多,尤其是当你进入分化和整合的领域时。更糟糕的是,这种区分足够灵活,可以部分完成。
老天爷啊!但是,嘿,我们已经让 Python 为我们完成了一些工作。唷!
本文解释了 Python 的 numpy 库中的 gradient( ) 函数的部署,用于 N 维数组。
也读作:NumPy nanmax——忽略任何 NaNs 的沿轴数组的最大值
numpy . gradient()的语法
让我们先看看 gradient( ) 函数的语法,然后再了解如何使用它。
numpy.gradient( array, varags, axis=None, edge_order=1)
在哪里,
- 数组–N 维标量实体的集合
- varags–包含可变参数的可选条款,可变参数规定了输入数组中每个维度的间距
- 轴–一个可选的规定,规定计算梯度&的方向,默认设置为无
- edge _ order–一个可选条款,处理要计算坡度的边界。它可以设置为“1”或“2”,前者是默认设置
Python 通过寻找差异来计算梯度,
- 在边界处相邻数字之间&除以默认间距“1”
- 在内部的相邻数字之间&除以默认间距“2”
计算等间距梯度:
在导入了 numpy 库之后,让我们从构造一个数组&开始,然后找到它的均匀间距的梯度,比如下面给出的‘3’。
import numpy as np
ar = np.array([1.2, 3.4, 5.6])
np.gradient(ar,3)
Gradient Calculated With Uniform Spacing
同样的事情也可以用 gradient( ) 函数的默认设置来完成,而不需要明确提到所需的间距。在这种情况下,间距被设置为本文语法部分前面提到的默认值。另外,要注意的是,如果需要找到一串整数的梯度,也可以在数组内将数据类型指定为'' float '。
ar = np.array([1, 3, 5, 9], dtype = float)
np.gradient(ar)
Calculating Gradient With Default Values
计算非均匀间距的梯度
也可以通过在 gradient( ) 函数中为输入数组的每个元素分配所需的间距来使用排他间距。但是,我们应该记住,这个数组应该与输入数组的维数相同。
ar = np.array([1.2, 3.4, 5.6], dtype = float)
sp = np.array([7.8, 9.0, 0.1], dtype = float)
np.gradient(ar,sp)
Calculating Gradient With Non-Uniform Spacing
计算 N 维数组的梯度:
当一个多维数组进入画面时, gradient( ) 函数将返回两个不同的结果,而不管其中一个是否提供均匀的间距。这让我们想知道为什么会这样?!'。
这个结果可以归因于这样的事实,即一个结果对应于关于行的梯度计算,而另一个结果对应于关于输入阵列的列的梯度计算。
让我们试着计算一个均匀间距为‘2’的二维数组的梯度,如下所示。
ar =([[1.2, 3.4, 5.6], [7.8, 9.0, 0.1]])
np.gradient(ar,2)
Gradient Of 2 Dimensional Array With Uniform Spacing
上图中的第一个结果是根据列计算的梯度,接下来的是根据行计算的梯度。
结论:
既然我们已经到了这篇文章的结尾,希望它已经详细阐述了如何在 Python 中找到 N 维数组的梯度。这里有另一篇文章解释了如何在 Python 中使用 numpy 返回每个元素的倒数。在 AskPython 中还有许多其他有趣的&文章,这些文章可能对那些希望提高 Python 水平的人有很大帮助。当你享受这些的时候,再见!
NumPy hypo t–完整指南
原文:https://www.askpython.com/python-modules/numpy/numpy-hypot
读者你好!欢迎来到本系列的另一个教程数字数学函数。在本教程中,我们将了解 NumPy 库的 hypot 函数。
我们一定都计算过数学中直角三角形斜边的值。我们过去常常应用著名的毕达哥拉斯定理来找出斜边或任何其他两条边(即垂线和底边)的值。
本教程将用很多例子来说明如何使用 NumPy hypot 函数。那么,我们开始吧。
斜边——快速概览
- 直角三角形有一个角等于 90 度,即两条边互相垂直。在直角三角形中,与 90 度角相对的边称为三角形的斜边。
- 直角三角形斜边的值是所有边中最大的。
为了更好地理解,请参考下图。
Hypotenuse
什么是 NumPy 海波?
- NumPy 提供了很多数学函数,numpy.hypot()就是其中之一。这里,hypot 代表直角三角形的斜边。三角形。
- numpy.hypot()在给定直角三角形其他两条边的值的情况下,计算直角三角形斜边的值。
NumPy hypot 的语法
numpy.hypot(x1, x2)
其中 x1 和 x2 是直角三角形两边的值。
这个函数根据毕达哥拉斯定理计算斜边的值。因此,numpy.hypot(x1, x2)
将被计算为 sqrt(x1² +x2² ),其中 sqrt 是平方根。
注意: x1 和 x2 不能为负。
使用 NumPy 海波函数
现在让我们看一些使用 numpy hypot 函数的实际例子。
计算两个值列表的斜边
# Importing the numpy library
import numpy as np
x1 = [12 , 4 , 5 , 6]
x2 = [5 , 6 , 7 , 14]
a = np.hypot(x1 , x2)
print("Hypotenuse Values:\n",a)
输出
Hypotenuse Values:
[13\. 7.21110255 8.60232527 15.23154621]
使用数值数组计算斜边
import numpy as np
a = np.array((4 , 5))
b = np.array((3 , 12))
c = np.hypot(a , b)
print("Hypotenuse Values :\n",c)
输出
Hypotenuse Values :
[ 5\. 13.]
具有二维数组的 NumPy 海波函数
继续,我们现在将使用一个 2D 数组来计算斜边。
计算 2D 列表的斜边
import numpy as np
# Creating two 3x3 arrays
x = [[1,2,3] , [4,5,6] , [7,8,9]]
y = [[10,11,12] , [13,14,15] , [16,17,18]]
z = np.hypot(x,y)
print("Hypotenuse Values:\n",z)
输出
Hypotenuse Values:
[[10.04987562 11.18033989 12.36931688]
[13.60147051 14.86606875 16.15549442]
[17.4642492 18.78829423 20.1246118 ]]
使用 np.ones()数据计算斜边
import numpy as np
#Initializing a 3x3 NumPy Array with all the elements equal to 3
m = 3*np.ones((3,3))
#Initializing a 3x3 NumPy Array with all the elements equal to 4
n = 4*np.ones((3,3))
p = np.hypot(m , n)
print("Hypotenuse Values:\n",p)
输出
Hypotenuse Values:
[[5\. 5\. 5.]
[5\. 5\. 5.]
[5\. 5\. 5.]]
np.ones()
函数创建一个所有元素都等于 1 的 NumPy 数组,在上面的代码片段中,我们创建了一个变量 m ,它包含一个所有元素都等于 3 的 3×3(二维数组)和另一个变量 n 也包含一个所有元素都等于 4 的 3×3(二维数组)。
下一步很简单,将 m 和 n 作为参数传递给 np.hypot()函数,计算两个数组中每对元素的斜边值。
摘要
这就是 NumPy 海波函数的全部内容,它是一个非常简单明了的函数。敬请关注,继续学习🙂
参考
NumPy identity 函数:返回一个主对角线上有 1 的正方形数组
原文:https://www.askpython.com/python-modules/numpy/numpy-identity
在本文中,我们将尝试理解 Python 中 NumPy 的 identity 函数。
Python 包 NumPy(数值 Python)用于操作数组。使用 NumPy 可以在一个数组上执行许多数学运算。
它提供了一个庞大的高级数学函数库来处理这些数组和矩阵,并提供了强大的数据结构来确保使用数组和矩阵进行高效计算。
2005 年,特拉维斯·奥列芬特开发了 NumPy。您可以免费使用它,因为它是一个开源项目。
也读作: Numpy 渐变:返回 N 维数组的渐变
numpy.identity()是什么?
该函数用于返回一个主对角线上有 1 的正方形数组(行数和列数相等的数组),这种数组称为恒等数组。
numpy.identity()的语法
numpy.identity(n, dtype=None, like=None)
因素
- n: int
- 需要
- 所需输出数组的行数或列数
- dtype:数据类型
- 可选择的
- 输出数组中值的数据类型,
- 默认设置为浮动。
- like: array_like
- 可选择的
- 可以使用引用对象创建非 NumPy 数组。如果符合数组函数协议,则结果将由 as like 中提供的数组 like 确定。在这种情况下,它确保创建的数组对象与作为参数提供的对象兼容。
返回一个 n x n 对称数组,其主对角线设置为 1,所有剩余元素设置为零。
numpy.identity()的实现
在使用这个函数之前,请确保在 IDE 中导入 NumPy 包。要导入 NumPy 包,请运行以下代码行。
import numpy as np
示例 1:只传递“n”参数
np.identity(4)
输出
Example 1
示例 2:传递其他参数
np.identity(3, dtype=int)
np.identity(3, dtype=complex)
输出
Example 2
摘要
通过使用 Python 中的 NumPy 包,处理数组变得很容易。identity()函数是创建一个 n×n 单位矩阵/数组的简单方法。
参考
https://numpy . org/doc/stable/reference/generated/numpy . identity . html
NumPy 面试问题:为你的 Python 工作面试做准备
原文:https://www.askpython.com/python/numpy-interview-questions
NumPy 是 Python 中的一个开源科学数值库。它主要用于执行涉及矩阵和数组的数学计算。它包含许多数学函数,本质上是高级的,这些函数对数组进行操作以提供输出。
NumPy 最初被开发为 数字 ,由 Jim Hugunin 和其他几个开发者作为项目的贡献者开发。2005 年,Travis Oliphant 创建了 Numarray,这是一个与 Numeric 竞争的类似的库。他将 Numarray 的特性结合到 Numeric 中,从而创造了 NumPy。
也读作:熊猫 Dataframe 和 Numpy 数组的区别
关键特征
以下是 NumPy 最重要的特性,这些特性使它在整个技术社区中真正流行起来。
- N 维数组–NumPy 速度非常快,功能强大,用途广泛。它使用向量化技术来执行数学运算。还将广播和索引作为数组计算的标准概念。
- 提供基于数字的计算工具——NumPy 可以处理大量的数学和复杂的函数。其中一些包括线性代数、随机数发生器、傅立叶变换等等,它们在科学计算中被广泛使用。
- 使用多种连接设备和硬件的能力–具体称为互操作性,NumPy 支持多种类型的硬件、计算平台、图形处理单元、分布式计算能力和稀疏阵列库集成,这使其成为周围大型社区使用的最强大的 Python 库之一。
- 优化和高性能的代码执行–NumPy 在其核心整合了高性能的 C 代码编译,提供高效和高速的代码执行。
- 用户友好–NumPy 提供了非常易读和简单的 Python 语法,这使得它非常用户友好。使用它的代码需求很少,并且易于调试。因此,使其可被所有级别的编码人员和跨多个行业使用和编程。
- 开源(–NumPy 有一个庞大而多样化的社区,有许多开源贡献者。它带有 BSD 许可证,在 GitHub 上公开开发和维护。
真实世界数据分析中的 NumPy 示例
NumPy 被科学界大量使用,这使得它在每一个重要的层面上都脱颖而出。下面是几个例子,提供了他们的一瞥。完整的案例研究可在 NumPy 官方网站上阅读。
- 第一张黑洞图像–NumPy 与 Matplotlib 和 SciPy 等使用 NumPy 作为依赖项的其他科学库一起,利用视界望远镜制作了第一张黑洞图像。
- 探测到引力波–在阿尔伯特·爱因斯坦于 1916 年首次预言引力波之后,100 年后,LIGO 科学家用 NumPy 证实了引力波的存在。
- 体育分析–体育行业大量使用预测分析和数据建模来提供团队和球员的统计分析,以提高他们的表现。在大多数情况下,NumPy 就是为此目的而使用的。
- 使用深度学习进行姿态估计–DeepLabCuts 正在使用 NumPy 进行动物行为观察,以更好地了解运动控制、物种和时间尺度,从而进行快节奏的科学研究。
理论数量面试问题
1.什么是 NumPy,它的基本特征是什么?
NumPy 是 Python 中的一个科学计算包/库。它提供了一个多维数组对象以及多个派生对象,如掩码数组和矩阵。NumPy 包的核心是n 数组 。这负责封装同质数据类型的 n 维数组,提供优化的代码编译,使其非常高效。它主要用于执行数学和逻辑运算、实现基本的线性代数、操纵数组形状、排序和选择、I/O、执行离散傅立叶变换等等。
2.NumPy 是用什么语言写的?
NumPy 本质上是一个 Python 库。它主要是用 C/C++编写的,目的是快速优化代码执行。然而,NumPy 的某些部分也是用 Python 编写的。
3.使用 NumPy 的主要原因是什么?
NumPy 是各行各业非常流行的 Python 库。数据科学是利用这个库的主要领域之一。大多数科学计算使用数组。在执行高级和复杂的计算时,为了尽快得到结果,高效和快速的代码执行是不可避免的。
虽然 Python 列表也是数组,但是这些列表的处理时间比 NumPy 数组慢 50 倍,这使得它成为执行数字和科学计算最流行的库。在 NumPy 中,数组对象被称为 ndarray ,它提供了许多额外的功能,使它更快更容易使用。
4.标准 Python 序列和 NumPy 数组之间有什么重要的区别?
以下是两者之间一些最显著的区别。
- Python 列表可以动态增长,而 NumPy 数组的大小在创建时是固定的。因此,当我们改变一个 ndarray 的大小时,它删除原来的数组并创建一个新的。
- 在计算包含大量数据的高等数学和各种其他类型的运算时,NumPy 的性能要高得多。使用 Python 进行计算需要更多的代码,效率也不如 NumPy。
- 与 Python 数组不同,NumPy 数组的所有元素的数据类型都是相同的,因此它占用固定的内存大小。然而,有一个例外,可以有对象数组(Python 和 Numpy ),允许数组有不同大小的元素。
- 许多使用基于 Python 的包进行高级计算的科学界都采用了 NumPy 数组。基于 Python 的序列通常会在预处理数据时转换为 NumPy 数组,并将结果作为 NumPy 数组输出。因此,编写高效的基于 Python 的科学计算需要 NumPy 数组的知识。
5.是什么让 NumPy 数组比 Python 列表快?
列表在创建和保存时,存储在随机的内存位置,如果对其进行操作,则需要更长的时间来访问和处理。这就是 NumPy 数组的亮点。它们作为 ndarrays 存储在一个连续的内存位置,使得操作和计算非常高效和优化。这种类型的代码执行与现代 CPU 架构是一致的,因此,使 NumPy 成为一个非常快速和优化的 Python 库。
6.在 NumPy 的上下文中简要解释一个数组。
在 NumPy 库中,数组是核心数据结构。数组包含原始数据信息,并提供解释项目和定位元素的方法。数组中的元素可以用多种方式索引,并由元素网格组成。
数组中的元素类型被称为 dtype ,它们也必须是相同的数据类型。维数与数组的秩有关。整数元组是提供沿每个维度的数组大小的数组形状。
7.列出 NumPy ndarray 对象的一些重要属性。
下面是一个n 数组 对象的一些主要属性
- ndarray . shape–输出数组尺寸。对于包含 n 行和 m 列的矩阵,形状将是 (n,m) 。为了获得给定数组的轴数,使用了 ndarray.ndim 。
- ndarray . dtype–描述数组中包含的元素的数据类型。我们也可以使用标准 Python 来指定数据类型。NumPy 还提供了自己的附加数据类型。一些例子是 numpy.int16、numpy.int32、和 numpy.float64 。
- ndarray . itemsize–输出给定数组中每个元素的大小,单位为T3 字节。T5 与使用 ndarray.dtype.itemsize 相同。比方说,我们有一个包含类型为 float64 的元素的数组。它的 itemsize 将是 8 ,这是 64/8 的结果。还有一种是当包含的数据类型为 complex32 时。它的 itemsize 将是 4 也就是 32/8 。
- ndarray . data–返回保存数组的内存位置或缓冲区。它并不常用,因为我们使用索引作为对该内存位置的引用来获取数组中包含的元素。
8.NumPy 中的通用函数有哪些?
像 exp、sin、cos、add、sqrt、等数学函数在 Numpy 中被称为通用函数或 ufunc 。它们对 NumPy 中的数组进行操作,并以数组的形式提供输出。他们使用向量化来实现操作,也支持广播以及其他方法,如累加和减少。
9.解释 NumPy 中的术语广播。
每当我们有不同维度的数组时,NumPy 在执行算术、函数、位运算以及逻辑运算时都以统一的方式对待它们。这被称为广播。它用于解释操作行为,这是隐式地一个元素一个元素地完成的。
NumPy Broadcasting
10.如何将 1D 阵列转换成 2D 阵列?
为了增加给定数组的维数,我们可以使用 NumPy 提供的 np.newaxis 和 np.expand_dims 函数。因此,我们可以将 1D 转换成 2D,将 2D 转换成 3D 等等。
11.解释 NumPy 中副本和视图的主要区别。
当我们使用 NumPy 中的 copy()函数时,它创建了一个全新的数组。我们在原始数组中所做的更改不会反映在它的复制版本中。另一方面,view()函数只是原始数组的反射。无论我们在原始数组中做什么更改,都将在用视图函数调用的数组中实现。
12.NumPy 和熊猫有什么不同?
以下是 NumPy 和熊猫的一些区别。
- NumPy 比熊猫快得多,内存效率高。
- NumPy 主要用于数值计算,而 Pandas 用于更广泛的目的,如数据分析和可视化。
- NumPy 支持使用矩阵和数组数据格式,其中 Pandas 可以用于表格数据、Excel 文件、CSV 文件等。
- NumPy 使用数组作为其主要对象,默认情况下也不进行索引。Pandas 使用系列和数据框作为其主要对象,并且默认情况下还提供索引。
13.陈述 NumPy 和 SciPy 之间的区别。
NumPy 实现了基本的功能,即索引、排序等等,这使它变得轻量和紧凑。另一方面,SciPy 用于涉及算法和代数函数的复杂计算。这使得它承载了更多的功能。
NumPy 中的函数定义得不是很全面,不像 SciPy。NumPy 的一个限制是被操作的数组必须是相同类型或同类的。SciPy 没有同质性的限制,这使得它更加灵活和通用。
Numpy 部分是用 Python 编写的,大部分使用 C 语言进行代码编译和执行。SciPy 是用 Python 编写的,与 NumPy 相比,它速度较慢,但它提供的功能比 NumPy 多得多。
14.NumPy 为数组迭代提供了哪些函数?
NumPy 提供的nditer()
和ndenumerate()
函数可以用来对不同维数的数组进行迭代运算。
15.如何在 NumPy 中加入数组?
我们可以使用concatenate()
和stack()
函数来连接 NumPy 数组。这两个函数输出相似的结果,除了堆叠操作是沿着新轴执行的,这与串联不同。
NumPy 编码问题
1.怎么才能安装 NumPy?
- 与康达
# Using an environment
conda create -n my-env
conda activate my-env
# Install using conda-forge
conda config --env --add channels conda-forge
# Installation command
conda install numpy
- 带 PIP
pip install numpy
2.导入 NumPy 并使用它创建一个简单的数组。
import numpy as np
array1 = np.array([10, 12, 14, 16])
print(array1)
3.如何检查已安装 NumPy 的版本?
import numpy as np
np.__version__
# Output: '1.21.5'
4.如何使用 NumPy 创建不同维度的数组?另外,检查尺寸。
import numpy as np
first_array = np.array(10) # 0D Array
second_array = np.array([21, 22, 23, 24, 25]) # 1D Array
third_array = np.array([[21, 22, 23], [24, 25, 26]]) # 2D Array
fourth_array = np.array([[[10, 20, 30], [40, 50, 60]], [[10, 20, 30], [40, 50, 60]]]) # 3D Array
first_array, first_array.ndim
# Output: (array(10), 0)
second_array, second_array.ndim
# Output: (array([21, 22, 23, 24, 25]), 1)
third_array, third_array.ndim
# Output:
"""
(array([[21, 22, 23],
[24, 25, 26]]),
2)
"""
fourth_array, fourth_array.ndim
# Output:
"""
(array([[[10, 20, 30],
[40, 50, 60]],
[[10, 20, 30],
[40, 50, 60]]]),
3)
"""
5.如何使用 NumPy 创建更高维的数组?
import numpy as np
higher_dimension_array = np.array([10, 20, 30, 40], ndmin=7)
higher_dimension_array
# Output: array([[[[[[[10, 20, 30, 40]]]]]]])
'Dimensions :', higher_dimension_array.ndim
# Output: ('Dimensions :', 7)
6.举例说明 NumPyn array属性的用法。
- n 阵列形状
import numpy as np
my_array = np.arange(10).reshape(2, 5)
my_array
# Output
"""
array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]])
"""
my_array.shape
# Output
"""
(2, 5)
"""
- ndarray.dtype
my_array.dtype
# Output
"""
dtype('int32')
"""
- ndaarray . item size
r_part = [2, 3, 4]
i_part = [6, 7, 8]
my_complex_array = np.array([r_part, i_part], dtype=complex)
my_complex_array
# Output
"""
array([[2.+0.j, 3.+0.j, 4.+0.j],
[6.+0.j, 7.+0.j, 8.+0.j]])
"""
my_complex_array.dtype
# Output
"""
dtype('complex128')
"""
my_complex_array.itemsize
# Output
"""
16
"""
- ndarray.data
my_array.data
# Output
"""
<memory at 0x000001E8ABFEDBA0>
"""
7.如何使用 NumPy 创建不同数据类型的数组?
我们可以通过几种方式使用 NumPy 创建数组。数组类型的推导是从那些序列中包含的元素类型中完成的。下面是一些例子。
- int 数据类型
first_array = np.array([1, 2, 3])
first_array
# Output: array([1, 2, 3])
first_array.dtype
# Output: dtype('int32')
- 浮点数据类型
second_array = np.array([2.3, 4.5, 6.7])
second_array
# Output: array([2.3, 4.5, 6.7])
second_array.dtype
# Output: dtype('float64')
- 多种数据类型
third_array = np.array([(2.3, 8.7, 3.2), (1, 2, 3)])
third_array
# Output
"""
array([[2.3, 8.7, 3.2],
[1\. , 2\. , 3\. ]])
"""
8.如何用 NumPy 创建复杂类型数组?
import numpy as np
complex_type_array = np.array([[1, 2, 4], [9, 10, 5]], dtype=complex)
complex_type_array
# Output
"""
array([[ 1.+0.j, 2.+0.j, 4.+0.j],
[ 9.+0.j, 10.+0.j, 5.+0.j]])
"""
9.我们如何使用内置函数创建 NumPy 数组?
- 使用“数组”功能创建数组
import numpy as np
np.arange(1, 20, 3)
# Output: array([ 1, 4, 7, 10, 13, 16, 19])
- 创建具有相等线性间距的阵列
import numpy as np
np.linspace(0, 1, 4 )
# Output : array([0\. , 0.33333333, 0.66666667, 1\. ])
- 创建固定形状的零数组
import numpy as np
np.zeros((4, 5))
# Output:
"""
array([[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.]])
"""
- 创建一个固定形状的数组
import numpy as np
np.ones((4, 5))
# Output
"""
array([[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.]])
"""
10.举例使用 NumPy 中的通用函数。
import numpy as np
first_array = np.arange(1, 5)
second_array = np.arange(6, 10)
first_array, second_array
# Output: (array([1, 2, 3, 4]), array([6, 7, 8, 9]))
np.sqrt(first_array)
# Output: array([1\. , 1.41421356, 1.73205081, 2\. ])
np.add(first_array, second_array)
# Output: array([ 7, 9, 11, 13])
11.使用 NumPy 中的np.newaxis
函数创建一个 2D 数组。
import numpy as np
# Create 1D array
first_array = np.array([3, 4, 5, 6, 7])
first_array.shape
# Output: (5,)
# Adding a new axis to our 1D array: with np.newaxis
second_array = first_array[np.newaxis, :]
second_array.shape
# Output: (1, 5)
# Adding another axis to our 2D array: with np.newaxis
third_array = second_array[np.newaxis, :]
third_array.shape
# Output: (1, 1, 5)
12.创建 NumPy 数组,显示np.expand_dims
函数的用法。
import numpy as np
# Creating a 1D array
first_array = np.arange(6)
first_array
# Output: array([0, 1, 2, 3, 4, 5])
first_array.shape
# Output: (6,)
# Adding a new axis to our 1D array at position 0: with np.expand_dims
second_array = np.expand_dims(first_array, axis=0)
second_array
# Output: array([[0, 1, 2, 3, 4, 5]])
second_array.shape
# Output: (1, 6)
# Adding a new axis to our 1D array at position 1: with np.expand_dims
third_array = np.expand_dims(first_array, axis=1)
third_array.shape
# Output: (6, 1)
13.展示一些用 1D、2D 和 3D 数组访问数组值的例子。
- 从 1D 数组中访问元素
import numpy as np
first_array = np.array([25, 30, 35, 40])
first_array[1] # Output: 30
- 从 2D 数组中访问元素
import numpy as np
my_array = np.array([[22, 33, 44, 55], [66, 77, 88, 99]])
# Accessing row 2, element 3
my_array[1, 2] # Output: 88
- 访问 3D 数组中的元素
import numpy as np
my_array = np.array([[[11, 22, 33], [44, 55, 66]], [[77, 88, 99], [100, 111, 122]]])
# Accessing 3rd element of 2nd array of 1st array
my_array[0, 1, 2] # Output: 66
14.显示了一个使用 NumPy 2D 数组的负索引的示例。
import numpy as np
my_array = np.array([[77, 88, 99], [100, 111, 122]])
# Accessing the last element from the first dimension
my_array[0, -1] # Output: 99
15.我们如何知道数组的形状?此外,首先将 1D 阵列重塑为 2D 阵列,然后将 1D 阵列重塑为三维阵列
import numpy as np
my_array = np.arange(16)
my_array
# Output: array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])
# 1D Array
my_array.shape # Output: (16,)
- 将 1D 转换为 2D 数组
my_array.reshape(4, 4)
"""
Output:
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])
"""
- 将 1D 转换为 3D 阵列
# Convert 1D to 3D Array
my_array.reshape(4, 2, 2)
"""
Output:
array([[[ 0, 1],
[ 2, 3]],
[[ 4, 5],
[ 6, 7]],
[[ 8, 9],
[10, 11]],
[[12, 13],
[14, 15]]])
"""
16.展示 NumPy 中复制功能的用法。
import numpy as np
my_array = np.array([14, 15, 16, 17, 18])
my_array_copy = my_array.copy()
my_array[-1] = 100
print(my_array)
print(my_array_copy)
"""
Output:
[ 14 15 16 17 100]
[14 15 16 17 18]
"""
17.展示 NumPy 中视图功能的用法。
view 函数创建一个类似别名的 Numpy 数组,将所有更改复制到新数组中。
import numpy as np
my_array = np.array([14, 15, 16, 17, 18])
my_array_view = my_array.view()
my_array[-1] = 100
print(my_array)
print(my_array_view)
"""
Output:
[ 14 15 16 17 100]
[ 14 15 16 17 100]
"""
18.NumPy 中的 arange 函数是如何使用的?
import numpy as np
my_array = np.arange(5)
my_array
# Output: array([0, 1, 2, 3, 4])
- 范围:用“启动、“停止
my_array = np.arange(1, 10)
my_array
# Output: array([1, 2, 3, 4, 5, 6, 7, 8, 9])
- 范围:用“开始、“停止、“步长
my_array = np.arange(1, 14, 3)
my_array
# Output: array([ 1, 4, 7, 10, 13])
- 量程:负 计数用开始、停止、步长
my_array = np.arange(25, 0, -4)
my_array
# Output: array([25, 21, 17, 13, 9, 5, 1])
19.给出在 NumPy 中迭代 1D 和 2D 数组的例子。
- 1D 阵列迭代
import numpy as np
my_array = np.arange(5)
for eachItem in my_array:
print(eachItem)
"""
Output:
0
1
2
3
4
"""
- 2D 阵列迭代
import numpy as np
my_array = np.array([[14, 15, 16], [17, 18, 19]])
for eachItem in my_array:
print(eachItem)
"""
Output:
[14 15 16]
[17 18 19]
"""
- 迭代 2D 数组中的每个标量项
import numpy as np
my_array = np.array([[14, 15], [17, 19]])
for each in my_array:
for eachItem in each:
print(eachItem)
"""
Output:
14
15
17
19
"""
20.我们如何用 nditer()函数迭代?
import numpy as np
my_array = np.array([[12, 13], [14, 15]])
for each_scalar_item in np.nditer(my_array):
print(each_scalar_item)
"""
Output:
12
13
14
15
"""
21.展示 nditer()函数提供步长的用法。
import numpy as np
my_array = np.array([[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]])
for eachItem in np.nditer(my_array[:, ::3]):
print(eachItem)
"""
Output:
0
3
5
8
"""
22.举一个使用 ndenumerate()函数的例子。
import numpy as np
my_array = np.array([[12, 13], [14, 15]])
for index, eachItem in np.ndenumerate(my_array):
print(index, eachItem)
"""
Output:
(0, 0) 12
(0, 1) 13
(1, 0) 14
(1, 1) 15
"""
23.如何在 NumPy 中使用 concatenate 函数连接两个数组?
import numpy as np
first_array = np.array([1, 2, 3])
second_array = np.array([4, 5, 6])
concatenated_array = np.concatenate((first_array, second_array))
concatenated_array
# Output: array([1, 2, 3, 4, 5, 6])
24.用 stack 函数连接两个 NumPy 数组。
import numpy as np
first_array = np.array([1, 2, 3])
second_array = np.array([4, 5, 6])
stacked_array = np.stack((first_array, second_array))
stacked_array
"""
Output:
array([[1, 2, 3],
[4, 5, 6]])
"""
25.我们如何在 NumPy 中使用 where()函数?
- 搜索数组中包含值 10 的所有索引
import numpy as np
my_array = np.array([10, 20, 30, 10, 40, 50, 60, 10])
search_indexes_for_ten = np.where(my_array == 10)
search_indexes_for_ten
# Output: (array([0, 3, 7], dtype=int64),)
- 搜索所有值为偶数的索引
import numpy as np
my_array = np.array([10, 11, 12, 15, 21, 26])
search_indexes_for_even = np.where(my_array % 2 == 0)
search_indexes_for_even
# Output: (array([0, 2, 5], dtype=int64),)
摘要
这些是 NumPy 库中一些重要的概念和问题。我希望这篇文章有助于很好地了解 NumPy 提供的功能和方法。
参考
NumPy LCM–返回两个数的最小公倍数
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-LCM
读者你好!欢迎来到另一个关于 NumPy 数学函数的教程。在本教程中,我们将通过例子详细研究 NumPy lcm 函数。
你一定在数学课上计算过两个数的 lcm(最小公倍数)。计算它很有趣🙂
现在,让我们看看如何使用 Python 编程语言计算 lcm。让我们开始吧。
什么是 NumPy lcm?
NumPy lcm 是 NumPy 库的数学函数之一,用于计算两个输入数字的 lcm。这里,输入的数字必须是正的。
让我们看看函数的语法。
NumPy lcm 的语法
numpy.lcm(x1 , x2)
这里,x1 和 x2 可以是个单一的数字,也可以是个数字数组。
注意:数字 x1 和 x2 不能是浮点数字。
使用 NumPy lcm
让我们编写一些代码来处理 numpy.lcm()方法,并看看如何使用它。
单个数字的 NumPy lcm
import numpy as np
print("The lcm of 3 and 15 is:",np.lcm(3 , 15))
print("The lcm of 12 and 44 is:",np.lcm(12 , 44))
print("The lcm of 3 and 9 is:",np.lcm(3 , 9))
print("The lcm of 120 and 200 is:",np.lcm(120,200))
输出
The lcm of 3 and 15 is: 15
The lcm of 12 and 44 is: 132
The lcm of 3 and 9 is: 9
The lcm of 120 and 200 is: 600
输出非常明显。现在,让我们看看如何计算两个 NumPy 数组的 lcm。
带有 NumPy 数组的 NumPy lcm
import numpy as np
a = np.array((12,44,78,144,10000))
b = np.array((24,54,18,120,100))
print("Input Arrays:\n",a,"\n",b)
print("The lcm values:\n",np.lcm(a , b))
输出
Input Arrays:
[ 12 44 78 144 10000]
[ 24 54 18 120 100]
The lcm values:
[ 24 1188 234 720 10000]
从两个 NumPy 数组中各选取一个元素,并计算它们的 lcm。
这就是关于 NumPy lcm 函数的全部内容,这个函数很容易理解,也很容易使用。敬请关注更多此类文章。
参考
NumPy linalg . det–计算给定数组的行列式
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-linalg-det
你好,欢迎来到这个关于 Numpy linalg.det 的教程。在本教程中,我们将学习 NumPy linalg.det() 方法,也将看到许多关于相同的例子。让我们开始吧!
也查:Numpy linalg . EIG——计算一个方阵的特征值和右特征向量
什么是 numpy.linalg.det?
NumPy 中的numpy.linalg.det()
方法用于计算给定方阵的行列式。
如果我们有一个形式为 2×2 的矩阵:
2×2 Array
它的行列式计算如下:
2×2 Array Determinant
对于像这样的 3×3 矩阵
3×3 Array
行列式的计算如下:
3×3 Array Determinant
同样,我们可以计算高阶数组的行列式。
NumPy linalg.det 的语法
numpy.linalg.det(a)
- 参数: 一个,一个 MxM 数组。要计算行列式的输入数组。
- 返回:的行列式 a 。
NumPy linalg.det 示例
让我们看一些 NumPy linalg.det 函数的例子来了解它是如何工作的。
1.在 2×2 阵列上使用 NumPy linalg.det
import numpy as np
arr = [[2, 1], [3, 5]]
# using np.linalg.det() method to compute the determinant
print("array = ", arr)
print("Determinant of array = ", np.linalg.det(arr))
det = 5*2 - 3*1
print("Determinant of array using manual calculation = ", det)
输出:
array = [[2, 1], [3, 5]]
Determinant of array = 6.999999999999999
Determinant of array using manual calculation = 7
在带有负数的 2×2 数组上使用 NumPy linalg.det
import numpy as np
arr = [[-5, 2], [-4, 8]]
# using np.linalg.det() method to compute the determinant
print("array = ", arr)
print("Determinant of array = ", np.linalg.det(arr))
det = (-5*8) - (-4*2)
print("Determinant of array using manual calculation = ", det)
输出:
array = [[-5, 2], [-4, 8]]
Determinant of array = -32.0
Determinant of array using manual calculation = -32
3×3 阵列的 NumPy 线性代数计算
import numpy as np
arr = [[2, 1, 3], [5, 3, 4], [1, 0, 1]]
# using np.linalg.det() method to compute the determinant
print("array = ", arr)
print("Determinant of array = ", np.linalg.det(arr))
det = 2*(3*1 -0*4) -1*(5*1 - 1*4) + 3*(5*0 - 3*1)
print("Determinant of array using manual calculation = ", det)
输出:
array = [[2, 1, 3], [5, 3, 4], [1, 0, 1]]
Determinant of array = -4.0
Determinant of array using manual calculation = -4
在上述所有示例中,我们使用numpy.linalg.det
方法计算行列式,并使用手动方法计算行列式,即通过上述公式。通过这一点,我们可以得出结论,两种方法返回相同的答案。
结论
仅此而已!在本教程中,我们学习了 Numpy linalg.det 方法,并使用该方法练习了不同类型的示例。
如果你想了解更多关于 NumPy 的知识,请随意浏览我们的 NumPy 教程。
参考
计算一个正方形数组的特征值和右特征向量
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-linalg-EIG
numpy linalg.eig 函数是一个强大的数学工具,使用户能够计算一个正方形数组的特征值和右特征向量。科学家和数学家在从物理和工程到经济和金融的各个领域都使用这个函数。
通过利用这一功能,用户可以深入了解系统的底层结构,并发现变量之间的关系。在本文中,我们将探讨什么是特征值和特征向量,以及 numpy linalg.eig 函数如何计算它们。
什么是特征值和特征向量?
特征值是与矩阵的线性方程相关的唯一标量值。特征值告诉我们一个特定的数据值在一个特定的方向上有多少方差。方向主要由特征向量给出。特征向量是非零向量,经过线性变换后,它最多可以被一个标量改变。
特征值和特征向量有什么用?
需要特征值和特征向量来压缩数据和移除或减少维度空间。
计算特征值和特征向量的必要条件
要计算特征值和特征向量的矩阵必须是方阵,即矩阵的维数必须是“nXn”的形式,其中 n =行数=列数。
Numpy linalg 库和 linalg.eig()函数
numpy 线性代数库 numpy linalg 包含一系列函数,使复杂的线性代数计算变得更加容易。
linalg.eig()函数的语法
下面给出了函数的语法,其中 x 是初始参数或输入:
linalg.eig(x)
numpy linalg . EIG()函数的参数
下面给出了该函数所需的参数:
输入–x : array
->要计算特征值和右特征向量的初始方阵。
输出--
y : array
- >特征值按其重数无序重复。数组的类型是复数,除非复数部分为零,在这种情况下,返回类型是实数。
z : array
- >列 z[:,i]对应特征值 y[i]的单位特征向量。
如何使用 numpy linalg.eig()函数
第一步是安装 numpy 包,如果你还没有安装的话。运行以下代码在您的系统中安装 numpy。
pip install numpy
接下来,将库导入到您的项目中,然后按照给出的示例进行操作。
示例 1–计算预定义矩阵的特征值和特征向量
这个代码计算预定义矩阵的特征值和特征向量。它首先从 numpy 导入必要的模块 numpy(作为 py)和 linalg。然后定义一个矩阵为 x,接下来使用 linalg.eig()函数计算矩阵的特征值和特征向量,并存储在变量 y 和 z 中,最后显示计算出的特征值和特征向量。
import numpy as py #importing required modules
from numpy import linalg as L #importing the linalg function
x=[[1,6],[4,9]] #pre defined matrix
y, z = L.eig(x) #computing the eigenvalues and eigenvectors
#displaying the values
print("the eigenvalues are:",y)
print("the eigenvectors are:",z)
输出:
the eigenvalues are: [-1.32455532 11.32455532]
the eigenvectors are: [[-0.93246475 -0.50245469]
[ 0.36126098 -0.86460354]]
示例 2–计算矩阵的特征值和特征向量
获取用户输入的矩阵并计算特征值和特征向量。这段代码被设计成接受用户输入的矩阵,计算它的特征值和特征向量,然后显示结果。它使用 NumPy 和 linalg 模块来执行计算。首先要求用户输入矩阵的行数和列数。如果行数不等于列数,将显示一条错误消息。然后提示用户逐行输入矩阵的值。一旦输入了矩阵,就会显示出来,然后使用 linalg.eig()函数计算特征值和特征向量。最后,显示结果。
#importing the required modules
import numpy as py
from numpy import linalg as L
#taking user input
row = int(input("Enter the number of rows:"))
col= int(input("Enter the number of columns:"))
print("NOTE!! The number of rows should be equal to the number of columns")
# Initializing the required matrix
x = []
print("enter the values rowwise:")
# For user input
for i in range(row): # loop for row entries
b =[]
for j in range(col): # loop for column entries
b.append(int(input()))
x.append(b)
# For displaying the matrix
print("The matrix is as follows:")
print("[")
for i in range(row):
for j in range(col):
print(x[i][j], end = " ")
print()
print("]")
y, z = L.eig(x) #computing the values and vectors
#displaying the result
print("the eigenvalues are:",y)
print("the eigenvectors are:",z)
输出:
Enter the number of rows:2
Enter the number of columns:2
NOTE!! The number of rows should be equal to the number of columns
enter the values rowwise:
1
-1
-1
1
The matrix is as follows:
[
1 -1
-1 1
]
the eigenvalues are: [2\. 0.]
the eigenvectors are: [[ 0.70710678 0.70710678]
[-0.70710678 0.70710678]]
特征值和特征向量的缺点
- 特征值和特征向量只适用于线性变换,所以不能用来解决非线性问题。
- 它们只能用来研究线性变换,不能用来研究非线性变换。
- 计算给定矩阵的特征值和特征向量可能是困难的,并且计算可能是耗时的。
- 特征向量通常不代表关于数据集的最直观或最有意义的信息。
如果矩阵的特征向量是线性相关的,则表明存在一个代数重数大于几何重数的特征值。在这种情况下,结果会有缺陷。要了解更多关于特征值的多重性,点击这里。
结论:
eig 函数是计算方阵的特征值和右特征向量的强大工具。通过使用该函数,科学家和数学家可以深入了解系统的底层结构,并发现变量之间的关系。
这可以帮助他们压缩数据,减少维度空间。然而,特征值和特征向量仅适用于线性变换,并且可能难以计算,因此用户在使用该函数时必须确保理解其局限性。
NumPy linalg.matrix_power:计算方阵的幂
原文:https://www.askpython.com/python-modules/numpy/numpy-linalg-matrix_power
在本教程中,我们将学习如何在线性代数中使用 NumPy 模块中的 Python 中的 linalg.matrix_power 方法来计算矩阵的给定幂。
numpy . linalg . matrix _ power()方法用于将方阵提升到整数 n 次幂
让我们先看看函数的语法。
也查:Numpy linalg . EIG——计算一个方阵的特征值和右特征向量
numpy.linalg.matrix_power 的语法
numpy.linalg.matrix_power(a, n)
- 参数:
- 一个,一个 MxM 数组。输入矩阵的幂。
- n ,整数,幂或指数。它可以是正数、负数或零。
- 回报: 一**n 。返回的矩阵与 a 的形状相同。如果 n 是正数或者零,那么返回类型是整数。如果 n 为负,那么返回类型为 float。
- 引发: LinAlgError 对于非方阵或者(对于负幂)其逆无法计算的矩阵。
注意:如果一个矩阵的行列式为零,那么它的逆就无法计算。
这个函数非常类似于numpy.power(n, p)
函数,它采用两个参数,一个数字 n 和一个幂 p ,并将 n 提升到幂 p 。
numpy.linalg.matrix_power 示例
现在让我们从 numpy linalg 矩阵幂方法的几个例子开始。
使用 numpy.linalg.matrix_power 的正幂
import numpy as np
matrix = [[2, 5], [1, 3]]
# calculating the matrix power
mat_power_2 = np.linalg.matrix_power(matrix, 2)
mat_power_3 = np.linalg.matrix_power(matrix, 3)
print("Matrix = \n", matrix,
"\nMatrix power 2 = \n", mat_power_2,
"\nMatrix power 3 = \n", mat_power_3)
输出:
Matrix =
[[2, 5], [1, 3]]
Matrix power 2 =
[[ 9 25]
[ 5 14]]
Matrix power 3 =
[[ 43 120]
[ 24 67]]
矩阵的 2 次幂通过矩阵乘以自身来计算,如下所示:
Step 1
Step 2
Step 3
Step 4 – Final result of matrix power 2
以上矩阵是矩阵幂 2 的结果。现在,为了计算矩阵的幂 3,我们可以将矩阵的幂 2 乘以给定的矩阵。也就是说,
Step 1
Step 2
Step 3
Step 4 – Final result of matrix power 3
使用负幂的 numpy.linalg.power()
当我们将一个负幂 n 传递给函数时,它首先计算矩阵的逆矩阵,然后将逆矩阵提升到幂 abs(n)。
对于像这样的 2×2 矩阵:
倒数计算如下:
import numpy as np
matrix = [[2, 5], [1, 3]]
# calculating the matrix power
mat_power = np.linalg.matrix_power(matrix, -2)
print("Matrix = \n", matrix, "\nMatrix power -2 = \n", mat_power)
输出:
Matrix =
[[2, 5], [1, 3]]
Matrix power -2 =
[[ 14\. -25.]
[ -5\. 9.]]
在这个例子中,
其倒数计算如下:
现在,将矩阵的逆矩阵提升到幂 abs(-2),即 2 ,如下所示:
The final result of matrix power -2
将 numpy.linalg.matrix_power 与 0 一起使用
当零作为幂传递给numpy.linalg.matrix_power
函数时,返回一个与输入矩阵形状相同的单位矩阵。
import numpy as np
matrix_1 = [[2, 5], [1, 3]]
matrix_2 = [[4, 2, 5], [1, 8, 3], [6, 0, 2]]
# calculating the matrix power
mat_1_power_0 = np.linalg.matrix_power(matrix_1, 0)
mat_2_power_0 = np.linalg.matrix_power(matrix_2, 0)
print("Matrix 1 = \n", matrix_1,
"\nMatrix 1 power 0 = \n", mat_1_power_0,
"\nMatrix 2 = \n", matrix_2,
"\nMatrix 2 power 0 = \n", mat_2_power_0)
输出:
Matrix 1 =
[[2, 5], [1, 3]]
Matrix 1 power 0 =
[[1 0]
[0 1]]
Matrix 2 =
[[4, 2, 5], [1, 8, 3], [6, 0, 2]]
Matrix 2 power 0 =
[[1 0 0]
[0 1 0]
[0 0 1]]
因为矩阵 1 是 2×2 矩阵,所以输出是 2×2 单位矩阵,类似地,矩阵 2 的输出自乘到 0 是 3×3 单位矩阵。
结论
因此,在本教程中,我们学习了线性代数中用于计算方阵幂的numpy.linalg.matrix_power
函数。我们还看到了各种可能的输入和输出示例。
如果你想了解更多关于 NumPy 的知识,请随意浏览我们的 NumPy 教程。
参考
NumPy 线性代数函数要知道!
原文:https://www.askpython.com/python/numpy-linear-algebraic-functions
读者朋友们,你们好!在本文中,我们将关注 Python 中的 NumPy 线性代数函数。所以,让我们开始吧!🙂
NumPy 模块为我们提供了各种处理和操作数据的功能。它使我们能够在数组数据结构中创建和存储数据。接下来,它为我们提供了各种函数来分析和操作数据值。
NumPy 线性代数函数列表
1。NumPy 模块提供的矩阵函数
通过 NumPy 模块,我们可以在数组结构上执行线性代数矩阵函数。
在本主题课程中,我们将了解以下功能
- 矩阵的秩:我们可以使用 numpy.linalg.matrix_rank()函数计算数组的秩。
- 行列式:numpy . linalg . det()函数帮助我们把数组当作一个矩阵来计算它的行列式。
- 求逆:inv()函数使我们能够计算数组的逆。
- 指数:使用 numpy.linalg.matrix_power()函数,我们可以对矩阵取幂值,并获取结果。
举例:
在下面的例子中,我们使用 numpy.array()函数创建了一个数组。此外,我们对阵列执行了上述线性代数运算,并打印了结果。
import numpy
x = numpy.array([ [2, 8, 7],
[6, 1, 1],
[4, -2, 5]])
print("Rank: ", numpy.linalg.matrix_rank(x))
det_mat = numpy.linalg.det(x)
print("\nDeterminant: ",det_mat)
inv_mat = numpy.linalg.inv(x)
print("\nInverse: ",inv_mat)
print("\nMatrix raised to power y:\n",
numpy.linalg.matrix_power(x, 8))
输出:
Rank: 3
Determinant: -306.0
Inverse: [[-0.02287582 0.17647059 -0.00326797]
[ 0.08496732 0.05882353 -0.13071895]
[ 0.05228758 -0.11764706 0.1503268 ]]
Matrix raised to power y:
[[ 85469036 43167250 109762515]
[ 54010090 32700701 75149010]
[ 37996120 22779200 52792281]]
2。数字阵列特征值
NumPy 线性代数函数有 linalg 类,它有 eigh()函数来计算传递给它的数组元素的特征值。
看看下面的语法!
语法:
numpy.linalg.eigh(array)
eigh()函数返回一个复矩阵或实对称矩阵的特征值和特征向量。
举例:
from numpy import linalg as li
x = numpy.array([[2, -4j], [-2j, 4]])
res = li.eigh(x)
print("Eigen value:", res)
输出:
Eigen value: (array([0.76393202, 5.23606798]), array([[-0.85065081+0.j , 0.52573111+0.j ],
[ 0\. -0.52573111j, 0\. -0.85065081j]]))
3。点积
使用 NumPy 线性代数函数,我们可以对标量值和多维值执行点运算。它对一维向量值执行标量乘法。
对于多维数组/矩阵,它对数据值执行矩阵乘法。
语法:
numpy.dot()
举例:
import numpy as np
sc_dot = np.dot(10,2)
print("Dot Product: ", sc_dot)
vectr_x = 1 + 2j
vectr_y = 2 + 4j
vctr_dot = np.dot(vectr_x, vectr_y)
print("Dot Product: ", vctr_dot)
输出:
Dot Product: 20
Dot Product: (-6+8j)
4。用 NumPy 模块解线性方程组
有了 NumPy 线性代数函数,我们甚至可以执行计算和求解线性代数标量方程。 numpy.linalg.solve()函数用公式 ax=b 求解数组值。
举例:
import numpy as np
x = np.array([[2, 4], [6, 8]])
y = np.array([2, 2])
print(("Solution of linear equations:",
np.linalg.solve(x, y)))
输出:
('Solution of linear equations:', array([-1., 1.]))
结论
如果你遇到任何问题,欢迎在下面评论。更多关于 Python 编程的文章,请继续关注我们。在那之前,学习愉快!!🙂
Numpy linspace()方法
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-linspace-python
在本文中,我们将看看 Numpy linspace()
功能。 Python NumPy 模块有不同的函数来操作数组并对其中的元素执行操作。
NumPy linspace()入门
NumPy 的 numpy.linspace() 函数基本上是用来在提供的数范围之外生成一个线性序列。
通常, numpy.arange()
函数可以用来生成一定范围内的数列。numpy.arange()函数的问题是,如果向它提供一个浮点类型参数,它会导致结果的精度损失。
因此,numpy.linspace()函数可以优先于它。
语法:
numpy.linspace(start, stop, num = value, endpoint = True/False, retstep = False/True, dtype = None)
start
:该值表示序列的起点。默认值被视为零(0)。stop
:该值表示序列的端点。num
:表示开始和停止范围之间要产生的步数或元素。
举例:
import numpy
inp = numpy.linspace(1, 3, 5)
print('Linear Sequence:\n',inp)
print('Length of the sequence:\n')
print(len(inp))
输出:
Linear Sequence:
[1\. 1.5 2\. 2.5 3\. ]
Length of the sequence:
5
Numpy linspace()的 retstep 参数
retstep
参数基本上是一个布尔值。如果提供为 True ,则指定生成序列的每个元素之间的步长。然后,它产生一个作为元组的序列。
举例:
import numpy
inp = numpy.linspace(1, 3, num=5, retstep=True)
print(inp)
print("Length of the sequence:",len(inp))
如上所述,当 retstep = True 作为参数传递给 linspace()方法时,它会生成一个 tuple 作为输出。所以元组的长度将是 2,而不是 6 !
输出:
(array([1\. , 1.5, 2\. , 2.5, 3\. ]), 0.5)
Length of the sequence: 2
linspace()方法的端点参数
endpoint
参数是一个布尔值。如果设置为假,则排除结果中序列的最后一个数字。端点的默认值为真。
举例:
import numpy
inp = numpy.linspace(1, 3, 5, endpoint=False)
print('Sequence from 1 to 3:', inp)
输出:
Sequence from 1 to 3: [1\. 1.4 1.8 2.2 2.6]
linspace()方法的轴参数
**axis**
参数基本上允许用户向提供一个轴,以便生成的序列沿着存储。只有当数据的起点和终点为数组类型时,轴参数才适用。
举例:
import numpy
inp1 = numpy.array([[10, 20, 30], [70, 40, 50]])
inp2 = numpy.array([[1, 3, 9], [5, 7, 11]])
op1 = numpy.linspace(inp1, inp2, 4, axis=0)
print(op1)
op2 = numpy.linspace(inp1, inp2, 2, axis=1)
print(op2)
当轴= 0 时,从第一个提供的轴获取序列限制。子阵列对 [10, 20, 30] and [1, 3, 9]
连同 [70, 40, 50] and [5, 7, 11]
被认为是从 inp1 到 inp2 导出序列的限制。
当轴= 1 时,使用列序列生成给定范围内的元素。
输出:
[[[10\. 20\. 30\. ]
[70\. 40\. 50\. ]]
[[ 7\. 14.33333333 23\. ]
[48.33333333 29\. 37\. ]]
[[ 4\. 8.66666667 16\. ]
[26.66666667 18\. 24\. ]]
[[ 1\. 3\. 9\. ]
[ 5\. 7\. 11\. ]]]
[[[10\. 20\. 30.]
[ 1\. 3\. 9.]]
[[70\. 40\. 50.]
[ 5\. 7\. 11.]]]
带有 Python matplotlib.pylab 模块的 NumPy linspace()函数
NumPy linspace() 函数可以借助来自 matplotlib 库的 pylab 来表示理解。
举例:
import numpy
import pylab
inp1 = numpy.linspace(10, 20, 5, endpoint = False)
inp2 = numpy.linspace(10, 20, 5, endpoint = False)
pylab.plot(inp1, inp2, '*')
输出:
NmpPy Linspace
结论
在本文中,我们已经了解了 numpy.linspace() 方法的工作原理。
参考
Python numpy.linspace()方法
numpy log10–返回输入数组以 10 为底的对数,按元素排序。
原文:https://www.askpython.com/python-modules/numpy/numpy-log10
在本文中,我们将解决一个简单的问题“如何获得一个输入数组的以 10 为底的对数,以元素为单位”。我们将获得数组中元素的以 10 为底的对数值。通过分析下面的例子,你可以更好地理解。
让我们假设一个数组,input[2.35,0,0.36,1,5.69,1000,10]——我们需要以新数组的形式获得这个数组的每个元素对应的对数值,如[ 0.37106786 -inf -0.4436975 0。0.75511227 3.1.] .
- log [10] (2.35) = 0.37106786
- log [10] (0) = -inf
- log [10] (0.36) = -0.4436975
- log [10] (1) = 0.0
- log [10] (5.69) = 0.75511227
- log [10] (1000) = 3.0
- log [10] (10) = 1.0
在进入我们的代码片段之前,让我们快速看一下下面!
理解数字对数方法
Python NumPy 库为不同的数学运算提供了一些内置方法。其中, Numpy.log() 是对数组进行对数运算最常用的函数之一。这个方法为我们的输入数组(因为我们使用了 NumPy 模块)中的所有元素返回各自的对数值、基数 e = 2.71。
Numpy 还提供了执行以 10 为底的对数(NumPy.log10()
)和以 2 为底的对数(NumPy.log2()
)运算的单独方法.
今天,我们将在今天的代码片段中学习如何实现Numpy.log10()
方法。
定义域 Numpy 对数函数位于正实数集合和实数集合中的范围之间。让我们快速浏览一下下面的内容,以理解我们函数的语法。
Numpy.log10()的语法
#syntax for log base 10
numpy.log10(x, out=None, where=True, casting='same_kind', order='K', subok : [bool, datatype])
#syntax for log base2
numpy.log2(x, out=None, where=True, casting='same_kind', order='K', subok : [bool, datatype])
上述代码片段中使用的参数如下:
- x: 它可以是包含弧度值的变量,也可以是包含某个值的数组
- out: 存储结果的位置。如果提供了,它必须具有与输入 x 相似的形状。如果没有提供或没有提供,则返回新的值或结果。这是可选的。
- 当条件为真时,我们必须得到我们的结果或输出;当条件为假时,我们将得不到任何结果。这是可选的。y 默认其值为真。
- casting='same_kind': 表示只允许 float64 到 float32 的值或结果。该函数在此范围或数据类型中呼喊 cast 值。
- order = 'K': 它总是以 K 排序的形式产生一个输出数组。(注意:有四种类型的订单:{‘K’,‘C’,‘F’,‘A’})。这是可选的。
- subok:【bool,datatype】是否生成结果的子类。如果为真,则提供子类的名称。它返回一个与给定数组具有相同形状和类型的数组。也是可选的。
使用 Numpy.log10()方法
现在,我们将依次进入代码片段,让您解释如何实现我们的方法。今天我们将使用我们的 google collab 进行编码。你们一定知道 google collab 也提供了最好的 python 平台。不要迟到。让我们开始吧。
步骤 1:导入数字
在这一步,我们将把使用NumPy.log10()
功能的Numpy
模块导入到我们的计算机中。如果不导入它们的依赖项,即“Numpy 模块”,我们就无法实现任何 NumPy 方法。
import numpy
步骤 2:创建数组以获取对数值
在这一步中,我们将创建一个包含要获取对数值的数组。
y = numpy.array([2.35, 0, 0.36, 1, 5.69, 1000, 10])
如果用户需要手动向数组中输入值。他/她可以遵循下面的代码片段。
# creating x array
x = []
n = int(input("Enter the number of values you want to enter : "))
for i in range(0, n):
value = int(input())
x.append(value)
执行上面的代码片段将让用户输入他想要连接的值的数量。接下来,用户可以将单个值输入数组,如下所示。
Enter the number of values you want to enter : 3
1
2
3
[1, 2, 3]
步骤 3:实现 Numpy.log10()方法
在这一步中,我们将如下实现我们的函数,并传递在步骤 2 中创建的两个数组。
a = numpy.log10(y)
b = numpy.log10(x)
步骤 4:获取输出并进行分析
在这最后一步,我们将打印分别加载到变量 a 和 b 中的输出。
print(a)
print(b)
#output
[ 0.37106786 -inf -0.4436975 0\. 0.75511227 3\. 1\. ]
[0\. 0.30103 0.47712125]
您可以看到,该函数返回一个数组,其中包含输入数组中所有元素各自的对数值。这样,Numpy.log10()
方法就成功实现了。
结论
今天,我们学习了如何使用 numpy.log10()方法获得一个以 10 为底的值的对数。我们尝试用两个数组作为例子来帮助更好地理解这个概念。如果你有兴趣了解更多关于 numpy 的知识,别忘了看看我们的 Numpy 教程列表。
NumPy mat mul–两个数组的矩阵乘积
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-matmul
你好,欢迎来到这个关于 Numpy matmul 的教程。在本教程中,我们将学习 NumPy matmul() 方法,也将看到许多关于这个方法的例子。让我们开始吧!
什么是 NumPy matmul?
NumPy 中的matmul()
方法返回两个数组的矩阵乘积。这里,输入参数只能是数组,不允许有标量值。输入 be 可以是 1 维数组、2 维数组或两者的组合,或者也可以是 n 维数组。
我们将在本教程接下来的章节中看到这些例子。
NumPy matmul 的语法
让我们来看看matmul
函数的语法。
numpy.matmul(x1, x2, out=None)
| 参数 | 描述 | 必需/可选 |
| x1 | 输入数组 1。 | 需要 |
| x2 | 输入数组 2。 | 需要 |
| 在外 | 放置结果的替代输出数组。它必须具有与预期输出相同的形状。 | 可选择的 |
如果 x1 是一个n×m矩阵, x2 是m×l矩阵,那么相乘后得到的矩阵将是一个n×l矩阵。
返回:
x1nadx2的矩阵乘积。如果 x1 和 x2 都是一维数组,那么结果将是一个标量值。
如果 x1 的最后一个维度与 x2 的倒数第二个维度不匹配,或者如果一个标量值作为参数传递,则引发:
。
使用 NumPy matmul 的示例
现在让我们看几个例子来更好地理解这个函数。
当两个输入都是一维数组时使用 NumPy matmul
import numpy as np
a = [1, 5, 3]
b = [10, 2, 4]
# using matmul method to compute the matrix product
ans = np.matmul(a, b)
print("a =", a, "\nb =", b)
print("Result =", ans)
输出:
a = [1, 5, 3]
b = [10, 2, 4]
Result = 32
这里,因为两个输入参数都是一维数组,所以它们的矩阵乘法会产生一个标量值,计算如下
ans = 1*10 + 5*2 + 3*4 = 10 + 10 + 12 = 32
当两个输入都是二维数组时
import numpy as np
a = [[2, 6], [8, 4]]
b = [[3, 1], [5, 10]]
# using matmul method to compute the matrix product
ans = np.matmul(a, b)
print("a =", a, "\nb =", b)
print("Result =\n", ans)
输出:
a = [[2, 6], [8, 4]]
b = [[3, 1], [5, 10]]
Result =
[[36 62]
[44 48]]
由于两个输入都是 2×2 矩阵,因此结果也是 2×2 矩阵。矩阵乘法计算如下
ans[0][0] = a[0][0]*b[0][0] + a[0][1]*b[1][0] = 2*3 + 6*5 = 6 + 30 = 36
ans[0][1] = a[0][0]*b[0][1] + a[0][1]*b[1][1] = 2*1 + 6*10 = 2 + 60 = 62
ans[1][0] = a[1][0]*b[0][0] + a[1][1]*b[1][0] = 8*3 + 4*5 = 24 + 20 = 44
ans[1][1] = a[1][0]*b[0][1] + a[1][1]*b[1][1] = 8*1 + 4*10 = 8 + 40 = 48
当一个输入是一维数组而另一个是二维数组时使用 NumPy matmul
import numpy as np
a = [10, 20]
b = [[8, 9], [3, 1]]
# using matmul method to compute the matrix product
ans = np.matmul(a, b)
print("a =", a, "\nb =", b)
print("Matrix product of a and b =", ans)
输出:
a = [10, 20]
b = [[8, 9], [3, 1]]
Matrix product of a and b = [140 110]
矩阵 a 的形状是 1×2,而 b 的形状是 2×2,因此得到的矩阵的形状是 1×2。矩阵乘积的计算如下:
ans[0][0] = a[0][0]*b[0][0] + a[0][1]*b[0][1] = 10*8 + 20*3 = 80 + 60 = 140
ans[0][1] = a[0][0]*b[1][0] + a[0][1]*b[1][1] = 10*9 + 20*1 = 90 + 20 = 110
我们也可以颠倒 matmul 函数中矩阵的顺序,如下所示:
import numpy as np
a = [10, 20]
b = [[8, 9], [3, 1]]
# using matmul method to compute the matrix product
ans = np.matmul(b, a)
print("a =", a, "\nb =", b)
print("Matrix product of b and a =", ans)
输出:
a = [10, 20]
b = [[8, 9], [3, 1]]
这里,输出计算如下:
ans[0][0] = b[0][0]*a[0][0] + b[1][0]*a[0][1] = 8*10 + 9*20 = 80 + 180 = 260
ans[0][1] = b[0][1]*a[0][0] + b[1][1]*a[0][1] = 3*10 + 1*20 = 30 + 20 = 50
结论
仅此而已!在本教程中,我们学习了 Numpy matmul 方法,并使用相同的方法练习了不同类型的示例。如果你想了解更多关于 NumPy 的信息,请随意浏览我们的 NumPy 教程。
参考
如何在数组上使用 Numpy Maximum?
原文:https://www.askpython.com/python-modules/numpy/numpy-maximum-on-arrays
更重要的事情!这些实体为偏向数据集的结果播下了种子,扭曲了它们的平均值,并给观众一种甚至不接近现实存在的幻觉。在本文中,我们将研究使用 Python 中的 numpy 库中的 maximum( ) 函数从数组中的给定元素中找出最大值的一系列步骤。在开始之前,让我们从理解它的语法开始。
最大值()函数的语法
下面是由强制和可选元素组成的基本构造,这些元素是为来自 numpy 库的 maximum( ) 函数的有效运行而提供的。
numpy.maximum(x1, x2, out=None, *, where=True, dtype=None)
在哪里,
- x1,x2—输入数组,保存要查找最大值的元素
- out—一个可选的构造,默认情况下设置为 none ,但可用于将结果存储在所需的数组中,该数组的长度与输出的长度相同
- ***–kwargs 或 keyword argument,这是一个可选结构,用于将关键字可变长度的参数传递给函数
- 其中—一个可选构造,当设置为真(默认设置)时,用于计算给定位置的通用函数(ufunc ),当设置为假时,不计算
- dtype—可选结构,用于指定正在使用的数据类型
在一维数组上使用最大值()
让我们通过使用以下代码在 Python 中导入 numpy 库来开始。
import numpy as np
现在让我们构造两个一维数组,确定它们的最大元素数。
ar1 = np.array([[1.2, 3.4, 6.7, 8.9]], dtype = int)
ar2 = np.array([[2.1, 4.3, 5.7, 6.9]], dtype = int)
从上面可以注意到,考虑的数据类型是 int ,所以可以很好地期望输出去掉十进制数。现在是时候使用最大值()函数了!
np.maximum(ar1, ar2, dtype = int)
Calculating the Maximum of One Dimensional Arrays
在 N 维数组上使用maximum()
现在我们已经处理了在一维数组的元素中寻找最大值的问题,让我们在本节中通过使用多维数组(如下所示)来扩展我们的探索,使用 maximum( ) 函数返回它们的最大值元素。
ar1 = np.array([[1.2, 3.4, 6.7, 8.9],
[9.8, 7.6, 5.4, 3.2]], dtype = float)
ar2 = np.array([[2.1, 4.3, 5.7, 6.9],
[9.7, 8.6, 4.5, 1.2]], dtype = float)
np.maximum(ar1, ar2, dtype = float)
Calculating the Maximum of N-Dimensional Arrays
受过训练的眼睛可以观察到与前一部分的输出数组的相似性,即两者都与它们的输入数组具有相同的维数。这给了我们一个如何构造输出数组的线索,如果我们想把结果存储在其他地方的话。
使用中的处的最大值()功能
我们现在开始使用 maximum( ) 函数,在这个函数中,我们还可以通过使用下面演示的 where 选项,有选择地查找限定在数组中特定位置的给定数组元素的最大值。
ar1 = np.array([[1.2, 3.4, 6.7, 8.9],
[9.8, 7.6, 5.4, 3.2]], dtype = float)
ar2 = np.array([[2.1, 4.3, 5.7, 6.9],
[9.7, 8.6, 4.5, 1.2]], dtype = float)
np.maximum(ar1, ar2, where = [True, True, False, True])
上面的代码要求 maximum( ) 函数只返回在所有位置进行比较的输入数组的最大值,除了第三个位置,在第三个位置它运行反向执行。
Results Using the Where Option
结论:
既然我们已经到了这篇文章的结尾,希望它已经详细说明了如何使用 numpy 库的 maximum( ) 函数找到数组元素的最大值。这里有另一篇文章解释了如何在 Python 中使用 numpy 找到数组元素的最小值。AskPython 中还有许多其他有趣的&内容丰富的文章,可能对那些希望提高 Python 水平的人有很大帮助。当你享受这些的时候,再见!
如何在数组上使用 Numpy 最小值?
原文:https://www.askpython.com/python-modules/numpy/numpy-minimum-on-arrays
很容易挑出一个奇怪的!但是当要挑选最小的一个时,特别是当有大量的数据要挑选时,麻烦就来了!为了让我们摆脱这种人类思维所需要的努力和时间的负担,我们在编程语言的计算能力中找到了慰藉。
在本文中,我们将研究使用 Python 中的 numpy 库中的 minimum( ) 函数从数组中的给定元素中找出最小值的一系列步骤。让我们开始理解它的语法。
也读作:【NumPy 闵楠——忽略任何 NaNs 的沿轴数组的最小值
最小值()函数的语法
下面是由强制和可选元素组成的基本构造,这些元素应该放在一起,以便来自 numpy 库的 minimum( ) 函数能够有效运行。
numpy.minimum(x1, x2, out=None, *, where=True, dtype=None)
在哪里,
- x1,x2—输入数组,保存要在其中找到最小值的元素
- out—一个可选的构造,默认情况下设置为 none ,但可用于将结果存储在所需的数组中,该数组的长度与输出的长度相同
- ***–kwargs 或 keyword argument,这是一个可选结构,用于将关键字可变长度的参数传递给函数
- 其中—一个可选构造,当设置为真(默认设置)时,用于计算给定位置的通用函数(ufunc ),当设置为假时,不计算
- dtype—一个可选结构,用于指定正在使用的数据类型
在一维数组上使用最小值()
让我们通过使用以下代码在 Python 中导入 numpy 库来开始。
import numpy as np
下面是一维数组,其中的最小元素将被确定。
ar1 = np.array([[1.2, 3.4, 6.7, 8.9]], dtype = int)
ar2 = np.array([[2.1, 4.3, 5.7, 6.9]], dtype = int)
从上面可以注意到,考虑的数据类型是 int ,所以可以很好地期望输出去掉十进制数。现在是时候使用最小值()函数了!
np.minimum(ar1, ar2, dtype = int)
Calculating The Minimum Of One Dimensional Arrays
在 N 维数组上使用 Numpyminimum()
现在让我们通过使用多维数组来扩展我们的 ask,如下所示,使用 minimum( ) 函数返回它们的最小元素。
ar1 = np.array([[1.2, 3.4, 6.7, 8.9],
[9.8, 7.6, 5.4, 3.2]], dtype = float)
ar2 = np.array([[2.1, 4.3, 5.7, 6.9],
[9.7, 8.6, 4.5, 1.2]], dtype = float)
np.minimum(ar1, ar2, dtype = float)
Calculating The Minimum Of N-Dimensional Arrays
类似于上一节的输出数组,这里输出数组的每个位置(与输入数组的维数相同)也用最小值替换。
使用中的处的最小值()功能
还可以通过使用下面演示的 minimum( ) 函数中的 where 选项,有选择地找到只限于数组中特定位置的给定数组元素的最小值。
ar1 = np.array([[1.2, 3.4, 6.7, 8.9],
[9.8, 7.6, 5.4, 3.2]], dtype = float)
ar2 = np.array([[2.1, 4.3, 5.7, 6.9],
[9.7, 8.6, 4.5, 1.2]], dtype = float)
np.minimum(ar1, ar2, where = [False, True, True, True])
上面的代码将 minimum( ) 函数限制为只返回输入数组中除第一个位置之外的所有位置的最小值。
Results Using The Where Option
结论
既然我们已经到了这篇文章的结尾,希望它已经详细说明了如何使用来自 numpy 库的 minimum( ) 函数找到数组元素的最小值。这里有另一篇文章解释了如何在 Python 中使用 numpy 来划分数组中的元素。AskPython 中还有许多其他有趣的&内容丰富的文章,可能对那些希望提高 Python 水平的人有很大帮助。当你享受这些的时候,再见!
NumPy mod——NumPy 中模数运算符的完整指南
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-mod
你好,欢迎来到这个关于 Numpy mod 的教程。在本教程中,我们将学习 NumPy mod() 方法,也将看到许多关于相同的例子。让我们开始吧!
什么是 NumPy mod?
NumPy 中的mod()
方法返回两个给定数组相除的元素余数。Python 中的%
运算符也返回除法的余数,类似于mod()
函数。
我们将在本教程接下来的章节中看到演示该函数用法的例子。
NumPy mod 的语法
numpy.mod(x1, x2, out=None)
| 参数 | 描述 | 必需/可选 |
| x1 (array_like) | 红利数组。 | 需要 |
| x2(类似数组) | 除数数组。 | 需要 |
| 在外 | 放置结果的替代输出数组。它必须具有与预期输出相同的形状。 | 可选择的 |
返回:返回除法的元素余数。如果 x1 和 x2 都是标量,那么结果也是标量值。
例子
现在让我们开始使用 numpy.mod 方法,这样我们可以理解输出。
当两个元素都是标量时
import numpy as np
dividend = 15
divisor = 7
ans = np.mod(dividend, divisor)
print("Dividend =", dividend, "\nDivisor =", divisor)
print(dividend, "%", divisor, "=", ans)
输出:
Dividend = 15
Divisor = 7
15 % 7 = 1
两个元素都是标量的简单情况。72=14,73=21,所以 15 不能被 7 整除,余数在这里是 1。
使用 numpy.mod()对标量和数组求模
import numpy as np
dividend = [13, 8, 16]
divisor = 7
ans = np.mod(dividend, divisor)
print("Dividend =", dividend, "\nDivisor =", divisor)
print(dividend, "%", divisor, "=", ans)
输出:
Dividend = [13, 8, 16]
Divisor = 7
[13, 8, 16] % 7 = [6 1 2]
在这种情况下,被除数数组中的所有元素都被除数一个接一个地除,并且每个除法的余数都存储在结果数组中。
输出计算如下:
13% 7 = 6
8% 7 = 1
16% 7 = 2
我们也可以如下反转元素:
import numpy as np
dividend = 7
divisor = [7, 5, 3]
ans = np.mod(dividend, divisor)
print("Dividend =", dividend, "\nDivisor =", divisor)
print(dividend, "%", divisor, "=", ans)
输出:
Dividend = 7
Divisor = [7, 5, 3]
7 % [7, 5, 3] = [0 2 1]
这里,除数数组中的每个元素除以被除数即 7,余数存储在输出数组中。因此,输出被计算为:
7%7 = 0
7%5 = 2
7%3 = 1
当两个元素都是一维数组时的模数
import numpy as np
dividend = [30, 58, 35]
divisor = [5, 9, 4]
ans = np.mod(dividend, divisor)
print("Dividend =", dividend, "\nDivisor =", divisor)
print(dividend, "%", divisor, "=", ans)
输出:
Dividend = [30, 58, 35]
Divisor = [5, 9, 4]
[30, 58, 35] % [5, 9, 4] = [0 4 3]
这里,两个数组中相同位置的元素进行除法运算,并计算余数。即被除数[0]除以除数[0]等等。这只不过是元素级的划分。
输出计算如下:
dividend[0] % divisor[0] = 30%5 = 0
dividend[1] % divisor[1] = 58%9 = 4
dividend[2] % divisor[2] = 35%4 = 3
当两个元素都是二维数组时
import numpy as np
dividend = [[16, 15], [24, 23]]
divisor = [[4, 7], [10, 9]]
ans = np.mod(dividend, divisor)
print("Dividend =", dividend, "\nDivisor =", divisor)
print(dividend, "%", divisor, "=\n", ans)
输出:
Dividend = [[16, 15], [24, 23]]
Divisor = [[4, 7], [10, 9]]
[[16, 15], [24, 23]] % [[4, 7], [10, 9]] =
[[0 1]
[4 5]]
与上面 1 维数组的例子相同,这里也进行元素式除法,余数计算如下:
第 1 行:
dividend[0][0] % divisor[0][0] = 16%4 = 0
dividend[0][1] % divisor[0][1] = 15%7 = 1
第 2 行:
dividend[1][0] % divisor[1][0] = 24%10 = 4
dividend[1][1] % divisor[1][1] = 23%9 = 5
结论
仅此而已!在本教程中,我们学习了 Numpy mod 方法,并使用该方法练习了不同类型的示例。如果你想了解更多关于 NumPy 的信息,请随意浏览我们的 NumPy 教程。
参考
NumPy 乘法——以简单的方式说明
原文:https://www.askpython.com/python-modules/numpy/numpy-multiply
嘿大家好!欢迎来到另一个关于 NumPy 函数的教程。在本教程中,我们将详细探讨 NumPy 乘法函数。
我们在日常生活中都会做乘法运算。无论是我们的数学课还是店主为了记录商店里的商品而做的计算。今天我们将看到如何使用 python 编程将两个数字或两个数字数组相乘。
让我们开始吧。
也读作:NumPy linalg . det——计算给定数组的行列式
什么是 NumPy 乘法?
NumPy multiply 是 NumPy 库的数学函数之一,它将传递给函数的输入相乘。
让我们来看看函数的语法。
NumPy 乘法语法
numpy.multiply(x1 , x2)
这里,输入 x1
和 x2
可以是标量数字,也可以是数字的 NumPy 数组。
使用 NumPy 乘法
我们来做一些 python 编程吧。
与标量值相乘
# Importing the NumPy module
import numpy as np
a = 5
b = 4
print("The product of 5 and 4 is:",np.multiply(a , b))
输出
The product of 5 and 4 is: 20
我们首先使用上面代码片段中的 import
语句导入 NumPy 库。在 print
语句中,调用函数 np.multiply(a,b)
,其中 a 和 b 作为输入传递给函数。
在这个代码片段中,输出也是一个标量值。
NumPy 乘以一个 NumPy 数组和一个标量值
# Importing the NumPy module
import numpy as np
# Creating the 2-D array
a = np.array([[2 , 4 , 7] , [5 , 10 , 15]])
b = 10
c = np.multiply(a , b)
print("Input Array:\n",a)
print("After multiplying 10 to each value of the Input Array:\n",c)
输出
Input Array:
[[ 2 4 7]
[ 5 10 15]]
After multiplying 10 to each value of the Input Array:
[[ 20 40 70]
[ 50 100 150]]
在上面的例子中,使用函数 np.array()
创建了一个大小为 2×3 的二维数组。在下面几行中,通过将 a
和 b
作为参数传递给函数来调用函数 np.multiply(a,b)
,其中 a
是 NumPy 数组, b
保存标量值 10。
在输出中,函数 np.multiply(a,b)
将 NumPy 数组的所有值乘以 10。
NumPy 乘以两个相同大小的 NumPy 数组
import numpy as np
# Creating 2x2 array
a = np.array([[2 , 5] , [1 , 4]])
b = np.array([[9 , 5] , [21 , 34]])
# Using the multiply function
c = np.multiply(a , b)
# Printing the values
print("Array 1:\n",a)
print("Array 2:\n",b)
print("Output array:\n",c)
输出
Array 1:
[[2 5]
[1 4]]
Array 2:
[[ 9 5]
[21 34]]
Output array:
[[ 18 25]
[ 21 136]]
在本例中,使用函数 np.array()
创建了两个大小为 2×2 的 NumPy 数组,并存储在变量 a
和 b
中。接下来,通过将 a
和 b
作为参数来调用函数np.multiply(a,b)
,其中 a
和 b
是我们之前使用函数np.array()
创建的 NumPy 数组。
在输出中,数组包含两个输入数组中相同位置处的值的乘积。
注意:输出数组与输入数组大小相同。
矩阵和向量相乘
import numpy as np
# Creating a vector or 1-D array
a = np.array((10 , 20 , 30))
# Creating a matrix or 2-D array
b = np.array([[1 , 2 , 4] , [8 , 10 , 16]])
c = np.multiply(a , b)
print("Array 1:\n",a)
print("Array 2:\n",b)
print("Output Array:\n",c)
输出
Array 1:
[10 20 30]
Array 2:
[[ 1 2 4]
[ 8 10 16]]
Output Array:
[[ 10 40 120]
[ 80 200 480]]
这是最有趣的例子。这里,我们创建了一个具有 3 个元素的向量或一维数组,以及一个大小为 2×3 的二维数组或矩阵,即具有 2 行 3 列。在下面几行中,通过传递 a
和 b
作为参数来调用函数 np.multiply(a,b)
,其中 a 是向量,b 是矩阵。
在这种情况下,NumPy 执行广播。它获取向量并将其与矩阵中的每一行相乘。这是可能的,因为向量的元素数与矩阵中的列数相同。
在输出数组中,第行第个元素是通过将向量乘以矩阵的第一行得到的,第行第二个元素是通过将向量乘以矩阵的第二行得到的。
至此,我们完成了本教程的所有示例。您应该尝试将该函数用于您选择的示例,并观察输出。
摘要
在本文中,我们学习了 NumPy 乘法函数,并练习了不同类型的示例。这真的是一个简单易用且易于理解的函数。继续探索更多这样的教程这里。
参考
NumPy nan max–忽略任何 nan 的沿轴数组的最大值
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-nanmax
你好,欢迎来到这个关于 Numpy nanmax 的教程。在本教程中,我们将学习 NumPy nanmax()
方法,也将看到许多关于这个方法的例子。让我们开始吧!
什么是 NumPy nanmax?
在 Python 中, NaN 表示而不是数字。如果我们有一个包含一些 NaN 值的数组,并且想要找到其中的最大值,我们可以使用 NumPy 的nanmax()
方法。
NumPy 中的nanmax()
方法是一个函数,它返回通过忽略数组中的 NaN 值计算的数组元素的最大值。它可以是所有数组元素的最大值、沿行数组元素的最大值或沿列数组元素的最大值。
我们将在本教程的下一节看到每个例子。
NumPy nanmax 的语法
让我们来看看nanmax()
函数的语法。
numpy.nanmax(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
| 参数 | 描述 | 必需/可选 |
| (类似数组) | 输入数据。 | 需要 |
| 轴 | 沿其计算数组最大值的轴。可以是 axis=0 或 axis=1 或 axis=None,这意味着要返回整个数组的最大值。 | 可选择的 |
| 在外 | 放置结果的替代输出数组。它必须具有与预期输出相同的形状。 | 可选择的 |
| keepdims (bool) | 如果设置为真,减少的轴将作为尺寸为 1 的尺寸留在结果中。使用此选项,结果将根据输入数组正确传播。 | 可选择的 |
| 最初的 | 输出元素的最小值。 | 可选择的 |
| 在哪里 | 要比较以找出最大值的元素。 | 可选择的 |
返回:
一个数组,包含数组沿指定轴的最大值,忽略所有的 nan。
NumPy nanmax 的示例
让我们进入使用 numpy.nanmax() 函数的不同例子。
一维数组的 Nanmax
import numpy as np
arr = [5, 32, 10, np.nan, 4]
# using the nanmax function to calculate the maximum
ans = np.nanmax(arr)
print("arr =", arr)
print("Result =", ans)
输出:
arr = [5, 32, 10, nan, 4]
Result = 32.0
忽略 NaN 值,5、32、10 和 4 中的最大值是 32,因此返回该值。
二维数组的 Nanmax
import numpy as np
arr = [[-12, 3], [np.nan, 36]]
# using the nanmax function to calculate the maximum
ans = np.nanmax(arr)
print("arr =", arr)
print("Result =", ans)
输出:
arr = [[-12, 3], [nan, 36]]
Result = 36.0
与前面的示例类似,12、3 和 36 的最大值是 36。
沿阵列轴的 Nanmax
轴= 0
import numpy as np
arr = [[5, 8], [np.nan, 36]]
# using the nanmax function to calculate the maximum
ans = np.nanmax(arr, axis=0)
print("arr =", arr)
print("Result =", ans)
输出:
arr = [[5, 8], [nan, 36]]
Result = [ 5\. 36.]
这里,比较特定列的每一行中的值,以找到最大元素。
ans[0] = max(arr[0][0], arr[1][0]) = max(5, np.nan) = 5 (ignoring NaN)
ans[1] = max(arr[0][1], arr[1][1]) = max(8, 36) = 36
轴= 1
import numpy as np
arr = [[5, 8], [np.nan, 36]]
# using the nanmax function to calculate the maximum
ans = np.nanmax(arr, axis=1)
print("arr =", arr)
print("Result =", ans)
输出:
arr = [[5, 8], [nan, 36]]
Result = [ 8\. 36.]
当轴=1 时,每一行中的元素在所有列中进行比较,以找到最大值。
ans[0] = max(arr[0][0], arr[0][1]) = max(5, 8) = 8
ans[1] = max(arr[1][0], arr[1][1]) = max(np.nan, 36) = 36 (ignoring NaN)
包含无穷大的数组的 NumPy nanmax
现在让我们看看numpy.nanmax()
方法如何处理数组中的无穷大和 nan。
import numpy as np
# array containing +infinity
a = np.array([25, np.nan, 36, np.inf, 8])
# array containing -infinity
b = np.array([25, np.nan, 36, np.NINF, 8])
# array containing +infinity and -infinity
c = np.array([25, np.nan, 36, np.inf, np.NINF, 8])
max_a = np.nanmax(a)
max_b = np.nanmax(b)
max_c = np.nanmax(c)
print("a =", a)
print("Maximum of the array a =", max_a)
print("\nb =", b)
print("Maximum of the array b =", max_b)
print("\nc =", c)
print("Maximum of the array c =", max_c)
输出:
a = [25\. nan 36\. inf 8.]
Maximum of the array a = inf
b = [ 25\. nan 36\. -inf 8.]
Maximum of the array b = 36.0
c = [ 25\. nan 36\. inf -inf 8.]
Maximum of the array c = inf
在上面的代码中, NINF 表示-无穷大, inf 表示无穷大。请注意,
- 如果数组包含正无穷大,那么最大值是正无穷大。
- 如果数组包含负无穷大的,那么最大值就是所有元素的最大值,忽略 NaNs** 。**
- 如果数组包含正无穷大和负无穷大,那么数组的最大值是 inf ,即正无穷大。
摘要
仅此而已!在本教程中,我们学习了 Numpy nanmax 方法,并使用相同的方法练习了不同类型的示例。
如果你想了解更多关于 NumPy 的信息,请随意浏览我们的 NumPy 教程。
参考
NumPy 闵楠–忽略任何 NaNs 的沿轴数组的最小值
原文:https://www.askpython.com/python-modules/numpy/numpy-nanmin
你好,欢迎来到这个关于 Numpy 闵楠的教程。在本教程中,我们将学习 NumPy nanmin()
方法,也将看到许多关于这个方法的例子。让我们开始吧!
也读作:NumPy nanmax——忽略任何 NaNs 的沿轴数组的最大值
什么是 NumPy 闵楠?
在 Python 中, NaN 表示而不是数字。如果我们有一个包含一些 NaN 值的数组,并且想要找到其中的最小值,我们可以使用 NumPy 的nanmin()
方法。
NumPy 中的nanmin()
方法是一个函数,它返回通过忽略数组中的 NaN 值而计算出的数组元素的最小值。它可以是所有数组元素的最小值、沿行数组元素的最小值或沿列数组元素的最小值。
我们将在本教程的下一节看到每个例子。
NumPy 闵楠的语法
让我们来看看nanmin()
函数的语法。
numpy.nanmin(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
| 参数 | 描述 | 必需/可选 |
| (类似数组) | 输入数据。 | 需要 |
| 轴 | 沿其计算数组最小值的轴。可以是 axis=0 或 axis=1 或 axis=None,这意味着要返回整个数组的最小值。 | 可选择的 |
| 在外 | 放置结果的替代输出数组。它必须具有与预期输出相同的形状。 | 可选择的 |
| keepdims (bool) | 如果设置为真,减少的轴将作为尺寸为 1 的尺寸留在结果中。使用此选项,结果将根据输入数组正确传播。 | 可选择的 |
| 最初的 | 输出元素的最大值。 | 可选择的 |
| 在哪里 | 要比较以找出最小值的元素。 | 可选择的 |
NumPy nanmin parameters
返回:
一个数组,包含沿指定轴的数组的最小值,忽略所有的 NaNs。
NumPy 闵楠的例子
让我们进入使用 numpy.nanmin() 函数的不同例子。
一维数组的 NumPy 闵楠
import numpy as np
arr = [np.nan, 54, 1, 3, 44]
# using the nanmin function to calculate the maximum
ans = np.nanmin(arr)
print("arr =", arr)
print("Result =", ans)
输出:
arr = [nan, 54, 1, 3, 44]
Result = 1.0
忽略 NaN 值,54、1、3 和 44 中的最小值是 1,因此返回该值。
二维数组的闵楠数
import numpy as np
arr = [[30, -9], [8, np.nan]]
# using the nanmin function to calculate the maximum
ans = np.nanmin(arr)
print("arr =", arr)
print("Result =", ans)
输出:
arr = [[30, -9], [8, nan]]
Result = -9.0
与前面的例子类似,30、-9 和 8 的最小值是 8。
沿着阵列轴的闵楠数
轴= 0
import numpy as np
arr = [[16, 4], [np.nan, 1]]
# using the nanmin function to calculate the maximum
ans = np.nanmin(arr, axis=0)
print("arr =", arr)
print("Result =", ans)
输出:
arr = [[16, 4], [nan, 1]]
Result = [16\. 1.]
这里,比较特定列的每一行中的值,以找到最小元素。
ans[0] = min(arr[0][0], arr[1][0]) = min(16, np.nan) = 16 (ignoring NaN)
ans[1] = min(arr[0][1], arr[1][1]) = min(4, 1) = 1
轴= 1
import numpy as np
arr = [[16, 4], [np.nan, 1]]
# using the nanmin function to calculate the maximum
ans = np.nanmin(arr, axis=1)
print("arr =", arr)
print("Result =", ans)
输出:
arr = [[16, 4], [nan, 1]]
Result = [4\. 1.]
当轴=1 时,每一行中的元素在所有列中进行比较,以找到最小值。
ans[0] = min(arr[0][0], arr[0][1]) = min(16, 4) = 4
ans[1] = min(arr[1][0], arr[1][1]) = min(np.nan, 1) = 1 (ignoring NaN)
包含无穷大的数组的 NumPy 闵楠
现在让我们看看numpy.nanmin()
方法如何处理数组中的无穷大和 nan。
import numpy as np
# array containing +infinity
a = np.array([16, 3, np.nan, 7, np.inf])
# array containing -infinity
b = np.array([16, 3, np.nan, 7, np.NINF])
# array containing +infinity and -infinity
c = np.array([16, 3, np.nan, np.NINF, 7, np.inf])
min_a = np.nanmin(a)
min_b = np.nanmin(b)
min_c = np.nanmin(c)
print("a =", a)
print("Minimum of the array a =", min_a)
print("\nb =", b)
print("Minimum of the array b =", min_b)
print("\nc =", c)
print("Minimum of the array c =", min_c)
输出:
a = [16\. 3\. nan 7\. inf]
Minimum of the array a = 3.0
b = [ 16\. 3\. nan 7\. -inf]
Minimum of the array b = -inf
c = [ 16\. 3\. nan -inf 7\. inf]
Minimum of the array c = -inf
在上面的代码中, NINF 表示-无穷大, inf 表示无穷大。请注意,
- 如果数组包含正无穷大,那么最小值是忽略 NaNs 的整个数组的最小值。
- 如果数组包含负无穷大,那么最小值就是负无穷大。
- 如果数组包含正负无穷大,那么数组的最小值是 -inf ,即负无穷大。
结论
仅此而已!在本教程中,我们学习了 Numpy 闵楠方法,并使用相同的方法练习了不同类型的例子。
如果你想了解更多关于 NumPy 的信息,请随意浏览我们的 NumPy 教程。
参考
numpy 纳米棒–完整指南
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-nanprod
你好,欢迎来到这个关于 Numpy nanprod 的教程。在本教程中,我们将学习 NumPy nanprod()方法,也将看到许多相同的例子。让我们开始吧!
也读作:【Numpy trunc()——返回输入的截断值,逐元素
什么是 NumPy nanprod?
在 Python 中,NaN 表示的不是数字。如果我们有一个包含一些 NaN 值的数组,并且想要找到它的乘积,我们可以使用 NumPy 的nanprod()
方法。
NumPy 中的nanprod()
方法是一个函数,它返回通过将数组中的 NaN 值视为等于 1 而计算的数组元素的乘积。它可以是所有数组元素的乘积、沿行数组元素的乘积或沿列数组元素的乘积。
我们将在本教程的下一节看到每个例子。
纳米棒语法
numpy.nanprod(a, axis=None, dtype=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
| 参数 | 描述 | 必需/可选 |
| (类似数组) | 需要其产品的输入数组。 | 需要 |
| 轴 | 沿其计算数组乘积的轴。它可以是 axis=0,即沿列,也可以是 axis=1,即沿行,或者 axis=None,这意味着要返回整个数组的乘积。 | 可选择的 |
| 数据类型 | 要返回的数组的数据类型。 | 可选择的 |
| 在外 | 放置结果的替代输出数组。它必须具有与预期输出相同的形状。 | 可选择的 |
| keepdims (bool) | 如果设置为真,减少的轴将作为尺寸为 1 的尺寸留在结果中。使用此选项,结果将根据输入数组正确传播。 | 可选择的 |
| 最初的 | 产品的起始值。 | 可选择的 |
| 在哪里 | 产品中包含的元素。 | 可选择的 |
返回:
一个与 a 形状相同的数组,该数组包含 a 的元素的乘积,将 NaN 值视为 1,沿给定的轴并移除指定的轴。如果 axis=None,则返回一个标量,它是整个数组的乘积。
numpy.nanprod()的示例
numpy.nanprod()
函数用于计算给定轴上数组元素的乘积,忽略 nan。让我们通过一些例子来看看numpy.nanprod()
的用法。
使用 numpy.nanprod()的整个数组的乘积
一维数组
import numpy as np
a = np.array([6, np.nan, 7])
product = np.nanprod(a)
print("a =", a)
print("Product of the array =", product)
输出:
a = [ 6\. nan 7.]
Product of the array = 42.0
在上面的代码中,数组包含一个 NaN 值。在计算乘积时,nanprod()
函数将 NaN 值视为 1,并将乘积计算为 617 = 42。
二维数组
import numpy as np
a = np.array([[6, np.nan, 7], [np.nan, np.nan, 3]])
product = np.nanprod(a)
print("a =", a)
print("Product of the array =", product)
输出:
a = [[ 6\. nan 7.]
[nan nan 3.]]
Product of the array = 126.0
将所有 NaN 值视为 1,乘积= 61711*3 = 126。
沿着轴的产品
列式产品
import numpy as np
a = np.array([[np.nan, np.nan, 4],
[5, np.nan, 10]])
# product along axis=0 i.e. columns
product = np.nanprod(a, axis=0)
print("a =", a)
print("Product of the array =", product)
输出:
a = [[nan nan 4.]
[ 5\. nan 10.]]
Product of the array = [ 5\. 1\. 40.]
将 NaN 值视为 1,
列 0 乘积= 15 = 5
列 1 乘积= 11 = 1
列 2 乘积= 4*10 = 40
逐行乘积
import numpy as np
a = np.array([[np.nan, np.nan, 4],
[5, np.nan, 10]])
# product along axis=1 i.e. rows
product = np.nanprod(a, axis=1)
print("a =", a)
print("Product of the array =", product)
输出:
a = [[nan nan 4.]
[ 5\. nan 10.]]
Product of the array = [ 4\. 50.]
将 NaN 值视为 1,
第 0 行乘积= 114 = 4
第 1 行乘积= 5110 = 50
空数组和全 NaN 数组的乘积
import numpy as np
# empty arrays
a = []
b = [[]]
product_a = np.nanprod(a)
print("a =", a)
print("Product of the 1-d empty array =", product_a)
product_b = np.nanprod(b)
print("b =", b)
print("Product of the 2-d empty array =", product_b)
# all NaN array
c = [np.nan, np.nan, np.nan]
product_c = np.nanprod(c)
print("c =", c)
print("Product of the all NaN array =", product_c)
输出:
a = []
Product of the 1-d empty array = 1.0
b = [[]]
Product of the 2-d empty array = 1.0
c = [nan, nan, nan]
Product of the all NaN array = 1.0
当对所有空数组和只包含 NaN 值的数组应用nanprod()
方法时,它们返回 1。
结论
仅此而已!在本教程中,我们学习了 Numpy nanprod 方法,并使用该方法练习了不同类型的示例。
参考
NumPy nan sum–完整指南
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-nansum
你好,欢迎来到这个关于 Numpy nansum 的教程。在本教程中,我们将学习 NumPy nansum()
方法,也将看到许多关于这个方法的例子。让我们开始吧!
什么是 NumPy nansum?
在 Python 中, NaN 表示而不是数字。如果我们有一个包含一些 NaN 值的数组,并且想要找到它的和,我们可以使用 NumPy 的nansum()
方法。
NumPy 中的nansum()
方法是一个函数,它返回通过将数组中的 NaN 值视为等于 0 而计算出的数组元素之和。它可以是所有数组元素的总和、沿行数组元素的总和或沿列数组元素的总和。
我们将在本教程的下一节看到每个例子。
NumPy nansum 的语法
numpy.nansum(a, axis=None, dtype=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
| 参数 | 描述 | 必需/可选 |
| (类似数组) | 需要求和的输入数组。 | 需要 |
| 轴 | 要沿其计算数组总和的轴。它可以是 axis=0,即沿列,也可以是 axis=1,即沿行,或者 axis=None,这意味着要返回整个数组的总和。 | 可选择的 |
| 数据类型 | 要返回的数组的数据类型。 | 可选择的 |
| 在外 | 放置结果的替代输出数组。它必须具有与预期输出相同的形状。 | 可选择的 |
| keepdims (bool) | 如果设置为真,减少的轴将作为尺寸为 1 的尺寸留在结果中。使用此选项,结果将根据输入数组正确传播。 | 可选择的 |
| 最初的 | 总和的起始值。 | 可选择的 |
| 在哪里 | 要包含在总和中的元素。 | 可选择的 |
返回:
一个与 a 形状相同的数组,如果轴不为 None,则包含沿给定轴将 NaN 值视为 0 的 a 的元素之和。如果 axis=None,则返回一个标量,它是整个数组的总和。
Numpy.nansum()的示例
现在让我们来看一些例子。
使用 Numpy.nansum()对整个数组求和
一维数组
import numpy as np
a = np.array([10, np.nan, 5, 3, np.nan])
ans = np.nansum(a)
print("a =", a)
print("Sum of the array =", ans)
输出:
a = [10\. nan 5\. 3\. nan]
Sum of the array = 18.0
这里,通过将所有 NaN 值视为零来计算数组的总和。因此,总和= 10+0+5+3+0 = 18。
二维数组
import numpy as np
a = np.array([[10, np.nan, 5], [np.nan, 2, 6]])
ans = np.nansum(a)
print("a =", a)
print("Sum of the array =", ans)
输出:
a = [[10\. nan 5.]
[nan 2\. 6.]]
Sum of the array = 23.0
类似于上面的例子,sum = 10+0+5+0+2+6 = 23。
使用 Numpy.nansum()沿轴求和
逐列求和
import numpy as np
a = np.array([[10, np.nan, 5],
[np.nan, 2, 6]])
# sum along axis=0 i.e. columns
ans = np.nansum(a, axis = 0)
print("a =", a)
print("Sum of the array =", ans)
输出:
a = [[10\. nan 5.]
[nan 2\. 6.]]
Sum of the array = [10\. 2\. 11.]
axis=0 指定按列计算总和。
第 0 列总和= 10+0 = 10
第 1 列总和= 0+2 =2
第 2 列总和= 5+6 = 11
逐行求和
import numpy as np
a = np.array([[10, np.nan, 5],
[np.nan, 2, 6]])
# sum along axis=1 i.e. rows
ans = np.nansum(a, axis = 1)
print("a =", a)
print("Sum of the array =", ans)
输出:
a = [[10\. nan 5.]
[nan 2\. 6.]]
Sum of the array = [15\. 8.]
将 NaN 值视为 0,
第 0 行总和= 10+0+5 = 15
第 1 行总和= 0+2+6 = 8
包含无穷大的数组的和
import numpy as np
# array containing +infinity
a = np.array([8, 4, np.nan, np.inf, 13])
# array containing -infinity
b = np.array([8, 4, np.nan, np.NINF, 13])
# array containing +infinity and -infinity
c = np.array([8, 4, np.nan, np.inf, np.NINF, 13])
sum_a = np.nansum(a)
sum_b = np.nansum(b)
sum_c = np.nansum(c)
print("a =", a)
print("Sum of the array a =", sum_a)
print("b =", b)
print("Sum of the array b =", sum_b)
print("c =", c)
print("Sum of the array c =", sum_c)
输出:
a = [ 8\. 4\. nan inf 13.]
Sum of the array a = inf
b = [ 8\. 4\. nan -inf 13.]
Sum of the array b = -inf
c = [ 8\. 4\. nan inf -inf 13.]
Sum of the array c = nan
在上面的代码中,NINF 表示-无穷大,INF 表示无穷大。请注意,如果数组包含正无穷大,则总和为正无穷大,如果数组包含负无穷大,则总和为负无穷大。如果数组同时包含正无穷大和负无穷大,则数组的和为 NaN。
结论
仅此而已!在本教程中,我们学习了 Numpy nansum 方法,并使用相同的方法练习了不同类型的示例。如果你想了解更多关于 NumPy 的信息,请随意浏览我们的 NumPy 教程。
参考
NumPy nancumsum–完全指南
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-nanum
大家好,欢迎来到这个关于 Numpy nancumsum 的教程。在我们之前的教程中,我们已经了解了 NumPy cumsum 和 NumPy nansum 。在本教程中,我们将学习 NumPy nancumsum() 方法,也将看到许多相同的例子。让我们开始吧!
推荐阅读: NumPy cumsum ,NumPy nansum
什么是 NumPy nancumsum?
在 Python 中, NaN 表示而不是数字。如果我们有一个包含一些 NaN 值的数组,并且想要找到它的累积和,我们可以使用 NumPy 的nancumsum()
方法。
累积和是给定序列的部分和的序列。如果 {a,b,c,d,e,f,…..} 是一个序列那么它的累加和表示为 {a,a+b,a+b+c,a+b+c+d,…。} 。
NumPy 中的nancumsum()
方法是一个函数,它返回通过将数组中的 NaN 值视为等于 0 而计算的数组元素的累积和。它可以是展平数组的累积和、沿行数组元素的累积和或沿列数组元素的累积和。
我们将在本教程的下一节看到每个例子。
NumPy nancumsum 的语法
numpy.nancumsum(a, axis=None, dtype=None, out=None)
| 参数 | 描述 | 必需/可选 |
| a | 输入数组。 | 需要 |
| 轴 | 要沿其计算数组累积和的轴。它可以是 axis=0 或 axis=1 或 axis=None,这意味着要返回展平数组的累积和。 | 可选择的 |
| 数据类型 | 要返回的数组的数据类型。 | 可选择的 |
| 在外 | 放置结果的替代输出数组。它必须具有与预期输出相同的形状和长度。 | 可选择的 |
返回:
一个新的数组,它包含将 NaN 值视为等于零的输出,即累积和。如果提到了 out ,则返回对它的引用。
numpy.nancumsum()方法的示例
现在让我们借助一些例子来看看如何使用这个函数。
单个元素的累积和
import numpy as np
a = 8
ans_a = np.nancumsum(a)
b = np.nan
ans_b = np.nancumsum(b)
print("a =", a)
print("Cumulative sum of a =", ans_a)
print("b =", b)
print("Cumulative sum of b =", ans_b)
输出:
a = 8
Cumulative sum of a = [8]
b = nan
Cumulative sum of b = [0.]
包含 nan 的一维数组的累积和
import numpy as np
arr = [7, 8, np.nan, 10, np.nan, np.nan]
ans = np.nancumsum(arr)
print("arr =", arr)
print("Cumulative sum of arr =", ans)
输出:
arr = [7, 8, nan, 10, nan, nan]
Cumulative sum of arr = [ 7\. 15\. 15\. 25\. 25\. 25.]
在上面的代码中,数组包含 3 个 NaN 值。在计算累积和时,nancumsum()
方法将这些值视为等于零。因此,累积和计算为 7,7+8,7+8+0,7+8+0+10,7+8+0+10+0,7+8+0+10+0+0,结果为 7,15,15,25,25,25。
包含 nan 的二维数组的累积和
import numpy as np
arr = [[5, np.nan, 3], [np.nan, 2, 1]]
ans = np.nancumsum(arr)
print("arr =", arr)
print("Cumulative sum of arr =", ans)
输出:
arr = [[5, nan, 3], [nan, 2, 1]]
Cumulative sum of arr = [ 5\. 5\. 8\. 8\. 10\. 11.]
在二维数组的情况下,当没有提到轴时,数组首先被展平,然后通过将 NaNs 视为 0 来计算其累积和。
在上面的示例中,数组首先被展平为[5,np.nan,3,np.nan,2,1],即按行排列,然后其累积和被计算为[5,5+0,5+0+3+0,5+0+3+0+2,5+0+3+0+2+1],这产生了函数返回的数组[5,5,8,8,10,11]。
将 NaN 视为 0 的沿轴累计总和
轴=0
import numpy as np
arr = [[8, np.nan, 6], [np.nan, 10, 20]]
# cumulative sum along axis=0
ans = np.nancumsum(arr, axis=0)
print("arr =\n", arr)
print("Cumulative sum of arr =\n", ans)
输出:
arr =
[[8, nan, 6], [nan, 10, 20]]
Cumulative sum of arr =
[[ 8\. 0\. 6.]
[ 8\. 10\. 26.]]
把南当 0,第一排照原样。第二行包含按 8+0、0+10、6+20 计算的累积和,即 8、10 和 26。也就是说,累积和是按列计算的,并以行的形式存储。
轴=1
import numpy as np
arr = [[8, np.nan, 6], [np.nan, 10, 20]]
# cumulative sum along axis=1
ans = np.nancumsum(arr, axis=1)
print("arr =\n", arr)
print("Cumulative sum of arr =\n", ans)
输出:
arr =
[[8, nan, 6], [nan, 10, 20]]
Cumulative sum of arr =
[[ 8\. 8\. 14.]
[ 0\. 10\. 30.]]
这里,第一列是原样,第二列包含计算为 8+0,0+10 的累积和,结果是 8,10,第三列具有 8+0+6,0+10+20 的累积和,即 14 和 30。也就是说,累积和是按行计算的,并以列的形式存储。
结论
仅此而已!在本教程中,我们学习了 Numpy nancumsum 方法,并使用该方法练习了不同类型的示例。你可以从我们的 NumPy 教程这里了解更多关于 NumPy 的信息。
参考
NumPy nancumprod–完整指南
原文:1230【https://www . aspython . com/python-modules/num py/numpy-nanumprod】
大家好,欢迎来到这个关于 Numpy nancumprod 的教程。在我们之前的教程中,我们学习了 NumPy cumprod 。在本教程中,我们将学习 NumPy nancumprod() 方法,也将看到许多关于相同的例子。让我们开始吧!
推荐阅读:NumPy cum prod–完整指南T5、NumPy nan prod–完整指南****
什么是 NumPy nancumprod?
在 Python 中, NaN 表示而不是数字。如果我们有一个包含一些 NaN 值的数组,并且想要找到它的累积积,我们可以使用 NumPy 的nancumprod()
方法。累积积是给定序列的部分积的序列。如果 {a,b,c,d,e,f,…..} 是一个序列那么它的累积积表示为 {a,ab,abc,abcd,…。}** 。
NumPy 中的nancumprod()
方法是一个函数,它返回通过将数组中的 NaN 值视为等于 1 而计算的数组元素的累积积。它可以是展平数组的累积积、沿行数组元素的累积积或沿列数组元素的累积积。
我们将在本教程的下一节看到每个例子。
NumPy nancumprod 的语法
numpy.nancumprod(a, axis=None, dtype=None, out=None)
| 参数 | 描述 | 必需/可选 |
| a | 输入数组。 | 需要 |
| 轴 | 要沿其计算数组累积积的轴。它可以是 axis=0 或 axis=1 或 axis=None,这意味着要返回展平数组的累积积。 | 可选择的 |
| 数据类型 | 要返回的数组的数据类型。 | 可选择的 |
| 在外 | 放置结果的替代输出数组。它必须具有与预期输出相同的形状和长度。 | 可选择的 |
返回:
一个包含输出的新数组。如果提到了 out ,则返回对它的引用。
numpy.nancumprod()方法的示例
现在让我们借助一些例子来看看如何使用这个函数。
单个元素的累积积
import numpy as np
a = 10
ans = np.nancumprod(a)
print("a =", a)
print("Cumulative product =", ans)
输出:
a = 10
Cumulative product = [10]
包含 nan 的一维数组的累积积
import numpy as np
a = [5, np.nan, 10, np.nan, np.nan, 2]
ans = np.nancumprod(a)
print("a =", a)
print("Cumulative product =", ans)
输出:
a = [5, nan, 10, nan, nan, 2]
Cumulative product = [ 5\. 5\. 50\. 50\. 50\. 100.]
在上面的代码中,数组包含 3 个 NaN 值。
在计算乘积时,nancumprod()
函数将 NaN 值视为 1,并将累积乘积计算为 5,5,5110,51101,5110*1,5 * 1 * 10 * 1 * 2,结果为 5,5,50,50,50,100。
包含 nan 的二维数组的累积积
import numpy as np
a = [[3, np.nan, 6], [8, np.nan, np.nan]]
ans = np.nancumprod(a)
print("a =", a)
print("Cumulative product =", ans)
输出:
a = [[3, nan, 6], [8, nan, nan]]
Cumulative product = [ 3\. 3\. 18\. 144\. 144\. 144.]
在二维数组的情况下,当没有提到轴时,数组首先被展平,然后通过将 NaNs 视为 1 来计算其累积积。
在上面的示例中,数组首先被展平为[3,np.nan,6,8,np.nan,np.nan],即按行排列,然后其累积积被计算为[3,31,316,3168,3168,1,3168,1*1],这产生了函数返回的数组[3,3,18,144,144,144]。
将 NaN 视为 1 的沿轴累积乘积
轴= 0
import numpy as np
a = [[5, 2, np.nan], [10, np.nan, 3]]
# cumulative product along axis=0
ans = np.nancumprod(a, axis=0)
print("a =\n", a)
print("Cumulative product =\n", ans)
输出:
a =
[[5, 2, nan], [10, nan, 3]]
Cumulative product =
[[ 5\. 2\. 1.]
[50\. 2\. 3.]]
把南当 1,第一排照原样。第二行包含计算为 510、21、1*3 的累积积,即 50、2 和 3。也就是说,累积积是按列计算的,并以行的形式存储。
轴= 1
import numpy as np
a = [[5, 2, np.nan], [10, np.nan, 3]]
# cumulative product along axis=1
ans = np.nancumprod(a, axis=1)
print("a =\n", a)
print("Cumulative product =\n", ans)
输出:
a =
[[5, 2, nan], [10, nan, 3]]
Cumulative product =
[[ 5\. 10\. 10.]
[10\. 10\. 30.]]
这里,第一列是原样,第二列包含计算为 52,101 的累积积,得到 10,10,第三列具有 521,1013 的累积积,即 10 和 30。也就是说,累积积是按行计算的,并以列的形式存储。
摘要
仅此而已!在本教程中,我们学习了 Numpy nancumprod 方法,并使用该方法练习了不同类型的示例。
参考
Numpy Nextafter:如何在 Python 中使用 Numpy Nextafter?
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-nextafter
寻找一个函数,返回一个给定数字在另一个数字方向的下一个浮点值?你想用一组数字而不是一个数字来实现同样的功能吗?
好了,不用再找了,numpy 库已经有了你正在寻找的东西——T2 next after()函数。在本文中,我们将展示上述函数的功能,并理解作为其功能输入的基本结构。
也读作: Numpy.kron():如何使用 Numpy 计算克罗内克积?
我们将首先使用下面的代码导入 numpy 库。
import numpy as np
此后,我们将通过下面的每一节进一步探索 nextafter( ) 函数。
- next after()函数的语法
- 在标量上使用 nextafter( )
- 在 N 维数组上使用next after()
next after()函数的语法
该函数依赖于下面给出的主要输入 x1 和 x2,其中,x1 是沿着 x2 方向找到下一个浮点值的实体。也可以在 nextafter( ) 函数中使用的其他可选输入如下。
numpy.nextafter(x1, x2, out=None, *, where=True, dtype=None)
在哪里,
- x1—N 维数组或标量,要查找其最近的浮点值
- x2—N 维数组或标量提供搜索方向
- out—一个可选的构造,默认情况下设置为 none ,但可用于将结果存储在所需的数组中,该数组的长度与输出的长度相同
- ***–kwargs 或 keyword argument,这是一个可选结构,用于将关键字可变长度的参数传递给函数
- 其中—一个可选构造,当设置为真(默认设置)时,用于计算给定位置的通用函数(ufunc ),当设置为假时,不计算
- dtype—一个可选结构,用于指定正在使用的数据类型
在标量上使用 nextafter( )
在本节中,让我们使用几个标量部署到 nextafter( ) 函数中,如下所示。
a = 100
b = -50
np.nextafter(a, b)
一旦运行了上面的代码,在后端就会发生下面的计算,当在‘b’方向搜索时,返回下一个最接近‘a’的数字。
- “b”被指定为“-50”,这意味着下一个最接近“a”的数字将被向左或在“100”之前搜索,而不是在“100”之后。
- 发现最接近“100”的数字是 99.9999999999999(Python 将浮点数返回到小数点后 14 位精度)。
Using nextafter( ) On Scalars
从上面的解释可以推断,当第二个输入‘x2’大于第一个输入‘x1’时,搜索方向与向右搜索数字行中的数字(第一个输入,x1)是同义的,或者如果第二个输入‘x2’小于第一个输入‘x1’,则向左搜索。
即使使用正无穷大或负无穷大而不是其他数字作为“x2 ”,同样的逻辑也适用,我们将使用下面的代码来解决这个难题。
c = -10
d = +np.inf
np.nextafter(c, d)
Using nextafter( ) on Scalars in the Direction of +Infinity
上面的结果证明,由于搜索方向是正无穷大,所以返回的最接近的浮点数在数字行中是朝着“-10”的右边。
在 N 维数组上使用next after()
当部署在数组上时,结果将四舍五入到数组中给定的小数之后的相同位数,而不是如下所示的 14 位整数。
ar1 = np.array([[1.05, 3, 7],
[2.9, 9, 4.3666667]])
ar2 = np.array([[-1, 0.3, +np.inf],
[0, -np.inf, 10]])
np.nextafter(ar1, ar2)
Using nextafter( ) on Arrays
结论
既然我们已经到了本文的结尾,希望它已经详细阐述了如何使用来自 numpy 库中的 nextafter( ) 函数。这里有另一篇文章详细介绍了使用 numpy kron() 计算 Kronecker 积。AskPython 中还有许多其他有趣且同样丰富的文章,可能对那些希望提高 Python 水平的人有很大帮助。恭喜!
NumPy one–完整指南
原文:https://www.askpython.com/python-modules/numpy/numpy-ones
你好,欢迎来到这个关于Numpy one的教程。在本教程中,我们将学习 NumPy ones() 方法,也将看到许多关于相同的例子。让我们开始吧!
NumPy ones 方法是什么?
NumPy ones
返回给定形状和数据类型的一个 Numpy 数组 ,所有值都设置为 1。
NumPy ones 的语法
让我们先来看看 NumPy ones 的语法。
numpy.ones(shape, dtype=None, order='C', like=None)
| 参数 | 描述 | 必需/可选 |
| 形状 | 所需的数组形状。它可以是一个整数,也可以是一组整数。 | 需要 |
| 类型 | 所需的数组数据类型。
默认数据类型为浮点型。 | 可选择的 |
| 命令 | 多维数据在存储器中存储的期望顺序。它可以是主要行(' C ')或主要列(' F ')。
默认顺序为【C】,即行主。 | 可选择的 |
| like (array_like) | 引用对象,以允许创建不是 NumPy 数组的数组。 | 可选择的 |
返回:
给定形状、数据类型和顺序的数组,只填充 1。
使用 NumPy 的例子
现在让我们看一些numpy.ones()
方法的实际例子。
使用 1 的一维数组
import numpy as np
one_dim_array = np.ones(4)
print(one_dim_array)
输出:
[1\. 1\. 1\. 1.]
使用零的二维数组
N×M 阵列
import numpy as np
two_dim_array = np.ones((4, 2))
print(two_dim_array)
输出:
[[1\. 1.]
[1\. 1.]
[1\. 1.]
[1\. 1.]]
1×N 阵列
import numpy as np
one_row_array = np.ones((1, 3))
print(one_row_array)
输出:
[[1\. 1\. 1.]]
N×1 阵列
import numpy as np
one_col_array = np.ones((5, 1))
print(one_col_array)
输出:
[[1.]
[1.]
[1.]
[1.]
[1.]]
一维整型数组
import numpy as np
one_dim_int_array = np.ones(5, dtype=np.int64)
print(one_dim_int_array)
输出:
[1 1 1 1 1]
二维整型数组
import numpy as np
two_dim_int_array = np.ones((3, 3), dtype=np.int64)
print(two_dim_int_array)
输出:
[[1 1 1]
[1 1 1]
[1 1 1]]
一维自定义数据类型数组
import numpy as np
custom_one_dim_array = np.ones(4, dtype=[('x', 'int'), ('y', 'float')])
print(custom_one_dim_array)
print(custom_one_dim_array.dtype)
输出:
[(1, 1.) (1, 1.) (1, 1.) (1, 1.)]
[('x', '<i4'), ('y', '<f8')]
在这个例子中,我们将第一个值指定为 int,将第二个值指定为 float。
二维自定义数据类型数组
我们可以将数组的元素指定为元组,还可以指定它们的数据类型。
import numpy as np
custom_two_dim_array = np.ones((2, 3), dtype=[('x', 'float'), ('y', 'int')])
print(custom_two_dim_array)
print(custom_two_dim_array.dtype)
输出:
[[(1., 1) (1., 1) (1., 1)]
[(1., 1) (1., 1) (1., 1)]]
[('x', '<f8'), ('y', '<i4')]
这里,代码将数组元素中元组的第一个值指定为 float,第二个值指定为 int。
结论
仅此而已!在本教程中,我们学习了 Numpy ones 方法,并使用相同的方法练习了不同类型的示例。
如果你想了解更多关于 NumPy 的信息,请随意浏览我们的 NumPy 教程。
参考
NumPy ones _ like 完整指南
原文:https://www.askpython.com/python-modules/numpy/numpy-ones_like
在本教程中,我们将学习到 NumPy ones_like 方法,也将看到许多关于相同的例子。让我们开始吧!
推荐阅读:
NumPy ones _ 是什么样子的?
NumPy 中的ones_like
方法是一个函数,它返回与给定数组具有相同形状和大小的一个数组。
NumPy ones _ like 的语法
让我们先来看看numpy.ones_like()
方法的语法。
numpy.ones_like(a, dtype=None, order='K', subok=True, shape=None)
| 参数 | 描述 | 必需/可选 |
| (类似数组) | 定义要返回的数组的形状和数据类型的对象。 | 需要 |
| 数据类型 | 所需数组的数据类型。覆盖结果的数据类型。 | 可选择的 |
| 命令 | 多维数据在存储器中存储的期望顺序。它可以是 row-major ('C '),column-major ('F '),如果 a 是 Fortran 连续的,则“A”表示“F”,否则为“C”。‘k’表示尽可能匹配 a 的布局。 | 可选择的 |
| subok (bool) | 确定新创建的数组是使用子类类型 a (subok=True)还是基类数组(subok=False)。
默认值为真。 | 可选择的 |
| 形状 | 所需数组的形状。覆盖结果的形状。 | 可选择的 |
返回:
与给定数组形状和数据类型相同的数组,用全 1 填充。
Numpy ones _ like 函数的示例
现在让我们看看numpy.ones_like()
函数是如何工作的,以及不同类型的输入的预期输出是什么。
使用 ones _ like 的一维数组
import numpy as np
a = np.arange(10)
print("a =", a)
b = np.ones_like(a)
print("b =", b)
输出:
a = [0 1 2 3 4 5 6 7 8 9]
b = [1 1 1 1 1 1 1 1 1 1]
使用 ones _ like 的二维数组
N×N 阵列
import numpy as np
a = np.arange(10).reshape(5, 2)
print("a =\n", a)
b = np.ones_like(a)
print("b =\n", b)
输出:
a =
[[0 1]
[2 3]
[4 5]
[6 7]
[8 9]]
b =
[[1 1]
[1 1]
[1 1]
[1 1]
[1 1]]
1×N 阵列
import numpy as np
a = np.arange(12).reshape(1, 12)
print("a =\n", a)
b = np.ones_like(a)
print("b =\n", b)
输出:
a =
[[ 0 1 2 3 4 5 6 7 8 9 10 11]]
b =
[[1 1 1 1 1 1 1 1 1 1 1 1]]
N×1 阵列
import numpy as np
a = np.arange(12).reshape(12, 1)
print("a =\n", a)
b = np.ones_like(a)
print("b =\n", b)
输出:
a =
[[ 0]
[ 1]
[ 2]
[ 3]
[ 4]
[ 5]
[ 6]
[ 7]
[ 8]
[ 9]
[10]
[11]]
b =
[[1]
[1]
[1]
[1]
[1]
[1]
[1]
[1]
[1]
[1]
[1]
[1]]
使用 Numpy ones _ like 的一维浮点型数组
import numpy as np
a = np.arange(10)
print("a =", a)
b = np.ones_like(a, dtype=float)
print("b =", b)
输出:
a = [0 1 2 3 4 5 6 7 8 9]
b = [1\. 1\. 1\. 1\. 1\. 1\. 1\. 1\. 1\. 1.]
二维浮点型数组
import numpy as np
a = np.arange(10).reshape(2, 5)
print("a =\n", a)
b = np.ones_like(a, dtype=float)
print("b =\n", b)
输出:
a =
[[0 1 2 3 4]
[5 6 7 8 9]]
b =
[[1\. 1\. 1\. 1\. 1.]
[1\. 1\. 1\. 1\. 1.]]
Numpy 和 ones _ like 有什么区别
- 注意,在
ones
方法中,我们正在创建一个我们想要的形状和数据类型的新数组,所有的值都是 1。但是,在这里,我们直接传递一个数组或类似数组的对象来获得一个具有相同形状和数据类型的数组。 - NumPy
ones_like
函数比 NumPyones
函数花费更多的时间来生成全 1 数组。
结论
仅此而已!在本教程中,我们学习了 Numpy ones_like 方法,并使用相同的方法练习了不同类型的示例。如果你想了解更多关于 NumPy 的信息,请随意浏览我们的 NumPy 教程。
参考
Numpy.outer():完整指南
原文:https://www.askpython.com/python-modules/numpy/numpy-outer
向量是非常迷人的实体,构成了在数学领域中使用的不同空间和平面导航的本质。虽然向量可以执行无数的操作,但是在本文中,我们将使用 numpy 库中的内置函数—outer()函数来探索这样一种操作!
还要检查:熊猫 Dataframe 和 Numpy 数组的区别
让我们先导入 numpy 库,然后使用下面的代码部署 outer( ) 函数。
import numpy as np
我们将通过以下几节深入介绍 outer( ) 函数。
- outer()函数的语法
- 计算一维数组的外积
- 计算 N 维数组的外积
- 计算字母的外积
- 用 Numpy 函数计算外积
outer()函数的语法
确定给定向量集的外积的基本机制是将一个向量的每个元素与其他每个元素相乘,并将每个相应的结果视为输出向量的一部分。这就是发生在 outer( ) 函数中的所有内容,其语法如下:
numpy.outer(a, b, out=None)
在哪里,
- a-n 维数组的第一个输入向量
- b—n 维数组的第二个输入向量
- out—一个可选的构造,默认情况下设置为 none ,但是可以用来将结果存储在一个适当长度的数组中
计算一维数组的外积
在导入了 numpy 库之后,让我们使用两个一维数组来寻找向量的外积,如下所示。
ar1 = [[12, 36, 71, 99]]
ar2 = [[2, 8, 9, 56]]
np.outer(ar1, ar2)
输出数组也应该包含 4 列,但重要的变化是行数,应该是 4 而不是 1。这里发生的是第一个数组的第一个元素,' 12 '与第二个数组中的每个元素相乘,这解释了输出的第一行的结果。
输出数组“24”的第一个元素是 12×2 的乘积,第二个元素“96”是 12×8 的乘积,依此类推。如此反复,直到数组的最后一个元素乘以 12 &然后对下一个元素‘36’重复这个过程。现在结果被记录在新的一行中!
Outer Product Calculated For One-Dimensional Arrays
计算 N 维数组的外积
在本节中,让我们使用 3 列 2 行的数组来计算向量的外积。猜猜结果会是什么?
ar3 = [[24, 25, 26],
[5, 2, 9]]
ar4 = [[6, 8, 12],
[4, 3, 10]]
np.outer(ar3, ar4)
一个 6×6 的阵列!
Outer Product Calculated For Two-Dimensional Arrays
计算字母的外积
向量的外积不仅限于数字,还可以通过将字母的数据类型指定为“对象”来使用字母,如下所示。
ar5 = np.array(['x', 'y', 'z'], dtype = object)
ar6 = [[2, 6, 1]]
np.outer(ar5, ar6)
产生的输出数组应包含“ar5”中的字母,其重复次数与“ar6”的每个元素中指定的次数相同。
Outer Product Calculated For Letters
用 Numpy 函数计算外积
还可以使用组合个 1()–来计算向量的外积,这将根据指定的维度创建一个由“1”组成的数组&linspace()–通过将指定的范围划分为指定数量的部分来创建一组数字。
让我们使用 linspace( ) 将 2 & 8 之间的范围划分为四个部分进行本节演示。
ar7 = np.ones(4)
ar8 = np.linspace(2, 8, 4)
np.outer(ar7, ar8)
Outer Product Calculated With Numpy Functions
结论
既然我们已经到了本文的结尾,希望它已经详细阐述了如何使用来自 numpy 库的 outer( ) 函数。这里有另一篇文章解释了如何在 Python 中使用 numpy 求平方根。AskPython 中还有许多其他有趣且信息量大的文章,可能对那些希望提高 Python 水平的人有很大帮助。当你享受这些的时候,再见!
Numpy 幂——将另一个数提高到的幂
原文:https://www.askpython.com/python-modules/numpy/numpy-power
我们今天要解决一个非常令人兴奋的问题!我们将取两个长度相同的数组。对于第一个数组的每个值,我们将把幂提升到与第二个数组的相应值相同的值。让我们从理论上理解这一点。
我们有两个数组
- x=[1,2,3,4,5,6,8]
- y=[5,4,3,2,1,9,3]
让我们得到从 0 到数组长度范围内所有 I 的值x[i]^(y[i])
。
- 1⁵ = 1
- 2⁴ = 16
- 3³ = 27
- 4² = 16
- 5¹ = 5
- 6⁹ = 10077696
- 8³ = 512
我们希望我们的结果或输出在一个数组中,比如[1,16,27,16,5,10077696,512]。
使用 Numpy.power()方法
我们将继续解决这个问题,按顺序排列每一步,让你解释为合理的。今天我们将使用我们的 google collab 进行编码。你们一定知道 google collab 也提供了最好的 python 平台。不要迟到。让我们开始吧。
第一步:导入数字
我们将在第一步导入所需的模块。因为我们要使用NumPy.power()
函数,我们需要导入依赖模块,即 Numpy 模块 。
import numpy
步骤 2:创建要乘幂的数组
让我们取或创建如下两个数组,由一些值组成。
x=[1,2,3,4,5,6,8]
y=[5,4,3,2,1,9,3]
步骤 3:确认数组长度相同
在这一步,我们将检查两个数组的长度是否相等,如果相等,我们将进一步让我们的问题得到解决。否则,它将不会进一步移动。
if len(x) == len(y):
#logicc to get our Resulatant array
else :
print("arrays are not of equal size. Plz review again")
第 4 步:对每个项目运行 numpy.power()方法
在这一步,我们将创建我们的逻辑和代码。我们正在循环解决我们的问题。在循环内部,我们使用 NumPy.power()
方法来获取结果并加载到z
数组中。快速浏览以便更好地理解。
for i in x:
output = numpy.power(i,y[w])
w = w + 1
z.append(output)
print(z)
解决我们问题的整体代码如下。
import numpy
x=[1,2,3,4,5,6,8]
y=[5,4,3,2,1,9,3]
z=[]
w = 0
if len(x) == len(y):
for i in x:
output = numpy.power(i,y[w])
w = w + 1
z.append(output)
print(z)
else :
print("arrays are not of equal size. Plz review again")
上面的代码片段将给出如下。
[1, 16, 27, 16, 5, 10077696, 512]
这次我们将传递两个带有different shapes or different indices
的数组。让我们看看实现相同代码后的结果。
import numpy
x=[1,2,3,4,5,6,8,8,9,4] #index = 10
y=[5,4,3,2,1,9,3] #index = 7
z=[]
w = 0
if len(x) == len(y):
for i in x:
output = numpy.power(i,y[w])
w = w + 1
z.append(output)
print(z)
else :
print("arrays are not of equal size. Please review")
上面的代码片段将给出如下结果。
arrays are not of equal size. Please review
接受用户输入以运行 numpy.power()
在这一步中,我们将让用户输入两个数组的值,而不是在程序或代码片段中创建数组。首先,我们需要定义一个空数组。并且让用户决定他将要输入多少输入。然后使用循环,他可以为数组输入所有需要的值。
# creating an empty array
x = []
# number of elements as input
n = int(input("Enter the number of values you want to enter : "))
# using for loop to enter all the values
for i in range(0, n):
value = int(input())
x.append(value)
上面的代码片段让我们将值输入到 x 数组中,如下所示。
像这样,您也可以输入 y 数组的值。最后用这些数组来实现。
#importing required module
import numpy
# creating x array
x = []
n = int(input("Enter the number of values you want to enter : "))
for i in range(0, n):
value = int(input())
x.append(value)
#creating y array
y = []
m = int(input("Enter the number of values you want to enter : "))
for i in range(0, m):
value = int(input())
y.append(value)
#implementing logic
z=[]
w = 0
if len(x) == len(y):
for i in x:
output = numpy.power(i,y[w])
w = w + 1
z.append(output)
print(z)
else :
print("arrays are not of equal size. Plz review again")
您可以看到,我们已经为每个数组输入了值,并使用了两个数组来获得第一个数组的值的乘方,其乘方等于第二个数组的值。
摘要
就这样,我们解决了我们需要的问题。希望你们已经理解了我们的代码片段中的每一步。我们必须再次访问,再次为您解决一些独家的激动人心的问题。我们不会让你等的。谢谢你。
NumPy 产品-完整指南
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-prod
你好,欢迎来到 Numpy prod 教程。在本教程中,我们将学习 NumPy prod()方法,也将看到许多关于该方法的例子。让我们开始吧!
也读作:【NumPy 零点——完全指南】
什么是 NumPy prod?
NumPy 中的 prod 方法是一个返回数组元素乘积的函数。它可以是所有数组元素的乘积、沿行数组元素的乘积或沿列数组元素的乘积。在本教程接下来的部分,我们将会看到每个例子。
NumPy 产品的语法
让我们首先看看 NumPy prod 函数的语法。
numpy.prod(a, axis=None, dtype=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
| 参数 | 描述 | 必需/可选 |
| (类似数组) | 输入数据。 | 需要 |
| 轴 | 沿其计算数组乘积的轴。它可以是 axis=0,即沿列,也可以是 axis=1,即沿行,或者 axis=None,这意味着要返回整个数组的乘积。如果 axis 是一个整数元组,则乘积在元组中指定的所有轴上执行,而不是像以前那样在单个轴或所有轴上执行。 | 可选择的 |
| 数据类型 | 要返回的数组的数据类型。 | 可选择的 |
| 在外 | 放置结果的替代输出数组。它必须具有与预期输出相同的形状。 | 可选择的 |
| keepdims (bool) | 如果设置为真,减少的轴将作为尺寸为 1 的尺寸留在结果中。使用此选项,结果将根据输入数组正确传播。 | 可选择的 |
| 最初的 | 产品的起始值。 | 可选择的 |
| 在哪里 | 产品中包含的元素。 | 可选择的 |
返回:
一个与 a 形状相同的数组,包含 a 沿给定轴的元素的乘积,并去掉指定轴。如果 axis=None,则返回一个标量,它是整个数组的乘积。
numpy.prod()的示例
让我们进入使用 numpy.prod()函数的不同例子。
整个数组的乘积
一维数组
import numpy as np
a = [5, 3, 1]
product = np.prod(a)
print("a =", a)
print("Product of the array =", product)
输出:
a = [5, 3, 1]
Product of the array = 15
数组的乘积= 531 = 15
二维数组
import numpy as np
a = [[5, 3, 1], [1, 2, 4]]
product = np.prod(a)
print("a =", a)
print("Product of the array =", product)
输出:
a = [[5, 3, 1], [1, 2, 4]]
Product of the array = 120
数组的乘积= 53112*4 = 120
沿着轴的产品
列式产品
import numpy as np
a = [[5, 3, 1],
[1, 2, 4]]
# product along axis=0 i.e. columns
product = np.sum(a, axis=0)
print("a =", a)
print("Product of the array along the columns =", product)
输出:
a = [[5, 3, 1], [1, 2, 4]]
Product of the array along the columns = [5 6 4]
第 0 列乘积= 51 = 5
第 1 列乘积= 32 = 6
第 2 列乘积= 1*4 = 4
逐行乘积
import numpy as np
a = [[5, 3, 1],
[1, 2, 4]]
# product along axis=1 i.e. rows
product = np.prod(a, axis=1)
print("a =", a)
print("Product of the array along the rows =", product)
输出:
a = [[5, 3, 1], [1, 2, 4]]
Product of the array along the rows = [15 8]
第 0 行产品= 531 = 15
第 1 行产品= 124 = 8
以浮点数据类型返回数组的乘积
这与上面的例子相同,只是这里返回值是浮点数据类型。
整个数组的乘积
import numpy as np
a = [[2, 3 ,6],
[1, 5, 4]]
product = np.prod(a, dtype=float)
print("a =", a)
print("Product of the array along the columns =", product)
输出:
a = [[2, 3, 6], [1, 5, 4]]
Product of the array along the columns = 720.0
列式产品
import numpy as np
a = [[2, 3 ,6],
[1, 5, 4]]
# product along axis=0 i.e. columns
product = np.prod(a, axis=0, dtype=float)
print("a =", a)
print("Product of the array along the columns =", product)
输出:
a = [[2, 3, 6], [1, 5, 4]]
Product of the array along the columns = [ 2\. 15\. 24.]
逐行乘积
import numpy as np
a = [[2, 3 ,6],
[1, 5, 4]]
# product along axis=1 i.e. rows
product = np.prod(a, axis=1, dtype=float)
print("a =", a)
print("Product of the array along the rows =", product)
输出:
a = [[2, 3, 6], [1, 5, 4]]
Product of the array along the rows = [36\. 20.]
数组中特定元素的乘积
一维数组
import numpy as np
a = [2, 9, 3, 4, 1]
product = np.prod(a, where=[True, False, False, True, True])
print("a =", a)
print("Product of the array =", product)
输出:
a = [2, 9, 3, 4, 1]
Product of the array = 8
在上面的代码中, 'where' 子句指定产品中包含哪些元素。“True”表示将该值包括在产品中,“False”表示不将该值包括在产品计算中。
这里,其中=[真,假,假,真,真]表示在乘积中只包括数组位置 0,3,4 的元素。因此,乘积= a[0]a[3]a[4] = 241 = 8。
二维数组
import numpy as np
a = [[2, 9],
[7, 10]]
product = np.prod(a, where=[[True, False], [False, True]])
print("a =", a)
print("Product of the array =", product)
输出:
a = [[2, 9], [7, 10]]
Product of the array = 20
这里,从第 0 行开始,只有 a[0][0]即 2,从第 1 行开始,只有 a[1][1]即 10 包括在乘积中。因此,乘积= 2*10 = 20。
结论
仅此而已!在本教程中,我们学习了 Numpy prod 方法,并使用相同的方法练习了不同类型的示例。
参考
Numpy Random . rand()-使用 Numpy 生成随机数据
原文:https://www.askpython.com/python-modules/numpy/numpy-random-rand
随机的。rand()函数可以帮助你以一种非常简单的方式生成随机数据。在本文中,我们将学习如何使用 random.rand()函数生成随机值。所以我们来了解一下。
random.rand()函数是什么?
random.rand()函数用于返回给定形状中随机生成的值。该函数返回一个具有指定形状的数组,并用正态分布在[0,1]范围内的随机值填充该数组。
random.rand()函数的语法
numpy.random.rand(d0、d1、…、dn)
| 参数 | 描述 |
| d0,d1,…..,dn | 数组的维度。 |
例如:
import numpy as np
x = np.random.rand()
print(x)
输出:
0.2967574962954477
还可以将 seed()函数合并到 random.rand()函数中,以生成每次运行都保持不变的输出。
import numpy as np
np.random.seed(0)
x = np.random.rand()
print(x)
输出:
0.5488135039273248
让我们看看如何在 Numpy random.rand()函数的帮助下生成一维和二维数组。
带有 np.random.rand()函数的一维数组
以下代码将返回指定形状的一维数组。
import numpy as np
np.random.seed(0)
x = np.random.rand(6)
print(x)
输出:
[0.5488135 0.71518937 0.60276338 0.54488318 0.4236548 0.64589411]
如果您想生成更多的数字,请使用下面的代码。
import numpy as np
np.random.seed(0)
x = np.random.rand(6)*10
print(x)
输出:
[5.48813504 7.15189366 6.02763376 5.44883183 4.23654799 6.45894113]
使用 np.random.rand()函数的二维数组
下面的代码将生成一个二维数组。
import numpy as np
np.random.seed(0)
x = np.random.rand(2,3)
print(x)
输出:
[[0.5488135 0.71518937 0.60276338]
[0.54488318 0.4236548 0.64589411]]
具有 np.random.rand()函数的多维数组
下面的代码将生成更高维的数组。
import numpy as np
np.random.seed(0)
x = np.random.rand(2,4,2,4)
print(x)
输出:
[[[[0.5488135 0.71518937 0.60276338 0.54488318]
[0.4236548 0.64589411 0.43758721 0.891773 ]]
[[0.96366276 0.38344152 0.79172504 0.52889492]
[0.56804456 0.92559664 0.07103606 0.0871293 ]]
[[0.0202184 0.83261985 0.77815675 0.87001215]
[0.97861834 0.79915856 0.46147936 0.78052918]]
[[0.11827443 0.63992102 0.14335329 0.94466892]
[0.52184832 0.41466194 0.26455561 0.77423369]]]
[[[0.45615033 0.56843395 0.0187898 0.6176355 ]
[0.61209572 0.616934 0.94374808 0.6818203 ]]
[[0.3595079 0.43703195 0.6976312 0.06022547]
[0.66676672 0.67063787 0.21038256 0.1289263 ]]
[[0.31542835 0.36371077 0.57019677 0.43860151]
[0.98837384 0.10204481 0.20887676 0.16130952]]
[[0.65310833 0.2532916 0.46631077 0.24442559]
[0.15896958 0.11037514 0.65632959 0.13818295]]]]
结论
在本文中,您学习了如何使用 np.random.rand()函数生成一维、二维以及更高维的数组。希望这篇文章对你有所帮助。
NumPy real 和 NumPy imag 完全指南
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-real-numpy-imag
嘿大家,欢迎回到另一个令人兴奋的 NumPy 教程。
你们一定都熟悉复数,对吧?如果没有,让我给你一个快速回顾。所以,复数是由两部分组成的特殊数字,实部和虚部。形式为 z = x+yi 的数 z ,其中 x 和 y 是实数,那么数 z,被称为复数。
这个简短的介绍是本教程所必需的,因为它是进一步理解这两个函数的基础。现在,我们可以仅仅通过使用简单的 NumPy 函数来提取复数的实部和虚部吗?是的,我们可以使用 NumPy 库的两个函数来实现,即 numpy.real()
和 numpy.imag()
。
这就是我们将在文章中讨论的内容。
理解数字真实
在 NumPy 库的众多函数中, numpy real 是一个提取复杂参数的实数部分的函数。
让我们来看看函数的语法。
NumPy real 的语法
numpy.real(val)
输入 val
可以是单个复数,也可以是复数的 NumPy 数组。
我们将在代码片段部分讨论它的返回类型,因为通过观察输出,您会更容易理解它。
使用 NumPy real
让我们写一些代码,让我们对函数的理解更清晰。
1.单个复数的 NumPy 实数
import numpy as np
# Passing Complex Numbers as argument to the fucntion
print("The real part of 1+3j is:",np.real(1+3j))
print("The real part of 3j is:",np.real(3j))
print("\n")
# Passing real numbers as argument to the function
print("The real part of 1 is:",np.real(1))
print("The real part of -1.1 is:",np.real(-1.1))
输出
The real part of 1+3j is: 1.0
The real part of 3j is: 0.0
The real part of 1 is: 1
The real part of -1.1 is: -1.1
注:每一个实数都可以表示为复数。例如,1 可以表示为 1+0i,其中虚部变为 0。
在上面的例子中,我们已经将复数和实数作为输入传递给了 np.real()
函数。注意到这两种情况下输出的差异真的很有趣。
当一个复数作为参数传递给函数时,输出是类型 float 。然而,当一个实数作为参数传递给函数时,那么输出的类型就是与输入数字相同的。这只是函数返回类型的不同。
2.NumPy 复数数组的 NumPy 实数
import numpy as np
a = np.array((1+3j , 3j , 1 , 0.5))
b = np.real(a)
print("The input array:\n",a)
print("The real part of the numbers:\n",b)
输出
The input array:
[1\. +3.j 0\. +3.j 1\. +0.j 0.5+0.j]
The real part of the numbers:
[1\. 0\. 1\. 0.5]
我们来理解一下上面的例子。这里,我们创建了一个变量 a
来存储四个元素的 NumPy 数组,其中两个是复数,另外两个是实数。
在下一行中,我们使用了 np.real()
函数来提取输入数组中元素的实部。该函数的输出是一个 NumPy 数组,存储在变量 b
中。
在接下来的两行中,我们使用了两个 print 语句来分别打印输入数组和输出数组。
这就是使用 NumPy 实数函数的全部内容。现在,我们将了解 NumPy imag 函数。
关于 NumPy imag
NumPy imag 也是 NumPy 库的数学函数之一,提取复数实参的虚部。
它的语法非常类似于 NumPy 实函数。
NumPy 图像的语法
numpy.imag(val)
输入 val
可以是单个复数,也可以是复数的 NumPy 数组。
它的返回类型与我们在上一节中讨论的 NumPy 实函数的返回类型完全相似。
使用 NumPy 图像
让我们对不同类型的输入值使用这个函数。
1.单个复数的 NumPy 图像
import numpy as np
# Passing Complex Numbers as argument to the fucntion
print("The imaginary part of 1+3j is:",np.imag(1+3j))
print("The imaginary part of 3j is:",np.imag(3j))
print("\n")
# Passing imag numbers as argument to the function
print("The imaginary part of 1 is:",np.imag(1))
print("The imaginary part of -1.1 is:",np.imag(-1.1))
输出
The imaginary part of 1+3j is: 3.0
The imaginary part of 3j is: 3.0
The imaginary part of 1 is: 0
The imaginary part of -1.1 is: 0.0
这里,输出的类型取决于函数的输入类型。我们可以观察到,如果一个复数作为输入被传递,那么函数的输出是一个浮点数,而如果输入是一个实数,输出数的类型取决于输入数的类型。
函数 np.imag()
提取复数的虚部。与复数中的术语“j”相关联的数字是复数的虚部。
2.复数 NumPy 数组的 NumPy 图像
import numpy as np
a = np.array((1+3j , 3j , 1 , 0.5))
b = np.imag(a)
print("The input array:\n",a)
print("The imaginary part of the numbers:\n",b)
输出
The input array:
[1\. +3.j 0\. +3.j 1\. +0.j 0.5+0.j]
The imaginary part of the numbers:
[3\. 3\. 0\. 0.]
在上面的代码片段中,前两个输出是清楚的,但是为什么输出数组中的另外两个值是 0 呢?
实际上,输入数组的后两个元素是实数,可以分别写成 1+0j 和 0.5+0j 。所以,很明显,两个数的虚部都等于 0。这就是输出数组中最后两个值等于 0 的原因。
所以,这就是使用 NumPy real 和 NumPy imag 函数的全部内容。
摘要
在本文中,我们学习了 NumPy real 和 imag 函数以及不同类型的示例。我们还了解了这两个函数的返回类型,这是本文最有趣的部分🙂
不断学习,不断探索更多这样的文章。
参考
Numpy.reciprocal():使用 Numpy 返回元素的倒数?
原文:https://www.askpython.com/python-modules/numpy/numpy-reciprocal
数字是需要处理的有趣的实体。他们有许多特殊的属性,可以在需要的时候使用。它们以多种形式存在,如小数、整数和整数,并且可以根据使用它们的人的需要而改变。
它们甚至存在于现实和想象的范例中。这些数字的一种形式是分数,它似乎存在于所有的整数中。
互易是分子和分母交换位置以确定结果数的一种性质。在本文中,我们将借助下面几节的内容,研究使用 Python 中的 numpy 库中的函数来往复处理数字和数组的不同方式。
- 介意小数!
- 使用倒数()函数
- 以公式往复运动
介意小数!
让我们通过使用下面的代码在 Python 中导入 numpy 库开始。
import numpy as np
我们现在将展示在 Python 中使用 numpy 库中的倒数()函数时小数点扮演的重要角色。一个随机数被分配给一个变量,然后通过倒数()函数,如下面的代码所示。
a = 3
r1 = np.reciprocal (a)
现在让我们看看使用 print( ) 函数的结果。
print (r1)
Incorrect Result For Reciprocating ‘3′
奇怪的是注意到‘3’的倒数被给定为零而不是 0.33!这可以用少了小数点来解释。让我们重复同样的操作,但这次使用一个带小数的数字,如下所示。
a = 3.14
np.reciprocal(a)
Correct Result Of Reciprocating
因此,当使用 Python 中的 numpy 函数来计算数字的倒数时,一定要记住小数点的用法。上述演示的结果甚至适用于小数中只有零的数字,如“3.0”。
a = 3\.
np.reciprocal(a)
0.3333333333333333
Result Of Reciprocating ‘3.’
使用 Numpy。倒数()功能
这一次,让我们尝试将这种往复扩展到数组中的一串数字。因此,我们从构造一个数组并将其赋给一个变量开始,如下面的代码所示。
ar = np.array([[2.5, 6.4, 3],
[1, 5, 0.9]])
Constructing An Array
完成后,我们可以使用下面的代码来确定声明数组的倒数。
r2 = np.reciprocal (ar)
print (r2)
Reciprocal Of An Array
在输入数组中可以很好地观察到,其中的某些数字条目不具有小数点,而其他条目具有小数点。这表明,如果在数组中的数字集合中至少指定一个小数点,Python 也会将所有其他实体识别为浮点型整数!
以公式往复运动
这是一个非常简单的方法,通过构造一个公式将所有的数字发送到除数为“1”的分母,从而推翻一组给定的数组。做的比说的好!这是演示上述内容的代码。
ar = np.array([[2.5, 6.4, 3],
[1, 5, 0.9]])
r3 = 1/ar
print (r3)
Result Of Reciprocating Using Formula
结论
既然我们已经到了本文的结尾,希望它已经详细说明了如何使用 Python 中的 numpy.reciprocal( ) 函数返回数组中元素的倒数。这里有另一篇文章详细介绍了如何在 Python 中使用 numpy 对整数进行四舍五入。AskPython 中还有许多其他有趣的&同样信息丰富的文章,可能对那些希望提高 Python 水平的人有很大帮助。当你享受这些的时候,再见!
numpy . rint()–将 NumPy 数组元素舍入到最接近的整数
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-rint
大家好!在本教程中,我们将学习 NumPy **rint**
函数。该功能简单易懂,易于使用。让我们开始吧。
numpy.rint()是什么?
NumPy rint
是 NumPy 库提供的另一个数学函数,它将输入数字舍入到最接近的整数。
让我们看看这个函数的语法。
numpy.rint()的语法
numpy.rint(input)
这里,输入可以是单个数字,也可以是数字的 NumPy 数组。需要注意的是,由 numpy.rint()
函数返回的数组具有与输入数组相同的类型和形状。****
使用数字打印机
我们已经完成了语法部分:)。现在让我们写一些代码来更好地理解这个函数。
numpy.rint()用于输入单个数字
import numpy as np
# Rounding the input values to the nearest integer
print("Rounded Value of 0.5 is:",np.rint(0.5))
print("Rounded Value of 1.5 is:",np.rint(1.5))
print("Rounded Value of 1.74 is:",np.rint(1.74))
print("Rounded Value of 5.56 is:",np.rint(5.56))
print("Rounded Value of 5.243 is:",np.rint(5.243))
print("Rounded Value of 10.111 is:",np.rint(10.111))
print("Rounded Value of 10.179 is:",np.rint(10.179))
输出
Rounded Value of 0.5 is: 0.0
Rounded Value of 1.5 is: 2.0
Rounded Value of 1.74 is: 2.0
Rounded Value of 5.56 is: 6.0
Rounded Value of 5.243 is: 5.0
Rounded Value of 10.111 is: 10.0
Rounded Value of 10.179 is: 10.0
有一件有趣的事情需要观察,那就是 numpy.rint()
函数的输出总是一个整数值。现在让我们尝试使用 NumPy 数组的函数。
NumPy rint 代表 NumPy 数字数组
import numpy as np
a = np.array((0.52 , 2.55 , 4.51 , 7.56 , 19.32))
print("Input Array:\n",a)
print("Rounded Values:\n",np.rint(a))
输出
Input Array:
[ 0.52 2.55 4.51 7.56 19.32]
Rounded Values:
[ 1\. 3\. 5\. 8\. 19.]
输出数组非常明显,其中输入数组的元素被舍入到最接近的整数值。
这就是关于 NumPy rint 函数的全部内容。请点击查看关于 python 其他主题的精彩文章。
参考
num py documentation–num py prints
NumPy 集合运算知道!
读者朋友们,你们好!在本文中,我们将学习 Python 中的通用 NumPy 集合操作。所以,让我们开始吧!🙂
有用的数字集合运算
在本文中,我们将讨论 5 种有用的 numpy 集合运算。
numpy.unique(array)
numpy.union1d(array,array)
numpy.intersect1d(array,array,assume_unique)
np.setdiff1d(arr1, arr2, assume_unique=True)
np.setxor1d(arr1, arr2, assume_unique=True)
让我们逐个检查这些操作。
1。NumPy 数组中的唯一值
这个 numpy 集合操作帮助我们从 Python 中的数组元素集合中找到唯一值。numpy.unique()
函数跳过所有重复的值,只表示数组中唯一的元素
语法:
numpy.unique(array)
举例:
在这个例子中,我们使用 unique()函数从数组集中选择并显示唯一的元素。因此,它跳过重复值 30,并且只选择它一次。
import numpy as np
arr = np.array([30,60,90,30,100])
data = np.unique(arr)
print(data)
输出:
[ 30 60 90 100]
2。在 NumPy 数组上设置 union 操作
NumPy 为我们提供了通用的union1d()
函数,可以对两个数组进行联合运算。
也就是说,它将两个数组中的值相加并表示出来。这个过程完全忽略了重复值,并且在数组的联合集中只包含一个重复元素。
语法:
numpy.union1d(array,array)
举例:
import numpy as np
arr1 = np.array([30,60,90,30,100])
arr2 = np.array([1,2,3,60,30])
data = np.union1d(arr1,arr2)
print(data)
输出:
[ 1 2 3 30 60 90 100]
3。在 NumPy 数组上设置交集操作
intersect1d() function
使我们能够对数组执行交集操作。也就是说,它从两个数组中选择并表示公共元素。
语法:
numpy.intersect1d(array,array,assume_unique)
- assume_unique:如果设置为 TRUE,则包含交集运算的重复值。将其设置为 FALSE 将导致交集运算忽略重复值。
举例:
这里,由于我们已经将assume_unique
设置为真,所以已经执行了包括重复值的交集操作,即它从两个数组中选择公共值,包括那些公共元素的重复。
import numpy as np
arr1 = np.array([30,60,90,30,100])
arr2 = np.array([1,2,3,60,30])
data = np.intersect1d(arr1, arr2, assume_unique=True)
print(data)
输出:
[30 30 60]
4.使用 NumPy 数组查找不常见的值
使用setdiff1d()
函数,我们可以根据传递给函数的参数找到并表示第一个数组中不存在于第二个数组中的所有元素。
import numpy as np
arr1 = np.array([30,60,90,30,100])
arr2 = np.array([1,2,3,60,30])
data = np.setdiff1d(arr1, arr2, assume_unique=True)
print(data)
输出:
[ 90 100]
5。对称差异
使用setxor1d()
函数,我们可以计算数组元素之间的对称差。也就是说,它选择并表示两个数组中不常见的所有元素。因此,它省略了数组中的所有公共值,并表示两个数组的不同值。
举例:
import numpy as np
arr1 = np.array([30,60,90,30,100])
arr2 = np.array([1,2,3,60,30])
data = np.setxor1d(arr1, arr2, assume_unique=True)
print(data)
输出:
[ 1 2 3 90 100]
结论
到此,我们就结束了这个话题。如果你遇到任何问题,欢迎在下面评论。更多与 Python 编程相关的帖子,请继续关注我们。
在那之前,学习愉快!!🙂
Numpy Sin 完全指南
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-sin
这是系列 NumPy 三角函数 的第一个教程。在这门课中,我们将通过例子学习 NumPy 库提供的三角函数。
你一定计算过某个特定角度的正弦,并且得到的结果在 [-1,1] 范围内。正弦运算也可以在数组上执行。这就是 Python 的 NumPy 库发挥重要作用的地方。
NumPy 提供了大量的高级数学函数来操作数组。
在本教程中,我们将学习如何使用 NumPy sin 函数,并通过示例帮助您更好地理解它。我们还将使用 Matplotlib 库绘制 sin 函数的图形。
让我们开始吧。
什么是 NumPy 罪?
NumPy 提供了许多可以在多维数组上执行的数学函数,而numpy.sin
是 NumPy 库提供的三角函数之一。
注意:numpy.sin
计算一个单一数字的三角正弦值以及角度的 Numpy 数组。
建议阅读:NumPy 数组简介
先决条件
- 您的系统必须安装最新版本的 python,可以从https://www.python.org/downloads/安装
- Numpy 必须安装在您的系统上,执行以下命令安装最新版本的 Numpy:
pip install numpy
- 您可以使用自己选择的任何 IDE。我推荐使用 Jupyter Notebook,它可以通过执行以下命令来安装:
pip install jupyter
设置环境
-
创建一个文件夹并在“终端”中打开它
-
执行以下命令打开 Jupyter 记事本:
jupyter notebook
- 点击
New
按钮,选择 Python 3(ipykernel)
在 Jupyter 中创建了一个新的无标题笔记本,我们将在其中编写代码。
Numpy Sin 函数的基本语法
Numpy sin 函数将一个以弧度为单位的角度作为参数。然而,角度在度中也可以作为自变量给出。
**Syntax:** numpy.sin(input)
其中输入可以是单个数字,也可以是 NumPy 数组
使用 Numpy Sin 计算角度的正弦值
现在让我们开始使用 numpy sin 函数,以便更好地理解它的工作原理。
使用 Numpy Sin 函数计算
import numpy as np
print("Sine of 0 is :",np.sin(0))
print("Sine of pi/2 radians is :",np.sin(np.pi/2))
print("Sine of 3pi/2 radians is :",np.sin(3*np.pi/2))
输出
Sine of 0 is : 0.0
Sine of pi/2 radians is : 1.0
Sine of 3pi/2 radians is : -1.0
注意:在 Jupyter 笔记本的每个单元格中写完代码后,点击shift + enter
以获得输出。
在上面的代码片段中,以弧度为单位的角度作为参数传递给 np.sin()。
现在,让我们看看如何将角度作为参数传递给 np.sin()函数。
将 Numpy Sin 与 deg2rad 函数相结合
为了计算正弦函数的自变量为度的角度的正弦值,使用函数deg2rad
。
import numpy as np
print("Sine of 45 degrees is :",np.sin(np.deg2rad(45)))
print("Sine of 60 degrees is :",np.sin(np.deg2rad(60)))
print("Sine of 90 degrees is :",np.sin(np.deg2rad(90)))
print("Sine of 270 degrees is :",np.sin(np.deg2rad(270)))
输出
Sine of 45 degrees is : 0.7071067811865476
Sine of 60 degrees is : 0.8660254037844386
Sine of 90 degrees is : 1.0
Sine of 270 degrees is : -1.0
注意:把角度(以度为单位)转换成弧度真的很简单,只要把numpy.pi/180
乘以角度(以度为单位)就行了。
现在,让我们了解如何对一组角度执行正弦运算。
计算角度数组的正弦值
s in 函数以弧度作为角度参数,因此在对 NumPy 数组 使用 sin 函数时,我们必须确保数组的元素被转换为弧度。
计算 Numpy 数组的正弦值
在这个代码片段中,使用numpy.array
创建了一个 NumPy 数组。
import numpy as np
a = np.array((0 , 30 , 45 , 60 , 90))
print("Sine Values :\n",np.sin(a*np.pi/180))
输出
Sine Values :
[0\. , 0.5 , 0.70710678 , 0.8660254 , 1\. ]
- 我们用 5 个元素初始化NumPy 数组。
- 然后,NumPy 数组的每个元素乘以作为参数传递给
np.sin()
的np.pi/180
。 - 每个元素的正弦被计算并存储在一个 NumPy 数组中,我们得到这个数组作为输出。
计算均匀间隔的 NumPy 数组的正弦值
在这段代码中,我们将使用NumPy.linspace
创建一个由 10 个等间距的值组成的 NumPy 数组。
import numpy as np
b = np.linspace(-np.pi,np.pi,10)
print("Printing the NumPy Array:",b)
print("\n")
print("Sine Values :",np.sin(b))
- 我们创建一个 NumPy 数组,从
-pi
到pi
有 10 个均匀分布的值,并把它作为参数传递给np.sin()
。 - NumPy 数组中的值已经以弧度表示,因此每个值的正弦值都被计算并存储在 NumPy 数组中。
输出
Printing the NumPy Array: [-3.14159265 -2.44346095 -1.74532925 -1.04719755 -0.34906585 0.34906585
1.04719755 1.74532925 2.44346095 3.14159265]
Sine Values : [-1.22464680e-16 -6.42787610e-01 -9.84807753e-01 -8.66025404e-01
-3.42020143e-01 3.42020143e-01 8.66025404e-01 9.84807753e-01
6.42787610e-01 1.22464680e-16]
- 输出看起来很奇怪,因为所有计算出的正弦值都是用科学符号表示的。
- 例如,sin(pi)等于 0,在上述输出中,pi 的计算正弦值是一个非常大的量,其指数为 10^(-16) ,等于 0。
这就是使用 NumPy Sin 函数的全部内容,它使用一个数字作为参数,一个 NumPy 数组作为参数。我建议在阅读本教程的同时编写代码。
可视化正弦函数
第一步是安装 Matplotlib 库:
pip install matplotlib
安装完成后,我们准备编码,让我们开始吧。
import numpy as np
# Importing the Matplotlib Library
import matplotlib.pyplot as plt
# Creating a NumPy Array of 30 evenly-spaced elements
a = np.linspace((-2*np.pi),(2*np.pi),30)
# Storing the sine values in a NumPy Array
b = np.sin(a)
plt.plot(a, b, color = "red", marker = "o")
plt.title("numpy.sin()")
plt.xlabel("X")
plt.ylabel("Y")
plt.show()
输出
Sine Plot
**plt.plot()**
函数用于绘制带四个参数的正弦函数。
- 第个参数是角度的 NumPy 数组(在第 7 行创建),绘制在 X 轴(水平轴)上。
- 第二个参数是计算出的正弦值的 NumPy 数组,绘制在 Y 轴(垂直轴)上。
- 第三个参数是绘图的颜色。
- 第四个参数是标记值,用指定的标记强调每个点。有不同类型的标记可用于表示曲线上的点。
**plt.title()**
功能用于设置地块的标题。
**plt.xlabel()**
函数用来给图上的横轴命名。同样,**plt.ylabel()**
函数用于给绘图上的垂直轴命名。
**plt.show()**
用于显示曲线绘图。
您已经成功绘制了正弦曲线。
摘要
在本教程中,我们通过例子了解了如何使用 NumPy Sin 函数。如果你使用的是 Jupyter Notebook,那么在每个单元格中写完每一行代码后,按shift+enter
来获得输出。你的任务是使用 NumPy Sin 函数来计算你选择的更多值的正弦。
在下一个教程中,我们将学习 NumPy Cos 函数。在此之前,继续学习并浏览两遍这篇文章,在浏览教程的同时练习这些代码。
参考
num py documentation–num py sin
numpy sinh–双曲正弦,基于元素
原文:https://www.askpython.com/python-modules/numpy/numpy-sinh-hyperbolic-sine
你一定听说过双曲函数。如果没有,你可能熟悉三角函数,比如正弦、余弦、正切、余切、割线和余割,以及其他像斜边、底和垂线。
今天我们将学习正弦双曲函数。在开始之前,让我们了解一下什么是双曲函数。
什么是双曲函数?
双曲线函数也有点类似于 三角函数 。
普通三角函数和双曲函数之间的唯一区别是,三角函数定义圆(圆弧度或角度)内的值,而双曲函数定义双曲线而不是圆内的值。
这些点构成了单位双曲线的右半部分。下面描述了双曲函数的一些重要公式。让我们看看它们。
什么是双曲 sin 或 sinh?
这也是三个重要的双曲函数。今天我们要学习双曲正弦函数。
下面我们也可以用代码的形式来表示 sinh 函数。
sinh (x) = 1/2 * (np.exp(x) - np.exp(-x))
使用 numpy.sinh()
在我们的代码片段中,我们不打算用上面的(我们不打算用公式来写)。python 中的 NumPy 库提供了一个预定义的双曲正弦函数 NumPy.sin()。我们将使用相同的。在本教程中,我们将学习如何找到弧度和复数值的双曲正弦函数。
numpy.sinh()的语法
让我们快速看一下下面的语法。
numpy.sinh(x, out=None, where=True, casting='same_kind', order='K', subok : [bool, datatype])
在上面的语法中,我们传递一些参数,如下所示:
- x: 它可以是包含弧度值的变量,也可以是包含某个值的数组
- out: 存储结果的位置。如果提供了,它必须具有与输入 x 相似的形状。如果没有提供或没有提供,则返回新的值或结果。这是可选的。
- 当条件为真时,我们必须得到我们的结果或输出;当条件为假时,我们将得不到任何结果。这是可选的。y 默认其值为真。
- casting='same_kind': 表示只允许 float64 到 float32 的值或结果。该函数在此范围或数据类型中呼喊 cast 值。
- order = 'K': 它总是以 K 排序的形式产生一个输出数组。(注意:有四种类型的订单:{‘K’,‘C’,‘F’,‘A’})。这是可选的。
- subok:【bool,datatype】是否生成结果的子类。如果为真,则提供子类的名称。它返回一个与给定数组具有相同形状和类型的数组。也是可选的。
现在,我们将在代码片段中实现相同的方法或功能。
np.sinh()用于单输入
我们将传递给 x 的单个输入(即math.pi/3
) 。将我们的结果加载到一个名为**output**
的变量中并打印出来。
#importing required modules
import numpy as np
import math
output = np.sinh(math.pi/3)
output
上面的代码应该给出如下输出。
1.2493670505239751
np.sinh()用于多输入或数组
我们要以数组的形式给 x 传递五个输入(即0, math.pi / 2, math.pi, 3 * math.pi/2, 2 * math.pi
)。并将我们的结果加载到一个名为another_output
的变量中并打印出来。
#providig multi input in the form of array
import numpy as np
import math
input = [0, math.pi / 2, math.pi, 3 * math.pi/2, 2 * math.pi]
another_output = np.sinh(input)
another_output
上面的代码应该给出如下输出。
array([ 0\. , 2.3012989 , 11.54873936, 55.6543976 ,
267.74489404])
提供可选的输出变量
让我们回忆一件小事。当我们讨论我们的NumPy.cosh()
方法的语法和参数时。有一个参数是“out”。它是一个存储结果的位置。如果提供了,它必须具有与输入 x 相似的形状。如果没有提供或没有提供,则返回新的值或结果。是可选的。在这个方法中,我们将看到如何尝试这个参数。
在这个代码片段中,我们将提供一个可选的输出变量,输出/结果将被加载到这个变量中。看看下面是如何实现的。
import numpy as np
import math
optional_output = np.array([0, 0, 0, 0, 0], dtype='d')
np.sinh(input, optional_output)
different_output = np.sinh(input)
您可以看到我们已经创建了一个名为“optional_output
”的数组,它的形状与我们的输入数组相似。在我们的numpy.sinh() method,
中,我们已经将这个数组作为“out”的值进行了传递。
得到的数组将被加载到这个数组中。通过打印相同的内容,我们可以得到我们的结果。
print(optional_output)
print(different_output)
[ 0\. 2.3012989 11.54873936 55.6543976 267.74489404]
[ 0\. 2.3012989 11.54873936 55.6543976 267.74489404]
np.sinh()用于复数输入
现在,在我们的最后一段代码中,我们将输入一个复数并得到双曲正弦结果。下面我们来快速看一下。
import numpy as np
import math
import cmath
a = 2.0
b = 3.0
z = complex(a,b)
c = np.sinh(z)
为了使用一个复杂变量,我们需要导入一个名为**cmath**
的库。然后使用 complex()
方法准备好我们的复数,并在我们的 numpy.sinh()
方法中传递相同的内容,我们将得到我们的结果。让我们打印我们的结果。
print(z)
(2+3j)
print(c)
(-3.59056458998578+0.5309210862485197j)
在图表上绘制 Numpy.sinh()
import numpy as np
import math
import matplotlib.pyplot as plt
input = [0, math.pi / 2, math.pi, 3 * math.pi/2, 2 * math.pi]
output_array = np.sinh(input)
plt.xlabel("input")
plt.ylabel("output_array")
plt.plot(input, output_array, color = 'green', marker = "*")
众所周知,为了在图上绘制一些东西,我们需要导入一个名为 Matplotlib 的附加库。我们在函数实现中传递名为 input 的多值数组。我们把我们的输出加载到" output_array
中后,实现了我们的功能。毕竟,我们用输入和输出数组表示了我们的函数,并得到了下面的结果。
摘要
就这样,我们完成了今天的文章。我们学习了这个方法及其参数。我们通过传递各种值并获得预期的结果来练习我们的代码片段。这样,对于双曲余弦和双曲正切,我们也可以得到相同的结果。我们必须带着这些激动人心的话题再次造访。谢谢你。
Numpy 间距函数:完全指南
原文:https://www.askpython.com/python-modules/numpy/numpy-spacing
在本文中,我们将尝试理解 Python 的 NumPy 包中的间距函数。Python 包 NumPy 用于操作数组。使用 NumPy 可以在一个数组上执行许多数学运算。
它提供了一个庞大的高级数学函数库来处理这些数组和矩阵,并提供了强大的数据结构来确保使用数组和矩阵进行高效计算。2005 年,特拉维斯·奥列芬特开发了 NumPy。您可以免费使用它,因为它是一个开源项目。
为什么要用间距函数?
使用 NumPy 编程语言中的 NumPy.spacing()函数计算输入值 x 和最邻近整数之间的距离。它返回一个标量值,用于测量输入值 x 和最接近的相邻数字之间的距离。
Numpy 间距的语法
numpy.spacing(x, /, out=None, *, where=True)
参数
- x :数组 _like
- 需要
- 要查找其间距的值。
- out:数组、None 或 n array 和 None 的元组,
- 可选择的
- 一个保存结果的地方。如果提供的话,它必须有一个输入广播到的形式。在没有任何输入或没有输入的情况下,返回一个新分配的数组。元组的长度(仅作为关键字参数可用)必须与输出的数量相匹配。
- 其中:array_like,
- 可选择的
- 这种情况是通过输入宣布的。在条件为真的点上,ufunc 结果将被设置为 out 数组。外部数组将在所有其他地方保持其初始值。应该注意的是,如果条件为假,由缺省 out=None 形成的未初始化 out 数组中的位置将继续未初始化。
- **kwargs
- 可选择的
- 对于其他仅包含关键字的参数,请参见 ufunc 文档。
实现 Numpy 间距
在实现间距函数之前,请确保在工作 IDE 中安装/导入 NumPy 包。下面一行代码用于导入 NumPy。
import numpy as np
一位数的实现
x = np.spacing(10)
print(x)
Implementation
在阵列上实现
arr = (10,20,30,50,1200)
y = np.spacing(arr)
print(y)
Implementation
输出
代表输入值x
(此处为 10 或值的元组)和最近的相邻数字之间距离的标量值。
摘要
在本文中,我们理解了 Python 中 Numpy 库的 spacing()函数的基本语法和实现。
参考
https://numpy . org/doc/stable/reference/generated/numpy . spacing . html
numpy . square()-以简单的方式解释
原文:https://www.askpython.com/python-modules/numpy/numpy-square
大家好!在本教程中,我们将学习 NumPy square 函数。这是一个易于理解和使用的简单函数。那么,我们开始吧。
什么是 NumPy 广场?
**NumPy square**
是 NumPy 库的数学函数之一,计算输入数字的平方值。是的,根据定义就是这么简单。它可以用于实数和复数。一个数的平方等于该数乘以它自己。
NumPy 正方形的语法
让我们看看 NumPy square 函数的语法。
numpy.square(input)
这里,输入可以是单个数字、数字的 NumPy 数组以及复数。让我们写代码来更好地理解函数。
使用 NumPy square
现在让我们开始研究 Numpy.square()方法,通过例子来理解它。
单个数的 NumPy 平方
import numpy as np
print("Square of 5 is :",np.square(-5))
print("Square of 2.5 is :",np.square(2.5))
print("Square of 10 is :",np.square(10))
print("Square of 13.345 is :",np.square(13.345))
print("Square of -19.93 is :",np.square(-19.93))
输出
Square of 5 is : 25
Square of 2.5 is : 6.25
Square of 10 is : 100
Square of 13.345 is : 178.08902500000002
Square of -19.93 is : 397.2049
上面的输出非常明显。在最后一个例子中,我们传递了一个负数作为函数的输入,输出是一个正数。
数字数组的数字平方
让我们看一些例子,在这些例子中,我们将使用 NumPy 数组和函数。
import numpy as np
# NumPy Array of Integral Values
a = np.array((3 , -4 , 5 , 12 , 499))
print("Input Array:\n",a)
print("Square Values:\n",np.square(a))
# NumPy Array of Floating Point Values
b = np.array((0.43 , -2.5 , 9.23 , 4.57 , 6.5))
print("Input Array:\n",b)
print("Square Values:\n",np.square(b))
输出
Input Array:
[ 3 -4 5 12 499]
Square Values:
[ 9 16 25 144 249001]
Input Array:
[ 0.43 -2.5 9.23 4.57 6.5 ]
Square Values:
[ 0.1849 6.25 85.1929 20.8849 42.25 ]
你们只有一个任务,必须使用 NumPy square 函数和一个二维 NumPy 数组,并观察输出。
复数的 NumPy 平方
现在,让我们使用复数的 NumPy square 函数。
import numpy as np
print("The square of 4+5j is:",np.square(4+5j))
print("The square of -1+0.5j is:",np.square(-1+0.5j))
输出
The square of 4+5j is: (-9+40j)
The square of -1+0.5j is: (0.75-1j)
计算复数平方背后的数学真的很有趣。它使用复数的一些基本公式和简单恒等式。
数字正方形的图形表示
现在,让我们使用 Matplotlib 库绘制 NumPy 平方曲线。
import numpy as np
import matplotlib.pyplot as plt
a = np.linspace(-10 , 10 , 30)
b = np.square(a)
plt.plot(a , b , color = "green" , marker = "o")
plt.title("numpy.square()")
plt.xlabel("X")
plt.ylabel("Y")
plt.show()
输出
NumPy Square Plot
好了,你画出了 NumPy 平方的曲线。至此,我们已经完成了 NumPy square 函数,执行了文章中给出的任务,并在阅读文章的同时练习了代码。
参考
Numpy . Subtract():Python 中如何用 NumPy 减去数字?
原文:https://www.askpython.com/python-modules/numpy/numpy-subtract
基本的算术运算之一是从一个实体中减去另一个实体。虽然这可能是一个不涉及编程语言(如 Python、等)计算能力的显而易见的问题,但在处理一次性数据时,人们可能会低估这个操作。
本文使用来自 numpy 库的 subtract( ) 函数来研究不同的方差,如下所示。
- 减去两个标量
- 减去两个数组
- 减去一个数组&一个标量
- 减去不同大小的数组
- 选择性减法
也读作:【Numpy Dot()——矢量、Numpy、计算点积的完全指南
numpy . subtract()的语法
在开始解决例子之前,让我们首先理解这个函数的语法。
numpy.subtract(x1, x2, where=True, dtype=None)
在哪里,
- x1,x2–是要进行减法运算的标量或一维数组或二维数组
- 其中–用于指定数组中的位置,该位置只需通过键入 TRUE 进行减法运算,而其他实体则无需进行减法运算
- dtype–用于指定作为结果返回的数据类型
在开始减去实体之前,使用下面的代码导入 numpy 库。
import numpy as np
使用 numpy.subtract()减去两个标量
标量是那些没有任何方向的量(你们学校的物理有印象吗?)意味着它们只是一个数字,不像数组拥有一个数字集合。现在让我们使用 subtract( ) 函数来减去两个数。
a = 10
b = 5
np.subtract(a,b)
Subtracting Scalars
使用 numpy.subtract()减去两个数组
现在我们将继续减去一对相同大小的一维数组。没错。为了让 subtract( ) 函数按预期执行,接受减法运算的数组必须具有相同的大小。可以使用如下所示的 array( ) 函数来输入数组。
ar_1 = np.array([2,1,0])
ar_2 = np.array([4,3,5])
现在使用下面的代码从数组 1 中减去数组 2。
np.subtract(ar_1, ar_2)
Subtracting One-Dimensional Arrays
减法也可以通过使用下面的代码使用减号运算符(-)来执行。
ar_1-ar_2
Subtracting Using Minus Operator
使用 numpy.subtract()减去一个数组&一个标量:
虽然检查应该被减去的两个数组的大小是否相同很重要,但是 Python 为我们提供了从数组中减去标量的灵活性。要理解这里发生了什么,人们应该知道这是如何执行的。
提供的标量将从数组的每个元素中删除,并将提供结果。让我们从创建一个数组开始,这次是二维的。
ar_3 = np.array([[2,1,0],[3,4,5],[6,7,8]])
一旦完成, subtract( ) 函数将被部署来从上述数组的每个元素中删除“10”。
np.subtract(ar_3, 10)
Subtracting A Scalar From A 2D Array
使用 numpy.subtract()减去不同大小的数组
这可能与本文前面给出的声明相矛盾,即使用 subtract( ) 函数时,两个数组的大小应该相同。嗯,这仍然是真的,但有一个例外!
Python 允许减去两个不同大小的数组,前提是两个数组中的列数相等。因此,让我们创建两个符合这一要求的数组。
ar_2 = np.array([4,3,5])
ar_3 = np.array([[2,1,0],[3,4,5],[6,7,8]])
现在可以调用 subtract( ) 函数来完成它的任务。
np.subtract(ar_3, ar_2)
Subtracting Arrays Of Different Sizes
使用 numpy.subtract()进行选择性减法
在这种技术中,应该使用 subtract( ) 函数的 where 组件。如前所述,这将选择性地只在函数被给定为真的地方进行减法,并用被减法的数组的实体替换其他地方。
ar_3 = np.array([[2,1,0],[3,4,5],[6,7,8]])
ar_4 = np.array([[0,9,10],[11,3,9],[7,4,7]])
R = np.subtract(ar_3,ar_4,where=[False, True, False])
Selective Subtraction
很明显,结果数组的第一个和第三个位置的元素被替换为 ar_4 的元素,而减法是按照指示在第二个位置执行的。
结论:
既然我们已经到了这篇文章的结尾,希望它已经详细阐述了如何使用 Python 编程减去实体。这里有另一篇文章详细介绍了如何在 Python 中乘实体。在 AskPython 中还有许多其他有趣的&文章,这些文章可能对那些希望提高 Python 水平的人有很大帮助。当你享受这些的时候,再见!
NumPy Sum–完整指南
你好,欢迎来到这个关于 Numpy 求和法的教程。在本教程中,我们将学习 NumPy sum 方法,也将看到许多相同的例子。让我们开始吧!
什么是 NumPy Sum?
NumPy 中的 sum 方法是一个返回数组总和的函数。它可以是整个数组的总和、沿行总和或沿列总和。我们将在本教程的下一节看到每个例子。
NumPy 和的语法
让我们首先看看 NumPy sum 函数的语法。
numpy.sum(a, axis=None, dtype=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
| 参数 | 描述 | 必需/可选 |
| (类似数组) | 要求和的元素。 | 需要 |
| 轴 | 要对数组求和的轴。它可以是 axis=0,即沿列,或者 axis=1,即沿行,或者 axis=None,这意味着对整个数组求和。 | 可选择的 |
| 数据类型 | 要返回的数组的数据类型。 | 可选择的 |
| 在外 | 放置结果的替代输出数组。它必须具有与预期输出相同的形状。 | 可选择的 |
| keepdims (bool) | 如果设置为真,减少的轴将作为尺寸为 1 的尺寸留在结果中。使用此选项,结果将根据输入数组正确传播。 | 可选择的 |
| 最初的 | 总和的起始值。 | 可选择的 |
| 在哪里 | 要包含在总和中的元素。 | 可选择的 |
返回:
一个与 a 形状相同的数组,包含沿给定轴的和,并移除指定轴。如果 axis=None,则返回一个标量,它是整个数组的总和。
Numpy.sum()方法的示例
现在让我们开始使用 numpy.sum 方法,这样我们可以理解输出。
整个数组的 Numpy.sum()
一维数组
import numpy as np
a = [2, 5, 3, 8, 4]
sum = np.sum(a)
print("a =", a)
print("Sum of the array =", sum)
输出:
a = [2, 5, 3, 8, 4]
Sum of the array = 22
数组之和= 2+5+3+8+4 = 17。
二维数组
import numpy as np
a = [[2, 5, 4], [3, 2, 1]]
sum = np.sum(a)
print("a =", a)
print("Sum of the array =", sum)
输出:
a = [[2, 5, 4], [3, 2, 1]]
Sum of the array = 17
数组之和= 2+5+4+3+2+1 = 17
沿轴的 Numpy.sum()
按列求和
import numpy as np
a = [[2, 5, 4],
[3, 2, 1]]
# sum along axis=0 i.e. columns
sum = np.sum(a, axis=0)
print("a =", a)
print("Sum of the array =", sum)
输出:
a = [[2, 5, 4], [3, 2, 1]]
Sum of the array = [5 7 5]
第 0 列总和= 2+3 = 5
第 1 列总和= 5+2 = 7
第 2 列总和= 4+1 = 5
逐行求和
import numpy as np
a = [[2, 5, 4],
[3, 2, 1]]
# sum along axis=1 i.e. rows
sum = np.sum(a, axis=1)
print("a =", a)
print("Sum of the array =", sum)
输出:
a = [[2, 5, 4], [3, 2, 1]]
Sum of the array = [11 6]
第 0 行总和= 2+5+4 = 11
第 1 行总和= 3+2+1 = 6
空数组的 Numpy.sum()
import numpy as np
a = []
b = [[]]
sum_a = np.sum(a)
print("a =", a)
print("Sum of the 1-d empty array =", sum_a)
sum_b = np.sum(b)
print("b =", b)
print("Sum of the 2-d empty array =", sum_b)
输出:
a = []
Sum of the 1-d empty array = 0.0
b = [[]]
Sum of the 2-d empty array = 0.0
空数组的和是中性元素,即 0。
以浮点数据类型返回数组的 Numpy.sum()
这与上面的例子相同,只是这里返回值是浮点数据类型。
整个数组的总和
import numpy as np
a = [[3, 12, 4], [3, 5, 1]]
sum = np.sum(a, dtype=float)
print("a =", a)
print("Sum of the array =", sum)
输出:
a = [[3, 12, 4], [3, 5, 1]]
Sum of the array = 28.0
按列求和
import numpy as np
a = [[3, 12, 4],
[3, 5, 1]]
# sum along axis=0 i.e. columns
sum = np.sum(a, dtype=float, axis=0)
print("a =", a)
print("Sum of the array =", sum)
输出:
a = [[3, 12, 4], [3, 5, 1]]
Sum of the array = [ 6\. 17\. 5.]
逐行求和
import numpy as np
a = [[3, 12, 4],
[3, 5, 1]]
# sum along axis=1 i.e. rows
sum = np.sum(a, dtype=float, axis=1)
print("a =", a)
print("Sum of the array =", sum)
输出:
a = [[3, 12, 4], [3, 5, 1]]
Sum of the array = [19\. 9.]
结论
仅此而已!在本教程中,我们学习了 Numpy sum 方法,并使用该方法练习了不同类型的示例。
参考
NumPy Tan 完整指南
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-tan
欢迎来到系列 NumPy 三角函数的第三篇教程。在本教程中,我们将了解 NumPy Tan 函数。切线是切线的简称。
- 当给定的输入是 pi/2 的奇数倍时,即 pi/2、-pi/2、3pi/2、-3pi/2 等,Tan 未定义。
- 有一个有趣的关系是: tan(x) = sin(x)/cos(x) 。
我们将练习不同类型的示例,并使用 Python 的 Matplotlib 库绘制 NumPy Tan 的图形。
什么是 NumPy Tan?
- NumPy Tan 也是 NumPy 库提供的三角函数之一,它计算单个数字和角度的 NumPy 数组的三角正切值。
- NumPy Tan 在元素方面相当于
np.sin(x)/np.cos(x)
。 - NumPy Tan 函数可以作为
numpy.tan
访问。
数字谭的语法
语法: numpy.tan(input)
其中输入可以是单个角度,也可以是角度的 NumPy 数组。
与 Numpy Tan 一起处理不同类型的值
让我们尝试一些 NumPy Tan 函数的例子来帮助我们更好地理解它。
Pi 值上的 NumPy Tan
import numpy as np
print("Tan of 0 is :",np.tan(0))
print("Tan of pi/6 is :",np.tan(np.pi/6))
print("Tan of pi/4 is :",np.tan(np.pi/4))
print("Tan of pi/3 is :",np.tan(np.pi/3))
print("Tan of pi is :",np.tan(np.pi))
输出
Tan of 0 is : 0.0
Tan of pi/6 is : 0.5773502691896257
Tan of pi/4 is : 0.9999999999999999
Tan of pi/3 is : 1.7320508075688767
Tan of pi is : -1.2246467991473532e-16
- π的 NumPy 正切提供了不同的输出——该输出采用科学记数法,等于 0。
任务:计算np.tan(np.pi/2)
、np.tan(3*np.pi/2)
并观察输出。
现在,让我们看看如何将角度作为参数传递给 numpy.tan 函数。
带 Deg2Rad 功能的 NumPy Tan
为了计算正切函数的自变量为度的角的正切值,使用了函数deg2rad
。
import numpy as np
print("Tangent of 30 degrees is :",np.sin(np.deg2rad(30)))
print("Tangent of 45 degrees is :",np.sin(np.deg2rad(45)))
print("Tangent of 60 degrees is :",np.sin(np.deg2rad(60)))
print("Tangent of 180 degrees is :",np.sin(np.deg2rad(180)))
输出
Tangent of 30 degrees is : 0.49999999999999994
Tangent of 45 degrees is : 0.7071067811865476
Tangent of 60 degrees is : 0.8660254037844386
Tangent of 180 degrees is : 1.2246467991473532e-16
注意:一个类似的函数是**rad2deg**
,它以弧度为单位获取一个角度,并将其转换为度数。该函数可与NumPy 库的三角函数一起使用。尝试使用具有不同输入值的函数,并观察输出🙂
现在,让我们看看如何计算一组角度的正切值。
角度数组上的 NumPy Tan
tan 函数也接受一个 NumPy 数组作为参数,但是我们必须确保角度被转换成弧度。
import numpy as np
# A NumPy array with all the angles in degrees
a = np.array((0 , 30 , 45 , 60 , 180))
print("Tangent Values :\n",np.tan(a*np.pi/180))
# A NumPy array with all the angles is radians
b = np.array((0 , np.pi/2 , np.pi/3 , np.pi))
print("Tangent Values :\n",np.tan(b))
输出
Tangent Values :
[ 0.00000000e+00 5.77350269e-01 1.00000000e+00 1.73205081e+00
-1.22464680e-16]
Tangent Values :
[ 0.00000000e+00 1.63312394e+16 1.73205081e+00 -1.22464680e-16]
在上面的代码片段中,输出是一个 NumPy 数组,值采用科学记数法。
均匀间隔的 NumPy 阵列上的 NumPy Tan
在这个例子中,我们将使用numpy.linspace
创建一个由 30 个均匀分布的值组成的 NumPy 数组。
import numpy as np
a = np.linspace(-(np.pi/4) , np.pi/4 , 30)
print("Tangent Values: ",np.tan(a))
输出
Tangent Values: [-1\. -0.89714006 -0.80382248 -0.71829915 -0.63918754 -0.5653756
-0.49595431 -0.43016871 -0.36738181 -0.30704735 -0.24868885 -0.19188316
-0.13624728 -0.08142734 -0.02708932 0.02708932 0.08142734 0.13624728
0.19188316 0.24868885 0.30704735 0.36738181 0.43016871 0.49595431
0.5653756 0.63918754 0.71829915 0.80382248 0.89714006 1\. ]
-
这里,我们使用
numpy.linspace
创建了一个 NumPy 数组,它有 30 个均匀间隔的弧度角,范围从-π/4到π/4。 -
输出也是一个 NumPy 数组,它是数组元素的正切。
现在,让我们使用 Matplotlib 库来可视化 Tan 函数的实际外观。
可视化 Numpy Tan 函数
import numpy as np
# Importing the Matplotlib Library
import matplotlib.pyplot as plt
# Creating a NumPy Array of 30 evenly-spaced elements
a = np.linspace((-np.pi/4),(np.pi/4),30)
# Storing the tangent values in a NumPy Array
b = np.tan(a)
plt.plot(a, b, color = "green", marker = "o")
plt.title("numpy.tan()")
plt.xlabel("X")
plt.ylabel("Y")
plt.show()
输出
Tangent Plot
这就对了,你已经成功地绘制了切线曲线。
摘要
这就是关于 NumPy Tan 函数的内容,在阅读教程的同时练习这些代码将有助于更好地理解 NumPy Tan 函数。别忘了做教程里给的任务。
在下一个教程中,我们将从反三角函数开始。在那之前请继续关注。
参考
num py 文档–num py tan
numpy tanh–双曲正切元素。
原文:https://www.askpython.com/python-modules/numpy/numpy-tanh-hyperbolic-tangent
是时候使用元素级 Numpy 双曲正切函数了。我们将使用我们的谷歌协作来做同样的事情。我们大多数人都有过在谷歌协作室工作的经历,对吗?它为我们提供了一个更好的用户友好的平台来使用 python 语言。让我们开始吧。
什么是双曲函数?
首先让我们了解一下什么是双曲函数。这与普通的 三角函数 有何不同?
双曲函数也有点类似于三角函数。普通三角函数和双曲函数之间的唯一区别是,三角函数定义圆(圆弧度)内的值,而双曲函数定义双曲线而不是圆内的值。这些点构成了单位双曲线的右半部分。
下面描述了双曲函数的三个重要公式。让我们看看它们。
什么是双曲线谭?
这也是三个最有用的双曲函数。今天我们要学习其中的一个,就是双曲正切函数。下面我们也可以用代码的形式来表示这个函数。
numpy.tanh(x) = np.sinh(x)/np.cosh(x)
但是在我们今天的代码片段中,我们不打算在今天的实现中使用上述代码。我们有一个预定义的双曲正切函数,它是由 NumPy 库提供的。我们将使用相同的。
使用双曲线 tan
在本教程中,我们将学习如何找到弧度和复数值的双曲正切函数。让我们快速看一下下面的语法。
numpy.tanh(x, out=None, where=True, casting='same_kind', order='K', subok : [bool, datatype])
上述代码片段中使用的参数如下:
- x: 它可以是包含弧度值的变量,也可以是包含某个值的数组
- out: 存储结果的位置。如果提供了,它必须具有与输入 x 相似的形状。如果没有提供或没有提供,则返回新的值或结果。这是可选的。
- 当条件为真时,我们必须得到我们的结果或输出;当条件为假时,我们将得不到任何结果。这是可选的。y 默认其值为真。
- casting='same_kind': 表示只允许 float64 到 float32 的值或结果。该函数在此范围或数据类型中呼喊 cast 值。
- order = 'K': 它总是以 K 排序的形式产生一个输出数组。(注意:有四种类型的订单:{‘K’,‘C’,‘F’,‘A’})。这是可选的。
- subok:【bool,datatype】是否生成结果的子类。如果为真,则提供子类的名称。它返回一个与给定数组具有相同形状和类型的数组。也是可选的。
现在,我们将看到如何通过在不同的方法中传递不同的参数来实现这个函数。
方法 1:传递单值参数
我们将为 x(即math.pi/
5) 传递一个输入,并将结果加载到一个名为**output**
的变量中。
import numpy as np
import math
output = np.tanh(math.pi/5)
通过打印同样的内容,我们可以看到最终的输出。
print(output)
0.5568933069002107
方法 2:传递多值参数
在这个方法中,我们将以数组的形式传递 x 的多输入值(即0, math.pi / 2, math.pi, 3 * math.pi/2, 2 * math.pi
),并将结果加载到一个名为another_output
的变量中。
import numpy as np
import math
input = [0, math.pi / 2, math.pi, 3 * math.pi/2, 2 * math.pi]
another_output = np.tanh(input)
您可以看到我们已经创建了一个名为 input 的弧度数组,并在我们的Numpy.tanh()
方法中传递了相同的内容。我们将结果数组加载到变量 another_output 中。让我们打印相同的。
print(another_output)
[0\. 0.91715234 0.99627208 0.99983861 0.99999303]
方法 3:提供可选的输出变量
让我们回忆一件小事。当我们讨论我们的NumPy.tanh()
方法的语法和参数时。有一个参数是“out”。这是存储结果的位置。如果提供了,它必须具有与输入 x 相似的形状。如果没有提供或没有提供,则返回新的值或结果。这是可选的。在这个方法中,我们将看到如何尝试这个参数。
在这个代码片段中,我们将提供一个"optional output
"变量,输出/结果将被加载到这个变量中。看看下面是如何实现的。
import numpy as np
import math
#passing our optional_output array where the result is to be loaded
optional_output = np.array([0, 0, 0, 0, 0], dtype='d')
np.tanh(input, optional_output)
#implementing the same and loading the result into the different_array
different_output = np.tanh(input)
您可以看到我们已经创建了一个名为“optional_output
”的数组,它的形状与我们的输入数组相似。在我们的,numpy.tanh() method,
我们曾经走过同一个地方。得到的数组将被加载到这个数组中。让我们打印出来,看看效果如何。
print(optional_output)
print(different_output)
[0\. 0.91715234 0.99627208 0.99983861 0.99999303]
[0\. 0.91715234 0.99627208 0.99983861 0.99999303]
方法 4:将复杂变量作为参数传递
让我们传递一个复杂的变量作为参数,看看结果。
import numpy as np
import math
import cmath
a = 2.0
b = 3.0
z = complex(a,b)
c = np.tanh(z)
要使用复杂变量,我们需要导入一个名为cmath
的库。然后使用complex()
方法准备好我们的复杂变量,并在我们的numpy.tanh()
方法中传递相同的变量,我们将得到我们的结果。让我们打印我们的结果。
print(z)
print(c)
(2+3j)
(0.965385879022133-0.009884375038322492j)
Numpy.tanh()在图中的表示
output_array = np.tanh(input)
print(output_array)
import matplotlib.pyplot as plt
plt.xlabel("input")
plt.ylabel("output_array")
plt.plot(input, output_array, color = 'green', marker = "*")
众所周知,为了在图上绘制一些东西,我们需要导入一个名为 Matplotlib 的附加库。我们导入了相同的内容,并传递了在方法 2 中创建的输入数组。在实现我们的函数之后,我们将输出加载到“output_array
”中。毕竟,我们使用输入和输出数组来表示我们的函数,并得到如下结果。
结论
最后,我们今天报道了我们的文章。通过传递四种不同类型的参数,我们尝试了四种不同的方法。这样就可以实现其他双曲函数了。您可以通过使用相同的代码片段并用我们需要的双曲函数替换函数语法来尝试所有这些方法。否则,我们将再次访问相同的。谢谢你。
Numpy . tensordot()–如何使用 Numpy 计算 Tensordot 乘积?
原文:https://www.askpython.com/python-modules/numpy/numpy-tensordot
这篇文章将帮助你理解如何使用 numpy 库中的 tensordot( ) 函数计算张量点积。一旦一对要求点积的张量以数组的形式作为输入,函数 tensordot( ) 对指定轴上 a 和 b 元素的乘积求和。
也读:Numpy Trace:Python 中使用 Numpy 计算 Trace 的指南
让我们开始理解这个函数,首先使用下面的代码导入 numpy 库。
import numpy as np
我们将在以下各节中进一步探讨 tensordot( ) 函数。
- tensordot()函数的语法
- 计算张量点积
- 相似之处&不同之处numpy . dot()
tensordot()函数的语法
下面是有效运行 tensordot( ) 函数所需的构造。
numpy.tensordot(a, b, axes)
在哪里,
- a—作为第一张量的阵列状物体
- b—作为第二张量的阵列状物体
- 轴-可以是一个标量或类似数组的对象,指定计算点积所沿的轴
计算张量点积
在这一节中,让我们找出以 N 维数组形式给出的一对张量的张量点积,如下所示。
ar1 = np.array([[1, 3, 7], [2, 9, 4]])
ar2 = np.array([[5, 6], [8, 0], [1, 7]])
现在让我们部署 tensordot( ) 函数,将轴的方向指定为‘1’。
np.tensordot(ar1, ar2, axes=1)
一旦上面的代码运行,下面的计算将在后端发生,用于计算以数组形式返回的结果。
- 第一个张量第一行的第一个元素乘以第二个张量第一列的第一个元素(即 1×5 = 5)。
- 第一个张量第一行的第二个元素乘以第二个张量第一列的第二个元素(即 3×8 = 24)。
- 第一和第二张量(即 7×1 = 7)中随后的第三元素也是如此。为了让读者更好地理解,这里打印了一些输入。
Input Tensors Printed As Arrays
- 一旦完成,将上面推导的所有元素的乘积相加,得到张量点积第一行的第一个元素(即 5+24+7 = 36)。
- 对输入张量的后续行和列重复相同的过程,以找到张量点积的其他元素。
- 张量点积第一行的第二个元素是从(1×6) + (3×0) + (7×7) = 55 中检索的
- 张量点积第二行的第一个元素是从(2×5) + (9×8) + (4×1) = 86 中检索的
- 张量点积第二行的第二个元素是从(2×6) + (9×0) + (4×7) = 40 中检索的
下面是代码运行后我们得到的结果,我们可以发现上面详细描述的元素推理与下面显示的有惊人的相似之处。
Tensor Dot Product Calculated With Axes=1
与 numpy.dot()的异同
当相同的输入通过 numpy.dot( ) 函数运行时,得到的结果可能会有惊人的相似之处。
np.dot(ar1, ar2)
Results Of numpy.dot( )
这是因为在运行 tensordot( ) 函数时将轴设置为“1”会产生传统的矩阵点积,这解释了上述相似性。然而,将轴设置更改为零(0)会指示 tensordot( ) 需要计算的方向,从而产生不同的结果。
np.tensordot(ar1, ar2, axes=0)
Tensor Dot Product Calculated With Axes=0
计算上述结果背后的基本逻辑是将整个数组“ar2”乘以“ar1”的每个元素。第一个子数组是“ar2”与“ar1”的第一个元素相乘的结果~ 1!
结论
现在我们已经到了本文的结尾,希望它已经详细说明了如何使用来自 numpy 库中的 tensordot( ) 函数来计算给定张量对的 tensordot 乘积。这里有另一篇文章解释了 Python 中 numpy 的trace()函数。AskPython 中还有许多其他有趣且信息量大的文章,可能会对那些希望提高 Python 水平的人有很大帮助。当你享受这些的时候,再见!
Numpy 跟踪:使用 Python 中的 Numpy 计算跟踪的指南
原文:https://www.askpython.com/python-modules/numpy/numpy-trace
黑客帝国很好玩!不是电影,是数学的那个。在对矩阵的属性有了一个相当好的理解之后,一个人可以很好地挖掘它们的潜力&在广泛的应用中部署它们。数据加密和密码生成等等!
也读: Python 矩阵教程
这篇文章将帮助你理解矩阵的众多属性之一——矩阵轨迹。轨迹有助于计算任何给定矩阵中对角元素的总和。让我们从使用下面的代码导入 numpy 库开始。
import numpy as np
我们将通过下面的每一节进一步探索 trace( ) 函数。
- trace()函数的语法
- 计算二维数组的轨迹
- 计算三维数组的轨迹
- 使用偏移量计算轨迹
trace()函数的语法
trace( ) 函数对任意给定的 N 维数组的对角线上的所有元素求和,但事情并没有就此结束。它还附带了一些特性,比如下面的语法中给出的那些特性,
numpy.trace(a, offset=0, axis1=0, axis2=1, dtype=None, out=None)
在哪里,
- a—要计算轨迹的 N 维数组
- 偏移-一个可选的构造,用于从主对角线偏移轨迹计算。默认设置为零(0),也可以使用'+1 '或'-1 '分别正或负偏移主对角线
- axis 1—一个可选的构造,用于指定二维子数组的第一个轴,从该轴开始取对角线。默认设置为零(0)。
- axis 2—一个可选的构造,用于指定二维子数组的第二个轴,从该轴开始取对角线。默认设置为一(1)。
- dtype—一个可选的构造,默认设置为 none ,但是可以用来指定正在使用的数据类型
- out-一个可选的构造,默认情况下设置为 none ,但是可以用来存储结果
计算二维数组的轨迹
在导入了 numpy 库之后,让我们使用下面给出的代码来寻找二维数组的轨迹。
ar1 = np.array([[12, 5],
[5, 9]], dtype = int)
np.trace(ar1)
一旦上面的代码运行,下面的计算将在后端发生,用于计算以数组形式给出的矩阵的轨迹。
- 对角线开始的第一行的第一个元素与对角线结束的第二行的第二个元素相加。
- 然后返回两个元素的和(即 12+9 = 21)作为给定输入数组的轨迹。
如上所述,在最后一步中推导出的最终答案也可以在下图中看到代码运行时的结果。
Trace Calculated For A Two-Dimensional Array
计算三维数组的轨迹
在计算三维数组(如下所示)的轨迹时,也可以使用相同的技术。
ar2 = np.array([[2.1, 5.5, 8.8], [10.2, 7.3, 3.5], [4.7, 9.8, 6.3]], dtype=float)
np.trace(ar2, dtype=float)
Trace Calculated For A Three-Dimensional Array
因为已经指定了数据类型,所以添加了对角元素(2.1+7.3+6.3 = 15.7) &具有十进制值的结果已经作为给定输入数组的轨迹返回。
使用偏移计算轨迹
应为上述部分中使用的相同阵列计算轨迹,但对角线偏移'+1 '。
ar2 = np.array([[2.1, 5.5, 8.8], [10.2, 7.3, 3.5], [4.7, 9.8, 6.3]], dtype=float)
np.trace(ar2, offset=+1, dtype=float)
Trace Calculated With Offset
对角线元素现在是 5.5 & 3.5,其和 9.0 作为结果返回!
结论
既然我们已经到了本文的结尾,希望它已经详细阐述了如何使用来自 numpy 库中的 trace( ) 函数来计算任何给定矩阵的对角元素之和。下面是另一篇解释 Python 中 numpy 的 vdot ()函数的文章。AskPython 中还有许多其他有趣且信息量大的文章,可能会对那些希望提高 Python 水平的人有很大帮助。当你享受这些的时候,再见!
要知道普适的 NumPy 三角函数
原文:https://www.askpython.com/python/numpy-trigonometric-functions
读者朋友们,你们好!在本文中,我们将学习万能的 NumPy 三角函数来认识!
所以,让我们开始吧!🙂
为了与一起,NumPy 中的数学函数被框架为通用函数。这些通用(数学 NumPy 函数)对 NumPy 数组类进行操作,并对数据值执行元素操作。通用 NumPy 函数属于 Python 中的 numpy.ufunc 类。
在本主题的背景下,我们将重点关注以下类型的通用三角函数
- 通用三角函数
- 帮助我们进行度数和弧度值相互转换的函数
- 双曲线函数
- 计算斜边值
- 根据三角函数确定角度值
1。Numpy 三角函数
在本教程中,我们将使用以下通用数字三角函数——
- numpy.sin()函数:计算数组值的正弦分量。
- numpy.cos()函数:计算数组值的余弦分量。
- numpy.tan()函数:计算数组数据元素的正切值。
举例:
import numpy as np
arr = np.array([30,60,90])
val_sin = np.sin(arr)
print("Sine value",val_sin)
val_cos = np.cos(arr)
print("Cosine value",val_cos)
val_tan = np.tan(arr)
print("Tangent value",val_tan)
输出:
Sine value [-0.98803162 -0.30481062 0.89399666]
Cosine value [ 0.15425145 -0.95241298 -0.44807362]
Tangent value [-6.4053312 0.32004039 -1.99520041]
2.度数和弧度值之间的相互转换
在任何语言中执行三角函数运算时,我们都会遇到需要将角度转换为弧度的情况,反之亦然。
同样,NumPy 为我们提供了通用功能
- deg2rad :将角度的度数转换为弧度。
- rad2deg :将弧度角度转换为度数。
举例:
import numpy as np
arr = np.array([30,60,90])
rad = np.deg2rad(arr)
print("Radian values for the array having degree values:", rad)
arr_rad = np.array([0.52359878, 1.04719755, 1.57079633])
degree = np.rad2deg(arr_rad)
print("Degree values for the array having radian values:", degree)
输出:
Radian values for the array having degree values: [0.52359878 1.04719755 1.57079633]
Degree values for the array having radian values: [30.00000025 59.99999993 90.00000018]
3.根据三角值确定角度
以逆向工程的形式,我们现在给下面的函数输入三角值,并试图从中获得角度值
- 反正弦()函数:根据正弦值计算角度值。
- arccos()函数:根据余弦值计算角度值。
- arctan()函数:从正切值计算角度值。
举例:
import numpy as np
arr = np.array([1,0.5])
sin_ang = np.arcsin(arr)
print("Angle from the sin function:", sin_ang)
cos_ang = np.arccos(arr)
print("Angle from the cos function:", cos_ang)
tan_ang = np.arctan(arr)
print("Angle from the tan function:", tan_ang)
输出:
Angle from the sin function: [1.57079633 0.52359878]
Angle from the cos function: [0\. 1.04719755]
Angle from the tan function: [0.78539816 0.46364761]
4。斜边
使用 numpy.hypot()函数,我们可以通过向函数提供底值和高值来根据毕达哥拉斯的标准计算斜边值。
语法:
numpy.hypot() function
举例:
import numpy as np
b = 5
h = 8
hy = np.hypot(b, h)
print(hy)
输出:
9.433981132056603
5.双曲函数
NumPy 为我们提供了以下函数来计算给定值的双曲三角值:
- numpy.sinh()函数:计算数组值的双曲正弦值。
- numpy.cosh()函数:计算数组值的双曲余弦值。
- numpy.tanh()函数:计算数组值的双曲正切值。
举例:
import numpy as np
arr = np.array([30,60,90])
val_sin = np.sinh(arr)
print("Hyperbolic Sine value",val_sin)
val_cos = np.cosh(arr)
print("Hyperbolic Cosine value",val_cos)
val_tan = np.tanh(arr)
print("Hyperbolic Tangent value",val_tan)
输出:
Hyperbolic Sine value [5.34323729e+12 5.71003695e+25 6.10201647e+38]
Hyperbolic Cosine value [5.34323729e+12 5.71003695e+25 6.10201647e+38]
Hyperbolic Tangent value [1\. 1\. 1.]
结论
至此,我们已经结束了 NumPy 三角函数这篇文章。如果你遇到任何问题,欢迎在下面评论。更多关于 Python 编程的帖子,敬请关注我们!
在那之前,学习愉快!!🙂
numpy trunc()–按元素返回输入的截断值
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-truc
今天,我们将学习如何使用 trunc()函数在我们的计算机上获得输入的截断值。该函数类似于天花板和地板函数,但是具有稍微不同的域和范围。要使用这个函数,我们需要导入 NumPy 模块。一旦导入了 NumPy,我们就可以使用 trunc()函数来获取任何输入的截断值。
让我们先从理论上理解我们的trunc
概念,然后再在今天的计算机上实现。
Numpy.trunc()方法是什么?
标量 x 的截断值是比 x 更接近零的最近整数 y。请看下面的两个例子。
- -2.35 的截断值为-2.0 。最接近-2.35 的整数是-3 和-2。-2 比-3 更接近 0。所以-2.35 的截断值是-2.0。
- 3.35 的截断值为 3 。3.35 最接近的整数是 3 和 4。3 比 4 更接近 0。所以 3.35 的截断值是 3。
- 0 的截断值为 0,对于-3 为-3,对于 5 为 5。(整数的截断值与数字相同)
使用 Numpy.trun()
现在我们将看看如何在今天的代码片段中实现这个函数。让我们看看下面的语法。
numpy.trunc(x, out=None, where=True, casting='same_kind', order='K', subok : [bool, datatype])
上述代码片段中使用的参数如下:
- x: 它可以是包含弧度值的变量,也可以是包含某个值的数组
- out: 存储结果的位置。如果提供了,它必须具有与输入 x 相似的形状。如果没有提供或没有提供,则返回新的值或结果。这是可选的。
- 当条件为真时,我们必须得到我们的结果或输出;当条件为假时,我们将得不到任何结果。这是可选的。y 默认其值为真。
- casting='same_kind': 表示只允许 float64 到 float32 的值或结果。该函数在此范围或数据类型中呼喊 cast 值。
- order = 'K': 它总是以 K 排序的形式产生一个输出数组。(注意:有四种类型的订单:{‘K’,‘C’,‘F’,‘A’})。这是可选的。
- subok:【bool,datatype】是否生成结果的子类。如果为真,则提供子类的名称。它返回一个与给定数组具有相同形状和类型的数组。也是可选的。
现在,我们将在下面的示例中实现这个函数。我们也应该尝试两个例子。最后,我们将看到同样的图形表示。
示例 1–使用两个值
在这个例子中,我们传递了两个值并接收了输出。在第二个实现中,我们为 out 参数传递了一个参数。默认情况下,out 参数格式化输出数组。因此,3.25 的截断值被加载到 c 数组中并打印出来。
import numpy as np
b = np.trunc(-2.35)
print(b)
np.trunc(3.25, c)
print(c)
#output
-2.0
[3\. 3\. 3\. 3\. 3\. 3\. 3.]
示例 2–数值数组上的 Numpy.trunc()
在这个例子中,我们在函数中传递一组值。它将返回一个结果数组,该数组包含输入数组中所有值的所有相应截断值。
import numpy as np
input = np.array([-2.35, -1, -0.36, 0, 0.36, 1, 5.69])
d=np.trunc(input)
print(d)
#output
[-2\. -1\. -0\. 0\. 0\. 1\. 5.]
在图形上绘制 numpy.trunc()
numpy.trunc()函数用于返回输入元素的截断值,即输入元素的整数部分。如果我们有一个输入数组,这个函数返回数组中每个元素的截断值。我们还可以使用 x-y 图以图形方式表示单个元素的截断值。
import matplotlib.pyplot as plt
import numpy
x=[]
y=[]
i=-6.99
while (i<7.00):
x.append(i)
y.append(numpy.trunc(i))
i=i+0.01
plt.xlabel("x axis")
plt.ylabel("y axis")
plt.grid(linestyle='-', linewidth=0.5,color='red')
plt.plot(x,y, linewidth=3, color = 'black')
上面的代码片段将给出如下输出。
结论
所以今天,我们用 python 在代码中介绍了 Numpy 截断函数的实现。我们看到了这个函数对于某些极限的图示。从这个图中,你可以分析这个函数以及它是如何工作的。通过这个,你可以更好地理解我们的话题。我们必须带着一些更令人兴奋的话题再次访问。
NumPy true _ Divide–按参数划分元素
原文:https://www.askpython.com/python-modules/numpy/numpy-true_divide
大家好,欢迎来到这个关于 Numpy true_divide 的教程。在本教程中,我们将学习 NumPy true_divide() 方法,也将看到许多关于这个方法的例子。让我们开始吧!
亦读:【NumPy floor _ divide——完整指南
什么是 NumPy true_divide?
true_divide()
是 NumPy 中的一个函数,它将一个数组中的元素按元素方式除以另一个数组中的元素,并返回一个包含答案的数组,即每个元素方式除法的商。
如果 x1 和 x2 是两个数组,那么true_divide(x1, x2)
将执行元素除法,使得 x1 中的每个元素除以 x2 中的相应元素,并将结果存储在一个新数组中。
NumPy true_divide 的语法
让我们来看看true_divide()
函数的语法。
numpy.true_divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
| 参数 | 描述 | 必需/可选 |
| x1 (array_like) | 红利数组。 | 需要 |
| x2(类似数组) | 除数数组。 | 需要 |
| 在外 | 放置结果的替代输出数组。它必须具有与预期输出相同的形状。 | 可选择的 |
| 在哪里 | 接受一个类似数组的对象。在为真的位置,out
数组将被设置为ufunc
结果。在其他地方,out
数组将保持其原始值。 | 可选择的 |
返回:
一个数组,包含 x1 除以 x2 的按元素划分的商。
如果两个输入都是标量,那么结果也是标量。
floor_divide 和 true_divide 的区别
在 Python 中,Numpy floor_divide()
函数按元素执行两个数组的下限除法。它相当于使用了/
操作符。
然而,NumPy true_divide()
按元素执行除法,相当于使用//
运算符。
NumPy true_divide 的示例
现在让我们进入例子,理解true_divide
方法实际上是如何工作的。
当两个输入都是标量时
import numpy as np
a = 18
b = 5
c = 6
# using the true_divide function to perform element-wise division
ans_1 = np.true_divide(a, b)
ans_2 = np.true_divide(a, c)
print("a =", a, "\nb =", b)
print("Result 1 =", ans_1)
print("Result 2 =", ans_2)
输出:
a = 18
b = 5
Result 1 = 3.6
Result 2 = 3.0
简单的例子
ans_1 = 18/5 = 3.6
ans_2 = 18/6 = 3
当一个输入是标量而另一个是一维数组时
import numpy as np
a = [2, 36, 10, 4, 20]
b = 5
# using the true_divide function to perform element-wise division
ans = np.true_divide(a, b)
print("a =", a, "\nb =", b)
print("Result =", ans)
输出:
a = [2, 36, 10, 4, 20]
b = 5
Result = [0.4 7.2 2\. 0.8 4\. ]
这里,标量值是除数,它将被除数数组中的每个元素划分如下:
ans[0] = 2/5 = 0.4
ans[1] = 36/5 = 7.2
ans[2] = 10/5 = 2
ans[3] = 4/5 = 0.8
ans[4] = 20/5 = 4
当两个输入阵列都是一维时
import numpy as np
a = [5, 30, 12, 36, 11]
b = [2, 5, 6, 7, 10]
# using the true_divide function to perform element-wise division
ans = np.true_divide(a, b)
print("a =", a, "\nb =", b)
print("Result =", ans)
输出:
a = [5, 30, 12, 36, 11]
b = [2, 5, 6, 7, 10]
Result = [2.5 6\. 2\. 5.14285714 1.1 ]
这里, a 中的每个元素除以 b 中的相应元素,输出计算如下:
ans[0] = a[0]/b[0] = 5/2 = 2.5
ans[1] = a[1]/b[1] = 30/5 = 6
ans[2] = a[2]/b[2] = 12/6 = 2
ans[3] = a[3]/b[3] = 36/7 = 5.14285714
ans[4] = a[4]/b[4] = 11/10 = 1.1
当两个输入阵列都是二维时
import numpy as np
a = [[25, 23], [12, 18]]
b = [[5, 6], [4, 5]]
# using the true_divide function to perform element-wise division
ans = np.true_divide(a, b)
print("a =", a, "\nb =", b)
print("Result =\n", ans)
输出:
a = [[25, 23], [12, 18]]
b = [[5, 6], [4, 5]]
Result =
[[5\. 3.83333333]
[3\. 3.6 ]]
类似于上面的例子,
ans[0][0] = a[0][0]/b[0][0] = 25/5 = 5
ans[0][1] = a[0][1]/b[0][1] = 23/6 = 3.83333333
ans[1][0] = a[1][0]/b[1][0] = 12/4 = 3
ans[1][1] = a[1][1]/b[1][1] = 18/5 = 3.6
true_divide (//)和 floor_divide (/)的比较
import numpy as np
a = [5, 30, 12, 36, 11]
b = [2, 5, 6, 7, 10]
# using the true_divide and floor_divide functions to perform element-wise division
ans_true_divide = np.true_divide(a, b)
ans_floor_divide = np.floor_divide(a, b)
print("a =", a, "\nb =", b)
print("Result of true divide =", ans_true_divide)
print("Result of floor divide =", ans_floor_divide)
输出:
a = [5, 30, 12, 36, 11]
b = [2, 5, 6, 7, 10]
Result of true divide = [2.5 6\. 2\. 5.14285714 1.1 ]
Result of floor divide = [2 6 2 5 1]
这里输出的不同之处在于,在底除法的输出中,实际商的底作为输出呈现,而真正的除法方法将实际商包括在输出中。
结论
仅此而已!在本教程中,我们学习了 Numpy true_divide 方法,并使用该方法练习了不同类型的示例。
如果你想了解更多关于 NumPy 的知识,请随意浏览我们的 NumPy 教程。
参考
NumPy 万能函数要知道!
原文:https://www.askpython.com/python-modules/numpy/numpy-universal-functions
读者朋友们,你们好!在本文中,我们将关注 Python 编程中的 NumPy 通用函数。所以,让我们开始吧!🙂
我们所说的 NumPy 万能函数是什么意思?
NumPy 通用函数实际上是数学函数。NumPy 中的 NumPy 数学函数被构造为通用函数。这些通用(数学 NumPy 函数)对 NumPy 数组进行运算,而对数据值执行元素式运算。
在 Python 中,通用 NumPy 函数属于 numpy.ufunc 类。当我们调用某些运算符时,一些基本的数学运算会在内部调用。例如,当我们构造 x + y 时,它在内部调用 numpy.add()通用函数。
我们甚至可以使用 frompyfunc()方法创建自己的通用函数。
语法:
numpy.frompyfunc(function-name, input, output)
- 函数名:作为通用函数的函数名
- 输入:输入数组的个数
- 输出:输出数组的个数
举例:
在本例中,我们使用 frompyfunc() 方法将函数 product 转换为通用函数。
因此,现在 product()方法的行为就像一个通用的数学函数,当数组作为参数传递给它时,它执行元素级乘法。
import numpy as np
def product(a, b):
return a*b
product = np.frompyfunc(product, 2, 1)
res = product([1, 2, 3, 4], [1,1,1,1])
print(res)
输出:
[1 2 3 4]
1.NumPy 中的泛三角函数
在这个概念的过程中,我们现在将看看 NumPy 中的一些通用三角函数。
- numpy。deg2raf() :这个函数帮助我们将度数转换成弧度。
- numpy.sinh()函数:计算双曲正弦值。
- numpy.sin()函数:计算正弦双曲值的倒数。
- numpy.hypot()函数:计算直角三角形结构的斜边。
举例:
import numpy as np
data = np.array([0, 30, 45])
rad = np.deg2rad(data)
# hyperbolic sine value
print('Sine hyperbolic values:')
hy_sin = np.sinh(rad)
print(hy_sin)
# inverse sine hyperbolic
print('Inverse Sine hyperbolic values:')
print(np.sin(hy_sin))
# hypotenuse
b = 3
h = 6
print('hypotenuse value for the right angled triangle:')
print(np.hypot(b, h))
输出:
Sine hyperbolic values:
[0\. 0.54785347 0.86867096]
Inverse Sine hyperbolic values:
[0\. 0.52085606 0.76347126]
hypotenuse value for the right angled triangle:
6.708203932499369
2.通用统计函数
除了三角函数, Python NumPy 还为我们提供了通用的统计函数。其中一些列举如下:
- numpy.amin()函数:表示数组中的最小值。
- numpy.amax()函数:表示数组中的最大值。
- numpy.ptp()函数:表示一个数组的值在一个轴上的范围,通过从最大值中减去最小值来计算。
- numpy.average()函数:计算数组元素的平均值。
举例:
import numpy as np
data = np.array([10.2,34,56,7.90])
print('Minimum and maximum data values from the array: ')
print(np.amin(data))
print(np.amax(data))
print('Range of the data: ')
print(np.ptp(data))
print('Average data value of the array: ')
print(np.average(data))
输出:
Minimum and maximum data values from the array:
7.9
56.0
Range of the data:
48.1
Average data value of the array:
27.025000000000002
结论
到此,我们就结束了这个话题。如果你遇到任何问题,欢迎在下面评论。
更多与 Python 编程相关的帖子,敬请关注我们!
在那之前,学习愉快!!🙂
NumPy 展开——完整指南
原文:https://www.askpython.com/python-modules/numpy/numpy-unwrap
你好读者,欢迎来到另一个关于 NumPy 数学函数 的教程。在本教程中,我们将涵盖 NumPy 展开功能,以及实践的例子。这是一个需要理解的有趣函数。
没有别的事了,让我们开始吧。
什么是 NumPy unwrap?
numpy.unwrap()
函数是 NumPy 库 提供的数学函数之一。这个函数将给定的数组展开成一组新的值。简单地说,它将原来的元素数组转换成一组新的元素。
现在,让我们来看看 numpy.unwrap()函数的语法,这样会使事情更清楚。
NumPy unwrap 的语法
numpy.unwrap ( p,
discont=None,
axis=- 1,
*,
period=6.283185307179586 )
该函数的参数是:
p
–是输入数组。discont
–它是输入数组的值之间的最大不连续性。默认情况下,discont
值是 pi。axis
–这是一个可选参数。它指定展开功能将沿其运行的轴。period
–该参数为浮点型,可选。它表示输入换行范围的大小。默认值是 2*pi。
为什么解开一个数组?
如果一个 NumPy 数组 有不连续的值,那么我们使用numpy.unwrap()
函数来转换输入数组的值。如果数组元素之间的跳跃大于其沿给定轴的 2*pi 补码值的discont
值,则展开函数展开或转换输入数组。
关于 NumPy unwrap 函数的理论,这就是你需要了解的全部内容。
注意:如果输入数组中的不连续性小于 pi 但大于 discont,则不进行展开,因为取 2*p i 补码只会使不连续性更大。
使用 NumPy 展开功能
让我们直接进入使用数组的例子
没有属性的默认 numpy 展开
import numpy as np
a = np.array((1 , 2 , 3 , 4 , 5))
print("Result1 :\n",np.unwrap(a))
b = np.array((0 , 0.78 , 5.55 , 7.89))
print("Result2 :\n",np.unwrap(b))
输出
Result1 :
[1\. 2\. 3\. 4\. 5.]
Result2 :
[ 0\. 0.78 -0.73318531 1.60681469]
在上面的输出中,您可以观察到输入数组 a 的元素之间没有不连续,并且没有对这个 NumPy 数组进行展开。
在第二个输出中,当 NumPy 数组 b 作为一个参数传递给 np.unwrap()函数时,展开就完成了。这是因为 0.78 和 5.55 之间的不连续性大于默认折扣值,即 pi。
现在,让我们尝试更多的例子,我们将设置自定义值。
使用不连续属性展开数字
import numpy as np
a = np.array((5, 7, 10, 14, 19, 25, 32))
print("Result1 :\n",np.unwrap(a , discont=4))
b = np.array((0, 1.34237486723, 4.3453455, 8.134654756, 9.3465456542))
print("Result2 :\n",np.unwrap(b , discont=3.1))
输出
Result1 :
[ 5\. 7\. 10\. 7.71681469 6.43362939 6.15044408
6.86725877]
Result2 :
[0\. 1.34237487 4.3453455 1.85146945 3.06336035]
对于 Result1,我们已经将 NumPy 数组 a
作为输入传递给 NumPy 展开函数,并且将 discont
值设置为 4,即如果数组 a 的元素之间的跳转将大于或等于 4,则值将被转换。这里,10 和 14 之间的差是 4,因此值被改变。
对于 Result2,我们传递了一个 NumPy 数组 b 作为 NumPy 展开函数的输入,并且将 discont
的值设置为 3.1。这里,4.3453455 和 8.134654756 之间的差大于 3.1,因此展开完成。
摘要
这就是关于 NumPy 展开函数的全部内容。功能真的很有趣,也很好用。请查看 NumPy 官方文档链接,获取更多示例。请继续关注更多关于 Python 主题的有趣文章🙂
参考
如何用 Numpy 求矢量点积?
原文:https://www.askpython.com/python-modules/numpy/numpy-vector-dot
矢量是在物体运动方向上既有大小又有方向的物理量。它们主要用于在数学领域的不同空间和平面中导航。虽然向量可以执行许多操作,但在本文中,我们将使用 numpy 库中的内置函数来探索一种这样的操作——向量点积!
也读作:【Numpy Dot()——矢量、Numpy、计算点积的完全指南
从 numpy 库中用于计算矢量点积的函数是 vdot( ) 函数。让我们从使用下面的代码导入 numpy 库开始。
import numpy as np
我们将通过下面的每一节进一步探讨 vdot( ) 函数。
- vdot()函数的语法
- 计算 N 维数组的矢量点积
- 计算复数的矢量点积
vdot()函数的语法
有人可能会问,既然在 numpy 库中已经有一个 dot( ) 函数可以达到同样的目的,为什么还要费心去使用 vdot( ) 函数。虽然这些最初看起来是同义词,但细节决定成败。
如果所提供的输入本质上是复杂的,则 vdot( ) 函数使用复共轭技术。该函数利用第一个输入参数的复共轭来计算给定两个向量的向量点积。
但是当 N 维数组出现时,真正的区别就出现了。 dot( ) 函数使用矩阵乘法技术来计算 N 维数组的点积,而 vdot( ) 函数将给定的 N 维数组展平成它们的一维等效值来计算点积。
所有这些都发生在 vdot( ) 函数中,其语法如下:
numpy.vdot(a, b)
在哪里,
- a-n 维数组或复数为第一个输入向量
- b—n 维数组或复数为第二个输入向量
计算 N 维数组的矢量点积
在导入了 numpy 库之后,让我们使用两个二维数组来寻找两个向量的点积,如下所示。
ar1 = np.array([[12, 5],
[5, 9]], dtype = int)
ar2 = np.array([[21, 50],
[8, 6]], dtype = int)
np.vdot(ar1, ar2)
一旦上面的代码运行,下面的计算将在后端进行,用于计算给定的两个向量的点积。
- 第一个输入数组的第一个元素与第二个输入数组的第一个元素相乘,例如“12×21”。
- 重复上述步骤,直到第一个输入数组中的每个元素都与第二个输入数组中相应的元素相乘,例如“5×50”、“5×8”、“9×6”。
- 然后将所有这些乘积的结果相加,以打印给定的两个 N 维数组的矢量点积,即(12×21)+(5×50)+(5×8)+(9×6) = 596
如上所述,在最后一步中推导出的最终答案也可以在下图中看到代码运行时的结果。
Dot Product Calculated For N-Dimensional Arrays
计算复数的矢量点积
本节将通过 vdot( ) 函数详细说明复数的用法。让我们分配几个变量&,然后用它们来计算矢量点积,如下面的代码所示。
ar3 = [[2+21j, 3-16j]]
ar4 = [[6-17j, 18+6j]]
np.vdot(ar3, ar4)
Vector Dot Product Calculated For Complex Numbers
这里使用了语法一节中所述的相同技术,将复数的共轭相乘以推导出最终结果。
结论
既然我们已经到了这篇文章的结尾,希望它已经阐述了如何使用来自 numpy 库中的 vdot( ) 函数来计算给定的两个向量的点积。这里有另一篇文章解释了如何在 Python 中使用 numpy 找到给定向量的外积。AskPython 中还有许多其他有趣且信息量大的文章,可能会对那些希望提高 Python 水平的人有很大帮助。当你享受这些的时候,再见!
Numpy 矢量化
原文:https://www.askpython.com/python-modules/numpy/numpy-vectorization
在本文中,我们将学习 Python 中的 Numpy 矢量化。Numpy 是 Python 中数组的 C 实现,在拥有相同的 Python 解释器的情况下速度相对较快。在本文中,我们将探讨如何使用 numpy.vectorize()将一个函数按元素应用于一个序列。
为什么 for 循环不是 Numpy 矢量化的最佳选择?
为了将一个函数应用于一个列表或元组的元素或者一个 NumPy 数组,我们可以很容易地在 Python 中使用 for 循环。但是 Python 是一种解释型语言,与 C 和 C++相比,大部分实现都很慢。这种缓慢计算的主要原因归结于 Python 的动态特性和编译器级优化的缺乏,这导致了内存开销。
对于使用 Python 进行大量计算的人来说,这不是一个理想的情况。虽然 NumPy 提供了更快的实现,但是 for 循环降低了 NumPy 提供的一些速度。为了解决这个瓶颈,NumPy 提供了矢量化功能,可以高效地将函数映射到序列上。
numpy.vectorize()与 Python for loop–矢量化速度比较
让我们测试一下 python for 循环和矢量化版本的速度。我们将使用 timeit 函数来获得精确的速度测试。
# We use a large array for benchmarking our method
a = np.random.rand(10000)
b = 5
print("Benchmark for the for loop implementation: ")
%timeit [foo(i, b) for i in a]
print()
print("Benchmark for the vecfoo implementation: ")
%timeit vecfoo(a, b)
我们看到,矢量化版本比 for 循环实现快 3 倍以上。
用 numpy.vectorize()函数进行 Numpy 矢量化
Numpy 矢量化函数接受一个 python 函数(pyfunc ),并返回该函数的矢量化版本。
该函数的矢量化版本将一系列对象或 NumPy 数组作为输入,并在输入序列的每个元素上计算 Python 函数。Numpy 矢量化功能本质上类似于 python map() ,但具有额外的功能—NumPy 广播机制。
因此,让我们更详细地理解 numpy.vectorize()函数:
numpy.vectorize(pyfunc, otypes=None, doc=None, excluded=None, cache=False, signature=None)
必需的参数:
pyfunc :我们希望应用于对象序列的函数
可选参数:
- otypes :函数的输出类型可以指定为一个字符串或一列数据类型。如果没有提到 otypes 并且缓存设置为 True ,则通过调用输入的第一个元素来确定输出类型。
- doc :指定创建的 docstring。如果没有提到,将使用函数的原始文档字符串(如果有)。
- 缓存:如果为真,那么如果没有提供 otypes ,则缓存决定输出数量的第一个函数调用。
向量化一个函数
def foo(a, b):
"""
If a > b return a + b,
else return a - b.
"""
if a >= b:
return a + b
else:
return a - b
# Create a vectorized version of foo
vecfoo = np.vectorize(foo)
vecfoo(np.arange(5), 5)
array([-5, -4, -3, -2, -1])
Fig 1: Python version of foo() vs vectorized version of foo()
矢量化函数的输出类型
如果 otypes 参数设置为 false,Numpy 会自动评估函数的输出类型。这里有一个例子来展示它:
a = np.array([1, 2, 3, 4])
b = 2
vecfoo = np.vectorize(foo)
res = vecfoo(a, b)
print(type(res[0]))
<class 'numpy.int64'>
我们还可以通过强制返回值的数据类型来控制矢量化函数的输出。这里有一个如何做的例子。
a = np.array([1, 2, 3, 4])
b = 2
vecfoo = np.vectorize(foo, otypes=[float])
res = vecfoo(a, b)
print(type(res[0]))
<class 'numpy.float64'>
缓存在 Numpy 矢量化中
我们已经看到,如果没有指定 optypes ,函数将调用输入的第一个参数来确定输入的数量。这个结果可以被缓存,从而防止函数一次又一次地运行相同的操作。但是,缓存实现会降低后续调用的速度,并且只有在函数计算开销很大的情况下才能使用。可以通过将参数缓存设置为真来设置缓存
最后备注
np.vectorize()并不是我们使用矢量化的唯一地方,我们一直在每天的 NumPy 操作中使用它。让我们另外举个例子:
np.arange(5) + 4
array([4, 5, 6, 7, 8])
同样的规则也适用于不同的原始函数,如减法、乘法、正弦、余弦等。这些函数具有内置的矢量化支持。但是我们自己的 Python 版本一般不支持这种矢量化,所以我们需要 numpy.vectorize()以快速有效的方式进行矢量化操作。
参考文献:
Numpy vstack()方法–完整概述
大家好!在本教程中,我们将学习什么是 Numpy vstack()
方法,以及如何在 Python 中使用它。所以让我们开始吧。
numpy.vstack()方法是什么?
Numpy.vstack()
是 Python 中的一个函数,它接受一个数组的元组,并沿第一维垂直连接它们,使它们成为一个数组。
它的语法是:
numpy.vstack(tup)
它的参数是一个 tuple,这是一个我们想要连接的 n 数组序列。除了第一个轴,数组在所有轴上都必须具有相同的形状。
该方法返回一个 ndarray,它是通过堆叠输入中给定的数组形成的。返回的数组至少有二维。
Numpy vstack()的示例
对于线性 1-D 阵列,所有阵列垂直堆叠以形成 2-D 阵列。所有输入数组的长度必须相同。
import numpy
a = numpy.array([1, 2, 3, 4, 5])
b = numpy.array([6, 7, 8, 9, 10])
c = numpy.array([11, 12, 13, 14, 15])
print("Shape of array A:", a.shape)
print("Shape of array B:", b.shape)
print("Shape of array C:", c.shape)
print()
stack = numpy.vstack((a, b, c))
print("Shape of new stacked array:", stack.shape)
print("Stacked array is")
print(stack)
Shape of array A: (5,)
Shape of array B: (5,)
Shape of array C: (5,)
Shape of new stacked array: (3, 5)
Stacked array is
[[ 1 2 3 4 5]
[ 6 7 8 9 10]
[11 12 13 14 15]]
对于 N 维数组,数组沿第一维堆叠,如下例所示。
import numpy
a = numpy.array([ [1, 2, 3], [4, 5, 6] ])
b = numpy.array([ [7, 8, 9], [10, 11, 12] ])
print("Shape of array A:", a.shape)
print("Shape of array B:", b.shape)
print()
stack = numpy.vstack((a, b))
print("Shape of new stacked array:", stack.shape)
print("Array is")
print(stack)
输出:
Shape of array A: (2, 3)
Shape of array B: (2, 3)
Shape of new stacked array: (4, 3)
Array is
[[ 1 2 3]
[ 4 5 6]
[ 7 8 9]
[10 11 12]]
对于 N 维数组,除了如下所示的第一维,数组的形状在所有维度上都必须相同。
import numpy
a = numpy.array([ [1, 2], [3, 4] ])
b = numpy.array([ [5, 6], [7, 8], [9, 10] ])
print("Shape of array A:", a.shape)
print("Shape of array B:", b.shape)
print()
stack = numpy.vstack((a, b))
print("Shape of new stacked array:", stack.shape)
print("Array is")
print(stack)
Shape of array A: (2, 2)
Shape of array B: (3, 2)
Shape of new stacked array: (5, 2)
Array is
[[ 1 2]
[ 3 4]
[ 5 6]
[ 7 8]
[ 9 10]]
结论
在这个 Python 教程中,我们学习了 NumPy 模块中的vstack()
方法。这个函数对于多达 3 维的数组最有意义。例如,对于具有高度(第一轴)、宽度(第二轴)和 r/g/b 通道(第三轴)的像素数据。
感谢阅读!!
Python 中的 NumPy zeros()方法
原文:https://www.askpython.com/python-modules/numpy/numpy-zeros-method-in-python
介绍
NumPy 是 Python 中大量实现的模块。今天我们将学习 Numpy zeros()
方法,它是 Numpy 中定义的方法之一。
所以,让我们开始吧!
Python 中的 Numpy zeros()方法
Python 中的 Numpy zeros()
方法创建一个指定形状和类型的新数组,它的所有元素都被初始化为 0 。该函数无论在哪里被调用都返回相同的数组。
zeros()
方法的基本语法可以由下式给出:
import numpy as np
arr = np.zeros( shape , dtype , order )
这里,
- arr 存储由
zeros()
方法返回的结果数组, shape
是一个整数序列,它决定了数组的大小和形状。当形状作为整数提供时,生成的数组将是 1D 数组。然而,如果我们给一个整数元组不同的整数值,我们将得到一个多维数组,dtype
or data type 指定数组元素的数据类型。默认情况下,它被设置为浮点型。Order
决定数组是按照行主(C)还是列主(F)模式/顺序存储在内存位置。
Python 中如何使用 Numpy zeros()?
现在我们知道了 Python 中的 Nump zeros()
方法是做什么的,让我们学习一下用法。
使用 Numpy 个零的 1D 数组()
我们可以用这种方法在 Python 中创建所有元素都为零的一维数组( 0 )。为了更好地理解,让我们举一个例子。
import numpy as np
arr1 = np.zeros(5)
print("The created array is: ",arr1) #generated array
print("It is of type:",type(arr1)) #type of array
输出:
1 D Array Using Zeros
在上面的代码中,
- arr1 是新创建的数组。正如我们所看到的,我们刚刚将' 5 '传递给了 Numpy
zeros()
函数,没有数据类型和顺序。 - 默认情况下,
dtype
和 order 的值分别被认为是浮点型和’C。这意味着生成的数组将具有 float 类型的元素,并以行为主的形式存储。 - 最后,当我们打印出数组时,我们得到一个 1D 数组,它的所有浮点元素的值都是 0 。而 arr1 的 type()告诉我们它是
ndarray
类的成员。
使用 Numpy 零()的不同数据类型的数组
因此,我们创建了一个默认类型为 float 的数组。如果我们需要一个包含整数值或元素的数组呢?我们可以通过将dtype
参数指定为我们想要的类型来轻松做到这一点。让我们看看如何
import numpy as np
int_array = np.zeros(4, dtype=int) #data type set as int
print("Array: ",int_array) #the final int array
print("Datatype: ", int_array.dtype) # the data types
输出:
Data Types Using Zeros
这里,
- int_array 是使用
zeros()
方法创建的新数组。 - 正如我们从输出中看到的,我们创建了一个整数类型的大小为 4 的数组。同样,元素的数据类型被给定为 int32 。(整数)。
使用 Numpy 个零的多维数组()
我们在本教程前面创建了一个 1D 数组,那么多维数组呢?让我们试着创建一个 2D 数组来说明如何创建元素为 0 的多维数组。
import numpy as np
arr2 = np.zeros((3, 3), int) #2D integer array
print("2D array created is: ",arr2)
print("Type of the array: ",type(arr2)) #type of the array
输出:
Multidimensional Array Using Zeros
在上面的代码中:
- 我们向 Numpy
zeros()
方法传递一个整数元组,而不是一个整数元组。这允许我们创建一个 int 类型的多维数组(指定的)。 - 正如我们从输出中看到的,我们得到了一个所有元素都为 0 的 2D 数组。
使用 Numpy 零()的异构数据类型数组
我们还可以使用 Python 中的zeros()
函数创建异构数据类型的数组。我们只需要传递一个包含所需信息的元组。
import numpy as np
# creating array with heterogeneous data types
arr = np.zeros((2,2), dtype=[('x', 'int'), ('y', 'float')])
print("The array created:",arr)
print("Type of the array: ",type(arr)) #type of the array
print("Datatype: ", arr.dtype) # the data types
输出:
Heterogeneous Data Type Array Using Zeros
这里,
- 我们通过将 shape 作为元组 (2,2) 传递来创建一个二维数组,
- 在数据类型的情况下,我们使用一个元组,指定整数和浮点类型,
- 这导致创建了具有元组元素的 2D 数组。每个元组有两个数据,一个是
int
类型,另一个是float
类型, - 最后,我们打印成员元素的数据类型,如输出所示。
结论
所以在本教程中,我们讨论了 Python 中的 Numpy zeros()
方法。希望大家理解得很好。如有任何问题,欢迎使用下面的评论。
参考
- Numpy Zeros Python 文档
- 关于 Numpy 零的 JournalDev 文章
NumPy Zeros–完整指南
原文:https://www.askpython.com/python-modules/numpy/numpy-zeros
你好,欢迎来到这个关于 Numpy 零点的教程。在本教程中,我们将学习 NumPy zeros 方法,也将看到许多关于相同的例子。让我们开始吧!
也读: NumPy 面试问题:为你的 Python 工作面试做好准备
什么是 NumPy 零?
NumPy zeros
方法返回给定形状和数据类型的一个 Numpy 数组 ,所有值都设置为 0。
NumPy 零的语法
让我们先来看看语法。
numpy.zeros(shape, dtype=float, order='C', like=None)
| 参数 | 描述 | 必需/可选 |
| 形状 | 所需的数组形状。它可以是一个整数,也可以是一组整数。 | 需要 |
| 类型 | 所需的数组数据类型。
默认数据类型为浮点型。 | 可选择的 |
| 命令 | 多维数据在存储器中存储的期望顺序。它可以是主要行(' C ')或主要列(' F ')。
默认顺序为【C】,即行主。 | 可选择的 |
| like (array_like) | 引用对象,以允许创建不是 NumPy 数组的数组。 | 可选择的 |
返回:具有给定形状、数据类型和顺序的数组。
使用 Numpy 零的示例
现在让我们看看 numpy.zeros()方法的一些实际例子。
使用零的一维数组
import numpy as np
one_dim_array = np.zeros(4)
print(one_dim_array)
输出:
[0\. 0\. 0\. 0.]
使用零的二维数组
N×M 阵列
import numpy as np
two_dim_array = np.zeros((2, 3))
print(two_dim_array)
输出:
[[0\. 0\. 0.]
[0\. 0\. 0.]]
1×N 阵列
import numpy as np
one_row_array = np.zeros((1, 4))
print(one_row_array)
输出:
[[0\. 0\. 0\. 0.]]
N×1 阵列
import numpy as np
one_col_array = np.zeros((4, 1))
print(one_col_array)
[[0.]
[0.]
[0.]
[0.]]
一维整型数组
import numpy as np
one_dim_int_array = np.zeros(3, dtype=np.int64)
print(one_dim_int_array)
输出:
[0 0 0]
二维整型数组
import numpy as np
two_dim_int_array = np.zeros((2, 4), dtype=np.int64)
print(two_dim_int_array)
输出:
[[0 0 0 0]
[0 0 0 0]]
一维自定义数据类型数组
import numpy as np
custom_one_dim_array = np.zeros(3, dtype=[('x', 'int'), ('y', 'float')])
print(custom_one_dim_array)
print(custom_one_dim_array.dtype)
输出:
[(0, 0.) (0, 0.) (0, 0.)]
[('x', '<i4'), ('y', '<f8')]
在这个例子中,我们指定第一个值为 int,第二个值为 float。
二维自定义数据类型数组
我们可以将数组的元素指定为元组,还可以指定它们的数据类型。
import numpy as np
custom_two_dim_array = np.zeros((3, 2), dtype=[('x', 'float'), ('y', 'int')])
print(custom_two_dim_array)
print(custom_two_dim_array.dtype)
输出:
[[(0., 0) (0., 0)]
[(0., 0) (0., 0)]
[(0., 0) (0., 0)]]
[('x', '<f8'), ('y', '<i4')]
这里,代码指定数组元素中元组的第一个值是 float,第二个值是 int。
结论
仅此而已!在本教程中,我们学习了 Numpy zeros 方法,并使用相同的方法练习了不同类型的示例。
参考
NumPy zeros _ like–完整指南
原文:https://www.askpython.com/python-modules/numpy/numpy-zeros_like
在本教程中,我们将学习 NumPy zeros_like 方法,也将看到许多关于这个方法的例子。让我们开始吧!
推荐阅读:【NumPy 零点——完整指南
NumPy zeros_like 是什么?
NumPy 中的zeros_like
方法是一个函数,它返回与给定数组具有相同形状和大小的零数组。
类似零的语法
numpy。 零 _ 像 ( 一 ,dtype =无 , order='K' ,subok =真 ,shape =无 )
| 参数 | 描述 | 必需/可选 |
| (类似数组) | 定义要返回的数组的形状和数据类型的对象。 | 需要 |
| 数据类型 | 所需数组的数据类型。覆盖结果的数据类型。 | 可选择的 |
| 命令 | 多维数据在存储器中存储的期望顺序。它可以是 row-major ('C '),column-major ('F '),如果 a 是 Fortran 连续的,则“A”表示“F”,否则为“C”。‘k’表示尽可能匹配 a 的布局。 | 可选择的 |
| subok (bool) | 确定新创建的数组是使用子类类型 a (subok=True)还是基类数组(subok=False)。
默认值为真。 | 可选择的 |
| 形状 | 所需数组的形状。覆盖结果的形状。 | 可选择的 |
返回:
与给定数组具有相同形状和数据类型的数组。
Numpy zeros_like 函数示例
现在让我们看看 numpy.zeros_like()函数是如何工作的,以及不同类型的输入的预期输出是什么。
使用 zeros_like 的一维数组
import numpy as np
a = np.arange(10)
print("a =", a)
b = np.zeros_like(a)
print("b =", b)
输出:
a = [0 1 2 3 4 5 6 7 8 9]
b = [0 0 0 0 0 0 0 0 0 0]
使用 zeros_like 的二维数组
N×N 阵列
import numpy as np
a = np.arange(10).reshape(2, 5)
print("a =\n", a)
b = np.zeros_like(a)
print("b =\n", b)
输出:
a =
[[0 1 2 3 4]
[5 6 7 8 9]]
b =
[[0 0 0 0 0]
[0 0 0 0 0]]
1×N 阵列
import numpy as np
a = np.arange(10).reshape(1, 10)
print("a =\n", a)
b = np.zeros_like(a)
print("b =\n", b)
输出:
a =
[[0 1 2 3 4 5 6 7 8 9]]
b =
[[0 0 0 0 0 0 0 0 0 0]]
N×1 阵列
import numpy as np
a = np.arange(10).reshape(10, 1)
print("a =\n", a)
b = np.zeros_like(a)
print("b =\n", b)
输出:
a =
[[0]
[1]
[2]
[3]
[4]
[5]
[6]
[7]
[8]
[9]]
b =
[[0]
[0]
[0]
[0]
[0]
[0]
[0]
[0]
[0]
[0]]
一维浮点型数组
import numpy as np
a = np.arange(10)
print("a =", a)
b = np.zeros_like(a, dtype=float)
print("b =", b)
输出:
a = [0 1 2 3 4 5 6 7 8 9]
b = [0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0.]
二维浮点型数组
import numpy as np
a = np.arange(10).reshape(2, 5)
print("a =\n", a)
b = np.zeros_like(a, dtype=float)
print("b =\n", b)
输出:
a =
[[0 1 2 3 4]
[5 6 7 8 9]]
b =
[[0\. 0\. 0\. 0\. 0.]
[0\. 0\. 0\. 0\. 0.]]
零和类零的区别
注意,在zeros
方法中,我们正在创建一个我们想要的形状和数据类型的新数组,所有的值都是 0。但是,在这里,我们直接传递一个数组或类似数组的对象来获得一个具有相同形状和数据类型的数组。NumPy zeros_like
函数比 NumPy zeros
函数花费更多的时间来产生一个全 0 的数组。
结论
仅此而已!在本教程中,我们学习了 Numpy zeros_like 方法,并使用该方法练习了不同类型的示例。
参考
Python 中的面向对象编程
原文:https://www.askpython.com/python/oops/object-oriented-programming-python
面向对象编程( OOP )是指软件设计,其中程序员定义数据结构的数据类型,以及可应用于该数据结构的功能类型。这种范式为数据结构提供了功能和行为模式。
这种范式将现实世界的事物映射和建模在一起,并描述它们之间的关系。OOP 将现实世界的实体建模为软件对象,这些实体有与之相关联的数据,并且有一些行为模式(功能)。
Object-Oriented Programming Paradigm
Python 中的类
类是实体功能的蓝图。类用于创建包含任意数据的新的用户定义的数据结构。对于动物,我们可以创建一个动物类来跟踪动物的属性,比如名字和年龄。
把类想象成一个有标签的动物的蓝图。它包含了关于名称、大小等的所有细节。根据这些描述,我们可以研究动物。在这里,动物是一个对象。
语法:
class class_name:
pass
示例:
class Animal:
pass
Python 中的对象
一个对象是一个类的实例。定义类时,只定义对象的描述。因此,不会分配任何内存。对象表示类及其功能和行为。
语法:
object_name = Class_name(argument list)
示例:
class Dog:
# class attribute
species = "animal"
# instance attribute
def __init__(self, name, age):
self.name = name
self.age = age
# instantiate the Dog class i.e create objects
A = Dog("Blu", 10)
B = Dog("Woo", 15)
# access the class attributes
print("A is a {}".format(A.__class__.species))
print("B is also a {}".format(B.__class__.species))
# access the instance attributes
print("{} is {} years old".format( A.name, A.age))
print("{} is {} years old".format( B.name, B.age))
输出:
A is a animal
B is also a animal
A is 10 years old
B is 15 years old
Python 中的数据抽象
抽象用于隐藏内部细节,显示必要的功能。抽象意味着以这样一种方式显示内容,即只有必要的功能根据特权显示给用户,其余的内部工作保持隐藏。
Python 中的封装
封装是指将数据和功能绑定到一个单元中。类表示封装,因为它将功能和行为绑定到单个单元中,并将其表示为对象。
Python 中的继承
在面向对象编程(OOP)的世界中,继承指的是一个类在运行中从另一个类派生或扩展属性的能力机制。该属性使派生类能够获取基类的属性或特征。
继承被认为是 OOP 最重要的方面之一,因为它提供了可重用性的特性,从而使代码更加可靠。
Inheritance
示例:
# Base class
class Dog:
# Class attribute
species = 'mammal'
# Instance attributes
def __init__(self, name, age):
self.name = name
self.age = age
# instance method
def description(self):
return "{} is {} years old".format(self.name, self.age)
# instance method
def speak(self, sound):
return "{} says {}".format(self.name, sound)
# Derived class (inherits from Dog class)
class Bulldog(Dog):
def run(self, speed):
return "{} runs {}".format(self.name, speed)
# Derived class inherits attributes and
# behavior from the parent class
Jim = Bulldog("Jim", 12)
print(Jim.description())
# Derived class has specific attributes
# and behavior as well
print(Jim.run("slowly"))
输出:
Jim is 12 years old
Jim runs slowly
Python 中的一种热门编码——一种实用方法
原文:https://www.askpython.com/python/examples/one-hot-encoding
读者朋友们,你们好!在本文中,我们将关注 Python 中 One hot encoding 的实际实现。
所以,让我们开始吧!
一、什么是 one 热编码?
在深入研究一键编码的概念之前,让我们了解一些先决条件。
变量分为两个主要部分
- 连续变量:这些是描述数值变量的变量。示例:[1,2,3,4,5,6…..100]
- 分类变量:这些变量描述了数据值中的类别或组。例子:[苹果,芒果,浆果]
在数据集中,我们会遇到包含分组形式的分类数据的数据,例如[苹果、浆果、芒果]。为了将每一类数据表示为一个独立的实体,我们使用了编码技术。
最常用的编码技术包括
- 虚拟变量
- 标签编码
- 一个热编码等。
今天,让我们来讨论一个热门的编码。
一个热编码以二进制向量的形式表示分类数据。
现在,您可能会想到一个问题,当它以二进制向量格式表示类别时,它何时将数据转换为 0 和 1,即整数?
在一种热编码方案中,在将其应用于数据之前,我们需要将分类数据值映射到整数数据值。这是借助标签编码完成的。
不要担心,我们将在后面的章节中讨论标签编码的实际实现。
因此,通过一次热编码,每个类别的数据值将被分配一个整数值,并被映射到二进制向量。
因此,映射到整数值的每个数据值将被表示为二进制向量,其中,除了被标记为 1 的整数(类别)的索引值之外,向量中的所有值都为零。
一个热编码实现示例
将包含分类数据的数据集视为[苹果和浆果]。应用标签编码后,假设它会将 apple 指定为“0”,将 berry 指定为“1”。
此外,在应用独热编码时,它将创建长度为 2 的二进制向量。这里,编码为“0”的标签“苹果”将具有二进制向量[1,0]。
这是因为值 1 将被放置在编码的索引处,对于 apple 来说,该索引为零(如其标签编码所示)。
因此,[苹果,浆果,浆果]将被编码为:
[1,0]
【0,1】
【0,1】
现在让我们通过例子来实现这个概念。
示例 1:分组分类数据的热编码
看看下面的例子!我们已经用一个热编码对水果进行了编码。
from sklearn.preprocessing import LabelEncoder
from sklearn.preprocessing import OneHotEncoder
cat_data = ["apple", "mango", "apple", "berry", "mango", "apple", "berry", "apple"]
label = LabelEncoder()
int_data = label.fit_transform(cat_data)
int_data = int_data.reshape(len(int_data), 1)
onehot_data = OneHotEncoder(sparse=False)
onehot_data = onehot_data.fit_transform(int_data)
print("Categorical data encoded into integer values....\n")
print(onehot_data)
输出:
Categorical data encoded into integer values....
[[1\. 0\. 0.]
[0\. 0\. 1.]
[1\. 0\. 0.]
[0\. 1\. 0.]
[0\. 0\. 1.]
[1\. 0\. 0.]
[0\. 1\. 0.]
[1\. 0\. 0.]]
说明:
- 加载完数据后,我们创建了一个对象
LabelEncoder()
,将分类数据编码成整数值。 - 此外,我们将把相同的整数数据传递给
OneHotEncoder()
以将整数值编码成类别的二进制向量。 fit_transform()
函数应用要对数据或一组值执行的特定函数。
示例 2:数据集上的一个热编码
在本例中,我们将一个数据集拉入 Python 环境。你可以找到下面的数据集供你参考。
Onehot Encode Dataset
此外,我们使用了ColumnTransformer()
函数来创建一个对象,该对象将类别 0 表示为 N 个类别中的第一列。
最后,我们将它应用于要编码成二进制数组形式的整个分类数据。
import pandas
import numpy
from sklearn.preprocessing import OneHotEncoder
from sklearn.compose import ColumnTransformer
cat_data = pandas.read_csv("bank-loan.csv")
#print(cat_data)
column_set = ColumnTransformer([('encoder', OneHotEncoder(),[0])], remainder='passthrough')
onehot_data = numpy.array(column_set.fit_transform(cat_data), dtype = numpy.str)
print(onehot_data)
输出:
所以,你看,数据现在包含两列:第一列描述第 0 类,第二列描述第 1 类。
[['0.0' '1.0']
['1.0' '0.0']
['1.0' '0.0']
...
['1.0' '0.0']
['1.0' '0.0']
['1.0' '0.0']]
结论
到此,我们就结束了这个话题。如果你遇到任何问题,欢迎在下面评论。在那之前,请继续关注并快乐学习!!🙂
Python 中有用的一行程序——快速指南
原文:https://www.askpython.com/python/examples/one-liners-in-python
Python 是有史以来最强大和用户友好的编程语言之一。Python 在程序员中很受欢迎,因为它简化了复杂的任务。
本教程将介绍一些简单有趣的一行程序。我们开始吧!
把两本词典的内容合并成一本。
如果你使用的是 Python3.9 或更高版本的,你可以使用|来实现。
x = {'a': 11, 'b': 22}
y = {'c': 13, 'd': 44}
z = x | y
print(z)
输出如下所示:
{'a': 11, 'b': 22, 'c': 13, 'd': 44}
获取最常用的元素
让我们利用集合模块中的 most_common()
函数来实现这一点。
from collections import Counter
l = ['1', 'b', '2', 'a', '3', 'z', '3', 'a', '2', '3']
Counter(l).most_common()[0][0]
代码返回‘3’作为正确的输出!
同时得到商和余数
divmod()
返回一个元组,其功能源于它结合了模百分比和除法/运算符。
Q, R = divmod(35632, 5)
print("Quo. - ",Q)
print("Rem. - ",R)
Quo. - 7126
Rem. - 2
找出前 n 个斐波那契数列
这将是在 Python 中记忆 lambda 函数和递归的极好练习。
fib = lambda x: x if x <= 1 else fib(x - 1) + fib(x - 2)
print(fib(20))
print(fib(5))
6765
5
从列表中删除重复元素
list(set(['1', '1', '2', '1', '3']))
在 Python 中,集合中的每个元素都是唯一的,因此不会有重复。
['1', '3', '2']
结论
恭喜你!您刚刚学习了 Python 编程语言中 5 个有用的一行程序。希望你喜欢它!😇
喜欢这个教程吗?无论如何,我建议你看一下下面提到的教程:
- Python 中更容易调试的技巧
- 在大学编程作业中取得好成绩的最佳技巧
- 3 个 Matplotlib 绘图技巧使绘图有效
- Python 中的竞争性编程:你需要知道什么?
感谢您抽出时间!希望你学到了新的东西!!😄
如何在 Python 中打开文件
原文:https://www.askpython.com/python/built-in-methods/open-files-in-python
Python 在其标准库中为我们提供了文件处理方法。这对于开发人员来说非常方便,因为您真的不需要导入更多的模块来处理文件。
Python 为我们提供的文件处理的关键方法有open()
、close()
、write()
、read()
、seek()
和append()
。
让我们回顾一下open()
方法,它允许我们以不同的模式打开 Python 中的文件。
用 Python 打开文件
要打开一个文件,我们需要的只是文件所在的目录路径。如果它位于同一个目录中,那么只包含完整的文件名就足够了。
我已经创建了一个包含一些示例文本的文件,我们将使用它作为学习 open file 方法的示例。
Python Open File Sample File Contents
1.使用 open()方法打开文件
要打开 OpenFile.txt 并读取文件的文本内容,让我们使用open()
和read()
方法。
file = open('OpenFile.txt')
print(file.read())
file.close()
read()
方法将读取文件的全部内容。
Python Open File Output
默认情况下,open()
方法以只读模式打开文件。要写入文件,我们需要指定文件必须以写模式打开。
2.open()方法的不同模式
让我们尝试在默认模式下写入文件。
file = open('OpenFile.txt')
print(file.read())
file.write("testing write")
file.close()
我们将保持读取操作不变,这样我们就可以看到代码在哪里停止。
File Write Not Permitted Read-Only Mode
那么什么是模式,我们如何添加它们呢?下面是使用 open()方法时的模式列表。
- r :只读模式。
- r+: 读写模式。不会创建新文件,如果文件不存在,打开将会失败
- rb :只读二进制模式,读取图像、视频等。
- w: 只写模式。覆盖现有文件内容。如果指定的文件名不存在,这将创建一个新文件。
- w+: 读写模式。
- wb: 写入媒体文件的二进制只写模式。
- wb+: 二进制读写模式。
- 答:追加模式。不覆盖现有内容
- a+: 追加和读取模式。如果文件名不存在,它将创建一个新文件。
- ab: 为图像、视频等追加二进制模式。
- ab+: 追加读取二进制模式。
3.在 Python 中以写模式打开文件
在 Python 中,有多种方式可以在写入模式下打开文件。根据您希望文件处理方法如何写入文件,您可以使用以下模式之一。
file = open('OpenFile.txt', 'w')
print(file.read())
file.close()
通过在打开文件的第一行时添加“w ”,我们指定文件应该以写模式打开。但是这个操作也会失败,因为文件是只写的,不允许我们使用 read()方法。
Write Only Mode File Not Readable
file = open('OpenFile.txt', 'w')
file.write('New content\n')
file.close()
上面的代码将完全清除文本文件的所有内容,而只说“新内容”。
如果您不想覆盖文件,您可以使用 a +或 r+ 模式。
r+模式将写入传递给write()
方法的任何内容。
file = open('OpenFile.txt', 'r+')
print(file.read())
file.write('r+ method, adds a line\n')
file.close()
a 或 a+模式将执行与 r+模式相同的操作,但有一个主要区别。
在 r+方法的情况下,如果指定的文件名不存在,则不会创建新文件。但是使用+模式,如果指定的文件不可用,将创建一个新文件。
4.使用 with 子句打开文件
当使用open()
方法读取文件时,您总是需要确保调用了close()
方法以避免内存泄漏。作为一名开发人员,您可能会错过添加close()
方法的机会,这会导致您的程序由于文件被打开而泄漏文件内存。
对于较小的文件,对系统资源没有明显的影响,但在处理较大的文件时会表现出来。
with open('OpenFile.txt', 'r+') as file:
print(file.read())
Python Open File Output
在上面的例子中,输出将与我们在开始时看到的一样,但是我们不需要关闭文件。
一个 with
块一执行就获得一个锁,一旦块结束就释放锁。
您还可以在数据上运行其他方法,同时保持在**with**
代码块中。在这种情况下,我编辑了 OpenFile.txt,并添加了一些更多的文本以便更好地理解。
with open('OpenFile.txt', 'r+') as file:
lines = file.readlines()
for line in lines:
print(line.split())
With Command Open File Python 1
只要我们继续在其作用域内工作,with
语句就会为我们处理内存。这是在 Python 中处理文件的另一种但更好的方法。
结论
现在,您应该已经掌握了如何在 Python 中打开文件,以及如何使用 open()方法处理打开文件的不同模式。我们将在接下来的教程中进一步介绍文件处理方法。
如何在 Selenium 中打开网页 URL
原文:https://www.askpython.com/python-modules/open-webpage-urls-selenium
在本文中,我们将学习如何在 Selenium 中访问和打开网页 URL。Python Selenium 是以编程方式操作 web 浏览器的强大工具。它兼容所有浏览器,运行在所有主流操作系统上,其脚本是用各种语言编写的,包括 Python、Java、C#等。其中我们将使用 Python。
Selenium Python 绑定提供了一个简单的 API 来访问 Selenium WebDrivers,比如 Firefox、Internet Explorer、Chrome、Remote 等等。Selenium 目前支持 Python、3.5 和更高版本。
下面给出的代码示例一定会帮助你用 Python 打开网页 URL:
使用 Selenium 打开 URL
现在让我们学习如何在 Python Selenium 中访问网页和打开 URL。这是使用硒的最基本要求。一旦理解了这一点,您只需使用 XPaths 并确定如何使用您用 Python Selenium 收集的数据
1.安装 Python Selenium
我们将使用 pip 命令来安装 selenium 包。
python -m pip install selenium
2.导入模块
现在让我们在 Python 代码中导入 selenium 模块,开始使用它。
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
driver = webdriver.Chrome('./chromedriver.exe')
注意:现在我们已经安装了 Selenium,但是要访问开放的 web 浏览器并使我们的代码可以访问它们,我们需要下载浏览器的官方驱动程序并记下它的路径
这里我们给路径命名为。/chromedriver.exe '因为我们已经将驱动程序放在了 Python 脚本的同一个目录中,如果您将它保存在任何其他地方,那么您必须提供它的完整路径。
3.打开 URL 示例
Python Selenium 中的 URL 是使用 Selenium 模块的 get() 方法打开或获取的
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
driver = webdriver.Chrome('./chromedriver.exe')
driver.get("https://www.google.com")
driver.close()
这将在一个新的测试浏览器窗口中打开谷歌的 Chrome 网站。
close()方法用于关闭浏览器窗口。
4.网页的标题
通过使用以下 python 命令,我们可以在控制台/终端窗口中将网页标题作为文本输出打开:
print(driver.title)
5.在谷歌上搜索查询
语法:网站/搜索?q= '要搜索的主题'
这将在一个新窗口中显示 Chrome 浏览器中谷歌搜索 python 的结果。
driver.get("https://www.google.com/search?q =Python")
6.在浏览器历史记录中来回移动
后退驱动在浏览器历史中后退一步。
语法:driver.back()
前进驱动在浏览器历史中前进了一步
语法:driver.forward()
示例实现:
from selenium import webdriver
driver = webdriver.Chrome("./chromedriver.exe")
# opens Google
driver.get("https://www.google.com")
# open python official website
driver.get("https://www.python.org")
现在,这里首先谷歌将在一个新的窗口中打开,然后在同一窗口和谷歌网站上打开 python 官方网站
driver.back()
# will go to Google
driver.forward()
# will go to python official website
您需要在 back 和 forward 方法之间使用类似 time.sleep(5)的东西来真正注意到转换。
结论
希望您已经学会了使用 Selenium 库在 Python 中打开网页 URL,并准备亲自尝试一下。
使用 OpenCV 的 Python 信用卡读卡器
原文:https://www.askpython.com/python/examples/opencv-credit-card-reader
本教程的目的是帮助您使用 OpenCV 和机器学习技术构建一个信用卡读卡器,以识别卡号和卡类型。
让我们开始吧!
也读:如何使用 OpenCV 读取 Python 中的图像?
OCR 简介
我们一直看到光学字符识别在机器学习和深度学习中被大量使用。许多这样的应用之一包括信用卡和卡号的识别和读取。
Credit Card Reader Demonstration
你可能会想到的问题是为什么?因此,这个应用程序对于银行和其他金融机构数字识别卡号和卡的类型有很大的帮助。
用 Python 实现信用卡读卡器
现在我们已经理解了这个概念,以及在本教程结束时我们将要构建什么。
让我们一步一步地开始构建项目。
步骤 1:导入模块
在这种情况下,我们将使用 numpy 和 matplotlib 以及 openCV 模块。
import cv2
import imutils
import argparse
import numpy as np
from imutils import contours
from matplotlib import pyplot as plt
步骤 2:分配卡类型
卡的类型是根据卡号的第一个数字来分配的。同样显示在下面。
FIRST_NUMBER = {
"3": "American Express",
"4": "Visa",
"5": "MasterCard",
"6": "Discover Card"}
步骤 3:参考图像的加载和预处理
为了读取参考 OCR 图像,我们利用 imread
功能。参考图像包含 OCR 字体中的数字 0-9,这种字体可以在以后的流水线中用于执行匹配。
图像的预处理包括将其转换为灰度图像,然后阈值化+反转图像以获得二值反转图像。
ref = cv2.imread('ocr_a_reference.png')
ref = cv2.cvtColor(ref, cv2.COLOR_BGR2GRAY)
ref = cv2.threshold(ref, 10, 255, cv2.THRESH_BINARY_INV)[1]
步骤 4:检测轮廓
在这一步中,我们找到预处理图像中的轮廓,然后存储返回的轮廓信息。接下来,我们从左到右对轮廓进行排序,并初始化字典 digits,它将数字名称映射到感兴趣的区域。
refCnts = cv2.findContours(ref.copy(), cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
refCnts = imutils.grab_contours(refCnts)
refCnts = contours.sort_contours(refCnts, method="left-to-right")[0]
digits = {}
步骤 5:在数字周围创建边界框
现在,在这一步中,我们循环遍历在上一步中获得的图像轮廓,其中每个值包含数字/数字以及轮廓信息。我们进一步计算每个轮廓的边界框,并存储(x,y)坐标以及计算出的框的高度和宽度。
for (i, c) in enumerate(refCnts):
(x, y, w, h) = cv2.boundingRect(c)
roi = ref[y:y + h, x:x + w]
roi = cv2.resize(roi, (57, 88))
digits[i] = roi
rectKernel = cv2.getStructuringElement(cv2.MORPH_RECT, (9, 3))
sqKernel = cv2.getStructuringElement(cv2.MORPH_RECT, (5, 5))
步骤 6:信用卡图像的加载和预处理
在这一步,我们加载我们的信用卡照片,然后resize
同样的宽度为 300,以保持长宽比。
该步骤之后是将图像转换为grayscale
。在这之后,我们对灰度图像执行morphological operations
。
下一步是计算一个 Scharr gradient
,并将结果存储为gradX
。然后我们计算存储的 gradX 数组的绝对值。我们的目标是缩放 0-255
范围内的所有值。
现在,通过计算 gradX 的最小和最大值来进行值的归一化,并形成一个等式来实现 min-max normalization
。
最后,我们找到contours
并将它们存储在一个列表中,并初始化一个列表来保存数字组的位置。然后像我们在step 5
中对参考图像所做的一样循环遍历轮廓。
接下来,我们将对来自left to right
的分组进行排序,并为信用卡数字初始化一个列表。
image = cv2.imread('credit_card_03.png')
image = imutils.resize(image, width=300)
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
tophat = cv2.morphologyEx(gray, cv2.MORPH_TOPHAT, rectKernel)
gradX = cv2.Sobel(tophat, ddepth=cv2.CV_32F, dx=1, dy=0, ksize=-1)
gradX = np.absolute(gradX)
(minVal, maxVal) = (np.min(gradX), np.max(gradX))
gradX = (255 * ((gradX - minVal) / (maxVal - minVal)))
gradX = gradX.astype("uint8")
gradX = cv2.morphologyEx(gradX, cv2.MORPH_CLOSE, rectKernel)
thresh = cv2.threshold(gradX, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]
thresh = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, sqKernel)
cnts = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
cnts = imutils.grab_contours(cnts)
locs = []
for (i, c) in enumerate(cnts):
(x, y, w, h) = cv2.boundingRect(c)
ar = w / float(h)
if ar > 2.5 and ar < 4.0:
if (w > 40 and w < 55) and (h > 10 and h < 20):
locs.append((x, y, w, h))
locs = sorted(locs, key=lambda x:x[0])
output = []
现在我们知道了每组四位数的位置,让我们遍历这四个已排序的分组并确定其中的位数。循环还包括阈值处理、检测轮廓和模板匹配。
for (i, (gX, gY, gW, gH)) in enumerate(locs):
groupOutput = []
group = gray[gY - 5:gY + gH + 5, gX - 5:gX + gW + 5]
group = cv2.threshold(group, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]
digitCnts = cv2.findContours(group.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
digitCnts = imutils.grab_contours(digitCnts)
digitCnts = contours.sort_contours(digitCnts, method="left-to-right")[0]
for c in digitCnts:
(x, y, w, h) = cv2.boundingRect(c)
roi = group[y:y + h, x:x + w]
roi = cv2.resize(roi, (57, 88))
scores = []
for (digit, digitROI) in digits.items():
result = cv2.matchTemplate(roi, digitROI, cv2.TM_CCOEFF)
(_, score, _, _) = cv2.minMaxLoc(result)
scores.append(score)
groupOutput.append(str(np.argmax(scores)))
cv2.rectangle(image, (gX - 5, gY - 5),
(gX + gW + 5, gY + gH + 5), (0, 0, 255), 2)
cv2.putText(image, "".join(groupOutput), (gX, gY - 15),
cv2.FONT_HERSHEY_SIMPLEX, 0.65, (0, 0, 255), 2)
output.extend(groupOutput)
步骤 7:显示最终结果
下面的代码将显示最终的卡类型、卡号和 OCR 应用的图像。
print("Credit Card Type: {}".format(FIRST_NUMBER[output[0]]))
print("Credit Card #: {}".format("".join(output)))
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Image'); plt.show()
最终代码
import cv2
import imutils
import argparse
import numpy as np
from imutils import contours
from matplotlib import pyplot as plt
FIRST_NUMBER = {
"3": "American Express",
"4": "Visa",
"5": "MasterCard",
"6": "Discover Card"}
ref = cv2.imread('ocr_a_reference.png')
ref = cv2.cvtColor(ref, cv2.COLOR_BGR2GRAY)
ref = cv2.threshold(ref, 10, 255, cv2.THRESH_BINARY_INV)[1]
refCnts = cv2.findContours(ref.copy(), cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
refCnts = imutils.grab_contours(refCnts)
refCnts = contours.sort_contours(refCnts, method="left-to-right")[0]
digits = {}
for (i, c) in enumerate(refCnts):
(x, y, w, h) = cv2.boundingRect(c)
roi = ref[y:y + h, x:x + w]
roi = cv2.resize(roi, (57, 88))
digits[i] = roi
rectKernel = cv2.getStructuringElement(cv2.MORPH_RECT, (9, 3))
sqKernel = cv2.getStructuringElement(cv2.MORPH_RECT, (5, 5))
image = cv2.imread('credit_card_03.png')
image = imutils.resize(image, width=300)
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
tophat = cv2.morphologyEx(gray, cv2.MORPH_TOPHAT, rectKernel)
gradX = cv2.Sobel(tophat, ddepth=cv2.CV_32F, dx=1, dy=0, ksize=-1)
gradX = np.absolute(gradX)
(minVal, maxVal) = (np.min(gradX), np.max(gradX))
gradX = (255 * ((gradX - minVal) / (maxVal - minVal)))
gradX = gradX.astype("uint8")
gradX = cv2.morphologyEx(gradX, cv2.MORPH_CLOSE, rectKernel)
thresh = cv2.threshold(gradX, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]
thresh = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, sqKernel)
cnts = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
cnts = imutils.grab_contours(cnts)
locs = []
for (i, c) in enumerate(cnts):
(x, y, w, h) = cv2.boundingRect(c)
ar = w / float(h)
if ar > 2.5 and ar < 4.0:
if (w > 40 and w < 55) and (h > 10 and h < 20):
locs.append((x, y, w, h))
locs = sorted(locs, key=lambda x:x[0])
output = []
for (i, (gX, gY, gW, gH)) in enumerate(locs):
groupOutput = []
group = gray[gY - 5:gY + gH + 5, gX - 5:gX + gW + 5]
group = cv2.threshold(group, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]
digitCnts = cv2.findContours(group.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
digitCnts = imutils.grab_contours(digitCnts)
digitCnts = contours.sort_contours(digitCnts, method="left-to-right")[0]
for c in digitCnts:
(x, y, w, h) = cv2.boundingRect(c)
roi = group[y:y + h, x:x + w]
roi = cv2.resize(roi, (57, 88))
scores = []
for (digit, digitROI) in digits.items():
result = cv2.matchTemplate(roi, digitROI, cv2.TM_CCOEFF)
(_, score, _, _) = cv2.minMaxLoc(result)
scores.append(score)
groupOutput.append(str(np.argmax(scores)))
cv2.rectangle(image, (gX - 5, gY - 5),
(gX + gW + 5, gY + gH + 5), (0, 0, 255), 2)
cv2.putText(image, "".join(groupOutput), (gX, gY - 15),
cv2.FONT_HERSHEY_SIMPLEX, 0.65, (0, 0, 255), 2)
output.extend(groupOutput)
print("Credit Card Type: {}".format(FIRST_NUMBER[output[0]]))
print("Credit Card #: {}".format("".join(output)))
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Image'); plt.show()
一些示例输出
现在让我们看看在各种信用卡图像上实现上述代码后的一些示例输出。
Credit Card Reader Output 01
Credit Card Reader Output 02
Credit Card Reader Output 03
结论
我希望你理解这个概念,并喜欢输出。用更多的图片尝试同样的方法,结果会让你大吃一惊。
编码快乐!😇
想了解更多?查看下面提到的教程:
Python OpenCV filter2D()函数–完整指南
大家好!在本教程中,我们将学习如何使用 OpenCV filter2D()
方法在图像上应用滤镜,如锐化、模糊和在图像中寻找边缘。所以让我们开始吧。
也读:用 OpenCV 用 Python 读图像
OpenCV filter2D()函数简介
在图像处理中处理图像时,filter2D()
功能用于根据周围的像素亮度值改变图像的像素亮度值。这种方法可以增强或移除图像的某些特征来创建新图像。
python 中定义filter2D()
函数的语法如下:
resulting_image = cv2.filter2D(src, ddepth, kernel)
- src :应用过滤器的源图像。它是一个以像素亮度值表示图像的矩阵。
- ddepth :目标图像的理想深度。值-1 表示结果图像将具有与源图像相同的深度。
- 内核:内核是应用在图像上的滤镜矩阵。
更正式地说,filter2D()
函数将图像与内核进行卷积,这导致图像变得模糊或锐化,并增强图像特征。
什么是内核?
也称为卷积矩阵或遮罩,内核是一个小的二维矩阵,它包含的值表示计算当前像素的亮度值时应该占用周围像素值的多少部分。通常,核是奇数长度的方阵,如 3×3,5×5,7×7 矩阵。
因此,核充当加权矩阵,并用于图像的模糊、图像的锐化、图像中边缘的检测等。在图像处理方面。这是通过图像和内核之间的卷积来完成的。
什么是卷积?
在图像处理中,卷积只是内核和源图像的某个部分的元素乘法,以产生代表像素的新的单个数据点,对图像的每个可能部分进行卷积,以创建新的图像。
在卷积中,我们从源图像中取出一个与核大小相同的子矩阵,将源图像的每个元素与核的相应元素相乘,对之前的计算执行加法,并对数据进行归一化,从而将数据表示为像素值。
考虑下图所示的示例:
Convolution Image Processing Example 1
图像上的卷积会导致图像的大小小于源图像。区别取决于我们内核的大小。然而,有一些方法可以处理它,如这里讨论的。
对不同内核使用 OpenCV filter2d()
让我们对不同内核的图像应用filter2d()
函数,看看会得到什么结果。对于这个例子,我们将使用下面的图像。
Filter2d Source Image
1.锐化图像
您可以了解更多关于锐化图像的信息。这一小段将锐化上面显示的图像。
import cv2
import numpy as np
# Loading source image
src_image = cv2.imread("pug-dog.jpg")
# Defining the kernel of size 3x3
kernel = np.array([
[0, -1, 0],
[-1, 5, -1],
[0, -1, 0]
])
resulting_image = cv2.filter2D(src_image, -1, kernel)
cv2.imshow("original image", src_image)
cv2.imshow("filter2d image", resulting_image)
cv2.imwrite("Filter2d Sharpened Image.jpg", resulting_image)
cv2.waitKey()
cv2.destroyAllWindows()
Filter2d Sharpened Image
2.模糊图像
import cv2
import numpy as np
# Loading source image
src_image = cv2.imread("pug-dog.jpg")
# Defining the kernel of size 3x3
kernel = np.array([
[1, 1, 1],
[1, 1, 1],
[1, 1, 1]
]) / 9
resulting_image = cv2.filter2D(src_image, -1, kernel)
cv2.imshow("original image", src_image)
cv2.imshow("filter2d image", resulting_image)
cv2.imwrite("Filter2d Blur Image.jpg", resulting_image)
cv2.waitKey()
cv2.destroyAllWindows()
Filter2d Blur Image
3.图像的轮廓边缘检测
让我们用 OpenCV filter2D()函数来看看边缘检测。
import cv2
import numpy as np
# Loading source image
src_image = cv2.imread("pug-dog.jpg")
# Defining the kernel of size 3x3
kernel = np.array([
[-1, -1, -1],
[-1, 8, -1],
[-1, -1, -1]
])
resulting_image = cv2.filter2D(src_image, -1, kernel)
cv2.imshow("original image", src_image)
cv2.imshow("filter2d image", resulting_image)
cv2.imwrite("Filter2d Outline Image.jpg", resulting_image)
cv2.waitKey()
cv2.destroyAllWindows()
Filter2d Outline Image
使用浮雕滤镜
import cv2
import numpy as np
# Loading source image
src_image = cv2.imread("pug-dog.jpg")
# Defining the Emboss kernel of size 3x3
kernel = np.array([
[-2, -1, 0],
[-1, 1, 1],
[0, 1, 2]
])
resulting_image = cv2.filter2D(src_image, -1, kernel)
cv2.imshow("original image", src_image)
cv2.imshow("filter2d image", resulting_image)
cv2.imwrite("Filter2d Emboss Image.jpg", resulting_image)
cv2.waitKey()
cv2.destroyAllWindows()
Filter2d Emboss Image
使用 Sobel 滤波器
import cv2
import numpy as np
# Loading source image
src_image = cv2.imread("pug-dog.jpg")
# Defining the Sobel kernel of size 3x3
kernel = np.array([
[-1, 0, 1],
[-2, 0, 2],
[-1, 0, 1]
])
resulting_image = cv2.filter2D(src_image, -1, kernel)
cv2.imshow("original image", src_image)
cv2.imshow("filter2d image", resulting_image)
cv2.imwrite("Filter2d Sobel Image.jpg", resulting_image)
cv2.waitKey()
cv2.destroyAllWindows()
Filter2d Sobel Image
结论
在本教程中,您了解了图像处理中的卷积和内核,以及如何在 python 中使用 OpenCV filter2D()函数来处理图像。现在你可以尝试不同的内核过滤器来获得不同的图像效果。
感谢阅读!!
OpenCV imwrite()–初学者指南
Python OpenCV 是基于英特尔在 2000 年开发的 C++函数。在本文中,将详细解释如何使用 imwrite()函数将图像保存到用户指定的目录中。
安装打开的 CV
由于 OpenCV 是一个第三方库函数,它没有预装在任何 Python IDE 中。因此,首先,您需要学习安装和配置 OpenCV,以便将其用作导入包。
你可能喜欢:Python 的 5 大最佳 ide
在这个例子中,我们使用 Pycharm IDE 来配置 Open CV,因为它比其他 IDE 更简单。
让我们安装最新版本的 PyCharm IDE。安装后,按照以下步骤进行配置:
- 创建新项目。
- 在项目中创建一个 python 文件(。py 扩展)
- 然后进入文件>设置,在左窗格中点击你创建的项目的名称。在下拉菜单中,您会发现一个名为 Python 解释器的选项。
- Python 解释器包含了该项目所需的所有解释器。您需要找到并点击位于“Package”栏上方的+号。
1.1, Open CV Configuration
- 点击它会打开一个新窗口,里面有一个很棒的 python 解释器列表。你需要搜索“opencv-python”并选择一个名为“opencv-Python”的,不要其他的
1.2 Open CV configuration
- 点击下面的安装包。这将在您的 pycharm 系统中安装 opencv 包以及其他必要的包,如果它们像' pip ',' numpy '等丢失的话
1.3 Open CV configuration
使用 OpenCV imwrite()
一旦完成以上步骤,PyCharm IDE 项目就可以使用了。现在我们来看编码部分。
以下内容将提供使用 python OpenCV imwrite()保存图像的步骤。
1.导入 OpenCV
从图像保存开始,我们将导入我们需要的两个包:cv2、os。
import cv2
import os
这篇特别的文章将使用两个 OpenCV 函数来保存图像。两个必需的 cv2 功能是:
- im read()
- imwrite()
2.读取图像
在读取映像之前,程序员需要向编译器指定文件路径和目录。
首先,用图像的文件路径初始化变量‘image location ’,而另一个变量‘filedirectory’用于保存新图像文件将被保存的目录路径。
当两个变量都被初始化时,使用 imread()函数读取图像
示例代码:
imagelocation = (r"C:\Users\Win 10\PycharmProjects\pythonProject\lena.jpg")
filedirectory = (r"C:\Users\Win 10\Pictures")
image = cv2.imread(imagelocation)
注意:要保存的图像文件应该位于 Python 项目文件夹中。您可以使用 PyCharm IDE 复制图像并将其粘贴到文件夹中,也可以手动搜索文件夹并将图像粘贴到其中。
3.保存图像
这里,一个新的名称存储在变量“newfilename”中,然后函数 imwrite()获取上一个示例中使用的变量“image ”,并用新名称保存它。
示例代码:
newfilename = 'image_savedasnew.jpg'<br><br>cv2.imwrite(newfilename, image)
4.使用 OpenCV imwrite()的完整代码
import cv2
import os
imagelocation = (r"C:\Users\Win 10\PycharmProjects\pythonProject\lena.jpg")
filedirectory = (r"C:\Users\Win 10\Pictures")
image = cv2.imread(imagelocation)
# Reading the image
image = cv2.imread(imagelocation)
# Using print command here is not necessary but helpful. If the filepath in both the variables ‘imagelocation’, and ‘filedirectory’ is stored successfully, this command will print a matrix of the image. If there is any mistake in filepath, the compiler will return ‘none’.
print(image)
#to direct compiler towards specified directory
os.chdir(filedirectory)
# It shows the contents of the directory before file is saved
print("list of files available before saving function is executed:")
print(os.listdir(filedirectory))
newfilename = 'image_savedasnew.jpg'
# This is the function specified above that saves image file
cv2.imwrite(newfilename, image)
#Lists directory contents after saving
print("Following execution of imwrite function:")
print(os.listdir(directory))
print('Image Saved Positively')
输出:
结论
关于 Python OpenCV imwrite()函数的快速简单教程到此结束。OpenCV 库中还有很多你可以探索的,我鼓励你在这里浏览我们收集的 OpenCV 教程。
OpenCV putText()–在图像上书写文本
你好,学习伙伴!在本教程中,我们将学习如何使用 OpenCV putText()方法在 Python 中的图像上编写字符串文本。所以让我们开始吧。
OpenCV putText()方法是什么?
OpenCV Python 是一个主要针对实时计算机视觉和图像处理问题的编程函数库。
OpenCV 包含用于在任何图像上放置文本的putText()
方法。该方法使用以下参数。
- img: 你要在上面写文字的图像。
- 文字: 您要在图像上书写的文字。
- org: 是你的文字左下角的坐标。它被表示为一个由两个值(X,Y)组成的元组。x 表示距图像左边缘的距离,Y 表示距图像上边缘的距离。
- 字体: 表示你要使用的字体类型。OpenCV 只支持好时字体的子集。
- 字体 _ 好时 _ 单纯形
- FONT_HERSHEY_PLAIN
- FONT_HERSHEY_DUPLEX
- FONT _ HERSHEY _ 复杂
- FONT_HERSHEY_TRIPLEX
- FONT _ 好时 _COMPLEX_SMALL
- 字体 _ 好时 _ 脚本 _ 单纯形
- FONT _ HERSHEY _ SCRIPT _ 复杂
- 字体 _ 斜体
- fontScale: 它用来增加/减少你的文本的大小。字体比例因子乘以特定字体的基本大小。
- 颜色: 它代表你要给的文本的颜色。它采用
BGR
格式的值,即首先是蓝色值,然后是绿色值,红色值都在 0 到 255 的范围内。 - 粗细(可选): 表示用来绘制文本的线条粗细。默认值为 1。
- 线型(可选): 表示您想要使用的线型。4 可用的线型有
- 装满
- 第 4 行
- LINE_8(默认)
- 线性的
- bottomLeftOrigin(可选): 为真时,图像数据原点在左下角。否则,它在左上角。默认值为 False。
使用 OpenCV–cv2 . puttext()方法在图像上添加文本
让我们使用下面的图片,用 OpenCV putText()方法写一个“早安”消息。
OpenCV PutText Initial Image
# importing cv2 library
import cv2
# Reading the image
image = cv2.imread("Wallpaper.jpg")
# Using cv2.putText()
new_image = cv2.putText(
img = image,
text = "Good Morning",
org = (200, 200),
fontFace = cv2.FONT_HERSHEY_DUPLEX,
fontScale = 3.0,
color = (125, 246, 55),
thickness = 3
)
# Saving the new image
cv2.imwrite("New Wallpaper.jpg", new_image)
OpenCV PutText Final Image
结论
在本教程中,您学习了如何使用 OpenCV putText()方法在图像上书写文本。感谢阅读!!
CV2 调整大小——初学者完全指南
在本文中,我们将学习 OpenCV 包,以及它的 cv2 resize 函数。我们还将查看一些代码示例,以便更好地理解如何在实际场景中使用该函数。
打开 CV–cv2 调整大小()
该图像处理计算机库由英特尔构建,旨在解决计算机中的实时视觉问题。cv2 resize()函数专门用于使用不同的插值技术来调整图像的大小。让我们来了解如何。
简单调整大小
import cv2
image = cv2.imread("img.png", 1)
bigger = cv2.resize(image, (2400, 1200))
cv2.imshow("Altered Image", bigger)
cv2.waitKey(0)
cv2.destroyAllWindows()
上面的代码演示了一个简单的调整大小技术。这里我们没有使用任何插值技术或比例因子,但我们得到了想要的输出。
我们也可以在语法中添加比例因子。缩放因子沿其轴缩放图像,不会给最终输出增加太多差异。带有比例因子的语法如下所示:
scaled = cv2.resize(image, (1200, 600), fx = 0.1, fy = 0.1
,interpolation = cv2.INTER_CUBIC)
通过更改纵横比来调整大小
改变图像的长宽比可以给我们一个缩小或放大的图像。在这个例子中,我们将看看如何做到这一点。
我们将会看到 3 个代码块,其中包括–包导入和图像加载,缩放加载的图像背后使用的逻辑,以及最后,使用插值调整图像的大小。
导入和图像读取
import cv2
pic = cv2.imread('img.png', cv2.IMREAD_UNCHANGED)
上面的代码导入 Python 的 OpenCV 库,然后将图像加载到变量‘pic’中。你可能已经注意到了,我们用了 cv2。它的基本功能是使用 alpha 通道加载图像,这意味着图片的原始分辨率得到保留。
改变纵横比的算法
pd_change = 60 # The percent change from the main aspect ratio
new_resolution = pd_change/100
pic_width = int(pic.shape[1] * new_resolution)
pic_height = int(pic.shape[0] * new_resolution)
new_dimension = (pic_width, pic_height)
让我们一行一行地理解上面的代码:
- “pd_change”变量保存原始纵横比所需的百分比变化。
- “new_resolution”变量将该百分比转换为小数并存储。
- 变量‘pic _ width’和‘pic _ height’使用该十进制值保存新的高度和宽度。语法“pic.shape”用于获取原始图片的纵横比。[0]表示高度,[1]表示宽度。([2]用于不在本文学习范围内的渠道)
- 变量‘new _ dimension’用于存储新的分辨率。
调整图像大小
altered_size = cv2.resize(pic, new_dimension, interpolation=cv2.INTER_AREA)
cv2.imshow("Altered Image", altered_size)
变量' altered_size '使用 cv2.resize()函数调整图像大小,这里使用的插值方法是' cv2。' INTER_AREA ',基本上是用来缩小图像的。因此,最后,我们得到了我们的图像完美地缩放到我们想要的百分比大小。
让我们看看完整的代码,以了解全貌。
import cv2
pic = cv2.imread('img.png', cv2.IMREAD_UNCHANGED)
print('Resolution of the original pic : ', pic.shape)
percent_dim_change = 60 # The percent change from the main size
pic_width = int(pic.shape[1] * percent_dim_change / 100)
pic_height = int(pic.shape[0] * percent_dim_change / 100)
dim = (pic_width, pic_height)
# resizing image
altered_size = cv2.resize(pic, dim, interpolation=cv2.INTER_AREA)
print('Changed Picture Dimensions : ', altered_size.shape)
cv2.imshow("Altered Image", altered_size)
cv2.waitKey(0)
cv2.destroyAllWindows()
Aspect Ratio Change
使用自定义值调整大小
我们可以用特定的宽度和高度值来调整图像的大小,而不考虑它们的原始尺寸。或者,我们可以改变单个参数,即高度,同时保持另一个参数,即宽度,不变。让我们看看代码,了解它是如何做到的。
import cv2
pic = cv2.imread('img.png', cv2.IMREAD_UNCHANGED)
print('Resolution of the original pic : ', pic.shape)
pic_width = pic.shape[1] # keeping intact the original width
pic_height = 800
new_dimension = (pic_width, pic_height)
# resize image
altered_size = cv2.resize(pic, new_dimension, interpolation=cv2.INTER_CUBIC)
print('Changed Picture Dimensions : ', altered_size.shape)
cv2.imshow("Resized image", altered_size)
cv2.waitKey(0)
cv2.destroyAllWindows()
Width Intact Resizing
这里,我们使用了一种不同的插值方法,“INTER_CUBIC”,它对 2X2 的相邻像素进行插值。更改插值方法不会产生太大的差异,在本例中最终结果几乎相同(作为练习,您可以通过更改插值方法并观察最终结果的变化,在您的机器上尝试本例)。尽管如此,在最终输出中,我们得到了一个高度改变的新图像。
注意:在上面的代码中,我们改变了图片的高度,也保持了我们的宽度不变。如果我们想在保持高度不变的情况下改变宽度,我们将使用:
pic_width = 480
pic_height = pic.shape[0] # keeping intact the original height
new_dimension = (pic_width, pic_height)
Height Intact Resizing
结论
我希望这篇文章能帮助你理解 cv2.resize 函数以及如何使用它来改变图像。我们研究了多种不同的方法,通过这些方法我们的图像可以被操纵。我们还研究了如何使用插值来获得我们的图像所需的结果。希望这篇文章能对你的学习有所帮助。
Python 中的 Openpyxl 简介
原文:https://www.askpython.com/python-modules/openpyxl-in-python
在本文中,我们将学习 Python 中的 openpyxl。Excel 电子表格是你在人生的某个阶段必须处理的许多事情之一。你可能需要学习如何处理电子表格,要么是因为你的经理喜欢它们,要么是因为营销人员需要它们,这就是学习openpyxl
的用处所在。
您可以读取电子表格,遍历每一行,从数据库中检索数据,然后使用 Openpyxl 写回电子表格。
了解一些基本术语
在开始学习本模块之前,让我们先了解下表中提到的基本定义:
| 期限 | 定义 |
| 工作簿 | 我们正在处理的主文件。 |
| 工作表 | 整个工作簿中的每个单独的工作表。 |
| 栏 | 标记为 A、B、C、D 等的垂直线。 |
| 行 | 标记为 1、2、3、4、5 等的水平线。 |
| 单元格 | 标记为 A1、A2、A3 等的行和列的组合。 |
Some basic terms and definitions
Openpyxl 模块介绍
Python 中的 Openpyxl 模块用于处理 Excel 文件,不需要第三方微软应用软件。利用这个模块,我们可以在不启动应用程序的情况下操作 Excel。它用于执行 excel 活动,例如从 excel 文件读取数据或将数据写入 excel 文件、绘制图表、访问 excel 表、重命名表、修改(添加和删除)表、格式化、设置表的样式以及任何其他作业。Openpyxl 是为您处理这些工作的高效工具。
数据科学家经常利用 Openpyxl 来执行各种任务,比如数据复制、数据挖掘和数据分析。
在 Python 中安装 Openpyxl
要使用 Openpyxl,您的计算机上必须安装 Python 3.7 和 openpyxl 2.6.2。让我们通过使用以下命令安装 openpyxl 来开始使用它:
pip install openpyxl
在 Python 中使用 openpyxl
让我们直接进入 Python 中 openpyxl 库的工作。我们将通过 excel 文件实现这个库。事不宜迟,我们继续吧。
1。创建和赋值
首先,我们可以使用工作簿功能创建一个新的工作簿。一个工作簿总是包含至少一个工作表。
from openpyxl import Workbook
wb = Workbook()
我们获取活动工作表的位置,并给活动工作表的单元格赋值。
sheet = wb.active
sheet['A1'] = 67847
sheet['A2'] = 'AskPython!'
sheet['A3'] = 8908.983
最后,我们可以使用 save()函数将所有数据存储到“sample_file.xlsx”文件中。最终的 excel 文件如下图所示。
SampleExcelFile1 Openpyxl
3。将数据追加到文件
Openpyxl 中的 append() 函数用于添加一组数据。可以附加任何种类的值。这些值被添加到底部的当前工作表中。
data = ((7434, 675, 5433), ("Python", 'Awesome!',452.8763) )
for i in data:
sheet.append(i)
wb.save("sample_file.xlsx")
修改后的 excel 表如下所示:
SampleExcelFile2 Openpyxl
结论
您现在了解了如何在 Python 中使用电子表格!说到 Excel 文件,您可以依靠 openpyxl 来完成任何事情!希望你喜欢它!😇
喜欢这个教程吗?无论如何,我建议你看一下下面提到的教程:
感谢您抽出时间!希望你学到了新的东西!!😄
Python 中的运算符重载
原文:https://www.askpython.com/python/operator-overloading-in-python
操作符过载是一种现象,它赋予操作符执行的操作超出其预定义操作功能的替代/不同含义。运算符重载也称为运算符特别多态性。
Python 运算符适用于内置类。但是同一个运算符用不同的类型表示是不同的。例如,+
运算符将对两个数字执行算术加法,合并两个列表并连接两个字符串。Python 允许同一个操作符根据引用的上下文有不同的含义。
示例:描述基本算术运算符的不同用法
# Program to show use of
# + operator for different purposes.
print(5 + 5)
# concatenate two strings
print("Safa"+"Mulani")
# Product two numbers
print(10 * 10)
# Repeat the String
print("Safa"*4)
输出:
10
SafaMulani
100
SafaSafaSafaSafa
如何在 python 中霸王一个运算符?
为了执行操作符重载,Python 提供了一些特殊的函数或神奇函数,当它与特定的操作符相关联时会被自动调用。例如,当我们使用+操作符时,神奇的方法__add__
被自动调用,其中定义了+操作符的操作。
Python 中的特殊函数
以双下划线 __ 开头的全局函数在 Python 中被称为特殊函数。是因为他们不一般。我们通常定义的类似于构造函数的 init()函数就是其中之一。每次我们创建该类的新对象时都会调用它。
Python 中二元运算符的神奇方法
| 操作员 | 魔法方法 |
| + | __ 添加 _ _(自己,其他) |
| – | sub(自己,其他) |
| ***** | mul(自己,其他) |
| / | truediv(自己,其他) |
| // | floordiv(自己,其他) |
| % | mod(自己,其他) |
| ****** | pow(自己,其他) |
Python 中比较运算符的神奇方法
| 操作员 | 魔法方法 |
| < | lt(自己,其他) |
| > | gt(自己,其他) |
| < = | le(自己,其他) |
| > = | ge(自己,其他) |
| == | eq(自己,他人) |
| != | ne(自己,其他) |
Python 中赋值运算符的神奇方法
| 操作员 | 魔法方法 |
| -= | isub(自己,其他) |
| += | iadd(自己,其他) |
| *= | imul(自己,其他) |
| /= | idiv(自己,其他) |
| //= | ifloordiv(自己,其他) |
| %= | imod(自己,其他) |
| **= | ipow(自己,其他) |
一元运算符的神奇方法
| 操作员 | 魔法方法 |
| – | neg(自己,其他) |
| + | pos(自己,其他) |
| ~ | invert(自身,其他) |
示例:在 Python 中重载二进制+运算符
当我们使用+操作符时,神奇的方法__add__
被自动调用,其中定义了+操作符的操作。因此,通过改变魔术方法的代码,我们可以赋予+运算符另一种含义。
# Program to overload an binary + operator
class X:
def __init__(self, x):
self.x = x
# adding two objects
def __add__(self, y):
return self.x + y.x
ob1 = X(5)
ob2 = X(5)
ob3 = X("Safa")
ob4 = X("Mulani")
print(ob1 + ob2) # simple addition of objects
print(ob3 + ob4) # concatenation of strings through object addition
输出:
10
SafaMulani
示例:在 Python 中重载比较运算符
class X:
def __init__(self, x):
self.x = x
def __lt__(self, other): # Overloading < operator
if(self.x<other.x):
return "ob1 is less than ob2"
else:
return "ob2 is less than ob1"
def __eq__(self, other):
if(self.x == other.x): # Overloading == operator
return "Both are equal"
else:
return "Not equal"
ob1 = X(2)
ob2 = X(3)
print(ob1 < ob2)
ob3 = X(4)
ob4 = X(4)
print(ob1 == ob2)
输出:
ob1 is less than ob2
Not equal
示例:运算符重载程序示例
class Animal:
def __init__(self, age):
self.__age = age
def setage(self, age):
self.__age = age
def getage(self):
return self.__age
def __add__(self, predict):
return Animal( self.__age + predict.__age )
def __gt__(self, predict):
return self.__age > predict.__age
def __lt__(self, predict):
return self.__age < predict.__age
def __str__(self):
return "Animal with original age " + str(self.__age)
c1 = Animal(5)
print(c1.getage())
c2 = Animal(5)
print(c2.getage())
c3 = c1 + c2
print(c3.getage())
print( c3 > c2)
print( c1 < c2)
print(c3)
输出:
5
5
10
True
False
Animal with original age 10
参考
- Python 运算符重载
- Python 比较运算符
Python 中的光学字符识别(OCR)
原文:https://www.askpython.com/python/examples/optical-character-recognition
在本文中,我们将了解如何使用pytesserac或 python-tesserac 执行光学字符识别。Pytesseract 是一个用于宇宙魔方 -OCR 引擎的包装器。Tesseract 是一个开源的 OCR 引擎,由 Google 管理。
有时候,我们的图像中有文本,我们需要在电脑上输入文本。
对于我们来说,理解图像中的文字是非常容易的,但是对于计算机来说,理解图像中的文字却是一项非常困难的任务。
计算机只会将图像视为像素阵列。
OCR 在这项任务中派上了用场。OCR 检测图像上的文本内容,并将信息转换为计算机容易理解的编码文本。
在本文中,我们将了解如何使用 Python 执行 OCR 任务。
用 Python 实现基本的光学字符识别
使用 pip 为 tesseract 安装 Python 包装器。
$ pip install pytesseract
你可以参考这个关于栈溢出的查询来获得关于安装 Tesseract 二进制文件和使 pytesseract 工作的细节。
1.获取带有清晰可见文本的图像
现在让我们看一个样本图像,并从中提取文本。
Sample text image
2.从图像中提取文本的代码
上面的图像是 jpeg 格式,我们将尝试从中提取文本信息。
#Importing libraries
import cv2
import pytesseract
#Loading image using OpenCV
img = cv2.imread('sample.jpg')
#Converting to text
text = pytesseract.image_to_string(img)
print(text)
输出:
On the Insert tab, the galleries include items that are designed
to coordinate with the overall look of your document. You can
use these galleries to insert tables, headers, footers, lists, cover pages, and other document building blocks. When you create
pictures, charts, or diagrams, they also coordinate with your
current document look.
在使用 OpenCV 加载图像之后,我们使用 pytesseract image _ to _ string 方法,该方法需要一个图像作为输入参数。这一行代码将把图像中的文本信息转换成编码文本。
然而,如果我们不对图像进行预处理,OCR 的实际任务将是具有挑战性的,因为转换的效率直接受到输入图像质量的影响。
利用 OpenCV 实现预处理后的 OCR
我们将用来预处理图像的步骤:
- 将图像转换成灰度–图像需要转换成二进制图像,所以首先,我们将彩色图像转换成灰度。
- 阈值处理用于将灰度图像转换为二值图像。它决定像素值是低于还是高于某个阈值。下面的所有像素都变成白色像素,上面的所有像素都变成黑色像素。
- 现在将图像反转为使用
bitwise_not
操作。 - 运用腐蚀、膨胀等各种降噪技术。
- 将文本提取方法应用于预处理后的图像。
1.查找带有清晰文本的图像
让我们使用下图在代码中实现上述步骤:
Sample For Test
2.使用 Python 从图像中预处理和提取文本的完整代码
现在,我们将按照步骤预处理文件,并从上面的图像中提取文本。当图像对于机器学习算法来说可读且清晰时,光学字符识别效果最佳。
#Importing libraries
import cv2
import pytesseract
import numpy as np
#Loading image using OpenCV
img = cv2.imread('sample_test.jpg')
#Preprocessing image
#Converting to grayscale
gray_image = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
#creating Binary image by selecting proper threshold
binary_image = cv2.threshold(gray_image ,130,255,cv2.THRESH_BINARY + cv2.THRESH_OTSU)[1]
#Inverting the image
inverted_bin = cv2.bitwise_not(binary_image)
#Some noise reduction
kernel = np.ones((2,2),np.uint8)
processed_img = cv2.erode(inverted_bin, kernel, iterations = 1)
processed_img = cv2.dilate(processed_img, kernel, iterations = 1)
#Applying image_to_string method
text = pytesseract.image_to_string(processed_img)
print(text)
输出:
On the Insert tab, the galleries include items that are designed
to coordinate with the overall look of your document. You can
use these galleries to insert tables, headers, footers, lists, cover
pages, and other document building blocks. When you create
pictures, charts, or diagrams, they also coordinate with your
current document look,
You can easily change the formatting of selected text in the
documenttext by choosing a look for the selected text from the
Quick Styies gallery on the Home tab. You can also format text
directly by using the other controls on the Home tab. Most
controls offer a choice of using the look from the current theme
or using a tormat that you specify directly.
To change the overall look of your document, choose new
Theme elements on the Page Layout tab. To change the looks
available in the Quick Style gallery, use the Change Current
Quick Style Set command. Both the Themes gallery and the
Quick Styles gallery provide reset commands so that you can
你可以在这里了解更多关于 OpenCV 及其图像转换功能。
结论
这篇文章是关于用 Python 实现光学字符识别的,它使用了pytesserac包装器和一些预处理步骤,这些步骤可能有助于获得更好的结果。
快乐学习!
Python 中的优化——完整指南
原文:https://www.askpython.com/python/examples/optimization-in-python
在本文中,我们将学习优化问题以及如何在 Python 中解决它。优化的目的是在大量的备选方案中选择一个问题的最佳解决方案。
优化问题
让我们看一个简单的优化案例。假设一家面包店每天生产 1000 包面包,每包包含 10 片面包。为了量化生产,每一批面包都是用精确数量的配料如小麦、酵母等来制作的。
在某个财政季度,公司决定在不降低面包质量或尺寸的情况下削减生产成本。管理层决定将其每个面包的对角线长度减少 1 英寸,这并不明显,但在大规模生产中具有广泛的意义。
所以现在,生产小尺寸面包所需的小麦和酵母的精确数量的要求使它成为一个优化问题。一个良好的优化结果可以削减投入成本,同时保持理想的面包大小。
像所有优化问题一样,这个有问题的任务需要一些对所有编程语言都类似的基本要素:
解决方案——你要提高的量。
在这个关键时刻,最重要的解决方案是尽可能地削减成本。你必须陈述一种方法,该方法在将解决方案保持在期望的限制下的同时,针对优化问题估计可行的结果。
计算可能解的方法被称为目标函数。在面包尺寸问题中,目标函数将告诉我们,当准备一批新的尺寸减小的面包时,需要多少小麦和酵母。
目标函数旨在为任何问题提供最大值(“最大”在这里意味着值根据问题的需要要么最高要么最低),面包维度问题是最小化的,因此最终结果将为解决方案提供最大值,意味着最低值。
约束是对目标函数结果的限制,它依赖于问题的需要,这意味着,在需要最高/最低值的问题中,约束充当最终限制,解决方案不能跨越。
例如,制作一批面包所需的原材料的最低数量将作为一个约束,这意味着每批面包需要小麦和酵母的最低限制。最小化解决方案无法估计低于该阈值的结果。
可行的解决方案可以满足问题的所有要求,但不一定是最优的。确定目标和约束是解决优化问题的第一步。
使用 python 解决优化问题
让我们解决 Python 中的优化问题。主要有三种优化:
- 线性优化
这是从一组参数中寻找最佳可能解决方案的过程。
- 整数优化
当问题中涉及的参数多于一个并且涉及整数或布尔参数时,那么它就变成了可通过整数优化来解决的问题。
- 约束优化
如果问题涉及一个非常大的参数集,并且需要从这个大的约束集中找到解决方案,那么它就变成了一个约束优化问题。
下面是一个最大化问题的例子,它将通过使用整数优化来解决。
最大化问题是一种整数优化问题,其中为某些参数提供约束,并且通过将这些约束转换成线性方程然后求解它来计算可行解。我们将找出下面等式的可行解。
等式是:3a+6b+2c <= 50
4a- 6b + 8c <= 45
3a+b–5c < = 37
这里我们需要最大化 3a + 2b + 2*c
解决最大化问题的主要阶段:
建立和解决问题的基本程序在每种语言中都是相同的:
- 导入您需要的库。
- 做一个关于求解器的声明。
- 变量和参数声明。
- 标记将用于实现目标的方法。
- 调用求解器并输出结果。
解决这个问题的基本步骤是:
进口
from ortools.linear_solver import pywraplp
求解器的声明
solver = pywraplp.Solver.CreateSolver('SCIP')
这是一种使用工具计算问题的方法。
SCIP:它是用于解决混合非线性问题的工具箱或工具的参数。
Pywraplp:因为 ortools 是基于 c++的,所以它需要一个包装器才能在 python 上工作。Pywraplp 就是那个包装器。
定义变量和约束
# a, b, and c are non-negative integer variables.
a = solver.IntVar(0.0, solver.infinity(), 'a')
b = solver.IntVar(0.0, solver.infinity(), 'b')
c = solver.IntVar(0.0, solver.infinity(), 'c')
约束将根据等式定义。例如,第一个等式 3a+6b+2c < = 50 将被定义为:
cons_in1 = solver.Constraint(-solver.infinity(), 50)
cons_in1.SetCoefficient(vara, 3)
cons_in1.SetCoefficient(varb, 6)
cons_in1.SetCoefficient(varc, 2)
目标函数:
我们需要最大化的等式是 3a + 2b + 2*c。下面的代码显示了为该等式创建目标函数的步骤。
obj_prog = solver.Objective()
obj_prog.SetCoefficient(vara, 3)
obj_prog.SetCoefficient(varb, 2)
obj_prog.SetCoefficient(varc, 2)
obj_prog.SetMaximization()
调用求解器并打印最终结果
solver.Solve()
# Print segment of program
print('Highest objective function value = %d' % solver.Objective().Value())
print()
for variable in [vara, varb, varc]:
print('%s = %d' % (variable.name(), variable.solution_value()))
最终代码:
from ortools.linear_solver import pywraplp
def Maximizationproblem():
solver = pywraplp.Solver.CreateSolver('SCIP')
vara = solver.IntVar(0.0, solver.infinity(), 'vara')
varb = solver.IntVar(0.0, solver.infinity(), 'varb')
varc = solver.IntVar(0.0, solver.infinity(), 'varc')
# 3*a + 6*b + 2*c <= 50
cons_in1 = solver.Constraint(-solver.infinity(), 50)
cons_in1.SetCoefficient(vara, 3)
cons_in1.SetCoefficient(varb, 6)
cons_in1.SetCoefficient(varc, 2)
# 4*a - 6*b + 8*c <= 45
cons_in2 = solver.Constraint(-solver.infinity(), 45)
cons_in2.SetCoefficient(vara, 4)
cons_in2.SetCoefficient(varb, -6)
cons_in2.SetCoefficient(varc, 8)
# 3*a + b - 5*c <= 37
cons_in3 = solver.Constraint(-solver.infinity(), 37)
cons_in3.SetCoefficient(vara, 3)
cons_in3.SetCoefficient(varb, 1)
cons_in3.SetCoefficient(varc, -5)
# [END constraints]
# [objective segment of program]
obj_prog = solver.Objective()
obj_prog.SetCoefficient(vara, 3)
obj_prog.SetCoefficient(varb, 2)
obj_prog.SetCoefficient(varc, 2)
obj_prog.SetMaximization()
# Calling solver
solver.Solve()
# Print segment of program
print('Highest objective function value = %d' % solver.Objective().Value())
print()
for variable in [vara, varb, varc]:
print('%s = %d' % (variable.name(), variable.solution_value()))
Maximizationproblem()
输出
Highest objective function value = 42
vara = 12
varb = 2
varc = 1
Process finished with exit code 0
结论
在本文中,我们了解了不同类型的优化以及如何在 Python 中实现这些优化。我们还学习了 ortools 和 python 包装器。此外,我们看到了一个完整的工作代码,它最大化了一组三个线性方程中的一个方程。本文将有助于理解 python 中的优化,并为学习者打下基础。
参考
https://developers . Google . com/optimization/introduction/python
https://developers.google.com/optimization/examples
Python 中的 ORB 特征检测
原文:https://www.askpython.com/python/examples/orb-feature-detection
你好,各位程序员,在本教程中,我们将看到什么是 ORB 特征检测器以及我们如何用 Python 实现它。ORB 代表快速定向旋转简报。
ORB 特征检测简介
Oriented FAST and rotated BRIEF(ORB)是一种快速鲁棒的局部特征检测器,由 Ethan Rublee et al. 于 2011 年首次提出,用于物体识别或 3D 重建等计算机视觉任务。
Sample Multiscaled Image Pyramid
ORB 使用了修改版的快速关键点检测器和简短描述符。在这种情况下,快速特征不是比例不变和旋转不变的。为了使快速惊吓不变,我们使用一个多尺度金字塔。ORB 检测每一关的特征以获得更高的精确度。
用 Python 实现 ORB 特征检测
当谈到 ORB 特征检测时,我们利用一些直接函数来读取图像,检测和计算 ORB 特征,然后将检测到的关键点绘制到图像中。
为了显示图像,我们使用了 OpenCV 库的旧的imshow
函数。代码如下,希望您清楚所采取的步骤。
import cv2
orb=cv2.ORB_create()
img=cv2.imread("selena.jpg",1)
kp, des = orb.detectAndCompute(img, None)
imgg=cv2.drawKeypoints(img, kp, None)
img = cv2.resize(img, (300, 300))
imgg = cv2.resize(imgg, (300, 300))
cv2.imshow("Original Image",img)
cv2.imshow("ORB Feature Detection on Image",imgg)
cv2.waitKey(0)
cv2.destroyAllWindows()
产出#1
1.1 选择的原始图像
Original Image Face Detection
1.2 特征检测后
ORB Face Detection Output Image
样本输出#2
2.1 选择的原始图像
Original Image Face Detection Image2
2.2 特征检测后
ORB Face Detection Output Image2
结论
如你所见,我们的模型检测到了主要特征。您也可以使用自己的个人图像尝试相同的算法。对模型的结果感到惊讶。希望你喜欢这个教程!
感谢您的阅读!
Oshash 模块快速介绍
大家好!oshash 模块将在今天的教程中讨论。我们将探索如何将它融入我们的系统并加以利用。我们还将分析该方法与其他算法在性能方面的比较。接下来,我们将查看它的一些实例,以便更好地理解它。
那么,我们开始吧,好吗?
哈希简介
散列是使用函数或算法将对象数据映射到代表性整数值的过程。这是通过使用具有键值对的表来实现的。它通过散列函数绕过该值进行操作,散列函数返回一个与该值对应的密钥,也称为散列密钥/散列码。然后,整数哈希代码被映射到我们拥有的固定大小。
由此我们可以得出结论,散列函数是可以用来将可变大小的数据转换成固定大小的值的任何函数。哈希值、哈希代码或简单的哈希是哈希函数返回的值。现在我们已经对散列有了基本的了解,我们可以继续学习模块" oshash "
whatmakesosashmodulebetter
虽然有各种有效的算法,但“T0”Oshash 探索了一些不同的技术来实现散列。与其他算法相比,它的主要目的是在其他算法落后时获得好的速度。
使它们变得迟缓的主要缺点是它们一次读取整个文件,这对于“oshash”是不推荐的。相反,它逐段读取文件。
然而,我们不必担心它的内部操作或散列函数。我们将更多地关注它的应用。让我们从安装开始,然后再看例子。
安装 Oshash 模块
我们可以使用 pip 和以下命令来安装它。
pip install oshash
实施 Oshash 模块
所以,一旦我们完成了安装,让我们看看如何把它投入使用。
我们可以通过两种方式利用它:第一种是在我们的程序文件中,第二种是通过命令行界面。让我们来看一个例子。在这两种情况下,它都返回一个散列文件。
程序文件的语法
import oshash
file_hash = oshash.oshash(<path to video file>)
命令行界面的语法
$ oshash <path to file>
虽然我们在前面的例子中没有看到任何这样的技术,但是在后台创建了一个散列,如下面的语法所示。
file_buffer = open("/path/to/file/")
head_checksum = checksum(file_buffer.head(64 * 1024)) # 64KB
tail_checksum = checksum(file_buffer.tail(64 * 1024)) # 64KB
file_hash = file_buffer.size + head_checksum + tail_checksum
结论
恭喜你!您刚刚学习了 Python 中的 Oshash 模块。希望你喜欢它!😇
喜欢这个教程吗?无论如何,我建议你看一下下面提到的教程:
- xlrd 模块——如何在 Python 中处理 Excel 文件?
- pyzbar 模块:用 Python 解码条形码
- Python HTTP 模块–您需要知道的一切!
- Python 制表模块:如何在 Python 中轻松创建表格?
感谢您抽出时间!希望你学到了新的东西!!😄
Python 中的回文
原文:https://www.askpython.com/python/examples/palindrome-in-python
今天我们要学习回文系列,以及如何在 Python 中实现和识别回文。所以让我们开始吧!
什么是回文?
一个数被定义为一个回文数,如果它从向前和向后读完全相同。疯狂的是,它不仅仅对数字有效。即使一个字符串前后读起来一样,它也是一个回文!
让我们看一些例子来更好地理解它。
什么是回文系列?
1.回文数字
让我们考虑两个数字:123321 和 1234561。
第一个数字 123321 ,向前和向后读都是同一个数字。因此它是一个回文数。
另一方面, 1234561 ,倒着读的时候是 1654321 肯定和原数不一样。因此,它不是一个回文数。
2.回文字符串
为回文数字解释的逻辑也适用于字符串。让我们考虑两个基本字符串:aba 和 abc。
字符串 aba 无论怎么读都是一样的(向后或向前)。但是另一方面,向后读取字符串 abc 会导致 cba 与原始字符串不同。
因此 aba 是一个回文,而 abc 不是。
如何验证为回文?
1.回文数字
为了检查一个数是否是回文数,我们首先获取该数的输入,并创建一个作为输入的该数的副本。
然后,我们创建一个新变量来存储反转后的数字,并用 0 初始化它。
使用 mod 10 和除以 10 运算遍历数字,并在每个循环中确保将数字添加到反转的数字变量*10 中。
2.回文字符串
为了检查字符串,我们将一个字符串作为输入,计算它的长度。我们还初始化一个空字符串来存储字符串的反码。
我们创建一个递减循环,从最后一个索引开始,到第一个索引,每次都将当前反转的字符串与获得的新字母连接起来。
用 Python 实现回文的伪代码
1.回文数字
READ n
CREATE A COPY OF n as c_n
CREATE r_v = 0 ( to store reversed number)
WHILE n!=0:
d=n%10
r_v=r_v*10+d
n=n/10
if(c_n == r_v):
print "PALINDROME"
else:
print "NOT PALINDROME"
2.回文字符串
READ s
CALCULATE length of s l_s
CREATE r_s = "" ( to store reversed string)
FOR i: l_s-1 -> 0
r_s + = s[i]
if(r_s == s):
PRINT "PALINDROME"
else:
PRINT "NOT PALINDROME"
用 Python 实现回文检查的代码
现在你知道了什么是回文,以及在字符串和数字的情况下如何处理它们,让我给你看两者的代码。
1.回文实现:数字
让我们使用 Python 来检查回文数字。
n = input()
n = int(n)
copy_n=n
result = 0
while(n!=0):
digit = n%10
result = result*10 + digit
n=int(n/10)
print("Result is: ", result)
if(result==copy_n):
print("Palindrome!")
else:
print("Not a Palindrome!")
2.回文实现:字符串
现在让我们检查 Python 中的回文字符串
s = input()
l_s=len(s)
r_s=""
for i in range(l_s-1,-1,-1):
r_s+=s[i]
print("Reuslt is: ",r_s)
if(r_s==s):
print("PALINDROME")
else:
print("NOT PALINDROME")
回文数字
123321
Result is: 123321
Palindrome!
回文字符串
aibohphobia
Reuslt is: aibohphobia
PALINDROME
结论
恭喜你!今天在本教程中,你学习了回文以及如何实现它们!希望你学到了一些东西!感谢您的阅读!
4 熊猫转换函数要知道用 Python!
原文:https://www.askpython.com/python-modules/pandas/pandas-conversion-functions
读者朋友们,你们好!在本文中,我们将关注 Python 中的 4 个重要的熊猫转换函数。
所以,让我们开始吧!
4 熊猫转换功能
在本主题的过程中,我们将在示例中使用自行车租赁计数预测数据集。你可以在这里找到数据集。
1。Pandas astype()函数
在 Pandas 模块中最常用的 Pandas 转换函数是 astype() 函数。
使用 astype()函数,我们可以轻松地将变量的数据类型从一种类型转换为另一种类型。因此,数据变量之间的相互转换变得容易。
举例:
在这个例子中,首先,我们使用 dtypes 对象检查 dataset 变量的数据类型。
BIKE.dtypes
变量的数据类型:
instant int64
dteday object
season int64
yr int64
mnth int64
holiday int64
weekday int64
workingday int64
weathersit int64
temp float64
atemp float64
hum float64
windspeed float64
casual int64
registered int64
cnt int64
dtype: object
除此之外,我们现在尝试使用 astype()函数将变量 season 的数据类型从整数更改为类别。
整数到类别的转换—
BIKE.season = BIKE.season.astype("category")
BIKE.dtypes
输出:
instant int64
dteday object
season category
yr int64
mnth int64
holiday int64
weekday int64
workingday int64
weathersit int64
temp float64
atemp float64
hum float64
windspeed float64
casual int64
registered int64
cnt int64
2。熊猫 isna()函数
说到数据分析和预处理,对我们来说,研究数据并提取出有意义的信息是非常重要的。检查空值的存在似乎是建模和转换之前的一个重要步骤。
使用 isna() 函数,我们可以很容易地检查空值的存在,如果有的话。这是一个布尔函数,如果它在列或数据集中检测到任何空值,则返回 TRUE。
举例:
在此示例中,isna()函数返回 false,因为它在数据集中遇到零缺失值或空值。
BIKE.isna()
输出:
Conversion Functions
3。Python notna()函数
使用 Python notna()函数,我们可以很容易地分离和查找不等于 NULL 或 na 的值。也就是说,如果 notna()函数检测到非空值的存在,它将返回 TRUE。
举例:
在下面的示例中, notna() 函数返回 TRUE,因为它在整个数据集中没有检测到任何空值。
BIKE.notna()
输出:
Conversion Functions Non Missing Values
4。Python dataframe.copy()函数
当涉及到操作数据集时,拥有原始数据的备份作为进行更改的备用副本对我们来说非常重要。这也有助于我们回滚到最初的情况,以防操纵不起作用。
举例:
在本例中,我们使用 copy() 函数创建了数据帧‘df ’,它保存了由 BIKE 对象表示的数据集的副本。
df = BIKE.copy()
print(df)
输出:
Pandas Copy Dataframe
结论
至此,我们已经结束了关于 Python 转换函数的主题。如果你遇到任何问题,欢迎在下面评论。
更多与 Python 编程相关的帖子,敬请关注我们!
在那之前,学习愉快!🙂
熊猫数据框架平均值——如何计算平均值?
原文:https://www.askpython.com/python-modules/pandas/pandas-dataframe-mean
在本文中,我们将计算 Python pandas 中的数据帧平均值。Python 被广泛用于数据分析和处理。所以一般来说 python 是用来处理庞大且未分类的非正式数据的。为了从我们现有的数据中获得有意义的信息,我们使用统计概念,如均值、中值和众数。这些概念有助于我们对数据进行适当的分类和建模,以便提出一个非常有效的模型。
什么是卑鄙?
Mean 基本上是我们数据集的平均值。对于一个数据集,算术平均值,也称为算术平均值,是一组有限数字的中心值:具体来说,是值的总和除以值的个数。平均值由以下公式给出:
| | = | 等差中项 |
| | = | 值的数量 |
| | = | 数据集值 |
熊猫的数据帧均值
我们在 pandas 中有一个内置的均值函数,可以用在我们的数据框对象上。为了使用 mean 函数,我们需要在代码片段中导入 pandas 库。现在让我们理解均值函数的基本语法和性质
熊猫。数据帧.平均值
mean 函数在应用于系列时将返回系列的平均值,在应用于 dataframe 对象时,将返回 dataframe 中所有系列的平均值列表。现在让我们理解均值函数的语法和参数。
句法
DataFrame.mean(axis=None,skipna=None,level=None,numeric_only=None,**kwargs)
因素
- 轴:取值可以是 0,也可以是 1。默认值为 0,表示索引/行轴。
当轴= 0 时,该功能应用于索引轴和 - 当 axis = 1 时,它应用于列。
- skipna: 计算结果时排除所有空值。
- 级别:与特定级别一起计数,如果轴是多指标(分层),则折叠成一个系列。
- numeric_only: 只包含 int、float、boolean 列。如果没有,它将尝试使用所有数据,然后只使用数字数据。未针对系列实施。
- **kwargs: 要传递给函数的附加关键字参数。
返回系列或数据帧的平均值。
既然我们已经熟悉了函数的语法和参数,现在让我们通过一些例子来理解函数的工作原理。
示例–如何计算数据帧平均值
import pandas as pd
data = [[4, 1, 5], [3, 6, 7], [4, 5, 2], [2, 9, 4]]
df = pd.DataFrame(data)
print(df.mean(axis = 0))
输出
0 3.25
1 5.25
2 4.50
dtype: float64
我们可以看到,平均值是为数据帧的每一行/索引计算的
示例–用轴 1 计算数据帧平均值
import pandas as pd
data = [[4, 1, 5], [3, 6, 7], [4, 5, 2], [2, 9, 4]]
df = pd.DataFrame(data)
print(df.mean(axis = 1))
输出
0 3.333333
1 5.333333
2 3.666667
3 5.000000
dtype: float64
这里我们可以看到,平均值是为每一列计算的。
在下一个例子中,我们将看到如何将均值函数应用于数据帧中的特定序列。
示例 3–计算不带轴的平均值
import pandas as pd
data = [[4, 1, 5], [3, 6, 7], [4, 5, 2], [2, 9, 4]]
df = pd.DataFrame(data)
print(df[0].mean())
上面的代码将打印数据帧中第一个索引轴的平均值。
输出
3.25
这里我们可以验证输出是一个标量值,它是 df[0] = {4,3,4,2}的平均值。即(4+3+4+2)/3 = 3.25
结论
通过本文,我们了解了 mean()函数在熊猫图书馆中的用途和应用。
参考
https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.mean.html
将 Pandas 数据帧转换为 Numpy 数组[分步]
原文:https://www.askpython.com/python-modules/numpy/pandas-dataframe-to-numpy-array
读者你好!在本文中,我们将了解什么是数据帧,以及如何将 Pandas 数据帧转换为 Numpy 数组,反之亦然。让我们开始吧:
介绍
Python 中的数据框是一种二维表格数据结构,由定义数据框不同特征的行和列组成。
我们可以使用 Pandas 库创建一个数据框,或者导入一个已经构建好的数据框(。csv 文件)并处理它。你可以使用 pip 命令安装 Pandas。
pip install pandas
上面写的代码安装了 pandas,我们都准备好使用 Pandas 库的不同功能了。同样,我们将安装 numpy 库:
pip install numpy
首先,我们将看到这个表格结构(pandas 数据帧)到 numpy 数组的转换。
1.将 Pandas 数据帧转换为 Numpy 数组
我们可以通过使用 dataframe.to_numpy() 方法来做到这一点。这将给定的 Pandas 数据帧转换成 Numpy 数组。
- 让我们创建两个数据框,我们将在本教程中使用。
#importing pandas
import pandas as pd
#creating dataframes
student_data = {"Name": ['Alice', 'Sam', 'Kevin', 'Max', 'Tom'],
"exam_no": [201, 202, 203, 204, 205],
"Result": ['Pass', 'Pass', 'Fail', 'Pass', 'Fail']}
set_of_numbers = {"Numbers": ['134', '273', '325','69.21','965']}
print("This is our first dataset :")
student_dataframe = pd.DataFrame(student_data)
print("\n",student_dataframe)
print("\nThis is our second dataset :")
numbers_dataframe = pd.DataFrame(set_of_numbers)
print("\n",numbers_dataframe)
- 我们创建了两个数据帧:学生数据和数字集合。我们的数据框看起来像这样:
- 现在,在将 Pandas 数据帧转换为 Numpy 数组之前,让我们来看看类型:
print(type(student_dataframe))
print(type(numbers_dataframe))
上面两条语句的输出是相同的。即,
<class 'pandas.core.frame.DataFrame'>
- 要将这个 Pandas 数据帧转换成 Numpy 数组,运行下面给出的代码
将学生数据转换为
student_array = student_dataframe.to_numpy()
print(student_array)
输出:
[['Alice' 201 'Pass']
['Sam' 202 'Pass']
['Kevin' 203 'Fail']
['Max' 204 'Pass']
['Tom' 205 'Fail']]
对于第二数据帧(组数)
numbers_array = numbers_dataframe.to_numpy()
print(numbers_array)
输出:
[['134']
['273']
['325']
['69.21']
['965']]
- 我们还可以检查两个数组的数据类型:
print(type(student_array))
print(type(numbers_array))
输出:
<class 'numpy.ndarray'>
<class 'numpy.ndarray'>
因此,我们可以清楚地看到,我们只用了几个步骤就将 Pandas 数据帧转换为 Numpy 数组。这是处理数据帧及其转换的最简单方法。
- 此外,我们还可以更改数据框中列的数据类型。考虑到我们的第二个数据帧,它由一些整数值和一些浮点值组成,让我们尝试将它们都改为浮点型。
print(numbers_dataframe.to_numpy(dtype ='float64'))
输出:
[[134\. ]
[273\. ]
[325\. ]
[ 69.21]
[965\. ]]
2.将 Numpy 数组转换为 Pandas 数据帧
现在您已经理解了 Pandas 数据帧到 Numpy 数组的转换,我们可能需要将数据转换回 Numpy 数组。让我们看看如何做到这一点:
- 首先,定义一个 numpy 数组。然后使用 pandas 执行转换。熊猫图书馆的 DataFrame()函数。
#importing pandas and numpy
import pandas as pd
import numpy as np
#defining numpy array
arr1 = np.array([[1,6,4,5], [3,7,2,4], [9,5,3,7]])
print("Numpy array : ")
print(arr1)
我们的数组是这样的:
Numpy array :
[[1 6 4 5]
[3 7 2 4]
[9 5 3 7]]
- 现在,把它转换成熊猫数据帧:
#converting array to dataframe
df = pd.DataFrame(arr1)
print("\npandas dataframe :")
df
转换后的数据帧为:
- 检查数据帧的类型:
type(df)
输出:
pandas.core.frame.DataFrame
- 我们还可以为数据帧的行和列指定自己的标题。可以使用关键字 index 给出行的标题,对于列,我们使用关键字 columns 。
#converting and providing headers
df = pd.DataFrame(arr1, index = ["1","2","3"], columns = ["A","B","C","D" ])
print("\npandas dataframe :")
df
这将使我们的数据框看起来像这样:
结论
就这样,我们到了这篇文章的结尾。在这篇文章中,你明白了
- 熊猫数据帧和数组的基本知识
- 如何将 pandas 数据帧转换为 numpy 数组
- 如何将 numpy 数组转换为 pandas 数据帧
我希望这篇文章对你有用。谢谢大家!🙂
参考文献—
- https://pandas . pydata . org/pandas-docs/stable/reference/API/pandas。data frame . to _ numpy . html
- https://stack overflow . com/questions/13187778/convert-pandas-data frame-to-numpy-array/
Pandas 数据帧和 Numpy 数组的区别
原文:https://www.askpython.com/python/pandas-dataframe-vs-numpy-arrays
我们经常混淆 Python 中的数据结构,因为它们看起来有些相似。Python 中的数据帧和数组是两种非常重要的数据结构,在数据分析中非常有用。在这篇文章中,我们将学习 Python 中 Pandas DataFrame 和 Numpy Array 的区别。
让我们从理解 Numpy 数组开始。
也读作:将熊猫 DataFrame 转换为 Numpy 数组【分步】
什么是 Numpy 数组?
NumPy 数组是 Python 中的一种多维数据结构,可以存储相似数据类型的对象。数组的元素由非负或正整数索引。数组是可变的,这意味着数组在形成后可以改变。数组在对向量进行数学运算时非常有用。它们为执行向量运算提供了许多有用的方法。
让我们看看如何创建一个数组。
我们将使用 Python 中的 Numpy 库。
import numpy as np
arr = np.array([1, 2, 3, 4, 5])
print(arr)
输出:
[1, 2, 3,4, 5]
现在让我们看看熊猫数据帧是什么。
什么是数据帧?
DataFrame 是 Python 中的一种二维表格可变数据结构,可以存储包含不同数据类型对象的表格数据。数据帧具有以行和列的形式标记的轴。数据帧是数据预处理的有用工具,因为它为数据处理提供了有用的方法。数据框架对于创建数据透视表和使用 Matplotlib 绘图也非常有用。
让我们看看如何在 Pandas 中创建数据帧。
import pandas as pd
# Creating a dictionary
data = {'Name':["Tommy","Linda","Justin","Brendon"], 'Age':[31,24,16,22]}
df=pd.DataFrame(data)
print(df)
输出:
Name Age
0 Tommy 31
1 Linda 24
2 Justin 16
3 Brendon 22
数据帧和数组的比较
下面列出了数据帧和数组之间的主要区别:
- Numpy 数组可以是多维的,而 DataFrame 只能是二维的。
- 数组包含相似类型的对象或元素,而数据帧可以有对象或多种或相似的数据类型。
- 数组和数据帧都是可变的。
- 数组中的元素只能使用整数位置来访问,而数据帧中的元素可以使用整数和索引位置来访问。
- 数据帧主要是以 SQL 表的形式出现,与表格数据相关联,而数组与数字数据和计算相关联。
- 数据帧可以处理动态数据和混合数据类型,而数组不具备处理此类数据的灵活性。
结论
在本文中,您了解了 Pandas DataFrame 和 Numpy Array 之间的区别。Numpy 数组专门用于复杂的科学计算,而数据帧主要用于数据预处理。虽然这两种数据结构在数据分析中都起着非常重要的作用。
熊猫 fillna()方法——完全指南
数据分析已经成为我们日常生活的重要组成部分。每天我们都要处理来自不同领域的不同种类的数据。数据分析的主要挑战之一是数据中缺失值的存在。在本文中,我们将学习如何在 fillna()方法的帮助下处理数据集中的缺失值。我们开始吧!
熊猫 fillna()方法是什么,为什么有用?
Pandas Fillna()是一种用于填充数据集中缺失值或 na 值的方法。您可以填充像零这样的缺失值,也可以输入一个值。当您处理 CSV 或 Excel 文件时,这种方法通常会很方便。
不要与我们删除丢失值的 dropna()方法混淆。在这种情况下,我们将用零或用户输入的值替换丢失的值。
让我们来看看 fillna()函数的语法。
DataFrame.fillna(value=None, method=None, axis=None, inplace=False, limit=None, downcast=None, **kwargs)
让我们看看下面的例子,看看如何在不同的场景中使用 fillna()方法。
Pandas DataFrame fillna()方法
在下面的例子中,我们将用零填充 NAN 值的位置。
import pandas as pd
import numpy as np
df = pd.DataFrame([[np.nan, 300, np.nan, 330],
[589, 700, np.nan, 103],
[np.nan, np.nan, np.nan, 675],
[np.nan, 3]],
columns=list('abcd'))
print(df)
#Filling the NaN values with zeros.
print("\n")
print(df.fillna(0))
输出
a b c d
0 NaN 300.0 NaN 330.0
1 589.0 700.0 NaN 103.0
2 NaN NaN NaN 675.0
3 NaN 3.0 NaN NaN
a b c d
0 0.0 300.0 0.0 330.0
1 589.0 700.0 0.0 103.0
2 0.0 0.0 0.0 675.0
3 0.0 3.0 0.0 0.0
只对一列应用 fillna()方法
df = pd.DataFrame([[np.nan, 300, np.nan, 330],
[589, 700, np.nan, 103],
[np.nan, np.nan, np.nan, 675],
[np.nan, 3]],
columns=list('abcd'))
print(df)
#Filling the NaN value
print("\n")
newDF = df['b'].fillna(0)
print(newDF)
输出
a b c d
0 NaN 300.0 NaN 330.0
1 589.0 700.0 NaN 103.0
2 NaN NaN NaN 675.0
3 NaN 3.0 NaN NaN
0 300.0
1 700.0
2 0.0
3 3.0
Name: b, dtype: float64
还可以使用 limit 方法指定要填充 NAN 值的行。
import pandas as pd
import numpy as np
df = pd.DataFrame([[np.nan, 300, np.nan, 330],
[589, 700, np.nan, 103],
[np.nan, np.nan, np.nan, 675],
[np.nan, 3]],
columns=list('abcd'))
print(df)
# Filing the NaN value
print("\n")
print(df.fillna(0, limit=2))
输出
a b c d
0 NaN 300.0 NaN 330.0
1 589.0 700.0 NaN 103.0
2 NaN NaN NaN 675.0
3 NaN 3.0 NaN NaN
a b c d
0 0.0 300.0 0.0 330.0
1 589.0 700.0 0.0 103.0
2 0.0 0.0 NaN 675.0
3 NaN 3.0 NaN 0.0
在上面的方法中,我们应用了 limit=2,这意味着我们只替换了前两行中的 NAN 值。
结论
总之,我们学习了在数据帧中填充 NAN 值的不同方法。所有这些方法在你的任何数据分析项目中都会派上用场。
了解熊猫 groupby()函数
原文:https://www.askpython.com/python-modules/pandas/pandas-groupby-function
嘿,伙计们!在本文中,我们将了解 Pandas groupby()函数以及它所提供的不同功能。
什么是 groupby()函数?
Python Pandas 模块广泛用于更好的数据预处理,并与数据可视化密切相关。
Pandas 模块具有各种内置功能,可以更有效地处理数据。Pandas 的dataframe.groupby() function
模块用于根据某些预定义的条件或选项,从整个数据集中分割和分离出一部分数据。
语法:
dataframe.groupby('column-name')
使用上面的语法,我们可以拆分数据集,并选择属于传递的列的所有数据作为函数的参数。
输入数据集:
Input Dataset Pandas groupby() Function
举例:
import pandas
data = pandas.read_csv("C:/marketing_tr.csv")
data_grp = data.groupby('marital')
data_grp.first()
在上面的例子中,我们使用了 groupby()函数来拆分和单独创建一个新的数据框,其中所有数据分别属于“婚姻”列。
输出:
Python Pandas groupby() function
多列 Pandas groupby()函数
使用Pandas dataframe.groupby() function
可以按照多列值分割数据。因此,我们可以将多个列标记作为参数传递,以便只将数据值与那些列值一起分割和隔离。
语法:
dataframe.groupby(['column1', 'column2', ...., 'columnN'])
举例:
import pandas
data = pandas.read_csv("C:/marketing_tr.csv")4
data_grp = data.groupby(['marital','schooling'])
data_grp.first()
输出:
Grouping Multiple Columns Using groupby() function
Pandas groupby()函数查看群组
除了根据特定的列值分割数据之外,我们甚至可以使用dataframe.groupby().groups
函数查看由列的类别组成的每个组的详细信息。
以下是本例中使用的样本数据集的快照:
Marketing Tr Csv 1
语法:
dataframe.groupby('column').groups
举例:
import pandas
data = pandas.read_csv("C:/marketing_tr.csv")
data_grp = data.groupby('marital').groups
data_grp
如上所示,我们已经拆分了数据,并从列“婚姻”中形成了一个新的数据框架。
此外,我们还使用了 groupby()。groups 函数显示该特定列中所有类别的值。
此外,它还表示这些类别在原始数据集中的位置,以及数据类型和值的数量。
输出:
{'divorced': Int64Index([ 3, 4, 33, 34, 63, 66, 73, 77, 98, 112,
...
7284, 7298, 7300, 7326, 7349, 7362, 7365, 7375, 7391, 7412],
dtype='int64', length=843),
'married': Int64Index([ 1, 2, 5, 7, 8, 9, 10, 11, 13, 14,
...
7399, 7400, 7403, 7404, 7405, 7406, 7407, 7408, 7410, 7413],
dtype='int64', length=4445),
'single': Int64Index([ 0, 6, 12, 16, 18, 19, 24, 29, 31, 32,
...
7383, 7385, 7386, 7390, 7397, 7398, 7401, 7402, 7409, 7411],
dtype='int64', length=2118),
'unknown': Int64Index([2607, 4770, 4975, 5525, 5599, 5613, 6754, 7221], dtype='int64')}
使用 Pandas groupby()函数选择组
正如到目前为止所看到的,我们可以查看不同类别的唯一值的概述,这些值在列中有详细信息。
使用dataframe.get_group('column-value')
,我们可以显示属于由 groupby()函数分组的列的特定类别/数据值的值。
语法:
dataframe.get_group('column-value')
举例:
import pandas
data = pandas.read_csv("C:/marketing_tr.csv")
data_grp = data.groupby('marital')
df = data_grp.get_group('divorced')
df.head()
在上面的示例中,我们显示了属于“婚姻”列的值为“离婚”的列的数据。
输出:
Selecting a group Using groupby() function
结论
因此,在本文中,我们已经详细了解了 Pandas groupby()函数的工作原理。
参考
- Pandas groupby()函数— JournalDev
熊猫的 isin()函数——一个完整的指南
原文:https://www.askpython.com/python-modules/pandas/pandas-isin
大家好!在本教程中,我们将学习熊猫模块中的isin()
方法,并且我们将研究当不同类型的值被传递时这个函数的行为。所以让我们开始吧。
DataFrame.isin()方法
Pandas isin()
方法用于过滤数据帧中的数据。该方法检查数据帧中的每个元素是否包含在指定的值中。这个方法返回布尔值的数据帧。如果元素出现在指定的值中,返回的数据帧包含True
,否则显示False
。因此,这种方法在过滤数据帧时很有用,我们将通过下面的例子看到这一点。
isin()
方法的语法如下所示。它只需要一个参数:
DataFrame.isin(values)
这里参数values
可以是其中的任何一个:
- 列表或可迭代
- 词典
- 熊猫系列
- 熊猫数据框
让我们看看当不同的值被传递给方法时isin()
方法的结果。
isin()方法的示例
让我们考虑一些通过传递不同类型的值的isin()
方法的例子。对于以下示例,我们将使用以下数据:
import pandas as pd
data = pd.DataFrame({
'Name': ['John', 'Sam', 'Luna', 'Harry'],
'Age': [25, 45, 23, 32],
'Department': ['Sales', 'Engineering', 'Engineering', 'Human Resource']
})
print(data)
Name Age Department
0 John 25 Sales
1 Sam 45 Engineering
2 Luna 23 Engineering
3 Harry 32 Human Resource
值为列表时的 isin()方法
当一个列表作为参数值传递给isin()
方法时,它检查 DataFrame 中的每个元素是否都在列表中,如果找到,就显示True
。例如,如果我们传递一个包含一些部门的值的列表,Department
列中的那些值将被标记为True
。
import pandas as pd
# Creating DataFrame
data = pd.DataFrame({
'Name': ['John', 'Sam', 'Luna', 'Harry'],
'Age': [25, 45, 23, 32],
'Department': ['Sales', 'Engineering', 'Engineering', 'Human Resource']
})
#List of Departments to filter
departments_to_filter = ['Engineering', 'Sales', 'Finance']
result = data.isin(departments_to_filter)
print(result)
Name Age Department
0 False False True
1 False False True
2 False False True
3 False False False
因此,使用这种方法,我们也可以根据情况过滤数据帧。例如,我们想要查找年龄在 20 到 30 岁之间的员工,我们可以在Age
列上使用isin()
方法。
import pandas as pd
# Creating DataFrame
data = pd.DataFrame({
'Name': ['John', 'Sam', 'Luna', 'Harry'],
'Age': [25, 45, 23, 32],
'Department': ['Sales', 'Engineering', 'Engineering', 'Human Resource']
})
start_age=20
end_age=30
# Using isin() method to filter employees on age
age_filter = data['Age'].isin(range(start_age, end_age+1))
# Using the filter to retrieve the data
result = data[ age_filter ]
print(result)
Name Age Department
0 John 25 Sales
2 Luna 23 Engineering
值为字典时的 isin()方法
当一个字典作为参数值传递给isin()
方法时,对于 DataFrame 的不同列,要搜索的数据范围是不同的。因此,我们可以分别搜索每一列。例如,在字典中,我们可以为Name
和Department
传递一个带有各自值的列表来进行搜索,如下所示。
import pandas as pd
# Creating DataFrame
data = pd.DataFrame({
'Name': ['John', 'Sam', 'Luna', 'Harry'],
'Age': [25, 45, 23, 32],
'Department': ['Sales', 'Engineering', 'Engineering', 'Human Resource']
})
#Dictionary data to filter DataFrame
dict_data_to_filter = {'Name': ['Sam', 'Harry'], 'Department': ['Engineering']}
result = data.isin(dict_data_to_filter)
print(result)
Name Age Department
0 False False False
1 True False True
2 False False True
3 True False False
值为序列时的 isin()方法
当熊猫序列作为参数值传递给isin()
方法时,序列中写入值的顺序变得很重要。数据帧的每一列都将按照写入的顺序,用序列中的值逐一检查。考虑下面的例子。
import pandas as pd
# Creating DataFrame
data = pd.DataFrame({
'Name': ['John', 'Sam', 'Luna', 'Harry'],
'Age': [25, 45, 23, 32],
'Department': ['Sales', 'Engineering', 'Engineering', 'Human Resource']
})
#Series data, changing index of Sam and Luna
series_data = pd.Series(['John', 'Luna', 'Sam', 'Harry'])
result = data.isin(series_data)
print(result)
Name Age Department
0 True False False
1 False False False
2 False False False
3 True False False
尽管序列中出现的值包含数据 DataFrame 中出现的所有Names
,但索引 1 和 2 处的结果包含False
,因为我们互换了“Sam”和“Luna”的索引。因此,当序列作为值传递时,索引很重要。
当值为 DataFrame 时,使用 isin()方法
当 Pandas 数据帧作为参数值传递给isin()
方法时,传递的数据帧的索引和列必须匹配。如果两个数据帧相同,但列名不匹配,结果将显示这些列的False
。如果两个数据帧中的数据相同,但顺序不同,那么对于那些不同的行,结果将是False
。因此,如果传递数据帧,索引和列都很重要。考虑这个例子。
import pandas as pd
# Creating DataFrame
data = pd.DataFrame({
'Name': ['John', 'Sam', 'Luna', 'Harry'],
'Age': [25, 45, 23, 32],
'Department': ['Sales', 'Engineering', 'Engineering', 'Human Resource']
})
# DataFrame to filter, here column name Age to lowercased to age
df = pd.DataFrame({
'Name': ['John', 'Sam', 'Luna', 'Harry'],
'age': [25, 45, 23, 32],
'Department': ['Sales', 'Engineering', 'Engineering', 'Human Resource']
})
result = data.isin(df)
print(result)
print("-----------------")
# DataFrame to filter, here last 2 rows are swapped
df = pd.DataFrame({
'Name': ['John', 'Sam', 'Harry', 'Luna'],
'Age': [25, 45, 32, 23],
'Department': ['Sales', 'Engineering', 'Human Resource', 'Engineering']
})
result = data.isin(df)
print(result)
Name Age Department
0 True False True
1 True False True
2 True False True
3 True False True
-----------------
Name Age Department
0 True True True
1 True True True
2 False False False
3 False False False
结论
在本教程中,我们学习了 Pandas isin()
方法,它的不同用例,以及该方法如何帮助从数据帧中过滤出数据。现在你知道了如何使用isin()
方法,并且可以在数据框架中轻松过滤数据,所以恭喜你。
感谢阅读!!
熊猫数学的数据分析功能,你应该知道!
原文:https://www.askpython.com/python-modules/pandas/pandas-math-functions
读者朋友们,你们好!在本文中,我们将详细关注用于数据分析的 Python Pandas 数学函数。所以,让我们开始吧!
熊猫数学函数在数据分析中的作用
在统计和数据分析领域,基本任务是分析数据并从中得出观察结果,以便在此基础上建立更好的模型。同样,我们也有必要探索在分析数据的过程中有助于从中提取有意义信息的函数。
Python 编程为我们提供了包含各种函数的 Pandas 模块,使我们能够分析数据值。
数据分析仅仅意味着从原始数据源中提取有意义的信息。这些信息使我们对数据的分布和结构有所了解。
在本文中,我们将了解以下功能:
- 熊猫。DataFrame.mean()函数
- 熊猫。DataFrame.sum()函数
- 熊猫。DataFrame.median()函数
- 熊猫最小()和最大()函数
- 熊猫。DataFrame.value_counts()函数
- 熊猫。DataFrame.describe()函数
在接下来的部分中,让我们逐一了解一下!
在本文中,我们利用了自行车租赁预测数据集。你可以在这里找到数据集!
1.熊猫意味着()函数
均值作为一个统计值,通过单个值表示数据的整个分布。使用 dataframe.mean() 函数,我们可以获得单个列或多个列(即整个数据集)的平均值。
举例:
在本例中,我们对整个数据集应用了 mean()函数。
BIKE.mean()
输出:
因此,数据集所有列的平均值如下所示
instant 366.000000
season 2.496580
yr 0.500684
mnth 6.519836
holiday 0.028728
weekday 2.997264
workingday 0.683995
weathersit 1.395349
temp 0.495385
atemp 0.474354
hum 0.627894
windspeed 0.190486
casual 848.176471
registered 3656.172367
cnt 4504.348837
dtype: float64
2.熊猫 sum()函数
除了 mean()函数之外,我们还可以利用 Pandas sum()函数在更大的范围内获得列值的总和。这使我们能够从数量上对数据有一个更广阔的视角。
举例:
这里,我们通过对整个数据集应用 sum()函数计算了数据集每一列的总和。
BIKE.sum()
输出:
instant 267546
dteday 2011-01-012011-01-022011-01-032011-01-042011-0...
season 1825
yr 366
mnth 4766
holiday 21
weekday 2191
workingday 500
weathersit 1020
temp 362.126
atemp 346.753
hum 458.991
windspeed 139.245
casual 620017
registered 2672662
cnt 3292679
dtype: object
3.熊猫中位数()函数
使用 median()函数,我们可以得到一组数据的 50%值或中心值。
举例:
这里,我们对数据集的每一列都应用了 median()函数。
BIKE.median()
输出:
在这里,我们看到数据集每一列的中值。
instant 366.000000
season 3.000000
yr 1.000000
mnth 7.000000
holiday 0.000000
weekday 3.000000
workingday 1.000000
weathersit 1.000000
temp 0.498333
atemp 0.486733
hum 0.626667
windspeed 0.180975
casual 713.000000
registered 3662.000000
cnt 4548.000000
4.熊猫 min()和 max()函数
使用 min()和 max()函数,我们可以获得数据集每一列的最小值和最大值,以及数据帧的单个列。
举例:
这里,我们应用了 max()函数来获取数据集每一列的最大限制。
BIKE.max()
输出:
instant 731
dteday 2012-12-31
season 4
yr 1
mnth 12
holiday 1
weekday 6
workingday 1
weathersit 3
temp 0.861667
atemp 0.840896
hum 0.9725
windspeed 0.507463
casual 3410
registered 6946
cnt 8714
dtype: object
5.Pandas value_counts()函数
使用 value_counts()函数,我们可以获取变量中每个类别或组的计数。这对于分类变量是有益的。
举例:
BIKE.season.value_counts()
这里,我们对季节变量应用了 value_counts()函数。如下所示,我们将变量中每个组的计数作为一个单独的类别。
输出:
3 188
2 184
1 181
4 178
6.熊猫描述()函数
用 describe()函数,我们立刻得到下面的统计信息:
- 每列数据值的计数
- 表示
- 标准偏差
- 最小值
- 最大值
- 25%值【第一个四分位数】
- 50%,即中位数
- 75%值【第三个四分位数】
举例:
BIKE.describe()
输出:
Pandas Describe Dataframe
结论
到此,我们就结束了这个话题。如果你遇到任何问题,欢迎在下面评论。
更多与 Python 编程相关的帖子,请继续关注我们。
在那之前,学习愉快!!🙂
Python 中的熊猫数据透视表–简易指南
原文:https://www.askpython.com/python-modules/pandas/pandas-pivot-tables
在本文中,我们将讨论 Python 中的数据透视表。我们将使用 Pandas 模块中的 pivot_table 函数实现相同的功能。
什么是数据透视表?
数据透视表是 Microsoft Excel 的一个关键特性,也是 Excel 在企业界如此受欢迎的原因之一。
数据透视表为执行数据分析提供了极大的灵活性。
它允许我们将列转换为行,将行转换为列。由于它允许基于任何参数进行分组,因此很容易与函数的 pandas Groupby 混淆。
可以将数据透视表看作是GroupBy
函数的多维版本。
用 Python 实现数据透视表的步骤
让我们直接进入 Python 中数据透视表的实现。
1.加载您选择的数据集
我们将使用统计数据集(从 Kaggle 下载)分析神奇宝贝。在这里可以得到数据集。
不管你是否喜欢口袋妖怪,你仍然可以从这篇文章中得到 100%。
要抓住他们所有人……🙂
import pandas as pd
#importing the dataset
data = pd.read_csv('Pokemon.csv')
data.head()
Dataset
2.pivot_table()方法语法
DataFrame.pivot_table(data, values=None, index=None,columns=None, aggfunc='mean')
在对一个数据帧调用了pivot_table
方法之后,让我们分解给这个方法的基本输入参数。
- 数据–这是我们应用聚合函数的数字列。比如销量,速度,价格等。
- index–我们要转换为行的列。我们可以将多个值作为一个列表传递。
- 列–我们现在希望保留为列的列变量。
- agg func–对数据执行的操作类型。即总和、平均值、计数等。
举个例子会更清楚。
3.用 Python 实现 pivot_tables
假设我们需要找到属于 Type-1 的神奇宝贝的平均速度。
使用 pandas Groupby
可以很容易地做到这一点,但是使用代码更加简洁的pivot_table
也可以很容易地实现相同的输出。
通过每个例子,我们将慢慢探索 pivot_table 的全部优点。
df.groupby(['Type 1'])[['Speed']].mean()
使用pivot_table
的类似结果
df.pivot_table('Speed' , index = ['Type 1'], aggfunc = 'mean')
Result With gropuby And Pivot Table
4.使用数据透视表查找平均速度
但是现在如果我们被要求找出每一个 1 型神奇宝贝的平均速度,并把它们分成传奇和非传奇。
df.pivot_table('Speed' , index = ['Type 1'] , columns= ['Legendary'] , aggfunc = 'mean')
Mean Speed Legendary Vs Non Legendary Pokémon’s
Tada!只需一行代码,我们就能获得想要的结果。
我不禁注意到,一般来说,传说中的神奇宝贝比非传说中的要快。数据透视表的魔力。
这里需要理解的一件重要事情是,我们需要 Type 1 列作为我们的索引,所以我们将它传递给 pivot_table 方法中的 index 参数。
但是现在,由于每个 1 型口袋妖怪都属于传奇或非传奇类别,我们只是以某种方式转换了我们的数据框架,以便它现在显示每种类型的平均速度。
现在,我们的数据中有了传奇或非传奇的特征。
由于我们需要数据中的“传奇”特性作为新数据的列,我们只需要在columns
参数中传递它。让我们稍微修改一下数据集,做一些新的分析。
我们现在创建速度可变的箱,作为新增加的功能。
df['speed_range'] = pd.cut(df['Speed'] , [0,40,60,80,120] , include_lowest=True)
现在让我们输出一个数据帧,显示基于传奇特征和速度范围特征的平均速度。
df.pivot_table('Speed' , index = ['Type 1'] , columns= ['speed_range','Legendary'] , aggfunc = 'mean')
Legendary As Well As Range Of Speed As Columns
我鼓励你在泰坦尼克号数据集上尝试熊猫pivot_table
,因为它将补充你对该主题的练习。
Python 中的数据透视表不是一个容易掌握的主题,但是考虑到它所提供的好处,人们必须明确地将这些知识包含在他们的分析工具包中。记住练习是这里的关键!
结论
如果这篇文章,我们试图通过在数据集上实现它来获得一些关于熊猫的想法。我们意识到它是 groupby 操作的多维版本(从概念上讲)。快乐学习!
如何使用熊猫阅读带标题的 CSV?
原文:https://www.askpython.com/python-modules/pandas/pandas-read-csv-with-headers
虽然 Python 完全适合于分析数据,但它天生就没有应该分析的数据集来源。所有这些数据集都将从其他地方获得,并被输入 Python,以便让奇迹发生。我们将探索一种这样的技术,使用 Python 的内置特性之一将数据导入 Python。本文中感兴趣的文件也应该有点特殊——一个带头文件的 CSV 文件!
我们将使用下面的数据集来演示操作的顺序,其中一行中的每个条目都由一个“制表符”分隔开。我们开始吧!
Text File for Demonstration
也读: Python 熊猫模块教程
进口熊猫:
我们应该使用下面的代码将 Pandas 库导入到活动的 Python 窗口中。
import pandas as pd
完成后点击回车&等待一会儿,软件会在后台加载“熊猫”库。这可以通过每行代码前的箭头很好地发现。在“熊猫”满载之前,这些箭头不应出现在新行中。
No Arrows when Pandas are loading
只有在成功加载熊猫后,这些箭头才会出现,如下图所示。
Arrows Appear after Pandas are Loaded
使用 read_csv() 读取带头文件的 csv 文件
CSV 代表逗号分隔值。你会问,哪些值是文本文件中的值!
这意味着文本文件中的值由逗号分隔,以将一个条目与另一个条目隔离开来。尽管 CSV 只使用“逗号”作为分隔符,但它被广泛用于表示文本文件,在这些文件中,分隔符是由制表符、空格甚至冒号来实现的。
下面是 read_csv() 的语法。
df = pd.read_csv(“filename.txt”,sep=”x”, header=y, names=[‘name1’, ‘name2’…])
在哪里,
- df-数据帧
- filename . txt–要导入的文本文件的名称。
- x–中使用的分隔符类型。csv 文件。
- “\ t”-制表符
- “,”–逗号
- “”–空间等等
- y–数据中的标题类型
- 无–如果第一行中的条目不是标题
- 0–如果第一行中的条目是标题
现在我们将应用这个语法从本文前面显示的文本文件中导入数据。
“filename.txt”被替换为“Sales Data.txt”,“x”被替换为“\ t”& y 被替换为 0(零),因为数据包含标题行。在这些替换之后,产生的代码应该如下所示:
df = pd.read_csv("Sales Data.txt", sep="\t", header=0)
按回车键&如果箭头在完全沉默片刻后出现,应该知道没有任何错误。
The Arrowheads Appear!
箭头表明数据已经成功地导入到 Python 中,但是如果我们没有偷偷看一眼,这会让我们感到满意吗?
Python 中可用的 print()命令就是为了达到这个目的。使用 read_csv()命令加载数据的数据框现在可以使用,
print(df)
输入上述&后,点击回车,导入的数据如下图所示。
Viewing the Imported Data
还要注意的是,即使 header=0 在代码中被跳过,read_csv()被设置为默认选择 0 作为头(即第一行)作为头,以便数据被导入时考虑相同的内容。
Importing Data With Default Header Setting
总结
既然我们已经到了这篇文章的结尾,希望它已经详细阐述了如何使用 Python 中的 Pandas 来读取带头文件的 CSV 文件。这里有另一篇文章详细介绍了 fillna()方法在 Pandas 中的用法。在 AskPython 中还有许多其他有趣的&文章,这些文章可能对那些想提高 Python 水平的人有很大帮助。
熊猫形状属性-完整指南
原文:https://www.askpython.com/python-modules/pandas/pandas-shape-attribute
Pandas 是一个用于外部数据预处理和内部数据集创建的扩展库。它是帮助预处理信息和清理信息以便更好地使用的主要软件包之一。
最好的特性是它能够从服务器读取大量数据。
这对 Python 的网络抓取和在线收集关键点有很大帮助。这篇文章谈到了这个模块的一个显著特征,那就是熊猫的形状属性。
先决条件
在我们开始之前,主要的事情是我们需要检查这个游戏的工具和武器。所以,让我们确保这一点。
工具和技术:
- Python:3.6 以上版本
- IDE: Jupyter 笔记本
- 浏览器:谷歌 Chrome
- 环境: 蟒蛇
- 支持包: Numpy 和 Matplotlib
- 稳定的互联网连接(仅在从服务器读取数据时需要)。
此外,我们还将确定我们将在本文中涵盖哪些内容:
我们将在本文中讨论的内容:
- 熊猫的形状属性是什么
- 读取数据集
- 使用数据集中的形状
现在我们已经准备好了,让我们开始吧!
熊猫中的形状属性是什么?
General Format Of Table 1
数据框是关于特定主题的信息的实际表示。这可以来自各种数据流和行业部分。在这个现代化的世界中,来自特定部门的每个个人和组织都可能维护着关键数据。它的主要格式是表格。但是这些表格数据有各种扩展,如 SQL、Excel、JSON 等。下图显示了实际图片:
它可大可小。大多数情况下,数据手册比我们预期的要大得多。因此,在记录行数和列数时,可能会出现一些人为错误。
因此,为了解决这个困难,pandas 库中的 shape 属性用于检查数据集或数据框中的实际行数和列数。
读取任何数据集形状的语法–这是读取数据集形状的通用语法:
dataframe.shape
在 Pandas 中读取数据集
数据集读数将把实际存在的东西带入图像中。这是使用 Pandas 中的读取功能完成的。不同的文件扩展名有不同的格式。我们将阅读三个数据集来检查每一个的形状。
使用的数据集:
- Test_set.csv
- salary.csv
- titanic . CSV
读取数据集的一般语法:
import pandas as pd
data_variable = pd.read_file('filename.extension')
# The read_file method is an example. There are different methods for each file extension.
数据集 1
Reading dataset 1 and retrieving its shape
在上图中,我们可以看到 shape 属性是如何工作的。它返回一个有两个值的元组。请记住,第一个值表示行数,第二个值表示列数。简而言之,这告诉我们数据集要大得多。它有 2671 行和 10 列。
数据集 2
Reading dataset 2 and retrieving its shape
它的名字叫 salary.csv 这个数据集形状是(16,4)。因此它有 16 行和 4 列。
数据集 3
Reading dataset 3
这个数据集是 titanic.csv。从 shape 属性中,我们可以看到它在这个数据集中有 418 行和 12 列。
使用 shape 属性的一些不同方法
通过这三个例子,我们知道了如何使用形状。对于这个属性,我们可以利用一些值得注意的要点。
- 仅检索行数。
- 仅检索列计数。
正如我们所知,它返回一组行,列。因此,我们可以为此使用索引切片。元组是不可变的,但是可以通过索引方法访问这些元素。这和我们处理列表是一样的。让我们看一个代码库示例:
tupple_1 = (12, 42, 45,90)
tuple_1[3]
tuple_1[0]
tuple_1[1]
# Output
# 90
# 12
# 42
为了检索行计数,访问第零个索引,为了检索列计数,访问第一个索引
data.shape[0] # returns number of rows
data.shape[1] # returns number of columns
结论
这就是熊猫的形状属性的表现。这是一个非常重要的功能,也是我们用于数据预处理的关键功能之一。
Pandas sort_index()函数
原文:https://www.askpython.com/python-modules/pandas/pandas-sort_index
Pandas 是一个 Python 库,主要用于数据分析。熊猫让导入、清理、探索、操作和分析数据变得更加容易。在本教程中,我们将学习熊猫的sort_index()
功能。
sort_index()函数语法
DataFrame.sort_index(axis=0, level=None, ascending=True, inplace=False, kind='quicksort', na_position='last', sort_remaining=True, ignore_index=False, key=None)
| 参数 | 描述 | 可能值 | 默认值 |
| 轴 | 按要排序的坐标轴排序。 | 0 /'索引',
1 /'列' | Zero |
| 水平 | 引用数据帧排序的级别。如果不是 None,则按指定索引级别中的值排序。 | int 或 level 名称或 int 列表或 level 名称列表 | 钠 |
| 上升的 | 按升序或降序排序。 | 布尔值或布尔值列表:“真”、“假” | 真实的 |
| 适当的 | 修改现有数据框架或创建新的数据框架。 | bool: ‘True’, ‘False’ | 错误的 |
| 种类 | 要应用的排序算法的种类。 | “快速排序”、“合并排序”、“堆排序”、“稳定” | 快速分类 |
| na _ 位置 | 放置 NaNs 的位置。 | “第一个”,“最后一个” | 最后的 |
| 排序 _ 剩余 | 指定在按指定级别排序后,数据帧是否要按其他级别排序。 | bool: ‘True’, ‘False’ | 真实的 |
| 忽略 _ 索引 | 如果为真,结果轴将被标记为 0,1,…,n–1。 | bool: ‘True’, ‘False’ | 错误的 |
| 键 | 指定是否要根据某个自定义键对数据帧进行排序 | 用户定义的任何自定义键 | 钠 |
返回:一个排序后的对象,即 dataframe。如果inplace=True
,原始数据帧本身被排序,否则用户必须指定一个新的数据帧来存储结果。如果没有分配新的数据帧和inplace=False
,则不返回任何数据。
该函数既适用于数字索引值,也适用于非数字索引值。
创建数据帧
在跳到这里的例子之前,让我们先创建一个数据帧。这将帮助我们处理数据帧并理解 Python sort_index()函数的实现。
import pandas as pd
import numpy as np
data = {
'Emp_Name' : ["Anna", "Jeremy", "Dennis", "Courtney",
"Bob", "Ronald"],
'Dept' : ["Operations", "Technology", "Design", "Administration",
"Operations", "Technology"],
'YOE' : [12, 5, 6, 20, 8, 4]
}
Emp_Id = [4, 3, 6, 7, 1, 2]
emp_data = pd.DataFrame(data, index=Emp_Id)
emp_data
输出:
Dataframe for Sort Index Examples
这是一个用于存储公司员工信息的数据框架。由员工姓名(员工姓名)、工作部门(部门)和工作年限 (YOE) 组成。数据是根据上面代码中指定的雇员 Id (Emp_Id) 排列的。
例子
让我们直接进入例子来理解 sort_index()函数是如何实现的以及它是如何工作的。
1.按索引的升序排序
# by default, axis=0 so sorting is done by row
emp_data2 = emp_data.sort_index()
emp_data2
输出:
Sort Index in Ascending order
在上面的示例中,我们创建了一个名为‘Emp _ data 2’的新数据帧,并根据索引对其进行排序,即按照升序对‘Emp _ Id’进行排序。结果,我们得到了上图所示的数据帧。
2.按索引的降序排序
# by default, axis=0 so sorting is done by row
emp_data2.sort_index(ascending=False, inplace=True)
emp_data2
输出:
Sort Index in Descending order
这里,我们通过在代码中指定ascending=False
对数据帧进行了降序排序。按照规定,inplace=True
并且由于我们没有给函数分配任何新的数据帧,emp_data2
被排序为代替。
3.根据列标签按升序排序
# axis=1 implies sort by column
emp_data3 = emp_data.sort_index(axis=1)
emp_data3
输出:
Sort Index By Column In Ascending Order
在这种情况下,我们有一个名为‘EMP _ data 3’的结果数据帧,其中列标签按升序排序,即按字典顺序排序。列标签'雇员姓名'、'部门'和' YOE '的字典顺序是、'部门'、'雇员姓名'、' YOE' ,因此列现在按此顺序排列。
类似地,我们可以通过写emp_data.sort_index(axis=1, ascending=False)
来按照列标签的降序对数据帧进行排序。这将导致下面的数据帧。
Sort Index By Column In Descending Order
4.使用 na_position 参数定位 nan
让我们考虑前面的 employee 数据框架的一个稍微修改的版本,如下所示。
import pandas as pd
import numpy as np
data = {
'Emp_Name' : ["Anna", "Jeremy", "Dennis", "Courtney",
"Bob", "Ronald"],
'Dept' : ["Operations", "Technology", "Design", "Administration",
"Operations", "Technology"],
'YOE' : [12, 5, 6, 20, 8, 4]
}
Emp_Id = [4, np.nan, 6, np.nan, 1, 2]
emp_df = pd.DataFrame(data, index=Emp_Id)
emp_df
Dataframe With NaN
上面的数据帧在索引中有一些 NaN 值,即 Emp_Id。让我们看看如何定位这些价值。
a.首先定位 NaNs
emp_df2 = emp_df.sort_index(na_position='first')
emp_df2
输出:
NaN values Placed First
这里,数据帧基于其索引即 Emp_Id 进行排序,并且 NaN 值被放置在结果数据帧的第个中。
b.定位 NaNs 最后
emp_df3 = emp_df.sort_index(na_position='last')
emp_df3
输出:
NaN values Placed Last
在本例中,数据帧根据其索引(即 Emp_Id)进行排序,NaN 值放在结果数据帧的最后处。
结论
这教程里都有!我们已经学习了熊猫的 sort_index()函数。你可以通过跟随我们的教程这里了解更多关于熊猫的知识。
参考
使用 Python 熊猫编写 Excel 文件
原文:https://www.askpython.com/python-modules/pandas/pandas-write-to-excel
如果你和我一样,喜欢寻找新的有趣的方法来处理数据。还有什么比在 Excel 中处理数据更有趣的呢?
Excel 是处理数据的强大工具,Python Pandas 使它变得更加简单。在这篇文章中,我将向您展示如何使用 Python Pandas 将数据写入 Excel 文件。
我将首先向您展示如何安装 Pandas 并创建一个数据框架。然后我将向您展示如何使用 Pandas 将数据写入 Excel 文件。
也读:xlrd 模块——如何用 Python 处理 Excel 文件?
什么是 Excel 文件?
Excel 文件是一种电子表格文件,包含行和列中的一些单元格(表格视图),有助于数据的排列、计算、排序和管理。
电子表格中的数据可以是数字、文本、公式、超链接、函数等。XLS 文件将数据存储为二进制流。它只能由最流行的 MS Excel 或其他电子表格程序创建。文件格式。xlsx 总是单独表示一个 excel 文件。
下图描述了由 MS-excel 程序创建的 excel 文件:
The Excel File By MS Excel 1
熊猫模块
它是 Python 中的一个开源库或模块,提供了一些内置的数据结构和数据分析工具。 熊猫模块 的一些关键特性如下。
- 它提供了高效、快速的数据管理和访问方式。
- 它有能力处理集成到其库中的缺失数据。
- 它有一些独特的数据索引技术。
- 它提供了各种各样的内置工具,帮助我们读写数据。
- 它可以支持 JSON、CSV、HDF5 和 Excel 文件。
- 它非常负责合并各种数据集。
- 它让我们可以访问其他有用的库,如 MatPlotLib 和 NumPy。
- 它允许用户对数据集进行各种数学运算。
安装 Python 熊猫
在开始阅读本文之前,请确保您的计算机上已经安装了这个模块。您可以通过命令提示符下的以下命令下载该模块。
pip install pandas
您可以按如下方式安装 pandas 模块。
Installing Panda Module 2
我们将在本文中使用另一个模块,让我们也理解这一点。
安装 openpyxl 模块
Openpyxl
是一个 Python 库或模块,用于读取或写入 Excel 文件。这个模块需要安装使用 load_workbook()之类的某些方法,否则我们无法使用那些方法,它会抛出error
。让我们使用命令提示符安装这个模块。
C:\Users\pc> pip install openpyxl
上面的代码片段将安装我们的openpyxl
模块。
Installing Openpyxl Module
将单个电子表格写入 Excel 文件
我们首先将它转换成熊猫数据帧,然后将数据帧写入 Excel。将熊猫数据帧导出为 Excel 文件(即。xlsx,。xls 文件),我们将使用to_excel()
方法。
遵循以下代码片段:
>>> import pandas as pd
>>> import openpyxl
>>> df = pd.DataFrame([['Hi', 'Hello', 'Hey'], ['Nandini', 'Rupali', 'Malina'], ['Ram','Shyam', 'Babu']], index=['one', 'two', 'three'], columns=['a', 'b', 'c'])
如果我们打印上面的数据框,我们可以得到如下结果。
>>> print(df)
a b c
one Hi Hello Hey
two Nandini Rupali Malina
three Ram Shyam Babu
>>>
现在,我们将使用下面的代码片段将上述数据框导出到 excel 文件。
df.to_excel('new_excel.xlsx', sheet_name='new_sheet_name')
上面的代码片段会自动在我们的 PC 文件夹中创建一个. xlsx 文件。
将多个电子表格写入 Excel 文件
让我们创建另一个数据框。
df2 = pd.DataFrame([[11, 21, 31], [12, 22, 32], [31, 32, 33]], index=['one', 'two', 'three'], columns=['a', 'b', 'c'])
现在,我们将 df 和 df2 数据框导出到 new_excel 文件中。遵循下面的代码片段
with pd.ExcelWriter('new_excel.xlsx') as writer:
df.to_excel(writer, sheet_name='sheet1')
df2.to_excel(writer, sheet_name='sheet2')
它将创建一个包含如下两张幻灯片的 excel 文件。
sheet 1
sheet 2
摘要
在本文中,我们介绍了两个使用 Python 将数据写入 Excel 文件的例子。我们讨论了适当输出的两个流行模块。希望你喜欢这个快速演示。
使用 Python 的帕斯卡三角形
原文:https://www.askpython.com/python/examples/pascals-triangle-using-python
帕斯卡三角形是一个由数字排列而成的漂亮形状。每个数字都是通过取上面两个数字的和而生成的。这个三角形的外边总是 1。三角形如下图所示。
Pascals Triangle
简单解释一下三角形,第一行是 1。下面一行有两个 1。这是第二行。
第三行是1 2 1
,它是通过取前一行的和而形成的。类似地,第四行由交替模式中的 1 和 2 的和形成,以此类推。
用 Python 编写帕斯卡三角形
让我们从创建PascalTriangle
函数开始。
在这个函数中,我们将首先使用trow
变量初始化顶行。我们也初始化变量 y=0。现在我们将使用 for 循环来运行代码进行n
迭代。
在循环的中,我们将打印由trow
变量初始化的列表。现在我们将添加 trow 的左右元素。除此之外,我们还在这里使用了 zip 函数。该函数如下所示。
def PascalTriangle(n):
trow = [1]
y = [0]
for x in range(n):
print(trow)
trow=[left+right for left,right in zip(trow+y, y+trow)]
return n>=1
现在只需给出一个带有参数的函数调用,说明所需的行数。如下图所示。
PascalTriangle(6)
代码的输出如下所示:
[1]
[1, 1]
[1, 2, 1]
[1, 3, 3, 1]
[1, 4, 6, 4, 1]
[1, 5, 10, 10, 5, 1]
结论
使用 Python 创建帕斯卡三角形的教程到此结束。试试这段代码,并在下面的评论区告诉我们你的反馈。
Python:如何将函数作为参数传递?
原文:https://www.askpython.com/python/examples/pass-function-as-argument
大家好!在本教程中,我们将讨论在 Python 中将函数作为参数传递的不同方式。
Python 中有哪些函数?
在 Python 编程中,函数起着非常关键的作用。我们在 Python 中有非常广泛和丰富的不同类型的函数集合。Python 中的函数提供了模块化特性。这意味着使用函数,我们可以将一个大的 Python 代码块分成更小的块,每个块必须执行特定的任务。我们可以使用预定义的函数,也可以定义自己的函数。在 Python 中,定义在特定类中的函数我们称之为方法。
充当一级对象
一级对象是那些在整个程序中被一致对待的对象。这意味着一级对象可以存储在变量中,作为参数传递给函数,或者在控制语句中使用。Python 支持一级对象的概念,将函数视为一级对象。正是因为这个原因,我们可以将函数作为参数传递给 Python 中的其他函数。
Python 中如何将函数作为参数传递?
在 Python 中,我们可以通过以下方式将不同类型的函数作为参数传递给另一个函数。让我们逐一讨论。
1.用户定义的函数
在 Python 中,就像普通变量一样,我们可以将用户定义的函数作为参数传递给另一个函数。接受另一个函数作为其参数的函数称为高阶函数。让我们看看如何通过 Python 代码实现这一点。
# Define higher order function
def fun(foo):
result = foo('Welcome To AskPython!!')
return result
# Define function-1
def fun1(str):
return str.lower()
# Define function-2
def fun2(str):
return str.upper()
# Pass funtion-1 as an argument
# to fun() function
str1 = fun(fun1)
print(str1)
# Pass funtion-2 as an argument
# to fun() function
str2 = fun(fun2)
print(str2)
输出:
welcome to askpython!!
WELCOME TO ASKPYTHON!!
2.分类方法
像用户定义的函数一样,我们也可以将类方法作为参数传递。让我们用两个方法在 Python 中定义一个类,并创建这个类的一个对象来调用这些方法。让我们看看实现这一点的 Python 代码。
# Define a Python class
class demo_class:
# Define method-1
def method1(self):
print("Method-1 Running")
return "AskPython!!"
# Define method-2
def method2(self, foo):
print("Method-2 Running")
result = foo()
return result
# Create a demo_class object
# using the class constructor
obj = demo_class()
# Pass method-1 as an argument to method-2
str = obj.method2(obj.method1)
print(str)
输出:
Method-2 Running
Method-1 Running
AskPython!!
3.λ函数
在 Python 中,λ函数是对λ表达式求值时返回的函数对象。像用户定义的函数和类方法一样,我们也可以将 lambda 函数作为参数传递给另一个函数。让我们看看实现这一点的 Python 代码。
# Create a Python list
ls = [1, 2, 3, 4, 5]
print('This is the given list:')
print(ls)
# Pass lambda function
# to map() function to claculate
# the square of each list element
iter_obj = map((lambda n: n**2), ls)
# Construct the list again with
# square of the elements of the given list
ls = list(iter_obj)
print('This is the final list:')
print(ls)
输出:
This is the given list:
[1, 2, 3, 4, 5]
This is the final list:
[1, 4, 9, 16, 25]
4.算子函数
在 Python 中,我们有包含预定义函数的操作符模块。这些函数允许我们对给定的参数列表执行数学、关系、逻辑或位运算。像用户定义的和 lambda 函数一样,我们也可以将一个操作符函数作为参数传递给另一个函数。这里我们将使用来自 operator 模块的operator.mul()
函数,并将其传递给reduce()
函数,该函数是在 functools 模块中定义的,并带有一个 Python 列表。这将计算并返回传递的列表元素的乘积。让我们通过 Python 代码来实现这一点。
# Importing Python functools module which contains the reduce() function
import functools
# Importing Python operator module which contains the mul() function
import operator
# Defining a Python list
ls = [1, 3, 5, 7, 9, 11]
print("Given Python list:")
print(ls)
# Pass the mul() function as an argument
# to the reduce() function along with the list
ls_product = functools.reduce(operator.mul, ls)
# Printing the results
print("Product of the given Python list: ", ls_product)
输出:
Given Python list:
[1, 3, 5, 7, 9, 11]
Product of the given Python list: 10395
5.内置函数
在 Python 中,我们有很多标准的内置函数,比如 list()、tuple()、dict()、str()等等。像用户定义的函数一样,我们也可以将内置函数作为参数传递给 Python 中的另一个函数。这里我们将把str()
函数传递给 map()
函数以及一个 Python 字符串和数字元组。这将返回一个迭代器对象,我们将使用 str.join()函数将给定的元组转换为 Python 字符串。让我们编写 Python 代码来实现这一点。
# Create a Python tuple
tup = ('Linux', 'Ubuntu', 20.04)
print("Given Python tuple:")
print(tup)
# Pass the str() function
# to the map() function
iter_obj = map(str, tup)
# Construct the string from
# the returned iterator object
# of the given tuple
str1 = "-".join(iter_obj)
# Print the result
print("Generated Python string from tuple:")
print(str1)
输出:
Given Python tuple:
('Linux', 'Ubuntu', 20.04)
Generated Python string from tuple:
Linux-Ubuntu-20.0
结论
在本教程中,我们学习了以下内容:
- 什么是一等品?
- 如何将自定义函数作为参数传递?
- 如何将类方法作为参数传递?
- 如何将 lambda 函数作为参数传递?
- 如何将运算符函数作为参数传递?
- 如何将内置函数作为参数传递?
希望您已经理解了上面讨论的所有概念,并准备好学习和探索更多关于 Python 中的函数。敬请关注我们!
Python 中的 PDFKit 模块–将 HTML 转换为 PDF
在本文中,让我们了解一个 PDFKit,它是一个 PDF 文档生成开源库。使用 Python 将任何网页转换成 PDF 是最简单的方法。
将 HTML 转换为 PDF 的先决条件
在我们开始代码 python 之前,请确保安装 PDFKit。要安装 PDFKit,下面是要使用的命令。
$ pip install pdfkit (or pip3 for python3)
一旦安装了库,安装wkhtmltopdf
。它是一个开源命令行工具,用于使用 Qt WebKit 渲染引擎将 HTML 渲染为 PDF 和各种图像格式。
对于 Debian/Ubuntu:
$ sudo apt-get install wkhtmltopdf
对于 macOS
$ brew install homebrew/cask/wkhtmltopdf
对于 Windows 点击这里。
记得给环境变量添加路径 wkhtmltopdf
以免出错。
使用 Python 将 HTML 转换为 PDF
在实现时,如果你的编辑器抛出一个类似“import error:No module named pdf kit”的错误,请尝试配置当前目录中的路径。这可以通过事先在编辑器中执行以下代码来实现。
path_wkthmltopdf = 'C:\Program Files\wkhtmltopdf\bin\wkhtmltopdf.exe'
config = pdfkit.configuration(wkhtmltopdf=path_wkthmltopdf)
将网址转换成 PDF 格式
import pdfkit
pdfkit.from_url("https://www.askpython.com/", "sample_url.pdf")
输出
Pdfkit 1
将 HTML 文件转换成 PDF
- 记住你要转换成 PDF 的文件应该是
.HTML
格式。 - 此外,该文件应该位于同一个目录中。
import pdfkit
pdfkit.from_file("sample.html", "sample_file.pdf")
输出
Pdfkit 2
将字符串转换成 PDF
import pdfkit
pdfkit.from_string('AskPython :)','sample_string.pdf')
输出
Pdfkit 3
摘要
在本文中,我们讨论了 PDFKit 包装器或库。PDFKit for python 是 ruby PDFKit 库的改编版本。此外,我们还学习了用 python 将网页、HTML 文件或字符串转换成 pdf 的最简单方法。
皮尔逊相关——在 Python 中实现皮尔逊相关
原文:https://www.askpython.com/python/examples/pearson-correlation
在本教程中,我将指导您完成皮尔逊相关性的 Python 实现。当两个或多个特性以这样的方式链接时,当一个特性的值增加或减少时,另一个特性的值同样增加或减少。这就是术语【关联】的含义。
相关性介绍
寻找变量之间的联系是相关性的全部。在数据科学中,我们利用相关性来发现彼此有利和不利关联的特征,以便我们可以使用最佳特征来训练机器学习模型。
相关度的范围从-1 到 1。
- 当特征之间的相关性为 1 时,特征彼此正相关。
- 当特征之间的相关性为-1 时,特征彼此负相关。
- 当特征之间的相关性等于零时,我们可以断定特征之间没有关联。
皮尔逊相关简介
Pearson correlation 是一种统计方法,用于确定两个或多个特征之间的线性关系强度。
皮尔森相关性的最好例子之一是需求和供给。例如,当对一种产品的需求增加时,该产品的供应增加,当对该产品的需求减少时,该产品的供应减少。一种产品的需求和供给之间存在正相关关系。
皮尔逊相关公式
Pearson Correlation Formula
Pearson 相关性在 Python 中的实现
为了观察相关性,我们需要遵循下面描述的一些步骤。
步骤 1–导入模块和加载数据集
任何程序的第一步都是加载必要的模块(如果需要的话)。对于这个程序,我们需要导入 pandas
模块。稍后,我们将使用read_csv
函数加载数据集。你可以在这里找到数据集。
import pandas as pd
movies = pd.read_csv("MoviesOnStreamingPlatforms_updated.csv")
步骤 2–找出所有特征之间的相关性
为了找到相关性,我们将利用corr
函数并将method
作为pearson
传递,因为我们的目标是找到特性之间的皮尔逊相关性。
movies['Rotten Tomatoes'] = movies["Rotten Tomatoes"].str.replace("%", "").astype(float)
movies.drop("Type", inplace=True, axis=1)
correlations = movies.corr(method='pearson')
步骤 3–可视化关联
为了可视化这种关联,我们将利用seaborn
图并导入seaborn
和matplotlib
模块。最后,我们利用heatmap
函数并传递我们在上一步中创建的关联。
import seaborn as sns
import matplotlib.pyplot as plt
sns.heatmap(correlations)
plt.show()
Pearson Correlation Visualization
我希望你喜欢这篇关于 Pearson 相关性及其 Python 实现的教程。继续多看教程,不断学习!😇
使用 Python 进行排列和组合
原文:https://www.askpython.com/python/permutations-and-combinations-using-python
在本文中,我们将学习如何使用 Python 寻找排列和组合。
Python 提供了一个名为 itertools 的库,其中包含计算排列和组合的内置函数。让我们快速看一下这些函数的实现。
导入所需的库
在我们能够使用以下任何函数之前,我们需要导入itertools
库。这是通过以下方式实现的:
import itertools
上面的语句导入了库,并形成了使用其函数的路径。
寻找排列
排列在数学上是指“某些数字或字母的排列”。itertools
库中的permutations()
函数就是这样做的。
1.Python 字符串的置换
如果给我们一个 Python 字符串,并要求我们找出其字母排列的所有方式,那么这个任务可以通过permutations()
函数轻松完成。
import itertools
st = "ABC"
per = itertools.permutations(st)
for val in per:
print(*val)
输出:
A B C
A C B
B A C
B C A
C A B
C B A
函数permutations()
接受一个字符串参数,并提供一个itertools
对象。如果我们试图直接打印变量'per'
,我们将得到如下结果:
<itertools.permutations object at 0x7fc9abdd8308>
因此,有必要运行一个循环来打印每个条目。
2.多个数字的排列
permuatations()
函数采用可迭代的参数,因此为了找出数字的排列,我们需要将数字作为列表、集合或元组来传递。
import itertools
values = [1, 2, 3]
per = itertools.permutations(values)
for val in per:
print(*val)
输出:
1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
在上述计算排列的技术中,我们包括了所有的数字或字母。有可能限制排列中元素的数量。
3.具有一定数量元素的排列
类似于‘nPr’的概念,即“从 n 个元素中排列 r 个元素”,这可以通过在元素集后传递一个整数来实现。
import itertools
values = [1, 2, 3, 4]
per = itertools.permutations(values, 2)
for val in per:
print(*val)
输出:
1 2
1 3
1 4
2 1
2 3
2 4
3 1
3 2
3 4
4 1
4 2
4 3
在上面的代码片段中,permutations()
函数被要求一次只排列所提供的数字列表中的 2 个元素。
寻找组合
术语组合指的是从一组对象中提取元素的方法。itertools
库为这个功能提供了一个方法combinations()
。
这里需要注意的一点是,挑选一组对象并不涉及排列。combinations()
函数有两个参数:
- 一组值
- 一个整数,表示要为组合选取的值的数量。
1.单词中字母的组合
给定一个单词,如果我们需要从这个单词中找出恰好包含两个字母的所有组合,那么combinations()
就是定位函数。
import itertools
st = "ABCDE"
com = itertools.combinations(st, 2)
for val in com:
print(*val)
输出:
A B
A C
A D
A E
B C
B D
B E
C D
C E
D E
2.数字集合的组合
类似于我们从一个单词中的字母得到的组合结果,它可以在一个列表中的数字上实现。
import itertools
values = [1, 2, 3, 4]
com = itertools.combinations(values, 2)
for val in com:
print(*val)
输出:
1 2
1 3
1 4
2 3
2 4
3 4
注意:生成的组合基于每个对象的索引值,而不是它们的实际值,因此,如果有任何值重复,则该函数会打印相似的组合,认为每个值都不同。
3.重复数字的组合
为了进一步解释上面的注释,让我们为它运行一个例子。
import itertools
values = [1, 1, 2, 2]
com = itertools.combinations(values, 2)
for val in com:
print(*val)
输出:
1 1
1 2
1 2
1 2
1 2
2 2
结果不言自明,因为列表中的数字是重复的。
4.数字自身的组合
在itertools
库中还有另一个与排列和组合相关的函数叫做combinations_with_replacement()
。这个函数是combinations()
函数的一个变体,略有不同的是它包括元素自身的组合。
import itertools
values = [1, 2, 3, 4]
com = itertools.combinations_with_replacement(values, 2)
for val in com:
print(*val)
输出:
1 1
1 2
1 3
1 4
2 2
2 3
2 4
3 3
3 4
4 4
当传递给combinations()
函数时,我们可以看到上述输出与具有相同参数的输出的明显区别。
数字有它们自己的组合,就像列表中有它们的多个实例。这基本上是因为,当我们从列表中选择一个元素时,上面的函数会再次放置相同的值,以获得与其自身的组合。
这总结了使用 Python 进行排列和组合的主题。
结论
排列和组合在数学领域的应用非常广泛。本教程中解释的方法在解决关于这种数学技术的问题时会派上用场。
我们希望这篇文章简单易懂。如有疑问和建议,欢迎在下面发表评论。
Python 中的 pickle 模块
原文:https://www.askpython.com/python-modules/pickle-module-python
我们经常遇到需要存储或转移对象的情况。Python 中的pickle
模块就是这样一个库,它的作用是将 Python 对象作为序列化的字节序列存储到文件中,以便以后检索。让我们看看它在本文中到底做了什么。
1.Python Pickle 模块示例
让我们看一些在 Python 中使用 pickle 模块的例子。
1.1“酸洗”成文件
由于文件由字节信息组成,我们可以通过pickle
模块将 Python 对象转换成文件。这叫腌制。让我们通过一个例子来看看如何做到这一点。
为了完成将对象序列化为文件的操作,我们使用了pickle.dump()
方法。
格式:pickle.dump(data_to_store, filename, protocol_type)
data_to_store
- >要序列化(酸洗)的对象filename
- >存储数据的文件的名称protocol_type
- >使用的协议类型(Python 3.8 中默认设置为 4)
这里有一个例子来说明这一点。
import pickle
data = ['one', 2, [3, 4, 5]]
with open('data.dat', 'wb') as f:
pickle.dump(data, f)
1.2 从文件中“取消选取”
这与 pickle 正好相反,pickle 从文件中检索对象。该文件包含作为字节序列的对象的序列化信息,现在被反序列化为 Python 对象本身,我们可以恢复原始信息。
为了执行这个操作,我们使用了pickle.load()
库函数。
格式:new_object = pickle.load(filename)
new_object
- >方法存储信息的对象filename
- >包含序列化信息的文件
import pickle
objdump = None
with open('data.dat', rb') as f:
# Stores the now deserialized information into objdump
objdump = pickle.load(f)
2.pickle 模块的异常处理
Pickle 模块定义了一些异常,这对程序员或开发人员处理不同的场景并适当地调试它们很有用。
该模块提到以下内容可以腌制:
None
、True
、False
- 整数、浮点、复数
- 字符串、字节、字节数组
- 仅包含可选择的对象的元组、列表、集合和字典
- 在模块顶层定义的命名函数
- 在模块顶层定义的类和内置函数
其他任何对象都是不可拾取的,称为不可拾取的。
该模块定义了 3 个主要例外,即:
| 异常名 | 这个异常是什么时候出现的? |
| pickle.PickleError
| 这只是其他异常的基类。这继承了Exception
|
| pickle.PicklingError
| 当遇到不可拆分的对象时引发。 |
| pickle.UnpicklingError
| 如果有任何问题(如数据损坏、访问冲突等),则在解除对象检查期间引发 |
这里是一个使用异常处理来处理pickle.PicklingError
的例子,当试图 pickle 一个不可 pickle 的对象时。
import pickle
# A lambda is unpicklable
data = ['one', 2, [3, 4, 5], lambda l: 1]
with open('data2.dat', 'wb') as f:
try:
pickle.dump(data, f)
except pickle.PicklingError:
print('Error while reading from object. Object is not picklable')
输出
Error while reading from object. Object is not picklable
这里是一个使用异常处理来处理pickle.UnpicklingError
的例子,当尝试解包一个非序列化的文件时。
import pickle
with open('data1.dat', 'wb') as f:
f.write('This is NOT a pickled file. Trying to unpickle this will cause an exception')
objdump = None
with open('data1.dat', 'rb') as f:
try:
objdump = pickle.load(f)
except pickle.UnpicklingError:
print('Cannot write into object')
输出
Cannot write into object
3.酸洗和酸洗面临的问题
-
正如该模块在文档中所述,它为我们提供了一个关于对对象文件进行酸洗和拆洗的严厉警告。除非您绝对信任源代码,否则不要使用此模块来进行拆包,因为任何类型的恶意代码都可能被注入到目标文件中。
-
此外,由于 Python 语言版本之间缺乏兼容性,可能会面临一些问题,因为不同版本的数据结构可能会有所不同,因此
Python 3.0
可能无法从Python 3.8
中解包一个 pickle 文件。 -
也没有跨语言兼容性,这对于非 Python 数据传输来说可能是一个烦恼。这些信息只是特定于 Python 的。
4.结论
在这里,我们学习了更多关于pickle
模块的知识,该模块可用于将 Python 对象序列化/反序列化到文件中。它是一种快速简便的传输和存储 Python 对象的方法,帮助程序员方便快捷地存储数据进行数据传输。
5.参考
- JournalDev 关于泡菜的文章:https://www.journaldev.com/15638/python-pickle-example
- 泡菜模块文档:https://docs.python.org/3/library/pickle.html
Python 枕头模块——简介
你好,初学者!今天在本教程中,我们将学习 Python 中一个有趣但未知的模块——枕头模块。我们先来了解一下枕头模块是什么,为什么要用?
枕头模块是什么?
Pillow
建立在众所周知的 PIL ( Python 图像库)模块之上,后者是图像处理最重要的模块之一。但是,现在 Python3 不支持 PIL 模块。
所以枕头模块基本上是 PIL 模块的替代品,但有更多的功能。Python3 也支持它。使用这个模块,人们可以在数字图像上实现几乎任何东西。
Python 枕头模块的实现
现在我们对枕头模块有了一点了解。让我们来学习如何实现它。
1.导入模块并加载初始映像
枕头模块的导入与PIL
模块完全相同,初始图像在图像子模块open
功能的帮助下加载。
要查看图像,我们只需在加载图像时对之前创建的图像变量使用show
函数。下面提到了相同的代码。
from PIL import Image
im = Image.open("image1.jpg")
im.show()
输出图像显示在单独的窗口中,其结果如下所示。
Initial Loaded Image
2.旋转图像
要旋转图像,我们只需使用下面代码所示的rotate
函数。输出也显示在代码的正下方。
im_rotate = im.rotate(40)
im_rotate.show()
Rotate Image Output
3.从普通图像创建缩略图
要将所有图像缩小到某个较小的尺寸,可以使用缩略图功能将图像转换为缩略图。相同的代码如下所示。缩略图功能将输出图像的高度和宽度作为参数。
img1 = Image.open('image1.jpg')
img1.thumbnail((200,200))
img1.show()
Thumbnail Output Image
4.模糊图像
在 PIL 模块的帮助下,只需使用filter
函数和ImageFilter
类,就可以轻松地给图像添加模糊效果。
我们首先需要从 PIL 模块导入 ImageFilter 类,然后在将图像转换为 RGB 格式后对加载的图像应用模糊效果,以获得 ImageFilter 工作的准确调色板。
谈到模糊图像,PIL 提出了三种类型的模糊效果:
- 简单模糊
- 框模糊
- 高斯模糊
我们将学习一个接一个地实现它们。
4.1.简单模糊
下面的代码输出带有简单模糊效果的图像。自己试试吧!
from PIL import ImageFilter
img2 = Image.open('image1.jpg')
img2.convert('RGB')
img2.show()
blur_img = img2.filter(ImageFilter.BLUR)
blur_img.show()
Blur Effect Output
4.2.框模糊
为了实现,框模糊一个需要指定radius
,这是简单的模糊过滤器在图像上应用的强度。代码如下所述。看一看!
from PIL import ImageFilter
img2 = Image.open('image1.jpg')
img2.convert('RGB')
blur_img = img2.filter(ImageFilter.BoxBlur(5))
blur_img.show()
在这段代码中,我们将半径设置为 5,得到的图像如下所示。好奇改变半径值会发生什么?来吧,你可以尽情地玩数字游戏!
Box Blur Radius5
4.3 高斯模糊
高斯模糊采用完全相同的参数,radius
,但不同之处在于,高斯模糊避免了图像中出现的哪怕是最轻微的边缘。这会产生更平滑的模糊效果。
from PIL import ImageFilter
img2 = Image.open('image1.jpg')
img2.convert('RGB')
blur_img = img2.filter(ImageFilter.GaussianBlur(5))
blur_img.show()
你可以在下面显示的图像中看到,高斯模糊忽略了所有的边缘,并在图像上给出了清晰和均匀的模糊效果。
Gaussian Blur Radius5
5.在图像上添加水印
有没有想过创作者如何将他们自己的水印添加到他们的图像中?你可以借助 PIL 模块的 ImageDraw 功能给你的图片添加你自己的水印。
下面显示了相同的代码,并预先添加了注释来指导您完成这些步骤。
from PIL import ImageDraw, ImageFont
## 1\. Loading the image
img = Image.open('image1.jpg')
## 2\. Creating a drawing object in order to draw on the image
draw = ImageDraw.Draw(img)
## 3\. Changing the font style and the size of the font to make the watermark clean
font = ImageFont.truetype('arial.ttf', 36)
## 4\. Drawing the text on the image :
# Add the x and y position values
# Enter the text to be drawn
# Set the font to font created in step 3
draw.text((100, 100),"My first Watermark",font=font)
img.show()
Watermark Added Image
结论
恭喜你!今天,您学习了一个新的图像处理模块。本模块中有更多内容需要探索,但可以在后面的教程中介绍。
希望你喜欢它!感谢您的阅读!
敬请关注更多教程!
Python 中的流水线技术——完全指南
原文:https://www.askpython.com/python/examples/pipelining-in-python
本文讨论 Python 中的管道技术。在应用的机器学习中,有典型的过程。它们是标准的,因为它们解决了测试设置中的数据泄漏等问题。
pipeline 是一个 Python scikit-learn 实用程序,用于编排机器学习操作。
管道的作用是允许一系列线性的数据转换链接在一起,产生一个可测量的建模过程。
目标是保证管道中的所有阶段,如训练数据集或交叉验证技术中涉及的每个折叠,仅限于评估可用的数据。
Python 中流水线操作的数据准备和建模
从训练数据集到测试数据集的数据泄漏是机器学习和数据科学中的一个常见陷阱。
为了防止落入这个陷阱,您将需要一个可靠的测试工具,具有清晰的培训和测试分离。包括数据准备。
数据准备是算法获取对整个训练数据集的访问的一种简单方法。例如,在学习之前对整个训练数据集进行规范化或标准化将不是一个合适的测试,因为测试集中的数据规模会影响训练数据集。
管道确保数据准备(如规范化)被限制在交叉验证操作的每一个环节中,从而最大限度地减少测试工具中的数据泄漏。
这种关键的数据准备和模型评估方法将在下面的示例中演示。管道中有两个步骤:
- 确保数据是统一的。
- 了解如何使用线性判别分析模型。
让我们来了解一下如何在 python 中创建管道,以及如何在管道中训练数据集。
导入库
创建管道需要将大量导入包加载到系统中。请记住,您需要预先安装和配置所有这些 python 包,以便在程序中使用它们。
from sklearn.linear_model import LogisticRegression
from sklearn.decomposition import PCA
from sklearn.feature_selection import SelectKBest
from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.pipeline import Pipeline
from sklearn.pipeline import FeatureUnion
数据加载
在本例中,将从包含糖尿病患者信息的公共域中获取数据。我们将使用这个数据库来训练我们的管道。
下面的代码演示了如何加载公共域记录:
url_data = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv"
varnames = ['var_preg', 'var_plas', 'var_pres', 'var_skin', 'var_test', 'var_mass', 'var_pedi', 'var_age', 'var_class']
vardataframe = read_csv(url_data, names=varnames)
vararray = vardataframe.values
varX = vararray[:,0:8]
varY = vararray[:,8]
在 Python 中创建管道
urlfeatures = []
urlfeatures.append(('pca', PCA(n_components=3)))
urlfeatures.append(('select_best', SelectKBest(k=6)))
feature_union = FeatureUnion(urlfeatures)
# Here, pipeline is created
estimators = []
estimators.append(('feature_union', feature_union))
estimators.append(('logistic', LogisticRegression()))
model = Pipeline(estimators)
# The pipelie is tested here
seed = 7
varkfold = KFold(n_splits=10)
dataresults = cross_val_score(model, varX, varY, cv=varkfold)
print(dataresults.mean())
流水线技术在 Python 中的完整实现
整个工作程序如下所示:
# Create a pipeline that extracts features from the data then creates a model
from sklearn.linear_model import LogisticRegression
from sklearn.decomposition import PCA
from sklearn.feature_selection import SelectKBest
from pandas import read_csv
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.pipeline import Pipeline
from sklearn.pipeline import FeatureUnion
# data laoded into global variables
url_data = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv"
varnames = ['var_preg', 'var_plas', 'var_pres', 'var_skin', 'var_test', 'var_mass', 'var_pedi', 'var_age', 'var_class']
vardataframe = read_csv(url_data, names=varnames)
vararray = vardataframe.values
varX = vararray[:,0:8]
varY = vararray[:,8]
# creating feature union
urlfeatures = []
urlfeatures.append(('pca', PCA(n_components=3)))
urlfeatures.append(('select_best', SelectKBest(k=6)))
feature_union = FeatureUnion(urlfeatures)
# Here, pipeline is created
estimators = []
estimators.append(('feature_union', feature_union))
estimators.append(('logistic', LogisticRegression()))
model = Pipeline(estimators)
# The pipelie is tested here
seed = 7
varkfold = KFold(n_splits=10)
dataresults = cross_val_score(model, varX, varY, cv=varkfold)
print(dataresults.mean())
输出
Mean calculation done through the pipeline
让我们看另一个例子来更好地理解管道测试。
在下面的代码中,一个虹膜数据库被加载到测试管道中。Iris 数据库是 sklearn 为测试管道而提供的数据库分类。在这个例子中,通过将管道分成相等的两半,使用单个数据库来训练和测试管道,即 50%的数据将被加载到测试管道中,而剩余的一半将用于训练管道中。
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.tree import DecisionTreeClassifier
# database is imported from inbuilt sklearn datasets
iris = datasets.load_iris()
X = iris.data
y = iris.target
#The data spliting is executed here
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.50)
# importing pipes for making the Pipe flow
from sklearn.pipeline import Pipeline
# The sequence of pipe flow is :
# PCA dimension is reduced by 2 >> Data gets scaled >> Classification of decission tree
pipe = Pipeline([('pca', PCA(n_components = 2)), ('std', StandardScaler()), ('decision_tree', DecisionTreeClassifier())], verbose = True)
# fitting the data in the pipeline
pipe.fit(X_train, y_train)
# scoring data
from sklearn.metrics import accuracy_score
print(accuracy_score(y_test, pipe.predict(X_test)))
输出
Pipeline flow output
结论
在本文中,我们了解了管道以及如何对其进行测试和训练。我们还了解了 sklearn 导入包,以及它的数据库和函数如何帮助创建用于数据测试的管道。我们进一步了解了如何使用公共领域记录来训练管道,我们还观察了如何拆分 sklearn 的内置数据库来提供测试和训练数据。
pipenv:Python 的新打包工具
原文:https://www.askpython.com/python/pipenv-python-packaging-tool
每当我们编写某种程序时,我们也利用外部库和包来避免重新发明轮子。我们还需要确保程序在不同的环境中正确执行。因此,我们需要某种以有组织的方式管理需求的配置文件。
pipenv 是什么?
Pipenv 是安装 Python 包和使用虚拟环境的推荐方式。这是因为当我们使用 Python 捆绑的 pip 包管理器时,所有的包都是全局安装的。
我们没有为我们的 Python 项目提供封装的环境,比如用【Django】****Flask创建 web 应用,或者其他一些机器学习项目。
Pipenv 允许我们隔离特定环境中的包。
按照惯例,程序员用 pip 创建一个虚拟环境并在其中安装软件包。但是 pipenv 自动创建和管理一个虚拟环境,并允许我们使用一个 Pip 文件来添加和删除包,该文件类似于各种包管理器,如 npm、yarn、composer、等。
它还生成了非常重要的 Pipfile.lock 。这用于产生确定性的构建,这意味着对于每个特定的项目,在 Pip 文件中列出的相同版本的包将被用于该特定的项目。
如果项目在任何其他地方运行,比如在生产环境中,或者在云上,或者在不同的机器上,都不会有重大的变化。
pipenv 试图解决的一些常见问题
- 我们不再需要单独使用 pip 和 virtualenv。
- requirements.txt 文件,管理起来很麻烦,在某些情况下还容易出错。pipenv 使用的 Pipfile 和 Pipfile.lock 更加人性化,易于管理,减少错误。
- Pipenv 自动暴露安全漏洞,除此之外,pipenv 到处使用散列值。
- 它提供了对所有包的依赖图的洞察。
- 通过加载简化开发工作流程。环境文件。
- 它还鼓励使用最新版本的依赖项来最小化过时组件带来的安全风险。
也读 : Conda vs Pip:选择你的 Python 包管理器
使用 pipenv
- 使用 pip 命令安装 pipenv:
pip install pipenv
使用 pip 查找所有包
pip freeze
输出:
certifi==2022.6.15
distlib==0.3.5
filelock==3.7.1
pep8==1.7.1
pipenv==2022.8.5
platformdirs==2.5.2
PySimpleGUI==4.60.3
virtualenv==20.16.3
virtualenv-clone==0.5.7
使用 pipenv 创建并激活虚拟环境
pipenv shell
这创建了一个包含我们所有依赖项的 Pipfile 。让我们看看我们的 Pipfile。
[[source]]
url = "https://pypi.org/simple"
verify_ssl = true
name = "pypi"
[packages]
[dev-packages]
[requires]
python_version = "3.10"
- 查看我们的项目主页信息
pipenv --where # Output: D:\Python
- 检查 virtualenv 信息
pipenv --venv # Output: C:\Users\Username\.virtualenvs\Python-hSRNNotQ
使用 pipenv 安装软件包
pipenv install flask
我们的 Pipfile 用包 flask 更新了。“*”代表烧瓶的最新版本。
[[source]]
url = "https://pypi.org/simple"
verify_ssl = true
name = "pypi"
[packages]
flask = "*"
[dev-packages]
[requires]
python_version = "3.10"
我们还可以看到一个 Pipfile.lock 文件,它包含了所有的依赖项以及它们的哈希值。这里是锁文件的一瞥。
{
"_meta": {
"hash": {
"sha256": "458ff3b49ddcf0963535dd3aea79b000fa2015d325295d0b04883e31a7adf93e"
},
"pipfile-spec": 6,
"requires": {
"python_version": "3.10"
},
"sources": [
{
"name": "pypi",
"url": "https://pypi.org/simple",
"verify_ssl": true
}
]
},
"default": {
"click": {
"hashes": [
"sha256:7682dc8afb30297001674575ea00d1814d808d6a36af415a82bd481d37ba7b8e",
"sha256:bb4d8133cb15a609f44e8213d9b391b0809795062913b383c62be0ee95b1db48"
],
"markers": "python_version >= '3.7'",
"version": "==8.1.3"
},
- 安装特定版本的软件包
pipenv install Django==2.1.1
我们的 Pipfile 现在
[[source]]
url = "https://pypi.org/simple"
verify_ssl = true
name = "pypi"
[packages]
flask = "*"
django = "==2.1.1"
[dev-packages]
[requires]
python_version = "3.10"
使用 pipenv 卸载软件包
pipenv uninstall Django
项目的开发依赖关系
在编写程序时,我们需要一些在开发阶段使用的包。在生产中,这些包不再需要,以后会被忽略。nose 是 Python 中的一个测试自动化框架,我们将把它作为一个开发依赖项来安装。
pipenv install nose --dev
我们的 Pipfile 现在
[[source]]
url = "https://pypi.org/simple"
verify_ssl = true
name = "pypi"
[packages]
flask = "*"
django = "==2.1.1"
[dev-packages]
nose = "*"
[requires]
python_version = "3.10"
检查已安装软件包中的安全漏洞
它还有一个专门的命令来检查安全漏洞,并在我们的终端上显示出来,以便解决这些问题。从而使代码更加健壮。
pipenv check
显示当前安装的依赖图信息
该命令显示每个包的所有依赖项以及依赖项的所有依赖项。
pipenv graph
输出:
Django==2.1.1
- pytz [required: Any, installed: 2022.1]
Flask==2.2.2
- click [required: >=8.0, installed: 8.1.3]
- colorama [required: Any, installed: 0.4.5]
- itsdangerous [required: >=2.0, installed: 2.1.2]
- Jinja2 [required: >=3.0, installed: 3.1.2]
- MarkupSafe [required: >=2.0, installed: 2.1.1]
- Werkzeug [required: >=2.2.2, installed: 2.2.2]
- MarkupSafe [required: >=2.1.1, installed: 2.1.1]
nose==1.3.7
在项目部署前设置锁文件
这确保了为当前项目使用 Pipfile.lock 中提供的任何依赖关系,并且还忽略了 Pipfile
# Setup before deployment
pipenv lock
# Ignore Pipfile
pipenv install –-ignore-pipfile
- 退出当前环境
exit
摘要
在本文中,我们介绍了设置虚拟环境和使用包来配置使用 pipenv 的定制 Python 项目的通用工作流。
我们还研究了一些核心命令,以及它们修改或提供我们的设置信息的方式。对于不同的项目,我们需要不同的配置。我们有效地管理了我们的包,使得它在不同的地方使用时不会抛出任何错误。Pipenv 确保了我们程序的稳定性,并帮助我们为代码提供一个健壮的结构。
参考
Python 中从一个数据集到另一个数据集的数据透视表
原文:https://www.askpython.com/python/examples/pivot-table-in-python
有时,我们希望只对大型数据集中的一部分数据进行快速分析。Python 中的 Pivot table 在这种情况下就派上了用场,它帮助我们提取我们需要的数据,并从新数据中获得洞察力。今天我们将使用 Pandas 中的数据透视表功能。本文将全面概述如何在 python 中将一个数据集的数据透视表转换为另一个数据集。
什么是数据透视表,如何制作数据透视表?
数据透视表是帮助从更大的表或数据集中提取数据的表。换句话说,我们从更大的数据集中“透视”数据。让我们来看看数据透视表的语法:
pandas.pivot_table(data, values=None, index=None, columns=None, aggfunc='mean', fill_value=None)
数据透视表函数将返回一个数据帧。现在我们知道了数据透视表的基础,让我们开始旋转吧!
加载数据集
让我们从在我们的环境中加载数据集开始。
import pandas as pd
df= pd.read_csv("C://Users//Intel//Documents//covid-variants.csv")
df.head()
现在我们将开始构建一个数据透视表。
用 Python 生成数据透视表
num_sequences_by_variant = pd.pivot_table(df, index = 'variant', values = 'num_sequences',aggfunc='mean')
print(num_sequences_by_variant)
num_sequences
variant
Alpha 270.696702
B.1.1.277 0.282744
B.1.1.302 0.116157
B.1.1.519 5.455306
B.1.160 8.130736
B.1.177 40.740201
B.1.221 3.675191
B.1.258 7.358270
B.1.367 0.229685
B.1.620 0.242830
Beta 9.683078
Delta 916.371893
Epsilon 15.804732
Eta 1.654876
Gamma 27.522945
Iota 10.254541
Kappa 1.787046
Lambda 2.249283
Mu 3.405354
Omicron 27.614245
S:677H.Robin1 1.564771
S:677P.Pelican 1.156071
non_who 222.537763
others 153.585803
如您所见,我们用变量 num_sequences 和 variants 创建了一个数据透视表。因为我们已经将 aggfunc 函数作为 mean 传递,所以 num_sequences 实际上是所有 num_sequences 的平均值。
如果想要所有 num_sequences 的总和,可以将总和传递给 aggfunc 参数。
total_by_variant = pd.pivot_table(df, index = 'variant', values = 'num_sequences',aggfunc='sum')
print(total_by_variant)
输出
num_sequences
variant
Alpha 1132595
B.1.1.277 1183
B.1.1.302 486
B.1.1.519 22825
B.1.160 34019
B.1.177 170457
B.1.221 15377
B.1.258 30787
B.1.367 961
B.1.620 1016
Beta 40514
Delta 3834100
Epsilon 66127
Eta 6924
Gamma 115156
Iota 42905
Kappa 7477
Lambda 9411
Mu 14248
Omicron 115538
S:677H.Robin1 6547
S:677P.Pelican 4837
non_who 931098
others 642603
在 Python 中设置数据透视表的索引
借助以下命令,我们可以非常简单地重置上述数据帧的索引。
num_sequences_by_variant.reset_index()
在 Python 中选择/过滤数据透视表中的数据
现在假设,我们想要查看序列总数大于 30000 的变体,我们必须传递以下命令。
total_by_variant[total_by_variant['num_sequences'] > 30000]
现在,让我们再一次假设我们希望看到只有 30000 到 70000 个序列的变体。然后我们必须传递下面的命令。
total_by_variant[(total_by_variant['num_sequences'] > 30000) | (total_by_variant['num_sequences'] < 70000)]
现在让我们开始学习多索引数据透视表。
Python 中的多索引数据透视表
到目前为止,我们只了解了具有单一索引的透视表。但是我们也可以用多个指数来构建数据透视表,这可以帮助你从数据中获得更多的洞察力。
在下表中,我们将变量类型和日期设置为索引。
multi_index_table= pd.pivot_table(df, index = ['variant', 'date'], values = 'num_sequences', aggfunc = 'sum')
print(multi_index_table)
输出
num_sequences
variant date
Alpha 2020-05-11 0
2020-05-25 0
2020-06-08 0
2020-06-22 0
2020-07-06 0
... ...
others 2021-11-15 928
2021-11-29 928
2021-12-13 619
2021-12-27 603
2022-01-05 2
[1080 rows x 1 columns]
具有多种功能的多索引数据透视表
除了设置多个索引,我们还可以为数据透视表的 aggfunc 参数设置多个函数。
例如:
multi_functions_table = pd.pivot_table(df, index = ['variant', 'date'], values = 'num_sequences', aggfunc = ['sum',len])
print(multi_functions_table)
输出
sum len
num_sequences num_sequences
variant date
Alpha 2020-05-11 0 78
2020-05-25 0 72
2020-06-08 0 78
2020-06-22 0 79
2020-07-06 0 74
... ... ...
others 2021-11-15 928 89
2021-11-29 928 85
2021-12-13 619 86
2021-12-27 603 64
2022-01-05 2 12
[1080 rows x 2 columns]
在 Python 中向数据透视表添加新列
在这一步中,我们将变量特性添加为一列,并将日期设置为索引。这将使你的数据更有组织性和可读性。
add_columns=pd.pivot_table(df, index = 'date', columns = 'variant', values = 'num_sequences', aggfunc = 'sum')
print(add_columns)
输出
variant Alpha B.1.1.277 B.1.1.302 B.1.1.519 B.1.160 B.1.177 \
date
2020-05-11 0 0 0 0 0 2
2020-05-25 0 0 0 0 0 0
2020-06-08 0 0 0 0 0 2
2020-06-22 0 0 0 0 0 8
2020-07-06 0 0 0 0 0 72
2020-07-20 0 7 3 0 8 88
2020-08-03 0 12 8 0 22 172
2020-08-17 0 43 12 0 89 499
2020-08-31 0 94 24 0 386 1400
2020-09-14 0 143 32 0 1017 2923
2020-09-28 3 178 27 0 1049 6225
2020-10-12 15 120 31 0 1188 8693
2020-10-26 47 155 21 1 2017 13008
2020-11-09 381 180 21 5 2773 15723
2020-11-23 1450 72 27 17 2274 15622
2020-12-07 1128 42 29 34 2029 10489
2020-12-21 9061 28 42 82 3110 19350
2021-01-04 14002 29 21 184 2934 14161
用 Python 可视化数据透视表
在本节中,我们将为表格创建条形图。这将有助于您更清楚地可视化数据。
add_columns.plot(kind='bar')
虽然剧情看起来很笨拙,但正如我们常说的,你可以使用 Python 中的 matplotlib 库或 Seaborn 库,让剧情更像样。
使用缺失值
在本节中,我们将学习如何处理数据透视表数据中的缺失值。首先,让我们检查数据集中是否存在任何缺失值。
print(df.info())
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 100416 entries, 0 to 100415
Data columns (total 6 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 location 100416 non-null object
1 date 100416 non-null object
2 variant 100416 non-null object
3 num_sequences 100416 non-null int64
4 perc_sequences 100416 non-null float64
5 num_sequences_total 100416 non-null int64
dtypes: float64(1), int64(2), object(3)
memory usage: 4.6+ MB
None
正如我们所看到的,我们的数据集中没有任何缺失值,所以我们不需要对数据做任何事情。
如果数据中有任何缺失值,可以在数据透视表函数中将 fill_value 参数作为 N/A 进行传递。
结论
在本文中,我们学习了如何从给定的数据集生成数据透视表,并将其转换为另一个数据框架。当您分析任何具有大量特征或变量的数据集时,数据透视表将非常方便。熟记以上所有的数据透视表功能,对你的数据分析项目会有很大帮助。
如何用 Python 播放音乐?
原文:https://www.askpython.com/python-modules/play-music-in-python
你好,学习伙伴!今天我们将学习如何使用几行简单的代码在 Python 中播放音乐。
方法 playsound 模块
playsound 库是一个跨平台模块,可以播放音频文件。这没有任何依赖性,只需使用 pip 命令安装库,就可以开始了!
要播放音乐,我们只需使用playsound
函数,并将音乐文件路径作为参数传递。该库适用于mp3
和wav
文件。
相同的代码如下所示:
from playsound import playsound
playsound('Music1.mp3')
音乐在后台播放一次,然后程序准备好执行下一部分代码。
方法 pydub 库
pydub 库仅适用于。wav 文件格式。通过使用这个库,我们可以播放,分割,合并,编辑我们的。wav 音频文件。
为了让这个库工作,我们从playdub.playback
模块导入了两个函数,即AudioSegment
和play
模块。
然后我们简单地载入歌曲。wav 格式并播放歌曲。相同的代码如下所示:
from pydub import AudioSegment
from pydub.playback import play
song = AudioSegment.from_wav('Music1.wav')
play(song)
方法 3:使用零食声音套件
零食声音套件可用于播放几乎所有格式的音频文件,包括 WAV、AU、AIFF、MP3、CSL、SD、SMP 和 NIST/球体。
这个库需要 GUI 模块Tkinter
来播放声音。所以我们需要在导入零食声音套件之前导入 tkinter 模块。
通过零食声音工具包播放音频文件包括创建一个 Tk 窗口并初始化它。然后调用sound
函数和read
函数来加载音乐。
最后,我们使用play
功能来播放音乐。相同的代码如下所示:
from Tkinter import *
import tkSnack
wind = Tk()
tkSnack.initializeSnack(wind)
snd = tkSnack.Sound()
snd.read('Music1.wav')
snd.play(blocking=1)
输出音乐
下面的音乐将是每种方法中播放的输出背景音乐。
Music Played
结论
今天,我们学习了使用简单的代码行和各种库在 python 中演奏音乐。厉害!
自己尝试代码,用 Python 播放美妙的音乐。感谢您的阅读!编码快乐!
如何用 Python 绘制树形图?
原文:https://www.askpython.com/python/examples/plot-a-treemap-in-python
Python 中的树形图是将矩形分割成子部分的数据的可视化。每个子部分的大小与其代表的数据成比例。它有点像饼状图。尽管与饼图相比,树形图可以表示更复杂的数据。
它可以帮助你想象单个值是如何组成一个整体的。 Treemap 图表还可以让你使用嵌套的矩形来可视化分层数据。
在本教程中,我们将学习如何使用 python 中的 Squarify 库在 Python 中绘制树形图。
让我们从安装 Squarify 开始。
pip install squarify
Squarify
使用 Squarify 在 Python 中绘制树形图
一旦我们安装了 Squarify,我们就可以开始将它导入到我们的笔记本中。让我们也导入 matplotlib 。
import matplotlib.pyplot as plt
import squarify
1.绘制基本的树形图
为了绘制一个非常基本的树形图,我们只需要每个矩形的值。绘制树形图后,矩形将与这些值成比例。
import matplotlib.pyplot as plt
import squarify
sizes = [40, 30, 5, 25]
squarify.plot(sizes)
plt.show()
Treemap
2.向树状图添加标签
您可以使用以下代码行在 Python 中向树形图添加标签:
import matplotlib.pyplot as plt
import squarify
sizes=[40, 30, 5, 25]
label=["A", "B", "C", "D"]
squarify.plot(sizes=sizes, label=label, alpha=0.6 )
plt.show()
Labels
如果您再次运行同一段代码,您将得到以下输出:
您可以看到,每次运行 treemap 时,它的配色方案都是不同的。矩形的颜色是随机选取的。Treemap 还为您提供了提及颜色、尺寸和标签的选项。接下来我们将学习如何改变树形图的颜色。
3.更改树形图中的颜色
要在 Python 中更改树图的颜色,请列出您希望树图具有的颜色。然后将该列表传递给 squarify.plot 方法。
import matplotlib.pyplot as plt
import squarify
sizes=[40, 30, 5, 25]
label=["A", "B", "C", "D"]
color=['red','blue','green','grey']
squarify.plot(sizes=sizes, label=label, color=color, alpha=0.6 )
plt.show()
Changing Color
4.关闭绘图轴
要绘制不带绘图轴的树形图,请使用:
plt.axis('off')
这行代码将关闭绘图轴。完整的代码如下:
import matplotlib.pyplot as plt
import squarify
sizes=[40, 30, 5, 25]
label=["A", "B", "C", "D"]
color=['red','blue','green','grey']
squarify.plot(sizes=sizes, label=label, color=color, alpha=0.6 )
plt.axis('off')
plt.show()
Plot Axis Off
为数据集绘制树状图
在教程的这一部分,我们将学习如何为数据集绘制树形图。我们将使用泰坦尼克号数据集。让我们从导入数据集开始。为了简化导入数据集的过程,我们将使用 seaborn 库。
1.导入数据集
要将 titanic 数据集从 seaborn 库导入到 Python 笔记本中,请使用:
import seaborn as sns
titanic = sns.load_dataset('titanic')
titanic.head()
Titanic Dataset
该数据集包含泰坦尼克号乘客的信息。
我们想根据幸存者所处的阶层为他们绘制一张树状图。
原始格式的数据无法绘制树状图。我们将执行一些操作,并尝试提取数据,我们可以使用绘制树状图。
为了得到每个类的幸存者,我们将对我们的数据使用分组方法。
2.准备用于打印的数据
您可以对数据集使用 groupby 函数,如下所示:
n = titanic.groupby('class')[['survived']].sum()
Groupby
这给了我们按班级分组的幸存者总数。
现在我们需要从中提取数据和标签作为列表。
a = titanic.groupby('class')[['survived']].sum().index.get_level_values(0).tolist()
print(a)
输出:
['First', 'Second', 'Third']
这为我们提供了列表形式的标签。要获得对应于这些标签的值,请使用:
d = titanic.groupby('class')[['survived']].sum().reset_index().survived.values.tolist()
print(d)
输出:
[136, 87, 119]
现在我们有了列表形式的标签和数据。我们可以用这些来绘制树状图。
3.绘制树状图
要绘制树形图,请使用以下代码行:
squarify.plot(sizes=d, label=a, alpha=.8)
plt.axis('off')
plt.show()
Titanic Treemap
将树状图可视化,我们可以大致了解第一类、第二类和第三类幸存者的数量。光看树状图,我们就可以很有信心地说,二班的幸存者最少。
用 Python 绘制树形图的完整代码
本节的完整代码如下所示:
import seaborn as sns
import squarify
import matplotlib.pyplot as plt
titanic = sns.load_dataset('titanic')
a = titanic.groupby('class')[['survived']].sum().index.get_level_values(0).tolist()
d = titanic.groupby('class')[['survived']].sum().reset_index().survived.values.tolist()
squarify.plot(sizes=d,label=a, alpha=.8 )
plt.axis('off')
plt.show()
结论
在本教程中,我们学习了如何使用 Squarify 在 python 中绘制树状图。希望你和我们一起学习愉快。
如何用 Python 绘制和自定义饼状图?
原文:https://www.askpython.com/python/plot-customize-pie-chart-in-python
饼图是一种圆形统计图形,它被分成若干片来说明数字比例。在饼图中,每个切片的弧长与其代表的数量成比例。
饼状图是表示民意调查结果的一种流行方式。在本教程中,我们将学习如何绘制饼图。此外,我们将学习如何用 python 定制饼图。
让我们开始吧。
创建示例数据
让我们创建一些在绘制饼图时可以使用的样本数据。
labels = 'Cricket', 'Football', 'Hockey', 'F1'
sizes = [15, 30, 45, 10]
该数据代表了一项关于人们最喜欢的运动的民意调查。
如何绘制饼状图?
为了绘制饼图,我们将使用 matplotlib 。
import matplotlib.pyplot as plt
为了绘制一个基本的饼图,我们需要标签和与这些标签相关的值。
labels = 'Cricket', 'Football', 'Hockey', 'F1'
sizes = [15, 30, 45, 10]
fig1, ax1 = plt.subplots()
ax1.pie(sizes, labels=labels)
ax1.axis('equal')
plt.show()
运行上面的代码片段,我们得到以下输出:
Pie Chart
请注意,这是一个非常基本的饼图。
现在让我们看看如何定制饼图,使它看起来更有趣。
在 Python 中自定义饼图
Matplotlib 在绘制饼图时提供了许多定制选项。让我们一个一个地看看这些。
1.弹出一个切片
您可以使用“分解”选项弹出一个或多个饼图切片。
为此,我们声明一个包含爆炸值的数组。分解数组指定偏移每个切片的半径分数。
import matplotlib.pyplot as plt
labels = 'Cricket', 'Football', 'Hockey', 'F1'
sizes = [15, 30, 45, 10]
explode = (0, 0.1, 0, 0)
fig1, ax1 = plt.subplots()
ax1.pie(sizes, explode=explode, labels=labels)
plt.show()
输出:
Explode
让我们尝试一些不同的爆炸值。
import matplotlib.pyplot as plt
labels = 'Cricket', 'Football', 'Hockey', 'F1'
sizes = [15, 30, 45, 10]
explode = (0.4, 0.2, 0.2, 0.2)
fig1, ax1 = plt.subplots()
ax1.pie(sizes, explode=explode, labels=labels)
plt.show()
Explode
2.旋转饼图
你可以通过设置一个角度来旋转饼图。
它将饼图的起点从 x 轴逆时针旋转指定的度数。
让我们来看看它的实际应用:
import matplotlib.pyplot as plt
labels = 'Cricket', 'Football', 'Hockey', 'F1'
sizes = [15, 30, 45, 10]
fig1, ax1 = plt.subplots()
explode = (0, 0.1, 0, 0)
ax1.pie(sizes, explode=explode, labels=labels,
shadow=True, startangle=90)
plt.show()
输出:
Rotate 90
import matplotlib.pyplot as plt
labels = 'Cricket', 'Football', 'Hockey', 'F1'
sizes = [15, 30, 45, 10]
fig1, ax1 = plt.subplots()
explode = (0, 0.1, 0, 0)
ax1.pie(sizes, explode=explode, labels=labels,
shadow=True, startangle=45)
plt.show()
Rotate 45
3.显示百分比
您还可以使用以下代码行显示每个切片的百分比:
import matplotlib.pyplot as plt
labels = 'Cricket', 'Football', 'Hockey', 'F1'
sizes = [15, 30, 45, 10]
fig1, ax1 = plt.subplots()
explode = (0, 0.1, 0, 0)
ax1.pie(sizes, explode=explode, labels=labels,autopct='%1.1f%%',
shadow=True, startangle=90)
plt.show()
输出:
Percentage
4.定制颜色
Matplotlib 让您可以发挥创意,让您的饼图看起来尽可能生动。
要改变饼图的颜色,使用下面几行代码。
import matplotlib.pyplot as plt
labels = 'Cricket', 'Football', 'Hockey', 'F1'
sizes = [15, 30, 45, 10]
colors = ( "orange", "cyan", "brown",
"grey")
fig1, ax1 = plt.subplots()
explode = (0, 0.1, 0, 0)
ax1.pie(sizes, colors = colors, explode=explode, labels=labels,autopct='%1.1f%%',
shadow=True, startangle=90)
plt.show()
这里我们声明了 4 种我们想在列表中使用的颜色。然后在绘制饼图时,我们将该列表作为参数传递。
输出结果如下:
Change Colours
5.显示颜色代码
除了您的饼图,您还可以显示一个包含饼图配色方案的框。当饼图中有很多切片时,这尤其有用。
要显示颜色代码,请使用以下代码片段:
import matplotlib.pyplot as plt
labels = 'Cricket', 'Football', 'Hockey', 'F1'
sizes = [15, 30, 45, 10]
colors = ( "orange", "cyan", "brown",
"grey")
fig1, ax1 = plt.subplots()
explode = (0, 0.1, 0, 0)
ax1.pie(sizes, colors = colors, explode=explode, labels=labels,autopct='%1.1f%%', shadow=True, startangle=90)
patches, texts, auto = ax1.pie(sizes, colors=colors, shadow=True, startangle=90,explode=explode, autopct='%1.1f%%' )
plt.legend(patches, labels, loc="best")
plt.show()
输出:
Colour Codes
结论
本教程讲述了如何使用 Matplotlib 在 Python 中绘制和定制饼图。希望你和我们一起学习愉快。要浏览 matplotlib 的官方文档,使用这个链接。
使用 Python 绘制 Excel 表格中的数据
原文:https://www.askpython.com/python/examples/plot-data-from-excel-sheet
在本教程中,我们将学习机器学习和数据科学领域的一个基本要求。绘制数据有助于可视化数据,并有助于更好地理解数据点。
使用 Python 从 Excel 表绘制数据的步骤
今天我们将在 Python 编程中的 pandas 和 matplotlib 模块的帮助下,利用 excel 表格绘制数据。所以让我们开始吧!
步骤 1:导入模块
我们将导入 matplotlib 和 pandas 模块,其中 matplotlib 模块用于绘图,pandas 用于处理 excel 文件数据点。
在导入模块之前,我们需要确保模块已经安装在我们的系统中,这可以使用 CMD(命令提示符)上的以下命令来完成。
pip install pandas
pip install matplotlib
现在,我们将使用下面的代码行在程序中导入这两个模块。
import pandas as pd
import matplotlib.pyplot as plt
步骤 2:加载数据集
为了加载数据,我们将使用 pandas 模块中的read_excel
函数,该函数将 excel 文件的路径作为参数。
对于本教程,我们创建了一个包含一些样本数据点的样本 excel 表,如下图所示。
Sample Excel Sheet Data Chosen
现在,数据的加载是在下面提到的代码语句的帮助下完成的。
var = pd.read_excel("sample_excel.xlsx")
print(var)
步骤 3:分离 x 和 y 值
现在,在数据集中,我们有两列,一列用于 x 数据点,另一列用于 y 数据点。这是在将第一列和第二列分成单独的变量之后完成的。
x = list(var['X values'])
y = list(var['Y values'])
在 x 和 y 坐标分离后,我们将在下一步中为数据绘制散点图。
步骤 4:绘制散点图
散点图是在下述代码块的帮助下显示的。
plt.figure(figsize=(10,10))
plt.style.use('seaborn')
plt.scatter(x,y,marker="*",s=100,edgecolors="black",c="yellow")
plt.title("Excel sheet to Scatter Plot")
plt.show()
Final Plot Excel Data
您可以尝试不同的数据集或在线搜索 excel 格式的随机数据集。我希望你彻底理解了这个概念,并且能够自己实现它!
感谢您的阅读!快乐学习!
使用 Python Plotly 在地图上绘制地理数据
原文:https://www.askpython.com/python/examples/plot-geographical-data-python-plotly
在本教程中,我们将学习如何使用 Python Plotly 在地图上绘制地理数据。在本次演示中,我们将从ourworldindata.org数据集绘制新冠肺炎案例。
用 Python 在地图上绘制地理数据的步骤
让我们开始吧。
1.导入所需的库
让我们从导入必要的库开始。我们需要导入以下两个库:
import pandas as pd
import plotly.express as px
现在,我们可以进入下一步,即下载数据集。
2.下载并读取数据集
要下载和加载数据集,请使用下面这段代码。
!wget https://covid.ourworldindata.org/data/owid-covid-data.csv
输出:
Download Dataset
使用 pandas read_csv 方法读取 Python 中的 CSV 数据集:
df = pd.read_csv('owid-covid-data.csv')
df.head()
Dataset
3.在地图上绘制新冠肺炎数据集
现在,我们可以使用 Plotly 来绘制上面数据集的数据。
我们正在绘制一张地图。它是一种地图,利用预先定义的区域内的阴影、颜色或符号放置的差异来表示这些区域内特定量的平均值。
我们将绘制每天新病例的数量。Plotly 让我们通过动画来实现。
下面是在地图上绘制颜色和阴影的代码:
fig = px.choropleth(df, locations="iso_code",
color="new_cases",
hover_name="location",
animation_frame="date",
title = "Covid Cases plotted using Plotly", color_continuous_scale=px.colors.sequential.PuRd)
fig["layout"].pop("updatemenus")
fig.show()
输出:
Feb
April
September
输出显示了一年中三个不同月份的地图外观。我们可以看到病毒在二月份迅速在中国传播,四月份在美国传播,九月份在印度传播。
您还可以将鼠标悬停在地图的任何区域上,查看新案例的数量。
Plotly 动画可以方便地可视化时间序列数据。
4.使用 Python Plotly 绘制地理数据的完整代码
下面给出了本节的完整代码:
import pandas as pd
import plotly.express as px
#download dataset
!wget https://covid.ourworldindata.org/data/owid-covid-data.csv
#import dataset
df = pd.read_csv('owid-covid-data.csv')
#plot
fig = px.choropleth(df, locations="iso_code",
color="new_cases",
hover_name="location",
animation_frame="date",
title = "Covid Cases plotted using Plotly", color_continuous_scale=px.colors.sequential.PuRd)
fig["layout"].pop("updatemenus")
fig.show()
6.绘制新冠肺炎亚洲数据
你也可以将地图的范围设置为亚洲。让我们看看如何为亚洲的内容绘制地理数据。
要将绘图范围设置为亚洲,请将参数“范围”设置为“亚洲”。
import pandas as pd
import plotly.express as px
#download dataset
!wget https://covid.ourworldindata.org/data/owid-covid-data.csv
#import dataset
df = pd.read_csv('owid-covid-data.csv')
#select entries with the continent as asia
df = df[df.continent == 'Asia']
#plot
fig = px.choropleth(df, locations="iso_code",
color="new_cases",
hover_name="location",
animation_frame="date",
title = "Daily new COVID cases",
scope ='asia', color_continuous_scale=px.colors.sequential.PuRd)
fig["layout"].pop("updatemenus")
fig.show()
输出:
https://www.askpython.com/wp-content/uploads/2020/12/covid-cases-in-asia-1.mov
该视频借助动画展示了每天的新冠肺炎新病例。
结论
本教程是关于用 Python Plotly 绘制地理数据的。我们使用 python 中的 Plotly 绘制了来自新冠肺炎数据集的数据。要了解 Plotly 允许您创建的其他类型的地图,请阅读他们的官方文档。
如何用 Python 为一个数据帧绘制图形?
原文:https://www.askpython.com/python-modules/pandas/plot-graph-for-a-dataframe
了解如何绘制数据框架将有助于您在几行代码中执行更好的数据分析。可视化数据帧是数据科学家为了更好地理解数据而首先开展的活动之一。
可视化数据集通常能提供更好的图片,并帮助你计划行动路线。它还可以很容易地发现异常值,并推测数据集中是否存在任何相关性。
简而言之,知道如何可视化数据帧是一项重要的技能。
用 Python 绘制数据帧的方法
让我们从导入数据集开始。
1.导入数据集
对于本教程的范围,我们将使用加州住房数据集。
让我们从使用 pandas 将数据导入数据框开始。
import pandas as pd
housing = pd.read_csv("/sample_data/california_housing.csv")
housing.head()
Housing Dataframe
使用熊猫绘图
您可以使用绘制数据帧。Pandas Dataframe 中的 plot()方法。
您需要将 matplotlib 导入到您的 python 笔记本中。使用以下代码行来完成此操作。
import matplotlib.pyplot as plt
1.绘制数据帧直方图
要绘制与住房数据中所有列相对应的直方图,请使用以下代码行:
housing.hist(bins=50, figsize=(15,15))
plt.show()
Plotting
当您需要看到所有列一起绘制时,这很好。接下来,让我们看看如何在两列之间制作散点图。
2.散点图
散点图有助于确定两个变量之间的相关性。
要绘制两个变量之间的散点图,请使用以下代码行:
housing.plot(x='population', y = 'median_house_value', kind='scatter')
plt.show()
这将产生以下输出:
Scatter Plot
我们可以看到数据集中有一些异常值。我们看不出这两个变量之间有很强的相关性。
让我们试着绘制中值收入对中值房价的图表。
housing.plot(x='median_income', y = 'median_house_value', kind='scatter')
plt.show()
Scatter Plot
这里我们可以看到两个变量之间的正相关关系。随着收入中位数的上升,住房价值中位数也趋于上升。
为了查看更强相关性的示例,让我们绘制另一个散点图。这个时间在人口和总间。逻辑上这两者应该有很强的正相关性。
正相关意味着两个变量倾向于一起增加和减少。
housing.plot(x='population', y = 'total_rooms', kind='scatter')
plt.show()
Scatter Plot
我们的推测是对的,房间总数和人口确实有很强的正相关性。我们可以这样说,因为这两个变量往往一起增加,如图表所示。
绘制不同的图时,可以使用以下不同的参数:
- “线条”:线条图(默认)
- “条形图”:垂直条形图
- “barh”:水平条形图
- “历史”:直方图
- “方框”:方框图
- “kde”:核密度估计图
- '密度' :与' kde '相同
- “面积”:面积图
- ‘pie’ : pie plot
- “散点图”:散点图
- “hex bin”:hex bin 图
使用 Seaborn 绘图
或者,您也可以使用 Seaborn 绘制数据帧。它是一个基于 matplotlib 的 Python 数据可视化库。它提供了一个高层次的界面来绘制有吸引力的和信息丰富的统计图形。
Seaborn 是一个非常强大的可视化工具。您可以获得许多定制选项。
1.进口海鲜
让我们从将 Seaborn 导入 python 笔记本开始。
import seaborn as sns
2.使用 Distplot
Seaborn 提供了绘制距离图的选项。distplot 是一个直方图,自动计算一个好的默认 bin 大小。
您可以使用以下代码行创建一个:
sns.distplot(housing['median_house_value'])
Distplot
在这里你也可以发现异常值。让我们试着为中等收入也画一个。
sns.distplot(housing['median_income'])
Distplot
结论
本教程是关于用 Python 绘制熊猫数据帧的。我们介绍了绘制数据帧的两种不同方法。希望你和我们一起学习愉快!
如何用 Python 绘制 K-Means 聚类?
原文:https://www.askpython.com/python/examples/plot-k-means-clusters-python
在本文中,我们将看到如何绘制 K 均值聚类。
K-means 聚类是一种迭代聚类方法,将数据分割成 k 个聚类,其中每个观察值属于具有最近均值(聚类质心)的聚类。
绘制 K 均值聚类的步骤
本文演示了如何可视化集群。我们将使用数字数据集来解释我们的原因。
1.准备用于打印的数据
首先让我们准备好数据。
#Importing required modules
from sklearn.datasets import load_digits
from sklearn.decomposition import PCA
from sklearn.cluster import KMeans
import numpy as np
#Load Data
data = load_digits().data
pca = PCA(2)
#Transform the data
df = pca.fit_transform(data)
df.shape
输出:
(1797, 2)
Digits 数据集包含大小为 8×8 像素的图像,将其展平以创建长度为 64 的特征向量。我们使用 PCA 来减少维数,这样我们可以使用 2D 散点图来可视化结果。
2.对数据应用 K 均值
现在,让我们对数据应用 K-mean 来创建聚类。
在数字数据集中,我们已经知道标签的范围从 0 到 9,所以我们有 10 个类(或聚类)。
但是在现实生活的挑战中,当执行 K-means 时,最具挑战性的任务是确定聚类的数量。
确定最佳聚类数的方法有多种,即肘形法、平均剪影法。但是确定星团的数量将是另一个话题。
#Import required module
from sklearn.cluster import KMeans
#Initialize the class object
kmeans = KMeans(n_clusters= 10)
#predict the labels of clusters.
label = kmeans.fit_predict(df)
print(label)
输出:
out: [0 3 7 ... 7 4 9]
kmeans.fit_predict
方法返回每个数据点所属的聚类标签数组。
3.标绘标签 0k-均值聚类
现在,是时候了解并看看如何绘制单个集群了。
标签数组保存了数据点的索引或序列,因此我们可以利用这个特性,使用带有 numpy 的布尔索引来过滤数据点。
让我们使用 matplotlib 库可视化标签为 0 的集群。
import matplotlib.pyplot as plt
#filter rows of original data
filtered_label0 = df[label == 0]
#plotting the results
plt.scatter(filtered_label0[:,0] , filtered_label0[:,1])
plt.show()
Plotting Label 0
上面的代码首先过滤并保留属于分类标签 0 的数据点,然后创建一个散点图。
看看我们如何传递一个布尔序列给 filter [label == 0]。将过滤后的数据编入索引,并作为(x,y)传递给plt.scatter
进行绘图。x =筛选的标签 0[:,0],y =筛选的标签 0[:,1]。
4.绘制额外的 K 均值聚类
现在,我们有了一些想法,让我们用标签 2 和 8 来绘制集群。
#filter rows of original data
filtered_label2 = df[label == 2]
filtered_label8 = df[label == 8]
#Plotting the results
plt.scatter(filtered_label2[:,0] , filtered_label2[:,1] , color = 'red')
plt.scatter(filtered_label8[:,0] , filtered_label8[:,1] , color = 'black')
plt.show()
Plotting Labels 2 And 8
精彩!
5.绘制所有 K 均值聚类
现在,我们已经获得了工作机制,让我们将它应用到所有集群。
#Getting unique labels
u_labels = np.unique(label)
#plotting the results:
for i in u_labels:
plt.scatter(df[label == i , 0] , df[label == i , 1] , label = i)
plt.legend()
plt.show()
Final Clusters
上面的代码根据每个唯一的类一次一次地迭代过滤数据。我们得到的结果是所有集群的最终可视化。
6.绘制聚类质心
#Getting the Centroids
centroids = kmeans.cluster_centers_
u_labels = np.unique(label)
#plotting the results:
for i in u_labels:
plt.scatter(df[label == i , 0] , df[label == i , 1] , label = i)
plt.scatter(centroids[:,0] , centroids[:,1] , s = 80, color = 'k)
plt.legend()
plt.show()
Clusters With Their Respective Centroids
返回一个质心位置的数组。
这是我们刚刚在上面看到的完整代码。
#Importing required modules
from sklearn.datasets import load_digits
from sklearn.decomposition import PCA
from sklearn.cluster import KMeans
import numpy as np
#Load Data
data = load_digits().data
pca = PCA(2)
#Transform the data
df = pca.fit_transform(data)
#Import KMeans module
from sklearn.cluster import KMeans
#Initialize the class object
kmeans = KMeans(n_clusters= 10)
#predict the labels of clusters.
label = kmeans.fit_predict(df)
#Getting unique labels
u_labels = np.unique(label)
#plotting the results:
for i in u_labels:
plt.scatter(df[label == i , 0] , df[label == i , 1] , label = i)
plt.legend()
plt.show()
结论
在本文中,我们看到了如何可视化由 k-means 算法形成的聚类。下次再见,学习愉快!
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】凌霞软件回馈社区,博客园 & 1Panel & Halo 联合会员上线
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】博客园社区专享云产品让利特惠,阿里云新客6.5折上折
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步
· CSnakes vs Python.NET:高效嵌入与灵活互通的跨语言方案对比
· DeepSeek “源神”启动!「GitHub 热点速览」
· 我与微信审核的“相爱相杀”看个人小程序副业
· Plotly.NET 一个为 .NET 打造的强大开源交互式图表库
· 上周热点回顾(2.17-2.23)
2022-10-31 ZetCode JavaScript 教程