AskPython-博客中文翻译-七-
AskPython 博客中文翻译（七）
绘制数学函数——如何用 Python 绘制数学函数？
原文：https://www.askpython.com/python/examples/plot-mathematical-functions
大家好！在本教程中，我们将学习如何使用 Python 绘制数学函数。所以让我们开始吧。
先决条件
为了使用 Python 绘制不同的数学函数，我们需要以下两个 Python 库:
1.NumPy
NumPy 是一个 Python 库，支持多维数组&矩阵，并提供广泛的数学函数来操作 NumPy 数组&矩阵。它是科学计算最基本的库之一。我们可以使用下面的命令在本地计算机上安装 NumPy。
> python -m pip install numpy
2. Matplotlib
Matplotlib 是一个 Python 库，广泛用于各种类型的绘图。使用 Matplotlib，我们可以非常容易地绘制静态和交互式可视化。我们可以使用以下命令在本地计算机上安装 Matplotlib。
> python -m pip install matplotlib
绘制数学函数的步骤
首先在主 Python 程序中导入numpy和matplotlib.pyplot模块(。py)或者 Jupyter 笔记本(。ipynb)使用以下 Python 命令。
import numpy as np
import matplotlib.pyplot as plt
对于所有的绘图，除了在各自的绘图中使用特定的数字数学函数外，我们将遵循几乎相同的步骤。
1.Plot (y = x)恒等函数
x = np.arange(0, 11, 1)
y = x
print('Values of x: ', x)
print('Values of y: ', y)
plt.plot(x, y)
plt.title("Identity Function")
plt.xlabel("Values of x")
plt.ylabel("Values of y")
plt.show()
输出:
Values of x: [ 0 1 2 3 4 5 6 7 8 9 10]
Values of y: [ 0 1 2 3 4 5 6 7 8 9 10]
Identity Function Plot
2.plot(y = a . x²+b . x²+c)二次函数
x = np.arange(-11, 11, 1)
a = 2
b = 9
c = 10
y = a*(x**2) + b*x + c
print('Values of x: ', x)
print('Values of y: ', y)
plt.plot(x, y)
plt.title("Quadratic Function")
plt.xlabel("Values of x")
plt.ylabel("Values of y")
plt.show()
输出:
Values of x: [-11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 7 8 9 10]
Values of y: [153 120 91 66 45 28 15 6 1 0 3 10 21 36 55 78 105 136 171 210 253 300]
Quadratic Function Plot
3.plot(y = a . x³+b . x²+c . x+d)三次函数
x = np.arange(-11, 11, 1)
a = 2
b = 3
c = 4
d = 9
y = a*(x**3) + b*(x**2) + c*x + d
print('Values of x: ', x)
print('Values of y: ', y)
plt.plot(x, y)
plt.title("Cubic Function")
plt.xlabel("Values of x")
plt.ylabel("Values of y")
plt.show()
输出:
Values of x: [-11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 7 8 9 10]
Values of y: [-2334 -1731 -1242 -855 -558 -339 -186 -87 -30 -3 6 9 18 45 102 201 354 573 870 1257 1746 2349]
Cubic Function Plot
4.Plot (y = ln(x)或 log [e] (x))自然对数函数
x = np.arange(1, 11, 0.001)
y = np.log(x)
print('Values of x: ', x)
print('Values of y: ', y)
plt.plot(x, y)
plt.title("Natural logarithm Function")
plt.xlabel("Values of x")
plt.ylabel("Values of y")
plt.show()
输出:
Values of x: [ 1\. 1.001 1.002 ... 10.997 10.998 10.999]
Values of y: [0.00000000e+00 9.99500333e-04 1.99800266e-03 ... 2.39762251e+00 2.39771344e+00 2.39780436e+00]
Natural Logarithm Function Plot
5.Plot (y = log [10] x)常用/十进制对数函数
x = np.arange(1, 11, 0.001)
y = np.log10(x)
print('Values of x: ', x)
print('Values of y: ', y)
plt.plot(x, y)
plt.title("Common logarithm Function")
plt.xlabel("Values of x")
plt.ylabel("Values of y")
plt.show()
输出:
Values of x: [ 1\. 1.001 1.002 ... 10.997 10.998 10.999]
Values of y: [0.00000000e+00 4.34077479e-04 8.67721531e-04 ... 1.04127423e+00 1.04131372e+00 1.04135320e+00]
Common Logarithm Function Plot
6.Plot (y = e^x )自然指数函数
x = np.arange(-11, 11, 0.01)
y = np.exp(x)
print('Values of x: ', x)
print('Values of y: ', y)
plt.plot(x, y)
plt.title("Natural exponential Function")
plt.xlabel("Values of x")
plt.ylabel("Values of y")
plt.show()
输出:
Values of x: [-11\. -10.99 -10.98 ... 10.97 10.98 10.99]
Values of y: [1.67017008e-05 1.68695557e-05 1.70390975e-05 ... 5.81045934e+04 5.86885543e+04 5.92783841e+04]
Natural Exponential Function Plot
7.Plot (y = a^x )一般指数函数
x = np.arange(-11, 11, 0.01)
a = 8
y = a**x
print('Values of x: ', x)
print('Values of y: ', y)
plt.plot(x, y)
plt.title("General exponential Function")
plt.xlabel("Values of x")
plt.ylabel("Values of y")
plt.show()
输出:
Values of x: [-11\. -10.99 -10.98 ... 10.97 10.98 10.99]
Values of y: [1.16415322e-10 1.18861455e-10 1.21358987e-10 ... 8.07043896e+09 8.24001604e+09 8.41315629e+09]
General Exponential Function Plot
8.Plot (y =符号(x))希格诺函数
x = np.arange(-11, 11, 0.001)
y = np.sign(x)
print('Values of x: ', x)
print('Values of y: ', y)
plt.plot(x, y)
plt.title("Signum Function")
plt.xlabel("Values of x")
plt.ylabel("Values of y)")
plt.show()
输出:
Values of x: [-11\. -10.999 -10.998 ... 10.997 10.998 10.999]
Values of y: [-1\. -1\. -1\. ... 1\. 1\. 1.]
Signum Function Plot
9.Python 中的 Plot (y = a.sin(b.x + c))正弦函数
x = np.arange(-11, 11, 0.001)
a = 5
b = 3
c = 2
y = a*np.sin(b*x + c)
print('Values of x: ', x)
print('Values of y: ', y)
plt.plot(x, y)
plt.title("Sinusoidal Function")
plt.xlabel("Values of x")
plt.ylabel("Values of y")
plt.show()
输出:
Values of x: [-11\. -10.999 -10.998 ... 10.997 10.998 10.999]
Values of y: [ 2.02018823 2.03390025 2.04759397 ... -2.10016104 -2.11376421 -2.12734835]
Sinusoidal Function Plot
10. Plot (y = sinc(x)) Sinc function
x = np.arange(-11, 11, 0.01)
y = np.sinc(x)
print('Values of x: ', x)
print('Values of y: ', y)
plt.plot(x, y)
plt.title("Sinc function")
plt.xlabel("Values of x")
plt.ylabel("Values of y")
plt.show()
输出:
Values of x: [-11\. -10.99 -10.98 ... 10.97 10.98 10.99]
Values of y: [1.41787526e-16 9.09768439e-04 1.82029537e-03 ... 2.73068428e-03
1.82029537e-03 9.09768439e-04]
Sinc Function Plot
11.Plot (y = cosh(x))双曲函数
x = np.arange(-11, 11, 0.001)
y = np.cosh(x)
print('Values of x: ', x)
print('Values of y: ', y)
plt.plot(x, y)
plt.title("Hyperbolic Function")
plt.xlabel("Values of x")
plt.ylabel("Values of y")
plt.show()
输出:
Values of x: [-11\. -10.999 -10.998 ... 10.997 10.998 10.999]
Values of y: [29937.07086595 29907.14875865 29877.2565585 ... 29847.39423524 29877.25655813 29907.14875828]
Hyperbolic Cosine Function Plot
总结
在本教程中，我们学习了如何使用 Numpy 和 Matplotlib 库绘制不同类型的数学函数。希望你已经了解了不同数学函数的作图过程，准备好自己实验了。感谢阅读！请继续关注我们，获取关于 Python 编程的惊人学习资源。
Plotly 等高线图-完整指南
原文：https://www.askpython.com/python-modules/plotly-contour-plot
在本文中，我们将学习 Python 的 Plotly 库，以及创建迷人等高线图的各种方法。我们将看到各种等高线图的例子，每个例子都有详细的代码分析。我们还将学习多种方法来定制一个人的轮廓图。所以，让我们从基础开始。
什么是等高线图？
轮廓是三维表面的二维描述，包括关节和曲线。它是在等高线函数(Z)的帮助下绘制的，等高线函数是两个变量(X 轴和 Y 轴坐标)的函数。
什么是 Plotly 库？
Plotly 提供了各种数据可视化库来绘制图表和图形。我们可以从大量的绘图库和工具中进行选择，这些工具专用于创建各种不同类型的图表。在本文中，我们将主要使用单个导入包和单个绘图函数。这就是我们在使用 Plotly 时获得的易用性。
安装 Plotly
要在您的系统中安装 Plotly ，请键入以下命令:
Pip install plotly==5.5.0
使用 Plotly 创建等高线图
让我们用 Plotly 来创建这些等高线图。
基本等高线图
首先，我们将使用 Plotly 绘制一个简单的等高线图。首先需要的是导入库。
下面的导入包 就像一个通用的 Plotly 语法，它完成了大部分工作。
import plotly.graph_objects as grob
Plotly 轮廓函数
轮廓函数使用初始化数据来绘制曲线。我们必须向它提供 x，y 坐标和 z 函数。
创建等高线图有两个部分:数据初始化和使用等高线函数创建对象，有多种不同的方法来完成这两个步骤，每种方法都会影响等高线。为了简单起见，让我们假设我们的坐标是用变量‘data’初始化的。
如下所示，代码告诉编译器获取轮廓的 z 函数的数据值。
grid_fig = grob.Figure(data =
grob.Contour(z = data))
让我们看几个程序例子来理解所有的方法。
使用坐标数组作为 z 函数绘制等高线图:
import plotly.graph_objects as grob
# This 5X5 matrix stores the coordinate values required for z function
data = [[6, 4, 5, 5, 6],
[1, 5, 5, 4, 6],
[5, 4, 4, 6, 4],
[7, 8, 4, 3, 3]]
grid_fig = grob.Figure(data =
grob.Contour(z = data))
grid_fig.show()
输出:
用特定的 X，Y，Z 值绘制等值线图
import plotly.graph_objects as grob
fig = grob.Figure(data =
grob.Contour(
z=[[10, 10.625, 12.5, 15.625, 20],
[5.625, 6.25, 8.125, 11.25, 15.625],
[2.5, 3.125, 5., 8.125, 12.5],
[0.625, 1.25, 3.125, 6.25, 10.625],
[0, 0.625, 2.5, 5.625, 10]],
x=[-3, -2, -1, 0, 1], # horizontal axis
y=[0, 1, 3, 4, 5] # vertical axis
))
fig.show()
输出:
这里的 z 函数是一个类似于前面例子的坐标数组。使用 Numpy 导入包进一步允许我们为等高线图使用更复杂的数据。在下一个例子中，我们将观察如何为 z 函数设置一个三角恒等式。
使用 Numpy 的等高线图
import plotly.graph_objects as grob
import numpy as nump
# variables are initialised with x,y co-ordinates
cordof_x = nump.arange(0, 23, 0.5)
cordof_y = nump.arange(0, 46, 0.3)
# A mesh is created with the given co-ordinates by this numpy function
[X, Y] = nump.meshgrid(cordof_x, cordof_y)
contour_function = nump.cos(X*(1/8)) + nump.sin(Y*(1/16))
contour_plot = grob.Figure(data =
grob.Contour(x = cordof_x, y = cordof_y, z = contour_function))
contour_plot.show()
输出:
希望上面的例子已经完全清楚了基本等高线图是如何创建的。到目前为止，我们已经学习了为等高线图创建输入和 z 函数的不同方法。现在，我们将冒险对我们的轮廓图的样式方面。
自定义 Plotly 等高线图
在本文的这一部分，我们将主要讨论轮廓图的前端方面或简单的样式方面。
设置绘图的颜色和比例
让我们以一个程序为例，其中我们有一个初始化为 z 函数的坐标数组。现在，在我们的等高线图中，如果我们想用一个自定义比例来表示我们的图，我们可以这样做:
dx=40,
x0=10,
dy=10,
y0=20,
现在，在比例设置好之后，让我们假设我们想要改变我们情节的主题。我们可以通过以下方式做到这一点:
colorscale='hot',
运筹学
colorscale='electric',
为了添加一些最后的润色，我们还可以添加一个色标到我们的绘图中。这可以通过以下方式实现:
contours=dict(
start=0,
end=14,
size=2,
),
让我们把所有的东西都放进一个程序里，观察它是如何运行的。
import plotly.graph_objects as grob
grid_fig = grob.Figure(data =
grob.Contour(
z=[[10, 10.625, 12.5, 15.625, 20],
[5.625, 6.25, 8.125, 11.25, 15.625],
[2.5, 3.125, 5., 8.125, 12.5],
[0.625, 1.25, 3.125, 6.25, 10.625],
[0, 0.625, 2.5, 5.625, 10]],
dx=40,
x0=10,
dy=10,
y0=20,
colorscale='electric',
contours=dict(
start=0,
end=14,
size=2,
),
))
grid_fig.show()
输出:
创建高级等高线图
到目前为止，我们已经了解了使用 Plotly 绘制等高线图的基本方面。现在，我们将把到目前为止所学的一切放在一起，创建一个高级的等值线图，以便我们能够了解为实际应用创建的等值线图是怎样的。
以下代码:
import numpy as np
import math
import plotly.graph_objects as grob
x = np.linspace(-np.pi, np.pi, num=80)
y = x
def pf(a, b):
return math.sin(b) / (1 + a**2)
f = np.empty((len(x), len(y)))
for i in range(len(x)):
for j in range(len(y)):
f[i,j] = pf(x[i], y[j])
grid_fig = grob.Figure()
grid_fig.add_trace(grob.Contour(z=f, x=x, y=y,
contours_coloring='lines',
line_width=1.5,
contours={"showlabels":True,
"labelfont":{"size":10,
"color":'red'}}))
grid_fig.update_layout(
{ "title": {"text": "<b>Advanced Contour Plot</b>", "x": 0.5, "y": 0.9, "font": {"size": 14} },
"showlegend": True,
"xaxis": {"title": "scale of x ----------------------->", "showticklabels":True, "dtick": 1},
"yaxis": {"title": "scale of y ------------>", "showticklabels": True, "dtick": 1},
"autosize":False,
"width":1200,
"height":600})
grid_fig.show()
输出:
结论
在这篇文章中，我们学习了 Plotly 的基本概念，以及如何根据我们的需求定制它。我们知道如何将特定的坐标值或坐标数组用于我们的输入法，以及 numpy 的集成如何支持三角函数的等高线绘制。最后，我们还观察了如何编写高级剧情。希望这篇文章能帮助你更好地学习和理解 Plotly。
使用 Plotly Dash 的 Python 仪表板[已实现]
原文：https://www.askpython.com/python-modules/plotly-dash-dashboard
Python 中的仪表盘是在一个地方显示的图表集合，以便更好地理解所分析的数据。绘图集包括但不限于条形图、直方图、饼图、折线图、等高线图、阴影图等。仪表板可以包括显示在一个屏幕上的不同图形的组合，也可以包括多个同类图形。
Python 提供了多个库来创建情节和支线情节，但在本文中，我们将严格使用为制作仪表板而创建的库——Plotly Dash。
也读:巨蟒精雕细琢完整教程
Dash 是什么？
Dash 是一个 Plotly 产品，用于创建绘图并通过基于 web 的 API 进行渲染。Plotly 网站表示，Dash 应用可以轻松实现 Tableau 和 PowerBI 难以实现的任务结果。这使得我们选择 Dash 作为我们在 Python 中创建仪表板的首选工具。
创建仪表板
在这篇文章中，我们将创建一个仪表板，分析 2020 年股票市场的崩溃及其复苏所造成的新冠肺炎。这里使用的例子采用了特定于索引的方法。我们使用每日时间段内 Nifty50 的 OHLC 数据。一旦绘制了仪表板，我们将讨论通过绘图观察到的见解。
在 Python 中创建仪表板有三个主要步骤:
- 导入必要的包
- 获取将被绘制的原始数据
- 初始化应用程序
安装必要的库
创建仪表板图需要主仪表板包及其子包。本文中的示例需要 3 个 dash 子包和一个 Numpy 包来呈现原始数据。让我们看看如何安装和配置这些包。要安装它们，请在终端中键入以下命令。
pip install dash
另一个需要的主要包装是熊猫。数据框的数学计算需要此 python 库。要安装它，请键入以下命令:
pip install pandas
注意:创建仪表板需要另外三个 dash 子包——dash html 组件、dash 渲染器和 dash 核心组件(dcc)。
手动安装它们很麻烦，所以我们建议在 Pycharm 或 Jupyter Notebooks 这样的 IDE 上执行这个例子。为了便于使用，我们将继续使用 Pycharm。在 Pycharm 中安装这些子包很简单，按照下面的步骤操作:
-
创建新项目。
-
进入文件>设置>项目:'项目名称' > Python 解释器。
单击“+”号。(如果“+”号无效，从上面的下拉列表中选择基本解释器，然后单击“+”号添加新的解释器。
将打开一个新窗口，显示解释器列表。在搜索框中键入解释器，然后单击安装包。您要查找的关键字是(“dash-html-components”、“dash-core-components”和“dash-renderer”)
为仪表板创建地块
一旦安装和配置了所有必要的库，我们将转移到编码部分。
导入数据
下面的库是我们在整个项目中需要的。
import dash
from dash import dcc
from dash import html
import pandas as pd
初始化和操作数据
对于这个例子，我们获取了 2020-2021 年 12 月 Nifty 50 指数的 OHLC(开盘-盘高-盘低-收盘)数据。我们将数据加载到数据框架——“数据”中。第二行将“日期”格式从缩写改为数字。
data = pd.read_csv("nifty 2020 crash.csv")
data['Date'] = pd.to_datetime(data['Date']).dt.strftime('%d-%m-%Y')
初始化应用程序
离线 API 的 dash 应用程序在这里初始化。当该应用程序运行时，绘图将被渲染并广播到本地服务器端口，可通过本地浏览器访问。下面的示例代码在服务器中绘制了一个图表，即指数的每日最高价格。
app = dash.Dash(__name__)
app.layout=html.Div(
children=[
html.H1(children="Nifty 50 Crash and Recovery",),
html.P(
children="Analyzing day wise high and low prices of Nifty50 when first wave of Covid-19 hit.",
),
dcc.Graph(
figure={
"data":[
{
"x":data["Date"],
"y":data["High"],
"type":"lines",
},
],
"layout":{"title":"Day-wise highest prices of index"},
},
),
]
if __name__ == "__main__":
app.run_server(debug=True)
到目前为止，您一定已经理解了如何使用您想要的数据部署 dash 应用程序。现在，让我们将所有部分放在一个程序中，创建一个 Nifty50 崩溃和恢复分析仪表板。
代码如下:
# importing packages
import dash
from dash import dcc
from dash import html
import pandas as pd
# initialisation and manipulation of data
data = pd.read_csv("nifty 2020 crash.csv")
data['Date'] = pd.to_datetime(data['Date']).dt.strftime('%d-%m-%Y')
app = dash.Dash(__name__)
# Initialising the application.
app.layout=html.Div(
children=[
html.H1(children="Nifty 50 Crash and Recovery",),
html.P(
children="Analyzing day wise high and low prices of Nifty50 when first wave of Covid-19 hit.",
),
dcc.Graph(
figure={
"data":[
{
"x":data["Date"],
"y":data["High"],
"type":"lines",
},
],
"layout":{"title":"Day-wise highest prices of index"},
},
),
dcc.Graph(
figure={
"data":[
{
"x":data["Date"],
"y":data["Low"],
"type":"lines",
},
],
"layout": {"title": "Day-wise lowest prices of index"},
},
),
dcc.Graph(
figure={
"data": [
{
"x": data["Date"],
"y": data["Close"],
"type": "lines",
},
],
"layout": {"title": "Day-wise closing prices of index"},
},
),
dcc.Graph(
figure={
"data": [
{
"x": data["Date"],
"y": data["Open"],
"type": "lines",
},
],
"layout": {"title": "Day-wise opening prices of index"},
},
),
] )
# deploying server
if __name__ == "__main__":
app.run_server(debug=True)
输出:
洞察力
所有发生在新冠肺炎之前的股市崩盘都见证了一个持续多年的缓慢经济复苏过程。但在上面的图表中，我们可以观察到反弹比预期更快，在短短几个月的时间里，整个市场飙升至新高。这使得得出一个结论:
- 市场参与者愿意在市场上收回他们的钱。
- 从复苏的速度来看，很明显，即使是大型金融机构也准备在崩盘后重新投资市场。
- 它为相信逢低买入的投资者提供了一个学习的例子。
结论
总之，我们可以从这个例子中学到一些重要的东西。观察 dash 是多么强大和高效，这个工具可以帮助轻松地创建复杂的数据密集型图表。您可以在仪表板中创建图形、图表，甚至它们的组合，甚至可以通过这个平台在基于 web 的 API 上广播。
从这篇文章中，我们了解了使用 Dash 创建仪表板的基本知识，Dash 既可以轻松实现，也可以作为一个很好的学习工具。希望这篇文章能为你学习 Dash 的高级概念提供一个足智多谋的学习工具。
参考
https://plotly.com/python/line-charts/#line-charts-in-dash
4 个简单的 Python 绘图库及示例
原文：https://www.askpython.com/python-modules/plotting-libraries-python
Python 提供了许多交互式绘图包，通过它们我们可以制作出一些最漂亮、最可定制的图形和图表。在本文中，我们将了解一些用于绘图的 python 模块，以及如何用它们编写基本图表。这些是一些最广泛使用的 python 包，可用于所有平台(如 Windows、Linux Mac)。
1.matplotlib–最早的绘图库
如果你习惯了 Python，你一定听说过 Matplotlib。它是用于绘图的最古老的 python 库之一，由 Michael Droettboom 在 18 年前构建，最初由 John D. Hunter 编写，但在 Python 学习者和数据分析师中仍然非常流行。它提供了一个面向对象的应用程序接口，使 matplotlib 绘图更容易在各种应用程序上运行。
让我们看一些使用 matplotlib 绘制图表的代码:
折线图
import matplotlib.pyplot as plt
from numpy import random
var1=random.randint(100, size=(100))
var2=random.randint(100, size=(100))
var1.sort()
var2.sort()
plt.plot(var1,var2)
plt.show()
Line chart
直方图
import matplotlib.pyplot as plt
import numpy as np
from numpy import random
hist_var = np.random.normal(170, 10, 250)
plt.hist(hist_var)
plt.show()
Histogram
2.希伯恩
它是一个基于 matplotlib 的子模块，用于从统计数据中创建图表。Seaborn 允许程序员直接从数组和数据框中提取数据，并让他们将统计数据可视化成图形。为了允许可视化，它在 Matplotlib 框架下工作，并且对于数据集成，它非常依赖 pandas。
为了理解 seaborn 是如何工作的，我们将研究一个示例代码。
分散
import pandas as pand
from matplotlib import pyplot as plt
import seaborn as sns
scores = pand.read_csv('scores.csv', encoding='unicode_escape', index_col=0)
def scatter_plot():
sns.lmplot(x='Attack', y='Defense', data=scores,
fit_reg=False, # It removes a diagonal line that remains by default
hue='Stage'
)
plt.show()
scatter_plot()
Seaborn Scatter
上面的代码绘制了我们从数据框“scores.csv”中获取的攻击和防御值的散点图。方法“scatter_plot()”包含 seaborn 函数“sns.lmplot”，该函数通过将“攻击”作为 x 轴，将“防御”作为 y 轴来绘制散点图。
让我们看看另一个示例代码。我们将使用 seaborn 绘制一个箱线图，使用与上一个示例中相同的一组值。
箱式打印
import pandas as pand
from matplotlib import pyplot as plt
import seaborn as sns
scores = pand.read_csv('scores.csv', encoding='unicode_escape', index_col=0)
sns.boxplot(data=scores)
plt.show()
Seaborn Boxplot
3.Plotly
Plotly 是 2012 年创建的数据可视化工具。在本文中，我们将学习 Plotly 的一个子模块，称为 Plotly Express 。这个子模块是一个 Python 库，目的是通过一个函数调用来创建图形可视化。另一方面，它也提供了一个很好的基础来为媒体和通信创建定制的图形。
让我们看一个 Plotly 代码示例，演示如何通过单个函数调用创建简单的图表。
import plotly.express as px
def linechart():
df_india = px.data.gapminder().query("country=='India'")
fig = px.line(df_india, x="year", y="lifeExp", title='Average life span in India:')
fig.show()
def scatter():
# x and y given as array_like objects
import plotly.express as px
fig = px.scatter(x=[5, 1, 3, 4, 3], y=[1, 5, 4, 13, 19])
fig.show()
def barplot():
import plotly.express as px
data_Japan = px.data.gapminder().query("country == 'Japan'")
fig = px.bar(data_Japan, x='year', y='pop')
fig.show()
linechart()
barplot()
scatter()
在上面的代码中，程序有三个不同的方法函数被一起调用。每个方法函数在被调用时都会为用户绘制一个图表。如果我们仔细观察，每个方法函数都有不同的输入方法。第一个函数从 Plotly express 数据库加载数据。第二个函数可视化了从两个不同数组中获取的值的散点图。第三个函数类似于第一个函数，它从 Plotly express 数据库加载数据，然后绘制条形图。
Plotly Line chart
Plotly Barchart
Plotly Scatter chart
4.破折号
Dash 是一个 Plotly 框架，允许我们制作 web 应用程序，并允许我们将图形、文本和控件链接在一起。这个子模块主要帮助管理应用程序前端的各个方面，比如它的布局和样式。最终的结果是一个 flask 应用程序，它可以很容易地部署到各种 web 托管平台上。
让我们看一些它的代码来加深理解。第一个程序从 Plotly gapminder 数据库绘制预期寿命线图。它描绘了所选大陆上所有国家的预期寿命。
折线图
import dash
from dash import dcc
from dash import html
from dash.dependencies import Input, Output
import plotly.express as px
frame_data = px.data.gapminder()
every_continent = frame_data.continent.unique()
app = dash.Dash(__name__)
app.layout = html.Div([
dcc.Checklist(
id="checklist",
options=[{"label": x, "value": x}
for x in every_continent],
value=every_continent[3:],
labelStyle={'display': 'inline-block'}
),
dcc.Graph(id="lineChart"),
])
@app.callback(
Output("lineChart", "figure"),
[Input("checklist", "value")])
def update_line_chart(continents):
data_mask = frame_data.continent.isin(continents)
figure = px.line(frame_data[data_mask],
x="year", y="lifeExp", color='country')
return figure
app.run_server(debug=True)
Dash – Line chart
散点图
下面的代码演示了如何在 Python 中使用 dash 绘制散点图。这里，我们使用 iris 数据库作为输入数据框架。虹膜数据库是一个模式识别数据集，包含三种不同种类的花的花瓣大小。这个程序将绘制一个散点图的花瓣大小的数据作为输入。
import dash
from dash import dcc
from dash import html
from dash.dependencies import Input, Output
import plotly.express as px
frame_data = px.data.iris()
app = dash.Dash(__name__)
app.layout = html.Div([
dcc.Graph(id="plotis_scatter"),
html.P("Width of Petal:"),
dcc.RangeSlider(
id='range-slider',
min=0, max=2.5, step=0.1,
marks={0: '0', 2.5: '2.5'},
value=[0.5, 2]
),
])
@app.callback(
Output("plotis_scatter", "figure"),
[Input("range-slider", "value")])
def update_bar_chart(slider_range):
low, high = slider_range
damask = (frame_data['petal_width'] > low) & (frame_data['petal_width'] < high)
figure = px.scatter(
frame_data[damask], x="sepal_width", y="sepal_length",
color="species", size='petal_length',
hover_data=['petal_width'])
return figure
app.run_server(debug=True)
Dash Scatter chart
结论
本文旨在解释 Python 可用的重要绘图工具。虽然这些 python 库在数据科学领域得到了广泛的应用，但我们试图以一种简单易学的方式提供概念和代码，这样即使是初学者也能掌握它们。希望本文能够帮助您理解本文中解释的所有库的基本概念——Matplotlib、Seaborn、Plotly、Dash。
Python 中的+=运算符——完全指南
原文：https://www.askpython.com/python/examples/plus-equal-operator
在这一课中，我们将看看 Python 中的 +=操作符，并通过几个简单的例子来看看它是如何工作的。
运算符“+=”是加法赋值运算符的简写。它将两个值相加，并将总和赋给一个变量(左操作数)。
让我们看三个例子来更好地理解这个操作符是如何工作的。
1.用+=运算符将两个数值相加
在下面提到的代码中，我们用初始值 5 初始化了变量 X，然后给它加上值 15，并将结果值存储在同一个变量 X 中。
X = 5
print("Value Before Change: ", X)
X += 15
print("Value After Change: ", X)
代码的输出如下所示:
Value Before Change: 5
Value After Change: 20
2.添加两个字符串
S1 = "Welcome to "
S2 = "AskPython"
print("First String : ", S1)
print("Second String: ", S2)
S1+=S2
print("Final String: ", S1)
在上面提到的代码中，我们初始化了两个变量 S1 和 S2，初始值分别为“Welcome to”和“AskPython”。
然后，我们使用'+= '运算符将两个字符串相加，该运算符将连接字符串的值。
代码的输出如下所示:
First String : Welcome to
Second String: AskPython
Final String: Welcome to AskPython
3.理解 Python 中“+=”运算符的结合性
“+=”运算符的结合性属性是从右向左的。让我们看看下面提到的示例代码。
X = 5
Y = 10
X += Y>>1
print(X)
我们初始化了两个变量 X 和 Y，初始值分别为 5 和 10。在代码中，我们将 Y 的值右移 1 位，然后将结果添加到变量 X，并将最终结果存储到 X。
输出结果是 X = 10，Y = 10。
结论
恭喜你！您刚刚学习了 python 中的'+= '操作符，还学习了它的各种实现。
喜欢这个教程吗？无论如何，我建议你看一下下面提到的教程:
感谢您抽出时间！希望你学到了新的东西！！😄
Python 中的多态性
原文：https://www.askpython.com/python/oops/polymorphism-in-python
多态性意味着具有生动的或不同的形式。在编程领域，多态性指的是同名函数携带不同功能的能力。它创建了一个可以使用多种对象形式的结构。
这允许函数/参数在不同时间使用不同类型的实体。
在面向对象编程中，多态性允许引用特定类的特定对象以类似的方式使用，就好像它是引用完全不同的类的不同对象一样。
Polymorphism In Python
用类在 Python 中实现多态性
Python 可以使用不同类型的类，以同样的方式，使用多态性。为了达到这个目的，我们可以创建一个循环来遍历一组对象。Post which，您可以调用这些方法，而不必查看对象所属的类的类型。
示例:类和对象的多态性
class Rabbit():
def age(self):
print("This function determines the age of Rabbit.")
def color(self):
print("This function determines the color of Rabbit.")
class Horse():
def age(self):
print("This function determines the age of Horse.")
def color(self):
print("This function determines the color of Horse.")
obj1 = Rabbit()
obj2 = Horse()
for type in (obj1, obj2): # creating a loop to iterate through the obj1, obj2
type.age()
type.color()
输出:
这个函数决定了兔子的年龄。
此功能决定兔子的颜色。
此功能决定马的年龄。
这个函数决定了马的颜色。
用继承在 Python 中实现多态性
我们将在派生类中定义与基类中的函数同名的函数。这里，我们重新实现了派生类中的函数。在派生类中重新实现一个函数的现象被称为方法覆盖。
示例:带有继承的多态性
class Animal:
def type(self):
print("Various types of animals")
def age(self):
print("Age of the animal.")
class Rabbit(Animal):
def age(self):
print("Age of rabbit.")
class Horse(Animal):
def age(self):
print("Age of horse.")
obj_animal = Animal()
obj_rabbit = Rabbit()
obj_horse = Horse()
obj_animal.type()
obj_animal.age()
obj_rabbit.type()
obj_rabbit.age()
obj_horse.type()
obj_horse.age()
输出:
各种类型的动物
动物的年龄。
各种类型的动物
年龄的兔子。
各种类型的动物
马的年龄。
推荐阅读:
编译时多态还是方法重载？
与许多其他流行的面向对象编程语言(如 Java)不同，Python 不支持编译时多态性或方法重载。如果一个类或 Python 脚本有多个同名的方法，最后一个定义的方法将覆盖前面的方法。
Python 不对方法签名使用函数参数，这就是为什么 Python 不支持方法重载。
Python 中的运算符重载
Python 支持运算符重载。这是另一种类型的多态性，其中操作符根据操作数的类型表现不同。
- +运算符将两个数相加并连接两个字符串
- *运算符将两个数字相乘，当与字符串和 int 一起使用时，将字符串重复给定的 int 次，并将它们连接起来。
阅读 Python 中的操作符重载。
多态性的优势
- 一次编写的代码和类可以多次重用和实现。
- 它有助于减少不同功能和对象行为之间的耦合。
参考
- Python 面向对象编程
- Python 函数
Python 中的多项式回归–Python 中的完整实现
原文：https://www.askpython.com/python/examples/polynomial-regression-in-python
欢迎阅读这篇关于机器学习中多项式回归的文章。为了更好的理解这篇文章，你可以浏览一下关于简单线性回归和多元线性回归的文章。
然而，让我们快速回顾一下这些概念。
简单线性回归和多元线性回归的快速修订
简单线性回归用于预测一系列数值数据的有限值。有一个独立变量 x 用于预测变量 y。还有像 b0 和 b1 这样的常数作为参数添加到我们的方程中。
Simple Linear Regression equation
说到多元线性回归，我们使用多个独立变量来预测值。这些自变量被制成特征矩阵，然后用于因变量的预测。该等式可以表示如下:
Multiple Linear Regression equation
什么是多项式回归？
多项式回归也是一种线性回归，通常用于使用独立变量的多项式幂进行预测。使用下面的等式可以更好地理解这个概念:
Polynomial Regression equation
什么时候用多项式回归？
在简单线性回归的情况下，有些数据高于或低于直线，因此是不准确的。这就是可以使用多项式回归的地方。
Simple Linear regression Vs Polynomial Regression
在左侧显示的图像中，您可以注意到有些点位于回归线上方，有些点位于回归线下方。这使得模型不太精确。这就是线性回归的情况。
现在，看看右边的图像，它是多项式回归的。在这里，我们的回归线或曲线拟合并通过所有的数据点。因此，使我们的模型回归更准确。
多项式回归为什么叫线性？
多项式回归有时也称为多项式线性回归。为什么这样
即使它有巨大的力量，它仍然被称为线性的。这是因为当我们谈论线性时，我们不是从 x 变量的角度来看的。我们讨论系数。
y 是 X 的函数，这个函数能否表示为系数的线性组合，因为最终用于插入 X 和预测 y。
因此，从系数的角度来看，这个方程是线性的。有趣吧？
现在我们将通过一个例子来理解如何执行这种回归。
Python 中多项式回归的一个简单例子
让我们快速地看一下如何执行多项式回归。对于这个例子，我使用了一个工资预测数据集。
假设，你是一家公司的人力资源团队，想要核实他们将要雇用的一名新的潜在雇员过去的工作细节。然而，他们得到的信息仅仅是他们职位上的 10 份薪水。
有了这个，人力资源团队就可以与这个人的职位(比如 6.5 级)联系起来，并可以检查这个员工是否一直在虚张声势地谈论他以前的工资。
因此，我们将建造一个 bluffy 探测器。
数据集可以在这里找到-https://github . com/content-anu/dataset-多项式-回归
1.导入数据集
为了导入和读取数据集，我们将使用 Pandas 库并使用 read_csv 方法将列读入数据框。
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
dataset = pd.read_csv('Position_Salaries.csv')
dataset
上述代码的输出显示了如下数据集:
Output of the dataset
2.数据预处理
观察数据集时，您会看到只有“级别”和“薪金”列是必需的，并且职位已经被编码到级别中。因此它可以被忽略。所以从特征矩阵中跳过“位置”。
X = dataset.iloc[:,1:2].values
y = dataset.iloc[:,2].values
因为我们只有 10 个观察值，所以我们不会将其分成测试集和训练集。这有两个原因:
- 小的观察没有意义，因为我们没有足够的信息在一组上训练，在另一组上测试模型。
- 我们想做一个非常准确的预测。我们需要更多关于列车组的信息。因此，整个数据集仅用于训练。
3.拟合线性回归模型
我们用它来比较多项式回归的结果。
from sklearn.linear_model import LinearRegression
lin_reg = LinearRegression()
lin_reg.fit(X,y)
上面代码的输出是一行声明模型已经被拟合的代码。
Linear regression fit
4.线性回归模型的可视化结果
plt.scatter(X,y, color='red')
plt.plot(X, lin_reg.predict(X),color='blue')
plt.title("Truth or Bluff(Linear)")
plt.xlabel('Position level')
plt.ylabel('Salary')
plt.show()
上面的代码生成了一个包含回归线的图形，如下所示:
Linear regression model visual representation
5.拟合多项式回归模型
我们将导入PolynomialFeatures类。poly_reg是一个转换工具，将特征矩阵 X 转换为新的特征矩阵 X_poly。它包含 x1，x12,……，x1n.
degree参数指定 X_poly 中多项式特征的次数。我们考虑默认值 ie 2。
from sklearn.preprocessing import PolynomialFeatures
poly_reg = PolynomialFeatures(degree=2)
X_poly = poly_reg.fit_transform(X)
X # prints X
Output of X
X_poly # prints the X_poly
Output of X_poly
X 是原始值。X_poly有三列。第一列是常数为 1 的列。包含实数值的 x 是中间的列，即 x1。第二列是 x1 的平方。
拟合必须包含在多元线性回归模型中。为此，我们必须创建一个新的线性回归对象lin_reg2，它将用于包含我们用 poly_reg 对象和 X_poly 进行的拟合。
lin_reg2 = LinearRegression()
lin_reg2.fit(X_poly,y)
上述代码产生以下输出:
Output
6.可视化多项式回归模型
from sklearn.preprocessing import PolynomialFeatures
poly_reg = PolynomialFeatures(degree=4)
X_poly = poly_reg.fit_transform(X)
lin_reg2 = LinearRegression()
lin_reg2.fit(X_poly,y)
X_grid = np.arange(min(X),max(X),0.1)
X_grid = X_grid.reshape(len(X_grid),1)
plt.scatter(X,y, color='red')
plt.plot(X_grid, lin_reg2.predict(poly_reg.fit_transform(X_grid)),color='blue')
plt.title("Truth or Bluff(Polynomial)")
plt.xlabel('Position level')
plt.ylabel('Salary')
plt.show()
Visualizing the polynomial regression
7.预测结果
Prediction
Python 中多项式回归的完整代码
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
dataset = pd.read_csv('Position_Salaries.csv')
dataset
X = dataset.iloc[:,1:2].values
y = dataset.iloc[:,2].values
# fitting the linear regression model
from sklearn.linear_model import LinearRegression
lin_reg = LinearRegression()
lin_reg.fit(X,y)
# visualising the linear regression model
plt.scatter(X,y, color='red')
plt.plot(X, lin_reg.predict(X),color='blue')
plt.title("Truth or Bluff(Linear)")
plt.xlabel('Position level')
plt.ylabel('Salary')
plt.show()
# polynomial regression model
from sklearn.preprocessing import PolynomialFeatures
poly_reg = PolynomialFeatures(degree=2)
X_poly = poly_reg.fit_transform(X)
X_poly # prints X_poly
lin_reg2 = LinearRegression()
lin_reg2.fit(X_poly,y)
# visualising polynomial regression
from sklearn.preprocessing import PolynomialFeatures
poly_reg = PolynomialFeatures(degree=4)
X_poly = poly_reg.fit_transform(X)
lin_reg2 = LinearRegression()
lin_reg2.fit(X_poly,y)
X_grid = np.arange(min(X),max(X),0.1)
X_grid = X_grid.reshape(len(X_grid),1)
plt.scatter(X,y, color='red')
plt.plot(X_grid, lin_reg2.predict(poly_reg.fit_transform(X_grid)),color='blue')
plt.title("Truth or Bluff(Polynomial)")
plt.xlabel('Position level')
plt.ylabel('Salary')
plt.show()
上面的代码输出如下图所示:
Output of the code
结论
关于多项式回归的这篇文章到此结束。希望您已经理解了多项式回归的概念，并且已经尝试了我们举例说明的代码。请在下面的评论区告诉我们您的反馈。
使用空间的自然语言处理中的词性标注
原文：https://www.askpython.com/python/examples/pos-tagging-in-nlp-using-spacy
词类是在句子中扮演不同角色的词。英语有 8 个词类。它们是:
- 名词
- 代词
- 动词
- 副词
- 形容词
- 介词
- 连词
- 交叉连接
词性标签提供了关于一个词及其相邻词的大量信息。它可以用于各种任务，如情感分析、文本到语音转换等。
也读:NLP 简介
什么是词性标注？
标记意味着将令牌分类到预定义的类别中。词性(POS) 标注是给定语料库中的每个单词标注一个合适的记号，即基于上下文的词性。它也被称为语法标记。
词性标注技术
主要有四种类型的位置标签:
- 基于规则的标记器:基于规则的标记器根据一些预定义的规则和提供给它们的信息的上下文来为单词分配词性。
- 随机/概率标记:这是最简单的词性标记方法。它使用概率、频率和统计。这些标记器找到在训练数据中考虑的文本中给定单词最频繁使用的标记，并将该标记分配给测试数据中的单词。有时，这可能会导致语法错误的标记。
- 基于内存的标记:一组案例保存在内存中，每个案例都有一个单词、它的上下文和一个适当的标记。基于保存在存储器中的案例中的最佳匹配，新的句子被标记。
- 基于转换的标签:它是基于规则和随机标签的结合。在这种类型中，规则是从数据中自动生成的。此外，还考虑了一些预定义的规则。这两个因素都用于在基于转换的词性标注器中执行词性标注。
现在，让我们尝试用 Python 实现词性标注。我们将看到如何使用 Python 中可用的spacy库来执行词性标注。
考虑下面的文本是我们的语料库，目的是执行词性标注。
Sarah lives in a hut in the village.
She has an apple tree in her backyard.
The apples are red in colour.
让我们创建一个上述句子的数据框架。
import pandas as pd
text = ['Sarah lives in a hut in the village.',
'She has an apple tree in her backyard.',
'The apples are red in colour.']
df = pd.DataFrame(text, columns=['Sentence'])
df
POS Tagging Dataframe
使用空间的词性标注
让我们开始使用 Python spacy 进行词性标注。
import spacy
#load the small English model
nlp = spacy.load("en_core_web_sm")
#list to store the tokens and pos tags
token = []
pos = []
for sent in nlp.pipe(df['Sentence']):
if sent.has_annotation('DEP'):
#add the tokens present in the sentence to the token list
token.append([word.text for word in sent])
#add the pos tage for each token to the pos list
pos.append([word.pos_ for word in sent])
如需了解更多 spacy 车型，请参考此链接。
在上面的代码中，
- 我们首先导入了空间库。
- 创建了两个列表——一个用于存储标记(标记，另一个(位置)用于存储词性标签。
- 然后，我们循环遍历数据帧(df)的“句子”列中的每个句子
- 将每个句子中的标记添加到标记列表中。
- 将令牌的相应词性标签添加到词性列表中。
token列表如下所示:
[['Sarah', 'lives', 'in', 'a', 'hut', 'in', 'the', 'village', '.'],
['She', 'has', 'an', 'apple', 'tree', 'in', 'her', 'backyard', '.'],
['The', 'apples', 'are', 'red', 'in', 'colour', '.']]
而pos列表是:
[['PROPN', 'VERB', 'ADP', 'DET', 'NOUN', 'ADP', 'DET', 'NOUN', 'PUNCT'],
['PRON', 'VERB', 'DET', 'NOUN', 'NOUN', 'ADP', 'PRON', 'NOUN', 'PUNCT'],
['DET', 'NOUN', 'AUX', 'ADJ', 'ADP', 'NOUN', 'PUNCT']]
如果我们想在一个句子中看到它旁边的标记和 POS 标签，我们可以写
df['token'] = token
df['pos'] = pos
它将产生以下数据帧:
POS And Token Dataframe
如果我们想知道特定 POS 标签的数量，我们将使用count方法。
# counting the number of a specific pos tag in each sentence
# (in the 'pos' col) and adding a new col for it in the df
df['noun'] = df.apply(lambda x: x['pos'].count('NOUN'), axis=1)
df['verb'] = df.apply(lambda x: x['pos'].count('VERB'), axis=1)
df['adj'] = df.apply(lambda x: x['pos'].count('ADJ'), axis=1)
df['punct'] = df.apply(lambda x: x['pos'].count('PUNCT'), axis=1)
df
上面的代码使用了一个 lambda 函数，该函数计算给定的 POS 标签在提到的列中出现的次数。我们可以根据需要清点其他 POS 标签。
这样的输出是:
POS Count Dataframe
结论
仅此而已！在本教程中，我们已经学习了词性标注及其使用空间的实现。请随时查看我们网站上的更多 Python 教程！
参考
用 Python 打印所有可能的子序列/子集
原文：https://www.askpython.com/python/examples/possible-subsequences-subsets
在本教程中，我们将理解一个非常有趣的问题，称为打印特定字符串的所有可能的子序列/子集。
概念解释
对于给定字符串中的每个元素，有两种选择:
- 包括子序列中的第一个元素，并查找剩余元素的子序列。
- 或者不包括第一个元素，而查找剩余元素的子序列。
这同样适用于每次递归调用，直到我们到达给定数组的最后一个索引。
在这种情况下，我们只需打印形成的子序列，然后返回查找下一个子序列。如果你想知道更多关于递归的知识，请阅读下面提到的教程。
了解更多关于递归的知识:Python 中的递归
代码实现
def get_all_subsequence(n,output,i):
if (i==len(n)):
if (len(output)!=0):
print(output)
else:
# exclude first character
get_all_subsequence(n,output,i+1)
# include first character
output+=n[i]
get_all_subsequence(n,output,i+1)
return
n = input()
get_all_subsequence(n,"",0)
print(n[0])
样本输出
通过上面的代码， "abc" 字符串的所有可能的子序列如下:
c
b
bc
a
ac
ab
abc
a
我希望你通过递归理解了子序列或字符串子集的概念。
感谢您的阅读！快乐学习！😇
Python 中的后序树遍历
原文：https://www.askpython.com/python/examples/postorder-tree-traversal-in-python
在本文中，我们将研究后序树遍历的概念和算法。然后我们将在 python 中实现后序遍历算法，并在一棵二叉树上运行它。
什么是后序树遍历？
后序遍历是一种深度优先的树遍历算法。在深度优先遍历中，我们从根节点开始，然后探索树的一个分支，直到结束，然后我们回溯并遍历另一个分支。
在后序遍历中，首先，我们遍历当前节点的左侧子树或左侧子树，然后我们遍历当前节点的右侧子树或右侧子树。最后，我们遍历当前节点。
我们递归地执行这个操作，直到所有的节点都被遍历。我们使用后序遍历来删除一棵二叉树。我们也可以使用后序树遍历从表达式树中找到后缀表达式。
后序遍历算法
下面是后序遍历的算法。
- 算法后置:
- 输入:对根节点的引用
- 输出:打印树的所有节点
- 开始吧。
- 如果根为空，则返回。
- 遍历根的左子树。// postorder(root.leftChild)
- 遍历根的右边子树。// postorder(root.rightChild)
- 遍历根节点。//打印节点
末端的值。
python 中后序遍历算法的实现
现在我们将实现上面的算法，以后序遍历的方式打印下面的二叉树的节点。
Binary Tree
在下面的代码中，首先创建了上面的二叉树，然后输出二叉树的后序遍历。
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 postorder(root):
#if root is None return
if root==None:
return
#traverse left subtree
postorder(root.leftChild)
#traverse right subtree
postorder(root.rightChild)
#traverse root
print(root.data)
root= insert(None,15)
insert(root,10)
insert(root,25)
insert(root,6)
insert(root,14)
insert(root,20)
insert(root,60)
print("Printing values of binary tree in postorder Traversal.")
postorder(root)
输出:
Printing values of binary tree in postorder Traversal.
6
14
10
20
60
25
15
在这里，我们可以看到，在处理当前节点之前，遍历了节点的每个子节点。所以我们可以使用后序遍历来删除一棵二叉树，因为我们可以从一个叶子开始删除节点，然后向上到根。
结论
在本文中，我们学习了后序树遍历的概念。我们还研究了该算法，并用 Python 实现了它来遍历二叉树。请继续关注更多内容丰富的文章。
Python pprint 模块
读者朋友们，你们好！在本文中，我们将详细关注 Python pprint 模块的功能。所以，让我们开始吧！🙂
了解 Python pprint 模块
无论是哪种编程语言，在表示最终产品或应用程序时，数据的表示总是起着关键的作用。除了开发人员之外，功能团队中的许多其他人利用特定模块的结果来进一步进行操作或分析。同样，输出也必须漂亮清晰。
特别是对于 API 调用，我们经常从调用中获得大量无格式数据，作为键值对形式的 JSON 文件。对于我们来说，要实现和浏览大量未格式化的数据似乎太难了。
考虑到这一点，我们有 Python 的 pprint 模块来解决这个问题。
Python pprint 模块格式化传递给它的整个输出，并以结构化的格式表示。
那么，Python print()函数有什么问题呢？虽然 print()函数表示输出，但它不对输出进行格式化，因此不适合大量数据值。
看看下面的例子来理解 print()函数的问题
为什么不用 print()函数呢？
在下面的例子中，我们从 API 获取数据，并将其加载到 JSON 格式。我们尝试使用 print()函数打印大量数据。
import json
response_API = requests.get('https://gmail.googleapis.com/$discovery/rest?version=v1')
#print(response_API.status_code)
data = response_API.text
parse_json = json.loads(data)
print(parse_json)
输出:
Python print Function
如您所见，大量数据以非结构化格式表示，因此任何人都很难分析 JSON 数据。
用 API 调用的数据实现 pprint()模块
另一方面，我们现在尝试表示从上述示例中的 API 获取的相同数据，并尝试使用 pprint()模块来表示它。
举例:
import requests
import json
from pprint import pprint
response_API = requests.get('https://gmail.googleapis.com/$discovery/rest?version=v1')
#print(response_API.status_code)
data = response_API.text
parse_json = json.loads(data)
pprint(parse_json)
输出:
Python pprint Module
如上所述，使用 pprint()函数以结构化且美观的格式表示整个庞大的数据，这使得读取和分析数据更加容易。
结论
尝试在其他场景中实现 pprint()函数，并在评论部分告诉我们您对相同内容的理解。如果你遇到任何问题，请随时留言。更多与 Python 编程相关的帖子，请继续关注我们。
在那之前，学习愉快！！🙂
Python 中的精度和召回
原文：https://www.askpython.com/python/examples/precision-and-recall-in-python
今天的文章就来说说精准和召回。每当我们实现一个分类问题(即决策树 ) 来分类数据点时，总有一些点经常被错误分类。
即使准确性给出了模型有多好的一般概念，我们需要更健壮的度量来评估我们的模型。
让我们考虑一个例子。
假设您是一名在公司工作的数据科学家，您被分配了一项识别欺诈交易的任务。现在你必须建立一个模型，它看起来有很好的准确性，但是有一个问题。
我想让你想象一下这个问题的两种情况。
- 场景 1 :你的模型将一个非欺诈交易归类为欺诈。
- 场景 2 :您的模型将欺诈交易归类为非欺诈交易。
在这两种情况中，考虑到欺诈交易会带来巨大损失，哪种情况是最需要注意的？
我希望你猜对了。
这是第二种情况。如果您的模型将欺诈交易归类为非欺诈交易，可能会使您的组织遭受重大损失。你不想那样，是吗？🙂
准确性不能提供任何处理这类问题的方法。
在本文中，我们将了解如何通过获取关于精确度和召回率的知识来处理此类问题。
理解混淆矩阵
在深入精确和回忆之前，我们必须知道混淆矩阵。
二元分类问题的混淆矩阵看起来是这样的。其中我们要么正确地对点进行分类，要么没有，但是这些错误分类的点可以进一步分为假阳性和假阴性。
Confusion Matrix
现在让我们来理解一下术语。
- 真正(TP):实际的正类被预测为正。
- 真阴性(TN):实际的阴性类被预测为阴性。
- 误报(FP):实际类别为阴性，但预测为阳性。
- 假阴性(FN):实际类别为阳性，但预测为阴性。
从混淆矩阵中可以解释出精度和召回。让我们看看它们是什么。
你说的精确是什么意思？
用最简单的话来说，精度是真正的阳性与被分类为阳性的所有点之间的比率。
为了计算模型的精度，我们需要混淆矩阵中的正数和负数。
精度= TP/(TP + FP)
为了审视精度，我们只是把它看作某种奇特的数学比率，但它究竟意味着什么呢？
参考上面的欺诈交易示例。这意味着在所有被分类为正面(欺诈)的交易中，有多少实际上是正面的。
你说的召回是什么意思？
简单来说，召回是我们的模型正确识别真正积极的措施。它也被称为真阳性率。
它是真阳性与真阳性和假阴性之和的比值。这意味着在所有实际上为正的点中，我们正确预测为正的占多少？
召回= TP/(TP + FN)
参照我们之前的例子。我们说，在所有实际上是欺诈的交易中，我们预测其中有多少是欺诈。
Recall Intuition
F1 的分数是多少？
F1 分数是精确度和召回率的调和平均值
它可以计算为:
F1 Score
当存在不平衡的班级时，F1 分数是一个更好的指标。当你想在精确度和召回率之间寻求平衡时，它是需要的。
在大多数现实生活的分类问题中，存在不平衡的类别分布，因此 F1-score 是评估我们的模型的更好的度量。
用 Python 计算精度和召回率
让我们看看如何在分类问题上使用 python 计算精度和召回率。
我们将利用 sklearn.metrics 模块。
#Importing the required libraries
from sklearn import datasets
import pandas as pd
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import precision_recall_curve
from sklearn.metrics import plot_precision_recall_curve
from sklearn.metrics import precision_score
from sklearn.metrics import recall_score
import matplotlib.pyplot as plt
#Loading the data
data = datasets.load_breast_cancer()
df = pd.DataFrame(data.data, columns=data.feature_names)
df['target'] = data.target
#Splitting the data into training and test set
X_train, X_test, y_train, y_test = train_test_split(
df.iloc[:,:-1], df.iloc[:,-1], test_size=0.3, random_state=42)
# Initialize and fit the Model
model = LogisticRegression()
model.fit(X_train, y_train)
#Make prediction on the test set
pred = model.predict(X_test)
#calculating precision and reall
precision = precision_score(y_test, pred)
recall = recall_score(y_test, pred)
print('Precision: ',precision)
print('Recall: ',recall)
#Plotting Precision-Recall Curve
disp = plot_precision_recall_curve(model, X_test, y_test)
Precision: 0.963963963963964
Recall: 0.9907407407407407
Precision Recall Curve
来自sklearn.metrics模块的precision_score( )和recall_score( )函数需要真实标签和预测标签作为输入参数，分别返回精度和召回分数。
结论
拥有高精度和高召回率的能力总是被期望的，但是很难达到。根据应用程序的类型，我们需要提高精度或召回率。这篇文章是关于理解两个非常非常重要的模型评估标准。
快乐学习！
根据 Python 中的名称预测国籍
原文：https://www.askpython.com/python/examples/predict-nationality-using-names
嘿伙计们！在本教程中，我们将建立一个 RNN 和 LSTM 模型，帮助我们根据每个角色的名字来预测国籍。
让我们从了解我们拥有的数据集开始。
了解数据集
Dataset 是一个文本文件，包含每个行中用逗号分隔的人名和姓名的国籍。该数据集包含超过 2 万个名字和 18 个独特的国籍，如葡萄牙语、爱尔兰语、西班牙语等等。
数据的快照如下所示。你可以在这里下载数据集。
Dataset Snapshot Nationality Predictor
用 Python 中的人名预测国籍
让我们直接进入代码实现。我们将从导入模块开始，然后导入我们为本次演示选择的名称和国籍数据集。
第一步:导入模块
在开始构建任何模型之前，我们需要将所有需要的库导入到我们的程序中。
from io import open
import os, string, random, time, math
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
from sklearn.model_selection import train_test_split
import torch
import torch.nn as nn
import torch.optim as optim
from IPython.display import clear_output
第二步:加载数据集
为了加载数据集，我们遍历数据中的每一行，并创建一个包含姓名和国籍的元组列表。这将使模型更容易理解后面部分中的数据。
languages = []
data = []
X = []
y = []
with open("name2lang.txt", 'r') as f:
#read the dataset
for line in f:
line = line.split(",")
name = line[0].strip()
lang = line[1].strip()
if not lang in languages:
languages.append(lang)
X.append(name)
y.append(lang)
data.append((name, lang))
n_languages = len(languages)
print("Number of Names: ", len(X))
print("Number of Languages: ",n_languages)
print("All Names: ", X)
print("All languages: ",languages)
print("Final Data: ", data)
Load Dataset Nationality Predictor
第三步:列车测试分割
我们将将数据按 80:20 的比例分成培训和测试，其中 80%的数据用于培训，其余 20%用于测试。
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 123, stratify = y)
print("Training Data: ", len(X_train))
print("Testing Data: ", len(X_test))
Training Data: 16040
Testing Data: 4010
步骤 4:编码数据
字符编码将被用作序列模型的输入，而不是原始文本数据。因此，我们必须对输入进行加密，并在字符级别对其进行识别。
一旦我们在字符级创建了编码，我们需要连接所有的字符级编码来获得整个单词的编码。这一过程适用于所有姓名和国籍。
all_letters = string.ascii_letters + ".,;"
print(string.ascii_letters)
n_letters = len(all_letters)
def name_rep(name):
rep = torch.zeros(len(name), 1, n_letters)
for index, letter in enumerate(name):
pos = all_letters.find(letter)
rep[index][0][pos] = 1
return rep
上面的函数 name_rep 为名称生成一次性编码。首先，我们声明一个零张量，输入大小等于名字的长度，外部大小等于列表中的全部字符数。
接下来，我们循环遍历每个字符以标识字母的索引，并将该索引位置值设置为 1，其余值为 0。
def nat_rep(lang):
return torch.tensor([languages.index(lang)], dtype = torch.long)
对国籍进行编码遵循的逻辑比对姓名进行编码简单得多。我们只需确定特定国籍在我们的国籍列表中出现的索引，以对国籍进行编码。然后，索引被指定为编码。
第五步:建立神经网络模型
我们将使用 Pytorch 建立一个 RNN 模型，我们创建一个类来实现这个目标。
init 函数(构造函数)帮助我们初始化网络特征，例如与隐藏层相关的权重和偏差。
class RNN_net(nn.Module):
def __init__(self, input_size, hidden_size, output_size):
super(RNN_net, self).__init__()
self.hidden_size = hidden_size
self.i2h = nn.Linear(input_size + hidden_size, hidden_size)
self.i2o = nn.Linear(input_size + hidden_size, output_size)
self.softmax = nn.LogSoftmax(dim = 1)
def forward(self, input_, hidden):
combined = torch.cat((input_, hidden), 1)
hidden = self.i2h(combined)
output = self.i2o(combined)
output = self.softmax(output)
return output, hidden
def init_hidden(self):
return torch.zeros(1, self.hidden_size)
forward 函数首先连接角色的输入和隐藏表示，然后使用 i2h、i2o 和 softmax 层将其作为输入来计算输出标签。
def infer(net, name):
net.eval()
name_ohe = name_rep(name)
hidden = net.init_hidden()
for i in range(name_ohe.size()[0]):
output, hidden = net(name_ohe[i], hidden)
return output
n_hidden = 128
net = RNN_net(n_letters, n_hidden, n_languages)
output = infer(net, "Adam")
index = torch.argmax(output)
print(output, index)
网络实例和人名作为输入参数传递给 infer 函数。我们将网络设置为评估模式，并在此函数中计算输入人名的一键表示。
接下来，我们将根据隐藏大小计算隐藏表示，并在将计算的隐藏表示返回到网络之前循环所有字符。
最后，我们将计算输出，即这个人的国籍。
第六步:计算 RNN 模型的精度
在继续训练模型之前，让我们创建一个函数来计算模型的准确性。
为了达到同样的目的，我们将创建一个评估函数，将以下内容作为输入:
- 网络实例
- 数据点的数量
- k 的值
- x 和 Y 测试数据
def dataloader(npoints, X_, y_):
to_ret = []
for i in range(npoints):
index_ = np.random.randint(len(X_))
name, lang = X_[index_], y_[index_]
to_ret.append((name, lang, name_rep(name), nat_rep(lang)))
return to_ret
def eval(net, n_points, k, X_, y_):
data_ = dataloader(n_points, X_, y_)
correct = 0
for name, language, name_ohe, lang_rep in data_:
output = infer(net, name)
val, indices = output.topk(k)
if lang_rep in indices:
correct += 1
accuracy = correct/n_points
return accuracy
在函数内部，我们将执行以下操作:
- 使用
data loader加载数据。 - 迭代数据加载器中出现的所有人名。
- 对输入调用模型并获得输出。
- 计算预测类。
- 计算正确预测的类别总数
- 返回最终百分比。
第七步:训练 RNN 模型
为了训练模型，我们将编写一个简单的函数来训练我们的网络。
def train(net, opt, criterion, n_points):
opt.zero_grad()
total_loss = 0
data_ = dataloader(n_points, X_train, y_train)
for name, language, name_ohe, lang_rep in data_:
hidden = net.init_hidden()
for i in range(name_ohe.size()[0]):
output, hidden = net(name_ohe[i], hidden)
loss = criterion(output, lang_rep)
loss.backward(retain_graph=True)
total_loss += loss
opt.step()
return total_loss/n_points
def train_setup(net, lr = 0.01, n_batches = 100, batch_size = 10, momentum = 0.9, display_freq = 5):
criterion = nn.NLLLoss()
opt = optim.SGD(net.parameters(), lr = lr, momentum = momentum)
loss_arr = np.zeros(n_batches + 1)
for i in range(n_batches):
loss_arr[i + 1] = (loss_arr[i]*i + train(net, opt, criterion, batch_size))/(i + 1)
if i%display_freq == display_freq - 1:
clear_output(wait = True)
print("Iteration number ", i + 1, "Top - 1 Accuracy:", round(eval(net, len(X_test), 1, X_test, y_test),4), 'Top-2 Accuracy:', round(eval(net, len(X_test), 2, X_test, y_test),4), 'Loss:', round(loss_arr[i]),4)
plt.figure()
plt.plot(loss_arr[1:i], "-*")
plt.xlabel("Iteration")
plt.ylabel("Loss")
plt.show()
print("\n\n")
n_hidden = 128
net = RNN_net(n_letters, n_hidden, n_languages)
train_setup(net, lr = 0.0005, n_batches = 100, batch_size = 256)
在对 100 个批次的模型进行训练之后，我们能够利用 RNN 模型实现 66.5%的前 1 名准确度和 79%的前 2 名准确度。
Loss Plot Nationality Predictor
第八步:LSTM 模式培训
我们还将讨论如何实现 LSTM 模型来对人名的国籍进行分类。为了达到同样的目的，我们将使用 Pytorch 并创建一个自定义的 LSTM 类。
class LSTM_net(nn.Module):
def __init__(self, input_size, hidden_size, output_size):
super(LSTM_net, self).__init__()
self.hidden_size = hidden_size
self.lstm_cell = nn.LSTM(input_size, hidden_size) #LSTM cell
self.h2o = nn.Linear(hidden_size, output_size)
self.softmax = nn.LogSoftmax(dim = 2)
def forward(self, input_, hidden):
out, hidden = self.lstm_cell(input_.view(1, 1, -1), hidden)
output = self.h2o(hidden[0])
output = self.softmax(output)
return output.view(1, -1), hidden
def init_hidden(self):
return (torch.zeros(1, 1, self.hidden_size), torch.zeros(1, 1, self.hidden_size))
n_hidden = 128
net = LSTM_net(n_letters, n_hidden, n_languages)
train_setup(net, lr = 0.0005, n_batches = 100, batch_size = 256)
在对 100 个批次的模型进行训练之后，我们能够利用 LSTM 模型实现 52.6%的前 1 名准确度和 66.9%的前 2 名准确度。
Loss Plot Nationality Predictor LSTM
结论
恭喜你！您刚刚学习了如何使用 Pytorch 构建国籍分类模型。希望你喜欢它！😇
喜欢这个教程吗？无论如何，我建议你看一下下面提到的教程:
感谢您抽出时间！希望你学到了新的东西！！😄
使用 Keras TensorFlow 预测莎士比亚文本
原文：https://www.askpython.com/python/examples/predict-shakespearean-text
嘿伙计们！在本教程中，我们将了解如何使用 Python 中的 Keras TensorFlow API 创建递归神经网络模型来预测莎士比亚文本。
也读作:股价预测使用 Python
为了产生新的文本，我们将使用定制的 RNN 模型来训练 GitHub 莎士比亚文本数据集 。
第一步:导入库
我们利用了一些最流行的深度学习库。Sweetviz 是一个新的软件包，可自动进行探索性数据分析，尤其有利于分析我们的训练数据集。
pip install sweetviz
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import tensorflow as tf
from tensorflow import keras
import sweetviz as sw
import seaborn as sns
sns.set()
第二步:加载数据集
shakespeare_url='https://raw.githubusercontent.com/karpathy/char-rnn/master/data/tinyshakespeare/input.txt'
filepath=keras.utils.get_file('shakespeare.txt',shakespeare_url)
with open(filepath) as f:
shakespeare_text=f.read()
Downloading data from https://raw.githubusercontent.com/karpathy/char-rnn/master/data/tinyshakespeare/input.txt
1122304/1115394 [==============================] - 0s 0us/step
1130496/1115394 [==============================] - 0s 0us/step
既然我们已经将数据集下载到 Python 笔记本中，我们需要在利用它进行训练之前对其进行预处理。
第三步:预处理数据集
标记化是将冗长的文本字符串分成较小部分或标记的过程。较大的文本块可以被标记成句子，然后变成单词。
预处理还包括从生成的标记中删除标点符号。
tokenizer=keras.preprocessing.text.Tokenizer(char_level=True)
tokenizer.fit_on_texts(shakespeare_text)
max_id=len(tokenizer.word_index)
dataset_size=tokenizer.document_count
[encoded]=np.array(tokenizer.texts_to_sequences([shakespeare_text]))-1
步骤 4:准备数据集
我们将使用tf.data.Dataset,它通常对大量的元素有用，比如大量的文本数据。
Dataset.repeat()遍历数据集并重复数据集指定的次数。window()就像一个滑动窗口，每次滑动指定数量的窗口，进行反复迭代。
train_size=dataset_size*90//100
dataset=tf.data.Dataset.from_tensor_slices(encoded[:train_size])
n_steps=100
window_length=n_steps+1
dataset=dataset.repeat().window(window_length,shift=1,drop_remainder=True)
dataset=dataset.flat_map(lambda window: window.batch(window_length))
batch_size=32
dataset=dataset.shuffle(10000).batch(batch_size)
dataset=dataset.map(lambda windows: (windows[:,:-1],windows[:,1:]))
dataset=dataset.map(lambda X_batch,Y_batch: (tf.one_hot(X_batch,depth=max_id),Y_batch))
dataset=dataset.prefetch(1)
第五步:建立模型
模型构建非常简单。我们将创建一个顺序模型，并向该模型添加具有某些特征的层。
model=keras.models.Sequential()
model.add(keras.layers.GRU(128,return_sequences=True,input_shape=[None,max_id]))
model.add(keras.layers.GRU(128,return_sequences=True))
model.add(keras.layers.TimeDistributed(keras.layers.Dense(max_id,activation='softmax')))
接下来，我们将编译模型并在数据集上拟合模型。我们将使用Adam优化器，但是你也可以根据你的喜好使用其他可用的优化器。
model.compile(loss='sparse_categorical_crossentropy',optimizer='adam')
history=model.fit(dataset,steps_per_epoch=train_size // batch_size,epochs=1)
31370/31370 [==============================] - 1598s 51ms/step - loss: 0.9528
第六步:测试模型
我们在下面提到的代码片段中定义了一些函数。这些函数将根据我们定义的模型预处理和准备输入数据，并预测下一个字符，直到指定的字符数。
def preprocess(texts):
X=np.array(tokenizer.texts_to_sequences(texts))-1
return tf.one_hot(X,max_id)
def next_char(text,temperature=1):
X_new=preprocess([text])
y_proba=model.predict(X_new)[0,-1:,:]
rescaled_logits=tf.math.log(y_proba)/temperature
char_id=tf.random.categorical(rescaled_logits,num_samples=1)+1
return tokenizer.sequences_to_texts(char_id.numpy())[0]
def complete_text(text,n_chars=50,temperature=1):
for _ in range(n_chars):
text+=next_char(text,temperature)
return text
让我们使用下面提到的代码来预测某个字母或单词的文本。
print("Some predicted texts for letter 'D' are as follows:\n ")
for i in range(3):
print(complete_text('d'))
print()
Some predicted texts for letter 'D' are as follows:
d, swalld tell you in mine,
the remeiviss if i shou
dima's for me, sir, to comes what this roguty.
dening to girl, ne'er i was deckong?
which never be
print("Some predicted texts for word 'SHINE' are as follows:\n ")
for i in range(3):
print(complete_text('shine'))
print()
输出:
Some predicted texts for word 'SHINE' are as follows:
shine on here is your viririno penaite the cursue,
i'll
shine yet it the become done to-k
make you his ocrowing
shine dises'-leck a word or my head
not oning,
so long
结论
恭喜你！您刚刚学习了如何使用 RNN 构建一个莎士比亚文本预测器。希望你喜欢它！😇
喜欢这个教程吗？无论如何，我建议你看一下下面提到的教程:
感谢您抽出时间！希望你学到了新的东西！！😄
用 Python 构建预测模型
原文：https://www.askpython.com/python/examples/predictive-model-in-python
今天我们将学习一个有趣的话题，如何用 python 创建一个预测模型。这是机器学习和数据科学中的一个基本概念。在深入探讨之前，我们需要了解什么是预测分析。让我们看看目录。
什么是预测分析？
预测分析是数据科学的一个领域，涉及对未来事件进行预测。我们可以创建关于火灾或未来几天的新数据的预测，并使机器支持相同的数据。我们使用各种统计技术来分析目前的数据或观察结果，并预测未来。
我们为什么要使用预测分析？
如果做得正确，预测分析可以提供几个好处。对选择预测分析高度负责的一些关键特征如下。
- 即时反馈系统
- 它也提供了一个更好的营销策略。
- 以营销服务或任何业务为例，我们可以了解人们喜欢它的程度，以及最重要的是，他们真正想要添加的额外功能。
- 它指出了当前的趋势。
- 最佳化
- 我们可以使用预测分析优化我们的预测以及即将到来的战略。
- 类似于修改。
- 它包括对现在、过去和未来战略的比较。
- 更好的策略
- 使用这种即时反馈系统和优化流程，我们最终会有一个更好的策略。
- 它还提供了多种策略。
- 它引导更好的决策。
- 降低风险
- 当我们不知道优化，不知道反馈系统时，我们也可以降低风险。
- 最适合新人。
预测分析用例
- 防止流失
- 它允许我们预测一个人是否会在我们的策略中。不管他/她是否满意。
- 我们获得基于 pon 客户使用的分析。利用这一点，我们可以赢得报价，并了解他们真正想要的是什么。
- 质量保证
- 我们可以通过提供表格、访谈等方式了解客户使用我们服务的感受。
- 人们到底想要什么，不同的人和不同的想法。
- 需要安装的新特性以及它们的环境如何？
- 风险建模
- 它让我们知道将要涉及的风险程度。这样我们也可以投资它。
- 分析当前策略和预测未来策略。
- 销售预测
- 在目前的策略中它是如何进行的，在接下来的日子里它会是什么样的。
- 分析这些数据并创建有组织的数据。
预测分析中涉及的步骤
- 问题定义
- 它旨在确定我们的问题是什么。我们需要解决同样的问题。我们需要预测的主要问题。
- 预测分析的每个领域都需要基于这个问题定义。
- 数据采集
- 我们从多个来源收集数据，并收集数据来分析和创建我们的角色模型。
- 数据清理
- 我们可以看看缺失的值和哪些不重要。它们需要被移除。
- 我们需要通过这种方式优化来提高这个模型的质量。
- 我们需要删除超出边界级别的值。
- 数据分析
- 它包括管理收集的数据。
- 管理数据指的是检查数据是否组织良好。
- 建模
- 这一步包括通过使用先决条件算法来安装我们的机器，从而保存最终确定的或有组织的数据
- 模型检验
- 我们需要测试这台机器是否符合标准。
- 我们需要检查或比较输出结果/值和预测值。
- 在 0 到 1 的范围内分析比较的数据，其中 0 表示 0%，1 表示 100 %。
- 部署
- 一旦我们的模型被创建，或者它表现良好，或者它获得了成功的准确性分数，那么我们需要部署它以供市场使用。
预测分析的应用
Predictive 可以构建未来预测，这将有助于许多业务，如下所示:
- 定价
- 需求计划
- 活动管理
- 客户获取
- 预算和预测
- 欺诈检测
- 促销
创建我们的预测模型(示例)
让我们使用 google collab 来尝试一个预测分析的演示，方法是从一个针对特定优惠的银行活动中收集数据集。分析数据，通过抽样采访了解他们是否会利用这一机会。
| 指数 | 海平面 | 年龄 | 工作 | 婚姻状况 | 教育 | 系统默认值 | 平衡 | 房屋 | 贷款 | 接触 | 天 | 月 | 期间 | 运动 | pdays | 以前的 | 结果 | y |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Zero | Zero | Thirty | 失业的 | 已婚的 | 主要的 | 不 | One thousand seven hundred and eighty-seven | 不 | 不 | 细胞的 | Nineteen | 十月 | Seventy-nine | one | A | Zero | 未知的 | 不 |
| one | one | three | 服务 | 已婚的 | 副手 | 不 | Four thousand seven hundred and eighty-nine | 是 | 是 | 细胞的 | Eleven | 可能 | Two hundred and twenty | one | Three hundred and thirty-nine | four | 失败 | 不 |
| Two | Two | Thirty-five | 管理 | 单一的 | 第三的 | 不 | One thousand three hundred and fifty | 是 | 不 | 细胞的 | Sixteen | 四月 | One hundred and eighty-five | one | Three hundred and thirty | one | 失败 | 不 |
| three | three | Thirty | 管理 | 已婚的 | 第三的 | 不 | One thousand four hundred and seventy-six | 是 | 是 | 未知的 | three | 六月 | One hundred and ninety-nine | four | four | Zero | 未知的 | 不 |
| four | four | Fifty-nine | 蓝领 | 已婚的 | 副手 | 不 | Zero | 是 | 不 | 未知的 | five | 可能 | Two hundred and twenty-six | one | A | Zero | 未知的 | 不 |
#importing modules
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.linear_model import LogisticRegression
import seaborn as sns
import matplotlib.pyplot as plt
%matplotlib inline
data = pd.read_csv("/dataset.csv", delimiter = ",", header = "infer")
data.head()
sns.pairplot(data)
Capture 2
data.corr()
Capture 3
sns.heatmap(data.corr(), annot = True)
Capture 4
data.dtypes
sl int64
age int64
job object
marital_status object
education object
default object
balance int64
housing object
loan object
contact object
day int64
month object
duration int64
campaign int64
pdays object
previous int64
poutcome object
y object
dtype: object
data_new = pd.get_dummies(data, columns=['marital_status', 'education', 'default', 'housing', 'loan', 'contact', 'month', 'poutcome' ])
data_new.y.replace(('yes','no'), (1,0), inplace = True)
data_new.dtypes
Capture 5
print(data.shape)
(5, 18)
data.education.unique()
array(['primary', 'secondary', 'tertiary'], dtype=object)
pd.crosstab(index = data["education"], columns = data["y"])
Capture 6
data.education.value_counts().plot(kind = "barh")
Capture 7
data_y = pd.DataFrame(data_new['y'])
data_x = data_new.drop(['y'], axis = 1)
print(data_y.columns)
print(data_x.columns)
Capture 8
x_train, x_test, y_train, y_test = train_test_split(data_x, data_y, test_size = 0.3, random_state = 2, stratify = data_y)
print(x_train.shape)
print(x_test.shape)
print(y_train.shape)
print(y_test.shape)
#OUTPUT FOR THE ABOVE CODE
(3, 27)
(2, 27)
(3, 1)
(2, 1)
摘要
今天，我们讲述了预测分析，并尝试使用样本数据集进行演示。希望您已经尝试过我们的代码片段。你也可以尝试获取更多的数据集。我们必须带着一些更令人兴奋的话题再次访问。
Python 中的前序树遍历
原文：https://www.askpython.com/python/examples/preorder-tree-traversal
在本文中，我们将研究前序树遍历的概念和算法。然后我们将在 Python 中实现前序遍历算法，并在一棵二叉树上运行它。
什么是前序树遍历？
前序遍历是一种深度优先的树遍历算法。在深度优先遍历中，我们从根节点开始，然后探索树的一个分支，直到结束，然后我们回溯并遍历另一个分支。
在前序遍历中，首先我们遍历当前节点，然后我们遍历当前节点的左子树或左子树，然后我们遍历当前节点的右子树或右子树。我们递归地执行这个操作，直到所有的节点都被遍历。
我们使用前序遍历来创建一个二叉树的副本。我们还可以使用前序遍历从表达式树中导出前缀表达式。
Python 中的前序树遍历算法
下面是前序树遍历的算法。
算法预定–
- 输入:对根节点的引用
- 输出:打印树的所有节点
- 开始吧。
- 如果根为空，则返回。
- 遍历根节点。//打印节点的值
- 遍历根的左子树。// preorder(root.leftChild)
- 遍历根的右边子树。// preorder(root.rightChild)
- 结束。
Python 中前序遍历算法的实现
现在我们将实现上面的算法来打印下面的二叉树的节点。
Binary Tree
在下面的代码中，首先创建了上面的二叉树，然后打印二叉树的前序遍历。
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 preorder(root):
#if root is None return
if root==None:
return
#traverse root
print(root.data)
#traverse left subtree
preorder(root.leftChild)
#traverse right subtree
preorder(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("Printing values of binary tree in preorder Traversal.")
preorder(root)
输出:
Printing values of binary tree in preorder Traversal.
15
10
6
14
25
20
60
结论
在本文中，我们学习了前序树遍历的概念。我们还研究了该算法，并用 python 实现了它来遍历二叉树。请继续关注更多内容丰富的文章。
快乐学习。
python Pretty print JSON——完整指南
原文：https://www.askpython.com/python/examples/pretty-print-json-in-python
在本文中，我们将学习如何打印一个 JSON 文件。你可能会被“Python Pretty Print JSON”这个标题搞糊涂。让我们也理解这一点。在开始之前，我们首先需要理解一个 JSON 文件。
了解 JSON 文件格式
JSON 是一种语法或格式，以文本形式存储数据并在网络上传输或交换。机器和人类一样容易读写。许多 API 和数据库都使用这种格式。JSON 代表 JavaScript 对象符号。其编写的编程代码的文件扩展名是.json。让我们来看看 JSON 文件的一些关键特性。
- JSON 提供了一种易于使用的方法。
- 它描述了一种最小化的数据形式，使用非常少的空间，因此速度非常快。
- 它是开源的，可以免费使用。
- 它给出清晰、兼容、易读的结果。
- JSON 没有任何帮助他独立运行的依赖项。
- 将数据写入 JSON 文件的语法与 Python 字典完全相同。
让我们看看下面的 JSON 文件。
{
"name": "mine",
"version": "1.0.0",
"description": "hey ",
"main": "2.js",
"dependencies": {
"express": "^4.17.1",
"mongoose": "^5.12.9",
"nodemon": "^2.0.7",
"pug": "^3.0.2"
}}
在上面的例子中，你可以看到一个 JSON 文件很可能看起来像一个 python 字典 ，包含一些键(名称、版本、描述、主、依赖项)和值 (mine，1.0.0，hey，2.js，{"express": "^4.17.1 "，" mongose ":" ^5.12.9″,"nodemon": " ^2.0.7 "， "pug": "^3.0.2" })。
它也是结构化的。如果我们使用 ms_doc 或在记事本中打开它，我们可以看到同样的结果。但是使用 python 的打印函数，它将按如下非结构化方式打印。我们需要以一种结构化的格式 打印相同的内容，这是为了美观或者以一种更漂亮的方式。
{{
"name": "mine", "version": "1.0.0","description": "hey ","main": "2.js","dependencies": {"express": "^4.17.1","mongoose": "^5.12.9","nodemon": "^2.0.7","pug": "^3.0.2"
}}
正在读取 JSON 文件
我们的第一步将是 读取 JSON 文件 。让我们也看看我们的代码片段。
import json
with open(file="/content/package.json", mode='r') as our_file:
output = json.load(our_file)
print(output)
在上面的代码片段中，我们使用
- 打开 JSON 文件的关键字。
- 以只读模式打开文件的
mode='r'参数。 json.load()方法将我们的文件加载到名为 output 的对象文件中。
在打印相同的内容后，我们得到如下所示的 JSON 文件。
{'name': 'mine', 'version': '1.0.0', 'description': 'hey ', 'main': '2.js', 'dependencies': {'express': '^4.17.1', 'mongoose': '^5.12.9', 'nodemon': '^2.0.7', 'pug': '^3.0.2'}, 'devDependencies': {}, 'scripts': {'test': 'echo "Error: no test specified" && exit 1'}, 'author': 'brand', 'license': 'ISC'}
您可以看到，通过正常打印，我们得到的输出应该不是格式化的、漂亮的或结构化的。我们希望它印刷精美，结构良好。我们使用关键字 Pretty 只是为了同样的目的。(漂亮就是漂亮的意思。我们需要以一种漂亮的方式打印 JSON 文件。)
我们可以通过一些特殊的方法或者使用一些特殊的库来得到我们期望的结果。让我们拥有它。
使用 json.dumps()方法打印 JSON
json.dump( object_name, indent = "your value")
上面描述了 json.dumps()方法的语法 . 我们需要传递加载 json 文件的对象名，并传递指定我们想要用来缩进 json 的空格数的 indent 值。我们只需要添加这一行就可以打印出更漂亮的 JSON 文件。让我们快速看看下面。
with open(file="/content/package.json", mode='r') as our_file:
output = json.load(our_file)
pretty_output = json.dumps(output, indent=4)
print(pretty_output)
我们可以得到如下打印的 JSON 文件。
{
"name": "mine",
"version": "1.0.0",
"description": "hey ",
"main": "2.js",
"dependencies": {
"express": "^4.17.1",
"mongoose": "^5.12.9",
"nodemon": "^2.0.7",
"pug": "^3.0.2"
},
"devDependencies": {},
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"author": "brand",
"license": "ISC"
}
打印 json 使用
pprint module提供了 Python 中的 pprint()方法 ，用于以一种可读且漂亮的方式打印数据。它是标准库的一部分，强烈推荐与 API 请求和数据库一起用于代码调试。让我们看看如何在我们的代码片段中使用相同的代码。
import json
from pprint import pprint
with open("/content/package.json", 'r') as our_file:
output = json.load(our_file)
pprint(output)
在上面的代码片段中，我们已经像以前一样加载了 JSON 文件，使用了json.load()方法，然后将序列化的对象our_file传递给了pprint()方法，这也允许我们打印结构化的漂亮输出。
{'author': 'brand',
'dependencies': {'express': '^4.17.1',
'mongoose': '^5.12.9',
'nodemon': '^2.0.7',
'pug': '^3.0.2'},
'description': 'hey ',
'devDependencies': {},
'license': 'ISC',
'main': '2.js',
'name': 'mine',
'scripts': {'test': 'echo "Error: no test specified" && exit 1'},
'version': '1.0.0'}
摘要
今天，我们讨论了使用 python 的漂亮打印。我们学习了如何以更漂亮的方式打印 JSON 文件。我们也用了两种方法，得到了相同的结果。希望你也喜欢它。我们必须带着一些更有趣的话题再次访问。
Python 中图像数据的主成分分析
原文：https://www.askpython.com/python/examples/principal-component-analysis-for-image-data
我们已经在之前的文章中研究过 PCA。在本文中，让我们对图像数据进行主成分分析。主成分分析是一种著名的无监督降维技术，每当维数灾难困扰我们时，它就来拯救我们。
使用影像数据与通常的数据集略有不同。一幅典型的彩色图像是由微小的像素(简称为“像素”)组成的，许多像素以阵列的形式聚集在一起形成一幅数字图像。
典型的数字图像是通过堆叠强度范围从 0 到 255 的红、蓝和绿像素阵列制成的。
RGB Arrays Combined To Make Digital Image
灰度图像不包含颜色，只包含灰色阴影。灰度图像的像素强度从黑色(0 强度)到白色(255 全强度)不等，这就是我们通常所说的黑白图像。
将主成分分析应用于数字数据集
数字数据集是具有 1797 个 8×8 图像的手写数字的灰度图像数据集。
#importing the dataset
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_digits
digits = load_digits()
data = digits.data
data.shape
sklearn.datasets模块通过导入load_digits类来快速导入数字数据。数字数据的形状是(1797，64)。展平 8×8 像素，为每个图像创建长度为 64 的向量。
让我们看看我们的数据是什么样的。
#taking a sample image to view
#Remember image is in the form of numpy array.
image_sample = data[0,:].reshape(8,8)
plt.imshow(image_sample)
Sample Image from Digit Dataset
1.缩小图像尺寸
现在，使用 PCA，让我们将图像尺寸从 64 减少到 2，这样我们就可以使用散点图来可视化数据集。
sklearn 为我们提供了一个非常简单的 PCA 实现。
#Import required modules
from sklearn.decomposition import PCA
pca = PCA(2) # we need 2 principal components.
converted_data = pca.fit_transform(digits.data)
converted_data.shape
数据从(1797，64)减少到(1797，2)。
2.可视化生成的数据集
我们将使用sklearn.decomposition提供的PCA()类来实现主成分分析算法。
它接受整数作为输入参数，描述我们希望转换后的数据集中主成分的数量。
我们也可以传递一个小于 1 的浮点值，而不是一个整数。即 PCA(0.90)，这意味着该算法将找到解释数据中 90%方差的主成分。
让我们想象一下结果。
plt.style.use('seaborn-whitegrid')
plt.figure(figsize = (10,6))
c_map = plt.cm.get_cmap('jet', 10)
plt.scatter(converted_data[:, 0], converted_data[:, 1], s = 15,
cmap = c_map , c = digits.target)
plt.colorbar()
plt.xlabel('PC-1') , plt.ylabel('PC-2')
plt.show()
Visualizing Digits Data In 2 Dimensions
图像数据压缩的主成分分析
PCA 的另一个很酷的应用是图像压缩。让我们来看看如何用 python 来实现这一点。
# Importing required libraries
import cv2
import numpy as np
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
1.加载图像
我们将使用 OpenCV (开源计算机视觉库)。 OpenCV 是一个开源的计算机视觉和机器学习库。
# Loading the image
img = cv2.imread('my_doggo_sample.jpg') #you can use any image you want.
plt.imshow(img)
Sample Original Image Output
2.将图像分割成 R、G、B 阵列
众所周知，数字彩色图像是 R、G 和 B 阵列相互堆叠的组合。这里，我们必须从图像中分离每个通道，并从每个通道中提取主成分。
# Splitting the image in R,G,B arrays.
blue,green,red = cv2.split(img)
#it will split the original image into Blue, Green and Red arrays.
这里要注意的重要一点是，OpenCV 将分成蓝色、绿色和红色通道，而不是红色、蓝色和绿色。请注意这里的顺序。
3.将主成分应用于单个阵列
现在，对每个阵列应用 PCA。
#initialize PCA with first 20 principal components
pca = PCA(20)
#Applying to red channel and then applying inverse transform to transformed array.
red_transformed = pca.fit_transform(red)
red_inverted = pca.inverse_transform(red_transformed)
#Applying to Green channel and then applying inverse transform to transformed array.
green_transformed = pca.fit_transform(green)
green_inverted = pca.inverse_transform(green_transformed)
#Applying to Blue channel and then applying inverse transform to transformed array.
blue_transformed = pca.fit_transform(blue)
blue_inverted = pca.inverse_transform(blue_transformed)
这里，我们应用 PCA，仅保留前 20 个主成分，并将其分别应用于 RGB 阵列。
4.压缩图像
逆变换对于重新创建基础图像的原始尺寸是必要的。
在从缩减的维度重建原始维度的过程中，由于我们只保留选定的主成分，在本例中为 20 个，因此丢失了一些信息。
img_compressed = (np.dstack((red_inverted, red_inverted, red_inverted))).astype(np.uint8)
使用dstack函数堆叠倒置的数组。这里指定数组的数据类型很重要，因为大多数图像是 8 位的。每个像素由一个 8 位字节表示。
#viewing the compressed image
plt.imshow(img_compressed)
Compressed Image With First 20 Principal Components
上面的输出是我们只考虑 20 个主成分时得到的结果。
如果我们增加主成分的数量，输出图像将变得清晰。
使用前 50 个主成分:
Compressed Image With First 50 Principal Components
现在，用 100 个主成分:
Compressed Image With First 100 Principal Components
有了前 100 个主成分，我们的输出变得更加清晰。现在让我们使用前 200 个主成分来应用 PCA。
Compressed Image With First 200 Principal Components
瞧啊。有了 200 个主要成分，我们就能创造出和原始图像一样清晰的图像。
要考虑的元件数量完全是任意的。从某个小值开始，逐渐增加，直到达到所需的输出。请随意试验这些代码。
结论
在本文中，我们探索了 PCA 作为降维技术的应用，并将其应用于图像数据。我们还看到了 PCA 如何在图像压缩中得到应用。
快乐学习！
Python 中从头开始的主成分分析
原文：https://www.askpython.com/python/examples/principal-component-analysis
主成分分析，简称 PCA，是一种著名的降维技术。
它自 1901 年以来一直存在，并且仍然被用作机器学习和统计中的主要降维方法。PCA 是一种无监督的统计方法。
在本文中，我们将对 PCA 有一些直觉，并将使用 Python 和 NumPy 从头开始自己实现它。
为什么首先要使用 PCA？
为了支持使用 PCA 的原因，让我们看一个例子。
假设我们有一个数据集，它有两个变量和 10 个数据点。如果要求我们将数据点可视化，我们可以非常容易地做到。结果也很好解释。
| X1 | Two | eight | one | four | Twenty-two | Fifteen | Twenty-five | Twenty-nine | four | Two |
| X2 | three | six | Two | six | Eighteen | Sixteen | Twenty | Twenty-three | six | four |
Example Data points
Plotting Data On Two Dimensions
现在，如果我们试图增加变量的数量，我们几乎不可能想象出比三维更高的维度。
我们在分析高维数据集时面临的这个问题就是通常所说的“”维度的诅咒。这个术语是由理查德·e·贝尔曼首先提出的。
主成分分析将高维数据降低到较低的维度，同时捕捉数据集的最大可变性。数据可视化是 PCA 最常见的应用。PCA 还用于通过减少数据的维数来使算法的训练更快。
用 python 实现主成分分析
为了从下面给出的内容中获得最大的直觉，我们假设你必须了解一点线性代数和矩阵。如果没有，那么我们强烈建议你在 YouTube 上观看格兰特·桑德森的 3Blue1Brown 的线性代数系列，以重温这些概念，因为它将被证明对你未来的机器学习之旅非常有益。
我们可以认为主成分分析就像将一个 n 维椭球体拟合到数据上，使得椭球体的每个轴都代表一个主成分。主成分轴越大，它所代表的数据的可变性就越大。
*
Example: Fitting An Ellipse To Data*
用 Python 实现 PCA 的步骤
*#Importing required libraries
import numpy as np*
1.减去每个变量的平均值
从数据集中减去每个变量的平均值，使数据集以原点为中心。事实证明，这样做在计算协方差矩阵时非常有用。
*#Generate a dummy dataset.
X = np.random.randint(10,50,100).reshape(20,5)
# mean Centering the data
X_meaned = X - np.mean(X , axis = 0)*
由上述代码生成的数据具有维度(20，5)，即 20 个示例和每个示例的 5 个变量。我们计算了每个变量的平均值，并从相应列的每一行中减去它。
2.计算协方差矩阵
计算以平均值为中心的数据的协方差矩阵。你可以在这篇内容丰富的维基百科文章中了解更多关于协方差矩阵的信息。
协方差矩阵是表示元素之间的协方差的方阵。一个元素与其自身的协方差只不过是它的方差。
这就是为什么协方差矩阵的对角元素就是元素的方差。
*# calculating the covariance matrix of the mean-centered data.
cov_mat = np.cov(X_meaned , rowvar = False)*
我们可以发现用numpy.cov( )方法很容易计算协方差矩阵。rowvar的默认值设置为True，记住将其设置为False以获得所需维度的协方差矩阵。
3.计算特征值和特征向量
现在，计算协方差矩阵的特征值和特征向量。我们得到的协方差矩阵的特征向量是相互正交的，每个向量代表一个主轴。
较高的特征值对应于较高的可变性。因此，具有较高特征值的主轴将是捕捉数据中较高可变性的轴。
正交意味着向量相互垂直。特征值和向量看起来很吓人，直到我们得到背后的思想和概念。
*#Calculating Eigenvalues and Eigenvectors of the covariance matrix
eigen_values , eigen_vectors = np.linalg.eigh(cov_mat)*
NumPy linalg.eigh( )方法返回一个复埃尔米特或实对称矩阵的特征值和特征向量。
4.按降序排列特征值
按照降序对特征值及其对应的特征向量进行排序。
请记住，特征向量矩阵中的每一列都对应一个主成分，因此按照特征值的降序排列它们将自动按照可变性的降序排列主成分。
因此，我们重新排列的特征向量矩阵中的第一列将是捕获最高可变性的主分量。
*#sort the eigenvalues in descending order
sorted_index = np.argsort(eigen_values)[::-1]
sorted_eigenvalue = eigen_values[sorted_index]
#similarly sort the eigenvectors
sorted_eigenvectors = eigen_vectors[:,sorted_index]*
np.argsort返回相同形状的索引数组。
5.从重新排列的特征值矩阵中选择子集
根据我们的需要从重新排列的特征值矩阵中选择一个子集，即 number_comp = 2。这意味着我们选择了前两个主成分。
*# select the first n eigenvectors, n is desired dimension
# of our final reduced data.
n_components = 2 #you can select any number of components.
eigenvector_subset = sorted_eigenvectors[:,0:n_components]*
n_components = 2 意味着我们的最终数据应该减少到只有 2 个变量。如果我们把它改成 3，那么我们的数据就减少到 3 个变量。
6.转换数据
最后，通过在特征向量子集的转置和以平均值为中心的数据的转置之间进行点积来变换数据。通过对换点积的结果，我们得到的结果是数据从较高的维度降低到较低的维度。
*#Transform the data
X_reduced = np.dot(eigenvector_subset.transpose(),X_meaned.transpose()).transpose()*
X_reduced 的最终维数将是(20，2)，而最初数据的维数更高(20，5)。
现在，我们可以用现有的工具来可视化我们的数据。万岁！任务完成。
Python 中主成分分析的完整代码
现在，让我们通过建立一个函数来结合上面的一切，并在一个例子上从头开始尝试我们的主成分分析。
*import numpy as np
def PCA(X , num_components):
#Step-1
X_meaned = X - np.mean(X , axis = 0)
#Step-2
cov_mat = np.cov(X_meaned , rowvar = False)
#Step-3
eigen_values , eigen_vectors = np.linalg.eigh(cov_mat)
#Step-4
sorted_index = np.argsort(eigen_values)[::-1]
sorted_eigenvalue = eigen_values[sorted_index]
sorted_eigenvectors = eigen_vectors[:,sorted_index]
#Step-5
eigenvector_subset = sorted_eigenvectors[:,0:num_components]
#Step-6
X_reduced = np.dot(eigenvector_subset.transpose() , X_meaned.transpose() ).transpose()
return X_reduced*
我们定义了一个名为 PCA 的函数，接受数据矩阵和组件数量作为输入参数。
我们将使用虹膜数据集并对其应用 PCA 函数。
*import pandas as pd
#Get the IRIS dataset
url = "https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data"
data = pd.read_csv(url, names=['sepal length','sepal width','petal length','petal width','target'])
#prepare the data
x = data.iloc[:,0:4]
#prepare the target
target = data.iloc[:,4]
#Applying it to PCA function
mat_reduced = PCA(x , 2)
#Creating a Pandas DataFrame of reduced Dataset
principal_df = pd.DataFrame(mat_reduced , columns = ['PC1','PC2'])
#Concat it with target variable to create a complete Dataset
principal_df = pd.concat([principal_df , pd.DataFrame(target)] , axis = 1)*
重要提示:在对数据应用任何 ML 算法之前，我们应该标准化数据。在上面的代码中，我们没有标准化我们的数据，但是我们在实现 PCA 的时候做到了。
让我们使用 seaborn 和 matplotlib 库来绘制我们的结果。
*import seaborn as sb
import matplotlib.pyplot as plt
plt.figure(figsize = (6,6))
sb.scatterplot(data = principal_df , x = 'PC1',y = 'PC2' , hue = 'target' , s = 60 , palette= 'icefire')*
*
Reduced Dimension Plot*
就是这样！效果非常好。
结论
在本文中，我们已经了解了 PCA，PCA 是如何工作的，并使用 NumPy 实现了 PCA。快乐学习！
打印 Python 列表的 3 种简单方法
原文：https://www.askpython.com/python/list/print-a-python-list
读者朋友们，你们好！在本文中，我们将关注打印 Python 列表的不同方法。所以，让我们开始吧！
首先，什么是 Python 列表？
Python 为我们提供了各种数据结构来存储和处理数据。名单就是其中之一。
Python List 是存储可变数据值序列的数据结构。此外，列表可以被认为是元素的有序集合，即它们遵循元素的顺序。
现在让我们关注一些打印列表元素的技术。
1.使用 map()函数打印 Python 列表
Python map() 函数可以和 join() 函数联合使用，轻松打印 Python 列表。
语法:
''.join(map(str,list))
举例:
lst = [10,20,30,'John',50,'Joe']
print("Elements of the List:\n")
print('\n'.join(map(str, lst)))
说明:
- 首先，我们应用 map 方法，将列表中的值转换为字符串，也就是说，我们将它们映射为字符串格式。
- 然后，我们应用 join 方法来组装元素，并包含一个新行来分隔元素。
输出:
Elements of the List:
10
20
30
John
50
Joe
2.使用' * '符号打印 Python 列表
接下来，我们将使用 Python ' '符号*来打印一个列表。
语法:
*list
我们可以通过包含 sep 值来定制输出。下面，我们将分隔值设置为一个换行符。
举例:
lst = [10,20,30,'John',50,'Joe']
print("Elements of the List:\n")
print(*lst, sep = "\n")
输出:
Elements of the List:
10
20
30
John
50
Joe
3.简单的方法——使用 for 循环
作为初学者，天真的方法总是最好的入门方法！
在这个方法中，我们使用循环的遍历列表的每个元素，然后在这里打印一个 Python 列表。
语法:
for element in list:
print(element)
举例:
lst = [10,20,30,'John',50,'Joe']
print("Elements of the List:\n")
for x in lst:
print(x)
输出:
Elements of the List:
10
20
30
John
50
Joe
结论
如上所述，这些是打印 Python 列表的不同方式。当然，我们可以用更多的方法来做同样的事情。但是我相信，方法 1 和 2(上面讨论过的)仍然很突出。
这个话题到此结束。更多与 Python 相关的话题，敬请关注，在此之前，请继续与我们一起学习和成长！！🙂
如何在 Python 中打印数组
原文：https://www.askpython.com/python/array/print-an-array-in-python
介绍
在本教程中，我们将学习如何用 Python 打印一个数组。
所以在我们进入主题之前，让我们了解一下 Python 中的数组。
Python 数组
数组是同名同类型数据元素的集合。在 Python 中，我们可以使用列表或 NumPy 模块来实现数组。NumPy 模块为我们提供了类型为ndarray (NumPy Array)的数组。
此外，阵列可以是多维的。我们知道，多维数组最简单的形式是二维数组。因此，在本教程中，我们将同时考虑 1D 和 2D 阵列。
用 Python 打印数组的方法
现在，让我们看看用 Python 打印 1D 和 2D 数组的一些方法。注意:这些数组将使用列表来实现。
使用 print()方法直接打印
我们可以直接将包含要打印的值的数组 (list)的名称传递给 Python 中的print()方法进行打印。
但是在这种情况下，数组以列表的形式打印出来，即带有括号和逗号分隔的值。
arr = [2,4,5,7,9]
arr_2d = [[1,2],[3,4]]
print("The Array is: ", arr) #printing the array
print("The 2D-Array is: ", arr_2d) #printing the 2D-Array
输出:
The Array is: [2, 4, 5, 7, 9]
The 2D-Array is: [[1, 2], [3, 4]]
这里，arr是一维数组。而arr_2d是二维的。我们直接将它们各自的名字传递给print()方法，分别以列表和列表列表的形式打印出来。
在 Python 中使用 for 循环
我们也可以用 Python 打印一个数组，方法是使用for循环遍历所有相应的元素。
让我们看看如何。
arr = [2,4,5,7,9]
arr_2d = [[1,2],[3,4]]
#printing the array
print("The Array is : ")
for i in arr:
print(i, end = ' ')
#printing the 2D-Array
print("\nThe 2D-Array is:")
for i in arr_2d:
for j in i:
print(j, end=" ")
print()
输出:
The Array is :
2 4 5 7 9
The 2D-Array is:
1 2
3 4
在上面的代码中，我们使用 for 循环遍历了一个 1D 以及一个 2D 数组的元素，并以我们想要的形式打印出相应的元素。
用 Python 打印 NumPy 数组的方法
如前所述，我们还可以使用 NumPy 模块在 Python 中实现数组。该模块带有一个预定义的数组类，可以保存相同类型的值。
这些 NumPy 数组也可以是多维的。所以，让我们看看如何用 Python 打印出 1D 以及 2D NumPy 数组。
使用 print()方法
类似于使用列表实现数组的情况，我们可以直接将 NumPy 数组名传递给print()方法来打印数组。
import numpy as np
arr_2d = np.array([[21,43],[22,55],[53,86]])
arr = np.array([1,2,3,4])
print("Numpy array is: ", arr) #printing the 1d numpy array
print("Numpy 2D-array is: ", arr_2d) #printing the 2d numpy array
输出:
Numpy array is: [1 2 3 4]
Numpy 2D-array is: [[21 43]
[22 55]
[53 86]]
这里，arr和arr_2d分别是一个 1D 和一个 2D NumPy 数组。我们将它们的名字传递给print()方法并打印它们。注意:这次数组也以带括号的 NumPy 数组的形式打印。
使用 for 循环
同样，我们也可以使用循环结构遍历 Python 中的 NumPy 数组。这样我们就可以访问数组的每个元素并打印出来。这是用 Python 打印数组的另一种方式。
仔细看下面的例子。
import numpy as np
arr = np.array([11,22,33,44])
arr_2d = np.array([[90,20],[76,45],[44,87],[73,81]])
#printing the numpy array
print("The Numpy Array is : ")
for i in arr:
print(i, end = ' ')
#printing the numpy 2D-Array
print("\nThe Numpy 2D-Array is:")
for i in arr_2d:
for j in i:
print(j, end=" ")
print()
输出:
The Numpy Array is :
11 22 33 44
The Numpy 2D-Array is:
90 20
76 45
44 87
73 81
这里我们也通过分别访问 1D 和 2D 数组的元素，以我们想要的方式打印 NumPy 数组的元素(没有括号)。
结论
所以在本教程中，我们学习了如何用 Python 打印一个数组。我希望你现在对这个话题有一个清晰的理解。关于这个话题的任何进一步的问题，请随意使用评论。
参考
- Python 中的数组–ask Python 教程，
- NumPy 数组介绍–ask python 帖子。
用 Python 打印列名的 3 种简单方法
原文：https://www.askpython.com/python-modules/pandas/print-column-names-in-python
读者朋友们，你们好！在本文中，我们将关注用 Python 打印列名的不同方式。
所以，让我们开始吧！
首先，在 Python 中哪里可以找到列？
我们经常会遇到这样的问题和问题陈述:我们觉得需要处理 excel 或 csv 文件中的数据，即以行和列的形式。
Python 作为一种编程语言，为我们提供了一种叫做‘data frame’的数据结构来处理行和列。
一个 Python 数据帧 由行和列组成，而 Pandas 模块为我们提供了各种函数来操作和处理这些行和列中的数据。
今天，我们将了解获取和显示数据帧或 csv 文件的列标题/名称的各种不同方法。
我们将在下面的例子中引用下面的 csv 文件
Dataset-Bank Loan
1.使用 pandas.dataframe.columns 在 Python 中打印列名
我们可以使用pandas.dataframe.columns变量轻松打印列标签或标题。看看下面的语法！
data.columns
举例:
import pandas
file = pandas.read_csv("D:/Edwisor_Project - Loan_Defaulter/bank-loan.csv")
for col in file.columns:
print(col)
在本例中，我们已经将 csv 文件加载到环境中。此外，我们使用 dataframe.columns 变量通过 for 循环打印了列名。
输出:
age
ed
employ
address
income
debtinc
creddebt
othdebt
default
2.使用 pandas . data frame . columns . values
Python 为我们提供了pandas.dataframe.columns.values来从 dataframe 或 csv 文件中提取列名并打印出来。
语法:
data.columns.values
举例:
import pandas
file = pandas.read_csv("D:/Edwisor_Project - Loan_Defaulter/bank-loan.csv")
print(file.columns.values)
因此，data.columns.values 为我们提供了数据帧中的列名/标题的列表。
输出:
['age' 'ed' 'employ' 'address' 'income' 'debtinc' 'creddebt' 'othdebt' 'default']
3.Python sorted()方法来获取列名
Python 的sorted()方法可以用来获得一个数据帧的列名列表，列的顺序是、、、。
看看下面的语法！
语法:
sorted(dataframe)
举例:
import pandas
file = pandas.read_csv("D:/Edwisor_Project - Loan_Defaulter/bank-loan.csv")
print(sorted(file))
输出:
['address', 'age', 'creddebt', 'debtinc', 'default', 'ed', 'employ', 'income', 'othdebt']
结论
到此，我们就结束了这个话题。我希望这篇文章对你来说是一个针对单个问题陈述的不同解决方案的技巧。
更多与 Python 相关的帖子，敬请关注，在此之前，祝你学习愉快！！🙂
使用 PySpark 打印数据——完整指南
原文：https://www.askpython.com/python-modules/print-data-using-pyspark
现在让我们学习如何使用 PySpark 打印数据。数据是当今可用的最基本的东西之一。它可以以加密或解密格式提供。事实上，我们也倾向于每天创建大量的信息。无论是点击智能手机上的按钮还是在电脑上上网。但是，为什么我们要谈论这么多呢？
前几年研究人员遇到的主要问题是如何管理如此大量的信息？技术是这个问题的答案。Apache Spark 应运而生，并构建出 PySpark 来解决这个问题。
如果你是 PySpark 的新手，这里有一个 PySpark 教程可以帮你入门。
使用 Pyspark 介绍 spark
Apache Spark 是一个数据管理引擎，它帮助我们发明与大型软件开发项目的分析相关的解决方案。
也是大数据工程师和数据科学家的选择工具。了解 Spark 是各种科技公司招聘的必备技能之一。
它附带了许多扩展和管理选项。其中之一是来自 Python 并面向 Python 开发者的 Pyspark 。这是支持在每台计算机中明确安装库的 API 之一。因此，这可以很容易地管理实现。众所周知，在 python 中安装库非常容易。
在我们使用 PySpark 打印数据之前
在我们开始学习使用 PySpark 打印数据的不同方式之前，我们需要考虑一些先决条件:
- 对 Python 的核心理解
- 对 Pyspark 及其支持包的核心理解。
- Python 3.6 及以上版本
- Java 1.8 及以上版本(最必需)
- 像 Jupyter Notebook 或者 VS 代码这样的 IDE。
要进行同样的检查，请转到命令提示符并键入命令:
python --version
java -version
Version Check
您可以通过以下方式使用 PySpark 打印数据:
- 打印原始数据
- 格式化打印数据
- 显示前 20-30 行
- 显示底部 20 行
- 显示前排序数据
教程剩余部分使用的资源和工具:
- 数据集:titanic . CSV
- 环境: 蟒蛇
- IDE: Jupyter 笔记本
创建会话
spark 环境中的会话是我们活动的所有实例的记录持有者。为了创建它，我们使用 spark 库中的 SQL 模块。
这个 SparkSession 类有一个 builder 属性，它有一个 appname() 函数。这个函数将应用程序的名称作为一个字符串形式的参数。
然后我们使用 getOrCreate() 方法创建应用程序，该方法使用点“.”调用操作员。使用这些代码，我们创建了名为“ App 的应用程序。
给我们创建的应用程序起任何名字都是完全自由的。 永远不要忘记创建一个会话，因为我们无法继续。
代码:
import pyspark
from pyspark.sql import SparkSession
session = SparkSession.builder.appName('App').getOrCreate() # creating an app
Creating A Session
使用 PySpark 打印数据的不同方法
既然你都准备好了，让我们进入正题。现在我们将在这里学习使用 PySpark 打印数据的不同方法。
1.打印原始数据
在本例中，我们将使用原始数据集。在 【人工智能】 领域中，我们将一组数据称为数据集。
它有多种形式，如 excel、逗号分隔值文件、文本文件或服务器文档模型。所以，记录下我们打印原始数据时使用的文件格式。
在这个例子中，我们使用了一个扩展名为 a .csv 的数据集。会话的 read 属性具有读取文件的各种功能。
这些函数通常根据不同的文件类型来命名。因此，我们对数据集使用 csv()函数。我们把一切都存储在数据变量中。
代码:
data = session.read.csv('Datasets/titanic.csv')
data # calling the variable
默认情况下，Pyspark 以字符串的形式读取所有数据。因此，我们调用我们的数据变量，然后它以字符串的形式返回每一列及其编号。
要打印原始数据，请使用点运算符-调用带有数据变量的 show() 函数
data.show()
Reading The Dataset
2.格式化数据
在 Pyspark 中格式化数据意味着显示数据集中出现的列的适当的数据类型。为了显示所有的标题，我们使用了选项()函数。这个函数接受两个字符串形式的参数。
- 键
- 价值
对于键参数，我们给出的值为头，值为真。这样做的目的是，它将扫描需要显示的标题，而不是顶部的列号。
最重要的是扫描每一列的数据类型。为此，我们需要激活 csv()函数中的 inferschema 参数，我们之前使用它来读取数据集。它是布尔数据类型的一个参数，也就是说，我们需要设置它为真来激活它。我们用点运算符连接每个函数。
代码:
data = session.read.option('header', 'true').csv('Datasets/titanic.csv', inferSchema = True)
data
data.show()
Showing The Data In Proper Format
输出:
正如我们所看到的，适当的数据类型的标题是可见的。
3.显示前 20-30 行
要显示前 20-30 行，我们只用一行代码就可以做到。 show() 函数为我们做到了这一点。如果数据集太大，默认情况下将显示前 20 行。但是，我们可以让它显示尽可能多的行。Jut 将该数字作为参数放入 show() 函数中。
data.show() # to display top 20 rows
Showing Top 20 Rows
data.show(30) # to display top 30 rows
Showing Top 30 Rows
我们可以使用 head() 函数实现同样的功能。该函数专门提供对数据集最顶端部分的行的访问。它将行数作为参数，按照行数显示。例如，显示前 10 行
data.head(10)
但是，结果是以数组或列表的形式。最令人失望的是，我们不能将 head()函数用于具有数千行的大型数据集。这就是证据。
Using The Head Method To Print First 10 Rows
4.显示底部的 20-30 行
这也是一个简单的任务。tail()函数可以帮助我们做到这一点。用数据框变量调用它，然后给出我们希望作为参数显示的行数。例如，要显示最后 20 行，我们将代码编写为:
data.tail(20)
Showing Botton 20 Rows
同样，我们也不能对此做出任何正确的看法，因为我们的数据集太大，无法显示这样的行。
5.显示前对数据进行排序
分类是我们把东西按正确的顺序摆放的过程。这可以是从上升–由小变大或者从下降–由大变小。这在按顺序查看数据点时起着重要的作用。数据框中的列可以是各种类型。但是，两种主要类型是整数和字符串。
- 对于整数，排序是根据较大和较小的数字。
- 对于字符串排序是根据字母顺序。
Pyspark 中的 sort()函数仅用于此目的。它可以将一列或多列作为内部参数。让我们在数据集上尝试一下。我们将对数据集中的 PassengerID 列进行排序。为此，我们有两个函数。
- sort()
- orderBy()
按升序排序
data = data.sort('PassengerId')
data.show(5)
Sorting A Single Column 1
PassengerID 列已经排序。该代码将所有元素按升序排列。这里我们只对一列进行排序。要对多个列进行排序，我们可以在 sort()函数中逐个传递它们，用逗号分隔。
data = data.sort('Name', 'Fare')
data.show(5)
Sorting Multple Columns
按降序排序
这是专门针对 orderBy() 函数的。这个函数提供了一个特殊的选项来对我们的数据进行降序排序。
在这种情况下，所有代码都保持不变，只是在插入列并使用点运算符将其连接后，我们调用了 orderBy() 中的 desc() 函数。
desc() 按降序对齐或排序那些特定列的所有元素。
首先，让我们看一下数据集中的所有列。
代码:
*data.columns*
*
Columns Record*
在下面的代码中，我们将对名称和费用列进行排序。该名称属于字符串数据类型，因此将根据字母顺序进行排序。而 Fare 是一个数字，所以它会是一个大-小的模式。
代码:
*data = data.orderBy(data.Name.desc(), data.Fare.desc())
data.show(5)*
*
Sorting In Descending Order*
结论
这就是我们如何使用 Pyspark 打印数据的全部内容。每一个代码都很短，理解起来很甜蜜。这足以获得 spark 函数的代码知识。这种环境对于大数据以及其他行业和技术领域来说非常强大。
用 Python 实现概率分布(实现示例)
原文：https://www.askpython.com/python/examples/probability-distributions
概率分布是描述随机变量在给定范围内所有可能值和可能性的数学函数。
概率分布有助于模拟随机现象，使我们能够估计某一事件发生的概率。
在本文中，我们将使用 Python 实现并可视化一些常用的概率分布
常见概率分布
最常见的概率分布如下:
- 均匀分布
- 二项分布
- 泊松分布
- 指数分布
- 正态分布
让我们用 Python 来实现每一个。
1.均匀分布
均匀分布在给定的连续值范围内定义了相等的概率。换句话说，它是一个概率不变的分布。
区间[a，b]上连续均匀分布的概率密度函数为:
Uniform Distribution
示例–当掷出六面骰子时，每一面都有 1/6 的机会。
使用 scipy 模块在 Python 中实现和可视化均匀概率分布。
#Importing required libraries
from scipy.stats import uniform
import seaborn as sb
import matplotlib.pyplot as plt
import numpy as np
#taking random variables from Uniform distribution
data = uniform.rvs(size = 100000, loc = 5, scale=10)
#Plotting the results
sb.set_style('whitegrid')
ax = sb.distplot(data, bins = 30, color = 'k')
ax.set(xlabel = 'interval')
plt.show()
Uniform Distribution Plot
scipy.stats模块有一个uniform类，其中第一个参数是下限，第二个参数是分布的范围。
loc–下限。scale–分布范围。
例如，如果我们想从 5 到 15 范围内的均匀分布中随机选取值。那么loc参数将为 5，因为它是下限。scale参数将被设置为 10，如果我们添加loc和scale，我们将得到 15 作为上限。
2.二项分布
二项分布是离散概率分布。它有参数 n 和 p ，其中 p 是成功的概率，n 是试验的次数。
假设我们有一个要么成功要么失败的实验:
- 我们有成功的可能性
- 那么二项式 pmf 可以告诉我们观察到 k 的概率
- 如果实验进行了 n 次 次。
二项分布的概率质量函数为:
PMF of Binomial Distribution
#Importing required modules
import seaborn as sb
import matplotlib.pyplot as plt
import numpy as np
from scipy.stats import binom
#Applying the binom class
pb = binom(n = 20, p = 0.6)
x = np.arange(1,21)
pmf = pb.pmf(x)
#Visualizing the distribution
sb.set_style('whitegrid')
plt.vlines(x ,0, pb.pmf(x), colors='k', linestyles='-', lw=5)
plt.ylabel('Probability')
plt.xlabel('Intervals')
plt.show()
Binomial Distribution Plot
scipy.stats模块有binom类，需要以下输入参数:
- n =间隔数
- p =成功的概率
binom 类有。pmf 方法要求区间数组作为输入自变量，输出结果是相应的概率值。
二项分布
这是 n = 1 的二项式分布的特殊情况。换句话说，它是一个单次试验的二项分布。
伯努利分布的概率质量函数由下式给出:
Bernoulli Distribution
#Importing the required modules
import seaborn as sb
import matplotlib.pyplot as plt
import numpy as np
from scipy.stats import bernoulli
#Applying the bernoulli class
data = bernoulli.rvs(size = 1000 , p = 0.8)
#Visualizing the results
sb.set_style('whitegrid')
sb.displot(data, discrete=True, shrink=.8 , color = 'k')
plt.show()
Bernoulli Distribution Plot
我们需要指定概率p作为bernoulli类对象的输入参数。为了从分布中选取随机值，伯努利类有一个.rvs方法，它采用一个可选的大小参数(要选取的样本数)。
3.泊松分布
它给出了给定数量的事件在固定时间间隔内发生的概率，如果这些事件以已知的恒定平均速率发生并且彼此独立。
平均速率也称为λ(λ)。
假设我们拥有一家水果店，平均每 10 分钟就有 3 名顾客来到店里。这里的平均速率是 3 或 λ = 3。泊松概率分布可以帮助我们回答这样的问题，比如 5 个客户在接下来的 10 分钟内到达的概率是多少？
概率质量函数由下式给出:
PMF of Poisson Distribution
#Importing the required modules
import seaborn as sb
import matplotlib.pyplot as plt
import numpy as np
from scipy.stats import poisson
#Applying the poisson class methods
x = np.arange(0,10)
pmf = poisson.pmf(x,3)
#Visualizing the results
sb.set_style('whitegrid')
plt.vlines(x ,0, pmf, colors='k', linestyles='-', lw=6)
plt.ylabel('Probability')
plt.xlabel('intervals')
plt.show()
Poisson Distribution Plot
来自scipy.stats模块的poisson类只有一个形状参数:mu，也就是上面公式中的 rate。.pmf将返回相应输入数组值的概率值。
4.指数分布
在概率统计中，指数分布是泊松点过程中事件之间时间的概率分布。指数分布描述了连续过程改变状态的时间。
泊松分布处理一个事件在给定时期内发生的次数，指数分布处理这些事件之间的时间间隔。
指数分布可以看作是几何分布的连续对应物。
Exponential Distribution Pdf
这里的 λ > 0 是分布的参数，通常称为率参数。
#Importing required modules
import seaborn as sb
import matplotlib.pyplot as plt
import numpy as np
from scipy.stats import expon
#Applying the expon class methods
x = np.linspace(0.001,10, 100)
pdf = expon.pdf(x)
#Visualizing the results
sb.set_style('whitegrid')
plt.plot(x, pdf , 'r-', lw=2, alpha=0.6, label='expon pdf' , color = 'k')
plt.xlabel('intervals')
plt.ylabel('Probability Density')
plt.show()
Exponential Distribution Plot
scipy.stats 模块的expon类的输入参数如下:
x: 分位数loc: 【可选】位置参数。默认值= 0scale: 【可选】刻度参数。默认= 1
为了计算给定区间的概率密度，我们使用.pdf方法。
5.正态分布
一个 正态分布 也被称为高斯分布或者著名的钟形曲线。
正态分布的概率密度函数(pdf ):
Normal Distribution
其中，μ =平均值，σ =标准差，x =输入值。
# import required libraries
from scipy.stats import norm
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sb
# Creating the distribution
data = np.arange(1,10,0.01)
pdf = norm.pdf(data , loc = 5.3 , scale = 1 )
#Visualizing the distribution
sb.set_style('whitegrid')
sb.lineplot(data, pdf , color = 'black')
plt.ylabel('Probability Density')
Normal Distribution Plot
scipy.stats模块有norm类用于实现正态分布。
location loc关键字指定了平均值。scale scale关键字在上面的代码中指定了标准偏差。
为了计算给定区间的概率密度，我们使用提供了loc和scale自变量的.pdf方法。
结论
在本文中，我们使用scipy.stats模块实现了一些非常常用的概率分布。我们也对不同分布的形状有了直观的了解。
快乐学习！
如何用 Python 处理 PDF 文件中的文本？
原文：https://www.askpython.com/python/examples/process-text-from-pdf-files
pdf 是共享文本的常用方式。 PDF 代表 可移植文档格式 ，使用 。pdf 文件扩展名。它是由 Adobe Systems 在 20 世纪 90 年代早期创建的。
使用 python 阅读 PDF 文档可以帮助您自动化各种各样的任务。
在本教程中，我们将学习如何用 Python 从 PDF 文件中提取文本。
让我们开始吧。
用 Python 从 PDF 文件中读取和提取文本
出于本教程的目的，我们正在创建一个 2 页的 PDF 样本。你可以使用任何文字处理软件，如微软 Word 或谷歌文档，将文件保存为 PDF 格式。
第 1 页上的文本:
Hello World.
This is a sample PDF with 2 pages.
This is the first page.
第 2 页的文本:
This is the text on Page 2\.
使用 PyPDF2 提取 PDF 文本
您可以使用 PyPDF2 从 PDF 中提取文本。让我们看看它是如何工作的。
1.安装软件包
要在您的系统上安装 PyPDF2，请在终端上输入以下命令。你可以阅读更多关于 pip 包管理器的信息。
pip install pypdf2
Pypdf
2.导入 PyPDF2
打开一个新的 python 笔记本，开始导入 PyPDF2。
import PyPDF2
3.以读取二进制模式打开 PDF
使用以下代码行，在读取二进制模式下打开 PDF:
pdf = open('sample_pdf.pdf', 'rb')
这将为我们的 PDF 创建一个 PdfFileReader 对象，并将其存储到变量' pdf '中。
4.使用 PyPDF2。PdfFileReader()来读取文本
现在您可以使用 PyPDF2 中的 PdfFileReader ()方法来读取文件。
pdfReader = PyPDF2.PdfFileReader(pdf)
要从 PDF 的第一页获取文本，请使用以下代码行:
page_one = pdfReader.getPage(0)
print(page_one.extractText())
我们得到的输出为:
Hello World.
!This is a sample PDF with 2 pages. !This is the first page. !
Process finished with exit code 0
这里我们使用 getPage 方法将页面存储为一个对象。然后我们使用 extractText()方法从页面对象中获取文本。
我们得到的文本属于类型 String。
同样，要从 PDF 获取第二页，请使用:
page_one = pdfReader.getPage(1)
print(page_one.extractText())
我们得到的输出为:
This is the text on Page 2\.
使用 PyPDF2 读取 PDF 文本的完整代码
本节的完整代码如下所示:
import PyPDF2
pdf = open('sample_pdf.pdf', 'rb')
pdfReader = PyPDF2.PdfFileReader(pdf)
page_one = pdfReader.getPage(0)
print(page_one.extractText())
如果您注意到，在上面的输出中，第一页的格式有点不对。这是因为 PyPDF2 读取 PDF 的效率不是很高。
幸运的是，Python 有比 PyPDF2 更好的替代方案。我们接下来会谈到这一点。
使用 PDFplumber 提取文本
PDFplumber】是另一个可以从 PDF 中提取文本的工具。与 PyPDF2 相比，它更强大。
1.安装软件包
让我们开始安装 PDFplumber。
pip install pdfplumber
Pdfplumber
2.导入 pdf 木材
使用下面一行代码从导入 PDFplumber 开始:
import pdfplumber
3.使用 PDFplumber 读取 pdf
您可以通过以下代码开始使用 PDFplumber 阅读 pdf:
with pdfplumber.open("sample_pdf.pdf") as pdf:
first_page = pdf.pages[0]
print(first_page.extract_text())
这将从我们的 PDF 的第一页获取文本。输出如下:
Hello World.
This is a sample PDF with 2 pages.
This is the first page.
Process finished with exit code 0
您可以将它与 PyPDF2 的输出进行比较，看看 PDFplumber 在格式化方面如何更好。
PDFplumber 还提供了从 PDF 获取其他信息的选项。
比如可以用。page_number 获取页码。
print(first_page.page_number)
输出:
1
要了解 PDFPlumber 下的更多方法，请参考其官方文档。
结论
本教程是关于从 pdf 中读取文本的。我们研究了两种不同的工具，并发现其中一种比另一种更好。
现在你知道了如何从 PDF 中读取文本，你应该阅读我们关于标记化的教程，开始学习自然语言处理！
Python 中的生产者-消费者问题
原文：https://www.askpython.com/python/producer-consumer-problem
大家好！在本教程中，我们将学习生产者-消费者问题，这是一个经典的并发性问题，以及如何使用 Python 线程解决它。所以让我们开始吧。
什么是生产者-消费者问题？
生产者-消费者问题由 3 个部分组成:
1.有界缓冲区
缓冲区是可由不同线程访问的临时存储。缓冲区的一个简单例子是数组。多个线程可以从缓冲区读取数据，也可以同时将数据写入缓冲区。有界缓冲区的容量有限，不能存储超出其容量的数据。
2.生产者线程
生产者线程是这样一种线程，它生成一些数据，将其放入缓冲区，然后再次启动，直到没有生成所有需要的数据。这方面的一个例子是一个线程，它通过网络下载一些数据，并将其临时存储在缓冲区中
3.消费者线程
消费者线程是这样一种线程，它消费缓冲区中存在的数据，将其用于某个任务，然后再次启动，直到分配给该线程的任务没有完成。这方面的一个例子是一个线程，它读取通过互联网下载的数据，并将其存储在数据库中。
当线程的运行速率不同时会发生什么？
由线程完成的操作的速度可以根据所分配的任务而变化。因此，在我们的例子中，或者我们的生产者线程可能比消费者线程慢，或者生产者线程可能比消费者线程消耗数据的速度快。
如果线程运行的速率不同，可能会有一些问题，这就是生产者-消费者问题。
- 如果生产者线程试图将数据生成到缓冲区中，并且发现缓冲区已经满了，则生产者线程既不能在缓冲区中添加更多的数据，也不能覆盖消费者尚未消费的现有数据。因此，生产者线程应该停止自己，直到一些数据没有从缓冲区消费。如果生产者线程很快，这种情况是可能的。
- 如果消费者线程试图消费来自缓冲区的数据，但是发现缓冲区是空的，则消费者线程不能获取数据，并且它应该停止自己，直到一些数据没有被添加到缓冲区中。如果消费者线程很快，这种情况是可能的。
- 由于缓冲区是由不同的线程共享的，这些线程可以同时访问缓冲区中的数据，因此可能会出现竞争情况，并且两个线程不应该同时访问共享的缓冲区。生产者线程应该将数据添加到缓冲区，而消费者线程应该等待，或者生产者线程应该等待，而消费者线程正在共享缓冲区上工作以读取数据。
使用信号量解决问题
我们可以借助信号量来解决这个问题，信号量是线程间同步的工具。为了解决生产者-消费者问题的问题陈述中定义的 3 个问题，我们维护了 3 个信号量。
- empty: 这个信号量存储缓冲区中为空的槽的数量。这个信号量的初始值是我们的有界缓冲区的大小。在缓冲区中添加任何数据之前，生产者线程将尝试获取这个信号量，并将它的值减 1。如果这个信号量的值已经是 0，这意味着缓冲区已满，我们的空信号量将阻塞生产者线程，直到空信号量的值变得大于 0。类似地，在消费者线程消耗完缓冲区中的数据后，它将释放这个信号量，并将信号量的值增加 1。
- full: 这个信号量存储缓冲区中已满的槽的数量。这个信号量的初始值是 0。在使用缓冲区中的数据之前，使用者线程将尝试获取这个信号量。如果这个信号量的值已经是 0，这意味着缓冲区已经是空的，我们的满信号量将阻塞消费者线程，直到满信号量的值变得大于 0。类似地，生产者线程将在添加一个项目后释放这个信号量。
- 互斥:这个信号量将通过一次只允许一个信号量在共享缓冲区上操作来处理竞争情况。这个信号量的初始值是 1。在对共享缓冲区进行操作之前，两个线程都将尝试获取这个信号量。如果任何线程发现这个信号量的值为 0，这意味着另一个线程正在缓冲区上操作，它将被这个信号量阻塞。在缓冲区上操作之后，工作线程将释放这个信号量，以便另一个线程可以在缓冲区上操作。
我们还维护了两个指针来帮助我们的线程添加或获取数据。
- in pointer: 这个指针将告诉我们的生产者线程，在生产者生成的缓冲区中，在哪里添加下一个数据。添加后，指针增加 1。
- out 指针:这个指针将告诉我们的消费者线程从缓冲区的哪里读取下一个数据。读取后，指针增加 1。
用 Python 实现生产者-消费者问题
让我们检查一下如何用 Python 解决这个问题的实现。假设我们有一个容量为 10 的有界缓冲区。生产者线程将生产 20 个项目，消费者线程将消费生产者生产的这 20 个项目。在生产者中添加time.sleep(1)和在消费者中添加time.sleep(2.5)使得我们的生产者线程比消费者线程运行得更快。即使我们首先启动我们的消费者线程，它也会一直等到缓冲区中没有数据。
import threading
import time
# Shared Memory variables
CAPACITY = 10
buffer = [-1 for i in range(CAPACITY)]
in_index = 0
out_index = 0
# Declaring Semaphores
mutex = threading.Semaphore()
empty = threading.Semaphore(CAPACITY)
full = threading.Semaphore(0)
# Producer Thread Class
class Producer(threading.Thread):
def run(self):
global CAPACITY, buffer, in_index, out_index
global mutex, empty, full
items_produced = 0
counter = 0
while items_produced < 20:
empty.acquire()
mutex.acquire()
counter += 1
buffer[in_index] = counter
in_index = (in_index + 1)%CAPACITY
print("Producer produced : ", counter)
mutex.release()
full.release()
time.sleep(1)
items_produced += 1
# Consumer Thread Class
class Consumer(threading.Thread):
def run(self):
global CAPACITY, buffer, in_index, out_index, counter
global mutex, empty, full
items_consumed = 0
while items_consumed < 20:
full.acquire()
mutex.acquire()
item = buffer[out_index]
out_index = (out_index + 1)%CAPACITY
print("Consumer consumed item : ", item)
mutex.release()
empty.release()
time.sleep(2.5)
items_consumed += 1
# Creating Threads
producer = Producer()
consumer = Consumer()
# Starting Threads
consumer.start()
producer.start()
# Waiting for threads to complete
producer.join()
consumer.join()
输出:
Producer produced : 1
Consumer consumed item : 1
Producer produced : 2
Producer produced : 3
Consumer consumed item : 2
Producer produced : 4
Producer produced : 5
Consumer consumed item : 3
Producer produced : 6
Producer produced : 7
Producer produced : 8
Consumer consumed item : 4
Producer produced : 9
Producer produced : 10
Consumer consumed item : 5
Producer produced : 11
Producer produced : 12
Producer produced : 13
Consumer consumed item : 6
Producer produced : 14
Producer produced : 15
Consumer consumed item : 7
Producer produced : 16
Producer produced : 17
Consumer consumed item : 8
Producer produced : 18
Consumer consumed item : 9
Producer produced : 19
Consumer consumed item : 10
Producer produced : 20
Consumer consumed item : 11
Consumer consumed item : 12
Consumer consumed item : 13
Consumer consumed item : 14
Consumer consumed item : 15
Consumer consumed item : 16
Consumer consumed item : 17
Consumer consumed item : 18
Consumer consumed item : 19
Consumer consumed item : 20
结论
恭喜你！现在你知道如何解决经典的生产者-消费者问题了。现实生活中有许多可能发生类似情况的例子，例如打印一个文档，其中多个应用程序想要打印一个文档，通过网络下载数据并存储在数据库中，等等。
感谢阅读！！
基于 Python 的产品推荐系统
原文：https://www.askpython.com/python/examples/product-recommendation-system
很多时候，你不知道哪种产品在某个特定领域比其他产品更好。好了，不用担心了！Python 对任何事情都有解决方案，这就是推荐系统的用途。
在本教程中，我们将使用 Python 编程语言构建一个产品推荐系统。让我们从理解我们将在本教程中使用的数据集开始。
在本教程中，我们将使用亚马逊美容产品评级数据集，其中包含超过 200 万个网站上销售的美容相关产品的客户评论和评级。
数据集包含每个产品的以下信息:UserID，它对每个客户都是唯一的，有助于识别用户；ProductID，它有助于唯一地标识产品；评级，范围从 1 到 5；以及时间戳，它提供评级的时间。
代码实现
我们将导入所有必要的库并将数据集加载到程序中。确保您的.csv文件与代码文件在同一个目录下，以避免任何错误。看看下面的代码。
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
df = pd.read_csv("ratings_Beauty.csv")
print("Number of Products in the dataset : ",df.shape[0])
在数据集中，我们可以看到总共有2023070条美妆产品评论。我们将尝试绘制一个条形图，显示评分值与评分数的对比。
这将帮助我们了解用户的评论在 5 个评分值(即 1、2、3、4 和 5)中的分布情况。请看下面的代码片段。
count_ratings = [0 for i in range(len(np.unique(df['Rating'])))]
print("Number of Unique Ratings available : ",len(count_ratings))
for i in range(df.shape[0]):
count_ratings[int(df['Rating'][i]-1)]+=1
print("Count of each ratings is : ",count_ratings)
plt.style.use('seaborn')
labels = ["1 star" , "2 star", "3 star",
"4 star", "5 star"]
plt.figure(figsize=(15,8),facecolor="w")
ax = plt.barh(labels,count_ratings,
color=["yellow","cyan","pink",
"skyblue","lightgreen"],
edgecolor="black")
for i in ax.patches:
plt.text(i.get_width()+0.6, i.get_y()+0.3,
str(round((i.get_width()), 4)),
fontsize=15, fontweight='bold',
color='grey')
plt.title("Horizontal Bar Graph - Ratings vs Count",fontsize=15)
plt.show()
代码执行后，程序将显示如下图。这个情节将帮助我们了解用户对亚马逊上的美妆产品的看法。
Ratings Vs Count Beauty Products
接下来，我们将从两个方面来看推荐:第一种方式是向用户推荐具有最高 4 星或 5 星评级的产品。
另一种方法是让用户知道哪些用户对产品进行了 4 星或 5 星评级，这将有助于认识到这些用户的评级是有帮助的，因为他们是最多的用户。
让我们使用下面的代码过滤掉评级为 4 星或 5 星的数据。
df_4 = df[df['Rating']==4.0]
df_5 = df[df['Rating']==5.0]
df_45 = pd.concat([df_4, df_5])
接下来，我们将查看具有 4 星和 5 星评级的顶级产品，并以条形图的形式显示出来，以了解网站根据评级推荐的最多产品
popular_products = pd.DataFrame(df_45.groupby('ProductId')['Rating'].count())
most_popular = popular_products.sort_values('Rating', ascending=False)[:10]
plt.figure(figsize=(15,8),facecolor="w")
most_popular.head(30).plot(kind = "barh")
plt.title("Products vs Count of Purchase",fontsize=15)
plt.show()
该代码在执行时会产生如下图所示的结果。该图显示 product_id 为 B001MA0QY2 的产品是最受推荐的产品，我们可以在下面的图中看到列出的前 10 个最受欢迎的产品。
Product Vs Count Reviews
现在让我们转到另一种方法，根据在网站上评分最高的用户向新用户推荐网站上的产品，因为他们是美容产品的更频繁用户。看看下面的代码和输出。
popular_users = pd.DataFrame(df_45.groupby('UserId')['Rating'].count())
most_popular_users = popular_users.sort_values('Rating', ascending=False)[:10]
plt.figure(figsize=(15,8),facecolor="w")
most_popular_users.head(30).plot(kind = "barh")
plt.title("UserIDs vs Count of Purchase",fontsize=15)
plt.show()
看一下上面的代码显示的图表，其中显示了该产品最频繁的用户。
Users Vs Count Reviews
结论
在本教程中，我们学习了使用 Python 编程语言的产品推荐系统。
推荐系统有助于了解产品的当前用户喜欢什么，他们对什么最感兴趣，以便帮助新用户了解他们必须试用什么产品。
感谢您的阅读！
Implementation网上赌场的编程语言
原文：https://www.askpython.com/python/programming-languages-for-online-casino
在线赌场游戏是用广泛的算法编程，并用编程语言创建的。游戏现在被设计成使用各种编程语言来执行不同的功能。他们对语言集的优化增强了游戏的适用性，开发了更好的视觉效果、更快的流程、更宽的下注范围和更大的获胜机会。
软件开发人员依赖于这些编程语言，并选择他们最熟悉的语言。多种高级编程语言用于在线娱乐场，并由开发者根据偏好选择。在这里，我们讨论你可以为你的赌场使用什么编程语言，描述如果你访问没有被 GamStop 屏蔽的英国在线赌场，你可以找到的最流行的解决方案，以及开发赌场平台的许多其他方面。如果有足够的编程语言知识，有经验的玩家和休闲玩家也可以钻研在线游戏制作。一般来说，编程语言使得任何人都可以玩在线赌场游戏。这里给出了一个可以在网上赌场实现的编程语言列表。
关于网络游戏编程和编程语言
在进入列表之前，有必要熟悉在线游戏编程的基本概念和语言。在线游戏的软件需要为游戏创建基本的结构。编程语言实现了决定游戏速度和结果的代码和算法。除了这些功能，由于集成了编程语言，游戏还可以在网站或应用程序上运行。从主题到游戏的基本设计都是通过整合这些编程语言来完成的。
HTML5
HTML5 非常用户友好，并适应移动设备。像 Java 一样，它易于使用和理解，因此深受所有用户的欢迎，从软件开发人员到涉足编程的新手。HTML5 和 JavaScript 经常配对在一起制作高级网络游戏。如今，为了更好的性能，你可以在 NGB 找到的大多数非 GamStop 在线赌场都使用这些编程语言。很多基于手机的游戏和网页游戏都是用 HTML5 设计的，尤其是主题槽。
C++
C++作为在线赌场游戏语言被广泛使用。C++是面向对象的，因此与其他编程语言相比使用起来更复杂，但由于程序执行速度快，所以强烈推荐使用。C++允许更好地处理可视化和说明性功能以及硬件进程。它在组织内存、框架管理和控制方面也有很强的把握，因此是一种高性能的编程语言。
C#
C#是基础编程语言，也是第一个被开发使用的语言。与 C++相比，它是一种更简单、更不复杂的编程语言，算法更容易。C#基于一个 XNA 框架，需要较少的存储空间，用于 Windows 上的在线游戏。C#可以被分配到多个平台上应用。
Java 语言(一种计算机语言，尤用于创建网站)
由于 JVM 或 Java 虚拟机，Java 使得在线赌场游戏可以在所有平台上访问。Java 因其资源丰富和易于应用而成为最值得推荐的在线游戏之一。如果你想实现 GamStop 这样的系统，Java 将是后端的最佳解决方案之一。它是一种编程语言，默认情况下在所有网页上都被接受，并且被认为是在线赌场游戏的理想编程语言。Java 可能是面向对象的，但它支持广泛的用途。
Java Script 语言
就网页和应用程序的可访问性而言，JavaScript 或 JS 的范围比 Java 更广。JS 对应用程序友好，是网站中最容易理解的编程语言。因此，这是非常值得称赞的在线赌场游戏开发。JS 可以集成使用 HTML5 和 CSS 来促进平台交叉。JS 对网络和手机都很友好，是最好的在线交流赌场游戏之一。
左上臂
Lua 有一套可变的工具，不依赖于固定的机制。Lua 的功能在于基于各种平台的配置和交叉脚本。Lua 也是一种简单而不费力的编程语言，因此在在线赌场行业的开发者和用户中很受欢迎。
非真实脚本
UnrealScript 使用了更复杂的算法，并融合了面向对象的方法与多变量方面。所有主要平台都支持它，但它更多地用于其他形式的游戏，而不是在线赌场开发。UnrealScript 因其可访问性而受欢迎。
计算机编程语言
Python 是一种通用编程语言，在网络游戏中有着无数的应用。如果您决定将这种语言用于您的应用程序，您可以在 AskPython 上找到许多有用的文章。Python 以其出色的性能、轻量级架构和高可扩展性而得到认可。Python 是通用的和用户友好的，由于其快速的算法处理，软件开发者更喜欢将其用于高级游戏开发。
结论
编程语言是专业软件开发人员最常用和最推荐的语言。此外，许多玩家使用自我排除服务，如果他们停止工作，他们可以切换到阻止软件，这也很容易实现。由于使用这些语言的代码的高级实现，新种类的在线游戏正在被开发，具有更高级的特性。用户友好和网络友好的功能可以帮助玩家尝试在线游戏。
在 Python 中使用 psutil 模块
先说 Python 中的 psutil 模块。在处理系统进程和分析的大部分时间里，我们倾向于希望有一种替代方法来检查系统的任务管理器，以了解我们的测试会产生什么影响。
沿着手动检查任务管理器信息的路线，我们开始意识到我们在一遍又一遍地做同样的过程。
当然，这在我们自己的爱好者眼中并不好看。
也就是说，您需要创建一个脚本，该脚本可以遍历系统进程，并在您运行脚本时提供一个报告。
这就是psutil模块发挥作用的地方，它提供了在处理系统进程时非常重要的特性。
psutil是最适合用于系统监控、剖析和限制进程资源和运行进程管理的模块。
让我们开始使用它吧！
安装 psutil 模块
使用 pip 系统的psutil安装程序非常简单，
pip install psutil
如果您正在使用任何其他软件包管理器，您可能需要查看它们的文档来安装 psutil。
既然我们已经设置好模块并准备好运行，我们可以开始替换检查任务管理器的需求了。
在 Python 脚本中使用 psutil 模块
psutil模块是一个包含很多方法的模块，这些方法可以分为几个部分，系统，进程， windows 服务，以及常量。还有一些独立的方法可以归入杂项类别。
这些方法有很多种，我们将在这些小节中只介绍其中的一部分，但是，在每个小节的小节中都会提供文档的链接。
1.系统信息
psutil为我们提供了各种各样的函数，我们可以使用这些函数来接收关于 CPU 、内存、磁盘、网络、传感器和其他系统信息的信息。
从每一部分中测试出来的几个函数将为我们提供下面的代码和输出。
# Importing the module before utilization
import psutil
# Retrieving information regarding the CPU
## Returns the system CPU times as a named tuple
print(psutil.cpu_times())
## Returns the system-wide CPU utilization as a percentage
print(psutil.cpu_percent())
## Returns the number of logical CPUs in the system
print(psutil.cpu_count())
## Returns the various CPU statistics as a tuple
print(psutil.cpu_stats())
## Returns the CPU frequency as a nameduple
print(psutil.cpu_freq())
当这些函数被打印到控制台时，我们会收到以下类型的日志，
scputimes(user=242962.0, system=84860.32812499994, idle=432883.46875, interrupt=5186.125, dpc=4331.65625)
0.0
4
scpustats(ctx_switches=2378452881, interrupts=1779121851, soft_interrupts=0, syscalls=3840585413)
scpufreq(current=2000.0, min=0.0, max=2601.0)
如果你想了解的话，我们已经编写了一个要点来简单概述psutil模块的使用。
模块中有更多的功能，可以在官方文档中找到。
2.处理
通过 psutil 模块提供的函数允许 Python 检索整个系统中当前正在运行的进程的相关信息。
这些进程有特定的 PID 或进程 ID，可以从系统中检索，我们可以使用它们来了解特定进程及其统计信息。
使用模块的功能来处理流程，我们可以以简单的方式检索关于某些流程的信息，
# Importing the module before utilization
import psutil
# Returning a sorted list of currently running processes
print(psutil.pids())
# Returns an iterator which prevents the race condition for process stats
print(psutil.process_iter())
# Used to check whether a certain process exists in the current process list
print(psutil.pid_exists(0))
# An example to terminate and wait for the children
def on_terminate(proc):
print("process {} terminated with exit code {}".format(proc, proc.returncode))
procs = psutil.Process().children()
for p in procs:
p.terminate()
gone, alive = psutil.wait_procs(procs, timeout=3, callback=on_terminate)
for p in alive:
p.kill()
更多对异常处理有用的函数，以及 process 类的利用都在文档中，如果你想了解可以使用的参数，这些函数值得一试。
3.Windows 服务
模块还为我们提供了检查所有已安装的 windows 服务的功能。
WindowsService 类是通过名称来表示每个 Windows 服务的类，关于服务的细节主要使用win_service_iter()和win_service_get()函数来检索。
# Importing the module before utilization
import psutil
# Returns an iterator yielding a WindowsService class instance
print(psutil.win_service_iter())
# To provide the list of all processes contained we can use the list() function
print(list(psutil.win_service_iter()))
# Gets a Windows service by name, returning a WindowsService instance
print(psutil.win_service_get('WpnUserService_6b5d2'))
psutil 的官方文档中深入介绍了使用 Windows 服务的方法，如果您希望深入了解这些功能的话。
4.系统常数
psutil模块允许检查系统常量，这些常量提供一个布尔响应，表明特定常量是否适用于您使用的操作系统。
为了解释这一点，我们可以使用 Python 进行测试，
# Importing the module
import psutil
# Checking whether the operating system is Linux based
print(psutil.LINUX)
# Windows based OS?
print(psutil.WINDOWS)
在我的例子中，操作系统是基于 Windows 的，因此，对于 LINUX，响应是假的，对于 Windows 是真的。
更多的系统常数可以被访问和验证，以便进一步进行操作，使用和识别要遵循的操作系统指令，并且可以在文档中找到。
结论
使用psutil模块非常简单，使用它的应用程序非常有用，可以显示日志信息，并处理资源消耗在您的系统中是如何发生的。
查看我们的其他文章，关于 Python 中可以让您的生活更轻松的不同模块——数据帧、 XML 解析、文件压缩。
参考
用 Python 从 API 中提取数据——详细指南！
原文：https://www.askpython.com/python/examples/pull-data-from-an-api
读者朋友们，你们好！在本文中，我们将关注如何从 Python 中的 API 中提取数据。
所以，让我们开始吧！
使用 Python 从 API 提取数据的步骤
现在让我们来关注一下从 API 中提取特定数据需要遵循的步骤。
您可以查看关于 连接到 API 的文章，以了解更多关于 API 和响应状态代码等的信息。
让我们开始吧！
示例 1:从开源 COVID API 中提取数据
在这个例子中，我们将连接到一个开源的 COVID API，只是为了以定制的方式提取和解析 json 信息。
1.连接到 API
首先，我们需要连接到一个 API 并建立一个安全连接，如下所示
在本文中，我们使用了 COVID19-India API 从 state-wise 列表中获取案例数据。
import requests
import json
response_API = requests.get('https://api.covid19india.org/state_district_wise.json')
#print(response_API.status_code)
当我们从 API 中提取数据时，我们使用了get()函数从 API 中获取信息。
2.从 API 获取数据
在与 API 建立了健康的连接之后，下一个任务是从 API 中提取数据。看下面的代码！
data = response_API.text
requests.get(api_path).text帮助我们从提到的 API 中提取数据。
3.将数据解析成 JSON 格式
提取完数据后，现在是将数据转换和解码成正确的 JSON 格式的时候了，如下所示
json.loads(data)
json.loads()函数将数据解析成 JSON 格式。
4.提取数据并打印出来
JSON 格式包含的数据是类似于 Python 字典的键值格式。因此，我们可以使用如下所示的关键值提取并打印数据
parse_json['Andaman and Nicobar Islands']['districtData']['South Andaman']['active']
你可以在下面找到完整的代码！
import requests
import json
response_API = requests.get('https://api.covid19india.org/state_district_wise.json')
#print(response_API.status_code)
data = response_API.text
parse_json = json.loads(data)
active_case = parse_json['Andaman and Nicobar Islands']['districtData']['South Andaman']['active']
print("Active cases in South Andaman:", active_case)
输出:
Active cases in South Andaman: 19
示例 2:从开源 GMAIL API 中提取数据
现在，让我们连接并从 GMAIL API 中提取数据。这个 API 代表了我们可以从 API 中获取的一般结构和信息。
所以，让我们开始吧！
看看下面的代码吧！
举例:
import requests
import json
response_API = requests.get('https://gmail.googleapis.com/$discovery/rest?version=v1')
#print(response_API.status_code)
data = response_API.text
parse_json = json.loads(data)
info = parse_json['description']
print("Info about API:\n", info)
key = parse_json['parameters']['key']['description']
print("\nDescription about the key:\n",key)
输出:
Info about API:
The Gmail API lets you view and manage Gmail mailbox data like threads, messages, and labels.
Description about the key:
API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
说明:
- 首先，我们使用
get()函数连接到通用的 GMAIL API。 - 在与 API 形成健康的连接后，我们使用
response_object.text从 API 获取数据 - 现在，我们使用
json.loads()函数将数据解析成 JSON 格式。 - 最后，我们从 JSON 对象中提取数据，比如 API 的描述和键的描述。
- 您可以通过访问示例中提到的 API 链接来交叉检查这些值。
结论
到此，我们就结束了这个话题。如果你遇到任何问题，请随时在下面评论。
更多与 Python 相关的帖子，敬请关注，在此之前，祝你学习愉快！！🙂
Python 中 PyAutoGUI 的自动化
原文：https://www.askpython.com/python-modules/pyautogui-in-python
让我们学习用 Python 中的 PyAutoGUI 实现任务自动化。每当我们遇到一个需要重复的任务时，我们都会想出具体的方法来避免它。这是人之常情。
在努力完成同一项任务的过程中，我们有了一个想法，我们可以创造一些自动运行的东西，只需要满足一系列条件就可以工作。
无论是需要电池和草地的割草机，还是一遍又一遍打印同一行的代码。
自动化已经成为我们人类生活中的一个重要部分，使用自动化可以让我们在工作过程中专注于其他任务。
然而，自动化需要工具来配合工作，这就是pyautogui模块发挥作用的地方。
pyautogui模块允许运行的脚本控制你的鼠标和键盘，像系统上的用户一样提供输入，允许系统上的应用程序之间的交互。
在 Python 中安装 PyAutoGUI
我们可以通过 PIP 包管理器在 Python 中安装 PyAutoGUI。您可以在任何使用 pip 的操作系统上使用相同的命令行进行安装。
# Windows does not have any dependencies for installation
pip install pyautogui
# Mac has two dependencies for PyAutoGUI
pip3 install pyobjc-core
pip3 install pyobjc
pip3 install pyautogui
# Linux distributions require a single dependency installed
pip3 install python3-xlib
pip3 install pyautogui
一旦我们安装了依赖项(如果有的话)和模块，我们就可以开始了！
使用 Python PyAutoGUI
在使用 Python 中 PyAutoGUI 提供的所有强大功能之前，我们必须首先在脚本中导入模块。
# Importing the PyAutoGUI module
import pyautogui as pag
在本文中，我们将为pyautogui模块使用一个别名，我们在上面称之为 pag 。
1.PyAutoGUI 基本函数
在处理任何脚本之前，我们最好知道哪些组件执行什么样的任务。
也就是说，Python 中的pyautogui提供了多种处理输入的方法，
# Gets the size of the primary monitor.
screenWidth, screenHeight = pag.size()
# Gets the XY position of the mouse.
currentMouseX, currentMouseY = pag.position()
# Move the mouse to XY coordinates.
pag.moveTo(100, 150)
# Allows the script to click with the mouse.
pag.click()
# Move the mouse to XY coordinates and click it.
pag.click(100, 200)
# Find where button.png appears on the screen and click it.
pag.click('button.png')
# Double clicks the mouse.
pag.doubleClick()
# The writing functionality provided by PyAutoGUI imitates keyboard input
pag.write('Hello world!')
# Presses the Esc key.
pag.press('esc')
# The keyDown button causes the script to hold down on a specific key.
pag.keyDown('shift')
# You can pass a list of keys to press, which will be consecutively executed.
pag.press(['left', 'left', 'left', 'left'])
# Lets go of a certain key.
pag.keyUp('shift')
# The hotkey() function allows for a selection of keys for hotkey usage.
pag.hotkey('ctrl', 'c')
# Make an alert box appear and pause the program until OK is clicked.
pag.alert('This is the message to display.')
同样需要注意的是，该模块还提供了在脚本中工作的关键字，这些关键字可以通过pyautogui.KEY_NAMES访问。
2.在 Python 中使用 PyAutoGUI 实现简单的自动化
我们可以创建一个简单的垃圾邮件自动化，使用一点 Python 和pyautogui模块在任何平台上连续发送消息。
让我们首先导入几个模块来处理所需的功能。
# Importing the pyautogui module
import pyautogui as pag
# Importing time to delay the input speed
import time
# Working with Tkinter allows us to use a GUI interface to select the file to read from
from tkinter import Tk
from tkinter.filedialog import askopenfilename
现在，这里是你如何做一个垃圾邮件机器人。
2.1.提供一种输入方法。
我们可以通过手动键入消息来提供输入，但是，这甚至会使自动发送垃圾消息的目的落空。
因此，让我们用文件来解析一个文件，并将内容写入平台。我们将使用 tkinter 模块来选择要读取的文件。
# The withdraw function hides the root window of Tkinter
Tk().withdraw()
# The askopenfilename() takes the file path from user selection.
filename = askopenfilename()
现在，我们通过askopenfilename()函数得到了文件的路径。该路径存储在filename变量中。
2.2.创建一个延迟来调整垃圾邮件的速度。
我们还需要在每个消息之间创建一个延迟，以便平台能够一个接一个地接受消息，而不是由于平台输入滞后而由单个消息覆盖自身。
# We take the input of the user and strip it such that we only receive a numeric input.
timeDelay = int(input("If you want a delay, enter the number of seconds for the delay : ").split()[0])
# In case the input time is designed to break the delay function, we can reset the timeDelay back to 1.
if timeDelay < 1:
timeDelay = 1
# We need to place the cursor in the right place to begin writing to the platform.
time.sleep(5)
2.3.垃圾邮件使用 PyAutoGUI！
我们现在可以使用pyautogui模块从文件中读取每个单词，并写入平台。
f = open(filename, "r")
for word in f:
time.sleep(timeDelay)
pag.typewrite(word)
pag.press("enter")
3.PyAutogui 在 Python 中的完整实现
我们现在完成了代码，您的最终代码应该是这样的，
import pyautogui as pag
import time
from tkinter import Tk
from tkinter.filedialog import askopenfilename
Tk().withdraw()
filename = askopenfilename()
print(filename)
timeDelay = int(input("If you want a delay, enter the number of seconds for the delay : ").split()[0])
if timeDelay < 1:
timeDelay = 1
time.sleep(5)
f = open(filename, "r")
for word in f:
time.sleep(timeDelay)
pag.typewrite(word)
pag.press("enter")
结论
现在您已经完成了这篇文章，您知道 Python 中的pyautogui提供了什么，以及您可以用它来做什么。
虽然我们不一定推荐垃圾邮件，但修补是完全可以接受的😉
查看我们的其他文章，使用熊猫模块， Numpy 数组，以及使用 Pygame 创建高低游戏。
参考
- 【PyAutoGUI 官方文档
- stack overflow to typeet()
Python Pygame:给 Python 游戏添加背景音乐
原文：https://www.askpython.com/python-modules/pygame-adding-background-music
你好。今天在本教程中，我们可以看看如何使用 pygame 在窗口中添加背景音乐。所以让我们开始吧！
第一步:下载我们想要播放的音乐
在进入编码部分之前，我们需要做的第一件事是下载一些音乐。你可以选择任何你想要的音乐。我现在用一些简单的朗朗上口的背景音乐。
我已经添加了我要使用的背景音乐。你想听就能听到。
MP3 FORMAT
但问题是在 pygame 中使用mp3格式的背景音乐会有很多问题，会导致奇怪的吱吱声和爆裂声，而不是音乐。
因此，为了防止这种情况，我们将 mp3 格式的文件转换为OOG格式，这使得它更适合 pygame 窗口。你可以在网上找到文件格式转换器，你只需要上传你的音乐文件，其余的都是免费的！
oog 文件听起来是一样的。我在下面添加了我的wav音乐文件供你验证。
WAV FORMAT
步骤 2:导入模块
每个程序的第一步是导入必要的模块。相同的代码如下所示。
import pygame
from pygame.locals import *
from pygame import mixer
我们将导入pygame和pygame.locals模块以使窗口平稳运行。我们将导入mixer模块来播放音乐。
步骤 3:创建基本的屏幕设计和功能
为了创建屏幕，我们首先使用init函数初始化 pygame。我们将使用image.load函数加载背景图像。
然后，我们将有一个运行循环，将把背景图像和更新屏幕设计。我们还将在事件处理的帮助下添加退出窗口功能。
最后，我们将使用quit函数来销毁之前启动的 pygame。相同的代码如下所示。
pygame.init()
width = 1000
height = 500
window = pygame.display.set_mode((width,height))
bg_img = pygame.image.load('Images/bg.png')
bg_img = pygame.transform.scale(bg_img,(width,height))
runing = True
while runing:
window.blit(bg_img,(0,0))
for event in pygame.event.get():
if event.type == QUIT:
runing = False
pygame.display.update()
pygame.quit()
上面代码的输出屏幕如下所示。
Output Screen1 Bg Music Pygame
步骤 4:在程序中初始化混合器
下一步是初始化程序中的mixer并使用music.load加载音乐，其中音乐文件的路径作为参数传递。
在这之后，我们添加了名为music.pla y 的函数。但是这不会启动背景音乐。为此，我们需要在代码中添加更多的元素，这将在后面的章节中介绍。
相同的代码如下所示。
mixer.init()
mixer.music.load('Music File/bensound-summer_wav_music.wav')
mixer.music.play()
给 Pygame 窗口添加背景音乐——完整代码
最终代码如下所示:
import pygame
from pygame.locals import *
from pygame import mixer
pygame.init()
width = 1000
height = 500
window = pygame.display.set_mode((width,height))
bg_img = pygame.image.load('Images/bg.png')
bg_img = pygame.transform.scale(bg_img,(width,height))
mixer.init()
mixer.music.load('Music File/bensound-summer_wav_music.wav')
mixer.music.play()
runing = True
while runing:
window.blit(bg_img,(0,0))
for event in pygame.event.get():
if event.type == QUIT:
runing = False
pygame.display.update()
pygame.quit()
最终输出
代码的输出显示在下面的视频中。我没有放一个完整的超过 3 分钟的视频。
你可以听到音乐完美的播放！
结论
恭喜你！您成功地学会了如何在屏幕上添加背景音乐！你可以尝试不同的音乐声音，并将其添加到你的游戏中，如果你有的话！
感谢您的阅读！
Pygame:创建交互式形状
原文：https://www.askpython.com/python-modules/pygame-creating-interactive-shapes
你好。今天我们将创建一个普通的 pygame 屏幕，但是为了增加趣味，我们将为它添加交互式的形状。听起来很有趣，对吗？
所以让我们开始吧！
步骤 1:创建一个基本的 Pygame 屏幕
我们的第一个任务是创建一个 pygame 屏幕，首先导入必要的模块，包括pygame模块、pygame.locals模块。我们还为背景音乐添加了mixer模块。
1.创建窗口
我们首先初始化 pygame，并通过设置屏幕的高度和宽度来创建一个窗口对象。
我们还将添加一个运行循环来处理各种事件，比如按下X按钮时关闭窗口。
2.添加背景图像
我们要做的下一件事是添加背景图像，首先加载图像并缩放图像以填充整个窗口。
然后在运行循环中使用blit和update函数添加图像。
3.添加背景音乐
我们将使用调音台模块的功能将音乐添加到我们的程序中。
首先，我们从音乐文件文件夹中导入音乐。同样，我们使用music.load功能，然后使用music.play功能播放音乐。
我们还将使用music.set_volume功能设置音乐的音量。
设计基本定制屏幕的完整代码如下:
import pygame
from pygame.locals import *
from pygame import mixer
pygame.init()
width = 500
height = 500
window = pygame.display.set_mode((width,height))
bg_img = pygame.image.load('Image Files/bg.png')
bg_img = pygame.transform.scale(bg_img,(width,height))
mixer.init()
mixer.music.load('Music File/Littleidea - wav music file.wav')
pygame.mixer.music.set_volume(0.05)
mixer.music.play()
runing = True
while runing:
window.blit(bg_img,(0,0))
for event in pygame.event.get():
if event.type == QUIT:
runing = False
pygame.display.update()
pygame.quit()
步骤 2:在屏幕上添加一个正方形
为了画一个正方形，我们使用了draw.rect函数，它有三个参数:窗口对象名、矩形的颜色和矩形的尺寸(宽度和高度、x 和 y 坐标)。
我们将在运行循环之前定义块的宽度和高度。除此之外，我们还将声明块的颜色。
添加了所需代码行的代码如下所示。所做的更改会突出显示，供您参考。
import pygame
from pygame.locals import *
from pygame import mixer
pygame.init()
width = 500
height = 500
window = pygame.display.set_mode((width,height))
bg_img = pygame.image.load('Image Files/bg.png')
bg_img = pygame.transform.scale(bg_img,(width,height))
x=y=50
color = "red"
mixer.init()
mixer.music.load('Music File/Littleidea - wav music file.wav')
pygame.mixer.music.set_volume(0.05)
mixer.music.play()
runing = True
while runing:
window.blit(bg_img,(0,0))
for event in pygame.event.get():
if event.type == QUIT:
runing = False
pygame.draw.rect(window, color, pygame.Rect(x, y, 60, 60))
pygame.display.update()
pygame.quit()
第三步:增加广场的互动性
现在用以下方法制作正方形:
- 向上箭头键:将 y 坐标减少 2
- 向下箭头键:将 y 坐标增加 2
- 左箭头键:将 x 坐标减少 2
- 右箭头键:将 x 坐标增加 2
但是在加入算术运算之前。我们将确保使用key.get_pressed函数捕获被按下的键，并将其存储在一个变量中。
然后，我们将检查变量，并根据捕获的键在坐标中应用必要的更改。
执行相同操作的代码行如下所示:
key = pygame.key.get_pressed()
if key[pygame.K_UP]:
y -= 2
if key[pygame.K_DOWN]:
y += 2
if key[pygame.K_LEFT]:
x -= 2
if key[pygame.K_RIGHT]:
x += 2
Pygame 中交互式形状的完整实现
下面的代码显示了最终完成的代码。希望你明白一切。
import pygame
from pygame.locals import *
from pygame import mixer
pygame.init()
#window attributes
width = 500
height = 500
window = pygame.display.set_mode((width,height))
bg_img = pygame.image.load('Image Files/bg.png')
bg_img = pygame.transform.scale(bg_img,(width,height))
#square attributes
x=y=50
color = "red"
#music addition
mixer.init()
mixer.music.load('Music File/Littleidea - wav music file.wav')
pygame.mixer.music.set_volume(0.05)
mixer.music.play()
#the running loop
runing = True
while runing:
#add background img
window.blit(bg_img,(0,0))
#handling events
for event in pygame.event.get():
#closing window function
if event.type == QUIT:
runing = False
#add the square
pygame.draw.rect(window, color, pygame.Rect(x, y, 60, 60))
#moving square on pressing keys
key = pygame.key.get_pressed()
if key[pygame.K_UP]:
y -= 2
if key[pygame.K_DOWN]:
y += 2
if key[pygame.K_LEFT]:
x -= 2
if key[pygame.K_RIGHT]:
x += 2
#update display
pygame.display.update()
#quit pygame
pygame.quit()
最终输出
下面的视频显示了上面代码的最终输出。你可以看到当箭头键被按下时，方块移动得多么完美！
结论
我希望这个基本的交互式形状教程能帮助你在 pygame 中学到一些新东西！
感谢您的阅读。
PyGame 教程:Python 中的图形高低游戏
原文：https://www.askpython.com/python/examples/pygame-graphical-hi-lo-game
PyGame 是一个用 Python 编写的 2D 游戏开发库。它包含程序员从头开始创建简单或复杂游戏所需的特定函数和类。
在本教程中，我们将使用 PyGame 库创建自己的高低游戏。Hi-Lo 是一种非常简单的赌场游戏，玩家必须猜测一副牌中的下一张牌是高于还是低于当前的牌。
建议:如果这是你第一次创建游戏，试试用 Python 的命令行实现 hi-lo 游戏。这更容易，并且会让你对游戏机制有更好的理解。但是，如果您已经精通 Python，请继续往下读！
牌的排名系统从最低排名的 Ace 开始，到最高排名的 king 结束。
Python 中的 GUI 高低游戏
https://www.askpython.com/wp-content/uploads/2020/07/hi_lo_pygame.mp4
导入 PyGame
在使用任何 pygame 的模块之前，我们需要导入库。
import pygame
所有的 PyGame 函数都可以使用pygame后跟'.'和函数名来访问。
声明游戏常数
每个游戏设计都需要一些常量，用来指定游戏的关键特性。
# Margins
MARGIN_LEFT = 230
MARGIN_TOP = 150
# WINDOW SIZE
WIDTH = 800
HEIGHT = 600
# COLORS
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
GRAY = (110, 110, 110)
GREEN = (0, 255, 0)
LIGHT_GREEN = (0, 120, 0)
RED = (255, 0, 0)
LIGHT_RED = (120, 0, 0)
对于程序员来说，常量的类型和值是不同的。预先定义这样的常数是一个好习惯，这样在值改变的情况下，我们不必到处去修正它们。
初始化游戏模块
为了使用 PyGame 模块，我们首先需要通过以下方式初始化它们:
# Initializing PyGame
pygame.init()
每个游戏都在一个特定的游戏窗口中进行，这个窗口可以根据程序员的需要而改变。这个游戏窗口需要尺寸参数。
# WINDOW SIZE
WIDTH = 800
HEIGHT = 600
# Setting up the screen and background
screen = pygame.display.set_mode((WIDTH, HEIGHT))
screen.fill(GRAY)
使用内置的set_mode()函数，我们定义窗口大小。在使用 PyGame 时要记住的一件事是，size 参数是作为一个由两个值组成的元组传递的:宽度和高度。
设置好窗口后，我们使用fill()命令设置背景颜色。
设置标题和图标
我们的游戏需要一个标题和图标来代表自己。
# Setting up caption
pygame.display.set_caption("Hi-Lo Game")
# Loading image for the icon
icon = pygame.image.load('icon.jpeg')
# Setting the game icon
pygame.display.set_icon(icon)
set_caption()函数将一个字符串作为参数，并将其作为标题。为了设置图标，我们首先需要使用接受图像文件名称的load()函数加载图像。
set_icon()功能将图像设置为游戏图标。
注意:如果图像文件不在与 python 游戏文件相同的目录中，那么我们需要添加相对路径以及图像的名称。
定义游戏字体
在屏幕上呈现文本之前，我们需要定义某些字体。
# Types of fonts to be used
small_font = pygame.font.Font(None, 32)
large_font = pygame.font.Font(None, 50)
Font()函数有两个参数:字体类型(默认字体为None)和字体大小。
设置游戏按钮的文本
我们的游戏有两个按钮:高和低。为按钮放置文本需要多个步骤:
- 为文本呈现字体
- 获取文本的矩形覆盖
- 将矩形放在屏幕上
# Hign and Low Game Buttons
high_button = large_font.render("HIGH", True, WHITE)
# Gets_rectangular covering of text
high_button_rect = high_button.get_rect()
# Places the text
high_button_rect.center = (280, 400)
low_button = large_font.render("LOW", True, WHITE)
low_button_rect = low_button.get_rect()
low_button_rect.center = (520, 400)
render()函数接受以下参数:
- 文本-“高”
- 对文本的平滑边缘应用抗锯齿？–正确
- 文本颜色-白色
get_rect()函数返回所提供文本的矩形覆盖。
下一行指定矩形封面的中心位置，从而放置文本。
定义我们的纸牌
为了定义我们的一副牌，我们首先要定义一张单独的牌。我们将借助 Python 类来完成这项任务。
# Card class definition
class Card:
def __init__(self, suit_type, value):
self.suit_type = suit_type
self.value = value
任何牌都有两个特征:花色类型和面值。继续讨论卡的定义，我们使用三种定义数据结构:
# The type of suit
suits = ["Spades", "Hearts", "Clubs", "Diamonds"]
# The type of card
cards = ["A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"]
# The card value
cards_values = {"A": 1, "2":2, "3":3, "4":4, "5":5, "6":6, "7":7, "8":8, "9":9, "10":10, "J":11, "Q":12, "K":13}
这些卡的存储是在 Python 对象列表中完成的。
# The deck of cards - List of Objects
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 the card to the deck
deck.append(Card(suit, card))
设置卡片图像
与图标图像类似，我们首先需要加载卡片图像，然后将它们呈现在游戏界面上。为此，我们需要一副牌中每张牌的图像。令人欣慰的是，它可以很容易地从互联网上获得。
这是卡片的样子:
The images for playing cards
正如我们所看到的，命名约定是必要的，因为当 Python 脚本从卡片组中取出卡片时，卡片将被加载。命名惯例很简单:牌值后跟花色的第一个字母。
# Load the card image
prev_card = pygame.image.load(r'./cards/card_cover.png')
# Scale the loaded image
prev_card = pygame.transform.scale(prev_card , (100,160))
# Choose the starting card from the deck
current_card = random.choice(deck)
# Keep choosing until it is not the highest or lowest
while current_card.value == "A" or current_card.value == "K":
current_card = random.choice(deck)
# Load the card image
cur_card = pygame.image.load(r'./cards/' + current_card.value + current_card.suit_type[0] + '.png')
# Scale the loaded card image
cur_card = pygame.transform.scale(cur_card , (100,160))
# Remove the card from the deck
deck.remove(current_card)
# Loading the card image
next_card = pygame.image.load(r'./cards/card_cover.png')
# Scaling the loaded image
next_card = pygame.transform.scale(next_card , (100,160))
放置原始图像文件可能会覆盖整个屏幕，因此，我们需要根据屏幕的宽度和高度来缩放图像。在 PyGame 中，这是通过scale()函数完成的，该函数接受一个输入图像和目标大小进行变换。
根据 Hi-Lo 游戏的规则，起始牌不能是最高或最低的牌，即分别是 a 或 k。我们运行一个循环，直到从一副牌中选出的牌不是他们中的任何一个。
在卡片被选取后，我们需要加载特定的卡片图像以显示在屏幕上。这是由load()函数完成的，该函数接受图像名称后面的相对路径。
声明游戏变量
有几个游戏变量是游戏所必需的:
# Number of chances left
chances = 3
# The current score
score = 0
# User's choice initialized
choice = -1
# Used to stop game functioning, if True
over = False
上述变量中的主要焦点是用于停止游戏运行的over变量，例如，按钮点击。
游戏循环
游戏循环是代码中永远运行的部分，负责维护游戏窗口、组件和游戏逻辑。
# The GAME LOOP
while True:
# Tracking the mouse movements
mouse = pygame.mouse.get_pos()
游戏循环的第一个议程是跟踪鼠标的移动。这对于识别鼠标点击的位置和其他事情来说很方便。
get_pos()函数以(X 轴，Y 轴)的形式返回鼠标在屏幕上的位置的 Python 元组。
处理 PyGame 事件
PyGame 开发中最重要的部分是处理游戏窗口中发生的事件。
PyGame 将发生的每个事件注册到一个事件对象列表中。我们将遍历每个事件对象来处理它。
# Loop events occuring inside the game window
for event in pygame.event.get():
# Qutting event
if event.type == pygame.QUIT:
pygame.quit()
quit()
# Left-mouse clicked event
if not over and event.type == pygame.MOUSEBUTTONDOWN:
# Clicked on the High Button
if 220 <= mouse[0] <= 220+125 and 370 <= mouse[1] <= 370+60:
choice = 1
# Clicked on the Low Button
if 460 <= mouse[0] <= 460+120 and 370 <= mouse[1] <= 370+60:
choice = 0
我们检查事件的类型并执行所需的任务。必须指出的是，在退出 python 代码之前，我们退出了 PyGame 模块。
游戏逻辑
游戏逻辑包括:
- 将当前卡片放入前一张卡片的位置。
- 从这副牌中选择一张新牌。
- 从这副牌中取出所选的牌。
- 检查新卡是高了还是低了。
- 如果牌越低，那么剩下的机会就越少。
- 如果牌更高，则增加分数。
- 重置玩家选择
# If a valid choice, the game logic
if choice != -1:
# Change current card to previous
previous_card = current_card
prev_card = pygame.image.load(r'./cards/' + previous_card.value + previous_card.suit_type[0] + '.png')
prev_card = pygame.transform.scale(prev_card , (100,160))
# Set up the current card
current_card = random.choice(deck)
deck.remove(current_card)
cur_card = pygame.image.load(r'./cards/' + current_card.value + current_card.suit_type[0] + '.png')
cur_card = pygame.transform.scale(cur_card , (100,160))
# Check the result, that is, High or Low
if cards_values[current_card.value] > cards_values[previous_card.value]:
result = 1
elif cards_values[current_card.value] < cards_values[previous_card.value]:
result = 0
else:
result = -1
# Manage the game variables
if result == -1:
continue
elif result == choice:
score = score + 1
else:
chances = chances - 1
# End the game if chances are finished
if chances == 0:
over = True
# Reset the choice
choice = -1
按钮动画
使用跟踪的鼠标移动，每当鼠标悬停在按钮上时，我们可以创建一个按钮动画。
# Manage the button hovering animation
if 220 <= mouse[0] <= 220+125 and 370 <= mouse[1] <= 370+60:
pygame.draw.rect(screen,LIGHT_GREEN,[220,370,125,60])
else:
pygame.draw.rect(screen,GREEN,[220,370,125,60])
if 460 <= mouse[0] <= 460+120 and 370 <= mouse[1] <= 370+60:
pygame.draw.rect(screen,LIGHT_RED,[460,370,120,60])
else:
pygame.draw.rect(screen,RED,[460,370,120,60])
在这段代码中，我们首先检查鼠标位置是否在按钮内部。如果是，那么我们在屏幕上用比原来的按钮颜色更浅的颜色画一个矩形，否则就是原来的按钮颜色。
这里的pygame.draw.rect()函数带三个参数，显示面(我们的游戏窗口)，矩形的颜色，盒子的尺寸【起始 x 坐标，起始 y 坐标，宽度，高度】。
显示记分板
我们需要显示一个记分牌，上面有当前的分数和剩余的机会数。
# Displaying scoreboard
pygame.draw.rect(screen, WHITE, [270, 40, 255, 90])
score_text = small_font.render("Score = "+str(score), True, BLACK)
score_text_rect = score_text.get_rect()
score_text_rect.center = (WIDTH//2, 70)
chances_text = small_font.render("Chances = "+str(chances), True, BLACK)
chances_text_rect = chances_text.get_rect()
chances_text_rect.center = (WIDTH//2, 100)
我们使用与按钮文本相似的文本呈现方式。
设置整个显示
在所有的显示组件初始化之后，我们可以使用blit()函数将它们放置在我们的游戏窗口上。
# Setting up all the buttons, images and texts on the screen
screen.blit(high_button, high_button_rect)
screen.blit(low_button, low_button_rect)
screen.blit(score_text, score_text_rect)
screen.blit(chances_text, chances_text_rect)
screen.blit(prev_card, (MARGIN_LEFT,MARGIN_TOP))
screen.blit(cur_card, (MARGIN_LEFT+120, MARGIN_TOP))
screen.blit(next_card, (MARGIN_LEFT+240, MARGIN_TOP))
blit()函数接收游戏对象，如图像或文本，以及其放置的位置。
管理最终游戏
在游戏逻辑中，当机会结束时，over变量被改为True。这里显示了它的效果。
# If the game is finished, display the final score
if over == True:
pygame.draw.rect(screen, WHITE, [270, 40, 255, 90])
score_text = small_font.render("Final Score = "+str(score), True, BLACK)
score_text_rect = score_text.get_rect()
score_text_rect.center = (WIDTH//2, 85)
screen.blit(score_text, score_text_rect)
游戏结束后，我们在记分牌上显示最终得分。
更新游戏显示
最后要做的事情是在游戏循环结束时更新游戏显示。
# Update the display after each game loop
pygame.display.update()
完整的代码
import pygame
import random
# Card class definition
class Card:
def __init__(self, suit_type, value):
self.suit_type = suit_type
self.value = value
if __name__ == '__main__':
# Margins
MARGIN_LEFT = 230
MARGIN_TOP = 150
# WINDOW SIZE
WIDTH = 800
HEIGHT = 600
# COLORS
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
GRAY = (110, 110, 110)
GREEN = (0, 255, 0)
LIGHT_GREEN = (0, 120, 0)
RED = (255, 0, 0)
LIGHT_RED = (120, 0, 0)
# The type of suit
suits = ["Spades", "Hearts", "Clubs", "Diamonds"]
# The type of card
cards = ["A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"]
# The card value
cards_values = {"A": 1, "2":2, "3":3, "4":4, "5":5, "6":6, "7":7, "8":8, "9":9, "10":10, "J":11, "Q":12, "K":13}
# The deck of cards - List of Objects
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 the card to the deck
deck.append(Card(suit, card))
# Initializing PyGame
pygame.init()
# Setting up the screen and background
screen = pygame.display.set_mode((WIDTH, HEIGHT))
screen.fill(GRAY)
# Setting up caption
pygame.display.set_caption("Hi-Lo Game")
# Loading image for the icon
icon = pygame.image.load('icon.jpeg')
# Setting the game icon
pygame.display.set_icon(icon)
# Types of fonts to be used
small_font = pygame.font.Font(None, 32)
large_font = pygame.font.Font(None, 50)
# Hign and Low Game Buttons
high_button = large_font.render("HIGH", True, WHITE)
# Gets_rectangular covering of text
high_button_rect = high_button.get_rect()
# Places the text
high_button_rect.center = (280, 400)
low_button = large_font.render("LOW", True, WHITE)
low_button_rect = low_button.get_rect()
low_button_rect.center = (520, 400)
# Load the card image
prev_card = pygame.image.load(r'./cards/card_cover.png')
# Scale the loaded image
prev_card = pygame.transform.scale(prev_card , (100,160))
# Choose the starting card from the deck
current_card = random.choice(deck)
# Keep choosing until it is not the highest or lowest
while current_card.value == "A" or current_card.value == "K":
current_card = random.choice(deck)
# Load the card image
cur_card = pygame.image.load(r'./cards/' + current_card.value + current_card.suit_type[0] + '.png')
# Scale the loaded card image
cur_card = pygame.transform.scale(cur_card , (100,160))
# Remove the card from the deck
deck.remove(current_card)
# Loading the card image
next_card = pygame.image.load(r'./cards/card_cover.png')
# Scaling the loaded image
next_card = pygame.transform.scale(next_card , (100,160))
# Number of chances left
chances = 3
# The current score
score = 0
# User's choice initialized
choice = -1
# Used to stop game functioning, if True
over = False
# The GAME LOOP
while True:
# Tracking the mouse movements
mouse = pygame.mouse.get_pos()
# Loop events occuring inside the game window
for event in pygame.event.get():
# Qutting event
if event.type == pygame.QUIT:
pygame.quit()
quit()
# Left-mouse clicked event
if not over and event.type == pygame.MOUSEBUTTONDOWN:
# Clicked on the High Button
if 220 <= mouse[0] <= 220+125 and 370 <= mouse[1] <= 370+60:
choice = 1
# Clicked on the Low Button
if 460 <= mouse[0] <= 460+120 and 370 <= mouse[1] <= 370+60:
choice = 0
# Finish the game if the deck is finished
if len(deck) == 1:
over = True
# If a valid choice, the game logic
if choice != -1:
# Change current card to previous
previous_card = current_card
prev_card = pygame.image.load(r'./cards/' + previous_card.value + previous_card.suit_type[0] + '.png')
prev_card = pygame.transform.scale(prev_card , (100,160))
# Set up the current card
current_card = random.choice(deck)
deck.remove(current_card)
cur_card = pygame.image.load(r'./cards/' + current_card.value + current_card.suit_type[0] + '.png')
cur_card = pygame.transform.scale(cur_card , (100,160))
# Check the result, that is, High or Low
if cards_values[current_card.value] > cards_values[previous_card.value]:
result = 1
elif cards_values[current_card.value] < cards_values[previous_card.value]:
result = 0
else:
result = -1
# Manage the game variables
if result == -1:
continue
elif result == choice:
score = score + 1
else:
chances = chances - 1
# End the game if chances are finished
if chances == 0:
over = True
# Reset the choice
choice = -1
# Manage the button hovering animation
if 220 <= mouse[0] <= 220+125 and 370 <= mouse[1] <= 370+60:
pygame.draw.rect(screen,LIGHT_GREEN,[220,370,125,60])
else:
pygame.draw.rect(screen,GREEN,[220,370,125,60])
if 460 <= mouse[0] <= 460+120 and 370 <= mouse[1] <= 370+60:
pygame.draw.rect(screen,LIGHT_RED,[460,370,120,60])
else:
pygame.draw.rect(screen,RED,[460,370,120,60])
# Displaying scoreboard
pygame.draw.rect(screen, WHITE, [270, 40, 255, 90])
score_text = small_font.render("Score = "+str(score), True, BLACK)
score_text_rect = score_text.get_rect()
score_text_rect.center = (WIDTH//2, 70)
chances_text = small_font.render("Chances = "+str(chances), True, BLACK)
chances_text_rect = chances_text.get_rect()
chances_text_rect.center = (WIDTH//2, 100)
# Setting up all the buttons, images and texts on the screen
screen.blit(high_button, high_button_rect)
screen.blit(low_button, low_button_rect)
screen.blit(score_text, score_text_rect)
screen.blit(chances_text, chances_text_rect)
screen.blit(prev_card, (MARGIN_LEFT,MARGIN_TOP))
screen.blit(cur_card, (MARGIN_LEFT+120, MARGIN_TOP))
screen.blit(next_card, (MARGIN_LEFT+240, MARGIN_TOP))
# If the game is finished, display the final score
if over == True:
pygame.draw.rect(screen, WHITE, [270, 40, 255, 90])
score_text = small_font.render("Final Score = "+str(score), True, BLACK)
score_text_rect = score_text.get_rect()
score_text_rect.center = (WIDTH//2, 85)
screen.blit(score_text, score_text_rect)
# Update the display after each game loop
pygame.display.update()
结论
使用 PyGame 创建我们自己的 Hi-Lo 游戏似乎是一项简单的任务。我们希望这个教程能成为读者未来 PyGame 测试和冒险的基础。
感谢您的阅读。如有疑问或建议，欢迎在下面发表评论。
Python Pygame:循环背景
原文：https://www.askpython.com/python-modules/pygame-looping-background
你好。今天我将教你如何在 Pygame 中制作一个非常有趣的循环背景！所以让我们开始吧！
步骤 1:导入 Pygame
我们将从导入pygame模块开始。我们还会将 pygame 初始化到我们的程序中。我们还将为 pygame 窗口的基本功能导入python.locals库
相同的代码如下所示。
import pygame
from pygame.locals import *
pygame.init()
步骤 2:创建基本窗口
接下来需要做的是创建变量来设置游戏窗口的宽度和高度。现在，让我们保持宽度和高度分别为 1000 和 500。
使用名为display.set_mode的 pygame 函数创建一个窗口对象，并传递游戏窗口的高度和宽度。
相同的代码如下所示:
width,height = 1000,500
window = pygame.display.set_mode((width,height))
步骤 3:添加背景图像
要添加背景图像，我们需要做的就是使用名为image.load的函数，并添加图像的路径作为参数。
我们还将调整图像的大小，以确保它完全填满整个屏幕。为此，我们将使用transform.scale函数，并传递我们的原始图像以及缩放尺寸，即屏幕尺寸。
相同的代码如下所示:
bg_img = pygame.image.load('Images/bg.jpg')
bg_img = pygame.transform.scale(bg_img,(width,height))
但是这段代码只会显示窗口几秒钟，然后就消失了。我们不需要那个！
因此，我们将添加逻辑，确保屏幕一直显示，直到用户点击屏幕上的X。
让我先给你看看代码。
runing = True
while runing:
window.blit(bg_img,(0,0))
for event in pygame.event.get():
if event.type == QUIT:
runing = False
pygame.display.update()
pygame.quit()
在代码中，我们创建了一个默认设置为True的运行变量。只要运行变量保持为真，应用程序就会运行。
为了放置图像，我们必须在运行循环中放置一个blit函数。blit函数将获取图像变量和图像的坐标。
为了设置游戏结束逻辑，我们将跟踪所有事件，并检查游戏中发生的事件类型。如果事件类型是按下屏幕上的X按钮，我们设置运行值为假。
但是背景图像的显示仍然没有完成。为此，我们将添加一个display.update函数，用声明的所有元素更新屏幕。
在加载并关闭整个屏幕后，我们退出了之前初始化的 pygame。
在我们做了所有必要的工作后，我们将会看到如下所示的屏幕。(如果您选择不同的背景图像或屏幕大小，背景图像或窗口形状可能会有所不同)
Screen01 Loop Bg
步骤 4:用 Pygame 循环背景
我们的主要目的是沿着屏幕的宽度循环背景图像。为此，我们将使用一个迭代器，i,并用 0 值初始化它。
我们将减少这个迭代器 (i ),因为我们必须继续。
下面的代码显示了代码的进度以及必要的更改。更改后的行也会突出显示，以便您更容易理解。
import pygame
from pygame.locals import *
pygame.init()
width = 1000
height = 500
window = pygame.display.set_mode((width,height))
bg_img = pygame.image.load('Images/bg.jpg')
bg_img = pygame.transform.scale(bg_img,(width,height))
i = 0
runing = True
while runing:
window.blit(bg_img,(i,0))
i-=1
for event in pygame.event.get():
if event.type == QUIT:
runing = False
pygame.display.update()
pygame.quit()
下面的视频显示了代码的结果。哦，看看右边的循环背景！但是结尾看起来不太对。
这里的问题是我们没有重画图像。因此，程序保持加载像素的最后配置。
现在为了解决这个问题，我们将在图像完全加载后，通过添加背景色来测试这种情况。同样，我们将使用fill函数，并传递颜色的 RBG 格式。现在我们将使用 黑色 。
同样的代码如下所示。这一行将出现在背景图像加载命令之前。
window.fill((0,0,0))
同样的输出如下所示。
但是我们希望在背景图像的宽度结束后加载背景图像，而不是黑色。同样，我们将使用blit函数并在未来坐标应用背景图像。同样的代码行如下所示。
window.blit(bg_img,(width+i,0))
添加代码行后的输出如下所示。背景图像显示两次，但随后再次返回背景。我们不想那样。
发生这种情况的原因是，I 达到了屏幕宽度的负值。我们需要处理同样的情况，当 I 达到宽度的负值时，通过使用blit函数来完成。I 值也被重置，即设置为 0。
相同的代码如下所示。这段代码添加在 i decrement 命令和初始加载背景图像之间。
if (i==-width):
window.blit(bg_img,(width+i,0))
i=0
最终代码如下所示。希望你现在清楚所有的概念。
import pygame
from pygame.locals import *
pygame.init()
width = 1000
height = 500
window = pygame.display.set_mode((width,height))
bg_img = pygame.image.load('Images/bg.jpg')
bg_img = pygame.transform.scale(bg_img,(width,height))
i = 0
runing = True
while runing:
window.fill((0,0,0))
window.blit(bg_img,(i,0))
window.blit(bg_img,(width+i,0))
if (i==-width):
window.blit(bg_img,(width+i,0))
i=0
i-=1
for event in pygame.event.get():
if event.type == QUIT:
runing = False
pygame.display.update()
pygame.quit()
代码的最终输出如下所示。
结论
这种类型的背景循环可用于创建一些基本的 2D 游戏，如简单的跑步或跳跃游戏。
希望你喜欢这个教程！
感谢您的阅读！
py installer–创建可执行 Python 文件
原文：https://www.askpython.com/python/pyinstaller-executable-files
嘿伙计们！在本教程中，我们将学习 Python 的 PyInstaller 的用途和基础知识。所以，让我们开始吧！
PyInstaller 是什么？
PyInstaller 是 Python 中的一个包，它将 Python 应用程序的所有依赖项捆绑在一个包中。
我们不需要为不同的应用程序安装不同的包或模块。
PyInstaller 读取并分析我们的代码，然后发现程序执行所需的模块。然后将它们打包到一个文件夹或一个可执行文件中。
它用于创建；用于 windows 的 exe 文件。适用于 Mac 的应用程序文件和适用于 Linux 的可分发包。
如何安装 PyInstaller？
我们可以从 PyPI 下载 PyInstaller。我们可以使用 pip 包管理器来安装它。
建议创建一个虚拟环境并在那里安装 PyInstaller。
在 windows 命令提示符下输入以下命令-
pip install pyinstaller
现在，将当前目录设置为您的程序 program.py 的位置。
cd CurrentDirectory
运行下面给出的代码。这里， program.py 是我们给定的 python 脚本的名称。
pyinstaller program.py
PyInstaller 分析我们的代码并执行以下操作-
- 创建一个 program.spec 文件，其中包含关于应该打包的文件的信息。
- 创建一个包含一些日志文件和工作文件的构建文件夹。
- 还将创建一个名为 dist 的文件夹，其中包含一个。与给定的 python 脚本名称同名的 exe 文件。
现在，使用 PyInstaller 有 3 个重要元素:
- 的。规格文件
- 构建文件夹
- dist 文件夹
什么是等级库文件？
规格文件，简称规格文件，是执行pyinstaller program.py后建立的第一个文件。它存储在--specpath= directory中。spec 文件是一个可执行的 python 代码，它告诉 PyIstaller 如何处理我们的 Python 脚本。
不需要修改规范文件，除非在极少数情况下，当我们希望:
- 将我们的数据文件与应用程序捆绑在一起。
- 包含 PyInstaller 未知的运行时库。
- 向可执行文件添加 Python 运行时选项。
- 用合并的公用模块创建多道程序包。
要创建一个规范文件，运行以下命令-
pyi-makespec program.py
该命令创建 program.py 规格文件。为了构建应用程序，我们将规范文件传递给 pyinstaller 命令:
pyinstaller program.spec
什么是构建文件夹？
构建文件夹存储元数据，对调试很有用。**
**build/文件夹中的文件 build/program/warn-program.txt 包含了很多输出，可以更好的理解事情。
要查看输出，使用--log-level=DEBUG选项重建可执行文件。建议保存此输出，以便以后参考。我们可以通过-
pyinstaller --log-level=DEBUG program.py
这将在 build 文件夹中创建一个 build.txt 文件，其中将包含许多调试消息。
什么是 dist 文件夹？
dist 文件夹包含应用程序的需求和可执行文件。它包含一个与我们的脚本同名的. exe 文件。
要运行的可执行文件在 windows 上是 dist/program/program.exe 。
什么是导入错误？
如果 PyInstaller 无法正确检测所有的依赖项，就会出现一个 导入错误 错误。当我们使用__import__( ) 时就会出现这种情况。函数内部导入或隐藏导入。
为了解决这个问题，我们使用了--hidden-import。该命令自动包含软件包和模块。
另一种方法是使用包含附加信息的钩子文件来帮助 PyInstaller 打包一个依赖项。
pyinstaller --additional-hooks-dir=. program.py
如何使用 PyInstaller 更改可执行文件的名称？
为了避免我们的规范、构建和可执行文件被命名为与我们的 python 脚本名称相同，我们可以使用–name命令。
pyinstaller program.py --name pythonproject
如何创建单个可执行文件？
PyInstaller 还可以为我们的 Python 脚本创建一个单文件应用程序。它包含我们的 Python 程序所需的所有 Python 模块的档案。
要创建 python 脚本的一个可执行文件，运行下面给出的代码-
pyinstaller --onefile --windowed program.py
测试我们的可执行文件
我们应该总是在一台没有任何开发环境的新机器上测试我们的可执行程序，比如 virtualev 、 conda 等等。因为 PyInstaller 可执行文件的主要目的是用户不需要在他们的系统上安装任何东西。
现在，在运行可执行文件之后，出现了以下错误。
FileNotFoundError: 'version.txt' resource not found in 'importlib_resources'
这是因为 'importlib_resources' 需要 version.txt 文件。我们可以通过下面给出的命令添加这个文件。
pyinstaller program.py \
--add-data venv/reader/lib/python3.6/site-packages/importlib_resources/version.txt:importlib_resources
这将包括 importlib_resources 文件夹下新文件夹中的 version.txt 文件。
结论
在本文中，我们学习了如何安装 PyInstaller、运行、调试和测试我们的可执行文件。敬请期待！
参考
PyPDF2:用于 PDF 文件操作的 Python 库
原文：https://www.askpython.com/python-modules/pypdf2-python-library-for-pdf-files
PyPDF2 是一个处理 PDF 文件的纯 python 库。我们可以使用 PyPDF2 模块来处理现有的 PDF 文件。我们无法使用此模块创建新的 PDF 文件。
PyPDF2 特性
PyPDF2 模块的一些令人兴奋的特性包括:
- PDF 文件元数据，如页数、作者、创建者、创建时间和上次更新时间。
- 逐页提取 PDF 文件内容。
- 合并多个 PDF 文件。
- 将 PDF 文件页面旋转一个角度。
- PDF 页面的缩放。
- 使用 Pillow library 从 PDF 页面提取图像并将其保存为图像。
安装 PyPDF2 模块
我们可以使用 PIP 来安装 PyPDF2 模块。
$ pip install PyPDF2
PyPDF2 示例
让我们看一些使用 PyPDF2 模块处理 PDF 文件的例子。
1.提取 PDF 元数据
我们可以得到 PDF 文件的页数。我们还可以获得关于 PDF 作者、创建者应用程序和创建日期的信息。
import PyPDF2
with open('Python_Tutorial.pdf', 'rb') as pdf_file:
pdf_reader = PyPDF2.PdfFileReader(pdf_file)
print(f'Number of Pages in PDF File is {pdf_reader.getNumPages()}')
print(f'PDF Metadata is {pdf_reader.documentInfo}')
print(f'PDF File Author is {pdf_reader.documentInfo["/Author"]}')
print(f'PDF File Creator is {pdf_reader.documentInfo["/Creator"]}')
样本输出:
Number of Pages in PDF File is 2
PDF Metadata is {'/Author': 'Microsoft Office User', '/Creator': 'Microsoft Word', '/CreationDate': "D:20191009091859+00'00'", '/ModDate': "D:20191009091859+00'00'"}
PDF File Author is Microsoft Office User
PDF File Creator is Microsoft Word
推荐阅读 : Python 带语句和 Python f-strings
- PDF 文件应该以二进制模式打开。这就是为什么文件打开模式被作为' rb '传递。
- PdfFileReader 类用于读取 PDF 文件。
- documentInfo 是一个包含 PDF 文件元数据的字典。
- 我们可以使用 getNumPages()函数获得 PDF 文件的页数。另一种方法是使用
numPages属性。
2.提取 PDF 页面的文本
import PyPDF2
with open('Python_Tutorial.pdf', 'rb') as pdf_file:
pdf_reader = PyPDF2.PdfFileReader(pdf_file)
# printing first page contents
pdf_page = pdf_reader.getPage(0)
print(pdf_page.extractText())
# reading all the pages content one by one
for page_num in range(pdf_reader.numPages):
pdf_page = pdf_reader.getPage(page_num)
print(pdf_page.extractText())
- PdfFileReader getPage(int)方法返回
PyPDF2.pdf.PageObject实例。 - 我们可以在 page 对象上调用 extractText()方法来获取页面的文本内容。
- extractText()不会返回任何二进制数据，如图像。
3.旋转 PDF 文件页面
PyPDF2 允许多种类型的操作，可以逐页进行。我们可以顺时针或逆时针旋转页面一个角度。
import PyPDF2
with open('Python_Tutorial.pdf', 'rb') as pdf_file:
pdf_reader = PyPDF2.PdfFileReader(pdf_file)
pdf_writer = PyPDF2.PdfFileWriter()
for page_num in range(pdf_reader.numPages):
pdf_page = pdf_reader.getPage(page_num)
pdf_page.rotateClockwise(90) # rotateCounterClockwise()
pdf_writer.addPage(pdf_page)
with open('Python_Tutorial_rotated.pdf', 'wb') as pdf_file_rotated:
pdf_writer.write(pdf_file_rotated)
- PdfFileWriter 用于从源 PDF 写入 PDF 文件。
- 我们使用 rotateClockwise(90)方法将页面顺时针旋转 90 度。
- 我们将旋转的页面添加到 PdfFileWriter 实例中。
- 最后，使用 PdfFileWriter 的 write()方法生成旋转后的 PDF 文件。
PDF writer 可以从一些源 PDF 文件编写 PDF 文件。我们不能用它从一些文本数据创建 PDF 文件。
4.合并 PDF 文件
import PyPDF2
pdf_merger = PyPDF2.PdfFileMerger()
pdf_files_list = ['Python_Tutorial.pdf', 'Python_Tutorial_rotated.pdf']
for pdf_file_name in pdf_files_list:
with open(pdf_file_name, 'rb') as pdf_file:
pdf_merger.append(pdf_file)
with open('Python_Tutorial_merged.pdf', 'wb') as pdf_file_merged:
pdf_merger.write(pdf_file_merged)
上面的代码看起来很适合合并 PDF 文件。但是，它生成了一个空的 PDF 文件。原因是在实际写入创建合并的 PDF 文件之前，源 PDF 文件已经关闭。
是 PyPDF2 最新版本的 bug。你可以在本期 GitHub 中读到。
有一种替代方法是使用contextlib模块保持源文件打开，直到写操作完成。
import contextlib
import PyPDF2
pdf_files_list = ['Python_Tutorial.pdf', 'Python_Tutorial_rotated.pdf']
with contextlib.ExitStack() as stack:
pdf_merger = PyPDF2.PdfFileMerger()
files = [stack.enter_context(open(pdf, 'rb')) for pdf in pdf_files_list]
for f in files:
pdf_merger.append(f)
with open('Python_Tutorial_merged_contextlib.pdf', 'wb') as f:
pdf_merger.write(f)
你可以通过这个 StackOverflow 问题了解更多信息。
5.将 PDF 文件分割成单页文件
import PyPDF2
with open('Python_Tutorial.pdf', 'rb') as pdf_file:
pdf_reader = PyPDF2.PdfFileReader(pdf_file)
for i in range(pdf_reader.numPages):
pdf_writer = PyPDF2.PdfFileWriter()
pdf_writer.addPage(pdf_reader.getPage(i))
output_file_name = f'Python_Tutorial_{i}.pdf'
with open(output_file_name, 'wb') as output_file:
pdf_writer.write(output_file)
Python_Tutorial.pdf 有 2 页。输出文件被命名为 Python_Tutorial_0.pdf 和 Python_Tutorial_1.pdf。
6.从 PDF 文件中提取图像
我们可以使用 PyPDF2 和 Pillow (Python 图像库)从 PDF 页面中提取图像并保存为图像文件。
首先，您必须使用以下命令安装 Pillow 模块。
$ pip install Pillow
下面是一个从 PDF 文件的第一页提取图像的简单程序。我们可以很容易地扩展它，从 PDF 文件中提取所有的图像。
import PyPDF2
from PIL import Image
with open('Python_Tutorial.pdf', 'rb') as pdf_file:
pdf_reader = PyPDF2.PdfFileReader(pdf_file)
# extracting images from the 1st page
page0 = pdf_reader.getPage(0)
if '/XObject' in page0['/Resources']:
xObject = page0['/Resources']['/XObject'].getObject()
for obj in xObject:
if xObject[obj]['/Subtype'] == '/Image':
size = (xObject[obj]['/Width'], xObject[obj]['/Height'])
data = xObject[obj].getData()
if xObject[obj]['/ColorSpace'] == '/DeviceRGB':
mode = "RGB"
else:
mode = "P"
if '/Filter' in xObject[obj]:
if xObject[obj]['/Filter'] == '/FlateDecode':
img = Image.frombytes(mode, size, data)
img.save(obj[1:] + ".png")
elif xObject[obj]['/Filter'] == '/DCTDecode':
img = open(obj[1:] + ".jpg", "wb")
img.write(data)
img.close()
elif xObject[obj]['/Filter'] == '/JPXDecode':
img = open(obj[1:] + ".jp2", "wb")
img.write(data)
img.close()
elif xObject[obj]['/Filter'] == '/CCITTFaxDecode':
img = open(obj[1:] + ".tiff", "wb")
img.write(data)
img.close()
else:
img = Image.frombytes(mode, size, data)
img.save(obj[1:] + ".png")
else:
print("No image found.")
我的示例 PDF 文件在第一页有一个 PNG 图像，程序用“image20.png”文件名保存它。
参考
PySimpleGUI:用 Python 创建 GUI 的简单方法
每当我们谈论 Python 编程时，我们经常会讨论围绕它的大型社区，这些社区将这种语言用于如此多的有用目的，以及我们可以用它解决的各种各样的问题。大多数 python 程序在其核心使用“命令行。对于在日常编程场景中经常看到终端的人来说，这在大多数情况下不是问题。
这不是一个仍然想使用 Python 程序的正常人的情况，而是存在一个可能被视为“ GUI 鸿沟”的数字鸿沟。
那么，我们谈论的这个图形用户界面是什么呢？
GUI 或图形用户界面提供了一个图形工具，可以交互地使用它来执行某些操作，这使得程序更容易被各种各样的观众所接受。GUI 需要解决的另一个障碍是它们不容易自己编程。这个问题的解决方案是什么？
嗯， PySimpleGUI 非常方便，它为我们提供了几个选项来轻松地编写 GUI，并使用更少的代码行。
也读: Tkinter 教程——用 Tkinter 画布画一条线
PySimpleGUI 简介
PySimpleGUI 是一个 Python 包，它为我们提供了各种选项，为所有级别的 Python 程序员创建 GUI。这个包实现了大部分的“样板代码”(在多个地方重复的代码段，几乎没有变化)。根据所使用的程序和框架，PySimpleGUI 程序可能需要 1/2 到 1/10 的代码量来直接使用其中一个框架创建一个相同的窗口。
为了编写一个简单的 GUI，我们需要使用一个“t”来指定什么叫做我们的“窗口，它包含小部件或者“元素”(在 PySimpleGUI 中调用)。我们指定的这个布局用于创建一个窗口，并使用 4 支持的框架来完成我们的应用程序的所有繁重工作，以显示我们的窗口并与之交互。
支持的框架有 Tkinter ，Qt，WxPython，Remi。这些包装有时被称为“包装纸”。****
使用 PySimpleGUI 理解核心概念
- 安装 PySimpleGUI 库并将其作为 sg 导入
!pip install library
- 导入
import PySimpleGUI as sg
- 定义窗口的内容:这里我们为 GUI 定义了布局。
****布局的第一部分是 GUI 的顶行文本，即“你的城市名是什么？”。
****第二部分是输入语句，其中 key='-INPUT-' 。语法的关键部分将把我们的输入连接到值，该值将在显示输出时被使用。
假设布局的第三部分是输出层，给它一个特定尺寸，同样提供键= "-输出-"** 。**
布局的第四部分是图形按钮，文本【确定】和【退出】并排排列。****
这总结了我们的布局定义。
#Define the window's contents
layout = [[sg.Text("What's your city name?")],
[sg.Input(key='-INPUT-')],
[sg.Text(size=(40,1), key='-OUTPUT-')],
[sg.Button('Ok'), sg.Button('Quit')]]
- 现在，我们已经定义了我们的布局，我们正在为我们的布局提供一个“标题”，同时创建我们的 GUI 窗口。我们使用 PySimple GUI 包提供的 窗口方法将标题和布局变量作为参数传递
#Create the window
window = sg.Window('Window Title', layout)
-
代码的下一部分是定义一个条件。 window.read 方法读取"事件"，在本例中是在我们的窗口中的" X "(关闭)按钮上的点击事件，以关闭它，这是由 PySimple GUI 提供的" WINDOW_CLOSED "函数或同样触发事件的 "Quit" 按钮处理的。在这两种情况下，我们都在处理这些事件，从循环中脱离，并关闭我们的 GUI。
-
条件的最后部分是我们使用键"-输出-** "的地方，它已经链接到我们窗口的输出层，我们正在用字符串'更新输出层'+ values['-INPUT-'] +"！感谢尝试 PySimpleGUI ，它再次与键 " -INPUT- "链接，并且 window.read 函数捕获值并在我们预定义的布局中显示它。**
#Display and interact with the Window using an Event Loop
while True:
event, values = window.read()
# See if user wants to quit or window was closed
if event == sg.WINDOW_CLOSED or event == 'Quit':
break
# Output a message to the window
window['-OUTPUT-'].update('Welcome to ' + values['-INPUT-'] + "! Thanks for trying PySimpleGUI")
# Finish up by removing from the screen
window.close()
带有输出的完整 PySimpleGUI 代码
#install PySimpleGUI library
!pip install library
import PySimpleGUI as sg
#Define the window's contents
layout = [[sg.Text("What's your city name?")],
[sg.Input(key='-INPUT-')],
[sg.Text(size=(40,1), key='-OUTPUT-')],
[sg.Button('Ok'), sg.Button('Quit')]]
#Create the window
window = sg.Window('Window Title', layout)
#Display and interact with the Window using an Event Loop
while True:
event, values = window.read()
# See if user wants to quit or window was closed
if event == sg.WINDOW_CLOSED or event == 'Quit':
break
# Output a message to the window
window['-OUTPUT-'].update('Welcome to ' + values['-INPUT-'] + "! Thanks for trying PySimpleGUI")
# Finish up by removing from the screen
window.close()
输出
**
Pop up window asking for the city name** **
pop up window after the input**
结论
在本文中，我们使用 PySimple GUI 库创建了一个非常简单的窗口。这个包背后的整个思想是在底层代码实现上提供一个易于使用和人类可读的抽象，用几行代码创建一个 GUI。因此，对于几乎所有级别的 python 开发人员来说，它都是一个非常棒的库，可以简单直观地创建 GUI。
参考
Pyspark 教程-初学者参考[有 5 个简单的例子]
原文：https://www.askpython.com/python-modules/pyspark-tutorial
这篇文章是关于最著名的框架库 Pyspark 的全部内容。对于大数据和数据分析， Apache Spark 是用户的选择。这是由于它的一些很酷的功能，我们将讨论。但在此之前，让我们先了解 PySpark 的不同部分，从大数据开始，然后是 Apache Spark。
也看: PyGame 教程:Python 中的图形化 Hi-Lo 游戏
什么是大数据？
在这个网络时代，每一条信息都可以在社交媒体、新闻和其他大型远程媒体上获得。就在几年前，这还是不可能的。一切都保存在文件或纸质记录中。但是今天这变得容易多了。为此，我们都有意或无意地生成大量数据，这些数据需要大量的实时处理和分析。
因此，从技术的巢穴中，出现了一个新的领域—大数据。
这个术语通过名称本身定义了定义- 数据大量可用 。但是，为什么它需要发生呢？因为通过对现有资源的深入研究，未来的预测是可能的。许多大公司和科技巨头都在投资大数据工程师。他们可以每天管理和维护重要而庞大的信息。但是，我们都知道，要做到这一点，我们需要一些工具和技术。
什么是阿帕奇火花？
Apache spark 是一个来自数据砖的 web 框架。它是专为数据管理而开发的。这是与大数据最相关的引擎之一。其特点如下:
- 免费开源:免费使用，开发者 300 多家公司为其开发做出贡献。
- 更快更稳定:考虑到它的速度比 Hadoop 等任何其他引擎都快 100 倍。
- 简单而强大:对我们来说很简单，实现各种数据分析技术。
- 跨平台:适合所有操作系统。
- 多语言支持:我们可以使用 Java、Python、R、Scala、SQL 进行专有使用。
- 复杂数据操作处理:能够分析最复杂的数据。
- 巨大的社区支持:它拥有全球开发者的支持。
除此之外，还有四套主要的库和其他第三方库:
- SQL 和数据框架。
- 火花四溅。
- MLib(机器学习)
- GraphX
主要的第三方库包括来自 C#/的额外支持。NET、Groovy、Kotlin、Julia 和 Clojure。云支持包括 IBM、亚马逊 AWS 和其他公司。更多信息请阅读此 链接 的文档。
Pyspark 是什么？
Pyspark 是 Apache Spark 对 Python 的著名扩展。它是一个开源库，主要关注:
- 机器学习
- 专有数据分析。
- 数据科学
- 使用 Python 和支持库的大数据。
由于广泛的贡献和开发者的支持，它已经成为最稳定和最合适的特殊模型构建包。在此框架下开发的模型往往会给出更准确、更快速的结果。
这更有用，因为它总是得到 API 的支持。想了解更多请访问此 链接 。在将它们添加到系统之前，我们必须考虑依赖性。
系统要求:
- Python 版本 : Python 3.6 及以上。
- 操作系统: Windows 7 及以上。
- 其他库支持: Numpy，熊猫等。
- 稳定的互联网连接是必不可少的。
如何在 Windows 中设置 PySpark？
按照以下步骤将 Pyspark 安装到您的系统中:
- 去https://pypi.org/project/pyspark/，在那里你会找到这个项目的文档。
- 这里也给出了通过 pip 命令进行安装的链接。
- 转到命令提示符处，键入以下命令:
pip install pyspark
Installation of Pyspark in the Anaconda environment through the pip command.
注意:默认环境是 Anaconda ，所以所有通过 pip 的库也被添加到 Anaconda only。
最重要的是确认它已经成功添加到我们的系统中，打开任何 Python IDE 并尝试导入它。如果它没有任何错误，那么我们都将踏上更远的旅程。
Configuring Pyspark Through IDLE
从 PySpark 开始
我们需要一个样本数据集来处理和使用 Pyspark。这是快速入门指南，我们将介绍基本知识。
环境:蟒蛇
IDE : Jupyter 笔记本
使用的数据集: titanic.csv
在 Pyspark 中首先创建的最重要的东西是一个会话。会话是我们的 spark 应用程序所在的参考框架。我们创建的会话封装了我们从开始到最后一个检查点的进度。我们通过 spark 的 SQL 模块创建它。
1.创建会话
让我们从使用 PySpark 的最基本部分开始——创建会话。以下代码可用于设置您的第一个会话。
代码:
import pyspark # importing the module
from pyspark.sql import SparkSession # importing the SparkSession module
session = SparkSession.builder.appName('First App').getOrCreate() # creating a session
session # calling the session variable
Creating A Session In Pyspark In Jupyter Notebooks
2.在 Spark 中读取数据集
当我们谈论数据集时，它是以行列格式的大量数据和记录的集合。它们可以是成千上万或更多。
具体来说，它们是我们称之为数据预处理的过程的一个重要方面。为了预测一些输出或结果，我们需要预处理数据，执行额外操作和情感分析。为此，Python 提供了特定的模块或库。
通常，我们使用熊猫库 来实现这个目的。但是，PySpark 的子模块减少了我们导入其他库的工作量。这样，它就有了 read()方法。这个方法有许多子方法，用于不同的文件扩展名和格式。这些是:
- 战斗支援车
- 格式
- jdbc
- 负荷
- 选择权
- 选择
- 妖魔
- 门球
- (计划或理论的)纲要
- 桌子
- 文本
我们正在使用泰坦尼克号的数据集。csv 扩展名，所以我们将使用第一种方法。
代码:
data = session.read.csv('Datasets/titanic.csv') # reading the dataset through the given path
data # calling the variable for column created
Reading The titanic.csv dataset.
我们创建的会话是这段代码的主要方法。然后，read 方法和 extension 方法使用点操作符。
若要检查数据集中的所有列和行，请使用 show()方法。如果太大，这将检索前 20 行。
data.show()
Retrieving The Dataset
现在我们可以看到这个数据集的呈现是不恰当的。列名没有整齐地出现。所以，我们需要对它做一些改变。read.option()方法使我们的工作变得容易。这将帮助我们检索带有标题的数据集。
代码:
data = session.read.option.('header', 'true').csv('Datasets/titanic.csv')
data
输出:
Retrieving The Headers From The Dataset
现在，如果我们检查数据集，它看起来像这样:
Getting The New Formatted Dataset
现在我们已经准备好了数据集，让我们获得一些关于它的列的信息。在 pandas 中，我们简单地使用了 info() 方法。在 Pyspark 中， printSchema() 是读取和给出关于每一列的信息值的方法。
代码:
data.printSchema()
Information Of The Dataset
默认情况下，Pyspark 以字符串的形式读取所有数据集。因此，为了处理这个问题，我们需要激活一个参数，即推断模式。它将读取所有主要列及其各自的数据类型，并相应地返回信息。
data = session.readoption('header', 'true').csv('Datasets/titanic.csv', inferSchema = True)
data.printSchema()
Exact Data Types
3.数据预处理
Pyspark 中的数据预处理相当简单。该库为我们提供了执行此类任务的特定功能。以下活动涉及。
- 选择一个特定的列
- 选择多列
- 添加一列
- 删除一列
- 重命名列
- 删除空值
要选择一列或多列，select()函数可以很好地工作。语法是:
dataframe.select(column_name) # selecting one column
dataframe.select(column_1, column_2, .., column_N) # selecting many columns
输出:
Selecting One Column
Selecting Multiple Columns
在 dataframe.withColumn()函数中添加一列。它需要两个参数
- 要添加的新列名
- 用于的现有列名(如果新列与现有列无关，则不需要)
代码:
# adding columns in dataframe
data = data.withColumn('Age_after_3_y', data['Age']+3)
我们在数据框中增加了一栏三年后的年龄。所用的年龄列是一个现有列。通过它，我们会计算出三年后乘客的年龄。
输出:
Adding A New Column In The Dataset
正如我们可以看到的，一个新的列被添加到了末尾。它的名字是: Age_after_3_y 。
4.从数据集中删除列和空值
Pyspark 中的删除是我们可以执行的最简单的任务。因为它给了我们那么多的灵活性和适应性。drop()函数执行删除列的任务。这种方法的语法很简单。
# dropping the columns
dataframe = dataframe.drop('column_name in strings')
dataframe.show()
我们将删除之前添加到数据集中的 Age_after_3_y 列。
代码:
# dropping the columns
data = data.drop('Age_after_3_y')
data.show()
Deleting A Column In The Dataset
重命名该列是一项比较简单的任务。withColunRenamed()函数同样可以帮助我们。它需要两个参数
- 列的新名称。
- 列的现有名称
举个例子，我们将把数据集中的票价列的名称改为价格。
代码:
# renaming the columns
data = data.withColumnRenamed('Fare', 'Price')
data.show()
Changing The Column Name
为了删除空值，我们使用带有 drop()属性的 na 函数。通常，它会删除所有具有空值的行。但是，函数中有两个参数可以用来以新的方式下降:
- 如何:确保根据分配给的值删除值。值为任意和全部。当 how = "any" 时，只有具有空值的单元格被删除，但是当 how = "all" 时，整行被删除。
- 阈值:取整数形式的值。例如:如果我们设置 thresh = 2 ，只有两个空值被丢弃。
- subset: 这有助于我们选择需要删除空值的特定列。
代码:
data = data.na.drop(how = 'any', thresh = 2)
data.show()
Dropping The Null Values
因此，我们删除了两个空值。
5.使用 Pyspark 进行过滤操作
过滤掉一些东西只是从我们的数据框架中检索我们需要的东西。例如，如果我们需要泰坦尼克号数据集中的幸存者。过滤是这里的最佳选择。
代码:
data = data.filter(data['Survived'] == 1)
data.show()
输出:
Filtering Out Columns
所以，所有事件幸存者的数据就摆在我们面前。
结论
于是，就这样，Pyspark 的话题结束了。我们讨论了向系统添加火花、数据读取、预处理和过滤技术等主题。这是关于 Pyspark 的基本介绍。
Python abs()函数
原文：https://www.askpython.com/python/built-in-methods/python-abs-function
嘿，伙计们！在这篇文章中，我们将推出带有不同模块的 Python abs()函数，例如 NumPy 和 Pandas。
Python abs()函数入门
Python 有大量的内置函数来处理数学和统计运算。一个这样的函数是 Python abs()函数。
abs() function返回作为参数传递给它的输入的绝对幅度或值。它返回输入的实际值，不考虑符号。
abs()函数只接受一个必须是数字的参数，并返回该数字的绝对值。
- 如果输入类型为
integer或float–ABS()函数返回绝对幅度/值 - 如果输入是一个
complex number，abs()函数只返回数字的幅度部分
语法:
abs(number)
- 该数字可以是整数类型、浮点类型或复数。
举例:
num = -25.78
print("Absolute value:",abs(num))
输出:
Absolute value: 25.78
Pandas DataFrame.abs()函数
Python Pandas 模块内置了DataFrame.abs() function来计算数据集数据帧的特定数据变量/列中出现的所有数据值的绝对值。
语法:
DataFrame['column_name'].abs()
输入数据集:
Input Dataset
举例:
import pandas as pd
import numpy as np
data = pd.read_csv("C:/marketing_tr.csv")
data.head(10)
data['cons.conf.idx'].abs()
在上面的代码片段中，我们使用了pandas.read_csv() function将数据集导入并加载到环境中。DataFrame.head(n) function实际上代表数据集的前“n”个值。
此外，我们已经使用 abs()函数找出了列' cons.conf.idx '的绝对值。
输出:
0 42.0
1 42.7
2 36.4
3 42.7
4 46.2
...
7409 36.4
7410 42.7
7411 46.2
7412 42.0
7413 36.4
Name: cons.conf.idx, Length: 7414, dtype: float64
Python numpy.absolute()函数
Python NumPy 模块有numpy.absolute() function来获取传递给它的数组元素的绝对值。
语法:
numpy.absolute(array)
举例:
import numpy as np
arr = [10, -20, 30, -40]
abs_res = np.absolute(arr)
print("The absolute values of the array elements:",abs_res)
输出:
The absolute values of the array elements: [10 20 30 40]
结论
因此，在本文中，我们已经理解了用 NumPy 和 Pandas 模块实现 Python abs()函数。
参考
- Python abs()函数—官方文档
- Python abs()函数— JournalDev
Python 向数组中添加元素
原文：https://www.askpython.com/python/array/python-add-elements-to-an-array
Python 没有特定的数据类型来表示数组。
以下内容可用于表示 Python 中的数组:
1。使用列表添加到数组
如果我们使用列表作为一个数组，下面的方法可以用来给它添加元素:
By using append() function:将元素添加到数组的末尾。By using insert() function:在给定的索引处插入元素。By using extend() function:它通过追加两个列表中的元素来延长列表。
示例 1:使用 append()函数向数组 添加元素
my_input = ['Engineering', 'Medical']
my_input.append('Science')
print(my_input)
输出:
['Engineering', 'Medical', 'Science']
示例 2:使用 extend()函数向数组添加元素
my_input = ['Engineering', 'Medical']
input1 = [40, 30, 20, 10]
my_input.extend(input1)
print(my_input)
输出:
['Engineering', 'Medical', 40, 30, 20, 10]
示例 3:使用 insert()函数向数组添加元素
my_input = [1, 2, 3, 4, 5]
print(f'Current Numbers List {my_input}')
number = int(input("Please enter a number to be added:\n"))
index = int(input(f'Enter the index between 0 and {len(my_input) - 1} to add the given number:\n'))
my_input.insert(index, number)
print(f'Updated List {my_input}')
输出:
Output-Insert Function
2.使用阵列模块添加到阵列
如果我们正在使用数组模块，可以使用以下方法向它添加元素:
By using + operator:结果数组是两个数组中元素的组合。By using append() function:将元素添加到数组的末尾。By using insert() function:在给定的索引处插入元素。By using extend() function:它通过追加两个列表中的元素来延长列表。
举例:
import array
s1 = array.array('i', [1, 2, 3])
s2 = array.array('i', [4, 5, 6])
print(s1)
print(s2)
s3 = s1 + s2
print(s3)
s1.append(4)
print(s1)
s1.insert(0, 10)
print(s1)
s1.extend(s2)
print(s1)
输出:
Output Array Module
3.向 NumPy 数组添加元素
我们可以使用以下方法向 NumPy 数组添加元素:
By using append() function:将元素添加到数组的末尾。By using insert() function:将数组中给定索引处的元素相加。
举例:
import numpy
# insert function
arr1_insert = numpy.array([1, 23, 33])
arr2_insert = numpy.insert(arr1_insert, 1, 91)
print(arr2_insert)
# append function
arr1_append = numpy.array([4, 2, 1])
arr2_append = numpy.append (arr1_append, [12, 13, 14])
print(arr2_append)
输出:
[ 1 91 23 33] [ 4 2 1 12 13 14]
结论
因此，在本文中，我们实现了向数组添加元素的可能方法。
参考
- Python 添加到数组
- Python 数组文档
- Python NumPy 文档
Python 添加到字典
原文：https://www.askpython.com/python/dictionary/python-add-to-dictionary
Python 字典基本上包含了键值对形式的元素。
这是一个无序的项目集合。
创建字典:
cities = {"Pune": "Maharashtra", "Ahemdabad": "Gujarat"}
print(cities)
#type(cities)
输出:
{'Pune': 'Maharashtra', 'Ahemdabad': 'Gujarat'}
如何在 Python 中添加字典
- 通过使用 update()方法
- 通过使用 setitem()方法
- 通过使用下标符号
- 通过使用“*”运算符
1.通过使用 update()方法
update()方法使用户能够向 dict 添加多个键值对。
info = {'name':'Safa', 'age':21}
print("Current Dict is: ", info)
info.update({'Address':'Pune'})
print("Updated Information is: ", info)
输出:
Current Dict is: {'name': 'Safa', 'age': 21}
Updated Information is: {'name': 'Safa', 'age': 21, 'Address': 'Pune'}
2.通过使用 setitem()方法
Python Dictionary 的 setitem()方法用于向 dict 添加一个键值对。
info = {'name':'Safa', 'age':'21'}
info.__setitem__('Address', 'Pune')
print(info)
输出:
{'age': '21', 'name': 'Safa', 'Address': 'Pune'}
3.通过使用下标符号
下标符号有助于向字典添加一个新的键值对。如果该键不存在，则会创建一个新键，并为其分配上述值。
语法:
dict[new-key]=[new-value]
info = {'name':'Safa', 'age':'21'}
info['Address'] = 'Pune'
print(info)
O 输出:T1
{'name': 'Safa', 'age': '21', 'Address': 'Pune'}
4.通过使用“**”运算符
“**”操作符基本上将键值对添加到新字典中，并将其与旧字典合并。
info = {'name':'Safa', 'age':'21'} #old dict
#adding item to the new dict(result) and merging with old dict(info)
result = {**info, **{'Address': 'Pune'}}
print(result)
输出:
{'name': 'Safa', 'age': '21', 'Address': 'Pune'}
向嵌套 Python 字典添加键
info = {'TEST' : {'name' : 'Safa', 'age' : 21}}
print("The Input dictionary: " + str(info))
info['TEST']['Address'] = 'Pune'
print("Dictionary after adding key to nested dict: " + str(info))
输出:
The Input dictionary: {'TEST': {'name': 'Safa', 'age': 21}}
Dictionary after adding key to nested dict: {'TEST': {'name': 'Safa', 'age': 21, 'Address': 'Pune'}}
向 Python 字典添加多个键值对
info = {'TEST' : {'name' : 'Safa', 'age' : 21}}
info.update([ ('Address', 'Pune') , ('zip_code',411027 )])
print(info)
输出:
{'TEST': {'name': 'Safa', 'age': 21}, 'Address': 'Pune', 'zip_code': 411027}
将一部词典加入另一部词典
info = {'TEST' : {'name' : 'Safa', 'age' : 21}}
info1 = { 'SET' : {'number' : 452756345, 'Address' : 'Pune'}}
#Adding elements of info1 to info
info.update(info1)
print(info)
输出:
{'TEST': {'name': 'Safa', 'age': 21}, 'SET': {'number': 452756345, 'Address': 'Pune'}}
结论
因此，在本文中，我们已经理解并实现了向 Python 字典添加键值对的可能方法。
参考
- Python 添加到字典
- Python 字典文档
Python Anaconda 教程–Anaconda 入门
原文：https://www.askpython.com/python-modules/python-anaconda-tutorial
嘿，伙计们！在本文中，我们将在这个完整的 Anaconda 教程中学习如何开始使用 Python Anaconda。让我们马上开始吧！
Python 中的 Anaconda 是什么？
Anaconda 是针对数据科学和机器学习应用程序的 Python 和 R 编程的免费开源发行版。它有超过 1500 个 Python/R 数据科学包。
它附带了 Spyder 和 Jupyter notebook 等工具，初学者可以使用这些工具来学习 Python，因为它们使用起来非常简单和方便。
Anaconda 简化了包的管理和部署。它创建了一个虚拟环境，使得部署任何项目都很容易。
在 Windows 上安装最新版 Anaconda 的步骤
转到这个链接，下载适合您的计算机的 anaconda 的最新版本。https://www.anaconda.com/products/individual
1.运行安装程序，然后单击下一步
2.选择文件位置
请记住，要将 anaconda 安装到不包含空格或 Unicode 字符的目录路径中。
3.完成设置
您可以选择是否将 Anaconda 添加到 PATH 环境变量中。建议不要将 Anaconda 添加到 PATH 环境变量中，因为这会干扰其他软件。
您可以将 Anaconda 注册为默认 Python，除非您计划安装和运行多个版本的 Anaconda 或多个版本的 Python。
在我的例子中，我将继续使用默认设置来演示安装。
现在，进入 Anaconda 命令提示符并输入‘jupyter notebook’。它将为您打开 jupyter 笔记本仪表盘。
向 Python Anaconda 添加包
Anaconda 自动安装了超过 250 个包，并且可以使用 conda install 命令额外安装超过 75，000 个开源包。
1.使用康达锻造
要使用 conda-forge 命令安装软件包，请在 anaconda 命令提示符下运行以下语法:
conda install -c conda-forge PACKAGENAME
示例:
conda install -c conda-forge numpy
2.使用画中画命令
要使用 pip 命令安装软件包，请在 anaconda 命令提示符下运行以下语法:
pip install PACKAGENAME
示例:
pip install pandas
了解虚拟环境
Python 是一种通用语言，可以用于任何事情。例如数据分析、机器学习、人工智能或 Web 开发等。这些任务中的每一个都需要不同的包和 Python 版本。
为了有效地使用这些包和版本，我们使用了虚拟环境。
它允许每个项目都有自己的依赖关系，我们可以轻松地在应用程序之间切换，而不管它们有什么依赖关系和需求。
Conda 就是 anaconda 中包含的一个这样的包管理器和环境管理器。
现在，让我们使用 conda 接口设置虚拟环境。
1.检查 conda 是否安装在您的路径中
打开 Anaconda 命令提示符并输入以下代码:
conda -V
2.更新 conda 环境
运行以下命令来更新 Python Anaconda 环境。
conda update conda
3.创建虚拟环境
conda create -n envname python=x.x anaconda
将 envname 替换为您想要给虚拟环境起的名字，将 x.x 替换为您想要使用的 Python 版本。
输入 y 继续
您可以通过输入以下代码来搜索可用 python 版本的列表:
^python$
4.激活虚拟环境
在 anaconda 命令提示符下输入给定的命令
conda activate envname
用给定的环境名替换 envname 。
要查看可用环境列表，输入 conda info -e 命令
5.安装附加软件包的步骤
在将 envname 替换为您给定的环境名称，将 PACKAGENAME 替换为您想要安装的软件包之后，输入给定的命令。
conda install -n envname PACKAGENAME
6.停用虚拟环境的步骤
要结束会话并退出环境，请执行以下操作:
conda deactivate
7.删除虚拟环境的步骤
用您的名字替换 envname 并删除虚拟环境。
conda remove -n envname -all
结论
在本教程中，我们学习了如何为 python 下载和设置 anaconda。我们知道安装软件包和设置虚拟环境是多么容易。通过大量的包，anaconda 提供了主要的支持和高效的结果。希望大家喜欢，敬请期待！
参考
Python 和运算符
运算符基本上用于对要操作的数据执行操作。有各种运算符，即逻辑运算符、按位运算符、算术运算符等。
Python 中有两种 AND 运算符:
Logical AND OperatorBitwise AND Operator
逻辑 AND 运算符
逻辑 AND 运算符处理布尔值，并根据条件得出 True 或 False。当两个操作数都为真时，和运算符返回真，否则返回假。
语法:
操作 1 和操作 2
举例:
num1 = int(input('Enter first number:\n'))
num2 = int(input('Enter second number:\n'))
if num1 > num2 and num1 < 10:
print('True')
elif num1 < 0 and num2 < 0:
print('Both the numbers are negative.')
else:
print('False')
输出:
输入第一个数字:
9
输入第二个数字:
5
真
逻辑运算符重载
Python 逻辑运算符处理布尔值。默认情况下，对象布尔值为真。如果对象为无或假，那么布尔值为假。我们可以提供 bool() 实现来改变一个对象的默认布尔值。
class Data:
def __init__(self, i):
self.id = i
def __bool__(self):
return self.id % 2 == 0
d1 = Data(6)
d2 = Data(4)
print(bool(Data(3)) and bool(Data(4))) # False
上面的代码片段将打印 False，因为 Data(3)布尔值为 False。
如果我们删除 bool()函数实现，两个数据对象的布尔值都将为真，并且它将打印为真。
按位 AND 运算符
按位运算符对位进行运算。当操作数的两位都为 1 时，它返回 1，否则它返回 0(零)。
语法:
操作数 1 和操作数 2
a = 6 = 0110(二进制)
b = 4 = 0100(二进制)
a & b = 0110 & 0100 = 0100 = 4(十进制)
举例:
a = 6
b = 4
c = a & b
print(c)
输出:
four
按位运算符重载
Python 中有各种定义的方法来重载按位运算符。
| 按位运算符 | 句法 |
| & | __ 和 _ _(自己，其他) |
| | | __ 或 _ _(自己，其他) |
| ^ | xor(自身，其他) |
| ~ | invert(self) |
| << | lshift(自己，其他) |
| >> | rshift(自己，其他) |
class Operate():
def __init__(self, x):
self.x = x
def __and__(self, res):
print("Bitwise AND operator overloading Example")
if isinstance(res, Operate):
return self.x & res.x
else:
raise ValueError("Must belong to Operate Class")
if __name__ == "__main__":
a = Operate(6)
b = Operate(4)
print(a&b)
输出:
按位 AND 运算符重载示例
4
逻辑运算符的求值顺序
通过操作符执行操作数从left to right开始。
举例:
def evaluate(n):
print("Function called for operand:", n)
return True if n > 0 else False
x = evaluate
y = evaluate
z = evaluate
if x(-1) or y(5) and z(10):
print("One of the numbers is positive.")
输出:
为操作数调用的函数:5
为操作数调用的函数:10
其中一个数字是正数。
参考
- Python 按位运算符
- Python 逻辑运算符
- Python 操作者文档
Python argparse 模块——轻松解析命令行参数
原文：https://www.askpython.com/python-modules/python-argparse-module-parse-command-line-arguments
在用 Python 编写命令行脚本时，我们可能会遇到这样的情况:我们需要为程序添加更多的命令行选项。我们自己进行参数解析往往是非常乏味和耗时的，并且经常会大大降低我们的速度。Python 的argparse模块提供了这个问题的解决方案。
argparse模块为程序员提供了一种快速简单地编写好的命令行界面的方法。让我们看看如何使用这个库为我们编写的任何脚本提供良好的命令行界面选项。
Python argparse 库方法
该库为我们提供了各种方法来解析和处理参数字符串，并添加用户友好的命令行选项。
1.创建参数解析器
为了处理参数字符串，我们首先需要构建一个解析器。该库为我们提供了argparse.ArgumentParser()来构建一个参数解析器。
格式:parser = argparse.ArgumentParser(description)
2.向解析器对象添加参数
下一步是为命令行界面的解析器添加参数/选项( CLI )。我们使用parser.add_argument()来做这件事。
格式:parser.add_argument(name, metavar, type, help)
- 名称 - >解析对象的属性名称
- metavar - >它为帮助消息中的可选参数提供了不同的名称
- 类型 - >变量的数据类型(可能是
int、str等) - 帮助 - >帮助消息中参数的描述
一个例子来说明上述概念
import argparse
# Create the parser
parser = argparse.ArgumentParser(description='A Simple Program which prints to the console.')
parser.add_argument('integer', metavar='N', type=int, help='an integer to be printed')
args = parser.parse_args()
a = args.integer
print('Printing the integer')
print(a)
输出
[email protected] $ python argparse_example.py
usage: argparse_example.py [-h] N
argparse_example.py: error: the following arguments are required: N
[email protected] $ python argparse_example.py 10
Printing the integer
10
[email protected] $ python argparse_example.py -h
usage: argparse_example.py [-h] N
A Simple Program which prints to the console.
positional arguments:
N an integer to be printed
optional arguments:
-h, --help show this help message and exit
[email protected] $ python argparse_example.py hi
usage: argparse_example.py [-h] N
argparse_example.py: error: argument N: invalid int value: 'hi'
请注意，该模块负责参数的类型检查，确保a必须是整数，并且必须传递正确的参数，程序才能运行。这就是type参数的意义。
程序界面的其他选项
通过在创建解析器对象时指定两个可选参数，即prog和usage，我们可以向程序添加/修改更多选项。
格式:argparse.ArgumentParser(prog, usage, description)
**prog**- >指定程序的名称(通常默认为sys.argv[0]，但可以通过该参数修改。**usage**- >指定帮助字符串的使用格式。**prefix_chars**- >指定可选参数的前缀字符(对于 Unix 系统为-，对于 Windows 为/
为了将所有这些放在一起，让我们基于前面的代码片段编写一些简单的代码来说明这个概念。
import argparse
# Create the parser
parser = argparse.ArgumentParser(prog='simple_printer',
usage='%(prog)s [options] integer string',
description='A Simple Program which prints to the Console',
prefix_chars='-')
# Add an integer argument
parser.add_argument('--integer', metavar='N',
type=int, help='an integer to be printed')
# Add a second string argument
parser.add_argument('--string', metavar='S',
type=str, help='a string to be printed')
# Parse the list of arguments into an object
# called 'args'
args = parser.parse_args()
print('Argument Object:', args)
print('Type of the Argument Object:', type(args))
first_argument = args.integer
second_argument = args.string
print('Printing the integer')
print(first_argument)
print('Printing the string')
print(second_argument)
1.传递可选参数
请注意，我们已经将参数的名称更改为--integer和--string。这是因为这是为 Python 脚本指定可选参数的标准格式。(python script.py -o --option)
argparse通过照顾--来自动为我们处理这个问题，确保我们只需要输入一次。下面的输出说明了使用 argparse 解析这些参数的便利性。
可选参数的输出
[email protected] $ python3 argparse_example.py --integer=10
Argument Object: Namespace(integer=10, string=None)
Type of the Argument Object: <class 'argparse.Namespace'>
Printing the integer
10
Printing the string
None
其他案例的输出，展示了argparse如何为您处理一切。
[email protected] $ python3 argparse_example.py 10 Hello
Argument Object: Namespace(integer=10, string='Hello')
Type of the Argument Object: <class 'argparse.Namespace'>
Printing the integer
10
Printing the string
Hello
[email protected] $ python3 argparse_example.py 10
usage: simple_printer [options] --integer --string
simple_printer: error: the following arguments are required: S
[email protected] $ python3 argparse_example.py -h
usage: simple_printer [options] integer string
A Simple Program which prints to the Console
optional arguments:
-h, --help show this help message and exit
--integer N an integer to be printed
--string S a string to be printed
[email protected] $ python3 argparse_example.py --integer 10 --string Hi
Argument Object: Namespace(integer=10, string='Hi')
Type of the Argument Object: <class 'argparse.Namespace'>
Printing the integer
10
Printing the string
Hi
[email protected] $ python3 argparse_example.py --integer=10 --string=Hi
Argument Object: Namespace(integer=10, string='Hi')
Type of the Argument Object: <class 'argparse.Namespace'>
Printing the integer
10
Printing the string
Hi
2.对可选参数使用短名称
为了避免为每个可选参数写完整的参数名，可以在我们的脚本中使用一个带连字符的选项(-o而不是--option)。argparse允许我们在向解析器添加参数时，只需将短选项名称作为第一个参数。
格式:parser.add_args('-o', '--option', help='a simple option')
在我们之前的代码片段中，我们简单地在--integer和--string选项中添加了两个小的变化:
# Add an integer argument
parser.add_argument('-i', '--integer', metavar='N',
type=int, help='an integer to be printed')
# Add a second string argument
parser.add_argument('-s', '--string', metavar='S',
type=str, help='a string to be printed')
以简短形式指定可选参数时的输出:
roo[email protected] $ python3 argparse_example.py -s=Hi
Argument Object: Namespace(integer=None, string='Hi')
Type of the Argument Object: <class 'argparse.Namespace'>
Printing the Integer
None
Printing the string
Hi
[email protected] $ python3 argparse_example.py -s=Hi -i=10
Argument Object: Namespace(integer=10, string='Hi')
Type of the Argument Object: <class 'argparse.Namespace'>
Printing the integer
10
Printing the string
Hi
结论
在本文中，我们了解了argparse库解析参数的基本用法，以及如何通过type参数利用类型检查。我们还学习了如何使用usage和带连字符的参数名，向脚本中添加可选参数，并使其更加用户友好。
参考
Python 数组声明
原文：https://www.askpython.com/python/array/python-array-declaration
嘿，读者们。希望你们都过得好。在本文中，我们将主要关注 Python 数组声明的变体。
什么是 Python 数组？
众所周知，Python 提供了各种数据结构来操作和处理数据值。
当谈到作为数据结构的数组时，Python 没有提供创建或使用数组的直接方法。相反，它为我们提供了以下数组变体:
- Python 数组模块:数组模块包含各种创建和处理值的方法。
- Python List : List 可以认为是一个动态数组。此外，与数组不同，异构元素可以存储在列表中。
- Python NumPy 数组:NumPy 数组最适合对大量数据执行数学运算。
了解了 Python 数组之后，现在让我们来了解在 Python 中声明数组的方法。
Python 数组声明–Python 数组的变体
在下一节中，我们将了解使用 Python 数组的变体来声明数组的技术。
类型 1: Python 数组模块
Python Array module 包含 array() function，使用它我们可以在 python 环境中创建一个数组。
语法:
array.array('format code',[data])
format_code:表示数组接受的元素类型。代码“I”代表数值。
举例:
import array
arr = array.array('i', [10,20,30,40,50])
print(arr)
输出:
array('i', [10, 20, 30, 40, 50])
类型 2:作为数组的 Python 列表
Python list可以用来动态创建和存储像数组一样的元素。
语法:
list = [data]
举例:
lst = [10,20,30,40, 'Python']
print(lst)
输出:
[10, 20, 30, 40, 'Python']
如上所述，不同数据类型的元素可以一起存储在 List 中。
类型 3: Python NumPy 数组
NumPy module包含各种创建和使用数组作为数据结构的函数。
在 Python 中,numpy.array() function可以用来创建一维和多维数组。它创建一个数组对象作为“ndarray”。
np.array([data])
示例:使用 numpy.array()函数创建数组
import numpy
arr = numpy.array([10,20])
print(arr)
输出:
[10 20]
此外，我们可以使用numpy.arange() function在数据值的特定范围内创建一个数组。
numpy.arange(start,stop,step)
start:数组的开始元素。end:数组的最后一个元素。step:数组元素之间的间隔或步数。
举例:
import numpy
arr = numpy.arange(1,10,2)
print(arr)
输出:
[1 3 5 7 9]
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
参考
Python 数组–13 个示例
原文：https://www.askpython.com/python/array/python-array-examples
Python 没有显式的数组数据结构。这是因为我们可以用列表做同样的事情。
该列表包含一组项目，并支持添加/更新/删除/搜索操作。这就是为什么 Python 中很少使用单独的数据结构来支持数组。
数组包含相同类型的项，但是 Python list 允许不同类型的元素。这是数组和列表之间唯一的特性差异。但是它不是交易破坏者，也不保证 Python 中有新的数据结构支持。
然而，Python 数组模块可用于为整数、浮点和 Unicode 字符创建类似数组的对象。
Python 数组模块
Python 数组模块允许我们创建一个对数据类型有约束的数组。这个模块只支持几种数据类型。
Python Array Supported Type Code
Unicode 类型代码在 Python 3.3 中已被弃用，并将在 Python 4.0 版本中被移除。
因此，我们可以创建一个整数数组，并使用数组模块进行浮点运算。让我们从数组模块开始，看看它提供的所有操作。
1.创建数组
创建数组的语法是 array.array(typecode, values_list) 。
import array
# creating array
int_array = array.array('i', [1, 2, 3, 4])
float_array = array.array('f', [1.1, 2.2, 3.3, 4.4])
# unicode array support is deprecated and will be deleted in Python 4
unicode_array = array.array('u', ['\u0394', '\u2167', '\u007B'])
2.打印阵列及其类型
如果我们打印数组对象，它会给我们关于类型码及其元素的信息。让我们打印上面创建的数组，并使用 type()内置函数打印对象类型。
# printing array
print(int_array)
print(float_array)
print(unicode_array)
print(type(int_array))
输出:
array('i', [1, 2, 3, 4])
array('f', [1.100000023841858, 2.200000047683716, 3.299999952316284, 4.400000095367432])
array('u', 'ΔⅧ{')
<class 'array.array'>
3.打印数组元素
我们可以使用循环的来打印数组元素。
import array
int_array = array.array('i', [1, 2, 3, 4])
for a in int_array:
print(a)
我们还可以使用元素的索引来访问元素。我们可以使用索引来打印数组元素。
for b in range(0, len(int_array)):
print(f'int_array[{b}] = {int_array[b]}')
输出:
int_array[0] = 1
int_array[1] = 2
int_array[2] = 3
int_array[3] = 4
4.插入和追加元素
我们可以使用 insert()函数在指定的索引处插入一个元素。指定索引中的元素向右移动一个位置。
int_array = array.array('i', [1, 2, 3, 4])
int_array.insert(0, -1) # -1,1,2,3,4
int_array.insert(2, -2) # -1,1,-2,2,3,4
print(int_array)
输出 : array('i', [-1, 1, -2, 2, 3, 4])
如果必须在数组末尾添加元素，请使用 append()函数。
int_array = array.array('i', [1, 2, 3, 4])
int_array.append(-3)
print(int_array) # array('i', [1, 2, 3, 4, -3])
5.Python 数组支持负索引
我们也可以通过负索引来访问 python 数组元素。
Python Array Index
int_array = array.array('i', [10, 20, 30, 40, 50, 60, 70, 80])
print(int_array[-2]) # 70
print(int_array[-5]) # 40
6.移除数组元素
我们可以使用 remove()方法删除一个数组元素。
int_array = array.array('i', [1, 2, 3, 4])
int_array.remove(2)
print(int_array) # array('i', [1, 3, 4])
如果数组中不存在该元素，则引发 ValueError 。
int_array = array.array('i', [1, 2, 3, 4])
try:
int_array.remove(20)
except ValueError as ve:
print(ve)
输出 : array.remove(x): x not in array
我们还可以使用 pop()函数删除给定索引处的元素。这个函数返回从数组中删除的元素。如果我们不指定索引，最后一个元素将被移除并返回。
int_array = array.array('i', [1, 2, 3, 4])
last_element = int_array.pop()
print(last_element) # 4
print(int_array) # array('i', [1, 2, 3])
second_element = int_array.pop(1)
print(second_element) # 2
print(int_array) # array('i', [1, 3])
7.分割数组
Python array 支持切片，并返回一个包含子元素的新数组。原始数组保持不变。切片也支持负索引。
int_array = array.array('i', [0, 1, 2, 3, 4, 5])
print(int_array[3:]) # array('i', [3, 4, 5])
print(int_array[:2]) # array('i', [0, 1])
print(int_array[1:3]) # array('i', [1, 2])
# negative index slicing
print(int_array[-2:]) # array('i', [4, 5])
print(int_array[:-2]) # array('i', [0, 1, 2, 3])
8.搜索数组中的元素
我们可以使用 index()函数来查找一个元素第一次出现的索引。如果数组中不存在该元素，将引发 ValueError。
int_array = array.array('i', [0, 1, 2, 3, 1, 2])
print(f'1 is found at index {int_array.index(1)}')
try:
print(int_array.index(20))
except ValueError as ve:
print(ve)
输出:
1 is found at index 1
array.index(x): x not in array
9.更新指定索引处的值
我们可以使用数组索引和赋值操作符来更新索引处的值。如果索引无效，将引发 IndexError。
int_array = array.array('i', [0, 1, 2, 3, 1, 2])
int_array[0] = -1
int_array[1] = -2
print(int_array)
try:
int_array[10] = -10
except IndexError as ie:
print(ie)
输出:
array('i', [-1, -2, 2, 3, 1, 2])
array assignment index out of range
10.反转数组
我们可以使用 reverse()函数来反转数组元素。
int_array = array.array('i', [0, 1, 2, 3])
int_array.reverse()
print(int_array) # array('i', [3, 2, 1, 0])
11.元素出现的次数
我们可以使用 count()函数来获取数组中某个值出现的次数。
int_array = array.array('i', [0, 1, 1, 0])
print(int_array.count(1)) # 2
print(int_array.count(10)) # 0
12.通过追加 Iterable 来扩展数组
我们可以使用 extend()函数将值从 iterable 追加到数组的末尾。
array1 = array.array('i', [0, 1])
array2 = array.array('i', [2, 3, 4])
array1.extend(array2)
print(array1) # array('i', [0, 1, 2, 3, 4])
print(array2) # array('i', [2, 3, 4])
array2.extend([1, 2])
print(array2) # array('i', [2, 3, 4, 1, 2])
array1 = array.array('i', [1])
array1.extend(set([0,0,0,2]))
print(array1) # array('i', [1, 0, 2])
13.将数组转换为列表
我们可以使用 tolist()函数将数组转换成列表。
int_array = array.array('i', [0, 1, 2, 3])
print(int_array.tolist()) # [0, 1, 2, 3]
结论
Python 数组模块帮助我们为整数和浮点数创建数组。但是，我们可以对列表执行相同的操作。因此，只有当您希望将数据约束为给定类型时，才应该使用数组模块。
参考资料:
Python 箭头模块
原文：https://www.askpython.com/python-modules/python-arrow-module
Python **arrow**模块支持日期时间操作。它有助于创建实例并相应地操作时间戳。
它展示了一种用户友好的方法来处理日期时间转换。
特性:
- Python 2.7 及更高版本支持箭头模块。
- 时区感知
- 自动解析字符串
- 全面实施
安装箭头模块:
**pip install arrow**
pip-arrow Install Command
访问特定时区的当前时间
示例:打印 UTC、IST 和本地时区的当前时间。
import arrow
utc = arrow.utcnow()
print('UTC Time =', utc)
ist = arrow.now('Asia/Calcutta')
print('IST Time =', ist)
print('tzinfo =', ist.tzinfo)
local_time = arrow.now()
print('Local Time =', local_time)
输出:
Output- Timezone Conversion
时区转换
Python arrow 模块提供了**to()**函数来转换时区。
import arrow
ist = arrow.now('Asia/Calcutta')
print('IST Time =', ist)
pst = ist.to('US/Pacific')
print('PST Time =', pst)
输出:
Output-Timezone Conversion
如何从时间戳中获取日期？
import arrow
local = arrow.now()
print('Current Local Time =', local)
print('Current Local Timestamp =', local.timestamp)
date = arrow.get(local.timestamp)
print('Date from Timestamp =', date)
输出:
Output-Date From Timezone
使用箭头模块格式化日期
format 方法用于根据用户的选择操作和格式化给定的日期。
例 1:将日期格式化为 YYYY-MM-DD 格式
import arrow
local = arrow.now()
result = local.format('YYYY-MM-DD')
print(result)
输出:
**2020-01-02**
例 2:将日期格式化为 YYYY-MM-DD HH:mm:ss 格式
import arrow
local = arrow.now()
result = local.format('YYYY-MM-DD HH:mm:ss')
print(result)
输出:
**2020-01-02 14:12:11**
将日期解析为字符串
import arrow
date = arrow.get('2013-05-05 12:30:45', 'YYYY-MM-DD HH:mm:ss')
print(date)
输出:
**2013-05-05T12:30:45+00:00**
如何从传递的参数中实例化日期？
import arrow
date = arrow.get(2020, 1, 2)
print(date)
输出:
**2020-01-02T00:00:00+00:00**
对日期和时间执行操作
replace()和shift()方法用于根据当前日期获得未来和过去的日期。
举例:
import arrow
utc = arrow.utcnow()
print('Current UTC= ', utc)
utc_updated1 = utc.replace(year=2017, month=9)
print('Updated UTC= ', utc_updated1)
utc_updated2 = utc.shift(years=-4, weeks=3)
print('Updated UTC= ', utc_updated2)
输出:
Output-Manipulation On Date Time
以人类友好的格式表示日期时间
humanize() 方法使我们能够根据当前日期/时间提供一种对人类友好的日期/时间表示。
**humanize()**方法使用户能够知道从给定时间起经过的时间量。
举例:
import arrow
local = arrow.now()
print(local)
result = local.humanize()
print("Time elapsed: ")
print(result)
输出:
**2020-01-02T14:34:40.447432+05:30 Time elapsed: just now**
结论
因此，在本文中，我们已经理解了 arrow 模块提供的功能。这是一个简单的模块，可以处理支持时区的日期和时间。
参考
- Python 箭头模块
- Python 箭头模块文档
如何使用 Python ascii()函数
原文：https://www.askpython.com/python/built-in-methods/python-ascii-function
在本文中，我们将看看 Python ascii() 函数。
ascii()函数返回对象的字符串表示，但实际上只有 ASCII 字符。
剩余的非 ASCII 字符将用反斜杠()进行转义。例如，换行符(\n)是非 ASCII 字符。
我们现在将看一些例子来理解它到底是如何工作的！
使用 Python ascii()函数–一些示例
Python ascii() 函数采用单个参数，该参数可以是任何对象。所以所有类型的对象，像列表，字符串等等，都是有效的。这将返回一个字符串。
如果你在一个列表或者任何集合上使用它，这个函数将为集合的每个成员调用。
现在让我们来看看这个。
在原始数据类型上使用 Python ascii()
对于像boolean、string、int这样的基本数据类型，它们按照您的预期工作。
i = 15
print(ascii(i))
b = True
print(ascii(b))
s = 'abc'
print(ascii(s))
s = 'Hello from\tAskPython\n'
print(ascii(s))
输出
'15'
'True'
"'abc'"
"'Hello from\\tAskPython\\n'"
如您所见，对于非 ASCII 字符(\t，\n)，反斜杠本身需要进行转义。
在 Iterables/Collections 上使用 ascii()
如果你想在列表/元组/字典上使用它，你仍然可以！但是，这只是将它应用于集合/iterable 中的每个成员。
因此，如果一个列表有n个元素，我们将把函数应用到所有的n个元素上，并得到一个字符串列表。
m = ["Hello from AskPython 22", "AskPythön", "Hi"]
print(ascii(m))
输出
['Hello from AskPython 22', 'AskPyth\xf6n', 'Hi']
类似地，对于字典{ key : value }，它将应用于key和value。
d = {'â':'å', '2':2, 'ç':'ć'}
print(ascii(d))
输出
{'\xe2': '\xe5', '2': 2, '\xe7': '\u0107'}
对于元组，它类似于列表。所有元素都将被转换成类似 ASCII 字符的字符串表示形式。
t = ("Hellö", 123, ["AskPython"])
print(ascii(t))
输出
('Hell\xf6', 123, ['AskPython'])
与 repr()函数的比较
repr()函数也用于返回对象的字符串表示。但是不同之处在于repr()同样打印非 ascii 字符。
对于定制对象，ascii()函数在内部调用__repr__()函数，但是确保对非 ASCII 字符进行转义。
让我们通过使用一个类创建我们自己的对象来试验一下。
class MyClass:
def __init__(self, name):
self.name = name
现在，让我们创建一个对象并尝试在其上调用ascii()和repr()，
my_obj = MyClass("AskPythön")
print(ascii(my_obj))
print(repr(my_obj))
输出
'<__main__.MyClass object at 0x7f6adcf30940>'
'<__main__.MyClass object at 0x7f6adcf30940>'
我们没有这个类的repr()函数，所以使用默认的object定义。这就是你在输出中看到MyClass object的原因。
要改变这一点，我们必须自己重载__repr__() dunder 方法。
class MyClass:
def __init__(self, name):
self.name = name
def __repr__(self):
return self.name
现在当你调用ascii()或者repr()的时候，我们可以直接得到 name 属性！
my_obj = MyClass("AskPythön")
print(ascii(my_obj))
print(repr(my_obj))
输出
AskPyth\xf6n
AskPythön
现在，你可以清楚地看到不同之处！
结论
在本文中，我们学习了在 Python 中使用ascii()函数，并学习了在不同类型的对象上使用它。
参考
- Python 文档关于 ascii()函数
- 关于 Python ascii()的 JournalDev 文章
Python 赋值帮助:你能信任某人来完成你的 Python 赋值吗？
原文：https://www.askpython.com/python/python-assignment-help-online
如果你正在寻找“谁来完成我的 python 任务？”问题，你已经找到了你所需要的！在本文中，您将了解关于 python 赋值帮助的一切，以及为什么获得它的帮助可能是个好主意。了解关于安全作业帮助服务的所有细节，以及如何找到一个好的服务，如下。
你应该在网上完成作业吗？
你真的应该花钱请人来做我的 python 作业吗？这个问题问得好！Python 作业编程帮助有很多好处。让我们弄清楚它们是什么，以及这些服务实际上是如何为您带来巨大帮助的:
- 便宜。没有必要为你的作业多付钱！在线 python 编程任务帮助通常是负担得起的，并且不会对已完成的任务收取很多费用。当然，不同的服务提供不同的价格，但你一定能找到不超出你的首选价格的东西。你也可以在网上找到许多销售和折扣。
- 你会得到你家庭作业问题的保证解决方案。Python 作业帮助将确保您获得正确的作业，从而获得可能的最佳成绩。
- 你将和专业作家一起工作。和专家一起工作总是很愉快的，尤其是涉及到你的个人事务和任务的时候。你不仅可能得到一个完美的解决方案，还可能得到一个惊人的建议。
- 你的成绩会上升。编程是一门复杂的学科，需要大量的时间和精力。取得好成绩可能是一项耗时的任务，如果你想提高你的 GPA，使用所有有助于你完成这项任务的手段和工具总是更好的。
- 不会错过最后期限。学生在完成作业时面临的最大问题之一是截止日期。不幸的是，大多数老师不准备改变截止日期，如果你错过了，他们会给你一个糟糕的分数。如果你使用在线作业帮助，这个问题很容易解决。
- 你会看到即使是最困难的任务也是如何完成的。学习很重要。通过在网上订购你的作业，你将会看到专业人士是如何处理的，并学会如何独立完成任何作业。
- 你生活中的压力会减少。这么多学生感到紧张的主要原因之一是大量的家庭作业。有时候，从一大堆文件和作业中出来喘口气是很重要的。在这种情况下，您需要在线 python 帮助。
如何选择合适的服务？
现在，你应该开始寻找最好的作业帮助服务。为了找到一个值得你信赖的好的服务，以下是你应该使用的 5 个技巧:
- 看一些评论。有大量的网站评论不同的服务并发表真实的观点。你应该看看这些，以确定所选择的服务是否值得一试。
- 看看客户的反馈。客户在服务网站上写了什么？发布客户评论的网站怎么办？比较两者以确定服务是否可信。
- 不要犹豫，提出问题。在网上订购任何东西的时候，问你的问题是可以的。互联网上有成吨的网站，所以很难选择一个。但是既然有这么多不同的服务，问任何问题并选择对你诚实的服务是完全没问题的。
- 比较利率。现在是时候看看这些服务提供什么样的价格了。王子可能范围，所以你必须先决定你准备支付多少。请记住，最终价格往往取决于最后期限。
- 与服务人员讨论您的任务。记得分享关于作业的所有重要细节。如果需要，与帮助者交谈以确定最后期限和其他需要的要求。如果你想取得好成绩，你必须知道如何解释你的需求和愿望。
获得正确的任务协助
那么你怎么看待在线作业帮助呢？你决定好要不要用了吗？请记住，这些只是伟大的工具，而不是最终的解决方案。然而，如果你恰当地使用这些服务，你将能够实现你心中的任何目标和梦想。你没有必要一直承受这么大的压力，所以如果你想充分利用在大学或学校度过的时光，请考虑使用 python 家庭作业帮助。请记住，寻求帮助并不可耻！
python astype()–数据列的类型转换
原文：https://www.askpython.com/python/built-in-methods/python-astype
在本文中，我们将详细讨论一个重要的概念——使用 Python astype()方法对数据帧中的列进行数据类型转换。
了解 Python astype()函数
在深入研究使用 Python astype()方法进行数据类型转换的概念之前，让我们首先考虑下面的场景。
在数据科学和机器学习领域，我们经常会遇到需要预处理和转换数据的阶段。事实上，准确地说，数据值的转换是走向建模的敏锐的一步。
这是数据列转换开始的时候。
Python astype()方法使我们能够设置或转换数据集或数据框中现有数据列的数据类型。
这样，我们可以使用 astype()函数将单个或多个列的数据值的类型改变或转换为另一种形式。
现在让我们在下一节中详细关注 astype()函数的语法。
语法–astype()函数
看看下面的语法！
DataFrame.astype(dtype, copy=True, errors=’raise’)
- dtype :我们要应用于整个数据框的数据类型。
- 复制:通过将它设置为真，它创建数据集的另一个副本，并向其灌输更改。
- 错误:通过将其设置为“引发，我们允许该函数引发异常。如果没有，我们可以将其设置为“忽略”。
理解了函数的语法之后，现在让我们把注意力放在函数的实现上！
1.带有数据帧的 Python astype()
在这个例子中，我们使用pandas.DataFrame() 方法从字典中创建了一个数据帧，如下所示。
举例:
import pandas as pd
data = {"Gender":['M','F','F','M','F','F','F'], "NAME":['John','Camili','Rheana','Joseph','Amanti','Alexa','Siri']}
block = pd.DataFrame(data)
print("Original Data frame:\n")
print(block)
block.dtypes
输出:
让我们看一下键的原始数据类型。
Original Data frame:
Gender NAME
0 M John
1 F Camili
2 F Rheana
3 M Joseph
4 F Amanti
5 F Alexa
6 F Siri
Gender object
NAME object
dtype: object
现在，我们已经对“性别”列应用了 astype()方法，并将数据类型更改为“类别”。
block['Gender'] = block['Gender'].astype('category')
block.dtypes
输出:
Gender category
NAME object
dtype: object
2。使用数据集实现 Python astype()
这里，我们使用 pandas.read_csv() 函数导入了数据集。你可以在这里找到数据集。
举例:
import pandas
BIKE = pandas.read_csv("Bike.csv")
BIKE.dtypes
列的原始数据类型—
temp float64
hum float64
windspeed float64
cnt int64
season_1 int64
season_2 int64
season_3 int64
season_4 int64
yr_0 int64
yr_1 int64
mnth_1 int64
mnth_2 int64
mnth_3 int64
mnth_4 int64
mnth_5 int64
mnth_6 int64
mnth_7 int64
mnth_8 int64
mnth_9 int64
mnth_10 int64
mnth_11 int64
mnth_12 int64
weathersit_1 int64
weathersit_2 int64
weathersit_3 int64
holiday_0 int64
holiday_1 int64
dtype: object
现在，我们尝试更改变量“season_1”和“temp”的数据类型。因此，我们说使用 astype()函数，我们可以一次改变多个列的数据类型！
BIKE = BIKE.astype({"season_1":'category', "temp":'int64'})
BIKE.dtypes
输出:
temp int64
hum float64
windspeed float64
cnt int64
season_1 category
season_2 int64
season_3 int64
season_4 int64
yr_0 int64
yr_1 int64
mnth_1 int64
mnth_2 int64
mnth_3 int64
mnth_4 int64
mnth_5 int64
mnth_6 int64
mnth_7 int64
mnth_8 int64
mnth_9 int64
mnth_10 int64
mnth_11 int64
mnth_12 int64
weathersit_1 int64
weathersit_2 int64
weathersit_3 int64
holiday_0 int64
holiday_1 int64
dtype: object
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
更多与 Python 相关的帖子，敬请关注，在此之前，祝你学习愉快！！🙂
在 Python 中使用 Selenium 自动化脸书登录
原文：https://www.askpython.com/python/examples/python-automate-facebook-login
大家好！在今天的文章中，我们将学习使用 Python 自动登录脸书。
这将是一个有趣的实验，让您一瞥使用 Python 的 Selenium web 驱动程序的 web 浏览器自动化。所以让我们直接进入主题，创建一个访问脸书页面的脚本，输入凭证，然后登录！
先决条件
现在，在阅读本教程之前，您需要在 Python 中安装某些库。这些库将使我们很容易登录到浏览器。
我们将使用 Python 中的 Selenium webdriver 模块。这个模块使我们能够使用驱动程序控制我们的网络浏览器(Chrome / Firefox)。
但是，要将 Selenium 与我们的浏览器一起使用，我们需要安装该浏览器的驱动程序(Chrome/Firefox)。为了安装它们，我们将借助另一个 Python 模块:webdriver_manager
不需要手动下载 selenium webdriver，您可以简单地导入这个模块！这将为您自动获取所有需求。
现在，让我们pip install必要的包，使用 pip 管理器:
pip install selenium
pip install webdriver_manager
现在我们已经安装了我们的需求，让我们开始编写代码吧！
编写我们的脚本来自动化脸书登录
我们先导入必要的模块。我们需要selenium和webdriver_manager。
from selenium import webdriver
from webdriver_manager.firefox import GeckoDriverManager
from webdriver_manager.chrome import ChromeDriverManager
import time
这里，我需要核心 Selenium 模块的webdriver类。此外，由于我们将在 firefox/chrome 上使用它，我们需要加载必要的网络驱动程序。
现在，我们将使用以下 url 登录:
LOGIN_URL = 'https://www.facebook.com/login.php'
现在，我们将登录功能实现为一个类。姑且称之为FacebookLogin。
当我们调用__init__()时，我们将初始化 selenium webdriver 会话。我们需要将电子邮件和密码字段发送到我们的 webdriver 会话，所以我们将它们作为输入。
最后，我们将从 webdriver 获取带有 GET 请求的LOGIN_URL。
class FacebookLogin():
def __init__(self, email, password, browser='Chrome'):
# Store credentials for login
self.email = email
self.password = password
if browser == 'Chrome':
# Use chrome
self.driver = webdriver.Chrome(executable_path=ChromeDriverManager().install())
elif browser == 'Firefox':
# Set it to Firefox
self.driver = webdriver.Firefox(executable_path=GeckoDriverManager().install())
self.driver.get(LOGIN_URL)
time.sleep(1) # Wait for some time to load
好了，现在我们已经初始化了类实例。现在，为了登录，我们将创建另一个名为login()的方法来完成这项工作。
要登录，我们需要向登录元素(html 页面上的email和pass)提供输入
Selenium 有find_element_by_id()方法，会自动给你定位对应的元素！
要发送键盘输入，我们可以直接用element.send_keys(input)！
def login(self):
email_element = self.driver.find_element_by_id('email')
email_element.send_keys(self.email) # Give keyboard input
password_element = self.driver.find_element_by_id('pass')
password_element.send_keys(self.password) # Give password as input too
login_button = self.driver.find_element_by_id('loginbutton')
login_button.click() # Send mouse click
time.sleep(2) # Wait for 2 seconds for the page to show up
注意这个 API 有多简单！我们可以直接做element.send_keys()和element.click()！
最后，用time.sleep()给程序一些时间来加载网页
下面我给你完整的代码。请确保在main模块中使用正确的登录凭证。
from selenium import webdriver
from webdriver_manager.firefox import GeckoDriverManager
from webdriver_manager.chrome import ChromeDriverManager
import time
LOGIN_URL = 'https://www.facebook.com/login.php'
class FacebookLogin():
def __init__(self, email, password, browser='Chrome'):
# Store credentials for login
self.email = email
self.password = password
if browser == 'Chrome':
# Use chrome
self.driver = webdriver.Chrome(executable_path=ChromeDriverManager().install())
elif browser == 'Firefox':
# Set it to Firefox
self.driver = webdriver.Firefox(executable_path=GeckoDriverManager().install())
self.driver.get(LOGIN_URL)
time.sleep(1) # Wait for some time to load
def login(self):
email_element = self.driver.find_element_by_id('email')
email_element.send_keys(self.email) # Give keyboard input
password_element = self.driver.find_element_by_id('pass')
password_element.send_keys(self.password) # Give password as input too
login_button = self.driver.find_element_by_id('loginbutton')
login_button.click() # Send mouse click
time.sleep(2) # Wait for 2 seconds for the page to show up
if __name__ == '__main__':
# Enter your login credentials here
fb_login = FacebookLogin(email='[email protected]', password='PASSWORD', browser='Firefox')
fb_login.login()
希望你的浏览器现在会显示你的主页。万岁，你已成功登录 facebook！
结论
在本文中，我们学习了如何使用 Python 和 Selenium 快速自动登录脸书！
Python 条形图-可视化 Python 中的分类数据
嘿，读者们。在本文中，我们将关注于创建一个 Python 条形图。
数据可视化 使我们能够理解数据，帮助我们以图形化的方式分析数据的分布。
BarPlot使我们能够可视化分类数据变量的分布。它们代表离散值的分布。因此，它表示分类值的比较。
x 轴代表离散值，而 y 轴代表比较的数值，反之亦然。
现在，让我们在接下来的部分中重点关注条形图的构造。
使用 Matplotlib 创建 Python 条形图
Python matplotlib 模块为我们提供了各种绘制数据和了解数据值分布的函数。
matplotlib.pyplot.bar() function 用于使用 matplotlib 模块创建条形图。
语法:
matplotlib.pyplot.bar(x, height, width, bottom, align)
- x:条形图的标量 x 坐标
- height:要绘制的条形的高度
- 底部:垂直基线
- width:要绘制的条形的宽度(可选)
- align:条形图的对齐类型(可选)。
此外，我们需要确保并理解只有分类数据值可以提供给柱状图。
现在让我们尝试使用 matplotlib 模块实现一个柱状图。
举例:
import matplotlib.pyplot as plt
country = ['INDIA', 'JAPAN', 'CHINA', 'USA', 'GERMANY']
population = [1000,800,600,400,1100]
plt.bar(country,population)
plt.show()
输出:
BARPLOT Using Matplotlib
使用 Seaborn 模块的条形图
Python Seaborn 模块构建于 Matplotlib 模块之上，为我们提供了一些高级功能来更好地可视化数据值。
语法:
seaborn.barplot(x,y)
举例:
import seaborn as sn
import matplotlib.pyplot as plt
import pandas as pd
BIKE = pd.read_csv("BIKE.csv")
sn.barplot(x="season",y="cnt",data=BIKE)
plt.show()
输出:
BARPLOT Using Seaborn
结论
因此，在本文中，我们已经了解了构建 Python 条形图的各种技术。
如果你遇到任何问题，欢迎在下面评论。
更多与 Python 相关的帖子，敬请关注，在此之前，祝你学习愉快！！
参考
Python bin()函数是什么？
原文：https://www.askpython.com/python/built-in-methods/python-bin-function
嘿，伙计们！在本文中，我们将关注使用 Python bin()函数的数据值的二进制表示。
Python bin()函数入门
Python 有各种内置函数来处理和执行对数字数据的操作。
Python bin() function用于将十进制数字数据值转换成二进制格式。
语法:
bin(number)
bin() function返回作为参数传递给它的整数的二进制表示值，并附加前缀‘0b’。
示例 1: 将正数值转换为二进制形式
num = 3
res_bin = bin(num)
print(res_bin)
输出:
0b11
示例 2: 将负数值转换为二进制格式
num = -3
res_bin = bin(num)
print(res_bin)
输出:
-0b11
NumPy 中元素的二进制表示
Python numpy.binary_repr() function用于在 NumPy 中以元素方式将数组的数据值转换为二进制形式。
语法:
numpy.binary_repr(array[value],width)
width:该参数定义返回的代表二进制格式的字符串的长度。- 如果传递给函数的是负值，并且未指定宽度，则在结果前会添加一个减号(“-”)。在指定宽度的情况下，数字的二进制补码表示为绝对值。
例 1:
import numpy as N
arr = [3,5,6,2]
res_arr = N.binary_repr(arr[1])
print(res_arr)
输出:
101
例 2:
import numpy as N
arr = [3,5,6,2]
res_arr = N.binary_repr(arr[1],width=5)
print(res_arr)
输出:
00101
熊猫中数据元素的二进制表示
我们有可能以二进制格式表示 Pandas 中数据集的元素。 format()函数可用于将数据集中的整数值表示为等效的二进制格式。
我们可以简单地使用apply() function并创建一个匿名函数来暗示使用 Python lambda 和 format()函数对每个数据值的操作。
语法:
data['column'].apply(lambda element: format(int(element), 'b'))
虚拟数据集:
Dataset
举例:
import pandas as PD
data = PD.read_csv("C:/marketing_tr.csv")
data_few = PD.DataFrame(data['custAge'].iloc[2:4])
data_few['custAge'].apply(lambda i: format(int(i), '05b'))
在上面这段代码中，我们使用了 format(value，' b ')函数将数据值转换为二进制形式。此外，我们使用 lambda 表达式创建了一个函数来实现相同的功能。“05b”表示返回字符串的长度，即长度= 5。
输出:
2 101010
3 110111
Name: custAge, dtype: object
结论
因此，在本文中，我们已经了解了使用 Python bin()函数将整数值表示为二进制形式的方法。
参考
- Python bin()函数— JournalDev
整数数据的 Python 位函数[简单解释]
原文：https://www.askpython.com/python/built-in-methods/python-bit-functions
读者朋友们，你们好！在本文中，我们将重点介绍一些针对整数数据 的 Python 位函数 。
所以，让我们开始吧！
什么是 Python 位函数？
在开始学习整数的 Python 位函数之前，让我们先了解一下整数的相互转换。
现在，当我们自动化一些手动步骤或者处理系统级信息时，数据值的转换就变得重要了。
当我们处理包括不同数字形式(如十六进制、数字、八进制等)的数据时，位函数在分析整数的位级数据中起着重要的作用。
Python 为我们提供了以下一组位级函数，帮助我们分析有关位级信息和表示的整数数据:
- bit _ length()函数
- to _ bytes()函数
- int . from _ bytes()函数
了解 Python 位函数
现在，让我们在下一节中逐一查看上述功能。
1.Python bit_length()函数
bit_length()函数计算并返回二进制表示所传递的整数数据值所需的位数。该函数不考虑数据值的符号以及前导零。
举例:
在本例中，我们最初将 data = 3 传递给了 bit_length()函数。它返回值为 2。但是二进制形式的整数值 3 的实际表示包括 2 个零，即总共 4 个比特(0011)。
但是由于该函数不考虑前导零，所以它只计算相同的非零位置。
此外，我们向函数传递了一个负 7，即(-7)。但是当函数忽略符号值时，它会像对待其他正整数一样对待。
data = 3
print(data.bit_length())
num = 9
print(num.bit_length())
num = -7
print(num.bit_length())
输出:
2
4
3
2.Python to_bytes()函数
int.to_bytes()函数也将整数值表示为字节数组的序列。
语法:
int.to_bytes(length, byteorder, signed=False)
- length: 表示结果数组的长度。
- byteorder: 如果设置为‘big’，最高有效字节放在数组的开头。如果设置为' little '，最高有效字节位于字节数组的末尾。
- signed: 如果设置为 True，它使用二进制补码将整数表示为字节数组。
举例:
在本例中，我们将整数值 2048 表示为长度等于 4 的字节数组，最高有效字节位于数组的开头。
print((2048).to_bytes(4, byteorder ='big'))
输出:
b'\x00\x00\x08\x00'
3.Python from_bytes()函数
int.from_bytes()函数与 int.to_bytes()函数完全相反。
也就是说，from_bytes()函数将一个字节数组作为参数，并带有 byteorder 参数，然后返回与之对应的整数值。
语法:
int.from_bytes(bytes, byteorder, signed=False)
举例:
print(int.from_bytes(b'\x00\x04', byteorder ='big'))
输出:
4
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。更多与 Python 编程相关的帖子，请继续关注我们。
在那之前，学习愉快！！🙂
Python 按位运算符
原文：https://www.askpython.com/python/python-bitwise-operators
运算符用于对值和变量执行运算。这些符号执行各种计算。运算符所运算的值称为操作数。
在 Python 中，逐位运算符用于根据位对整数进行计算。整数被转换成binary，然后进行逐位运算。然后，结果以decimal格式存储回来。
Python 中按位运算符的类型
| 操作员 | 句法 | |
|---|---|---|
| 按位与(&) | x & y | |
| 按位或(|) | x | y | |
| 按位非(~) | ~x | |
| 按位异或(^) | x ^ y | |
| 按位右移(>>) | x > > | |
| 按位左移(< | x < < |
1.按位 AND 运算符
当两位都为 1 时，该语句返回 1，否则返回 0。
x = 5 = 0101(二进制)
y = 4 = 0100(二进制)
x & y = 0101 & 0100 = 0100 = 4(小数)
2.按位 OR 运算符
当两位中的任何一位为 1 时，语句返回 1，否则返回 0。
x = 5 = 0101
y = 4 = 0100
x & y = 0101 | 0100 = 0101 = 5(小数)
3.按位非运算符
该语句返回所提到的数的补数。
x = 5 = 0101
~x = ~0101
= -(0101 + 1)
= -(0110) = -6(十进制)
4.按位异或运算符
如果任一位为 1，另一位为 0，则该语句返回 true，否则返回 false。
x = 5 = 0101(二进制)
y = 4 = 0100(二进制)
x & y = 0101 ^ 0100
= 0001
= 1(小数)
按位移位运算符
移位运算符用于左移或右移一个数的位，从而分别将该数乘以或除以 2。当我们必须将一个数乘以或除以 2 时，就会用到它们。
5.按位右移运算符
它将数字的位向右移动，结果在右边的空白处填充 0。它提供了一种类似于用 2 的幂来除这个数的效果。
x = 7
x >> 1
= 3
6.按位左移运算符
它将数字的位向左移动，结果在左边的空白处填充 0。它提供了一种类似于将数字乘以 2 的幂的效果。
x = 7
x << 1
= 14
Python 按位运算符示例
a = 5
b = 6
# Print bitwise AND operation
print("a & b =", a & b)
# Print bitwise OR operation
print("a | b =", a | b)
# Print bitwise NOT operation
print("~a =", ~a)
# print bitwise XOR operation
print("a ^ b =", a ^ b)
c = 10
d = -10
# print bitwise right shift operator
print("c >> 1 =", c >> 1)
print("d >> 1 =", d >> 1)
c = 5
d = -10
# print bitwise left shift operator
print("c << 1 =", c << 1)
print("d << 1 =", d << 1)
输出:
a & b = 4
a | b = 7
~a = -6
a ^ b = 3
c >> 1 = 5
d >> 1 = -5
c << 1 = 10
d << 1 = -20
参考
- Python 按位运算符
- Python 组织文档
Python bool()方法:您想知道的一切
原文：https://www.askpython.com/python/built-in-methods/python-bool-method
你好。今天在本教程中，我们将学习 Python bool()方法。
所以，让我们进入正题。
Python bool()方法
bool()方法是一个内置的 Python 方法，它将标准的真值测试过程应用于传递的对象/值，并返回一个布尔值。此外，bool 类不能被子类化。它仅有的实例是False和True。下面给出了使用该方法的语法。
bool([x])
这里， x 是一个可选参数，可以是一个对象、某个值或者任何表达式。当 True 被传递时，该方法返回True,同样，当 False 被传递时，该方法返回False。
bool()方法为下述条件返回False。否则，它返回True。
- 如果对象有一个已定义的 bool() 方法，那么布尔结果取决于它返回的内容。否则，如果对象定义了 len() ，而不是 bool() ，则考虑其返回值。
- 如果值为零任何类型(0，0.0，0j 等。),
- 如果对象是一个空集合或序列，如列表、 st r ing 、元组、字典等。
- 如果值是
False或None常数。
注意:如果对于任何一个对象x，没有定义 __bool__()或者__len__()方法，我们得到的结果是True。
Python bool()工作
现在我们已经学习了bool()方法的基础，让我们尝试一些例子来更好地理解。
1.用数字
下面的例子说明了使用数字的bool()方法。
from fractions import Fraction
from decimal import Decimal
# variable
val = 55
val1 = 0
print("bool(val):", bool(val))
print("bool(val1):", bool(val1))
# expression
print("bool(20 - 4):", bool(20 - 4))
print("bool(20 - 20):", bool(20 - 20))
# float
print("bool(0.0001):", bool(0.0001))
print("bool(0.00):", bool(0.00))
# hex
print("bool(0xF):", bool(0xF))
# Complex Numbers
print("bool(12 - 34j):", bool(12 - 34j))
print("bool(0j):", bool(0j))
# decimal floating point and fractional numbers
print("bool(Decimal(0)):", bool(Decimal(0)))
print("bool(Fraction(0, 2)):", bool(Fraction(0, 2)))
输出:
bool(val): True
bool(val1): False
bool(20 - 4): True
bool(20 - 20): False
bool(0.0001): True
bool(0.00): False
bool(0xF): True
bool(12 - 34j): True
bool(0j): False
bool(Decimal(0)): False
bool(Fraction(0, 2)): False
2.用绳子
对于字符串，bool()方法返回 True，直到它的len()等于零 (0)。
# bool() with strings
string1 = "Python" # len > 0
print(bool(string1))
string1 = '' # len = 0
print(bool(string1))
string1 = 'False' # len > 0
print(bool(string1))
string1 = '0' # len > 0
print(bool(string1))
输出:
True
False
True
True
3.带有内置对象
对于序列或集合，只有当传递的对象是空的时，该方法才返回False。
# list
a = [1, 2, 3, 4]
print(bool(a))
# empty objects
a = []
print(bool(a))
a = ()
print(bool(a))
a = {}
print(bool(a))
输出:
True
False
False
False
4.使用自定义对象
在下面的例子中，我们为我们的custom类定义了__init__()和__bool__()方法。我们用不同的值构造两个对象 x 和 y 。
****注意:即使我们为自定义类定义了__len__()，也不会影响bool()的结果，因为我们已经定义了__bool__()。_ _ len _ _()的返回值仅在类没有定义 bool()时才考虑。
class custom():
val = 0
def __init__(self, num):
self.val = num
def __bool__(self):
return bool(self.val)
# custom objects
x = custom(0)
y = custom(52)
print(bool(x))
print(bool(y))
输出:
False
True
这里，定制对象x和y的bool()结果间接依赖于传递的参数(x 的 0 ，y 的 52 )。因此，我们得到 x 的False(bool(0)= False)和 y 的True(bool(52)= True)。
包扎
今天到此为止。希望你已经清楚地理解了这个主题 Python 中的 bool()方法。我们建议浏览参考资料一节中提到的链接，以获得关于该主题的更多信息。
如有任何进一步的问题，欢迎使用下面的评论。
参考
- Python bool() 文件，
- Python bool 类型–文档，
- bool()在 Python 中的实际应用是什么？–堆栈溢出问题。
Python break 语句
- Python 中的 break 语句用于退出当前循环。
- 我们不能在循环外使用 break 语句，它会抛出一个错误，如" SyntaxError:在循环外使用' break '"。
- 我们可以使用带的 break 语句来循环和，而循环。
- 如果 break 语句出现在嵌套循环中，它将终止内部循环。
- “break”是 Python 中的一个 保留关键字。
中断语句流程图
Break Statement Flow Diagram
Python break 语句语法
break 语句的语法是:
break
我们不能在 break 语句中使用任何选项、标签或条件。
Python break 语句示例
让我们看一些在 Python 中使用 break 语句的例子。
1.用 for 循环中断语句
假设我们有一个整数序列。我们必须一个接一个地处理序列元素。如果我们遇到“3 ”,那么处理必须停止。我们可以使用 for 循环和带有 if 条件的 break 语句来实现这一点。
t_ints = (1, 2, 3, 4, 5)
for i in t_ints:
if i == 3:
break
print(f'Processing {i}')
print("Done")
输出:
Python break Statement with for Loop
2.用 while 循环中断语句
count = 10
while count > 0:
print(count)
if count == 5:
break
count -= 1
输出:
Python break Statement with while Loop
3.带有嵌套循环的 break 语句
下面是嵌套循环中 break 语句的一个示例。
list_of_tuples = [(1, 2), (3, 4), (5, 6)]
for t in list_of_tuples:
for i in t:
if i == 3:
break
print(f'Processing {i}')
输出:
Python break Statement Nested Loop
Python 为什么不支持带标签的 break 语句？
许多流行的编程语言都支持带标签的 break 语句。它主要用于在嵌套循环的情况下脱离外部循环。但是，Python 不支持带标签的 break 语句。
PEP 3136 被引发，为 break 语句添加标签支持。但是，它被拒绝了，因为它会给语言增加不必要的复杂性。对于这个场景，有一个更好的替代方案——将代码移动到一个函数中，并添加返回语句。
Python 断点()函数
原文：https://www.askpython.com/python/built-in-methods/python-breakpoint-function
对于开发人员来说，Python 中的调试有相当多的问题。常见的调试器是 pdb 调试器。但是，为了分析会话，我们需要做一些事情，比如:
import pdb
a = None
for i in range(10):
if i == 4:
a = 'Hi'
print('a is set to', a)
elif i == 5:
pdb.set_trace()
输出
a is set to Hi
> d:\user\pdb-tut.py(4)<module>()
-> for i in range(10):
(Pdb) p a
'Hi'
(Pdb)
虽然您可以使用pdb.set_trace()获得环境的内容和所有相关的变量，但是每次需要进行调试时插入这些内容通常会非常耗时。
此外，对于所有开发人员来说，每次需要进行调试时导入一个模块似乎并不直观。
考虑到这些问题，Python 3.7 引入了断点()方法，它完成导入pdb和调用pdb.set_trace()的工作。
因此，对breakpoint()的调用将产生一个 pdb 会话。
关于断点()
breakpoint()函数调用sys模块中另一个名为sys.breakpointhook()的方法，该方法进入pdb会话。
该方法的签名是:breakpoint(*args, **kwargs)
位置和关键字参数被传递给sys.breakpointhook()，如果签名不匹配，这可能会引发一个TypeError。
下面的例子显示了如何使用breakpoint()。
a = []
for i in range(10):
a.append(i)
if i == 6:
# Start pdb instance when i = 6
breakpoint()
print(a)
输出
> user/askpython/breakpoint_example.py(3)<module>()
-> for i in range(10):
(Pdb) p a
[0, 1, 2, 3, 4, 5, 6]
(Pdb) n
> user/askpython/breakpoint_example.py(4)<module>()
-> a.append(i)
(Pdb) p a
[0, 1, 2, 3, 4, 5, 6]
(Pdb) n
> user/askpython/breakpoint_example.py(5)<module>()
-> if i == 6:
(Pdb) n
> user/askpython/breakpoint_example.py(3)<module>()
-> for i in range(10):
(Pdb) n
> user/askpython/breakpoint_example.py(4)<module>()
-> a.append(i)
(Pdb) n
> user/askpython/breakpoint_example.py(5)<module>()
-> if i == 6:
(Pdb)
> user/askpython/breakpoint_example.py(3)<module>()
-> for i in range(10):
(Pdb)
> user/askpython/breakpoint_example.py(4)<module>()
-> a.append(i)
(Pdb)
> user/askpython/breakpoint_example.py(5)<module>()
-> if i == 6:
(Pdb)
> user/askpython/breakpoint_example.py(3)<module>()
-> for i in range(10):
(Pdb)
> user/askpython/breakpoint_example.py(8)<module>()
-> print(a)
(Pdb)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
--Return--
PYTHONBREAKPOINT 环境变量
sys.pythonbreakpointhook()使用环境变量PYTHONBREAKPOINT。如果该变量被设置为0或禁用，当breakpoint()被调用时pdb调试器不被使用，从而禁用调试器。
因此，我们可以使用这个环境变量在调试模式之间切换。
因此，如果代码中有断点，但您不想进入调试模式，只需在运行 Python 程序时取消设置该环境变量。
[email protected] $ PYTHONBREAKPOINT=0 python breakpoint_example.py
输出
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
更改调试会话
除了pdb之外，PYTHONBREAKPOINT环境变量可用于使用各种第三方调试器进行调试。
我们可以使用变量来设置一个可调用的名称，这将启动一个第三方调试会话，比如web-pdb和pudb。
如果您想使用它们，您可以使用以下方式安装它们:
pip3 install pudb
pip3 install web-pdb
下面的例子显示了使用breakpoint()调用与pudb调试会话的集成。
[email protected] $ PYTHONBREAKPOINT=pudb.set_trace python3 breakpoint_example.py
输出
A Pudb Debugging Session
类似地，可以使用下面的命令启动一个web-pdb会话。(注意web_pdb.set_trace命令中的下划线而不是连字符)
[email protected] $ PYTHONBREAKPOINT=web_pdb.set_trace python3 breakpoint_example.py
2019-12-28 14:52:55,398: root - web_console:108 - CRITICAL - Web-PDB: starting web-server on root-pc:5555...
输出(在localhost:5555上)
A Web Pdb Debugger Session
结论
我们了解了用于调试目的的 Python 的breakpoint()函数，以及PYTHONBREAKPOINT环境变量，该变量可用于使用其他第三方调试器启动各种调试会话。
参考
- Python 断点()文档
- 断点()上的 JournalDev 文章
Python 内置函数:简要概述
原文：https://www.askpython.com/python/built-in-methods/python-built-in-functions-brief-overview
内置函数是编程语言中已经存在的函数。在本文中，让我们通过例子来理解这些函数。
abs()
abs(number)
该函数返回一个数的绝对值。该参数可以是整数、浮点数或复数，如果是复数，则返回数字的大小。
print(abs(10))
print(abs(-210))
print(abs(2 + 3j)) #complex number
输出:
10
210
3 . 56386 . 38638686667
alter_)
aiter(async iterable)
这个函数为异步迭代返回一个异步迭代器。这是 python 3.10 中的一个新函数。
此函数的示例实现。(更多示例请访问此处)
async def aitersync(iterable):
results = []
async for x in aiter(iterable):
results.append(x)
return iter(results)
all()
all(iterable)
该函数采用 iterable(iterable 是可以迭代方式使用的对象，或者在中用于循环。例如:列表、字符串、字典、集合、元组等)作为参数，并在两种情况下返回真值。
- 当 iterable 的所有元素都为真时
- 当 iterable 为空时
#Below list wil return false as all the elements are not true.
list1 = [10, 20, 30, 40, 50, false]
print(all(list1)
#Below set will return true as the set is empty
set1 = {}
print(all(set1))
#Below dictionary wil return true as all elements of the dictonary are true.
dict1 = {1: "Ask", 2: "Python"}
print(all(dict1))
any()
any(iterable)
该函数也将 iterable 作为参数，如果 iterable 的任何元素为 true，则返回 true。如果 iterable 为空，则返回 false。
#Below list wil return True even when some the elements are not true.
list1 = [10, 20, 30, 40, 50, false]
print(all(list1)
#Below set will return False as the set is empty
set1 = {}
print(all(set1))
ascii()
ascii(object)
该函数返回对象的可打印版本。在非 ascii 字符的情况下，它用转义字符替换它们。
x = ascii("åsk python")
print(x)
输出: '\xe5sk python '
字符被替换为转义字符。
bin()
bin(int)
该函数返回指定整数的二进制版本。返回字符串总是以前缀0b开头。
num = bin(7)
print(num)
输出:0b111
bool()
bool(object)
该函数返回指定对象的布尔值(真或假)。如果对象为真，函数将返回真；如果对象为假，或无，或零(0)，或空，函数将返回假。
#below object will return False, as it is empty
list1 = bool()
print(list1)
#below object will return False, as it is 0
list2 = bool(0)
print(list2)
#below object will return True, as it is non-empty
nums = bool({1,2,3,4,5})
orint(nums)
bytearray()
bytearray(x, encoding, error)
这个函数返回一个新的字节数组。它将对象转换为 bytearray 对象，或者创建特定所需大小的空 bytearray 对象。它有 3 个参数
- x:源参数
- 如果它是一个整数，数组将具有该大小，并用空字节初始化。
- 如果是一个字符串，还必须给出编码(以及可选的错误)参数
- 编码:如果源是字符串，则为字符串的编码。
- 错误:如果源是字符串，编码转换失败时要采取的操作。
arr = bytearray(5)
print(arr)
str = "Ask Python"
arr1 = bytearray(str, 'utf-8')
print(arr1)
输出:
bytearray(b ' \ x00 \ x00 \ x00 \ x00 \ x00 ')
字节数组(b'Ask Python ')
字节()
byte(x, encoding, error)
这个函数返回一个新的“字节”对象。它是 bytearray()的不可变版本，这意味着 bytes()返回一个不可修改的对象。参数也与 bytearray()的相同
- x:源参数
- 如果它是一个整数，数组将具有该大小，并用空字节初始化。
- 如果是一个字符串，还必须给出编码(以及可选的错误)参数
- 编码:如果源是字符串，则为字符串的编码。
- 错误:如果源是字符串，编码转换失败时要采取的操作。
arr = bytes([1,2,3,4,5])
print(arr)
输出: b'\x01\x02\x03\x04\x05 '
callable()
callable(object)
如果对象参数是可调用的，该函数返回 true，否则返回 False。如果返回 True，调用仍然有可能失败，但是如果返回 False，调用对象将永远不会成功。
def x():
a = 100
print(callable(x))
输出:真
chr()
chr(int)
这个函数返回一个字符，这个字符的 Unicode 等于 integer int 的 Unicode。整数的范围是 0 到 1，114，111。如果整数超出定义的范围，该函数将返回 ValueError ，如果参数为非整数，则返回 TypeError 。
num = chr(99)
print(num)
输出:c
classmethod()
#considered un-Pythonic
classmethod(function)
#new version
@classmethod
def func(cls, args...)
这个函数将一个函数作为参数，并将其转换为一个类方法。(类方法绑定到类，而不是对象，所以它不需要类实例)@classsmethod 是 class method 的装饰形式。
创建 classmethod 示例:
#defining class
class Employee:
salary = 10000
dept: 'HR'
def printSalary(cls):
print('The employee earns', cls.salary, 'per month.')
#creating classmethod
Employee.printSalary = classmethod(Employee.printSalary)
Employee.printSalary()
产出:员工月薪 10000
编译()
compile(source, filename, mode, flag, dont_inherit, optimize)
这个函数将源代码转换成代码或 AST 对象。如果编译的源代码无效，函数返回*SyntaxError*,如果源代码包含空字节，函数返回*ValueError*。传递参数有:
- source:(强制)要编译的源代码可以是任何东西，如 AST 对象、字符串等
- filename:(强制)读取源文件的文件名，如果不存在这样的文件，自己命名。
- mode:(强制)指定必须编译哪种代码
- eval–如果源包含单个表达式
- exec–如果源包含语句块
- single–如果源包含单个交互式语句
- flag 和 dont_inherit:(可选)控制应该激活哪些编译器选项，以及应该允许哪些未来功能。默认值分别为 0 和 false。
- optimize:(可选)指定编译器的优化级别；
-1的默认值
复杂()
complex(real, imaginary)
该函数返回给定的实数值和虚数值。它将字符串或数字转换成复数。如果第一个参数是一个字符串，它将被解释为一个复数，并且必须在没有第二个参数的情况下调用函数。第二个参数不能是字符串。如果省略了任何一个参数——实数或虚数，那么缺省值仍然是 0，并且构造函数充当类似 int 和 float 的数字转换。如果两个参数都省略，则返回 0j。
z0 = complex(9,-8)
print(z0)
z1 = complex()
print(z1)
z2 = complex(10)
print(z2)
z3 = complex('10-4j')
print(z3)
z4 = complex('5-7j','7')
print(z4)
输出:
(9-8j)
0j
(10+0j)
(10-4j)
类型错误:如果第一个参数是字符串，则 complex()不能接受第二个参数
delattr()
delattr(object, attribute)
如果对象允许，这个函数会删除指定的属性。第一个参数指定从哪个对象中删除属性，第二个属性指定必须删除什么
class Employee:
Name= "Alex"
Dept = "HR"
Salary = 15000
City = "Mumbai"
delattr(Employee, 'Salary')
#Salary attribute gets deleted from the Employee
字典()
dict(keyword arguments)
class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)
该功能
该功能
这个函数创建一个新的字典。dict 对象是 dictionary 类。class dict()返回一个新字典，它由一个可选的位置参数和一组可能为空的关键字参数初始化。
d1 = dict(Name ="Alex", Salary =15000, City ="Mumbai")
print(d1)
输出:
{ '姓名':'亚历克斯'，'薪金':15000，'城市':'孟买' }
dir()
dir(object)
当没有提供参数时，该函数返回当前局部范围内的名称列表。当参数存在时，它返回该对象的有效属性列表。
s1 = {10, 20, 30, 40,}
print(dir(s1))
输出:
['and '，' class '，' contains '，' delattr '，' dir '，' doc '，' format '，' ge '，' getattribute '，' gt '，' hash '，' iand '，' init '，' init_subclass '，'，' ior '，'，' __isub
时尚()
divmod(dividend, divisor)
此函数返回由作为参数传递的数字的商和余数组成的数字对。它将为非数字参数返回 TypeError。
dividend = 110
divisor = 4
nums = divmod(dividend, divisor)
print(nums)
输出: (27，2)
枚举()
enumerate(iterable, start)
此函数返回 iterable 的枚举对象( iterable 必须是序列 eg- tuple)。它向 iterable 添加一个计数器(从开始，默认为 0)。
a = ('Monday', 'Tuesday', 'Wednesday','Thursday')
b = enumerate(a)
#notice the difference in output
print(list(a))
print(list(b))
输出:
['星期一'，'星期二'，'星期三'，'星期四']
[(0，'星期一')，(1，'星期二')，(2，'星期三')，(3，'星期四')]
eval()
eval(expression, globals, locals)
此函数计算作为参数传递的表达式，如果表达式是有效的 Python 语句，它将被执行。这些参数是:
- 表达式:要计算的字符串/表达式
- globals(可选):必须是字典
- 局部变量(可选):可以是任何映射对象。
a = 10
b = 2
c = 'print(a * a + b)'
eval(c)
输出: 102
exec()
exec(object, globals, locals)
这个函数不返回任何值，它不返回任何值。这是一个支持 Python 代码动态执行的函数。对象必须是字符串或代码对象。如果它是一个代码对象，那么它只是被执行，但是在字符串的情况下，它首先被解析为一组 Python 语句，然后被执行。参数与 eval()相同，只是 eval()中的表达式被 exec()中的对象所更改
过滤器()
filter(function, iterable)
顾名思义，这个函数通过函数过滤 iterable，检查该项是否被接受。它返回经过筛选的 iterable。
def Result(x):
if x < 30:
return False
else:
return True
marks = [60, 91, 12, 29, 30, 41]
pass_or_not = filter(Result, marks)
for x in pass_or_not:
print(x)
输出: 60 91 30 41
float()
float(value)
该函数返回由一个值构造的浮点数。值可以是数字或字符串。
x_int = 25
y_float = float(x_int)
print(x_int)
print(y_float)
输出:
Twenty-five
Twenty-five
格式()
format(value, format)
该函数根据作为参数传递的指定格式返回格式化值。默认的格式是一个空字符串，但是，有一个大多数内置类型都使用的标准格式语法:格式规范迷你语言。
# binary format - b
x = 7
print(format(x, "b"))
输出: 111
frozenset()
frozenset(iterable)
该函数返回一个新的 set 或 frozenset 对象，其元素取自 iterable 。一个集合的元素必须是可散列的(如果它有一个在其生命周期中从不改变的散列值)。要表示集合的集合，内部集合必须是 frozenset 对象。如果没有指定 iterable ，则返回一个新的空集。
getattr()
getattr(object, attribute, default)
这个函数返回指定的属性。第一个参数指定从哪个对象中找到属性，第二个属性指定必须找到什么(属性)。
class Employee:
name = 'Alex'
city = 'Mumbai'
Engineer = Employee()
name = getattr(Engineer, 'name')
print(name)
输出:亚历克斯
globals()
globals()
这个函数返回实现当前模块名称空间的字典。global()的输出将显示当前程序的所有全局变量和其他符号。
hasattr()
hasattr(object, attribute)
如果指定的对象中存在指定的属性，则该函数返回 true，如果该属性不存在，则返回 false。
class Employee:
name = 'Alex'
city = 'Mumbai'
Engineer = Employee()
x = hasattr(Engineer, 'name')
print(x)
y = hasattr(Engineer,'salary')
print(y)
输出:
真实的
错误的
哈希()
hash(object)
这个函数返回对象的哈希值(如果有的话)。哈希值是用于在字典查找过程中快速比较字典键的整数。
x1 = 'Ask Python'
print('Ask Python: ', hash(x1))
x2 = 3.147
print('3.147: ',hash(x2))
x3 = 71
print('71:', hash(x3))
输出:
求 Python:-1041620088632976012
3.147:338958922354412547
71:71
帮助()
help(object)
该函数调用内置的帮助系统。它旨在用于交互式使用。在 python shell 上尝试这个函数。
- 如果没有给出参数，交互式帮助系统在解释器控制台上启动。
- 如果参数是一个字符串，那么该字符串将被作为模块、函数、类、方法、关键字或文档主题的名称进行查找，并在控制台上打印一个帮助页面。
- 如果参数是任何其他类型的对象，则生成关于该对象的帮助页面。
help() with no arguments
Help() with arguments
十六进制()
hex(number)
这个函数将指定的数字转换成十六进制值。返回字符串总是以0x开头。
x1 = hex(-44)
print(x1)
x2 = hex(321)
print(x2)
输出:
-0x2c
0x141
id()
id(object)
这个函数返回“身份”(唯一 id——这是一个整数，保证在对象的生命周期中是唯一的和恒定的。)的对象。
x0 = 10
print(id(x0))
x1 = 11
print(id(x1))
x2 = x1
print(id(x2))
输出:
Nine million seven hundred and fifty-six thousand five hundred and twelve
Nine million seven hundred and fifty-six thousand five hundred and forty-four
Nine million seven hundred and fifty-six thousand five hundred and forty-four
输入()
input(prompt)
该函数用于接收用户的输入。该函数从 input 中读取一行，将其转换为一个字符串(去掉尾随换行符)，然后返回该字符串。
String1 = input('Input from the user: ')
print('The input:', String1)
输出:
来自用户的输入:询问 Python
int()
int(value)
int (value, base)
该函数返回一个整数对象，该对象由一个数字或字符串值构成。如果没有给定参数，那么函数将返回 0。基是可选的，表示值的数字系统。它可以是 0、2、8、10 或 16。
#base 2 -> binary number
print(int('0b11101',2))
#base 16 -> hexadecimal number
x2 = 0xC1
print(int('0xC1',16))
输出:
Twenty-nine
One hundred and ninety-three
isinstance()
isinstance(object, classinfo)
该函数返回一个布尔值。如果对象参数是指定的 classinfo 参数或其子类的实例，则返回 true。否则返回 false。如果 classinfo 参数不是类型或类型元组，则该函数返回 TypeError。
numset = {1, 2, 3}
print('Checking for set: ', isinstance(numset, set))
print('Checking for list: ', isinstance(numset, list))
输出:
检查集合:真
检查列表:假
issubclass()
issubclass(class, classinfo)
该函数返回一个布尔值，如果类参数是类信息参数的子类，则返回 true，否则返回 false
class company:
Office= 'AskPython'
class employee(company):
name = 'Alex'
Office = company
print(issubclass(employee, company))
print(issubclass(employee, employee)) #every class is its own subclass
print(issubclass(company, employee))
输出:
真实的
真实的
错误的
iter()
iter(object, sentinel)
这个函数迭代器为给定的对象参数返回一个对象，直到取出标记为止。Sentinel 是可选的，它是用于表示序列结束的值。
list1 = iter(["North", "East", "South", "West"])
print(next(list1))
print(next(list1))
print(next(list1))
输出:
北
东方
南方
len()
len(object)
该函数返回长度，即一个对象的项数。对象参数可以是字符串、字节、元组、列表或范围等序列，甚至可以是字典、集合等集合。
l1 = len([10,20,30,40])
print(l1)
set1 = len({1,2,3,4,5,6,7})
print(set1)
sent = len("Ask Python")
print(sent)
输出:
four
seven
Ten
列表()
list(iterable)
该函数创建一个作为参数传递的 iterable 列表。在没有参数的情况下，该函数将创建一个空列表。
string1 = 'Ask Python'
string2 = list(string1)
print(string1)
print(string2)
输出:
求 Python
['A '，' s '，' k '，' '，' P '，' y '，' t '，' h '，' o '，' n']
本地人()
locals()
这个函数返回一个代表当前本地符号表的字典。它还在必要时更新局部符号表。这个函数没有任何参数。它在函数块中返回自由变量，但在类块中不返回。
print(locals())
输出:
{'In': ["，' locals()']，' Out': {}，' _ '::，' __ ':，' builtin ':，' _ _ builtin _ _ ':，' name': 'main '，' _dh': ['/home/repl']，' _i ':"，' _i1': 'locals()'，' _ih': ["，' locals()']，' _ii ':"，' _iii ':"，' _oh '::':':' '
地图()
map(function, iterables)
该函数将指定为参数的函数应用于作为参数传递的 iterable 的每一项，并返回结果迭代器。
def solve_nums(n,m,k):
return n*m+k
numbers = (1, 2, 3, 4)
result = map(solve_nums,(1,2,3),(10,10,10),(1,2,3))
print(result)
print(list(result))
输出:
[11, 22, 33]
max()
max(n1, n2, n3, ...)
max(iterable)
该函数返回一个可迭代参数中最大的项，或传递的两个或多个参数中最大的项(n1，n2…)。对于字符串参数，最大的项是按字母顺序排序的 iterable 的最后一项。
str1 = max("India","China", "Dubai")
print(str1)
nums = max(-2, -9, -12)
print(nums)
输出:
印度
-2
内存视图()
memoryview(object)
顾名思义，该函数返回对象的“memory view”；memoryview 允许您通过创建内存视图对象来访问对象的内部缓冲区。
str = memoryview(b"Ask Python")
print(str)
#Unicode of the first character
print(str[0])
#Unicode of the second character
print(str[4])
输出:
Sixty-five
Eighty
min()
min(n1, n2, n3, ...)
min(iterable)
该函数返回一个可迭代参数中的最小项，或者两个或多个传递参数中的最小项(n1，n2…)。对于字符串参数，最小的项是按字母顺序排序的 iterable 的第一项。
str1 = min("India","China", "Dubai")
print(str1)
nums = min(-2, -9, -12)
print(nums)
输出:
中国
-12
下一个()
next(iterable, default)
该函数检索指定的 iterable 的下一项。默认值是可选的，并且返回默认的值，直到 iterable 到达它的最终项。
nums = iter([10,20,30])
#the next element -> 1st
nums_1 = next(nums)
print(nums_1)
#the next element -> 2nd
nums_2 = next(nums)
print(nums_2)
输出:
Ten
Twenty
object()
x = object()
这个函数不接受任何参数。它返回一个新的无特征的对象。一个对象拥有所有 Python 类实例共有的方法。它是所有阶级的基础
abc = object()
当创建输出“abc”对象时
oct()
oct(x)
此函数将指定的数字转换为十八进制值。返回字符串总是以0 o 开始。
x1 = oct(-44)
print(x1)
x2 = oct(321)
print(x2)
输出:
-0o54
0o501
打开()
open(file, mode='r', buffering=- 1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
这个函数打开文件并返回一个相应的 file 对象。如果找不到指定的文件，该函数将返回 OSError。这些参数是
- 文件–提供路径名，它是一个类似路径的对象
- mode-这是一个可选字符串，指定文件打开的模式。以下是一些常用的模式
| 'r' | 打开以供阅读(默认) |
| 'w' | 打开进行写入，首先截断文件 |
| 'x' | 以独占方式打开，如果文件已经存在，则失败 |
| 'a' | 打开以供写入，追加到文件的末尾(如果存在) |
| 'b' | 二进制 |
| 't' | 文本模式(默认) |
| '+' | 打开以进行更新(读取和写入) |
Modes and their description
- 缓冲–这是一个可选字符串，用于设置缓冲策略
- encoding–这是一个可选字符串，用于说明编码格式
- errors–这是一个可选字符串，用于解决编码/解码错误
- newline–这是一个可选字符串，用于说明换行模式如何工作
- closefd–这是一个可选字符串，默认情况下必须为 true 如果给定或否则，将发生异常。
- opener–它是一个可选字符串，返回一个打开的文件描述符
ord()
ord(ch)
这个函数只是返回所传递参数的 Unicode 码位的整数表示。
print(ord('T'))
print(ord('1'))
print(ord('@'))
输出:
84
49
64
pow()
pow(number, exponential, modulus)
该函数返回一个值，该值等于数的指数次方。modulus 参数是可选的，如果存在，则返回 mod of number。
print(pow(2,0))
print(pow(0, 2))
print(pow(2,3,3)) #(2*2*2)/3
输出:
1
0
2
print()
print(object(s), sep=separator, end=end, file=file, flush=flush)
顾名思义，这个函数将对象打印到文本流文件中，由 sep 分隔，后跟 end 。除了对象之外的所有其他参数都是可选的。
nums = [1,2,3,4]
print("Numbers are: ", nums, sep='0', end='\n')
print("Ask Python")
输出:
数字是:0[1，2，3，4]
问 Python
属性()
property(fget=None, fset=None, fdel=None, doc=None)
该函数采用四个可选参数，并返回 property 属性。
- fget 用于获取一个属性值。
- 偏移用于设置属性值。
- fdel 用于删除属性值。
- doc 为属性创建一个 docstring。
范围()
range(start, stop, step)
这个函数根据传递的参数返回一个不可变的数字序列。如果传递了一个参数，那么该函数会将其视为一个 stop 参数。
nums = [1,2,3,4,5,6,7,8,9,10]
nums = range(5)
print(list(nums))
#2, and 10 are considered start and stop respectively
nums = range(2,10)
print(list(nums))
#increament step 2
nums = range(2,10,2)
print(list(nums))
输出:
[0，1，2，3，4]
【2，3，4，5，6，7，8，9】
【2，4，6，8】
repr()
repr(object)
该函数返回一个字符串，该字符串包含一个对象的可打印表示。在大多数情况下，它返回相同的对象。
string1 = 'Ask Python'
print(repr(string1))
nums1 = [1,2,3,4]
print(repr(nums1))
输出:
问 Python'
[1，2，3，4]
反转()
reversed(sequence)
该函数返回指定序列参数的逆序。这里，序列可以是任何可索引的可迭代的，例如列表、元组、集合等。
list1 = [1, 2, 4, 3, 5]
print(list(reversed(list1)))
tuple1 = ('A','S','K',' ','P','Y','T','H','O','N')
print(list(reversed(tuple1)))
输出:
[5，3，4，2，1]
['N '，' O '，' H '，' T '，' Y '，' P '，' '，' K '，' S '，' A']
回合()
round(number, ndigits)
该函数返回一个四舍五入到小数点后位数的数字。 ndigits 参数是可选的，如果不提供，函数将返回最接近的整数。
print('1.8 -> ',round(1.8))
print('1.2 -> ',round(1.2))
print('1.5678 (2 decimal points)-> ',round(1.5678,2))
输出:
1-> 1
1.8->2
1.2->1
1.5678(小数点后两位)- > 1.57
集合()
set(iterable)
这个函数为指定的 iterable 参数构造一个集合。如果没有指定参数，那么函数将构造一个空集。
print(set()) #empty set will be constructed
print(set(('A','S','K',' ','P','Y','T','H','O','N')))
print(set(('Ask Python')))
输出:
set()
{'S '，' O '，' K '，' A '，' H '，' N '，' P '，' Y '，' ' }
setattr()
setattr(object, name, value)
该函数用于设置或修改指定的对象参数中的名称及其值。
class Employee:
name = 'Atlas'
emp = Employee()
print('Before:', emp.name)
#modifying the name using setattr()
setattr(emp, 'name', 'Ryle')
print('After:', emp.name)
输出:
之前:阿特拉斯
之后:赖尔
切片()
slice(stop)
slice(start, stop, step)
该函数返回对象的一个切片，该切片是在开始和停止参数之间的一个对象的项目。这里步和开始是可选参数。如果未提及开始，则功能从第 1 项开始。步长参数用于指示增量，默认值设置为无。
string1 = 'Ask Python'
slice_object1 = slice(6)
print(string1[slice_object1])
nums1 = [1,2,3,4,5,6,7,8,9,10,11]
slice_object2 = slice(1, 6, 2)
print(nums1[slice_object2]) #increament by 2
输出:
询问 Py
[2，4，6]
已排序()
sorted(iterable, key=key, reverse=reverse)
该函数从 iterable 中的项目返回一个新的排序列表。键是一个可选参数，用于指定返回列表的顺序。倒档也是一个可选参数。它是一个布尔值，如果降序，则返回 true，如果升序，则返回 false。
nums = [50,20,40,10,30]
print(sorted(nums))
print(sorted(nums,reverse = True))
string1 = 'AskPython'
print(sorted(string1))
输出:
[10，20，30，40，50]
【50，40，30，20，10】
[' A '，' P '，' h '，' k '，' n '，' o '，' s '，' t '，' y']
str()
str(object=b'', encoding='utf-8', errors='strict')
这个函数返回一个 str 对象的一个版本。编码参数指定编码格式，默认值设置为 utf-8。错误参数指定解码失败时如何响应。它可以是严格的，忽略的或替换的。
s1 = bytes('AskPython', encoding='utf-8',errors='strict')
print(str(s1, encoding='ascii', errors='ignore'))
输出:
AskPython
sum()
sum(iterable, start=0)
该函数返回所有项目的总和加上开始参数。start 参数是可选的，默认情况下被认为是 0。iterable 的项目只能是数字。
nums = [10,20,30,40,50]
print(sum(nums))
print(sum(nums,3))
输出:
150
153
超级()
super(object)
这个函数返回对象的父类或兄弟类。这对于访问在类中被重写的继承方法很有用。
class Employee(object):
def __init__(self, emp):
print(emp, 'works for AskPython')
class emp(Employee):
def __init__(self):
super().__init__('Alex')
emp1 = emp()
输出:
亚历克斯为 AskPython 工作
元组()
tuple(iterable)
这个函数为指定的 iterable 参数构造一个元组。如果没有指定参数，那么函数将构造一个空元组。
print(tuple()) #empty tuple will be constructed
print(tuple([10,20,30,40]))
print(tuple(('Ask Python')))
输出:
()
(10，20，30，40)
('A '，' s '，' k '，' '，' P '，' y '，' t '，' h '，' o '，' n ')
type()
type(object)
type(name, bases, dict)
这个函数以两种不同的方式工作。
- 如果参数对象被传递，那么它将返回对象的类型。
- 如果传递了三个参数，那么它返回一个新类型的对象。名称字符串是类名。基元组包含基类。如果为空，则添加一个对象，即所有类的最终基。字典包含了类体的属性和方法定义。
nums= {10,20,30,40}
print(type(nums))
class Employee:
name: 'Atlas'
emp = Employee()
print(type(emp))
sample1 = type('AskPython',(Employee,) ,dict(x1='a', x2='b'))
print(type(sample1))
输出:
<class 'main.employee'>
<class 'type'>
乌鸦()
vars(object)
这个函数返回指定对象参数的字典映射属性(dict)。如果没有提到参数，那么函数返回局部范围内的方法。
print (vars())
print(vars(tuple))
输出:
{'name': 'main '，' doc': None，' package': None，' loader ':' spec ':None，' annotations': {，' builtins': }
zip()
zip(*iterables)
基于作为参数传递的 iterable 的元组的这个函数迭代器。
- 如果没有指定参数，函数将返回一个空迭代器。
- 如果指定了单个 iterable 参数，该函数将返回一个元组迭代器，每个元组只有一个元素。
- 如果指定了多个 iterables 参数，该函数将返回一个元组迭代器，每个元组包含所有 iterables 中的元素。
nums = [1, 2, 3, 4]
string1 = ['North', 'East', 'West','South']
# Two iterables are passed
x = zip(nums, string1)
list1 = list(x)
print(list1)
输出:
[(1，'北')，(2，'东')，(3，'西')，(4，'南')]
__ 导入 _ _()
__import__(name, globals=None, locals=None, fromlist=(), level=0)
当语句调用此函数时，此函数用于更改导入语句的语义。反而用进口挂钩更好。该功能很少使用，我们不鼓励使用该功能。
结论
Python 是最好解释的语言之一。内置函数使得更容易有效地使用它。在本文中，我们介绍了 python 中所有可用的内置函数，以及它们的用法和示例。
如需更多参考资料，请点击此处。
Python bytearray()函数
原文：https://www.askpython.com/python/built-in-methods/python-bytearray-function
在本文中，我们将了解 Python 的内置函数之一— Python bytearray()函数。
了解 Python bytearray()函数
Python 有内置的 bytearray()方法，创建一个字节数组，返回一个创建的数组的 bytearray 对象，其大小由特定的 iterable 或值定义。
语法:
bytearray(source_input, encoding_scheme, error)
参数:
source_input:可选参数。它主要用于初始化数组数据元素。source_input 可以是一个可迭代的、值等。encoding_scheme(可选):用于定义字符串的编码模式。error(可选):定义编码失败时需要采取的动作。
bytearray() method以一个 iterable 如 list、string、tuple 等或 value 作为参数，用 size 初始化一个数组，并返回它的一个 bytearray 对象。
例子: 无参数的 Python bytearray()函数
inp = bytearray()
print(inp)
当没有参数传递给 bytearray()函数时，该函数返回一个空 bytearray 对象。
输出:
bytearray(b'')
1.Python bytearray()函数，使用字符串作为参数
当一个字符串值作为参数传递给 bytearray()函数时，它会将字符串转换成一个字节数组。
强制条件继续保持，使得无论何时在参数列表中传递字符串，都必须在参数列表中为相同的字符串定义编码，否则引发TypeError exception。
例 1:
inp_str = "JournalDev"
arr_8 = bytearray(inp_str, 'utf-8')
print(arr_8)
这里，我们将 encoding_scheme 作为' utf-8 '传递，以便将输入字符串转换为字节数组。
输出:
bytearray(b'JournalDev')
例 2:
inp_str = "JournalDev"
arr_16 = bytearray(inp_str, 'utf-16')
print(arr_16)
在上面的例子中，编码方案被定义为' utf-16 '。
输出:
bytearray(b'\xff\xfeJ\x00o\x00u\x00r\x00n\x00a\x00l\x00D\x00e\x00v\x00')
2.将 iterable 作为参数传递的 Python bytearray()函数
当一个 iterable 如 list 、 set 、 tuple 等作为参数传递给 bytearray()函数时，它返回一个包含初始内容的字节数组作为 bytearray 对象中的数组元素。
强制条件:如果将 iterable 作为参数传递给 bytearray()函数，则 iterable 的所有元素都必须是类型integer以避免类型错误。
例子: Python bytearray()带列表
inp_lst = [2, 4, 6, 8]
res_byte = bytearray(inp_lst)
print(res_byte)
如清楚理解的，列表的内容，即[2，4，6，8] 已经被用于创建 bytearray 对象。
输出:
bytearray(b'\x02\x04\x06\x08')
3.Python bytearray()函数，以整数值作为参数
如果 bytearray()函数遇到一个整数值作为参数，它就用size = integer value创建一个 bytearray 对象，然后用空值(' \0')** 初始化**。
举例:
inp = 14
res_byte = bytearray(inp)
print(res_byte)
在上面的例子中，创建了一个数组对象，数组大小为“14”，并用空值初始化。
输出:
bytearray(b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')
摘要
- Python bytearray()函数返回一个 bytearray 对象，即生成一个提供给该函数的源输入类型的字节数组。
- bytearray()函数可以有一个可迭代的、值等作为它的参数。
- 每当向 iterable 传递函数时，iterable 的元素必须是整数类型。
结论
因此，在本文中，我们已经理解了 Python bytearray()方法使用各种类型的参数的工作原理。
参考
- python bytearray()–journal dev
- Python bytearray()函数——官方文档
Python 字节()
原文：https://www.askpython.com/python/built-in-methods/python-bytes
Python bytes() 是一个内置函数，它返回一个 bytes 对象，该对象是一个不可变的整数序列，范围为 0 < = x < 256。根据作为源传递的对象类型，它相应地初始化 byte 对象。
让我们看看如何在本文中使用这个函数。
句法
这需要三个可选参数，即:
source- >初始化字节数组的源encoding->source字符串的编码(可以是-8等)。errors- >对源字符串编码失败时函数的行为。
byte_array = bytes(source, encoding, errors)
因为这三个参数都是可选的，所以我们可以传递一个空字符串来生成一个空字节数组(大小为 0 的字节数组)。
根据source参数的类型，适当的字节数组将被初始化。
- 如果
source是一个字符串，Python bytes() 会用[str.encode()](https://www.askpython.com/python/string/python-encode-and-decode-functions)把字符串转换成字节。因此，我们还必须提供编码和可选的错误，因为encode()正被用于处理字符串。 - 如果
source是一个整数，Python bytes() 会创建一个给定整数大小的数组，全部初始化为 NULL 。 - 如果
source属于Object类，对象的只读缓冲区将用于初始化字节数组。 - 如果
source是可迭代的，那么必定是 0 < = x < 256 范围内的整数的可迭代的，这些整数作为数组的初始内容。
如果source是None，这将给出一个TypeError，因为它不能将一个None对象转换成一个字节数组。
为了更好地理解该函数，我们来看一些例子。
使用 Python 字节()
没有和没有参数
b = bytes()
print(b)
c = bytes(None)
print(c)
输出
b''
TypeError: cannot convert 'NoneType' object to bytes
使用源字符串
任何没有编码的字符串都会引发一个TypeError。
类似地，试图修改bytes对象也会给出相同的异常，因为它本质上是不可变的。
try:
a = bytes('Hello from AskPython')
except TypeError:
print('We need to specify string encoding always!')
b = bytes('Hello from AskPython', 'UTF-8')
print(type(b), b)
try:
b[0] = 10
except TypeError:
print('byte objects are immutable!')
输出
We need to specify string encoding always!
<class 'bytes'> b'Hello from AskPython'
byte objects are immutable!
使用源整数
整数零初始化数组中的字节元素对象。
a = bytes(10)
print(type(a), a)
输出
<class 'bytes'> b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
如您所见，bytes 对象是一个由 10 个元素组成的零初始化数组。
源是可迭代的
这用len(iterable)个元素初始化数组，每个元素的值都等于 iterable 上相应的元素。
字节数组值可以通过普通迭代访问，但不能修改，因为它们是不可变的。
a = bytes([1, 2, 3])
print(type(a), a)
print('Length =', len(a))
# To access the byte array values, we can iterate through it!
for byte_obj in a:
print(byte_object)
输出
<class 'bytes'> b'\x01\x02\x03'
Length = 3
1
2
3
iterable 上的任何其他内容都将导致一个TypeError
>>> a = bytes([1, 2, 3, 'Hi'])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object cannot be interpreted as an integer
结论
在本文中，我们学习了 Python bytes() 函数，它可以将合适的对象转换成字节数组。
参考
- 字节数为()的 JournalDev 文章
如何使用 Python callable()方法
原文：https://www.askpython.com/python/built-in-methods/python-callable-method
介绍
在本教程中，我们将讨论Python callable()方法及其用法和工作原理。
基本上，当一个对象或实例有一个已定义的 __call__()函数时，它被称为可调用的。那样的话，我们可以用更简单的方式引用 a.call(arg1，arg2，…)，a(arg1，arg2，…)。因此，它变得可调用。
Python callable()方法
此外，Python 中的callable()方法使得用户更容易识别可调用和不可调用的对象和函数。这是一个单参数函数，如果传递的对象是可调用的，则返回 true ，否则返回 false 。
下面给出了该方法的语法,
callable(obj)
这里的obj是用户想要检查是否可调用的实例或对象。
Python callable()方法的工作原理
让我们看一些例子来清楚地理解 Python 中的callable()方法。
当 Python callable()返回 True 时
如前所述，当传递的对象可调用时，该方法返回 true 。让我们看看它是在什么条件下这样做的。
#true
def demo():
print("demo() called!")
#object created
demo_obj = demo
class demo_class:
def __call__(self, *args, **kwargs): #__call__() is defined here
print("__call__() defined!")
demo_class_obj = demo_class()
print("demo_obj is callable? ",callable(demo_obj))
print("demo_class is callable? ",callable(demo_class)) #classes are always callable
print("demo_class_obj is callable? ",callable(demo_class_obj))
demo_obj() #calling demo()'s object
demo_class_obj() #calling the demo_class object
输出:
demo_obj is callable? True
demo_class is callable? True
demo_class_obj is callable? True
demo() called!
__call__() defined!
这里，
- 我们定义
demo()函数，创建它的新实例 demo_obj ， - 然后用
__call__()函数定义一个新的类 demo_class ， - 并创建名为 demo_class_obj 的类 demo_class 的对象，
- 最后，检查创建的对象和类是否是可调用的。我们可以从输出中看到，是可调用的。
- 最后，我们调用函数
demo()和demo_class_obj()。在演示类的对象调用中，执行了 call() 方法，我们可以从输出中看到这一点。
注意:所有的类都是可调用的，所以对于任何一个类，callable()方法都返回 true。这在上面的例子中很明显，我们试图检查 demo_class 的callable()输出。
当 Python callable()返回 False 时
同样，当传递的对象不可调用时，callable()返回 false 。让我们看看它是在什么条件下这样做的。
n = 10
class demo_class:
def print_demo(self):
print("demo")
demo_class_obj = demo_class()
print("n is callable? ",callable(n))
print("demo_class_obj is callable? ",callable(demo_class_obj))
输出:
n is callable? False
demo_class_obj is callable? False
在上面的代码中，
- 我们将整数 n 初始化为 n = 10 ，
- 然后用成员函数
print_demo()定义一个类 demo_class ， - 之后，我们创建一个名为 demo_class_obj 的 demo_class 对象，
- 最后，检查 n 和 demo_class_obj 是否可调用，从上面的输出可以看出，它们是不可调用的。
n 是一个整数，显然不能调用。而在 demo_class_obj 的情况下，类(demo_class)没有定义好的
__call__()方法。因此不可调用。
结论
因此，在本教程中，我们学习了 Python callable()方法及其工作原理。该方法广泛用于程序的防错。
在实际调用之前检查对象或函数是否可调用有助于避免类型错误。
希望你对题目有清晰的认识。如有任何问题，欢迎在下面评论。
参考
Python 验证码生成器–用 Python 创建音频和图像验证码
原文：https://www.askpython.com/python/examples/python-captcha-generator
嘿程序员们！我很确定在一些网站上遇到过验证码，它可以验证你是人还是机器人。是的，你是对的，它们是当你完成一份长表格，甚至有时付款时出现的恼人的事情。看看下面的验证码样本。
Captcha Example
在本教程中，我们将尝试使用 Python 来生成我们自己的验证码！有趣吧？让我们直接进入代码吧！
安装验证码模块
所以就像任何其他程序一样，第一步是安装验证码库。为此，请打开命令提示符并运行以下命令:
pip install captcha
用 Python 创建验证码生成器的步骤
在本教程中，我们将尝试生成图像和音频验证码。因此，当您完成安装库时，您需要分别从 captcha.image 和 captcha.audio 子库中导入 ImageCaptcha 和 AudioCaptcha 函数。
from captcha.image import ImageCaptcha
from captcha.audio import AudioCaptcha
用 Python 生成图像验证码
让我们从创建一个图像验证码开始。我们将从用户那里获取关于需要在屏幕上显示的文本的输入，然后为数据生成图像验证码。
为了创建验证码，我们需要创建一个 Imagecaptcha 对象，然后使用 generate 函数为数据生成验证码。看看下面的代码。
img = ImageCaptcha(width = 280, height = 90)
text = input("Enter the Text for Captcha: ")
Cap_data = img.generate(text)
图像已经生成，但是要保存图像，我们需要使用下面的代码来使用 write 函数。
img.write(text, 'Sample_Cap_1.png')
在我们输入 AskPython 作为验证码的文本后，我们得到如下所示的验证码:
Sample Cap 1 1
看起来很酷，对吧？！
使用 Python 生成音频验证码
现在让我们试着生成一个音频验证码。对于音频验证码，我们将尝试为用户输入的数字生成一个数字验证码。看看下面的代码。音频验证码的工作方式与图像验证码类似。
audio = AudioCaptcha()
text = input("Enter the Text for Captcha: ")
data = audio.generate(text)
audio.write(text,'Sample_Cap_2.wav')
当我们进入 3422 时，我们会听到类似下面的声音。
这听起来肯定很奇怪，但请仔细听！您将听到音频中所有噪音之间的数字。
结论
恭喜你！您刚刚学习了如何使用 Python 编程语言生成自己的验证码。你可以玩验证码，生成更多的验证码。尽情享受吧！
快乐学习！😁
python–捕捉多个异常
原文：https://www.askpython.com/python/examples/python-catch-multiple-exceptions
Python 总是在基于异常的模型上运行。也就是说，程序执行期间的任何错误都被作为异常传递并返回给程序员，这可以使用异常处理技术来相应地处理。
有时，一个流程可能会引发多个异常，这取决于控制流。因此，我们可能需要为这个程序/函数捕获多个异常。
让我们了解如何在 Python 中处理多个异常。
捕捉多个异常
Python 允许我们以两种方式处理多个异常:
使用多个 Except 块
我们可以通过顺序写下所有这些异常的except块来捕捉多个异常。
伪代码如下所示:
try:
pass
except Exception1:
pass
except Exception2:
pass
让我们通过一个例子来理解这种处理方式。
考虑下面的函数，它试图使用+操作符添加一个列表中的所有项，并检查是否有任何整数项小于 200。因为如果类型不同，加法/串联也可能失败，所以可能有多个例外。
input_list_1 = ['Hello', ' from', 123, 456, ' AskPython']
input_list_2 = [123, 456, ' AskPython']
def add_list(ip):
# Adds all items of a list
# Will raise ValueError if any integer item > 200
# and will raise TypeError if addition operands are of different types
if isinstance(ip, list):
result = '' if isinstance(ip[0], str) else 0
for item in ip:
if isinstance(item, int) and item > 200:
raise ValueError('Integer Item has to be <= 200')
result = result + item
return result
else:
return None
try:
# Will raise TypeError
res = add_list(input_list_1)
print(res)
except TypeError as te:
print(type(te), te)
except ValueError as ve:
print(type(ve), ve)
try:
# Will raise ValueError since 456 > 200
res = add_list(input_list_2)
print(res)
except TypeError as te:
print(type(te), te)
except ValueError as ve:
print(type(ve), ve)
该函数在两个列表上运行，以显示单个函数可以引发多个异常。
输出
<class 'TypeError'> can only concatenate str (not "int") to str
<class 'ValueError'> Integer Item has to be <= 200
使用单个 Except 块
如果您希望所有的异常都有相同的行为，我们也可以在一个except块中捕获多个异常。
这可以避免不必要的代码重复，如果多个异常的输出相同，还可以节省程序员的时间。
相同的伪代码:
try:
pass
except (Exception1, Exception2) as e:
pass
让我们针对多个异常使用单个except块来修改main块。
try:
res = add_list(input_list_1)
print(res)
except (TypeError, ValueError) as err:
print(type(err), err)
try:
res = add_list(input_list_2)
print(res)
except (TypeError, ValueError) as err:
print(type(err), err)
输出将保持不变:
<class 'TypeError'> can only concatenate str (not "int") to str
<class 'ValueError'> Integer Item has to be <= 200
注意:多重异常可以是内置异常和自定义异常的任意组合。
结论
在本文中，我们学习了在 Python 中处理多个异常的两种方法，一种是使用多个连续的except块，另一种是使用单个except块来减少代码重复。
参考
-
关于多重异常处理的 JournalDev 文章
如何使用 Python center()方法？
原文：https://www.askpython.com/python/string/python-center-method
大家好！在本文中，我们将了解带有 String、NumPy 和 Pandas 模块的 Python center()函数。
带字符串的 Python center()方法
Python String 有很多内置的函数来操作和处理字符串。
string.center() method以集中的形式在输入字符串的两边(左右两边)用特定的字符对字符串进行填充。
语法:
string.center(width,fillchar)
width:该值决定字符串周围的填充区域。fillchar:填充区域由特定字符填充。默认字符是空格。
例 1:
inp_str = "Python with JournalDev"
print("Input string: ", inp_str)
res_str = inp_str.center(36)
print("String after applying center() function: ", res_str)
在上面的代码片段中，使用 center()函数，我们用默认的 fillchar 填充了字符串，即参数列表中定义的宽度(36)的空格。
输出:
Input string: Python with JournalDev
String after applying center() function: Python with JournalDev
例 2: 用 center()函数通过特定的 fillchar 填充字符串
inp_str = "Python with JournalDev"
print("Input string: ", inp_str)
res_str = inp_str.center(36,"$")
print("String after applying center() function: ", res_str)
输出:
Input string: Python with JournalDev
String after applying center() function: $$$$$$$Python with JournalDev$$$$$$$
带有熊猫模块的 Python center()函数
Python center()函数也可以和 Pandas 模块的数据帧一起使用。
DataFrame.str.center() function用传递给函数的字符沿着字符串两边的特定宽度(包括字符串的宽度)填充输入字符串。
语法:
DataFrame.str.center(width,fillchar)
输入数据集:
contact
1 cellular
2 telephone
3 cellular
4 cellular
5 telephone
6 telephone
7 telephone
8 cellular
9 cellular
举例:
import pandas
info=pandas.read_csv("C:/marketing_tr.csv")
info_con=pandas.DataFrame(info['contact'].iloc[1:10])
info_con['contact']=info_con['contact'].str.center(width = 15, fillchar = '%')
print(info_con['contact'])
输出:
1 %%%%cellular%%%
2 %%%telephone%%%
3 %%%%cellular%%%
4 %%%%cellular%%%
5 %%%telephone%%%
6 %%%telephone%%%
7 %%%telephone%%%
8 %%%%cellular%%%
9 %%%%cellular%%%
Name: contact, dtype: object
带有 NumPy 模块的 Python center()函数
Python center()函数可以和 NumPy 模块一起使用，对数组的每个元素进行中心填充。
numpy.char.center() method用于将元素居中，甚至通过数组元素两侧的特定字符对其进行填充。
语法:
numpy.char.center(array,width,fillchar)
举例:
import numpy as np
inp_arr = ['Python', 'Java', 'Kotlin', 'C']
print ("Input Array : ", inp_arr)
res_arr = np.char.center(inp_arr, 15, fillchar = '%')
print("Array after applying center() function: ", res_arr)
在上面的例子中，我们已经将 center()函数应用于数组的每个元素，从而使元素居中，并根据两边的宽度用 fillchar 填充数组元素。
输出:
Input Array : ['Python', 'Java', 'Kotlin', 'C']
Array after applying center() function: ['%%%%%Python%%%%' '%%%%%%Java%%%%%' '%%%%%Kotlin%%%%' '%%%%%%%C%%%%%%%']
结论
因此，在本文中，我们已经分别理解了 Python center()函数以及 NumPy 和 Pandas 模块的工作原理。
参考
- Python center()函数— JournalDev
python chain map–您需要知道的一切！
读者朋友们，你们好！在本文中，我们将详细关注 Python 链图。
所以，让我们开始吧！！🙂
什么是 Python ChainMap 数据结构？
在深入了解 ChainMap 的概念之前，让我们快速回顾一下对 Python 集合模块的理解。
Python 集合模块为我们提供了各种数据结构来存储和操作数据。通过提供定制的数据存储和操作，它从所有其他默认数据结构中脱颖而出。
该模块表现为存储不同类型的数据对象的容器，并具有用于将其塑造成定制数据结构的定制特征。
集合模块提供的一个这样的容器是 ChainMap！
使用 ChainMap，我们可以将不同类型的键值实体合并并存储到一个地方。ChainMap 容器使我们能够拥有多个字典，然后将它们合并成一个字典。
导入 Python 链图
为了实现链图模块的功能，我们需要导入如下所示的模块
from collections import ChainMap
做完这些，现在让我们试着从多个字典中创建一个通用的链表结构
语法:
ChainMap(dict, dict)
举例:
在下面的例子中，我们已经创建了两个字典 A 和 B ，然后我们将它们合并起来作为一个实体。
输出:
from collections import ChainMap
a = {'Age': 1, 'Name': 'X'}
b = {'Age': 3, 'Name': 'Y'}
cm = ChainMap(a, b)
print(cm)
输出—
ChainMap({'Age': 1, 'Name': 'X'}, {'Age': 3, 'Name': 'Y'})
链图模块中需要了解的重要函数
随着 ChainMap container 的出现，出现了一个庞大的函数列表，人们可以用它来操作存储在其中的字典。让我们看看下面的函数。
- 按键()
- 值()
- 地图T2 属性
1.Chainmap.keys()函数
顾名思义，keys()函数使我们能够从每个字典的每个键值对中提取键值。可以一次从多个字典中提取关键字。
语法—
ChainMap.keys()
示例—
from collections import ChainMap
a = {'Age': 1, 'Name': 'X'}
b = {'Age': 3, 'Name': 'Y'}
cm = ChainMap(a, b)
print(cm)
print ("Keys: ")
print (list(cm.keys()))
输出—
ChainMap({'Age': 1, 'Name': 'X'}, {'Age': 3, 'Name': 'Y'})
Keys:
['Age', 'Name']
2.ChainMap.maps 属性
为了获得更清晰的输出，maps 属性使我们能够将每个键与字典中的值相关联。因此，它将输出表示为字典的每个键值对。
语法—
ChainMap.maps
示例—
from collections import ChainMap
a = {'Age': 1, 'Name': 'X'}
b = {'Age': 3, 'Name': 'Y'}
cm = ChainMap(a, b)
print(cm)
print ("Maps: ")
print (list(cm.maps))
输出—
ChainMap({'Age': 1, 'Name': 'X'}, {'Age': 3, 'Name': 'Y'})
Maps:
[{'Age': 1, 'Name': 'X'}, {'Age': 3, 'Name': 'Y'}]
3.Chainmap.values()函数
除了将键和整个字典显示为一个映射之外，values()函数使我们能够独立地提取和表示与特定键相关联的所有值。
语法—
ChainMap.values()
示例—
from collections import ChainMap
a = {'Age': 1, 'Name': 'X'}
b = {'Std': 3}
cm = ChainMap(a, b)
print(cm)
print ("Values: ")
print (list(cm.values()))
输出—
ChainMap({'Age': 1, 'Name': 'X'}, {'Std': 3})
Values:
[1, 3, 'X']
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
更多与 Python 编程相关的帖子，请继续关注我们。
在那之前，学习愉快！！🙂
python–检查变量是否为字符串
原文：https://www.askpython.com/python/examples/python-check-if-variable-is-a-string
因为 Python 不支持静态类型检查(即编译类型的类型检查)，如果你想检查一个 Python 变量或对象是否是一个字符串；我们需要使用某些方法。
让我们了解一下检查一个字符串类型对象的一些方法。
1.使用 isinstance()方法
isinstance (object，type)方法检查object是否属于type，如果该条件成立，则返回 True ，否则返回 False 。
常见的类型有: int ， str ， list ， object 等。
由于我们要检查str类型，我们将使用isinstance(object, str)并检查它是否是True。
让我们通过一个例子来理解这一点。
a = 123
b = 'Hello'
print('Is a an instance of str?', isinstance(a, str))
print('Is b an instance of str?', isinstance(b, str))
输出
Is a an instance of str? False
Is b an instance of str? True
2.使用类型(对象)方法
这类似于isinstance()方法，但是它显式地返回对象的类型。
让我们用它来检查返回的类型是否是str。
示例:
a = 123
b = 'Hello'
print('type(a) =', type(a))
print('type(b) =', type(b))
print('Is a of type string?', type(a) == str)
print('Is b of type string?', type(b) == str)
输出
type(a) = <class 'int'>
type(b) = <class 'str'>
Is a of type string? False
Is b of type string? True
检查函数参数是否为字符串
我们可以应用上述任何一种方法在任何函数中引入“检查”条件，这允许我们仅在输入是字符串时才执行函数的主体。
让我们用一个简单的例子来理解这一点。
a = 123
b = 'Hello'
def capitalize_name(inp):
# We can also use "if isinstance(inp, str)"
if type(inp) != str:
print('Input must be a string')
else:
print(inp.upper())
capitalize_name(a)
capitalize_name(b)
输出
Input must be a string
HELLO
我们的函数现在在进入主体之前，明确地检查参数是否是一个字符串。由于 Python 的动态类型检查，这些类型检查有可能避免不必要的运行时错误。
我们没有从函数中抛出任何错误。但是，在实际编程中，大多数函数参数类型验证都会抛出TypeError异常。
结论
在本文中，我们学习了如何使用 Python 的isinstance()、type()方法并检查输入是否是字符串。我们还将此应用于一个函数，只接受字符串形式的参数。
现在，在运行时可能会导致更少的错误，这种格式对于一个好的 Python 程序来说是非常必要的。希望这篇文章对你有用！
参考
- 关于变量类型检查的 JournalDev 文章
Python chr()和 ord()
原文：https://www.askpython.com/python/built-in-methods/python-chr-and-ord-methods
Python 的内置函数 chr() 用于将整数转换为字符，而函数 ord() 用于进行相反的操作，即将字符转换为整数。
让我们快速浏览一下这两个函数，并了解如何使用它们。
chr()函数
句法
它接受一个整数i并将其转换成一个字符c，因此它返回一个字符串。
格式:
c = chr(i)
这里有一个例子来说明这一点:
# Convert integer 65 to ASCII Character ('A')
y = chr(65)
print(type(y), y)
# Print A-Z
for i in range(65, 65+25):
print(chr(i), end = " , ")
输出
<class 'str'> A
A , B , C , D , E , F , G , H , I , J , K , L , M , N , O , P , Q , R , S , T , U , V , W , X , Y , Z
该参数的有效范围是从 0 到 1，114，111(十六进制的 0x10FFFF)。如果整数 i 在该范围之外，则 ValueError 将被提升。
让我们用一些例子来验证这一点
print(chr(-1))
这将引发一个ValueError。
ValueError: chr() arg not in range(0x110000)
start = 0
end = 1114111
try:
for i in range(start, end+2):
a = chr(i)
except ValueError:
print("ValueError for i =", i)
输出
ValueError for i = 1114112
order()函数
ord() 函数接受单个 Unicode 字符的字符串参数，并返回其整数 Unicode 码位值。它与chr()相反。
句法
这采用单个 Unicode 字符(长度为 1 的字符串)并返回一个整数，因此格式为:
i = ord(c)
为了验证它是否与chr()相反，让我们用一些例子来测试这个函数。
# Convert ASCII Unicode Character 'A' to 65
y = ord('A')
print(type(y), y)
alphabet_list = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
# Print 65-90
for i in alphabet_list:
print(ord(i), end = " , ")
输出
<class 'int'> 65
65 , 66 , 67 , 68 , 69 , 70 , 71 , 72 , 73 , 74 , 75 , 76 , 77 , 78 , 79 , 80 , 81 , 82 , 83 , 84 , 85 , 86 , 87 , 88 , 89 , 90 ,
如果输入字符串的长度不等于 1，就会引发一个TypeError。
y = ord('Hi')
输出
TypeError: ord() expected a character, but string of length 2 found
传递十六进制数据
我们还可以将其他常用基数表示的整数传递给 chr() 和 ord() 等十六进制格式(基数 16)。
在 Python 中，我们可以通过在整数前面加上0x来使用十六进制，只要它在整数值的 32/64 位范围内。
>>> print(hex(18))
'0x12'
>>> print(chr(0x12))
'\x12'
>>> print(ord('\x12'))
18
>>> print(int('\x12'))
18
我们将十六进制格式的整数 18 传递给chr()，后者返回十六进制的0x12。我们将它传递给chr()，并使用ord()来取回我们的整数。
注意，我们也可以使用int()获得整数，因为单个字符串也是一个字符串，它可以是上述函数的有效参数。
结论
在本文中，我们学习了如何使用chr()和ord()将整数转换成字符，反之亦然。
参考
- 用于 chr()的 Python 文档
- Python 文档 for ord()
- JournalDev 文章
Python 类构造函数–Python _ _ init _ _()函数
原文：https://www.askpython.com/python/oops/python-class-constructor-init-function
Python 类构造函数的作用是初始化类的实例。Python init()是 Python 中类的构造函数。
Python init()函数语法
init()函数的语法是:
def __init__(self, [arguments])
- def 关键字用于定义它，因为它是一个函数。
- 第一个参数引用当前对象。它将实例绑定到 init()方法。通常按照命名约定命名为“self”。你可以在 Python 自变量了解更多。
- init()方法参数是可选的。我们可以用任意数量的参数定义一个构造函数。
Python 类构造函数示例
让我们看一些不同场景下的构造函数的例子。
1.没有构造函数的类
我们可以创建一个没有任何构造函数定义的类。在这种情况下，调用超类构造函数来初始化该类的实例。object类是 Python 中所有类的基础。
class Data:
pass
d = Data()
print(type(d)) # <class '__main__.Data'>
下面是另一个例子，确认超类构造函数被调用来初始化子类的实例。
class BaseData:
def __init__(self, i):
print(f'BaseData Constructor with argument {i}')
self.id = i
class Data(BaseData):
pass
d = Data(10)
print(type(d))
输出:
BaseData Constructor with argument 10
<class '__main__.Data'>
2.不带参数的简单构造函数
我们可以创建一个不带任何参数的构造函数。这对于记录日志很有用，比如记录类的实例数。
class Data1:
count = 0
def __init__(self):
print('Data1 Constructor')
Data1.count += 1
d1 = Data1()
d2 = Data1()
print("Data1 Object Count =", Data1.count)
输出:
Data1 Constructor
Data1 Constructor
Data1 Object Count = 2
3.带参数的类构造函数
大多数时候，你会发现带有一些参数的构造函数。这些参数通常用于初始化实例变量。
class Data2:
def __init__(self, i, n):
print('Data2 Constructor')
self.id = i
self.name = n
d2 = Data2(10, 'Secret')
print(f'Data ID is {d2.id} and Name is {d2.name}')
输出:
Data2 Constructor
Data ID is 10 and Name is Secret
4.具有继承的类构造函数
class Person:
def __init__(self, n):
print('Person Constructor')
self.name = n
class Employee(Person):
def __init__(self, i, n):
print('Employee Constructor')
super().__init__(n) # same as Person.__init__(self, n)
self.id = i
emp = Employee(99, 'Pankaj')
print(f'Employee ID is {emp.id} and Name is {emp.name}')
输出:
Employee Constructor
Person Constructor
Employee ID is 99 and Name is Pankaj
- 调用超类构造函数是我们的责任。
- 我们可以使用 super()函数来调用超类构造函数。
- 我们也可以使用超类名来调用它的 init()方法。
5.具有多级继承的构造函数链接
class A:
def __init__(self, a):
print('A Constructor')
self.var_a = a
class B(A):
def __init__(self, a, b):
super().__init__(a)
print('B Constructor')
self.var_b = b
class C(B):
def __init__(self, a, b, c):
super().__init__(a, b)
print('C Constructor')
self.var_c = c
c_obj = C(1, 2, 3)
print(f'c_obj var_a={c_obj.var_a}, var_b={c_obj.var_b}, var_c={c_obj.var_c}')
输出:
A Constructor
B Constructor
C Constructor
c_obj var_a=1, var_b=2, var_c=3
6.多重继承构造函数
在多重继承的情况下，我们不能使用 super()来访问所有的超类。更好的方法是使用超类的类名调用它们的构造函数。
class A1:
def __init__(self, a1):
print('A1 Constructor')
self.var_a1 = a1
class B1:
def __init__(self, b1):
print('B1 Constructor')
self.var_b1 = b1
class C1(A1, B1):
def __init__(self, a1, b1, c1):
print('C1 Constructor')
A1.__init__(self, a1)
B1.__init__(self, b1)
self.var_c1 = c1
c_obj = C1(1, 2, 3)
print(f'c_obj var_a={c_obj.var_a1}, var_b={c_obj.var_b1}, var_c={c_obj.var_c1}')
输出:
C1 Constructor
A1 Constructor
B1 Constructor
c_obj var_a=1, var_b=2, var_c=3
Python 不支持多个构造函数
Python 不支持多个构造函数，不像 Java 等其他流行的面向对象编程语言。
我们可以定义多个 init()方法，但最后一个将覆盖前面的定义。
class D:
def __init__(self, x):
print(f'Constructor 1 with argument {x}')
# this will overwrite the above constructor definition
def __init__(self, x, y):
print(f'Constructor 1 with arguments {x}, {y}')
d1 = D(10, 20) # Constructor 1 with arguments 10, 20
Python init()函数能返回什么吗？
如果我们试图从 init()函数返回一个非 None 值，它将引发 TypeError。
class Data:
def __init__(self, i):
self.id = i
return True
d = Data(10)
输出:
TypeError: __init__() should return None, not 'bool'
如果我们将 return 语句改为 return None ，那么代码将无一例外地工作。
参考资料:
Python 类和对象
原文：https://www.askpython.com/python/oops/python-classes-objects
Python 是一种面向对象的编程语言。类和对象是在 Python 中实现面向对象编程模型的核心
什么是 Python 类？
类是创建对象的蓝图。这些类可以有属性和函数。
例如，我们可以有一个类 Employee，其属性为employee_id，函数为work()。我们可以从这个类创建不同的 Employee 对象。
这些属性通常位于对象级别，因此对于不同的 employee 对象，employee_id 可以不同。
这些函数位于对象级或类级。这些函数主要处理对象属性并执行特定的任务。
如何用 Python 创建一个类
我们可以使用类保留关键字创建一个 Python 类。让我们看一个没有任何属性或函数的空类。
class Employee:
pass
有一个空班并没有给我们带来任何好处。所以，让我们给它添加一些类属性和函数。
class Employee:
employee_id = 0
def work(self):
print(f'{self.employee_id} is working')
如何用 Python 实例化一个类？
当我们创建一个 Python 类时，它会自动为它创建一个默认的无参数构造函数。我们可以调用这个构造函数来创建类的实例。这个实例被称为类的对象。
emp = Employee()
print(type(emp))
emp.work()
输出:
<class '__main__.Employee'>
0 is working
内置的 type()函数返回对象的类型。它用于获取对象的类信息。
Python 中的基类是什么？
你想过 Employee 类是如何自动获得无参数构造函数的吗？
这是因为 Python 支持继承，Python 中的每个类都是从基类“object”自动继承的。当我们没有为类定义构造函数时,“object”类构造函数用于创建类的实例。
为类定义构造函数
如果您注意到 Employee 类的实现，就无法设置 employee_id 值。我们可以定义一个单独的方法来设置 employee_id 值。但是，它是 Employee 对象的强制属性。设置这些属性的最佳位置是通过构造函数。
Python 构造函数是一个特殊的函数，当我们创建类的实例时会调用它。这个函数名总是 init 并且可以有任意数量的参数。第一个参数总是对象本身，通常命名为自身变量。
让我们继续为 Employee 类创建一个构造函数。我们希望 caller 程序将 employee_id 值作为参数传递。
class Employee:
def __init__(self, i):
self.employee_id = i
def work(self):
print(f'{self.employee_id} is working')
emp = Employee(100)
emp.work()
输出 : 100 is working
注意:创建 Employee 对象的早期代码现在不能工作了，因为 Employee 构造函数需要一个参数。如果我们调用Employee()，它将引发类型错误:init()缺少 1 个必需的位置参数:“id”。
Python 中可以有多个构造函数吗？
与其他流行的面向对象编程语言不同，Python 不支持方法重载和构造函数重载。
但是，如果我们在类中定义多个构造函数，它不会抛出任何错误。最后一个构造函数将覆盖先前定义的构造函数定义。我们来看一个例子。
class Employee:
def __init__(self, id):
self.employee_id = id
# this will overwrite earlier defined constructor
def __init__(self, id, n):
self.employee_id = id
self.emp_name = n
def work(self):
print(f'{self.emp_name}[{self.employee_id}] is working')
emp = Employee(100, 'Pankaj')
emp.work()
emp = Employee(100) # will raise Error
emp.work()
输出:
Pankaj[100] is working
Traceback (most recent call last):
File "/Users/pankaj/Documents/PycharmProjects/AskPython/hello-world/class_examples.py", line 19, in <module>
emp = Employee(100)
TypeError: __init__() missing 1 required positional argument: 'n'
类变量与实例变量
当一个变量在类级别定义时，它被称为类变量。当变量在构造函数中定义时，它被称为实例变量。
类变量在类的所有实例之间共享，而实例变量是实例独有的。所以，理解什么时候使用类变量，什么时候使用实例变量是非常重要的。
在前面的例子中，employee_id 属性对于 employee 实例是唯一的，所以最好将其作为实例变量并在构造函数中定义。
假设我们想要跟踪创建的雇员实例的数量和分配的雇员 id。在这种情况下，我们可以使用类变量来存储这些数据并由实例进行更新。
class Employee:
count = 0
ids_list = []
def __init__(self, i):
self.id = i
Employee.count += 1
self.ids_list.append(i)
for x in range(0, 10):
emp = Employee(x)
print(f'Number of employees created = {Employee.count}')
print(f'List of employee ids allocated = {Employee.ids_list}')
emp = Employee(1000)
print(f'List of employee ids allocated = {emp.ids_list}')
输出:
Python Class Object Example
Number of employees created = 10
List of employee ids allocated = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
List of employee ids allocated = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 1000]
注意:我们可以通过类名和实例变量来访问类变量。
参考资料:
Python 类方法()
Python classmethod()是 Python 标准库的内置函数！
Python 中有三种类型的方法:
- 实例方法
- 类方法
- 静态方法
在本文中，我们将重点讨论 Python 的 class 方法。所以让我们开始吧。
什么是 Python classmethod()？
一个 Python classmethod() 可以被一个类调用，也可以被一个对象调用。为给定函数返回类方法的方法称为 class method()。
它是所有对象共享的方法。它是 Python 编程语言中的内置函数。
classmethod()只接受一个名为 function 的参数。因此，python 中 classmethod()方法的语法如下:
Syntax : classmethod(function)
使用 Python 类方法()
让我们在这里看一个 Python classmethod()函数的例子。在下面的例子中，我们使用 classmethod()函数打印在类中声明的学生的分数，而不是将变量传递给函数。
class Student:
marks = 50
def printMarks(cls):
print("Marks obtained by the Student is:",cls.marks)
Student.printMarks=classmethod(Student.printMarks)
Student.printMarks()
输出:
============= RESTART: C:/Users/Admin/Student.py =============
Marks obtained by the Student is: 50
在上面的代码中，我们观察到:
- 我们有一个班级学生，其成员变量标记为。
- 我们有一个函数 printMarks ，它接受参数 cls 。
- 我们已经传递了总是附加到一个类的 classmethod()。
- 这里，第一个参数总是类本身，这就是为什么我们在定义类时使用' cls' 。
- 然后我们将方法 Student.printMarks 作为参数传递给 classmethod( ) 。最后的 printMarks 被调用，它打印类变量的标记。
使用 Decorator @ class 方法
使用 classmethod()函数的另一种方法是使用 @classmethod 装饰器。
通过使用 decorator 方法，我们可以调用类名而不是对象。它可以应用于该类的任何方法。
@classmethod Decorator 方法的语法如下:它接受一个参数和多个实参。
class c(object):
@classmethod
def function(cls, argument1, argument2, ...):
/*remaining code*/
让我们看看如何使用 decoartor classmethod 运行一个类似的示例，而不是像前面的示例那样使用函数。
class Student:
course = 'Python'
@classmethod
def printCourse(cls):
print("Course opted by the Student is:",cls.course)
Student.printCourse()
输出:
============= RESTART: C:/Users/Admin/Student.py =============
Course opted by the Student is: Python
在上面提到的例子中， @classmethod 装饰器已经应用于 printCourse( ) 方法。它有一个参数 cls 。然后，该方法自动选取该类的成员变量，而不是要求用户将一个成员变量传递给函数。
结论
简单来说，这是关于使用 Python classmethod()函数的两种方法。敬请关注更多关于 Python 的文章！
Python 集合
原文：https://www.askpython.com/python-modules/python-collections
集合用于将一组相似的数据项表示为用于分组和管理相关对象的单个单元。
它们包含用于有效操作和存储数据的数据结构。 Python 集合模块提供了很多数据结构来实现不同类型的集合。
以下是我们将在本文中探讨的集合类型:
OrderedDictdefaultdictcounternamedtupledequeChainMap
1.1.有序直接
Python OrderedDict通过字典中的键值对来维护元素的插入顺序。如果用户再次尝试插入一个键，它会覆盖该键的上一个值。在 OrderedDict 中，严格保持项目的顺序，即作为输出的元素的顺序与元素的插入顺序相同。
举例:
OrderedDict
输出:
Output-OrderedDict
1.2 .DefaultDict(预设字典)
DefaultDict在 python 中是集合类中的容器。它类似于字典容器，唯一的区别是如果没有设置键，默认字典将有一个默认值。因此，我们可以对属于同一个键的项目进行分组。
举例:
DefaultDict
输出:
Output DefaultDict
键–Safa被使用了两次，与它相关的值在打印时被收集在一起。
1.3.计数器
Counter集合记录了插入到集合中的所有元素以及键。它是 Dictionary 的子类，用于跟踪项目。
举例:
Counter
输出:
Output Counter
1.4.命名元组
Namedtuple允许用户为元素提供名称/标签。因此，可以通过索引值或名称来访问元素。
因此，它增强了代码的可读性，并且是不可变的。
举例:
让我们用 Python 创建一个元组。
Tuple
输出:
Output-Tuple
为了更好的可读性和理解，我们可以通过为元组中的条目指定名称来创建命名元组。
举例:
NamedTuple
输出:
Output-NamedTuple
1.5.双端队列
Deque是一个双端队列，允许用户从两端添加和删除元素。它增加和增强了堆栈或队列的能力和功能。
举例:
Deque
输出:
Output Deque
1.6.链式地图
ChainMap返回字典链/列表，并将其表示为单个视图映射。当不同的字典中有几个键值对时，ChainMap 工作得很好，在这种情况下，ChainMap 将它们表示为所有字典的单个列表/结构。
举例:
from collections import ChainMap
x = { 1: 'Engineering' , 2: 'Medical'}
y = {3: 'Analytics' , 4: 'Python'}
z = ChainMap(x,y)
print(z)
输出:
Output-ChainMap
参考
- Python 集合
- Python 集合文档
Python 命令行参数–3 种读取/解析方法
原文：https://www.askpython.com/python/python-command-line-arguments
Python 命令行参数是在执行脚本时提供给脚本的参数。命令行参数用于向程序提供特定的输入。
Python 命令行参数的好处是什么？
Python 命令行参数有助于我们保持程序的通用性。例如，我们可以编写一个程序来处理 CSV 文件。如果我们从命令行传递 CSV 文件名，那么我们的程序将适用于任何 CSV 文件。这将使我们的程序松散耦合，易于维护。
命令行参数的另一个好处是随之而来的额外的安全性。假设我们有一个程序将数据保存到数据库中。如果我们将数据库凭证存储在脚本或某个配置文件中，任何有权访问这些文件的人都可以访问和执行它。但是，如果用户名/密码是作为命令行参数提供的，那么它就不会出现在文件系统中，我们的程序就更加安全。
如何在 Python 中传递命令行参数？
如果从终端运行 python 脚本，只需在脚本名称后传递参数。参数用空白字符分隔。
$ python script.py arg1 arg2 ... argN
在 PyCharm 中传递命令行参数
PyCharm 是 Python 编程最流行的 IDE。如果您想将命令行参数传递给 python 程序，请转到“运行>编辑配置”,设置参数值并保存。
Python Command Line Arguments PyCharm
如何在 Python 脚本中读取命令行参数？
Python 脚本中有三个流行的模块来读取和解析命令行参数。
- sys.argv
- 停了
- 抱怨吗
1.使用 sys 模块读取 Python 命令行参数
命令行参数存储在 sys 模块argv变量中，该变量是字符串的列表。我们可以从这个列表中读取命令行参数，并在我们的程序中使用它。
注意，脚本名也是sys.argv变量中命令行参数的一部分。
import sys
if len(sys.argv) != 2:
raise ValueError('Please provide email-id to send the email.')
print(f'Script Name is {sys.argv[0]}')
email = sys.argv[1]
print(f'Sending test email to {email}')
输出:
$ python3.7 command-line-args.py [email protected]
Script Name is command-line-args.py
Sending test email to [email protected]
$ python3.7 command-line-args.py
Traceback (most recent call last):
File "command-line-args.py", line 4, in <module>
raise ValueError('Please provide email-id to send the email.')
ValueError: Please provide email-id to send the email.
$
2.使用 getopt 模块解析命令行参数
Python getopt 模块的工作方式与 Unix getopt()函数类似。当您希望脚本接受选项及其值时，该模块很有帮助，类似于许多 Unix 命令。
该模块与 sys.argv 协同工作，解析命令行参数，并提取一列元组中的选项值。
import getopt
import sys
argv = sys.argv[1:]
opts, args = getopt.getopt(argv, 'x:y:')
# list of options tuple (opt, value)
print(f'Options Tuple is {opts}')
# list of remaining command-line arguments
print(f'Additional Command-line arguments list is {args}')
输出:
$ python3.7 command-line-args.py -x 1 -y 2 A B
Options Tuple is [('-x', '1'), ('-y', '2')]
Additional Command-line arguments list is ['A', 'B']
$
3.使用 argparse 模块解析命令行参数
我们还可以使用 Python argparse 模块来解析命令行参数。argparse 模块有很多选项。
- 位置参数
- 帮助消息
- 参数的默认值
- 指定参数的数据类型等等。
import argparse
# create parser
parser = argparse.ArgumentParser()
# add arguments to the parser
parser.add_argument("language")
parser.add_argument("name")
# parse the arguments
args = parser.parse_args()
# get the arguments value
if args.language == 'Python':
print("I love Python too")
else:
print("Learn Python, you will like it")
print(f'Hello {args.name}, this was a simple introduction to argparse module')
输出:
$ python3.7 command-line-args.py Python David
I love Python too
Hello David, this was a simple introduction to argparse module
$
$ python3.7 command-line-args.py Java Lisa
Learn Python, you will like it
Hello Lisa, this was a simple introduction to argparse module
$
$ python3.7 command-line-args.py -h
usage: command-line-args.py [-h] language name
positional arguments:
language
name
optional arguments:
-h, --help show this help message and exit
$
注意，帮助消息是由 argparse 模块自动生成的。
结论
如果您的脚本需要简单的命令行参数，您可以使用 sys.argv。但是，如果您的程序接受大量的位置参数、默认参数值、帮助消息等，那么您应该使用 argparse 模块。getopt 模块也可以工作，但是它很混乱，很难理解。
参考资料:
- 【T0 缝合. argv】t1
- getopt 模块
- argparse 模块
Python 注释–多行注释，最佳实践
注释是任何程序不可或缺的一部分。每种编程语言都提供了添加注释的方法。Python 评论系统非常简单。在本指南中，我们将学习 Python 中的注释。它们为开发人员提供了关于代码的有用信息。
如何用 Python 写注释？
- Python 注释以#字符开始，延伸到行尾。
- 我们可以从行首开始注释，在一些空格或代码之后。
- 如果散列字符出现在字符串中，它就是字符串的一部分。
Python 注释示例
我们可以为变量、函数和类添加注释。它们用于提供代码部分的预期用途。让我们看一些 Python 中注释的例子。
1.变量的注释
name = "Pankaj" # employee name
id = 100 # employee id
data = "#123" # this is comment, data contains # and that is not part of the comment.
2.函数的注释
# This function adds the two numbers
def add(x, y):
return x+y
Python Comments
3.课程注释
# This class provides utility functions to work with Strings
class StringUtils:
def reverse(s):
return ''.join(reversed(s))
Python 注释块或多行注释
有时在一行中包含注释是不可行的。在这种情况下，我们可以创建一个注释块，或者将注释分成多行。我们必须在每一行前面加上#来写多行注释。
# This class provides utility functions to work with Strings
# 1\. reverse(s): returns the reverse of the input string
# 2\. print(s): prints the string representation of the input object
class StringUtils:
def reverse(s):
return ''.join(reversed(s))
def print(s):
print(s)
Python Multiline Comment
使用 Python Docstring 作为多行注释
Python 文档字符串(Docstring)用于为函数、类和模块提供文档。它们被定义在一对三重双引号(" ")之间。它们必须定义在函数或类声明的正下方。
让我们快速看一下 Python 文档字符串的一些例子。
def foo():
"""The foo() function needs to be implemented.
Currently, this function does nothing."""
pass
class Data:
""" This class is used to hold Data objects information."""
我们可以使用__doc__属性访问实体的 docstring。
print(foo.__doc__)
print(Data.__doc__)
Python Docstrings
使用 Docstring 指定长的多行注释是个好主意吗？
Python docstrings 的目的是提供文档。有时你会注意到它被误用来提供长评论。但是，这不是推荐的方法。如果您希望注释扩展到多行，只需在每一行前面加上散列字符。
Python 多行字符串作为多行注释
我们也可以使用多行字符串作为多行注释。根据这个 圭多的推文 ，他们没有生成代码。
'''
This function read employees data from the database
emp_id: employee id, should be int
returns employee object.
'''
def read_emp_from_db(emp_id):
i = int(emp_id)
'''code to read emp data
using the employee unique id number'''
pass
但是，这可能会导致缩进的问题。同样令人困惑的是，为什么一个字符串出现在代码中却没有任何用处。因此，最好坚持使用散列字符的常规多行注释。
Python 注释最佳实践
- 总是提供有意义的注释来指定实体的用途。
- 最好把长评论拆成多行。
- 评论里不要无礼。
- 保持评论的重点。没人愿意在代码评论里看小说。
- 避免不提供任何有用信息的无用评论。下面是一些无用评论的例子。
# count variable
count = 10
# foo() function
def foo():
pass
- 有时候评论是不必要的。实体本身有合适的名称就足够了。让我们看一个这个场景的例子。
# This function add two numbers
def foo(x, y):
return x + y
# Better to have function defined as below. There is no use of comments.
def add_two_numbers(x, y):
return x + y
- 建立一个评论系统总是一个好主意。当在一个组织中与许多团队成员和多个项目一起工作时，建议使用注释策略。例如，您可以像这样定义注释策略:
# {Object Type} - {Usage}
# Data Object - stores the Data fetched from the database
data_obj = Data()
# {Function Short Description}
# {Input Arguments and their types}
# {Return object details}
# {Exception Details}
# This function adds all the elements in the sequence or iterable
# numbers: sequence or iterable, all the elements must be numbers
# Returns the sum of all the numbers in the sequence or iterable
# Throws ArithmeticError if any of the element is not a number
def add_numbers(numbers):
sum_numbers = 0
for num in numbers:
sum_numbers += num
return sum_numbers
注释掉块的 Python 注释快捷方式
如果您正在使用 Python IDE 或 Jupyter Notebook，您可以使用快捷方式注释掉代码块。
- macOS 评论快捷键——选择你想要评论的行，按 Command+/ ，它会自动在每行的开头加上#变成评论块。如果是空行，它会在行首加#你可以写注释。
- Windows 和 Linux 注释快捷键——使用 Ctrl+/ 作为将代码块变成注释的快捷键。
摘要
- Python 评论系统很简单，总是从#开始。
- Python docstring 用于文档。您不应该将它误用为多行注释。
- 对于多行注释，每一行都以散列字符开始。
- 遵循向计划添加注释的最佳实践。
- 当与许多团队成员一起工作时，有一个合适的评论策略总是一个好主意。
下一步是什么？
我们在本教程中引用了很多主题，你应该阅读下面的教程来进一步了解它们。
参考资料:
Python 比较运算符
原文：https://www.askpython.com/python/python-comparison-operators
Python 中的运算符用于执行或操作某些任务。Python 比较运算符也称为关系运算符，分别用于比较两个值和应用条件。
这里可以有两种可能的输出，或者是True或者是False。
Python Comparison Operators Flowchart
Python 中比较运算符的类型
有 6 种类型的比较运算符:
- 小于(< )
- 大于(> )
- 等于(== )
- 不等于(！= )
- 小于或等于(< = )
- 大于或等于(> = )
Python Comparison Operators
1.小于( < )
它用于检查与其他数字或变量相比较小的值或包含较小值的变量。如果提供的数字或变量小于给定的数字或变量。然后，小于运算符将返回 True。否则，它将返回 false。
a = 10
if (a < 10)
print("Yes")
else
print("No")
输出:否
2.大于( > )
它用于检查与其他数字或变量相比更大的值或包含更大值的变量。如果提供的数字或变量大于给定的数字或变量。然后，大于运算符将返回 True。否则，它将返回 false。
a = 10
if (a > 10)
print("True")
else
print("False")
输出:假
3.等于(==)
该运算符检查值是否相等。如果输入的值和给定的值相等，那么它将返回 True，否则返回 False。
a = 10
b = 20
if (a == b)
print("True")
else
print("False")
输出:假
4.不等于(！=或<>
它用 != 表示，这与等于运算符正好相反。如果运算符两边的值不相等，则返回 True。
print(3!=3.0)
输出:假
5.小于或等于(< =)
仅当左边的值小于或等于右边的值时，该运算符的计算结果为True。
a = 15
b = 5
if(b <= a)
print("b is either less than or equal to a")
输出 : b 小于或等于 a
6.大于或等于(> =)
仅当左边的值大于或等于右边的值时，该运算符的计算结果为True。
a = 5
b = 15
if(b >= a)
print("b is either greater than or equal to a")
输出 : b 大于或等于 a
Python 比较运算符示例
a = 10
b = 5
c = 0
if ( a == b ):
print "a is equal to b"
else:
print "a is not equal to b"
if ( a != b ):
print "a is not equal to b"
else:
print "a is equal to b"
if ( a <> b ):
print "a is not equal to b"
else:
print "a is equal to b"
if ( a < b ):
print "a is less than b"
else:
print "a is not less than b"
if ( a > b ):
print "a is greater than b"
else:
print "a is not greater than b"
a = 6;
b = 15;
if ( a <= b ):
print "a is either less than or equal to b"
else:
print "a is neither less than nor equal to b"
if ( b >= a ):
print "b is either greater than or equal to b"
else:
print "b is neither greater than nor equal to b"
输出:
a is not equal to b
a is not equal to b
a is not equal to b
a is not less than b
a is greater than b
a is either less than or equal to b
b is either greater than or equal to b
参考
如何使用 Python complex()方法
原文：https://www.askpython.com/python/built-in-methods/python-complex-method
Python complex() 方法用于从其他原始数据类型创建一个复数。当您希望快速执行复杂的算术和转换时，这非常有用。
让我们来看看如何使用这个方法。
Python 复合体的语法()
该函数返回一个包含实部和虚部的复数。复数的数据类型是class complex。
因此，函数调用语法是:
class complex([real[, imag]])
复数的形式为:
complex_number = real + imag*j
这里，j是虚数(sqrt(-1))
Python complex()方法将返回这个复数。
让我们看一些例子，来熟悉这个方法。
你可能认为我们可以只用整数和浮点数来构造复数，但事实并非如此！
我们也可以用一个字符串，十六进制，二进制，甚至是另一个复数来构造它！
我们将看一些例子来说明这一点。
使用 Python complex()方法
调用不带任何参数的 complex()
我们可以调用这个方法而不传递任何参数给它。这将返回零复数0j。
a = complex()
print(type(a))
print(a)
输出
<class 'complex'>
0j
使用数字参数调用 Python complex()
这将构造所需的形式为a + bj的复数，其中a和b是数字参数。
a = complex(1, 2)
print(a)
b = complex(1, 1.5)
print(b)
c = complex(-1.5, 3.414)
print(c)
输出
(1+2j)
(1+1.5j)
(-1.5+3.414j)
使用十六进制/二进制参数调用 complex()
我们也可以直接把十六进制或二进制数传入这个，而不用把它转换成整数。
a = complex(0xFF) # hexadecimal
print(a)
b = complex(0b1010, -1) # binary
print(b)
输出
(255+0j)
(10-1j)
使用另一个复数调用 complex()
当使用complex()构造一个复数时，我们也可以传递另一个复数
a = 1 + 2j
b = complex(a, -4) # Construct using another complex number
print(b)
c = complex(1+2j, 1+2J)
print(c)
输出
(1-2j)
(-1+3j)
因为两个参数都是按照形式a + b*j相加的，所以在第一种情况下，结果将是:1+2j+(-4 * j)=1–2j
第二种情况，我们有(因为 j * j =-1):1+2j+(1+2j)* j =(1+2j+j–2)=-1+3j
使用字符串参数调用 Python complex()
我们也可以用它来传递 string，只要它和之间没有任何空格。该字符串只能是“a+bj”形式，即可以表示复数的字符串。
如果我们使用一个字符串，我们只能使用一个参数。
a = complex("1+2j")
print(a)
输出
(1+2j)
如果字符串包含空格或任何其他无关字符，将会引发一个ValueError异常。
b = complex("2 + 4j")
print(b)
这将引发一个ValueError，因为字符串中有空格。
类似地，如果我们传递两个参数给 Python complex()，它将引发一个TypeError异常，因为如果第一个参数是字符串，我们不允许传递多个参数。
结论
在本文中，我们学习了如何使用内置的complex()方法从不同的数据类型中构造一个复数。如果你想了解其他 Python 内置函数，请访问这里。
参考
- Python 文档关于 complex()方法
- 关于使用 complex()方法的 JournalDev 文章
Python 复数
复数是任何形式的数字a + bj，其中a和b是实数，j*j = -1。
在 Python 中，有多种方法可以创建这样一个复数。
在 Python 中创建复数
- 我们可以直接使用语法
a + bj来创建一个复数。
>>> a = 4 + 3j
>>> print(a)
(4+3j)
>>> print(type(a))
<class 'complex'>
- 我们也可以使用
complex类来创建一个复数
>>> a = complex(4, 3)
>>> print(type(a))
<class 'complex'>
>>> print(a)
(4+3j)
复数中的实部和虚部
每个复数(a + bj)都有一个实部(a)，和一个虚部(b)。
要得到实部，用number.real，要得到虚部，用number.imag。
>>> a
(4+3j)
>>> a.real
4.0
>>> a.imag
3.0
复数的共轭
复数a + bj的共轭定义为a - bj。我们也可以用number.conjugate()方法得到共轭。
>>> a
(4 + 3j)
>>> a.conjugate()
(4-3j)
复数上的算术运算
与实数类似，复数也可以加、减、乘、除。让我们看看如何用 Python 来做这件事。
a = 1 + 2j
b = 2 + 4j
print('Addition =', a + b)
print('Subtraction =', a - b)
print('Multiplication =', a * b)
print('Division =', a / b)
输出:
Addition = (3+6j)
Subtraction = (-1-2j)
Multiplication = (-6+8j)
Division = (2+0j)
注:与实数不同，我们不能比较两个复数。我们只能分别比较它们的实部和虚部，因为它们是实数。下面的片段证明了这一点。
>>> a
(4+3j)
>>> b
(4+6j)
>>> a < b
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'complex' and 'complex'
复数的相位(自变量)
我们可以将一个复数表示为由两个分量组成的向量，这两个分量位于由轴real和轴imaginary组成的平面上。因此，向量的两个分量是它的实部和虚部。
Complex Number Vector
向量与实轴之间的角度定义为复数的argument或phase。
它的正式定义是:
【相位(数字)=反正切(虚部/实部)
其中反正切函数是反正切数学函数。
在 Python 中，我们可以使用复数的cmath模块来获得复数的相位。我们也可以使用math.arctan函数，从它的数学定义中得到相位。
import cmath
import math
num = 4 + 3j
# Using cmath module
p = cmath.phase(num)
print('cmath Module:', p)
# Using math module
p = math.atan(num.imag/num.real)
print('Math Module:', p)
输出:
cmath Module: 0.6435011087932844
Math Module: 0.6435011087932844
注意，这个函数返回的是radians中的相角，所以如果我们需要转换到degrees，可以使用另一个类似numpy的库。
import cmath
import numpy as np
num = 4 + 3j
# Using cmath module
p = cmath.phase(num)
print('cmath Module in Radians:', p)
print('Phase in Degrees:', np.degrees(p))
输出:
cmath Module in Radians: 0.6435011087932844
Phase in Degrees: 36.86989764584402
直角坐标和极坐标
使用cmath.rect()和cmath.polar()功能可以将复数写成直角坐标或极坐标格式。
>>> import cmath
>>> a = 3 + 4j
>>> polar_coordinates = cmath.polar(a)
>>> print(polar_coordinates)
(5.0, 0.9272952180016122)
>>> modulus = abs(a)
>>> phase = cmath.phase(a)
>>> rect_coordinates = cmath.rect(modulus, phase)
>>> print(rect_coordinates)
(3.0000000000000004+3.9999999999999996j)
cmath 模块中的常数
cmath 模块中有一些特殊的常量。下面列出了其中的一些。
print('π =', cmath.pi)
print('e =', cmath.e)
print('tau =', cmath.tau)
print('Positive infinity =', cmath.inf)
print('Positive Complex infinity =', cmath.infj)
print('NaN =', cmath.nan)
print('NaN Complex =', cmath.nanj)
输出:
π = 3.141592653589793
e = 2.718281828459045
tau = 6.283185307179586
Positive infinity = inf
Positive Complex infinity = infj
NaN = nan
NaN Complex = nanj
三角函数
在cmath模块中也可以使用复数的三角函数。
import cmath
a = 3 + 4j
print('Sine:', cmath.sin(a))
print('Cosine:', cmath.cos(a))
print('Tangent:', cmath.tan(a))
print('ArcSin:', cmath.asin(a))
print('ArcCosine:', cmath.acos(a))
print('ArcTan:', cmath.atan(a))
输出:
Sine: (3.853738037919377-27.016813258003936j)
Cosine: (-27.034945603074224-3.8511533348117775j)
Tangent: (-0.0001873462046294784+0.999355987381473j)
ArcSin: (0.6339838656391766+2.305509031243477j)
ArcCosine: (0.9368124611557198-2.305509031243477j)
ArcTan: (1.4483069952314644+0.15899719167999918j)
双曲函数
与三角函数类似，复数的双曲函数也可在cmath模块中使用。
import cmath
a = 3 + 4j
print('Hyperbolic Sine:', cmath.sinh(a))
print('Hyperbolic Cosine:', cmath.cosh(a))
print('Hyperbolic Tangent:', cmath.tanh(a))
print('Inverse Hyperbolic Sine:', cmath.asinh(a))
print('Inverse Hyperbolic Cosine:', cmath.acosh(a))
print('Inverse Hyperbolic Tangent:', cmath.atanh(a))
输出:
Hyperbolic Sine: (-6.5481200409110025-7.61923172032141j)
Hyperbolic Cosine: (-6.580663040551157-7.581552742746545j)
Hyperbolic Tangent: (1.000709536067233+0.00490825806749606j)
Inverse Hyperbolic Sine: (2.2999140408792695+0.9176168533514787j)
Inverse Hyperbolic Cosine: (2.305509031243477+0.9368124611557198j)
Inverse Hyperbolic Tangent: (0.11750090731143388+1.4099210495965755j)
指数和对数函数
import cmath
a = 3 + 4j
print('e^c =', cmath.exp(a))
print('log2(c) =', cmath.log(a, 2))
print('log10(c) =', cmath.log10(a))
print('sqrt(c) =', cmath.sqrt(a))
输出:
e^c = (-13.128783081462158-15.200784463067954j)
log2(c) = (2.321928094887362+1.3378042124509761j)
log10(c) = (0.6989700043360187+0.4027191962733731j)
sqrt(c) = (2+1j)
杂项功能
有一些杂七杂八的函数来检查一个复数是有限的，无限的还是nan。还有一个函数检查两个复数是否接近。
>>> print(cmath.isfinite(2 + 2j))
True
>>> print(cmath.isfinite(cmath.inf + 2j))
False
>>> print(cmath.isinf(2 + 2j))
False
>>> print(cmath.isinf(cmath.inf + 2j))
True
>>> print(cmath.isinf(cmath.nan + 2j))
False
>>> print(cmath.isnan(2 + 2j))
False
>>> print(cmath.isnan(cmath.inf + 2j))
False
>>> print(cmath.isnan(cmath.nan + 2j))
True
>>> print(cmath.isclose(2+2j, 2.01+1.9j, rel_tol=0.05))
True
>>> print(cmath.isclose(2+2j, 2.01+1.9j, abs_tol=0.005))
False
结论
我们学习了复数模块，以及与cmath模块相关的各种函数。
参考
- 关于 cmath 模块的 JournaDev 文章
- 维基百科关于复数的文章
python–连接字符串和整数
原文：https://www.askpython.com/python/string/python-concatenate-string-and-int
在 Python 中，我们通常使用+操作符来执行字符串连接。然而，正如我们所知,+操作符也用于将整数或浮点数相加。
那么，如果操作数两边都有一个字符串和一个整型，会发生什么呢？
由于 Python 是一种动态类型的语言，我们在编译期间不会遇到任何错误，但是，我们会得到一个运行时错误。(更具体地说，引发了一个类型错误异常)
以下片段证明了这一点:
a = "Hello, I am in grade "
b = 12
print(a + b)
输出
Traceback (most recent call last):
File "concat.py", line 5, in <module>
print(a + b)
TypeError: can only concatenate str (not "int") to str
因此，由于我们不能直接将一个整数和一个字符串连接起来，我们需要操作操作数，以便它们可以被连接起来。有多种方法可以做到这一点。
1.使用 str()
我们可以通过str()函数将整数转换成字符串。现在，新字符串可以与另一个字符串连接起来，以给出输出；
print(a + str(b))
输出
Hello, I am in grade 12
这是将整数转换为字符串的最常见方式。
但是，我们也可以使用其他方法。
2.使用格式()
a = "Hello, I am in grade "
b = 12
print("{}{}".format(a, b))
输出和以前一样。
3.使用“%”格式说明符
a = "Hello, I am in grade "
b = 12
print("%s%s" % (a, b))
虽然我们可以指定a和b都是字符串，但是我们也可以使用 C 风格的格式说明符(%d、%s)将一个整数和一个字符串连接起来。
print('%s%d' % (a,b))
以上代码的输出保持不变。
4.使用 f 弦
我们可以在 Python 3.6 或更高版本上使用 Python f-strings 来连接一个整数和一个字符串。
a = "Hello, I am in grade "
b = 12
print(f"{a}{b}")
5.使用 print()打印字符串
如果我们想直接打印连接的字符串，我们可以使用print()来完成连接。
a = "Hello, I am in grade "
b = 12
print(a, b, sep="")
我们使用空字符串分隔符(sep)连接a和b，因为print()的默认分隔符是空格(" ")。
结论
在本文中，我们学习了如何使用各种方法将一个整数连接成一个字符串。
参考
- StackOverflow 关于 string 和 int 串联的问题
- JournalDev 关于字符串和整型连接的文章
Python continue 语句
原文：https://www.askpython.com/python/python-continue-statement
- Python continue 语句用于跳过循环当前迭代的执行。
- 我们不能在循环外使用 continue 语句，它将抛出一个错误，如"syntax error:" continue " outside loop"。
- 我们可以使用带有的 continue 语句来循环和，而循环。
- 如果 continue 语句出现在嵌套循环中，它只跳过内部循环的执行。
- “继续”是 Python 中的一个 保留关键字。
- 一般来说，continue 语句与 if 语句 一起使用，确定跳过当前循环执行的条件。
继续语句的流程图
Python continue Statement Flow Diagram
Python continue 语句语法
continue 语句的语法是:
continue
我们不能在 continue 语句中使用任何选项、标签或条件。
Python continue 语句示例
让我们看一些在 Python 中使用 continue 语句的例子。
1.继续 for 循环
假设我们有一个整数序列。如果值为 3，我们必须跳过处理。我们可以使用 for 循环和 continue 语句来实现这个场景。
t_ints = (1, 2, 3, 4, 5)
for i in t_ints:
if i == 3:
continue
print(f'Processing integer {i}')
print("Done")
输出:
Python continue Statement with for Loop
2.使用 while 循环继续语句
下面是一个在 while 循环中使用 continue 语句的简单示例。
count = 10
while count > 0:
if count % 3 == 0:
count -= 1
continue
print(f'Processing Number {count}')
count -= 1
输出:
Python continue Statement with while Loop
3.带有嵌套循环的 continue 语句
假设我们有一个元组列表要处理。元组包含整数。对于以下情况，应跳过处理。
- 如果元组的大小大于 2，则跳过元组的处理。
- 如果整数为 3，则跳过执行。
我们可以用嵌套的 for 循环来实现这个逻辑。我们将不得不使用两个 continue 语句来实现上述条件。
list_of_tuples = [(1, 2), (3, 4), (5, 6, 7)]
for t in list_of_tuples:
# don't process tuple with more than 2 elements
if len(t) > 2:
continue
for i in t:
# don't process if the tuple element value is 3
if i == 3:
continue
print(f'Processing {i}')
输出:
Python continue Statement with Nested Loop
Python 为什么不支持带标签的 continue 语句？
许多流行的编程语言都支持带标签的 continue 语句。它主要用于在嵌套循环的情况下跳过外部循环的迭代。但是，Python 不支持带标签的 continue 语句。
PEP 3136 被引发，以添加对 continue 语句的标签支持。但是，它被拒绝了，因为这是一个非常罕见的场景，它会给语言增加不必要的复杂性。我们总是可以在外部循环中编写条件来跳过当前的执行。
Python 继续 vs 中断 vs 通过
| 继续 | 破裂 | 及格 |
| continue 语句只跳过循环的当前迭代。 | break 语句终止循环。 | pass 语句用于写入空代码块。 |
| 我们只能在循环中使用 continue 语句。 | 我们只能在循环中使用 break 语句。 | 我们可以在 Python 代码的任何地方使用 pass 语句。 |
Python:将数字转换成单词
原文：https://www.askpython.com/python/python-convert-number-to-words
大家好！在本文中，我们将研究如何创建一个 Python GUI 项目，将整数值转换为单词。
让我们马上开始这个项目吧！
步骤 1:导入模块
我们首先将所有必要的模块/库导入我们的程序。
我们将导入tkinter模块来创建 GUI 窗口。与此同时，我们将导入num2words模块，以实现数字到文字的功能。
import num2words as n2w
from tkinter import *
步骤 2:创建 GUI 窗口
现在，我们将使用基本函数创建基本的 Tkinter 窗口，然后在屏幕上添加一些基本的小部件。其中一些包括标签、输入框和按钮。
如果你不知道 Tkinter widgets，看看下面提到的教程:
root = Tk()
root.title("Numbers tdo Words")
root.geometry("650x400")
num = StringVar()
title = Label(root, text="Number to Words converter",fg="Blue", font=("Arial", 20, 'bold')).place(x=220, y=10)
formats_lable = Label(root, text="Formats supported : ",fg="green", font=("Arial", 10, 'bold')).place(x=100, y=70)
pos_format_lable = Label(root, text="1\. Positives : ",fg="green", font=("Arial", 10, 'bold')).place(x=200, y=90)
neg_format_lable = Label(root, text="2\. Negatives ",fg="green", font=("Arial", 10, 'bold')).place(x=200, y=110)
float_format_lable = Label(root, text="3\. Zeros ",fg="green", font=("Arial", 10, 'bold')).place(x=200, y=130)
zero_format_lable = Label(root, text="4\. Floating points/decimals/fractions ",fg="green", font=("Arial", 10, 'bold')).place(x=200, y=150)
num_entry_lable = Label(root, text="Enter a number :",fg="Blue", font=("Arial", 15, 'bold')).place(x=50, y=200)
num_entry = Entry(root,textvariable=num,width=30).place(x=220, y=200)
btn = Button(master=root, text="calculate",fg="green",
font=("Arial", 10, 'bold'),command=num_to_words).place(x=280,y=230)
display = Label(root, text="",fg="black", font=("Arial", 10, 'bold'))
display.place(x=10, y=300)
root.mainloop()
你可能注意到在Line 21中我们有按钮的command属性。属性被设置为num_to_words，但是我们还没有声明函数 yer。
第三步:字数函数
在该函数中，我们将首先读取用户给出的输入，然后使用num2words函数将读取的值转换为单词，最后将显示值更改为数字的计算单词形式。
def num_to_words():
given_num = float(num.get())
num_in_word = n2w.num2words(given_num)
display.config(text=str(num_in_word).capitalize())
使用 Python Tkinter 将数字转换为单词
import num2words as n2w
from tkinter import *
def num_to_words():
given_num = float(num.get())
num_in_word = n2w.num2words(given_num)
display.config(text=str(num_in_word).capitalize())
root = Tk()
root.title("Numbers tdo Words")
root.geometry("650x400")
num = StringVar()
title = Label(root, text="Number to Words converter",fg="Blue", font=("Arial", 20, 'bold')).place(x=220, y=10)
formats_lable = Label(root, text="Formats supported : ",fg="green", font=("Arial", 10, 'bold')).place(x=100, y=70)
pos_format_lable = Label(root, text="1\. Positives : ",fg="green", font=("Arial", 10, 'bold')).place(x=200, y=90)
neg_format_lable = Label(root, text="2\. Negatives ",fg="green", font=("Arial", 10, 'bold')).place(x=200, y=110)
float_format_lable = Label(root, text="3\. Zeros ",fg="green", font=("Arial", 10, 'bold')).place(x=200, y=130)
zero_format_lable = Label(root, text="4\. Floating points/decimals/fractions ",fg="green", font=("Arial", 10, 'bold')).place(x=200, y=150)
num_entry_lable = Label(root, text="Enter a number :",fg="Blue", font=("Arial", 15, 'bold')).place(x=50, y=200)
num_entry = Entry(root,textvariable=num,width=30).place(x=220, y=200)
btn = Button(master=root, text="calculate",fg="green",
font=("Arial", 10, 'bold'),command=num_to_words).place(x=280,y=230)
display = Label(root, text="",fg="black", font=("Arial", 10, 'bold'))
display.place(x=10, y=300)
root.mainloop()
Initial Screen Number2Words
一些示例输出
Sample Output 1 Number 2 Words
Sample Output 2 Number 2 Words
Sample Output 3 Number 2 Words
结论
我希望你能很好地理解这个概念，并且喜欢它的输出。感谢您抽出时间阅读教程。
快乐学习！😇
另请参阅:
- Python Tkinter 项目:随机移动号码生成器
- 使用 Python Tkinter 的 YouTube 视频下载器
- t inter 闹钟——逐步指南
- Python Tkinter:简单的储蓄计算器
python–将字符串转换为列表
原文：https://www.askpython.com/python/string/python-convert-string-to-list
在 Python 中，如果您需要处理对其他 API 执行各种调用的代码库，可能会出现这样的情况:您可能会收到类似列表格式的字符串，但仍然不是显式的列表。在这种情况下，您可能希望将字符串转换为列表。
在本文中，我们将研究在 Python 上实现相同功能的一些方法。
转换列表类型字符串
一个列表类型的字符串可以是一个在列表中有左括号和右括号并且列表元素有逗号分隔字符的字符串。它和列表之间的唯一区别是左引号和右引号，这表示它是一个字符串。
示例:
str_inp = '["Hello", "from", "AskPython"]'
让我们看看如何将这些类型的字符串转换成列表。
方法 1:使用 ast 模块
Python 的ast(抽象语法树)模块是一个方便的工具，可以用来处理这样的字符串，相应地处理给定字符串的内容。
我们可以使用ast.literal_eval()来评估文字，并将其转换为列表。
import ast
str_inp = '["Hello", "from", "AskPython"]'
print(str_inp)
op = ast.literal_eval(str_inp)
print(op)
输出
'["Hello", "from", "AskPython"]'
['Hello', 'from', 'AskPython']
方法 2:使用 json 模块
Python 的json模块也为我们提供了可以操作字符串的方法。
特别是，json.loads()方法用于解码 JSON 类型的字符串并返回一个列表，我们可以相应地使用它。
import json
str_inp = '["Hello", "from", "AskPython"]'
print(str_inp)
op = json.loads(str_inp)
print(op)
输出和以前一样。
方法 3:使用 str.replace()和 str.split()
我们可以使用 Python 内置的str.replace()方法，手动迭代输入字符串。
我们可以在使用str.split(",")向新形成的列表添加元素时删除左括号和右括号，手动解析列表类型的字符串。
str_inp = '["Hello", "from", "AskPython"]'
str1 = str_inp.replace(']','').replace('[','')
op = str1.replace('"','').split(",")
print(op)
输出:
['Hello', ' from', ' AskPython']
转换逗号分隔的字符串
逗号分隔的字符串是指有一系列字符，用逗号分隔，并包含在 Python 的字符串引号中。
示例:
str_inp = "Hello,from,AskPython'
要将这些类型的字符串转换为元素列表，我们有一些其他的方法来执行这项任务。
方法 1:使用 str.split('，')
我们可以通过使用str.split(',')分隔逗号来直接将其转换成列表。
str_inp = "Hello,from,AskPython"
op = str_inp.split(",")
print(op)
输出:
['Hello', 'from', 'AskPython']
方法 2:使用 eval()
如果输入字符串是可信的，我们可以启动一个交互式 shell，并使用eval()直接评估该字符串。
然而，由于运行潜在的不可信代码的安全隐患，这是而不是推荐的，并且应该避免。
即便如此，如果你还想用这个，那就用吧。我们警告过你！
str_inp = "potentially,untrusted,code"
# Convert to a quoted string so that
# we can use eval() to convert it into
# a normal string
str_inp = "'" + str_inp + "'"
str_eval = ''
# Enclose every comma within single quotes
# so that eval() can separate them
for i in str_inp:
if i == ',':
i = "','"
str_eval += i
op = eval('[' + str_eval + ']')
print(op)
输出将是一个列表，因为字符串已经被求值，并且插入了一个括号来表示它op是一个列表。
输出
['potentially', 'untrusted', 'code']
这很长，不建议解析出逗号分隔的字符串。在这种情况下，使用str.split(',')是显而易见的选择。
结论
在本文中，我们学习了一些将列表转换成字符串的方法。我们处理了列表类型的字符串和逗号分隔的字符串，并将它们转换成 Python 列表。
参考
Python 复制–执行深层和浅层复制
在本文中，我们将研究如何使用 Python Copy 模块来执行深度和浅度复制操作。
那么，我们所说的深层拷贝和浅层拷贝是什么意思呢？
让我们看一看，用说明性的例子！
为什么我们需要 Python 复制模块？
在 Python 中，一切都用对象来表示。因此，在很多情况下，我们可能需要直接复制对象。
在这些情况下，我们不能直接使用赋值操作符。
赋值背后的要点是多个变量可以指向同一个对象。这意味着，如果对象使用这些变量中的任何一个发生变化，变化将会在任何地方反映出来！
下面的例子说明了这个问题，使用了一个共享的列表对象，它是可变的。
a = [1, 2, 3, 4]
b = a
print(a)
print(b)
b.append(5)
# Changes will be reflected in a too!
print(a)
print(b)
输出
[1, 2, 3, 4]
[1, 2, 3, 4]
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]
如你所见，由于两个变量指向同一个对象，所以当b改变时，a也会改变！
为了处理这个问题，Python 给了我们一种使用 Copy 模块的方法。
Python 复制模块是标准库的一部分，可以使用以下语句导入:
import copy
现在，在本模块中，我们主要可以执行两种类型的操作:
- 浅拷贝
- 深层拷贝
现在让我们来看看这些方法。
浅拷贝
此方法用于执行浅层复制操作。
调用此方法的语法是:
import copy
new_obj = copy.copy(old_obj) # Perform a shallow copy
这将做两件事——
- 创建新对象
- 插入在原始对象中找到的对象的所有引用
现在，由于它创建了一个新对象，我们可以确定我们的新对象不同于旧对象。
但是，这仍将保持对嵌套对象的引用。因此，如果我们需要复制的对象有其他可变对象(列表、集合等)，这仍然会维护对同一个嵌套对象的引用！
为了理解这一点，我们举个例子。
为了说明第一点，我们将尝试使用一个简单的整数列表(没有嵌套对象！)
import copy
old_list = [1, 2, 3]
print(old_list)
new_list = copy.copy(old_list)
# Let's try changing new_list
new_list.append(4)
# Changes will not be reflected in the original list, since the objects are different
print(old_list)
print(new_list)
输出
[1, 2, 3]
[1, 2, 3, 4]
[1, 2, 3]
如你所见，如果我们的对象是一个简单的列表，那么浅拷贝就没有问题。
让我们看另一个例子，我们的对象是一个列表列表。
import copy
old_list = [[1, 2], [1, 2, 3]]
print(old_list)
new_list = copy.copy(old_list)
# Let's try changing a nested object inside the list
new_list[1].append(4)
# Changes will be reflected in the original list, since the object contains a nested object
print(old_list)
print(new_list)
输出
[[1, 2], [1, 2, 3]]
[[1, 2], [1, 2, 3, 4]]
[[1, 2], [1, 2, 3, 4]]
这里，请注意old_list和new_list都受到了影响！
如果我们必须避免这种行为，我们必须递归地复制所有对象，以及嵌套的对象。
这被称为使用 Python 复制模块的深度复制操作。
深层拷贝
此方法类似于浅层复制方法，但现在将原始对象中的所有内容(包括嵌套对象)复制到新对象中。
要执行深度复制操作，我们可以使用以下语法:
import copy
new_object = copy.deepcopy(old_object)
让我们以以前的例子为例，尝试使用深层拷贝来解决我们的问题。
import copy
old_list = [[1, 2], [1, 2, 3]]
print(old_list)
new_list = copy.deepcopy(old_list)
# Let's try changing a nested object inside the list
new_list[1].append(4)
# Changes will be reflected in the original list, since the objects are different
print(old_list)
print(new_list)
输出
[[1, 2], [1, 2, 3]]
[[1, 2], [1, 2, 3]]
[[1, 2], [1, 2, 3, 4]]
请注意，旧列表没有改变。因为所有对象都是递归复制的，所以现在没有问题了！
但是，由于要复制所有对象，与浅层复制方法相比，这种深层复制方法的成本要高一些。
所以明智地使用它，只在你需要的时候！
结论
在本文中，我们学习了如何使用 Python 复制模块来执行浅层复制和深层复制操作。
参考
- Python 复制模块文档
- 关于 Python 复制模块的 JournalDev 文章
如何使用 Python count()函数
原文：https://www.askpython.com/python/string/python-count-method
嗨，伙计们！在本文中，我们将重点关注带有字符串和列表的 Python count()方法。
1.带字符串的 Python count()函数
Python String 有一个内置的函数——String . count()方法来计算特定输入字符串中某个字符或子字符串的出现次数。
string.count() method接受一个字符或子串作为参数，并返回输入子串在字符串中出现的次数。
语法:
string.count(string, start_index,end_index)
substring(mandatory):输入字符串中需要统计出现次数的字符串。start_index(optional):开始搜索子字符串的索引。end_index(optional):需要停止搜索子字符串的索引。
举例:
inp_str = "JournalDev -- AskPython @ JournalDev"
str_cnt = inp_str.count("JournalDev")
print(str_cnt)
输出:
2
例 2:
inp_str = "Python Java Python Kotlin"
str_cnt = inp_str.count("Python", 0 , 6)
print(str_cnt)
在上面的例子中，我们传递了' Python '作为要搜索的子字符串，并计算了在索引 0–索引 6 之间的存在。
输出:
1
例 3:
inp_str = "Python Java Python Kotlin"
str_len=len(inp_str)
str_cnt = inp_str.count("Python", 5 , str_len )
print(str_cnt)
在这里，我们搜索子字符串–'Python ',并计算它在索引 5 到字符串末尾之间的出现次数，这就是为什么我们将字符串的长度作为 end_index 参数传递。
输出:
1
Python 字符串计数()方法:TypeError
Python string.count()只接受单个子字符串作为参数。如果我们试图传递多个子字符串作为参数，就会引发TypeError exception。
举例:
inp_str = "Python Java Python Kotlin"
str_cnt = inp_str.count('Python', 'Java')
print(str_cnt)
输出:
TypeError Traceback (most recent call last)
<ipython-input-40-6084d1350592> in <module>
1 inp_str = "Python Java Python Kotlin"
----> 2 str_cnt = inp_str.count('Python', 'Java')
3 print(str_cnt)
TypeError: slice indices must be integers or None or have an __index__ method
2.Python 列表计数()函数
Python list 有一个 list.count()方法来计算列表中特定元素的出现次数。
list.count() method对输入列表中出现的特定值/数据项进行计数。
语法:
list.count(value)
例 1:
inp_lst = ['Apple','Banana','Apple','Grapes','Jackfruit','Apple']
lst_cnt = inp_lst.count('Apple')
print(lst_cnt)
输出:
3
例 2:
inp_lst = [ ['Rat','Cat'], ['Heat','Beat'], ['Rat','Cat'] ]
lst_cnt = inp_lst.count(['Rat','Cat'])
print(lst_cnt)
在上面的例子中，我们基本上统计了嵌套列表['Rat '，' Cat']在列表中的出现次数。
输出:
2
Python count()函数一目了然！
- Python
string.count() function用于计算特定字符串中输入子字符串的出现次数。 - 如果我们试图将多个子字符串作为参数传递，string.count()方法会引发一个
TypeError exception。 list.count() function检查特定元素在特定列表中出现的次数。
结论
因此，在本文中，我们已经了解了内置 Python count 函数对字符串和列表的处理。
参考
- Python 字符串计数()函数–journal dev
Python 课程–和声明
原文：https://www.askpython.com/course/python-course-and-statement
Python 的“and”语句处理逻辑因子，也是布尔代数的一部分。Python and 是一个逻辑运算符，用于组合条件语句并给出 true 或 false 输出。
Python 课程–按位运算符
原文：https://www.askpython.com/course/python-course-bitwise-operators
按位运算符对位进行运算。整数被转换成二进制，然后逐位执行运算。输出是十进制形式的。
Python 课程–break 语句
原文：https://www.askpython.com/course/python-course-break-statement
在 Python 中，break 语句用于结束迭代并继续下一个代码块。
Python 课程–注释
注释用于留下关于程序的重要信息。在 Python 中我们也可以有多行注释。
Python 课程-比较运算符
原文：https://www.askpython.com/course/python-course-comparison-operator
Python 中的比较运算符用于比较两个值并返回布尔结果。
Python 课程–继续陈述
原文：https://www.askpython.com/course/python-course-continue-statement
在 Python 中，continue 关键字跳过循环迭代，继续下一行迭代。它不会结束循环，而是跳过特定的条件或代码行。
Python 课程-数据类型
数据类型定义了数据的类型。Python 不是严格的类型化语言，这意味着我们不必在声明时指定变量的类型。
Python 课程 Docstring
Python 中的 Docstrings(文档字符串)是在源代码中指定的文本或字符串文字，作为注释来记录程序的特定部分。
Python 课程–for 循环
Python for 循环用于序列的迭代。for 循环继续迭代，直到序列结束。
Python 课程–函数
Python 函数是可以从程序的其他地方调用的代码块。
Python 课程-标识符
原文：https://www.askpython.com/course/python-course-identifiers
标识符是赋予 Python 程序元素的名称，如变量、函数、类名等。如果你想以真正的 Python 方式编写 Python 程序，有一些规则和最佳实践要遵循。
Python 课程–if-else 语句
原文：https://www.askpython.com/course/python-course-if-else-statement
在 Python 中，决策是通过 if 语句做出的，也称为选择语句。如果条件为“真”，则执行 if 块语句。如果条件为假，则执行 else 块。
Python 课程–缩进
原文：https://www.askpython.com/course/python-course-indentation
Python 语句使用缩进进行分组。因此，了解它是一个好主意，因为一个小的缩进错误会导致您的代码移动到一些不同的块中，从而导致不必要的影响。
Python 课程——安装 Python 和 PyCharm IDE
原文：https://www.askpython.com/course/python-course-installing-python-pycharm-ide
欢迎来到 Python 初学者课程。在本视频课程中，您将从基础开始，学习 Python 编程的基本概念和语法。
这是第一个视频，您将学习如何在 Windows 上安装 Python 和安装 PyCharm IDE，这将帮助您轻松学习 Python 编程。
Python 课程–关键词
Python 关键字是 Python 解释器使用的保留字列表。所以，我们不能在程序中使用它们。我们不能创建与这些关键字同名的变量或函数名。
Python 课程–lambda 函数
原文：https://www.askpython.com/course/python-course-lambda-functions
Lambda 函数也称为匿名函数。匿名函数是没有名字的函数。它可以接受任意数量的参数。该功能的范围仅限于该定义的范围。
Python 课程-逻辑运算符
原文：https://www.askpython.com/course/python-course-logical-operators
逻辑运算符处理逻辑，如 AND、or、NOT 等。Python 有许多逻辑运算符，结果总是布尔值，即真或假。
Python 课程–数字
在 Python Numbers 中存储数值。数字是不可变的数据类型，如果您更改值，它会分配一个新的位置。不可变对象不能改变它们的状态、值或内容。
Python 课程–操作员
运算符允许我们对变量执行特定的操作。Python 中有不同类型的运算符，如算术运算符、布尔运算符等。
Python 课程–通过陈述
原文：https://www.askpython.com/course/python-course-pass-statement
Pass 语句用于忽略一个块并向前移动，而不执行任何操作。它基本上是一个空语句。Pass 用于避免编译错误。
Python 课程–返回声明
原文：https://www.askpython.com/course/python-course-return-statement
Python return 语句在函数中用于将某个值返回给函数的参数。不执行 return 语句后面的行。
Python 课程–语句
原文：https://www.askpython.com/course/python-course-statements
语句是给 Python 解释器的指令，用来执行一些特定的逻辑。让我们来学习这段视频中关于陈述的所有内容。
Python 课程-用户输入
原文：https://www.askpython.com/course/python-course-user-input
Python input()是一个内置函数，用于接收用户的输入。
Python 课程–变量
变量用于存储值，然后在程序的其他部分引用它们。每个变量都有一个基于定义位置的范围。
Python 课程–while 循环
原文：https://www.askpython.com/course/python-course-while-loop
在 Python 中，当要执行某个块直到 while 语句中的条件为真时，使用 while 循环。如果条件从不为假，循环就变成无限的。
Python crontab–如何在 Python 中使用 Cron？
今天来说一个有趣的调度模块——Python crontab。值得一提的是，POSIX(即 Windows 操作系统)非常缺乏对 cron 的支持。因此，本文中的例子使用 Linux。
Python crontab 简介
如果您曾经使用过 datetime 模块，或者 sched 模块，那么可以肯定地说，您想要在某个时间点安排一个提醒。
如果您已经思考过这样一个特性的扩展将如何持续下去，那么您也可能会得出这样一个结论:您可以编写一个脚本来持续地、重复地部署相同的事件。
简化所有这些，你可能会有一个想法，或者一个问题，我把我的任务自动化怎么样？
好消息。
这很容易做到！cron 是一个允许调度命令的特性，因此有助于在特定的时间间隔运行命令。
cron 是什么？
类 UNIX 操作系统中存在的一个特性是基于时间的作业调度器，即 cron 。
它用在软件开发环境中，以便安排可以定期运行的作业，在固定的时间、日期或您可以为自己设置的间隔运行。
Python crontab 的语法
Cron 需要一整篇文章来解释，所以，这里有一篇文章可以帮助你了解我们将在这里做什么。
我们将使用 crontabs，它包含了我们已经调度或将要调度的所有作业。
如果您在创建 cron 任务时遇到任何问题，您应该尝试一些在线工具来帮助您理解语法。查看 crontab.guru 来创建你的任务，以防你面临任何问题。
使用 Python crontab 模块
python-crontab模块允许创建 cron 作业的过程变得更加简单。
它为我们提供了一个接受直接输入的简单类，而我们根本不需要使用 cron 语法。
安装 python-crontab
为了在 Python 中使用 cron 和 crontab，我们首先需要安装所需的模块，这可以通过 shell 中的 pip 包管理器命令来完成。
pip install python-crontab
这应该会自动安装所需的模块，一旦你完成了它，我们应该准备好使用它！
使用 python-crontab
让我们直接进入这个模块的工作，安排我们的第一个任务。
1.0 设置
在开始使用 Crontab 中的表达式和任务之前，我们首先需要导入所需的模块。
# Importing the CronTab class from the module
from crontab import CronTab
1.1 对象创建
为了使用 Python crontab ，我们需要设置一个对象来创建作业和它们的循环。
# Creating an object from the class
## Using the root user
cron = CronTab(user="root")
## Using the current user
my_cron = CronTab(user=True)
# Creating an object from the class into a file
file_cron = CronTab(tabfile="filename.tab")
1.2 使用作业
使用python-crontab模块，我们可以创建作业，并指定我们希望它们重复的时间，以及它们必须重复出现的时间间隔。
该模块简化了创建这些任务的大部分工作，并将其从功能性输入转变为 crontab。
# Creating a new job
job = cron.new(command='echo hello_world')
# Setting up restrictions for the job
## The job takes place once every 5 minutes
job.minute.every(5)
## The job takes place once every four hours
job.hour.every(4)
## The job takes place on the 4th, 5th, and 6th day of the week.
job.day.on(4, 5, 6)
# Clearing the restrictions of a job
job.clear()
请记住，每次更改作业的限制时，作业都会清除并用新的限制替换自己。
1.3 写入 crontab 文件
最后，我们创建这些作业来为我们提供给定限制的 cron 形式，为了写入文件，我们必须手动命令对象将自身写入文件。
这可以通过设置作业限制结束时的一个简单命令来执行。
cron.write()
回头看，您会发现 cron 是我们从CronTab类创建的对象的名称。
1.4 CronTab file
每次设置新的限制时执行 Python 文件，一个干净的 CronTab 应该是这样的。
*/5 * * * * echo hello_world
*/5 */4 * * * echo hello_world
*/5 */4 4,5,6 * * echo hello_world
结论
使用 cron 是自动化过程中的一大进步，如果您希望查看可以帮助决定设置任务和工作的时间和日期的模块，您可能会对我们的其他文章感兴趣！
这里是与 dateutil 、 psutil 合作，如果你出于任何原因试图自动化数据集，并且需要一个起点，熊猫！
参考
Python CSV 模块–读取和写入 CSV 文件
原文：https://www.askpython.com/python-modules/python-csv-module
在本教程中，我们将了解 Python CSV 模块，它对于 CSV 文件处理非常有用。
使用 Python 附带的这个模块，我们可以轻松地读写 CSV 文件。
我们开始吧！
使用 Python csv 模块
我们必须导入 csv 模块才能使用相关方法。
import csv
现在，根据您想要做什么，我们可以使用适当的对象读取或写入 csv 文件。
我们先来看看读取 csv 文件。
使用 csv.reader()读取 csv 文件
要读取 csv 文件，我们必须构造一个 reader 对象，然后它将解析文件并填充我们的 Python 对象。
Python 的csv模块有一个名为csv.reader()的方法，它会自动构造 csv reader 对象！
我们必须在已经打开的文件对象上调用csv.reader()方法，使用open()。
import csv
reader = csv.reader(file_object)
通常，推荐的方法是使用with上下文管理器来封装所有内容。
您可以做类似的事情:
import csv
# Open the csv file object
with open('sample.csv', 'r') as f:
# Construct the csv reader object from the file object
reader = csv.reader(f)
reader 对象将是一个包含 csv 文件中所有行的 iterable 对象。默认情况下，每个row都会是一个 Python 列表，所以对我们来说会非常方便！
因此，您可以使用循环的直接打印行，如下所示:
for row in reader:
print(row)
好吧。现在我们有了一个基本的模板代码，让我们使用csv.reader()打印下面文件的内容。
让我们考虑sample.csv有以下内容。
Club,Country,Rating
Man Utd,England,7.05
Man City,England,8.75
Barcelona,Spain,8.72
Bayern Munich,Germany,8.75
Liverpool,England,8.81
现在，让我们运行代码:
import csv
with open('sample.csv', 'r') as f:
reader = csv.reader(f)
for row in reader:
print(row)
输出
['Club', 'Country', 'Rating']
['Man Utd', 'England', '7.05']
['Man City', 'England', '8.75']
['Barcelona', 'Spain', '8.72']
['Bayern Munich', 'Germany', '8.75']
['Liverpool', 'England', '8.81']
好的，我们得到了所有的行。在这里，你可以看到，csv在逗号后面给了我们空格。
如果您想要解析单个单词，通过使用空白字符进行分隔，您可以简单地将它作为分隔符传递给csv.reader(delimiter=' ')。
现在让我们尝试修改后的代码:
import csv
with open('sample.csv', 'r') as f:
reader = csv.reader(f, delimiter=' ')
for row in reader:
print(row)
输出
['Club,', 'Country,', 'Rating']
['Man', 'Utd,', 'England,', '7.05']
['Man', 'City,', 'England,', '8.75']
['Barcelona,', 'Spain,', '8.72']
['Bayern', 'Munich,', 'Germany,', '8.75']
['Liverpool,', 'England,', '8.81']
事实上，我们现在已经把单词分开了，所以Man Utd变成了Man和Utd。
类似地，如果您想要解析带分隔符的内容，只需将该字符作为分隔符传递给csv.reader()。
现在让我们看看如何写入 csv 文件。
使用 csv.writer()写入 csv 文件
类似于用于读取的csv.reader()方法，我们有用于写入文件的csv.writer()方法。
这将返回一个writer对象，我们可以用它将行写入我们的目标文件。
让我们看看如何使用它。首先，创建writer对象:
import csv
with open('output.csv', 'w') as f:
writer = csv.writer(f)
我们现在可以使用writer.writerow(row)方法来写一行。在这里，类似于 reader 对象，row是一个列表。
所以，我们可以这样调用它:
writer.writerow(['Club', 'Country', 'Rating'])
现在让我们看看运行整个程序:
import csv
with open('output.csv', 'w') as f:
writer = csv.writer(f)
writer.writerow(['Club', 'Country', 'Rating'])
clubs = [['Real Madrid', 'Spain', 9.1], ['Napoli', 'Italy', 7.5]]
for club in clubs:
writer.writerow(club)
我们现在来看看output.csv。
Club,Country,Rating
Real Madrid,Spain,9.1
Napoli,Italy,7.5
事实上，我们在输出文件中有自己的行！
注:类似于csv.reader(delimiter)，我们也可以通过一个分隔符来写使用csv.writer(delimiter)
如果您仔细观察，我们已经手动遍历了我们的行列表(列表列表),并逐个写入了每一行。
原来还有一个叫writer.writerows(rows)的方法可以直接写我们所有的行！
让我们来测试一下。删除output.csv并运行以下代码。
import csv
with open('output.csv', 'w') as f:
writer = csv.writer(f)
writer.writerow(['Club', 'Country', 'Rating'])
clubs = [['Real Madrid', 'Spain', 9.1], ['Napoli', 'Italy', 7.5]]
writer.writerows(clubs)
输出
Club,Country,Rating
Real Madrid,Spain,9.1
Napoli,Italy,7.5
我们确实得到了和以前一样的输出！
使用 csv。DictReader()和 csv。DictWriter()将 csv 作为字典来读写
还记得当使用reader对象读取时，我们以列表的形式按行获取对象吗？
如果您想要精确的column_name: row_name映射，我们可以使用csv.DictReader类并获得一个字典来代替！
让我们看看如何将 csv 文件读入字典。
import csv
with open("sample.csv", 'r') as file:
csv_file = csv.DictReader(file)
for row in csv_file:
print(dict(row))
这里，csv.DictReader()返回一个OrderedDict()对象的 iterable。我们需要使用dict(row)将每个OrderedDict行转换成一个dict。
让我们看看输出:
{'Club': 'Man Utd', ' Country': ' England', ' Rating': ' 7.05'}
{'Club': 'Man City', ' Country': ' England', ' Rating': ' 8.75'}
{'Club': 'Barcelona', ' Country': ' Spain', ' Rating': ' 8.72'}
{'Club': 'Bayern Munich', ' Country': ' Germany', ' Rating': ' 8.75'}
{'Club': 'Liverpool', ' Country': ' England', ' Rating': ' 8.81'}
事实上，我们有列名和行值！
现在，为了从字典写入 csv 文件，您有了csv.DictWriter()类。
这几乎和csv.write()一样，除了你是从字典而不是从列表开始写。
尽管语法有点不同。我们必须预先指定列名，作为我们的fieldnames的一部分。
然后我们需要使用writer.writeheader()写入第一行(header)。
fieldnames = ['Club', 'Country', 'Rating']
writer = csv.DictWriter(f, fieldnames=fieldnames)
writer.writeheader()
现在，我们可以遍历我们的列表dicts，它包含相关的信息。
让我们用csv.DictWriter()重写我们以前的writer例子。
import csv
with open('output.csv', 'w') as f:
fieldnames = ['Club', 'Country', 'Rating']
# Set the fieldnames
writer = csv.DictWriter(f, fieldnames=fieldnames)
# Write the header
writer.writeheader()
clubs = [{'Club': 'Real Madrid', 'Country': 'Spain', 'Rating': 9.1}, {'Club': 'Napoli', 'Country': 'Italy', 'Rating': 7.5}]
for club in clubs:
writer.writerow(club)
我们现在将获得与之前相同的输出，表明我们已经使用我们的csv.DictWriter()对象成功地写入了 csv 文件！
结论
希望您已经理解了如何使用csv模块轻松处理 csv 文件。我们使用合适的对象使 csv 文件的读写变得容易。
参考
- 关于用 Python 读写 csv 文件的 JournalDev 文章
Python 自定义异常
原文：https://www.askpython.com/python/python-custom-exceptions
每当遇到错误时，就会引发一个异常，它表示程序出了问题。默认情况下，语言为我们定义了很多例外，比如传递错误类型时的TypeError。在本文中，我们将看看如何在 Python 中创建我们自己的定制异常。
但是在我们看一下如何实现定制异常之前，让我们看看如何在 Python 中引发不同类型的异常。
引发异常
Python 允许程序员使用raise关键字手动引发异常。
格式:raise ExceptionName
根据传递给函数的输入，below 函数会引发不同的异常。
def exception_raiser(string):
if isinstance(string, int):
raise ValueError
elif isinstance(string, str):
raise IndexError
else:
raise TypeError
输出:
>>> exception_raiser(123)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 3, in exception_raiser
ValueError
>>> exception_raiser('abc')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 5, in exception_raiser
IndexError
>>> exception_raiser([123, 456])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 7, in exception_raiser
TypeError
正如您所观察到的，程序员可以根据输入选择不同类型的异常。这也为错误处理提供了很好的灵活性，因为我们可以主动预测为什么会出现异常。
定义自定义例外
类似地，Python 也允许我们定义自己的定制异常。使用raise关键字，我们可以完全控制这个异常能做什么，以及何时引发它。让我们看看如何定义和实现一些自定义异常。
1.创建自定义异常类
我们可以创建一个定制的异常类来定义新的异常。再次强调，使用类背后的想法是因为 Python 将所有东西都视为一个类。所以一个异常也可以是一个类并不奇怪！
所有的异常都继承了父类Exception,我们在创建类的时候也会继承它。
我们将创建一个名为MyException的类，只有当传递给它的输入是一个列表并且列表中的元素数量是奇数时，它才会引发异常。
class MyException(Exception):
pass
def list_check(lst):
if len(lst) % 2 != 0:
raise MyException
# MyException will not be raised
list_check([1, 2, 3, 4])
# MyException will be raised
list_check([1, 3, 5])
输出:
[email protected]:~# python3 exceptions.py
Traceback (most recent call last):
File "exceptions.py", line 12, in <module>
list_check([1, 3, 5])
File "exceptions.py", line 6, in list_check
raise MyException
__main__.MyException
2.添加自定义消息和错误
我们可以添加我们自己的错误消息，并将它们打印到控制台，用于我们的自定义异常。这涉及到传递我们的MyException类中的另外两个参数，即message和error参数。
让我们修改我们的原始代码，为我们的异常考虑一个定制的 消息 和 错误 。
class MyException(Exception):
def __init__(self, message, errors):
# Call Exception.__init__(message)
# to use the same Message header as the parent class
super().__init__(message)
self.errors = errors
# Display the errors
print('Printing Errors:')
print(errors)
def list_check(lst):
if len(lst) % 2 != 0:
raise MyException('Custom Message', 'Custom Error')
# MyException will not be raised
list_check([1, 2, 3, 4])
# MyException will be raised
list_check([1, 3, 5])
输出:
Printing Errors:
Custom Error
Traceback (most recent call last):
File "exceptions.py", line 17, in <module>
list_check([1, 3, 5])
File "exceptions.py", line 11, in list_check
raise MyException('Custom Message', 'Custom Error')
__main__.MyException: Custom Message
因此，我们已经成功地实现了我们自己的定制异常，包括添加用于调试目的的定制错误消息！如果您正在构建一个库/API，而另一个程序员想知道在定制异常出现时到底哪里出错了，这将非常有用。
结论
在本文中，我们学习了如何使用raise关键字引发异常，还使用一个类构建了我们自己的异常，并向我们的异常添加了错误消息。
参考
- 关于自定义异常的 JournalDev 文章
- Python 中的异常处理
使用 NumPy 和 Pandas 清理 Python 数据
原文：https://www.askpython.com/python/examples/python-data-cleaning-numpy-pandas
Python 数据清理是用一些默认值替换空值、删除不需要的列、删除缺失的行等的过程。当处理大量原始数据时，在分析之前清理数据是有意义的，这样我们就可以处理完整的数据集。
Python 中的数据清理
Python NumPy 和 Pandas 模块为 Python 中的数据清理提供了一些方法。数据清理是指通过更新或删除缺失、不准确、格式不正确、重复或不相关的信息来清理需要传递到数据库或用于数据分析的所有数据的过程。应该定期进行定期数据清理，以避免多年来堆积未清理的数据。
为什么我们需要清理 Python 中的数据？
如果数据清理不当，可能会导致巨大的损失，包括降低营销效率。因此，清理数据对于避免主要结果中的所有不准确性变得非常重要。
高效的数据清理意味着更少的错误，从而导致更满意的客户和更少沮丧的员工。它还能提高生产力，做出更好的决策。
清理 Python 数据集中的数据的步骤
1.数据加载
现在让我们对我从网上下载的一个随机的csv文件进行数据清理。数据集的名称是“旧金山建筑许可”。在对数据进行任何处理之前，首先从文件中加载数据。数据加载的代码如下所示:
import numpy as np
import pandas as pd
data = pd.read_csv('Building_Permits.csv',low_memory=False)
首先，导入所有需要的模块，然后加载 CSV 文件。我添加了一个名为low_memory的额外参数，其目的是确保程序不会因为庞大的数据集而出现任何内存错误。
数据集包含 198900 个许可细节和 43 列。数据集中的列如下:
- 许可证号码
- 许可类型
- 许可类型定义
- 许可证创建日期
- 街区
- 大量
- 街道号码
- 街道号码后缀
- 街道名称
- 街道后缀
- 单位
- 单位后缀
- 描述
- 当前状态
- 当前状态日期
- 字段日期
- 签发日期
- 完成日期
- 首次施工文件日期
- 结构通知
- 现有故事的数量
- 提议故事的数量
- 自愿软层改造
- 只允许用火
- 许可证到期日期
- 预算造价
- 修订成本
- 现有用途
- 现有单位
- 拟议用途
- 提议的单位
- 计划集
- TIDF 合规
- 现有建筑类型
- 现有建筑类型描述
- 提议的结构类型
- 建议的结构类型描述
- 工地许可证
- 主管区
- 邻域-分析边界
- 邮政编码
- 位置
- 记录 ID
2.删除不必要的列
当我们查看数据集时，我们看到数据集中有如此多的列。但是对于处理，我们可以在处理过程中跳过一些列。
现在，让我们删除一些随机的列，即 TIDF 合规性、仅火灾许可、单位后缀、区块和批次。
columns_to_drop=['TIDF Compliance', 'Fire Only Permit', 'Unit Suffix', 'Block','Lot']
data_dropcol=data.drop(columns_to_drop,axis=1)
我们将首先创建一个列表，存储要从数据集中删除的所有列名。
在下一行中，我们使用了 drop 函数，并将创建的列表传递给该函数。我们还传递轴参数，该参数的值可以是 0(按行放置)或 1(按列放置)。
代码执行后，新数据只包含 38 列，而不是 43 列。
3.删除缺少的值行
在直接移动到删除带有缺失值的行之前，让我们首先分析数据集中有多少缺失值。出于同样的目的，我们使用下面提到的代码。
no_missing = data_dropcol.isnull().sum()
total_missing=no_missing.sum()
在代码执行时，我们发现数据集中有 1670031 个丢失的值。因为丢失的值太多了，所以我们不是删除丢失数据的行，而是删除丢失值最多的列。相同的代码如下所示。
drop_miss_value=data_dropcol.dropna(axis=1)
该代码导致删除了最大列数，结果数据集中只剩下 10 列。是的，大部分信息都从数据集中删除了，但至少现在数据集得到了充分的清理。
摘要
数据分析是一项资源密集型操作。因此，在分析之前清理原始数据以节省时间和精力是有意义的。数据清理也确保了我们的分析更加准确。Python pandas 和 NumPy 模块最适合 CSV 数据清理。
下一步是什么？
Python 数据科学问题
原文：https://www.askpython.com/python/python-data-science-questions
在这一节中，我们将讨论什么是 python，它的历史、起源、当前版本、薪水和 2022 年的工作角色，然后我们将进入重要的 Python 编程问题。
近年来，Python 已经成为世界上最流行的编程语言之一。它在全球众多设备上使用。由于可用库的范围很广，开发人员和非开发人员都可以使用它。
Python 是一种计算机编程语言，通常用于构建网站和软件、自动化任务以及行为记录分析。它是一种通用语言，这意味着它可以用来创建各种不同的程序，而不是专门针对任何特定的问题。这种多功能性，加上它对初学者的友好性，使它成为当今最常用的编程语言之一。在世界各地不同组织提供的许多调查中，Python 成为 2022 年最受欢迎的语言。
Python 是由吉多·范·罗苏姆于 20 世纪 80 年代末在荷兰国家数学和计算研究院开发的。它继承了 ABC 编程语言，该语言与阿米巴操作系统接口，并具有出色的处理能力。
Python 3.10.7 是 Python 编程语言的最新版本，包括许多新特性和优化。
2022 年薪酬最高的 Python 职位
- 人工智能专家|＄135，238
- 解决方案架构师|＄120，756
- 机器学习工程师|＄112343
- 分析经理|＄99，121
- 数据科学家|＄97004
- 数据工程师|＄92，999
- 软件工程师|＄88280
- 后端开发人员|＄87，009
- 计算机科学家|＄81812
- 前端开发人员|＄76，289
理论 Python 数据科学问题
1.我们使用哪个库进行数据操作？
Pandas 是 Python 的库。pandas 是一个非常受欢迎的库，它与 NumPy 和 matplotlib 一起被广泛用于数据科学。它有一个活跃的社区，有 1000 多名贡献者，主要用于数据分析和清理。
2.用 Python 写数据科学的前 5 个库。
在数据科学项目中广泛使用的 5 大 Python 库是:
- TensorFlow
- 熊猫
- NumPy
- Matplotlib
- 轨道轨道
3.数列和向量有什么区别？
- 向量只分配索引位置值为 0，1，…，(n-1)。
- 系列只有一列。它为每个数据系列分配自定义索引位置值。例如:客户标识、客户名称、总销售额。系列可以从列表、数组、字典中创建。
4.区分数据框和矩阵。
数据帧
- 数据框是共享一个公共索引的系列的集合。
- 它可以保存多个不同数据类型的序列。
- 例如，雇员数据有各种列，如雇员 id、雇员姓名、年龄、性别和部门。这些分别是不同数据类型的系列。
矩阵
- Numpy 中的矩阵由多个向量构成。
- 在整个二维结构中，它只能容纳一种数据类型。
5.解释熊猫数据帧分组的用途。
Groupby 允许根据列将行组合在一起，并对这些组合行执行聚合函数。示例:df.groupby('salary ')。平均值()。
6.说出一些可以用于可视化的 Python 库。
Matplotlib 是一个标准的数据可视化库，对于生成二维图形非常有用。例如:直方图、饼图、条形图、柱形图和散点图。很多库都是在 Matplotlib 之上构建的，它的函数可以在后端使用。此外，它还广泛用于创建可视化的轴和布局。
Seaborn 基于 Matplotlib。它是 Python 中的一个数据可视化库。它适用于 Numpy 和 Pandas，并且为绘制有吸引力的和信息丰富的统计图形提供了一个很好的界面。
7.什么是散点图？
二维数据可视化解释了两个不同变量的观察值之间的关系。一个绘制在 x 轴上，另一个绘制在 y 轴上。
8.regplot()、lmplot()和 residplot()有什么区别？
- regplot() 是用于绘制数据的和拟合的线性回归模型。为了估计回归模型，有几种互斥的可能性。
- lmplot() 绘制数据，回归模型拟合一个面网格。它被设计为一个实用的接口，用于跨数据集的条件子集拟合回归模型，并且计算量更大。lmplot()结合了 regplot()和 FacetGrid。
- residplot() 绘制 X 和 Y 之间的误差，为其创建一个线性回归方程。
9.定义热图。
热图是一种数据可视化，它利用颜色来描述一个值如何根据另外两个变量的值而变化。例如，您可以使用热图来了解一组城市的气温如何随时间变化。
10.为什么使用 Python 而不是其他语言？
Python 是一种广泛使用、灵活且通用的编程语言。因为它简单明了，所以作为第一语言是很棒的。它也是任何程序员工具箱中的有用语言，因为它可以用于从 web 开发到软件开发到科学应用的任何事情。
11.Python 中的枚举函数是什么？
Python enumerate()为 iterable 增加一个计数器，并以枚举对象的形式返回。枚举对象可以直接用于循环，或者使用list()方法转换成元组列表
12.复数绝对值背后的数学原理是什么？
如果**z=a+ib**，则绝对值计算为 sqrt(a^2+b^2)
13.Python 中有哪些顶级的文本挖掘库？
- 自然语言工具包(NLTK)
- Gensim
- -好的
- 宽大的
- 文本 Blob
- 模式
- PyNLPl
14.熊猫在数据分析中是如何使用的？
Pandas 使得使用类似 SQL 的查询来加载、处理和分析这样的表格数据变得非常方便。Pandas 为表格数据的可视化分析提供了多种选项，可与 Matplotlib 和 Seaborn 配合使用。Pandas 中的主要数据结构是用 Series 和 DataFrame 类实现的。
15.说出五大 Python 编译器。
- 皮查姆
- 崇高的文本
- 托尼
- Visual Studio 代码
- Jupyter 笔记型电脑
16.Python 中的关键词是什么？
Python 使用具有特定含义的保留字，称为关键字。它们通常用于指定变量的种类。变量名和函数名不允许包含关键字。下面列出的 33 个关键词都是 Python 中的:
| 或者 | 和 | 不 | 如果 | 艾列弗 |
| 其他 | 为 | 在…期间 | 破裂 | 极好的 |
| 如同 | 希腊字母的第 11 个 | 及格 | 返回 | 真实的 |
| 错误的 | 随着 | 尝试 | 维护 | 班级 |
| 继续 | 是吗 | 除...之外 | 最后 | 从 |
| 全球的 | 进口 | 在 | 是 | 没有人 |
| 非局部的 | 上升 | 产量 | | |
Python Keywords
数据科学:编码问题
1.用 Python 写一个程序预测输出类型
# Defining the variable
x = 'z'
print(type(x))
2.编写一个 python 程序，使用 while 循环打印一个 13 的表。
i = 0
while i <= 10:
print(i*13)
i+=1
3.如何用 Python 访问 CSV 文件？
- 通过使用 CSV 库
import csv
with open("bwq.csv", 'r') as file:
csv_reader = csv.reader(file)
for row in csvreader:
print(row)
- 使用熊猫图书馆
import pandas as pd
data_bwq = pd.read_csv("bwq.csv")
data_bwq
4.用 Python 生成随机数。
#generating random numbers between (0,22)
import random
n = random.randint(0,22)
print(n)
5.检查元素是否在序列中。
42 in [2, 39, 42]
# Output: True
6.展示 extend 和 append 函数的区别。
- append:它将对象附加在末尾。
a = [1, 2, 3]
a.append([4, 5])
print (a)
# Output: [1, 2, 3, [4, 5]]
- extend:通过追加 iterable 中的元素来扩展列表。
a = [1, 2, 3]
a.extend([4, 5])
print (a)
# Output: [1, 2, 3, 4, 5]
7.打印 10 到 100 的所有倍数。
multiples=[]
for i in range(10, 101):
if i%10==0:
multiples.append(i)
print(multiples)
# Output: [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
8.修复 Python 中的 ModuleNotFoundError 和 ImportError。
- 首先，确保使用绝对导入
- 其次，将项目的根目录导出到
PYTHONPATH
大多数现代 Python IDEs 会自动完成这一任务，但如果不是这样，我确信会有这样一个选项，您可以在其中为您的 Python 应用程序定义PYTHONPATH(至少是 PyCharm)。如果您在另一个环境中运行 Python 应用程序，比如 Docker、vagger，或者在您的虚拟环境中，您可以在 bash 中运行以下命令:
export PYTHONPATH="${PYTHONPATH}:/path/to/your/project/"
# * For Windows
set PYTHONPATH=%PYTHONPATH%;C:\path\to\your\project\
9.编写方法来分隔具有特定扩展名(.csv，。txt)存储在一个目录中
- 方法 1
import os
for root, dirs, files in os.walk(directory):
for file in files:
if file.endswith(‘.txt’):
print file
- 方法二
import os
path = ‘mypath/path’
files = os.listdir(path)
files_txt = [i for i in files if i.endswith(‘.txt’)
结论
以上是数据科学面试中一些最常被问到的问题。还有许多其他的例子，但 Python 的基础知识是面对数据科学面试的基本要求。文档参考也是获得数据科学领域中使用的多个库的更好工作知识所需的关键技能之一。
Python 数据类型
Python 是一种面向对象的编程语言。Python 中的每个变量都是某个类的实例。有许多预定义的 Python 数据类型。我们可以创建自己的类来定义 Python 中的自定义数据类型。
Python 中流行的数据类型有哪些？
Python 中一些流行的数据类型有:
- 数字–整数、浮点数、复数
- 序列–字符串、列表、元组、集合
- 地图-字典
Python 数据类型检查
我们可以使用type()函数来检查变量的数据类型。
i = 10
print(type(i))
Python Data Types
让我们看一些 Python 中数据类型的例子。
Python 字符串数据类型
Python 字符串是类' str 的实例。该字符串是 Unicode 字符序列。Python 字符串是不可变的。我们可以用单引号(')或双引号(")来定义字符串。
字符串是 Python 中最流行的数据类型。字符串对象支持各种操作——长度、格式、分割、连接、切片等。
s = "abc"
print(type(s))
s1 = 'hello'
print(type(s1))
print(s[1:2])
print(len(s))
print(s.split('b'))
输出:
<class 'str'>
<class 'str'>
b
3
['a', 'c']
Python 数字数据类型
数字类别中有三种数据类型——int、float 和 complex。Python 2 中有另一种数据类型“long ”,但在 Python 3 中被弃用了。
i = 10
print(type(i))
i = 1.23
print(type(i))
i = 1 + 2j
print(type(i))
Python Numbers Data Types
Python 元组数据类型
Python 中的元组是有序的项目序列。元组是不可变的，即一旦定义，我们就不能改变它的值。
我们可以使用圆括号定义一个元组，其中项目用逗号分隔。元组可以包含任意数量的元素，并且元素可以是任意类型。
t = (1, 2, 3)
print(type(t))
t = ('a', 1, [1, 2])
print(type(t))
输出:
<class 'tuple'>
<class 'tuple'>
Python 列表数据类型
该列表与 Tuple 几乎相同，只是它是可变的。元素的顺序保持不变。
Python 列表用括号定义，元素用逗号分隔。
my_list = [1, 2, 3]
print(type(my_list))
my_list = ['a', 1, [1, 2]]
print(type(my_list))
输出:
<class 'list'>
<class 'list'>
Python 集合数据类型
Python 集合是一个无序的项目集合。集合不能有重复值。元素的顺序不在集合中保持。
集合是用大括号定义的，其中元素用逗号分隔。Python Set 使用哈希来存储元素。所以元素必须是可散列的，即hash()函数应该对它们起作用。因为列表是不可共享的，我们不能在集合中存储列表对象。
my_set = {1, 2, 3, 1}
print(type(my_set))
print(my_set)
my_set = {'a', 1, 'a'}
print(type(my_set))
print(my_set)
输出:
<class 'set'>
{1, 2, 3}
<class 'set'>
{1, 'a'}
让我们看看当我们试图将一个列表作为集合元素时会发生什么。
>>> my_set = {1, [1]}
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
>>>
Python 字典数据类型
Python 字典是一个无序的键值对集合。它是用大括号定义的，元素用逗号分隔。键和值可以是任何类型。键-值对是使用冒号(key: value)定义的。
Python 字典对象属于“dict”类型。在需要快速检索的地方，它们适合存储大量的值。
my_dict = {"1": "Apple", "2": "Banana"}
print(type(my_dict))
my_dict = {1: 1, 2: 'b', 3: [1, 2]}
print(type(my_dict))
Python 字典在键上使用散列来存储和检索元素，因此键对象必须支持 hash()函数。这就是为什么我们不能使用列表作为字典元素的键。
>>> my_dict = {[1]: "a"}
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
>>>
在 Python 中定义自定义数据类型
我们可以通过在 Python 中创建一个类来定义自定义数据类型。
class Data:
pass
d = Data()
print(type(d))
Python Custom Data Type
Python 函数有数据类型吗？
到目前为止，我们已经看到数据类型与 Python 变量相关联。但是， python 函数也有数据类型吗？
让我们用一个简单的程序来检查一下。
def foo():
pass
print(type(foo))
输出:
<class 'function'>
所以 Python 函数也有一个数据类型——函数。它们是类函数的实例。
Python 类方法有数据类型吗？
让我们看看 python 类方法是否也有数据类型。
class Data:
def foo(self):
pass
d = Data()
print(type(d.foo))
输出:
<class 'method'>
因此 Python 类方法的数据类型是“方法”。它们是类“method”的实例。
摘要
Python 是一种面向对象的编程语言。Python 中的一切都是某个类的对象，甚至是函数和类方法。我们可以使用 Python 中内置的 type()函数来确定一个实体的数据类型。
下一步是什么？
参考
Python 日期类–要知道的 7 个函数！
原文：https://www.askpython.com/python-modules/python-date-class
嘿！在本文中，我们将详细关注 Python 日期类。那么，让我们开始吧。
什么是 Python 日期时间模块？
Python datetime 模块为我们提供了各种类和函数来处理和操作日期和时间值方面的数据值。
我们需要导入 datetime 模块，以便访问其中包含的不同类和方法。
在这里，您可以使用下面的代码片段来导入 date 类，并通过用户定义的参数创建一个 date 对象
from datetime import date
dte = date(2020,12,27)
print("Date: ", dte)
输出
Date: 2020-12-27
现在，让我们在下一节中理解 Python datetime 模块的 date 类。
日期类的实现方法
Python date 类包含各种处理数据值的日期格式的方法。
通过使用 date 类的函数，我们可以很容易地将数据值处理成标准的日期格式 YYYY-MM-DD 。
现在让我们详细看看由 date 类函数构成的一些重要函数。
1.日期.今天()函数
date.today() function从系统中获取当前日期并表示。
语法:
date.today()
举例:
from datetime import date
dte = date.today()
print("Date: ", dte)
输出:
Date: 2020-07-25
2.date.year()函数
我们可以使用 year 函数从日期表达式中访问和获取年份。year function从提供的日期表达式中提取并表示年值。
语法:
date.today().year
举例:
from datetime import datetime,date
year = date.today().year
print(year)
从 date.today()函数中，我们得到当前日期，即 2020-07-26。除此之外，我们还使用 year()函数提取了 year 值。
输出:
2020
3.日期.月份()函数
为了提取和表示月份值，可以使用month function 。
语法:
date.today().month
举例:
from datetime import datetime,date
mnth = date.today().month
print(mnth)
输出:
7
4.date.day 函数
使用如下所示的 day function,可以很容易地从日期表达式中提取日值
语法:
date.day
举例:
from datetime import datetime,date
day = date.today().day
print(day)
输出: 25
5.日期替换()函数
有时，当我们想要改变日期表达式的日期部分时，可能会出现这种情况。这个任务可以使用 replace()函数来完成。
date.replace() function可用于替换以下日期部分——
- 年
- 月
- 天
语法:
date.replace(year,day,month)
举例:
from datetime import datetime,date
dt = date.today()
print("Current date: ",dt)
res = dt.replace(year=2021,day=20)
print("Modified date: ",res)
在上面的例子中，我们已经替换了当前日期(2020-07-26)的年和日值。
输出:
Current date: 2020-07-26
Modified date: 2021-07-20
6.日期.工作日()函数
使用weekday function，我们可以从日期表达式中获取日期值的星期几。
为工作日提供的索引如下:
- 星期一-0
- 星期二-1
- 星期三-2
- 周四至 3 日
- 星期五-4
- 星期六-5
- 周日至 6 日
举例:
from datetime import datetime,date
date = date.today().weekday()
print("Weekday: ",date)
在上面的例子中，我们已经计算了当前日期的星期几:2020-07-26。
输出:
6
7. date.strftime() function
date.strftime() function使我们能够提取日期表达式的日期部分，并将值表示为字符串。
要了解 strftime()函数的变体，请访问 Python strftime()函数。
语法:
date.strftime("%Y-%m-%d")
举例:
from datetime import datetime,date
date = date.today()
year = date.strftime("%Y")
print("Current Year:", year)
str_date = date.strftime("%Y-%m-%d")
print("Date value:",str_date)
输出:
Current Year: 2020
Date value: 2020-07-26
结论
到此，我们就结束了这个话题。如果你有任何疑问，欢迎在下面评论。
在那之前，学习愉快！！
参考
Python 日期时间模块——终极指南
原文：https://www.askpython.com/python-modules/python-datetime-module
嘿，伙计们！希望你们都过得好。在本文中，我们将重点关注 Python 日期时间模块。
本文将特别关注 Python 中处理数据结构的方法或技术。那么，让我们开始吧。
什么是 Python 日期时间模块？
Python Datetime module使我们能够在 Python 中处理日期类型的数据值。datetime 模块由不同的类组成，用于处理日期和 Datetime 表达式。
众所周知，Python 并没有为日期和时间提供任何特定的数据类型，相反，我们可以导入并使用 datetime 模块来有效地处理日期和时间。
与 Python 日期时间模块相关联的类
Python Datetime 模块包含六(6)个处理日期和时间值的类。
在 Python 中，日期和日期时间表达式实际上被视为对象。因此，下面提到的这些类可以用来处理这些日期对象:
- 日期
- 时间
- datetime
- 时距增量
- tzinfo
- 时区
现在，让我们详细了解上述每个类及其功能。
1.datetime.date 类
datetime 模块的日期类以日期格式— YYYY:MM:DD 表示日期对象的信息。
语法:
datetime.date(year,month,day)
让我们了解一下 Date 类提供的各种功能。
from datetime import date
dte = date(2000,12,27)
print(dte)
在上面的例子中，我们使用了date() function 将日、月和年的值转换成标准的日期格式。
输出:
2000-12-27
在本例中，我们使用了date.today() function从系统中获取当前日期。此外，我们还打印了当前的日、年、月值，如下所示:
from datetime import date
dte = date.today()
print("Present date: ",dte)
print("Present year: ",dte.year)
print("Present month: ",dte.month)
print("Present day: ",dte.day)
输出:
Present date: 2020-07-14
Present year: 2020
Present month: 7
Present day: 14
2.datetime.time 类
time 类提供与日期表达式或日期对象无关的时间值的具体信息。
因此，我们可以使用 datetime 模块中的 time 类来访问标准或正则化时间戳形式的时间值。
语法:
datetime.time(hour,min,sec)
举例:
from datetime import time
tym = time(12,14,45)
print("Timestamp: ",tym)
输出:
Timestamp: 12:14:45
在本例中，我们使用time() function访问了小时、分钟和秒的值，如下所示
from datetime import time
tym = time(12,14,45)
print("Hour value from the timestamp: ",tym.hour)
print("Minute value from the timestamp: ",tym.minute)
print("Second value from the timestamp: ",tym.second)
输出:
Hour value from the timestamp: 12
Minute value from the timestamp: 14
Second value from the timestamp: 45
3. datetime.datetime class
datetime 类为我们提供了关于日期和时间值的信息。因此，它使用类的函数表示整个日期和时间值。
语法:
datetime.datetime(year,month,day,hour,min,sec,microsecond)
在下面的例子中，我们已经传递了必要的参数，并实现了 datetime 类的datetime() function。
from datetime import datetime
dte_tym = datetime(2020,3,12,5,45,25,243245)
print(dte_tym)
输出:
2020-03-12 05:45:25.243245
4.datetime.timedelta 类
Python DateTime 模块为我们提供了 timedelta 类来处理各种与日期相关的操作。
语法:
datetime.timedelta(days,hours,weeks,minutes,seconds)
在对数据执行指定操作后， timedelta() function返回日期。
from datetime import datetime, timedelta
dte = datetime(2020,12,9)
updated_tym = dte + timedelta(days = 2,weeks=4)
print("Updated datetime: ",updated_tym)
在上面的例子中，我们已经向预定义的日期值添加了天数和周数。
输出:
Updated datetime: 2021-01-08 00:00:00
除了加法，我们还可以通过从日期时间表达式中减去特定的日期部分或时间部分来回溯日期值，如下所示:
from datetime import datetime, timedelta
dte = datetime(2020,12,9)
updated_tym = dte - timedelta(days = 2,weeks=4)
print("Updated datetime: ",updated_tym)
输出:
Updated datetime: 2020-11-09 00:00:00
结论
这个话题到此结束。如上所述，datetime 模块在以各种方式表示日期和时间方面起着重要的作用。
如果你有任何疑问，欢迎在下面评论。
在那之前，学习愉快！！
参考
- Python 日期时间模块— JournalDev
- Python 日期时间模块—文档
Python 十进制模块–你需要知道的 7 个函数！
原文：https://www.askpython.com/python-modules/python-decimal-module
嘿，大家好！在本文中，我们将看看其中一个有趣的模块——Python 十进制模块。
无论在哪个领域，我们都需要搜索函数来执行数学运算。Python 十进制模块为我们提供了我们需要的所有数学函数。
所以，让我们开始吧！
了解 Python 十进制模块
Python decimal 模块包含各种函数来处理数字数据并对其执行不同的数学运算。使用十进制模块，我们可以在整个程序中有效地处理十进制数。
The decimal module为我们提供了控制和克服小数值精度问题的功能。
理解了十进制模块的需要后，现在让我们看看该模块提供的一些重要功能。
为了使用这些功能，我们需要导入如下所示的模块:
import decimal
十进制模块的功能及实现
可以对十进制或数字数据执行不同的算术运算来提高结果。
我们可以使用如下所示的decimal.Decimal() function来定义小数点数字
语法:
import decimal
variable = decimal.Decimal(decimal-number)
此外，我们可以通过十进制模块的内置函数— decimal.getcontext().prec函数来控制小数点位数结果的精度值。
语法:
decimal.getcontext().prec = precision value
下面解释的函数帮助我们高效快速地执行小数点算术运算。
1.exp()函数–指数计算
exp() function计算传递给它的特定十进制数的指数值，即 e^x 。
语法:
decimal.Decimal(decimal-number).exp()
举例:
import decimal as d
d.getcontext().prec = 5
#Intializing with an addition operation
val = d.Decimal(12.201) + d.Decimal(12.20)
#Calculating exponential of the decimal value
exp = val.exp()
#variable with no calculations
no_math = d.Decimal(1.131231)
print("Sum: ",val)
print("Exponential: ", exp)
print(no_math)
输出:
Decimal Number: 24.401
3.9557E+10
1.131231000000000097571728474576957523822784423828125
注意我们输出的数字总数是 5？这是因为我们在这里设置了精度值。
需要记住的一点是，当您对两位小数执行数学运算时，精度值适用，而不是当您使用上面的“no_math”变量中显示的值直接初始化变量时。
2.sqrt()函数——平方根
sqrt()函数计算并返回传递给它的十进制数的平方根值。
语法:
decimal.Decimal(decimal-number).sqrt()
举例:
import decimal as d
d.getcontext().prec = 3
val = d.Decimal(122.20)
sqrt = val.sqrt()
print("Decimal Number: ",val)
print("Square root of the decimal number: ",sqrt)
输出:
Decimal Number: 122.2000000000000028421709430404007434844970703125
Square root of the decimal number: 11.1
同样，请注意声明的值如何包含完整的十进制数，而计算的值遵循我们的 3 位数精度集。
要找到更多的数学运算，请阅读我们关于 Python 中的数学模块的文章
3.对数函数
十进制模块为我们提供了以下函数来计算小数点数字的对数值
- decimal.ln()
- decimal.log10()
decimal.ln() function 返回十进制数的自然对数值，如下所示
decimal.Decimal(decimal-number).ln()
decimal.log10()函数用于计算传递给它的十进制数的以 10 为底的对数值。
decimal.Decimal(decimal-number).log10()
举例:
import decimal as d
d.getcontext().prec = 2
val = d.Decimal(122.20)
log = val.ln()
print("Natural log value of the decimal number: ",log)
log_10 = val.log10()
print("Log value with base 10 of the decimal number: ",log_10)
输出:
Natural log value of the decimal number: 4.8
Log value with base 10 of the decimal number: 2.1
4.compare()函数
decimal.compare() function比较两个小数点，并根据以下条件返回值
- 如果第一个十进制数小于第二个十进制数，则返回-1。
- 如果第一个十进制数大于第二个十进制数，则返回 1。
- 如果两个小数点的值相等，则返回 0。
举例:
import decimal as d
valx = d.Decimal(122.20)
valy = d.Decimal(123.01)
print("Value 1: ",valx)
print("Value 2: ",valy)
compare = valx.compare(valy)
print(compare)
输出:
Value 1: 122.2000000000000028421709430404007434844970703125
Value 2: 123.0100000000000051159076974727213382720947265625
-1
5.函数的作用是
decimal.copy_abs() function返回传递给它的有符号十进制数的绝对值。
语法:
decimal.Decimal(signed decimal number).copy_abs()
举例:
import decimal as d
valx = d.Decimal(-122.20)
print("Value 1: ",valx)
absolute = valx.copy_abs()
print("Absolute value of the given decimal number: ",absolute)
输出:
Value 1: -122.2000000000000028421709430404007434844970703125
Absolute value of the given decimal number: 122.2000000000000028421709430404007434844970703125
6.最大和最小函数
Python decimal 模块包含以下函数来计算小数点数字的最小值和最大值。
- min()函数:返回两个十进制值中的最小值。
- max()函数:返回两个小数值中的最大值。
#Syntax for min() function-
decimal1.min(decimal2)
#Syntax for max() function-
decimal1.max(decimal2)
举例:
import decimal as d
valx = d.Decimal(122.20)
valy = d.Decimal(123.01)
print("Value 1: ",valx)
print("Value 2: ",valy)
min_val = valx.min(valy)
print("The minimum of the two values: ",min_val)
max_val = valx.max(valy)
print("The maximum of the two values: ",max_val)
输出:
Value 1: 122.2000000000000028421709430404007434844970703125
Value 2: 123.0100000000000051159076974727213382720947265625
The minimum of the two values: 122.2000000000000028421709430
The maximum of the two values: 123.0100000000000051159076975
7.十进制模块的逻辑运算
Decimal 模块包含一组内置函数，用于对十进制数执行逻辑运算，如 AND、OR、XOR 等。
- logical_and()函数:对两个十进制数进行逻辑与运算，并返回结果。
- logical_or()函数:对两个十进制数进行逻辑或运算，并返回结果。
- logical_xor()函数:对两个十进制数进行逻辑异或运算，并返回结果。
#Syntax for logical_and() function-
decimal1.logical_and(decimal2)
#Syntax for logical_or() function-
decimal1.logical_or(decimal2)
#Syntax for logical_xor() function-
decimal1.logical_xor(decimal2)
举例:
import decimal as d
valx = d.Decimal(1001)
valy = d.Decimal(1111)
print("Value 1: ",valx)
print("Value 2: ",valy)
AND = valx.logical_and(valy)
print("The logical AND value of the two decimals: ",AND)
OR = valx.logical_or(valy)
print("The logical OR value of the two decimals: ",OR)
XOR = valx.logical_xor(valy)
print("The logical XOR value of the two decimals: ",XOR)
输出:
Value 1: 1001
Value 2: 1111
The logical AND value of the two decimals: 1001
The logical OR value of the two decimals: 1111
The logical XOR value of the two decimals: 110
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
在那之前，学习愉快！！
参考
- 了解 Python 十进制模块— JournalDev
如何使用 Python delattr()函数？
原文：https://www.askpython.com/python/built-in-methods/python-delattr-function
嘿，读者们！在本文中，我们将重点介绍 Python delattr()函数 。
Python delattr()方法入门
在面向对象编程中，Class 是一个实体，它包装了属性和行为，并用Object来表示它们。
一个类的特性确实存在于 Python 中，因为它是一种面向对象的语言。在创建属性和定义行为时，我们可能会遇到想要删除 Python 类的某些属性的情况。这就是 Python delattr()出现的原因。
The delattr() function用于删除与特定类相关的属性。
语法:
delattr(object, attribute)
举例:
class Info:
name = "AskPython"
lang = "Python"
site = "Google"
obj = Info()
print(obj.name)
delattr(Info, 'lang')
输出:
AskPython
在上面的例子中，我们创建了一个具有如下属性的类信息:
- name = AskPython
- lang = Python
- 网站=谷歌
此外，我们使用下面的命令创建了一个类别为'信息的对象:
obj = <classname>()
创建对象后，我们使用 delattr()函数删除了属性–'lang'。
delattr()的错误和异常
删除一个属性后，如果我们试图访问那个特定的对象，编译器将抛出AttributeError。
举例:
class Info:
name = "AskPython"
lang = "Python"
site = "Google"
obj = Info()
delattr(Info, 'lang')
print(obj.lang)
输出:
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-5-699f50a1e7c7> in <module>
5 obj = Info()
6 delattr(Info, 'lang')
----> 7 print(obj.lang)
AttributeError: 'Info' object has no attribute 'lang'
使用 Python del 运算符删除属性
Python del operator也可以用来直接删除类的属性，不需要通过对象访问。
语法:
del Class-name.attribute-name
举例:
class Info:
name = "AskPython"
lang = "Python"
site = "Google"
print("Attribute before deletion:\n",Info.lang)
del Info.lang
print("Attribute after deletion:\n",Info.lang)
输出:
Attribute before deletion:
Python
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-16-9d8ed21690ff> in <module>
5 print("Attribute before deletion:\n",Info.lang)
6 del Info.lang
----> 7 print("Attribute after deletion:\n",Info.lang)
AttributeError: type object 'Info' has no attribute 'lang'
Python delattr()方法 v/s Python del 运算符
在动态删除属性方面，Python delattr()方法比 Python del 运算符更有效。
另一方面，与 Python delattr()方法相比，Python del 运算符执行操作的速度更快。
结论
因此，在本文中，我们已经通过 Python delattr()方法和 del 运算符了解了属性的删除。
参考
- Python delattr()方法—文档
- Python deattr() v/s Python del 运算符— JournalDev
Python:检测轮廓
原文：https://www.askpython.com/python/examples/python-detecting-contours
你好，学习伙伴！今天我们将学习如何检测图像中的轮廓。轮廓被定义为对象的精确边界，在检测对象时非常有用。
推荐阅读:如何在 Python 中检测边缘？
使用 Python 检测轮廓
因此，让我们开始使用 Python 中的 OpenCV 库来检测图像的轮廓。
1.导入模块
首先，我们导入必要的模块，包括 OpenCV 和 matplotlib 来在屏幕上绘制图像。
import cv2
import matplotlib.pyplot as plt
2.将图像载入程序
下一步包括使用imread函数将图像从文件目录加载到我们的程序，然后将图像转换成RGB格式。
我们将以subplot的形式绘制图像，其中第一个图像是原始加载的图像。相同的代码如下所示。
loaded_img = cv2.imread("image.jpg")
loaded_img = cv2.cvtColor(loaded_img, cv2.COLOR_BGR2RGB)
plt.figure(figsize=(20,20))
plt.subplot(2,2,1)
plt.title("Original Image")
plt.imshow(loaded_img)
plt.axis("off")
3.将图像转换为灰度
为了更好地检测轮廓，我们使用cvtColor功能将图像转换为灰度图像。将图像转换成灰度后，我们将它绘制在主图上的第二个子图上。
gray_image = cv2.cvtColor(loaded_img, cv2.COLOR_RGB2GRAY)
plt.subplot(2,2,2)
plt.title("Grayscale Image")
plt.imshow(gray_image,cmap="gray")
plt.axis("off")
4.获取二进制图像
接下来，我们将图像转换为二进制图像，因为它从图像中移除了不必要的项目，并且只关注重要的对象，从而使图像处理更加容易。
相同的代码如下所示。我们将在主图上的第三个位置绘制二进制图像。
_, binary_img = cv2.threshold(gray_image, 225, 255, cv2.THRESH_BINARY_INV)
plt.subplot(2,2,3)
plt.title("Binary Image")
plt.imshow(binary_img,cmap="gray")
plt.axis("off")
5.检测轮廓
最后一步是使用 openCV 库的findContours方法检测轮廓，然后我们在图像上绘制轮廓。
然后我们绘制子情节中的所有图像，代码如下所示。
contours, hierarchy = cv2.findContours(binary_img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
final_image = cv2.drawContours(loaded_img, contours, -1, (0, 255, 0), 2)
plt.subplot(2,2,4)
plt.title("Contours detected Image")
plt.imshow(final_image,cmap="gray")
plt.axis("off")
输出图
上面解释的整个过程的最终输出如下所示。你可以看到结果非常准确。
Contour Detection Output 1
检测轮廓的最终代码
import cv2
import matplotlib.pyplot as plt
loaded_img = cv2.imread("image1.png")
loaded_img = cv2.cvtColor(loaded_img, cv2.COLOR_BGR2RGB)
plt.figure(figsize=(20,20))
plt.subplot(2,2,1)
plt.title("Original Image")
plt.imshow(loaded_img)
plt.axis("off")
gray_image = cv2.cvtColor(loaded_img, cv2.COLOR_RGB2GRAY)
plt.subplot(2,2,2)
plt.title("Grayscale Image")
plt.imshow(gray_image,cmap="gray")
plt.axis("off")
_, binary_img = cv2.threshold(gray_image, 225, 255, cv2.THRESH_BINARY_INV)
plt.subplot(2,2,3)
plt.title("Binary Image")
plt.imshow(binary_img,cmap="gray")
plt.axis("off")
contours, hierarchy = cv2.findContours(binary_img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
final_image = cv2.drawContours(loaded_img, contours, -1, (0, 255, 0), 2)
plt.subplot(2,2,4)
plt.title("Contours detected Image")
plt.imshow(final_image,cmap="gray")
plt.axis("off")
plt.savefig('Contour_Detection_output_2.png', dpi = 1000,bbox_inches = 'tight')
plt.tight_layout()
plt.show()
我还为不同的图像尝试了相同的代码。结果显示如下。
Contour Detection Output 2
结论
恭喜你！现在你离从图像中检测物体又近了一步。我们今天学习了探测物体的适当边界！
继续学习！编码快乐！
感谢您的阅读！
Python Dict items()方法的 5 个例子
原文：https://www.askpython.com/python/dictionary/python-dict-items-method
嘿，伙计们！在本文中，我们将关注于 Python Dict items()方法来提取和表示字典值。
Python Dict items()方法是如何工作的？
Python 字典是以键值对格式存储数据元素的数据结构。此外，每个唯一键都与唯一/冗余值相关联。
为了迭代和显示字典元素，Python 的 dict items()方法提供了这个功能。
dict.items() method将字典所占用的数据元素显示为键-值对的列表。
语法:
dict.items()
dict.items()方法不接受任何参数并且返回一个包含键值的列表作为字典的元组对。
使用 Python 字典项()返回(键，值)对的列表
在本例中，我们创建了一个字典，并使用 dict.items()方法返回输入字典中所有键值对的列表。
inp_dict = { 'a':3,'ab':2,'abc':1,'abcd':0 }
print("Dictionary: ", inp_dict.items())
输出:
Dictionary: dict_items([('a', 3), ('ab', 2), ('abc', 1), ('abcd', 0)])
使用 Python 字典项返回字符串项
在下面的示例中，输入字典包含字符串值形式的键值对。
因此，可以说dict.items() method 不受键或值类型的影响，并返回 dict 中作为元组对出现的所有元素的列表。
lang_dict = {
'A':'Python',
'B':'C++',
'C':'Kotlin'}
print("Dictionary: ", lang_dict.items())
输出:
Dictionary: dict_items([('A', 'Python'), ('B', 'C++'), ('C', 'Kotlin')])
使用字典项()返回空字典
dict.items()方法不会为空字典抛出任何类型的错误或异常。因此，如果字典为空，dict.items()方法返回一个空列表。
empty_dict = {}
print("Dictionary: ", empty_dict.items())
输出:
Dictionary: dict_items([])
更新值后打印出字典项目
在下面的例子中，我们创建了一个输入字典，并使用 items()函数显示字典值。
此外，我们已经使用 items()方法更新了字典键-值对并再次显示了字典。因此，可以说 dict.items()方法很好地配合了 dictionary 的更新，并以列表格式显示更新后的值。
如果 dict 得到更新，这些变化会自动反映在使用 dict.input()方法显示的列表中。
lang_dict = {
'A':'Python',
'B':'C++',
'C':'Kotlin'}
print("Dictionary before updation: ", lang_dict.items())
lang_dict['B']='Ruby'
print("Dictionary after updation: ", lang_dict.items())
输出:
Dictionary before updation: dict_items([('A', 'Python'), ('B', 'C++'), ('C', 'Kotlin')])
Dictionary after updation: dict_items([('A', 'Python'), ('B', 'Ruby'), ('C', 'Kotlin')])
不使用 Dict items()方法打印出字典元素
我们可以通过调用如下所示的输入字典对象，直接以键值形式显示字典的元素:
input_dict={}
print(input_dict)
上述代码行将返回一个空括号“{ 0 }”。
在下面的例子中，我们使用了 dictionary 对象和 dict.items()方法来显示 dict 键值对。
lang_dict = {
'A':'Python',
'B':'C++',
'C':'Kotlin'}
print("Dictionary: ", lang_dict)
print("Dictionary using items() method:", lang_dict.items())
输出:
Dictionary: {'A': 'Python', 'B': 'C++', 'C': 'Kotlin'}
Dictionary using items() method: dict_items([('A', 'Python'), ('B', 'C++'), ('C', 'Kotlin')])
摘要
- Python dict.items()方法用于以元组对列表的形式显示 dict 的数据元素。
- 如果 dict 为空，则 dict.items()方法返回一个空列表。
- 当我们更新字典时，dict.items()方法会将这些更改很好地合并到输出列表中。
结论
因此，在本文中，我们已经理解了 Python Dictionary items()方法在各种例子中的工作。
参考
理解 Python 字典理解
原文：https://www.askpython.com/python/dictionary/python-dictionary-comprehension
在本文中，我们将了解如何使用 Python 字典理解来轻松创建字典。
与列表理解类似，python 字典理解在一行中用我们的规范构建了一个字典。这避免了创建一个字典实例，然后使用多个语句填充它的麻烦。
让我们用一些说明性的例子来看看我们可以轻松创建字典的一些方法！
基本的 Python 字典理解
例如，假设我们想要构建一个 {key: value} 对的字典，将英文字母字符映射到它们的 ascii 值。
所以，当我们调用my_dict['a']时，它必须输出相应的 ascii 值( 97 )。让我们为字母a-z这样做。
对于不熟悉 Python 代码的人来说，通常的方法是在填充之前创建一个字典，就像这样。
# Create the dictionary
my_dict = {}
# Now populate it
for i in range(97, 97 + 26):
# Map character to ascii value
my_dict[chr(i)] = i
# Print the populated dictionary
print(my_dict)
输出
{'a': 97, 'b': 98, 'c': 99, 'd': 100, 'e': 101, 'f': 102, 'g': 103, 'h': 104, 'i': 105, 'j': 106, 'k': 107, 'l': 108, 'm': 109, 'n': 110, 'o': 111, 'p': 112, 'q': 113, 'r': 114, 's': 115, 't': 116, 'u': 117, 'v': 118, 'w': 119, 'x': 120, 'y': 121, 'z': 122}
虽然上面的代码可以工作，但是我们可以通过调用 Python 字典理解特性使它更“Python 化”，并且只用一行代码就可以做到！
对于字典理解，语法类似于:
my_diict = {key: func(key) for key in something}
甚至是这个
my_dict = {func(val): val for val in something}
这里，something可以是 iterable，产生key或者val。然后函数func将键映射到值，反之亦然。您可以在一行中立即将键映射到值，同时还可以创建字典！
在我们的例子中，val是变量i，而func(val)是函数chr(i)。
所以现在，我们的例子可以简化，但仍然可读的代码！
my_dict = {chr(i): i for i in range(97, 97 + 26)}
print(my_dict)
输出
{'a': 97, 'b': 98, 'c': 99, 'd': 100, 'e': 101, 'f': 102, 'g': 103, 'h': 104, 'i': 105, 'j': 106, 'k': 107, 'l': 108, 'm': 109, 'n': 110, 'o': 111, 'p': 112, 'q': 113, 'r': 114, 's': 115, 't': 116, 'u': 117, 'v': 118, 'w': 119, 'x': 120, 'y': 121, 'z': 122}
这给出了与之前相同的输出！很神奇，不是吗？
虽然上面的例子似乎足以说明字典理解的力量，但我们还能做得更多吗？
答案是肯定的，我们甚至可以在字典理解中加入像if和else这样的条件句！让我们来看看。
在词典理解中使用条件句
我们可以用if和else这样的条件语句来做字典理解。
让我们以第一种情况为例，我们只想使用一个if条件。
字典理解的语法如下所示:
my_dict = {key: value for key in iterable if condition}
在这种情况下，字典将只为 iterable 中满足条件的元素提供映射。
假设我们想从一个列表中构造一个字典，这个列表只将偶数映射到它的平方，我们可以使用字典理解来完成这个任务。
my_list = [0, 1, 2, 3, 4, 5, 6]
my_dict = {i: i*i for i in my_list if i % 2 == 0}
print(my_dict)
输出
{0: 0, 2: 4, 4: 16, 6: 36}
的确，我们的字典里只有偶数，作为键！
现在让我们也用一个else条件来做一个字典理解！
如果还需要else条件，我们需要修改语法以便理解。如果我们希望拥有映射到可能不同的值的相同键，语法应该是这样的:
my_dict = {key: (value1 if condition1(value) is True else value2) for key, value in something}
让我们考虑使用现有的字典构建一个字典。如果是奇数，新字典的值将为 0。否则，它将简单地使用我们以前的字典中的旧值。
old_dict = {'a': 97, 'b': 98, 'c': 99, 'd': 100}
new_dict = {k: (val if val % 2 == 0 else 0) for k, val in old_dict.items()}
print(new_dict)
输出
{'a': 0, 'b': 98, 'c': 0, 'd': 100}
结论
在本文中，我们通过一些说明性的例子学习了如何理解 Python 字典。
参考
浙公网安备 33010602011771号