AskPython-博客中文翻译-一-
AskPython 博客中文翻译（一）
使用 Matplotlib 在 Python 中绘制三维图形
原文：https://www.askpython.com/python-modules/matplotlib/3-dimensional-plots-in-python
就像二维绘图一样，你也可以使用 matplotlib 在 Python 中创建三维绘图。在本教程中，我们将学习如何使用 matplotlib 绘制三维图。
如何用 Python 绘制三维图形？
我们将使用 mplot3d 工具包和 matpotlib 库。mplot3d 工具包建立在 matplotlib 库的基础上，可以轻松创建三维绘图。
所以不要再拖延了，让我们开始吧！
1.导入必要的模块
首先，我们将导入 matplotlib 和 mplot3d 工具包。除了这两个，我们还将 导入 numpy 来创建样本数据。下面给出了导入这三个组件的代码。
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
2.创建三维轴
现在我们可以使用导入的模块创建三维轴。
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
#create 3d axes
fig = plt.figure()
ax = plt.axes(projection='3d')
plt.show()
输出:
Axes
现在我们有了轴，让我们试着画些东西。在绘图时，我们需要确保提供所有三个轴(x、y 和 z)的值。
在接下来的几节中，我们将学习如何使用正弦函数(正弦和余弦)制作螺旋。
在此之前，我们将学习如何为情节添加标题。
3.为情节添加标题
您可以使用 set_title()方法向绘图添加标题:
ax.set_title('Learning about 3D plots')
要查看上面的代码行，请运行以下命令:
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
#create 3d axes
fig = plt.figure()
ax = plt.axes(projection='3d')
#set title
ax.set_title('Learning about 3D plots')
plt.show()
输出:
Plot With Title
4.创建一个螺旋
为了创建一个螺旋，我们将沿着 x 轴使用正弦函数和沿着 y 轴使用余弦函数。
螺旋的数据点可以按如下方式生成:
z = np.linspace(0, 15, 1000)
x = np.sin(z)
y = np.cos(z)
这里函数 np.linespace 给出了 1000 个 0 到 15 之间的等距点。
完整的代码如下:
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
#create 3d axes
fig = plt.figure()
ax = plt.axes(projection='3d')
#cordiates for spiral
z = np.linspace(0, 15, 1000)
x = np.sin(z)
y = np.cos(z)
ax.plot3D(x, y, z, 'red')
plt.show()
输出:
Spiral
5.改变视角
根据视角的不同，三维图看起来会有所不同。您可以使用 view_init()方法更改三维绘图的视角:
ax.view_init(60, 50)
完整的代码如下所示:
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
#create 3d axes
fig = plt.figure()
ax = plt.axes(projection='3d')
#cordiates for spiral
z = np.linspace(0, 15, 1000)
x = np.sin(z)
y = np.cos(z)
ax.plot3D(x, y, z, 'red')
ax.view_init(60, 50)
plt.show()
输出:
Changing Viewing Angle
这里我们提到两个参数，轴的仰角和角度(以度为单位)。
我们换个角度试试。
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
#create 3d axes
fig = plt.figure()
ax = plt.axes(projection='3d')
#cordiates for spiral
z = np.linspace(0, 15, 1000)
x = np.sin(z)
y = np.cos(z)
ax.plot3D(x, y, z, 'red')
ax.view_init(120, 90)
plt.show()
输出:
Example 2
6.绘制线框
可使用 plot_wireframe()方法绘制三维线框，如下例所示:
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
#create 3d axes
fig = plt.figure()
ax = plt.axes(projection='3d')
#function for Z values
def f(x, y):
return np.cos(np.sqrt(x ** 2 + y ** 2))
# x and y values
x = np.linspace(1, 10, 10)
y = np.linspace(1, 10, 10)
X, Y = np.meshgrid(x, y)
Z = f(X, Y)
ax = plt.axes(projection ='3d')
ax.plot_wireframe(X, Y, Z, color ='red')
plt.show()
输出:
Wireframe
这里函数 np.meshgrid 从坐标向量创建坐标矩阵。
同样，您也可以创建曲面图。让我们在下一节学习如何做到这一点。
7.创建曲面图
我们可以用与上面相同的数据创建一个表面图。要创建三维表面图，我们将使用 plot_surface()方法。
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
#create 3d axes
fig = plt.figure()
ax = plt.axes(projection='3d')
#function for Z values
def f(x, y):
return np.cos(np.sqrt(x ** 2 + y ** 2))
# x and y values
x = np.linspace(1, 10, 10)
y = np.linspace(1, 10, 10)
X, Y = np.meshgrid(x, y)
Z = f(X, Y)
ax = plt.axes(projection ='3d')
ax.plot_surface(X, Y, Z, rstride=1, cstride=1,
cmap='viridis')
plt.show()
输出:
Surface-plot
在这里，以下自变量的含义如下:
| rstride | 数组行步距(步长) |
| cstride | 数组列跨距(步长) |
| 营地 | 曲面片的颜色图。 |
结论
本教程是关于 Python 中的三维绘图。我们学习了如何绘制三维轴和数据点。要了解更多 mplot3d 下的三维形状，请参考他们的官方文档。
Python 中的 3D 绘图:快速指南
原文：https://www.askpython.com/python-modules/matplotlib/3d-plot-in-python
我们将学习几种在 Python 中绘制 3D 图的方法及其适当的用法。我们将开发我们的 Google Colab 笔记本。我们进入正题。
绘图所需的方法
在开始我们的例子之前，让我们也理解一下方法。我们将进一步使用它们。
numpy.linespace()
这个方法用于在我们需要的轴上绘制数值。numpy.linespace()的语法如下。
numpy.linspace(start, stop, num = 50, endpoint = True, retstep = False, dtype = None)
该方法的参数是:
- 开始:我们坐标轴坐标的开始。
- 停止:坐标轴的终点。
- num: 要绘制的点样本数
- restep: 如果为真，返回(样本，步骤)。默认情况下，restep = False。(可选)
- dtype: 输出数组的类型。(可选)
我们可以通过下面的例子更好地理解。
import numpy as np
import pylab as p
# taking Start = 0, End = 2 and num=15 as parameters
x1 = np.linspace(0, 2, 15, endpoint = True)
y1 = np.zeros(15)
#taking x axis from -0.2 to 2.1 in our graph
p.xlim(-0.2, 2.1)
#plotting graph
p.plot(x1, y1, "*")
代码片段将给出如下结果。
numpy.linespace() method output
numpy.mgrid(数码相机)
返回多维度mesh grid的 NumPy 库的实例。一个mesh grid是一个具有相似值的 2d 数组。此方法调用 mesh grid 方法来初始化密集多维数组。输出数组的维数和数量等于索引维数。
numpy.mgrid 的语法如下。
numpy.mgrid = <numpy.lib.index_tricks.nd_grid object>
在我们的代码片段中，我们可以更好地理解下面的例子。
>>> import numpy as np
>>> new = np.mgrid[0:6, 0:4]
>>> print(new)
[[[0 0 0 0]
[1 1 1 1]
[2 2 2 2]
[3 3 3 3]
[4 4 4 4]
[5 5 5 5]]
[[0 1 2 3]
[0 1 2 3]
[0 1 2 3]
[0 1 2 3]
[0 1 2 3]
[0 1 2 3]]]
>>> new2 = np.mgrid[0:3, 0:5]
>>> print(new2)
[[[0 0 0 0 0]
[1 1 1 1 1]
[2 2 2 2 2]]
[[0 1 2 3 4]
[0 1 2 3 4]
[0 1 2 3 4]]]
让我们开始用不同的方法绘制 3D 模型。
使用. plot3D()方法绘制三维模型
用 python 绘制我们的第一个 3D 模型，我们将在 3D 图形中使用 Python 创建一个螺线管。让我们看看下面的代码片段。
#importing required modules for 3D plotting
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
#creating our 3D space using projection=3D parameter
ax = plt.axes(projection='3d')
#using linespace() method to assign plotting range of z-axis
zline = np.linspace(10, 200, 1000)
#taking x-intercept and y-intercept values as sin(zvalue) and cos(zvalue) respectively for different zvalue as radian.
xline = np.sin(zline)
yline = np.cos(zline)
#using plot3D() method by passing 3 axes values and plotting colour as "green"
ax.plot3D(xline, yline, zline, 'green')
按照上面的代码片段，我们可以得到如下输出。
Example 1 Output
您可以通过更改参数值来尝试上面的代码片段。你可以得到各种其他的结果，也可以更好地理解。让我们看另一个 3D 模型的例子。
使用. scatter3D()方法绘制 3D 模型
绘制第二个 3D 模型。我们将使用 python 在 3D 图形中创建一个分散的点状螺线管。让我们看看下面的代码片段。
#importing modules and creating a 3D as previous example
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
ax = plt.axes(projection='3d')
a = 500
# Data for three-dimensional scattered points
zdata = 50 * np.random.random(a)
xdata = np.sin(zdata) + 0.0 * np.random.random(a)
ydata = np.cos(zdata) + 0.0 * np.random.random(a)
#using the scatter3D() method by passing 3 co-ordinates
ax.scatter3D(xdata, ydata, zdata);
按照上面的代码片段，我们可以得到如下输出。
Example 2 Output
通过改变参数中相同代码片段的值，我们可以得到如下不同的图。
# Data for three-dimensional scattered points
a = 400
zdata = 20 * np.random.random(a)
xdata = np.sin(zdata) + 0.3 * np.random.random(a)
ydata = np.cos(zdata) + 0.1 * np.random.random(a)
ax.scatter3D(xdata, ydata, zdata);
Example 2 Output After Changing Parameter Values
从元组列表绘制表面
在这个方法中，我们将为一些元组绘制曲面(将元组视为坐标)。
import numpy as np
from matplotlib import pyplot as plt
ax = plt.axes(projection='3d')
# List of tuples
tuple_list = [(1, 0, 0), (0, 1, 0), (0, 0, 1)]
# Data points from the list of tuples
x, y, z = zip(tuple_list)
x, y = np.meshgrid(x, y)
Z = x ** 2 + y ** 2
# Surface plotting using .plot_surface() method
ax.plot_surface(x, y, Z)
plt.show()
按照上面的代码片段，我们可以得到如下输出。
Surface By Tuples
使用绘制 3D 模型。plot_surface()方法
在这个方法中，我们将使用 plot_surface() 在 Python 中绘制球体表面上的点。
import matplotlib.pyplot as plt
import numpy as np
ax = plt.axes(projection='3d')
getting the values for spherical points
u, v = np.mgrid[0:2 * np.pi:50j, 0:np.pi:50j]
x = np.cos(u) * np.sin(v)
y = np.sin(u) * np.sin(v)
z = np.cos(v)
#Plotting the surface using plot_surface() method
ax.plot_surface(x, y, z)
plt.show()
按照上面的代码片段，我们将得到如下输出。
Plot Surface Method
摘要
在本文中，我们介绍了如何使用 Python 绘制 3D 模型。我们绘制了一个螺线管、一个球体和一个法线平面。您可以使用不同的值作为参数来尝试相同的代码片段，以获得不同的输出。我们也可以学到更多。希望你一定喜欢它。
A*算法——算法介绍(带 Python 实现)
原文：https://www.askpython.com/python/examples/a-star-algorithm
在本文中，让我们试着理解 A*算法的概念及其重要性。它是一种启发式搜索算法，主要用于确定几个选项中哪一个对达到特定目标状态最有效。
什么是 A*算法？
a算法(读作 A-star)是“分支定界搜索算法”和“最佳搜索算法”与动态规划原理的结合。A算法是众所周知的，因为它用于定位路径和图形遍历。这种算法被用在许多在线地图和游戏中。它使用通常用 f(X)表示的启发式或评估函数来确定搜索访问树中节点的顺序。节点 N 的启发式函数定义如下:
f(N) = g(N)+h(N)
函数 g 是从起始节点到当前节点 N 的成本的度量，即，它是沿着到当前节点的最佳路径应用的规则的成本的总和。函数 h 是从当前节点 N 到目标节点的附加成本的估计。这是利用问题领域知识的地方。一般来说，A*算法被称为或图/树搜索算法。
A*算法从起始节点开始逐步搜索所有路由，直到找到到达目标的最短路径。从给定的节点开始，该算法扩展具有最低 f(x)值的节点。它维护一组部分解决方案。扩展节点的未扩展叶节点存储在具有相应 f 值的队列中。该队列可以作为优先级队列来维护。
例子
让我们再次考虑一个 8 字谜的例子，并通过使用 A*算法来解决它。简单评估函数 f(x)定义如下:
f(x) = g(x)+h(X),
在哪里
- h(X) =在给定状态 X 下，不在目标位置的瓷砖数量
- g(X) =搜索树中节点 X 的深度
考虑到
Initial State
让我们试着借助 g(x)和 h(x)计算 f(x)的值，为这个问题开发一个搜索树。
Search Tree
用 Python 实现
from copy import deepcopy
import numpy as np
import time
def bestsolution(state):
bestsol = np.array([], int).reshape(-1, 9)
count = len(state) - 1
while count != -1:
bestsol = np.insert(bestsol, 0, state[count]['puzzle'], 0)
count = (state[count]['parent'])
return bestsol.reshape(-1, 3, 3)
# checks for the uniqueness of the iteration(it).
def all(checkarray):
set=[]
for it in set:
for checkarray in it:
return 1
else:
return 0
# number of misplaced tiles
def misplaced_tiles(puzzle,goal):
mscost = np.sum(puzzle != goal) - 1
return mscost if mscost > 0 else 0
def coordinates(puzzle):
pos = np.array(range(9))
for p, q in enumerate(puzzle):
pos[q] = p
return pos
# start of 8 puzzle evaluvation, using Misplaced tiles heuristics
def evaluvate_misplaced(puzzle, goal):
steps = np.array([('up', [0, 1, 2], -3),('down', [6, 7, 8], 3),('left', [0, 3, 6], -1),('right', [2, 5, 8], 1)],
dtype = [('move', str, 1),('position', list),('head', int)])
dtstate = [('puzzle', list),('parent', int),('gn', int),('hn', int)]
costg = coordinates(goal)
# initializing the parent, gn and hn, where hn is misplaced_tiles function call
parent = -1
gn = 0
hn = misplaced_tiles(coordinates(puzzle), costg)
state = np.array([(puzzle, parent, gn, hn)], dtstate)
#priority queues with position as keys and fn as value.
dtpriority = [('position', int),('fn', int)]
priority = np.array([(0, hn)], dtpriority)
while 1:
priority = np.sort(priority, kind='mergesort', order=['fn', 'position'])
position, fn = priority[0]
# sort priority queue using merge sort,the first element is picked for exploring.
priority = np.delete(priority, 0, 0)
puzzle, parent, gn, hn = state[position]
puzzle = np.array(puzzle)
blank = int(np.where(puzzle == 0)[0])
gn = gn + 1
c = 1
start_time = time.time()
for s in steps:
c = c + 1
if blank not in s['position']:
openstates = deepcopy(puzzle)
openstates[blank], openstates[blank + s['head']] = openstates[blank + s['head']], openstates[blank]
if ~(np.all(list(state['puzzle']) == openstates, 1)).any():
end_time = time.time()
if (( end_time - start_time ) > 2):
print(" The 8 puzzle is unsolvable \n")
break
hn = misplaced_tiles(coordinates(openstates), costg)
# generate and add new state in the list
q = np.array([(openstates, position, gn, hn)], dtstate)
state = np.append(state, q, 0)
# f(n) is the sum of cost to reach node
fn = gn + hn
q = np.array([(len(state) - 1, fn)], dtpriority)
priority = np.append(priority, q, 0)
if np.array_equal(openstates, goal):
print(' The 8 puzzle is solvable \n')
return state, len(priority)
return state, len(priority)
# initial state
puzzle = []
puzzle.append(2)
puzzle.append(8)
puzzle.append(3)
puzzle.append(1)
puzzle.append(6)
puzzle.append(4)
puzzle.append(7)
puzzle.append(0)
puzzle.append(5)
#goal state
goal = []
goal.append(1)
goal.append(2)
goal.append(3)
goal.append(8)
goal.append(0)
goal.append(4)
goal.append(7)
goal.append(6)
goal.append(5)
state, visited = evaluvate_misplaced(puzzle, goal)
bestpath = bestsolution(state)
print(str(bestpath).replace('[', ' ').replace(']', ''))
totalmoves = len(bestpath) - 1
print('\nSteps to reach goal:',totalmoves)
visit = len(state) - visited
print('Total nodes visited: ',visit, "\n")
输出:
Implementation
A*的可受理性
对于任何一个图，如果从起始状态到目标状态的最优路径存在，那么搜索算法是可接受的。我们前面已经看到，如果试探函数“h”低估了从当前状态到目标状态的实际值，那么它必然给出最优解，因此被称为容许函数。因此，我们可以说，在 h 是一个可接受的启发函数的情况下，A*总是以最优路径终止。
限制
用于计算 h 的启发式技术的精度对执行 A*搜索(n)的速度有很大的影响。因此，具有复杂性的问题。
摘要
在本文中，我们学习了一种被称为 A*算法的最佳算法。这种搜索算法有助于解决许多常见的寻路问题，如 N 皇后问题、0-1 背包问题、旅行推销员问题等。这种算法以解决复杂问题而闻名，它也用于网络路由协议。它也有助于定义其他算法。它在人工智能领域有着广泛的应用。
Python 中的绝对导入与相对导入
原文：https://www.askpython.com/python-modules/absolute-vs-relative-importing
你好，学习伙伴！今天我们将学习 Python 中绝对导入和相对导入的区别。
每次你需要一个直接的函数来实现我们程序中的任何东西，我们可以直接从正确的库中导入它！现在让我们学习 Python 编程中的绝对和相对导入。
什么是绝对进口？
当我们通过绝对导入来导入模块时，我们需要在 import关键字后面包含模块的完整路径。
完整路径包括主模块/库以及程序中使用的子模块或函数。
绝对进口的优势
- 这种方法清晰、直截了当且易于理解
- 即使 import 语句的当前位置在以后发生了变化，absolute import 命令仍然有效。
绝对进口的缺点
让我们假设，我们必须导入一个存在于根模块更深层的函数。此类模块的绝对导入命令如下所示:
from package_1.sub_package_1.sub_package2.sub_package3.module1 import req_function
如果所需的功能存在于更深的层中，那么就会变得非常混乱和复杂。这时候相对进口来拯救！
什么是相对导入？
在相对方法中，我们可以相对于某个包或子包的位置来导入一个函数，这是一种更好的导入模块和函数的方法。
我们有两种类型的相对导入方法，即implicit和explicit方法，但是隐式方法不再支持 Python3.x 版本。
相对导入方法如下所示:
from .sub_package_x.module_5 import req_function
最初的.考虑了所有之前的主机模块/库，我们不需要像绝对导入那样写整个东西。
相对进口的优势
- 重要陈述简短明了。
- 降低导入语句的复杂性
相对进口的缺点
- 这种方法可读性不强，而且程序员不知道许多根模块。
- 程序员不知道我们正在导入的函数的来源
结论——绝对进口与相对进口
现在您知道了绝对和相对导入方法之间的基本区别。
我建议你作为初学者选择绝对方法，随着你编码经验的增加，你可以开始使用相对方法。
理解 Python 中的抽象
原文：https://www.askpython.com/python/oops/abstraction-in-python
导言
在今天的教程中，我们将讨论 Python 中面向对象编程方法的抽象概念。
如果你是第一次接触 OOP ，我们强烈推荐你阅读我们的Python 中的面向对象编程文章。
基本上，抽象关注于对用户隐藏过程或方法的内部实现。这样，用户知道他在做什么，但不知道工作是如何完成的。
让我们更深入地挖掘这个主题，以发现它在现实生活和编程中的重要性。
Python 中的抽象是什么？
在面向对象编程中，继承、多态和封装齐头并进。但是抽象也是 OOP 的基本元素。
例如，人们并不认为汽车是由成千上万个独立零件组成的。相反，他们认为它是一个定义明确的对象，有自己独特的行为。这种抽象允许人们在不知道组成汽车的部件的复杂性的情况下使用汽车来驾驶。他们可以忽略发动机传动系统和制动系统如何工作的细节。相反，他们可以自由地将对象作为一个整体来使用。
管理抽象的一个强有力的方法是通过使用层次分类。这允许我们将复杂系统的语义分层，将它们分成更易管理的部分。从外面看，汽车是一个单一的物体。一旦进入车内，你会看到汽车由几个子系统组成:转向、刹车、音响系统、安全带等。反过来，这些子系统又由更小的单元组成。
关键是我们通过使用层次抽象来管理汽车(或任何其他复杂系统)的复杂性。
这也可以应用于使用 OOP 概念的计算机程序。这是面向对象编程的精髓。
Python 中的抽象类和方法
要声明一个抽象类，我们首先需要导入abc模块。让我们看一个例子。
from abc import ABC
class abs_class(ABC):
#abstract methods
这里，abs_class是抽象类，在其中可以定义抽象方法或任何其他种类的方法。
作为一个属性，抽象类可以有任意数量的抽象方法与任意数量的其他方法共存。例如，我们可以在下面看到。
from abc import ABC, abstractmethod
class abs_class(ABC):
#normal method
def method(self):
#method definition
@abstractmethod
def Abs_method(self):
#Abs_method definition
这里，method()是普通方法，而Abs_method()是从 abc 模块实现@abstractmethod的抽象方法。
Python 抽象示例
现在我们知道了抽象类和方法，让我们看一个例子，它解释了 Python 中的抽象。
from abc import ABC, abstractmethod
class Absclass(ABC):
def print(self,x):
print("Passed value: ", x)
@abstractmethod
def task(self):
print("We are inside Absclass task")
class test_class(Absclass):
def task(self):
print("We are inside test_class task")
class example_class(Absclass):
def task(self):
print("We are inside example_class task")
#object of test_class created
test_obj = test_class()
test_obj.task()
test_obj.print(100)
#object of example_class created
example_obj = example_class()
example_obj.task()
example_obj.print(200)
print("test_obj is instance of Absclass? ", isinstance(test_obj, Absclass))
print("example_obj is instance of Absclass? ", isinstance(example_obj, Absclass))
输出:
Python Abstraction Example
这里，
Absclass是从 ABC 模块的 ABC 类继承而来的抽象类。它包含一个用户可见的抽象方法task()和一个print()方法。从这个抽象类继承的另外两个类是test_class和example_class。两者都有自己的task()方法(抽象方法的扩展)。
在用户从 test_class 和 example_class 两个类中创建对象并为它们调用task()方法后，两个类中task()方法的隐藏定义开始发挥作用。这些定义对用户来说是隐藏的。来自抽象类Absclass的抽象方法task()实际上从未被调用过。
但是当对 test_obj 和 example_obj 都调用print()方法时，就会调用 Absclass 的print()方法，因为它不是抽象方法。
注意:我们不能创建抽象类的实例。它引发了一个Error。
结论
所以今天在本教程中，我们理解了 Python 中抽象的概念。
对于任何进一步的相关问题，请随意使用下面的评论。
参考
Python 中的 4 个激活函数要知道！
原文：https://www.askpython.com/python/examples/activation-functions-python
读者朋友们，你们好！在本文中，我们将详细关注 Python 激活函数。
所以，让我们开始吧！！🙂
什么是激活函数？
在神经网络和卷积模型深度学习的世界中，Python 在数据建模和分析方面一直发挥着重要作用。
激活函数是数学基础模型，使我们能够控制神经网络模型的输出。也就是说，它帮助我们分析和估计对模型的实现做出贡献的神经元是被保留还是被移除(激发)。
一些突出的激活功能–
了解了激活函数之后，现在让我们在下一节看看上面的激活函数。
1.ReLu 函数
ReLu 函数是一种激活函数，它使我们能够即兴创作神经网络的卷积图。它根据模型结果检测神经网络的状态。
ReLu 函数声明当输入为负时，返回零。否则对于非负输入，它返回 1。
举例:
这里，我们使用 Python 中的 max()函数实现了一个用户定义的函数来灌输 ReLu 条件。
def ReLu(ar):
return max(0.0,ar)
ar = 1.0
print(ReLu(ar))
ar1= -1.0
print(ReLu(ar1))
输出—
1.0
0.0
2.泄漏 ReLu 函数
梯度分数，即传递给 ReLu 函数的非零输入的导数值，被发现为零。这基本上说明了权重没有被学习函数正确地更新。
为了克服 ReLu 函数的梯度问题，我们引入了泄漏 ReLu 函数。
Leaky ReLu 函数在传递给函数的负(非零)输入权重上附加一个小的线性分量(常数值)。这样，这些非零输入权重的梯度分数变成了非零值。
举例:
def ReLu(x):
if x>0 :
return x
else :
return 0.001*x
x = -1.0
print(ReLu(x))
输出 t:
-0.001
3.Sigmoid 函数
sigmoid 激活函数简单地基于以下 Sigmoid 数学公式
Sigmoid formula
由于分母总是大于 1，因此该激活函数的输出总是在 0 和 1 之间。
举例:
import numpy as np
def sigmoid(num):
return 1/(1 + np.exp(-num))
num = -1.0
print(sigmoid(num))
输出:
0.2689414213699951
4.Softmax 函数
softmax 激活函数可以被称为一个数学模型，它接受一个数字数据变量向量作为输入，然后对数据进行归一化。
也就是说，将(缩放数据值)归一化为概率分布，其中每个数据值的概率与向量中存在的每个值的比例成比例。
因此，所有数据值都将在 0–1 的范围内。此外，所有数据值的总和将等于 1，因为它们被解释为概率。
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
更多与 Python 编程相关的帖子，请继续关注我们。
在那之前，学习愉快！！🙂
用 Python 添加换行符——6 种简单的方法！
原文：https://www.askpython.com/python/examples/add-a-newline-character-in-python
嘿伙计们！希望你们都过得好。在本文中，我们将揭示在 Python 中添加换行符(\n)到要打印的数据输出的不同方法。
所以，让我们开始吧！
技巧 1:在多行字符串中添加换行符
Python 多行字符串提供了一种以对齐方式表示多个字符串的有效方式。换行符(\n)可以添加到多行字符串中，如下所示
语法:
string = '''str1\nstr2....\nstrN'''
在多行字符串中，我们可以很容易地在想要显示在新行上的每个字符串前使用' \n '。
举例:
str='''Hello all!! \nI am Pythoner \nWelcome to the AskPython Tutorial'''
print(str)
输出:
Hello all!!
I am Pythoner
Welcome to the AskPython Tutorial
技术 2:在 Python 列表中添加新行
Python List 可以认为是一个动态数组，在动态运行时将异构元素存储到其中。
string.join()函数可用于在列表元素中添加新行，如下所示
语法:
'\n'.join(list)
举例:
lst = ['Python','Java','Kotlin','Cpp']
print("List before adding newline character to it:",lst)
lst = '\n'.join(lst)
print("List after adding newline character to it:\n",lst)
输出:
List before adding newline character to it: ['Python', 'Java', 'Kotlin', 'Cpp']
List after adding newline character to it:
Python
Java
Kotlin
Cpp
技术 3:在控制台上显示换行符
在最开始的阶段，了解控制台上功能的执行是很重要的。要在控制台上添加换行符，请使用以下代码
print("str1\nstr2")
举例:
Python newline with console
技巧 4:通过打印语句显示新行
换行符可以添加到 print()函数中，以便在新的一行上显示字符串，如下所示
语法:
print("str1\nstr2\n...\strN")
举例:
print("Hello Folks! Let us start learning.")
print("Statement after adding newline through print() function....")
print("Hello Folks!\nLet us start learning.")
输出:
Hello Folks! Let us start learning.
Statement after adding newline through print() function....
Hello Folks!
Let us start learning.
技巧 5:通过 Python f-string 添加一个换行符
Python f-string 也在控制台上以格式化的方式表示字符串语句。要通过 f 字符串添加换行符，请遵循以下语法:
newline = '\n'
string = f"str1{newline}str2"
举例:
newline = '\n'
str = f"Python{newline}Java{newline}Cpp"
print(str)
输出:
Python
Java
Cpp
技巧 6:向文件中写入新的一行
可以使用以下语法将换行符追加到 Python 文件中:
语法:
file_object.write("\n")
举例:
这里，我们使用了 Python.txt 文件，其中包含如下所示的预定义内容
Python Text-file
import os
file = "/Python.txt"
with open(file, 'a') as file:
file.write("\n")
输出:
如下所示，新的一行被添加到文件内容中。
Add newline To A Python File
结论
到此，我们就结束了这个话题。如果你遇到任何问题，请随时在下面评论。
在那之前，学习愉快！！
参考
如何在 Matplotlib 中添加网格线？
原文：https://www.askpython.com/python-modules/matplotlib/add-grid-lines
在本文中，我们将学习如何在 Matplotlib 绘图中添加网格线。Matplotlib 是一个 python 绘图库，它为创建科学绘图和图形提供了一个交互式环境。让我们直接进入主题。
向 Matplot 库图添加网格线的步骤
现在让我们回顾一下将网格线添加到 Matplotlib 图的步骤。
1.安装模块
Matplotlib–
pip install matplotlib
Pyplot –
pyplot 子模块包含 Matplotlib 的大部分功能
注意:编译器通常没有显示图形的能力，但是在 Python 中，我们可以通过添加几行代码使它们兼容:
import sys
import matplotlib
matplotlib.use('Agg')
# Matplotlib relies on a backend to render the plots and here ‘Agg’ is the default backend
import matplotlib.pyplot as pyt
# lines of code for plotting a graph
pyt.savefig(sys.stdout.buffer)
sys.stdout.flush()
# these two lines are used to avoid excess buffering and print the data without any delay and make sure the code works
示例:
import sys
import matplotlib
matplotlib.use('Agg')
# Matplotlib relies on a backend to render the plots and here ‘Agg’ is the default backend
import matplotlib.pyplot as pyt
import numpy as np
x = np.array([0, 10])
y = np.array([0, 200])
pyt.plot(x, y)
pyt.show()
pyt.savefig(sys.stdout.buffer)
sys.stdout.flush()
Plot A Graph
2.向地块添加网格线
我们可以在 Pyplot 中使用 grid() 函数来添加网格线。
示例:
x = np.array([0,10])
y = np.array([0,200])
pyt.title("Sales of Ice Cream")
# to represent the title on the plot
pyt.xlabel("Days") # to label the x-axis
pyt.ylabel("Customers") # to label the y-axis
pyt.plot(x, y)
pyt.grid()
pyt.show()
Plot
3.指定要显示的网格线
使用 grid()函数中的轴参数，我们可以指定显示哪些网格线。允许的值有:‘x’，‘y’，或‘两者’。但是缺省值是‘both ’,所以我们可以避免写它。
示例:
- 仅显示 x 轴网格线:
pyt.grid(axis = ‘y’)
Plot Only X Axis
- 仅显示 y 轴网格线:
pyt.grid(axis = ‘x’)
Plot Y Axis
4.设置网格的线条属性
我们可以用各种方式设置网格的属性，如颜色、样式等。
我们将样式定义为:color= 'specify_color '，linestyle='specify_linestyle '，linewidth= number，axis='specify_axis('x '，' y '或' both ')'
例如:
pyt.grid(color = 'red', linestyle = '--', linewidth = 0.75, axis='both')
Grid Property Changed Plot
结论
教程到此为止！希望你已经很好地学习了如何在 Python 中绘制网格线，以及使用 matplotlib 库可能得到的网格线的各种属性。请继续关注 Python，获取更多关于 Python 的教程。
如何给熊猫数据框添加一个新列？
原文：https://www.askpython.com/python-modules/pandas/add-new-column-to-dataframe
在本教程中，我们将讨论向 pandas 数据框添加新列的不同方法。
什么是熊猫数据框？
Pandas data frame 是一种二维异构数据结构，以表格形式存储数据，并带有标记索引，即行和列。
通常，当我们必须处理大型数据集时，会使用数据框，然后我们可以通过将该大型数据集加载到 pandas 数据框中来查看其摘要，并查看数据框的摘要。
在现实场景中，熊猫数据框是通过从现有的 CSV 文件、Excel 文件等加载数据集来创建的。
但是也可以从列表、字典、列表列表、字典列表、n 数组/列表字典等创建 pandas 数据帧。在我们开始讨论如何向现有数据框添加新列之前，我们需要一个 pandas 数据框。
安装和导入熊猫
我们需要 Python 的熊猫库来处理数据帧，所以我们必须首先安装熊猫库，然后将其导入 Python 程序。以下是安装和导入 pandas 的命令:
# Installing pandas Python library
pip install pandas
# Importing pandas into the program
import pandas as pd
在我们开始讨论如何向现有的 pandas 数据框添加新列之前，我们需要一个 pandas 数据框。
从列表字典创建数据框
# Creating a dictionary of lists
data = {'name': ['Sanjay', 'Ravi', 'Shreya', 'Abhishek', 'Shantanu'],
'roll': [55, 65, 75, 85, 95]}
# Creating a pandas data frame from the above data
df = pd.DataFrame(data)
print(df)
输出:
现在，让我们讨论向我们刚刚创建的现有数据框添加新列的不同方法。向现有数据框中添加新列有多种方法，但这里我们将只讨论三种主要的可靠且强大的方法。
使用数据帧索引添加新列
这是向现有 pandas 数据框添加新列的最简单方法，我们只需用新列的名称对现有数据框进行索引，并为相应的行分配一个要存储在列中的值列表:
# Adding a new column named 'cgpa' to the data frame
# Using DataFrame indexing
df['cgpa'] = [8.1, 9.3, 8.2, 7.9, 7.5]
print(df)
输出:
使用 assign() 向 pandas 数据框添加新列
这是使用 pandas 内置的assign()方法向现有数据框添加新列的第二种健壮方法。这将向现有数据框添加一个新列，然后返回一个包含添加列的新数据框。让我们看看使用它的 Python 代码:
# Adding a new column named 'address' to the data frame
# Using the assign() method
# And saving the new returned data frame
df2 = df.assign(address = ['Bihar', 'Bihar', 'Jharkhand', 'UP', 'UP'])
print(df2)
输出:
使用 insert()方法添加新列
这是向现有数据框添加新列的第三种有效方式。与以前向数据框添加列的方法不同，以前的方法只是将新列作为最后一列添加到数据框的末尾，而insert()方法允许我们在现有数据框中的任何指定位置添加新列。让我们看看使用它的 Python 代码:
# Adding a column named 'branch'to the data frame
# Using the insert() method
# First argument is the column position
# Second argument is the column name
# And third argument is the column value
df2.insert(3, 'branch', ['ECE', 'CSE', 'ECE', 'EE', 'ECE'])
print(df2)
输出:
在输出中，可以清楚地看到名为 分支 的新列被添加到 Python 代码中指定的第三列索引处。
结论
因此，在本教程中，我们学习了什么是 pandas 数据框架，如何从列表字典创建新的数据框架，以及向现有数据框架添加新列的三种可靠方法:DataFrame索引、assign()方法和insert()方法。
向熊猫数据框架添加行的 5 种简单方法
原文：https://www.askpython.com/python-modules/pandas/add-rows-to-dataframe
在本 Python 教程中，我们将讨论向 pandas DataFrame 对象添加或插入一行或多行的前五种方法。那么，我们开始讨论吧。
向 Pandas 数据帧添加行的方法
让我们首先创建一个示例 pandas DataFrame 对象，然后我们将使用以下方法向它添加一行或多行。
# Import pandas Python module
import pandas as pd
# Create a sample pandas DataFrame object
df = pd.DataFrame({'RegNo': [111, 112, 113, 114, 115],
'Name': ['Gautam', 'Tanya', 'Rashmi', 'Kirti', 'Ravi'],
'CGPA': [8.85, 9.03, 7.85, 8.85, 9.45],
'Dept': ['ECE', 'ICE', 'IT', 'CSE', 'CHE'],
'City': ['Jalandhar','Ranchi','Patna','Patiala','Rajgir']})
# Print the created pandas DataFrame
print('Sample pandas DataFrame:\n')
print(df)
输出:
Sample pandas DataFrame:
RegNo Name CGPA Dept City
0 111 Gautam 8.85 ECE Jalandhar
1 112 Tanya 9.03 ICE Ranchi
2 113 Rashmi 7.85 IT Patna
3 114 Kirti 8.85 CSE Patiala
4 115 Ravi 9.45 CHE Rajgir
方法 1
将 pandas 系列对象作为一行添加到现有的 pandas DataFrame 对象中。
# Create a pandas Series object with all the column values passed as a Python list
s_row = pd.Series([116,'Sanjay',8.15,'ECE','Biharsharif'], index=df.columns)
# Append the above pandas Series object as a row to the existing pandas DataFrame
# Using the DataFrame.append() function
df = df.append(s_row,ignore_index=True)
# Print the modified pandas DataFrame object after addition of a row
print('Modified Sample pandas DataFrame:\n')
print(df)
输出:
Modified Sample pandas DataFrame:
RegNo Name CGPA Dept City
0 111 Gautam 8.85 ECE Jalandhar
1 112 Tanya 9.03 ICE Ranchi
2 113 Rashmi 7.85 IT Patna
3 114 Kirti 8.85 CSE Patiala
4 115 Ravi 9.45 CHE Rajgir
5 116 Sanjay 8.15 ECE Biharsharif
方法 2
将一个 Python 字典作为一行添加到现有的 pandas DataFrame 对象中。
# Create a Python dictionary object with all the column values
d_row = {'RegNo':117,'Name':"Sarthak",'CGPA':8.88,'Dept':"ECE",'City':"Allahabad"}
# Append the above Python dictionary object as a row to the existing pandas DataFrame
# Using the DataFrame.append() function
df = df.append(d_row,ignore_index=True)
# Print the modified pandas DataFrame object after addition of a row
print('Modified Sample pandas DataFrame:\n')
print(df)
输出:
Modified Sample pandas DataFrame:
RegNo Name CGPA Dept City
0 111 Gautam 8.85 ECE Jalandhar
1 112 Tanya 9.03 ICE Ranchi
2 113 Rashmi 7.85 IT Patna
3 114 Kirti 8.85 CSE Patiala
4 115 Ravi 9.45 CHE Rajgir
5 116 Sanjay 8.15 ECE Biharsharif
6 117 Sarthak 8.88 ECE Allahabad
注意:在传递 Python 字典或熊猫系列时，请将DataFrame.append()函数的ignore_index参数设置为True，否则会抛出错误。
方法 3
使用DataFrame.loc[]方法将 Python 列表对象作为一行添加到现有的 pandas DataFrame 对象中。
# Create a Python list object with all the column values
l_row = [118,"Kanika",7.88,"EE","Varanasi"]
# Append the above Python list object as a row to the existing pandas DataFrame
# Using the DataFrame.loc[]
df.loc[7] = l_row
# Print the modified pandas DataFrame object after addition of a row
print('Modified Sample pandas DataFrame:\n')
print(df)
输出:
Modified Sample pandas DataFrame:
RegNo Name CGPA Dept City
0 111 Gautam 8.85 ECE Jalandhar
1 112 Tanya 9.03 ICE Ranchi
2 113 Rashmi 7.85 IT Patna
3 114 Kirti 8.85 CSE Patiala
4 115 Ravi 9.45 CHE Rajgir
5 116 Sanjay 8.15 ECE Biharsharif
6 117 Sarthak 8.88 ECE Allahabad
7 118 Kanika 7.88 EE Varanasi
方法 4
使用DataFrame.append()函数将一个 pandas DataFrame 对象的行添加到另一个 pandas DataFrame 对象中。
# Create a new pandas DataFrame object
df2 = pd.DataFrame({'RegNo': [119, 120, 121],
'Name': ['Gaurav', 'Thaman', 'Radha'],
'CGPA': [8.85, 9.03, 7.85],
'Dept': ['ECE', 'ICE', 'IT'],
'City': ['Jalandhar','Ranchi','Patna']})
# Print the newly created pandas DataFrame object
print('New pandas DataFrame:\n')
print(df2)
# Append the rows of the above pandas DataFrame to the existing pandas DataFrame
# Using the DataFrame.append()
df = df.append(df2,ignore_index=True)
# Print the modified pandas DataFrame object after addition of rows
print('\nModified Sample pandas DataFrame:\n')
print(df)
输出:
New pandas DataFrame:
RegNo Name CGPA Dept City
0 119 Gaurav 8.85 ECE Jalandhar
1 120 Thaman 9.03 ICE Ranchi
2 121 Radha 7.85 IT Patna
Modified Sample pandas DataFrame:
RegNo Name CGPA Dept City
0 111 Gautam 8.85 ECE Jalandhar
1 112 Tanya 9.03 ICE Ranchi
2 113 Rashmi 7.85 IT Patna
3 114 Kirti 8.85 CSE Patiala
4 115 Ravi 9.45 CHE Rajgir
5 116 Sanjay 8.15 ECE Biharsharif
6 116 Sanjay 8.15 ECE Biharsharif
7 118 Kanika 7.88 EE Varanasi
8 119 Gaurav 8.85 ECE Jalandhar
9 120 Thaman 9.03 ICE Ranchi
10 121 Radha 7.85 IT Patna
方法 5
使用DataFrame.iloc[]方法在现有 pandas DataFrame 对象的特定索引位置添加一行。
# Create a Python list object with all the column values
i_row = [122,"Zahir",6.88,"ME","Kolkata"]
# Append the above Python list object as a row to the existing pandas DataFrame
# At index 2 using the DataFrame.iloc[]
df.iloc[2] = i_row
# Print the modified pandas DataFrame object after addition of a row
print('Modified Sample pandas DataFrame:\n')
print(df)
输出:
Modified Sample pandas DataFrame:
RegNo Name CGPA Dept City
0 111 Gautam 8.85 ECE Jalandhar
1 112 Tanya 9.03 ICE Ranchi
2 122 Zahir 6.88 ME Kolkata
3 114 Kirti 8.85 CSE Patiala
4 115 Ravi 9.45 CHE Rajgir
5 116 Sanjay 8.15 ECE Biharsharif
6 116 Sanjay 8.15 ECE Biharsharif
7 118 Kanika 7.88 EE Varanasi
8 119 Gaurav 8.85 ECE Jalandhar
9 120 Thaman 9.03 ICE Ranchi
10 121 Radha 7.85 IT Patna
注意:使用DataFrame.iloc[]方法时请小心，因为它会用新行替换索引位置的现有行。
结论
在本教程中，我们已经学习了在现有的 pandas DataFrame 对象中添加或插入一行或多行的前五种方法。希望你已经很好地理解了上面讨论的东西，并准备在自己的数据分析项目中使用这些方法。感谢阅读！请继续关注我们，获取更多关于 Python 编程的精彩学习资源。
如何在 Python 中执行加法？
原文：https://www.askpython.com/python/examples/addition-in-python
在这篇文章中，我们将讨论一个最基本的话题。如果你是初学者，这对你有好处。但是如果你已经用 Python 写了代码，跳过这一步。
Python 中用户输入的两个数相加
我们将使用 input()方法接受用户输入，然后使用这些数字在 Python 中执行加法。python 中两个数相加的基本代码是:
def adding(x , y):
return x + y
a = int(input("Enter first number :" ))
b = int(input("Enter second number :"))
sum = adding(a , b)
print("addition of {} and {} is {}".format(a,b,sum))
输出是:
Enter first number : 6
Enter second number : 5
Addition of 6 and 5 is 11
在上面的代码中，我们使用 int()方法将字符串输入转换为整数，从而将输入类型转换为 int。
对列表中的元素进行加法运算
def add_list(l1) :
res = 0
for val in l1 :
res = res + val
return res
list = [1,3,5,7,9]
ans = add_list(list)
print("The sum of all elements within the given list is {}".format(ans))
这段代码的输出是:
The sum of all elements in the list is 25
在上面的代码中，我们定义了一个函数，在这个函数中，我们使用 for 循环来遍历列表中的所有元素，并在每次迭代后更新 res 的值。将我们的列表作为参数传递给 add_list 函数会给出我们的最终输出。
这是 python 中加法的基础。
高级 Python 概念
原文：https://www.askpython.com/python/advanced-python-concepts
今天让我们来看看一些更高级的 Python 概念。虽然我们已经在之前的教程中讨论了其中的一些概念，但本页将为您提供 Python 学习中常见高级概念的快速指南。
高级 Python 概念的简要列表
事不宜迟，让我们继续我们的第一个先进概念。
1.λ函数
在 Python 中， lambda 函数是一个声明为匿名的单行函数，即声明时没有名字，它可能有许多参数，但只有一个表达式。
语法:
lambda arguments: expression
- 如下面的语法所示，lambda 函数是通过使用关键字“lambda”来声明的。
- 然后我们写一个参数列表，lambda 函数可以带任意数量的参数，但不能是零。在冒号之后，我们编写一个表达式，将这些参数应用于任何实际操作。从语法上讲，lambda 函数仅限于单个表达式，即它只能包含一个表达式，不能超过一个。
举例:
remainder = lambda number: number%2
print (remainder (25))
说明:
在上面的代码中，lambda num: number%2是 lambda 函数。数字是参数，而数字% 2 是被计算并返回结果的表达式。
该表达式推导出输入 2 的输入模数。我们给 25 作为参数，除以 2，我们得到剩下的 1。
您应该注意到，上面脚本中的 lambda 函数没有被赋予任何名称。它只是将给定的项返回给标识符的其余部分。
然而，即使它是未知的，我们也有可能称它为正常函数。
这是 lambda 函数的另一个例子:
addition = lambda a, b: a+b
print (addition (19,55))
输出: 74
2.Python 中的理解
Python 中理解力为我们提供了一种压缩但简洁的方式来创造新的序列(如列表、集合、字典等)。)
Python 支持 4 种理解类型
- 列表理解
- 词典理解
- 一组
- 发电机
列表理解
列表是 Python 中基本的数据类型之一。每当您遇到一个变量名后跟一个方括号[ ]，或列表生成器，它是一个可以包含多个项目的列表，使其成为一种集成的数据类型。同样，宣布一个新的列表，然后向其中添加一个或多个项目也是一个好主意。
示例:
even_numbers = [2, 4, 6, 8, 10]
print (even_numbers)
输出:
[2,4,6,8,10]
什么是列表理解？
简单来说，列表理解就是从现有列表中构建新列表的过程。或者，你可以说这是 Python 独特的方式，将循环的添加到列表中。事实上，列表理解比传统列表有很多优势。
首先，代码不超过一行，易于声明和阅读。使用理解比使用 for 循环更便于理解列表。最后，这也是创建一个新的、更动态的列表的简单、快速和准确的方法。
语法:
[expression for item in list]
运筹学
[expression for item in list if conditional]
list comprehension 的语法与其他语法有点不同，因为表达式是在循环之前提到的，但这就是它的工作方式。
举例:
n_letter = [letter for letter in 'encyclopedia']
print(n_letter)
输出:
['e '，' n '，' c '，' y '，' c '，' l '，' o '，' p '，' e '，' d '，' I '，' a']
词典理解
字典是一种称为关联数组的数据结构的 Python 实现。字典包含一组键值。每对密钥将密钥设置为其对应的值。您可以通过用大括号({})括起逗号分隔的键值对列表来定义字典。冒号(:)将每个键与其关联的值分隔开:
举例:
thisdict = {"name": "Ford","age": 34, "last_name": "Mustang"}
print(thisdict)
输出:
{'name': 'Ford', 'age': 34, 'last_name': 'Mustang'}
什么是词典理解？
字典理解类似于列表理解，但需要定义一个关键字:
语法:
output_dict = {key:value for (key, value) in iterable if (key, value satisfy this condition)}
举例:
在这个例子中，我们将使用一个常规函数执行与理解相同的功能。
sq_dict = dict()
for number in range(1, 9):
sq_dict[number] = number*number
print(sq_dict)
现在，让我们使用字典理解来尝试相同的功能
square_dict = {num: num*num for num in range(1, 9)}
print(square_dict)
输出:
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64}
集合理解
集合用于在单个变量中存储多个项目。集合是 Python 内置的用于存储数据集合的 4 种数据类型之一。其他 3 个列表、元组和字典，都有不同的属性和用途。
举例:
brand_set = {"Mustang", "Ferrari", "Ford","Aston Martin"}
print(brand_set)
输出:
{'Aston Martin', 'Mustang', 'Ford', 'Ferrari'}
什么是集合理解？
集合理解类似于列表理解。它们之间唯一的区别是集合理解使用了花括号{}。我们看下面这个例子来理解集合理解。
语法:
{expr for variable in iterable}
运筹学
{expression for variable in iterable if condition}
举例:
s = [1,2,3,4,5,4,6,6,7,8,8,]
using_comp = {var for var in s if var % 2 ==0}
print(using_comp)
输出:
{8, 2, 4, 6}
生成器理解
一个生成器是一种特殊类型的迭代器，它维护着关于如何分别产生它的单个组件的指令，以及它的当前复制状态。它只在迭代请求时产生每个成员，一次一个。
语法:
(expression for var in iterable if condition)
什么是生成器理解？
生成器理解和列表理解非常相似。两者的一个区别是，生成器理解用圆括号，列表理解用方括号。
它们之间的主要区别是生成器不为整个列表设置内存。相反，它们单独产生每个值，这就是为什么它们在内存中工作得如此之好。
举例:
input_list = [1, 2, 3, 4, 4, 5, 6, 7, 7]
output_gen = (var for var in input_list if var % 2 == 0)
print("Output values using generator comprehensions:", end = ' ')
for var in output_gen:
print(var, end = ' ')
输出:
Output values using generator comprehensions: 2 4 4 6
3.装饰函数
装饰器是强大而足智多谋的工具，允许程序员在不影响基本功能的情况下改变功能的性能。
你可以想到其他活动，比如普通甜甜圈；在甜甜圈上涂涂料的装饰工艺。不管你怎么装饰它们，它们还是甜甜圈。
换句话说，decorators 允许程序员包装另一个函数，以便在不改变其内部算法的情况下提高包装函数的性能。
语法:
@dec2
@dec1
def func (arg1, arg2, ...):
pass
4.哈希能力
Hashability 是 Python objects 的一个特性，它告诉我们一个对象是否有哈希值。如果一个项目有一个散列值，它可以被用作一个字典键或一个预置项目。
如果一个对象在其整个生命周期中有一个固定的哈希值，那么它就是可哈希的。Python 有一个内置的 hash 方法(__hash __())，可以和其他对象进行比较。
比较需要 __eq __()或 __cmp __()方法，如果可散列项相等，则它们具有相同的散列值。
举例:
s1 = (2,4,6,8,10)
s2 = (1,3,5,7,9)
#shows the id of the object
print(id(s1))
print(id(s2))
输出:
1898434378944
1898436290656
在上面的例子中，两个项目是不同的，因为不可转换类型的哈希值依赖于存储的数据，而不是它们的 id。
使用散列的最大优点是从字典中获取条目的快速搜索时间(例如，O (1)复数时间)。类似地，检查某个东西是否是一个集合需要正常的时间。
换句话说，使用散列作为启动过程为各种标准操作提供了高性能，例如对象检测、对象安装和对象测试，使用了在引擎盖下具有散列表的头部。
结论
在本文中，我们回顾了 Python 中的五个高级概念。这里快速回顾一下最重要的信息。
- Lambda activities :使用 Lambda 函数执行一个简单的任务，通常是在另一个函数调用中，比如 filter()或 max()。
- 理解:这是一种简单有效的方法，可以从系统中制作列表、字典和收藏。
- 生成器:延迟求值的迭代器，仅在被请求时才提供条目，因此，它们在内存中工作得很好。当按顺序处理大数据时，应该使用它们。
- decorator:当你想寻找其他非算法变化和当前函数时，decorator 很有用。另外，装饰者可以重复使用。一旦定义好了，它们就可以随心所欲地修饰许多功能。
- Hashability : Strength 是 Python 对象的必备组件，可以作为字典键或者 set 对象使用。他们提供了一种方法来恢复和安装一些有效的东西，以及成员测试。
这是关于 python 中一些高级主题的简单介绍。
希望这有所帮助！
Python Tkinter: GUI 年龄计算器
原文：https://www.askpython.com/python-modules/tkinter/age-calculator
你好，初学者！今天我们将使用 Python Tkinter 构建一个 GUI 应用程序——年龄计算器。
让我们开始吧！
应用程序的名称说明了应用程序将要做的一切，所以让我们开始构建应用程序。
设计年龄计算器界面
任何项目的第一步都是设计应用程序窗口。设计包括两个步骤，即:
- 创建自定义窗口
- 向窗口应用程序添加元素
创建自定义窗口
创建空的自定义窗口。我们必须导入tkinter模块并创建一个窗口对象。然后我们添加窗口应用程序的背景颜色和标题。
我们还将可调整大小的功能设置为 False 以确保尺寸保持不变。相同的代码如下所示。
import tkinter as tk
window = tk.Tk()
window.geometry("400x300")
window.config(bg="#F7DC6F")
window.resizable(width=False,height=False)
window.title('Age Calculator!')
向窗口添加所有必需的元素
下一步包括在我们的应用程序中添加所有的标签、输入框、按钮和文本框。
1.标签
我们将使用多个标签，每个标签将服务于不同的目的。我们有介绍信息的标签，询问用户出生日期的输入框的标签。
2.输入框
我们将使用三个输入框来输入用户的出生日期。一个是日期，一个是月份，最后一个是出生年份。
3.小跟班
在我们的应用程序中，我们将使用两个按钮，一个用于计算年龄，另一个用于退出应用程序。
4.文本框
我们将只使用一个文本框来显示计算出的年龄。
整个设计代码如下所示。我们将根据自己的喜好定制元素。如果你愿意，你可以改变它。
l1 = tk.Label(window,text="The Age Calculator!",font=("Arial", 20),fg="black",bg="#F7DC6F")
l2 = tk.Label(window,font=("Arial",12),text="Enter your birthday which includes the day-month-year.",fg="black",bg="#F7DC6F")
l_d=tk.Label(window,text="Date: ",font=('Arial',12,"bold"),fg="darkgreen",bg="#F7DC6F")
l_m=tk.Label(window,text="Month: ",font=('Arial',12,"bold"),fg="darkgreen",bg="#F7DC6F")
l_y=tk.Label(window,text="Year: ",font=('Arial',12,"bold"),fg="darkgreen",bg="#F7DC6F")
e1=tk.Entry(window,width=5)
e2=tk.Entry(window,width=5)
e3=tk.Entry(window,width=5)
b1=tk.Button(window,text="Calculate Age!",font=("Arial",13),command=get_age)
l3 = tk.Label(window,text="The Calculated Age is: ",font=('Arial',12,"bold"),fg="darkgreen",bg="#F7DC6F")
t1=tk.Text(window,width=5,height=0,state="disabled")
b2=tk.Button(window,text="Exit Application!",font=("Arial",13),command=exit)
将元素放置在屏幕上
为了在屏幕上放置元素，我们使用了place函数，该函数需要元素的 x 和 y 坐标来将项目放置在正确的位置。
放置元素的代码如下所示:
l1.place(x=70,y=5)
l2.place(x=10,y=40)
l_d.place(x=100,y=70)
l_m.place(x=100,y=95)
l_y.place(x=100,y=120)
e1.place(x=180,y=70)
e2.place(x=180,y=95)
e3.place(x=180,y=120)
b1.place(x=100,y=150)
l3.place(x=50,y=200)
t1.place(x=240,y=203)
b2.place(x=100,y=230)
Tkinter 中年龄计算器的界面
应用程序的最终设计看起来像下面显示的窗口。
Initial State Age Calculator
向按钮添加功能
1.计算年龄按钮
为了计算年龄，我们首先必须从三个输入框中获得三个输入(数据-月-年)。现在，下一步涉及计算出生日期和当前日期之间的差异。
为了获得当前日期，我们从datetime模块导入date函数。我们还创建了一个存储今天整个日期的对象。相同的代码如下所示:
from datetime import date
today = date.today()
现在我们创建一个计算年龄的函数，并连接到计算年龄按钮。该函数获取三个条目，并找到年龄(当前和出生日期之间的差异)
在清除文本框中先前的信息后，计算的年龄将被插入到文本框中。相同的代码如下所示:
def get_age():
d= int(e1.get())
m=int(e2.get())
y=int(e3.get())
age = today.year-y-((today.month, today.day)<(m,d))
t1.config(state='normal')
t1.delete('1.0', tk.END)
t1.insert(tk.END,age)
t1.config(state='disabled')
突出显示的行是计算年龄的代码的主要语句。
2.退出应用程序按钮
对于退出应用程序按钮，我们简单地创建一个破坏窗口的函数，然后将commad属性添加到按钮声明中。
退出函数的代码如下所示:
def exit():
window.destroy()
Python 中年龄计算器的完整代码
下面提到了整个代码:
from datetime import date
today = date.today()
def exit():
window.destroy()
def get_age():
d= int(e1.get())
m=int(e2.get())
y=int(e3.get())
age =today.year-y-((today.month, today.day)<(m,d))
t1.config(state='normal')
t1.delete('1.0', tk.END)
t1.insert(tk.END,age)
t1.config(state='disabled')
import tkinter as tk
window = tk.Tk()
window.geometry("400x300")
window.config(bg="#F7DC6F")
window.resizable(width=False,height=False)
window.title('Age Calculator!')
l1 = tk.Label(window,text="The Age Calculator!",font=("Arial", 20),fg="black",bg="#F7DC6F")
l2 = tk.Label(window,font=("Arial",12),text="Enter your birthday which includes the day-month-year.",fg="black",bg="#F7DC6F")
l_d=tk.Label(window,text="Date: ",font=('Arial',12,"bold"),fg="darkgreen",bg="#F7DC6F")
l_m=tk.Label(window,text="Month: ",font=('Arial',12,"bold"),fg="darkgreen",bg="#F7DC6F")
l_y=tk.Label(window,text="Year: ",font=('Arial',12,"bold"),fg="darkgreen",bg="#F7DC6F")
e1=tk.Entry(window,width=5)
e2=tk.Entry(window,width=5)
e3=tk.Entry(window,width=5)
b1=tk.Button(window,text="Calculate Age!",font=("Arial",13),command=get_age)
l3 = tk.Label(window,text="The Calculated Age is: ",font=('Arial',12,"bold"),fg="darkgreen",bg="#F7DC6F")
t1=tk.Text(window,width=5,height=0,state="disabled")
b2=tk.Button(window,text="Exit Application!",font=("Arial",13),command=exit)
l1.place(x=70,y=5)
l2.place(x=10,y=40)
l_d.place(x=100,y=70)
l_m.place(x=100,y=95)
l_y.place(x=100,y=120)
e1.place(x=180,y=70)
e2.place(x=180,y=95)
e3.place(x=180,y=120)
b1.place(x=100,y=150)
l3.place(x=50,y=200)
t1.place(x=240,y=203)
b2.place(x=100,y=230)
window.mainloop()
输出:
现在我们已经完成了编码部分。让我们运行应用程序吧！它工作得很好，同样的情况可以在下面的输出中看到。
Output1 Age Calculator
Output2 Age Calculator
结论
恭喜你！今天你学会了如何建立你的年龄计算器！希望你玩得开心！
感谢您的阅读！
为什么交易员需要开始学习 Python？
原文：https://www.askpython.com/python/algorithmic-trading-with-python
作为交易者，你的主要目标可能是尽可能多的赚钱，尽可能快。手动交易很难实现这个目标。
这是因为手动下单会带来许多风险，包括基于情绪和心理偏见的错误，在价格不利时下单，以及错误的手动订单输入(如果这是一个大错误，可能会很糟糕)。
此外，人类无法与当今最先进的计算机程序的速度和处理能力相媲美，这些程序主宰着金融市场。这些计算机程序可以分析大量数据，比任何人类交易者更快地采取行动。
如果你想在当今高度竞争和技术驱动的金融市场中取得成功，你需要两样东西:算法交易和 Python ，一种用于算法交易的计算机编程语言。
但是算法交易和 Python 到底是什么，这两个工具如何帮助你在当今高度复杂的金融市场中取得成功？
这就是我们今天要学习的内容，所以请继续阅读，了解更多。
什么是算法交易？
算法交易也被称为算法交易、自动交易和黑箱交易，算法交易使用一个遵循预定义指令集(即算法)的计算机程序。预定义的指令集可以基于数学模型或 KPI，如时间、价格和数量。
世界各大银行和华尔街机构使用算法交易来交易传统资产(如股票)和较新的市场(如加密货币)。
交易者、投资者和程序员编写代码，一旦满足某些条件，这些代码就会执行交易。当正确执行时，交易算法可以以人工交易者无法比拟的速度和频率产生利润。
算法交易的一些优势包括:
- 实施自动化、基于规则的决策制定(消除了源于人为偏见的风险)。
- 即时准确地进行交易(这更有可能产生最佳和有利可图的结果)。
- 同时自动检查各种市场条件。
- 使用历史和实时数据进行回溯测试，以确定交易策略的可行性。
要更深入地了解算法交易及其利弊，请查看 Investopedia 的这篇好文章。
关于算法交易的最佳书籍，请看 Trality 的这个伟大列表。
Python 是什么？
Python 是一种开源的计算机编程语言，广泛应用于各种领域，包括算法交易。近年来，它已经成为算法交易的首选，因为它的所有软件包都可以免费用于商业用途。
它还被广泛应用于金融科技的其他领域，如数据分析、加密货币市场、风险管理和银行服务。
投资者和机构每天都在使用 Python 来执行各种功能，包括定量研究。它也用于原型，测试和执行交易算法。
Python 允许用户使用科学库(如 Pandas、NumPy、Scikit-learn 和 Zipline)构建复杂的统计模型。这些库的更新在开发人员社区中是经常发生的，这意味着它们每天都在改进。
虽然还有其他编程语言，但 Python 是金融科技领域最受欢迎的，尤其是在量化交易领域。由于如此多的算法交易都是使用 Python 进行的，如果你使用这种语言，合作、交换代码和众包也更容易。
似乎这些证明还不够有力，Python 也被一些世界上最大的公司使用，包括谷歌、脸书、Instagram、Stripe 和 Dropbox。
为什么要用 Python 做算法交易？
以下是交易者应该考虑学习 Python 的主要原因:
- 易用性和可访问性
Python 代码以其可读性和可访问性而闻名，这些品质使它成为那些从未使用过算法交易软件的人的理想选择。
由于其高度功能化的编程方法，在 Python 上编写和评估 algo 交易结构以及构建动态 Python 交易机器人通常要容易得多。
- 众多支持库
与其他编码语言不同，由于前面提到的扩展支持库，使用 Python 进行交易需要的代码行更少。这也意味着最常用的编程任务已经被脚本化，限制了需要编写的代码长度。
- 增加交易组合的可扩展性
并行化和 Python 强大的计算能力赋予了您的交易组合可伸缩性。与其他语言相比，给 Python 添加新模块并使其具有可扩展性也更容易。由于现有的模块，交易者可以更容易地在不同的程序之间共享功能。
- 调试无忧
Python 中的调试既全面又彻底，因为允许对代码和数据进行实时修改。这加快了调试过程，因为出现的是单个错误，而不是多个错误，并且可以解决。
使用 Python 的缺点
虽然使用 Python 进行在线交易有明显的好处，但也有一些缺点:
- 变量存储不必要的数据
因为在 Python 中每个变量都被认为是一个对象，所以每个变量都会存储不必要的数据，比如值、大小和引用指针。如果不同变量的内存管理效率不高，这可能会导致严重的性能瓶颈和内存泄漏。
- 移动计算效率更低
虽然 Python 非常适合桌面和服务器应用程序，但它的移动计算效率较低。Python 通常被视为移动计算的弱语言，这就是为什么很少有移动应用程序是用它构建的。
Python 与其他编程语言相比如何？
与其他主要的编程语言(如 C++ 和 R)相比，Python 被认为更容易掌握和操作。然而，注意到所有这些编程语言都有独特的特性和它们自己独特的优点和缺点是有帮助的。因此，在为您的应用程序选择正确的语言时，您需要考虑这些因素。
Python 与 C++
C++以难学而闻名，这使得 Python 成为想快速学习如何开发动态交易算法的菜鸟交易者的明显选择。另一方面，Python 比 C++慢，所以如果速度是你交易策略的重要部分，那么你可能会选择 C++。
另一个要考虑的主要因素是交易频率。通常，如果交易频率少于一秒，那么 C++将是更好的选择。但是在为回溯测试和研究环境选择语言时，最终的选择应该基于可用的库以及算法的需求。
Python 对 R
就在几年前，许多交易者认为 Python 和 R 不相上下，但从那以后，Python 几乎在各个方面都超过了它的对手。Python 现在拥有对现代软件开发工具和更好的包库的高级支持。
遗言
虽然为你的网上交易选择编程语言有很多因素，但 Python 通常是希望学习一门既容易理解又容易操作的语言的新手的最佳选择。这反过来会帮助你原型化、测试和执行更好的加密交易机器人和交易算法。
Python 编程中的 all()方法
原文：https://www.askpython.com/python/built-in-methods/all-method-in-python
Python 附带了许多有趣的预定义方法。其中之一就是 Python 中的all()方法。这个方法被广泛用于检查一个可迭代 Python 对象的所有元素是否都是真值。因此，让我们学习更多关于all()方法的知识，并看看如何在我们的代码中加入。
Python 中 all()方法的工作原理
理论上，Python 中的 all()方法检查一个 Python iterable 对象的所有元素，如列表、字典、数组等。T4 是真的还是假的。如果所有的元素都是可迭代的(或者对象是空的)，那么它返回True，如果至少有一个元素不是，那么它返回False。
你有没有注意到我们使用了术语【真实】而不是【真实】？这是因为这两个术语有不同的含义。
在 Python 中，all()检查所有元素，看bool(element)是否为真。这样，我们可以推断，这里的真与真是不同的。
all()函数用法和示例
现在让我们看一个例子，它可以说明 Python 中的all()方法的工作原理。
#python all() example
print("all() in Python:")
#Defining different type of variables
list1=['J','o','u','r','n','a','l','D','e','v']
list2=[0,1,1,1,0]
dictionary1={1:"True",2:"False"}
dictionary2={0:"False",1:"True"}
tpl1=(0,1,2,3)
#Evaluating the variables with the all() method.
print("list1=['J','o','u','r','n','a','l','D','e','v']:",all(list1))
print("list2=[0,1,1,1,0]:",all(list2))
print("tpl1=(0,1,2,3):",all(tpl1))
print("dictionary1:",all(dictionary1))
print("dictionary2:",all(dictionary2))
# Testing all() method's evaluation of empty objects
print("Now for empty objects:")
dict_empt={}
list_empt=[]
print("dict_empt:",all(list_empt))
print("list_empt:",all(dict_empt))
输出:
all() Output
- 对于列表 1 ，
all()返回True，因为它的所有元素都是非 falsy， - 然而，对于列表 2 ，我们得到了
False，因为它包含了计算结果为假的数字 0。 - 对于元组 tpl1 ，该方法也返回
False，因为第一个元素是 0 ，其评估为假。 - 对于字典 1 ，我们得到
True作为输出，因为没有一个键是 0 或假。出于演示的目的，我们添加了计算结果为 TRUE 的“false”字符串，因为 FALSE 字符串不是布尔 False。 - 我们为字典 2 得到一个
False，因为它的一个键是 0。 - 对于任何类型的空可迭代对象，无论是列表还是字典，
all()方法返回True。
参考
- https://stack overflow . com/questions/35685768/how-the-all-function-in-python-work
- https://docs.python.org/2/library/functions.html#all
Python 中的字谜简介
原文：https://www.askpython.com/python/examples/anagrams-in-python
你好。今天我们将学习如何在 Python 中实现一个有趣的主题，叫做字谜。让我们先了解一下什么是变位词。
什么是变位词？
字谜是单词和句子背后有趣的悬念。如果一个特定单词或句子的所有字母经过重新排列后都可以形成其他单词或句子，那么它们彼此都是变位词。
一些变位词的例子有“sram”和“mars”，“top”和“otp”等等。但是现在下一个问题是为什么要学习字谜呢？
字谜对作家真的很有帮助，因为它们给写作增加了一层额外的悬念，而且它们是一种聪明有趣的方式，让写作变得有趣。使用变位词真的很有趣。
在 Python 中检查变位词
让我们看看如何使用简单的算法识别 Python 中的变位词。
检验两个单词是否为变位词的算法
下面的步骤显示了如何检查两个字符串是否是变位词。
STEP 1: Take input of the 1st string
STEP 2: Take input of the 2nd string
STEP 3: Sort all the letters of both the strings
STEP 4: Check if after sorting both the strings match.
if they match: Anagram
if not: Not an Anagram
检查两个字符串是否是变位词的程序
s1 = input()
s2 = input()
s1 = sorted(s1)
s2 = sorted(s2)
if(s1==s2):
print("Anagram")
else:
print("Not an Anagram")
一些示例字符串的结果如下所示。首先检查的琴弦是tac和cat，以及tic和cat。我们可以清楚地看到，第一对是变位词，而第二对不是变位词。
tac
cat
Anagram
tic
cat
Not an Anagram
结论
恭喜你！我们学习了字谜以及如何在 Python 编程语言中实现它们。我希望现在你对字谜很清楚，并能自己实现它！
编码快乐！感谢您的阅读！
用 Python 分析 Cars.csv 文件——完整指南
原文：https://www.askpython.com/python/examples/analyzing-cars-dataset-in-python
在本教程中，让我们了解如何使用 Python 探索 cars.csv 数据集。我们将首先加载数据集，然后处理数据。我们还将可视化数据集，当最终数据集准备好时，同一数据集可用于开发各种模型。
在 Python 中分析 Cars.csv 数据集的步骤
我们将使用熊猫和熊猫进行分析。我们还将使用 Seaborn 库进行可视化实验。让我们开始吧。
1.加载 Cars.csv 数据集
由于数据集已经是 CSV 格式，我们需要做的就是将数据格式化为 pandas 数据框。这是通过导入pandas库使用名为read_csv的 pandas 数据框架方法完成的。
通过将 CSV 文件的路径作为参数传递给函数来使用read_csv数据框方法。当我们使用head函数时，代码会产生一个组织整齐的 pandas 数据帧。
让我们从将所有必要的模块和库导入代码开始。
import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
sns.set(color_codes=True)
现在数据在pandas模块的帮助下被加载。
df = pd.read_csv("CARS.csv")
df.head()
该数据集的428 rows和15 features具有关于不同汽车品牌的数据，例如宝马、奔驰、奥迪等，并且具有关于这些汽车的多个特征，例如型号、类型、产地、传动系、建议零售价等。
2.移除不相关的特征
在后面的章节中，如果我们需要根据给我们的一些特征来计算汽车的价格。但并不是所有的特征都是确定汽车价格所必需的，我们的目标是从数据集中移除相同的不相关特征。
我们将要删除的功能包括传动系、型号、发票、类型和来源。所有这些特征都不是确定成本所必需的。您可以根据自己的喜好删除或保留功能。
df = df.drop(['Model','DriveTrain','Invoice', 'Origin', 'Type'], axis=1)
df.head()
3.查找重复数据
在任何数据集中，都可能存在重复/冗余数据，为了删除这些数据，我们使用了reference feature(在本例中为 MSRP)。我之所以把 MSRP 作为参考，是因为两辆车的价格很少能 100%匹配。
为了消除重复，我们使用下面提到的代码。您可以观察到行数从 428 行减少到 410 行。
print("Count before Removing Duplicates: ")
df.count()
输出如下所示。
Count before Removing Duplicates:
Make 428
MSRP 428
EngineSize 428
Cylinders 426
Horsepower 428
MPG_City 428
MPG_Highway 428
Weight 428
Wheelbase 428
Length 428
dtype: int64
df = df.drop_duplicates(subset='MSRP', keep='first')
print("Count after Removing Duplicates: ")
df.count()
Count after Removing Duplicates:
Make 410
MSRP 410
EngineSize 410
Cylinders 408
Horsepower 410
MPG_City 410
MPG_Highway 410
Weight 410
Wheelbase 410
Length 410
dtype: int64
4.查找缺失值或空值
没有一个数据集是完美的，数据集中缺少值是很常见的事情。现在，有几种方法可以处理缺失值。
可以删除任一行，或者用该列中所有值的平均值填充空值。最好取列值的平均值，而不是删除整行，因为每一行对开发人员都很重要。
让我们首先看看我们的数据集中有多少空值。
print(df.isnull().sum())
您可以观察到在Cylinders列中有两个空值，其余的都是清晰的。我们的目标是处理该列的 2 个空值。发现空值属于第247 and 248行，因此我们将用所有值的平均值来替换它。
# Calculate mean of all the values of the column
val = df['Cylinders'].mean()
print("The mean of the column is: ",val)
val = round(val)
print("Rounded value of the mean of the column is: ",val)
# Replace the null value with the mean of the column
df['Cylinders'][247] = val
df['Cylinders'][248] = val
5.将对象值转换为整数类型
如果您还没有观察到，MSRP 的值以$开始，但是我们需要值是整数类型。因此，我们需要确保从该列的所有值中删除美元符号。
df['MSRP'] = [x.replace('$','') for x in df['MSRP']]
df['MSRP'] = [x.replace(',','') for x in df['MSRP']]
df['MSRP']=pd.to_numeric(df['MSRP'],errors='coerce')
df.head()
6.可视化热图
热图是查找特征之间相关性的最佳方式之一。当绘制热图时，我们可以看到 MSRP 和马力之间有很强的相关性。
plt.figure(figsize=(10,10))
plt.style.use("seaborn")
c= df.corr()
sns.heatmap(c,cmap='PiYG',annot=True)
Cars Csv File Heatmap
希望你理解这个概念，并在其他各种 CSV 文件中应用相同的内容。感谢您的阅读！
Python 逻辑运算符中的“与”
原文：https://www.askpython.com/python/and-in-python-logical-operator
Python 有三个逻辑运算符。Python 中的逻辑运算符“and”与两个布尔操作数一起使用，并返回一个布尔值。它也被称为短路运算符或布尔运算符。我们不能在 Python 中重载“and”运算符。它只适用于布尔操作数。
逻辑运算符——在 Python 中
假设我们有两个布尔变量——x 和 y。只有四种可能的变化和两种可能的结果。
| x | y | x 和 y |
| 真实的 | 真实的 | 真实的 |
| 真实的 | 错误的 | 错误的 |
| 错误的 | 真实的 | 错误的 |
| 错误的 | 错误的 | 错误的 |
基于上表，and 运算的结果是:如果 x 为假，则 x，否则 y 。
让我们看一些 Python 代码中“and”操作符的简单例子。
>>> x = True
>>> y = False
>>> x and y
False
>>> y = True
>>> x and y
True
按位&(与)运算符
Python 中的按位 and 运算符仅适用于整数。操作数被转换成二进制，然后对每一位执行“与”运算。然后，该值被转换回十进制并返回。
如果两位都是 1，那么& operator 返回 1，否则返回 0。让我们看一些例子。
>>> 10 & 5
0
>>> 10 & -5
10
解释:
10 = 1010
5 = 0101
-5 = 1011
1010&0101 = 0000 = 0
1010&1011 = 1010 = 10
摘要
Python 中的布尔运算符“and”处理布尔操作数。我们不能重载它或者使用非布尔值。我们还有按位 and 运算符，它只处理整数。
下一步是什么？
资源
Python 中的动画直方图——逐步实现
原文：https://www.askpython.com/python/examples/animated-histograms
嘿伙计们！今天，我们将使用 Python 编程语言进行编程，以获得动画直方图。
Python 和 Matplotlib 可用于创建静态 2D 图。但是 Matplotlib 有一个秘密的力量，可以用来创建动态自动更新动画情节。
我们开始吧！
1.导入模块
我们从导入所有必要的模块/库开始，包括numpy创建数据、[matplotlib](https://www.askpython.com/python-modules/matplotlib/python-matplotlib)绘制直方图，最后matplotlib.animation绘制动画图。
我们还将导入 HTML 函数，以便将视频转换为 HTML 格式。
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
from IPython.display import HTML
plt.style.use('seaborn')
2.创建数据集
为了创建数据，我们将需要 numpy 模块，首先修复一个随机状态，以便使用它。接下来，我们使用行间距函数初始化容器的数量。
接下来，我们将使用 linspace 函数创建随机的 1000 个数据点。最后一步是使用直方图功能将数据点转换成直方图数据点。
np.random.seed(19680801)
HIST_BINS = np.linspace(-4, 4, 100)
data = np.random.randn(1000)
n, _ = np.histogram(data, HIST_BINS)
3.动画显示直方图
为了让直方图有动画效果，我们需要一个animate函数，它将生成一些随机数，并不断更新容器的高度。
def prepare_animation(bar_container):
def animate(frame_number):
data = np.random.randn(1000)
n, _ = np.histogram(data, HIST_BINS)
for count, rect in zip(n, bar_container.patches):
rect.set_height(count)
return bar_container.patches
return animate
3.显示动画直方图
在hist()函数的帮助下，可以得到一个BarContainer的实例(矩形实例的集合)。
然后我们将调用prepare_animation，在它下面定义了animate函数。
最后，我们将使用to_html5_video函数将情节转换成 HTML 格式。
fig, ax = plt.subplots()
_, _, bar_container = ax.hist(data, HIST_BINS, lw=1,ec="red", fc="blue", alpha=0.5)
ax.set_ylim(top=55)
ani = animation.FuncAnimation(fig, prepare_animation(bar_container), 50,repeat=True, blit=True)
HTML(ani.to_html5_video())
在 Python 中显示动画直方图的完整实现
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
from IPython.display import HTML
plt.style.use('seaborn')
np.random.seed(19680804)
HIST_BINS = np.linspace(-4, 4, 100)
data = np.random.randn(1000)
n, _ = np.histogram(data, HIST_BINS)
def prepare_animation(bar_container):
def animate(frame_number):
data = np.random.randn(1000)
n, _ = np.histogram(data, HIST_BINS)
for count, rect in zip(n, bar_container.patches):
rect.set_height(count)
return bar_container.patches
return animate
fig, ax = plt.subplots()
_, _, bar_container = ax.hist(data, HIST_BINS, lw=1,ec="blue", fc="yellow", alpha=0.5)
ax.set_ylim(top=100)
ani = animation.FuncAnimation(fig, prepare_animation(bar_container), 50,repeat=True, blit=True)
HTML(ani.to_html5_video())
结论
我希望您在观看动画直方图时感到愉快！您可以尝试使用不同的数据、箱数，甚至改变直方图的速度。
编码快乐！😊
阅读更多
Python 绘图:在 Python 中创建动画绘图
原文：https://www.askpython.com/python-modules/matplotlib/animated-plots
到目前为止，你一定已经看过基本的 matplotlib 图，但是同样的 matplotlib 模块也可以用来制作动画图！让我们看看如何建立相同的！
导入必要的模块
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
import random
from itertools import count
from IPython import display
下表显示了每个模块及其要求:
| 模块名 | 要求 |
| Numpy 模块 | 用于为绘图创建数据集。 |
| Matplotlib 模块 | 绘制所需的图 |
| matplotlib .动画 | 为动画情节提供功能 |
| 随机 | 为了最初为随机间隔生成随机点 |
| 计数模块 | 生成一系列连续的数字 |
| 显示组件 | 显示动画情节的视频 |
Name and Requirement of various modules
在 Python 中为动画地块创建数据集
为了创建数据集，我们创建了两个列表，即x和y，其中 x 存储 x 坐标，y 存储 y 坐标。
现在 x 坐标是连续的数字。在使用count函数创建计数迭代器之后，我们将使用 cound 模块从0开始计数。为了访问下一个数字，我们还使用了next功能。
对于 y 坐标，我们将使用random模块在两个整数之间选择任意的随机整数。下面的代码实现了同样的功能，其中包括一个animate函数，该函数执行值的递增:
x=[]
y=[]
i = count()
def animate(j):
x.append(next(i))
y.append(random.randint(0, 10))
plt.plot(x,y)
创建动画对象
下一步是创建一个名为animation_1的对象。为了在一定的时间间隔后重复执行animate功能，我们使用了FuncAnimation，它采用了下面提到的几个参数:
- plt.gcf():将作为下一个参数提到的函数作为“当前函数”。
- 函数名:在这种情况下是动画。
- 间隔:设置重复该功能的时间。
animation_1 = animation.FuncAnimation(plt.gcf(),animate,interval=1000)
plt.show()
如果你正在使用python IDLE，一个绘图将自动生成。但是，如果您正在使用jupyter notebook、，即使在代码后使用了plt.show()函数，也不会输出任何内容。为了避免这种情况，需要将视频转换成 HTML 格式，这将在下一节提到。
将动画情节转换为 HTML 视频(针对 Jupyter 笔记本用户)
我们首先需要将创建的动画转换成 html5 视频，这是在下面代码中的第1行完成的。行号2创建一个 HTML 代码来显示 html5 视频。最后一行3显示了我们生成的显示视频的 html 代码。
video_1 = animation_1.to_html5_video()
html_code_1 = display.HTML(video_1)
display.display(html_code_1)
plt.tight_layout()
plt.show()
在后面的行号4和5中，我们可以简单地绘制这些点。代码的输出结果如下所示。你的图可能与我的不同，因为这些点是随机生成的。
下图是某个时间点后的最终剧情。
x_vs_y_animated_plot
绘制动画正弦波图
我们可以使用下面的代码绘制一个漂亮的正弦波。我们所做的一些更改如下:
- 使用生成的两倍计数值作为 x 坐标，以便更好地绘图
- 减少动画功能中的间隔以获得更清晰的视觉效果
x1=[]
y1=[]
i1 = count()
def animate1(j):
t=next(i1)
x1.append(2*t)
y1.append(np.sin(t))
plt.cla()
plt.plot(x1,y1)
animation_2 = animation.FuncAnimation(plt.gcf(),animate1,interval=50)
video_2 = animation_2.to_html5_video()
html_code_2 = display.HTML(video_2)
display.display(html_code_2)
plt.tight_layout()
plt.show()
特定间隔后的输出动画图和静态图如下所示。
https://www.askpython.com/wp-content/uploads/2021/04/Sine_x_vs_y_wave.mp4
Sine plot after a certain interval of time
在同一个动画图上绘制正弦和余弦
查看下面的代码，查看同一动画中的两条动画曲线。我们分别取 y 值，一个代表正弦曲线，一个代表余弦曲线，并将它们绘制在同一个动画上。同样，让我们使用‘黑暗背景’来增加一点趣味。
plt.style.use('dark_background')
x=[]
y_sin=[]
y_cos=[]
i_n = count()
def animate_n(j):
t=2*next(i)
x.append(t)
y_sin.append(np.sin(t))
y_cos.append(np.cos(t))
plt.cla()
plt.plot(x,y_sin,label="Sine wave",color="red")
plt.plot(x,y_cos,label="Cosine wave",color="green")
animation_n = animation.FuncAnimation(plt.gcf(),animate_n,interval=500)
video_n = animation_n.to_html5_video()
html_code_n = display.HTML(video_n)
display.display(html_code_n)
plt.tight_layout()
plt.show()
下面的动画是上面代码的结果。
结论
恭喜你！今天，您学习了如何使用 matplotlib 模块绘制动画图。希望你喜欢自己编写代码。感谢您的阅读！快乐编码和学习！
用 Python 制作数据动画——简单指南
原文：https://www.askpython.com/python/examples/animating-data-in-python
当我们听到术语数据可视化时，我们实际上想到了什么？一会儿，我们可以对图表、线图、散点图等有所了解。但是，如果我们能创造一些现场剧情呢。这些不是视频记录，这只是纯粹的编程和使用一些库。我们能够制作图形、直方图、偏差等漂亮的动画。
库和环境设置简介
我们将使用的库包括:
集成开发环境环境:
- Visual Studio 代码
- 蟒蛇环境
- Python 版本:3 . 9 . 7
Matplotlib 的动画类
Matplotlib 是一个非常著名的库，它使得绘图变得非常容易。它是免费和开源的，并且文档提供了一个简单的入门指南。为了动画的目的，它提供了一个特殊的类，即:“animation”。这个类有几个函数可以满足我们在 Python 中制作任何数据动画的需求。我们将通过一个简单的代码来看看如何使用它。
你可以在https://matplotlib.org/stable/api/animation_api.html查阅官方文件
首先，让我们简短地看看我们通过计算过程可视化的图形类型。
Matplotlib 中的静止图
它们只是描述轴上几个点的数据流的图片。
Matplotlib 中的动画情节
这些实际上是通过在屏幕上一个接一个地显示每个像素来告诉我们点在哪里。这使得情节本身生动起来。
简单散点图与动画散点图
简单散点图代码:
from matplotlib import pyplot as plt
import random
import sys
x = []
y = []
for i in range(0, 50):
x.append(random.randint(0, 100))
y.append(random.randint(0, 100))
# plt.xlim(0, 100)
# plt.ylim(0, 100)
plt.xlabel("X-axis")
plt.ylabel("Y-plot")
plt.title("Simple x-y plot")
plt.scatter(x, y, color = "green")
# plt.pause(0.01)
sys.exit(plt.show())
输出:
A Simple Scatter Plot
动画散点图代码:
from matplotlib import pyplot as plt
import random
import sys
x = []
y = []
plt.xlabel("X-axis")
plt.ylabel("Y-plot")
plt.title("Simple x-y plot")
for i in range(0, 50):
x.append(random.randint(0, 100))
y.append(random.randint(0, 100))
plt.scatter(x, y, color = "green")
plt.pause(0.01)
sys.exit(plt.show())
输出:
说明:
- 首先，导入库。
- 然后我们声明两个空列表 x 和 y。
- 然后运行一个 for 循环，并使用
random模块的randint()方法用一些随机整数填充列表。记得在循环中设置一个限制范围。 - 然后我们从
pyplot模块调用 scatter()函数。将绘图颜色设置为绿色。 - 最后一条非常重要。我们使用
plt.pause()功能设置每个图的 0.01 秒的时间间隔。 - 最后使用 plt.show()函数来显示图表。
条形图动画代码
from matplotlib import pyplot as plt
import random
import sys
x = []
y = []
plt.xlabel("X-axis")
plt.ylabel("Y-plot")
plt.title("Simple bar plot")
for i in range(0, 50):
x.append(random.randint(0, 100))
y.append(random.randint(0, 100))
plt.bar(x, y, color = "green")
plt.pause(0.01)
sys.exit(plt.show())
输出:
说明:
- 所有的过程都和上面的情节一样。
- 但是我们调用
plt.bar()函数来绘制动画条形图。
使用 matplotlib.animation 模块
随着我们向前推进，主要的焦点转移到内置的动画类上。这可以更有趣地学习。这个子模块有几个元素:有两个子类继承了这个类的属性。
- ArtistAnimation :使用艺术家属性制作动画。
- FuncAnimation :遵循递归并连续调用一个函数来动画化图表/绘图。
为了使绘图更加精细，我们使用了这些类。举个简单的例子，我们将看到使用相同概念的 sin(x)函数的流程。
FuncAnimation 语法
class FuncAnimation(fig, func, frames=None, init_func=None, fargs=None, save_count=None, *, cache_frame_data=True, **kwargs)
该类有三个基本参数:
- func :更新屏幕上每一帧的功能。
- init_func :读取绘图数据的初始化器。
- 帧 :每秒更新屏幕上每一帧的性质。
代码:
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
fig, ax = plt.subplots()
xdata, ydata = [], []
ln, = plt.plot([], [], 'ro')
def init():
ax.set_xlim(0, 2*np.pi)
ax.set_ylim(-1, 1)
return ln,
def update(frame):
xdata.append(frame)
ydata.append(np.sin(frame))
ln.set_data(xdata, ydata)
return ln,
ani = FuncAnimation(fig, update, frames=np.linspace(0, 2*np.pi, 128),
init_func=init, blit=True)
plt.show()
输出:
说明:
- 在第一行中，从 matplotlib 的动画类中导入 FuncAnimation 函数。
- 然后为子绘图创建两个对象图，轴。
- 将两个空列表声明为 xdata，ydata。
- 然后创建一个 plt.plot() 函数的实例“ln”和“，”。记住使用逗号，因为它会创建两个实例。
- 空实例帮助我们返回艺术家对象序列。
- 创建一个 init() 函数。在那设定中 x_lim() 从 0 度，到 360 度。在 NumPy 0 到 2 * NPπ。这决定了我们的函数从一个点到另一个点的旋转。将 y_lim()从-1 设置为 1，最后返回 ln 和那个空实例。
- 然后创建一个 update() 函数来更新屏幕上的每一帧。它将一个帧作为参数。在扩展数据列表中追加帧。在 ydata 列表中追加 np.sin(frame) ，这是正弦转换。
- 使用 set_data() 函数修复信息，并插入两个列表 xdata 和 ydata。返回 ln 和空实例。
- 为 FuncAnimation()类创建一个动画对象。这需要两个函数作为参数。
- 初始化函数: init() 在我们的代码中。
- update:我们代码中的 update()。
- 最后使用 plt.show() 方法显示图形。
- 我们有一个漂亮的 sin(x)函数,显示了它在轴中的流动。
现场图的应用
- 在股票市场上，投资者可以看到股票价格的实时涨跌。
- 多专科医院有心脏监测器，使用动画图显示病人的脉搏率。
结论
因此，通过这种方式，我们可以创造出美丽的视觉效果。它们有非常好的应用程序，在许多现实生活场景中非常有用。在这里，我们结束这个话题。
Python 中的动画
原文：https://www.askpython.com/python-modules/animation-in-python-celluloid
使用 Python 中的动画，我们可以更有效地表达我们的数据。动画是一种方法，在这种方法中，数字被处理成移动的图像，由一系列图片产生的运动模拟就是动画。
在本文中，我们将使用赛璐珞库，它使得 Python Matplotlib 中的动画非常简单。
赛璐珞 Python 中的简单动画
对于初学者来说，matplotlib 动画教程可能会很复杂。赛璐珞使得使用 matplotlib 制作动画变得很容易。
使用赛璐珞，我们为我们的可视化“拍照”，以在每次迭代中创建一个帧。一旦所有的帧都被捕获，我们就可以用一个调用来创建一个动画。查看自述文件了解更多详情。
你可以使用 Python pip 命令在 Python 中安装赛璐珞库
pip install celluloid
使用赛璐珞制作动画的步骤
一旦你准备好了库，让我们开始制作动画。
1。从赛璐珞导入相机类
首先，我们需要从赛璐珞模块导入 camera 类，并通过传递 Matplotlib figure 对象创建一个 Camera 对象。
from celluloid import Camera
fig = plt.figure()
camera = Camera(fig)
2.在数据循环时创建快照
循环递增地在 Matplotlib 图形上绘制数据，并使用 camera 对象的.snap( )方法拍摄快照。
#plotting data using loops and creating snapshot at each iteration
plt.plot(..)
camera.snap()
3.创建动画对象
创建完所有帧后，使用 camera 类的.animate( )方法。
#Applying the animate method to create animations
animation = camera.animate()
#Saving the animation
animation.save('my_animation.mp4')
Python 中动画的示例实现
现在让我们通过在 Python 中创建一个追踪正弦函数的动画来清楚地理解上面的步骤。
#Importing required libraries
%matplotlib notebook
import matplotlib.pyplot as plt
import numpy as np
from celluloid import Camera
import ffmpeg
#Creating Data
x = np.linspace(0, 10, 100)
#defining a function to return sine of input values.
def fun(i):
y = np.sin(i)
return y
x_y = fun(x)
#Creating matplotlib figure and camera object
fig = plt.figure()
plt.xlim(0,10)
plt.ylim(-2,2)
camera = Camera(fig)
#Looping the data and capturing frame at each iteration
for i in x:
plt.plot(x,x_y , color = 'green' , lw = 0.8)
f = plt.scatter(i, fun(i) , color = 'red' , s = 200)
plt.title('tracing a sin function')
camera.snap()
#Creating the animation from captured frames
animation = camera.animate(interval = 200, repeat = True,
repeat_delay = 500)
https://www.askpython.com/wp-content/uploads/2020/11/sine_wave.mp4
在上面的代码中，我们定义了一个 fun()函数，它接受数值并返回输入值的正弦值。
当我们准备好相机对象时，我们遍历数据，每次迭代我们都传递跟踪器的新坐标(红色的点)并创建输出图像的快照。
在捕获所有帧后，我们应用带有以下输入参数的.animate( )方法:
interval–两帧之间的时间，单位为毫秒。repeat–(布尔)指定我们是否要不断重复动画。repeat_delay–如果 repeat 为真，我们使用它指定时间延迟来重复动画。
#Saving the animation
animation.save('sine_wave.mp4')
使用本库的一些限制:
- 确保所有图的轴限制相同。
- 将艺术家传递给
legend函数来分别绘制他们，因为图例将从先前的情节中累积。
结论
在本文中，我们发现了一个非常简单的使用赛璐珞库在 Python 中创建动画的方法。使用库来更好地学习它，并变得更有效率！快乐学习！！🙂
Python 编程中的 any()方法
原文：https://www.askpython.com/python/built-in-methods/any-method-in-python
Python 中的 any()方法是另一种内置方法。我们之前看到了 Python 中 all()方法的工作和用法。any()方法与该方法非常相似。它告诉我们任何可迭代对象的性质。让我们了解这个方法实际上是什么以及它是如何工作的。
Python 中 any()方法的工作原理
Python 中的 any()方法检查可迭代对象的任何元素，如数组、列表、元组等。是否为真。
如果其中任何一个为真，该方法将直接返回'真'和'假'如果它们都不为真。如果提供的 iterable 对象为空，那么any()方法也返回一个“ False ”。仔细看看下面的语法，
语法，
any( iterable_object_name )
这里，
iterable_object_name，顾名思义，是要进行检查的对象的名称- 当且仅当任何 iterable 对象元素为真时，该方法将返回True
- 另一方面，如果所有的元素都是假的或者可迭代的是一个空的元素，那么这个方法将返回“假的****
Python 中 any()方法的示例
下面给出的代码试图以最好的方式说明内置 Python 方法any()的使用和工作，
# python any() example
print("any() in Python:")
# Defining different type of variables
list1 = ['John','Arya','Daniel','Sophie']
list2 = [0, 1, 1, 1, 0]
dictionary1 = {1: "True", 2: "False"}
dictionary2 = {0: "False", 1: "True"}
tpl1 = (0, 0, 0, 0)
# Evaluating the variables with the any() method.
print("any() results for various variables and objects:")
print("list1=['John','Arya','Daniel','Sophie']:", any(list1))
print("list2=[0,1,1,1,0]:", any(list2))
print("tpl1=(0,0,0,0):", any(tpl1))
print("dictionary1:", any(dictionary1))
print("dictionary2:", any(dictionary2))
# Testing any() method's evaluation for empty objects
dict_empt = {}
list_empt = []
print("any() results for empty objects:")
print("dict_empt:", any(list_empt))
print("list_empt:", any(dict_empt))
输出:
any() Method Testing Example
从我们在这个例子中考虑的不同的可迭代对象开始，我们使用了列表、元组，以及字典。但是any()方法适用于任何可迭代的对象，而不仅仅是我们所使用的对象。
理解代码，
- 由于列表 1 具有所有真值，列表 1 的
any()方法返回真值， - 类似地， list2 包含三(3)个非零、非虚假值，因此在这种情况下 any() 也返回 True
- 对于元组 tpl1 ，该方法返回
False，因为所有元素都是 0 并且评估为假 - 这两个字典，字典 1 和字典 2 至少有一个真值。所以我们得到了我们想要的输出，那就是
True - 对于空的 iterable 对象，如前所述，any()方法为空列表和字典返回 False
Python 中 any()和 all()方法的区别
Python 中 all()和 any()方法之间的一个快速、概括的区别是:
any()检查是否至少有一个元素是真的all()检查是否一个可迭代的所有元素都是真的- 对于空对象， any() 返回假，而 all() 返回真
结论
在本教程中，我们学习了 Python 中的内置any()方法，它是如何工作的，以及它如何与各种可迭代对象交互。
你也可以看看我们之前关于 Python 中的内置方法的文章，这将帮助你理解 Python 中总是可以使用的不同方法，而不需要导入任何东西。
参考
- https://stack overflow . com/questions/19389490/how-do-python-any-and-all-functions-work
- https://stack overflow . com/questions/16505456/how-确切地说，python-any-function-work
如何在 Python 中追加数组？
原文：https://www.askpython.com/python/array/append-an-array-in-python
嘿，伙计们！在本文中，我们将关注在 Python 中添加数组的方法。
Python 数组是什么？
在编程术语中，数组是一个存储相似类型元素的线性数据结构。
众所周知，Python 并没有为我们提供一种特定的数据类型——“数组”。相反，我们可以使用 Python Array 的以下变体——
- Python List :包含了一个数组的所有功能。
- Python Array 模块:这个模块用来创建一个数组，并用指定的函数操作数据。
- Python NumPy 数组:NumPy 模块创建一个数组，用于数学目的。
现在，让我们来理解将元素附加到 Python 数组的上述变体的方法。
使用 Append()函数在 Python 中追加数组
Python append() function允许我们将一个元素或一个数组添加到另一个数组的末尾。也就是说，指定的元素被追加到输入数组的末尾。
根据上面提到的 Python 数组的变体，append()函数具有不同的结构。
现在让我们了解 Python append()方法在 Python 数组的每个变体上的功能。
变体 1:带有列表的 Python append()函数
列表被认为是动态数组。Python append()方法可以在这里构造，以将元素添加/追加到列表的末尾。
语法:
list.append(element or list)
列表或元素被添加到列表的末尾，列表用添加的元素更新。
举例:
lst = [10,20,30,40]
x = [0,1,2]
lst.append(x)
print(lst)
输出:
[10, 20, 30, 40, [0, 1, 2]]
变体 2:带有数组模块的 Python append()方法
我们可以使用 array 模块创建一个数组，然后应用 append()函数向其中添加元素。
使用数组模块初始化 Python 数组:
import array
array.array('unicode',elements)
unicode:表示数组要占用的元素类型。例如，“d”表示双精度/浮点元素。
此外，append()函数的操作方式与 Python 列表相同。
举例:
import array
x = array.array('d', [1.4, 3.4])
y = 10
x.append(y)
print(x)
输出:
array('d', [1.4, 3.4, 10.0])
变体 3:带有 NumPy 数组的 Python append()方法
NumPy 模块可用于创建一个数组，并根据各种数学函数操作数据。
语法:Python numpy.append()函数
numpy.append(array,value,axis)
array:要追加数据的 numpy 数组。value:要添加到数组中的数据。axis(可选):指定按行或按列操作。
在下面的示例中，我们使用 numpy.arange()方法在指定的值范围内创建了一个数组。
举例:
import numpy as np
x = np.arange(3)
print("Array x : ", x)
y = np.arange(10,15)
print("\nArray y : ", y)
res = np.append(x, y)
print("\nResult after appending x and y: ", res)
输出:
Array x : [0 1 2]
Array y : [10 11 12 13 14]
Result after appending x and y: [ 0 1 2 10 11 12 13 14]
结论
这个题目到此为止。如果你有任何疑问，欢迎在下面评论。更多关于 Python 的帖子，请访问 【邮件保护】 。
参考
- Python 添加到数组— JournalDev
- NumPy append()方法— JournalDev
在 Python 中追加多个字符串的 4 种简单方法
原文：https://www.askpython.com/python/string/append-multiple-strings-in-python
在这篇文章中，我们将看看在 Python 中插入和追加多个字符串的不同方法。字符串插值涉及在特定语句中注入字符串。让我们开始吧！
技巧 1: f-string 在 Python 中追加多个字符串
Python f-string 也被称为格式——string已经被证明是处理字符串的一种有效和最佳的方式。f 字符串在 PEP 498 下作为文字字符串插补引入。
f-string主要用于string interpolation的目的，即将多个字符串注入到一个语句或结构中。
语法:
f'{string1} {string2} {stringN}'
- {} :要插值的字符串放在花括号之间。
例 1:
str1 = 'Python'
str2 = '@'
str3 = 'JournalDev'
res = f'{str1} {str2} {str3}'
print("Appending multiple strings using f-string:\n")
print(res)
输出:
Appending multiple strings using f-string:
Python @ JournalDev
例 2:
str1 = 'Python'
str2 = 'and'
str3 = 'R'
str4 = '@ JournalDev'
res = f'{str1} {str2} {str3} {str4}'
print("Appending multiple strings using f-string:\n")
print(res)
输出:
Appending multiple strings using f-string:
Python and R @ JournalDev
技术 2:追加多个字符串的 Python format()方法
Python string.format()函数也可以用来高效地格式化字符串。
语法:
1。使用 format()函数进行单字符串格式化
{}.format(string)
2。使用 format()函数格式化多个字符串
{} {}.format(string1, string2)
string.format() function格式化字符串，并通过位置格式化帮助替换字符串，即根据字符串在函数参数列表中的位置。
例 1:
str1 = 'Python'
str2 = '@'
str3 = 'JournalDev'
res = "{} {} {}".format(str1, str2, str3)
print("Appending multiple strings using format():\n")
print(res)
输出:
Appending multiple strings using format():
Python @ JournalDev
例 2:
str1 = 'Python'
str2 = 'and'
str3 = 'Java'
str4 = '@ JournalDev'
res = "{} {} {} {}".format(str1, str2, str3, str4)
print("Appending multiple strings using format():\n")
print(res)
输出:
Appending multiple strings using format():
Python and Java @ JournalDev
让我们学习更多在 Python 中追加多个字符串的方法。
技巧 3:使用“+”操作符追加多个字符串
Python 串联运算符即'+' operator可用于将多个字符串追加在一起。
语法:
string1 + string2 + ..... + stringN
例 1:
str1 = 'Python'
str2 = '@'
str3 = 'JournalDev'
res = str1 + str2 + str3
print("Appending multiple strings using Python '+' operator:\n")
print(res)
输出:
Appending multiple strings using Python '+' operator:
[email protected]
例 2:
str1 = 'Python'
str2 = '+'
str3 = 'R'
str4 = "@JournalDev"
res = str1 + str2 + str3 + str4
print("Appending multiple strings using Python '+' operator:\n")
print(res)
输出:
Appending multiple strings using Python '+' operator:
[email protected]
技巧 4:Python“%”操作符追加多个字符串
Python '%' operator的作用是字符串格式化和插值。
语法:
"%s" % (string)
' %s' 作为一个占位符，用括号()中传递的字符串替换它。
例 1:
str1 = 'Python'
str2 = '+'
str3 = 'Java'
res = "%s %s %s" % (str1, str2, str3)
print("Appending multiple strings using Python '%' operator:\n")
print(res)
输出:
Appending multiple strings using Python '%' operator:
Python + Java
例 2:
str1 = 'Python'
str2 = '+'
str3 = 'Java'
str4 = '@ journalDev'
res = "%s %s %s %s" % (str1, str2, str3, str4)
print("Appending multiple strings using Python '%' operator:\n")
print(res)
输出:
Appending multiple strings using Python '%' operator:
Python + Java @ journalDev
结论
因此，在本文中，我们已经了解了在 Python 中插入和追加多个字符串的不同方法。
参考
- Python 字符串串联–journal dev
在 Python 中追加到列表
原文：https://www.askpython.com/python/list/append-to-a-list-in-python
在本文中，我们将看看如何在 Python 中向一个列表追加内容。
Python 的 list.append() 提供了这个问题的解决方案，所以我们将看到一些使用这个方法的例子。
我们开始吧！
在 Python 中追加到普通列表
我们可以在列表中使用 Python 内置的 append() 方法，并将元素添加到列表的末尾。
my_list = [2, 4, 6, 8]
print("List before appending:", my_list
# We can append an integer
my_list.append(10)
# Or even other types, such as a string!
my_list.append("Hello!")
print("List after appending:", my_list)
输出
List before appending: [2, 4, 6, 8]
List after appending: [2, 4, 6, 8, 10, "Hello!"]
如您所见，我们的列表在末尾插入了两个元素 10 和“你好”。当你追加到一个普通列表时就是这种情况。
现在让我们看看其他一些案例。
追加到 Python 嵌套列表中的列表
嵌套列表是一个包含其他列表的列表。在这个场景中，我们将了解当列表嵌套时，如何在 Python 中追加列表。
我们将看看嵌套列表有不同长度的 N 个列表的特殊情况。我们想在原来的列表中插入另一个正好包含 N 个元素的列表。
但是现在，我们不是直接追加到嵌套列表，而是将每个 N 元素依次追加到每个 N 列表。
为了给你看一个例子，这里是我们的嵌套列表，有 N = 3 个列表:
nested_list = [[1, 2, 3], [4, 5, 6, 7], [2, 4, 5, 6, 7]]
我们将插入列表的 N 个元素中的每一个:
my_list = [10, 11, 12]
10 将被添加到第一个列表中，11 将被添加到第二个列表中，12 将被添加到第三个列表中。
因此，我们的输出将是:
[[1, 2, 3, 10], [4, 5, 6, 7, 11], [2, 4, 5, 6, 7, 12]]
有问题吗？现在就来解决吧！
因此，对于嵌套列表中的每个列表，我们从my_list中选择相应的元素，并将其附加到该列表中。我们一直这样做，直到到达嵌套列表的末尾，以及my_list。
一种可能的方法是遍历嵌套列表。因为我们知道嵌套列表的每个元素都是一个列表，所以我们可以获取当前元素的索引，并将my_list[idx]附加到nested_list[idx]。
nested_list = [[1, 2, 3], [4, 5, 6, 7], [2, 4, 5, 6, 7]]
my_list = [10, 11, 12]
for idx, small_list in enumerate(nested_list):
small_list.append(my_list[idx])
print(nested_list)
输出
[[1, 2, 3, 10], [4, 5, 6, 7, 11], [2, 4, 5, 6, 7, 12]]
的确，我们的产量符合我们的预期！
结论
在本文中，我们学习了如何追加到 Python 列表中，并研究了这个过程的各种情况。
Python 中数组是可变的吗？
原文：https://www.askpython.com/python/array/are-arrays-mutable-in-python
我们可以将 Python 对象分为两大类，即可变对象和不可变对象。可变对象是那些一旦被创建就可以被改变或修改的对象，而不可变对象一旦被创建就不能被改变。数组属于可变对象的范畴。在本文中，我们将学习数组及其可变性，以及可以对数组执行的操作。所以让我们开始吧！
Python 中的数组是什么？
数组是 Python 中存储相似类型对象集合的数据结构。数组中的对象由一组正整数索引。它们可以是多维的，对科学计算非常有用。
例如:
import numpy as np
list=[1,2,3,4]
arr = np.array(list)
print(arr)
输出:
[1 2 3 4]
在上面的例子中，我们从一个列表中创建了一个一维数组。
您可以通过以下方法访问数组元素。
import numpy as np
list=[1,2,3,4]
arr = np.array(list)
print("First element of array is:",arr[0])
print("Last element of array is:",arr[-1])
输出:
First element of array is: 1
Last element of array is: 4
现在我们来看看数组的可变属性。
数组的可变属性
现在，我们将通过例子来看看我们能在数组中做出什么样的改变。
在数组中插入元素
insert 函数帮助你在数组中插入元素。该函数有两个参数，一个是要插入元素的索引位置，另一个是元素的值。
import array as np
a = np.array('i', [1, 2, 3])
#using insert function
a.insert(1, 4)
print(a)
输出:
array('i', [1, 4, 2, 3])
修改数组中的元素
您可以借助以下代码修改数组中的元素。
import array as np
a = np.array('i', [1, 2, 3])
#using insert function
a[1]=9
print(a)
输出:
array('i', [1, 9, 3])
您需要指定要修改的元素的索引位置。
弹出数组中的元素
pop()函数将帮助你弹出一个元素。您需要指定想要弹出的元素的索引位置。该函数的作用类似于删除操作。
import array as np
a = np.array('i', [1, 2, 3])
#using pop function
a.pop(1)
print(a)
输出:
array('i', [1, 3])
从数组中删除或移除元素
remove()函数将帮助你从一个数组中移除元素。您必须指定要删除的元素的值。
import array as np
a = np.array('i', [1, 2, 3])
#using remove function
a.remove(3)
print(a)
输出:
array('i', [1, 2])
反转数组
简单的 reverse()函数将帮助你反转一个数组。
import array as np
a = np.array('i', [1, 2, 3])
#using remove function
a.reverse()
print(a)
输出:
array('i', [3, 2, 1])
结论
总之，我们知道数组是可变的，可以在创建后修改或变更。理解基本的数组操作非常重要，因为数组在科学计算中非常有用。
笔记本电脑的编程能力够强吗？
原文：https://www.askpython.com/resources/are-laptops-powerful-enough-for-programming
如今，编程是一个快速发展的领域，具有巨大的多样性和不断的演变。web 或软件开发领域很多，开发人员类型也很多。
对健壮、可靠的机器的需求几乎是显而易见的，因为这些条件是好的应用程序、软件和游戏的先决条件。你的笔记本电脑会是那台机器吗？它对编程来说足够强大吗，或者你应该继续使用你的 PC 吗？
让我们来看看笔记本电脑中每个组件的重要性。
公羊
RAM 对于编程至关重要，但是你需要多少呢？制造商、开发人员甚至博客都建议使用 8gb 甚至 16 GB 的内存，而不是常规的 4gb。由于最终价格和现代应用要求，这一点至关重要。
程序员通常会意识到这一点。同时运行许多工具或使用虚拟机可能会降低笔记本电脑的运行速度。
CPU
高质量的处理器无疑是流体操作的关键。有些作者提到了核心数、线程、工作频率、缓存等的重要性。一个不可否认的事实是，没有故障的工作使 CPU 安全，编程更流畅，没有延迟和干扰。
英特尔 i5 和 i7 通常是排名最高的型号，但 AMD 锐龙系列 3 或 5 并没有落后太多。你也可以看看最适合工作站的CPU来了解最合适的那一个。
GPU
这个小发明对游戏开发者来说至关重要。集成显卡和非集成显卡是有区别的。编码和测试游戏需要更强的 GPU 和更大的内存。另一方面，集成显卡使用现有 RAM 的一部分。
储存
大量的固态硬盘提供了更快、更顺畅的运行，更快的启动时间，以及在使用或编写应用程序时更好的性能。256 GB 的存储可能是一个很好的开始。
谈到硬币，为更大的硬盘节省一些总是一个好的决定，比如 512 GB 甚至 1 TB。
至于个人文件和文件夹，未来的程序员应该把它们放在硬盘上，这是一种较老但仍有价值的硬盘。它们更慢但更便宜，而且你存储的文件不会危及编程和操作系统本身。要决定，先搞清楚 SSD 和 HDD 的区别。
电池
如果你打算写代码，你的笔记本电脑的电池至少可以用六个小时。在最关键的时刻耗尽电量是非常不愉快的，所以电池应该是一个交易破坏者或交易制造者。这完全取决于你在电源插座附近花了多少时间。
在这种情况下，客户评论很有帮助。许多网站还可以帮助你选择合适的笔记本电脑，进行包括电池在内的所有必要功能的编程。
显示
最好的选择是购买 15 英寸屏幕的笔记本电脑，这是大多数情况下的标准配置。顾客注意到这种特定的尺寸是最方便的，不会让你的眼睛酸痛。
在户外花费大量时间使得便携性成为一个需要考虑的特性。市面上有很多型号可以选择，屏幕从 13 到 15，6 寸都有。
操作系统
操作系统有时是决定买什么的决定性因素。尽管许多应用程序可以在 Windows、Linux 和 macOS 上运行，但还是有一些功能需要首先考虑。
对于那些不想被一个品牌限制的人来说，Windows 是一个更好的选择。另一方面，macOS 更喜欢只与 MacBook 建立打字和操作关系。
然而，这并不是任何品牌或操作系统的缺点。它只是提醒人们市场上现有的笔记本电脑型号的特性和适应性。
Linux 是第三个操作系统，对潜在用户来说很幸运，预装了一些品牌，支持驱动程序。这使得这种笔记本电脑适合各种编程，并且更容易操作。
然而，大多数开发人员选择 Windows，因为它在与其他软件的兼容性方面超过了其他人。例如，找到合适的代码编辑器不会有问题。此外，您还有许多选择来进一步保护您的笔记本电脑。Windows 的 VPN 也是值得考虑的方案之一。它可以保护笔记本电脑，并开放更多编程资源。
请注意，虚拟专用网络的功能类似于您安装的任何其他应用程序。它对流量进行加密，并通过安全服务器进行重新路由。
键盘
有些人可能认为键盘不是一个必要的功能。在输入代码几个小时后，如果你的笔记本电脑有一个高质量的键盘，你的胳膊和手会很感激。
潜在买家必须考虑数字键盘。此外，注意按键的硬度和触感的柔软度。
此外，许多键盘已经重新定位或最小化了像 Enter、Fn 和 Ctrl 这样的键，这可能会暂时令人不愉快，并且需要一些调整时间。
最后，背光是一个很好的细节，可以改善你的风格和工作，即使在晚上也可以放松疲劳的眼睛。
结论
现在是裁决的时候了。推荐笔记本电脑从来都不是一件容易的事情，因为用户在考虑不同的功能和活动。
根据你的需要，明智地选择。Web 开发不需要顶级的图形，而创建游戏可能是独立图形的噩梦。请记住，购买笔记本电脑不是日常行为。您可以随时升级它们，但仅限于某种程度。
* Python 中的 args 和**kwargs
Python 提供了一些方便的方法，通过这些方法我们可以让函数接受可变数量的参数。*args和**kwargs就是这么做的。
*args - >代表一个 列表//元组** 的位置参数要传递给任何函数**
**kwargs - >代表一个 字典 中的关键字参数要传递给任何函数
*参数的用途
在定义函数时，如果您不确定要作为函数参数传递的参数的数量，通常会使用*args。所以本质上，这种类型的语法允许我们向函数传递任意数量的参数，确切的数量在运行时确定。
有两种情况下*(星号)运算符的含义不同。
案例 1:在函数定义中
这里，*操作符用于将参数打包到传递给函数的元组/列表(包含所有位置)中。因此，我们在定义中使用*args来表示传递给函数的所有位置参数都被打包到一个名为args的列表/元组中(可以给出任何其他名称，但是通常的做法是编写*args来表示使用了参数打包)
def find_average(*args):
total = 0
print('Packed Argument Tuple ->', args)
for i in args:
total += i
return total / len(args)
print('Average ->', find_average(1, 2, 3, 4, 5))
输出
Packed Argument Tuple -> (1, 2, 3, 4, 5)
Average -> 3.0
案例 2:在函数调用中
这里，*操作符用于解包传递给它的对应列表/元组，甚至是一个生成器。
a = [1, 2, 3]
print(*a)
输出
1 2 3
如果您希望一个 iterable 只被相应的函数调用，这可能是有用的。
组合案例 1 和案例 2 以使用*args
这里有一个例子，使用 Case1 和 Case2 来计算一个被解包并传递到一个函数中的列表的最大值，这个函数采用可变数量的参数。
def compute_maximum(*args):
maximum = 0
for i in args:
if i > maximum:
maximum = i
return maximum
a = [4, 5, 10, 14, 3]
print('Maximum ->', compute_maximum(*a))
输出
Maximum -> 14
**kwargs 的目的
这里，**操作符的使用方式与前一种情况类似，但是它专门用于将传递给函数的关键字参数打包到字典中。**kwargs习语只适用于函数定义，与*args不同，它在函数调用中没有任何特殊意义。
这里有一个例子来说明**kwargs的用途
def find_average(**kwargs):
total = 0
print('Keyword Argument Dictionary ->', kwargs)
for key, value in kwargs.items():
total += value
return total / len(kwargs.items())
print('Average ->', find_average(first=1, second=2, third=3, fourth=4, fifth=5))
输出
Keyword Argument Dictionary -> {'first': 1, 'second': 2, 'third': 3, 'fourth': 4, 'fifth': 5}
Average -> 3.0
这里可以使用*操作符来解包**kwargs，并将所有的keys / values传递给关键字字典
>>> print(*kwargs)
first second third fourth fifth
>>> print(*kwargs.values())
1 2 3 4 5
结论
这篇文章帮助我们更深入地理解了如何在函数定义中使用*args和**kwargs来获得可变数量的位置/关键字参数并操作它们，以及程序员如何在编写易于使用的函数的常见实践中使用它。
参考
stack overflow:https://stack overflow . com/questions/3394835/use-of-args-and-kwargs
Python 中的 ARIMA 模型演示
原文：https://www.askpython.com/python/examples/arima-model-demonstration
在本文中，我们将了解一个著名的时间序列预测模型——ARIMA 模型。
时间序列数据是不同的，因为数据是以固定的时间间隔记录的。时间序列数据添加了时间成分，并且序列中的每个数据点都依赖于先前的数据点。
时间序列预测的一种广泛使用的统计方法是 ARIMA 模型。
假设我们需要预测苹果的销售，并且我们有每天的销售记录。这个问题可以归类为时间序列建模。
在这篇文章中，我们将实现 ARIMA 模型。
什么是 ARIMA？
ARIMA 代表自回归综合移动平均线。它基于描述数据中的自相关性，是分析和预测时间序列数据的流行和强大的时间序列算法之一。
让我们来分解一下 ARIMA 的意思:
- 自回归(AR):一个观察值和一些滞后观察值之间的依赖关系。这意味着过去的值用于预测下一个值。
- 积分 (I):对数列进行差分运算，使其平稳。
- 移动平均 (MA):表示用来预测未来值的过去预测误差的个数。
1.ARIMA 模型的参数。
ARIMA 需要三个组件，**p**、**d**和**q**来构建模型。
- p :自回归滞后的次数，模型的自回归方面需要。
- d :
d与模型的集成部分相关联。这是使数列平稳所需的差分阶。 - q : q 指移动平均线滞后的次数。它与模型的移动平均线部分相关联。
2.平稳序列
平稳序列是指性质不随时间变化的序列。这意味着时间序列的统计特性，如均值、方差和协方差都是恒定的。
如果我们的序列不是平稳的，我们就无法建立时间序列模型。ARIMA 模型要求数据是平稳序列。
制作平稳序列的一些流行方法有增强迪基-富勒检验、差分、去趋势等。
用 Python 演示 ARIMA 模型
我们将实现auto_arima函数。它会自动找到 ARIMA 模型的最佳参数。
换句话说，该函数将自动确定 ARIMA 模型的参数p、d和q，这非常方便，因为数据准备和参数调整过程最终非常耗时。
我们将使用具有 auto_arima 函数的pmdarima模块。所以让我们开始吧
1.导入数据集
我们将在本次演示中使用的数据集是电力 _ 生产数据集(从 Kaggle 下载的)。
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
series = pd.read_csv('Electric_Production.csv' , index_col = 0)
#divide into train and validation set
train = series[:int(0.7*(len(series)))]
valid = series[int(0.7*(len(series))):]
#Plotting the data
plt.figure(figsize = (8,5))
ax = plt.gca()
ax.xaxis.set_major_locator(plt.MaxNLocator(20))
plt.xticks(rotation = 45)
plt.plot(series)
plt.show()
Plot Of Electrical Production Dataset
2.检查系列是否稳定
让我们执行“扩展的 Dickey-Fuller 检验”来检查数据是否是稳定的。
# Importing required modules
from pmdarima.arima import ADFTest
adf_test = ADFTest(alpha = 0.05)
adf_test.should_diff(series)
Output: (0.01, False)
pmdarima.arima有ADFTest类来执行增强的 Dickey-Fuller 测试。
我们也可以使用具有adfuller类的statsmodels.tsa.stattools模块来执行测试。
上面代码的输出意味着这个序列不是平稳的，我们需要先把它变成一个平稳的序列来实现 ARIMA。
在这种情况下，auto Arima 非常有用，它会自动确定差分参数“d ”,使序列保持平稳。
3.实施 ARIMA 模式
#Importing the module
import pmdarima as pmd
arima_model = pmd.auto_arima(train,
start_p=0,d = 1,start_q=0,
test="adf", supress_warnings = True,
trace=True)
#Summary of the model
arima_model.summary()
Summary Stats Of The Fitted Model
我们传递给这个函数一些重要的输入参数。该函数的重要参数是:
- 用于拟合 ARIMA 模型的时间序列。
start_p:自回归(AR)模型的阶数。start_q:移动平均线(MA)模型的阶。d:先差的顺序。默认设置为无。test:用于检测平稳性的单位根检验的类型。
4.使用 MAPE 检查模型性能
现在，使用平均绝对百分比误差作为性能指标，检查我们的模型有多好。
#Predict the future values
valid['predicted'] = arima_model.predict(n_periods = len(valid))
def MAPE(true, pred):
true, pred = np.array(true), np.array(pred)
return np.mean(np.abs((true - pred) / true)) * 100
MAPE(valid.IPG2211A2N, valid.predicted)
输出:
12.44044096590272
MAPE 值应该尽可能低，这表明我们的模型犯的错误越来越少。
结论
在本文中，我们学习了时间序列预测的 ARIMA 模型，并用 Python 实现了它。我们确定了模型的时间序列数据集的平稳条件，并实施了扩展的 Dickey-Fuller 测试来检查平稳性。
快乐学习！
如何使用 Python 对图像执行算术运算
原文：https://www.askpython.com/python/examples/arithmetic-operations-on-images
在本教程中，我们将学习如何使用 Python 对图像执行不同的算术运算。我们将执行不同的运算，如加、减、乘、除。
我们对图像的算术运算是什么意思？
图像运算是指对图像的算术运算。每当我们对图像执行任何算术运算时，它都是对单个像素值执行的。例如:如果图像是彩色的，那么加法是这样执行的:
f_img(i, j, k) = img1(i, j, k) + img2(i, j, k)
or
f_img(i, j, k) = img1(i, j, k) + constant
如果图像是一个 灰度图像 ，那么加法是这样执行的:
f_img(i, j) = img1(i, j) + img2(i, j)
or
f_img(i, j) = img1(i, j) + constant
类似地，其他算术运算也在图像上执行。要首先对图像执行任何算术运算，我们必须使用 cv2.imread()方法加载图像。
正如我们所知，图像被加载为 NumPy N 维数组，因此对它们执行不同的算术运算变得非常容易。注意:如果对两幅或多幅图像进行算术运算，那么所有图像都应该是相同的类型，如 jpeg、jpg、png 等。、 ^(**) 深度、尺寸。
^(******) 深度:用于表示每个像素的比特数，如每通道 8 比特，通常被称为 24 比特彩色图像(8 比特×3 通道)。
使用 OpenCV 对图像进行算术运算
首先，我们必须安装 OpenCV-Python 库，然后在 Python 程序中导入 cv2 模块。以下是安装 OpenCV-Python 和导入 cv2 模块的命令:
# Installing OpenCV-Python library
pip install opencv-python
# Importing cv2 module
import cv2
1.图像添加
我们既可以添加两个图像，也可以为一个图像添加一个常量值。图像添加通常用作一些复杂过程中的中间步骤，而不是作为其本身的有用操作。
在进行适当的掩蔽后，它可用于将一幅图像叠加到另一幅图像上。我们可以通过两种方式执行图像添加:
- NumPy 加法:在这里，我们简单地加载图像文件，并使用(+)操作符添加加载图像后返回的 NumPy N-d 数组。这是一个模运算，这意味着如果输入(加载)图像的像素值相加后所得像素值大于 255，则计算所得像素值与 256(对于 8 位图像格式)的模(%)，并将其分配给所得像素值，以保持其低于 255 或 255，因为任何像素值都不能超过 255。例如:
250+10 = 260 => 260 % 256 = 4
Sample Image 1
Sample Image 2
# Reading image files
img1 = cv2.imread('sample-img-1.jpg')
img2 = cv2.imread('sample-img-2.jpg')
# Applying NumPy addition on images
fimg = img1 + img2
# Saving the output image
cv2.imwrite('output.jpg', fimg)
O 输出:
Output Image
OpenCV 添加:在这里，我们简单地加载图像文件，并将加载图像后返回的 NumPy N-d 数组作为参数传递给cv2.add()方法。这是一个饱和 操作，这意味着如果在输入(加载)图像的像素值相加之后得到的像素值大于 255，则它饱和到 255，使得任何像素值都不能超过 255。这叫做^() 饱和度。例如:** 250+10 = 260 => 255
^(******) 饱和度是一种用于处理像素溢出的图像处理技术，其中我们将所有溢出的像素设置为最大可能值。
# Reading image files
img1 = cv2.imread('sample-img-1.jpg')
img2 = cv2.imread('sample-img-2.jpg')
# Applying OpenCV addition on images
fimg = cv2.add(img1, img2)
# Saving the output image
cv2.imwrite('output.jpg', fimg)
输出:
Output Image
注意:坚持使用 OpenCV 函数对图像执行不同的操作总是明智的，因为从上面两个例子的输出可以看出，它们提供了更好的结果。
2.图像减影
图像减法就是像素减法，它将两幅图像作为输入，产生第三幅图像作为输出，第三幅图像的像素值就是第一幅图像的像素值减去第二幅图像的相应像素值。我们也可以使用单个图像作为输入，并从其所有像素值中减去一个常数值。某些版本的运算符将输出像素值之间的绝对差值，而不是直接的有符号输出。
如果输出像素值为负，图像相减的实现方式会有所不同。如果图像格式支持负值像素，在这种情况下，负值是好的。如果图像格式不支持负像素值，那么这种像素通常被设置为零(即通常为黑色)。或者
如果图像减法计算使用相同像素值类型的两个输入图像的绝对差，则输出像素值不会超出由输入图像像素类型表示的指定范围，因此不会出现这个问题。这就是为什么使用绝对差异是好的。同样，我们可以通过两种方式执行图像相减:
NumPy 减法和 OpenCV 减法。
我们将只使用 OpenCV 减法，因为它产生更好的结果，并且被广泛使用。使用cv2.subtract()方法进行图像相减，结果将类似于res = img1 - img2，其中 img1 & img2 是相同深度和类型的图像。
图像相减既可以作为复杂图像处理技术的中间步骤，也可以作为一种独立的重要操作。图像减法的一个最常见的用途是从场景中减去背景照明的变化，以便可以更容易和更清楚地分析前景中的物体。
注意:我们也将使用相同的样本图像进行图像减影。
# Reading image files
img1 = cv2.imread('sample-img-1.jpg')
img2 = cv2.imread('sample-img-2.jpg')
# Applying OpenCV subtraction on images
fimg = cv2.subtract(img1, img2)
# Saving the output image
cv2.imwrite('output.jpg', fimg)
输出:
Output Image
3.图像倍增
像对图像的其他算术运算一样，图像乘法也可以在表单中实现。第一种形式的图像乘法采用两个输入图像并产生输出图像，其中像素值是输入图像的相应像素值的乘积。
第二种形式采用单个输入图像并产生输出，其中每个像素值是输入图像的相应像素值和指定常数(比例因子)的乘积。这第二种形式的图像乘法应用更广泛，通常称为缩放。
图像缩放有多种用途，但一般来说，缩放系数大于 1 时，图像会变亮，缩放系数小于 1 时，图像会变暗。
与简单地将偏移添加到像素值相比，缩放通常会在图像中产生更自然的亮或暗效果，因为它可以更好地保留图像的相对对比度。
注意:常数值往往是一个浮点数，根据它可以增加或减少图像强度。如果图像格式支持，它可以是负数。如果计算出的输出值大于最大允许像素值，则在该最大允许像素值处将其截断。
让我们使用 NumPy 图像乘法来增加下面给出的样本图像的亮度。
Sample Image
# Reading image file
img = cv2.imread('sample_img.jpg')
# Applying NumPy scalar multiplication on image
fimg = img * 1.5
# Saving the output image
cv2.imwrite('output.jpg', fimg)
输出:
Output Image
现在让我们看看这个示例图像在使用cv2.multiply()方法应用 OpenCV 图像乘法时的变化，该方法通常采用两个图像数组或一个图像数组和一个指定的常数。
# Reading image file
img = cv2.imread('sample_img.jpg')
# Applying OpenCV scalar multiplication on image
fimg = cv2.multiply(img, 1.5)
# Saving the output image
cv2.imwrite('output.jpg', fimg)
输出:
Output Image
4.图像分割
图像分割操作通常将两幅图像作为输入，并产生第三幅图像，其像素值是第一幅图像的像素值除以第二幅图像的相应像素值。
它也可以用于单个输入图像，在这种情况下，图像的每个像素值都除以指定的常数。
图像除法运算可以像减法一样用于变化检测，但是除法运算给出对应像素值之间的分数变化或比率，而不是给出每个像素值从一个图像到另一个图像的绝对变化。
这就是为什么它通常被称为配给制。
让我们使用图像分割来降低上面样本图像的亮度，使用cv2.divide()方法，通常采用两个图像数组或一个图像数组和一个指定的常数。
# Reading image file
img = cv2.imread('sample_img.jpg')
# Applying OpenCV scalar division on image
fimg = cv2.divide(img, 2)
# Saving the output image
cv2.imwrite('output.jpg', fimg)
输出:
Output Image
或者，我们也可以使用数字除法来降低上述样本图像的亮度，如下所示:
# Reading image file
img = cv2.imread('sample_img.jpg')
# Applying NumPy scalar division on image
fimg = img / 2
# Saving the output image
cv2.imwrite('output.jpg', fimg)
输出:
Output Image
结论
在本教程中，我们学习了如何对图像执行不同的算术运算，分析了用于执行图像算术运算的不同 OpenCV 方法的工作原理，并学习了这些图像算术运算的使用位置，如饱和度、、缩放、等。
Python 中的算术级数——完全指南
原文：https://www.askpython.com/python/examples/arithmetic-progression-in-python
嘿伙计们！在本教程中，我们将了解什么是算术级数，以及如何在 Python 编程语言中实现它。
等差数列入门
算术级数是一个项级数，其中下一项是通过将前一项加上一个公共差而生成的。
A.P .系列是一个数列，其中任意两个连续数字之间的差总是相同的。这种区别被称为普通差异。
等差数列的数学计算如下:
应付帐款系列之和:Sn = n/2(2a+(n–1)d)
应付帐款系列的 Tn 项:Tn = a+(n–1)d
Python 中算术级数的代码实现
让我们使用 Python 来研究算术级数的实现。我们将举两个相同的例子来帮助你更好地理解这个概念。
1.打印算术级数的前 n 项
要实现 n AP 条款，需要几个步骤。步骤如下:
第一步–输入 a(第一项)、d(第一步)和 n(项数)
第二步–从 1 到 n+1 循环，在每次迭代中计算第 n 项，并继续打印这些项。
# 1\. Take input of 'a','d' and 'n'
a = int(input("Enter the value of a: "))
d = int(input("Enter the value of d: "))
n = int(input("Enter the value of n: "))
# 2\. Loop for n terms
for i in range(1,n+1):
t_n = a + (i-1)*d
print(t_n)
2.获得算术级数中前 n 项的和
计算前 n 个 AP 项的和需要很多步骤。步骤如下:
步骤 1–输入 a(第一项)、d(步骤)和 n(项数)
步骤 2–使用上面提到的公式计算前“n”项的总和。
# 1\. Take input of 'a','d' and 'n'
a = int(input("Enter the value of a: "))
d = int(input("Enter the value of d: "))
n = int(input("Enter the value of n: "))
S_n = (n/2)*(2*a + (n-1)*d)
print("Sum of first n terms: ", S_n)
Enter the value of a: 1
Enter the value of d: 2
Enter the value of n: 5
Sum of first n terms: 25.0
结论
恭喜你！您刚刚学习了如何用 Python 实现算术级数。希望你喜欢它！😇
喜欢这个教程吗？无论如何，我建议你看一下下面提到的教程:
感谢您抽出时间！希望你学到了新的东西！！😄
Python 中的阿姆斯特朗数——易于实现
原文：https://www.askpython.com/python/examples/armstrong-number
你好。今天让我们来学习一些有趣的东西，阿姆斯特朗号。我们将理解这个数字是什么，然后执行一个程序来检查一个数字是否是阿姆斯特朗数字。
什么是阿姆斯特朗数？
如果每个数字的幂的和等于原来的数，那么一个数字就是一个阿姆斯特朗数。
阿姆斯壮数定义为:abcd…(n 位数)= a^n + b^n + c^n + d^n +。。。。。诸如此类。
阿姆斯特朗数的例子
示例 1 : 153
总位数= 3
计算(位数)= 1^3 + 5^3 + 3^3 = 1 + 125 + 27 = 153
所做的计算直接等于原始数字。因此这个数字是阿姆斯特朗数。
示例 2 : 548834
总位数= 6
计算(数字型)= 56+46 +86+86+36+46 = 15625+4096+262144+262144+729+4096 = 548834
所做的计算直接等于原始数字。因此这个数字是阿姆斯特朗数。
检验阿姆斯特朗数的算法
要检查一个数字是否是阿姆斯特朗数，需要遵循以下步骤
- 计算数字的位数。
- 在模和除法运算的帮助下，每个数字被一个接一个地访问
- 每一个数字都是数字的幂，结果存储在一个单独的变量中
- 重复步骤 2 和 3，直到数字用尽。
- 检查用原始数字计算的结果
- 如果匹配:阿姆斯特朗号码
- 否则:不是阿姆斯特朗号码
阿姆斯特朗数的伪代码
下面的代码显示了检查一个数字是否是阿姆斯特朗数的伪代码:
READ n
CALCULATE NO OF DIGITS n_digit
MAKE A COPY OF n
result=0
CHECK DIGIT BY DIGIT:
WHILE n!=0
GET CURRENT DIGIT : digit = n % 10
UPDATE RESULT : result = result + digit^(n_digit)
TRIM THE LAST DIGIT : n = n / 10
ENDWHILE
CHECK FOR ARMSTRONG NUMBER:
IF result==COPY OF n
PRINT "ARMSTRONG NUMBER"
ELSE
PRINT "NOT AN ARMSTRONG NUMBER"
用 Python 实现 Armstrong 数检查
现在我们知道了什么是阿姆斯特朗数以及实现它的步骤，让我们一行一行地实现阿姆斯特朗检查。
1.创建初始变量
我们首先获取一个输入n，然后计算输入的长度。我们还存储了一个输入的副本，这样无论我们对原始数字做了多少修改，我们都可以用这个副本来检查 Armstrong 的数字。我们还将结果初始化为 0。
相同的代码如下所示:
n = input()
n_digit = len(n)
n=int(n)
copy_n=n
result = 0
2.遍历数字并更新结果
为了访问每个数字，我们取数字的模(mod 10)来提取数字的最后一位。下一步是将结果更新为前一个结果和数字的幂。
我们采取的最后一步是将数字除以 10，去掉数字的最后一位。重复相同的过程，直到数字中没有剩余的数字。
相同的代码如下所示:
while(n!=0):
digit = n%10
result=result+pow(digit,n_digit)
n=int(n/10)
3.检查该号码是否是阿姆斯特朗号码
最后一步是检查我们之前创建的数字的副本，并计算结果以最终判断该数字是否是 Armstrong 数字。相同的代码如下所示:
if(result==copy_n):
print("Armstrong Number!")
else:
print("Not an Armstrong Number!")
代码的输出示例
现在，我测试了程序的四个输入。所有四个模块的输出如下所示:
数字 1: 153
153
Armstrong Number!
数字 2: 121
121
Not an Armstrong Number!
号码 3: 548834
548834
Armstrong Number!
号码 4: 9468632
9468632
Not an Armstrong Number!
结论
恭喜你！你已经成功地学习了阿姆斯特朗数并实现了它！
但是不要就此打住！坚持读书学习！
如何在 Python 中求数组长度
原文：https://www.askpython.com/python/array/array-length-in-python
嘿，伙计们！我希望你们都过得很好。在本文中，我们将揭示 Python 中数组长度的 3 种变体。
众所周知，Python 并不直接支持或为我们提供数组数据结构。相反，Python 在这里为我们提供了使用数组数据结构的 3 种不同变体。
让我们先来看看创建 Python 数组的不同方法。
此外，在接下来的章节中，我们将讨论如何使用 Python len()方法来获取每个变量中数组的长度。
使用 len()方法在 Python 中查找数组长度
Python 为我们提供了以下形式的数组数据结构:
- Python 列表
- Python 数组模块
- NumPy 模块
我们可以使用上面的任何变体创建一个数组，并使用不同的函数来处理和操作数据。
Python len() method使我们能够找到数组/对象中元素的总数。也就是说，它返回数组/对象中元素的计数。
语法:
len(array)
现在让我们来了解一下 Python array 的上述变种中求数组长度的方法。
查找 Python 列表的长度
Python len() method可与列表一起使用，获取并显示列表中元素的数量。
在下面的例子中，我们创建了一个异构元素列表。此外，我们使用了 len()方法来显示列表的长度。
lst = [1,2,3,4,'Python']
print("List elements: ",lst)
print("Length of the list:",len(lst))
输出:
List elements: [1, 2, 3, 4, 'Python']
Length of the list: 5
查找 Python 数组的长度
Python Array module使用模块的各种功能帮助我们创建数组并操纵数组。len()方法可以用来计算数组的长度。
import array as A
arr = A.array('i',[1,2,3,4,5])
print("Array elements: ",arr)
print("Length of array:",len(arr))
Array elements: array('i', [1, 2, 3, 4, 5])
Length of array: 5
寻找 Python NumPy 数组的长度
众所周知，我们可以使用NumPy module创建一个数组，并将其用于任何数学目的。len()方法帮助我们找出 NumPy 数组中存在的数据值的数量。
import numpy as np
arr = np.arange(5)
len_arr = len(arr)
print("Array elements: ",arr)
print("Length of NumPy array:",len_arr)
输出:
Array elements: [0 1 2 3 4]
Length of NumPy array: 5
结论
这个话题到此结束。如果你遇到任何问题，欢迎在下面评论。在那之前，学习愉快！
参考
- Python len() with List — JournalDev
理解 Python 中的数组切片
原文：https://www.askpython.com/python/array/array-slicing-in-python
介绍
在本教程中，我们将了解 Python 中数组切片的概念。
数组切片
Python 支持数组切片。它是在用户定义的起始和结束索引的基础上，从给定的数组创建一个新子数组。我们可以通过以下任一种方法对数组进行切片。
遵循 Python 切片方法可以很容易地完成数组切片。其语法如下所示。
arr[ start : stop : step ]
同样，Python 还提供了一个名为 slice() 的函数，该函数返回一个包含要切片的索引的 slice 对象。下面给出了使用该方法的语法。
slice(start, stop[, step])
对于这两种情况，
- start 是我们需要对数组 arr 进行切片的起始索引。默认设置为 0，
- stop 是结束索引，在此之前切片操作将结束。默认情况下等于数组的长度，
- 步骤是切片过程从开始到停止的步骤。默认设置为 1。
Python 中的数组切片方法
现在我们知道了使用这两种方法的语法，让我们看一些例子，并试着理解切片过程。
在下面的例子中，我们将考虑数组模块中的两个数组以及 NumPy 数组。
1.只有一个参数
开始、停止和步进的默认值分别等于 0、数组长度和 1。因此，指定 start 或 stop 中的一个，我们就可以对数组进行切片。
让我们看看如何。
import array
import numpy as np
#array initialisation
array_arr= array.array('i',[1,2,3,4,5])
np_arr = np.array([6,7,8,9,10])
#slicing array with 1 parameter
print("Sliced array: ", array_arr[:3])
print("Sliced NumPy array: ", np_arr[:4])
输出:
Sliced array: array('i', [1, 2, 3])
Sliced NumPy array: [6 7 8 9]
这里，我们已经初始化了两个数组，一个来自array模块，另一个来自NumPy数组。输出中显示了使用一个参数对它们进行切片的结果。正如我们所看到的，对于这两种情况，开始和步骤被默认设置为 0 和 1 。切片数组包含索引为 0 到 (stop-1) 的元素。这是 Python 中最快的数组切片方法之一。
2.Python 中带两个参数的数组切片
同样，指定 start、stop 和 end 中的任意两个参数，可以通过考虑第三个参数的默认值来执行 Python 中的数组切片。
让我们举一个例子。
import array
import numpy as np
#array initialisation
array_arr= array.array('i',[1,2,3,4,5])
np_arr = np.array([6,7,8,9,10])
#slicing array with 2 parameters
print("Sliced array: ", array_arr[2:5])
print("Sliced NumPy array: ", np_arr[1:4])
输出:
Sliced array: array('i', [3, 4, 5])
Sliced NumPy array: [7 8 9]
在这种情况下，分片的array模块数组和 NumPy 数组也包含指定为开始到(stop-1)的索引的元素，其中步长设置为 1 。因此输出是合理的。
3.使用步长参数
当提到所有这三个参数时，你可以在 Python 中从索引开始到 (stop-1) 执行数组切片，每个索引跳转等于给定的步。
看看下面的例子就有了清晰的认识。
import array
import numpy as np
#array initialisation
array_arr= array.array('i',[1,2,3,4,5,6,7,8,9,10])
np_arr = np.array([11,12,13,14,15,16,17,18,19,20])
#slicing array with step parameter
print("Sliced array: ", array_arr[1:8:2])
print("Sliced NumPy array: ", np_arr[5:9:3])
输出:
Sliced array: array('i', [2, 4, 6, 8])
Sliced NumPy array: [16 19]
类似地，这里我们从给定索引 start 到 stop-1 的数组中得到切片数组的值。这里唯一的区别是步长值，这次对于array模块数组和NumPy数组分别指定为 2 和 3 。因此，这次每个步进跳转都是给定步骤的值。
4.Python 中使用 slice()方法的数组切片
Python 中的slice()方法使用给定的步骤值返回一系列索引，范围从开始到停止-1 。
与前面的情况类似，这里 start 和 stop 的默认值也是 0，步长等于 1。
import array
import numpy as np
#array initialisation
array_arr = array.array('i',[1,2,3,4,5,6,7,8,9,10])
np_arr = np.array([11,12,13,14,15,16,17,18,19,20])
s = slice(3,9,3)
#slicing array with slice()
print("Sliced array: ", array_arr[s])
print("Sliced NumPy array: ", np_arr[s])
输出:
Sliced array: array('i', [4, 7])
Sliced NumPy array: [14 17]
这里，首先我们初始化了两个数组，一个来自array模块，另一个来自NumPy模块。slice()方法的开始、停止和步进分别称为 3 、 9 和 3 。因此，当我们将这个序列s传递给数组时，我们得到切片数组，其值包含索引 3 和 6 处的元素。
因此，输出是合理的。
注意:原始数组总是保持完整，保持不变。如果需要，切片数组可以存储在某个变量中。
结论
所以在本教程中，我们要学习 Python 中的数组切片的概念。任何进一步的问题，请在下面随意评论。
参考
- Python 数组教程，
- NumPy 数组在 Python 中，
- Python slice()函数。
Python 编程语言中的 ASCII 艺术
在本教程中，我们将使用pyfiglet库创建 ASCII 艺术，这将使在屏幕上显示艺术更加容易和有趣！ ASCII 艺术意味着使用一些图案或特殊符号来显示一个单词或句子，以特别使文本更具创造性，并增强文本的整体外观。
正如我提到的，为了创建 ASCII 艺术，我们需要一个 python 模块 pyfiglet，在命令提示符中使用pip命令。
pip install pyfiglet
我们将从导入模块开始，然后使用input函数从用户那里获取文本输入。然后，我们将使用将文本作为参数的figlet_format函数。我们将最终打印 ASCII 艺术。
import pyfiglet
T = input("Enter Text you want to convert to ASCII art : ")
ASCII_art_1 = pyfiglet.figlet_format(T)
print(ASCII_art_1)
让我们看一下代码执行后的示例输出。
ASCII Art Output 1
我们也可以改变字体风格。我们所需要做的就是给名为font的 pyfiglet 库的主函数添加一个新参数。
import pyfiglet
T = input("Enter Text you want to convert to ASCII art : ")
ASCII_art_1 = pyfiglet.figlet_format(T,font='digital')
print(ASCII_art_1)
执行完代码后，看看文本如何通过改变字体属性来改变。
ASCII Art Output 2
如果您希望使用字母而不是符号行，您可以通过将字体属性更改为alphabet来轻松实现。看看下面提到的代码。
import pyfiglet
T = input("Enter Text you want to convert to ASCII art : ")
ASCII_art_1 = pyfiglet.figlet_format(T,font='alphabet')
print(ASCII_art_1)
请看下面的示例输出。
ASCII Art Output 3
每个人都喜欢事物的三维可视化。幸运的是，通过再次改变字体样式，ASCII 艺术也可以以 3D 形式显示，
import pyfiglet
T = input("Enter Text you want to convert to ASCII art : ")
ASCII_art_1 = pyfiglet.figlet_format(T,font='isometric1')
print(ASCII_art_1)
ASCII Art Output 4
结论
恭喜你！您可以每天在项目中使用 ASCII 艺术，以确保您的项目从其他项目中脱颖而出。您可以尝试字体样式并探索更多的显示选项。
感谢您的阅读！编码快乐！😁
Python 中的断言
原文：https://www.askpython.com/python/built-in-methods/assertions-in-python
让我们了解一种常用的测试和调试技术，在 Python 中称为断言。我们将学习什么是断言，为什么使用它们，什么时候不使用它们，以及它们的语法。所以让我们开始吧。
Python 中的断言是什么？
Python 中的断言是用来断言程序中的一个条件的语句。它们被设计成如果断言的条件被证明为假，程序将不会继续。
如果断言的条件为假，该语句产生一个AssertionError。
您可以选择随AssertionError异常一起发送消息。
为什么要使用断言？
断言语句被程序员用来在开发周期中测试和调试代码，并且通知程序员代码中可能存在的任何 bug。
这些语句仅供开发人员使用，因为 assert 语句是测试和调试代码的一部分。
因此，为了确保在块执行之前或之后满足某些条件，以便在程序的后面可以避免逻辑错误和异常，我们使用断言。
assert 语句的预期用途是，您在语句中编写的条件永远不会为假。如果这个条件被证明是假的，那么它应该是程序中的一个错误，必须被删除。
断言的一个很好的例子是确保计算一个数的反对数的函数总是给出一个正的结果，如果不是这样，那么错误是在函数的逻辑中，而不是在输入或任何其他外部因素中。
什么时候不使用断言？
断言不应该处理运行时错误。
类似“文件未找到”、“内存/堆不足”、“连接未建立”等错误。可以在 else 子句或 except 子句中处理和更正。
这些语句不是 bug，只是因为某些外部因素没有满足而存在，程序本身很可能是没问题的。
因为断言是调试指令，如果程序在优化模式下运行，那么在程序执行期间所有的断言都被忽略。
为了在优化模式下运行程序，我们使用-O 标志，如下所示:
python -O file_name.py
这将禁用代码调试，所有断言语句都将被忽略。
因此，如果任何断言被用于验证输入或安全问题，那么它的验证在优化模式下不再存在，并且会导致不必要的错误和安全漏洞。
例如，如果您使用断言来断言用户是管理员，并给予他们管理员权限，那么用户可以简单地在优化模式下运行代码，断言将被忽略，给予所有用户管理员权限。
类似地，如果使用断言来验证用户的年龄是否超过 18 岁，那么如果代码以优化模式运行，任何用户都可以绕过断言。
不言而喻，如果条件是程序本身的错误导致的，即代码中有问题，而不是输入或外部条件中有问题，那么断言用于断言条件，以便可以确定错误的存在。
用 Python 实现断言
让我们举几个例子来理解如何用 Python 写断言。
请注意，代码示例是非常基本的示例，仅用于解释语句的语法和工作原理。
a = 12
b = int(input())
assert b != 0
print(a / b)
在上面的代码中，我们在转到下一条语句之前断言了条件b不能为零。
在输出之前，让我们先看看语法。
关键字 assert 后面必须始终跟一个将得出 True 或 False 的表达式。我们也可以选择添加消息，但我们稍后会看到。
在上面的例子中，如果输入不是0，表达式将产生True，输出如下:
Assertion example when condition is satisfied
这里我们给了5作为输入，代码运行没有任何问题。
现在让我们看看当我们给0作为输入时会发生什么:
Assertion example when condition is not satisfied
当b的值为0时，条件返回False，语句引发AssertionError。
这就像任何其他异常一样，可以在 try-except-clause 中处理，然而，这样做违背了断言的目的，因为它们应该通知程序员程序中可能存在的 bug。
让我们给断言添加一条消息:
a = 12
b = int(input())
assert b != 0, "The input cannot be zero!"
print(a / b)
这里，我们再次断言条件b不能是0，如果条件为假，断言将给出一个AssertionError和一条消息。
因此，要给出异常的消息，我们需要在编写条件并用逗号分隔条件和消息之后，指定一个包含消息的字符串。
对于非零输入，输出不会有任何变化，但如果输入是0，那么输出会是这样的:
Assertion fail with a message
请注意，异常后面是我们指定的错误消息。如果你有多个断言，断言语句应该总是有一个消息来理解哪个断言失败了。
结论
在本教程中，我们学习了什么是 assert 语句，讨论了什么时候使用它们，什么时候不使用它们。然后我们看到了它们是如何用 Python 编写的，以及它们如何帮助调试您的代码。
我希望你学到了一些东西，下节课再见。
使用 Python 脚本自动加入缩放会议
原文：https://www.askpython.com/python/examples/auto-join-zoom-meetings
在本教程中，我们将创建一个简单的 zoom bot，它可以使用 python selenium 和 pyautogui 自动参加 zoom 会议。
如何使用 Python 自动加入 Zoom 会议
现在让我们创建自动加入机器人来连接 Zoom 会议。这个机器人将根据设定的时间连接到特定的链接。
1.安装 Selenium 和 Pyautogui
对于这个项目，我们需要 selenium 和 pyautogui 模块，它们可以使用 pip 包管理器中的以下命令下载。
pip install selenium
pip install pyautogui
除了这些模块，我们还需要下载 chrome 或 firefox 网络驱动程序。webdriver 和 web 浏览器的版本必须相同，这一点很重要，您可以在他们的官方浏览器网站或简单的 google 搜索中下载。
推荐阅读:在 Selenium Python 中安装 Web 驱动
from selenium import webdriver
import pyautogui as py
import time
导入必要的模块后，我们现在需要初始化 webdriver。在下面的代码中，我们将传递 webdriver 的路径。
driver = webdriver.Chrome(Path of downloaded chrome webdriver)
2.打开缩放并获取所需信息
现在我们的设置已经完成，我们可以开始编码我们的机器人自动参加会议。
为了参加 zoom 上的任何会议，我们需要一个会议 id 和密码。所以我们将两者保存在一个变量中。此链接将打开 zoom join 会议网页。
driver.get('https://zoom.us/join')
# --> storing meeting id and passcode, you may also take this as an input in your code from the user
meet_code = "275 816 9386"
passcode = "9pX9pT"
3.查找 Web 元素
当我们尝试加入会议时，Zoom 客户端会向我们显示身份验证页面，这也是通过获取上一步中的 URL 获得的，网页要求输入会议代码。
Authentication In Zoom
我们将检查 id 框和 join 按钮，以便找到它们的 xpath ，这样我们就可以定位元素并使用 selenium 自动执行这些操作。在下面的代码中，我们首先找到 id 框，并使用 send keys 方法给它我们的会议代码。
填写会议代码后，我们将点击加入按钮进入下一步。
我们的机器人将模仿相同的人类行为来输入值和加入会议。
# finding id text box and sending it our meeting code.
element_box = driver.find_element_by_xpath("//input[@id='join-confno']")
element_box.send_keys(meet_code)
#waiting for 2 seconds to send the code
time.sleep(2)
#finding the join button and clicking on it
Btn = driver.find_element_by_xpath("//a[@id='btnSubmit']")
Btn.click()
4.使用 Pyautogui 键入密码
单击“加入”按钮后，缩放客户端将打开，要求您输入会议密码。因此，为了找到输入密码和提交按钮的文本框，我们将使用 pyautogui。我们将获取输入字段和提交按钮的截图,并将其保存在与 python 文件相同的目录中。
Entering Meeting Password Automatically
使用 pyautogui 的locate center screen(' image _ path ')我们将找到这些图像在屏幕上的中心坐标，并将这些坐标传递给 moveTo() 方法，该方法将光标移动到文本字段和按钮。
enter_passcode = py.locateCenterOnScreen('passcode.png')
py.moveTo(enter_passcode)
py.click()
py.write(passcode)
在上面的代码中，我们找到了文本框并用 write 方法填充它。
btn = py.locateCenterOnScreen("zoom\join.png")
py.moveTo(btn)
py.click()
就这样，我们只需运行一个 python 脚本，就能自动参加任何会议。
也读作:使用 Python 自动键入文本
完成 Python 脚本以自动加入缩放会议
机器人的最终代码:
from selenium import webdriver
import pyautogui as py
import time
passcode = "9pX9PT"
meet_code = "272 916 9386"
def join(meet, password):
driver = webdriver.Chrome('C://software/chromedriver.exe')
driver.get('https://zoom.us/join')
time.slee(5) #to let the webpage open completely
driver.find_element_by_xpath("//input[@id='join-confno']").send_keys(meet_code)
time.sleep(2)
driver.find_element_by_xpath("//a[@id='btnSubmit']").click()
time.sleep(5)
# enter passcode
enter_passcode = py.locateCenterOnScreen('passc.png')
py.moveTo(enter_passcode)
py.click()
py.write(passcode)
# join the meeting
time.sleep(5)
btn = py.locateCenterOnScreen("join.png")
py.moveTo(btn)
py.click()
join(meet_code,passcode)
在这个脚本中，还可以提供在特定时间加入和离开会议的方法。此外，您可以为任何其他会议客户端(如 Google Meet、微软团队等)构建一个机器人。使用上面讨论的方法。
结论
对机器人来说就是这样。希望您已经很好地学习了如何创建一个自动加入 Zoom 会议的机器人，并准备好为您的会议创建一个机器人并自动完成任务。
根据 Python 中的种子关键字自动建议用户名
原文：https://www.askpython.com/python/examples/auto-suggest-usernames
在本教程中，我们将学习如何通过在 Python 中添加约束来建议用户名。在生成用户名之前，我们已经设置了以下约束:
- 至少两个大写字母
- 仅允许使用特殊字符
.、-和_ - 至少有 3 位数字
Python 中的自动建议用户名
为了让它对用户更有意义，我们将首先从用户那里获取输入数据，在输入数据的基础上，我们将向他们建议一个用户名。让我们一步步来看完整的代码。
步骤 1:启动用户名
现在用户名大多以“#”或“@”开头。我们将保留用户名开头的标签(#)。你可以保留任何你想要的符号。
步骤 2:获取用户信息
显然，我们希望用户名对用户有某种意义，用户必须以某种方式与它联系起来，使他们更容易记住。
人们可以获得的关于一个人的最简单的信息是他的名字，这里我们将考虑用户的全名。
步骤 3:添加约束
下一步，我们将在用户名生成代码中添加以下约束。
1.至少两个大写字母
我们将使用名和姓的首字母来满足这个约束。
2.特殊字符添加
只允许 3 个特殊字符，即“.”，'-'和' _ '。
所以在大写字母后面，我们会插入一个特殊的字符。您可以将字符放在您希望的任何位置，只是改变语句的顺序。
3.至少三个数字和一些随机的小写字母
最后一个约束是小写字母和至少三位数字的组合。
小写字母的数量取决于用户名的长度，在我们的例子中，我们将用户名的长度保持为 10。
到目前为止，在这 10 个字符中，有四个字符已经被' # '填充，两个大写字符和一个特殊字符。
为了简化小写字母，我们将从用户名的剩余字母中选择随机字符。我们将从 0 到 9 中随机选择三个数字。
我们将保留用户名的最终顺序，如下所示。
# + 2 Uppercase characters + . or - or _ + 3 Lowercase characters + 3 Digits
使用 Python 自动建议用户名[实现]
完整的代码实现如下所示，为了便于理解，添加了一些注释。
# Taking input of name of the user
name = input("Enter your full name: ")
# Initializing the username
username = "#"
# 1\. First two uppercase letter
l = name.split()
# Name must have both first and last name
while(len(l)!=2):
name = input("Enter full name please: ")
l = name.split()
username += l[0][0].upper()
username+=l[1][0].upper()
# 2\. Adding special character ( . , _ or -)
import random
choice = random.choices(".-_", k=1)
username += choice[0]
# 3\. Atleast three digits : The 3 digits chosen ( will be added after lowecase letters)
digits_chosen = random.choices("0123456789",k=3)
# 4\. Lowercase letters ( 3 )
remaining = l[0][1:] + l[1][1:]
letters_chosen = random.choices(remaining,k=3)
# 5\. Include the three lower and then three digits
username = username+ letters_chosen[0] + letters_chosen[1] + letters_chosen[2]
username = username + digits_chosen[0] + digits_chosen[1] + digits_chosen[2]
print("The Final Username Generated is: ", username)
输出
针对一些随机输入对代码进行了测试。你可以自己看一看。
Enter your full name: Isha Bansal
The Final Username Generated is: #IB-sha914
如果用户没有输入它的全名，程序会要求再次输入。
Enter your full name: Kartik
Enter full name please: Kartik Gupta
The Final Username Generated is: #KG_iat397
我希望你理解了问题的逻辑和实现。您可以根据自己的偏好设置和更改约束。
感谢您的阅读！
使用 Python Pyautogui 自动键入文本
原文：https://www.askpython.com/python/examples/auto-type-text-using-python
想学习如何使用 Python 自动输入文本吗？复制粘贴不是模仿文本文件输入的好方法。如果一些 python 脚本可以模仿真人从键盘输入文本，你会怎么想？通过打字，我的意思是指实际的打字，一个字母接一个字母，一个单词接一个单词地在任何输入框，聊天框等等。
在本教程中，我们将向您展示如何编写一个 python 脚本，它接受一个文件(文本、数据、符号)并在您指示它键入的任何地方自动地将它的内容键入到中。
使用 Python 实现自动类型化
让我们来看看使用 Python 实现自动化类型的代码。这段代码可以用来在任何文本编辑器上打字，让它看起来很酷🙂
为什么需要自动文字输入？
您可能会猜测为什么您需要任何自动文本输入 python 脚本，但是这里有几个原因。
- 它可以自动输入任意字数或行数的文本
- 模仿实际的键盘输入
- 当你休息的时候，为你做些事情是很有趣的。此外，仅出于教育目的，这可能会被用来发送垃圾邮件。
1.设置 pyautogui
第一步是在您的计算机系统中安装所需的库和模块来编写脚本，并使您可以轻松地使用这些功能。
虽然 pyautogui 和 时间模块 都与 python 安装捆绑在一起，但是如果它不在您的计算机中，那么您可以使用 pip 包管理器来安装它们，如图所示:
pip install pyautogui
pip install time
现在，我们已经安装了所需的库，我们开始将它导入到我们的代码文件中。
import pyautogui
import time
2.创建包含数据的文件
为了输入我们的自动脚本来编写/键入文本，我们需要文本形式的数据(可以是任何东西，任何语言)。尽管我们可以直接在 python 代码文件中插入我们想要输入的文本，但这看起来并不优雅，也不是执行此操作的明智方式。
- 用创建一个文件。txt 扩展名
- 在我们的示例中，创建名为“typing-data.txt”的文件
- 您可以在这个文件中存储任何文本，例如。“你好，我是 Python，我正在自动输入这段文字”。
对于我们的例子，我将使用一首流行歌曲的歌词——“舞猴”，这是我很容易从谷歌搜索得到的。
样本数据后的文本文件如下所示:
Typing Data File
3.使用 Python 自动输入
现在，我们已经执行了一些必需的步骤，让脚本自动输入的最后一步是在 python 脚本文件中编写输入功能。
设置时间延迟
为了获得一些时间，让用户选择文本字段，在运行/执行 python 文件后，我们希望在该字段中键入内容。
time.sleep(10)
打开要读取的文本文件
为了打开我们的文本文件(typing-data.txt ),我们使用 pyautogui 库的 open()方法,以 Read 格式打开文件。
open("typing-data.txt", "r"):
但是现在，我们需要从文件中读取文本，这是多行的，我们需要一次又一次地迭代，直到文件中的文本结束。为此，我们使用 for 循环对文本文件中的每一行****进行读取。
import pyautogui
import time
time.sleep(10)
for line in open("typing-data.txt", "r"):
键入变量中的文本
现在，我们需要输入/写入读取或存储在“line”变量中的文本行。
我们通过使用模块的 typewrite()方法来实现这一点。
pyautogui.typewrite(line)
我们需要每次发送消息，对于每一行，这意味着我们需要逐行发送我们的消息，对于这一点，我们在每次迭代时按 enter 键。但是，如果你想一次发送消息(从文本文件中)，你必须跳过这一行。
要一个字一个字地输入文本，而不是一行一行地输入，你需要另一个循环来迭代句子中的每个单词。
pyautogui.press("enter")
使用 Python 自动键入文本的完整代码
下面给出了自动输入文本的最终代码。为了使用这个脚本自动输入，我们运行 python 文件，然后快速导航到文本字段，我们打算在这里演示自动输入。如输出视频所示。
import pyautogui
import time
time.sleep(10)
for line in open("typing-data.txt", "r"):
pyautogui.typewrite(line)
pyautogui.press("enter")
输出-
https://www.askpython.com/wp-content/uploads/2022/01/output-to-auto-text-type.mp4
结论
教程到此为止。我希望你已经学会了如何用 Python 编写一个脚本来自动输入文本。
Python 中的 auto clicker——2 种简单易行的方法
原文：https://www.askpython.com/python/examples/autoclicker-in-python
嗨，开发者们！！在本教程中，我们将看看 Python 中的自动点击器。我们将首先学习它的含义以及如何用 Python 实现它。所以，事不宜迟，让我们直奔主题。
Auto clicker 是一款 Python 软件，允许用户以很短的时间间隔连续点击鼠标。它由用户定义的密钥控制，可在所有环境下工作，包括 Windows、Mac 和 Linux。在 Python 中，我们将利用一个名为 PyAutoGUI 的包来完成这项工作。这将允许我们同时操作鼠标和监控键盘。
方法 1:使用 PyAutoGui
PyAutoGUI 使用(x，y)坐标，原点(0，0)在屏幕的左上角。当我们向右移动时，x 坐标增加，但是 y 坐标减少。
PyAutoGUI 目前只在主显示器上工作。对于第二台显示器的屏幕来说是不可信的。PyAutoGUI 执行的所有键盘操作都被传输到具有当前焦点的窗口。
代码实现
import pyautogui
import time
def click():
time.sleep(0.1)
pyautogui.click()
for i in range(20):
click()
方法 2:使用 Pynput
让我们尝试使用 Pynput 模块在 Python 中实现一个 autoclicker。
导入所需模块
import time
import threading
from pynput.mouse import Button, Controller
from pynput.keyboard import Listener, KeyCode
程序中导入了多个模块，包括导入按钮和控制器以控制鼠标动作，以及导入监听器和键码以跟踪键盘事件来处理自动点击动作的开始和停止。
声明重要变量
delay = 0.001
button = Button.left
start_stop_key = KeyCode(char='s')
exit_key = KeyCode(char='e')
下一步是声明一些重要的变量，包括:
- 按钮变量，设置为需要点击的鼠标按钮。
- Begin_End
- 退出 _ 键 变量关闭 autoclicker。
创建扩展线程的类
class ClickMouse(threading.Thread):
def __init__(self, delay, button):
super(ClickMouse, self).__init__()
self.delay = delay
self.button = button
self.running = False
self.program_run = True
def start_clicking(self):
self.running = True
def stop_clicking(self):
self.running = False
def exit(self):
self.stop_clicking()
self.program_run = False
def run(self):
while self.program_run:
while self.running:
mouse.click(self.button)
time.sleep(self.delay)
time.sleep(0.1)
由于我们构建的线程，我们将能够管理鼠标点击。有两个选项:延时和按钮。此外，还有两个指示器指示程序是否正在执行。
创建从外部处理线程的方法
- start_clicking(): 启动线程
- 停止 _ 点击 (): 停止线程
- exit(): 退出程序并复位
创建一个将在线程启动时运行的方法
当线程启动时，这个方法将被调用。我们将循环迭代，直到 run_prgm 的结果等于 True 。循环内的循环迭代，直到游程的值为真。一旦进入两个循环，我们就按下设置按钮。
创建鼠标控制器的实例
mouse = Controller()
thread = ClickMouse(delay, button)
thread.start()
创建设置键盘监听器的方法
def on_press(key):
if key == start_stop_key:
if thread.running:
thread.stop_clicking()
else:
thread.start_clicking()
elif key == exit_key:
thread.exit()
listener.stop()
with Listener(on_press=on_press) as listener:
listener.join()
如果您点击开始结束键，它将停止点击，如果标志设置为真。否则，它将开始。如果按下 exit 键，线程的 exit 方法被调用，监听器被终止。
结论
这是用 Python 开发自动点击器的两种截然不同的方法。它可以根据用户的需要进一步定制。
喜欢这个教程吗？无论如何，我建议你看一下下面提到的教程:
感谢您抽出时间！希望你学到了新的东西！！😄
python Twilio–自动化 WhatsApp 业务 API 消息
原文：https://www.askpython.com/python-modules/automate-whatsapp-business-api-python-twilio
在本文中，我们将探索使用 Python Twilio 模块自动化 WhatsApp 消息传递的更好方法。我们将讨论如何设置，以及这种方法的注意事项。
什么是 Twilio？
Twilio 是一个云通信平台，允许其客户通过互联网拨打和接听电话、短信、社交媒体消息和各种功能。Twilio 及其 API 可编程地用于发送个人或商业用途所需的自动消息和呼叫。
它的最新功能是与 Whatsapp Business API 的集成，允许企业主自动与客户沟通。
使用消息服务提供商(如 Twilio)的优势
大量的个人和企业正在使用消息应用程序来发送他们的商业优惠、购买等的通知/警报。甚至有些甚至提供获取用户和帐户信息的查询。
为什么要使用按摩服务 API？
- 当脚本在服务器上运行时，可以在一天中的任何时间发送消息/通知/响应
- 没有或很少停机时间
- 易于实现，因为我们只需要负责传递参数，API 会为我们处理其余的事情。
如何使用 Python Twilio 自动化 WhatsApp 业务 API 消息
现在让我们来看一下使用 WhatsApp Business API 和 Python Twilio 库来自动化消息的步骤。这种方法比我们以前使用 Pywhatkit 发送消息的方式要好，因为你不需要保持你的 WhatsApp 网站打开并登录。
此外，一旦你可以访问 API，你可以执行更多的自动化操作，包括创建成熟的 WhatsApp 机器人。
第一步。创建帐户
使用免费试用版账户在 Twilio 上创建一个账户，该账户甚至不需要信用卡/借记卡授权。
验证您的电子邮件和电话号码，以便使用所有可用的工具和功能(免费)。请随意完成帐户设置的其他手续，这是完全免费的，你可以获得 15.50 美元的试用帐户奖金。
当您创建 Twilio 帐户时，Whatsapp 必须得到您的脸书业务经理帐户的批准，以便将您的 Twilio 号码与 Whatsapp 业务档案相关联。
第二步。获取帐户详细信息
一旦您的 Twilio 号码获得批准，您就可以使用 python 库发送和接收消息。
按照以下分步指南自动发送 WhatsApp 信息:
- 从 Twilio 控制台获取你的账号 SID 和认证令牌，在首页你账号的项目信息部分显示。
Account SID And Authentication In Twilio
3.安装所需的库[代码实现]
在你的命令提示符或终端窗口中，使用 pip 包管理器将 Twilio 库安装到你的计算机中。如果你没有 PIP 的权限，有其他方法可以安装它 这里 。
pip install twilio
现在我们已经安装了所需的库，我们需要将它导入到我们的代码中。
创建一个新的 python 文件(例如 whatsapp-msg.py)。从刚刚创建的文件顶部的助手库中导入客户机函数。
#import the Client function from the helper library
from twilio.rest import Client
然后导入 OS 库。我们将使用这个库的环境变量。这些值可以在计算机终端中访问，并用于以更一致的方式存储数据。
#import OS for environment variables
import os
4.在代码中授权 Twilio API
现在，为 SID 和 Auth 键设置环境变量。这些是我们在步骤 2 中从 Twilio 控制台获得的值。他们将帮助 Twilio 授权(确认)我们是他们 WhatsApp 消息 API 的实际用户。
#set the User credentials
account_sid = os.environ['TWILIO_ACCOUNT_SID']
auth_token = os.environ['TWILIO_AUTH_TOKEN']
client = Client(account_sid, auth_token)
您需要在代码中输入帐户 SID 和验证令牌(来自 TWILIO 仪表板)来代替“TWILIO_ACCOUNT_SID”和“AUTH_TOKEN”，以获得有效授权。
5.发送文本消息
为了发送标准的 WhatsApp 文本消息，我们使用 Twilio 库中客户端对象的“messages.create()”方法，使用以下参数:
- 正文:您希望发送/广播的信息
- From_:获得 Whatsapp 网络许可的 Twilio 号码
- 收件人:你要在 WhatsApp 上发送信息的号码
#send text message
text_message = client.messages.create(
body='Hello there!',
from_='whatsapp:+14155238886',
to='whatsapp:+15005550006'
)
6.发送媒体(图像/视频)消息
要创建媒体消息，请使用以下参数调用客户端对象下的“messages.create()”函数:
除了主体参数之外，一切都保持不变。
- media_url:要发送的媒体文件(图像/视频/gif )(可以是文件或链接)
#send media message
media_message = client.messages.create(
media_url=['https://images.unsplash.com/photo-1545093149-618ce3bcf49d?ixlib=rb-1.2.1&ixid=eyJhcHBfaWQiOjEyMDd9&auto=format&fit=crop&w=668&q=80'],
from_='whatsapp:+14155238886',
to='whatsapp:+15005550006'
)
7.打印响应
这很重要，因为它告诉我们 Twilio 给出的回应。在出现错误的情况下，这就是我们如何知道错误是什么或者代码的哪一部分导致了错误
#print response
print(text_message.sid)
print(media_message.sid)
成功的回应应该是这样的
Successful Response From Twilio API
结论
与我们之前使用网络浏览器和模拟键盘和鼠标移动的方法相比，这种方法需要额外的步骤。但是如果你是一家企业，并且正在寻找为你的客户支持建立高级响应系统的方法，这个方法绝对值得一试。
用 5 种简单的方法在 Python 中求一个列表的平均值
原文：https://www.askpython.com/python/list/average-of-a-list-in-python
在 Python 中有很多方法可以找到一个列表的平均值，只要它们都是相同的类型。在本文中，我们将研究一些方法来寻找一个 Python 列表的平均元素。
我们开始吧！
方法 1:使用 reduce()在 Python 中查找列表的平均值
我们可以使用 reduce ()方法，以及 lambda 函数(如这里的所示)。
我们将使用 lambda 对元素求和，并将结果除以列表的长度，因为 average =(所有元素的总和)/(元素的数量)
所以，相应的表达式是:
average = (reduce(lambda x, y: x + y, input_list)) / len(input_list)
让我们举一个完整的例子来说明这一点。
from functools import reduce
input_list = [3, 2, 1, 5, 7, 8]
average = (reduce(lambda x, y: x + y, input_list)) / len(input_list)
print("Average of List:", average)
输出
Average of List: 4.333333333333333
这确实是正确的输出，因为平均值是:(3+2+1+5+7+8)/6 = 26/6 = 4.333
我们不能传递不同类型的元素，因为+操作数可能不起作用。因此，列表中的所有元素都必须与+操作数类型兼容，这样才能工作。这是我们可以在 Python 中找到一个列表的平均值的方法之一。
方法 2:使用 sum()方法(推荐)
不用reduce()的方法，我们可以直接用sum(list)求和，除以长度。
input_list = [3, 2, 1, 5, 7, 8]
average = sum(input_list) / len(input_list)
print("Average of List:", average)
我们会得到和以前一样的输出！
这是在 Python 中查找列表平均值的推荐方法，因为它只使用内置函数，并且使用起来非常简单。
方法 3:使用 statistics.mean()
对于 3.4 及以上的 Python 版本，我们也可以使用statistics模块在 Python 中求一个列表的平均值。
import statistics
input_list = [3, 2, 1, 5, 7, 8]
average = statistics.mean(input_list)
print("Average of List:", average)
方法 4:使用 numpy.mean()
如果你想使用基于 NumPy 的方法，numpy.mean()会帮你做到这一点。
import numpy as np
input_list = [3, 2, 1, 5, 7, 8]
average = np.mean(input_list)
print("Average of List:", average)
你也可以将列表转换成一个 numpy 数组，然后使用ndarray.mean得到平均值。您可以使用对您的用例来说更好的，但是它们的性能是一样的。
import numpy as np
input_list = [3, 2, 1, 5, 7, 8]
# Convert to a numpy ndarray and get the mean
# using ndarray.mean
average = np.array(input_list).mean
print("Average of List:", average)
方法 5:使用 pandas Series.mean()
如果你用的是Pandas，你可以用pandas.Series(list).mean()得到一个列表的平均值
import pandas as pd
input_list = [3, 2, 1, 5, 7, 8]
# Convert the list to a Pandas Series using pd.Series(list)
# and then get it's mean using series.mean()
average = pd.Series(input_list).mean()
print("Average of List:", average)
输出
Average of List: 4.333333333333333
结论
在本文中，我们学习了如何使用不同的方法在 Python 中找到列表的平均值。
参考
- StackOverflow 问题求一个列表的平均值
Python 中的 AVL 树:完整指南
原文：https://www.askpython.com/python/examples/avl-tree-in-python
在本文中，让我们理解 Python 中 AVL 树的概念；俗称自我平衡的二叉查找树。这种树是为了纪念它的发明者 G.M.Adelson-Velsky 和 E.M.Landis 而命名的。要彻底理解 AVL 树，必须先了解二叉查找树。
使用这种数据结构的本质优势在于，在一般情况和最坏情况下，执行任何操作都需要花费 O(log N) 的时间。无论是插入、删除还是搜索操作，所有函数的时间复杂度都是一样的。
Python 中 AVL 树的平衡因子
AVL 树的结构类似于标准的二叉树，但是 AVL 树在其结构中有一个称为平衡因子的额外变量。这个变量被分配给树的每个节点。平衡因子是通过从其左子树的高度中减去其右子树的高度来计算的。
平衡因子=高度(左子树)-高度(右子树)
Python 中计算平衡系数的函数实现如下:
平衡因子本身的值描述了树。在高度平衡树的情况下，它可以是 1、0 或-1。如果树的任何节点有任何其他值，那么它是一个不平衡的树，需要重新平衡。
- 如果平衡因子= 1，那么该树被称为左重树，这意味着该树的左子树比其右子树高一级。
- 如果平衡因子= 0，那么就说这棵树是完全平衡的，这意味着左子树等于右子树。
- 如果平衡因子= -1，那么该树被称为右重树，这意味着该树有一个比其右子树低一级的左子树。
Balance Factor
在 Python 中搜索 AVL 树中的节点
AVL 树中的搜索操作与二叉查找树中的完全相同。因为搜索操作不会以任何可能的方式修改树的结构，所以不需要任何特殊的规定。该操作的时间复杂度保持为 O(Logn)
用 Python 在 AVL 树中插入节点
插入操作也与二叉查找树中的操作相同，但是在 Python 中的 AVL 树中，插入操作之后是一个额外的步骤。如果在树中插入新节点后，树的平衡因子改变，则需要称为旋转的附加步骤来恢复树的平衡。
新节点总是作为叶节点插入，作为叶节点，新节点的平衡因子等于零。通过递归地比较新节点的值和根节点的值来决定新节点的位置。如果新节点的值小于根节点的值，则将该节点移动到左子树，否则将该节点移动到右子树。
位于从根节点到新插入节点的路径中的所有节点的平衡因子。为了更好地理解，考虑下面的例子。
Insertion In Leftsubtree
Insertion In Rightsubtree
现在，在插入节点后，有四种方法可以根据新插入节点的位置重新平衡树。这四种类型的旋转是
- LL 旋转:当一个节点插入到关键节点的左子树左侧时。
- RR 旋转:当一个节点插入到关键节点的右子树的右侧时。
- LR 旋转:当一个节点插入到关键节点的左子树的右侧时。
- RL 旋转:当一个节点插入到关键节点的右子树左侧时。
LL 旋转
考虑下图中给出的树。树(a)是 Python 中的 AVL 树。在树(b)中，在关键节点 A 的左子树的左子树中插入一个新节点(节点 A 是关键节点，因为它是平衡因子不是-1、0 或 1 的最近祖先)，因此我们应用 LL 旋转，如树(c)所示。
树(a)是一棵 AVL 树。在树(b)中，在关键节点 A 的左子树的左子树中插入新节点(节点 A 是关键节点，因为它是平衡因子不是-1、0 或 1 的最近的祖先)，因此我们应用 LL 旋转，如树(c)中所示。旋转时，节点 B 成为根，T1 和 A 是其左右子节点。T2 和 T3 成为 a 的左右子树
LL Rotation
RR 旋转
考虑下图中给出的树。
树(a)是 Python 中的 AVL 树。在树(b)中，新节点被插入到关键节点 A 的右子树的右子树中(节点 A 是关键节点，因为它是平衡因子不是-1、0 或 1 的最近的祖先)，因此我们应用 RR 旋转，如树(c)中所示。
注意，新节点现在已经成为树 T3 的一部分。旋转时，节点 B 成为根，A 和 T3 作为其左右子节点。T1 和 T2 成为 a 的左右子树
RR Roatation
左右旋转
考虑下图中给出的树。树(a)是 Python 中的 AVL 树。在树(b)中，在关键节点 A 的左子树的右子树中插入新节点(节点 A 是关键节点，因为它是平衡因子不是-1、0 或 1 的最近的祖先)，因此我们应用 LR 旋转，如树(c)所示。注意，新节点现在已经成为 T2 树的一部分。旋转时，节点 C 成为根，B 和 A 作为其左右子节点。节点 B 将 T1 和 T2 作为其左右子树，T3 和 T4 成为节点 a 的左右子树
LR Rotation
RL 旋转
考虑下图中给出的树。树(a)是 Python 中的 AVL 树。在树(b)中，新节点被插入到关键节点 A 的右子树的左子树中(节点 A 是关键节点，因为它是平衡因子不是-1、0 或 1 的最近的祖先)，因此我们应用 RL 旋转，如树(c)中所示。注意，新节点现在已经成为 T2 树的一部分。旋转时，节点 C 成为根，A 和 B 作为其左右子节点。节点 A 将 T1 和 T2 作为其左右子树，T3 和 T4 成为节点 b 的左右子树
RL Rotation
在 Python 中从 AVL 树中删除节点
在 Python 中从 AVL 树中删除节点类似于从二叉查找树中删除节点。但是在 AVL 树的情况下，增加了一个步骤，即在删除节点之后重新平衡树。在删除节点之前，我们首先检查要删除的节点的位置。
如果该节点是叶节点(没有子节点的节点)，那么我们只需删除该节点。在节点只有一个子节点的情况下，我们将子节点的值存储在要删除的节点中，然后删除子节点。最后，如果节点有两个孩子，那么我们找到一个没有更多孩子的节点的后继节点，并将这个后继节点的值存储到要删除的节点中，然后删除这个后继节点。
Python 函数
定义类并初始化节点
class avl_Node(object):
def __init__(self, value):
self.value = value
self.leaf = None
self.root = None
self.height = 1
定义一个计算身高和平衡系数的函数。
def avl_Height(self, root):
if not root:
return 0
return root.height
def avl_BalanceFactor(self, root):
//base case for leaf nodes
if not root:
return 0
//implementing the above mentioned formula
return self.avl_Height(root.l) - self.avl_Height(root.r)
定义一个函数来寻找一个空节点
def avl_MinValue(self, root):
if root is None or root.left is None:
return root
return self.avl_MinValue(root.left)
定义一个函数，以预先排序的方式遍历树。
def preOrder(self, root):
if not root:
return
print("{0} ".format(root.value), end=" ")
self.preOrder(root.left)
self.preOrder(root.right)
定义旋转函数
def leftRotate(self, b):
a = b.right
T2 = a.left
a.left = b
b.right = T2
b.height = 1 + max(self.avl_Height(b.left),
self.avl_Height(b.right))
a.height = 1 + max(self.avl_Height(a.left),
self.avl_Height(a.right))
return a
def rightRotate(self, b):
a = b.left
T3 = a.right
a.right = z
b.left = T3
b.height = 1 + max(self.avl_Height(b.left),
self.avl_Height(b.right))
a.height = 1 + max(self.avl_Height(a.left),
self.avl_Height(a.right))
return a
在 Python 中定义一个在 AVL 树中插入节点的函数
def insert_node(self, root, value):
if not root:
return avl_Node(value)
elif value < root.value:
root.left = self.insert_node(root.left, value)
else:
root.right = self.insert_node(root.right, value)
root.height = 1 + max(self.avl_Height(root.left),
self.avl_Height(root.right))
# Update the balance factor and balance the tree
balanceFactor = self.avl_BalanceFactor(root)
if balanceFactor > 1:
if value < root.left.value:
return self.rightRotate(root)
else:
root.left = self.leftRotate(root.left)
return self.rightRotate(root)
if balanceFactor < -1:
if value > root.right.value:
return self.leftRotate(root)
else:
root.right = self.rightRotate(root.right)
return self.leftRotate(root)
return root
在 Python 中定义一个从 AVL 树中删除节点的函数
def delete_node(self, root, value):
# Find the node to be deleted and remove it
if not root:
return root
elif value < root.value:
root.left = self.delete_node(root.left, value)
elif value > root.value:
root.right = self.delete_node(root.right, value)
else:
if root.left is None:
temp = root.right
root = None
return temp
elif root.right is None:
temp = root.left
root = None
return temp
temp = self.avl_MinValue(root.right)
root.value = temp.key
root.right = self.delete_node(root.right, temp.value)
if root is None:
return root
# Update the balance factor of nodes
root.height = 1 + max(self.avl_Height(root.left), self.avl_Height(root.right))
balanceFactor = self.avl_BalanceFactor(root)
# Balance the tree
if balanceFactor > 1:
if self.avl_BalanceFactor(root.left) >= 0:
return self.rightRotate(root)
else:
root.left = self.leftRotate(root.left)
return self.rightRotate(root)
if balanceFactor < -1:
if self.avl_BalanceFactor(root.right) <= 0:
return self.leftRotate(root)
else:
root.right = self.rightRotate(root.right)
return self.leftRotate(root)
return root
Python 中 AVL 树的完整代码
class avl_Node(object):
def __init__(self, value):
self.value = value
self.left = None
self.right = None
self.height = 1
class AVLTree(object):
def insert_node(self, root, value):
if not root:
return avl_Node(value)
elif value < root.value:
root.left = self.insert_node(root.left, value)
else:
root.right = self.insert_node(root.right, value)
root.height = 1 + max(self.avl_Height(root.left),
self.avl_Height(root.right))
# Update the balance factor and balance the tree
balanceFactor = self.avl_BalanceFactor(root)
if balanceFactor > 1:
if value < root.left.value:
return self.rightRotate(root)
else:
root.left = self.leftRotate(root.left)
return self.rightRotate(root)
if balanceFactor < -1:
if value > root.right.value:
return self.leftRotate(root)
else:
root.right = self.rightRotate(root.right)
return self.leftRotate(root)
return root
def avl_Height(self, root):
if not root:
return 0
return root.height
# Get balance factore of the node
def avl_BalanceFactor(self, root):
if not root:
return 0
return self.avl_Height(root.left) - self.avl_Height(root.right)
def avl_MinValue(self, root):
if root is None or root.left is None:
return root
return self.avl_MinValue(root.left)
def preOrder(self, root):
if not root:
return
print("{0} ".format(root.value), end=" ")
self.preOrder(root.left)
self.preOrder(root.right)
def leftRotate(self, b):
a = b.right
T2 = a.left
a.left = b
b.right = T2
b.height = 1 + max(self.avl_Height(b.left),
self.avl_Height(b.right))
a.height = 1 + max(self.avl_Height(a.left),
self.avl_Height(a.right))
return a
def rightRotate(self, b):
a = b.left
T3 = a.right
a.right = b
b.left = T3
b.height = 1 + max(self.avl_Height(b.left),
self.avl_Height(b.right))
a.height = 1 + max(self.avl_Height(a.left),
self.avl_Height(a.right))
return a
def delete_node(self, root, value):
# Find the node to be deleted and remove it
if not root:
return root
elif value < root.value:
root.left = self.delete_node(root.left, value)
elif value > root.value:
root.right = self.delete_node(root.right, value)
else:
if root.left is None:
temp = root.right
root = None
return temp
elif root.right is None:
temp = root.left
root = None
return temp
temp = self.avl_MinValue(root.right)
root.value = temp.key
root.right = self.delete_node(root.right, temp.value)
if root is None:
return root
# Update the balance factor of nodes
root.height = 1 + max(self.avl_Height(root.left), self.avl_Height(root.right))
balanceFactor = self.avl_BalanceFactor(root)
# Balance the tree
if balanceFactor > 1:
if self.avl_BalanceFactor(root.left) >= 0:
return self.rightRotate(root)
else:
root.left = self.leftRotate(root.left)
return self.rightRotate(root)
if balanceFactor < -1:
if self.avl_BalanceFactor(root.right) <= 0:
return self.leftRotate(root)
else:
root.right = self.rightRotate(root.right)
return self.leftRotate(root)
return root
Tree = AVLTree()
root = None
root = Tree.insert_node(root,40)
root = Tree.insert_node(root,60)
root = Tree.insert_node(root,50)
root = Tree.insert_node(root,70)
print("PREORDER")
Tree.preOrder(root)
输出:
预订
50 40 60 70
总结:
AVL 树是二叉查找树的有效实现之一。本文涵盖了 AVL 树的理论知识和实际实现。
要了解更多关于二分搜索法树的信息，请点击此处参考。也可以看看 Python 中的抽象语法树。
Python 中的反向传播——快速指南
原文：https://www.askpython.com/python/examples/backpropagation-in-python
有时候你需要提高你的神经网络模型的精度，反向传播恰恰可以帮助你达到想要的精度。反向传播算法帮助您获得神经网络模型的良好预测。在本文中，我们将详细了解反向传播算法，以及如何用 Python 实现它。
什么是反向开发，为什么它是必要的？
反向传播算法是一种用于人工神经网络的监督学习算法，其中我们微调权重函数并提高模型的准确性。它采用梯度下降法来降低成本函数。它减少了预测数据和实际数据之间的均方距离。这种类型的算法通常用于为给定数据训练前馈神经网络，该给定数据的分类是我们已知的。
为了获得更高的准确性，您也可以将反向传播视为误差的反向传播。如果我们从一个神经网络模型接收到一个与实际输出有巨大差异的预测，我们需要应用反向传播算法来实现更高的精度。
注:前馈神经网络一般为多层神经网络(MLN)。数据从输入层到隐藏层，再到输出层。
Python 中的反向传播是如何工作的？
现在让我们直观地了解算法实际上是如何工作的。反向传播模型主要有三层，即输入层、隐藏层和输出层。以下是该算法的主要步骤:
- 步骤 1 :输入层接收输入。
- 步骤 2: 然后对输入进行加权平均。
- 第三步:每个隐层处理输出。每个输出在这里被称为“误差”,它实际上是实际输出和期望输出之间的差。
- 步骤 4 :在这一步中，算法再次移回隐藏层，以优化权重并减少误差。
Python 中反向传播的类型
主要有两种类型的反向传播方法，即静态反向传播和递归反向传播。让我们看看这两种类型的实际含义。在静态反向传播中，静态输入产生静态输出。这是专门用于静态分类问题，如光学字符识别。另一方面，循环传播继续发生，直到它达到一个确定的值或阈值。一旦达到固定值，误差就会反向传播。
在 Python 中实现反向传播
让我们看看如何以循序渐进的方式在 Python 中实现反向传播。首先，我们需要导入所有必需的库。
1.导入库
import numpy as np
import pandas as pd
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
现在，让我们看看我们将使用什么数据集。
2.加载数据集
我们今天将使用一个非常简单的数据集，即虹膜数据集。我们将使用 load_iris()函数加载数据集，它是 scikit-learn 库的一部分。数据集由三个主要类组成。我们将它们分为目标变量和特征。
# Loading dataset
data = load_iris()
# Dividing the dataset into target variable and features
X=data.data
y=data.target
3.在训练和测试中拆分数据集
现在我们将把数据集分成训练集和测试集。我们将使用函数 train_test_split()。该函数有三个参数:测试集的特性、目标和大小。
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=20, random_state=4)
现在，在下一步中，我们必须开始初始化超参数。我们将输入学习率、迭代次数、输入大小、隐藏层数和输出层数。
learning_rate = 0.1
iterations = 5000
N = y_train.size
# Input features
input_size = 4
# Hidden layers
hidden_size = 2
# Output layer
output_size = 3
results = pd.DataFrame(columns=["mse", "accuracy"])
3.初始化权重
np.random.seed(10)
# Hidden layer
W1 = np.random.normal(scale=0.5, size=(input_size, hidden_size))
# Output layer
W2 = np.random.normal(scale=0.5, size=(hidden_size , output_size))
现在，我们将创建辅助函数，如均方差、精确度和 sigmoid。
def sigmoid(x):
return 1 / (1 + np.exp(-x))
def mean_squared_error(y_pred, y_true):
return ((y_pred - y_true)**2).sum() / (2*y_pred.size)
def accuracy(y_pred, y_true):
acc = y_pred.argmax(axis=1) == y_true.argmax(axis=1)
return acc.mean()
现在我们将开始建立我们的反向传播模型。
4.用 Python 构建反向传播模型
我们将为给定次数的迭代创建一个 for 循环，并在每次迭代中更新权重。该模型将经历三个阶段前馈传播、误差计算阶段和反向传播阶段。
for itr in range(iterations):
# Implementing feedforward propagation on hidden layer
Z1 = np.dot(X_train, W1)
A1 = sigmoid(Z1)
# Implementing feed forward propagation on output layer
Z2 = np.dot(A1, W2)
A2 = sigmoid(Z2)
# Calculating the error
mse = mean_squared_error(A2, y_train)
acc = accuracy(A2, y_train)
results=results.append({"mse":mse, "accuracy":acc},ignore_index=True )
# Backpropagation phase
E1 = A2 - y_train
dW1 = E1 * A2 * (1 - A2)
E2 = np.dot(dW1, W2.T)
dW2 = E2 * A1 * (1 - A1)
# Updating the weights
W2_update = np.dot(A1.T, dW1) / N
W1_update = np.dot(X_train.T, dW2) / N
W2 = W2 - learning_rate * W2_update
W1 = W1 - learning_rate * W1_update
现在，我们将使用 pandas plot()函数绘制均方误差和精度。
results.mse.plot(title="Mean Squared Error")
results.accuracy.plot(title="Accuracy")
现在我们将计算模型的精度。
Z1 = np.dot(X_test, W1)
A1 = sigmoid(Z1)
Z2 = np.dot(A1, W2)
A2 = sigmoid(Z2)
acc = accuracy(A2, y_test)
print("Accuracy: {}".format(acc))
输出:
Accuracy: 0.8
可以看到模型的准确率已经大幅提高到了 80%。
Python 中反向传播的优势
它是实现起来相对更快更简单的算法。广泛应用于人脸识别和语音识别领域。此外，这是一种灵活的方法，因为不需要神经网络的先验知识。
反向传播的缺点
该算法对于有噪声和不规则的数据不是不利的。反向传播的性能高度依赖于输入。
结论
总之，我们知道反向传播是一种提高前馈神经网络模型精度的好方法。这是一个非常简单和灵活的算法，但不适合有噪声的数据。这是减少误差和提高模型精度的一个很好的方法。它通过借助梯度下降最小化损失函数来向后优化权重。
用 python 从头开始创建单词包模型
原文：https://www.askpython.com/python/examples/bag-of-words-model-from-scratch
单词袋模型是一种非常简单的表示文本数据的方式，便于机器学习算法理解。在自然语言处理问题领域，如文档分类，它被证明是非常有效的。
在本文中，我们将使用 python 实现一个 BOW 模型。
理解单词袋模型模型
在实现单词袋模型之前，让我们先直观地了解一下它是如何工作的。
考虑下面的文本，我们希望使用 BOW 模型以矢量的形式表示:
- 她喜欢披萨，披萨很好吃。
- 她是个好人。
- 好人是最好的。
现在我们创建一组给定文本中的所有单词。
set = {'she', 'loves', 'pizza', 'is', 'delicious', 'a', 'good', 'person', 'people', 'are', 'the', 'best'}
我们的文本语料库中有 12 个不同的单词。这将是我们矢量的长度。
现在，我们只需要计算单词在每个文档中出现的频率，我们得到的结果是一个单词包，代表句子。
Bag Of Words Model
在上图中，我们只需要计算每个单词在句子中出现的次数。
用 Python 实现单词包模型
让我们开始将上述概念编写成代码。
1.预处理数据
数据预处理和句子分词。(我们还将单词转换为小写以避免单词重复)
#Importing the required modules
import numpy as np
from nltk.tokenize import word_tokenize
from collections import defaultdict
#Sample text corpus
data = ['She loves pizza, pizza is delicious.','She is a good person.','good people are the best.']
#clean the corpus.
sentences = []
vocab = []
for sent in data:
x = word_tokenize(sent)
sentence = [w.lower() for w in x if w.isalpha() ]
sentences.append(sentence)
for word in sentence:
if word not in vocab:
vocab.append(word)
#number of words in the vocab
len_vector = len(vocab)
2.给这些词指定一个索引
创建一个索引字典，为每个单词分配唯一的索引
#Index dictionary to assign an index to each word in vocabulary
index_word = {}
i = 0
for word in vocab:
index_word[word] = i
i += 1
3.定义单词袋模型函数
最后定义单词包函数来返回输入句子的向量表示。
def bag_of_words(sent):
count_dict = defaultdict(int)
vec = np.zeros(len_vector)
for item in sent:
count_dict[item] += 1
for key,item in count_dict.items():
vec[index_word[key]] = item
return vec
4.测试我们的模型
完成了完整的实现后，让我们测试一下我们的模型功能。
vector = bag_of_words(sentences[0])
print(vector)
BOW Representation of Input Sentence
词汇袋的局限性
即使单词袋模型实现起来超级简单，它仍然有一些缺点。
- 稀疏度 : BOW 模型创建稀疏向量，这增加了空间复杂性，也使得我们的预测算法难以学习。
- 含义:BOW 模型中不保留序列的顺序，因此句子的上下文和含义可能会丢失。
结论
这篇文章是关于理解 BOW 模型是如何工作的，我们使用 python 从头开始实现了我们自己的模型。我们还关注了这个模型的局限性。
快乐学习！
Python 中的多臂强盗问题
原文：https://www.askpython.com/python/examples/bandit-problem-in-python
n 臂强盗问题是一个强化学习问题，其中给代理一个有 n 个强盗/臂的老虎丨机。吃角子老虎丨机的每个手臂都有不同的获胜机会。拉任何一条手臂要么奖励要么惩罚代理人，即成功或失败。
代理人的目标是一次拉一个强盗/武器，这样操作后获得的总奖励最大化。此外，问题描述指定代理不知道武器成功的可能性。它最终通过试错和价值评估来学习。
本教程将教我们如何利用策略梯度方法，该方法使用 TensorFlow 构建一个基本的神经网络，该网络由与每个可用分支获得老虎丨机奖金的可能性成比例的权重组成。在这个策略中，代理基于贪婪方法选择机器手臂。
这意味着代理通常会选择具有最高预期值的动作，但它也会随机选择。
通过这种方式，间谍测试了几把枪中的每一把，以便更好地了解它们。当代理采取行动时，例如选择吃角子老虎丨机的一只手臂，它会得到 1 或-1 的奖励。
用 Python 实现 Bandit 问题
以下是用 Python 编写的 n 臂/多臂 bandit 问题的简单实现:
对于我们的代码实现，我们选择 n=6(老虎丨机的 6 个臂)，它们的数量是[2，0，0.2，-2，-1，0.8]。
我们将逐步发现，代理人学习并有效地选择具有最高收益的强盗。
第一步:导入模块
方法tf.disable_v2_behavior(顾名思义)禁用在 TensorFlow 1.x 和 2.x 之间更改的任何全局行为，并使它们按照 1.x 的意图运行
import numpy as np
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()
步骤 2:计算武器奖励
我们指定我们的土匪在插槽武器阵列。数组的长度存储在len_slot_arms中。方法 discovers()从正态分布中创建一个平均值为 0 的随机整数。
武器/强盗数量越少，代理越有可能返回正奖励(1)。
slot_arms = [2,0,0.2,-2,-1,0.8]
len_slot_arms = len(slot_arms)
def findReward(arm):
result = np.random.randn(1)
if result > arm:
#returns a positive reward
return 1
else:
#returns a negative reward
return -1
步骤 3:设置神经代理
TensorFlow 库的方法tf.rese_default_graph清除默认图形堆栈并重置全局默认图形。第 2 行和第 3 行将特定强盗的权重确定为 1，然后进行实际的武器选择。
tf.reset_default_graph()
weights = tf.Variable(tf.ones([len_slot_arms]))
chosen_action = tf.argmax(weights,0)
训练由下面的代码处理。它最初向网络提供奖励和指定的动作(arm)。然后，神经网络使用下面所示的算法计算损失。这种损失然后被用于通过更新网络来提高网络性能。
reward_holder = tf.placeholder(shape=[1],dtype=tf.float32)
action_holder = tf.placeholder(shape=[1],dtype=tf.int32)
responsible_weight = tf.slice(weights,action_holder,[1])
loss = -(tf.log(responsible_weight)*reward_holder)
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)
update = optimizer.minimize(loss)
Loss = -log(weight for action)*A(Advantage from baseline(here it is 0)).
第四步:训练特工并找到最佳武器/强盗
我们通过做随机活动和获得激励来训练代理。上面的代码启动一个 TensorFlow 网络，然后选择一个随机动作，从其中一个手臂中选择一个奖励。这种激励有助于网络更新，并且也显示在屏幕上。
total_episodes = 1000
total_reward = np.zeros(len_slot_arms) #output reward array
e = 0.1 #chance of taking a random action.
init = tf.initialize_all_variables()
with tf.Session() as sess:
sess.run(init)
i = 0
while i < total_episodes:
if np.random.rand(1) < e:
action = np.random.randint(len_slot_arms)
else:
action = sess.run(chosen_action)
reward = findReward(slot_arms[action])
_,resp,ww = sess.run([update,responsible_weight,weights], feed_dict={reward_holder:[reward],action_holder:[action]})
total_reward[action] += reward
if i % 50 == 0:
print ("Running reward for the n=6 arms of slot machine: " + str(total_reward))
i+=1
print ("The agent thinks bandit " + str(np.argmax(ww)+1) + " has highest probability of giving poistive reward")
if np.argmax(ww) == np.argmax(-np.array(slot_arms)):
print("which is right.")
else:
print("which is wrong.")
结论
恭喜你！您刚刚学习了如何用 Python 编程语言解决多臂强盗问题。我希望你喜欢它！😇
喜欢这个教程吗？无论如何，我建议你看一下下面提到的教程:
感谢您抽出时间！希望你学到了新的东西！！😄
带逻辑的波束搜索算法及其 Python 实现
原文：https://www.askpython.com/python/examples/beam-search-algorithm
读者朋友们好，在本文中，我们来试着了解一下人工智能中使用的最高效的算法之一:波束搜索算法。
什么是波束搜索算法？
波束搜索算法是最佳优先搜索算法的改进版本。它根据条件概率选择节点。波束搜索方法的每次迭代可以包括根据路径长度排序和选择的多个路径。因此，用于查找最短或最便宜的路径。
波束搜索是如何工作的？
一种称为波束搜索的启发式搜索策略总是在每一层扩展 W 个最佳节点。它一级一级地前进，总是从每一级中最上面的 W 个节点开始。波束搜索使用广度优先搜索构建其搜索树。它在树的每一层产生当前层的状态的所有后继者，并按照启发式值的升序对它们进行组织。
不过，它只考虑了每个级别的 W 州。省略了其他节点。基于节点的启发式成本，选择最佳节点。这里的 w 指的是波束搜索的宽度。如果 B 是分支因子，则只选择 W 个节点，因为在任何级别只考虑 W * B 个节点。消除的状态数随着束宽的减小而增加。如果 W = 1，那么搜索转换为爬山搜索，其中总是挑选最佳的后继节点。没有状态被消除，如果波束宽度不确定，波束搜索与呼吸优先搜索相同。
算法
输入:开始和目标状态
局部变量:OPEN，NODE，SUCCs，W_OPEN，FOUND
输出:是或否
方法:
- NODE =根节点:Found = false:
- 如果节点是目标节点，那么 Found = true 否则查找节点的 SUCCs。如果有的话，其估计成本和存储在开放列表中:
- while(发现为假，无法继续)do
- 排序开放列表:
- 从开放列表中选择顶部的 W 个元素，并将它们放入 W_OPEN 列表中，并清空开放列表。
- 对于 W_OPEN 列表中的每个节点
- 结束 while 循环
- 如果发现=真，则返回是，否则返回否
- 停下来。
复杂性
- (W 是波束宽度，B 是任何路径的最大深度)
- 时间复杂度:取决于启发式函数，其 O(W*B)
- 空间复杂度:由于该算法在搜索树的每一层只存储 W 个节点，所以它的 O(W*B)
工作
假设 W = 2 和 B = 3，使用波束搜索算法生成的搜索树在下面给出。在这里，基于它们的启发值来选择彩色节点，以便进一步扩展。
Beam Algorithm
用 Python 实现波束搜索算法
下面是 python 中波束搜索算法的一个简单实现。我们使用 python 中的 NumPy 模块来处理性能中使用的数组数据结构。主函数 beam_search()被多次迭代以找到最短路径。该函数中传递的参数是
- 距离–顶点之间权重值的距离
- β-光束的宽度
from numpy import array
#main function
#beta here is width of beam and distances can be considered as weights.
def beam_search(distances, beta):
#initialising some record
paths_so_far = [[list(), 0]]
#traverse through the neighbouring vertices row by row.
for idx, tier in enumerate(distances):
if idx > 0:
print(f'Paths kept after tier {idx-1}:')
print(*paths_so_far, sep='\n')
paths_at_tier = list()
for i in range(len(paths_so_far)):
path, distance = paths_so_far[i]
# Extending the paths
for j in range(len(tier)):
path_extended = [path + [j], distance + tier[j]]
paths_at_tier.append(path_extended)
paths_ordered = sorted(paths_at_tier, key=lambda element: element[1])
# The best paths are saved
paths_so_far = paths_ordered[:beta]
print(f'\nPaths reduced to after tier {idx}: ')
print(*paths_ordered[beta:], sep='\n')
return paths_so_far
#Distance matrix
dists = [[1, 4, 6, 8],
[5, 2, 3, 4]]
dists = array(dists)
# Calculating the best paths
best_paths = beam_search(dists, 2)
print('\nThe best paths:')
for beta_path in best_paths:
print(beta_path)
输出
Output
从输出中，我们可以看到海滩搜索算法中路径的选择方法。在第一次迭代(第 0 层)之后，减少或切断两条路径，保留两条用于进一步扩展。这两个保留的路径被进一步迭代(第 1 层)，六个路径被切断，两个最适合的路径被保留并被声明为最佳路径。
比较
- 除了鲁棒性之外，波束搜索算法在处理巨大而密集的图形时保持资源有限的系统的可伸缩性和效率的能力可能是其最突出的特征。
- 波束搜索比最佳优先搜索需要更少的内存。这是因为不需要将所有后续节点存储在一个队列中。相反，它只选择β(波束宽度)方面最好的。
- 然而，它仍然有一些 Best First Search 的缺点。首先，它是不完整的，这意味着它甚至可能没有提出一个解决方案。其表现不佳是第二个问题。因此，它返回的答案可能不是最佳答案。
应用- 在可能有多个合适解的情况下，比如在机器翻译中，波束搜索算法被广泛使用。
结论
在本文中，我们学习并实现了人工智能项目中常用的波束搜索算法。
蟒蛇美丽的汤，方便网页刮
原文：https://www.askpython.com/python/beautiful-soup-web-scraping
读者朋友们，你们好！在本文中，我们将详细关注用于 Web 抓取的 Python Beautiful Soup 模块。
所以，让我们开始吧！🙂
也可阅读:如何使用 Python Scrapy 刮出 Google 搜索结果
使用漂亮的汤进行网络刮擦–清晰概述
如今，随着数据科学和机器学习在 IT 行业占据主导地位，数据变得越来越重要。
当我们想到一个特定的领域或主题时，有许多方法可以获取数据并对其进行分析。当谈到获取数据进行分析时，我们从各种网站收集数据进行分析，并从中调查出可能性。
类似地，这些概念产生了网络抓取的概念。
通过网络抓取，我们可以在网页上冲浪和搜索数据，从网页上收集必要的数据，然后轻松地以定制的格式保存。这就是我们称之为从网上抓取数据的原因。
了解了抓取之后，现在让我们继续用 Python 把 Beautiful Soup 作为 Web 抓取的一个模块。
用于网页抓取的 Python 美汤模块
网络抓取的概念并不像听起来那么简单。
首先，当我们希望从网站上抓取数据时，我们需要编写一个脚本，向主服务器请求数据。
接下来，通过定制脚本，我们可以将数据从网页下载到我们的工作站上。
最后，我们可以根据 HTML 标签定制我们希望收集的信息，这样就可以从网站上下载特定的信息。
Python 为我们提供了漂亮的 Soup 模块，它由各种函数组成，可以轻松地从网页中抓取数据。有了漂亮的 Soup 模块，我们可以轻松抓取和抓取 HTML、XML、网页、文档等。
用美汤刮谷歌搜索结果
首先，当在服务器上搜索单词 science 时，我们将使用 Beautiful Soup 模块来抓取网页的结果。
最初，我们需要在 python 环境中加载 BeautifulSoup 模块。
from bs4 import BeautifulSoup
import requests
现在，我们将提供需要搜索的网页的 URL。此外，我们将单词 science 附加到 URL，以便获得与数据科学相关的帖子的网络链接。
此外，我们设置了用户代理头,让服务器识别我们希望下载抓取数据的系统和浏览器。
A = ("Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2228.0 Safari/537.36",
"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2227.1 Safari/537.36",
"Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2227.0 Safari/537.36",
)
现在，我们需要向 URL 添加一个 GET 请求，以便从搜索结果中下载 HTML 内容。
requests.get(url, header)
此外，我们从下载的 HTML 内容中定制并获取所有的 Header 3 值。
举例:
import requests
from bs4 import BeautifulSoup
import random
text = 'science'
url = 'https://google.com/search?q=' + text
A1 = ("Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2228.0 Safari/537.36",
"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2227.1 Safari/537.36",
"Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2227.0 Safari/537.36",
)
Agent1 = A1[random.randrange(len(A1))]
headers = {'user-agent': Agent1}
requ = requests.get(url, headers=headers)
soup_obj = BeautifulSoup(requ.text, 'lxml')
for x in soup_obj.find_all('h3'):
print(x.text)
print('#######')
输出:
Science
#######
American Association for the Advancement of Science (Nonprofit organization)
#######
Science (Peer-reviewed journal)
#######
Science | AAAS
#######
Science
#######
Science - Wikipedia
#######
ScienceDirect.com | Science, health and medical journals
#######
science | Definition, Disciplines, & Facts | Britannica
#######
Science News | The latest news from all areas of science
#######
Science - Home | Facebook
#######
Science Magazine - YouTube
#######
Department Of Science & Technology
#######
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
更多与 Python 编程相关的帖子，请继续关注我们。
在那之前，学习愉快！！🙂
初学 Python 编程面试问题
原文：https://www.askpython.com/python/beginner-python-programming-interview-questions-beginners
Python 是一种动态类型的、通用的、垃圾收集的高级编程语言，它专注于读者友好的代码，并使用缩进来实现这一点。Python 支持多种范例，如过程式(逐步)、函数式和面向对象编程。
1991 年，Guido von Rossum 创作了 Python，它的灵感来自于英国喜剧团体 Monty Python 的飞行马戏团的名字。2008 年，Guido 决定，已经使用了很长时间的 Python 版本 2 有一些他和社区想要改变的东西。所以在 2008 年，他们决定开发 Python 3，这是该语言在 2008 年发布的新版本。Python 3 不向后兼容以前的版本。Python 版本 2 在 2020 年的版本 2.7.18 中停止了。
Python 如何执行代码？
当我们谈论 Python 语言时，我们指的是实现。本质上，我们不是在谈论语言本身，因为语言 Python 只是一个规范。你可以把它想象成某人写的一份文件，上面写着“嘿！当我写下单词 def 或 print 时，这在 Python 中意味着什么。但是翻译机器呢？我们可以有很多。不同的解释器，不同的编译器。
例如，当下载 Python 时，我们实际上是在下载 CPython ，因为它是用 C 编程语言编写的。这是一个用 C 写的程序，用来读取你的 Python 文件，然后在机器上运行它。但是还有其他实现。例如，有Jython 项目。这是一个用 Java 语言编写的翻译器。还有 PyPy ，用 Python 写的。所以，它是用 Python 写的解释器或翻译机。而且还有像 IronPython 这种为dot****net框架编写的东西。
我们从 Python 下载的时候，官方语言是 CPython 。我们正在下载遵循 Python 规范的解释器。但归根结底，它是由某人制造的机器，这些机器可以有多种形式。所以当大多数人谈论 Python 时，他们谈论的是为我们做翻译的 CPython 。我们通过解释器 CPython 运行的 Python 文件创建了一个叫做的字节码。解释器会在幕后自动为我们完成这项工作。
现在，一旦它创建了一个更接近机器码的字节码，它就使用运行这个代码的 CPython 虚拟机或 VM ，然后这个代码在我们的计算机、笔记本电脑、电话和许多其他设备上运行。因此，当我们从 www.python.org下载时，我们正在下载这两个部分，即解释器和 CPython VM ，我们可以运行 Python。
Python Code Execution
初学 Python 编程要知道的问题
Python 是整个科技行业最顶尖的编程语言之一。在本文中，我们将讨论 Python 面试中的一些重要问题。
1.展示一些例子来检查 Python 中不同数据类型的数字。
解决方案:
print(type(11))
print(type(11.05))
print(type(11.05j))
"""
Output:
<class 'int'>
<class 'float'>
<class 'complex'>
"""
2.用 Python 编写模/余数、指数和底数除法运算的示例。
解决方案:
num1 = int(input("Enter first number: "))
num2 = int(input("Enter second number: "))
print(f"Modulo/Remainder: {num1 % num2}")
print(f"Exponent: {num1 ** num2}")
print(f"Floor Division: {num1 // num2}")
"""
Output:
Enter first number: 10
Enter second number: 3
Modulo/Remainder: 1
Exponent: 1000
Floor Division: 3
"""
3.写一个程序，找出三个用户输入数字中最大的一个。
num1 = float(input("Enter first number: "))
num2 = float(input("Enter second number: "))
num3 = float(input("Enter third number: "))
if (num1 >= num2) and (num1 >= num3):
largest = num1
elif (num2 >= num1) and (num2 >= num3):
largest = num2
else:
largest = num3
print("The largest number is", largest)
"""
Output:
Enter first number: 45
Enter second number: 67
Enter third number: 23
The largest number is 67.0
"""
4.写一个函数来计算两个数的和。
解决方案:
def my_sum(num1, num2):
return num1 + num2
print(my_sum(10, 39)) # Output: 49
5.用 Python 写一个匿名函数，计算两个数相乘。
解决方案:
multiply_func = lambda num1, num2: num1 * num2
print(multiply_func(2, 6)) # Output: 12
6.编写一个 lambda 函数，将整数值转换为字符串值并打印输出。另外，检查输出类型。
解决方案:
conversion_func = lambda value: str(value)
result = conversion_func(123)
print(result) # Output: 123
print(type(result)) # Output: <class 'str'>
7.编写一个函数，它接受两个字符串类型的数字，并计算它们的和。
解决方案:
def my_sum(num1, num2):
return int(num1) + int(num2)
print(my_sum("21", "34")) # Output: 55
8.写一个函数来连接两个字符串输入。
解决方案:
concat_strings = lambda s1, s2: s1 + s2
print(concat_strings("123", "hello")) # Output: 123hello
print(concat_strings("67", "89")) # Output: 6789
如果你想更好地理解这个概念，我们还会更详细地介绍λ函数或匿名函数 。
9.写一个程序，接受两个字符串并打印较长的字符串。
解决方案:
def compare_func(str1, str2):
if len(str1) > len(str2):
return f"{str1} is longer than {str2}"
elif len(str1) < len(str2):
return f"{str2} is longer than {str1}"
elif len(str1) == len(str2):
return f"{str1} and {str2} have same length"
print(compare_func("three", "four"))
# Output: three is longer than four
print(compare_func("one", "two"))
# Output: one and two have same length
您还可以了解更多关于 Python 中的 if-else 块的信息，以便更好地掌握这段代码。
10.写一个程序，找出所有能被 9 整除，但不是 6 的倍数的数。数字应该在 300 到 500 之间(应该包括这两个数字)。结果应该打印在一行中，每个结果应该用逗号分隔。
解决方案:
my_list = []
for eachItem in range(300, 501):
if (eachItem % 9 == 0) and (eachItem % 6 != 0):
my_list.append(str(eachItem))
print(",".join(my_list))
"""
Output:
315,333,351,369,387,405,423,441,459,477,495
"""
这里我们使用 Python 中的 join 和 list append 函数。
11.写一个计算给定数字的阶乘的程序。
解决方案:
def factorial_function(arg):
if arg == 0:
return 1
return arg * factorial_function(arg - 1)
num = int(input("Enter a number: "))
print(f"Factorial {num} is {factorial_function(num)}")
"""
Output:
Enter a number: 7
Factorial 7 is 5040
"""
12.写一个程序打印一个字典，格式为{num, num*num*num}的键:值对。“num”是一个整数，应该由用户输入。结果字典应该包含输入整数的整个长度的结果:例如:如果输入是 5，那么结果应该是{1: 1, 2: 8, 3: 27, 4: 64, 5: 125}
解决方案:
num = int(input("Enter a number: "))
result_dictionary = dict()
for eachItem in range(1, num + 1):
result_dictionary[eachItem] = eachItem**3
print(result_dictionary)
"""
Output:
Enter a number: 5
{1: 1, 2: 8, 3: 27, 4: 64, 5: 125}
"""
13.写一个程序，从一个条目列表中请求输入，并把它转换成一个元组。显示两个序列。
解决方案:
input_items = input("Enter a list of items: ")
my_list = input_items.split(",")
my_tuple = tuple(my_list)
print(my_list)
print(my_tuple)
"""
Output:
Enter a list of items: apple,orange
['apple', 'orange']
('apple', 'orange')
"""
14.下面给出了一个对象类“Dog ”,它在构造函数中接受名字和年龄作为参数。为下列问题编写代码。
class Dog:
# constructor
def __init__(self, name, age):
self.name = name
self.age = age
# Class Object Attribute
scientific_name = "Canis lupus familiaris"
- 问题 1:列举 3 只狗的名字和年龄。
- 问题 2:打印出“scientific_name”属性。
- 问题 3:写一个函数找到最老的狗。
- 问题 4:打印如下:“最老的狗是 x 岁。”通过使用第三个问题的函数，x 将是最老的狗的年龄。
解决方案:
# 1 Instantiate the Dog object with 3 dogs
Dog1 = Dog("Arnold", 2)
Dog2 = Dog("Stan", 4)
Dog3 = Dog("Hufflepuff", 6)
# 2 Print out class attribute
print(f"The scientific name for Dog is {Dog.scientific_name}")
# 3 Create a function that finds the oldest dog
def oldest_dog(*args):
return max(args)
# 4 Print out: "The oldest dog is x years old." x will be the oldest dog's age by using the function from the third question."
print(f"The oldest dog is {oldest_dog(Dog1.age, Dog2.age, Dog3.age)} years old")
"""
Output:
The scientific name for Dog is Canis lupus familiaris
The oldest dog is 6 years old
"""
15.编写一个程序，接受一个句子作为输入，并按字母顺序打印出单词。在程序中利用列表理解。
解决方案:
words = [eachItem for eachItem in input("Enter a sentence: ").split(" ")]
words.sort()
print(f"Rearranged Sequence: {' '.join(words)}")
"""
Output:
Enter a sentence: hi how are you doing today
Rearranged Sequence: are doing hi how today you
"""
16.写一个程序，接受一个句子作为输入。该计划应删除重复的话，也安排/排序字母数字的话。
解决方案:
input_sentence = input("Enter a sentence: ")
words = [eachWord for eachWord in input_sentence.split(" ")]
print(" ".join(sorted(list(set(words)))))
"""
Output:
Enter a sentence: I felt happy because I saw the others were happy and because I knew I should feel happy
I and because feel felt happy knew others saw should the were
"""
17.编写一个计算输入句子的数字和字母的程序。
解决方案:
sentence = input("Enter a sentence with numbers as well: ")
letter_count, digit_count = 0, 0
for each in sentence:
if each.isalpha():
letter_count += 1
elif each.isnumeric():
digit_count += 1
print(
f"Number of letters: {letter_count}\nNumber of digits: {digit_count}"
)
"""
Output:
Enter a sentence with numbers as well: my name is alpha47
Number of letters: 13
Number of digits: 2
"""
18.写一个程序，计算一个输入句子中大写和小写字母的数量。
解决方案:
sentence = input("Enter a sentence with different cases: ")
num_upper, num_lower = 0, 0
for each in sentence:
num_lower += each.islower()
num_upper += each.isupper()
print(
f"Numer of Upper Case Letters: {num_upper}\nNumer of Lower Case Letters: {num_lower}"
)
"""
Output:
Enter a sentence with different cases: HELLO My Name is QUINN
Numer of Upper Case Letters: 12
Numer of Lower Case Letters: 6
"""
19.编写一个程序来计算序列(z+ZZ+zzz+zzzz+zzzz)的值，其中“z”是用户输入的数字。
解决方案:
def calc_func(num):
return sum(int(num * n) for n in range(1, 6))
digit_value = input("Enter a digit between 0 to 9: ")
print(f"The sequence total is: {calc_func(digit_value)}")
"""
Output:
Enter a digit between 0 to 9: 7
The sequence total is: 86415
"""
20.使用 Python functools 模块中的 reduce 函数，编写一个程序来计算序列(z + zz + zzz + zzzz + zzzzz)的值，其中“z”是用户输入的数字。
解决方案:
from functools import reduce
input_digit = input("Enter a digit between 0 to 9: ")
total = reduce(
lambda accumulator, eachItem: int(accumulator) + int(eachItem),
[input_digit * i for i in range(1, 6)],
)
print(f"The sequence total with the reduce function is: {total}")
"""
Output:
Enter a digit between 0 to 9: 7
The sequence total with the reduce function is: 86415
"""
21.从用户提供的数字列表中，编写一个程序来查找偶数并打印立方体。
解决方案:
my_list = input("Enter a list of numbers: ")
only_even_cubed_list = [
str(int(eachNum) ** 3) for eachNum in my_list.split(",") if int(eachNum) % 2 == 0
]
print(f"The new list is: {','.join(only_even_cubed_list)}")
"""
Output:
Enter a list of numbers: 3,5,2,7,8
The new list is: 8,512
"""
22.编写一个程序，根据输入的交易金额计算银行账户中的金额。
解决方案:
acc_balance = 0
confirm_msg = "Account balance Updated Successfully!"
while True:
user_request = input(
"B for Balance|| D for Deposit || W for Withdraw || E for Exit: "
).lower()
if user_request == "d":
add_balance = input("Enter deposit amount: ")
acc_balance = acc_balance + int(add_balance)
print(confirm_msg)
elif user_request == "w":
withdraw_amount = input("Enter withdrawal amount: ")
acc_balance = acc_balance - int(withdraw_amount)
print(confirm_msg)
elif user_request == "b":
print(acc_balance)
else:
quit()
"""
Output:
B for Balance|| D for Deposit || W for Withdraw || E for Exit: d
Enter deposit amount: 1200
Account balance Updated Successfully!
B for Balance|| D for Deposit || W for Withdraw || E for Exit: w
Enter withdrawal amount: 500
Account balance Updated Successfully!
B for Balance|| D for Deposit || W for Withdraw || E for Exit: b
700
B for Balance|| D for Deposit || W for Withdraw || E for Exit: e
"""
23.编写一个 Python 类和一个生成器，它可以遍历一系列可被 3 整除的数字，并打印出这些数字。
解决方案:
class CalcFunc:
def three_divisor(self, num):
for eachNum in range(1, num + 1):
if eachNum % 3 == 0:
yield eachNum
my_instance = CalcFunc()
user_number = int(input("Enter a number: "))
generator_function = my_instance.three_divisor(user_number)
for eachItem in generator_function:
print(eachItem)
"""
Output:
Enter a number: 10
3
6
9
"""
24.写一个程序来计算每个单词在用户输入中出现的次数。此外，打印按字母数字排序的结果。请参见下面的输入和输出语句示例。
Input: I bought 3 oranges and finished eating all 3 of them.
Expected Output:
'3' x 2 times
'I' x 1 times
'all' x 1 times
'and' x 1 times
'bought' x 1 times
'eating' x 1 times
'finished' x 1 times
'of' x 1 times
'oranges' x 1 times
'them.' x 1 times
解决方案:
user_input_sentence = input("Enter a sentence: ")
splitted = user_input_sentence.split()
unique_and_sorted = sorted(set(splitted))
for eachItem in unique_and_sorted:
print(f"'{eachItem}' x {user_input_sentence.count(eachItem)} times")
"""
Output:
Enter a sentence: I bought 3 oranges and finished eating all 3 of them.
'3' x 2 times
'I' x 1 times
'all' x 1 times
'and' x 1 times
'bought' x 1 times
'eating' x 1 times
'finished' x 1 times
'of' x 1 times
'oranges' x 1 times
'them.' x 1 times
"""
25.如何才能看到 Python 内置的函数文档？举例说明。此外，为自定义函数编写一个文档。
- 检查内置函数的文档
print(float.__doc__)
# Output: Convert a string or number to a floating point number, if possible.
print(abs.__doc__)
# Output: Return the absolute value of the argument.
- 自定义函数与文档
def cube(num):
"""
Docstring: Returns the cube of a number
"""
return num**3
print(cube(5))
print(cube.__doc__)
"""
Output:
125
Docstring: Returns the cube of a number
"""
26.写一个程序把摄氏温度转换成华氏温度，反之亦然。公式:Celcius = (5 / 9) * (Fahrenheit - 32)
解决方案:
input_temperature = float(input("Enter a temperature value: "))
input_unit = input(
"Choose a unit for the above temperature: C for Celcuis || F for Fahrenheit: "
)
if input_unit == "C" or input_unit == "c":
temp_in_F_units = 9 / 5 * input_temperature + 32
print(f"Temperature in Fahrenheit is {temp_in_F_units}")
elif input_unit == "F" or input_unit == "f":
temp_in_C_units = 5 / 9 * (input_temperature - 32)
print(f"Temperature in Celsius is {temp_in_C_units}")
else:
print("Invalid unit provided")
"""
Output:
Enter a temperature value: 40
Choose a unit for the above temperature: C for Celcuis || F for Fahrenheit: c
Temperature in Fahrenheit is 104.0
"""
27.写一个程序来计算作为输入参数的前 n 个自然数的立方之和。
解决方案:
def series_summation_func(num):
accumulated_sum = 0
for eachNum in range(1, num + 1):
accumulated_sum += eachNum**3
return accumulated_sum
print(series_summation_func(4)) # Output: 100
print(series_summation_func(5)) # Output: 225
28.写一个程序来检查用户输入的数字是否是质数。
解决方案:
user_input = int(input("Please enter a number: "))
is_prime = True
if user_input > 1:
# Factor Checking
for each in range(2, user_input):
if user_input % each == 0:
is_prime = False
break
if is_prime:
print(f"{user_input} is a prime number.")
else:
print(f"{user_input} is a not prime number.")
"""
Output:
Please enter a number: 23
23 is a prime number.
"""
29.写一个函数来计算用户输入半径的圆的面积。
解决方案:
def calc_circle_area(radius):
PI = 3.147
return PI * (radius**2)
input_radius = float(input("Please enter a radius value: "))
print(f"Area of the circle is {calc_circle_area(input_radius)} ")
"""
Output:
Please enter a radius value: 10
Area of the circle is 314.7
"""
30.写一个程序，从给定的数字列表中找出最高的偶数。
解决方案:
my_list = [11, 2, 3, 4, 14, 8, 10]
def highest_even_func(lst):
even_list = []
for eachItem in lst:
if eachItem % 2 == 0:
even_list.append(eachItem)
return max(lst)
val = highest_even_func(my_list)
print(f"Highest even number in the list is {val}")
# Output: Highest even number in the list is 14
31.编写一个程序，从给定的列表中查找重复项，并在新列表中打印这些项。
解决方案:
my_list = ["a", "a", "b", "c", "a", "e", "d", "c", "c", "e"]
list_of_duplicates = []
for eachItem in my_list:
if my_list.count(eachItem) > 1:
if eachItem not in list_of_duplicates:
list_of_duplicates.append(eachItem)
print(list_of_duplicates) # Output: ['a', 'c', 'e']
32.使用 list comprehension，编写与上面相同的程序，从给定的列表中打印出一个新的重复项列表。
解决方案:
some_random_list = ["b", "n", "m", "n", "a", "b", "c"]
list_with_duplicate_items = list(
set([value for value in some_random_list if some_random_list.count(value) > 1])
)
print(list_with_duplicate_items)
# Output: ['b', 'n']
33.编写一个程序，转换所有列表项的 2 次幂，并输出一个新列表。
解决方案:
my_list = [12, 10, 31, 4, 7]
def squared(item):
return item**2
mapped = map(squared, my_list)
print(f"Original List: {my_list}")
print(f"Squared List: {list(mapped)}")
"""
Output:
Original List: [12, 10, 31, 4, 7]
Squared List: [144, 100, 961, 16, 49]
"""
34.Python 中的 reduce 函数是如何使用的？举个例子。
解决方案:
from functools import reduce
my_list = [1, 2, 3, 4]
def add_numbers(accumulator, number):
return accumulator + number
# reduce(function, iterable, initial_value)
result_obtained = reduce(add_numbers, my_list, 10)
print(f"Accumulated Result is {result_obtained}")
# Output: Accumulated Result is 20
35.写一个程序来检查一个输入字符串是否是回文。
解决方案:
my_str = input("Enter a string: ")
my_str = my_str.lower()
rev_str = reversed(my_str)
if list(my_str) == list(rev_str):
print("The input string is a palindrome.")
else:
print("The input string is not a palindrome.")
"""
Output:
Enter a string: MAlAYaLAm
The input string is a palindrome.
"""
结论
这些是 Python 面试中的一些顶级编程问题。掌握解决特定问题的基本概念和语法是非常重要的。最重要的是，要想擅长编码，需要花费相当多的时间和努力。所以，祝你的编码面试好运，我希望这篇文章能以某种方式帮助你更好地解决 Python 编程问题。编码快乐！
使用半监督学习(SSL)训练带有未标记数据的分类器模型的初学者教程
传统上，训练像分类器这样的计算机视觉模型需要标记数据。训练数据中的每个示例都需要成对出现:一个图像和一个描述该图像的人工生成的标签。
最近，新的 SSL 技术为 Imagenet 等经典挑战提供了计算机视觉中最准确的模型。半监督学习(SSL)允许模型从标记和未标记的数据中学习。无标签数据仅由图像组成，没有任何标签。
SSL 很棒，因为通常未标记的数据比标记的数据多得多，尤其是当您将模型部署到生产环境中时。此外，SSL 减少了标记的时间、成本和工作量。
但是一个模型如何从没有标签的图像中学习呢？关键的洞见是图像本身有信息。SSL 的神奇之处在于，它可以通过根据图像的结构自动对相似的图像进行聚类，从未标记的数据中提取信息，这种聚类为模型提供了额外的学习信息。
本教程使用 Google Colab 中包含的几个常见 Python 库，包括 matplotlib、numpy 和 TensorFlow。如果你需要安装它们，你通常可以在 Jupyter 笔记本中运行!pip install --upgrade pip; pip install matplotlib numpy tensorflow或者从命令行运行pip install --upgrade pip; pip install matplotlib numpy tensorflow(没有感叹号)。
如果你使用的是 Google Colab，一定要把运行时类型改成 GPU。
对于本教程，让我们在 CIFAR-10 数据集上训练一个分类器。这是自然图像的经典研究数据集。让我们把它装上来看看。我们将在 CIFAR-10 中看到一些职业:青蛙、船、汽车、卡车、鹿、马、鸟、猫、狗和飞机。
import matplotlib.pyplot as plt
def plot_images(images):
"""Simple utility to render images."""
# Visualize the data.
_, axarr = plt.subplots(5, 5, figsize=(15,15))
for row in range(5):
for col in range(5):
image = images[row*5 + col]
axarr[row, col].imshow(image)
import tensorflow as tf
NUM_CLASSES = 10
# Load the data using the Keras Datasets API.
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.cifar10.load_data()
plot_images(x_test)
创建模型
通常，您会想要使用现成的模型架构。这为您节省了摆弄模型架构设计的努力。模型大小调整的一般规则是选择一个足够大的模型来处理您的数据，但不要大到在推理时很慢。对于像 CIFAR-10 这样非常小的数据集，我们将使用一个非常小的模型。对于具有较大图像大小的较大数据集，高效网络系列是一个不错的选择。
def get_model():
return tf.keras.applications.MobileNet(input_shape=(32,32,3),
weights=None,
classes=NUM_CLASSES,
classifier_activation=None)
model = get_model()
准备数据
现在，让我们通过将标签(表示 10 类对象的从 0 到 9 的整数)转换成像[1，0，0，0，0，0，0，0，0，0，0]和[0，0，0，0，0，0，0，0，1]这样的单热点向量来准备数据。我们还将把图像像素更新到模型架构所期望的范围，即范围[-1，1]。
def normalize_data(x_train, y_train, x_test, y_test):
"""Utility to normalize the data into standard formats."""
# Update the pixel range to [-1,1], which is expected by the model architecture.
x_train = x = tf.keras.applications.mobilenet.preprocess_input(x_train)
x_test = x = tf.keras.applications.mobilenet.preprocess_input(x_test)
# Convert to one-hot labels.
y_train = tf.keras.utils.to_categorical(y_train, NUM_CLASSES)
y_test = tf.keras.utils.to_categorical(y_test, NUM_CLASSES)
return x_train, y_train, x_test, y_test
x_train, y_train, x_test, y_test = \
normalize_data(x_train, y_train, x_test, y_test)
该数据集包括 50，000 个示例。我们用其中的 5000 张作为标记图片，20000 张作为未标记图片。
import numpy as np
def prepare_data(x_train, y_train, num_labeled_examples, num_unlabeled_examples):
"""Returns labeled and unlabeled datasets."""
num_examples = x_train.size
assert num_labeled_examples + num_unlabeled_examples <= num_examples
# Generate some random indices.
dataset_size = len(x_train)
indices = np.array(range(dataset_size))
generator = np.random.default_rng(seed=0)
generator.shuffle(indices)
# Split the indices into two sets: one for labeled, one for unlabeled.
labeled_train_indices = indices[:num_labeled_examples]
unlabeled_train_indices = indices[num_labeled_examples : num_labeled_examples + num_unlabeled_examples]
x_labeled_train = x_train[labeled_train_indices]
y_labeled_train = y_train[labeled_train_indices]
x_unlabeled_train = x_train[unlabeled_train_indices]
# Since this is unlabeled, we won't need a y_labeled_data.
return x_labeled_train, y_labeled_train, x_unlabeled_train
NUM_LABELED = 5000
NUM_UNLABELED = 20000
x_labeled_train, y_labeled_train, x_unlabeled_train = \
prepare_data(x_train,
y_train,
num_labeled_examples=NUM_LABELED,
num_unlabeled_examples=NUM_UNLABELED)
del x_train, y_train
基线训练
为了测量 SSL 带来的性能改进，让我们首先使用没有 SSL 的标准训练循环来测量模型的性能。
让我们用一些基本的数据增强来建立一个标准的训练循环。数据扩充是一种正则化，它可以防止过度拟合，并允许您的模型更好地概括从未见过的数据。
下面的超参数值(学习率、时期、批量等)是普通默认值和手动调整值的组合。
结果是一个大约 45%准确的模型。(记得看验证精度，不是训练精度)。我们的下一个任务将是弄清楚我们是否可以使用 SSL 来提高模型的准确性。
model.compile(
optimizer=tf.keras.optimizers.Adam(),
loss=tf.keras.losses.CategoricalCrossentropy(from_logits=True),
metrics=[tf.keras.metrics.CategoricalAccuracy()],
)
# Setup Keras augmentation.
datagen = tf.keras.preprocessing.image.ImageDataGenerator(
featurewise_center=False,
featurewise_std_normalization=False,
horizontal_flip=True)
datagen.fit(x_labeled_train)
batch_size = 64
epochs = 30
model.fit(
x = datagen.flow(x_labeled_train, y_labeled_train, batch_size=batch_size),
shuffle=True,
validation_data=(x_test, y_test),
batch_size=batch_size,
epochs=epochs,
)
baseline_metrics = model.evaluate(x=x_test, y=y_test, return_dict=True)
print('')
print(f"Baseline model accuracy: {baseline_metrics['categorical_accuracy']}")
输出:
Epoch 1/30
79/79 [==============================] - 4s 23ms/step - loss: 2.4214 - categorical_accuracy: 0.1578 - val_loss: 2.3047 - val_categorical_accuracy: 0.1000
Epoch 2/30
79/79 [==============================] - 1s 16ms/step - loss: 2.0831 - categorical_accuracy: 0.2196 - val_loss: 2.3063 - val_categorical_accuracy: 0.1000
Epoch 3/30
79/79 [==============================] - 1s 16ms/step - loss: 1.9363 - categorical_accuracy: 0.2852 - val_loss: 2.3323 - val_categorical_accuracy: 0.1000
Epoch 4/30
79/79 [==============================] - 1s 16ms/step - loss: 1.8324 - categorical_accuracy: 0.3174 - val_loss: 2.3496 - val_categorical_accuracy: 0.1000
Epoch 5/30
79/79 [==============================] - 1s 16ms/step - loss: 1.8155 - categorical_accuracy: 0.3438 - val_loss: 2.3339 - val_categorical_accuracy: 0.1000
Epoch 6/30
79/79 [==============================] - 1s 15ms/step - loss: 1.6477 - categorical_accuracy: 0.3886 - val_loss: 2.3606 - val_categorical_accuracy: 0.1000
Epoch 7/30
79/79 [==============================] - 1s 15ms/step - loss: 1.6120 - categorical_accuracy: 0.4100 - val_loss: 2.3585 - val_categorical_accuracy: 0.1000
Epoch 8/30
79/79 [==============================] - 1s 16ms/step - loss: 1.5884 - categorical_accuracy: 0.4220 - val_loss: 2.1796 - val_categorical_accuracy: 0.2519
Epoch 9/30
79/79 [==============================] - 1s 18ms/step - loss: 1.5477 - categorical_accuracy: 0.4310 - val_loss: 1.8913 - val_categorical_accuracy: 0.3145
Epoch 10/30
79/79 [==============================] - 1s 15ms/step - loss: 1.4328 - categorical_accuracy: 0.4746 - val_loss: 1.7082 - val_categorical_accuracy: 0.3696
Epoch 11/30
79/79 [==============================] - 1s 16ms/step - loss: 1.4328 - categorical_accuracy: 0.4796 - val_loss: 1.7679 - val_categorical_accuracy: 0.3811
Epoch 12/30
79/79 [==============================] - 2s 20ms/step - loss: 1.3962 - categorical_accuracy: 0.5020 - val_loss: 1.8994 - val_categorical_accuracy: 0.3690
Epoch 13/30
79/79 [==============================] - 1s 16ms/step - loss: 1.3271 - categorical_accuracy: 0.5156 - val_loss: 2.0416 - val_categorical_accuracy: 0.3688
Epoch 14/30
79/79 [==============================] - 1s 17ms/step - loss: 1.2711 - categorical_accuracy: 0.5374 - val_loss: 1.9231 - val_categorical_accuracy: 0.3848
Epoch 15/30
79/79 [==============================] - 1s 15ms/step - loss: 1.2312 - categorical_accuracy: 0.5624 - val_loss: 1.9006 - val_categorical_accuracy: 0.3961
Epoch 16/30
79/79 [==============================] - 1s 19ms/step - loss: 1.2048 - categorical_accuracy: 0.5720 - val_loss: 2.0102 - val_categorical_accuracy: 0.4102
Epoch 17/30
79/79 [==============================] - 1s 16ms/step - loss: 1.1365 - categorical_accuracy: 0.6000 - val_loss: 2.1400 - val_categorical_accuracy: 0.3672
Epoch 18/30
79/79 [==============================] - 1s 18ms/step - loss: 1.1992 - categorical_accuracy: 0.5840 - val_loss: 2.1206 - val_categorical_accuracy: 0.3933
Epoch 19/30
79/79 [==============================] - 2s 25ms/step - loss: 1.1438 - categorical_accuracy: 0.6012 - val_loss: 2.4035 - val_categorical_accuracy: 0.4014
Epoch 20/30
79/79 [==============================] - 2s 24ms/step - loss: 1.1211 - categorical_accuracy: 0.6018 - val_loss: 2.0224 - val_categorical_accuracy: 0.4010
Epoch 21/30
79/79 [==============================] - 2s 21ms/step - loss: 1.0425 - categorical_accuracy: 0.6358 - val_loss: 2.2100 - val_categorical_accuracy: 0.3911
Epoch 22/30
79/79 [==============================] - 1s 16ms/step - loss: 1.1177 - categorical_accuracy: 0.6116 - val_loss: 1.9892 - val_categorical_accuracy: 0.4285
Epoch 23/30
79/79 [==============================] - 1s 19ms/step - loss: 1.0236 - categorical_accuracy: 0.6412 - val_loss: 2.1216 - val_categorical_accuracy: 0.4211
Epoch 24/30
79/79 [==============================] - 1s 18ms/step - loss: 0.9487 - categorical_accuracy: 0.6714 - val_loss: 2.0135 - val_categorical_accuracy: 0.4307
Epoch 25/30
79/79 [==============================] - 1s 16ms/step - loss: 1.1877 - categorical_accuracy: 0.5876 - val_loss: 2.3732 - val_categorical_accuracy: 0.3923
Epoch 26/30
79/79 [==============================] - 2s 20ms/step - loss: 1.0639 - categorical_accuracy: 0.6288 - val_loss: 1.9291 - val_categorical_accuracy: 0.4291
Epoch 27/30
79/79 [==============================] - 2s 19ms/step - loss: 0.9243 - categorical_accuracy: 0.6882 - val_loss: 1.8552 - val_categorical_accuracy: 0.4343
Epoch 28/30
79/79 [==============================] - 1s 15ms/step - loss: 0.9784 - categorical_accuracy: 0.6656 - val_loss: 2.0175 - val_categorical_accuracy: 0.4386
Epoch 29/30
79/79 [==============================] - 1s 17ms/step - loss: 0.9316 - categorical_accuracy: 0.6800 - val_loss: 1.9916 - val_categorical_accuracy: 0.4305
Epoch 30/30
79/79 [==============================] - 1s 17ms/step - loss: 0.8816 - categorical_accuracy: 0.7054 - val_loss: 2.0281 - val_categorical_accuracy: 0.4366
313/313 [==============================] - 1s 3ms/step - loss: 2.0280 - categorical_accuracy: 0.4366
Baseline model accuracy: 0.436599999666214
使用 SSL 进行培训
现在，让我们看看是否可以通过向训练数据中添加未标记的数据来提高模型的准确性。我们将使用 Masterful，一个为像我们的分类器这样的计算机视觉模型实现 SSL 的平台。
让我们安装 Masterful。在 Google Colab 中，我们可以从笔记本电脑上进行 pip 安装。我们也可以通过命令行安装它。更多详情，请参见专业安装指南。
!pip install --upgrade pip
!pip install masterful
import masterful
masterful = masterful.register()
输出:
Loaded Masterful version 0.4.1\. This software is distributed free of
charge for personal projects and evaluation purposes.
See http://www.masterfulai.com/personal-and-evaluation-agreement for details.
Sign up in the next 45 days at https://www.masterfulai.com/get-it-now
to continue using Masterful.
设置高手
现在，让我们设置一些 Masterful 的配置参数。
# Start fresh with a new model
tf.keras.backend.clear_session()
model = get_model()
# Tell Masterful that your model is performing a classification task
# with 10 labels and that the image pixel range is
# [-1,1]. Also, the model outputs logits rather than a softmax activation.
model_params = masterful.architecture.learn_architecture_params(
model=model,
task=masterful.enums.Task.CLASSIFICATION,
input_range=masterful.enums.ImageRange.NEG_ONE_POS_ONE,
num_classes=NUM_CLASSES,
prediction_logits=True,
)
# Tell Masterful that your labeled training data is using one-hot labels.
labeled_training_data_params = masterful.data.learn_data_params(
dataset=(x_labeled_train, y_labeled_train),
task=masterful.enums.Task.CLASSIFICATION,
image_range=masterful.enums.ImageRange.NEG_ONE_POS_ONE,
num_classes=NUM_CLASSES,
sparse_labels=False,
)
unlabeled_training_data_params = masterful.data.learn_data_params(
dataset=(x_unlabeled_train,),
task=masterful.enums.Task.CLASSIFICATION,
image_range=masterful.enums.ImageRange.NEG_ONE_POS_ONE,
num_classes=NUM_CLASSES,
sparse_labels=None,
)
# Tell Masterful that your test/validation data is using one-hot labels.
test_data_params = masterful.data.learn_data_params(
dataset=(x_test, y_test),
task=masterful.enums.Task.CLASSIFICATION,
image_range=masterful.enums.ImageRange.NEG_ONE_POS_ONE,
num_classes=NUM_CLASSES,
sparse_labels=False,
)
# Let Masterful meta-learn ideal optimization hyperparameters like
# batch size, learning rate, optimizer, learning rate schedule, and epochs.
# This will speed up training.
optimization_params = masterful.optimization.learn_optimization_params(
model,
model_params,
(x_labeled_train, y_labeled_train),
labeled_training_data_params,
)
# Let Masterful meta-learn ideal regularization hyperparameters. Regularization
# is an important ingredient of SSL. Meta-learning can
# take a while so we'll use a precached set of parameters.
# regularization_params = \
# masterful.regularization.learn_regularization_params(model,
# model_params,
# optimization_params,
# (x_labeled_train, y_labeled_train),
# labeled_training_data_params)
regularization_params = masterful.regularization.parameters.CIFAR10_SMALL
# Let Masterful meta-learn ideal SSL hyperparameters.
ssl_params = masterful.ssl.learn_ssl_params(
(x_labeled_train, y_labeled_train),
labeled_training_data_params,
unlabeled_datasets=[((x_unlabeled_train,), unlabeled_training_data_params)],
)
输出:
MASTERFUL: Learning optimal batch size.
MASTERFUL: Learning optimal initial learning rate for batch size 256.
火车！
现在，我们准备使用 SSL 技术进行培训！我们会把叫做 masterful.training.train ，这是 masterful 的训练引擎的入口。
training_report = masterful.training.train(
model,
model_params,
optimization_params,
regularization_params,
ssl_params,
(x_labeled_train, y_labeled_train),
labeled_training_data_params,
(x_test, y_test),
test_data_params,
unlabeled_datasets=[((x_unlabeled_train,), unlabeled_training_data_params)],
)
输出:
MASTERFUL: Training model with semi-supervised learning enabled.
MASTERFUL: Performing basic dataset analysis.
MASTERFUL: Training model with:
MASTERFUL: 5000 labeled examples.
MASTERFUL: 10000 validation examples.
MASTERFUL: 0 synthetic examples.
MASTERFUL: 20000 unlabeled examples.
MASTERFUL: Training model with learned parameters partridge-boiled-cap in two phases.
MASTERFUL: The first phase is supervised training with the learned parameters.
MASTERFUL: The second phase is semi-supervised training to boost performance.
MASTERFUL: Warming up model for supervised training.
MASTERFUL: Warming up batch norm statistics (this could take a few minutes).
MASTERFUL: Warming up training for 500 steps.
100%|██████████| 500/500 [00:47<00:00, 10.59steps/s]
MASTERFUL: Validating batch norm statistics after warmup for stability (this could take a few minutes).
MASTERFUL: Starting Phase 1: Supervised training until the validation loss stabilizes...
Supervised Training: 100%|██████████| 6300/6300 [02:33<00:00, 41.13steps/s]
MASTERFUL: Starting Phase 2: Semi-supervised training until the validation loss stabilizes...
MASTERFUL: Warming up model for semi-supervised training.
MASTERFUL: Warming up batch norm statistics (this could take a few minutes).
MASTERFUL: Warming up training for 500 steps.
100%|██████████| 500/500 [00:23<00:00, 20.85steps/s]
MASTERFUL: Validating batch norm statistics after warmup for stability (this could take a few minutes).
Semi-Supervised Training: 100%|██████████| 11868/11868 [08:06<00:00, 24.39steps/s]
分析结果
您传递到 masterful.training.train 中的模型现在已经训练并更新到位，因此您可以像评估任何其他训练过的 Keras 模型一样评估它。
masterful_metrics = model.evaluate(
x_test, y_test, return_dict=True, verbose=0
)
print(f"Baseline model accuracy: {baseline_metrics['categorical_accuracy']}")
print(f"Masterful model accuracy: {masterful_metrics['categorical_accuracy']}")
输出:
Baseline model accuracy: 0.436599999666214
Masterful model accuracy: 0.558899998664856
可视化结果
如您所见，您将准确率从大约 0.45 提高到了 0.56。当然，更严格的研究将试图消除基线训练和通过 Masterful 平台使用 SSL 的训练之间的其他差异，以及重复几次运行并生成误差线和 p 值。现在，让我们确保将它绘制成图表，以帮助解释我们的结果。
import matplotlib.cm as cm
from matplotlib.colors import Normalize
data = (baseline_metrics['categorical_accuracy'], masterful_metrics['categorical_accuracy'])
fig, ax = plt.subplots(1, 1)
ax.bar(range(2), data, color=('gray', 'red'))
plt.xlabel("Training Method")
plt.ylabel("Accuracy")
plt.xticks((0,1), ("baseline", "SSL with Masterful"))
plt.show()
结论
恭喜你。我们刚刚成功地采用了 SSL，这是目前最先进的培训方法之一，通过一个简单的教程来提高您的模型准确性。一路走来，你避免了贴标签的成本和努力。
SSL 不仅仅适用于分类——各种风格适用于几乎任何计算机视觉任务。要更深入地了解这个主题，并了解 SSL 在对象检测中的作用，请查看其他教程这里。
学习 Python 的 10 个无可争议的好处
原文：https://www.askpython.com/python/benefits-of-learning-python
今天，人们无法反驳那些认为学习编程语言非常重要的人。世界各地的人们使用智能技术来执行特定编程代码提供的各种命令。Javascript、C++、Python 和其他编程语言在每个国家都很流行。需要 Python 作业的学生需要专家的帮助，努力掌握代码，在 21 世纪的就业市场上变得有竞争力。为什么 Python 学习如此有益？有十大原因可以解释这一趋势。
原因 1。Python 属于最简单的编码语言
如果一个初学者想掌握一些编码，从 Python 开始会比较好。专家列举了需要这种编码的项目的三个积极特征:
- 很容易读懂；
- 很好写；
- 记住它很容易。
换句话说，这种编程语言并不太复杂。原因是它与英语句法相似。它的开发者使它对用户友好。与许多其他代码不同，它包含空格，并且是逐行书写的。所以，每个人都能理解它所说的。
许多教育机构将 Python 作为 STEM 课程的一部分。根据助手的经验，教孩子们使用这种计算机语言很容易。于是，年轻的学生成为了没有高校的 Python 专业人士。他们变成了有前途的学生，可以掌握其他代码，成为成功的 IT 专家或程序员。
原因二。它属于就业市场上需求量最大的代码
2020 年，Python 领域的专家程序员的平均工资为 119.082 美元！它是列表中的第二个(第一个选择了 Ruby professionals)。如果一个人很了解 Python，那么他可以赚很多钱，而且找工作也没有问题。即使这项研究被证明是昂贵的，它也肯定是对一个人未来的明智和有前景的投资。程序员属于 21 世纪收入最高的职业。
原因三。高水平的生产力
一些编码语言要求程序员深刻理解它们的行为和语法。Python 赋值需要更少的编码，但由于这种简单性，有望更快地解决问题。因此，学生们写得很少，但是与其他编码语言相比，这个程序做得更多。
原因四。智能技术涉及 Python
智能手机、智能房屋、智能汽车和其他技术都涉及人工智能。反过来，人工智能涉及 Python 编码，以顺利运行，正如它应该的那样。这种语言有丰富的框架和库，所以它简化了设备的创建和设置。
原因五。它不需要针对不同平台的额外代码
经常发生的情况是，人们在各种平台上使用 C++时，每次移位时都要修改。Python 最有益的特性是无需任何改动就可以在所有平台上运行。它保证了从 Linux 到 Windows，以及从 Windows 到 MacOS 的出色可移植性。
原因六。将数据转化为有用信息的完美工具
当一个人收集事件的日期和描述时，他或她将获得数据。如果一个人把接收到的数据系统化，就会得到信息。Python 与数据科学这样一门时髦的学科紧密相关。专业人员使用 Python 将数据转换成信息，帮助解决一些紧急问题。
例如，专家们设法为西南航空公司削减了燃料费用，降低了空气污染水平，并缩短了飞机的闲置时间。有三个问题，但是一个专家设法用一个程序解决了它们并且节省了钱。知道 Python 编码所有秘密的人成为最渴望的员工。这就是现实。
原因 7。各种可用的库
受限的情况下很难写代码。有时，一个人需要使用外部库来提供家庭作业或工作任务所需的功能。在这种情况下，Python 是一个包罗万象的代码。有如此多的库支持它，以至于一个人在执行任务时不会遇到任何困难。
如果需要一些外部选项，这个代码有一个出色的包管理器。人们可以快速方便地从 PyPi 导入一个人需要的包。
原因 8。在 STEM 服务中工作
学生们经常寻找可以帮助他们做作业的 STEM 服务。专家的帮助是需要的，而且报酬很高。如果你在搜索栏中输入“谁能做我的作业”,你的搜索引擎会提供处理这类作业的相关服务的链接。所以，这是另一个越来越受欢迎的职业机会。
原因 9。更简单的误差校正
一个程序必须没有错误才能执行要求的任务。当一个人使用 Python 时，他(她)一行一行地写。它保证了动态典型。如果出现错误，系统会通知创建者。有时一个人因为这个而无法继续写作。所以，它能让人一次搞定一切。此外，系统只通知一个错误，即使学生或程序员犯了几个错误。由于这一点，调试代码的速度更快，并且只专注于一个问题，防止完全混乱。
理由 10。简单免费分发
这种编码语言拥有开源许可，并得到了开放系统公司的批准。所以，一个人可以免费使用，也可以分享。任何人都可以下载所需的代码，并根据自己的需要进行修改。随后，创建者可以毫无问题地分发修改后的 Python 版本。这个选项对于想要修改一些行为和用升级的代码开发一些部分的公司是有益的。
外卖食品
随意用一切可能的方式努力学习 Python。Python 是一种优秀的通用编码语言，因为它简单易用。有些人不喜欢它，因为它比其他程序慢一点。尽管如此，这一功能并没有破坏它的声誉，并使其成为顶级的。学习者可以尝试其他编码语言，对比 Python 和其他现有的计算机语言。既适合新手，也适合有经验的程序员。
Python 编程的十大最佳笔记本电脑——购买指南
原文：https://www.askpython.com/python/examples/best-laptop-for-python-programming
您正在寻找 Python 编程的最佳笔记本电脑吗？如果是的话，那么这篇文章就是为你准备的，在这里我们回顾了 10 款最适合 Python 编程的笔记本电脑。在我们的专家团队根据性能进行全面研究后，所有以下功能的笔记本电脑都进入了候选名单。
从互联网上众多优秀的笔记本电脑中找到最好的并不容易。
让我们暂时把这方面放在一边，想想编程笔记本电脑的电池和实时性能。我们相信你不太可能很容易就找到一台全能的笔记本电脑。我们带着这个指南来帮助你找到最适合你的 python 编程笔记本电脑。
为日常生活选择一台好的笔记本电脑一直是一件令人头疼的事情，另一方面，它让你更加意识到应该搭配什么。由于互联网变得越来越流行，现在每个人都知道如何找到一个好的产品，但他们中的大多数人无法选择合适的一个。
因此，为了让您摆脱这种困境，今天我们以合理的价格列出了最好的 python 编程笔记本电脑。但是，如果你赶时间，这里是我们的最佳推荐。
[amazon box="B08N5M7S6K，B08SW1LTST，b 088 wkz 678 " template = " table "]
10 款最适合 Python 编程的笔记本电脑综述
1。苹果 MacBook Air
[aawp fields = " b 08n 5m 7s 6k " value = " thumb " image _ size = " large " image _ align = " center "]
规格
- 中央处理器:苹果 M1
- GPU:集成 7 核/8 核 GPU
- 内存:8GB–16GB
- 屏幕:13.3 英寸(对角线)2，560 x 1，600 LED 背光显示屏，采用 IPS 技术
- 存储:256 GB–2TB 固态硬盘
新的苹果 MacBook Air M1-2020 是编程的最佳笔记本电脑，这要归功于基于 ARM 的苹果 M1 芯片。最近，苹果放弃了英特尔，转而推出新的笔记本电脑和台式机系列，他们推出了这款出色的、首屈一指的 M1 芯片，为新款 MacBook 提供动力。
苹果笔记本电脑的性能是众所周知的，这是任何其他笔记本电脑无法相比的。这款新的 MacBook 2020 配备了一些有趣的功能，如强大的可定制 RAM、容量高达 2TB 的强大而快速的 SSD，最重要的是，电池续航时间超过 11 小时。
这意味着一天充一次电，你就可以开始了。我们最欣赏的一点是其时尚美观的设计，使其更具吸引力，便于随身携带。充足的屏幕尺寸，以及令人惊叹且易于管理的键盘，不会让您在忙于写作时失望！
PROS (What we liked)
- 采用 IPS 技术的 LED 背光显示屏
- C 型端口
- 802.11ax Wi-Fi 6 无线网络
- 蓝牙 5.0 无线技术
CONS (What we didn’t like)
- 没有缺点
[亚马逊盒子="B08N5M7S6K"]
2。LG 克 17 (2021)
[aawp fields = " b 08 sw1 ltst " value = " thumb " image _ size = " large " image _ align = " center "]
规格
- CPU:第十代英特尔酷睿 i7 处理器
- GPU: Nvidia GeForce RTX 3000 系列
- 内存:高达 64GB
- 存储:1TB 固态硬盘
- 尺寸:381 x 261 x 17.78mm 毫米
- 重量:1.35 克
- 操作系统:Windows 10
LG Gram 17 (2021)是目前市场上最新的稳健型笔记本电脑，是一款味道十足的系统，在办公或编程笔记本电脑系列的竞争中也能立于不败之地。
这款大屏幕笔记本电脑具有这些绝对的功能，是无缝体验所必需的。如果你是一个程序员，正如我们之前提到的，它有一个大屏幕，可以帮助你管理你的文件，你也可以启动任何最好的代码编辑器，如 Atom，Notepad++，Sublime Text，QED 等。、高端显卡的最佳配置。
这款第 10 代英特尔酷睿 i7 笔记本电脑非常时尚轻巧，是您的必购之选。我们欣赏的另一件事是它的长电池寿命特性，即使您忘记携带充电器，它也不会破坏您的开箱即用创造力。
PROS (What we liked)
- 超大扁平键帽
- USB4 兼容性
- 加宽的 16:10 触摸板
- 按键间距从 1.5 毫米提高到 1.6 毫米
CONS (What we didn’t like)
- 昂贵的
[亚马逊盒子="B08SW1LTST"]
3. Dell Inspiron 14 5000
[aawp fields = " b 088 wkz 678 " value = " thumb " image _ size = " large " image _ align = " center "]
规格
- CPU:英特尔酷睿 i5-8265U(四核，最高 3.9GHz 睿频加速)
- GPU:NVIDIA GeForceR MX 150 2GB gddr 5
- 内存:8GB
- 存储:256GB 固态硬盘
- 尺寸:32.4×23.2×1.9 厘米
- 重量:1.48 千克
- 操作系统:Windows 10
如果您正在寻找一款全能产品，那么无论是在个人还是专业工作管理方面，Dell Inspiron 灵越 14 5000 都是您的最佳选择。这款戴尔 Inspiron 笔记本电脑是 python 编程的最佳选择，价格更低，但不代表它不达标。
我们注意到，许多购买了这款笔记本电脑的人都对其性能和强大的功能感到满意。说到它的优势，它有高端分辨率的全高清屏幕，英特尔四核处理器，和最快的 SSD 硬盘。在笔记本电脑中拥有这些规格意味着您可以选择它，而无需到处思考。
除此之外，这种笔记本电脑也在编码用途的笔记本电脑和热销的竞赛中。这款笔记本电脑将是那些预算紧张但仍想拥有一台坚固而优雅的笔记本电脑的人的首选。
PROS (What we liked)
- 超便携
- 专为极致便利而打造
- 全高清 IPS 触摸显示屏
- 戴尔移动连接
CONS (What we didn’t like)
- 不建议只为办公室工作的人使用
[亚马逊盒子="B088WKZ678 "
4。微软 Surface Laptop 3
[aawp fields = " b 08 t1 q8bn 1 " value = " thumb " image _ size = " large " image _ align = " center "]
规格
- CPU: Intel Core i5 – i7 / AMD Ryzen 5 / AMD Ryzen 7
- GPU:英特尔 Iris Plus 显卡/ AMD 镭龙 Vega 9 / AMD 镭龙 RX Vega 11
- 内存:8GB–16GB
- 屏幕:13.5 英寸 pixel sense(2256 x 1504)/15 英寸 pixel sense(2496 x 1664)
- 存储:128GB、256GB、512GB 或 1TB 固态硬盘
人们多次注意到，微软的产品更好，同时也更安全。在我们的 python 编程最佳笔记本电脑列表中，Microsoft Surface Laptop 3 是设计精良、深受喜爱的笔记本电脑之一。这款笔记本电脑相当昂贵，但有许多有趣和坚固的功能，肯定会让你爱上这款笔记本电脑。
它可以在 Windows 10 上完美运行，这就是为什么你可以在该操作系统上运行其他几个应用程序。您在使用和编码时不会感觉到任何延迟，因为它为设备规格提供了优化的性能。微软在软件方面一直是焦点，但这一次，它推出了这样一款时尚而坚固的笔记本电脑，以扩展其在科技世界的翅膀。
如果我们在设计上加点光，微软 Surface Laptop 3 有各种颜色，100%优质铝被用来抛光。将此笔记本电脑标记在您的列表顶部以进行检查。
PROS (What we liked)
- 出色的 Wi-Fi 性能
- 电池续航时间长
- 非常便于携带
- 快速充电–大约一小时可充电 80%
CONS (What we didn’t like)
- 有点贵
[亚马逊盒子="B08T1Q8BN1 "
5。惠普 Envy 13
[aawp fields = " b 08 k1 lbx JL " value = " thumb " image _ size = " large " image _ align = " center "]
规格
- CPU:第八代英特尔酷睿 i5-i7 处理器
- GPU:英特尔 UHD 显卡 620，Nvidia GeForce MX150 2GB GDDR5
- 内存:8GB–16GB
- 屏幕:全高清(1，920 x 1，080)
- 存储:256-512GB 固态硬盘
办公室更喜欢在家里使用惠普笔记本电脑。现在，惠普最近在 Envy 系列中推出了全新的 Envy 13。其时尚、美观、高端设计的笔记本电脑将为您的生活增添价值，并在您的买家或客户面前留下深刻印象。
Envy 13 配备了多种功能，如 13 英寸高清显示屏、显卡 620、固态硬盘存储选项，除此之外，您还可以根据自己的需求进行定制。键盘和触摸板使用起来非常舒适。无论你使用笔记本电脑一个小时还是一整天，你都不会感到疲劳。
当你选择笔记本电脑进行编程时，这是需要考虑的因素。
PROS (What we liked)
- 高级隐私功能
- 自动检查您电脑的健康状况
- 带 USB Type-C 的雷电 3 (40Gbps 信号速率)
- 惊人的表现
CONS (What we didn’t like)
- 很少有用户抱怨电池寿命
[亚马逊盒子="B08K1LBXJL"]
6。谷歌 Pixelbook Go
[aawp fields = " b 07 ymm 4 YC 1 " value = " thumb " image _ size = " large " image _ align = " center "]
规格
- CPU:英特尔酷睿 m3–英特尔酷睿 i7
- GPU:英特尔 UHD 显卡 615
- 内存:8GB–16gb
- 屏幕:13.3 英寸全高清(1，920 x 1，080)或 4K 液晶触摸屏
- 存储:128 GB–256 GB eMMC
如果你更有可能是一名 Android 用户，并作为一名 Android 开发人员工作，那么谷歌 Pixelbook Go 就是百万分之一的笔记本电脑，在编程时你可以大致使用它。
谈到这台笔记本电脑，我们发现它是一台顶级的笔记本电脑，可以帮助您进行 Python 编程。您还可以运行任何 android 应用程序和编辑器，帮助您完美地编写代码。
让我们看一下它的配置，我们必须知道，您可以选择将其从 8GB 定制到 16GB RAM，从 128GB 定制到 256GB eMMC 存储。另一个最吸引我们的是 13.3 英寸的高清显示屏，让每种颜色都赏心悦目。电池也很强大。
PROS (What we liked)
- 几秒钟内启动
- 背光键盘，超静音按键
- 绚丽的高清触摸屏
- 宽敞的触摸板
CONS (What we didn’t like)
- 没有缺点
[亚马逊盒子="B07YMM4YC1 "
7。联想 ThinkPad X1 Extreme 笔记本电脑
[aawp fields = " b 01 gquhjis " value = " thumb " image _ size = " large " image _ align = " center "]
规格
- CPU:最高可配第八代英特尔酷睿 i7 处理器
- GPU:采用 Max-Q 设计的 Nvidia GeForce GTX 1050Ti
- 内存:高达 64GB
- 屏幕:15.6 英寸 FHD(1920 x 1080)-15.6 英寸 4K UHD HDR (3840 x 2160)多点触控屏幕
- 存储:最高 1TB 固态硬盘
然后，我们将介绍联想 ThinkPad X1 Extreme 笔记本电脑。自上市以来，由于其强劲的性能和引人注目的设计，它已经聚集了坚实的粉丝基础。有很多原因使它成为编程用途的最佳笔记本电脑之一。
您可以根据自己的口袋情况定制配置。然而，我们已经知道，我们的经验丰富的开发人员团队已经注意到，它的基本配置是非常令人钦佩的，足以让一个编码器摇滚。
这款功能强大的笔记本电脑有多种颜色、高清显示屏、实心显卡和铝制包装，可确保其在未来数年内的安全性和耐用性。
PROS (What we liked)
- 背光 6 排防泼溅键盘
- 高性能
- 集成锂聚合物 80 瓦时电池
- 正版微软 Windows 10 家庭版 64 位
CONS (What we didn’t like)
- 非常昂贵
[amazon box="B01GQUHJIS"]
8 .HP 频谱 x360
[aawp fields = " b 087 c 38 rnh " value = " thumb " image _ size = " large " image _ align = " center "]
规格
- CPU:第十代英特尔酷睿 i3–i5
- GPU:英特尔 UHD 显卡
- 内存:8GB–16GB 2133 MHz lpddr 3
- 屏幕:14 英寸 LED 背光全高清(1920 x 1080) 16:9 显示屏
- Storage: 512GB / 256GB / 128GB PCIe® NVMe 3.0x 2 M.2 SSD
正如我们之前所讨论的，无论是个人使用还是全职专业使用，惠普都是每个人的首选。HP Spectre x360 非常昂贵，但有许多惊人的功能，可以帮助您在几分钟内渲染代码。
当我们评估这款笔记本电脑时，我们注意到，与竞争对手相比，它的纤薄设计更具吸引力。然而，如果你不是轻量级笔记本电脑的粉丝，或者想要感觉更坚固的东西，你最好换一台笔记本电脑。
PROS (What we liked)
- 非常轻便，便于携带
- 惊人的构建质量
- IPS 技术实现宽视角
- 背光键盘有很好的橡胶感
CONS (What we didn’t like)
- 很少有顾客抱怨建筑质量
[亚马逊盒子="B087C38RNH"]
9. Dell XPS 15 (2020)
[aawp fields = " b 089 hjx 59 l " value = " thumb " image _ size = " large " image _ align = " center "]
规格
- CPU:第十代英特尔酷睿 i5–i7
- GPU:英特尔 Iris Plus 显卡–Nvidia GeForce GTX 1650 Ti
- 内存:8GB–64GB
- 屏幕:15.6 英寸 FHD+(1920 x 1200)IPS–UHD+(3840 x 2400)
- 存储:256 GB–1TB 固态硬盘
戴尔 XPS 系列再次成为编程最佳笔记本电脑。这个令人惊叹的流行笔记本电脑系列是 Python 程序员的绝佳选择。这款高预算笔记本电脑配有 15 英寸大屏幕、漂亮的外观设计和优质的制造质量。
虽然它是一款轻薄的笔记本电脑，但这并不妨碍它所提供的功能和特性。
除此之外，电池是购买编程笔记本电脑时最重要的因素之一。戴尔 XPS 15 将为您提供持久的电池续航时间，这为您认真考虑它增加了额外的一分。
PROS (What we liked)
- 眼睛安全显示技术
- 戴尔移动连接
- 触摸板增大了 62%
CONS (What we didn’t like)
- 没有缺点
[亚马逊盒子="B089HJX59L"]
10。宏碁 Aspire E15 E5-576G-5762
[aawp fields = " b 075 flb JV 7 " value = " thumb " image _ size = " large " image _ align = " center "]
规格
- CPU: Intel Core i5 1.6 GHz
- 内存:8GB DDR4
- 存储:固态硬盘 256GB
- GPU: NVIDIA GEFORCE MX150 GPU
- 显示屏:15.6 英寸高清显示屏
我们相信每个有技术背景的人都知道宏碁提供了很棒的笔记本电脑。不仅如此，宏碁还提供了一个很大的性价比。
它配备了英特尔酷睿 i5 处理器，使其能够一次性渲染大型应用程序。如果我们看它的设计，它会完全让你大吃一惊！我们欣赏的另一件事是它的背光键盘，这将帮助您找到正确的键和 15.6 英寸高清显示屏，这使它成为一个有吸引力的产品。
PROS (What we liked)
- 长达 15 小时的电池续航时间
- Windows 10 主页
CONS (What we didn’t like)
- 没有缺点
[亚马逊盒子="B075FLBJV7 "
选购指南:如何选择最适合 Python 编程的笔记本电脑？
在购买编程笔记本电脑时，需要考虑许多因素，如内存、用例、电池寿命、实时性能等等。在你做出决定之前，我们希望你认真对待并仔细阅读这些建议，因为它将帮助你选择最好的、物有所值的产品。
大多数时候，这取决于一个人对另一个人，因为一些开发人员关注设计，而其他人关注性能。因此，无论您是在寻找一台外观纤薄优雅的笔记本电脑，还是一台功能强大、坚固耐用的笔记本电脑，我们都能让您轻松应对。
1。屏幕尺寸:
我们注意到的第一件事是屏幕大小，因为当你写代码时，你可能需要一个大屏幕才能完美地工作。我们推荐 15 英寸显示屏的 python 笔记本电脑。它将帮助您了解微妙的方面，您将能够对 GUI 进行调整以构建一个完美的产品。
2。内存和存储:
编程笔记本电脑必须具备的另一个特性是强大的存储能力。既然你是 python 开发者，就需要和 Visual Studio 这样的开发环境打交道。然而，在这个列表中，我们提到了内存充足的笔记本电脑，它们不会在编码时耗尽内存。
理想情况下，对于 python 编程笔记本电脑，我们建议至少配备 8GB 的笔记本电脑，但 16GB 将是最佳选择。
3。处理器:
你需要注意的下一个方面是处理器。您将需要配备具有更高时钟频率和更多 CPU 内核的高端处理器。无缝性能是考虑最佳笔记本电脑的基本要求，因为当您处理复杂的网站布局和高级功能时，您将需要一个出色的处理器来帮助您更快地编译代码。
4。图形:
要构建和设计一个吸引人和引人注目的产品，您需要在系统中使用高端显卡，以便能够区分输出中微小的颜色变化。在这一点上， NVIDIA 现在更受欢迎，但 GTX 1070 或 1080 是流畅编程体验的最佳显卡。
5。操作系统:
操作系统取决于最终用户，比如他们对首选操作系统的适应程度。你们中的许多人会使用 MacOS，而一些 Windows 或 Linux。然而，无论你使用什么操作系统，都要确保它是最新的和兼容的。你可以使用符合你目标的操作系统，你使用起来也更加自信和舒适。
遗言
在本指南中，我们精选了 10 款最好的 python 编程笔记本电脑。你可以和他们中的任何一个一起去。在您购买笔记本电脑之前，我们建议您检查一下它的基本规格和配置。
本指南基于用户评级和实际体验，因此您可以不假思索地购买任何笔记本电脑。我们希望这篇关于 Python 编程的最佳笔记本电脑的文章对您有所帮助。如果你觉得这篇文章对你有任何帮助，请分享它。
在大学编程作业中获得高分的最佳技巧
原文：https://www.askpython.com/python/best-tips-to-score-well-in-college-programming-assignment
在学习时，每个大学生都面临许多困难。他们尽最大努力在编程作业中获得优异成绩。大学生需要快速学习才能取得优异成绩。
学生做的每一项作业都是为了测试学生对编程语言概念的理解，以及在程序中可以创造出多少编程语言。由于它需要正确的方向和不断的努力，大多数学生无法应付他们的项目。处理事情最好的方法就是选择一个编程作业来帮忙完成作业。如果是专家做的，他们可以轻松应对不同难度的编码。
顶级建议在责任方面得分很高
每个注册学士或硕士学位的学习者都想成为最优秀的学生，并证明他们在不断提高计算技能。即使一个学习者是计算机技术的爱好者，获得计算机科学学位也是一项挑战。很难处理教授们每天提供的大量新信息。
这里有一些关键的技巧，可以帮助你成为一名成功的学生，如果不是小组中最优秀的学生的话。
1.积极看待学生所做的一切
自信的态度也许是对寻求完成家庭作业的大学生最重要的建议。虽然准备是令人厌倦的，但他们必须承认在他们的学术旅程中需要准备。所以，要学会接受，用积极的心态去解决出现的问题。
这将有助于将作业视为实现学习目标的垫脚石。这种态度打开了学生的眼界，让他们了解与完成作业相关的课程。在一天结束时，如果一些问题或部分很难，学习者可以寻求帮助，这样以积极的态度完成任务会更容易。
2.去每个班级
如果你想在编程作业上取得优异的成绩，你必须参加每一堂课。定期听课的意义不会很大。但与此同时，学生们跳过讲座、演示、辩论、例子和约会。如果你不去上课，你将无法学习。
3.永远不要对你正在做的事情绝望
这说起来容易做起来难，因为可能没有一个程序员一次就开发出程序。总是很难坐下来，试图找出错误出现的原因，并调整代码来消除它。这不仅耗时，而且在许多情况下会令人沮丧，导致你不时地放弃。学习者绝不能退出这个项目，只是在遇到困难的时候休息一下，然后再回来完成它，幸运的是，只有这一次。
4.在开始这项任务之前，先做些研究
不要在作业公布后就直接投入到作业中。这看起来像是不同意，因为你被鼓励在任务下达后立即开始工作。花时间收集作业的主题或范围。写作业时最好的技巧是彻底研究题目，然后开始写文件。
彻底而全面的研究让你对这个主题有更广泛的了解。你还会遇到其他写过相同主题的人。在这样做的同时，你会获得支持你的概念的元素。
5.与其他程序员聊天
学习程序的一个不可估量的方法就是与其他学生和开发者交流。和程序员谈谈你正在学习什么，什么最能激励你，或者你目前正在做什么。这种交流有助于了解机构、援助和编程语言。以及用这种方式描述你永远不会想到的各种想法。
6.随意尝试新想法
测试和尝试新资源最有益的事情是并行多个项目。如果你正在尝试一个新的代码或终端，结果不符合你的期望，不要浪费太多时间。你应该花在任何新的编码想法上的最大时间是 40 分钟。如果事情没有按计划进行，最好离开这个行当，过一段时间再继续，那时候你可能会有更多的支持。
7.在需要的地方提前获得帮助
导师和学校管理人员明白，你可能需要指导的任务。因此，你可以在一定范围内寻求帮助。如果你不理解指导方针，或者在获取正确的学习要素方面有困难，你的导师会帮助你。其他专家的帮助包括在线作业写作服务。专业专家将帮助研究、起草、写作、编辑和其他与家庭作业相关的服务。他们建议 编程作业帮助，这保证你的工作获得最高分。你必须根据你的任务质量支付写作服务费。而且会是擅长编码领域的人。
如果你在大学学习编程，这看起来会很令人生畏，因为你必须做更多的分析和工作。但是当你需要生活的时候，不要失去你的生活。玩得开心，认识朋友，去俱乐部或者旅游，参加学生活动。学习是重要的，但它不应该是你纪念的唯一活动。散步和娱乐会让你精神焕发，提高学习成绩。
偏差方差权衡–理解概念
为了评估模型性能，我们必须了解预测误差，主要是偏差和方差。 偏差方差权衡 是机器学习中一个非常本质的概念。
正确理解这些误差将有助于创建良好的模型，同时在训练算法时避免数据欠拟合和过拟合。
在这篇文章中我们将理解这个基本概念。
什么是偏见？
偏差是我们的模型的平均预测值和模型试图预测的正确目标值之间的差异。
具有高偏差的模型会过度简化我们的模型，并导致实际值和预测值之间的更大差异。
为了理解偏差，让我们看下图:
High Bias
从上图中可以清楚地看出，模型或线与数据不匹配，这被著名地称为拟合不足。这是一个具有高偏差的示例，因为实际值(蓝色数据点)和预测值(红线)之间的差异很大。
它总是导致训练和测试数据的高误差。
什么是方差？
方差是给定数据点的模型预测的可变性，它告诉我们数据的分布。那么高方差是什么样子的呢？
High Variance
具有高方差的模型对数据的拟合非常复杂，这基本上意味着我们的模型只是记住了训练数据。由于这个原因，我们的模型不能对以前看不见的数据给出正确的预测。
这种模型在训练数据上表现很好，但是在测试数据上有很高的错误率。
这被称为过拟合。
总误差是多少？
偏差和方差由下式给出:
- Bias[f '(X)]= E[f '(X)-f(X)]
- 方差[f '(x)]= e[x2]−e[x]2
其中 f(X)是真实值，f'(x)是我们预测接近 f(X)的值的模型函数
这里需要注意的唯一要点是，模型中的总误差由三个要素组成。
总误差=偏差+方差+不可约误差
总误差是偏差、方差和不可约误差的总和。
这里不可约误差是不可约的误差。这是我们数据中固有的噪音。但是我们当然可以控制模型的偏差和方差。
因此，我们试图通过改变模型的复杂性来获得偏差和方差的最优值。我们在偏差和方差之间找到了一个很好的平衡，使得总误差最小。
Total Error
什么是偏差方差权衡？
如果我们有一个非常简单的模型，这意味着我们有一个高偏差，低方差，正如我们在前面部分看到的。类似地，如果我们在训练数据上得到一个复杂的拟合，我们说该模型具有高方差和低偏差。不管怎样，我们都不会有好结果。
因此，偏差方差权衡意味着模型偏差和方差之间必须有一个适当的平衡，以便在不过度拟合和欠拟合数据的情况下最小化总误差。
Optimal Balance between Bias and Variance
偏差和方差之间的最佳平衡永远不会导致过度拟合或欠拟合。
Python 中偏差方差权衡的示例
让我们看看如何计算模型的偏差和方差。在命令提示符下运行这一行来获取包。
pip install mlxtend
您可以在此处下载本例中使用的数据集(文件名–score . CSV)。
让我们看看如何使用 mlxtend 库来确定模型的偏差和方差。
#Importing the required modules
from mlxtend.evaluate import bias_variance_decomp
from sklearn.tree import DecisionTreeRegressor
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
from sklearn.metrics import mean_squared_error
import pandas as pd
import numpy as np
#Reading the dataset
df = pd.read_csv('score.csv')
x = np.array(df.Hours).reshape(-1,1)
y = np.array(df.Scores).reshape(-1,1)
#Splitting the dataset into train and test set
x_train,x_test, y_train, y_test = train_test_split(x,y, test_size = 0.4 , random_state = 0)
#Making the model
regressor = DecisionTreeRegressor(max_depth = 1)
#Fitting the data to the model
regressor.fit(x_train,y_train)
#Calculating Bias and Variance
avg_expected_loss, avg_bias, avg_var = bias_variance_decomp(
regressor, x_train, y_train, x_test, y_test,
loss='mse',
random_seed=1)
#Plotting the results
x= np.linspace(min(x_train) , max(x_train), 100)
plt.plot(x, regressor.predict(x))
plt.scatter(x_train , y_train , color = 'red')
plt.xlabel('Hours')
plt.ylabel('Score')
plt.title('Model with a High Bias')
print('average Bias: ',avg_bias)
print('average Variance: ',avg_var)
average Bias: 10455.986051700678
average Variance: 61.150793197489904
Model With High Bias
上面的图清楚地表明，我们的模型没有很好地学习，因此有很高的偏差，因为我们将树的最大深度设置为 1。当在测试集上评估时，这样的模型将产生差的结果。
您可以尝试在不同的数据集上使用代码，使用不同的模型并更改参数，以获得低偏差和低方差的模型。
结论
偏差和方差在决定使用哪个预测模型时起着重要的作用。在本文中，我们学习了偏差和方差权衡，欠拟合和过拟合是什么样子。最后，我们了解到，一个好的模型应该具有较低的偏差误差和较低的方差误差。
快乐学习
Python 中的双向搜索
原文：https://www.askpython.com/python/examples/bidirectional-search-in-python
读者们好，在本文中，让我们试着理解什么是双向搜索，它的优点、缺点，以及它在 python 中的实现。
也读作:深度优先迭代深化(DFID)算法 Python 中的
什么是双向搜索？
一种称为双向搜索的图搜索算法同时进行两种搜索。当两个搜索在中途相遇时，一个停止从起点向前移动，另一个停止从目的地向后移动。对于只有一个起始状态和一个目标状态的问题，这很有帮助。
当对 k = 1，2，…进行双向搜索时，可以使用深度优先迭代深化搜索 (DFID)。在第 k 次迭代中，不是存储状态，而是简单地与从转发方向生成的存储状态进行匹配，使用广度优先搜索从起始状态到深度 k 以及从目标状态到深度 k 和深度 k+ 1 生成转发方向上的所有状态。
这里，为了识别奇数长度的答案，需要反向或向后搜索到深度 k+ 1 。如果识别出匹配，则可以确定从起点到匹配状态以及从匹配状态到目标状态的路线。应该注意，每个节点都有到其后继节点以及其父节点的链接。这些链接将有助于生成从开始到目标状态的完整路径。
双向搜索是如何工作的？
让我们用现有的图表来说明这种方法的工作原理。考虑下图，如图所示。考虑该图，找出从为 1 的第一个节点到最后一个元素 16 的路由。
Bidirectional Graph 1
同时在两个方向上跟踪节点。
Iteration
在 Python 中实现双向搜索
class adjacent_Node:
def __init__(self, v):
self.vertex = v
self.next = None
class bidirectional_Search:
def __init__(self, vertices):
self.vertices = vertices
self.graph = [None] * self.vertices
self.source_queue = list()
self.last_node_queue = list()
self.source_visited = [False] * self.vertices
self.last_node_visited = [False] * self.vertices
self.source_parent = [None] * self.vertices
self.last_node_parent = [None] * self.vertices
def AddEdge(self, source, last_node):
node = adjacent_Node(last_node)
node.next = self.graph[source]
self.graph[source] = node
node = adjacent_Node(source)
node.next = self.graph[last_node]
self.graph[last_node] = node
def breadth_fs(self, direction = 'forward'):
if direction == 'forward':
current = self.source_queue.pop(0)
connected_node = self.graph[current]
while connected_node:
vertex = connected_node.vertex
if not self.source_visited[vertex]:
self.source_queue.append(vertex)
self.source_visited[vertex] = True
self.source_parent[vertex] = current
connected_node = connected_node.next
else:
current = self.last_node_queue.pop(0)
connected_node = self.graph[current]
while connected_node:
vertex = connected_node.vertex
if not self.last_node_visited[vertex]:
self.last_node_queue.append(vertex)
self.last_node_visited[vertex] = True
self.last_node_parent[vertex] = current
connected_node = connected_node.next
def is_intersecting(self):
#
for i in range(self.vertices):
if (self.source_visited[i] and
self.last_node_visited[i]):
return i
return -1
def path_st(self, intersecting_node,
source, last_node):
path = list()
path.append(intersecting_node)
i = intersecting_node
while i != source:
path.append(self.source_parent[i])
i = self.source_parent[i]
path = path[::-1]
i = intersecting_node
while i != last_node:
path.append(self.last_node_parent[i])
i = self.last_node_parent[i]
path = list(map(str, path))
print(' '.join(path))
def bidirectional_search(self, source, last_node):
self.source_queue.append(source)
self.source_visited[source] = True
self.source_parent[source] = -1
self.last_node_queue.append(last_node)
self.last_node_visited[last_node] = True
self.last_node_parent[last_node] = -1
while self.source_queue and self.last_node_queue:
self.breadth_fs(direction = 'forward')
self.breadth_fs(direction = 'backward')
intersecting_node = self.is_intersecting()
if intersecting_node != -1:
print("Path exists between {} and {}".format(source, last_node))
print("Intersection at : {}".format(intersecting_node))
self.path_st(intersecting_node,
source, last_node)
exit(0)
return -1
if __name__ == '__main__':
n = 17
source = 1
last_node = 16
my_Graph = bidirectional_Search(n)
my_Graph.AddEdge(1, 2)
my_Graph.AddEdge(1, 3)
my_Graph.AddEdge(1, 4)
my_Graph.AddEdge(2, 5)
my_Graph.AddEdge(2, 6)
my_Graph.AddEdge(3, 7)
my_Graph.AddEdge(4, 8)
my_Graph.AddEdge(4, 9)
my_Graph.AddEdge(5, 10)
my_Graph.AddEdge(6, 10)
my_Graph.AddEdge(10, 11)
my_Graph.AddEdge(7, 11)
my_Graph.AddEdge(7, 12)
my_Graph.AddEdge(8, 13)
my_Graph.AddEdge(9, 13)
my_Graph.AddEdge(10, 6)
my_Graph.AddEdge(11, 14)
my_Graph.AddEdge(12, 15)
my_Graph.AddEdge(13, 15)
my_Graph.AddEdge(14, 16)
my_Graph.AddEdge(15, 16)
out = my_Graph.bidirectional_search(source, last_node)
if out == -1:
print("No path between {} and {}".format(source, last_node))
输出:
路径存在于 1 和 16 之间
十字路口:8
1 4 8 13 15 16
双向搜索的复杂性
这种方法的原因是两个搜索中的每一个都具有 O(b^d/2 和 O(bd/2+bd/2 的时间复杂度，这比一个搜索从开始到目标 O(b^d).的运行时间少得多该搜索可以在已经存在的图/树中进行，或者可以生成搜索图/树作为搜索的一部分。
优势
- 我们获得期望结果的速度是双向搜索的主要优势之一。
- 通过同时进行多个搜索，搜索时间显著缩短。
- 用户还可以节省资源，因为存储所有搜索所需的内存更少。
不足之处
- 如果算法不够健壮，无法识别搜索应该终止的交叉点，就有可能出现无限循环。
- 另一个挑战是，这种算法的实现需要额外的代码和指令，并且每个节点和步骤都应该仔细实现，以便进行这样的搜索。
- 双向搜索有一个基本问题，用户必须知道目标状态才能使用它，因此减少了它的用例。
摘要
它确实有一些缺点，双向搜索是最流行和广泛研究的搜索算法之一，因为当在搜索开始之前知道目的地状态时，它是达到期望的搜索结果的最有效和快速的方法。
Python 中的二分搜索法算法
原文：https://www.askpython.com/python/examples/binary-search-algorithm-in-python
今天，我们将学习一种非常快速的搜索算法 Python 中的二分搜索法算法。我们会看到它的逻辑，如何用 Python 写，是什么让它这么快。
二分搜索法算法
开始前有一点需要注意，算法要求给定的列表要排序。这是因为我们可以根据列表的排序来确定一个数字是在列表中某个数字之前还是之后。
回想一下我们是如何在字典中找到单词或者在书中找到页码的。我们简单地去序列中的一个点，检查我们需要找到的是在这个点之前还是之后，我们像这样进行猜测，直到我们找到那个项目。
同样，在二分搜索法，我们从清单的中心开始。要么我们将在那里找到该项，在这种情况下算法结束，要么我们将根据列表的排序方式知道该项是在中间项之后还是之前。
在这之后，我们将简单地忽略不应该有我们需要的项目的那一半。我们重复这个过程，到另一半的中间。
最终，我们要么找到物品，要么不再有一半要消除，这将成功或不成功地结束算法。
请注意，我们将列表分成两半，然后去掉一半，由于算法的这种行为，它被恰当地命名为二分搜索法。
韦氏词典对“二元”的解释:被认为是截然相反的两个组或两个类的划分。
推荐阅读:Python 中的二叉查找树算法
二分搜索法算法的理论示例
让我们举一个例子来更好地理解它:
给定列表 : 11，23，36，47，51，66，73，83，92
找 : 23
- 列表有 9 项，所以中间的一项必须在位置 5，即 51。
- 51 不等于 23，但比 23 多。所以如果 23 在列表中，它必须在 51 之前。所以我们排除 51 和它之后的所有项目。
- 剩余名单 : 11、23、36、47
- 现在我们在列表中有 4 个条目，根据你如何计算中心索引，它会告诉我们 2 是中心位置，或者 3 是中心位置。
- 为了简单起见，我们将计算开始和结束位置的平均值来获得中心。
- 这里 start = 1，end = 4，所以均值是 2(2.5 的整数部分)。
- 因此，在位置 2，我们有 23，这是我们需要找到的项目。算法会结束并给出目标的位置。
现在让我们看看二分搜索法算法是如何用 Python 编写的。
蟒蛇皮二分搜索法
def binary_search(lst, target):
start = 0
end = len(lst) - 1
while(start <= end):
mid = (start + end) // 2
if(lst[mid] > target):
end = mid - 1
elif(lst[mid] < target):
start = mid + 1
else:
return mid
return None
让我们来看一下算法，
- 我们创建一个函数，它有两个参数，第一个是列表，第二个是我们需要找到的目标。
- 我们声明两个变量
start和end，分别指向列表的开始(0)和结束(length–1)。 - 这两个变量负责从搜索中排除项目，因为算法不会考虑此范围之外的项目。
- 只要开始小于或等于结束，下一个循环将继续查找并消除项目，因为开始变得大于结束的唯一方式是如果项目不在列表上。
- 在循环内部，我们找到了
start和end的平均值的整数值，并将其视为列表的中间项。
现在，如果中项多于目标，则意味着目标只能出现在中项之前。所以我们将列表的末尾设置为中间之前的索引，这样，mid之后的所有索引，包括mid，都被排除在考虑之外。
同样，如果中项小于目标，则意味着目标只能出现在中项之后，为了消除索引mid和mid之前的所有索引，我们将start变量设置为mid之后的索引。
如果上述两种情况都不成立，即如果中间的项目既不大于也不小于目标，那么它一定是目标。所以我们简单的返回这个中项的索引，结束算法。
如果循环结束，那么这意味着没有找到目标，这意味着目标不在列表中，函数简单地返回None。
让我们看看代码的执行并检查它的输出。
输出
Binary Search example
我们可以看到 23 出现在列表numbers中，所以函数返回它的索引，也就是 2，但是 70 不在列表中，所以函数返回None。
是什么让二分搜索法如此之快？
考虑一个简单的搜索算法，比如线性搜索，我们必须遍历每个项目，直到找到我们要找的东西。这意味着对于较大的输入大小，查找项目所需的时间会随着输入大小的增加而增加。可量化地，其时间复杂度为 O(n)。
时间复杂度是一种量化算法速度或效率的方法。在二分搜索法的例子中，它的时间复杂度是" O(log [2] n) "，这意味着如果我们将输入列表的大小加倍，算法将只执行一次额外的迭代。
类似地，如果输入大小乘以 1000，那么这个循环将不得不再运行 10 次。
回想一下，在每次迭代中，列表的一半被消除，所以消除整个列表并不需要很长时间。
结论
在本教程中，我们学习了二分搜索法是什么，它的名字是怎么来的，它到底是做什么来查找项目的，以及它是如何这么快。我们从时间复杂性的角度讨论了它的效率，并看到了如何用 Python 对它进行编码。
二分搜索法是众多搜索算法中的一种，也是最快的一种。我希望你喜欢学习二分搜索法，并在下一个教程中看到你。
在 Python 中使用递归的二分搜索法
原文：https://www.askpython.com/python/examples/binary-search-recursion
在本教程中，我们将了解如何借助递归实现二分搜索法。我希望现在你已经熟悉了二分搜索法和递归。
为了让你更简单，我们将简要地介绍它们。
什么是二分搜索法？
二分搜索法是一种高效快速的算法，用于在元素的排序列表中查找元素。
它通过重复将数组一分为二来查找元素，然后比较除法的中间部分来识别元素可能出现在哪个除法中。
为了实现二分搜索法，我们需要三个指针，即下界、上界、和一个中间指针。
子阵列的划分由下限和上限定义，而中间指针值与需要定位的元素的值进行比较。
在这里阅读更多关于二分搜索法:Python 中的二分搜索法算法
什么是递归？
现在，二分搜索法可以用许多方式来实现，下面提到了其中的一些:
在本教程中，我们将借助递归实现二分搜索法。
当一个函数调用本身可以是一个直接或间接的调用，以解决一个较小的问题或同一类型的一个较大的问题时，这种技术被称为递归。
在这里阅读更多关于递归的内容:Python 中的递归
使用递归的二分搜索法实现
让我们在这里用 Python 实现递归的二分搜索法算法。我添加了带有注释的代码，以帮助您理解每一行的作用。
def Binary_Search(arr,n,lb,ub,X):
# 1\. List is empty
if(n==0):
print("ERROR!")
# 2\. If element is not found lb exceeds ub
elif(lb>ub):
print("Not found!")
# 3\. Keep searching for the element in array
else:
mid = int((lb+ub)/2)
if(arr[mid]==X):
print(mid+1)
elif(arr[mid]>X):
Binary_Search(arr,n,lb,mid,X);
elif(arr[mid]<X):
Binary_Search(arr,n,mid+1,ub,X);
arr = [1,2,3,4,5,6,7,8,9]
n = len(arr)
X = int(input())
Binary_Search(arr,n,0,n-1,X)
输出
Original List is: [1, 2, 3, 4, 5, 6, 7, 8, 9]
Element to Search for: 90
Result: Not found!
Original List is: [1, 2, 3, 4, 5, 6, 7, 8, 9]
Element to Search for: 5
Result: 5
结论
在本教程中，我们了解了如何借助递归以及二分搜索法和递归的一些基础知识来实现二分搜索法。
希望你喜欢这个教程！感谢您的阅读！
敬请关注更多此类教程！😇
Python 中的二叉查找树实现
原文：https://www.askpython.com/python/examples/binary-search-tree
在这篇文章中，我们将了解二分搜索法树。我们将研究二分搜索法树背后的基本概念，然后实现代码。要阅读这篇文章，你应该熟悉二叉树的概念。
什么是二叉查找树？
二叉查找树是一种二叉树数据结构，除了二叉树的属性之外，还具有其他属性。在二叉查找树，
- 没有重复的值。
- 节点的左子树的所有数据值都小于它自己的数据。即左孩子或左孩子的孩子总是小于当前节点中的值。
- 一个节点的右边子树的所有数据值都大于它自己的数据。即当前节点的右子节点或右子节点的子节点总是大于当前节点。
这可以在下面的例子中观察到。
Depiction of Binary Search Tree
二叉查找树在 Python 中的实现
为了实现二叉查找树，我们将使用与二叉树相同的节点结构，如下所示。
class BinaryTreeNode:
def __init__(self, data):
self.data = data
self.leftChild = None
self.rightChild=None
现在，为了实现二叉查找树，我们将实现在树中插入一个值的函数，在二叉树中搜索一个值，然后我们将看到如何从二叉查找树中找到最小和最大元素。
在二叉查找树插入一个节点
在二叉查找树中插入节点时，可能会出现三种情况。
- 二叉查找树可以是空的。即根本身将是一个值 None。
- 要插入的值小于根。
- 要插入的值大于根。
要实现第一个条件，我们只需创建一个新节点，并将其声明为 root。为了实现第二和第三个条件，我们遵循下面的方法。
从二叉查找树的性质，我们可以看到，每一个子树本身就是一个二叉查找树。因此，我们可以将每个节点视为另一个二叉树的根。
在插入新节点时，如果新数据的值小于当前节点的值，我们将把它添加到二叉查找树的左子节点，否则，我们将把它添加到右子节点。
递归进行，我们将总是达到第一个条件，然后我们将声明一个新的节点，并将该节点添加到二叉查找树。
下面是上述方法的实现。
class BinaryTreeNode:
def __init__(self, data):
self.data = data
self.leftChild = None
self.rightChild=None
def insert(root,newValue):
#if binary search tree is empty, make a new node and declare it as root
if root is None:
root=BinaryTreeNode(newValue)
return root
#binary search tree is not empty, so we will insert it into the tree
#if newValue is less than value of data in root, add it to left subtree and proceed recursively
if newValue<root.data:
root.leftChild=insert(root.leftChild,newValue)
else:
#if newValue is greater than value of data in root, add it to right subtree and proceed recursively
root.rightChild=insert(root.rightChild,newValue)
return root
root= insert(None,15)
insert(root,10)
insert(root,25)
insert(root,6)
insert(root,14)
insert(root,20)
insert(root,60)
a1=root
a2=a1.leftChild
a3=a1.rightChild
a4=a2.leftChild
a5=a2.rightChild
a6=a3.leftChild
a7=a3.rightChild
print("Root Node is:")
print(a1.data)
print("left child of node is:")
print(a1.leftChild.data)
print("right child of node is:")
print(a1.rightChild.data)
print("Node is:")
print(a2.data)
print("left child of node is:")
print(a2.leftChild.data)
print("right child of node is:")
print(a2.rightChild.data)
print("Node is:")
print(a3.data)
print("left child of node is:")
print(a3.leftChild.data)
print("right child of node is:")
print(a3.rightChild.data)
print("Node is:")
print(a4.data)
print("left child of node is:")
print(a4.leftChild)
print("right child of node is:")
print(a4.rightChild)
print("Node is:")
print(a5.data)
print("left child of node is:")
print(a5.leftChild)
print("right child of node is:")
print(a5.rightChild)
print("Node is:")
print(a6.data)
print("left child of node is:")
print(a6.leftChild)
print("right child of node is:")
print(a6.rightChild)
print("Node is:")
print(a7.data)
print("left child of node is:")
print(a7.leftChild)
print("right child of node is:")
print(a7.rightChild)
输出:
Root Node is:
15
left child of node is:
10
right child of node is:
25
Node is:
10
left child of node is:
6
right child of node is:
14
Node is:
25
left child of node is:
20
right child of node is:
60
Node is:
6
left child of node is:
None
right child of node is:
None
Node is:
14
left child of node is:
None
right child of node is:
None
Node is:
20
left child of node is:
None
right child of node is:
None
Node is:
60
left child of node is:
None
right child of node is:
None
在上面的输出中，我们可以验证示例中二叉查找树的每个属性。在这里，在声明了根节点之后，不管元素的插入顺序是什么，输出总是相同的。尝试将这段代码复制并粘贴到您自己的 python IDE 中。
在二叉查找树中搜索元素
我们在上面已经看到，值小于当前节点的值的节点将总是在当前节点的左子树中，而值大于当前节点的值的节点将总是在当前节点的右子树中。我们将使用该属性在二叉查找树中搜索元素。
- 如果当前节点为空，即无，则树中不存在要搜索的元素，我们将返回 False。
- 如果当前节点的值等于搜索查询，我们将返回 True。
- 如果要搜索的值大于当前节点的值，我们将搜索当前节点的右子树。
- 如果要搜索的值小于当前节点的值，我们将搜索当前节点的左子树
下面给出了该逻辑的实现。
class BinaryTreeNode:
def __init__(self, data):
self.data = data
self.leftChild = None
self.rightChild=None
def insert(root,newValue):
#if binary search tree is empty, make a new node and declare it as root
if root is None:
root=BinaryTreeNode(newValue)
return root
#binary search tree is not empty, so we will insert it into the tree
#if newValue is less than value of data in root, add it to left subtree and proceed recursively
if newValue<root.data:
root.leftChild=insert(root.leftChild,newValue)
else:
#if newValue is greater than value of data in root, add it to right subtree and proceed recursively
root.rightChild=insert(root.rightChild,newValue)
return root
def search(root,value):
#Condition 1
if root==None:
return False
#Condition 2
elif root.data==value:
return True
#Condition 3
elif root.data <value:
return search(root.rightChild,value)
# Condition 4
else:
return search(root.leftChild,value)
root= insert(None,15)
insert(root,10)
insert(root,25)
insert(root,6)
insert(root,14)
insert(root,20)
insert(root,60)
print(search(root,14))
print(search(root,22))
输出:
True
False
如何求二叉查找树的最大元素？
从我们目前所看到的，我们知道一个比当前节点大的元素总是在它的右边。
当我们递归地从根开始移动到每个节点的右边的子节点时，最大的元素将出现在最后。
所以，要找到二叉查找树的最大元素，我们只需要找到树的最右边的元素。下面是这个逻辑的实现。
class BinaryTreeNode:
def __init__(self, data):
self.data = data
self.leftChild = None
self.rightChild=None
def insert(root,newValue):
#if binary search tree is empty, make a new node and declare it as root
if root is None:
root=BinaryTreeNode(newValue)
return root
#binary search tree is not empty, so we will insert it into the tree
#if newValue is less than value of data in root, add it to left subtree and proceed recursively
if newValue<root.data:
root.leftChild=insert(root.leftChild,newValue)
else:
#if newValue is greater than value of data in root, add it to right subtree and proceed recursively
root.rightChild=insert(root.rightChild,newValue)
return root
def findLargestElement(root):
#check if binary search tree is empty
if root==None:
return False
#check if current node is rightmost node
elif root.rightChild==None:
return root.data
#check right subtree of current node
else:
return findLargestElement(root.rightChild)
root= insert(None,15)
insert(root,10)
insert(root,25)
insert(root,6)
insert(root,14)
insert(root,20)
insert(root,60)
print("Largest Element is:")
print(findLargestElement(root))
输出:
Largest Element is:
60
如何求二叉查找树的最小元素？
我们知道比当前节点小的元素总是在它的左边。当我们递归地从根开始移动到每个节点的左侧子节点时，最小的元素将出现在最后。
因此，要找到二叉查找树的最小元素，我们只需找到树的最左边的元素。下面是这个逻辑的实现。
class BinaryTreeNode:
def __init__(self, data):
self.data = data
self.leftChild = None
self.rightChild=None
def insert(root,newValue):
#if binary search tree is empty, make a new node and declare it as root
if root is None:
root=BinaryTreeNode(newValue)
return root
#binary search tree is not empty, so we will insert it into the tree
#if newValue is less than value of data in root, add it to left subtree and proceed recursively
if newValue<root.data:
root.leftChild=insert(root.leftChild,newValue)
else:
#if newValue is greater than value of data in root, add it to right subtree and proceed recursively
root.rightChild=insert(root.rightChild,newValue)
return root
def findSmallestElement(root):
#check if binary search tree is empty
if root==None:
return False
#check if current node is leftmost node
elif root.leftChild==None:
return root.data
#check right subtree of current node
else:
return findSmallestElement(root.leftChild)
root= insert(None,15)
insert(root,10)
insert(root,25)
insert(root,6)
insert(root,14)
insert(root,20)
insert(root,60)
print("Smallest Element is:")
print(findSmallestElement(root))
输出:
Smallest Element is:
6
结论
在本文中，我们已经看到了二分搜索法树背后的基本概念。我们还实现了各种操作，如插入、搜索、查找二叉查找树中的最大元素和最小元素。
我会鼓励你执行这些代码，并利用它们。请继续关注更多内容丰富的教程。
快乐学习。
Tkinter 中的绑定和事件
原文：https://www.askpython.com/python-modules/tkinter/bind-and-events-in-tkinter
读者们好，在这篇文章中让我们试着去了解 Tkinter 中有哪些事件。在开始这个话题之前，我们必须记住 Python 的 Tkinter 包是用来设计基于 GUI 的界面的。Tkinter 具有多种内置功能和扩展，可用于增强应用程序的功能和性能。
什么是事件？
“事件”一词的基本定义是特定事件的发生，或者可以定义为类似地发生或发生的事情。事件是用户执行的操作，如鼠标移动或按键。事件用于将用户执行的动作连接到应用程序可理解的逻辑，从而导致图形变化。
当我们在 Tkinter 中使用小部件时，它们确实有很多内置的行为。例如，一个按钮将执行它的命令回调来响应鼠标点击。但是，您可以使用 Tkinter 的事件绑定功能来添加、修改或删除动作/行为。
这种绑定功能是通过使用.bind()函数实现的，事件和事件处理程序在小部件中定义
widget.bind(event, event handler)
- 事件–由用户引起的可能反映变化的事件。
- 事件处理器–事件发生时应用程序中被调用的函数。
- Bind–配置一个事件处理程序(python 函数)，当一个事件发生在一个小部件上时，调用这个事件处理程序。
例如:
Example
输出
作为输出，首先会出现一个对话框，上面显示一个按钮，一旦用户在显示的按钮上单击鼠标左键，事件处理程序(这里名为askPython的函数作为事件处理程序)被调用，文本消息“你正在成功学习 Tkinter”将出现在输出窗口。
Output
事件的语法。
事件序列通常是包含一个或多个事件模式的字符串。每个事件模式描述了一个可能的结果。如果一个序列有许多事件模式，处理程序将不会被调用，直到每个模式都出现在该序列中。记住事件顺序总是在"<....>"之间描述
Syntax:
<modifier - type - detail>
修改器和细节部分是可选的。类型是定义事件的关键部分。
- modifier–指定组合的部分，例如使用鼠标或单击其他键时按住 shift 或 control 按钮。
- 类型–定义特定类型的事件，如鼠标点击或按键。
- 细节–描述您正在寻找的鼠标按钮或按键时使用的元素。鼠标上的按钮 1 为 1，按钮 2 为 2，按钮 3 为 3。
事件的类型
**`<button>`**
用户单击了一个鼠标按钮。细节部分示例中指定了哪个按钮:
**`<buttonRelease>`**
用户释放了鼠标按钮。由于用户可能会将鼠标从小部件上移开以防止误按按钮，这无疑是大多数场景中比按钮事件更好的替代方法。
**`<Configure>`**
用户修改了小部件的大小，例如通过扩展窗口的角或边。
**`<Destroy>`**
小组件正在被销毁。
**`<Enter>`**
用户将鼠标指针放在小部件的可见区域上。(这不同于回车键，回车键是按键事件)
**`<Expose>`**
每当您的小工具或应用程序的至少一部分在被另一个窗口隐藏后变得可见时，就会发生这种情况。
**`<FocusIn>`**
这可能是为了响应用户交互(例如使用 tab 键在小部件之间切换)或以编程方式(例如，当您的软件调用。小部件上的 focus set()方法)。
**`<FocusOut>`**
作为输入焦点的小部件已被更改。与<focusin>类似，用户或您的软件都可以启动该事件。
**`<KeyPress>`**
用户按下了键盘键。该键在事件部分的详细信息部分中指定。“key”这个词可以用作缩写。
**`<KeyRelease>`**
用户释放了按键。
**`**<**Leave>`**
用户将鼠标指针移出小部件。
**`**<**Map>`**
一个应用程序正在映射，或者使一个小部件可见。例如，如果您使用小部件的. grid()方法，就会发生这种情况。
**`**<**Motion>`**
当按下鼠标按钮时，鼠标移动。使用
**`**<**MouseWheel>`**
用户上下移动了鼠标滚轮。
**`**<**Unmap>`**
未映射的微件是那些不再可见的微件。例如，当您使用 widgets.grid remove()方法时，就会出现这种情况。
**`**<**Visibility>`**
当应用程序窗口的至少一部分在屏幕上可见时，这就发生了。
摘要
我们已经在 Tkinter 中详细讨论了主题 events，并理解了使用 events 的主要目的是理解用户执行的动作(可以通过鼠标移动或按键)并通过改变 GUI 的行为来响应这些动作。
Tkinter 中的绑定:完全指南
原文：https://www.askpython.com/python-modules/tkinter/bind-in-tkinter
在本文中，让我们试着理解 Tkinter 中使用的 bind 概念。在开始这个主题之前，我们必须记住 Python 的 Tkinter 包是用来设计基于 GUI 的界面的。Tkinter 具有多种内置功能和扩展，可用于增强应用程序的功能和性能。
bind 是什么？
单词 bind 的基本定义是粘在一起或使粘在一起成为一个整体。类似地，Tkinter bind 用于连接小部件中传递的事件和事件处理程序。事件处理程序是在事件发生时被调用的函数。
widget.bind(sequence=None, func=None, add=None)
*sequence* 参数描述了我们期望的事件，而 func 参数是当事件发生在小部件上时要调用的函数。如果这个小部件的那个事件已经有一个绑定，通常旧的回调会被替换为 func ，但是您可以通过传递add='+'来保留这两个回调。
可以使用不同级别的绑定函数将事件绑定到事件处理程序。
1.实例级绑定
人们可以将一个事件绑定到一个特定的小部件。要绑定小部件的事件，调用小部件上的.bind()方法。
widget.bind(event, event handler)
- 事件–由用户引起的可能反映变化的事件。
- 事件处理器–事件发生时应用程序中被调用的函数。
- Bind–配置一个事件处理程序(python 函数)，当一个事件发生在一个小部件上时，调用这个事件处理程序。
以下是如何将事件绑定到小部件的特定实例的示例。
import tkinter as tk
class Display:
def __init__(self):
self.root = tk.Tk()
self.entry1 = tk.Entry(self.root)
self.entry1.bind("<KeyPress>", self.onKeyPress)
self.entry1.pack()
self.root.mainloop()
def onKeyPress(self, event):
print("Key has been Pressed.")
display = Display()
输出
Implementation
多重绑定
如果我们需要将一个以上的功能绑定到一个特定的小部件，该怎么办？传递两个包含 bind the 函数的语句肯定是行不通的，因为第二个语句会覆盖第一个语句，因此只有第二个函数会被调用，如下所示
Implementation
这个问题可以通过向使用bind函数的第二条语句添加一个额外的参数**add**来解决。另外，不要忘记分配 add="+"。这将调用两个函数。因此，我们可以在 Tkinter 中启用多重绑定。
Implementation
2.类级绑定
可以将一个事件绑定到一个类的所有小部件。例如，您可以通过在英语和日语标签之间来回切换来设置所有的Button小部件来响应鼠标中键的点击。要将一个事件绑定到一个类的所有小部件，调用任何小部件上的.bind_class()方法。
bind_class中提到的“类”是指 tk 库使用的内部类名，而不是 python 类名。bind_class是一个对所有小部件都可用的方法，它简单地再次调用 Tk bind 命令，但是不是用实例名，而是用小部件类名。
w.bind_class(className, sequence=None, func=None, add=None)
.bind_class的基本工作与.bind功能相同。
例如，假设你有同一个类的几个小部件，这里我们假设我们有多个入口小部件，我们需要把它们都设置成同一个函数。您不必为每一个都调用.bind(),而是可以像这样用一个调用来设置它们:
from tkinter import *
import tkinter as tk
class Display:
def __init__(self):
self.root = tk.Tk()
self.entry_username = tk.Entry(self.root)
self.entry_birthday = tk.Entry(self.root)
self.entry_password= tk.Entry(self.root)
self.entry_username.bind_class("Entry", "<Return>", self.onReturn)
self.entry_username.pack()
self.entry_birthday.pack()
self.entry_password.pack()
#to know the class type of the widget use following command.
#print(self.entry_username.winfo_class())
self.root.mainloop()
def onReturn(self, event):
print("Return pressed")
display = Display()
输出
Implementation
3.应用程序级绑定
我们可以设置一个绑定，这样不管什么小部件有焦点或者在鼠标下面，某个事件都会调用一个处理程序。
w.bind_all(sequence=None, func=None, add=None)
类似于.bind()，但是适用于整个应用程序中的所有小部件。
例如，在整个程序中可能有多个相同类型的小部件，它们属于不同的类。要在应用程序级别绑定事件，请在任何小部件上调用.bind_all()方法。一边用。bind_all 您不需要提及类名，因为绑定应用于应用程序的每个事件。下面是实现它的方法，
from tkinter import *
import tkinter as tk
class Display:
def __init__(self):
self.root = tk.Tk()
self.entry_username = tk.Entry(self.root)
self.entry_birthday = tk.Entry(self.root)
self.entry_password = tk.Entry(self.root)
self.entry_username.bind_all("<Return>", self.onReturn)
self.entry_username.pack()
self.entry_birthday.pack()
self.entry_password.pack()
#to know the class type of the widget use following command.
print(self.entry_username.winfo_class())
self.root.mainloop()
def onReturn(self, event):
print("Return pressed")
display = Display()
输出
Implementation
摘要
在本文中，我们已经了解到，绑定是 Tkinter 中使用的函数，用于将事件与小部件的特定函数(称为事件处理程序)连接或关联。此外，Tkinter 支持三种级别的绑定:实例级绑定、类级绑定和应用程序级绑定。
参考
Python 中的二分图–完整指南
原文：https://www.askpython.com/python/examples/bipartite-graph-in-python
嘿伙计们！今天，在本教程中，我们将了解什么是二分图，以及如何使用 networkx 库在 python 编程语言中实现它们。
二分图简介
A 二部图 是顶点可以分成两个独立集合——A 和 b 的图，每一个(A，b)都意味着集合 A 中的一个节点和集合 b 中的一个节点之间的连接，这里“A”属于 A，“b”属于 b
一个集合中的节点不能相互连接；它们只能连接到另一组中的节点。
Bipartite Graph Example
例如，二分图在客户购买的建模中非常有用。在这种情况下，节点分为两组:客户分区和产品分区。
边缘表示消费者已经购买了某种产品。在这种情况下，似乎可以推断出项目不能相互链接；毕竟，一个产品不能购买另一个产品。
用 Python 实现二分图
程序的第一步是将模块/库导入到我们的代码中。我们需要从 networkx 导入基本 networkx 和二分网络。
import networkx as nx
from networkx.algorithms import bipartite
接下来，我们将创建一个空图，以便在后面的部分中向其添加节点和边。
G = nx.Graph()
下一步是添加节点属性为“bipartite”的节点。这里，二分属性的值决定了节点的类。如果它的值是 0，那么它属于第一类，如果它的值是 1，那么它属于第二类。
G.add_nodes_from(['A1','A2','A3','A4'], bipartite=0)
G.add_nodes_from(['B1','B2','B3'],bipartite=1)
接下来，我们将只在相反类的节点之间添加边。你可以添加任意多的边，现在，我们已经添加了一些。
G.add_edges_from([('A1', "B3"),('A4', "B1"),('A2', "B2"),('A2', "B3"),('A3', "B1")])
我们还可以使用下面提到的简单代码行来确认该图是否是二分图。
bipartite.is_bipartite(G)
现在，通过下面提到的代码片段非常容易地将图形可视化。
nx.draw_networkx(G, pos = nx.drawing.layout.bipartite_layout(G, ['A1','A2','A3','A4']), width = 2)
Bipartite Graph Visualization
结论
恭喜你！您刚刚学习了如何使用 Networkx 构建二分图。希望你喜欢它！😇
喜欢这个教程吗？无论如何，我建议你看一下下面提到的教程:
感谢您抽出时间！希望你学到了新的东西！！😄
使用 Python 创建我们自己的 21 点游戏
原文：https://www.askpython.com/python/examples/blackjack-game-using-python
21 点是一种在赌场玩的纸牌游戏。这个游戏的参与者不是互相竞争，而是赌场指定的庄家。在本文中，我们将从头开始创建玩家和庄家之间的 21 点游戏，可以在终端上玩。
二十一点的规则
我们将为从未玩过 21 点的读者提供一套简单的规则。21 点的神奇数字是 21。将发给玩家的所有牌的值相加，如果总和超过 21，玩家将立即失败。
如果一个玩家得到一个精确的 21，这个玩家就赢了庄家。否则，为了赢，玩家的牌的总和必须大于庄家的牌的总和。
每张正面牌都有一个确定的值 10，而 a 可以根据玩家获胜的机会被计为 1 或 11。其余牌的价值由它们的号码决定。
在 21 点游戏中发牌如下:
- 给玩家发一张面朝上的牌(每个人都可以看到)。
- 庄家发一张牌给所有人都看得见的自己。
- 另一张牌面朝上发给玩家。
- 庄家为自己发一张面朝下的牌。
- 玩家必须决定是坚持当前的牌还是换一张牌。
- 如果玩家决定打，就发另一张牌。
- 如果玩家决定站着，那么发牌者展示他隐藏的牌。
- 庄家没有权力决定是打还是站。一般规则是，如果庄家的牌数总和小于 17，庄家需要继续打出更多的牌。
- 一旦庄家的牌数达到或超过 17 张，庄家就必须站起来。
- 根据最后的牌数，决定谁是赢家。
一旦理解了规则，21 点游戏的编程就变得简单了。从头开始创建基于终端的游戏需要三个主要组件:游戏设计、游戏逻辑和玩家交互管理。
21 点游戏演示
https://www.askpython.com/wp-content/uploads/2020/09/blackjack_game.mp4
用 Python 设计 21 点
首先，我们将致力于我们游戏的设计。我们的工作是在终端上有效地显示一系列卡片，如下图所示。
Game
我们需要一个打印卡片序列的函数，并且与卡片的数量无关。此外，如果需要，它必须提供打印隐藏卡片的功能。
下面的代码解决了我们的问题。
# Function to print the cards
def print_cards(cards, hidden):
s = ""
for card in cards:
s = s + "\t ________________"
if hidden:
s += "\t ________________"
print(s)
s = ""
for card in cards:
s = s + "\t| |"
if hidden:
s += "\t| |"
print(s)
s = ""
for card in cards:
if card.value == '10':
s = s + "\t| {} |".format(card.value)
else:
s = s + "\t| {} |".format(card.value)
if hidden:
s += "\t| |"
print(s)
s = ""
for card in cards:
s = s + "\t| |"
if hidden:
s += "\t| * * |"
print(s)
s = ""
for card in cards:
s = s + "\t| |"
if hidden:
s += "\t| * * |"
print(s)
s = ""
for card in cards:
s = s + "\t| |"
if hidden:
s += "\t| * * |"
print(s)
s = ""
for card in cards:
s = s + "\t| |"
if hidden:
s += "\t| * * |"
print(s)
s = ""
for card in cards:
s = s + "\t| {} |".format(card.suit)
if hidden:
s += "\t| * |"
print(s)
s = ""
for card in cards:
s = s + "\t| |"
if hidden:
s += "\t| * |"
print(s)
s = ""
for card in cards:
s = s + "\t| |"
if hidden:
s += "\t| * |"
print(s)
s = ""
for card in cards:
s = s + "\t| |"
if hidden:
s += "\t| |"
print(s)
s = ""
for card in cards:
s = s + "\t| |"
if hidden:
s += "\t| |"
print(s)
s = ""
for card in cards:
if card.value == '10':
s = s + "\t| {} |".format(card.value)
else:
s = s + "\t| {} |".format(card.value)
if hidden:
s += "\t| * |"
print(s)
s = ""
for card in cards:
s = s + "\t|________________|"
if hidden:
s += "\t|________________|"
print(s)
print()
每张卡片的详细信息都存储为一个卡片对象。print_cards()函数的第二个参数是一个布尔值，表示是否要显示隐藏的卡片。
创建卡片
在类和对象的帮助下，我们可以创建一套花色和值来表示一张“扑克牌”。在 21 点中，一张牌有三个属性:花色、代表值和得分值。
所有上述属性都保留在下面的卡类中。
# The Card Class definition
class Card:
def __init__(self, suit, value, card_value):
# Suit of the Card like Spades and Clubs
self.suit = suit
# Representing Value of the Card like A for Ace, K for King
self.value = value
# Score Value for the Card like 10 for King
self.card_value = card_value
使用上面的类，我们可以创建一副包含 52 个卡片对象的卡片。
一些基本价值观
每种纸牌游戏都需要基本的价值，如花色、牌的类型以及每张牌的价值。
# The type of suit
suits = ["Spades", "Hearts", "Clubs", "Diamonds"]
# The suit value
suits_values = {"Spades":"\u2664", "Hearts":"\u2661", "Clubs": "\u2667", "Diamonds": "\u2662"}
# The type of card
cards = ["A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"]
# The card value
cards_values = {"A": 11, "2":2, "3":3, "4":4, "5":5, "6":6, "7":7, "8":8, "9":9, "10":10, "J":10, "Q":10, "K":10}
这里需要注意的一点是，a 最初被标记为 11 点的牌。这种策略背后的想法是，每当玩家/庄家的得分似乎超过 21 时，我们可以将 Ace(如果发牌)的得分减少到 1。
在本文的后面，我们将看到缩减的实现。
生成一副扑克牌
一副普通的扑克牌由 52 张牌组成，每张牌都有不同的花色和价值组合。使用上述基本值和卡片类，我们生成一副卡片。
# The deck of cards
deck = []
# Loop for every type of suit
for suit in suits:
# Loop for every type of card in a suit
for card in cards:
# Adding card to the deck
deck.append(Card(suits_values[suit], card, cards_values[card]))
实际上，21 点游戏涉及多副牌，因此上述循环集可以重复用于填充多副牌。
新创建的卡片组被传递给执行游戏的函数。
blackjack_game(deck)
让我们学习玩家和基于计算机的庄家之间的 21 点游戏的单次迭代背后的游戏逻辑。
声明重要的游戏变量
在任何时刻，我们都需要以下游戏变量:
- 发给玩家和发牌者的牌的列表。
- 每一面的牌值总和。
# Function for a single game of blackjack
def blackjack_game(deck):
global cards_values
# Cards for both dealer and player
player_cards = []
dealer_cards = []
# Scores for both dealer and player
player_score = 0
dealer_score = 0
当我们设计游戏逻辑时，这些游戏变量开始发挥作用。
Python 点游戏逻辑
整个游戏逻辑围绕着发牌和玩家选择击打或站立。一旦我们处理了以上两件事，我们就完成了这一天的工作。
发牌的第一阶段:强制牌
最初的发牌包括给玩家和发牌者两张牌。然而，庄家的第二张牌必须是未知的。
# Initial dealing for player and dealer
while len(player_cards) < 2:
# Randomly dealing a card
player_card = random.choice(deck)
player_cards.append(player_card)
deck.remove(player_card)
# Updating the player score
player_score += player_card.card_value
# In case both the cards are Ace, make the first ace value as 1
if len(player_cards) == 2:
if player_cards[0].card_value == 11 and player_cards[1].card_value == 11:
player_cards[0].card_value = 1
player_score -= 10
# Print player cards and score
print("PLAYER CARDS: ")
print_cards(player_cards, False)
print("PLAYER SCORE = ", player_score)
input()
# Randomly dealing a card
dealer_card = random.choice(deck)
dealer_cards.append(dealer_card)
deck.remove(dealer_card)
# Updating the dealer score
dealer_score += dealer_card.card_value
# Print dealer cards and score, keeping in mind to hide the second card and score
print("DEALER CARDS: ")
if len(dealer_cards) == 1:
print_cards(dealer_cards, False)
print("DEALER SCORE = ", dealer_score)
else:
print_cards(dealer_cards[:-1], True)
print("DEALER SCORE = ", dealer_score - dealer_cards[-1].card_value)
# In case both the cards are Ace, make the second ace value as 1
if len(dealer_cards) == 2:
if dealer_cards[0].card_value == 11 and dealer_cards[1].card_value == 11:
dealer_cards[1].card_value = 1
dealer_score -= 10
input()
# Player gets a blackjack
if player_score == 21:
print("PLAYER HAS A BLACKJACK!!!!")
print("PLAYER WINS!!!!")
quit()
对于一笔看似简单的交易来说，可能需要喝很多酒。让我们理解一下上面代码中涉及的过程:
- 主循环运行，直到玩家和庄家各得到两张牌。
- 从这副牌中随机选择一张牌，在下一步中，这张牌被从这副牌中取出。
- 该卡的价值会添加到玩家的分数中。
- 类似地，为发牌者随机选择一张牌，并且其值被添加到发牌者的分数中。
- 玩家的牌正常显示在屏幕上。
- 庄家的牌被小心地展示，使得第二张牌和它的值不被暴露。
- 如果任何一个参与者得到两个 a，他们的分数会被调整，这样他们都不会失败。
- 以上事情全部顺利发生后，我们进入第二阶段的交易。
注:对于玩家和庄家来说，分数的调整是有细微差别的。在前一种情况下，调整第一张卡的值，而在后一种情况下，调整第二张卡的值。
调整第二张牌的值的原因是，如果我们调整了第一张牌，我们就会暴露隐藏的牌是 a 的身份。
这里需要做的最后一件事是检查玩家是否已经有了 21 点。如果他这样做，玩家获胜，游戏结束。
注意:
input()功能暂停节目，直到玩家按下“回车”。这防止了所有游戏事件的快速失败。
clear()功能负责清理终端，给游戏一个干净的美感。
发牌的第二阶段:玩家的选择
发牌的第二阶段取决于玩家的决定，要么想要另一张牌来增加分数，要么坚持当前的一套牌。
# Print dealer and player cards
print("DEALER CARDS: ")
print_cards(dealer_cards[:-1], True)
print("DEALER SCORE = ", dealer_score - dealer_cards[-1].card_value)
print()
print("PLAYER CARDS: ")
print_cards(player_cards, False)
print("PLAYER SCORE = ", player_score)
# Managing the player moves
while player_score < 21:
choice = input("Enter H to Hit or S to Stand : ")
# Sanity checks for player's choice
if len(choice) != 1 or (choice.upper() != 'H' and choice.upper() != 'S'):
clear()
print("Wrong choice!! Try Again")
# If player decides to HIT
if choice.upper() == 'H':
# Dealing a new card
player_card = random.choice(deck)
player_cards.append(player_card)
deck.remove(player_card)
# Updating player score
player_score += player_card.card_value
# Updating player score in case player's card have ace in them
c = 0
while player_score > 21 and c < len(player_cards):
if player_cards[c].card_value == 11:
player_cards[c].card_value = 1
player_score -= 10
c += 1
else:
c += 1
clear()
# Print player and dealer cards
print("DEALER CARDS: ")
print_cards(dealer_cards[:-1], True)
print("DEALER SCORE = ", dealer_score - dealer_cards[-1].card_value)
print()
print("PLAYER CARDS: ")
print_cards(player_cards, False)
print("PLAYER SCORE = ", player_score)
# If player decides to Stand
if choice.upper() == 'S':
break
# Check if player has a Blackjack
if player_score == 21:
print("PLAYER HAS A BLACKJACK")
quit()
# Check if player busts
if player_score > 21:
print("PLAYER BUSTED!!! GAME OVER!!!")
quit()
玩家决定是打还是站，直到分数超过 21 或者玩家决定站。发给玩家的牌的数量没有限制，只是在分数上。
每当玩家决定击中时，从该副牌中分发一张新牌，并且更新分数。如前所述，a 可以算作 1 或 11。一段特殊的代码将 Ace 的值从 11 转换为 1，以防分数超过 21。
当玩家对当前分数满意时，他就站了起来。当他这样做时，我们在进行一些强制性检查(如 21 点或破坏场景)后，进入交易的最后阶段。
发牌的最后阶段:庄家的牌
在发牌的最后阶段，庄家隐藏的牌被揭开，庄家的分数也被揭开。根据标准的 21 点规则，庄家必须给自己发更多的牌，直到其得分大于或等于 17。
# Managing the dealer moves
while dealer_score < 17:
clear()
print("DEALER DECIDES TO HIT.....")
# Dealing card for dealer
dealer_card = random.choice(deck)
dealer_cards.append(dealer_card)
deck.remove(dealer_card)
# Updating the dealer's score
dealer_score += dealer_card.card_value
# Updating player score in case player's card have ace in them
c = 0
while dealer_score > 21 and c < len(dealer_cards):
if dealer_cards[c].card_value == 11:
dealer_cards[c].card_value = 1
dealer_score -= 10
c += 1
else:
c += 1
# print player and dealer cards
print("PLAYER CARDS: ")
print_cards(player_cards, False)
print("PLAYER SCORE = ", player_score)
print()
print("DEALER CARDS: ")
print_cards(dealer_cards, False)
print("DEALER SCORE = ", dealer_score)
input()
庄家继续击球，直到得分超过 17 分。如果需要，我们有一个类似的实现，将 ace 的卡值从 11 转换为 1。
最终游戏
当庄家的分数达到或超过 17 分时，我们进入游戏的最后阶段，包括比较价值和提名游戏的赢家。可能有几种情况:
- 经销商破产–经销商的分数超过 21。
- 庄家有 21 点，庄家的精确分数是 21。
- 平局游戏-玩家和庄家得分相等。
- 玩家赢了–玩家的分数比庄家的分数多。
- 庄家赢–庄家的分数比玩家的分数多。
我们检查以上每一种可能性，并宣布获胜者。
# Dealer busts
if dealer_score > 21:
print("DEALER BUSTED!!! YOU WIN!!!")
quit()
# Dealer gets a blackjack
if dealer_score == 21:
print("DEALER HAS A BLACKJACK!!! PLAYER LOSES")
quit()
# TIE Game
if dealer_score == player_score:
print("TIE GAME!!!!")
# Player Wins
elif player_score > dealer_score:
print("PLAYER WINS!!!")
# Dealer Wins
else:
print("DEALER WINS!!!")
这结束了玩家和庄家之间的 21 点游戏的单次迭代。
21 点游戏的完整 Python 代码
import random
import os
import time
# The Card class definition
class Card:
def __init__(self, suit, value, card_value):
# Suit of the Card like Spades and Clubs
self.suit = suit
# Representing Value of the Card like A for Ace, K for King
self.value = value
# Score Value for the Card like 10 for King
self.card_value = card_value
# Clear the terminal
def clear():
os.system("clear")
# Function to print the cards
def print_cards(cards, hidden):
s = ""
for card in cards:
s = s + "\t ________________"
if hidden:
s += "\t ________________"
print(s)
s = ""
for card in cards:
s = s + "\t| |"
if hidden:
s += "\t| |"
print(s)
s = ""
for card in cards:
if card.value == '10':
s = s + "\t| {} |".format(card.value)
else:
s = s + "\t| {} |".format(card.value)
if hidden:
s += "\t| |"
print(s)
s = ""
for card in cards:
s = s + "\t| |"
if hidden:
s += "\t| * * |"
print(s)
s = ""
for card in cards:
s = s + "\t| |"
if hidden:
s += "\t| * * |"
print(s)
s = ""
for card in cards:
s = s + "\t| |"
if hidden:
s += "\t| * * |"
print(s)
s = ""
for card in cards:
s = s + "\t| |"
if hidden:
s += "\t| * * |"
print(s)
s = ""
for card in cards:
s = s + "\t| {} |".format(card.suit)
if hidden:
s += "\t| * |"
print(s)
s = ""
for card in cards:
s = s + "\t| |"
if hidden:
s += "\t| * |"
print(s)
s = ""
for card in cards:
s = s + "\t| |"
if hidden:
s += "\t| * |"
print(s)
s = ""
for card in cards:
s = s + "\t| |"
if hidden:
s += "\t| |"
print(s)
s = ""
for card in cards:
s = s + "\t| |"
if hidden:
s += "\t| |"
print(s)
s = ""
for card in cards:
if card.value == '10':
s = s + "\t| {} |".format(card.value)
else:
s = s + "\t| {} |".format(card.value)
if hidden:
s += "\t| * |"
print(s)
s = ""
for card in cards:
s = s + "\t|________________|"
if hidden:
s += "\t|________________|"
print(s)
print()
# Function for a single game of blackjack
def blackjack_game(deck):
# Cards for both dealer and player
player_cards = []
dealer_cards = []
# Scores for both dealer and player
player_score = 0
dealer_score = 0
clear()
# Initial dealing for player and dealer
while len(player_cards) < 2:
# Randomly dealing a card
player_card = random.choice(deck)
player_cards.append(player_card)
deck.remove(player_card)
# Updating the player score
player_score += player_card.card_value
# In case both the cards are Ace, make the first ace value as 1
if len(player_cards) == 2:
if player_cards[0].card_value == 11 and player_cards[1].card_value == 11:
player_cards[0].card_value = 1
player_score -= 10
# Print player cards and score
print("PLAYER CARDS: ")
print_cards(player_cards, False)
print("PLAYER SCORE = ", player_score)
input()
# Randomly dealing a card
dealer_card = random.choice(deck)
dealer_cards.append(dealer_card)
deck.remove(dealer_card)
# Updating the dealer score
dealer_score += dealer_card.card_value
# Print dealer cards and score, keeping in mind to hide the second card and score
print("DEALER CARDS: ")
if len(dealer_cards) == 1:
print_cards(dealer_cards, False)
print("DEALER SCORE = ", dealer_score)
else:
print_cards(dealer_cards[:-1], True)
print("DEALER SCORE = ", dealer_score - dealer_cards[-1].card_value)
# In case both the cards are Ace, make the second ace value as 1
if len(dealer_cards) == 2:
if dealer_cards[0].card_value == 11 and dealer_cards[1].card_value == 11:
dealer_cards[1].card_value = 1
dealer_score -= 10
input()
# Player gets a blackjack
if player_score == 21:
print("PLAYER HAS A BLACKJACK!!!!")
print("PLAYER WINS!!!!")
quit()
clear()
# Print dealer and player cards
print("DEALER CARDS: ")
print_cards(dealer_cards[:-1], True)
print("DEALER SCORE = ", dealer_score - dealer_cards[-1].card_value)
print()
print("PLAYER CARDS: ")
print_cards(player_cards, False)
print("PLAYER SCORE = ", player_score)
# Managing the player moves
while player_score < 21:
choice = input("Enter H to Hit or S to Stand : ")
# Sanity checks for player's choice
if len(choice) != 1 or (choice.upper() != 'H' and choice.upper() != 'S'):
clear()
print("Wrong choice!! Try Again")
# If player decides to HIT
if choice.upper() == 'H':
# Dealing a new card
player_card = random.choice(deck)
player_cards.append(player_card)
deck.remove(player_card)
# Updating player score
player_score += player_card.card_value
# Updating player score in case player's card have ace in them
c = 0
while player_score > 21 and c < len(player_cards):
if player_cards[c].card_value == 11:
player_cards[c].card_value = 1
player_score -= 10
c += 1
else:
c += 1
clear()
# Print player and dealer cards
print("DEALER CARDS: ")
print_cards(dealer_cards[:-1], True)
print("DEALER SCORE = ", dealer_score - dealer_cards[-1].card_value)
print()
print("PLAYER CARDS: ")
print_cards(player_cards, False)
print("PLAYER SCORE = ", player_score)
# If player decides to Stand
if choice.upper() == 'S':
break
clear()
# Print player and dealer cards
print("PLAYER CARDS: ")
print_cards(player_cards, False)
print("PLAYER SCORE = ", player_score)
print()
print("DEALER IS REVEALING THE CARDS....")
print("DEALER CARDS: ")
print_cards(dealer_cards, False)
print("DEALER SCORE = ", dealer_score)
# Check if player has a Blackjack
if player_score == 21:
print("PLAYER HAS A BLACKJACK")
quit()
# Check if player busts
if player_score > 21:
print("PLAYER BUSTED!!! GAME OVER!!!")
quit()
input()
# Managing the dealer moves
while dealer_score < 17:
clear()
print("DEALER DECIDES TO HIT.....")
# Dealing card for dealer
dealer_card = random.choice(deck)
dealer_cards.append(dealer_card)
deck.remove(dealer_card)
# Updating the dealer's score
dealer_score += dealer_card.card_value
# Updating player score in case player's card have ace in them
c = 0
while dealer_score > 21 and c < len(dealer_cards):
if dealer_cards[c].card_value == 11:
dealer_cards[c].card_value = 1
dealer_score -= 10
c += 1
else:
c += 1
# print player and dealer cards
print("PLAYER CARDS: ")
print_cards(player_cards, False)
print("PLAYER SCORE = ", player_score)
print()
print("DEALER CARDS: ")
print_cards(dealer_cards, False)
print("DEALER SCORE = ", dealer_score)
input()
# Dealer busts
if dealer_score > 21:
print("DEALER BUSTED!!! YOU WIN!!!")
quit()
# Dealer gets a blackjack
if dealer_score == 21:
print("DEALER HAS A BLACKJACK!!! PLAYER LOSES")
quit()
# TIE Game
if dealer_score == player_score:
print("TIE GAME!!!!")
# Player Wins
elif player_score > dealer_score:
print("PLAYER WINS!!!")
# Dealer Wins
else:
print("DEALER WINS!!!")
if __name__ == '__main__':
# The type of suit
suits = ["Spades", "Hearts", "Clubs", "Diamonds"]
# The suit value
suits_values = {"Spades":"\u2664", "Hearts":"\u2661", "Clubs": "\u2667", "Diamonds": "\u2662"}
# The type of card
cards = ["A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"]
# The card value
cards_values = {"A": 11, "2":2, "3":3, "4":4, "5":5, "6":6, "7":7, "8":8, "9":9, "10":10, "J":10, "Q":10, "K":10}
# The deck of cards
deck = []
# Loop for every type of suit
for suit in suits:
# Loop for every type of card in a suit
for card in cards:
# Adding card to the deck
deck.append(Card(suits_values[suit], card, cards_values[card]))
blackjack_game(deck)
读者没有义务遵循整个编码序列。可以对上述代码进行各种修改，增加多个玩家对抗庄家的功能。
结论
一场 21 点的游戏起初看起来简单而随意，但只有当玩家遵循某些策略，如算牌，游戏才变得复杂。
世界各地流传着许多版本的 21 点，如瑞典酒吧 21 点和家庭游戏 21 点。好奇的读者可以了解这些变体，并尝试使用本文中获得的知识来实现它们。
感谢您的阅读。请随意查看如何用 Python 开发一个智多星游戏。
Python 中的 BLEU score–初学者概述
读者朋友们，你们好！在本文中，我们将关注 Python 中 BLEU score 的实现。
所以，让我们开始吧！🙂
也读作:在 Python 中自定义数据集
什么是 BLEU 评分？
在机器学习建模、深度学习和自然语言处理的领域中，我们需要特定的错误度量，以使我们能够评估字符串输入上构建的模型。
BLEU 评分就是这样一种度量，它使我们能够估计机器翻译模型或系统的效率。今天，这已经被自然语言处理模型和应用程序广泛使用。
在幕后，BLEU 术语评分将候选句子与参考句子进行比较，然后评估候选句子与参考句子的融合程度。这样，它分别在 0-1 的范围内对分数进行评级。
Python 中 BLEU 分数的计算
为了实现 BLEU 分数，我们将使用由 sentence_bleu()函数组成的 NLTK 模块。它使我们能够传递参考句子和候选句子。然后，它对照参考句子检查候选句子。
如果找到完全匹配，它返回 1 作为 BLEU 分数。如果完全不匹配，则返回 0。对于部分匹配，蓝色分数将在 0 和 1 之间。
实现 BLEU 评分
在下面的例子中，
- 我们已经导入了 NLTK 库和 sentence_bleu 子模块。
- 此外，我们生成一个引用语句列表，并通过对象 ref 指向它们。
- 然后我们创建一个测试句子，并使用 sentence_bleu()来测试它与 ref 的对比。
- 因此，它给出了一个大约为 1 的输出。
- 下一次，我们创建一个 test01 语句并将其传递给函数。
- 由于语句由和组成，后者是引用语句的一部分，但不完全匹配引用语句，因此它返回一个接近 0 的近似值。
from nltk.translate.bleu_score import sentence_bleu
ref = [
'this is moonlight'.split(),
'Look, this is moonlight'.split(),
'moonlight it is'.split()
]
test = 'it is moonlight'.split()
print('BLEU score for test-> {}'.format(sentence_bleu(ref, test)))
test01 = 'it is cat and moonlight'.split()
print('BLEU score for test01-> {}'.format(sentence_bleu(ref, test01)))
输出—
BLEU score for test-> 1.491668146240062e-154
BLEU score for test01-> 9.283142785759642e-155
用 Python 实现 N-gram score
如上所述，默认情况下，sentence_bleu()函数在引用语句中搜索 1 个单词进行匹配。我们可以根据引用语句在队列中搜索多个单词。这就是所谓的 N-gram。
- 1 克:1 个字
- 2-gram:成对的单词
- 三个字母:三个一组等等
同样，我们可以将以下参数传递给 sentence_bleu()函数来实现 N-gram:
1-gram: (1, 0, 0, 0)
2-gram: (0, 1, 0, 0)
3-gram: (1, 0, 1, 0)
4-gram: (0, 0, 0, 1)
举例:
在下面的示例中，我们使用下面提到的引用语句 ref 使用 sentence_bleu()函数计算了候选句子 test01 的 2-gram BLEU 得分，传递了 2-gram 得分的权重，即(0，1，0，0)。
from nltk.translate.bleu_score import sentence_bleu
ref = [
'this is moonlight'.split(),
'Look, this is moonlight'.split(),
'moonlight it is'.split()
]
test01 = 'it is cat and moonlight'.split()
print('2-gram:' sentence_bleu(ref, test01, weights=(0, 1, 0, 0)))
输出:
2-gram: 0.25
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
更多与 Python 编程相关的帖子，请继续关注我们。
在那之前，学习愉快！！🙂
Python 中的身体质量指数计算器——完整的分步教程
在本教程中，我们将了解什么是身体质量指数或身体质量指数，我们如何用 Python 编程语言创建身体质量指数计算器。
我们开始吧！
什么是身体质量指数(身体质量指数)？
BMI 取决于一个人的身高和体重。此外，人们根据他们的身体质量指数值被分为体重不足，超重，甚至肥胖。
BMI Or Body Mass Index Infographic Chart
身体质量指数可以作为精确测量身体脂肪百分比的替代品。此外，身体质量指数是一种低成本和简单的方法来检查那些可能因体重而有健康问题风险的人。
身体质量指数计算器的 Python 实现
身体质量指数是通过将一个人的体重(公斤)除以身高(米)的两倍来确定的，以下是用 Python 编写的身体质量指数计算器的代码:
h=float(input("Enter your height in meters: "))
w=float(input("Enter your Weight in Kg: "))
BMI=w/(h*h)
print("BMI Calculated is: ",BMI)
if(BMI>0):
if(BMI<=16):
print("You are very underweight")
elif(BMI<=18.5):
print("You are underweight")
elif(BMI<=25):
print("Congrats! You are Healthy")
elif(BMI<=30):
print("You are overweight")
else:
print("You are very overweight")
else:
print("enter valid details")
让我们逐行理解整个代码。
Line 1和Line 2–输入人的身高和体重
然后我们检查身体质量指数是否大于 0，因为体重和身高都不能为负，因此身体质量指数值不能小于 0。
现在，根据身体质量指数值，使用 if-else 条件语句将人分类为体重不足、健康和超重。
一些示例输出
Sample Output1 BMI
Sample Output2 BMI
结论
我希望你理解了身体质量指数以及如何用 python 实现和计算它。你自己试试！
编码快乐！😇
想了解更多？查看下面提到的教程:
Python 中的布尔索引——快速指南
原文：https://www.askpython.com/python/examples/boolean-indexing
布尔值可以作为数据帧中的索引，这不是很有趣吗？布尔索引代表数据帧中的每一行。布尔索引可以帮助我们从数据集中过滤掉不必要的数据。过滤数据可以让您获得一些深入的信息，否则您可能无法找到这些信息。在本文中，我们将学习如何使用布尔索引来过滤和分割数据。所以让我们开始吧！
Python 中的布尔索引
让我们从创建一个数据帧开始。我们将使用参加竞赛的一组候选人的年龄数据创建一个数据框架。
import pandas as pd
# Creating a dictionary
data = {'Name':["Tommy","Linda","Justin","Brendon"], 'Age':[31,24,16,22]}
df = pd.DataFrame(data,index=[True,False,True,False])
print(df)
输出
Name Age
True Tommy 31
False Linda 24
True Justin 16
False Brendon 22
1.使用. loc []函数
这是一个优秀而简单的函数，可以帮助你根据布尔索引过滤数据。使用这个函数，我们可以过滤掉具有特定布尔值的数据。假设我们将 True 传递给。loc []函数，我们将只得到索引值为 True 的过滤数据。在这个方法中，我们不能使用整数作为布尔值。
例如:
import pandas as pd
# Creating a dictionary
data = {'Name':["Tommy","Linda","Justin","Brendon"], 'Age':[31,24,16,22]}
df = pd.DataFrame(data,index=[True,False,True,False])
print(df.loc[True])
输出:
Name Age
True Tommy 31
True Justin 16
2.使用。iloc[]函数
iloc[]函数只接受整数值，因此我们需要将整数值传递给该函数。
例如:
import pandas as pd
# Creating a dictionary
data = {'Name':["Tommy","Linda","Justin","Brendon"], 'Age':[31,24,16,22]}
df = pd.DataFrame(data,index=[1,0,0,1])
print(df.iloc[1])
输出:
Name Linda
Age 24
Name: 0, dtype: object
3.使用。ix[]函数
这也是一种类似于上面的方法，但是在这种情况下我们可以使用整数作为布尔值。因此，例如，如果我们将索引值指定为 1 和 0，我们可以过滤索引值为 0 或 1 的行。
import pandas as pd
# Creating a dictionary
data = {'Name':["Tommy","Linda","Justin","Brendon"], 'Age':[31,24,16,22]}
df = pd.DataFrame(data,index=[1,1,0,0])
print(df.ix[0])
输出:
Name Age
0 Justin 16
0 Brendon 22
结论
总之，我们学习了如何在 python 中使用布尔索引并过滤有用的数据。希望这篇文章对你有所帮助。
Python 中的票房收入预测——一个简单的实现
原文：https://www.askpython.com/python/examples/box-office-revenue-prediction
你好。今天本教程结束时，我们将使用线性回归进行票房收入预测。我们开始吧！
分步票房收入预测
在这个机器学习项目中，我们将借助最流行的机器学习算法之一的线性回归来预测票房收入。
Simple Linear Regression Example
IBM 表示
线性回归分析用于根据一个变量的值预测另一个变量的值。你要预测的变量叫做因变量。用来预测另一个变量的值的变量称为自变量。
1.导入模块
让我们从为我们的项目导入模块开始。我们将与熊猫和 T2 以及 sklearn 一起工作。
import pandas
from pandas import DataFrame
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
plt.style.use('seaborn')
2.加载数据
下一步是加载数据，可以在这里找到。
为了加载数据，我们需要 read_csv 函数。让我们看看数据的形状以及数据的描述。
data = pandas.read_csv('cost_revenue_clean.csv')
print("Shape of data is: ",data.shape)
print("Description of data")
data.describe()
Description Box Office Data
3.数据可视化
现在我们已经成功地加载了数据，是时候以 scatter图的形式可视化数据了。
首先，我们从最初加载的数据中制作两个数据框架，包括生产成本和产生的全球收入。我们将分别存储为 X 和 Y 数据点，并使用plt.scatter函数绘制这些点。
下面是上述步骤的代码。
X = DataFrame(data, columns=['production_budget_usd'])
y = DataFrame(data, columns=['worldwide_gross_usd'])
plt.figure(figsize=(10,6))
plt.scatter(X, y, alpha=0.3)
plt.title('Film Cost vs Global Revenue')
plt.xlabel('Production Budget $')
plt.ylabel('Worldwide Gross $')
plt.ylim(0, 3000000000)
plt.xlim(0, 450000000)
plt.show()
Initial Box Office Visual
4.应用线性回归
该过程的最后一步是应用线性回归，包括以下主要步骤:
创建一个LinearRegression对象，并将 X 和 Y 数据点放入我们刚刚创建的模型对象中
regression = LinearRegression()
regression.fit(X, y)
现在让我们看看我们刚刚生成的作为模型输出的线性点是如何以直线的形式出现的。下面提到的代码也是如此。
plt.plot(X, regression.predict(X), color='red', linewidth=3)
plt.title("Final Linear Regression Line Plot")
plt.plot()
Final LR Box Office Plot
但是我们能够理解这个情节是否正确吗？让我们沿着数据的散点图绘制这条线。下面的代码将显示最终的情节。
plt.scatter(X, y, alpha=0.3,color="green")
plt.plot(X, regression.predict(X), color='red', linewidth=3)
plt.title("Final Linear Regression Plot")
plt.plot()
Final Box Office Revenue Prod Visual
用 Python 实现的票房收入预测
现在让我们从顶部开始组合所有的代码片段，看看我们完整的代码是什么样子的。
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
plt.style.use('seaborn')
data = pd.read_csv('cost_revenue_clean.csv')
X = pd.DataFrame(data, columns=['production_budget_usd'])
y =pd.DataFrame(data, columns=['worldwide_gross_usd'])
plt.figure(figsize=(10,6))
plt.subplot(1,2,1)
plt.scatter(X, y, alpha=0.3)
plt.title('Film Cost vs Global Revenue')
plt.xlabel('Production Budget $')
plt.ylabel('Worldwide Gross $')
plt.ylim(0, 3000000000)
plt.xlim(0, 450000000)
plt.subplot(1,2,2)
plt.scatter(X, y, alpha=0.3,color="green")
plt.plot(X, regression.predict(X), color='red', linewidth=3)
plt.title("Final Linear Regression Plot")
plt.plot()
plt.show()
Final Output Box Office
结论
我希望你理解这个概念，并喜欢输出。在您的系统上尝试相同的数据。编码快乐！😇
想了解更多？查看下面提到的教程:
箱线图:你需要知道的一切
箱线图使用四分位数来显示给定数据的分布情况。发现数据的分布是探索性数据分析(EDA)的重要部分。为此，我们有一些现有的工具，如直方图和密度图。
但是箱线图比这两者有一些主要的优势。
箱线图在一个非常小的平面上包含了更多的信息，当在一个图上比较两个或多个变量时会很有用。
在本文中，我们将了解盒图是什么，它们的用途，以及如何使用 Python 实现盒图。
解释箱线图
箱线图显示基于五个汇总统计数据的数据分布，即:
- 第一个四分位数(Q1)
- 第三个四分位数(Q3)
- 最低限度
- 最高的
- 中位数
它关注分布中的值的范围。
Box Plot Components
1.箱线图提供的摘要
- 中位数:中位数是中间两个数的平均值。它是数据集的中间值。
- 第一个四分位数(Q1) :第一个四分位数是中位数左边的数据点的中位数。它也被称为 25 日
- 第三个四分位数(Q3): 第三个四分位数是位于中位数右侧的数据点的中位数。
- **四分位范围(IQR):Q3–Q1 或第 25 百分位到第 75 百分位之间的数据。
- 最小值: Q1 -1.5 * IQR(不含离群值)
- 最大值:Q3 + 1.5 * IQR(不包括异常值)
2.极端值
箱线图非常善于在提供的数据中发现异常值。用箱线图发现异常值最常用的方法是 1.5 倍 IQR 法则。
任何小于 Q1-1.5 倍的数据点和任何大于 Q3+1.5 倍的数据点都被视为异常值。
用 Python 实现箱线图
可以使用许多绘图库绘制箱线图。让我们看看如何使用 python 创建箱线图。
我们将使用的数据集是 Titanic 数据集来演示绘图，你可以在这里下载数据集。
1.使用熊猫
Pandas 在 dataframe 上有一个boxplot方法，它只需要我们需要绘制的列作为输入参数。
*#Import the required modules
import numpy as np
import pandas as pd
data = pd.read_csv('Titanic.csv')
#Plotting Boxplot of Age column
boxplot = data.boxplot(column=['Age'])*
*
Pandas Boxplot Age Column*
如果我们的数据中有分类值，如性别等。然后熊猫可以根据每个类别创建箱线图。让我们看看如何做到这一点。
*boxplot = data.boxplot(column=['Age' ], by = ['Sex'])*
*
Pandas Boxplot Age With Gender Columns*
我们还可以传递一个包含多个列的列表，根据提供的列对数据进行分组，然后创建箱线图。
*boxplot = data.boxplot(column=['Age' ] , by = ['Sex','Survived'] , notch = True)*
*
Pandas Boxplot Grouped By Gender And Survived Columns*
当 notch 设置为 True 时，我们在箱线图上得到 notch，它显示了中值的置信区间，默认情况下，它被设置为 95%的置信区间。
在数据集上使用boxplot方法，可视化箱线图变得非常快。
2.使用 Seaborn
有了 Seaborn 我们可以绘制出一些真正高质量的方块图。让我们开始吧。
*#Importing required modules
import seaborn as sns
import pandas as ppd
data = pd.read_csv('Titanic.csv')
sns.boxplot(data = data , x = 'Survived' , y = 'Age' , hue = 'Sex')*
*
Seaborn Boxplot Grouped By Gender*
假设现在我们想要关于幸存和死亡的人的年龄并根据性别分组的箱线图，seaborn boxplot 有hue的论点，这对于这个目的是有用的。
*sns.boxplot(data = data , x = 'Survived' , y = 'Age' , hue = 'Sex' , notch = True )*
*
Seaborn Boxplot Grouped By Gender And Survived Columns*
3.使用 Matplotlib
尽管我们可以使用 seaborn 库用更少的代码行创建更具美感的情节，但 seaborn 实际上是建立在 Matplotlib 之上的。Matplotlib 有一个绘制箱线图的方法，方便地称为boxplot。
让我们使用 Matplotlib 创建箱线图。
*# importing required modules
import pandas as pd
import matplotlib.pyplot as plt
data = pd.read_csv('Titanic.csv')
plt.boxplot(data.Age.dropna() , labels = ['Age'])
plt.show()*
*
Matplotlib Boxplot Age*
我们可以通过将多个变量作为一个列表传递来创建它们的箱线图。
*plt.boxplot([data.Fare , data.Age.dropna()] , labels = ['Fare' , 'Age'])
plt.show()*
*
Matplotlib Boxplot On Fares And Age*
结论
在本文中，我们探讨了箱线图、它们的重要性以及它们的用途。我们还分别使用 pandas、seaborn 和 matplotlib 库实现了代码来创建我们自己的箱线图。快乐学习！
分支定界搜索，示例及 Python 实现
原文：https://www.askpython.com/python/examples/branch-and-bound-search
我们将尝试理解本文中的一种启发式搜索技术。启发式技术是一种标准，用于确定几个选择中哪一个对实现特定目标最有效。分支定界搜索也称为统一成本搜索。
什么是分支定界搜索算法？
分支定界是一种用于组合、离散和一般数学优化问题的搜索算法。它类似于回溯，因为它同样实现了一个状态空间流来表示问题的解决方案。
然而，它可能更适合尝试解决优化问题，并且只解决最小化问题，而不是最大化问题。从统计学上来说，分支和界限算法从整个搜索空间的可能性中为一个 NP-Hard 问题找到最佳解决方案。
分支和界限搜索是如何工作的？
在分支定界搜索策略中，生成成本函数(由 g(X)表示)，该成本函数通过使用一系列操作符，将累积成本分配给从开始节点到当前节点 X 的路径。已经发现的最便宜的价格路径在搜索空间生成过程的每一步都被扩展，直到我们到达目标状态。
分支限界搜索也称为统一成本搜索，因为它扩展了成本最低的部分路径。例如，在旅行推销员问题中，从起点到当前节点 X 行进的实际距离可以表示为 g(X)。
算法的步骤
Input: START and GOAL states
Local Variable: OPEN, CLOSED, NODE, SUCCs, FOUND
Output: Yes or No
Method:
Initialise FOUND = false
while(OPEN is not NULL and FOUND = false) do
{
remove the top element from OPEN list and call it NODE
if NODE is the goal node then FOUND = true
else
{
put NODE in CLOSED list:
find SUCCs of NODE. if any,and compute thier 'g' values and store them in OPEN list:
sort all the nodes in the OPEN list based on their cost - function values.
}
}end while loop
if FOUND = true then return Yes otherwise return No.
如果所有算子的 g(X) = 1，分支限界方法退化为直接的广度优先搜索。人工智能认为它与深度优先和广度优先一样有害。如果我们添加动态编程，我们可以通过消除冗余路径来做得更好。
我们注意到该方法通常需要创建一个解决方案并评估其功效。任何技术都可以用来得出答案，试探法也可以用于测试。以下是用于开发和测试策略的算法的基本结构。
start
Generate possible solutions
Test if it is a goal
If not go to start else quit
end
品牌和边界搜索算法的应用
为了更清楚地理解这个概念，让我们尝试使用分支定界算法来实现 8 难题。问题描述如下。
提供一个有 8 块瓷砖(每块瓷砖有 1 到 8 的数字)和一个空白空间的 3 x 3 板。目标是利用空白空间排列瓷砖上的数字，使它们与最终的排列相匹配。四个相邻的(左、右、上、下)牌可以滑入可用区域。
例如
Initial State
为了避免在不包括回答节点的子树中搜索，通常可以使用成本函数的近似来加速对回答节点的搜索。然而，它不使用回溯方法，而是进行 BFS 式的搜索。
基本上，分支和界限涉及三种不同的节点。
- 活节点是生成的节点，其子节点尚未生成。
- 现在正在检查 E 节点(一个活动节点)的子节点。或者换句话说，E 节点是当前正在扩展的节点。
- 将不被进一步开发或检查的已创建节点被称为死节点。一个死节点已经扩展了它的所有子节点。
代价函数:在搜索树中，每个节点 X 都有相应的代价。使用成本函数可以找到下一个 E 节点。具有最低成本的 E 节点是下一个。成本函数的定义是
C(X) = g(X) + h(X)
where
C(X) is also refered as 'f 'sometimes.
g(X) = cost of reaching the current node from the root
h(X) = cost of reaching an answer node from X.
Tree
用 Python 实现分支定界搜索算法
import copy
from heapq import heappush, heappop
# we have defined 3 x 3 board therefore n = 3..
n = 3
# bottom, left, top, right
row = [ 1, 0, -1, 0 ]
col = [ 0, -1, 0, 1 ]
class priorityQueue:
def __init__(self):
self.heap = []
# Inserts a new key 'k'
def push(self, k):
heappush(self.heap, k)
# remove minimum element
def pop(self):
return heappop(self.heap)
# Check if queue is empty
def empty(self):
if not self.heap:
return True
else:
return False
class node:
def __init__(self, parent, mat, empty_tile_pos,
cost, level):
# parent node of current node
self.parent = parent
# matrix
self.mat = mat
# position of empty tile
self.empty_tile_pos = empty_tile_pos
# Total Misplaced tiles
self.cost = cost
# Number of moves so far
self.level = level
def __lt__(self, nxt):
return self.cost < nxt.cost
# Calculate number of non-blank tiles not in their goal position
def calculateCost(mat, final) -> int:
count = 0
for i in range(n):
for j in range(n):
if ((mat[i][j]) and
(mat[i][j] != final[i][j])):
count += 1
return count
def newNode(mat, empty_tile_pos, new_empty_tile_pos,
level, parent, final) -> node:
new_mat = copy.deepcopy(mat)
x1 = empty_tile_pos[0]
y1 = empty_tile_pos[1]
x2 = new_empty_tile_pos[0]
y2 = new_empty_tile_pos[1]
new_mat[x1][y1], new_mat[x2][y2] = new_mat[x2][y2], new_mat[x1][y1]
# Set number of misplaced tiles
cost = calculateCost(new_mat, final)
new_node = node(parent, new_mat, new_empty_tile_pos,
cost, level)
return new_node
#print the N x N matrix
def printMatrix(mat):
for i in range(n):
for j in range(n):
print("%d " % (mat[i][j]), end = " ")
print()
def isSafe(x, y):
return x >= 0 and x < n and y >= 0 and y < n
def printPath(root):
if root == None:
return
printPath(root.parent)
printMatrix(root.mat)
print()
def solve(initial, empty_tile_pos, final):
pq = priorityQueue()
# Create the root node
cost = calculateCost(initial, final)
root = node(None, initial,
empty_tile_pos, cost, 0)
pq.push(root)
while not pq.empty():
minimum = pq.pop()
# If minimum is the answer node
if minimum.cost == 0:
# Print the path from root to destination;
printPath(minimum)
return
# Produce all possible children
for i in range(4):
new_tile_pos = [
minimum.empty_tile_pos[0] + row[i],
minimum.empty_tile_pos[1] + col[i], ]
if isSafe(new_tile_pos[0], new_tile_pos[1]):
# Create a child node
child = newNode(minimum.mat,
minimum.empty_tile_pos,
new_tile_pos,
minimum.level + 1,
minimum, final,)
# Add child to list of live nodes
pq.push(child)
# Driver Code
# 0 represents the blank space
# Initial state
initial = [ [ 2, 8, 3 ],
[ 1, 6, 4 ],
[ 7, 0, 5 ] ]
# Final State
final = [ [ 1, 2, 3 ],
[ 8, 0, 4 ],
[ 7, 6, 5 ] ]
# Blank tile position during start state
empty_tile_pos = [ 2, 1 ]
# Function call
solve(initial, empty_tile_pos, final)
输出
Output
摘要
在这篇文章中，我们学习了一种最有效的算法，叫做分支定界搜索。这种搜索算法有助于解决许多常见的问题，如 N 皇后问题，0-1 背包问题，旅行推销员问题等。在每种情况下，根据问题中提供的条件对算法进行比特修改，但是搜索方法的基本思想仍然与前面解释的相同。
图中的广度优先搜索
原文：https://www.askpython.com/python/examples/breadth-first-search-graph
广度优先搜索是一种遍历技术，在这种技术中，我们遍历一个图，并恰好打印一次顶点。在本文中，我们将研究并实现 python 中遍历图的广度优先搜索。
什么是广度优先搜索算法？
在广度优先搜索中，我们从任意单个顶点开始，遍历图的每个顶点恰好一次。对于每个选中的顶点，我们首先打印该顶点，然后打印它的所有邻居。这个过程一直持续到遍历完所有顶点。当使用广度优先搜索遍历图形时，看起来我们是从所选的顶点开始分层移动的。
从下面的例子可以清楚地理解这一点。
Graph Implementation In Python- Askpython
如果我们以广度优先的方式从 0 开始访问上图，我们将按照 0 –> 1 –> 3 –> 2 –> 4 –> 5 的顺序处理顶点。也可能有替代遍历。如果我们在 1 之前处理 3，而我们在 0，那么图的 BFS 遍历将看起来像:0 –> 3 –> 1 –> 4 –> 2 –> 5。
Python 中图的广度优先搜索算法
由于我们对广度优先搜索有了一个大致的概念，现在我们将阐述图的 BFS 遍历的算法。这里，我们将假设图的所有顶点都可以从起始顶点到达。
也读作:用 Python 实现一个图形
假设已经给了我们一个邻接表表示的图和一个起始顶点，我们必须遍历这个图。
我们将首先打印起始顶点的值，然后我们将打印起始顶点的邻居的值，在完成当前级别后，我们将继续下一个级别，直到图形的所有顶点都被打印出来。
因此，我们的任务是打印当前级别的顶点，从第一个顶点开始，直到每个顶点都被遍历。为了实现这个概念，我们将使用先进先出技术，即队列来处理图形。
此外，我们将使用一个访问过的顶点列表来检查顶点是否在过去被遍历过，这样就不会有顶点被打印两次。
我们将打印一个顶点，将其添加到已访问的顶点列表中，并将其邻居放入队列中。我们将从队列中逐个取出顶点，打印后添加到已访问列表中，然后将它们的邻居放入队列中。下面是描述整个过程的图的广度优先搜索遍历算法。
Algorithm BFS:
Input: Graph(Adjacency list) and Source vertex
Output: BFS traversal of graph
Start:
1.Create an empty queue Q.
2.Create an empty set to keep record of visited vertices.
3.Insert source vertex into the Q and Mark the source as visited.
4.If Q is empty, return. Else goto 5.
5.Take out a vertex v from Q.
6.Print the Vertex.
7.Insert all the vertices in the adjacency list of v which are not in visited list into Q and mark them visited.
8.Goto 4.
Stop.
Python 中图的广度优先搜索遍历
现在我们已经熟悉了概念和算法，我们将实现图的广度优先搜索算法，然后我们将执行上图中给出的图的算法。
from queue import Queue
graph = {0: [1, 3], 1: [0, 2, 3], 2: [4, 1, 5], 3: [4, 0, 1], 4: [2, 3, 5], 5: [4, 2], 6: []}
print("The adjacency List representing the graph is:")
print(graph)
def bfs(graph, source):
Q = Queue()
visited_vertices = set()
Q.put(source)
visited_vertices.update({0})
while not Q.empty():
vertex = Q.get()
print(vertex, end="-->")
for u in graph[vertex]:
if u not in visited_vertices:
Q.put(u)
visited_vertices.update({u})
print("BFS traversal of graph with source 0 is:")
bfs(graph, 0)
输出:
The adjacency List representing the graph is:
{0: [1, 3], 1: [0, 2, 3], 2: [4, 1, 5], 3: [4, 0, 1], 4: [2, 3, 5], 5: [4, 2], 6: []}
BFS traversal of graph with source 0 is:
0-->1-->3-->2-->4-->5-->
如果你还不能理解代码的执行，这里有一个修改的 BFS 算法解释每一步。
from queue import Queue
graph = {0: [1, 3], 1: [0, 2, 3], 2: [4, 1, 5], 3: [4, 0, 1], 4: [2, 3, 5], 5: [4, 2], 6: []}
print("The adjacency List representing the graph is:")
print(graph)
def bfs_explanation(graph, source):
Q = Queue()
visited_vertices = set()
Q.put(source)
visited_vertices.update({0})
while not Q.empty():
vertex = Q.get()
print("Processing {} after taking out from Q".format(vertex))
for u in graph[vertex]:
if u not in visited_vertices:
print("At {}, adding {} to Q".format(vertex, u))
Q.put(u)
visited_vertices.update({u})
print("visited vertices are: ", visited_vertices)
print("Explanation of BFS traversal of graph with source 0 is:")
bfs_explanation(graph, 0)
输出:
The adjacency List representing the graph is:
{0: [1, 3], 1: [0, 2, 3], 2: [4, 1, 5], 3: [4, 0, 1], 4: [2, 3, 5], 5: [4, 2], 6: []}
Explanation of BFS traversal of graph with source 0 is:
Processing 0 after taking out from Q
At 0, adding 1 to Q
At 0, adding 3 to Q
visited vertices are: {0, 1, 3}
Processing 1 after taking out from Q
At 1, adding 2 to Q
visited vertices are: {0, 1, 2, 3}
Processing 3 after taking out from Q
At 3, adding 4 to Q
visited vertices are: {0, 1, 2, 3, 4}
Processing 2 after taking out from Q
At 2, adding 5 to Q
visited vertices are: {0, 1, 2, 3, 4, 5}
Processing 4 after taking out from Q
visited vertices are: {0, 1, 2, 3, 4, 5}
Processing 5 after taking out from Q
visited vertices are: {0, 1, 2, 3, 4, 5}
结论
在本文中，我们看到了图的广度优先搜索遍历算法背后的基本概念，设计了它的算法，然后用 python 实现了它。我们还看到了 Python 中算法的逐步执行。请继续关注更多内容丰富的文章。
Python 中的砖块排序算法[易于实现]
原文：https://www.askpython.com/python/examples/brick-sort-algorithm
在本教程中，我们将学习如何实现砖块排序算法，以便对数组中的元素进行排序。这在编码界是未知的，但学习一种新的排序技术没有坏处。
在用 python 编程语言实现 brick sort 之前，让我们先了解一下什么是 brick sort。
也读作:在 Python 中插入排序
砖块排序算法简介
砖块排序，又称奇偶排序，是泡泡排序的修改版本。排序算法分为两个阶段，即奇数阶段和偶数阶段。通过确保在每次迭代中执行偶数和奇数阶段，控制将一直运行，直到对数组进行排序。
现在你可能会问这些奇数和偶数阶段是什么意思？当控件执行奇数阶段时，我们将只对奇数索引处的元素进行排序。在事件阶段的执行过程中，以类似的模式，控件将只对偶数索引处的元素进行排序。
砖块排序算法实现
为了实现砖块排序，我们将遵循一些步骤，下面也将提到。
- 声明砖块排序函数来执行排序，并取一个变量到在奇数和偶数阶段之间切换。
- 创建一个变量 isSort ，初始值为 0。此变量的目的是跟踪当前阶段。
- 运行 while 循环进行迭代，直到 isSort 等于 1。
- 创建一个内部 for 循环来对奇数条目进行排序。
- 类似地，创建另一个内部 for 循环来对偶数条目进行排序。
- 一旦排序完成，我们返回结果。
在 Python 中实现砖块排序
让我们直接进入 Python 中的块排序算法的实现，并确保我们可以获得预期的输出。
def brickSort(array, n):
isSort = 0
while isSort == 0:
isSort = 1
for i in range(1, n-1, 2):
if array[i] > array[i+1]:
array[i], array[i+1] = array[i+1], array[i]
isSort = 0
for i in range(0, n-1, 2):
if array[i] > array[i+1]:
array[i], array[i+1] = array[i+1], array[i]
isSort = 0
return
array = [31, 76, 18, 2, 90, -6, 0, 45, -3]
n = len(array)
print("Array input by user is: ", end="")
for i in range(0, n):
print(array[i], end =" ")
brickSort(array, n);
print("\nArray after brick sorting is: ", end="")
for i in range(0, n):
print(array[i], end =" ")
上面提到的代码如下所示。您可以看到数组排序成功。
Array input by user is: 31 76 18 2 90 -6 0 45 -3
Array after brick sorting is: -6 -3 0 2 18 31 45 76 90
结论
我希望今天你学到了一种新的排序算法。虽然要求不多，但是口袋里有一些额外的知识总是好的！
感谢您的阅读！快乐学习！😇
Python 中的气泡图——初学者指南
原文：https://www.askpython.com/python/examples/bubble-plots-in-python
在本教程中，我们将学习如何使用 Matplotlib 在 Python 中创建气泡图。
气泡图是散点图，但散点图上数据点的大小由不同的变量编码。从本质上讲，如果第三个变量更大，你会得到一个更大的充满颜色的圆，即一个更大的气泡，一个更小的气泡代表一个更低的数值。
导入必要的模块/库
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
在 PYthon 中为气泡图创建数据
为了创建气泡图，我们将使用 NumPy random 函数模拟数据。
我们为散点图构造一个 x 和 y 变量，以及气泡图中气泡大小的第三个变量。在 Python 中，我们可以添加第四个变量来给气泡图着色。
np.random.seed(42)
N = 100
x = np.random.normal(170, 20, N)
y = x + np.random.normal(5, 25, N)
colors = np.random.rand(N)
area = (25 * np.random.rand(N))**2
让我们将模拟数据放入熊猫数据框中。在这个例子中，我们通过使用 Pandas 的 data frame 方法并以字典的形式传递变量，从 NumPy 数组创建一个数据帧。
df = pd.DataFrame({
'X': x,
'Y': y,
'Colors': colors,
"bubble_size":area})
df.head()
Bubble Plot Dataset
绘制气泡图
使用 Matplotlib 和 scatter()方法，我们可以在 Python 中创建气泡图。要创建气泡图，我们必须使用大小选项“s”来确定数据点的大小。
在我们的例子中，使用了 s =‘气泡大小’。
plt.style.use('ggplot')
plt.scatter('X', 'Y', s='bubble_size',alpha=0.5, data=df)
plt.xlabel("X", size=16)
plt.ylabel("y", size=16)
Bubble Plot 1
基于 size 变量的值，我们可以看到散点图中的点现在是气泡。默认情况下，Matplotlib 将气泡着色为蓝色。我们还使用 alpha=0.5 为气泡图中的气泡提供透明度。
获取彩色气泡图
让我们在泡泡图中使用另一个变量来给泡泡涂上不同的颜色。可以使用 scatter()函数的“c”选项来指定颜色。我们使用 c =“Colors”选项，用一个变量给气泡着色。颜色是我们在构建数据框时定义的定量变量。
plt.scatter('X', 'Y',s='bubble_size',c='Colors',alpha=0.5, data=df)
plt.xlabel("X", size=16)
plt.ylabel("y", size=16)
Bubble Plot Colors
结论
恭喜你！您刚刚学习了如何用 Python 绘制气泡图。希望你喜欢它！😇
喜欢这个教程吗？无论如何，我建议你看一下下面提到的教程:
感谢您抽出时间！希望你学到了新的东西！！😄
Python 中的冒泡排序
原文：https://www.askpython.com/python/examples/bubble-sort-in-python
我们来研究一个最直观最易学的排序算法，用 Python 实现冒泡排序。我们将从理解排序本身开始，然后我们将通过冒泡排序进行排序，最后，我们将看到如何在 Python 中实现它。
排序算法的重要性
什么是排序？为什么它如此重要？这些是我们将在本节中尝试回答的问题。
从图书馆里的书和字典里的单词到数据库的条目和处理器中的指令，我们经历了无数次排序。
在计算机科学中，排序是将事物按有序的顺序排列的行为–维基百科
这意味着当我们对事物进行排序时，我们需要知道我们将根据什么标准来安排给我们的序列。出于本教程的目的，我们将假设标准是一个数字的值，我们将对一个给定的数字序列进行排序。
在计算机科学中，排序最重要的目的是产生高效的算法。二分搜索法是一种异常快速的搜索算法，在无序的对象集合中是不可能的。
几乎所有的集合操作对排序后的数据都非常有效。
除了制造有效的算法，当一个程序的真正需求是对某样东西进行排序时，就要用到排序，就像一个处理一副卡片的程序。因此，排序算法是程序员必须知道的最基本的概念之一。
了解冒泡排序算法
想想在一杯苏打水里，里面的气泡是如何升起的。气泡代表给定序列中的最大/最小元素，气泡的上升运动代表最大/最小元素如何移动到序列的结尾/开头。
这就是冒泡排序的工作原理，也是它得名的原因。
简单地说，我们遍历序列多次，每次，我们交换几对元素，使得序列中最大/最小的元素在序列的一端结束。
出于本教程的考虑，我们将考虑给定的数组，我们将按照数字值的升序对其进行排序。
12, 16, 11, 10, 14, 13
现在，冒泡排序算法的工作原理是这样的，按升序排序:
- 考虑两个变量 i 和 j 。 i 表示我们已经排序的元素的数量，或者我们遍历列表的次数，因为每次遍历列表，我们都会对一个项目进行排序。
j 代表列表中的一个位置，所以如果我们说 j 是 3，那么我们说的就是列表中的第三个数字，也就是 11。 - 将 n 视为列表中元素的数量。
- 设 i 等于 0。因为我们没有浏览列表，也没有对元素进行排序。
- 设 j 等于 1。所以我们从第一个位置的数字开始。
- 如果位置 j 的数字大于位置 j+1 的数字，那么我们需要交换位置 j 和 j+1 的数字。这是因为列表是按升序排列的，所以前面的数字不能大于后面的数字。
- 将 j 增加 1。那么现在，我们可以看下一对数字了。
- 如果 j 不是 n-i ，则进入步骤 5，否则，我们停止循环，进入下一步。在这个循环中，每次交换发生时，较大的元素向列表的末尾移动。这是冒泡排序的行为，最大的元素在列表末尾冒泡。如果 i 表示已经排序的元素的数量，那么列表的最后 i 元素处于它们的正确位置(因为它们在我们遍历循环的 i 次数中冒泡通过)，所以我们不需要检查最后的 i 元素，因为这只会浪费时间，因此当 j 等于 n-i 时循环结束。
- 将 i 增加 1。如果我们在 j 到达末尾时结束循环，那么我们又一次遍历了列表，又一个元素被排序。
- 如果 i 不是 n-1 ，则转到步骤 4，否则，我们用 i 停止循环，转到下一步。你可能已经注意到了，有两个循环，带有 j 的内部循环负责再排序一个元素，我们总共有 n 个元素要排序，这由运行在 i 上的外部循环处理。如果 i 变为 n-1 ，这意味着 n-1 个元素被排序，这自动意味着最后一个元素也在其正确的位置，这意味着整个序列被排序，因此我们停止。
- 序列已排序。
现在，你可能想在给定的序列上尝试一下，这就是我们现在要做的。
冒泡排序示例
给定顺序:12，16，11，10，14，13
元素个数( n ): 6
让我们开始-
- 第一步:变量 i 和 j 代表排序后的元素和位置。
- 第二步: n 为 6。 n = 6
- 第三步:设置 i 为 0。 i = 0
- 第四步:设置 j 为 1。 j = 1
- 第五步:比较位置 j 和 j+1 ，位置 1 (12)的元素不大于位置 2 (16)的元素。
- 第六步:增量 j 。 j = 2
- 第七步: j (2)不是 n-i (6)，所以我们到第五步。
- 第五步:位置 2 (16)大于位置 3 (11)，所以我们互换。
- 序列:12、 11、 、 16、 、10、14、13
- 第六步:增量 j 。 j = 3
- 第七步: 3 不是 6，所以我们到第五步。
- 第五步: 16 大于 10，所以我们互换。序列:12、、 10、、、 16、、，14、13
- 第六步:增量 j 。 j = 4
- 第七步: 4 不是 6，所以我们到第五步。
- 第五步: 16 大于 14，所以我们互换。序列:12、11、10、、14、、 16、、13、
- 第六步:增量 j 。 j = 5
- 第七步: 5 不是 6，所以我们到第五步。
- 第五步: 16 大于 13，所以我们互换。序列:12、11、10、14、、、、 16、、、
- 第六步:增量 j 。 j = 6
- 第 7 步: j (6)等于 n-i (6)，那么我们继续第 8 步。注意最大的元素(16)在最后，我们已经确定排序了一个元素。
- 第八步:增加I .I = 1
- 第 9 步: i (1)不是 n-1 (5)，所以我们从第 4 步开始全部重复一遍，循环继续，得到的序列变化会是这样的:
【11】、【12】、10、14、13、【16】
【11】、 16 ，【11】，， 【11】、12】【13】、【14】、【16】
【10】、【11】
在这之后， i 变成了 5，也就是 n-1 ，于是循环结束，算法告诉我们列表已经排序。看起来在算法完成之前，列表可能已经被排序了，这仅仅意味着给定的序列在给算法之前已经被排序了。
在 Python 中实现冒泡排序
现在我们已经准备好了算法，我们可以开始用 Python 实现每一步了。有一些事情需要注意:
该序列将由一个列表来表示，并且列表具有索引而不是位置，并且索引从 0 到大小-1 而不是 1 到大小，所以这将需要被调整，下面是该算法看起来的样子:
def bubble_sort(sequence):
n = len(sequence)
for i in range(n-1):
for j in range(n-i-1):
if(sequence[j] > sequence[j+1]):
sequence[j], sequence[j+1] = sequence[j+1], sequence[j]
让我们用一个例子，并用这个算法对它进行排序:
**
Binary Sort Example**
注意，这个算法就地对列表进行排序，但是很容易修改算法，使它返回一个排序后的列表。
结论
在本教程中，我们学习了什么是排序以及在哪里使用排序，然后我们学习了冒泡排序是如何工作的，我们提出了一个算法并用 Python 实现了冒泡排序。
冒泡排序是众多排序算法中的一种，它远不是最好的，但却非常容易实现。不经常使用它的原因是它的复杂性为 O(n² ，这意味着如果列表中的元素数量增加一倍，使用该算法对它们进行排序所需的时间将增加四倍。
所以对于非常大的数据量，这个算法就变得低效了。然而，作为一名程序员，了解冒泡排序是很重要的，我希望你能学到一些东西。
用 python 从 CSV 文件构建仪表板[简单步骤]
原文：https://www.askpython.com/python/examples/build-a-dashboard-in-python
读者你好！在本教程中，我们将了解如何使用 dash 从 CSV 文件中快速构建 Python 中的仪表板。
Dash 是一个 Python 框架，使得任何人都可以轻松地用 Python 构建仪表板，而不必直接处理所需的前端。
用 Python 构建仪表板的步骤
现在让我们开始使用 Python 构建一个仪表板，使用 dash 库显示 CSV 文件中的数据！
步骤 1:使用 Plotly 绘制数据
我们将使用一个简单的 CSV 文件作为数据源，即 COVID 时间序列数据集。
我正在使用来自 Kaggle 的这个新冠肺炎数据集。一旦你准备好了，我们就可以开始使用了。
为了渲染这些图，我们将使用 Python plotly 库。要安装此库，请使用:
pip install plotly
现在让我们画出各种状态的时间序列数据。我们将使用 Pandas read_csv()函数从 csv 数据集中读取数据。这只是三行简单的代码！
import plotly.express as px
df = pd.read_csv('covid_19_india.csv')
# Plot the scatterplot using Plotly. We ploy y vs x (#Confirmed vs Date)
fig = px.scatter(df, x='Date', y='Confirmed', color='State/UnionTerritory')
fig.update_traces(mode='markers+lines')
fig.show()
现在 plotly 应该给你一个很好的数据可视化。现在让我们在 Dash 应用程序中渲染它。
步骤 2:用破折号嵌入图形
为了呈现我们的仪表板应用程序，我们将使用破折号。使用以下方式安装此库:
pip install dash
我们将使用 dash 在布局中呈现数据。
在此之前，让我们设置一些样式表(CSS)来使我们的页面看起来更好！我用的是这个 dash 官方教程的默认数据。
import dash
import dash_core_components as dcc
import dash_html_components as html
import plotly.express as px
import pandas as pd
external_stylesheets = ['https://codepen.io/chriddyp/pen/bWLwgP.css']
app = dash.Dash(__name__, external_stylesheets=external_stylesheets)
colors = {
'background': '#F0F8FF',
'text': '#00008B'
}
现在让我们在这个布局中配置我们的数据。
# Our dataframe
df = pd.read_csv('covid_19_india.csv')
fig = px.scatter(df, x='Date', y='Confirmed', color='State/UnionTerritory')
fig.update_traces(mode='markers+lines')
app.layout = html.Div(children=[
html.H1(children='COVID-19 Time Series Dashboard'),
html.Div(children='''
COVID-19 Dashboard: India.
'''),
dcc.Graph(
id='example-graph',
figure=fig
)
])
步骤 3:用 Flask 运行应用服务器
现在，让我们最后运行应用服务器(通过 Flask ):
if __name__ == '__main__':
app.run_server(debug=True)
这将在本地端口 8050 上启动服务器。我们现在来看看输出，当我们到http://localhost:8050的时候
Dashboard Output
正如你所看到的，我们确实用几行 Python 代码就有了一个好看的交互式仪表板！
结论
在本教程中，我们学习了如何使用 Dash 从 CSV 文件构建 Python 中的仪表板。
如何用 Python 构建货币转换器
原文：https://www.askpython.com/python/build-currency-converter-python
你曾经尝试过提供一种产品，一种服务，或者只是想用不同的货币显示价格吗？那么你就知道提供最新的、准确的汇率有多难。
这就是货币兑换 API 的用武之地。外汇 API 帮助您处理您的外汇汇率转换。在这个例子中，我们将看看如何使用 Flask web 框架和一些用于前端样式的 Javascript 将货币 API 集成到一个简单的 Python 应用程序中，以便您可以构建自己的货币转换器。
如何用 Python 创建货币转换器的分步指南
首先，我们将建立我们的开发堆栈:
- Python 3 ( > 3.7)
- 烧瓶
- Javascript (节点)
- 纱线(npm 安装-全球纱线)
- 轻快地
- 顺风 CSS
- postcss
- 自动贴合
- 免费的currencyapi.comAPI 密钥
步骤 1:初始化我们的前端项目
首先，我们需要在开发工作区中初始化一个 Vite 项目:
yarn create vite currency-converter --template vanilla
步骤 2:样式设置(可选)
样式是可选的，但是如果您选择遵循这个步骤，我们推荐使用 Tailwind CSS。Autoprefixer & postcss 进一步实现了流畅的开发体验。因此，我们需要安装这些软件包:
yarn add -D tailwindcss postcss autoprefixer
现在我们可以初始化顺风。这将创建一个配置文件(tailwind.config.js):
npx tailwindcss init
我们现在需要修改这个新创建的配置，以便与我们的 Vite 项目设置一起工作:
module.exports = {
content: [
'./main.js',
'./index.html',
],
theme: {
extend: {},
},
plugins: [],
}
要包含 Tailwind CSS，请在 style.css 的顶部添加以下代码行:
@tailwind base;
@tailwind components;
@tailwind utilities;
接下来，我们需要在 postcss 的根目录下创建一个名为 postcss.config.js 的配置文件。因此，我们补充:
module.exports = {
plugins: [
require('tailwindcss'),
require('autoprefixer')
]
}
第三步:开始邀请
我们现在可以在开发模式下启动 vite，通过热重装来提供我们的文件:
yarn dev
步骤 4:准备我们的 HTML
接下来，我们要修改默认的登录页面。为此，我们打开 index.html 并构建一个表单。我们将需要以下要素:
- 我们输入的包装器
- 本方基础货币的输入:
- 基础货币选择
<select id= currency >提交按钮一个响应容器下面是我们实现 index.html 的样子:
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8" /> <link rel="icon" type="image/svg+xml" href="favicon.svg" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" /> <title>Currency converter example</title> </head> <body class="bg-gradient-to-b from-cyan-800 to-slate-800 min-h-screen py-5"> <form id="currency_converter" class="mx-auto w-full max-w-sm bg-white shadow rounded-md p-5 space-y-3 text-sm"> <div class="flex items-center space-x-5"> <label for="base_currency_input">Amount:</label> <input type="tel" id="base_currency_input" name="base_currency_input" placeholder="1" value="" class="grow border-slate-300 border rounded-md py-2 px-4 text-sm" required /> </div> <div class="flex items-center space-x-5"> <label for="currency">Currency:</label> <select name="currency" id="currency" class="bg-gray-50 border border-gray-300 text-gray-900 text-sm rounded-lg focus:ring-blue-500 focus:border-blue-500 block w-full p-2.5 dark:bg-gray-700 dark:border-gray-600 dark:placeholder-gray-400 dark:text-white dark:focus:ring-blue-500 dark:focus:border-blue-500"> <option selected value="USD">USD</option> <option value="EUR">EUR</option> <option value="CHF">CHF</option> </select> </div> <button type="submit" class="bg-slate-800 text-white rounded-md py-2 px-4 mx-auto relative block w-full">Convert </button> </form> <div id="result" class="mx-auto my-5 w-full max-w-sm bg-white shadow rounded-md relative overflow-hidden text-sm empty:hidden divide-y divide-dotted divide-slate-300"> </div> <script type="module" src="/main.js"></script> </body> </html>
步骤 5:用 JavaScript 处理表单提交
在 main.js 中，我们将货币金额(base_currency_input)和货币(base_currency)发送到后端。我们将在响应中收到所有货币和相应值的列表。
import './style.css' const currencyConverter = document.getElementById('currency_converter'); const baseCurrencyInput = document.getElementById('base_currency_input'); const baseCurrency = document.getElementById('currency'); const resultContainer = document.getElementById('result'); currencyConverter.addEventListener('submit', (e) => { e.preventDefault(); fetch(`http://localhost:6001/convert?` + new URLSearchParams({ 'base_currency_input': baseCurrencyInput.value, 'currency': baseCurrency.value })) .then(response => response.json()) .then(data => { var result = '<div class="space-y-1 px-5 py-3 border-2 rounded-md">'; for (let entry of data) { result += `<div class="flex items-baseline justify-between"><span class="font-medium">${entry.code}:</span><span>${entry.value}</span></div>`; } resultContainer.innerHTML = result; }); });
步骤 6:准备后端应用程序
现在，我们创建一个新文件夹，即“货币转换器”文件夹中的“后端应用程序”: 注意:命令对 macOS/Linux 有效；对于 Windows，请在这里勾选。
mkdir backend-application cd backend-application python3 –m venv venv . venv/bin/activate pip install Flask currencyapicom
步骤 7:创建后端应用程序
在最后一步中，我们只需添加一个名为“main.py”的新文件:
from flask import Flask, request, jsonify from currencyapicom import Client from config import CURRENCYAPI_KEY app = Flask(__name__) @app.route("/convert", methods=['GET']) def convert(): currency_input = request.args.get('base_currency_input', '') currency = request.args.get('currency', 'USD') if currency_input and currency in ['USD', 'EUR', 'CHF']: api_client = Client(CURRENCYAPI_KEY) response = api_client.latest(currency) response = jsonify([{'value': response['data'][x]['value'] * float(currency_input), 'code': x} for x in response['data'].keys()]) response.headers.add("Access-Control-Allow-Origin", "*") return response
我们可以用几个简单的命令运行应用程序(我们将端口绑定到 6001 以避免与其他应用程序冲突):
export FLASK_APP=main flask run –port 6001
在最后一步，我们需要创建一个“config.py”文件，包括 currencyapi.com API 密钥。您可以免费获得它，并在文档中了解更多关于 API 的信息。就是这样！ 最新和准确通过这几个步骤，您现在可以使用 Python 构建自己的货币转换器，并以不同的货币显示准确和最新的价格。货币转换器有许多使用案例；无论您是将它用于电子商务商店、分析还是电子表格，我们都希望本教程能指导您完成这一过程。
用 Python 计算整数中的设定位
原文：https://www.askpython.com/python/examples/calculate-set-bits-integer
嘿，勒纳！在本教程中，我们将使用 Python 编程语言来计算一个整数中设置位的总数。这个问题将展示位操作概念的重要性和威力。
什么是设置位–简介
在二进制数的世界中，集合位由 1 表示。所以，基本上，我们需要找出一个数的二进制形式中 1 的总数。
No Set Bits Demonstration
理解问题
N 给出一个数字。
返回数字 n 的二进制版本中存在的集合位的总数
例如，
如果给定的数(N) = 5。那么结果就是 2，因为 5 的二进制版本是 101。101 中 1 的总数是 2。因此，设置位的数量是 2。
方法 1:手动转换
将给定的十进制数转换为二进制数，然后计算转换后的二进制数中 1 的总数。然而，这不是解决问题的有效方法。
在这种情况下，时间复杂度将是线性的，但是我们可以使这种策略更有效。
方法 2:位操作
因此，在这种方法中，我们将看到一种位操作方法。通过使用这种方法，我们可以提高代码和方法的效率。
因此，我们将遵循以下步骤:
- 检查 N 是否大于 0
- 计算 A 和 A-1 的和
- 不断重复步骤 2，直到 A！= 0
- 我们将保持迭代次数的计数
- 该计数等于数字 N 中的置位位数
使用 Python 计算设定位
def countsetbits(A):
count = 0
while(A!=0):
A = A & (A-1)
count = count+1
return(count)
n = int(input("Enter the Number: "))
print(countsetbits(n))
样本输出
Enter the Number: 5
2
Enter the Number: 100
3
我希望你能理解问题背后的概念以及问题的解决方案。
感谢您阅读教程！😇
Python 中如何使用 Numpy 计算平方根？
原文：https://www.askpython.com/python-modules/numpy/calculate-square-root-using-numpy
数学中有许多令人感兴趣的度量。其中一个度量就是平方根！当问题是找出这些数字的平方根时，我们可以很容易地大声说出这些数字，而这些数字是它们自身的乘积，当它们不再符合上述条件时，事情就变得很糟糕了。
在本文中，我们将探索使用 numpy 库中的内置函数来计算给定实体的平方根的不同方法—sqrt()函数！
重要的事情先来！在使用下面的代码部署 sqrt( ) 函数之前，导入 numpy 库。
import numpy as np
我们将在接下来的章节中介绍 sqrt( ) 函数的各个方面。
- sqrt()函数的语法
- 计算一维数组的平方根
- 计算 N 维数组的平方根
- 计算复数的平方根
- 限制 sqrt( ) 功能
sqrt()函数的语法
在深入了解如何使用 sqrt( ) 函数的细节之前，让我们从理解它正常运行所需的基本组件开始。
numpy.sqrt(x, out=None, where=True, dtype=None)
在哪里，
- x—要计算平方根的输入数组或标量实体
- out—一个可选的构造，默认情况下设置为 none ，但可用于将结果存储在所需的数组中，该数组的长度与输出的长度相同
- 其中—一个可选构造，当设置为真(默认设置)时，用于计算给定位置的通用函数(ufunc ),当设置为假时，不计算
- dtype—可选结构，用于指定正在使用的数据类型
计算一维数组的平方根
在导入了 numpy 库之后，让我们用要计算平方根的元素构建一个一维数组，如下所示。
ar1 = [[12, 36, 71, 99]]
现在让我们使用 sqrt( ) 函数来推导上述数组的结果。
np.sqrt(ar1)
Square Root Calculated For One-Dimensional Array
计算 N 维数组的平方根:
与一维数组类似，也可以计算 N 维数组中给定实体的平方根。下面是一个二维数组，使用如下所示的 sqrt( ) 函数计算平方根。
ar2 = np.array([[12.5, 33.3, 25],
[26, 79, 14.5]], dtype = float)
np.sqrt(ar2)
Square Root Calculated For Two-Dimensional Array
计算复数的平方根
虽然简单的平方根推导可以让我们大赚一笔，但当我们冒险进入复数领域时，事情就变得更加棘手了。为了客观地看待问题，下面是用于计算复数平方根的公式！
Square Root Formula For Complex Numbers
为了将我们从痛苦中解救出来， sqrt( ) 函数也能够推导出复数的平方根。它能够从给定的数组中直接推导出一个复数，但是这个特性的另一面是，这个函数继续将数组中的所有其他元素也视为一个复数。
ar3 = [[12+5j, 33-3j, 25],
[26, 7-9j, 14+5j]]
np.sqrt(ar3)
Square Root Calculated For Complex Numbers
sqrt()函数的限制
虽然它将能力扩展到了复数，但这并不是说 sqrt( ) 函数是万能的，而是说它也有其局限性。其中之一就是计算负数平方根的能力。
现在让我们试着找出'-6 '的平方根，并见证它的结果。
Warning & NaN Error Appears
结论
现在我们已经到了本文的结尾，希望它已经详细说明了如何使用来自 numpy 库的 sqrt( ) 函数来寻找数组元素的平方根。这里有另一篇文章解释了如何使用 Python 中的 numpy 在一组数组元素中找到的最大值。AskPython 中还有许多其他有趣的&内容丰富的文章，可能对那些希望提高 Python 水平的人有很大帮助。当你享受这些的时候，再见！
Python 中计算平方根的 4 种方法
原文：https://www.askpython.com/python/examples/calculate-square-root
在本教程中，我们将讨论在 Python 中计算平方根的不同方法。
什么是平方根？
在数学中，一个数' p 的平方根是一个数' q ，它遵循条件p = q²。在 Python 中，我们有那么多计算数字平方根的方法。我们来讨论一下 Python 中一些比较知名的计算数字平方根的方法。
1.使用指数运算符计算平方根
在这个方法中，我们将定义自己的函数来求一个数的平方根。为了计算一个数的平方根，我们将在 Python 中使用指数运算符(**)。
定义的函数将一个数字作为参数，如果它是正的，返回这个数字的平方根，否则它将打印一个警告。让我们用 Python 代码实现它。
# Define the user defined sqrt() function
# to calculate the square root of a number
def sqrt(N):
if N < 0:
print('Square root of negative number does not exist!')
return
else:
print(f'Square root of number {N}: {N**0.5}')
return
# Call the above defined sqrt() function
# to calculate the square root of a number
sqrt(441)
sqrt(0.81)
sqrt(6.25)
sqrt(634)
sqrt(-121)
输出:
Square root of number 441: 21.0
Square root of number 0.81: 0.9
Square root of number 6.25: 2.5
Square root of number 634: 25.179356624028344
Square root of negative number does not exist!
2.使用 sqrt()函数
在 Python 中，sqrt()函数是在数学模块中定义的预定义函数。sqrt()函数返回作为参数传递的数字的平方根。让我们看看如何在 Python 程序中使用内置的sqrt()函数。
# Import Python math module
import math as m
# Call the predefined sqrt() function
# to calculate the square root of a number
print(f'Square root of number 121: {m.sqrt(121)}')
print(f'Square root of number 0.49: {m.sqrt(0.49)}')
print(f'Square root of number 4.41: {m.sqrt(4.41)}')
print(f'Square root of number 265: {m.sqrt(265)}')
输出:
Square root of number 121: 11.0
Square root of number 0.49: 0.7
Square root of number 4.41: 2.1
Square root of number 265: 16.278820596099706
注意:如果一个负数作为参数传递给内置的 sqrt()函数，那么它将抛出一个数学域错误。让我们看一个例子。
# Import Python math module
import math as m
# Call the predefined sqrt() function
# to calculate the square root of a negative number
m.sqrt(-125)
输出:
math domain error: sqrt()
3.使用 pow()函数
在这个计算平方根的方法中，我们将使用内置的 pow()函数。在 Python 中，pow()函数是在math模块中定义的预定义函数。pow()函数接受两个参数，一个是基数，另一个是指数/幂，并返回作为第一个参数传递的数字的平方根(基数)。为了计算平方根，指数/幂参数固定为 0.5 。让我们看看如何在 Python 程序中使用内置的pow()函数。
# Import Python math module
import math as m
# Call the predefined pow() function
# to calculate the square root of a number
print(f'Square root of number 625: {m.pow(625, 0.5)}')
print(f'Square root of number 0.64: {m.pow(0.64, 0.5)}')
print(f'Square root of number 1.21: {m.pow(1.21, 0.5)}')
print(f'Square root of number 7: {m.pow(7, 0.5)}')
输出:
Square root of number 625: 25.0
Square root of number 0.64: 0.8
Square root of number 1.21: 1.1
Square root of number 7: 2.6457513110645907
注意:同样，如果一个负数作为参数传递给内置的pow()函数，那么它将抛出一个数学域错误。让我们看一个例子。
# Import Python math module
import math as m
# Call the predefined pow() function
# to calculate the square root of a negative number
m.pow(-121, 0.5)
输出:
math domain error: pow()
4.使用内置的 np.sqrt()函数
在这种求平方根的方法中，我们将使用内置的np.sqrt()函数。在 Python 中，np.sqrt()函数是在 numpy 模块中定义的预定义函数。np.sqrt()函数返回一个 numpy 数组，其中每个元素是作为参数传递的 numpy 数组中相应元素的平方根。让我们看看如何在 Python 程序中使用内置的np.sqrt()函数。
# Import Python numpy module
import numpy as np
# Define a numpy array
arr = np.array([0, 225, 0.36, 6.25, 10, -15])
print('NumPy array:')
print(arr)
# Call the predefined np.sqrt() function
# to calculate the square root of each element
# in the numpy array
print('Returned NumPy array with Square roots:')
print(np.sqrt(arr))
输出:
NumPy array:
[ 0\. 225\. 6.25 10\. -15\. ]
Returned NumPy array with Square roots:
[ 0\. 15\. 2.5 3.16227766 nan]
<ipython-input-29-541b85f9361a>:13: RuntimeWarning: invalid value encountered in sqrt print(np.sqrt(arr))
注意:如果在 numpy 数组中有一个负数，并且它被传递给内置的np.sqrt()函数，那么它将抛出一个 RuntimeWarning 表示在 sqrt 中遇到一个无效值。并在返回的 numpy 数组中负元素的平方根处设置一个 nan 值。
结论
在本教程中，我们学习了用 Python 计算数字平方根的不同方法。我们还学习了如何使用 Python 函数，如math.sqrt()、math.pow()和numpy.sqrt()。希望你已经很好地理解了这些事情，并很高兴探索和学习更多。
Python 中如何计算汇总统计？
原文：https://www.askpython.com/python/examples/calculate-summary-statistics
要在 Python 中计算汇总统计数据，您需要使用。描述熊猫下的 () 法。。describe()方法既处理数字数据，也处理对象数据，比如字符串或时间戳。
两者的输出将包含不同的字段。对于数字数据，结果将包括:
对于对象数据，结果将包括:
- 数数
- 独一无二的
- 顶端
- 频率
使用 describe()方法在 Python 中计算汇总统计数据
在本教程中，我们将看到如何使用？用数字和对象数据描述()方法。
我们还将看到如何使用？描述方法。
让我们开始吧。
1.数字数据的汇总统计
让我们用从 1 到 6 的数字定义一个列表，并尝试获取该列表的汇总统计信息。
我们将从进口熊猫开始。
import pandas as pd
现在我们可以将一个系列定义为:
s = pd.Series([1, 2, 3, 4, 5, 6])
要显示汇总统计信息，请使用:
s.describe()
完整的代码和输出如下:
import pandas as pd
s = pd.Series([1, 2, 3, 4, 5, 6])
s.describe()
输出:
count 6.000000
mean 3.500000
std 1.870829
min 1.000000
25% 2.250000
50% 3.500000
75% 4.750000
max 6.000000
dtype: float64
让我们了解每个值的含义。
| 数数 | 条目总数 |
| 意思是 | 所有条目的平均值 |
| 标准 | 标准偏差 |
| 部 | 最小值 |
| 25% | 25%标志 |
| 50% | 50%标志(中间值) |
| 75% | 75%标志 |
| 最大 | 最大值 |
2.Python 对象数据的汇总统计数据
让我们将一个系列定义为一组字符，并使用。描述在其上计算汇总统计的方法。
我们可以将该系列定义为:
s = pd.Series(['a', 'a', 'b', 'c'])
要获取汇总统计信息，请使用:
s.describe()
完整的代码和输出如下:
import pandas
s = pd.Series(['a', 'a', 'b', 'c'])
s.describe()
输出:
count 4
unique 3
top a
freq 2
dtype: object
让我们了解以下各项的含义:
| 数数 | 条目总数 |
| 独一无二的 | 唯一条目的总数 |
| 顶端 | 最频繁进入 |
| 频率 | 最频繁条目的频率 |
3.大型数据集的汇总统计信息
您也可以使用 pandas 从大型数据集中获取汇总统计数据。您只需要将数据集导入到 pandas 数据框中，然后使用。描述方法。
在本教程中，我们将使用加州住房数据集作为样本数据集。
让我们从导入 CSV 数据集开始，然后调用。描述它的方法。
import pandas as pd
housing = pd.read_csv("/content/sample_data/california_housing.csv")
housing.describe()
输出:
我们可以看到结果包含了数据集中所有列的汇总统计信息。
4.时间戳系列的汇总统计信息
你可以用。描述如何获取时间戳系列的汇总统计信息。让我们从定义一个时间戳序列开始。
import datetime
import numpy as np
s = pd.Series([np.datetime64("2000-01-01"),np.datetime64("2010-01-01"),np.datetime64("2010-01-01"),np.datetime64("2002-05-08")])
现在你可以打电话了。描述这个时间戳系列。
s.describe()
完整的代码和输出如下:
import datetime
import numpy as np
s = pd.Series([np.datetime64("2000-01-01"),np.datetime64("2010-01-01"),np.datetime64("2010-01-01"),np.datetime64("2002-05-08")])
s.describe()
输出:
count 4
unique 3
top 2010-01-01 00:00:00
freq 2
first 2000-01-01 00:00:00
last 2010-01-01 00:00:00
dtype: object
也可以指导。描述如何将日期时间视为数值。这将以类似于数字数据的方式显示结果。您可以用日期时间格式获得平均值、中间值、25%和 75%的值。
这可以通过以下方式实现:
s.describe(datetime_is_numeric=True)
输出如下所示:
count 4
mean 2005-08-03 00:00:00
min 2000-01-01 00:00:00
25% 2001-10-05 12:00:00
50% 2006-03-05 12:00:00
75% 2010-01-01 00:00:00
max 2010-01-01 00:00:00
可以看到，结果包含了平均值、中值、25%和 75%的日期时间格式。
结论
本教程是关于用 Python 计算汇总统计数据的。我们查看数字数据、对象数据、大型数据集和时间戳系列来计算汇总统计数据。
Python 中的计算精度——分类误差度量
原文：https://www.askpython.com/python/examples/calculating-precision
读者朋友们，你们好！在本文中，我们将详细关注 Python 中的计算精度。
所以，让我们开始吧！！🙂
精确度——分类误差指标
在深入研究分类错误度量的概念具体来说，精度之前，让我们先了解一下机器学习中的错误度量是什么。
误差指标是一组指标，使我们能够评估模型在准确性方面的效率，并让我们估计最适合我们的问题陈述的模型。
根据机器学习算法的类型，有各种类型的误差度量。
对于回归算法，我们有以下可用于评估的指标-
对于分类算法，我们可以利用以下指标-
- 混乱矩阵
- 精度
- 精度
- 回忆等。
精度帮助我们估计被预测为正的和实际上为正的正数据值的百分比。
精度公式:
精度=真阳性/(真阳性+假阳性)
注—所谓真正值，是指预测为正值且实际为正值的值。而假正值是预测为正值但实际上为负值的值。
精度分值的范围分别为 0.0 到 1.0。
现在，让我们关注 Python 中数据集的精度误差度量的实现。
Python 中计算数据集精度的步骤
首先，我们将利用银行贷款数据集进行演示。
你可以在这里找到数据集 ！
- 最初，我们使用 read_csv()函数将数据集加载到 Python 环境中。
- 使用缺失值分析、异常值检测技术进行数据分析和清理。
- 使用 train_test_split()函数将数据集拆分为训练数据和测试数据。
- 在应用模型之前，我们需要定义用于评估模型的误差度量。我们利用混淆矩阵来获得真阳性和假阳性分数。此外，我们已经应用了上面讨论的公式来获得精度分数。
- 最后，我们在数据集上应用决策树算法，并用精度分数测试其效率。
你可以在下面找到完整的代码
import pandas as pd
import numpy as np
loan = pd.read_csv("bank-loan.csv") # dataset
from sklearn.model_selection import train_test_split
X = loan.drop(['default'],axis=1)
Y = loan['default'].astype(str)
# Error metrics -- Confusion matrix\FPR\FNR\f1 score\
def err_metric(CM):
TN = CM.iloc[0,0]
FN = CM.iloc[1,0]
TP = CM.iloc[1,1]
FP = CM.iloc[0,1]
precision =(TP)/(TP+FP)
accuracy_model =(TP+TN)/(TP+TN+FP+FN)
recall_score =(TP)/(TP+FN)
specificity_value =(TN)/(TN + FP)
False_positive_rate =(FP)/(FP+TN)
False_negative_rate =(FN)/(FN+TP)
f1_score =2*(( precision * recall_score)/( precision + recall_score))
print("Precision value of the model: ",precision)
print("Accuracy of the model: ",accuracy_model)
#Decision Trees
decision = DecisionTreeClassifier(max_depth= 6,class_weight='balanced' ,random_state =0).fit(X_train,Y_train)
target = decision.predict(X_test)
targetclass_prob = decision.predict_proba(X_test)[:, 1]
confusion_matrix = pd.crosstab(Y_test,target)
err_metric(confusion_matrix)
输出—
因此，精度分数为 0.25，这意味着总预测正值的 25%实际上是正的。
Precision value of the model: 0.25
Accuracy of the model: 0.6028368794326241
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
更多与 Python 编程相关的帖子，请继续关注我们。
在那之前，学习愉快！！🙂
在 Python 中计算 Softmax
原文：https://www.askpython.com/python/examples/calculating-softmax
你好，学习者！！在本教程中，我们将学习 Softmax 函数，以及如何使用 NumPy 在 Python 中计算 softmax 函数。我们还将了解具有 Softmax 内置方法的框架。所以让我们开始吧。
什么是 Softmax 函数？
Softmax 是一个数学函数，它将数字向量作为输入，并将其归一化为概率分布，其中每个值的概率与向量中每个值的相对比例成比例。
在对矢量应用 softmax 函数之前，矢量的元素可以在(-∞, ∞)的范围内。
一些元素可以是负的，而一些可以是正的。
应用 softmax 函数后，每个值都将在[0, 1]的范围内，并且这些值的总和将为 1，以便可以将它们解释为概率。
softmax 的计算公式为
其中我们首先找到向量中每个元素的指数，并将它们除以所计算的指数之和。
Softmax 函数最常用作多类分类问题的激活函数，在这种情况下，您有一系列值，并且需要找到它们出现的概率。softmax 函数用于预测多项式概率分布的神经网络模型的输出层。
用 Python 实现 Softmax 函数
现在我们知道了在一个数字向量上计算 softmax 的公式，让我们来实现它。我们将使用 NumPy exp()方法计算向量的指数，使用 NumPy sum()方法计算分母和。
import numpy as np
def softmax(vec):
exponential = np.exp(vec)
probabilities = exponential / np.sum(exponential)
return probabilities
vector = np.array([1.0, 3.0, 2.0])
probabilities = softmax(vector)
print("Probability Distribution is:")
print(probabilities)
Probability Distribution is:
[0.09003057 0.66524096 0.24472847]
使用框架计算 softmax
许多框架提供了在各种数学模型中使用的向量上计算 softmax 的方法。
1. Tensorflow
您可以使用tensorflow.nn.softmax计算矢量上的 softmax，如图所示。
import tensorflow as tf
import numpy as np
vector = np.array([5.5, -13.2, 0.5])
probabilities = tf.nn.softmax(vector).numpy()
print("Probability Distribution is:")
print(probabilities)
Probability Distribution is:
[9.93307142e-01 7.51236614e-09 6.69285087e-03]
2.我的天啊
Scipy 库可用于使用如下所示的scipy.special.softmax计算 softmax。
import scipy
import numpy as np
vector = np.array([1.5, -3.5, 2.0])
probabilities = scipy.special.softmax(vector)
print("Probability Distribution is:")
print(probabilities)
Probability Distribution is:
[0.3765827 0.00253739 0.62087991]
3. PyTorch
您可以使用 Pytorch torch.nn.Softmax(dim)来计算 softmax，指定您想要计算的尺寸，如图所示。
import torch
vector = torch.tensor([1.5, -3.5, 2.0])
probabilities = torch.nn.Softmax(dim=-1)(vector)
print("Probability Distribution is:")
print(probabilities)
Probability Distribution is:
tensor([0.3766, 0.0025, 0.6209])
结论
恭喜你！！现在，您已经了解了 softmax 函数以及如何使用各种方式来实现它，您可以使用它来解决机器学习中的多类分类问题。
感谢阅读！！
使用 Streamlit 的计算器应用程序–简单的分步方法
原文：https://www.askpython.com/python-modules/calculator-app-using-streamlit
你好，欢迎来到本教程！这是 Streamlit 教程系列的第三篇教程。到目前为止，在前两个教程中，我们已经对 Streamlit 进行了介绍，并学习了如何安装 Streamlit 、创建“Hello World”应用程序、 Streamlit 中可用的文本元素和小部件，以及如何通过使用 Streamlit 中的 主题来设计我们的应用程序。
如果您还没有完成以下教程，我们强烈建议您完成:
使用细流创建计算器应用程序
现在我们知道了所有这些，我们必须在前进之前实践我们所学的。因此，在本教程中，我们将应用我们现在所学的概念知识来开发一个简单的计算器应用程序。让我们开始吧！
步骤 1:创建基本应用程序
在您喜欢的 IDE 中创建一个文件 Python 文件。你可以给它起任何名字。这里，文件名是calculator.py。
import streamlit as st
st.title("Calculator App using Streamlit")
# creates a horizontal line
st.write("---")
在这里，我们首先导入了 Streamlit，并为我们的应用程序添加了一个标题。此外，在标题下面，我们添加了一条水平线，以便将标题与下面的部分分开。
记住，我们可以使用以下命令运行应用程序:
streamlit run calculator.py
基本应用程序如下所示:
Streamlit Calculator Step 1
步骤 2:接受用户输入
由于我们正在构建一个计算器，我们希望我们的用户能够输入数字来执行操作。我们开始吧。
# input 1
num1 = st.number_input(label="Enter first number")
# input 2
num2 = st.number_input(label="Enter second number")
Streamlit Calculator Step 2
因为我们想要对数字执行操作，所以我们使用了numeric_input()输入小部件。你可以在这里了解更多。因此，我们创建了两个输入字段num1和num2，我们将使用它们。
步骤 3:添加数学运算
现在我们有了输入，让我们添加用户可以对其执行的操作。由于我们希望在输入上一次只执行一个操作，我们将单选按钮来提供选项，因为单选按钮一次只允许一个选择。
st.write("Operation")
operation = st.radio("Select an operation to perform:",
("Add", "Subtract", "Multiply", "Divide"))
单选按钮有一个标签和一个选项列表，列出了我们可能允许用户执行的所有操作。此列表并不详尽，可以根据您的要求进行定制。
Streamlit Calculator Step 3
步骤 4:向计算器添加功能
我们有投入，也有运营。现在我们需要定义这两者如何一起工作。我们将创建一个名为calculate的函数，它根据用户选择的输入和操作来执行操作。
ans = 0
def calculate():
if operation == "Add":
ans = num1 + num2
elif operation == "Subtract":
ans = num1 - num2
elif operation == "Multiply":
ans = num1 * num2
elif operation=="Divide" and num2!=0:
ans = num1 / num2
else:
st.warning("Division by 0 error. Please enter a non-zero number.")
ans = "Not defined"
st.success(f"Answer = {ans}")
我们首先创建了一个变量ans来存储结果。calculate功能只是检查用户从选项列表中选择了哪个操作，并相应地执行操作。
有一点要注意，被零除是没有定义的。所以当选择除法操作时，我们需要先检查第二个输入是否为 0。如果是，给出一个警告信息，这表示该操作是不可能的，否则只执行除法。
成功完成操作后，我们使用 Streamlit 中的 success status 元素显示结果。
步骤 5:添加计算按钮
要查看上面步骤中编写的逻辑，我们需要一个 calculate 按钮。所以让我们补充一下。
if st.button("Calculate result"):
calculate()
当点击按钮时，答案将被计算并显示在屏幕上。
Streamlit Calculator Step 5
在细流中构建计算器的完整代码
import streamlit as st
st.title("Calculator App using Streamlit")
# creates a horizontal line
st.write("---")
# input 1
num1 = st.number_input(label="Enter first number")
# input 2
num2 = st.number_input(label="Enter second number")
st.write("Operation")
operation = st.radio("Select an operation to perform:",
("Add", "Subtract", "Multiply", "Divide"))
ans = 0
def calculate():
if operation == "Add":
ans = num1 + num2
elif operation == "Subtract":
ans = num1 - num2
elif operation == "Multiply":
ans = num1 * num2
elif operation=="Divide" and num2!=0:
ans = num1 / num2
else:
st.warning("Division by 0 error. Please enter a non-zero number.")
ans = "Not defined"
st.success(f"Answer = {ans}")
if st.button("Calculate result"):
calculate()
玩我们的计算器应用程序
现在让我们输入一些信息，看看结果。
添加数字
Streamlit Calculator Add
减去数字
Streamlit Calculator Subtract
乘法数字
Streamlit Calculator Multiply
除法数字
Streamlit Calculator Divide
除以零
Streamlit Calculator Divide By Zero
结论
耶！因此，我们已经成功地使用 Streamlit 完成了我们的第一个计算器。这是一个基本的计算器。你可以试着按照你的意愿来定制它。请点击这里查看本系列的更多教程和 Python 相关概念。
Python 中的计算器程序
原文：https://www.askpython.com/python/examples/calculator-program-python
Python 编程是评估和进行操作的一个很好的工具。在本文中，我们将学习 Python 3 中一个简单的命令行计算器程序。
我们将使用数学运算符、条件语句、函数和处理用户输入来制作我们的计算器。
先决条件
系统应该在本地计算机上安装 Python 3，并在机器上设置一个编程环境。
接受/提示用户输入
我们将接受用户的输入。为此，我们将使用 Python 的 input()函数。对于这个程序，我们将让用户输入两个数字，所以让程序提示这两个数字。
num_1 = input('Enter your first number: ')
num_2 = input('Enter your second number: ')
输出:
Enter your first number: 10
Enter your second number: 5
我们应该在运行程序之前保存它。您应该能够在终端窗口中键入内容来响应每个提示。
定义和使用运算符
现在，让我们在计算器程序中加入加、乘、除、减等运算符。
num_1 = int(input('Enter your first number: '))
num_2 = int(input('Enter your second number: '))
# Addition
print('{} + {} = '.format(num_1, num_2))
print(num_1 + num_2)
# Subtraction
print('{} - {} = '.format(num_1, num_2))
print(num_1 - num_2)
# Multiplication
print('{} * {} = '.format(num_1, num_2))
print(num_1 * num_2)
# Division
print('{} / {} = '.format(num_1, num_2))
print(num_1 / num_2)
# The format() will help out output look descent and formatted.
输出:
Enter your first number: 15
Enter your second number: 10
15 + 10 =
25
15 - 10 =
05
15 * 10 =
150
15 / 10 =
1.5
如果你看一下上面的输出，我们可以注意到，只要用户输入num_1作为15和num_2作为10，计算器的所有操作都会被执行。
如果我们想限制程序一次只执行一个操作，我们就必须使用条件语句，使整个计算器程序成为基于用户选择的操作程序。
包括使程序成为用户选择的条件语句
因此，我们将开始在程序的顶部添加一些信息，以及要做出的选择，以使用户理解他/她应该选择什么。
choice = input('''
Please select the type of operation you want to perform:
+ for addition
- for subtraction
* for multiplication
/ for division
''')
num_1 = int(input('Enter your first number: '))
num_2 = int(input('Enter your second number: '))
if choice == '+':
print('{} + {} = '.format(num_1, num_2))
print(num_1 + num_2)
elif choice == '-':
print('{} - {} = '.format(num_1, num_2))
print(num_1 - num_2)
elif choice == '*':
print('{} * {} = '.format(num_1, num_2))
print(num_1 * num_2)
elif choice == '/':
print('{} / {} = '.format(num_1, num_2))
print(num_1 / num_2)
else:
print('Enter a valid operator, please run the program again.')
输出:
Please select the type of operation you want to perform:
+ for addition
- for subtraction
* for multiplication
/ for division
*
Please enter the first number: 10
Please enter the second number: 40
10 * 40 =
400
参考
- Python 计算器简单程序
- Python if else elif 语句
Python 日历模块–需要了解的 6 个 IMP 函数！
原文：https://www.askpython.com/python-modules/calendar-module-2
读者朋友们，你们好！在本文中，我们将详细关注 Python 日历模块。所以，让我们开始吧！！
一、什么是日历模块？
Python 为我们提供了各种模块来处理数据，进行操作和修改，并以格式化的方式呈现出来。
使用 Python 中的日历模块，我们可以很容易地以类似日历的格式表示与日期相关的数据。此外，它为我们提供了许多功能来处理与日期戳相关的数据，进行操作并从中获得所需的数据。
日历模块帮助我们按照日期、年、月、日和其他属性(如月份中的星期、闰年等)来操作和表示数据。
Python 中日历模块的功能
我们将介绍 Python 日历模块提供的以下功能:
- calendar.month()函数
- calendar.calendar()函数
- monthdatescalendar()函数
- formatmonth()函数
- isleap()函数
- leapdays()函数
现在，让我们在接下来的部分中逐一了解一下！
1。函数的作用是
使用日历模块，我们可以很容易地以可读的日历格式表示整个月份的日历。 calendar.month()函数使我们能够表示所需月份的日历。同样，我们需要将月份和年份值传递给 month()函数。
看看下面的语法！
calendar.month(year, month)
举例:
在本例中，我们已经过了 2020 年和 8 月，即 8 月。因此，month()函数返回 2020 年 8 月的日历。
import calendar
year = 2020
month = 8
print(calendar.month(year, month))
输出:
August 2020
Mo Tu We Th Fr Sa Su
1 2
3 4 5 6 7 8 9
10 11 12 13 14 15 16
17 18 19 20 21 22 23
24 25 26 27 28 29 30
31
2。calendar.calendar()函数
除了表示月份的日历之外，使用 Python 中的日历模块，我们甚至可以以定制的方式表示全年的日历。
语法:
calendar.calendar(year)
举例:
在本例中，我们使用 calendar.calendar()函数表示了 2020 年的整个日历。
import calendar
year = 2020
print(calendar.calendar(year))
输出:
Python Calendar Module
3。以 HTML 格式表示月份
日历模块也可以用 HTML 格式表示特定月份或年份的数据。因此，一年中想要的月份用 HTML 格式和与之相关的标签来表示。
语法:
calendar.HTMLCalendar(firstweekday = 0)
举例:
带日历。HTMLCalendar()函数，我们可以生成 HTML 日历的实例。此外，formatmonth()函数使我们能够生成一年中所需月份的 HTML 日历。设置 withyear = TRUE，允许我们在 HTML 格式的标题中包含年份值。
import calendar
cal = calendar.HTMLCalendar(firstweekday = 0)
print(cal.formatmonth(2020, 9, withyear = True))
输出:
<table border="0" cellpadding="0" cellspacing="0" class="month">
<tr><th colspan="7" class="month">September 2020</th></tr>
<tr><th class="mon">Mon</th><th class="tue">Tue</th><th class="wed">Wed</th><th class="thu">Thu</th><th class="fri">Fri</th><th class="sat">Sat</th><th class="sun">Sun</th></tr>
<tr><td class="noday"> </td><td class="tue">1</td><td class="wed">2</td><td class="thu">3</td><td class="fri">4</td><td class="sat">5</td><td class="sun">6</td></tr>
<tr><td class="mon">7</td><td class="tue">8</td><td class="wed">9</td><td class="thu">10</td><td class="fri">11</td><td class="sat">12</td><td class="sun">13</td></tr>
<tr><td class="mon">14</td><td class="tue">15</td><td class="wed">16</td><td class="thu">17</td><td class="fri">18</td><td class="sat">19</td><td class="sun">20</td></tr>
<tr><td class="mon">21</td><td class="tue">22</td><td class="wed">23</td><td class="thu">24</td><td class="fri">25</td><td class="sat">26</td><td class="sun">27</td></tr>
<tr><td class="mon">28</td><td class="tue">29</td><td class="wed">30</td><td class="noday"> </td><td class="noday"> </td><td class="noday"> </td><td class="noday"> </td></tr>
</table>
4。calendar.isleap()函数
使用 calendar.isleap()函数，我们可以检查某一年是否是闰年。
语法:
calendar.isleap(year)
举例:
在下面的例子中，我们检查了 2020 年和 2002 年是否是闰年。由于 isleap()是一个布尔函数，如果年份是闰年，则返回 TRUE，否则返回 FALSE。
import calendar
print(calendar.isleap(2020))
print(calendar.isleap(2002))
输出:
True
False
5。calendar.leapdays()函数
使用 leapdays()函数，我们可以很容易地计算并表示传递给该函数的年份之间的闰日数。
语法:
calendar.leapdays(year1, year2)
举例:
在这里，我们试图计算 2016 年和 2020 年以及 2002 年和 2003 年之间的闰日数。它计算这些年之间的闰日数，并返回整数值。
import calendar
print(calendar.leapdays(2016, 2020))
print(calendar.leapdays(2002, 2003))
输出:
1
0
结论
如果你遇到任何问题，欢迎在下面评论。更多与 Python 编程相关的帖子，请继续关注我们。在那之前，学习愉快！！🙂
Python 中的回调函数——完整概述
原文：https://www.askpython.com/python/built-in-methods/callback-functions-in-python
回调是 Python 以及 Javascript、C 等其他语言中的一个通用概念。我们知道 Python 是面向对象的语言，函数是 Python 中的一级对象。这意味着，在 Python 中，我们可以将一个函数返回的值赋给一个变量，并从另一个函数返回一个函数。
在本教程中，我们将学习 Python 编程语言中回调的概念，也将看到一些与之相关的例子。所以让我们开始吧。
Python 中的回调函数
当一个函数被另一个函数调用时，这就是所谓的回调。回调函数是作为参数传递给另一个函数的函数。有两种方法可以做到:
- 将一个函数作为参数传递给另一个函数
- 在另一个函数中调用一个函数
以上两点可以帮助你判断一个给定的函数是不是回调函数。作为回调函数，上述两个条件不一定都为真。即使满足上述两个条件中的一个，该函数也称为回调函数。
回调可以使用内置函数和用户自定义函数来实现。在本教程中，我们将看到这两种实现的例子。
使用内置函数回调
我们都熟悉 Python 中的sorted函数。让我们先快速回顾一下。
语法:
sorted(iterable, key)
| 参数 | 意为 |
| iterable(强制) | 要排序的数据结构(列表、字典等)。) |
| key(关键字，可选) | 分类标准。它可以被分配任何你想使用的功能。 |
sorted function parameters
当调用sorted函数时，iterable 将首先被传递给key函数，它将在 iterable 上实现。那么新的/改变的 iterable 将被排序。
这里，我们是调用 sorted 函数内部的 key 函数。所以，这里满足第二个条件。因此，这里的key函数是一个回调函数。
让我们看一个例子。假设我们要对字符串列表进行排序。
#list
a = ["lmn", "AbCd", "khJH", "ert", "SuNnY"]
#sorted based on the ASCII values
print(sorted(a))
#first convert all letters to lowercase & then sort based on ASCII values
print(sorted(a, key=str.lower))
输出:
['AbCd', 'SuNnY', 'ert', 'khJH', 'lmn']
['AbCd', 'ert', 'khJH', 'lmn', 'SuNnY']
如果您还记得的话，A 的 ASCII 值是 65，B 是 66，e 是 101 等等。ASCII 值表请参考此链接。
所以，在第一种情况下，列表只根据 ASCII 值进行排序。
如果我们观察列表，我们可以看到列表中的字符串是大写字母和小写字母的混合。比方说，我们现在想只根据每个字母的小写形式对列表进行排序。为此，我们在函数key=str.lower中引入了一个新参数。
这里，str.lower首先在 iterable 列表上实现。也就是说，列表中的字符串被转换成小写。所以现在，这个列表实际上是'lmn', 'abcd', 'khjh', 'ert', 'sunny'，然后这个列表被传递给sorted函数。
注意，全小写列表与原始列表不同，但在原始列表中，这里的' lmn '表示' lmn '，' abcd '表示' AbCd '，' khjh '表示' khJH '，' ert '表示' ert '，而' sunny '表示' SuNnY '。新列表的排序版本是'abcd', 'ert', 'khjh', 'lmn, 'sunny'，因此输出如上所示。
这就是 Python 内置函数中回调的工作方式。
用户定义函数中的回调
现在让我们学习一下用户定义函数中的回调。让“调用”一个函数的函数名为caller，被调用的函数名为called。这里，caller功能可以说是主功能，而called功能是从功能，因为主功能总是可以调用从功能，但反之则不行。
假设给我们一个由两个整数组成的元组，我们需要计算这两个整数的乘积。
def called(n):
return n[0]*n[1]
def caller(func, n):
return func(n)
#tuple
num = (8, 5)
ans = caller(called, num)
print("Multiplication =", ans)
输出:
Multiplication = 40
在上面的代码中，我们定义了两个函数:caller和called。called函数是作为参数传递给caller函数的。因此，第一个条件在这里得到满足，所以这也是一个回调函数，called就是这里的回调函数。
当程序执行时，首先创建元组，然后调用caller函数。现在，控制转到caller函数的定义。它有两个参数:一个函数(func)和一个 iterable ( n)，在本例中是一个元组。在caller函数中，希望将作为参数传递的函数应用于 iterable，并返回结果(func(n))。
所以现在，控制权在called函数定义处。它将一个元组作为参数，并返回其成员的乘积。这个值然后被返回给caller函数，然后caller函数返回答案，即 8×5 = 40。
摘要
因此，我们已经了解了 Python 中的回调，以及如何使用内置函数和用户自定义函数来实现回调。
使用 Python 捕捉屏幕截图的两种方法
原文：https://www.askpython.com/python/examples/capture-screenshots
在本教程中，我们将学习如何使用 Python 编程语言截屏。有多种方法可以实现这一点，我们将在接下来的章节中讨论其中的一些方法。
如何使用 Python 捕捉屏幕截图
Python 提供了各种库来捕捉截图。我们今天将探索其中的一些库，并了解如何用 Python 实现代码来捕捉屏幕。
方法 1:使用 pyautogui 模块
pyautogui模块使用screenshot函数，该函数负责截取整个计算机屏幕的截图。然后使用save功能将截图保存到我们的设备上。
import pyautogui
im = pyautogui.screenshot()
im.save("SS1.jpg")
保存的图像如下所示。
Screenshot Python 1
如果想在截屏前有所延迟，程序员可以使用time模块和sleep函数。
方法 2:使用枕头模块
枕形模块利用了ImageGrab子模块。这种方法需要一个需要被捕获的区域，这意味着设置该区域的对角线坐标。
然后我们使用grab函数，该函数将获取区域参数来捕捉屏幕截图。最后，使用save功能保存捕获的图像。
from PIL import ImageGrab
ss_region = (300, 300, 600, 600)
ss_img = ImageGrab.grab(ss_region)
ss_img.save("SS3.jpg")
捕获的区域如下所示。我们也可以利用time模块来延迟截图的捕捉。
Screenshot Python 2
结论
所以现在你知道了两种捕捉电脑屏幕截图的方法。是的，还有其他方法，python 是一种非常高级的语言。希望你喜欢阅读它！
感谢您的阅读！
Python catboost 模块:catboost 分类器简介
你好，初学者！在本教程中，我们将学习 catboost 模块和一个更复杂的概念CatboostClassifier。所以让我们开始吧！
什么是 catboost 模块？
CatBoost 模块是一个快速、可扩展的开源库，是决策树和其他机器学习任务上的一个非常高性能的梯度提升系统。它还提供 GPU 支持来加速训练
Catboost 可以用于一系列的回归和分类问题，kaggle 上也有。
实现 Catboost 分类器
1.导入模块
对于 catboost 模块的简单实现，我们将导入三个模块。用于数据可视化的catboost模块和 matplotlib 与numpy模块一起生成数据集。
如果任何模块导入出错，确保使用pip命令安装模块。导入正确模块和正确函数的代码如下所示。
from catboost import CatBoostClassifier
import matplotlib.pyplot as plt
import numpy as np
2.培训和测试数据准备
下一步是创建用于训练 catboost 模块的测试数据，然后创建测试数据来检查随机点。
培训用数据
为了创建样本训练数据，我们需要两个矩阵，一个用于均值，另一个用于协方差，其中均值描述点的中心，协方差描述点的扩散。
随后，我们创建了一个多元正态分布，它通过了平均值和协方差矩阵以及点数。
为两个不同的类创建数据的代码如下所示。
mean1=[8,8]
covar1=[[2,0.7],[0.7,1]]
d2=np.random.multivariate_normal(mean1,covar1,200)
mean2=[1,1]
covar2=[[2,0.7],[0.7,1]]
d2=np.random.multivariate_normal(mean2,covar2,200)
测试数据
为了获得训练点，我们将导入随机模块并生成 10 个随机 x 和 y 坐标，稍后传递给训练好的模型。下一步是使用循环的将 x 和 y 坐标放在一个列表中。
相同的代码如下所示。
import random
x_cord_test = [random.randint(-2,10) for i in range(5)]
y_cord_test = [random.randint(-2,10) for i in range(5)]
test_data = []
for i in range(len(x_cord_test)):
test_data.append([x_cord_test[i],y_cord_test[i]])
数据可视化–1
我们将使用 matplotlib 库可视化数据，并绘制训练数据以及测试点。
相同的代码如下所示。
plt.style.use('seaborn')
plt.scatter(d1[:,0],d1[:,1],color="Red",s=20)
plt.scatter(d2[:,0],d2[:,1],color="Blue",s=20)
for i in test_data:
plt.scatter(i[0],i[1],marker="*",s=200,color="black")
plt.show()
结果图如下所示。
Binary Data Plot Catboost
模型准备的最终训练数据
最后一步是通过将两个类的数据合并到一个数据框中来创建最终的训练数据。
结果数据中的行数将等于两个类中数据点数量的总和。列的数量将等于 3，其中列存储点的 x 和 y 坐标以及标签。
我们创建了一个所有值都为 0 的虚拟数据帧。然后，我们将两个类的数据和标签放入数据帧中的正确位置。最后一步涉及数据的混洗。
df_rows=d1.shape[0]+d2.shape[0]
df_columns=d1.shape[1]+1
df=np.zeros((df_rows,df_columns))
df[0:d1.shape[0],0:2]=d1
df[d1.shape[0]:,0:2]=d2
df[0:d1.shape[0],2]=0
df[d1.shape[0]:,2]=1
np.random.shuffle(df)
数据可视化–2
现在让我们使用下面的代码来可视化我们的最终数据。
plt.scatter(df[:,0],df[:,1],color="Green")
for i in test_data:
plt.scatter(i[0],i[1],marker="*",s=200,color="black")
plt.show()
最终的图表如下所示。现在数据准备好进入CatBoostClassifier。
Train Test Data Plot Catboost
3.使用 catboost 模块–catboost 分类器
为了实现 CatBoostClassifier，我们为其创建了模型对象，该对象将迭代次数作为参数。我们还将为模型使用GPU，因此我们将tak_type作为参数传递。
下一步是使用fit函数拟合训练数据点和标签来训练模型。我们还会将每个测试点传入predict函数并得到结果。
model = CatBoostClassifier(iterations=100,task_type="GPU")
model.fit(df[:,0:2],df[:,2],verbose=False)
结果如下。你可以从图表中反复核对，结果相当准确。
(6,3) ==> 0.0
(10,4) ==> 0.0
(6,-2) ==> 0.0
(1,7) ==> 1.0
(3,0) ==> 1.0
结论
恭喜你！今天，您已经成功地了解了一种称为 CatBoost 的快速而神奇的分类器。您可以在自己的各种数据集上尝试同样的方法！编码快乐！
感谢您的阅读！
Python Tkinter:摄氏到华氏转换器
原文：https://www.askpython.com/python-modules/tkinter/celsius-to-fahrenheit-converter
程序员朋友你好！今天我们将构建自己的应用程序，使用 Python tkinter 将摄氏温度转换为华氏温度。
使用 Tkinter 构建摄氏到华氏的转换器
这个主题是不言自明的，因此我们直接进入实现部分。
步骤 1:创建窗口
在我们开始项目的主要部分之前，我们必须创建一个空白的自定义窗口。相同的代码如下所示:
import tkinter as tk
window = tk.Tk()
window.geometry("300x250")
window.config(bg="#A569BD")
window.resizable(width=False,height=False)
window.title('Celsius to Fahrenheit Converter!')
我们确保在此步骤中完成以下工作:
- 导入
tkinter模块 - 创建窗口对象并设置窗口的尺寸和背景颜色
- 将 resizable 属性设置为 false，以确保提到的维度保持固定。
- 设置应用程序的标题
上面提到的代码的结果如下:
Blank Screen Tkinter
步骤 2:向屏幕添加基本元素
应用程序使用的基本元素如下所列:
- 两个标签:关于应用程序的信息
- 输入框:输入温度值
- 按钮 1:将温度转换为华氏温度
- 文本框:显示转换温度的结果
- 按钮 2:退出应用程序
添加所有元素的代码如下所示:
l1 = tk.Label(window,text="Celsius to Fahrenheit Converter",font=("Arial", 15),fg="white",bg="black")
l2= tk.Label(window,text="Enter temperature in Celsius: ",font=("Arial", 10,"bold"),fg="white",bg="#A569BD")
l3= tk.Label(window,text="Temperature in Fahrenheit is: ",font=("Arial", 10,"bold"),fg="white",bg="#A569BD")
empty_l1 = tk.Label(window,bg="#A569BD")
empty_l2 = tk.Label(window,bg="#A569BD")
e1= tk.Entry(window,font=('Arial',10))
btn1 = tk.Button(window,text="Convert to Fahrenheit!",font=("Arial", 10))
btn2 = tk.Button(window,text="Exit application",font=("Arial", 10))
t1=tk.Text(window,state="disabled",width=15,height=0)
除了所有提到的元素，我们确保我们有一些空标签来在两个元素之间添加新的行。
为了在屏幕上添加元素，我们使用了pack函数，并将所有元素按特定顺序打包。包装代码如下所示:
l1.pack()
l2.pack()
e1.pack()
empty_l1.pack()
btn1.pack()
l3.pack()
t1.pack()
empty_l2.pack()
btn2.pack()
输出如下所示:
Initial Image
步骤 3:向按钮添加功能
按钮 1:退出应用程序按钮
让我们先创建一个更简单的按钮来退出应用程序。我们需要做的就是创建一个破坏窗口的函数。相同的代码如下所示:
def exit():
window.destroy()
为了执行按钮 click 上的功能，我们向退出应用程序按钮添加了command属性。并添加命令作为退出函数。
按钮 2:转换温度按钮
第二个按钮将温度转换为‘华氏’，同样包括以下步骤:
- 从输入框中获取摄氏温度
- 使用公式将获得的温度转换为华氏温度
- 清除文本框
- 将计算出的温度值插入文本框
相同的代码如下所示:
def convert():
c = int(e1.get())
f = ((c*9)/(5))+32
t1.config(state='normal')
t1.delete('1.0', tk.END)
t1.insert(tk.END,f)
t1.config(state='disabled')
要使该功能可在按钮上执行，单击将命令属性添加到 convert 按钮。
摄氏温度至法亨海特温度转换器的完整代码
def exit():
window.destroy()
def convert():
c = int(e1.get())
f = ((c*9)/(5))+32
t1.config(state='normal')
t1.delete('1.0', tk.END)
t1.insert(tk.END,f)
t1.config(state='disabled')
import tkinter as tk
window = tk.Tk()
window.geometry("300x250")
window.config(bg="#A569BD")
window.resizable(width=False,height=False)
window.title('Celsius to Fahrenheit Converter!')
l1 = tk.Label(window,text="Celsius to Fahrenheit Converter",font=("Arial", 15),fg="white",bg="black")
l2= tk.Label(window,text="Enter temperature in Celsius: ",font=("Arial", 10,"bold"),fg="white",bg="#A569BD")
l3= tk.Label(window,text="Temperature in Fahrenheit is: ",font=("Arial", 10,"bold"),fg="white",bg="#A569BD")
empty_l1 = tk.Label(window,bg="#A569BD")
empty_l2 = tk.Label(window,bg="#A569BD")
e1= tk.Entry(window,font=('Arial',10))
btn1 = tk.Button(window,text="Convert to Fahrenheit!",font=("Arial", 10),command=convert)
btn2 = tk.Button(window,text="Exit application",font=("Arial", 10),command=exit)
t1=tk.Text(window,state="disabled",width=15,height=0)
l1.pack()
l2.pack()
e1.pack()
empty_l1.pack()
btn1.pack()
l3.pack()
t1.pack()
empty_l2.pack()
btn2.pack()
window.mainloop()
样本输出
上面的应用程序测试了两个测试样本，结果是完美的！两种输入的输出屏幕如下所示:
Output1 C2F
Output2 C2F
结论
恭喜你！您已经成功构建了一个将摄氏温度转换为华氏温度的应用程序。
希望你喜欢这个项目！继续编码！
python Tkinter–更改按钮的状态
原文：https://www.askpython.com/python-modules/tkinter/change-button-state
在本 Python 教程中，我们将学习如何使用 Tkinter 来检查和改变按钮的状态。
首先，我们必须首先在我们的 Python 环境中安装 Tkinter。我们将看到一个图形用户界面窗口，在这里我们可以通过按下 Tkinter 按钮来修改它的状态。
首先，我们必须掌握 Python Tkinter 中的状态是什么。
Tkinter 是一个 Python 包，允许我们设计自己的图形用户界面(GUI)。Tkinter 按钮有两种状态:正常和禁用。在常规状态下，我们可以按下按钮；但是，在禁用状态下，我们不能单击该按钮。
因此，在本教程中，我们将学习 Tkinter 按钮状态。
实现按钮状态
让我们从所提供的挑战的编码部分开始。首先，导入 Tkinter 包。现在，我们将创建一个 app 对象，并将窗口大小设置为 200 x 200。
import tkinter as tk
app = tk.Tk()
app.geometry("200x200")
我们将再添加两个按钮，按钮 1 和按钮 2。我们将提供一个参数作为应用程序，它将显示在应用程序窗口中，我们将通过将文本属性设置为“Python Button 1”来给它命名
通过向按钮 1 的状态提供值 tk，我们将指示它被禁用。已禁用。
类似地，在按钮 2 中，我们将提供关于某个函数名称的指令，以便当我们点击该按钮时，将执行下面的函数。
作为一个功能，我们为它们提供了 switchButtonState。该功能将在后面定义。我们还将使用包来放置这两个按钮。
button1 = tk.Button(app, text="Python Button 1",state=tk.DISABLED)
button2 = tk.Button(app, text="EN/DISABLE Button 1",command = switchButtonState)
button1.pack()
button2.pack()
下面的功能将改变按钮的状态。点击按钮，如果按钮 1 的状态为正常，则变为禁用状态；否则，它将保持正常。
def switchButtonState():
if (button1['state'] == tk.NORMAL):
button1['state'] = tk.DISABLED
else:
button1['state'] = tk.NORMAL
最后，我们必须使用 app.mainloop()来执行应用程序。
app.mainloop()
通过单击按钮 2，您现在可以修改按钮 1 的状态。
使用 Python tkinter 更改按钮的状态
import tkinter as tk
def switchButtonState():
if (button1['state'] == tk.NORMAL):
button1['state'] = tk.DISABLED
else:
button1['state'] = tk.NORMAL
app = tk.Tk()
app.geometry("200x200")
button1 = tk.Button(app, text="Python Button 1",state=tk.DISABLED)
button2 = tk.Button(app, text="EN/DISABLE Button 1",command = switchButtonState)
button1.pack()
button2.pack()
app.mainloop()
输出屏幕
Change Btn States Output 1
Change Btn States Output 2
结论
恭喜你！您刚刚学习了如何更改按钮的状态。希望你喜欢它！😇
喜欢这个教程吗？无论如何，我建议你看一下下面提到的教程:
- Python Tkinter 教程:了解 Tkinter 字体类
- Python Tkinter 项目:随机移动号码生成器
- Tkinter StringVar 示例–Tkinter 教程
- Tkinter int var–带示例的 Tkinter 教程
感谢您抽出时间！希望你学到了新的东西！！😄
如何在 Tkinter 中设置字体大小？
原文：https://www.askpython.com/python-modules/tkinter/change-font-size-tkinter
在这篇文章中，我们将学习如何在 Tkinter 中改变文本的字体大小。字体大小是指屏幕上显示的字符有多大。为了在任何需要的地方吸引读者的注意力，使用合适的字体大小是至关重要的。让我们来看看使用 Tkinter 改变文本字体大小的不同方法。
方法 1:使用字体作为元组来更改 Tkinter 字体大小
import tkinter as tk
from tkinter import *
#main window
root = Tk()
#title of the window
root.title("Tkinter Font Size")
#adding a label
l = Label(root, text="This is a sample line with font size 15.", width=40,
height=5, font=('Times New Roman', 15, 'bold'))
l.pack()
root.mainloop()
输出:
Font Size Tuple Output
在上面的代码中，我们创建了一个非常基本的 GUI，并为它添加了一个标签。标签部件有一个内置的字体属性(“字体系列”，大小，“字体样式”)。在上面的代码中，字体作为一个参数。如果没有明确提到，参数将有它们的默认值。在上面的代码中，我们只使用了 size 属性，并将大小设置为 15。
方法 2:使用字体作为对象来更改 tkinter 字体大小
推荐阅读: Tkinter 字体类教程
import tkinter as tk
from tkinter import *
import tkinter.font as tkFont
#main window
root = tk.Tk()
#title of the window
root.title("Tkinter Font Size")
#creating a font object
fontObj = tkFont.Font(size=28)
#adding a label
l = Label(root, text="This is a sample line with font size 28.",
width=40, height=5, font=fontObj)
l.pack()
root.mainloop()
输出:
Font Size Object Output
这里，我们创建了一个名为 fontObj 的字体类对象，并将字体大小设置为 28 。后来，在标签中，我们将字体的参数值指定为等于 font 对象(fontObj ),因此，在输出中，字体大小为 28。除了大小，我们还可以根据需要提到字体家族和风格。
方法 3:使用自定义类更改字体
import tkinter as tk
from tkinter import *
from tkinter.font import Font
#creating a custom class
class cl:
def __init__(self, master) -> None:
self.master = master
#setting the font size to be 40
self.customFont = Font(size=40)
Label(self.master, text="Font size in the custom class is 40.",
font=self.customFont).pack()
#end of custom class
if __name__ == "__main__":
#main window
root = tk.Tk()
#title of the window
root.title("Tkinter Font Size")
#adding a label
l = Label(root, text="This is a sample line with default font size.",
width=40, height=5)
l.pack()
#calling our class object
customSize = cl(root)
root.mainloop()
输出:
Font Size Custom Class Output
在上面的例子中，我们定义了一个自定义类( cl )，在这个类中我们有一个构造函数，我们将字体大小指定为 40。还创建了一个标签，其字体参数等于自定义字体。
在 main 函数中，我们首先创建了一个没有明确提及文本大小的标签。因此，它具有默认大小。之后，我们通过创建对象 customSize 来调用 cl 类。创建新的实例或对象时，字体大小为 40 的标签也会与默认大小标签一起显示在输出中。
每次创建该类的新实例时，将显示字体大小为 40 的标签，因为它是该类构造函数的一部分。我们还可以在类内部设置字体系列和样式。
摘要
这样，我们已经了解了如何通过多种方式在 Tkinter 中更改字体大小。这是一个容易理解和实现的主题。请点击查看我们的其他 Tkinter 教程。
在 Python 中改变熊猫数据帧的列顺序的 4 种方法
原文：https://www.askpython.com/python-modules/pandas/change-the-column-order-dataframe
在本教程中，我们将讨论如何改变一个给定的 pandas DataFrame 对象的列顺序。在数据预处理阶段，我们可能会遇到这样一种情况，即相关的 pandas 数据帧的列没有按照期望的顺序排列，那么我们必须改变数据帧的列顺序。
如何改变熊猫数据框的列顺序？
让我们来看看在 Pandas 中改变数据帧的列顺序的不同方法。
方法 1:使用所需的顺序列列表
这是改变 pandas DataFrame 对象的列顺序的最简单的方法之一。在这个方法中，我们简单地将 DataFrame 的列的 Python 列表以期望的顺序传递给 DataFrame 对象。让我们看看如何用 Python 编写这个方法。
# Method-1
# Import pandas Python module
import pandas as pd
# Create a pandas DataFrame
df = pd.DataFrame({'Roll': [111, 112, 113, 114, 115],
'Name': ['Sanjay', 'Aman', 'Ankit', 'Ravi', 'Komal'],
'Branch': ['ECE', 'ICE', 'IT', 'CSE', 'CHE'],
'CGPA': [8.15, 9.03, 7.85, 8.55, 9.45]})
print('Given pandas DataFrame:\n')
print(df)
# Change the order of the DataFrame
# Using the desired order columns list
df_1 = df[['Name', 'CGPA', 'Roll', 'Branch']]
print('\nPandas DataFrame with changed column order:\n')
print(df_1)
输出:
Given pandas DataFrame:
Roll Name Branch CGPA
0 111 Sanjay ECE 8.15
1 112 Aman ICE 9.03
2 113 Ankit IT 7.85
3 114 Ravi CSE 8.55
4 115 Komal CHE 9.45
Pandas DataFrame with changed column order:
Name CGPA Roll Branch
0 Sanjay 8.15 111 ECE
1 Aman 9.03 112 ICE
2 Ankit 7.85 113 IT
3 Ravi 8.55 114 CSE
4 Komal 9.45 115 CHE
方法 2:使用 loc 方法
在这个方法中，我们将利用 pandas DataFrame 类的loc方法。使用loc方法，我们可以通过提供列名的 Python 列表来重新排序 pandas DataFrame 对象的列。让我们编写 Python 代码来实现这个方法。
# Method-2
# Import pandas Python module
import pandas as pd
# Create a pandas DataFrame
df = pd.DataFrame({'Name': ['Sanjay', 'Aman', 'Ankit', 'Ravi', 'Komal'],
'Roll': [111, 112, 113, 114, 115],
'Branch': ['ECE', 'ICE', 'IT', 'CSE', 'CHE'],
'CGPA': [8.15, 9.03, 7.85, 8.55, 9.45]})
print('Given pandas DataFrame:\n')
print(df)
# Change the order of the DataFrame
# Using the loc method of pandas DataFrame class
df_2 = df.loc[2:4, ['Roll', 'Name', 'CGPA', 'Branch']]
print('\nPandas DataFrame with changed column order:\n')
print(df_2)
输出:
Given pandas DataFrame:
Name Roll Branch CGPA
0 Sanjay 111 ECE 8.15
1 Aman 112 ICE 9.03
2 Ankit 113 IT 7.85
3 Ravi 114 CSE 8.55
4 Komal 115 CHE 9.45
Pandas DataFrame with changed column order:
Roll Name CGPA Branch
2 113 Ankit 7.85 IT
3 114 Ravi 8.55 CSE
4 115 Komal 9.45 CHE
方法 3:使用 iloc 方法
在这个方法中，我们将使用 pandas DataFrame 类的iloc方法。使用iloc方法，我们可以通过提供列索引的 Python 列表(即 0，1，2，3，…)而不是列名来重新排序 pandas DataFrame 对象的列。让我们看看如何通过 Python 代码实现这个方法。
# Method-3
# Import pandas Python module
import pandas as pd
# Create a pandas DataFrame
df = pd.DataFrame({'CGPA': [8.15, 9.03, 7.85, 8.55, 9.45],
'Name': ['Sanjay', 'Aman', 'Ankit', 'Ravi', 'Komal'],
'Roll': [111, 112, 113, 114, 115],
'Branch': ['ECE', 'ICE', 'IT', 'CSE', 'CHE']})
print('Given pandas DataFrame:\n')
print(df)
# Change the order of the DataFrame
# Using the iloc method of pandas DataFrame class
df_3 = df.iloc[1:4, [1, 2, 0, 3]]
print('\nPandas DataFrame with changed column order:\n')
print(df_3)
输出:
Given pandas DataFrame:
CGPA Name Roll Branch
0 8.15 Sanjay 111 ECE
1 9.03 Aman 112 ICE
2 7.85 Ankit 113 IT
3 8.55 Ravi 114 CSE
4 9.45 Komal 115 CHE
Pandas DataFrame with changed column order:
Name Roll CGPA Branch
1 Aman 112 9.03 ICE
2 Ankit 113 7.85 IT
3 Ravi 114 8.55 CSE
注意:在上面的两个方法loc和iloc中，我们有一个额外的优势，即在给定的 pandas DataFrame 对象中只选择一系列行。
方法 4:使用 reindex()函数
在这个方法中，我们将使用 pandas DataFrame 对象的reindex()函数。使用reindex()函数，我们可以通过传递列名的 Python 列表来重新排列 pandas DataFrame 对象的列顺序。让我们通过 Python 代码来实现这个方法。
# Method-4
# Import pandas Python module
import pandas as pd
# Create a pandas DataFrame
df = pd.DataFrame({'Branch': ['ECE', 'ICE', 'IT', 'CSE', 'CHE'],
'CGPA': [8.15, 9.03, 7.85, 8.55, 9.45],
'Name': ['Sanjay', 'Aman', 'Ankit', 'Ravi', 'Komal'],
'Roll': [111, 112, 113, 114, 115]})
print('Given pandas DataFrame:\n')
print(df)
# Change the order of the DataFrame
# Using the reindex() function of pandas DataFrame class
df_4 = df.reindex(columns = ['Roll', 'CGPA', 'Name', 'Branch'])
print('\nPandas DataFrame with changed column order:\n')
print(df_4)
输出:
Given pandas DataFrame:
Branch CGPA Name Roll
0 ECE 8.15 Sanjay 111
1 ICE 9.03 Aman 112
2 IT 7.85 Ankit 113
3 CSE 8.55 Ravi 114
4 CHE 9.45 Komal 115
Pandas DataFrame with changed column order:
Roll CGPA Name Branch
0 111 8.15 Sanjay ECE
1 112 9.03 Aman ICE
2 113 7.85 Ankit IT
3 114 8.55 Ravi CSE
4 115 9.45 Komal CHE
总结
在本教程中，我们学习了如何用四种不同的方法来改变 pandas DataFrame 对象的列顺序。希望你已经理解了上面讨论的所有方法，并且很乐意自己使用它们。感谢您的阅读，请继续关注我们，了解更多关于 Python 编程的精彩内容。
在 Python 中更改时区
原文：https://www.askpython.com/python-modules/changing-timezone-in-python
有时，产品或基础设施工程师需要在遍布世界各地的基础设施上工作。他们必须与位于美国、亚洲、欧洲和英国等地的机器协作。因此，时区对 Python 来说更加重要。
随着当今编程语言的不断进步，几乎所有的编程语言中都维护着几个模块。Python 有一个名为pytz的时区包，支持跨平台的实时时区计算。
安装 pytz 模块
首先，我们将导入pytz模块的时区库。该pip命令可用于安装该模块。
pip install pytz
导入必要的模块
此外，我们需要从 DateTime 模块导入 DateTime。为了保持一致性，我们可以指定日期和时间输出的格式。
from pytz import timezone
from datetime import datetime
获取当前日期和时间
在本程序中，我们将指定格式为 YY-毫米-日时:分:秒。
执行代码时，我们将调用 DateTime 库的 now()方法来获取指定格式的当前时间。另一方面，输出时区格式将采用其 DateTime 对象格式。
因此，为了使它更具可读性，我们通过调用 strftime()方法将其转换为字符串时间格式。
time_format = '%Y-%m%d %H:%M:%S %Z%z'
default_now = datetime.now()
formatted_now = datetime.now().strftime(time_format)
print("Date Time in defaut format: ", default_now, '\n')
print("Date Time in string format: ", formatted_now)
Date Time in defaut format: 2021-11-22 09:26:40.054185
Date Time in string format: 2021-1122 09:26:40
将当前日期和时间转换为多个时区
现在我们将创建一个时区列表，并遍历它，将当前时间转换为该时区。我们将包括美国、欧洲、亚洲和标准 UTC 的时区。
timezones = ['US/Central', 'Europe/London',
'Asia/Kolkata', 'Australia/Melbourne', 'UTC']
for tz in timezones:
dateTime = datetime.now(timezone(tz)).strftime(time_format)
print(f"Date Time in {tz} is {dateTime}")
Date Time in US/Central is 2021-1122 03:27:58 CST-0600
Date Time in Europe/London is 2021-1122 09:27:58 GMT+0000
Date Time in Asia/Kolkata is 2021-1122 14:57:58 IST+0530
Date Time in Australia/Melbourne is 2021-1122 20:27:58 AEDT+1100
Date Time in UTC is 2021-1122 09:27:58 UTC+0000
接下来，我们将遍历作为 DateTime 库的 now()方法的参数创建的列表中的所有时区，以获取所有时区和每个时区中的当前时间。我们还将把它转换成字符串格式，以便于阅读。
结论
恭喜你！您刚刚学习了如何在 Python 中更改时区。希望你喜欢它！😇
喜欢这个教程吗？无论如何，我建议你看一下下面提到的教程:
感谢您抽出时间！希望你学到了新的东西！！😄
使用 spaCy NLP 库在 Python 中构建聊天机器人
原文：https://www.askpython.com/python/examples/chatbot-in-python-using-spacy
读者你好！欢迎来到本教程，在这里我们将用 python 构建一个天气机器人，它将用自然语言与用户互动。没有任何进一步的到期让我们开始吧。
必读:NLP 简介
什么是聊天机器人？
你们一定都访问过一个网站，在那里有一条信息说“嗨！我能帮你什么”然后我们点击它，开始和它聊天。你有没有想过谁和我们互动？嗯，它是智能软件，与我们互动，并回应我们的查询。
让我们再举一个现实生活中的例子，比如苹果公司的 Siri、亚马逊公司的 Alexa、谷歌助手等等。每当我们说“Alexa，在 Spotify 上播放我的音乐播放列表”，你的音乐播放列表就会开始播放。这些智能助理使用人工智能和机器学习，并接受过用户提供的各种输入的训练。
聊天机器人可以执行各种任务，如预订火车票，提供特定主题的信息，寻找你附近的餐馆等。聊天机器人就是为用户完成这些任务而创建的，让他们从自己搜索这些信息中解脱出来。
在本教程中，您将使用 spacy NLP 库 创建一个聊天机器人，它可以告诉用户城市的当前天气，并且能够用自然语言与用户交谈。这个聊天机器人将使用 OpenWeather API 告诉用户世界上任何一个城市的当前天气。
推荐阅读 : 自然语言处理 Top 5 Python 库
用 Python 创建聊天机器人的先决条件
- 最新版本的 Python 可以从https://www.python.org/downloads/下载
- 在本教程中，我们将为 OpenWeather 使用一个 API 键。要获取 API 密钥，请访问 OpenWeather 并创建一个帐户。请确认您的电子邮件地址。注册成功后，请访问 API 密钥部分，查看为您的帐户生成的 API 密钥。这个 API 密钥是一个字母数字字符序列。
满足上述要求后，我们就可以进入下一步了。
安装库
在本教程中，我们将需要两个库**[spacy](https://www.askpython.com/python/examples/pos-tagging-in-nlp-using-spacy)**和**[requests](https://www.askpython.com/python-modules/requests-in-python)**。空间库将帮助你的聊天机器人理解用户的句子，请求库将允许聊天机器人发出 HTTP 请求。
安装spacy:
pip install -U spacy
接下来，我们将下载 spacy 的英语语言模型:
python -m spacy download en_core_web_md
如果出现以下错误，则需要安装wheel:
Output
ERROR: Failed building wheel for en-core-web-md
安装车轮:
pip install -U wheel
然后，再次下载英语语言模型。
要确认 spacy 安装正确，请在终端中执行以下命令打开 Python 解释器:
python
现在，导入空间并加载英语语言模型:
>>> import spacy
>>> nlp = spacy.load("en_core_web_md")
如果这两条语句正确执行，则 spacy 安装成功。您可以关闭 python 解释器:
>>> exit()
**requests**库预装了 Python。如果在导入请求模块时收到错误消息，则需要安装库:
pip install requests
创建聊天机器人
好了，安装了上面的库，我们可以开始编码了。
步骤 1–创建天气函数
在这里，我们将创建一个函数，机器人将使用它来获取一个城市的当前天气。
打开您最喜欢的 IDE，并将以下代码添加到 python 文件中:
import requests
api_key = "your_api_key"
def get_weather(city_name):
api_url = "http://api.openweathermap.org/data/2.5/weather?q={}&appid={}".format(city_name, api_key)
response = requests.get(api_url)
response_dict = response.json()
weather = response_dict["weather"][0]["description"]
if response.status_code == 200:
return weather
else:
print('[!] HTTP {0} calling [{1}]'.format(response.status_code, api_url))
return None
让我们来理解代码！
首先，我们导入 requests 库，这样我们就可以发出 HTTP 请求并使用它们。在下一行中，您必须用为您的帐户生成的 API 密钥替换**your_api_key**。
接下来，我们定义一个函数**get_weather**()，它将城市的名称作为参数。在函数内部，我们为 OpenWeather API 构造了 URL。我们将通过这个 URL 发出 get 请求。URL 以 JSON 格式返回城市的天气信息。之后，我们使用requests.get()函数向 API 端点发出 GET 请求，并将结果存储在响应变量中。之后，使用response.json()将 GET 请求的结果转换成 Python 字典。我们这样做是为了方便访问。
接下来，我们将天气条件提取成一个 天气变量 。
接下来，我们处理一些条件。在 if 块中，我们确保 API 响应的状态代码为 200(这意味着我们成功获取了天气信息)并返回天气描述。
如果请求有问题，错误代码会打印到控制台，并且不会返回任何内容。
以上就是关于 get_weather()函数的全部内容。现在，让我们用一些输入来测试这个函数。将代码粘贴到您的 IDE 中，并用为您的帐户生成的 api 密钥替换 your_api_key 。
代码片段
import requests
def get_weather(city_name):
api_url = "http://api.openweathermap.org/data/2.5/weather?q={}&appid={}".format(city_name, api_key)
response = requests.get(api_url)
response_dict = response.json()
weather = response_dict["weather"][0]["description"]
if response.status_code == 200:
return weather
else:
print('[!] HTTP {0} calling [{1}]'.format(response.status_code, api_url))
return None
weather = get_weather("Patna")
print(weather)
输出
mist
多神奇啊！我们有一个函数可以获取世界上任何一个城市的天气情况。
步骤 2–创建聊天机器人功能
在这里，我们将创建一个功能正常的聊天机器人，它使用get_weather()函数获取一个城市的天气状况，使用 spacy NLP 库用自然语言与用户进行交互。将以下代码片段添加到前面的代码中。您不需要为此创建新文件。
首先，我们将导入空间库并加载英语语言模型:
import spacy
nlp = spacy.load("en_core_web_md")
之后，get_weather()添加以下代码:
weather = nlp("Weather Conditions in a city")
def chatbot(statement):
statement = nlp(statement)
在上面的代码片段中，变量weather和statement被标记化，这对空间计算用户输入statement和weather之间的语义相似度是必要的。聊天机器人函数将statement作为一个参数，它将与存储在变量天气中的句子进行比较。
接下来，我们将使用 spaCy 库的 similarity()函数。similarity()方法计算两个语句的语义相似度，并给出一个介于 0 和 1 之间的值，其中数字越大表示相似度越大。该功能用于使聊天机器人变得智能，以便它可以将用户给出的句子与基本句子进行比较，并给出所需的输出。当我们测试聊天机器人时，情况会变得更加清楚🙂
但是，我们必须为相似性设置一个最小值，以使聊天机器人决定用户希望通过输入语句了解城市的温度。所以，我们把最小值设为 0.75。您可以根据您的项目需求更改该值。
到目前为止，我们的代码是这样的:
import spacy
nlp = spacy.load("en_core_web_md")
weather = nlp("Weather Conditions in a city")
def chatbot(statement):
statement = nlp(statement)
min_similarity = 0.75
现在是本教程的最后也是最有趣的部分。我们将用户输入与存储在变量weather中的基本句子进行比较，我们还将从用户给出的句子中提取城市名称。
添加以下代码:
if weather.similarity(statement) >= min_similarity:
for ent in statement.ents:
if ent.label_ == "GPE": # GeoPolitical Entity
city = ent.text
city_weather = get_weather(city)
if city_weather is not None:
return "In " + city +", the current weather is: " + city_weather
else:
return "Something went wrong."
else:
return "You need to tell me a city to check."
else:
return "Sorry I don't understand that. Please rephrase your statement."
为了提取命名实体，我们使用 spaCy 的命名实体识别特性。为了提取城市的名称，使用了一个循环来遍历 spaCy 从用户输入中提取的所有实体，并检查实体标签是否为“GPE”(地理政治实体)。如果是，那么我们将实体的名称存储在变量city中。一旦提取了城市名称，就调用 get_weather()函数，城市作为参数传递，返回值存储在变量city_weather中。
现在，如果 get_weather()函数成功地获取了天气，那么它将被传递给用户，否则如果发生了错误，将向用户显示一条消息。
至此，您终于使用 spaCy 库创建了一个聊天机器人，它可以理解用户用自然语言输入的内容，并给出想要的结果。
完整的聊天机器人程序代码
import spacy
import requests
nlp = spacy.load("en_core_web_md")
api_key = "019947b686adde825c5c6104b3e13d7e"
def get_weather(city_name):
api_url = "http://api.openweathermap.org/data/2.5/weather?q={}&appid={}".format(city_name, api_key)
response = requests.get(api_url)
response_dict = response.json()
weather = response_dict["weather"][0]["description"]
if response.status_code == 200:
return weather
else:
print('[!] HTTP {0} calling [{1}]'.format(response.status_code, api_url))
return None
weather = nlp("Weather Conditions in a city")
def chatbot(statement):
statement = nlp(statement)
min_similarity = 0.75
if weather.similarity(statement) >= min_similarity:
for ent in statement.ents:
if ent.label_ == "GPE": # GeoPolitical Entity
city = ent.text
city_weather = get_weather(city)
if city_weather is not None:
return "In " + city +", the current weather is: " + city_weather
else:
return "Something went wrong."
else:
return "You need to tell me a city to check."
else:
return "Sorry I don't understand that. Please rephrase your statement."
print("Hi! I am Windy a weather bot.........")
statement = input("How can I help you ?\n")
response = chatbot(statement)
print(response)
我们已经要求聊天机器人提供比哈尔邦的天气情况，让我们看看我们得到了什么输出:
Hi! I am Windy a weather bot.........
How can I help you ?
How is the weather in Bihar
In Bihar, the current weather is: broken clouds
摘要
看到我们的聊天机器人给我们提供天气情况真的很有趣。请注意，我用自然语言询问聊天机器人，聊天机器人能够理解并计算输出。
最后，您已经创建了一个聊天机器人，并且您可以向它添加许多功能。
参考
检查表是否存在–Python SQLite3
原文：https://www.askpython.com/python-modules/check-if-a-table-exists-python-sqlite3
嘿读者们！在本文中，我们将学习如何使用 SQLite3 来检查一个表是否存在。这对我们来说很容易，因为我们将使用 Python 及其内置模块 SQLite3。所以，让我们努力吧。
请注意:您应该熟悉 SQLite3 和 SQL 命令。
这篇文章涵盖了什么？
- 创建数据库。
- 给它添加一些数据。
- 故意删除表格。
- 用 Python 创建程序检查表格是否存在
使用 Python SQLite3 创建数据库
在本节中，我们将创建一个名为 company 的示例数据库，并向其中添加一个 employee 表。该表包含该公司员工的基本信息。确保你创建了一个新的工作目录来保存所有的东西。
代码:
import sqlite3
connection = sqlite3.connect('databases/company.db') # file path
# create a cursor object from the cursor class
cur = connection.cursor()
cur.execute('''
CREATE TABLE employee(
emp_id integer,
name text,
designation text,
email text
)''')
print("Database created successfully!!!")
# committing our connection
connection.commit()
# close our connection
connection.close()
输出:
Database created successfully!!!
这将在数据库文件夹中添加一个 "company.db" 文件。这个文件包含我们的雇员表。这是一个空表，所以让我们给它添加一些数据。
使用 Python SQLite3 向表中添加数据
使用 "executemany()" 函数，我们可以在表中一次插入多条记录。因此，我们将在这里使用相同的:
代码:
import sqlite3
connection = sqlite3.connect('databases/company.db') # file path
cur = connection.cursor()
# creating a list of items
records = [(100, 'Arvind Sharma', 'Software Engineer', '[email protected]'),
(102, 'Neha Thakur', 'Project Manager', '[email protected]'),
(103, 'Pavitra Patil', 'Database Engineer', '[email protected]')]
cur.executemany("INSERT INTO employee VALUES (?,?,?,?)", records)
print('Data added successfully!!!')
connection.commit()
# close our connection
connection.close()
输出:
Data added successfully!!!
这些是我们刚刚通过 Python 脚本添加的记录。
故意删除表格
现在，我们将特意删除该表。我们使用默认 SQL 的 DROP TABLE 命令。
代码:
import sqlite3
connection = sqlite3.connect('databases/company.db')
connection.execute("DROP TABLE employee")
print("Your table has been deleted!!!")
connection.close()
输出:
Your table has been deleted!!!
使用 Python SQLite3 检查表是否存在
现在，检查该表是否存在。我们需要编写一个代码来尝试定位该表，如果没有找到，它应该返回一个类似于:“Table not found！!"。为此， fetchall() 函数很有用。这使我们能够检索/访问SQL 中一个表包含的所有信息。这将返回它获得的所有信息的列表。
逻辑:
- SELECT * FROM table name 命令试图从数据库中检索整个表。
- 如果该表存在，它将使用 fetchall() 函数将其存储在一个名为 data_list 的列表中。
- 如果数据存在，它将把它存储在一个列表中。
- 如果不存在表，那么它将从 sqlite3 模块中抛出 OperationalError 。
- 通过 except block 处理，然后打印一条消息“无此表:table _ name”。
代码:
import sqlite3
connection = sqlite3.connect('databases/company.db')
cur = connection.cursor()
try:
cur.execute("SELECT * FROM employee")
# storing the data in a list
data_list = cur.fetchall()
print('NAME' + '\t\tEMAIL')
print('--------' + '\t\t-------------')
for item in items:
print(item[0] + ' | ' + item[1] + '\t' + item[2])
except sqlite3.OperationalError:
print("No such table: employee")
connection.commit()
connection.close()
输出:
No such table: employee
因此，通过这种方式，我们可以检测特定表中的表是否存在于数据库中。
结论
就这样，本文到此结束。我希望读者已经了解了如何使用 SQLite3 来使用数据库。这对 DBs 新手来说可能是一个巨大的帮助。
检查数据帧是否为空的 4 种方法
原文：https://www.askpython.com/python-modules/pandas/check-if-dataframe-is-empty
读者你好！在本教程中，我们将讨论四种不同的方法来检查熊猫数据帧是否为空。那么，我们开始吧。
方法 1:使用 DataFrame.empty 属性
这是检查一个熊猫数据框对象是否为空的最常用的方法。在这个方法中，我们将使用 Pandas DataFrame 类的DataFrame.empty属性。
当DataFrame.empty属性应用于熊猫数据帧对象时，它返回一个布尔值，即True或False。首先，它检查 DataFrame 对象是否为空，返回真，如果 DataFrame 对象不为空，返回假。让我们通过 Python 代码来实现这一点。
# Import pandas module
import pandas as pd
# Create an empty DataFrame
# Using pd.DataFrame() function
df1 = pd.DataFrame()
print('\nThis is DataFrame-1:')
print(df1)
# Create a non-empty DataFrame
# Using pd.DataFrame() function
df2 = pd.DataFrame({'Char': ['A', 'B', 'C', 'D', 'E'],
'ASCII': [65, 66, 67, 68, 69]})
print('\nThis is DataFrame-2: ')
print(df2)
# Check if the above created DataFrames are empty
# Or not using DataFrame.empty attribute
print(f'\nDataFrame-1 is empty: {df1.empty}')
print(f'\nDataFrame-2 is empty: {df2.empty}')
输出:
This is DataFrame-1:
Empty DataFrame
Columns: []
Index: []
This is DataFrame-2:
Char ASCII
0 A 65
1 B 66
2 C 67
3 D 68
4 E 69
DataFrame-1 is empty: True
DataFrame-2 is empty: False
方法 2:使用 DataFrame.shape 属性
这是第二种最常用的方法来检查给定的 Pandas 数据帧是否为空。在这个方法中，我们将使用 Pandas DataFrame 类的DataFrame.shape属性。
shape属性返回代表 DataFrame 对象的维度(即行数和列数)的 元组 。为了检查 DataFrame 对象是否为空，我们必须在 DataFrame 对象上应用shape属性。
然后它检查 DataFrame 对象是否为空。它为返回的元组对象的第零个索引返回零值，表示数据帧中的行数为零。
如果 DataFrame 对象不为空，则返回 DataFrame 对象中的行数。让我们编写 Python 代码来实现这一点。
# Import pandas module
import pandas as pd
# Create an empty DataFrame with 5 columns
# Using pd.DataFrame() function
df1 = pd.DataFrame(columns = ['A', 'B', 'C', 'D', 'E'])
print('\nThis is DataFrame-1:')
print(df1)
# Create a non-empty DataFrame with 5 rows & 2 columns
# Using pd.DataFrame() function
df2 = pd.DataFrame({'Char': ['A', 'B', 'C', 'D', 'E'],
'ASCII': [65, 66, 67, 68, 69]})
print('\nThis is DataFrame-2:')
print(df2)
# Check if the above created DataFrames are empty
# Or not using DataFrame.shape attribute
print(f'\nNumber of rows in DataFrame-1: {df1.shape[0]}')
print(f'\nNumber of rows in DataFrame-2: {df2.shape[0]}')
输出:
This is DataFrame-1:
Empty DataFrame
Columns: [A, B, C, D, E]
Index: []
This is DataFrame-2:
Char ASCII
0 A 65
1 B 66
2 C 67
3 D 68
4 E 69
Number of rows in DataFrame-1: 0
Number of rows in DataFrame-2: 5
方法 3:将 DataFrame 对象传递给 len()函数
这是一种不常用的方法，用来检查给定的 pandas DataFrame 对象是否为空。在这个方法中，我们将使用len()函数。为了检查 DataFrame 是否为空，我们可以直接将 pandas DataFrame 对象传递给len()函数。
如果传递的数据帧对象是空数据帧，则 len()函数返回一个零值，表示数据帧对象中的行数为零。但是如果传递的 DataFrame 对象不为空，那么len()函数返回一个非零值表示 DataFrame 对象中的行数。让我们通过 Python 代码来实现这一点。
# Import pandas module
import pandas as pd
# Create an empty DataFrame with 3 columns
# Using pd.DataFrame() function
df1 = pd.DataFrame(columns = ['C1', 'C2', 'C3'])
print('\nThis is DataFrame-1:')
print(df1)
# Create a non-empty DataFrame with 4 rows & 2 columns
# Using pd.DataFrame() function
df2 = pd.DataFrame({'Char': ['a', 'b', 'c', 'd'], 'ASCII': [97, 98, 99, 100]})
print('\nThis is DataFrame-2:')
print(df2)
# Check if the above created DataFrames are empty
# Or not passing the DataFrame object to the len() function
print(f'\nLength of DataFrame-1: {len(df1)}')
print(f'\nLength of DataFrame-2: {len(df2)}')
输出:
This is DataFrame-1:
Empty DataFrame
Columns: [C1, C2, C3]
Index: []
This is DataFrame-2:
Char ASCII
0 a 97
1 b 98
2 c 99
3 d 100
Length of DataFrame-1: 0
Length of DataFrame-2: 4
在上面的输出中，DataFrame 的长度表示其中的行数。这就是为什么空数据帧的长度为零，因为其中没有行，而非空数据帧的长度非零，即它等于其中的行数。
方法 4:检查数据帧索引的长度
这是检查给定 Pandas DataFrame 对象是否为空的一种不太常用的方法。这里我们也将使用len()函数来检查数据帧是否为空。但是我们可以将数据帧索引列表传递给len()函数，而不是将整个熊猫数据帧对象传递给len()函数。
我们可以使用 pandas DataFrame 类的DataFrame.index.values属性获得 DataFrame 索引列表，该属性返回包含 DataFrame 对象索引作为其元素的 Python 列表。
如果传递的数据帧索引列表为空，则len()函数返回一个零值。这意味着数据帧的行数为零。但是如果传递的数据帧索引列表不为空，那么len()函数返回一个非零值，这意味着数据帧索引列表有一些值。让我们看看实现这一点的 Python 代码。
# Import pandas module
import pandas as pd
# Create an empty DataFrame with 3 columns
# Using pd.DataFrame() function
df1 = pd.DataFrame(columns = ['Col-1', 'Col-2', 'Col-3'])
print('\nThis is DataFrame-1:')
print(df1)
# Create a non-empty DataFrame with 3 rows & 2 columns
# Using pd.DataFrame() function
df2 = pd.DataFrame({'Col-1': ['Python', 'Matlab', 'Csharp'],
'Col-2': ['.py', '.mat', '.cs']}, index = ['i', 'ii', 'iii'])
print('\nThis is DataFrame-2:')
print(df2)
# Obtain the DataFrame index list for
# DataFrame-1 & DataFrame-2
# Using the DataFrame.index.values attribute
print(f'\nIndex list of DataFrame-1: {df1.index.values}')
print(f'\nIndex list of DataFrame-2: {df2.index.values}')
# Check if the above created DataFrames are empty
# Or not passing the DataFrame index list to the len() function
print(f'\nLength of DataFrame-1 index list: {len(df1.index.values)}')
print(f'\nLength of DataFrame-2 index list: {len(df2.index.values)}')
输出:
This is DataFrame-1:
Empty DataFrame
Columns: [Col-1, Col-2, Col-3]
Index: []
This is DataFrame-2:
Col-1 Col-2
i Python .py
ii Matlab .mat
iii Csharp .cs
Index list of DataFrame-1: []
Index list of DataFrame-2: ['i' 'ii' 'iii']
Length of DataFrame-1 index list: 0
Length of DataFrame-2 index list: 3
总结
在本教程中，我们学习了 Python 中四种不同的方法来检查 pandas DataFrame 对象是否为空。希望你已经理解了上面讨论的事情。想了解更多关于熊猫的信息，请继续关注我们。
检查 Python 中是否存在文件
原文：https://www.askpython.com/python-modules/check-if-file-exists-in-python
介绍
如何在 Python 中检查文件是否存在？我们已经在之前的文件处理教程中学习了对文件执行各种操作，包括读、写、删除以及用 Python 复制一个文件。但是，在我们对文件执行任何这些操作之前，检查文件是否已经存在是必要的。
如果一个文件不存在，那么我们既不能读取它，也不能复制或删除它。即使在写的时候，用户也可能想要检查文件的存在以避免覆盖信息。
让我们进入主题，看看检查文件是否存在的一些方法。
方法来检查文件是否存在于 Python 中
我们可以使用下面提到的不同方法来检查一个文件是否存在于 Python 中。
1.使用 pathlib 模块
Python 中的pathlib模块附带了一些有趣的方法，如is_file()、is_dir()、exists()等。让我们逐一看一些例子:
import pathlib
path = pathlib.Path('file.txt')
print("pathlib-exists()---->",path.exists())
print("pathlib-is_file()---->",path.is_file())
print("pathlib-is_dir()---->",path.is_dir())
输出:
pathlib Output
**pathlib.Path()**返回指向指定文件名的 path 对象，保存在变量 ' path ' 中，- 方法检查所提供的路径是否指向一个有效的文件。在我们的例子中，由于 file.txt 的路径存在，结果为真。
- 另一方面，
**is_file()**方法检查路径对象是否是文件。这在我们的例子中是正确的，正如我们在输出中看到的。 - 方法检查提供的路径是否是任何目录。这里，因为我们的 file.txt 路径不是一个目录，所以我们得到上面的输出。
2.使用操作系统模块
广泛使用的检查文件存在的方法之一是来自标准 python 库的 os.path 模块。它带有一些基本方法，如isfile()和exists()，类似于 pathlib 模块的方法。让我们仔细看看一个例子:
import os.path
print("os.path-exists()---->",os.path.exists('file.txt'))
print("os.path-isfile()---->",os.path.isfile('file.txt'))
输出:
os.path Output
- 与 pathlib 模块
exists()和is_file()方法类似，os.exists()和os.isfile()也分别做类似的检查。 - 唯一的区别是 pathlib 模块引入了一些很棒的面向对象的方法，并将路径视为路径对象而不是字符串(对于 os 模块)。
3.使用异常处理
现在让我们看看几种不同的方法，使用异常来检查 Python 中的文件是否存在。
这一次我们将使用内置的open()函数打开一个文件，并检查是否有异常，如果出现，将确认该文件不存在或不可访问。例如:
My_file=open('file.txt')
try:
My_file.close()
print("File found!")
except FileNotFoundError:
print("Files couldn't be opened!")
输出:
File found!
- 在上面给出的代码中，由于 file.txt 存在于我们的系统中，
FileNotFoundError没有被引发，文件被成功关闭。
同样，当 no-file.txt 在我们的机器上不存在时:
try:
My_file=open('no-file.txt')
My_file.close()
print("File found!")
except FileNotFoundError:
print("Files couldn't be opened!")
输出:
FileNotFoundError Exception
- 所以我们可以清楚地看到，当文件没有找到时，异常
FileNotFoundError被抛出。
此外，同样的任务可以通过IOError来完成，它检查程序是否可以读取和访问正在打开的文件。例如，考虑下面的代码片段:
try:
My_file = open('no-file.txt')
My_file.close()
print('File is found!')
except IOError:
print('IOError encountered!')
输出:
IOError
参考
- https://stack overflow . com/questions/82831/how-do-I-check-if-a-file-exists-without-exceptions
- https://docs.python.org/3/library/pathlib.html
- https://docs.python.org/3/library/os.html
检查 Python 字典中是否存在键的 4 个简单技巧
原文：https://www.askpython.com/python/dictionary/check-if-key-exists-in-a-python-dictionary
在本文中，我们将重点讨论检查 Python 字典中是否存在键的 4 种方法。Python 字典基本上是一种数据结构，其中数据项存储在键值对中。
技巧 1:“in”操作符检查 Python 字典中是否存在键
Python in operator和if statement可以用来检查特定的键是否存在于输入 Python 字典中。
Python in operator 主要检查特定的元素或值是否包含在特定的序列中，如列表、元组、字典等。
语法:
for/if value in iterable:
举例:
inp_dict = {'Python': "A", 'Java':"B", 'Ruby':"C", 'Kotlin':"D"}
search_key = 'Ruby'
if search_key in inp_dict:
print("The key is present.\n")
else:
print("The key does not exist in the dictionary.")
在上面的例子中，我们使用了 if 语句和 Python in操作符来检查关键字‘Ruby’是否出现在字典中。
输出:
The key is present.
技巧 2: Python keys()方法
Python 内置的keys() method可以用来检查现有字典中是否存在一个键。
语法:
dict.keys()
keys()方法不接受参数并返回一个对象，该对象表示特定输入字典中存在的所有键的列表。
因此，为了检查 dict 中是否存在特定的键，我们使用Python if statement和 keys()方法来比较 search_key 和 keys()方法返回的键列表。如果键存在，它将跟随 If 部分的语句，否则它将跳转到else 部分的语句。
举例:
inp_dict = {'Python': "A", 'Java':"B", 'Ruby':"C", 'Kotlin':"D"}
search_key = 'Ruby'
if search_key in inp_dict.keys():
print("The key is present.\n")
else:
print("The key does not exist in the dictionary.")
输出:
The key is present.
例 2:
inp_dict = {'Python': "A", 'Java':"B", 'Ruby':"C", 'Kotlin':"D"}
search_key = 'Cpp'
if search_key in inp_dict.keys():
print("The key is present.\n")
else:
print("The key does not exist in the dictionary.")
输出:
The key does not exist in the dictionary.
技术 3: get()方法检查 Python 字典中是否存在键
Python get() method可以用来检查特定的键是否出现在字典的键-值对中。
如果键碰巧出现在字典中，get()方法实际上返回与键相关联的值，否则它返回“ None ”。
语法:
dict.get(key, default=None)
我们把要搜索的关键字作为参数传递给 get()方法，如果 get()函数没有返回None，也就是说，如果关键字存在于 dict 中，我们就打印它。
例 1:
inp_dict = {'Python': "A", 'Java':"B", 'Ruby':"C", 'Kotlin':"D"}
if inp_dict.get('Python')!=None:
print("The key is present.\n")
else:
print("The key does not exist in the dictionary.")
输出:
The key is present.
技巧 4: Python has_key()方法
注意:****Python 3 版及以上已经省略了 has_keys()方法。
Python has_key() method检查特定的键在 dict 中是否可用，并返回 True，否则返回 false。
语法:
dict.has_keys()
举例:
inp_dict = {'Python': "A", 'Java':"B", 'Ruby':"C", 'Kotlin':"D"}
search_key = 'Kotlin'
if inp_dict.has_key(search_key):
print("The key is present.\n")
else:
print("The key does not exist in the dictionary.")
结论
因此，在本文中，我们揭示并理解了检查 Python 字典中是否存在 key 的各种技术。
我推荐所有的读者通过下面的帖子来更详细地了解 Python 字典。
参考
- Python 词典
- Python if 语句
检查列表是否为空——3 个简单的方法
原文：https://www.askpython.com/python/list/check-if-list-is-empty
嘿伙计们！希望你们都过得好。在这篇文章中，我们将关注检查列表是否为空的不同技术。
在进入之前，让我们看一下 Python 列表。
什么是 Python 列表？
Python List 是一种将数据动态存储到其中的数据结构。在 Python 中，它服务于数组的目的。此外，列表可以存储不同种类的元素，即不同数据类型的元素。
现在，已经理解了列表的工作原理，让我们来理解检查列表是否为空的不同方法。
技巧 1:使用 len()函数
Python len() function 可用于检查列表是否为空。如果 len()函数返回零，则该列表为空。
举例:
lst = [] ## empty list
length = len(lst)
if length == 0:
print("List is empty -- ",length)
else:
print("List isn't empty -- ",length)
输出:
List is empty -- 0
技巧 2:使用条件语句
Python 条件 if 语句可用于检查列表是否为空，如下所示
语法:
if not list:
#empty
else:
举例:
lst = [] ## empty list
if not lst:
print("List is empty.")
else:
print("List isn't empty.")
在上面的例子中，我们使用 if 语句来验证列表中是否存在任何元素。
输出:
List is empty.
技巧 3:直接比较
我们可以通过直接将列表与空列表进行比较来检查是否存在空列表，即如下所示的[ ]
语法:
if list == []:
#empty
else:
举例:
lst = list() ## empty list
if lst == []:
print("List is empty.")
else:
print("List isn't empty.")
这里，我们将指定的列表与空列表进行了比较，以检查给定的列表是否为空。
输出:
List is empty.
结论
到此，我们就结束了这个话题。如果你遇到任何问题，请随时在下面评论。
在那之前，学习愉快！！
参考
如何在 Python 中检查一个字符串是否包含子串？
原文：https://www.askpython.com/python/string/check-string-contains-substring-python
子串是字符串中的字符序列。以下是 Python 中检查一个字符串是否包含另一个字符串(即 substring)的方法。
- 通过使用
find()方法 - 通过使用
in运算符 - 通过使用
count()方法 - 通过使用
str.index()方法 - 通过使用
operator.contains()方法
方法 1:使用 find()方法
find()方法检查一个字符串是否包含特定的子字符串。如果字符串包含特定的子字符串，则该方法返回子字符串的起始索引，否则返回-1。
语法 : string.find(substring)
示例:使用 find()方法检查字符串中是否存在子字符串
str="Safa Mulani is a student of Engineering discipline."
sub1="Safa"
sub2="Engineering"
print(str.find(substring1))
print(str.find(substring2))
输出:
0
28
方法 2:通过使用 in 运算符
in操作符检查字符串中是否存在子串，如果存在子串，则返回真，否则返回假。
语法:string _ object 中的子串
示例:使用 in 运算符检查字符串中是否存在子字符串
str="Safa Mulani is a student of Engineering discipline."
sub1="Safa"
sub2="Done"
print(sub1 in str)
print(sub2 in str)
输出:
真
假
方法 3:使用 count()方法
count()方法检查字符串中 substring 的出现。如果在字符串中找不到子字符串，则返回 0。
语法 : string.count(子串)
示例:使用 count()方法检查字符串中是否存在子字符串
str="Safa Mulani is a student of Engineering discipline."
sub1="Safa"
sub2="student"
sub3="Done"
print(str.count(sub1))
print(str.count(sub2))
print(str.count(sub3))
输出:
1
1
0
方法 4:使用 index()方法
方法检查字符串中是否存在子字符串。如果子串不在字符串中，那么它不返回任何值，而是生成一个 ValueError 。
语法 : string.index(子串)
示例:使用 index()方法检查字符串中是否存在子字符串
str = "Safa is a Student."
try :
result = str.index("Safa")
print ("Safa is present in the string.")
except :
print ("Safa is not present in the string.")
输出:
Safa 出现在字符串中。
方法 5:使用 operator.contains()方法
语法 : operator.contains(string，substring)
示例:使用 operator.contains()方法检查字符串中是否存在子字符串
import operator
str = "Safa is a Student."
if operator.contains(str, "Student"):
print ("Student is present in the string.")
else :
print ("Student is not present in the string.")
输出:学生出现在字符串中。
参考
- Python 字符串
Python 中如何检查两个栈是否相等？
原文：https://www.askpython.com/python/examples/check-two-stacks-equality
在本教程中，我们将讨论使用 Python 检查两个堆栈是否相等的不同方法。
什么是堆栈？
一个 Python 栈 是一个线性数据结构，基于 LIFO 原理工作。根据 LIFO 原则，最后插入堆栈的元素将首先被移除/访问。这就是为什么我们称之为后进先出。这意味着我们只能在一个方向上对栈执行不同的操作。栈可以用任何编程语言实现，包括 Python。在 Python 中，可以使用 list、deque 和 LifoQueue 来实现堆栈。为了简单起见，这里我们将使用 Python 列表来实现堆栈。
Python 堆栈的属性
- 堆栈是单向的，即堆栈的元素只能从一端插入或删除。
- 堆栈维护一个指向堆栈最后一个元素的 top 指针。
- 要访问堆栈的第( i )个元素，我们必须移除最后( N-i )个元素。
- 堆栈可以是无溢出条件的动态或有溢出条件的静态的。
检查 Python 中两个堆栈的相等性
我们有两个堆栈，必须检查这两个堆栈是否相同。只有当两个堆栈中的元素数量相同、值相同、顺序相同时，它们才被称为等于。例如:
stack1 = [1, 5, 7, 9]
stack2 = [1, 5, 7, 9]
(stack1 & stack2) are the same.
stack3 = [9, 5, 7, 1]
(stack1 & stack3) and (stack2 & stack3) are not the same.
方法 1:比较并弹出两个堆栈的顶部元素
让我们看看 Python 中方法一检查两个给定堆栈相等性的算法:
- 首先创建一个 checker 变量，并将其设置为 True (最初假设两个堆栈相等)。
- 然后比较两个堆栈的大小，如果它们不相等，则将 checker 变量设置为 False 并返回控制。
- 否则比较两个堆栈的顶部元素。如果相等，将它们从两个堆栈中取出。
- 如果栈顶元素不相等，则将 checker 变量设置为 False 并返回控制。
- 重复步骤 3 和 4 直到两个堆栈都变空，即堆栈的所有元素都弹出。
- 最后检查我们在步骤 1 中定义的 checker 变量的值，如果为真则表示两个堆栈相等，否则不相等(或不相等)。
让我们通过 Python 代码来实现上面的算法。
# Define a function in Python
# To check if the two stacks
# Equal or not
def equal_stacks(s1, s2):
# Create a checker variable
# And initialize it with True
val = True
# Check the size of both stacks
# Passed as arguments
if len(s1) != len(s2):
val = False
return val
# Compare the top of each stack
while(len(s1)):
if s1[-1] == s2[-1]:
s1.pop()
s2.pop()
else:
val = False
break
# Return the final value
# Of checker variable val
return val
# Driver Code
# Define two stacks
stack1 = [8, 15, 7, 11]
stack2 = [8, 15, 9, 11]
# Pass the above two Stacks to equal_stacks() function
# And check their equality
if equal_stacks(stack1, stack2):
print("Two stacks are equal!")
else:
print("Two stacks are not equal!!")
# Print the contents of both the stacks
# After their comparison
print(f'\nStack-1 after comparison: {stack1}')
print(f'\nStack-2 after comparison: {stack2}')
输出:
Two stacks are not equal!
Stack-1 after comparison: [8, 15, 7]
Stack-2 after comparison: [8, 15, 9]
在上面的输出中，我们可以清楚地看到，在比较之后，两个堆栈的内容都发生了改变。
方法 2:比较没有改变的两个堆栈的顶部元素
让我们看看 Python 中方法二检查两个给定堆栈相等性的算法:
- 首先创建一个 checker 变量，并将其设置为 True (最初假设两个堆栈相等)。
- 然后将两个堆栈的大小保存在两个独立的变量中，比如(P 和 Q ),并对它们进行比较。如果它们不相等，则将 checker 变量设置为 False 并返回控制。
- 否则，在范围[1，P + 1]上运行循环的，并执行以下操作:
- 首先将栈 1 的顶部(P-1)个元素转移到栈 2。
- 将堆栈 1 的当前顶部元素存储到一个单独的变量中，比如说 temp。
- 现在将堆栈 2 的顶部 2*(P-1)个元素转移到堆栈 1。
- 将堆栈 2 的顶部元素与 temp 变量(即堆栈 1 的顶部元素)内的值进行比较。
- 如果两个堆栈的两个对应的顶部元素相等，则通过将堆栈 1 的顶部(P-1)个元素转移到堆栈 2 来重建两个堆栈。
- 否则将检验器变量设置为假并返回控制。
- 最后检查我们在步骤 1 中定义的 checker 变量的值，如果为真则表示两个堆栈相等，否则不相等(或不相等)。
让我们通过 Python 代码来实现上面的算法。
# Define a function to push the elements of
# One stack into another stack
def push_stack(s1, s2, len):
i = 1
while (i <= len):
# Append the top of s1 to s2
s2.append(s1[-1])
# Delete the top of s1
s1.pop()
# Increment the loop counter
i = i + 1
# Define a function to check
# If the two stacks equal or not
def equal_stacks(s1, s2):
# Create a checker variable
# And initialize it with True
val = True
# Find the size of S1 stack
P = len(s1)
# Find the size of S2 stack
Q = len(s2)
# Compare the size of s1 & s2 stacks
if (P != Q):
val = False
return val
# Compare the top elements of each stack
for i in range(1, P + 1):
# Push P-i elements of stack s1 to stack s2
push_stack(s1, s2, P - i)
# Save the value of S1 top
val = s1[-1]
# Push 2 * (P-i) elements of stack S2 to stack S1
push_stack(s2, s1, 2 * (P - i))
# Compare the top elements of both stacks s1 & s2
if (val != s2[-1]):
val = False
return val
# Reconstruct both the stacks s1 & s2
push_stack(s1, s2, P - i)
# Return the final value of val
return val
# Driver Code
# Define two stacks
stack1 = [5, 7, 11, 8]
stack2 = [5, 7, 11, 8]
# Pass the above two Stacks to equal_stacks() function
# And check their equality
if equal_stacks(stack1, stack2):
print("Two stacks are equal!")
else:
print("Two stacks are not equal!!")
# Print the contents of both the stacks
# After their comparison
print(f'\nStack-1 after comparison: {stack1}')
print(f'\nStack-2 after comparison: {stack2}')
输出:
Two stacks are equal!
Stack-1 after comparison: [5, 7, 11, 8]
Stack-2 after comparison: [5, 7, 11, 8]
在上面的输出中，我们可以清楚地看到两个堆栈的内容在比较后都没有被修改或改变。
结论
在本教程中，我们学习了 Python 中检查两个给定堆栈相等性的不同方法。
- 在第一种方法中，我们在改变它们之后检查了两个堆栈的相等性，即，在最后我们没有原始堆栈。
- 在第二种方法中，我们已经检查了两个堆栈的相等性，而没有改变它们，也就是说，最后我们得到了原始堆栈。
Python 中检查字符串是否为空的 4 种方法
原文：https://www.askpython.com/python/examples/check-whether-string-is-empty
这个标题听起来有点奇怪，因为有人可能认为我们可以在 len()或 not 操作符的帮助下简单地检查 spring 是否为空。但我们需要记住，它将空格作为字符串中的一个字符，并将字符串显示为非空字符串。在本文中，我们将学习可以用来检查字符串是否为空的方法。我们开始吧！
方法来检查 Python 中的字符串是否为空
让我们看看 Python 中检查字符串是否为空的 4 种不同方法。我们将通过一个例子来探究每种方法，并显示输出，以帮助您自己执行同样的操作。
1.使用 NOT 运算符
此方法将带有空格的字符串视为非空字符串。它将字符串中的空格算作一个字符。我们应该知道带空格的字符串是一个空字符串，并且大小不为零，但是这个方法忽略了这个事实。
例如
str1 = ""
str2 = " "
if(not str1):
print ("Yes the string is empty")
else :
print ("No the string is not empty")
if(not str2):
print ("Yes the string is empty")
else :
print ("No the string is not empty"
输出:
Yes the string is empty
No the string is not empty
你可以看到它把带空格的字符串打印成了一个非空字符串。
2.使用 len()函数
与 not 操作符一样，这也将带有空格的字符串视为非空字符串。此方法检查非空的零长度字符串。
例如:
str1 = ""
str2 = " "
if(len(str1) == 0):
print ("Yes the string is empty ")
else :
print ("No the string is not empty")
if(len(str2) == 0):
print ("Yes the strinf is empty")
else :
print ("No the string is not empty")
输出:
Yes the string is empty
No the string is not empty
3.使用 not+str.strip()方法
这个方法没有忽略空+非零长度字符串的事实。因此，此方法可以用于检查空的零长度字符串。它寻找一个空的非零长度的字符串。
例如:
str1 = ""
str2 = " "
if(not (str1 and str1.strip())):
print ("Yes the string is empty")
else :
print ("No the string is not empty")
if(not(str2 and str2.strip())):
print ("Yes the string is empty")
else :
print ("No the string is not empty")
输出:
Yes the string is empty
Yes the string is empty
4.使用 not str.isspace 方法
这个方法和上面的方法类似。这种方法被认为是更健壮的，因为它执行剥离操作，如果字符串包含大量空格，该操作将承担计算责任。
str1 = ""
str2 = " "
if(not (str1 and not str1.isspace())):
print ("Yes the string is empty")
else :
print ("No the string is not empty")
if(not (str2 and not str2.isspace())):
print ("Yes the string is empty")
else :
print ("No the string is not empty")
输出:
Yes the string is empty
Yes the string is empty
结论
所以在这篇文章中，我们学习了很多不同的方法来检查空字符串。虽然每种方法都有自己的缺点，但您可以根据自己的适合程度来使用它们。
Python 中的循环链表
原文：https://www.askpython.com/python/examples/circular-linked-lists
循环链表是用来存储列表的数据结构。它非常类似于链表，但是有一些额外的特性。在本教程中，我们将讨论什么是循环链表，我们将在 python 中实现它，并查看它的输出。
先决条件:理解链表
在讨论循环链表之前，我们必须首先定义链表。
链表是一种列表，其中的列表项以特定的方式链接到其他列表项。不同形式的链表有不同的链接对象的方式。
“单向链表”或简称为“链表”是最流行的链表，其中每个项目链接到列表中的下一个项目。因此，为了讨论第十个项目，我们必须首先讨论第九个项目，它与第十个项目相联系。一旦我们访问了第十项，我们就可以通过第十项的连接访问第十一项。
节点是链表中每个对象的名称。单链表中的每个节点都有两个部分。第一部分包含节点的数据，而第二部分包含到下一个节点的链接。
现在让我们来看看循环链表。
Python 中的循环链表
循环链表与链表的相似之处在于节点通过链接连接，但是最后一个节点也链接到第一个节点，而不仅仅是链接到空。因此，在我们访问了最后一个节点之后，我们可以通过最后一个节点访问第一个节点。
这样做的方法只是不把最后一个节点的链接保持为None，而是让它指向第一个节点。
这样做的好处是，可以更容易地实现具有循环出现的项目列表的算法。例如，循环调度算法，或者多人游戏中的玩家循环本质上是循环的。
为了形象化，循环链表看起来像这样:
Circular Linked List Representation
在上面的例子中，您可以看到列表中有四个节点。每个节点都有一些数据，并且除了链接到列表第一个节点的最后一个节点之外，每个节点都链接到列表的下一个节点。
有一个头指向列表的开始，用来进入列表并遍历循环链表。
推荐阅读——
在 Python 中实现循环链表
为了创建循环链表，我们创建两个类:第一个类用于节点，第二个类用于将使用节点的链表。
类:节点
对于节点类，我们有两个成员。一个用于存储数据，另一个用于存储到下一个节点的链接。类别定义将是:
class Node:
def __init__(self, data = None):
self.data = data
self.next = self
因此，最初，每个新创建的节点要么有数据值，要么没有数据值，这取决于它是如何创建的，但默认情况下，它会指向自身，因此它就像一个单项循环链表。
类:循环链表
这个类将使用前一个类创建的节点来实现一个循环链表。它将包含一个头节点、一个计数成员和用于特定任务的多个方法。
class CLL:
def __init__(self):
self.head = None
self.count = 0
def __repr__(self):
string = ""
if(self.head == None):
string += "Circular Linked List Empty"
return string
string += f"Circular Linked List:\n{self.head.data}"
temp = self.head.next
while(temp != self.head):
string += f" -> {temp.data}"
temp = temp.next
return string
def append(self, data):
self.insert(data, self.count)
return
def insert(self, data, index):
if (index > self.count) | (index < 0):
raise ValueError(f"Index out of range: {index}, size: {self.count}")
if self.head == None:
self.head = Node(data)
self.count += 1
return
temp = self.head
for _ in range(self.count - 1 if index - 1 == -1 else index - 1):
temp = temp.next
aftertemp = temp.next #New node goes between temp and aftertemp
temp.next = Node(data)
temp.next.next = aftertemp
if(index == 0):
self.head = temp.next
self.count += 1
return
def remove(self, index):
if (index >= self.count) | (index < 0):
raise ValueError(f"Index out of range: {index}, size: {self.count}")
if self.count == 1:
self.head = None
self.count = 0
return
before = self.head
for _ in range(self.count - 1 if index - 1 == -1 else index - 1):
before = before.next
after = before.next.next
before.next = after
if(index == 0):
self.head = after
self.count -= 1
return
def index(self, data):
temp = self.head
for i in range(self.count):
if(temp.data == data):
return i
temp = temp.next
return None
def size(self):
return self.count
def display(self):
print(self)
我们来讨论一下上面写的方法。
__init__法
在构造函数中，我们初始化两个成员，我们将head设置为None,因为列表中没有节点，出于同样的原因，我们将count设置为0。
__repr__法
打印链表的字符串将由__repr__进程返回。所以要么列表是空的，在这种情况下我们打印它，要么列表不是空的，在这种情况下我们逐个打印每个节点的数据。
append``insert法
在这个实现中，可以在指定位置附加或插入节点。要追加，我们只需调用insert方法，并将列表的大小作为index发送。
在insert方法中，我们首先检查指定的索引是否有效，如果无效，我们抛出一个ValueError。通过检查后，如果列表为空，我们只需将新节点分配给head，递增count，并从方法返回。
如果列表不为空，我们首先到达指定索引之前的节点。例如，如果给定的索引是 5，那么我们到达第 4 个索引处的节点，因为列表是循环的，如果给定的索引是 0，那么我们到达列表的最后一个节点。
现在，我们将新节点分配给指定索引之前的节点的next，并使新节点的next链接到指定索引处的节点。这将确保新节点被插入到位于指定索引处的节点之前，从而获取其索引并将其向前推。
现在，如果给定的索引是 0，我们已经在列表的最后一个节点后插入了一个节点，所以我们简单地让head指向新的节点，使它成为列表的新头部。
remove法
要移除一个项目，我们必须指定要从哪里移除该项目。如果指定的索引超出范围，我们就抛出一个ValueError。如果列表上只有一项，我们只需创建head None和count 0，并从方法返回。
否则，我们必须到达指定索引之前的节点和指定索引之后的节点。例如，如果指定的索引是 4，那么我们需要到达第 3 个节点和第 5 个节点，并且因为如果指定的索引是 0，列表是循环的，所以我们需要到达最后一个节点(在它之前)和第 1 个节点(在它之后)。
在此之后，我们只需将指定索引之后的节点赋给指定索引之前的节点的next。这将跳过指定索引处的节点，从而将其从列表中删除。如果指定的索引为 0，那么head已经从列表中删除，所以我们只需将指定索引之后的节点分配给head，列表将被恢复。别忘了递减列表的count。
指标、尺寸和显示方法
方法在列表中搜索一个条目。如果找到，它返回它的索引，否则，它返回None。size方法返回列表中的节点数，display方法打印列表。
输出
Example illustrating initialization, appending, and insertion.
Example illustrating removal, searching, the size method, and printing.
结论
我们学习了循环链表以及如何在 Python 中使用它们。我们从单链表的工作方式开始，然后转向循环链表的不同之处。我们用 Python 编写了数据结构代码，讨论了每个方法的工作原理，然后查看了代码的结果。
我希望你在学习中过得愉快，下次教程再见。
PyTorch 中的 Clamp()函数–完整指南
原文：https://www.askpython.com/python/examples/clamp-function-in-pytorch
各位编码员，你们好吗？因此，在本教程中，我们将尝试使用 PyTorch clamp()函数。我们将从理论和实践两个角度来看待它。
让我们开始吧。
Python PyTorch 中 clamp()介绍
clamp()函数用于约束指定范围内的数值。这意味着什么？
首先，让我们搞清楚。
假设你已经得到了一个从 60 到 110 的数字范围，你正在寻找数字 85(T2，T3)。因此，clamp()函数将其值限制为 85。在这种情况下，85 介于 60 和 110 之间，很容易计算。
但是，如果你选择了 35 ，你就在范围之外了。在这种情况下，它被限制为 60，因为它最接近下限，而不是在范围的中间。
同样，如果输入一个大于 110 的数，比如 132 ，它会返回 110，因为 132 接近最大限制，也就是 110。
在 PyTorch 中实现 clamp()函数
让我们开始在 PyTorch 中实现 clamp()函数。
使用 clamp()功能
Python clamp 功能没有内置到语言中，但可以使用以下代码进行定义:
def clamp_fucntion (no , min_no , max_no ):
n = max(min(no, max_no), min_no)
return n
print( "Find 10 in 20 to 30 : ", clamp_fucntion(10 ,20 ,30) )
print( "Find 25 in 20 to 30 : ", clamp_fucntion(25 ,20 ,30 ) )
print( "Find 115 in 20 to 30 : ", clamp_fucntion(115 ,20 ,30 ) )
Find 10 in 20 to 30 : 20
Find 25 in 20 to 30 : 25
Find 115 in 20 to 30 : 30
还有一些实现箝位功能的其他方法。让我们在下一节看看其中的一些。
pyker 夹点()
然而，虽然这个函数在核心 Python 中并不常用，但它在许多 Python 库中被广泛使用，比如 Pytorch 和 Wand ImageMagick 库。
此外，这个函数已经包含在这些库中。您只需要导入它并根据需要使用它。
让我们来看一些例子。
import torch
T = torch.FloatTensor([3,12,15,18,21])
print("Input Tensor: ", T)
output = torch.clamp(T,min=10,max=20)
print("Output Tensor: ",output)
Input Tensor: tensor([ 3., 12., 15., 18., 21.])
Output Tensor: tensor([10., 12., 15., 18., 20.])
结论
恭喜你！您刚刚学习了 Clamp 函数及其在 Python 中的实现。希望你喜欢它！😇
喜欢这个教程吗？无论如何，我建议你看一下下面提到的教程:
感谢您抽出时间！希望你学到了新的东西！！😄
Python 类属性和实例属性
原文：https://www.askpython.com/python/oops/class-and-instance-attributes
在本文中，我们将重点关注 Python 类属性和实例属性。
属性是编程语言的关键。它们负责保存重要的数据值，也有助于数据操作。
让我们现在就开始吧！
了解 Python 类属性
Python Class Attribute是包含在类中的属性/变量。也就是说，它的范围位于 Python 类内。
类属性仅创建其自身的单个副本，并且该单个副本由该特定类中的所有函数和对象共享和利用。
语法:
class Class-name:
variable = value
现在让我们通过下面的例子来理解相同的实现。
用示例实现 Class 属性
class class_attribute:
val = 1
def product(self):
class_attribute.val *= 10
print(class_attribute.val)
obj1 = class_attribute()
obj1.product()
obj2 = class_attribute()
obj2.product()
在这个例子中，我们创建了一个类变量‘val’并将其初始化为 1。
此外，我们访问函数 product()中的变量“val ”,并通过将该值乘以 10 来处理它。
可以清楚地看到，创建的两个对象使用了变量‘val’的同一个副本。因此，起初，val = 1。
当对象 obj1 调用该函数时，使用相同的“val”副本(该值不会重置)，因此它变为 val=10。在被 obj2 调用时，val 变为 val10，即 1010 = 100。
输出:
10
100
了解 Python 实例属性
Python Instance attribute是一个局部属性/变量，其范围位于使用该属性的特定函数内。因此，它被一个特定的函数所包围。
每当实例属性被一个函数/对象调用时，它就会创建一个自身的新副本。也就是说，每次对象或函数试图访问该变量时，都会使用该变量的一个不同副本。
语法:
def function-name():
variable = value
现在让我们借助一个例子来实现局部属性。
用示例实现实例属性
class instance_attribute:
def product(self):
val = 20
val *= 10
print(val)
obj1 = instance_attribute()
obj1.product()
obj2 = instance_attribute()
obj2.product()
在这个例子中，我们将一个实例属性声明并初始化为 val = 20。
此外，当 obj1 试图通过函数访问变量时，它会创建自己的新副本，将默认值重置为初始化值，然后提供对它的访问。
当 obj2 试图访问实例变量‘val’时，同样的场景会重复出现。
输出:
200
200
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
参考
Python 中类的属性
原文：https://www.askpython.com/python/oops/class-instance-attributes
类是 Python 语言的基础部分。它们提供了一种将相关功能组合在一起的方法，并且在面向对象编程中起着核心作用。在本文中，我们将看看 Python 中类的属性。
关于一般类的更多信息
- 这些类只是一个接口，其中包含变量和函数。这些分别被称为数据成员和成员函数。
- 要访问它们，我们需要创建一个该类的对象。对象是我们可以编辑其属性的实例。
- 为了给类本身提供一些参数，有一个特殊的方法叫做构造函数。当我们形成对象时，方法在运行时调用。
- 我们可以只使用对象来访问所有的数据成员和成员函数。
在 Python 中创建类
Python 中的类是用关键字 class 创建的，后跟类名。类属性是在类名之后定义的，由该类的所有实例共享。单个实例属性是在类属性之后定义的，它们对于每个实例都是唯一的。方法定义也放在类定义之后。方法是与类相关联的函数，它们用于处理或操作存储在类实例中的数据。
现在让我们定义一个类来更好地理解这一点。
代码:
class student:
def __init__(self, name, std, roll_no):
self.nm = name
self.std = std
self.rl_no = roll_no
def getData(self):
print("Student name: ", self.nm)
print("Standard: ", self.std)
print("Roll number: ", self.rl_no)
def setData(self, name, std, roll_no):
self.nm = name
self.std = std
self.rl_no = roll_no
stud = student("Om", "4th", 9)
stud.getData()
print() # to print a new line in between
stud_1 = student("Hari", "5th", 14)
stud_1.getData()
输出:
Student name: Om
Standard: 4th
Roll number: 9
Student name: Hari
Standard: 5th
Roll number: 14
说明:
- 使用 class 关键字声明一个类。然后在它后面添加 class_name，并给出一个冒号来开始数据插入。
- 然后调用 "init()" 方法。这是 Python 中任何类的构造函数方法。
- 我们创建一个学生类，然后给它一些属性，比如名字、标准和编号。
- 然后我们使用 self 关键字来确保属性被正确地绑定到类。如果我们不使用 self 关键字，就没有使用类声明。
- 该类中有两个方法。
- 第一个“getData()”检索实例属性。
- 第二个“setData()”允许更改这些属性的值。
- 现在我们为这个类创建两个对象。第一个有不同的参数。这是两个学生的名字和信息。
- 这些被称为实例变量或实例属性。它们对每个对象都是唯一的。
访问类变量实例属性
您可以使用点运算符(.).例如，如果要访问 myClass 的属性 x，可以使用表达式 myClass.x。如果要调用 myClass 的方法 myMethod，可以使用表达式 myClass.myMethod()。
在这个演示中，让我们在类中定义一些实例属性。
访问实例属性的语法:
object = class_name(parameter1 = value_!, parameter2 = value_2, .., parameter_N = value_N)
object.parameter_1
object.parameter_2
.
.
object.parameter_N
代码:
class Rectangle:
def __init__(self, length, width):
self.side_1 = length
self.side_2 = width
def area(self):
a = self.side_1*self.side_2
print("Area of the rectangle is: ", a)
rect = Rectangle(45.0, 56.98)
# printing the type of object
print(type(rect))
# accessing the values through object
print(rect.side_1)
print(rect.side_2)
输出:
<class '__main__.Rectangle'>
45.0
56.98
因此，通过这种方式，我们可以访问它们。
访问类方法和其他实例属性
语法:
class_name.variable_1
class_name.variable_2
.
.
class_name.variable_N
这个概念的简单变化就是我们所说的类属性就是类变量。这些变量只能通过使用 class_name 来访问。它们也被称为静态变量。内存不会清除它，而是在每次成功运行代码之后。它更新新值，保留以前的值。
例如，我们取同一个学生类，并为其创建类属性:
class student:
school = "Universal Public School"
batch = "2020-2021"
def __init__(self, name, std, roll_no):
self.nm = name
self.std = std
self.rl_no = roll_no
def getData(self):
print("Student name: ", self.nm)
print("Standard: ", self.std)
print("Roll number: ", self.rl_no)
def setData(self, name, std, roll_no):
self.nm = name
self.std = std
self.rl_no = roll_no
print("The school name is: ", student.school)
print("The batch year is: ", student.batch, "\n")
stud = student("Om", "4th", 9)
stud.getData()
print() # to print a new line in between
stud_1 = student("Hari", "5th", 14)
stud_1.getData()
输出:
The school name is: Universal Public School
The batch year is: 2020-2021
Student name: Om
Standard: 4th
Roll number: 9
Student name: Hari
Standard: 5th
Roll number: 14
说明:
- 学生类一开始只包含两个新东西。它包含了学校和批次变量。
- 下一个代码与第一个代码相同。其他的只是
getter() and setter()方法。 - 现在在第 21 和 22 行代码中，我们调用这些变量。
- 注意区别:
- 我们只使用类名调用它们，而不是创建一个对象。
- 然后使用点运算符.”访问被占用。
- 另外，请注意，我们可以在运行时使用等号“=”操作符来改变它们的值，也可以调用它们。
示例(运行期间):
class Employee:
# class attributes
COMPANY = ""
BRANCH = ""
def __init__(self, name, designation, ID):
self.name = name
self.designation = designation
self.id = ID
def getData(self):
print(self.name)
print(self.designation)
print(self.id)
print()
def setData(self, name, desig, ID):
self.name = name
self.designation = desig
self.id = ID
def main():
Employee.COMPANY = input("Enter the company name: ")
Employee.BRANCH = input("Enter the branch: ")
print()
print("...The employee details are...")
print("The company name is: ", Employee.COMPANY)
print("The company branch is at: ", Employee.BRANCH)
emp_1 = Employee("Varun", "Tirpathi", 1001)
emp_2 = Employee("Dhanush", "Reddy", 1002)
emp_3 = Employee("Neha", "Singh", 1003)
emp_1.getData()
emp_2.getData()
emp_3.getData()
main()
输出:
Enter the company name: Microsoft
Enter the branch: Bengaluru
...The employee details are...
The company name is: Microsoft
The company branch is at: Bengaluru
Varun
Tirpathi
1001
Dhanush
Reddy
1002
Neha
Singh
1003
说明:
- 这里我们有一个简单的雇员类。构造函数包含雇员的姓名、职务和 ID 等参数。
- 接下来的方法是名字中的
getData() and setData().,我们可以理解为第一个方法用于检索数据，第二个方法用于编辑数据。 - 这个类有两个属性:
- 公司。
- 分支。
- 这个函数接受这两个类属性的输入。
- 在最后六行中，我们有三个 Employee 类的对象。
- 然后为了检索数据，我们调用 getData()方法。
结束了
所以，这样，我们可以说一个类的属性也叫做类变量。我希望这将有助于学习与 OOP 和 Python 中的类相关的新概念。更多新的话题。在那之前，继续学习和进步。
用 Python 分类新闻标题——机器学习
原文：https://www.askpython.com/python/examples/classify-news-headlines-in-python
我们生活在一个数据驱动的社会，随着我们收集越来越多的数据，对事物进行分类变得越来越重要。因此，在本帖中，我们将根据新闻的类型对新闻标题进行分类。比如体育新闻，科技新闻，等等。
在本教程中，我们将处理包含新闻标题及其类别的数据。我们的目标是利用 Python 编程语言中的机器学习概念对新闻标题进行分类。
介绍数据集
我们将使用包含新闻标题及其类别的数据集。在本教程中，我们不会深入细节，如如何抓取网页。您可以从 这里 下载数据集，然后放入您的工作目录。
用 Python 分类新闻标题的步骤
让我们进入用 Python 对新闻标题进行分类的步骤。按照本教程来理解整个过程。
1。导入模块/库
我们将从导入我们将使用的不同模块开始。复制粘贴下面的代码片段并继续。
import tensorflow as tf
from tensorflow.keras import layers
from tensorflow.keras.models import Sequential
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
from sklearn.model_selection import train_test_split
import numpy as np
import pandas as pd
2。加载数据集
df = pd.read_csv('news_headlines.csv')
df.head(n=10)
First 10 Rows News Headlines
3。列车测试分割
现在，我们将使用 80:20 规则进行训练-测试分割，其中 80%的数据用于训练，其余 20%用于测试。
training_data,testing_data = train_test_split(df.iloc[:5000,:],test_size=0.2)
# 80% training data
为了形象化，我们可以借助下面提到的代码分别绘制训练和测试。
import matplotlib.pyplot as plt
# plotting distribution of each news_category in training& testing data
plt.plot(training_data['news_category'].value_counts())
plt.plot(testing_data['news_category'].value_counts())
plt.title('Train-Test Split Visualization')
plt.show()
Train Test Split News Headlines
4。标记化功能
这个函数非常简单，它发生在新闻标题数据的训练和测试过程中，并返回与之相关的序列。
你可以参考 这篇 教程来了解更多关于标记化的过程。
def tokenization_(training_headings, testing_headings, max_length=20,vocab_size = 5000):
tokenizer = Tokenizer(num_words = vocab_size, oov_token= '<oov>')
#Tokenization and padding
tokenizer.fit_on_texts(training_headings)
word_index = tokenizer.word_index
training_sequences = tokenizer.texts_to_sequences(training_headings)
training_padded = pad_sequences(training_sequences,padding= 'post',maxlen = max_length, truncating='post')
testing_sequences = tokenizer.texts_to_sequences(testing_headings)
testing_padded = pad_sequences(testing_sequences,padding= 'post',maxlen = max_length, truncating='post')
return tokenizer,training_padded,testing_padded
为了将 tokenizer 函数应用于训练和测试数据集，我们需要运行下面提到的代码片段。
tokenizer,X_train,X_test = tokenization_(training_data['news_headline'],
testing_data['news_headline'])
labels = {'sports':[0,1,0],'tech':[1,0,0],'world':[0,0,1],}
Y_train = np.array([labels[y] for y in training_data['news_category']])
Y_test = np.array([labels[y] for y in testing_data['news_category'] ])
我们还会将 news_headline 和它们的标签分离到不同的列表中，因为它们将在模型中分别用于训练和测试目的。
5。构建神经网络
def build_model( n, vocab_size, embedding_size):
model = tf.keras.models.Sequential()
model.add(tf.keras.layers.Embedding(vocab_size,
embedding_size,input_length=n))
model.add(tf.keras.layers.GlobalAveragePooling1D())
model.add(tf.keras.layers.Dense(3,activation = 'softmax'))
model.compile(loss='categorical_crossentropy',optimizer='adam',
metrics='accuracy')
print(model.summary())
return model
上面的代码执行以下操作:
- 创建顺序模型
- 向顺序模型添加输入和输出图层
- 编译模型并在训练后显示模型的摘要
- 最后，返回训练好的模型
在这个模型中，我们将利用两层，其中第一层是嵌入层，第二层是输出层。
6。训练神经模型
epochs = 25
history = model.fit(X_train,Y_train,
validation_data = (X_test,Y_test),
epochs = epochs)
最初，我们将设置一个纪元值。你可以把它设置成你喜欢的任何值，因为这个模型有 25 个纪元就足够了。接下来，我们将把我们的训练和测试数据拟合到神经模型中。
该模型在训练数据集上给出了 97% 的准确率，在验证/测试数据集上给出了 94% 的准确率，这是相当好的，因此该模型工作得相当好。
结论
恭喜你！您刚刚学习了如何制作一个分类神经模型，以便预测新闻标题的类别。希望你喜欢它！😇
喜欢这个教程吗？无论如何，我建议你看一下下面提到的教程:
感谢您抽出时间！希望你学到了新的东西！！😄
用 Python 对服装图像进行分类——完全指南
原文：https://www.askpython.com/python/examples/classifying-clothing-images
大家好！在本教程中，我们将看看如何使用 Python 编程语言在 TensorFlow 的帮助下对各种服装图像进行分类。
社交媒体平台 Instagram、YouTube 和 Twitter 已经接管了我们的日常生活。模特和名人尤其需要知道如何将服装分成几类，如果他们想看起来最好的话。
也读作:用 Python 加密价格预测
Classify Images Sample Demonstration
照片中时尚物品的分类包括个体服装的识别。这同样适用于社交网络、电子商务和刑法。
步骤 1:导入模块
每个项目的第一步是导入所有需要的模块。我们将与 Tensorflow 以及 numpy 和 matplotlib 一起工作。
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
步骤 2:数据的加载和预处理
我们将要加载到程序中的数据集可以在这里看到。
这个数据集包括来自十个不同时尚类别的60,000张灰度照片，每张照片的尺寸为28x28 pixels，外加一组虚拟的10,000 图像。
可以使用该数据集替换 MNIST。下面的代码行实现了数据的加载。
fashion_data=tf.keras.datasets.fashion_mnist
步骤 3:训练和测试数据分割
任何机器学习模型的主要部分都包括基于 80-20 规则将数据分成两部分。
80-20 规则规定，80%的数据发送给训练数据，20%发送给测试数据。下面的代码将数据分为训练和测试。
(inp_train,out_train),(inp_test,out_test)=fashion_data.load_data()
inp_train = inp_train/255.0
inp_test = inp_test/255.0
print("Shape of Input Training Data: ", inp_train.shape)
print("Shape of Output Training Data: ", out_train.shape)
print("Shape of Input Testing Data: ", inp_test.shape)
print("Shape of Output Testing Data: ", out_test.shape)
代码还对加载的数据集进行标准化。
Shape of Input Training Data: (60000, 28, 28)
Shape of Output Training Data: (60000,)
Shape of Input Testing Data: (10000, 28, 28)
Shape of Output Testing Data: (10000,)
步骤 4:数据可视化
将初始数据可视化的代码如下:
plt.figure(figsize=(10,10))
for i in range(100):
plt.subplot(10,10,i+1)
plt.imshow(inp_train[i])
plt.xticks([])
plt.yticks([])
plt.xlabel(out_train[i])
plt.tight_layout()
plt.show()
MNIST Clothes Data Visualize
步骤 5:将标签更改为实际名称
我们已经看到了可视化，但我们也希望标签有明确定义的名称。下面提到的代码将达到目的。
Labels=['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat','Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']
plt.figure(figsize=(10,10))
for i in range(100):
plt.subplot(10,10,i+1)
plt.xticks([])
plt.yticks([])
plt.imshow(inp_train[i], cmap=plt.cm.binary)
plt.xlabel(Labels[out_train[i]])
plt.tight_layout()
plt.show()
MNIST Clothes Data Visualize With Labels
你现在可以看到，可视化现在更容易理解了。
步骤 6:构建、编译和训练模型
TensorFlow 和 Keras 模型的构建、编译和定型代码如下所示:
my_model = tf.keras.Sequential([
tf.keras.layers.Flatten(input_shape=(28, 28)),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dense(10)
])
my_model.compile(optimizer='adam',
loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics=['accuracy'])
my_model.fit(inp_train, out_train, epochs=20)
步骤 7:检查最终损失和准确性
既然我们的模型已经训练成功，现在就轮到计算损失并找到所创建和训练的模型的最终精度了。
loss, accuracy = my_model.evaluate(inp_test,out_test,verbose=2)
print('\nAccuracy:',accuracy*100)
整个模型处理后得到的最终精度为88.8%，相当不错。
第八步:做预测
我们已经到了程序的最后一步，使用我们刚刚创建和训练的模型进行预测。
*prob=tf.keras.Sequential([my_model,tf.keras.layers.Softmax()])
pred=prob.predict(inp_test)*
步骤 9:可视化最终预测
对任何分类模型来说，重要的是我们做出最终的可视化。为了简单起见，我们将可视化数据集的前 20 幅图像。
*plt.figure(figsize=(20,20))
for i in range(20):
true_label,image = out_test[i],inp_test[i]
pred_label = np.argmax(pred[i])
plt.subplot(10,10,i+1)
plt.xticks([])
plt.yticks([])
plt.imshow(image, cmap=plt.cm.binary)
if pred_label == true_label:
color = 'green'
label="Correct Prediction!"
else:
color = 'red'
label="Wrong Prediction!"
plt.tight_layout()
plt.title(label,color=color)
plt.xlabel(" {} -> {} ".format(Labels[true_label],Labels[pred_label]))*
*
Final Visual Clothes Classification*
感谢您阅读教程。我希望你通过它学到了很多。
快乐学习！继续阅读，了解更多。
Python 中如何清理 CSV 数据？
原文：https://www.askpython.com/python/examples/clean-csv-data-python
机器学习算法的有效实现，甚至在数据集上做一些数据分析时，我们都需要干净的数据。
关于用数据进行数值建模，有一个众所周知的说法，“垃圾进垃圾出”，当我们的数据不干净时，我们就不能指望得到像样的结果。
在本文中，我们将探索使用 python pandas 库清理 CSV 数据的常用技术。
CSV 数据清理检查
我们将根据以下内容清理数据:
- 缺少值
- 极端值
- 重复值
1.清除 CSV 文件中丢失的值
在 Pandas 中，缺少的值通常用NaN表示，因为它是基于 NumPy 包的，它是 NumPy 特有的特殊浮点 NaN 值。
你可以在这里找到本文使用的数据集。
查找缺失值
让我们先看看如何发现数据中是否有缺失值。
#方法 1:目测
import pandas as pd
import seaborn as sb
import matplotlib.pyplot as plt
#importing Dataset
df = pd.read_csv('IMDB-Movie-Data.csv')
#Creating the heatmap
plt.figure(figsize = (8,6))
sb.heatmap(df.isnull(), cbar=False , cmap = 'magma')
Missing Values Using the Heatmap
isnull()方法返回布尔值，表明数据中是否有缺失值。
然而，这一过程可能仅限于中小型数据集。
#接近 2
我们可以在应用.isnull()后使用.sum()方法，这将返回数据帧中每一列内缺失值的总和。
import pandas as pd
#importing dataset
df = pd.read_csv('IMDB-Movie-Data.csv')
df.isnull().sum()
Finding Sum Of Missing Values
从数据中清除缺失值
我们发现我们的数据集确实有一些缺失值，接下来我们应该做什么来获得干净的数据？
我们可以删除其中包含缺失值的行和列，或者用适当的值(即平均值、中值或众数)替换缺失值。
- 删除缺失值:
#imporing pandas
import pandas as pd
#Importing dataset
df = pd.read_csv('IMDB-Movie-Data.csv')
#Size of original dataset
print(df.shape)
#Dropping the missing rows.
df_dropped = df.dropna(how = 'any')
上述代码将从数据帧中删除缺少值的行。
我们来详细看看.dropna()的方法:
- df . dropna()–删除所有具有 NaN 值的行
- df . dropna(how = ' ALL ')–仅当所有列都是 NaN 时删除
- df . dropna(thresh = 2)-如果没有至少两个值是 not NaN，则删除行
- df . dropna(subset =[1])–仅在特定列中有 NaN 时删除
考虑删除缺失值时必须小心，因为这可能会影响数据集的质量。
2.替换缺失值
import pandas as pd
#importing the dataset
df = pd.read_csv('IMDB-Movie-Data.csv')
#Creating a copy of dataframe
df_new = df
df_new['Metascore'] = df_new['Metascore'].fillna((df_new['Metascore'].mean()))
#printing the dataframes after replacing null values
print(df_new.isna().sum())
print(df.isna().sum())
Before And After Filling Null Values
熊猫模块有。fillna()方法，它接受一个我们想要替换 NaN 值的值。我们只是计算列的平均值，并将其作为输入参数传递给fillna()方法。
2.处理异常值
离群值可能会改变整个预测的过程，因此我们有必要检测并移除离群值。
使用 Z 分数
让我们检测数据集中投票列的异常值，并使用 z 分数过滤异常值。
这种方法背后的思想在于，距离平均值 3 标准差的值将被称为异常值。
#importing required modules
import pandas as pd
import numpy as np
from scipy import stats
#importing dataset
df = pd.read_csv('IMDB-Movie-Data.csv')
#filtering outliers
df_new = df[(np.abs(stats.zscore(df.Votes)) < 3)]
应用此方法的列应该是数字变量，而不是分类变量。
使用分位数
通过这种方法，序列中低于 0.01 分位数和高于 0.99 分位数的值将被过滤掉。
#importing required modules
import pandas as pd
import numpy as np
from scipy import stats
#importing dataset
df = pd.read_csv('IMDB-Movie-Data.csv')
#Selecting limits
q_low = df["Votes"].quantile(0.01)
q_hi = df["Votes"].quantile(0.99)
#filtering outliers
df_filtered = df[(df["Votes"] < q_hi) & (df["Votes"] > q_low)]
3.处理重复条目
我们可以使用 .duplicated() 方法检查数据帧中的任何重复项。这将返回熊猫系列，而不是 DataFrame。
为了检查特定列中的重复值，我们可以将列名作为输入参数提供给.duplicated( )方法。
让我们来看看实际情况。
幸运的是，我们的数据框中没有重复值，因此我们将从数据框本身追加一些值来创建重复值。
#Import the required modules
import pandas as pd
import numpy as np
#importing and appending similar rows to of the dataframe
df = pd.read_csv('IMDB-Movie-Data.csv')
df1 = df.append(df.iloc[20:30,:])
df1.duplicated().sum()
Output:
10
现在，.drop_duplicates()方法用于从数据帧中删除重复值。
#Importing the required modules
#Import the required modules
import pandas as pd
import numpy as np
#importing and appending similar rows to of the dataframe
df = pd.read_csv('IMDB-Movie-Data.csv')
df1 = df.append(df.iloc[20:30,:])
#dropping the duplicates
df1 = df1.drop_duplicates()
#checking the duplicates
df1.duplicated().sum()
output:
0
摘要
使用 pandas 和 NumPy 模块，Python 中的 CSV 数据清理很容易。在对数据进行分析之前，一定要进行数据清理，以确保分析是正确的。
下一步是什么？
资源
Python 中的闭包——实用参考
在本教程中，我们将看到 Python 中的闭包是什么，它们何时存在，以及我们如何使用它们。
为了理解闭包的概念，我们需要理解一些基本的概念，比如嵌套函数和自由变量。
然后我们会看到闭包在 Python 中的实现，闭包存在的条件，以及使用闭包的好处。
Python 中的嵌套函数是什么？
Python 中的嵌套函数是定义在另一个函数内部的函数。下面是一个嵌套函数的例子。
这里 nested_function() 定义在 outer_function() 的局部作用域内，除非在函数调用时被 outer_function 返回，否则只能在同一作用域内调用。
#nested function example
def outer_function():
x=10
print("It is outer function which encloses a nested function")
def nested_function():
print("I am in nested function and I can access x from my enclosing function's scope. Printing x")
print(x)
nested_function()
#Execution
outer_function()
输出:
It is outer function which encloses a nested function
I am in nested function and I can access x from my enclosing function's scope. Printing x
10
我们可以看到嵌套函数可以从它的封闭范围访问变量。当 outer_function 被调用时，它定义 nested_function 并最终调用它打印 x 的值
需要记住的重要一点是，函数是 python 中的第一类对象；即函数可以作为参数传递，从其他函数返回，并赋给任何变量。
什么是自由变量？
一个变量只能在它被定义的范围内被访问，也就是说，如果我们在一个函数或块内声明一个变量，那么它只能在那个函数或块内使用。否则将会出现名称错误。
当一个变量在一个没有定义的函数或代码块中使用时，这个变量被称为自由变量。
在上面的例子中, x 是自由变量。这里 nested_function 可以引用 x ，因为一个函数可以访问定义它的作用域中定义的变量。
Python 中的闭包是什么？
Python 中的闭包用于面向对象编程，通过它，嵌套函数记住并访问定义它的函数范围内的变量。
闭包在实现中使用嵌套函数和自由变量。
执行嵌套函数时，外部函数不必是活动的，即外部函数范围内的变量可能不在内存中，但嵌套函数可以访问它。
这样，数据被附加到代码上，甚至不存在于内存中，然后被嵌套函数使用。
Python 中闭包存在的条件是什么？
从上面的描述中，我们可以很容易地发现 Python 中闭包的存在。
- 我们需要嵌套函数。
- 嵌套函数需要引用其外部作用域(即外部函数)中定义的变量。
- 闭包存在的第三个也是最重要的条件是外部函数必须返回嵌套函数。
Python 中闭包的例子
让我们看一个 Python 中闭包的例子。假设我们希望有一个函数对传递给它的数字进行计算并打印结果。
#closure example
def generate_number():
print("I am in generate_number function and will return the inner_function when called")
x=999
y=100
def inner_function(number):
result=(number*x)%y
print("I am in inner function and printing the result")
print(result)
return inner_function
#execute
print("Calling generate_number")
do_something = generate_number()
print("Calling do_something")
do_something(77)
输出
Calling generate_number
I am in generate_number function and will return the inner_function when called
Calling do_something
I am in inner function and printing the result
23
在上面的例子中，
- 函数 generate_number() 被定义，它有两个变量和一个函数 inner_function 被定义在其作用域内。
- inner_function 可以访问函数 generate_number 范围内的变量 x 和 y 。它执行计算并打印结果。
- 现在在执行过程中，当我们调用 generate_number() 函数时，它完成它的执行并将 inner_function 返回给变量 do_something 。
- 此时， generate_number 的执行结束，其作用域从内存中被清空(参见 Python 垃圾收集 ) 。
- 现在 do_something 变量开始作为一个函数。
- 当我们调用这个函数时，它执行 inner_function 并打印结果。
这里需要注意的是， inner_function 正在执行，而 generate_number 已经完成了它的执行。
因此，变量 x 和 y 不在内存中，内部函数仍然可以使用这些变量。
这表明数据已经附加到代码而不是内存中。这就是闭包的本质。
为什么要在 Python 中使用闭包？
如果我们想避免使用全局变量，可以使用 Python 中的闭包，因此可以用于数据隐藏。当装饰器被实现时，闭包的一个非常好的用法就完成了。
结论
好了，今天就到这里。我们涵盖了很多 Python 的基础和高级教程，以满足您的需求。如果你是初学者，试试这篇 Python 初学者教程。快乐学习！🙂
Python 中的聚类分析——快速指南
原文：https://www.askpython.com/python/examples/cluster-analysis-in-python
有时，我们需要对我们没有太多信息的数据进行聚类或分离，以获得更好的可视化效果或更好地理解数据。有三种主要的算法来执行这些功能，在本文中，我们将了解三种不同的数据聚类方法。我们开始吧！
什么是数据的聚类和聚类分析？
数据聚类是指根据属性或特性将数据分组为小的聚类。聚类分析被用于多种应用中，例如医学成像、异常检测大脑等。
聚类分析是一种无监督的机器学习算法。它用于没有任何正确标签的数据。对于这类数据，聚类很方便。
聚类算法的类型
以下是一些最流行的聚类算法:
- 亲和传播
- 层次凝聚聚类
- 桦树
- 基于密度的噪声应用空间聚类
- K-表示
- 小批量 K 均值
- 均值漂移
- 光学
- 谱聚类
- 高斯混合
在本文中，我们将讨论其中最流行的三种算法:K-Means 聚类、DBSCAN 和 HAC。
1.k-均值聚类算法
在这种类型的算法中，数据将数据划分或隔离成“K 个不相交的簇”。你需要根据你的数据选择聚类数(K)。聚类中心或质心代表每个聚类。
算法是这样工作的:
- 第一步:首先选择聚类中心或聚类个数。
- 步骤 2 :通过计算欧几里德距离，将每个点委派到其最近的聚类中心。
- 步骤 3 :聚类质心将根据分配给该聚类的点的平均值进行优化。
- 步骤 4 :一旦我们看到聚类质心没有做很多移动或移动很小的距离，我们就可以有把握地说 K-means 聚类已经收敛。
让我们看看如何在 Python 中实现 K-means 聚类。我们使用著名的 Iris 数据集来实现我们的 K-Means 算法。
from copy import deepcopy
import numpy as np
import pandas as pd
from matplotlib import pyplot as plt
现在让我们导入一个 CSV 文件并创建一个数据帧。
df = pd.read_csv("/content/Iris.csv")
df.drop('Id',axis=1,inplace=True)
df.head()
df["Species"] = pd.Categorical(df["Species"])
df["Species"] = df["Species"].cat.codes
# Changing dataframe to numpy matrix
data = df.values[:, 0:4]
category = df.values[:, 4]
创建 K 均值聚类的时间。为了使事情更简单，我们将使用 matplotlib 模块创建一个绘图。
k = 3
# Training data
n = data.shape[0]
# Number of features in the data
c = data.shape[1]
# Generating random centers
mean = np.mean(data, axis = 0)
std = np.std(data, axis = 0)
centers = np.random.randn(k,c)*std + mean
# Plotting data
colors=['blue', 'yellow', 'green']
for i in range(n):
plt.scatter(data[i, 0], data[i,1], s=7, color = colors[int(category[i])])
plt.scatter(centers[:,0], centers[:,1], marker='.', c='r', s=150)
尽管 K-均值聚类是一种健壮的算法，但它可能不会收敛于局部最优最小值。
基于密度的噪声应用空间聚类(DBSCAN)
基于密度的聚类算法基于这样的思想:空间中的聚类是由低点密度区域与其他聚类分隔开的高密度点。这种聚类算法非常适合含有大量噪音和异常值的数据。该算法采用两个参数 minPts 和 minPts 是密集区域中聚集在一起的点的最小数量，eps 用于测量点之间的距离。
让我们来理解算法是如何工作的。
- 第一步:第一步，在数据集中拾取任意一点，然后遍历数据集中所有点。
- 步骤 2: 如果算法发现在距离所选点 EPS(ε)的距离内有“minpts”，则算法认为所有这些点都是同一聚类的一部分。
- 步骤 3 :然后对邻近点重复该算法，从而扩展聚类。
让我们看看如何用 python 实现 DBSCAN。
首先，我们将导入必要的库。
import numpy as np
from sklearn.cluster import DBSCAN
from sklearn import metrics
from sklearn.datasets import make_blobs
from sklearn.preprocessing import StandardScaler
现在我们将生成随机数据。
centers = [[1, 1], [-1, -1], [1, -1]]
X, labels_true = make_blobs(n_samples=750, centers=centers, cluster_std=0.4,
random_state=0)
X = StandardScaler().fit_transform(X)
在下一步中，我们将执行 DBSCAN。
db = DBSCAN(eps=0.3, min_samples=10).fit(X)
core_samples_mask = np.zeros_like(db.labels_, dtype=bool)
core_samples_mask[db.core_sample_indices_] = True
labels = db.labels_
n_clusters_ = len(set(labels)) - (1 if -1 in labels else 0)
n_noise_ = list(labels).count(-1)
print('Estimated number of clusters: %d' % n_clusters_)
print('Estimated number of noise points: %d' % n_noise_)
print("Homogeneity: %0.3f" % metrics.homogeneity_score(labels_true, labels))
print("Completeness: %0.3f" % metrics.completeness_score(labels_true, labels))
print("V-measure: %0.3f" % metrics.v_measure_score(labels_true, labels))
print("Adjusted Rand Index: %0.3f"
% metrics.adjusted_rand_score(labels_true, labels))
print("Adjusted Mutual Information: %0.3f"
% metrics.adjusted_mutual_info_score(labels_true, labels))
print("Silhouette Coefficient: %0.3f"
% metrics.silhouette_score(X, labels))
输出:
Estimated number of clusters : 3
Estimated number of noise points : 18
Homogeneity : 0.953
Completeness : 0.883
V-measure : 0.917
Adjusted Rand Index : 0.952
Adjusted Mutual Information : 0.916
Silhouette Coefficient : 0.626
现在，让我们画出我们在上面的输出中看到的结果。
import matplotlib.pyplot as plt
%matplotlib inline
unique_labels = set(labels)
colors = [plt.cm.Spectral(each)
for each in np.linspace(0, 1, len(unique_labels))]
for k, col in zip(unique_labels, colors):
if k == -1:
# Black used for noise.
col = [0, 0, 0, 1]
class_member_mask = (labels == k)
xy = X[class_member_mask & core_samples_mask]
plt.plot(xy[:, 0], xy[:, 1], 'o', markerfacecolor=tuple(col),
markeredgecolor='k', markersize=14)
xy = X[class_member_mask & ~core_samples_mask]
plt.plot(xy[:, 0], xy[:, 1], 'o', markerfacecolor=tuple(col),
markeredgecolor='k', markersize=6)
plt.title('Estimated number of clusters: %d' % n_clusters_)
plt.show()
DBSCAN 算法的最佳运行时复杂度是 0 (nlogn)。
层次凝聚聚类
这种类型的聚类方法遵循自底向上的方法。每个对象首先被视为单个元素或集群。在每次迭代中，两个最可能的聚类被组合成一个大的聚类。重复这个过程，直到每个点都归入一个大簇。
让我们看看算法是如何工作的。
- 第一步:第一步，估计数据集中每两个对象之间的相似程度。
- 第二步:现在，在链接功能的帮助下，开始根据距离将对象分组到一个层次聚类树中。因此，使用链接功能来组合或链接靠近的对象。
- 第三步:将层次树划分成簇。
我们来看看如何用 Python 实现算法。我们将使用 numpy 数组生成数据点。
import numpy as np
X = np.array([[5,3],
[10,15],
[15,12],
[56,10],
[30,40],
[85,70],
[91,80],
[50,78],
[60,55],
[70,91],])
现在，我们将绘制已经生成的数据点。在这里，我们从 1 到 10 标记数据点。
import matplotlib.pyplot as plt
labels = range(1, 11)
plt.figure(figsize=(10, 7))
plt.subplots_adjust(bottom=0.1)
plt.scatter(X[:,0],X[:,1], label='True Position')
for label, x, y in zip(labels, X[:, 0], X[:, 1]):
plt.annotate(
label,
xy=(x, y), xytext=(-3, 3),
textcoords='offset points', ha='right', va='bottom')
plt.show()
输出:
您可能会注意到数据点形成了三个集群。一个有 1，2，3，另一个有 4 和 5，还有一个从 6 到 10。但是在多维数据的情况下，用肉眼指出这样的簇是非常困难的。
让我们为这些数据点绘制树状图。
from scipy.cluster.hierarchy import dendrogram, linkage
from matplotlib import pyplot as plt
linked = linkage(X, 'single')
labelList = range(1, 11)
plt.figure(figsize=(10, 7))
dendrogram(linked,
orientation='top',
labels=labelList,
distance_sort='descending',
show_leaf_counts=True)
plt.show()
输出:
该算法将首先通过计算欧几里德距离或曼哈顿距离来找到彼此最接近的点。从前面的图中可以看出，2 和 3 以及 6 和 7 彼此最接近，因此在树状图中它们被连接在一起。
树状图的垂直高度表示两点之间的欧几里德距离。在下一步中，该算法将继续将一个聚类加入到其最近的聚类中，依此类推。重复这个步骤，直到形成一个大的集群，并且所有的点都被连接。
结论
总之，我们学习了三种流行的聚类算法，以及如何在 python 中使用它们。这三种算法有非常不同的聚类方法。您必须根据您的数据集选择聚类算法。当我们想要在没有关于数据的任何先验信息的情况下对数据进行分组时，我们使用聚类，这意味着以无监督的方式！
决定系数–Python 中的 R 平方值
原文：https://www.askpython.com/python/coefficient-of-determination
读者朋友们，你们好！在本文中，我们将关注 Python 中的决定系数。所以，让我们开始吧！🙂
什么是决定系数(R 平方值)？
在深入探讨决定系数的概念之前，让我们先了解一下通过误差度量来评估一个机器学习模型的必要性。
在数据科学领域，为了解决任何模型，工程师/开发人员在将模型应用于数据集之前，评估模型的效率是非常必要的。模型的评估基于某些误差度量。决定系数就是这样一种误差度量。
决定系数，也就是通常所说的 R 平方值，是一个regression error metric,用于评估模型在应用数据值时的准确性和效率。
r 平方值描述了模型的性能。它描述了由数据模型的独立变量预测的响应或目标变量的变化。
因此，简单地说，R 平方值有助于确定模型的混合程度，以及数据集的决定(独立)变量对输出值的解释程度。
R 平方的取值范围在[0，1]之间。看看下面的公式！
R²= 1-SS[RES]/SS[tot]
这里，
- SS [res] 表示数据模型的残差的平方和。
- SS [tot] 代表误差的总和。
R 平方值越高，模型和结果越好。
带数字图书馆的 r 广场
现在让我们尝试使用 Python NumPy 库来实现 R square。
我们按照以下步骤使用 Numpy 模块获得 R 平方的值:
- 使用
numpy.corrcoef()函数计算相关矩阵。 - 对索引为[0，1]的矩阵进行切片，以获取 R 的值，即
Coefficient of Correlation。 - 对 R 的值求平方，得到 R 平方的值。
举例:
import numpy
actual = [1,2,3,4,5]
predict = [1,2.5,3,4.9,4.9]
corr_matrix = numpy.corrcoef(actual, predict)
corr = corr_matrix[0,1]
R_sq = corr**2
print(R_sq)
输出:
0.934602946460654
带 Python sklearn 库的 R square
现在，让我们尝试使用 sklearn 库计算 R 平方的值。Python sklearn 库为我们提供了一个 r2_score()函数来确定决定系数的值。
举例:
from sklearn.metrics import r2_score
a =[1, 2, 3, 4, 5]
b =[1, 2.5, 3, 4.9, 5.1]
R_square = r2_score(a, b)
print('Coefficient of Determination', R_square)
输出:
Coefficient of Determination 0.8929999999999999
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。更多与 Python 相关的帖子，敬请关注。快乐学习！！🙂
使用 Python Tkinter 的硬币翻转 GUI
原文：https://www.askpython.com/python-modules/tkinter/coin-flip-gui
在本教程中，我们将使用 Python Tkinter 编写一个具有图形用户界面(GUI)的硬币投掷程序。本教程旨在向您传授 Tkinter 模块的基础知识，这是一个用 Python 开发基于 GUI 的程序的优秀模块。
用 Python Tkinter 实现硬币翻转 GUI 应用程序
Tkinter 是 python 的标准 GUI 库，用于开发基于界面的应用程序。Tkinter 与 Python 结合使用，使得基于 GUI 的应用程序变得非常容易。
1.安装模块
对于这个程序，我们需要 Python NumPy 、 Pillow 和 Tkinter 库，我们可以使用 pip 轻松下载这些库。
pip install numpy
pip install pillow
pip install tk
2.导入模块
安装模块后，我们可以通过导入程序中的所有模块来开始编写程序。
import numpy as np
from tkinter import *
from PIL import Image, ImageTk
注意:-在上面的代码中，' * '意味着我们从模块 Tkinter 导入所有内容。
3.为我们的应用程序创建主窗口
首先，我们将使用 Tk()对象初始化 Tkinter 类，并将其赋给“root”变量。所以现在通过使用 root，我们可以访问 Tkinter 模块的所有方法。
在第二行代码中，我们指定了输出 GUI 屏幕的窗口大小，就像这里我们给了它 400*400 的值(对于 widthxheight)。
现在我们使用 mainloop 方法使窗口持久化意味着窗口不会关闭，除非我们自己想关闭它。如果我们跳过这一行代码，输出屏幕会出现一次并立即关闭。
root = Tk()
root.geometry("500*500")
root.mainloop()
运行上述代码后，我们将得到如下所示的窗口。如果你有一个这样的窗口，你就很好，可以继续下去。
Output GUI Screen Tkinter
4.加载图像
我们将根据我们程序的结果显示一个硬币的图像。如果输出是正面，那么它将显示硬币的正面，当它是反面时，显示硬币的反面。
正面和反面两个图像都保存在与我们的程序文件相同的目录中。如果没有，那么您需要传递图像文件名及其位置。
#load heads image
load = Image.open("heads.jpg")
heads = ImageTk.PhotoImage(load)
#load tails image
load = Image.open("tails.jpg")
tails = ImageTk.PhotoImage(load)
为了您的方便，我们已经将图像文件添加到硬币的正面和背面。
5.添加按钮
现在我们的主窗口已经准备好了，我们需要一个按钮，我们可以按下这个按钮来投掷硬币。
按下这个按钮，我们就调用了一个 tossTheCoin 函数。我们可以使用 tkinter 中的按钮类来创建按钮。
b1=Button(root, text="Toss the Coin", font=("Arial", 10), command=tossTheCoin, bg='teal', fg='white', activebackground="lightblue", padx=10, pady=10)
b1.pack()
上面的代码将在我们的主窗口中呈现一个按钮，文本为 Toss the Coin。在命令中，我们将传递我们的函数名。
注意:我们使用 pack() 方法在我们的主窗口上渲染每一个元素。
6.结果的文本字段
现在，我们以文本格式为掷硬币的结果创建一个文本字段。为此，我们使用代码:
tfield = Text(root, width=52, height=5)
tfield.pack()
要在该文本字段中插入文本，我们使用 insert 函数，如下所示:
tfield.insert(INSERT, "Click on the Button.. To Flip the Coin and get the result")
现在，每次结果发生变化时，我们都需要删除之前插入的文本，所以我们将 delete text 方法与按钮 click–
tfield.delete("1.0", "end")
7.实现 tossTheCoin()函数
当我们扔硬币时，它有 50%的机会正面或反面落地。我们希望在我们的程序中有这种公平的性质，这样它就可以接近真实的抛硬币场景。为此，我们将使用 NumPy 模块的二项式方法。
np.random.binomial(1,0.5)
这将返回 1 或 0。因此，我们可以编写 if 条件语句来检查它是 1 还是 0，并使用 config 方法相应地呈现头部或尾部图像。
完整的代码看起来像这样-
import numpy as np
from tkinter import *
from PIL import Image, ImageTk
def coinFlip():
result = np.random.binomial(1,0.5)
tfield.delete("1.0", "end")
if(result == 1):
tfield.insert(INSERT, " It's ————> HEADS")
i.config(image = heads)
else:
tfield.insert(INSERT, " It's ————> TAILS")
i.config(image = tails)
root = Tk()
root.title("Python Coin Flip")
#load heads image
load = Image.open("head.png")
heads = ImageTk.PhotoImage(load)
#load tails image
load = Image.open("tail.png")
tails = ImageTk.PhotoImage(load)
i = Label(root, image=heads)
i.pack()
root.geometry("500x500")
b1 = Button(root, text="Toss the Coin", font=("Arial", 10), command=coinFlip, bg='teal', fg='white', activebackground="lightblue", padx=10, pady=10)
b1.pack()
#Text Field for Result
tfield = Text(root, width=52, height=5)
tfield.pack()
tfield.insert(INSERT, "Click on the Button.. To Flip the Coin and get the result")
root.mainloop()
程序的最终输出:-
Output For Heads 1
Output For Tails 1
The output of our code – on button click for Coin Flip
结论
就是这样！对于教程。希望你已经学得很好，并使用 Python Tkinter 轻松地编写了一个基于 GUI 的代码。
使用 Python 进行颜色检测——初学者参考
原文：https://www.askpython.com/python/examples/color-detection
你好，程序员朋友们！今天在本教程中，我们将学习如何在 Python 中的 OpenCV 库的帮助下检测图像中的各种颜色。
颜色检测简介
检测图像中任何颜色名称的过程称为颜色检测。对人类来说，这是一项极其简单的任务，但对计算机来说却不那么简单。人类的眼睛和大脑协同工作，将光转化为颜色。信号通过我们眼睛里的光感受器传递到大脑。这种颜色被我们的大脑识别出来。
在这个 Python 颜色检测教程中，我们将创建一个应用程序，让您只需点击它就可以获得颜色的名称。因此，我们需要一个包含颜色名称和值的数据文件。然后我们将计算每种颜色之间的距离，并选择距离最小的颜色。
用于颜色检测的数据集
红、绿、蓝是构成任何可用颜色的三原色。计算机中的每个颜色值都被定义为 0 到 255 之间的一个数字。一种颜色可以有大约 1650 万种不同的表现方式。我们需要使用数据集将每种颜色的值转换成它们的名称。我们将使用包含 RGB 值及其名称的数据集。
导入 OpenCV
第一步是导入所有需要的模块和 OpenCV，然后加载图像，但是要确保图像和代码文件在同一个文件夹中。
import cv2
import numpy as np
import pandas as pd
img = cv2.imread("sample.jpg")
加载“colors.csv”文件
我们利用pandas库对 CSV 这样的数据文件进行操作。而pd.read_csv()函数用于加载和读取 CSV 文件。我们还在索引列表中为每一列指定了一个名称，以便于访问。
index = ["color", "color_name", "hex", "R", "G", "B"]
data = pd.read_csv("colors.csv", names=index, header=None)
创建一个窗口和一个回调函数
首先，我们必须创建一个显示输入图像的新窗口。然后，我们提供了一个回调函数，只有当鼠标事件在图像上发生时，该函数才会被激活。
cv2.namedWindow("Color Detection Window")
cv2.setMouseCallback("Color Detection Window",call_back_function)
但是现在我们要创建一个call_back_function这个名字提到的回调函数。
创建回调函数
让我们来理解这个回调函数将做什么:它将计算我们双击的像素的 rgb 值，并保存鼠标位置的(x，y)坐标。
def call_back_function (event, x,y,flags,param):
if event == cv2.EVENT_LBUTTONDBLCLK:
global b,g,r,xpos,ypos, clicked
clicked = True
xpos = x
ypos = y
b,g,r = img[y,x]
b = int(b)
g = int(g)
r = int(r)
从 rgb 值中提取颜色名称
既然我们已经从图像中提取了 rgb 值，现在我们需要将 rgb 值更改为颜色名称。下面的函数也是如此。
def get_Color_Name(R,G,B):
minimum = 10000
for i in range(len(csv)):
d = abs(R- int(csv.loc[i,"R"])) + abs(G- int(csv.loc[i,"G"]))+ abs(B- int(csv.loc[i,"B"]))
if(d<=minimum):
minimum = d
cname = csv.loc[i,"color_name"]
return cname
为了得到颜色名称，我们计算一个距离(d ),它告诉我们离一个特定的颜色有多近，然后选择一个距离最小的颜色。使用以下公式计算距离:
d = abs(红-红颜色)+(绿-绿颜色)+(蓝-绿颜色)
在窗口上显示结果
我们利用cv2.imshow()函数在我们之前创建的窗口上绘制图像。当用户双击窗口时，在图像上绘制一个矩形，分别使用cv2.rectangle和cv2.putText()函数获得窗口的颜色名称。
while(1):
cv2.imshow("Color Detection Window",img)
if (clicked):
cv2.rectangle(img,(20,20), (750,60), (b,g,r), -1)
text = getColorName(r,g,b)+'R='+str(r)+'G='+ str(g)+'B='+ str(b)
cv2.putText(img, text,(50,50),2,0.8, (255,255,255),2,cv2.LINE_AA)
if(r+g+b>=600):
cv2.putText(img, text,(50,50),2,0.8,(0,0,0),2,cv2.LINE_AA)
clicked=False
if cv2.waitKey(20) & 0xFF ==27:
break
cv2.destroyAllWindows()
样本输出
Color Detection Window Opencv
Detected Red Color Detection
Detected Cyan Color Detection
在另一个图像上输出
Skin Color Detection Image2
结论
今天我们学习了如何使用 Python 编程语言中的 OpenCV 来检测颜色。希望你学到了一些东西！
感谢您的阅读！
Python colorsys 模块
读者朋友们，你们好！在本文中，我们将详细关注 Python colorsys 模块。所以，让我们开始吧！🙂
什么是 colorsys 模块？
Python 为我们提供了不同的模块来测试数据值的功能，并执行操作和表示。Python colorsys 模块就是这样一个模块。
colorsys 模块帮助我们对以下颜色值进行双向转换
- (色调明度饱和度)
- YIQ(亮度(Y)同相正交)
- HSV(色调饱和度值)
- RGB(红、绿、蓝)
所有这些颜色的坐标表示都是浮点值。转换值的允许范围通常分别在 0–1 之间。
如何使用 colorsys 模块？
现在让我们在下一节看看它们之间的相互转换。
1。RGB 到 YIQ 的相互转换
colorsys 模块为我们提供了 rgb_to_yiq()方法，该方法启动 rgb 到亮度(Y)同相正交颜色范围之间的转换。同样，我们需要将三个颜色值作为参数传递给函数，如下所示:
- 红色
- 绿色
- 蓝色
看看下面的语法！🙂
语法:
colorsys.rgb_to_yiq(Red, Green, Blue)
例 1: RGB- > YIQ
在下面的例子中，我们将红色、绿色和蓝色这三个颜色值传递给了 rgb_to_yiq()函数，并实现了 rgb 到 yiq 色阶的转换。
import colorsys
R = 0.1
G = 0.3
B = 0.3
YIQ = colorsys.rgb_to_yiq(R, G, B)
print(YIQ)
输出:
(0.24, -0.11979999999999999, -0.0426)
Python colorsys 模块包括 yiq_to_rgb()函数，用于将亮度(Y)同相正交颜色值转换为 rgb 模式。
语法:
yiq_to_rgb(Y, I, Q)
例二: YIQ- > RGB
我们已经执行了 YIQ 色标值到红绿蓝色标的转换。
import colorsys
Y = 0.1
I = 0.3
Q = 0.3
RGB = colorsys.yiq_to_rgb(Y, I, Q)
print(RGB)
输出:
(0.5711316397228637, 0.0, 0.28013856812933025)
2。HSV 到 RGB 的相互转换
除了 YIQ 和 rgb，colorsys 模块还为我们提供了 hsv_to_rgb(H，S，V)函数来执行 hsv 比例数据到 RGB 比例的转换。
语法:
hsv_to_rgb(H,S,V)
例 1: HSV- > RGB
import colorsys
H = 0.1
S = 0.3
V = 0.3
RGB = colorsys.hsv_to_rgb(H, S, V)
print(RGB)
输出:
(0.3, 0.264, 0.21)
除此之外，colorsys 模块还为我们提供了 rgb_to_hsv(R，G，B)函数来执行 rgb 比例到 hsv 颜色值格式的转换。
例 2: HSV- > RGB
我们利用 rgb_to_hsv()函数实现了 rgb 色标到 hsv 色标的转换。
import colorsys
R = 0.1
G = 0.3
B = 0.3
HSV = colorsys.rgb_to_hsv(R, G, B)
print(HSV)
输出:
(0.5, 0.6666666666666666, 0.3)
3。RGB 到 HLS 的相互转换
使用 Python colorsys 模块，您可以使用 rgb_to_hls()函数轻松执行 RGB 色标到 HLS 色标的转换。
语法:
rgb_to_hls(R, G, B)
举例:
在本例中，我们将 RGB 色阶值转换为 HLS 格式。
import colorsys
R = 0.1
G = 0.3
B = 0.3
HLS = colorsys.rgb_to_hls(R, G, B)
print(HLS)
输出:
如下所示，在上面的例子中也是如此，转换范围通常只限于 0 到 1 的范围。
(0.5, 0.2, 0.49999999999999994)
结论
如果你遇到任何问题，欢迎在下面评论。更多与 Python 编程相关的帖子，请继续关注我们。
在那之前，学习愉快！！🙂
参考
- Python colorsys 模块— 文档
如何用 Python 合并 CSV 文件？
原文：https://www.askpython.com/python-modules/pandas/combine-csv-files-using-python
通常在处理 CSV 文件时，我们需要处理大型数据集。根据数据分析的要求，我们可能会发现所有需要的数据都不会出现在一个 CSV 文件中。然后，需要合并多个文件以获得所需的数据。然而，将所需的列从一个文件复制粘贴到另一个文件，以及从大型数据集中复制粘贴，并不是解决这个问题的最佳方法。
为了解决这个问题，我们将学习如何使用熊猫的append、merge和concat方法来合并 CSV 文件。
将多个 CSV 文件组合在一起
首先，让我们创建将要使用的示例 CSV 文件。
CSV File 1
CSV File 2
CSV File 3
请注意，所有三个文件都有相同的列或标题，即、【姓名】、、【年龄】、、【分数】、。此外，文件 1 和文件 3 的‘name’列有一个公共条目，即 Sam ，但是这些文件中的其余值是不同的。****
注意，在下面的例子中，我们认为所有的 CSV 文件都与 Python 代码文件在同一个文件夹中。如果不是这样，请在自己尝试示例时相应地指定路径。所有的例子都记录在一本笔记本上。
在 Python 中组合 CSV 文件的不同方法
开始之前，我们将创建一个 CSV 文件列表，这些文件将在下面的示例中使用，如下所示:
import glob
# list all csv files only
csv_files = glob.glob('*.{}'.format('csv'))
csv_files
输出:
['csv_file_1.csv', 'csv_file_2.csv', 'csv_file_3.csv']
方法 1: append()
我们来看看这里的 append 方法合并三个 CSV 文件。
import pandas as pd
df_csv_append = pd.DataFrame()
# append the CSV files
for file in csv_files:
df = pd.read_csv(file)
df_csv_append = df_csv_append.append(df, ignore_index=True)
df_csv_append
输出:
append方法，顾名思义，将每个文件的数据帧附加到前一个文件的末尾。在上面的代码中，我们首先创建一个数据帧来存储名为 df_csv_append 的结果。然后，我们遍历列表，读取每个 CSV 文件，并将其附加到数据帧 df_csv_append 。
方法 2: concat()
另一种用于合并 CSV 文件的方法是熊猫concat()方法。该方法需要一系列对象作为参数，因此我们首先为每个 CSV 文件创建一系列数据框对象，然后对其应用concat()方法。
import pandas as pd
df_csv_concat = pd.concat([pd.read_csv(file) for file in csv_files ], ignore_index=True)
df_csv_concat
编写这段代码的一种更容易理解的方式是:
l = []
for f in csv_files:
l.append(pd.read_csv(f))
df_res = pd.concat(l, ignore_index=True)
df_res
以上两个代码在执行时会产生如下所示的相同输出。
注意，产生的数据帧与append()方法的数据帧相同。
方法 3:合并()
merge方法用于连接非常大的数据帧。一次可以对两个数据框执行连接。我们可以指定执行连接所基于的键。
为避免重复行，为数据框中的每个条目选择一个唯一的键是一种很好的做法。我们还可以指定希望执行的连接类型，即、、、、、、、或、【交叉】、连接。
我们需要首先将每个 CSV 文件读入一个单独的数据帧。
import pandas as pd
df1 = pd.read_csv('csv_file_1.csv')
df2 = pd.read_csv('csv_file_2.csv')
df3 = pd.read_csv('csv_file_3.csv')
df1
df2
df3
连接 df1 和 df2:
df_merged = df1.merge(df2, how='outer')
df_merged
输出:
Merge Output 1
基于密钥“name”连接 df1 和 df3。
df_merged = df1.merge(df3, on="name", how='outer')
df_merged
输出:
Merge Output 2
df1 和 df3 都有一个名为“Sam”的条目，并且两者的年龄和分值不同。因此，在结果数据帧中，存在用于表示来自 df1 和 df3 的条目的列。由于约翰和鲍勃在数据帧 df1 和 df3 中不常见，因此它们的值在任何适用的情况下都是 NaN。
结论
在本文中，我们学习了 Pandas 方法，即 concat 、 merge 和 append ，以及如何使用它们通过 Python 组合 CSV 文件。
参考
