AskPython 博客中文翻译（四十七）

原文：AskPython Blog

协议：CC BY-NC-SA 4.0

Plotly 等高线图-完整指南

原文：https://www.askpython.com/python-modules/plotly-contour-plot

在本文中，我们将学习 Python 的 Plotly 库，以及创建迷人等高线图的各种方法。我们将看到各种等高线图的例子，每个例子都有详细的代码分析。我们还将学习多种方法来定制一个人的轮廓图。所以，让我们从基础开始。

什么是等高线图？

轮廓是三维表面的二维描述，包括关节和曲线。它是在等高线函数(Z)的帮助下绘制的，等高线函数是两个变量(X 轴和 Y 轴坐标)的函数。

也读作:【Matplotlib 等高线图——完整参考

什么是 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

https://plotly.com/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 中的’+= '操作符，还学习了它的各种实现。

喜欢这个教程吗？无论如何，我建议你看一下下面提到的教程:

1. Python 中的“in”和“not in”运算符
2. Python //运营商——基于楼层的部门
3. Python 不等于运算符
4. 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() 

输出:

各种类型的动物
动物的年龄。
各种类型的动物
年龄的兔子。
各种类型的动物
马的年龄。

推荐阅读:

• Python 中的继承
• Python 中的多重继承

---

编译时多态还是方法重载？

与许多其他流行的面向对象编程语言(如 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 个观察值，所以我们不会将其分成测试集和训练集。这有两个原因:

1. 小的观察没有意义，因为我们没有足够的信息在一组上训练，在另一组上测试模型。
2. 我们想做一个非常准确的预测。我们需要更多关于列车组的信息。因此，整个数据集仅用于训练。

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，x1^{2,……，x1}n.

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 个词类。它们是:

1. 名词
2. 代词
3. 动词
4. 副词
5. 形容词
6. 介词
7. 连词
8. 交叉连接

词性标签提供了关于一个词及其相邻词的大量信息。它可以用于各种任务，如情感分析、文本到语音转换等。

也读:NLP 简介

---

什么是词性标注？

标记意味着将令牌分类到预定义的类别中。词性(POS) 标注是给定语料库中的每个单词标注一个合适的记号，即基于上下文的词性。它也被称为语法标记。

---

词性标注技术

主要有四种类型的位置标签:

1. **基于规则的标记器:**基于规则的标记器根据一些预定义的规则和提供给它们的信息的上下文来为单词分配词性。
2. **随机/概率标记:**这是最简单的词性标记方法。它使用概率、频率和统计。这些标记器找到在训练数据中考虑的文本中给定单词最频繁使用的标记，并将该标记分配给测试数据中的单词。有时，这可能会导致语法错误的标记。
3. **基于内存的标记:**一组案例保存在内存中，每个案例都有一个单词、它的上下文和一个适当的标记。基于保存在存储器中的案例中的最佳匹配，新的句子被标记。
4. **基于转换的标签:**它是基于规则和随机标签的结合。在这种类型中，规则是从数据中自动生成的。此外，还考虑了一些预定义的规则。这两个因素都用于在基于转换的词性标注器中执行词性标注。

---

现在，让我们尝试用 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 模块

原文：https://www.askpython.com/python-modules/pprint-module

读者朋友们，你们好！在本文中，我们将详细关注 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 模型的精度

在继续训练模型之前，让我们创建一个函数来计算模型的准确性。

为了达到同样的目的，我们将创建一个评估函数，将以下内容作为输入:

1. 网络实例
2. 数据点的数量
3. k 的值
4. 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 

在函数内部，我们将执行以下操作:

1. 使用data loader加载数据。
2. 迭代数据加载器中出现的所有人名。
3. 对输入调用模型并获得输出。
4. 计算预测类。
5. 计算正确预测的类别总数
6. 返回最终百分比。

第七步:训练 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 构建国籍分类模型。希望你喜欢它！😇

喜欢这个教程吗？无论如何，我建议你看一下下面提到的教程:

1. 用 Python 分类服装图像——完全指南
2. 使用 Python 进行葡萄酒分类——简单易懂

感谢您抽出时间！希望你学到了新的东西！！😄

---

使用 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 构建一个莎士比亚文本预测器。希望你喜欢它！😇

喜欢这个教程吗？无论如何，我建议你看一下下面提到的教程:

1. 利用 Python 预测股价
2. 用 Python 进行加密价格预测
3. 利用 Python 进行股票价格预测
4. Python 中的票房收入预测——简单易行

感谢您抽出时间！希望你学到了新的东西！！😄

---

用 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)

摘要

今天，我们讲述了预测分析，并尝试使用样本数据集进行演示。希望您已经尝试过我们的代码片段。你也可以尝试获取更多的数据集。我们必须带着一些更令人兴奋的话题再次访问。