修改和操作 Excel 文件(更新销售报告)

图片由作者提供。来自 Unsplash 的背景图片。

本教程系列面向所有想开始使用 python 而不是 Excel 的人，例如，自动化任务或提高速度和可伸缩性。或者只是出于好奇。

这个博客文章系列是为你准备的，当:

• 您可以使用 Excel 合并各种工作表或表格(使用诸如 Index、Match、VLookup
• 使用简单的数学运算，如求和与*均
• 使用条件聚合函数(例如，每个类别的交易总和)或数据透视表

它不会涵盖您需要了解的转储 Excel 的所有内容，也不是本系列的目标。第 1 部分意在让你开始并改变你的思维模式，从 Excel 到 Python/Pandas。第 2 部分将介绍如何通过 python 更新给定的 Excel 报表。

虽然 Excel 有它自己的位置，而且非常快速和方便，但我希望这个博客文章系列能够帮助您探索除 Excel 之外的其他数据处理方式。

目标:

在这一部分中，我们面临的任务是用新数据更新某个 Excel 文件，即销售报告。我们将看到两种方法，其中一种是有意义的，我们将在笔记本的最后讨论进一步使用第二种方法的原因和动机。

要求:

虽然 python 的一些基本经验会有所帮助，但你不必成为一名程序员或数据科学家来遵循本教程。理想情况下，您应该听说过熊猫和 jupyter notebook，并亲自花了一些时间使用 python。

但是不要气馁。试着跟上并阅读我们没有涉及的内容。你可以随时回到这里或者重访其他地方。如果你需要一些个人指导，我们在 www.hosd-mentoring.com的 HOSD 辅导公司提供免费的一对一数据辅导

1.形势

在第一部分中，我们假设你刚开始是一家大型在线零售商销售部门的数据分析师。在过去的几周里，你深入研究了企业产生的各种数据。当然，你还要负责制作定期的销售报告。

该公司以 Excel 模板的形式提供了这些报告的一般结构。最重要的报告之一是月度销售报告。许多企业领导人喜欢这种一站式报告，因为它以数字和视觉的方式展示了企业的健康和发展。

作为一名新员工，你发现这种报告已经过时。您与您的老板交谈，建议使用直接连接到数据源的报告和可视化工具，如 PowerBI 或 Tableau。然而，在这一点上，由于一些奇怪的业务原因，这个选项是不可行的，所以我们被迫尽我们所能处理给定的 Excel 报告。

这就是报告的样子。

作者图片

虽然本教程不是关于做分析，而是关于更新和维护一个给定的 Excel 报表的过程，但是会出现一些策略问题，这些问题可能会导致当前报表的有用扩展。

几个战略问题:

• 随着时间的推移，某些品牌是如何发展的(绝对和相对)？
• 产品类别的发展(绝对和相对)
• 5 大增长和亏损产品

由于现在是 8 月，公司要求我们用下面显示的 7 月数据更新报告。

作者图片

我们可以在 Excel 中完全做到这一点，例如通过创建数据透视表，一个用于品牌，一个用于类别，然后将汇总的销售数字复制到七月份的汇总表中。

然而，虽然这种只有四个品牌和类别以及不到 20 种产品的手工工作是可行的，但该公司预计将在未来几个月内大幅增加其产品。因此，开始建立一个更加可扩展和自动化的过程是合理的。

2.使用 Python 更新 Excel 报表

我们已经知道如何使用 pandas 通过 pd.read_csv 方法读取 csv 文件。幸运的是，熊猫也有读取 Excel 文件的方法: pd.read_excel() 。

让我们看看它看起来怎么样。

import pandas as pd

# Read sales for july
sales_july = pd.read_csv("data/sales_july_export.csv")
sales_july.head()

作者图片

# Read excel file with pandas
monthly_sales_report = pd.read_excel("data/Monthly Sales Report.xlsx")
monthly_sales_report

作者图片

呃！这看起来很奇怪，一点也不像我们在 Excel 中打开的报告。

原因是 pandas 只是试图将每个单元格的内容显示为数据帧中的一个值。因此，格式以及合并和组合的单元格都会被忽略。曾经漂亮的视觉效果不再是有 nan 的空牢房。

通常，在 pandas 中使用 Excel 数据需要清理数据框架，例如删除所有不必要的行和列(如标题)。这个过程被称为切片，你可以在熊猫官方文档中读到更多关于索引和选择数据的信息。

例如，这是品牌表的样子。

# create copy of full report df to slice
monthly_brand_df = monthly_sales_report.copy()

# use first row as header (alternative: set header parameter when reading excel file)
monthly_brand_df.columns = monthly_brand_df.iloc[5]

# only keep relevant rows with data for brand sales
monthly_brand_df = monthly_brand_df[6:11]

# first column is always empty as it exists purely for formatting reasons; drop it
monthly_brand_df = monthly_brand_df.iloc[:,1:]

# reset index after slicing
monthly_brand_df.reset_index(drop=True, inplace=True)

# change column names
monthly_brand_df.columns = ['Brand', 'January', 'February', 'March', 'April',
                            'May', 'June', 'July', 'August', 'September',
                            'October', 'November',  'December', 'Full Year']

monthly_brand_df

作者图片

然而，在这个场景中，我们感兴趣的不是仅仅处理数据，而是用新数据更新报告。事实上，我们只需要接触几个单元格，即对应于七月的单元格。

因此，假设报表的结构保持不变，我们正在寻找一种用指定值填充指定单元格的方法。

因此，我们的方法是:

• 步骤 1:在品牌和产品类别级别上计算七月份的销售额(两个汇总表)
• 步骤 2:将数据写入 Excel 报表，并保存新的更新版本

第一步:计算 7 月份汇总表

本质上，我们将做与使用 excel 中的数据透视表相同的事情，在 excel 中，我们使用品牌作为一行来合计销售额。

作者图片

接下来，我们使用产品类别而不是销售做同样的事情。这就是我们如何使用熊猫在 python 中实现的。

sales_july.head(5)

作者图片

# sales by brand
sales_july_by_brand = sales_july.groupby(["Brand"], as_index=False).agg({"Sales":"sum"})
sales_july_by_brand

作者图片

# sales by category
sales_july_by_category = sales_july.groupby(["Product Category"], as_index=False).agg({"Sales":"sum"})
sales_july_by_category

作者图片

第 2 步:将数据写入 Excel 报表

好了，现在我们已经计算了我们的小例子中需要的所有销售数字，我们可以更新 Excel 文件了。

例如，我们知道我们需要用品牌 a 的七月销售数字更新第行第 6 和第列未命名:8 中的单元格。

# helper functions to color certain cells green
def highlight_cell(x):
    df = x.copy() 
    df.loc[:,:] = '' 
    df.at[6,"Unnamed: 8"] = 'background-color: lightgreen'
    return df 

def highlight_cells(x):
    df = x.copy() 
    df.loc[:,:] = '' 
    df.at[6,"Unnamed: 8"] = 'background-color: lightgreen'
    df.at[7,"Unnamed: 8"] = 'background-color: lightgreen'
    df.at[8,"Unnamed: 8"] = 'background-color: lightgreen'
    df.at[9,"Unnamed: 8"] = 'background-color: lightgreen'
    return df 

def highlight_grandtotal(x):
    df = x.copy() 
    df.loc[:,:] = '' 
    df.at[10,"Unnamed: 8"] = 'background-color: yellow'
    return df# ugly imported excel file
monthly_sales_report.head(15).style.apply(highlight_cell, axis=None)

作者图片

# take sales for Brand A from sales_july_by_brand and write to monthly_sales_report to a specified cell
monthly_sales_report.at[6, "Unnamed: 8"] = sales_july_by_brand.at[0, "Sales"]

# see updates
monthly_sales_report.head(15).style.apply(highlight_cell, axis=None)

作者图片

我们可以通过循环遍历这些行四次来更新其他品牌，并重复上面的操作。

# update July sales for all brand
for i in range(4):
    monthly_sales_report.at[i+6, "Unnamed: 8"] = sales_july_by_brand.at[i, "Sales"]

# see updates
monthly_sales_report.head(15).style.apply(highlight_cells, axis=None)

作者图片

要更新所有品牌的总销售额，我们需要对所有品牌求和，并将结果写入单元格 monthly_sales_report.at[10，" named: 8"]

monthly_sales_report.head(15).style.apply(highlight_grandtotal, axis=None)

作者图片

# calculate sum over all brands for July
total_sum = sum(sales_july_by_brand["Sales"])
print(total_sum)

# write total sum to table
monthly_sales_report.at[10, "Unnamed: 8"] = total_sum

# show updates
monthly_sales_report.head(15).style.apply(highlight_grandtotal, axis=None)11319

作者图片

# Same approach for updating sales per category
for i in range(4):
    monthly_sales_report.at[i+29, "Unnamed: 8"] = sales_july_by_category.at[i, "Sales"]

# see updates
monthly_sales_report

作者图片

# save excel file
monthly_sales_report.to_excel("monthly_sales_report_updated_1.xlsx")

作者图片

替代方案:将数据直接写入 Excel 报表(目前是真的)

当你在阅读最后一节时翻了翻白眼，问自己为什么要用 python 来更新如此复杂的简单 Excel 文件时，我为你提供了另一个选择，而不是使用 pandas。

上面的方法有两个缺点。首先，它太复杂了。第二，从 Excel 加载数据，在数据框架中操作数据，并将其保存回 Excel，这将删除所有格式设置和图形等非数据内容。上面的截图显示。

import xlwings as xw

excel_app = xw.App(visible=False)
excel_book = excel_app.books.open("data/Monthly Sales Report.xlsx")
sheet = excel_book.sheets[0]

# Directly write July sales for Brand A to corresponding cell in Excel
sheet.range("I8").value = sales_july_by_brand.at[0, "Sales"]
excel_book.save()

#excel_book.close()
#excel_app.quit()

当我们切换到 Excel 时，我们可以看到单元格 I8 不再是空的。

作者图片

我们可以使用这种方法将计算出的七月份品牌级别和类别级别的销售额写入相应的单元格。

为此，我们定义了单元格的范围，例如品牌级销售的 I8:I11，并使用了转置选项。否则，数据将从左向右写入一行，而不是一列。

# update a list of cells with a list of values (brand-level and category-level sales) caluclated above
sheet.range('I8:I11').options(transpose=True).value = sales_july_by_brand["Sales"].values
sheet.range('I31:I34').options(transpose=True).value = sales_july_by_category["Sales"].values

作者图片

请注意，与之前的方法不同，我们不需要再次计算总和，因为 Excel 公式仍然保持不变。

此外，图会自动更新，因为它们是基于单元格值的。

因此，这种使用 xlwings 更新 Excel 报表的方法应该是首选方法。

3.但是为什么不继续使用 Excel 呢？

如果完全在 Excel 中完成，你可能会快得多——明白了。我之所以在这里使用这个简单的例子，是为了说明由于 xlwings，使用 Python 向 Excel 中指定的单元格写入值是多么容易，所有的公式和连通图都保持不变。

现在，你为什么想用 python 向 Excel 写值呢？

比方说，你必须更新销售数据，不是每月，而是每天(频率)，不是四个品牌，而是数百个其他子类别(数据量)。

更新的频率会使手工工作不是一个非常有吸引力的选择，而运行预定义的灵活脚本可以在几秒钟内处理更新过程。

子类别的数量，您需要单独的数据透视表或更复杂的条件公式，只支持这一点。与 Excel 相比，Python 在处理更大的数据集时表现更好，因此外包数据处理是有意义的。

此外，Excel 本身无法完成的计算类型怎么办？

假设您想要写入 Excel 文件的输出值不是简单的条件聚合的结果(例如品牌 1 在 7 月的销售额)，而是复杂的机器学习模型的结果(例如使用神经网络预测的销售额)。

当然，您可以导出模型结果并将 Excel 文件连接到输出文件，但是不难想象，将结果直接写入 Excel 表格可能是更好的方式。

Python 作为 Excel 的插件

如果您对此感兴趣，并且希望进一步了解 xlwings 的功能，这里有几篇文章可供跟进:

• Python Excel 与 Xlwings 的集成
• 如何用 Python 为 Excel 增压
• 用 Python 桥接 Excel:XL wings

他在这段 YouTube 视频中描述了他的书的内容。

图片来自 https://www.xlwings.org/book

虽然我个人对此没有任何经验，但使用 xlwings 作为 Excel 中的插件来直接运行 python 脚本而不是复制输出，从而为客户端提供或多或少自包含的 Excel 解决方案的可能性对于某些用例来说可能是一种很大的可能性，因此值得探索。

4.摘要

我们试图通过 pandas 使用我们在第 1 部分中学到的方法更新一个给定的 Excel 报表。然而，**导入和导出 Excel 文件会改变格式，删除公式和图表**。

python 包 xlwings 允许我们直接在指定的 Excel 单元格中编写输出，因此只在我们希望的地方更改文件，同时保持公式和连接图的完整性。

在这样一个简单的用例中，将数据处理外包给 python 可能没有必要。然而，假设品牌和产品的数量以及更新频率显著增加，这证明我们已经在考虑自动更新报告的方法。

此外，一旦我们离开 Excel 的舒适环境，我们使用 python 的能力将是无穷无尽的。我们可以或多或少地使用机器学习模型的输出来扩展报告，而不需要手动导入它们。这些复杂的定制模型中有许多不能仅仅在 Excel 中定义和计算。

因此，这里概述的方法将是我们数据分析师工具箱中的一项好技能。

我再次鼓励你考虑一下你在工作中的情况或者你的个人数据项目，像 xlwings 这样的工具可以帮助你，然后尝试一下。开始总是艰难的，但坚持下去，你会比任何 Excel 专业人员更有效、更快。

不要害羞:)

金融 Python 你应该知道的 7 个有用的库

原文：https://towardsdatascience.com/python-for-finance-7-useful-libraries-that-you-should-know-e422b9e9aaba?source=collection_archive---------4-----------------------

使用这些库开始学习金融技术

DocuSign 在 Unsplash 上拍摄的照片

在这篇文章中，我将分享金融和金融技术中使用的必须知道的 7 个 Python 库/模块。假设你想知道一些公司是如何在短时间内变得更加知名的。在这种情况下，主要是因为他们将 Python 模块整合到了决策过程中。他们能够消除中间商、外包公司和其他处理效率低下的环节，从而在没有任何外国影响的情况下迅速做出决策，更好地了解市场力量。机器学习在金融和金融技术领域的发展中发挥着非常重要的作用。

创建自己的决策模型是获得更大成功的一个好方法。我今天要和大家分享的这些库，也会帮助你获得一些经验。巨大的资源，尤其是如果你打算申请金融科技公司。许多行业越来越依赖编程和计算机科学。

以下是清单:

• PyAlgoTrade
• Pyfolio
• 滑索
• SciPy
• Scikit-learn
• Finmarketpy
• 数字价格

我们开始吧！

1。PyAlgoTrade

Python 上涉及数据科学和金融评估的第一个模块叫做 PyAlgoTrade。该模块是一个基于算法的模块，用于辅助纸面交易和交易营销的实时评估。它在 Bitstamp 上工作，是使用 Python 2.7/3.7 版开发的。该模块非常适合以最小的工作量检索结果，因为结果是基于对历史数据及其模式的研究而提供的。

官方页面: PyAlgoTrade

2。投资组合

单子上的下一个模块是文件夹。与数据科学相关的 python 模块有助于分析金融投资组合的风险。Pyfolio 于 2015 年公开，有一个开源库可供参考。该模块使用基于退货构建的样张，并将交易与贝叶斯分析相结合。Pyfolio 更多的功能包括绘图和基于统计函数创建的时间序列。

官方页面: Pyfolio

3。滑索

Zipline 是另一个专注于财政援助的 Python 库。但是，它是基于事件而不是基于算法的。Zipline 最适合回溯测试和现场交易。它的结构包括一段用 Python 写的 Zipline 代码。此外，财务模块负责通过消除任何偏差来处理每个成本和订单延迟。它由 Quantopian 监管，定期更新，以帮助用户将最新的分析用于金融用途。

官方页面: 滑索

4。SciPy

下一个 python 模块被称为 SciPy。它使用数学算法和函数来达到预期的结果。考虑一下 SciPy，它是 NumPy 模块的扩展，在用户中也很有名。SciPy 使用稀疏矩阵的数值积分和微分方程。然而，它主要是一个 scipy 类和例程的数据库。SciPy 包含的一些函数是 NPV、IRR、IPMY 和 PPMT 的计算。

官方页面: SciPy

说到 SciPy 库，我想分享一下饶彤彤写的这篇关于如何在金融中使用 SciPy 的伟大文章:用 SciPy 进行投资组合优化。

5。Scikit-learn

我们列表中的下一个是 scikit-learn。该模块的功能非常多样和快速，其范围超出了 Python 中可用的财务模块。Scikit-learn 主要用于处理数据、对信息进行分类和消除数据聚类，以帮助进行关于数据科学的复杂分析。该模块是许多处理接口的基础，这些接口仍用于根据库存水*监控生产以及向供应商付款。

官方页面: Scikit-learn

6。金融市场

我们已经接*尾声了，让我们继续读下去。Finmarketpy 是另一个基于金融的 python 模块。它用于市场分析和交易策略，因为该模块带有一个简单的数据库界面，带有预先安装的模板，可快速操作。您可以使用该库在特定时间范围内运行策略，以了解季节性挑战。

Finmarketpy 也是一个优秀的模块，可以用各种参数进行调查和观察数据。Finmarketpy 模块也依赖于 SciPy 中的库。

官方页面: Finmarketpy

7。NumPy

最后，让我们讨论 NumPy，另一个基于数学和计算的有用的财务模块。NumPy 主要用于 Python 中的数学和科学函数。最初的几个版本为它提供了一个长期的财务框架。它最*被更新以计算可用于理解大量数据科学结构的矩阵。正如我们之前所读到的，您可以意识到它的重要性，其中一些财务模块是如何基于 NumPy 模块的。

官方页面: NumPy

结论

在这些财务模块的帮助下，许多企业能够先于竞争对手发现市场中的低效和缺陷。这些模块是用于预测目的和简化解释的最佳工具，否则解释将会变得复杂和令人厌倦。当计算技术在我们的手指下可用时，为什么不使用它呢？希望你今天学到了新的东西。

我们来连线。查看我的博客和 youtube 以获得灵感。谢谢你，

为您提供更多 Python 和金融文章

Python 从 A 到 Z (1)

原文：https://towardsdatascience.com/python-from-a-to-z-8a37e0573773?source=collection_archive---------22-----------------------

你应该知道的 26 个概念——第一部分:从 A 到 J

图片由亚历山大·奈特在 Unsplash 拍摄

Python 是全球领先的编程语言之一。它被用在从数据科学、机器人、网络开发到游戏和快速原型制作的许多环境中。其简单的语法使 Python 程序非常容易阅读和编写，确保了快速的学习曲线。此外，Python 有“电池包”——多个库(标准库和第三方库)，这将极大地方便程序员的工作。虽然与其他编程语言相比，可以更快地达到基本编程水*，但掌握 Python 肯定需要一些时间。在这一系列文章中，我们将详细解释 Python 的 26 个特性，帮助您发现 Python 拥有的巨大能力范围。

蟒蛇

Anaconda 是一个用 Python 管理包和环境的程序。它广泛用于数据科学领域，因为在安装 Anaconda 时，默认情况下会安装数据科学中最常用的包。

如果需要，Anaconda 还允许您通过在 anaconda 提示符下键入命令conda install package_name来安装任何包。安装包时，也可以一次安装多个包，比如命令conda install pandas numpy会同时安装 pandas 和 NumPy。Anacondas 安装最新版本的软件包；但是，如果您的项目需要以前的版本，您可以通过添加版本号来指定它，如下所示:conda install pandas=0.22。

通过分别使用命令conda remove package_name和conda update package_name，Anaconda 还可以用于在您的环境中卸载和更新软件包。

除了包管理器之外，Anaconda 还可以用来创建隔离项目的环境。虚拟环境允许在特定项目的隔离目录中本地安装包。当我们需要在不同的 Python 版本和安装包版本之间切换时，这种方法特别有用。

用 Anaconda 创建虚拟环境非常简单。您只需要在 Anaconda 提示符下键入conda create -n environment_name [python==X.X] [list_of_packages](括号中提供的参数是可选的)。例如，您可以基于 Python 版轻松创建一个名为myenv的虚拟环境，如下所示:conda create -n myenv python==3.6。在这种特殊情况下，我们在创建环境时没有指定要安装的软件包列表。一旦环境被激活，也可以在以后安装附加的软件包。

创建新环境后，您需要通过键入conda activate environment_name来激活它。最后，要离开当前的活动环境，在提示符下键入conda deactivate命令。重要的是要记住，这只是介绍如何将 Anaconda 用作包和环境管理器。由于篇幅有限，还有许多操作和命令没有在本简介中详细说明。

美味的汤

互联网是最重要的信息资源之一；然而，在大多数情况下，很难从网页中获取数据，因为信息是嵌入在 HTML 代码中的。这不像下载一个 CSV 文件那么简单。因此， Python 提供了各种各样的工具来简化从互联网上提取数据的过程。

美汤是一个广泛使用的第三方库，用于从一个 HTML 文档中提取任何数据。它允许您轻松地交互和浏览 HTML 代码，并获得您需要的特定信息(例如页面上的所有图像)。该库提供了不同的方法和属性来从网页中识别和提取所需的信息——使用 Python 字符串方法将是一项非常复杂和耗时的任务(但却是可能的)。

创建一个漂亮的汤对象是任何漂亮的汤项目的第一步。可以用BeautifulSoup构造函数创建一个漂亮的 Soup 对象，传递一个字符串(HTML 代码)作为参数。在下面的例子中，我们使用请求库获得网页(【https://en.wikipedia.org/wiki/Madrid】)的 HTML 代码(作为字符串)。然后，我们用BeautifulSoup解析 HTML 代码，使其更易于获取信息。

提取的 HTML 代码看起来相当混乱，但是BeautifulSoup将这些代码转换成易于解析的树形结构。如上所述， Beautiful Soup 包含了一些从代码中提取信息的简便方法。例如，您可以通过使用find_all('a')方法获得文档中的所有锚标记。此外，您还可以通过在查询中添加关键字参数id或class_来根据 ID 或类名查找 HTML 元素。

您可以使用更多的函数和属性从 HTML 文档中提取信息(在文档中有详细的解释)。

https://beautiful-soup-4.readthedocs.io/en/latest/

需要指出的是，为了从代码中提取特定的信息，您总是可以使用浏览器的开发工具来交互式地浏览 HTML 代码并找到信息所在的位置，然后您可以编写最佳的漂亮的 Soup 查询来检索这个特定的信息。

类

面向对象编程允许将变量和函数组合成一种数据类型，称为类。对于大型程序， OOP 给你的代码增加了组织性，把你的程序分解成更小的部分，更容易理解和调试。

Python 中的类是创建对象的蓝图，由方法和属性组成。要定义一个类，您将使用class关键字，后跟类名(使用 CapWords 约定)。下面的代码定义了由两个属性和一个方法组成的Circle类。

班级圈(图片由作者创作)

属性描述了对象的特征(在本例中是颜色和半径)，并在__init__函数中定义。该函数放在类的开头，在类启动时自动执行。

方法是一个类可以采取的动作(例如计算圆的面积)。它们与函数非常相似(都使用def关键字)，不同之处在于方法是在类内部定义的，而不是在类外部定义的。

定义了类之后，您可以创建一个对象。创建对象的过程称为实例化。在这种情况下，对象将是一个特定的圆，例如，一个半径为 5 的红色圆。

不同的圆形对象(图片由作者创建)

随后，我们可以再次使用Circle类来创建该类的更多实例。所有对象都有相同数量的属性和方法，基本上是因为它们来自同一个蓝图——Circle类。

一旦red_circle对象被创建，你可以使用点符号访问它的属性。同样使用点符号，您可以调用一个类的方法，但是在这种情况下，您必须在括号内指定输入参数。

一个defaultdict工作起来非常像一个 Python 字典，意味着两个类共享方法和操作。defaultdict功能在模块collections中定义。这个模块是 Python 标准库的一部分，意味着不需要额外安装。要访问该功能，我们必须在程序的开头包含from collections import defaultdict。

在字典中，当我们试图访问一个尚未定义的键(不存在的键)时，会引发KeyError异常。

然而，当使用defaultdict时，将创建一个新的键(使用提供给defaultdict构造函数的参数),而不会引发任何异常。该参数必须是一个可调用的对象或无。

在下面的代码中，当试图访问一个不存在的键时，调用函数int。该函数返回的值，在本例中为 0，将被分配给丢失的键。

提供给defautdict构造函数的参数也可以是用户定义的函数(在本例中是 lambda 函数)，如下所示。

编码(字符)

一个字符编码提供了计算机中的字节(原始零和一)和真实字符之间的映射(翻译)。

编码(图片由作者创建)

多年来，编程语言使用 ASCII 作为字符的内部表示。本标准包括 128 个字符使用 7 位信息。它涵盖所有英文字符(它最初是为美国的电子通信开发的)；但是，它未能涵盖出现在其他世界语言中的字符，如带有口音的字符。由于这个原因，在过去的几年中，出现了向 Unicode 编码的转变。该标准包含更广泛的字符和符号，根据编码类型使用 8、16 或 32 位信息，与 ASCII 相比自然需要更多的空间。

除了 ASCII 和 Unicode，Python 还支持多种编码。Python 中可用编码的完整列表可以在codecs模块的 Python 标准文档中查阅。

在处理文本数据时，编码是必须考虑的因素。重要的是要记住，Python 用于需要编码的操作(比如读取文件)的默认编码是 UTF-8。**处理文件时，由于编码不一致而导致字符显示不正确或异常是一个常见问题。**因此，在读取文件时，您需要通过在open函数中包含参数encoding来指定所使用的编码(当它与默认编码不匹配时)。

Findall (re 模块)

使用正则表达式通常可以简化文本处理。正则表达式是用于匹配字符串中字符组合的模式。它们在测试操作中非常有用，这就是为什么 Python 标准库有一个专门处理正则表达式模式的模块——re 模块。这个模块提供了各种各样的函数，在处理文本数据时您肯定会遇到的一个函数是findall函数。

re.findall(pattern, string)函数从字符串(string)中提取正则表达式(pattern)的所有非重叠匹配。函数的第一个参数是一个正则表达式，而第二个参数是我们要搜索的字符串。该函数返回一个字符串列表，其中每个元素都是非重叠匹配的。

Findall 函数(图片由作者创建)

下面的代码从字符串中提取所有数字(包括十进制数字)。我们不打算深入讨论正则表达式如何工作的细节。为此，我们需要再写一篇文章😛。你会盲目地相信这个模式可以提取数字。

如上所示，findall函数返回一个字符串列表，包含所有不重叠的匹配。提取数据后，我们可以很容易地使用 list comprehensions 将列表中的每个字符串转换为 float。

在这种情况下，使用的模式非常简单；然而，正则表达式可以变得更加复杂。它们可以方便地从文档中提取网页、电子邮件、密码或电话号码，是从文本数据中获取信息的一个非常强大的工具。

Get(字典法)

在 Python 中使用字典时，KeyError异常是常见的异常。当用户试图访问一个不在字典中的key时，就会引发这个异常。

在下面的代码示例中，当试图访问字典中不存在的key时，会引发一个KeyError异常。

为了处理这个问题，除了使用try except模块，一个常见的解决方案是采用get方法。该方法返回在指定的key找到的值(如果key可用)。相反，如果key在字典中不可用，get方法返回None或一个自定义值，从不引发异常。

永远记住，为了避免使用字典时出现KeyError异常，您可以从直接访问字典的key切换到使用get方法。这将防止在代码执行过程中出现意外异常。

帮助

在 Python 中工作时，记住每个函数的语法有时是一个挑战，尤其是那些你很少使用的函数。Python help函数提供了对特定函数文档的访问，显示了该函数的功能及其语法。

以下代码总结了hasattr功能。如下所示，help函数打印关于该函数如何工作及其定义的基本信息。

除了help功能之外，Python 还提供了更详细的文档，可以在线查阅。

索引错误

Python 中的有序容器(例如列表或元组)通过位置(索引)来标识它们的元素。 Python 遵循一种称为从零开始的索引的约定，这意味着有序容器中的第一个元素位于索引 0 处。

要访问列表中的元素，可以使用一个索引操作符，它由一对方括号([])和一个索引(从 0 开始)组成，指定要检索的元素。

访问列表元素(由作者创建的图像)

如果您试图访问列表中超出可用元素范围的项目，您将得到一个IndexError异常，如下所示。

出现这种错误是很常见的，尤其是如果您刚刚开始学习 Python 的话。如果您来自 R，错误的索引是您将面临的常见错误，因为 R 与 Python 不同，它使用基于一的索引。

Join(字符串方法)

join方法用于将包含在 iterable 中的字符串连接成一个字符串。该方法的语法如下所示，其中string表示插入 iterable 的每个元素之间的分隔符，而iterable是我们想要连接的字符串的序列(必需参数)。该序列可以是例如列表、元组、字典、集合或生成器。

string.join(iterable)

下面的代码块展示了我们如何使用 Python 中的join方法来连接字符串。正如您所看到的，join方法返回一个字符串，该字符串由 iterable 中的字符串串联而成(在本例中是一个列表)。

iterable 的所有元素都应该是字符串类型的。如果没有，将引发一个TypeError异常，如下所示。要连接一个包含数字的迭代器，我们应该先用str()函数将它们转换成字符串，因为 Python 不做隐式字符串转换。

重要的是要记住join是一个字符串方法，而不是一个列表方法，因为我们称它为字符串而不是可迭代的(列表)。然而，字符串序列(iterable)是join方法的主要参数。

您可能知道，我们还可以使用+操作符连接字符串；但是，这不是连接大量字符串的有效方式。主要是因为+操作符需要在每次使用时创建一个新的对象，导致性能下降。如果您想更多地了解为什么join方法优于+操作符，请阅读下面的文章💚

字符串对象有更多的方法。要了解有关字符串方法的更多信息，可以参考官方 Python 文档，网址为:

这个简短的介绍展示了使用 Python 编程时可能会遇到的一些主要功能和问题。它的可读性、一致性和丰富的库使 Python 成为世界上最重要的编程语言之一，是任何数据科学家都应该拥有的基本资产。

阿曼达·伊格莱西亚斯

Python:从菜鸟到摇滚明星

原文：https://towardsdatascience.com/python-go-from-rookie-to-rockstar-d03fa07a32e8?source=collection_archive---------4-----------------------

数据科学

你还在等什么？

图片由 安德里亚·皮亚卡迪奥 来自 像素

Python 是什么？

Python 是一种解释的(逐行运行代码)高级(隐语表示不那么痛苦)通用(尽情发挥你的想象力)编程语言。

Python 是由吉多·范·罗苏姆在 20 世纪 80 年代末创建的，现在它无处不在。数据科学(pandas、matplotlib 等)、机器学习(Tensorflow、PyTorch 等)、网络应用(Django、Flask 等)、Linux(OS 安装程序)、GUI(PyQT)、视频游戏(PyGame)、3D 动画(作为 Maya、3DSMax 等的脚本语言)以及你能想到的每一个角落。

它受欢迎的原因是它的易用性和全面的标准库。这导致大多数用例的大多数库都是用 Python 编写的，因此，Python 成为进入这些领域(尤其是人工智能和数据科学)的第一扇门。

基础知识

对于任何编程语言来说，一开始都会遇到变量、条件和循环这三种情况。

来源:作者

那我们继续吧。

变量

变量用来在程序内部存储信息，做一些有用的事情(或者有趣的事情)。就像其他语言一样，=用来给变量赋值。最有用的变量类型有:数字、浮点数(带小数的数字)、字符串和布尔值(真或假)。

条件式

条件帮助代码根据条件决定做什么。就像在我们的生活中，如果我们心情好，我们就开心，否则，我们就脾气暴躁。对于 Python，它应该是这样的:

但是，如果我们想在代码中容纳更多的条件呢？别担心，有办法的。延伸我们之前的例子，我们可以说，如果心情好，我们就快乐；如果心情不好，我们脾气暴躁，否则，我们正好处于中间状态。让我们看看 Python 是如何做到这一点的:

对于条件句，你只需要记住大部分的时候，if-else，有时候，if-elif-else。

PS: ==是比较运算符，用于在左侧和右侧的人之间进行比较。

环

循环用于一次又一次地重复相同的任务。如果我让你把数字从 1 加到 10 亿会怎么样？在 Python 中，如果没有循环，它看起来会像这样:

这将是一项真正令人痛苦和沮丧的任务。这就是为什么需要循环的确切原因。这是用 Python 实现上述操作的方法(简单快捷的方法):

range是一个 Python 函数，用于创建一个范围内的值(在我们的例子中，从 1 到 10 亿)。+=表示先求和后赋值，表示*answer += i*也可以写成answer = answer + i。

for循环将会是你经常使用的一个。除此之外，我们还有while循环，它也可以用来解决从 1 到 10 亿以上的数字相加问题，就像这样:

for和while回路可以互换使用。一般来说，for循环用于遍历一列数字或一些数据，而while循环用于等待一个条件。

现在，基本的东西都不碍事了。如果我们能有一些东西允许我们一次存储多个值，那将是非常有用的。假设您正在考虑自动邀请参加聚会，您需要将所有这些姓名和电子邮件地址存储在某个地方。

数据结构

瞧，我向您介绍了数据结构的世界(存储和组织数据的技术)。我们还有另外三样东西:列表、字典和集合。

来源:作者

目录

List 就像日常生活中的任何列表一样，处理以直线方式收集的数据。在 Python 中，一个班级的学生名字、一家公司的股票价格、购物清单以及生活中出现的许多其他清单都可以很好地放在[]中。这里有一个例子:

我们能够把所有这些值存储在漂亮的小盒子里，这很好，但是我们如何把它们取出来呢？重温我们的学生时代，我们都有点名号码(或类似的东西),我们回答那个号码。这里也一样。只有一点小小的不同，这里的编号从 0 开始。

让我们看一个例子:

正如我们所看到的，杂货清单中的第一个元素(“苹果”)对应于点名 0，以此类推。

在 Python 中，每个数据结构都有一些特性。让我们看看下面的例子。

这里有三个突出的新东西:append、len和pop。

append是一种用于在列表末尾添加元素的方法。

len是获取列表长度的方法。

pop用于抛出列表中的 nᵗʰ元素。(我们给 n = 0，所以第一个元素被抛出)。

字典

字典用于存储相互之间有关系的数据。比如国家及其首都，家庭关系或者一个人的信息。举个例子，

在上面的例子中，我们用括号来表示这是一个字典，并且在括号之间有一对括号来表示信息。但是，我们如何称呼这些信息呢？

接着是字典名，在两个方括号之间，你放上键名，就这样。

让我们看看如何在字典中添加键值对。

使用同样的方法，我们使用访问值和赋值操作符(' = ')，我们可以很容易地将新值添加到字典中。

让我们看看如何从字典中删除一个键值对。

为了删除键-值对，我们将键传递给 pop 函数(同名的方法也用于从列表中删除值)。

设置

集合对于存储唯一的项目非常有用。他们有你在高中读过的所有东西。有时，您可能希望检查某个值是否重复，或者只保留唯一的项目(一个大列表中唯一城市的数量)，set 就是您想要的。让我们看一个例子。

首先，set 也使用括号但是没有 key:value 对，这对 Python 理解发生了什么没有任何问题。接下来，由于a = {}将被 Python 当作一个空字典，我们使用a = set()创建一个新的空集。

从上面的第 1 行到第 4 行，我们看到即使在第一个语句中，我们已经放置了重复的元素，但是仍然只保留了唯一的值。

从第 6 行开始，我们看到在一个空集里，即使我们把相同的值放两次，也只能保留 1。

上面，我们还学习了如何在集合中添加元素。现在，让我们看看如何删除它们。

为了从集合中删除一个元素，只需给 remove 方法一个值。

现在，正如我所承诺的，让我们来看一个高中的例子。

快速复习:

• 两个集合的并集获取两个集合中的所有唯一元素。
• 两个集合的交集得到集合之间的公共元素。
• 两个集合的差得到第一个集合中不在第二个集合中的元素。
• 两个集合的对称差在两个集合中都得到唯一的元素，除了在两个集合中共同的元素。

因此对于 Python 中的集合:

• | =联合
• & =交集
• • =差异
• ^ =对称差

遍历数据结构

有必要遍历我们创建的数据结构。Python 的好处在于，对于上面的任何一种数据结构，我们的做法都没有太大的不同。让我们来看看。

一个简单的 for 循环可以用来遍历任何数据结构。我是在浏览数据结构时的代表。

相同的 for 循环可用于遍历字典键，我们已经知道如何获取字典中某个键的值，因此也可以访问它。

最后，不做任何修改，同样的循环的也可以用于集合中的值。

利用我们上面学到的，你可以用 Python 做任何事情。我们将在前面学到的东西会让我们减少这样做的努力。这也将有助于在将来我们不得不做更改时维护我们的代码。

功能

在 Python 中，函数非常有用，可以帮助我们一次又一次地重复同一套指令。就在上面我们已经看到了同样的一组指令可以用来查看列表、字典和集合中的值。当你继续用 Python 构思时，事情会变得复杂，一遍又一遍地写同样的代码不是对你的时间和动机的最好利用。这就是函数有用的地方。让我们看一个例子。

在上面第 4 行的例子中，我们看到函数*显示。*

每个函数都以关键字 def 开头，后跟函数名，在我们的例子中是 show ，在后面的括号中，参数用逗号分隔。在我们的例子中，我们只有一个自变量数据。

在随后的几行中，我们编写了一组我们不想再重复编写的重复指令。在函数中，我们对函数的参数进行操作。

以前，我们必须编写 example_list 或 example_set 来遍历它，但是现在，我们使用数据来做同样的事情。数据在我们的函数中充当示例 _ 列表或示例 _ 集合的占位符。这允许我们通过将 example_list 和 example_set 视为相同来避免再次编写相同的代码。

还有更复杂的函数，需要更多的代码行来完成它们的工作，这就是你将真正意识到函数的用途的地方。除此之外，在未来，如果你想改变你的代码，你只需要在一个地方进行修改。

但是，随着系统变得越来越大，这些代码的大小也在增长。一个人再也无法处理这件事了。此时此刻需要更多的结构。除了结构的需要，一个大的代码必然会有一部分代码具有相似的功能和相似的数据。为了适应这一点，类的概念出现了。

班级

我们举个例子。假设您有一些数字数据，对于这些数据，您需要计算它的*均值(所有数字的*均值)和方差(整个数据与*均值相差多少)。我们要做的计算会变成函数，是的，我们可以把数字数据列表传给他们，我们就能得到答案。但是，如果它们可以打包在一起就好了，因为它们是相关的。

如果需要这些函数，我们可以在类中找到。否则，他们可能会迷失在代码的海洋中。作为人类，我们渴望混乱中的结构。现在，让我们看看我们的数值数据类是什么样子的。

PS: 类是一个对象的蓝图。正是通过对象，我们使用类中的功能。

sum()是 Python 中的一个函数，用于计算列表的总和

上面我们有一个类的例子。创建一个类首先需要的是关键字 class ，正如我们在第 1 行中看到的。在第 2 行，我们看到了 *__init__* 函数，它不是创建一个类所必需的，但是我在这里展示它是为了演示它的用途。 *__init__* 函数允许存储将由该类的所有方法共享的内容。在我们的例子中，这就是我们要计算*均值和方差的数组。

下一个突出的是自我。 Self 代表从类中创建的对象。因此*，self.data* 是一个属于 self 的变量，并且由于 self 被提供给类中的每个函数，我们可以很容易地使用该数据，而不用将其作为参数传递。

在第 16 行，我们看到对象 *num。*为了创建它，我们首先编写类名，然后在括号中加上 arr 。它实际上是在调用我们在类定义中编写的 init 函数。 init 也称为构造函数，因为它有助于对象的构造。因此，传递给类以创建对象的内容由 init 函数或构造函数决定。

类允许您在代码上编织一个全局结构，并使其易于导航未来的变化。

结论

有了上面的知识，你现在可以认为自己是 Python 中的摇滚明星了。实践上面展示的所有内容，阅读更多关于 Python 的功能。这是一个伟大的美丽和奇妙的世界，给你无限的可能性。

探索愉快！

Python 曲棍球初学者分析教程

快速掌握 Python 的基础知识。

作为教程的一部分，您将构建此图表。

目录

• 什么是 Python？
• 要求
• 安装 Python
• 安装和升级 Pip
• 安装上下曲棍球刮刀
• 安装 Jupyter Lab
• 打开 Jupyter 实验室
• 开始教程
• 导入我们的包
• 刮数据
• 清理数据
• 让数据好看
• 准备用于分析的数据
• 分析数据
• 可视化数据
• 进行更深入的分析

Python 是什么？

Python 是一种开源编程语言，可用于各种应用，如数据分析、数据科学和数据可视化、软件和 web 开发，以及为系统编写脚本。Python 如此强大，以至于 MacOS 的某些部分实际上依赖于它，这种强大的功能与 Python 直观、用户友好的语法相结合，使它成为世界上最流行的编程语言之一。

如果这听起来像是你想学的东西——尤其是在分析曲棍球统计数据的背景下——那你来对地方了。在本教程结束时，您不仅将对 Python 作为一种编程语言有一个基本的了解，而且您将能够熟练地使用 Python 来自己执行小范围的数据分析。

本教程相当全面，应该需要几个小时才能完成。完成其中的一部分，休息一下，然后在不同的时间完成剩下的部分，这完全没问题；你不是在比赛。

要求

为了完成本教程，您需要以下内容:

• 能够运行 Python 3.6 或更高版本的工作计算机。
• 使用曲棍球分析学 Python 的愿望。

就是这样！其他的一切都将通过本教程提供给你。本教程将引导您完成安装 Python 的过程和您将要编码的环境，并且假设您没有 Python 或任何其他编程语言的知识。

安装 Python

这是我最不喜欢的部分。到目前为止。老实说，这可能是最难的。但是它需要被完成。

本教程利用了一个需要 Python 版的包。即使您安装了 Python，在确认您的版本足够之前，也不要跳过这一步。

不管你的操作系统是什么，你都需要在安装过程中进入你的终端/命令提示符。对于不熟悉在 terminal 中工作的人来说，这可能是非常令人畏惧的，但是一旦你投入进去，事情就不会太糟糕。

如果你在这个过程中遇到任何问题，或者你正在使用 Linux，我建议你看看来自 Real Python 的 Python 3 安装指南 **。**此外，如果您使用的是 Windows，您可能会发现这个视频很有帮助: Python + JupyterLab 安装&路径集指南 — Windows

根据您的操作系统，请按照以下步骤开始操作:

Windows 操作系统

按下键盘左下角的 windows 键，键入 cmd，然后打开命令提示符。进入后，输入以下命令查看您安装的 Python 版本:

python --version

如果您还没有安装 Python，或者您已经安装了 Python，但是您没有版本 3.9.4(本文撰写时的最新版本)或更高版本，您将需要打开 Microsoft store 并通过它安装最新版本。(如果您安装了 3.9.4 或更高版本，请跳到下一步。)

使用键盘左下方的 Windows 键打开 Microsoft Store，并进行搜索。然后，进入商店后，在应用商店的搜索栏中搜索 Python，并选择最新版本。点按屏幕右上角的“安装”来下载应用程序。下载完成后，在终端中输入以下内容:

python --version

你应该看到 Python 3.9.4。如果是的话，那么恭喜你，你已经安装了 Python！您现在可以前进到安装和升级 pip 。如果没有，你可能在某个地方走错了。如果您仍然看到 3.6 或更高的版本，您可能会没事。如果不是，你需要重新追踪你的步骤…

马科斯

如果你有一台 Mac，你可能已经安装了 Python，但是你使用哪个版本的 Python 将取决于你的操作系统。为了确定哪个版本，请通过按 command + space 打开 spotlight search，键入 Terminal，然后按 enter。打开终端后，通过分别输入以下命令来检查 Python 版本、Python 2 版本和 Python 3 版本:

python --versionpython2 --versionpython3 --version

这里唯一真正重要的是 Python 3 版本的输出。您将需要使用最新版本的 Python(本文发布时是 3.9.4)，所以如果您的 Python 3 版本不是这个版本，或者您根本没有 Python 3，您将需要安装它。(如果没有 Python 3，可能一输入就提示安装。请忽略此提示，并按照这些步骤进行操作。)只需几个步骤就可以安装 Python 3:

2)点击最新的 Python 3 版本。

3)点击适合您的 macOS 版本的 macOS 安装程序。(这很可能是 macOS 64 位 Intel 安装程序。)这样做会下载官方的安装向导。官方安装程序非常简单，会指导你完成剩下的过程。

恭喜你！你刚刚安装了 Python。现在，您可以关闭安装窗口，并将安装包移到垃圾箱中。

安装和升级 pip

Pip 是 Python 的一个包管理工具。根据您的操作系统，您可能已经有了 pip，但是我们不想在这里讨论任何可能，所以在终端/命令提示符下运行以下命令来确定您拥有的是哪个版本:

**Windows** python -m pip --version**macOS** python3 -m pip --version

如果您已经安装了 pip，您可以通过运行以下命令来升级它:

**Windows** python -m pip install --upgrade pip**macOS** python3 -m pip install --upgrade pip

1. 点击此链接，在另一个选项卡中打开一个巨大的 Python 文件。

2)右键单击选项卡并选择另存为。将文件保存为名为 get-pip 的 Python 文件。确保将 get-pip 保存在您将从中运行命令的用户目录中。

3)返回到您的终端，输入以下命令:

**Windows** python get-pip.py**macOS**
python3 get-pip.py

这会运行您刚刚下载的 Python 脚本，并安装一个名为 pip 的模块。Pip 是一个软件包安装程序，它将使你今后的生活更加轻松。

安装自上而下曲棍球刮刀

现在有趣的部分来了:安装 TopDownHockey 刮刀。在您的终端中，只需输入以下命令:

**Windows**
python -m pip install TopDownHockey_Scraper**macOS**
python3 -m pip install TopDownHockey_Scraper

这不仅会安装最新版本的 scraper(在撰写本文时是 1.0.6)，还会安装其他必需的包，如 bs4、numpy 和 requests，前提是您还没有安装它们。如果您在安装时看到警告，请记下它们，但现在先把它们放在一边，然后进入下一步。

安装 Jupyter 实验室

Jupyter Lab 是一个集成开发环境(IDE)。对于那些不熟悉这个术语的人来说，你基本上可以把 IDE 想象成一个运行代码的地方。Jupyter 实验室特别为运行 Python 提供了一个非常用户友好的界面，我已经将本教程的后半部分打包成了一个 Jupyter 笔记本，您可以在 Jupyter 实验室访问它。下载它有一点痛苦，但是环境本身会比最初的下载给你带来更多的麻烦。

要下载这款出色的 IDE，请进入终端并输入以下命令:

**Windows**
python -m pip install jupyterlab**macOS**
python3 -m pip install jupyterlab

如果你能够毫无问题地安装它，你可以前进到打开 Jupyter Lab 并忽略接下来的步骤。但是，如果在安装过程中，您收到如下消息:

WARNING: The scripts jlpm.exe, jupyter-lab.exe, jupyter-labextension.exe and jupyter-labhub.exe are installed in 'C:\Users\YourName\AppData\Local\Packages\PythonSoftwareFoundation.Python.3.9_qbz5n2kfra8p0\LocalCache\local-packages\Python39\Scripts' which is not on PATH

您需要更新您的路径。这个过程将取决于您的操作系统。

Windows 操作系统

1. 通过在搜索栏中键入控制面板并打开它来打开控制面板。
2. 选择用户帐户，然后在用户帐户中，再次选择用户帐户。
3. 选择更改我的环境变量。
4. 在用户的环境变量中，突出显示“Path”变量并选择 edit。
5. 在编辑环境变量屏幕中，选择“New”并逐个输入三个新路径:

C:\Users\YourName\AppData\Local\Packages\PythonSoftwareFoundation.Python.3.9_qbz5n2kfra8p0\LocalCache\local-packages\Python39\ScriptsC:\Users\YourName\AppData\Local\Programs\Python\Python39\C:\Users\YourName\AppData\Local\Programs\Python\Python39\Scripts\

(一定要把你的名字改成你的用户名！)

完成这些步骤后，请确保单击确定以确认您的更改，然后离开控制面板。(如果你对这个过程有疑问，我制作了这个视频，可能也会有所帮助。)

macOS

我没有苹果电脑作为我的个人电脑，所以我不能在这里建立一个视频或验证过程。但是，根据 JupyterLab 文档，这是修复路径的方法:

如果使用pip install --user安装，您必须将用户级bin目录添加到您的PATH环境变量中，以便启动jupyter lab。如果你使用的是 Unix 的衍生版本(FreeBSD，GNU / Linux，OS X)，你可以通过使用export PATH="$HOME/.local/bin:$PATH"命令来实现。

尝试在终端中输入导出路径命令。

开放 Jupyter 实验室

一旦您安装了 Jupyter Lab 并准备打开它，请打开一个新的终端窗口并在其中运行以下命令:

**Windows**
python -m jupyter lab**macOS**
python3 -m jupyter lab

如果你成功打开了 Jupyter 实验室，你现在可以开始教程。

**如果您仍然无法让 Jupyter Lab 在路径上运行，**但是您已经安装了 Python，请尝试以下两个命令:

**Windows** python -m pip install jupyter notebook
python -m notebook**macOS** python3 -m pip install jupyter notebook
python3 -m notebook

这应该会打开一个 Jupyter 笔记本浏览器，和 Jupyter 实验室很像。它没有一些相同的功能，但在最坏的情况下，它仍然足以完成本教程。

开始教程

如果您已经成功打开 Jupyter Lab(或 Jupyter Notebook),“终端”将在您当前使用的窗口中打开一个新标签。它应该看起来像这样。

这是 Jupyter 实验室的主屏幕。如果你在这里成功了，你基本上就自由了。如果你只是设法打开 Jupyter 笔记本，你会看到更多这样的东西:

如果您看到以下内容:

进入你的终端，从命令提示符下复制并粘贴两个 URL 中最上面的一个到你的浏览器中。

本教程的其余部分对您来说应该相对容易。现在你已经进入了，是时候为这个教程下载交互式 Python 笔记本(ipynb)了。

然后在 Jupyter Lab 中，单击屏幕左上角的文件夹选项卡，导航到下载它的目录，双击打开它。如果在 Jupyter Notebook 中，默认情况下会列出您的目录，您可以简单地通过这种方式导航到那里。

无论哪种方式，一旦您打开教程，您应该会看到类似这样的内容:

如果你和我一样，这对你来说太亮了。在做任何其他事情之前，对自己好一点，将鼠标悬停在设置、JupyterLab 主题上，然后切换到 JupyterLab 黑暗模式，将事情更改为黑暗模式:

那好多了。也可能不是，在这种情况下，您可以随意切换回光照模式。不管怎样，我们开始吧。

这是一个交互式 Python 笔记本。它使运行代码变得容易一百万倍。在 Jupyter Lab 中，您可以同时打开多个笔记本。继续操作，再次点击左上角的文件夹图标将其最小化，因为我们不再需要它，同时关闭启动器选项卡。下面屏幕截图中可见的单元格是 markdown 单元格，构建这些单元格是为了直观地显示文本，而不是为了执行代码:

您可以通过查看选项卡正下方(Jupyter 实验室内)并看到该单元格类型被列为减价单元格来确认这一点。如果您按 shift + enter，Python 将有效地“执行”markdown 单元格(在本例中不做任何事情)并移动到下一个单元格。现在你在下一个包含代码的单元格中，Jupyter 实验室将它列为代码单元格。

现在，关于 Jupyter Lab，您真正需要知道的是使用 shift + enter 运行命令。然而，如果你有兴趣了解更多关于这个接口的信息或者你有问题，我建议你参考官方文档。

从现在开始，我将在这篇中型文章中提供一个演示，它基本上与 Jupyter 实验室中的演示相同，只是提供了一些截图来显示您的输出应该是什么样子。如果你愿意，你可以随意关闭这个浏览器，把 Jupyter 实验室切换到全屏，在那里完成这个教程；只需记住使用 shift+enter 来运行单元格，如果您对输出的外观感到困惑，请参考本教程。或者，如果您执意要在 Jupyter Lab 之外的不同环境中运行您的代码，您可以在该环境中键入屏幕截图中的所有命令。

事不宜迟，让我们开始吧。

导入我们的包

这些包中的每一个都已经被放到了 TopDownHockey_Scraper 中，所以你已经把它们安装到了你的电脑中。以下代码行将它们导入到您当前的 Python 会话中。

您实际上是在运行五个独立的大型 Python 代码库，每个代码库在您的会话中存储各种函数和变量。特别是 TopDownHockey Scraper 在其代码末尾有几个 prints 语句，它写下了您所看到的消息。

搜集数据

我们将使用TopDownHockey_Scraper包中的TopDownHockey_EliteProspects_Scraper module从精英潜在客户那里收集数据。

• 一个模块是一个包含 Python 语句和定义的文件。它也可以被认为是一个代码库。Python 包是模块的集合。

请注意，我们将每个模块都作为全名的缩写导入。这是因为为了从一个模块中调用一个函数，我们每次都需要在函数前面键入模块的名称，而键入这些较短的名称要容易得多。例如，当我们稍后从TopDownHockey_EliteProspects_Scraper模型中调用get_skaters函数时，我们将键入tdhepscrape.get_skaters。这比敲TopDownHockey_EliteProspects_Scraper.get_skaters更有效率。

get_skaters函数有两个参数:一个或多个赛季和一个或多个联赛。在这种情况下，我们将收集过去两个赛季的 AHL 和 NHL 数据，这意味着我们将构建两个lists，然后将它们提供给我们的函数。

• 列表是以一定顺序存在的一组可变元素。在这种情况下，我们的列表将由两个字符串组成。

我们的函数将抓取我们提供的联赛和赛季的所有数据，并返回一个dataframe。

• 数据帧是包含行和列的二维数据结构。

我们将把这个数据帧分配给一个名为ahl_nhl_skaters_1719的对象。

下一个单元格顶部的“时间魔法”功能会告诉你刮花了多长时间。它应该需要大约一分钟。

清理数据

数据清理不是任何人的最爱，但它是数据分析的关键部分。您在分析开始时花在清理数据上的每一分钟都是对最终产品的投资，大多数情况下，您将获得正的投资回报。在早期识别和解决问题要容易得多。

在清理数据之前，我们想做的第一件事是查看一下数据。我们之前的命令将函数的输出存储为一个名为 ahl_nhl_skaters_1719 的数据帧，其中包含了我们需要的所有数据。让我们从看看这个对象开始这个过程。

我们打印的数据帧的左下角告诉我们，我们正在处理 4，088 行和 14 列。当我们查看我们的专栏时，我们会看到一个链接、一些识别信息和一些 boxcar 统计数据(对于那些不熟悉这个术语的人来说，这只是一个术语，指的是通过加号/减号进行的游戏的统计数据)。

Ou 播放器和 playername 专栏其实差不多，可以去掉一个；理想情况下，丑陋的球员列包含冗余的位置数据。为了做到这一点，我们将使用drop。

• Drop 允许您指定要从列或行中删除的标签。

如果你对事物是全新的，下面的线可能看起来令人生畏，但是它实际上是非常简单的。以下是指挥系统的工作方式:

• 我们的代码行以ahl_nhl_skaters_1719 =开始，这意味着在此之后的输出将被分配给一个同名的对象。
• 我们已经创建的对象(也称为 ahl_nhl_skaters_1719)是我们将要应用函数的对象。(本质上，我们将覆盖它。)
• ahl_nhl_skaters_1719.drop中的句点告诉我们，我们将在该对象上使用 drop。
• 在括号中，我们指定了将要删除的内容:名为 player 的列。

如您所见，没有输出被打印出来，因为我们将命令的输出赋给了一个新变量，而不是只打印它。让我们通过打印来再次检查我们是否做对了:

好吧，我们做了我们想做的。这个新的数据框架更好，但还远远不够理想。我们有我们的球队，然后是我们的 boxcar 统计，然后是一个大的丑陋的链接，只有在这之后我们才能真正看到赛季，联赛，球员和位置。理想情况下，这个关键标识符信息应该在开始，我们的 boxcar 统计数据应该在后面，只有这样我们才能看到链接。

为什么我们要看到链接栏呢？又大又丑，好像也没加什么东西。理想的布局难道不是没有这一列吗？

在完美的世界里，是的。但在这个不完美的世界里，我们偶尔会把两个完全不同的同名玩家搞混。为了演示，我们将使用loc只过滤出名字与 Sebastian Aho 相同的玩家。

• loc 允许我们根据一组行和列的标签是否满足某个标准来定位它们。(官方文档没有确认 loc 是否代表任何东西，但我喜欢认为它代表 locate，它可能会帮助你这样想。)

在我们运行它并查看我们的 Sebastian Ahos 之前，让我们回顾一下这行代码的命令链:

• ahl_nhl_skaters_1719.loc中的句号告诉我们，我们将在这个对象上使用loc函数。
• 在括号中的loc函数中，ahl_nhl_skaters_1719.playername中的句点告诉我们，我们正在从该数据帧中选择 playername 列。这将返回一个series。(A 系列是带轴标签的一维数组)。
• 然后我们设置playername系列等于 Sebastian Aho(使用两个等号。在 Python 中，我们一般用一个等号来给对象赋值，用两个来判断对象是否相等。
• 本质上，这仅定位我们选择的系列中的值——playername列中的值——正好等于 Sebastian Aho 的行和列。

等等，什么？为什么在我们的数据框架中没有一个球员的名字和塞巴斯蒂安·阿霍一模一样？岛民组织中的防守队员可能是一个狂热的梦想，但绝对有一个塞巴斯蒂安·阿霍在卡罗莱纳飓风队中担任中锋。他在 2018-2019 赛季场均得分超过 1 分！这里没有叫塞巴斯蒂安·阿霍的人，这不对吧？

从技术上来说，它是可以的，事实上也的确如此。不幸的是，我们的数据带有一些空白。为了演示这一点，我们将使用iloc。

这里，我们将使用 iloc 来定位轴标签为 0 的行。(在 Python 中，索引以 0 而不是 1 开始。)下面是这段代码的命令链的运行方式:

• 就其本身而言，ahl_nhl_skaters_1719.playername返回一个包含数据帧中每个球员名字的序列，其顺序与他们在数据帧中的顺序相同。
• 在这个列表中，iloc函数将定位我们的系列中所有轴标签为 0 的值。

嗯，你看看这个:在特里的 y 和表示名字结尾的单引号之间有一个空格。克里斯·特里显然存在于数据库中，但如果我们过滤名字完全是克里斯·特里的球员，我们将一无所获。亲自尝试一下:

有几种方法可以处理这个问题，但最简单的方法是清除 playername 字段中的空白。为了做到这一点，我们将使用str.strip()。

让我们分解下一个单元格中的命令链:

• 我们没有将语句的输出分配给 ahl_nhl_skaters_1719 数据帧，而是将其分配给ahl_nhl_skaters_1719.playername列。
• 我们在原来的列上使用.str.strip()来删除这个字符串两端的空白。
• 完成后，我们只想看看我们的塞巴斯蒂安·阿霍斯和克里斯·特里。我们不是只传递一个语句给loc，而是传递两个，并使用|来定位满足第一个或第二个标准的情况。(|在这种情况下可以解释为或。我希望 Python 能让我输入 or，但是乞丐不能挑肥拣瘦。)

这证实了两件事:

1. 我们的 str.strip()函数起作用了，我们成功地去掉了克里斯·特里名字周围的空格。
2. 有两个塞巴斯蒂安·阿霍。

理论上，我们可以通过使用名称和位置作为标识符，或者使用包含 playername 旁边的位置数据的原始 player 列来解决 Aho 问题。因为一个塞巴斯蒂安·阿霍是前锋，一个是防守队员，这将允许我们区分他们两个。

这种方法的问题是同名球员并不总是踢不同的位置。每一对塞巴斯蒂安·阿霍斯和科林·怀特打两个不同的位置，就有一对埃里克·古斯塔夫松或埃里克·卡尔松打相同的位置。(另一个叫埃里克·卡尔松的防守队员从未在 NHL 打过球，但他确实存在，他毁了我的 NHL 模型。)虽然这个项目的范围很小，但是您最终可能会过渡到范围更大的项目，并且需要一个适当的过程来处理这些问题。

值得庆幸的是，每个玩家都有自己独特的精英前景页面，因此也有自己独特的链接。再看看我们的塞巴斯蒂安·阿霍斯；布里奇波特的防守队员和卡罗莱纳的前锋有着不同的联系。他们并不都在这里，但两个埃里克·古斯塔夫森也是如此。这就是我们保持联系的原因。因为我们已经有了联系，我们不需要再担心像塞巴斯蒂安·阿霍这样的搭档。我们一开始并不真的需要清理我们的数据，但这是一个很好的实践，可以确保在继续前进之前做到这一点。

让数据看起来不错

我们陷入了塞巴斯蒂安·阿霍斯的兔子洞，完全偏离了主题，但请记住我之前为我们的数据设定的理想顺序:球员、赛季、球队、联赛和位置，然后我们的 boxcar 统计数据按照它们出现的顺序排列，最后是那个可怕但有用的链接。我们将使用 loc 告诉 Python 要保留哪些列，并实际上按照我们想要的顺序传递所有列。我们还将rename那个丑陋的 playername 专栏。

• 重命名改变轴标签。

让我们在下面几行代码中分解命令链:

• 我们在数据帧上使用了loc功能。
• 我们使用两组支架，而不是一组支架。在外层括号中，我们简单地从:, 开始。这通知 Python 我们将处理列而不是行。
• 在第二组括号中，我们传递一个我们希望保留的列名列表。在这种情况下，我们实际上保留了所有内容，只是顺序与之前不同。
• 一旦第一行完成，ahl_nhl_skaters_1719 现在已经被覆盖，以反映我们的变化。在下一行中，我们使用 rename 语句。这类似于我们之前使用的 drop 语句，只是我们输入列的原始名称，一个冒号，然后输入您希望该列更改的名称。

这看起来棒极了！我们的数据是干净的，我们准备向前迈出一步。

为分析准备数据

还记得我们过去是如何用 loc 过滤掉名字叫克里斯·特里或者塞巴斯蒂安·阿霍的球员的吗？现在我们将使用 loc 构建两个独立的数据框架:一个用于 2017-2018 AHL 赛季，一个用于 2018-2019 NHL 赛季。

既然我们已经设置了两个独立的数据帧，我们将merge这两个数据帧并创建一个名为 ahl_1718_nhl_1819 的新数据帧。

• merge 将共享公共列或索引的两个数据帧放在一起。

在我们运行下一行命令之前，让我们用一幅有用的图像来分解命令链:

• 我们在 ahl_skaters_1718 上执行merge函数，并将我们的 nhl_skaters_1819 作为第一个参数传递给我们的函数。这意味着我们将合并 2017-2018 款阿勒和 2018-2019 款 NHLers。
• 我们在链接上合并，这意味着我们使用玩家链接作为公共字段。本质上，我们添加了 2018-2019 年的 NHL 数据，用于与 2017-2018 年的 AHL 选手有相同联系的选手。
• 我们将使用的合并类型是inner合并。下面的文氏图显示了不同类型的合并。(在这种情况下，合并和连接是可以互换的。)
• 我们内部的合并意味着我们将只保留 2017-2018 年的 AHL 球员，他们也在 2018-2019 年出现在 NHL。

呀！我们的合并是成功的，我们得到了一个相当于 302 名球员的可靠样本，他们这一年在 AHL 打球，下一年在 NHL 打球，但是我们得到了一堆难看的列，上面有 x 和 y。

当我们合并两个具有相同名称的列的数据帧时，如果我们不在这些列上连接，就会发生这种情况:具有相同名称的列会重复。

这不是世界末日。其实挺好办的。我们知道新数据框的左侧(其列名附有 x)包含 2017-2018 年的 AHL 数据，我们知道右侧包含 2018-2019 年的 NHL 数据。(如果我们忘记了，我们的数据帧的名称实际上是一个提醒。)我们还知道，这些球员在不同的赛季不会改变名字或位置，所以我们可以只保留数据左侧的球员和位置，而删除右侧的球员和位置。

所以我们有 6 列要删除。让我们先做那件事。

看起来已经好多了，但还是有点乱。在我们做任何事情之前，我们应该将我们的链接字段移动到数据帧的最右侧，尽可能地远离我们的视线和头脑。不过，我们不是按照我们想要的顺序输入所有 19 个列名，而是要加快这个过程，并且用列表和附加到列表上的函数来获得一点乐趣。

• 列表可以用许多不同的方式操作。

让我们具体分析下一个单元格中的内容:

• 我们首先创建一个列表，它只是我们的数据框架中的列的名称。
• 我们在列表中使用基于列表的remove方法来删除列表中的第一个项目“link”。
• 请注意，与将更改分配给其他对象(如数据帧)不同，列表不需要使用等号进行严格的分配，而是会被自动覆盖。简单地在这里输入第二行代码将会永久地改变列表。
• 然后，我们使用基于列表的append方法将“link”添加到列表的末尾。
• 然后我们打印清单，以确保我们做对了事情。

现在我们已经得到了一个按照我们想要的顺序排列的列列表。下一步是在我们之前使用的方法中使用 loc 函数，首先给它提供:,来表明我们对列而不是行感兴趣，然后传递我们想要的列的列表。完成后，我们将重命名这些列，使它们更容易理解，然后打印新的 dataframe，以确保一切看起来都是正确的。

嘿，这开始看起来像是我们可以实际工作的东西了！我们在一边清楚地展示了 AHL 的数据，在另一边清楚地展示了 NHL 的数据。虽然我们已经取得了很大的进步，但我们还有一些地方需要改进。为了确定这些变化是什么，让我们使用dtypes。

• dtypes 返回数据帧中每一列的类型。

我们的数据框架中的每一列目前都是一个object类型。为了对它们执行数学函数，我们需要将它们转换成float类型。

• float 类型是浮点数。整数在很多情况下是可以的，但是如果你像我们一样使用小数，你需要把它们转换成浮点数。

让我们用一个专栏来测试一下，只用 AHL 每场比赛的积分。这里的命令链非常简单:

• 我们使用ahl_1718_nhl_1819.ahl_ppg对该列进行操作，将其视为一个系列。
• 我们使用astype函数并传递float作为参数，将其改为浮点类型。
• astype 将数据帧中的对象转换为特定类型。

不要把它分配给一个新对象，让我们打印它…

啊哦！看起来我们在这个列中有一些值仅仅是-，Python 不能将它们转换成浮点类型，这是有意义的，因为它们不包含数字数据。

让我们看一下具有该值的每一行，以确认情况确实如此:

好吧，所以在我们做其他事情之前我们需要先处理这个。我们还会在某个时候使用我们的“已玩游戏”列，因此我们还应该确保我们也清理了该列，以防其中也存在一些讨厌的值。

为了进行这种清理，我们将使用numpy模块中的where函数来将所有值从-更改为 0，并将所有其他值保持不变。请记住，我们将 numpy 作为 np 导入，因此当我们调用该模块的 where 函数时，我们只需键入 np.where 而不是 numpy.where。

• numpy.where 如果满足条件则返回一个值，否则返回另一个值。

在这种情况下，以下是这些行的命令链:

• 我们根据np.where语句的结果为 4 个不同的列分配新值。
• 在我们的 np.where 语句中，如果当前值是-，我们将赋值 0。如果当前值不等于-，我们简单地返回之前的值。
• 我们对四个字段重复这个过程——打了 NHL/AHL 的比赛和每场比赛的 NHL/AHL 积分——然后打印 ahl_ppg 值等于的行，以确保这是有效的。(我们应该看不到。)

酷，这很有效。现在我们可以把这些都改成浮点类型。然后，在我们新的浮动类型栏中，我们可以只过滤出在两个联赛中至少打了 20 场比赛的球员，并查看他们。

我们的数据现在处于可以真正开始工作的位置，这太棒了。

不幸的是，我们的样本量受到了很大的冲击；数据框中的行数告诉我们只剩下 113 名选手了。为了确定这是多大的问题，让我们通过构建两个独立的数据帧来看看我们有多少前锋和防守队员:一个只包含前锋，另一个只包含防守队员，然后使用len来确定这些数据帧的长度。

前锋和防守队员的数量目前被存储为两个独立的变量。我们不只是打印它们，而是使用 Python 的print函数来打印这些带有消息的值。

• 打印打印输出。

在我们这样做之前，我们必须创建变量的新版本，现在是整数，也就是字符串。我们通过使用str来做到这一点。

• str 将一个对象转换成一个字符串。

将字符串相互添加并打印出来非常容易，但是必须小心确保传递给打印函数的所有内容都是字符串。

所以我们有 77 名前锋和 36 名后卫。这不是很好，但对于一些基本的分析来说已经足够了。

分析数据

我们要做的第一件事是确定哪些球队在 2018-2019 年拥有最多的 NHL 前锋，他们在前一年从 AHL 跳了出来。

(展望未来，我将把进行这次跳跃的滑冰运动员称为“过渡球员”，他们在 2017-2018 年参加了至少 20 场 AHL 比赛，在 2018-2019 年参加了 20 场 NHL 比赛如果我特别提到进行这种跳跃的前锋或防守队员，我会称他们为“过渡前锋”或“过渡防守队员”)

为了做到这一点，我们将使用groupby按团队对我们的前锋数据帧进行分组，并计算每个团队的球员人数。

• groupby 以某种方式对一个对象进行分组，并在组合结果之前对该组应用某种函数。

让我们看看下一行代码的命令链:

• 我们将 nhl_team 作为参数传递给 groupby 这一组由 NHL 队列。
• 我们从我们的组中提取玩家系列。
• 我们用count()来统计每支队伍在这个系列赛中的人数。Count 是一个可以应用于组的函数。

现在我们有一个系列来告诉我们每支球队有多少球员。这太棒了！但是我们更希望有一个数据框架。它更容易使用和处理。我们将使用来自我们的pandas模块的DataFrame函数(我们将其作为pd导入)将它转换成一个数据帧。

现在，我们将使用sort_values函数来查看哪支球队拥有最多的球员。

• sort_values 沿任一轴按值排序。默认设置是 x 轴或行。

我们还想从大到小排序，所以我们将 ascending 设置为 False。(默认情况下，它被设置为 true。)

最常见的团队是“totals”，可以更容易地解释为“multiple teams”。这是有道理的。在那之后，为每支球队效力的转换前锋的数量似乎相当均匀地分布在 1、2、3 和 4 之间。

但是还有一些东西很突出。还记得我们构建的每一个其他数据帧都有一个从 0 到最左边的值的索引吗？你可能没有注意到它，但是如果你向上翻，你会发现它是为他们每一个人准备的。这个没有那个。保存索引是一个很好的做法。为了添加一个，我们简单地使用reset_index。

我们不仅要重置索引，还要再次对值进行排序，因为我们实际上并没有将带有排序值的数据帧赋给一个新变量。

对于初学编程的人来说，一行一行地写完全没问题，但是如果可能的话，用更少的行将多个语句链接在一起会更有效。对于这一个，只是做一点练习，我们将在一行中做所有的事情:首先按我们的 player 列中的值排序，然后重置其值被排序的新数据帧的索引。一旦我们完成了这个，让我们把它打印出来，以确保我们做对了。

现在我们已经有了一个索引，是时候仔细看看它了。它从 0 到 29，这意味着这里只有 30 个不同的值。totals 实际上也不是一支 NHL 球队，这意味着我们这里只有 29 支球队。NHL 有 31 支球队，所以肯定有两支球队在 2018-2019 年没有打过一场过渡前锋。

如果我们想知道这些团队是谁呢？我们可以去 NHL.com，一个接一个地寻找名单上的每支球队，找到我们遗漏的两支球队。会有用的。但这也是完全低效的，而且容易出错。

有一个更好的方法。让我们从使用 NHL 选手的完整数据框架中的团队栏上的set开始，以获得每个 NHL 团队的集合，然后看一看它。

• set 返回对象中的每个唯一值。

好的，我们已经召集了所有国家冰球联盟的队伍。下一步是确定这个集合中的哪些值没有出现在我们的向前转换中。我们将使用isin来完成这项工作。

• isin 确定数据帧中的元素是否包含在其他值中。

请注意 isin 是如何具体确定数据帧中的元素是否存在于其他值中的？我们不是在处理一个数据框架，我们是在处理一个集合。我们需要遵守规则，将此集合更改为数据帧。让我们这样做，看看它:

这看起来不错。我们的指数上升到 31，这意味着我们有 32 个值，但最后一个是“总数”，它实际上不是一个团队，所以我们实际上有 31 个团队。

但是，有一个问题:列名。是 0。当您构建一个没有列名的 dataframe 时，就会发生这种情况。

让我们用之前用过的 rename 函数来快速改变一下，只是这一次，我们不是以字符串的形式传递要重命名的列名，而是以整数的形式传递，因为这就是 0。(因此，我们的 0 周围没有引号。)

现在我们的专栏命名为 nhl_team，可以进入正题了。请记住，我们的最终目标是这个数据框架的一个版本，它只包含在我们向前过渡中不存在的球队。我们的最终目标是在我们的过渡前锋数据框架中建立一个球队列表，然后过滤我们的 NHL 球队数据框架，只包括没有出现在该列表中的球队。

不过，在我们这样做之前，我们实际上只是要看看在我们的过渡前锋名单中是的球队，只是为了熟悉 isin 功能。下面是命令链的工作方式:

• 第一行将 forward_counts.nhl_team 系列转化为一个名为teams_in_transitioning_forwards的列表。
• 第二行使用带有条件的典型 loc 语句。我们首先指定我们将使用来自团队系列的值作为指标。然后我们对过滤器应用isin,并将我们新的 teams _ in _ transitioning _ forwards 列表传递给 isin。

该指数最高为 31，这不太合理。如果原始数据帧中有 2 个值不满足这个条件，它不应该在 29 处达到顶点吗？

技术上来说，没必要。在打印出来的数据帧中必须有30 个不同的值(包括讨厌的“总计”值)，但实际上有；索引没有从原始位置重新设置。如果你仔细看索引，你会设法找到一些遗漏的队伍。不相信我？看看我们数据帧的长度。

所以，过滤器确实起作用了。现在是时候找到不符合这个条件的队伍了。这只需要一个简单的步骤:将~操作符添加到我们的 filter 语句的开头。该过滤器返回不符合条件的内容，而不是符合条件的内容。

这就对了。两支拥有零过渡前锋的球队是哥伦布蓝夹克队和底特律红翼队。我不会把它解读成一个小问题的答案，但是当这些问题出现时，培养回答这些问题的技巧是很重要的。

早些时候我说过，每支球队的转换前锋人数看起来相当均匀，在 1 到 4 人之间。这显然是不正确的，因为有两个值为 0 的团队我没有考虑。在我们进一步仔细检查最初的声明之前，我们应该修复我们已经知道完全错误的部分，并将这些团队及其零值添加到我们的原始数据框架中。

不过，很快地，让我们回忆一下原始数据帧的样子。我们不打印全部内容，我们只打印head,因为我们只想看到它的结构。

这和我们的失踪队数据框有相同的结构，只是多了一个球员栏。我们知道，在缺失球队的数据帧中，每个球队的球员值都是 0，所以我们可以使用assign在另一个数据帧中创建一个新列，然后向球员列提供值 0。

• 分配给数据帧分配新列或覆盖旧列。

我们丢失的团队数据帧现在具有与原始数据帧完全相同的结构。我们将通过使用来自pandas的concat函数来组合它们。

• concat 连接特定访问中的对象。

这看起来几乎完美，但我们的指数有点偏离。注意它是如何从 1 到 29，然后到 12，再到 17 的？我们需要重置索引，但与之前不同的是，这有点复杂，因为这个数据帧已经有了一个索引。为了显示这种复杂性，我们将只打印该数据帧的头部，并重置其索引:

在已经有索引的数据帧上重新设置索引会创建一个新的“索引”列，这很难看，而且对任何人都没有帮助，因为它不是实际的索引。在继续前进之前，我们会想要摆脱它。

好了，我们的数据框架准备好了。

将数据可视化

现在是时候可视化我们的数据了。为了做到这一点，我们将使用前面作为sns导入的seaborn模块中的countplot函数。

所以，至少有一名前锋的队伍实际上*相当*均地分布在 1 到 4 名前锋之间，但是没有前锋的两个队伍有点偏离。*

现在让我们来玩一点数据可视化。在所有转型的球员中，不仅仅是前锋，在 AHL 的得分预测在 NHL 的得分有多准确？我喜欢通过确定两个变量的相关性来回答这样的问题。我们可以使用来自numpy(我们导入为np)的corrcoef函数来计算这两者之间的相关系数。

是的，那是一种丑陋的输出。我们并不真的需要这整个相关系数矩阵；我们只需要第一个和第二个值之间的相关性，我们可以通过在命令的末尾添加[0, 1]来提取它。这将告诉 Python 输入两个数组中的第一个(索引为 0 的那个)并提取第二个项目(索引为 1)。请看下面:

好多了。这是两个变量之间的相关系数。但我更喜欢 R，它告诉我们一个变量的方差有多少可以用另一个来解释。为了提取 R，给定相关系数，简单地将初始值乘以它本身。这可以通过在数字的末尾加上**2来实现。

这里我们真的不需要超过两位小数点，所以让我们把这个输出赋值给一个叫做 RSQ 的变量，然后把它四舍五入到两位小数。

酷，我们已经得到了 R。现在是时候构建另一个数据可视化了，只需要比我们在计数图中投入更多一点努力。这一次，我们将使用regplot。

• regplot 绘制数据和线性回归模型拟合。

我们将把我们的第一列——x 变量——作为 x 输入 regplot，然后对 y 做同样的处理，然后选择指定蓝绿色，因为我喜欢它。

厉害！正如我们所看到的，这些值并没有在我们的线上紧密地组合在一起，但是有一个可靠的相关性。这已经很有用了，但是我们还可以做更多来改进它。我想到的第一件事是添加标签，通过添加更容易解释的列名来清楚地说明这里发生了什么。

为了添加这些信息，我们首先写出同一行代码。这让 Python 知道我们将打印这个图。然后，我们使用 matplotlib.pyplot(我们导入为 plt)中的 xlabel 和 ylabel 函数来更改我们要打印的绘图的 x 标签。

那看起来好多了！不过，在左上角有很多空白的地方；plt.text 函数允许我们在绘图的选定位置打印文本。我们将重复这个单元格，只是底部有 plt.text。

干得好！这是一个非常可靠的数据可视化。没什么太花哨的，但也不一定。

进行更深入的数据分析

现在是时候使用 Gabriel Desjardins 在联赛等效性中提出的方法建立一个非常基本的 NHL 等效性模型了。这是他的公式:

• 联赛 x 的质量=(第 2 年 NHL 的*均 PPG)/(第 1 年联赛 x 的*均 PPG)

这是一个非常简单的公式，但它足够好，可以开始使用，而且效果惊人。我们将通过使用 numpy 的均值函数来计算每个联盟每场比赛的*均得分，然后将它们除以另一个。

因此，AHL 的一个点相当于 NHL 的 0.45 个点，这与 Desjardins 在他的论文中使用旧数据得出的值相同。有趣的是这是怎么回事。

本教程非常接*完成。只剩下一件事要做:定义我们自己的函数，为一个在 AHL 打过球的球员获取一个 NHLe 值。

您已经对函数有些熟悉了，因为在本教程中您已经使用了一些函数。给你一个正式的定义，函数是一段代码，只在你调用它的时候运行。我们将构建一个函数，用户输入每场比赛的 AHL 积分值，该函数获取该值并自动给出 NHLe 分数。下面是定义函数的工作方式:

• 在第 1 行中，我们定义了函数的名称，并在括号中输入函数接受的每个参数。我们用冒号结束第一行。
• 函数中第 1 行之后的每一行都缩进。通知 Python 该行是函数的一部分。
• 在函数中，我们编写代码。

我们的功能被定义了。什么都没发生，因为我们只是存储了函数，还没有调用它。现在是时候结束了。

简单来说，我们说的是一个在 AHL 的 40 场比赛中得了 40 分的球员，因此他的 AHL 场均得分为 1。如果我们将他每场比赛的 AHL 点数作为参数传递给我们的函数，我们会收到他的 NHLe:

因此，根据我们建立的非常基本的 NHLe 模型，每场比赛 1 分的 AHL 分数就有每 82 场比赛 37 分的 NHLe。在我看来很合理。

祝贺您完成 Python 曲棍球分析教程！

如果您现在参加一个 Python 测验，其中只包含我们在本教程中介绍的内容，您可能仍然不会取得非常好的成绩。没关系！计算机编程最酷的地方在于，你不一定需要记住任何东西。这很有帮助，但是除非你在面试，否则你总是可以回头看看你以前的工作，想想你是怎么做的。

虽然这标志着我们教程的结束，但我希望它只是标志着你进入曲棍球分析和计算机编程之旅的开始。社区需要更多聪明的人来提问和寻找答案，如果你有能力完成本教程，我们可以使用你。

Python:用 pyenv、pyenv-virtualenv & pipX 创建干净的学习环境

原文：https://towardsdatascience.com/python-how-to-create-a-clean-learning-environment-with-pyenv-pyenv-virtualenv-pipx-ed17fbd9b790?source=collection_archive---------0-----------------------

设置您的 Python 学习环境，而不污染您未来的开发环境

萨法尔·萨法罗夫在 Unsplash 上拍摄的照片

我最*写了一篇文章，详细介绍了我学习 Python 编程语言的早期经历。这篇文章的主要焦点是在学习之旅的一开始就建立一个合适的开发环境的重要性。这是许多针对初学者的教程和在线课程经常忽略的内容，可能会导致许多学习者在准备开始自己的一些项目时，陷入一个复杂而不可行的开发环境。这是我从惨痛的教训中学到的！

https://medium.com/pythoneers/want-to-learn-python-what-nobody-tells-you-until-it-is-too-late-16bb1f473095

设置一个合适的 Python 环境，使您能够有效地管理不同 Python 版本的多个安装，并将所有包/库及其相关的依赖项与您的全局系统和用户环境隔离开来，这一点的重要性肯定是不可低估的。

在本文中，我打算向您介绍我当前的 Python 开发环境，并列出允许您复制它的步骤。以下步骤与我在运行 macOS Big Sur 的 MacBook Pro 上使用默认 zsh shell 的设置相关。我将向您展示如何:

• 使用 pyenv 安装和管理 Python 版本
• 使用 pyenv-virtualenv 创建虚拟环境，并为学习和项目目录/存储库提供隔离
• 使用 pipX 安装基于 CLI 的工具和软件包，以便在所有目录和虚拟环境中使用

这不是一个完整的教程，解释这些工具必须提供的所有功能，而是简单地解释如何安装每个工具，以及如何使用它们来隔离您的学习和后续项目环境。

系统 Python 版本 2.7 —请勿触摸！

**但首先发出警告！**您的 Mac 将已经安装了 Python 2.7 版本。Mac 操作系统使用此 Python 安装(位于 usr/bin/python 中)来执行您的计算机*稳运行所需的关键任务。请务必不要从您的计算机上删除这个版本的 Python，并且强烈建议您不要将它用于您自己的编程活动，因为您可能会使您的计算机变得无用！

终端(命令行界面)

如果您希望发展开发人员的技能，或者只是想提高您对计算机的掌握程度，您需要学习如何使用一个关键工具，那就是命令行界面(CLI)。这是通过在 Mac 上打开“终端”应用程序来启动的(应用程序→实用程序)。这是一个应用程序，它在您的计算机上打开一个文本窗口(称为 Shell ),并允许您键入基于文本的命令或一系列指令，然后您的计算机将直接执行这些命令或指令。

有许多免费的课程和教程可以帮助您学习如何有效地使用 CLI，但是对于本文的目的和设置您的 Python 环境，我将简单地提供一些命令，您可以将它们复制并粘贴到终端窗口的提示符中。

预设置和目录结构

在安装一些特定于 Python 的工具之前，您首先需要为您的 Mac 提供帮助创建和管理 Python 环境所需的工具。

1.安装命令行工具

虽然您的 Mac 已经有了大量有用的命令和工具，可以通过命令行界面来指导您的计算机的活动，但为了完成我们的 Python 设置，这些需要用一些开发人员特定的工具来增强。这些可以通过直接安装苹果 Xcode 开发者应用中包含的工具子集来获得。

只需打开终端，输入以下命令，然后按照屏幕上出现的一系列弹出窗口中的说明进行操作:

xcode-select --install

2.安装自制软件包管理器

家酿是一个软件包管理器的 Mac，让您轻松地安装和管理免费的开源软件应用程序和工具，直接从终端窗口。我们将使用 Homebrew 来安装 pyenv、pyenv-virtualenv 和 pipX，但是很可能 Homebrew 将成为您将来需要的更多工具的软件包管理器的选择。

要安装 Homebrew，只需将下面一行复制到您的终端窗口，然后按照屏幕上的任何指示操作:

/bin/bash -c “$(curl -fsSL [https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh](https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh))"

3.创建目录结构

在您安装 Python 并开始创建虚拟环境之前，创建一个简单的目录结构非常重要，您可以在其中组织您的项目和相关文件。下图所示的结构对我很有用，因为它让我能够圈住我最初的学习活动，同时创造一个空间，一旦我发展了足够的技能，就可以开始从事我自己的一些具体项目。

--> Python
   --> Learning
      --> Python_Playground
      --> Training_Course1
      --> Training_Course2
   --> Projects
      --> Project1
      --> Project2

在随后的章节中，您将了解如何为每个文件夹安装/分配特定的 Python 版本，以及如何为每个文件夹创建单独的虚拟环境，从而完全控制每个文件夹中安装的库和模块。

您会注意到，在学习目录中，除了特定的培训课程文件夹之外，我还创建了一个名为 Python Playground 的文件夹。我使用 Python Playground 文件夹作为一个安全的地方来试验和尝试我从培训教程中学到的东西的变体。我在这个环境中安装了最新版本的 Python，并自由地安装了我想要试验的所有库和模块，安全地知道它们将被完全隔离，不会影响我的整体开发环境。

在特定的培训课程文件夹中，我可以安装符合特定培训课程的 Python 版本，以及完成课程或教程所需的任何特定库或模块。

这个阶段的项目文件夹是为将来的使用而创建的——指定的、隔离的环境，在那里我可以开始构建我的第一个项目。

使用 pyenv 安装 Python

我们将使用名为 pyenv 的工具安装最新版本的 Python，而不是简单地通过 Homebrew、APT 或从 Python.org 直接安装到我们的全球系统环境中。Pyenv 允许您安装多个版本的 Python，并让您完全控制希望使用哪个版本，何时何地使用特定版本，并让您能够快速简单地在这些版本之间切换。

要使用 Homebrew 安装 pyenv，您可能首先需要安装一些关键的依赖项。将以下内容复制到终端中。

brew install openssl readline sqlite3 xz zlib

现在，您可以通过在终端中输入以下内容来安装 pyenv。

brew install pyenv

安装完成后，您还有一步要完成，以确保 pyenv 可以添加到您的路径中，允许它在命令行上正确工作，并启用填充和自动完成。

在终端中依次输入以下各行，这将更新。包含所需信息的 zshrc 文件。

echo 'export PYENV_ROOT="$HOME/.pyenv"' >> ~/.zshrc
echo 'export PATH="$PYENV_ROOT/bin:$PATH"' >> ~/.zshrc
echo -e 'if command -v pyenv 1>/dev/null 2>&1; then\n  eval "$(pyenv init -)"\nfi' >> ~/.zshrc

现在只需关闭并重新加载终端窗口，这将确保 Shell 拾取这些更改。

祝贺您，您现在已经准备好使用 pyenv 安装您的第一个 Python 版本了。

要查看可以通过 pyenv 安装的 Python 的所有可用版本的列表，只需在终端中键入以下内容。

pyenv install --list

一旦您确定了想要的版本，请输入以下命令进行安装(用您选择的版本替换 3.9.1)。您可以根据需要多次重复此步骤，以安装所有需要的版本。

pyenv install 3.9.1

现在您已经安装了多个版本的 Python，您可以开始选择在哪些实例中使用哪个版本。

输入命令pyenv versions将显示您当前安装在计算机上的所有 Python 版本。要将特定版本设置为默认的全局版本，只需输入以下命令(用您选择的版本替换 3.9.1)。

pyenv global 3.9.1

您还可以设置要在特定目录中使用的特定 Python 版本，方法是导航到该目录，然后运行以下命令(用您选择的版本替换 3.8.1)

pyenv local 3.8.1

或者，您可以通过输入以下命令，简单地设置要在当前 Shell 中使用的 Python 版本(用您选择的版本替换 3.8.1)。

pyenv shell 3.8.1

您可以通过重新输入相关命令并输入不同的版本号来更改分配给上述任何场景的 Python 版本。

pyenv-virtualenv

JESHOOTS.COM在 Unsplash 上拍照

既然您已经习惯了使用 pyenv 安装和管理多个版本的 Python，我们就继续创建一个虚拟环境。这将允许您为特定的目录/文件夹分配特定版本的 Python，并确保安装在该文件夹中的所有库和依赖项都是完全隔离的。除非您明确地将它们安装在其他特定的虚拟环境中或者全局安装它们，否则它们对其他目录不可用(不推荐，我将在下一节向您展示如何使用 pipX 来实现这一点)。

首先，您需要安装 pyenv-virtualenv。您可以通过在终端中输入以下命令来做到这一点。

brew install pyenv-virtualenv

您现在可以创建您的第一个虚拟环境。在本例中，您将为 Python Playground 目录创建一个虚拟环境。同样的步骤也适用于为您希望的任何目录创建虚拟环境。

使用终端，导航到将要创建虚拟环境的目录，在本例中是 Python Playground。

cd Python/Learning/Python_Playgrounds

接下来，您需要设置您希望在环境中使用的 Python 版本(在这个例子中我们将使用 3.9.1，但是您可以用您需要的版本替换)。

pyenv local 3.9.1

要创建虚拟环境，请输入下面的命令。pyenv virtualenv是创建环境的实际命令。版本号与您刚刚设置为环境的本地版本的 Python 版本一致，最后一部分是虚拟环境的名称。我个人的偏好是在名称前加上“venv ”,然后将虚拟环境的名称与它相关的目录的名称对齐。

pyenv virtualenv 3.9.1 venv_python_playground

最后一步是将目录的本地 python 版本设置为虚拟环境。

pyenv local venv_python_playground

当您想要在虚拟环境中工作时，您需要激活它。一旦激活，将使用指定的 Python 版本，并且您安装的任何库都将包含在环境中。在虚拟环境中完成工作后，请务必记住停用虚拟环境，以便返回到您的全球环境。使用以下命令可以激活和停用环境。

pyenv activate venv_python_playground
pyenv deactivate

要在进出相关目录时启用虚拟环境的自动激活和停用，只需在终端中输入以下命令来更新。包含所需信息的 zshrc 文件。

echo 'eval "$(pyenv virtualenv-init -)"' >> ~/.zshrc

现在您知道了如何为您的每个培训课程和未来项目创建一个隔离的 Python 环境。

pipX

随着您 Python 学习经验的进步，并开始从事自己的一些项目，您可能会开始确定您希望在每个项目中使用的某些包或工具。您可以使用一个名为 pipX 的工具，而不是在每个虚拟环境中复制安装。

pipX 将创建一个特定的全局虚拟环境，在该环境中可以安装这些工具和软件包，这些工具和软件包可以通过命令行、所有全局目录和所有虚拟环境进行访问。这对于 Python formatters (Autopep8 或 Black)、Pylint 等 linters 或 Jupyter Notebooks 等您可能需要在所有项目中使用的工具尤其有用。

要安装 pipX，请在您的终端中运行以下命令。

brew install pipx
pipx ensurepath

然后用 pipX 安装、升级或卸载软件包和工具，您只需使用pipx install、pipx upgrade和pipx uninstall，就像使用 pip 管理您的库一样。您还可以使用pipx list来查看您已经用 pipX 安装的包的列表。

结论

干得好！您现在有了一个很好的 Python 开发设置，允许您自由地进行实验和学习，使您能够尝试尽可能多的包和库，安全地知道一切都隔离在一个组织良好和受控的环境中。

此外，您已经学习了一些进入 Python 开发旅程下一阶段所需的工具和技能，并且拥有一个干净整洁的项目基础设施，随时等待您充分利用。

后续步骤

既然已经建立了基本的开发环境，为什么不花些时间探索一下开发设置中更有趣和可定制的元素呢？下面列出了一些可供您进一步探索的领域…

1. 选择并安装您选择的 IDE，并定制主题和扩展
2. 用 iTerm2 &哦，我的 ZSH 升级你的基本 mac 终端
3. 安装并学习如何使用 GIT 和 GitHub

参考

如果您希望探索我在本文中提到的一些工具，并增长您对它们全部功能的了解，那么下面的链接可能会很有用…

1. https://github.com/pyenv/pyenv
2. https://realpython.com/intro-to-pyenv/
3. 【https://github.com/pyenv/pyenv-virtualenv
4. https://github.com/pipxproject/pipx

用于数据科学的 Python:初学者指南

原文：https://towardsdatascience.com/python-i-data-types-and-operators-variable-assignment-and-print-6f2eafb1b899?source=collection_archive---------37-----------------------

学习 Python 基础知识，以便在数据科学项目中使用它。

图片来自皮克斯拜的约翰逊·马丁

一、关于 Python🐍

由荷兰程序员吉多·范·罗苏姆在Centrum wisk unde&Informatica 创建的 Python 于 1991 年首次亮相。三十多年来，它广受欢迎，赢得了“编程语言的瑞士军刀”的美誉。以下是几个原因:

• 一个强大的社区已经开发了大量的免费库和包，允许 Python 与不同领域的技术相结合。Python 在数据科学方面很受欢迎，但是你也可以用它来进行 web 开发、金融、设计游戏等等。
• Python 也是一种多范例语言——换句话说，它既允许结构化/功能性的编程，也允许面向对象的编程。
• 作为一种高级语言，语法被设计得直观易读。这一特性对初学者以及 Instagram 和谷歌这样的大公司都很有吸引力。

在数据科学、人工智能和机器学习等新兴领域，强大的社区、丰富的包、范式灵活性和语法简单性使初学者和专业人士能够专注于见解和创新。

三。数据类型

Python 大约有十二种不同的数据类型，在本教程中我将向您介绍其中的五种: string ， integer ， float ， boolean ，以及 list 。我还将向您展示一些可以在 Python 中用于您的项目的基本函数和方法。这应该足以让你开始，并为下一个教程做好准备:熊猫 I 。

1.Python 字符串

字符串是一系列字符。它们可以是数字和非数字字符。在 Python 中，它们用引号括起来。你会注意到在字符串的上方，有一个 hashtag 后面的描述。这叫做评论。标签后面的任何内容都是评论。

# This is a comment. The line below is a string in Python.
“This is a string.”   # you can also use them inline

在 Python 中，我们将任何类型的值赋给 变量 以便使用它们。看起来像这样:

the_string = “This is a string.”

单等号(=) 用于给变量赋值。以下是一些关于变量的注意事项:

• 命名约定表明变量应该是小写的
• 字母和数字都可以，但是数字不能没有字母(例如“a1”可以，而“1”不行)。
• 不允许使用特殊字符和空格。下划线**(" _ "**应该用来代替空格
• 你可以给一个变量起任何你想要的名字，但是有几个名字你不能用，因为它们已经是 Python 关键字了。请参见下面的列表:

False      class      finally    is         return
None       continue   for        lambda     try
True       def        from       nonlocal   while
and        del        global     not        with
as         elif       if         or         yield
pass       else       import     assert
break      except     in         raise

要打印所有输出，包括 Python 中的字符串，我们使用 print() :

[in]  print(the_string)
[out] "This is a string."

你可以连接或者像这样把字符串放在一起:

[in]  another_string = “This is another string.”
      a_combo_string = the_string + another string
      print(a_combo_string)
[out] "This is a string. This is another string."

字符串是不可变的，这意味着它们不能被改变。它们需要被重新分配来改变(如果你愿意，你可以回收这个变量)。

如果想知道任意值或变量的数据类型，可以使用 type() 。

[in]  print(type(the_string))
[out]  <class 'str'>

2.Python 整数

Python 中的整数是不带小数点的数字。它们可以是积极的，也可以是消极的。

[in]  int_num = 1
      print(int_num)
[out] 1

您可以使用算术运算符对数字数据类型整数执行运算。

[in]  print(1 + 2)
[out] 3

您可以将它们赋给变量，也可以执行操作。

[in]  a = 5
      b = 6
      c = a — b 
      print(c)
[out] -1

你也可以乘除:

[in]  print(a * b / c)
[out] -30.0

3.Python 浮动

像整数一样，浮点数也是一种数字数据类型。它们也可以是积极的和消极的。然而，他们是浮点小数，这意味着他们有一个小数点，而不是整数。然而，我们可以在整数上执行的大多数操作都可以在浮点数上执行。

[in]  int_float = 2.5
      print(num_float)
      d = 1.33
      e = 4.67
      f = d + e
      g = f — 7
      print(g)
[out] 2.5
      1.0

4.Python 布尔值

布尔值不是真就是假。

[in]  print(type(True))
      print(type(False))
[out] <class 'bool'>
      <class 'bool'>

您可以使用布尔运算符来比较值。

[in]  print(d > e)   # d greater than g 
[out] False [in]  print(c >= g)  # c greater than or equal to g 
[out] True[in]  print(a < e)   # a less than e
[out] False[in]  print(d <= g)  # d less than or equal to g 
[out] False[in]  print(g == c)  # g equals c
[out] True

5.Python 列表

Python 中的列表是存储值的容器。它们用括号括起来，我们一般把它们赋给变量。

[in]  our_list = [a, b, c, d, e, f, g]
      print(our_list)
[out] [5, 6, -1, 1.33, 4.67, 6.0, -1.0]

它们可以是数值，也可以是非数值。

[in]  i = “Ice”
      j = “Jewel”
      k = “Karate”
      l = “Lemon”
      another_list = [i, j, k, l]

它们可以是**排序()**也可以。

[in]  sorted(our_list)
[out] [-1, -1.0, 1.33, 4.67, 5, 6, 6.0]

但是，如果我们希望列表在操作时保持排序，我们需要重新分配它:

[in] our_sorted_list = sorted(our_list)

我们可以用 append() 添加列表:

[in]  h = 7
      our_list.append(h)
      print(our_list)
[out] [5, 6, -1, 1.33, 4.67, 6.0, -1.0, 7]

我们可以用 remove() 删除东西:

[in]   our_list.remove(a)
       print(our_list)
[out]  [6, -1, 1.33, 4.67, 6.0, -1.0, 7]

我们可以连接(放在一起)两个列表:

[in]  combined_list = our_list + another_list
      print(combined_list)
[out] [6, -1, 1.33, 4.67, 6.0, -1.0, 7, 'Ice', 'Jewel', 'Karate', 'Lemon']

我们也可以使用 add-assign 操作符 (+=) 将列表放在一起:

[in]  another_combo_list = []
      another_combo_list += combined_list
      print(another_combo_list)
[out] [6, -1, 1.33, 4.67, 6.0, -1.0, 7, 'Ice', 'Jewel', 'Karate', 'Lemon']

最后，我们可以使用等式操作符(" ==") 来比较列表，以获得一个布尔输出。

[in]  print(combined_list == another_combo_list)
[out] True

二。我们做了什么？

1. 在 Python 中发现了五种不同的数据类型:整型、浮点型、布尔型、字符串型和列表型。
2. 讨论了变量赋值、print()、type()和注释。
3. 学习算术运算符和布尔运算符。
4. 尝试列表。

四。下一步是什么？

在 Pandas I 中，您将学习如何使用 Python 和 Pandas 来分析 Metal Bands by Nation 数据集。

超参数优化的网格搜索和随机搜索的 Python 实现

原文：https://towardsdatascience.com/python-implementation-of-grid-search-and-random-search-for-hyperparameter-optimization-2d6a82ebf75c?source=collection_archive---------11-----------------------

使用 Scikit-learn GridSearchCV 和 RandomizedSearchCV 函数进行超参数优化的指南

照片由迪查茨在 Unsplash 上拍摄

如果不进行任何超参数优化(调整)，就无法从机器学习模型中获得最佳效果。默认的超参数值并不是您的数据的最佳模型。sikit-learn-Python 机器学习库为超参数优化提供了两个特殊函数:

• GridSearchCV — 进行网格搜索
• RandomizedSearchCV — 进行随机搜索

如果你是数据科学和机器学习领域的新手，你可能不熟悉这些词。在这篇文章中，我将重点介绍网格搜索和随机搜索的 Python 实现，并解释它们之间的区别。读完这篇文章后，您将能够获得使用 Scikit-learn 实现网格搜索和随机搜索的实践经验。

先决条件

强烈建议对k-折叠交叉验证有良好的了解。我们也推荐构建决策树模型的知识，因为我们在这里使用这样的模型来实现网格搜索和随机搜索。如果你不熟悉这些东西，不要担心。我也为他们写了内容。首先，阅读它们，然后继续阅读这一个。以下是链接:

对于k-折叠交叉验证:

对于决策树:

首先，我们将区分模型 参数 和 超参数 。

模型参数与超参数

模型参数 在训练过程中学习它们的值。我们不手动设置这些值。他们从我们提供的数据中学习。例如，线性回归模型的模型系数可以被认为是模型参数。

相反， 模型超参数 不从数据中学习它们的值。所以，我们必须手动设置它们。我们总是在创建特定模型时(即在训练过程之前)设置超参数的值。例如，我们可以通过为 规格化 超参数设置一个布尔值来指定是否规格化线性回归模型的输入特征(X):

from sklearn.linear_model import LinearRegressionlr_1 = LinearRegression(*normalize=False*) # No any normalization
lr_2 = LinearRegression(*normalize=True*) # Normalization applied

lr_1 和 lr_2 模型给出两种不同的输出，因为它们具有不同的 归一化 超参数值。模型超参数可以控制模型参数。这意味着模型超参数会影响模型的性能。因此，我们有责任设置模型超参数值，以便它们给出模型的最优或最佳可能输出。

在大多数情况下，即使简单的模型也有两个或更多的超参数。因此，我们必须同时考虑所有这些超参数，以找到每个超参数的最佳值。寻找模型超参数最优组合的过程称为 超参数优化(调优) 。我们不能手动这样做，因为有许多超参数，每个超参数有许多不同的值。幸运的是，Scikit-learn 提供了 GridSearchCV 和 RandomizedSearchCV 函数来自动化优化(调整)过程。

超参数搜索空间

这是超参数调整过程中一个非常重要的概念。搜索空间包含用户定义的超参数值的所有不同组合。下图显示了两个不同超参数的二维搜索空间— 最大深度和最小样本分割。

(图片由作者提供)

如果有 3 个不同的超参数，则搜索空间是三维的。同样，随着超参数数量的增加，搜索空间可以是高维的。你应该知道的一般事情是:

• 搜索空间中的维数定义了超参数的数量。(例如 2 维-2 个超参数)
• 搜索空间中的每个点定义了超参数值的每个组合。点 (8，30) 定义了最大 _ 深度的值 8 和最小 _ 样本 _ 分割的值 30。

我们可以将搜索空间定义为一个 Python 字典，其中包含作为关键字的超参数名称和作为值列表的这些超参数的值。这种字典的一般格式是:

search_space = {'param_1':[val_1, val_2],
                'param_2':[val_1, val_2],
                'param_3':['str_val_1', 'str_val_2']}

现在，我们区分网格搜索和随机搜索。

网格搜索与随机搜索

网格搜索 在搜索空间中搜索用户定义的所有不同的超参数组合。这将耗费大量的计算资源，并且当搜索空间是高维的并且包含许多值的组合时，通常具有高的执行时间。当有少量超参数和有限(固定)数量的超参数值时，这种方法是理想的。

网格搜索(作者图片)

相比之下，随机搜索在寻找最优组合时不会检查所有不同的超参数组合。相反，它检查在 RandomizedSearchCV 函数的 n_iter 中指定的随机选择的固定数量的组合。随机搜索在随机选择的组合中找到最佳超参数组合的概率非常高。当搜索空间是高维的并且包含许多值的组合时，该方法对于快速有效地找到最优超参数组合是非常有用的。

随机搜索(图片由作者提供)

构建基础模型

基本模型(等到加载 Python 代码！)

(图片由作者提供)

正如您从输出中看到的，我们的基本模型不是很好。它已经很好地学习了训练数据，但它无法对新的输入数据(测试集)进行归纳。用技术术语来说，我们的基本模型显然是过度拟合的。决策树模型通常倾向于过度拟合。

我们现在可以使用网格搜索和随机搜索方法来提高我们模型的性能(测试准确度分数)。

首先，我们将尝试网格搜索。

网格搜索的 Python 实现

网格搜索的 Python 实现可以使用 Scikit-learnGridSearchCV函数来完成。它具有以下重要参数:

• estimator — (第一个参数)一个 Scikit-learn 机器学习模型。换句话说，这是我们的基本模型。
• param_grid — 如前所述的搜索空间的 Python 字典。我们的搜索空间是三维的，包含 576 种不同的组合。这意味着我们用网格搜索训练 576 个不同的模型！
• 评分— 用于衡量模型性能的评分方法。对于分类，我们一般用‘准确度’或‘roc _ AUC’。对于回归，首选“r2”或“负均方误差”。由于我们的基础模型是一个分类模型(决策树分类器)，我们使用“准确性”作为评分方法。要查看可用评分方法的完整列表，请点击此处。
• n_jobs — 指定执行网格搜索时要运行的并行作业的数量。如果您的计算机处理器有许多内核，请为此设置一个较高的值。 -1 值使用所有可用的内核。这将加快执行过程。
• cv — 交叉验证的折叠数。标准数字是 5，10。当 cv 为 10 时，每个超参数组合重复 10 次。因此，总迭代次数为 5760 (576 x 10)。

看看下面的 Python 代码，它在我们的基本模型上执行网格搜索。

网格搜索(等到加载 Python 代码！)

(图片由作者提供)

这是一个用几个 print() 函数格式化的很好的输出。您可以将这个输出与我们基本模型的先前输出进行比较。该模型的性能现已得到明显改善。这一次，模型并没有过度拟合。它在训练集和测试集上都表现良好。除此之外，调整超参数后，假阳性和假阴性都显著减少。

现在，让我们来关注一下这种情况下网格搜索的执行时间。大约只有 22.5 秒。运行 5760 次迭代在处理器所有内核都启用的情况下只需要 22.5 秒( n_jobs=-1 )！

接下来，我们尝试随机搜索。

随机搜索的 Python 实现

随机搜索的 Python 实现可以使用 Scikit-learn 的 RandomizedSearchCV 函数来完成。大多数参数与 GridSearchCV 函数中的参数相同。这里，搜索空间由参数 _ 分布而不是参数 _ 网格定义。除此之外，

• n_iter — 指定随机选择的超参数组合的数量。这是因为随机搜索不会检查搜索空间中定义的所有超参数组合。相反，它只考虑组合的随机样本。这里，n_iter=10 意味着它执行大小为 10 的随机样本任务，该样本包含 10 个不同的超参数组合。所以随机搜索只训练 10 个不同的模型(之前是 576 个带网格搜索的模型)。
• random_state — 控制每次不同执行时获取超参数组合样本的随机化。我们可以使用任何整数。

这里，总迭代次数是 100 (10 x 10)，这比前一种情况(5760 次迭代)少得多。

现在，看看下面的 Python 代码，它在我们的基本模型上执行随机搜索。

随机搜索(等到加载 Python 代码！)

(图片由作者提供)

模型性能与网格搜索完全相同。然而，最佳超参数值是不同的。现在，执行时间仅为 0.51 秒，比前一个版本(22.5 秒)少得多。在这种情况下，随机搜索比网格搜索快 44 倍(22.5 / 0.51)。这是因为随机搜索只少执行 57.6 倍(5760 / 100)的迭代！

结论

在我们的例子中，您可以尝试网格搜索和随机搜索，因为这两种方法只需要不到半分钟的时间。然而，请记住，随机搜索的力量。在我们的例子中，它快了 44 倍(22.5 / 0.51)。这意味着如果随机搜索将花费 1 分钟的执行时间，网格搜索将花费大约 44 分钟！所以，当搜索空间是高维的，包含很多不同的超参数组合时，我强烈推荐你使用随机搜索。

运行网格搜索或随机搜索后，您将获得最佳超参数组合。例如，我们在网格搜索中得到以下最优超参数组合:

{'max_depth': 6, 'min_samples_leaf': 6, 'min_samples_split': 2}

因此，我们可以将最优模型定义如下:

from sklearn.tree import DecisionTreeClassifierdtclf_optimal = DecisionTreeClassifier(**max_depth=6**,
                                       **min_samples_leaf=6**,
                                       **min_samples_split=2**,
                                       random_state=42)

然而，我们不需要这样写代码。 GridSearchCV 和randomzedsearchcv函数都有一个名为 best_estimator_ 的属性，用来获得具有最优超参数的模型。因此，

gs.best_estimator_ 

会给出同样的 dtclf_optimal 模型。这里， gs 是拟合的 GridSearchCV 模型。

此外，请注意，网格搜索和随机搜索一次考虑所有超参数，而不是一个接一个。这就是为什么网格搜索和随机搜索得到的不同超参数值给出了相同的准确率分数。如果您想查看单个超参数的影响，我建议您使用验证曲线 —一种图形技术。我写的下面这篇文章解释了我们如何使用它。

我的读者可以通过下面的链接注册成为会员，以获得我写的每个故事的全部信息，我将收到你的一部分会员费。

非常感谢你一直以来的支持！下一个故事再见。祝大家学习愉快！

除封面图片、代码样本、其他内容链接和文字内容外的所有图片均归作者版权所有。特别要感谢 Unsplash 上的迪查茨，他是封面图片的所有者。非常感谢，迪查茨，为我在本帖中提供了一张出色的封面图片！

鲁克山普拉莫迪塔 2021–06–07

Python 一个简单应用程序中的重要概念

原文：https://towardsdatascience.com/python-important-concepts-in-one-application-classes-staticmethod-classmethod-decorators-c44a0d588da5?source=collection_archive---------19-----------------------

类，staticmethod，classmethod，自定义装饰器

澳门图片社在 Unsplash 上拍摄的照片:装饰让一切看起来都很美，甚至你的代码...

从前..不，不，只是几天前，我的一个朋友让我解释一些 python 的概念。其中一些是类、装饰器、classmethod、staticmethod。

我在网上搜索，给她发一些好的链接来理解这些概念，但是我找不到一个地方能以简明易懂的方式解释这些概念。我找不到一个简单的方法来解释这些，对于那些对 OOPS 概念不是很有效率的人来说。

所以，我花了一些时间创建了一个小应用程序来主要解释使用这些的为什么。然后我想为什么不分享一下呢？

现在，让我们直接去理解这些概念。我正在创建一个名为计算器的应用程序。有三个用户想要访问计算器并使用该计算器执行不同的操作。

计算器应用

这是应用程序，有加，减，乘操作，不同的用户应该能够与应用程序交互和执行操作。

无类别方式(未创建类别):

所以，让我们从构建一个名为 Calculator 的类开始。但是等等..它的蟒蛇..我们真的需要上课吗？难道我就不能创建四个函数，名为加、减、乘、除，让人们使用吗？当然，我可以，但是请记住，您可以按照您想要的任何方式编码，但是构建一个定义上下文的代码并在其中分离操作(封装)是创建一个可读且可维护的代码的方法。

首先，让我们采用非类的方式:创建四个方法:

计算器应用程序的加、减、乘方法

现在，假设有三个用户想要访问它:Aron、Ben 和 Cathy 。

Aron 调用 add(2，3)并得到结果。但是如果你想追踪是谁打来的呢？在这种情况下，您可能希望将函数修改为:

加，减，乘的方法来记录谁打电话

以人为输入的运算符方法！！这是正确的方法吗？

这里，我们更新了方法，在“person”变量中传递人名，我们可以知道哪个人调用了特定的方法。Aron 调用这个方法为:add(2，3，“Aron”)并得到结果。它成功了，我们完成了！！

不，还没有。想一想，用人名作为输入来执行计算的方法好吗？不对，对！！为什么不将打印姓名与执行这些操作分开呢？

救援来了...类别和对象:

优雅的方式:

类是封装内部功能的一种方式，因此可以创建特定的对象。对象是为特定的实例创建的，可以重用这些实例对对象的现有状态执行不同的操作。哼！！太啰嗦了。如果我刚才说的你一个字也没听懂，就忽略它，继续前进。我们通过例子来了解一下。

class Calculator():
    def __init__(self, person_name):
        self.per_name = person_name

    def add(self, a, b):
        print("Operation called by", self.per_name)
        return a+b

    def subtract(self, a, b):
        print("Operation called by", self.per_name)        
        return a-b

    def multiply(self, a, b):
        print("Operation called by", self.per_name)
        return a*b

在这里，我创建了一个名为 calculator 的类，加、减、乘方法只有它们特定的功能。 init 方法是一个构造函数，将用于为特定的人创建对象。让我们为 Aron 创建它:

if __name__ == '__main__':
    aron_calculator = Calculator('Aron')
    ben_calculator = Calculator('Ben')
    cathy_calculator = Calculator('Cathy')
    print(aron_calculator.add(6, 5))
    print(aron_calculator.subtract(6, 5))
    print(ben_calculator.subtract(6, 5))
    print(cathy_calculator.multiply(12, 3))**Output:**
Operation called by Aron
11
Operation called by Aron
1
Operation called by Ben
1
Operation called by Cathy
36

到底是什么意思？

在这里，您可以想象 Aron 登录到 Calculator 应用程序，并收到一个 aron_calculator 对象作为响应。这将设置 Aron 的对象，并传递人名。现在，他可以使用该对象来执行任何计算，我们将知道 Aron 正在执行这些操作。**“self”**包含与 Aron 和 self.per_name 相关的详细信息，提供 Aron(因为我们在为他创建对象时已经在 init 中设置了它。)

这些方法被称为实例方法。现在你知道了类和实例方法(需要 self)以及我们为什么需要它们。先说 classmethod 和 staticmethod。

@静态方法:

静态方法是那些不附属于任何对象或类的方法。这些都是独立的方法(就像 python 函数一样),它们被保留在类中的原因是只有其他类方法使用它们。让我们创建一个方法作为 staticmethod，并看看如何以及何时使用它:

class Calculator():
    def __init__(self, person_name):
        self.per_name = person_name

    def add(self, a, b):
        print_operator_name(self.per_name)
        return a+b

    def subtract(self, a, b):
        print_operator_name(self.per_name)        
        return a-b

    def multiply(self, a, b):
        print_operator_name(self.per_name)
        return a*b **@staticmethod    
    def print_operator_name(person_name):
        print("Operation called by", person_name)**

这里，正如您所看到的，我们没有在方法中使用 print 语句，而是创建了一个 static method print _ operator _ name，它负责打印细节。实例方法可以调用这个 staticmethod(它不需要 self，和类外的 python 函数一样好)来打印操作符名称。

@classmethods:

这是 python 提供的内置 decorator(我稍后会谈到 decorator ),它影响类，而不仅仅是特定的对象。因此，通过 classmethod 更新的任何东西都可以更新类级别的变量，然后所有的对象都可以看到这些变量被更新了。让我们看一个例子:

class Calculator:
    **status = False**

    def __init__(self, person_name):
        **if not self.status:
            raise ValueError("Calculator is not running. Please update status.")**
        self.per_name = person_name

    def add(self, a, b):
        self.print_operator_name(self.per_name)
        return a+b

    def subtract(self, a, b):
        self.print_operator_name(self.per_name)
        return a-b

    def multiply(self, a, b):
        self.print_operator_name(self.per_name)
        return a*b

    @staticmethod    
    def print_operator_name(person_name):
        print("Operation called by", person_name)
 **@classmethod
    def set_status(cls):
        cls.status = True

    @classmethod
    def reset_status(cls):
        cls.status = False

    @classmethod
    def getStatus(cls):
        return cls.status**

这里，我在计算器类级别创建了一个状态:

class Calculator():
    status = False

状态=假！！这是什么意思？

这决定了我们计算器的*状态。*最初，是假的。你可以想象你需要通过设置它为真来启动你的计算器。然后 Aron，Ben，Cathy 可以通过创建它们的对象来操作它们。否则，即使在创建对象时，他们也会得到一个异常，如果没有对象，他们就不能操作计算器。

为此，由于 status 是一个类级别的变量，我们需要 classmethod。set_status 将其设置为 True，reset_status 将其设置为 False，get_status 返回状态。**“cls”**是一个类作用域变量，用来访问类的变量(就像 self 可以访问 per_name 这样的对象级变量一样)。 cls，self 只是标准，你可以用任何你想要的字符串替换它，但是这是推荐的，因为它有助于保持代码的一致性。

让我们运行它:

if __name__ == '__main__':
 **Calculator.reset_status()**    print(Calculator.getStatus())
    aron_calculator = Calculator('Aron')
    ben_calculator = Calculator('Ben')
    cathy_calculator = Calculator('Cathy')
    print(aron_calculator.add(5, 6))
    print(aron_calculator.subtract(4, 2))
    print(cathy_calculator.subtract(3, 1))
    print(cathy_calculator.multiply(4, 5))

我们得到一个异常，声明状态不为真，因为构造函数不允许状态为假，因此不会创建对象。这意味着，没有人可以访问计算器，因为它是关闭的(状态为假):

Output:
False
Traceback (most recent call last):
  File "C:\Users\tushar_seth\PycharmProjects\calculator_medium\Calculator.py", line 49, in <module>
    aron_calculator = Calculator('Aron')
  File "C:\Users\tushar_seth\PycharmProjects\calculator_medium\Calculator.py", line 13, in __init__
    raise ValueError("Calculator is not running. Please update status.")
ValueError: Calculator is not running. Please update status.

**想运行计算器？使状态为真

if __name__ == '__main__':
 **Calculator.set_status()**    print(Calculator.getStatus())
    Calculator.set_status()
    aron_calculator = Calculator('Aron')
    ben_calculator = Calculator('Ben')
    cathy_calculator = Calculator('Cathy')
    print(aron_calculator.add(5, 6))
    print(aron_calculator.subtract(4, 2))
    print(cathy_calculator.subtract(3, 1))
    print(cathy_calculator.multiply(4, 5))

我们得到适当的输出:

Output:
True
Operation called by Aron
11
Operation called by Aron
2
Operation called by Cathy
2
Operation called by Cathy
20

这显示了 staticmethod 和 classmethod 的能力。

装修工

现在，让我们进入下一个主要概念:装饰者。您看到了@staticmethod 和@classmethod，它们是内置的 python 装饰器。如果你想用自己的功能创建自己的装饰器呢？

但是首先，你为什么要创造自己的装饰者呢？

装饰器在很多编程语言中使用，主要是为了使代码简洁，并用几个词隐藏样板代码。如果您想在每次调用某个方法时都以特定的方式运行该方法，那么您可以只应用装饰器，甚至不用接触实际的方法。

继续我们之前的计算器课程。您是否注意到，我们需要记录操作符和操作细节，为此，我们创建了一个 staticmethod，并从每个方法中一次又一次地调用。如果我们不想接触那些方法，假设我们已经构建了复杂的方法，并且我们不想弄乱它们的功能，该怎么办？在这种情况下，我们可以用公共方法的方法名来修饰操作符方法。

别拿理论烦我，给我看看例子！！

让我们直接跳到例子来理解这一点，我们在类外创建一个方法(这是最简单的方法。理想情况下，我们应该创建一个内部类，并在其中定义 decorator。但是我的范围是让你理解功能。要查看在类中创建 decorator 的内部类方法，请查看以下链接:https://medium . com/@ vadimpushtaev/decorator-inside-python-class-1e 74d 23107 F6

**def logging_decorator(incoming_function):
    def inner_function(self, a, b):
        print('Operation called by', self.per_name)
        return incoming_function(self, a, b)
    return inner_function**

在这里，logging_decorator 接受一个函数，这个函数本来就是要有这个 decorator 的。然后 inner_function 接受(加、减、乘)方法得到的参数。然后我们可以改变调用该函数的行为，首先打印我们的日志，然后将实际的方法调用返回给被调用者。

现在，我们可以使用 decorator 用这个函数来修饰我们的方法，这很简单，只需在方法上写@logging_decorator，因此我们的最终代码如下:

def logging_decorator(incoming_function):
    def inner_function(self, a, b):
        print('Operation called by', self.per_name)
        return incoming_function(self, a, b)
    return inner_function

class Calculator:
    status = False

    def __init__(self, person_name):
        if not self.status:
            raise ValueError("Calculator is not running. Please update status.")
        self.per_name = person_name

    @logging_decorator
    def add(self, a, b):
        return a+b

    @logging_decorator
    def subtract(self, a, b):
        return a-b

    @logging_decorator
    def multiply(self, a, b):
        return a*b

    @staticmethod    
    def print_operator_name(person_name):
        print("Operation called by", person_name)

    @classmethod
    def set_status(cls):
        cls.status = True

    @classmethod
    def reset_status(cls):
        cls.status = False

    @classmethod
    def getStatus(cls):
        return cls.status

if __name__ == '__main__':
    Calculator.set_status()
    print(Calculator.getStatus())
    aron_calculator = Calculator('Aron')
    ben_calculator = Calculator('Ben')
    cathy_calculator = Calculator('Cathy')
    print(aron_calculator.add(5, 6))
    print(aron_calculator.subtract(4, 2))
    print(cathy_calculator.subtract(3, 1))
    print(cathy_calculator.multiply(4, 5))

它的输出将与前一个完全相同:

True
Operation called by Aron
11
Operation called by Aron
2
Operation called by Cathy
2
Operation called by Cathy
20

因此，我们改变了方法调用的行为方式，甚至没有触及方法(corona time！！不要碰它)(是的是的我们移除了之前对静态方法的调用..我戴着面具做那个！！).

如果我有一个接受 3 个参数的方法呢？这个会失败吧？

是的，这肯定会失败。为了克服这一点，我们可以创建一个通用参数方法:

**def logging_decorator(incoming_function):
    def inner_function(*args, **kwargs):
        print('Operation called by', args[0].per_name)
        return incoming_function(*args, **kwargs)
    return inner_function**

有了这个，我们甚至可以有多变量方法:

**@logging_decorator
def add3(self, a, b, c):
    return a + b + c**print(cathy_calculator.add3(4, 5, 8))Output:
Operation called by Cathy
17

下面，我们用一个简单的例子来解释 Python 的基本概念，这些概念非常重要，但人们发现它们很难掌握。这些都是棘手的概念，但并不难。一旦你学会了这一点，你将会在你的 python 生涯中用到很多。我非常喜欢装修工，希望在这之后，你也会喜欢。上面讨论的代码的 GitHub 链接在这里:

感谢阅读！！。对于任何建议，疑问或讨论，在评论区拍摄。如果你喜欢这个代码，请在 Github 上投票。

在 medium 和 GitHub 上关注我，获取即将发布的文章；到那时，快乐的蟒蛇和好运:)

崇高文本 3 中的蟒蛇与崇高的 REPL 和蟒蛇

灵活的、以项目为中心的设置

只需一个按键就可以在项目之间切换，而不必担心构建系统的切换。借助这种以项目为中心的设置，加快您的数据科学工作流程。

在本教程中，您将学习如何将 Sublime Text 3 链接到 Anaconda/Miniconda 环境中，并使用 Sublime REPL 执行 Python。当您在 Sublime 中切换项目时，构建系统也会切换到与之相关联的 conda 环境。

您可能已经有了不同虚拟环境的现有项目——不用担心。这种设置可以很容易地应用到您已经拥有的任何项目。**注意:**本指南是为 Windows 10 编写的。

照片由 Pexels 的凯拉·伯顿拍摄

TL；速度三角形定位法(dead reckoning)

看起来可能需要很多步骤，但是如果你手头有一切，你可以在 1 分钟内完成。这是*你需要*去做的:崇高文本 3，包控制，项目经理，Anaconda/Miniconda 和 conda 虚拟环境。比如我这里用 *example_env* 。

1. 打开崇高文本 3，并确保你有包控制，崇高 REPL 和项目经理。用命令面板安装快捷键:CTRL+SHIFT+p，键入安装 > 包控制:安装包 > 【包名】
2. 记下 conda env 的名称或创建一个新的名称conda create --name **example_env** python=3.8 -y
3. 将C:\Program Files\Sublime Text 3\(或者subl.exe所在的任何地方)添加到你的系统环境变量中，打开项目目录中的cmd，用subl .打开 Sublime
4. 使用命令面板通过 CTRL+SHIFT+p > Project Manager: Add new project向项目管理器添加一个新项目
5. CTRL+SHIFT+p 键入browse，选择Preferences: Browse packages。浏览器在C:\Users\[YOURNAME]\AppData\Roaming\Sublime Text 3\Packages\中打开。导航至SublimeREPL/config/Python，复制文件Main.sublime-menu并返回C:\Users\[YOURNAME]\AppData\Roaming\Sublime Text 3\Packages\。
6. 打开User文件夹，创建目录SublimeREPL\config\Python，将Main.sublime-menu粘贴到刚刚创建的目录下(C:\Users\[YOURNAME]\AppData\Roaming\Sublime Text 3\Packages\User\SublimeREPL\config\Python)。将Main.sublime-menu改名为**example_env**.sublime-menu，用 Sublime 打开。
7. 搜索"id": "repl_python_run",所在的块，找到"cmd": ["python", "-u", "$file_basename"],。我们将"python"替换为我们想要链接到项目的 conda env 的路径，然后保存。比如:"cmd": ["C:\\Users\\philipp\\miniconda3\\envs\\**example_env**\\python.exe", "-u", "$file_basename"],。
8. CTRL+SHIFT+p 查找Project: edit project。插入下面的代码片段来定义项目的构建系统。用你想要的 conda env 替换 example_env 。

{ 
"build_systems": [ 
{ 
"name": "Conda Python **example_env** REPL", 
"target": "run_existing_window_command", "id": "repl_python_run", "file": "config/Python/**example_env**.sublime-menu", 
} 
], 
... }

厉害！用 CTRL+ ALT + p 在项目之间轻松切换，不用担心 conda 环境。该设置是项目特定的。我希望这能加快你的工作流程。祝你未来的项目愉快！

如果您遇到任何问题，请参考下面更详细的指南。如果你还有问题，有不清楚的地方或者你只是想打个招呼，请告诉我。非常感谢任何形式的反馈。

问题

项目越多，创建的虚拟环境就越多，特定于项目的设置就变得越重要。最*，当三个项目并行运行，我不得不频繁地在它们之间切换时，我就经历了这种情况。切换项目和构建系统打乱了我的工作流程。我需要一种快速的方法来切换和改变每个构建系统。我的工作流程依赖于 Sublime Text 3、Anaconda 和 Sublime REPL，所以我需要一个针对这些工具的解决方案。本文提出了一种*稳地集成它们的方法，以实现快速而稳定的项目设置。

对于一个轻量级和快速的 Python 设置，我们需要什么？

• 使用轻量级文本编辑器快速加载文件→升华文本 3
• 在项目之间轻松切换→提升项目经理
• 处理与为每个项目定义的虚拟环境的依赖关系→ Anaconda/Miniconda
• 使用交互式命令行构建系统→升华 REPL

这里提供的设置允许您使用 CTRL+ALT+p 在项目和它们相关的虚拟环境之间切换。选择另一个项目后，构建系统也会切换到您在项目设置中定义的项目。有几个步骤是必须遵循的，但这是值得的。希望这也对你有用。

开始之前

如果您还没有，请安装以下软件:

本教程假设 Windows 10 ，但应该同样适用于 Linux。我推荐使用 Miniconda，在 Reddit 上看看为什么

解决办法

来自 Pexels 的 Andrea Piacquadio 的照片

我们安装了上面列表中的所有东西，并且有一个 conda 环境。我使用 example_env 作为 conda 环境。第一步是将 Sublime 放在项目根文件夹的中心。这样，所有像用 CTRL+p 跳转到一个文件这样的快捷方式都与项目根./相关。然后我们初始化项目管理器。

让我们像C:\Users\[YOURNAME]\[PATH-TO-PROJECT]\[PROJECTNAME]一样在项目根打开 Sublime 的一个新实例。我已经将 Sublime 添加到我的环境变量中(下面有一个简短的操作方法),并在项目根目录中打开一个终端C:\Users\philipp\projects\Sublime project setup。用 CTRL+l 进入地址栏，键入cmd打开命令，
回车。运行subl .(仅当您将subl.exe添加到您的 Windows 环境变量中时才有效——在下面的附录中找到一个简短的方法)。一扇空荡的窗户打开了。这就对了。

现在我们转向项目经理。使用命令面板通过 CTRL+SHIFT+p > Project Manager: Add new project向项目管理器添加一个新项目。用 CTRL+SHIFT+p > Project Manger: Edit project检出项目设置文件。Sublime 在这里存储您的项目设置，包括项目name和path:

{ 
"folders": [ 
{ "binary_file_patterns": [ ], 
"file_exclude_patterns": [ ], 
"folder_exclude_patterns": [ ], 
"name": "Sublime project setup", 
"path": "C:\\Users\\philipp\\projects\\Sublime project setup" 
} 
] 
}

接下来，我们定义一个构建系统，它采用 conda env 项目的python.exe， example_env 。记下 conda 环境的名称。例如，在本教程中，我用conda create --name **example_env** python=3.8 -y创建了一个环境。所以，我在这里使用 example_env 作为环境。

1. CTRL+SHIFT+p 键入browse并选择Preferences: Browse packages。浏览器在C:\Users\[YOURNAME]\AppData\Roaming\Sublime Text 3\Packages\中打开。
2. 从这里，导航到SublimeREPL/config/Python并复制文件Main.sublime-menu
3. 回到C:\Users\[YOURNAME]\AppData\Roaming\Sublime Text 3\Packages\，打开User，创建以下文件夹:SublimeREPL\config\Python。
4. 现在你在C:\Users\[YOURNAME]\AppData\Roaming\Sublime Text 3\Packages\User\SublimeREPL\config\Python中，将Main.sublime-menu粘贴到目录中。
5. 将Main.sublime-menu改名为example_env.sublime-menu，用 Sublime 打开
6. 重要步骤:搜索"id": "repl_python_run",所在的区块，用"cmd": ["C:\\Users\\[YOURNAME]\\[PATHTOCONDA]\\envs\\**example_env**\\python.exe", "-u", "$file_basename"],替换"cmd": ["python", "-u", "$file_basename"],并保存。*注意:*用任何通向您的 conda 环境的python.exe的路径替换该路径。对我来说，这是C:\\Users\\philipp\\Miniconda3\\envs\\**example_env**\\python.exe。
7. 用 CTRL+SHIFT+p find Project: edit project打开命令面板，选择项目名称。现在我们定义使用我们的 conda 环境的 Python 的构建系统，**example_env**。复制粘贴下面的代码片段，并用您的环境名称替换 **example_env**。重要提示:共有 2 处替换粗体。

{ "build_systems": [ 
{ "name": "Conda Python **example_env** REPL", 
"target": "run_existing_window_command", 
"id": "repl_python_run", 
"file": "config/Python/**example_env**.sublime-menu", } 
], "folders": 
[ 
{ "binary_file_patterns": [ ], 
"file_exclude_patterns": [ ], 
"folder_exclude_patterns": [ ], 
"name": "example project", 
"path": "C:\\Users\\[YOURNAME]\\Projects\\example_project" } 
] }

为了简单地测试设置，创建一个像test.py一样的新文件并插入

用我们的构建系统运行这个文件(这里:Conda Python example _ env REPL):

我希望它一直工作到现在。如果没有，请给我留言或留下评论！

使用

当您并行处理几个项目时，这种设置显示了它的优势。您可以(I)使用 CTRL+ ALT + p 在项目之间切换,( ii)在您的构建系统之间拥有相关的虚拟环境。

要设置一个新项目，从命令行的subl .开始，重复解决方案部分的所有步骤。这样做两次左右，1 分钟后就会自然了。

我确信还有其他我还没有弄清楚的方法和项目设置。因此，我很欣赏任何关于崇高，REPL 和蟒蛇项目设置的技巧和最佳实践。

如果有人想自动化这个过程，并为 Sublime REPL 实现一个基于项目的构建系统，我将不胜感激！我认为许多其他人将从中受益。它将连接来自崇高的阿纳康达和 REPL 世界的最好的工具。

结论

在本教程中，您学习了如何设置崇高的 REPL 和链接到您的康达环境。通过这种方式，您可以跨项目拥有多个环境，并使用 Sublime 的项目管理器及其快捷键 CTRL+ ALT+p 轻松切换。享受您的新设置，享受您的项目！

如果你觉得这很有帮助，或者在安装过程中遇到了一些问题，请给我留言。非常感谢您的反馈！

进一步寻找中级提示和技巧来开发您的数据科学工作流？敬请关注下一篇关于数据科学工具 2021 的帖子。

附录

如何将 subl.exe 添加到环境变量

Windows 用户的快捷方式:点击 Windows 键，输入env，从搜索结果中选择Edit environment variables for your account。

然后点击Path>Edit>New>C:\Program Files\Sublime Text 3\>OK。用找到subl.exe的目录替换C:\Program Files\Sublime Text 3\。另见本教程。

资源

https://stackoverflow.com/questions/38214656/using-different-conda-envs-with-sublime-repl

最初发布于https://philippschmalen . github . io。

Python 是完美的——为什么反 Python 开发者不会放弃

原文：https://towardsdatascience.com/python-is-perfect-why-anti-python-developers-wont-give-up-326ae1a09e7f?source=collection_archive---------3-----------------------

编程；编排

如何让讨厌 Python 的人闭嘴？

费尔南多·埃尔南德斯在 Unsplash 上的照片

软件开发长期以来一直有点像雷区。

一般人会觉得用传统的编程语言(如 C 和 JAVA)进入软件领域是很可怕的。

但是一旦 Python 加入游戏，这种情况很快就改变了。Python 因其革命性的编程方法而成为软件开发的一大飞跃。

人们爱上 Python 是因为它的简单性、广泛的库支持和表达能力。就这样，像 C 和 JAVA 这样的语言的统治结束了。

没有什么是完美的。等等，真的吗？

如果你是一名软件开发人员，你可能很熟悉术语权衡。

每当出现关于编程语言的问题时，人们期望得到的传统答案是:“视情况而定。”

普遍认为没有完美的编程语言。等等，是真的吗？

对我来说，不是。我开始意识到 Python 是编程语言的银弹。

到目前为止，我用过 Python C，C++，MATLAB，JAVA。Python 是最后的，也是最好的。到目前为止。

为了测试 Python，我做了一个实验，将我的大部分非 Python 程序转换成 Python。最终的 Python 版本要好得多。

现在，据我所知，Python 在两个主要问题上一直受到严厉批评。

• 动态打字
• 速度

虽然我同意这些问题在某种程度上对软件开发有重大影响，但我可以肯定这是在 Python 还处于婴儿期的时候。

然而，由于其坚如磐石的社区，Python 已经发展到了几乎可以与所有编程语言相提并论的地步。动态类型和速度不再对编码实践有重大影响。

Python 兼容所有问题。

如果是这样的话，为什么 Python 还没有被广泛采用呢？

如果我现在回答这个问题，我的话将没有任何争论的分量。因此，有必要解释一下为什么动态类型和性能问题是容易被忽略的小问题。

动态打字

要理解动态类型，最好一直拖着对立面——静态类型。

静态类型语言是 C、JAVA 等。这些语言和它们的动态类型对应物之间的主要区别在于类型检查。静态类型是在编译时执行类型检查，而在动态类型中，类型检查是在运行时执行的。

名词（noun 的缩写）b:这是动态和静态类型的一个*淡无奇的定义。细节和技术细节超出了这篇文章的范围。

由于 Python 的调试问题，以及这种语言如何使跟踪 bug 的过程变得更加复杂，一些开发人员对 Python 怨声载道。

这种抱怨源于这样一个事实，即作为一种动态类型语言，Python 在运行时会标记错误，这使得它比像 JAVA 这样的静态类型语言更容易出错。

从理论上讲，考虑到众所周知的谚语— 人非圣贤，孰能无过，这是一种威胁。但是实际上，我怀疑类型错误就像他们声称的那样严重。

说真的，现在谁会犯打字错误？

静态类型语言远不是一个没有麻烦的调试避风港。除了类型错误之外，大多数静态类型语言都无法捕捉到您可能认为可以检测到的细微错误。这些错误同样发生在静态类型和动态类型中。

此外，我们可以同意，几乎没有代码是在没有单元测试的情况下部署的。单元测试为防止类型错误提供了一个很好的保护层。只有极少数情况下，类型错误会绕过单元测试，从而搞乱代码。

编程语言在调试方面的另一个特性是安全和不安全的类型。众所周知，允许用户重写系统类型的语言具有不安全的类型，例如 C。虽然不安全的类型赋予了用户对类型的控制权，但是它的误用会导致程序任意崩溃。

大多数静态类型语言都是不安全的类型系统。然而，JAVA 是一种安全的类型。Python 和我所知道的其他动态类型编程语言也是如此。

最后，我更愿意用像 Python 这样方便和高级的语言编写一百万次代码，而不是陷入像 JAVA 这样的低级语言的细节中。

速度

可怜的蟒蛇一直微笑着接受性能批评。如果你正在进行编程语言的辩论，我几乎可以保证，一旦你开始吹捧 Python，你的性能就会大打折扣。这是真的。嗯，在某种程度上。

我不会争论原始或标准 Python 比 C 或 JAVA 慢的事实。但是正如我之前所说的，有了像 Python 这样勤奋和创新的社区，不用担心。

在过去的几年里，Python 和它的静态竞争对手之间的性能差距已经大大缩小了。JIT 编译和并行计算的进步让 Python 赶上了它的竞争对手。

为了解决 Python 的性能问题，开发了许多变通方法。例如:

• 将实现从 CPython 改为 PyPy 显著提高了执行速度。偶尔，PyPy 甚至可以跑赢 C

名词（noun 的缩写）B: CPython 是你从Python.org下载的实现

• 抑制 GIL 使 Python 能够并行执行序列，从而提高计算速度。
• JIT 编译器 Numba 。把 Numba 装饰器放在你的函数上，看着它以光速运行就足够了。
• 很多 Python 库像 Numpy 和 Scipy 都是用 C/C++写的。

如您所见，性能在某种程度上是反对 Python 的过时论点。有了所有这些解决方案，除了称赞 Python 充满活力的社区之外，别无他法。

但是为什么有些人仍然不喜欢 Python，而更喜欢老式的 JAVA 之类的东西呢？

为什么不向 Python 投降？

首先，这里有一个 quora 帖子让我忍俊不禁。

来源: Quora

显然，有些人没有也不会把 Python 当回事。有意思！

无论如何，我个人认为，阻碍 Python 被大规模采用的是人们对待编程的心态。换句话说，问题不在于语言，而在于人。

你看，Python 的出现是为了让编程变得更容易，更重要的是，为了节省时间。

您可能会想，“我用 JAVA 编码很舒服。我为什么需要 Python？”你当然不知道，但是你知道如果你投资 Python，你将能够释放你的全部编码潜力，而不是停留在 JAVA 的低级混乱中。

Python 是开源的、干净的、用户友好的。有了一个好的文本编辑器，你甚至可以让你的代码比英文文本更漂亮。Python 不期待什么回报，只是一点点欣赏。

Python 可能好得令人难以置信。我个人认为是。

而人们仍在使用 C 和 JAVA 的原因是一个古老的信念——努力就会有回报。我不会撒谎说这个信念是错误的，因为它不是。但是，我想传达的是“*努力就会有回报”*只是被放在了错误的属性上。相反，它应该放在 Python 中。

事实上，在一头扎进 Python 之前，JAVA 之类的东西是的一个很好的热身。他们很可能让你在 Python 上获得成功。

此外，在顽固的程序员眼中，向 Python 的过渡并不是一个选项，例如，他们协助推出了 C 语言，并从那以后就陷入了困境。一个真正与语言一起成长并在其起伏中支持它的开发人员不太可能放弃它。

我确信这些值得尊敬的开发人员即使在极端情况下也不会改变主意——例如，发布一种可以自己编写代码的编程语言。

事实是**“适应”说起来容易做起来难。**

最后的想法

软件开发是一个迷人的领域。它总是让你保持警觉。

因此，你应该随时准备好武器来反击任何对你最亲爱的编程语言的批评。否则，你只能看着它被射杀。知识和经验是你最好的武器。

编程曾经是一个很难触及的领域，但是现在由于 Python 的出现，它对每个人都是一个开放的世界。

“Python 可以教给孩子”——Guido Van Rossum

我个人认为 Python 是一种完美的编程语言。Python 在可读性方面胜过所有人。当然，一个糟糕的 Python 程序员会产生杂乱的代码。然而，我希望混乱的代码没有那个家伙用另一种语言写同样的代码那么混乱。

坦率地说，我从未遇到过 Python 与另一种编程语言相比相形见绌的情况。也许将来我会的。如果我知道，我会重新忏悔。

同时，如果你有 Python 失去了你的尊重的经历，欢迎在评论中分享。

如果 Python 不是开源的，人们会指责我为 Python 做广告。

很高兴是这样！

参考

文章灵感来自《计算机的进步》一书和作者的经历。

Python Lambda 函数:三个实际例子(排序、映射和应用)

原文：https://towardsdatascience.com/python-lambda-functions-three-practical-examples-sort-map-and-apply-286593792cb4?source=collection_archive---------21-----------------------

通过真实的例子学习 lambda 函数

照片由托尔加·乌尔坎在 Unsplash 上拍摄

简介—λ函数

一个高级的 Python 概念是 lambda 函数，它是使用lambda关键字定义的匿名函数。Lambda 函数具有以下基本形式:

lambda params: expression

• 关键字lambda表示您正在定义一个 lambda 函数。
• params指的是 lambda 函数将使用的参数。参数的数量可以是零到多个。
• expression表示 lambda 函数将要运行的表达式。

就其核心而言，lambda 函数就像其他 Python 函数一样，可以使用 call 操作符(括号)来调用。下面的代码向您展示了相关的事实。

>>> multiply = lambda x, y: x*y
>>> type(multiply)
<class 'function'>
>>> multiply(5, 3)
15
>>> multiply(8, 5)
40

虽然我们把 lambda 函数赋给了变量multiply，这只是为了向你展示 lambda 是函数的事实。在实际项目中，强烈建议不要这样做，因为正如它的别名所知，lambdas 是匿名函数，应该用在不需要明确定义函数的地方。

在了解了如何定义 lambda 函数之后，让我们探索它的实际用例，以便更彻底地学习这种技术。

实际例子

示例 1:对自定义实例列表进行排序

通常，我们使用列表来保存同类数据——相同类型的对象。但是，这些对象可能不会按照特定需求的期望顺序排列。例如，一个列表可以包含一个论坛应用程序的一堆帖子。我们应该允许用户按照作者或者评论号来排序文章。在这些情况下，我们可以将sort方法与 lambda 函数一起使用。

使用 Lambda 排序

因为我们希望按照作者的姓氏对文章进行排序，所以 lambda 函数的表达式需要提取每次的姓氏。我们利用了 string 的 split 方法，它创建了一个字符串列表。因为姓氏是最后一项，所以我们使用-1 来检索它。

如你所见，这些帖子确实是按照作者的姓氏排序的。顺便提一下，sort 方法对列表中的项目进行就地排序，这意味着它改变了原始列表的顺序。

示例 2:绘制熊猫系列的数据(地图)

pandas 中的一个主要数据类型是Series类型，它表示一维数据，比如数据表中的一行或一列。当我们从一个系列开始时，我们可以使用 map 方法创建另一个系列。尽管可以使用 dictionary 对象来提供映射，但通常可以使用 lambda 函数。考虑下面的例子。

>>> import pandas as pd
>>> str_data = pd.Series(["95.2%", "92.7%", "93.4%"])
>>> str_data
0    95.2%
1    92.7%
2    93.4%
dtype: object
>>> float_data = str_data.map(lambda x: float(x[:-1]))
>>> float_data
0    95.2
1    92.7
2    93.4
dtype: float64

如上所示，我们从一个由多个百分比字符串数据组成的Series开始。但是，我们希望在删除百分号后提取这些字符串的数值。我们可以用一个 lambda 函数轻松完成转换:lambda x: float(x[:-1])。在这个函数中，x指的是Series中的每一项，我们使用float函数将字符串转换成相应的数值。

示例 3:从 Pandas 数据框架创建数据(应用)

pandas 中的另一个基本数据类型是DataFrame类型，它表示类似数据表的二维电子表格。带有DataFrame的 lambda 函数最常见的用例是apply方法，使用它，我们可以从现有的列创建新的数据列。让我们通过下面的例子来探索这种用法。

数据帧应用 Lambda

在示例中，我们使用 lambda 函数创建另一列portion。参数x指的是DataFrame中的每一行(因为我们设置了axis=1，这意味着操作是按行应用的)。如您所见，在操作之后，我们成功地计算出了具有相应百分比值的部分。

结论

在本文中，我们回顾了 lambda 函数的三个常见用例。本质上，lambda 函数应该用于执行不需要定义常规函数的小任务。

如何在 Python 中实现链表

原文：https://towardsdatascience.com/python-linked-lists-c3622205da81?source=collection_archive---------2-----------------------

探索如何使用 Python 从头开始编写链表和节点对象

照片由 Mael BALLAND 在 Unsplash 上拍摄

介绍

链表是最基本的数据结构之一，表示一系列节点。序列的第一个元素称为链表的头和尾，最后一个元素对应于尾和尾。

序列中的每个节点都有一个指向下一个元素的指针，也可以有一个指向上一个元素的指针。在单链表中，每个节点只指向下一个节点。

单链表—来源:作者

另一方面，在双向链表中，每个节点既指向前一个节点，也指向下一个节点。

双向链表——来源:作者

链表在各种场景中都非常有用。在以下情况下，它们通常优于标准阵列

• 在序列中添加或删除元素时，您需要一个恒定的时间
• 更有效地管理内存，尤其是当元素的数量未知时(如果是数组，您可能必须不断地缩小或增大它们。注意，填充数组通常比链表占用更少的内存。
• 您希望更有效地在中间点插入项目

与其他通用语言不同，Python 的标准库中没有内置的链表实现。在今天的文章中，我们将探索如何使用 Python 实现一个用户定义的链表类。

在 Python 中实现用户定义的链接类

首先，让我们为链表中的单个节点创建一个用户定义的类。这个类既适用于单链表，也适用于双向链表。因此，这个类的实例应该能够存储节点的值，下一个和上一个节点的值。

class Node:
    def __init__(self, value, next_node=None, prev_node=None):
        self.value = value
        self.next = next_node
        self.prev = prev_node

    def __str__(self):
        return str(self.value)

请注意，当一个Node的实例将next设置为None时，这意味着它本质上是链表的尾部(单个或两个)。类似地，在双向链表中，当一个节点的prev被设置为None时，这表明该节点是链表的头。

既然我们已经为节点创建了一个类，现在我们可以为链表本身创建类了。如前所述，链表有一个head、一个tail和指向彼此的节点。

class LinkedList:
    def __init__(self, values=None):
        self.head = None
        self.tail = None if values is not None:
            self.add_multiple_nodes(values)

现在，为了将构造函数中提供的值作为节点添加到链表中，我们需要定义两个额外的方法。

第一个方法叫做**add_node**,用于向链表中添加一个节点。

def add_node(self, value):
    if self.head is None:
        self.tail = self.head = Node(value)
    else:
        self.tail.next = Node(value)
        self.tail = self.tail.next
    return self.tail

现在让我们快速浏览一下这个方法的逻辑。如果链表没有头，那么这意味着它是空的，因此要添加的节点将是链表的头和尾。如果头部不为空，那么我们添加新创建的Node作为当前tail的next元素，最后移动尾部指向新创建的Node。

第二个方法叫做**add_multiple_nodes**，它在构造函数中被调用，并且简单地调用我们之前定义的add_node方法，以便在链表实例中添加多个值作为节点。

def add_multiple_nodes(self, values):
    for value in values:
        self.add_node(value)

到目前为止，我们的链表类如下所示:

class LinkedList:
    def __init__(self, values=None):
        self.head = None
        self.tail = None if values is not None:
            self.add_multiple_nodes(values) def add_node(self, value):
        if self.head is None:
            self.tail = self.head = Node(value)
        else:
            self.tail.next = Node(value)
            self.tail = self.tail.next
        return self.tail def add_multiple_nodes(self, values):
        for value in values:
            self.add_node(value)

现在让我们创建一个额外的方法，它能够插入一个新元素，但是这次是在链表的开始，也就是作为一个头。

def add_node_as_head(self, value):
    if self.head is None:
        self.tail = self.head = Node(value)
    else:
        self.head = Node(value, self.head)
    return self.head

现在让我们在类中重写一些可能有用的特殊方法。首先，让我们实现__str__方法，以便链表对象的字符串表示是人类可读的。例如，当打印出一个带有节点a, b, c, d的链表时，输出将是a -> b -> c -> d。

def __str__(self):
    return ' -> '.join([str(node) for node in self])

其次，让我们也实现__len__方法，它将返回我们的用户定义类的长度，本质上是序列中包含的节点数。我们需要做的就是遍历序列的每个节点，直到到达链表的尾部。

def __len__(self):
    count = 0
    node = self.head
    while node:
        count += 1
        node = node.next
    return count

最后，让我们通过实现__iter__方法来确保LinkedList类是可迭代的。

def __iter__(self):
    current = self.head
    while current:
        yield current
        current = current.next

此外，我们还可以创建一个名为values的属性，这样我们就可以访问序列中所有节点的值。

@property
def values(self):
    return [node.value for node in self]

最终的类如下所示:

class LinkedList:
    def __init__(self, values=None):
        self.head = None
        self.tail = None if values is not None:
            self.add_multiple_nodes(values) def __str__(self):
        return ' -> '.join([str(node) for node in self]) def __len__(self):
        count = 0
        node = self.head
        while node:
            count += 1
            node = node.next
        return count def __iter__(self):
        current = self.head
        while current:
            yield current
            current = current.next @property
    def values(self):
        return [node.value for node in self] def add_node(self, value):
        if self.head is None:
            self.tail = self.head = Node(value)
        else:
            self.tail.next = Node(value)
            self.tail = self.tail.next
        return self.tail def add_multiple_nodes(self, values):
        for value in values:
            self.add_node(value) def add_node_as_head(self, value):
        if self.head is None:
            self.tail = self.head = Node(value)
        else:
            self.head = Node(value, self.head)
        return self.head

现在，即使我们的Node类可以表示包含在单向或双向链表中的节点，我们定义的LinkedList类只能支持单向链表。这是因为在添加节点时，我们没有指定前一个节点。

为了处理双向链表，我们可以简单地创建一个额外的类，它继承自LinkedList类并覆盖add_node和add_node_as_head方法:

class DoublyLinkedList(LinkedList):
    def add_node(self, value):
        if self.head is None:
            self.tail = self.head = Node(value)
        else:
            self.tail.next = Node(value, None, self.tail)
            self.tail = self.tail.next
        return self def add_node_as_head(self, value):
        if self.head is None:
            self.tail = self.head = Node(value)
        else:
            current_head = self.head
            self.head = Node(value, current_head)
            current_head.prev = self.head
        return self.head

Python 中用户自定义链表的完整代码

包含我们在今天的教程中创建的三个类的完整代码作为 GitHub 要点在下面给出。

包含 Node、LinkedList 和 DoublyLinkedList Python 类的完整代码——来源:作者

最后的想法

在今天的指南中，我们讨论了最基本的数据结构之一，即链表。鉴于 Python 的标准库不包含这种特定数据结构的任何实现，我们探索了如何从头实现用户定义的链表类。

成为会员 阅读介质上的每一个故事。你的会员费直接支持我和你看的其他作家。你也可以在媒体上看到所有的故事。

https://gmyrianthous.medium.com/membership

你可能也会喜欢

Python 列表被高估了

原文：https://towardsdatascience.com/python-lists-are-overrated-776e87cda3e5?source=collection_archive---------27-----------------------

考虑这些潜在的更好的选择

照片由来自佩克斯的克里斯蒂娜·莫里洛拍摄

如果您使用 Python 已经有一段时间了，那么您应该非常熟悉列表；它们无处不在。

列表可以说是 Python 中最流行的数据结构，很容易理解为什么。它们具有巨大的实用性和多功能性。

不幸的是，随着对列表的严重依赖，忽略了其他有能力的数据结构，这些数据结构可以说比列表执行得更好。

你可能会想:这有什么关系呢？如果列表能完成工作，为什么还要用其他工具呢？

如果您满足于处理少量数据，这种推理是合理的。然而，如果你打算利用你的技能为其他公司服务，你应该明白，你不能对如何存储和处理你的数据如此松懈。

经常被数十亿字节的数据所累的公司强调开发在时间和内存消耗方面优化的高效程序的重要性。

效率和功能一样重要！

您需要理解，即使有多种工具可以完成工作，但有些工具就是比其他工具优越。了解哪种数据结构对于特定场景是理想的，对于提高代码质量来说是一个巨大的进步。

虽然列表确实是一种可靠的数据结构，但它们并不适合所有情况。以下是几个值得考虑的替代方案。

1.元组

元组与列表有许多相似之处。这两种数据结构都存储不同的数据类型，并为它们的元素分配特定的顺序。

两者之间的主要区别在于，与列表不同，元组是不可变的。它们的赋值不能以任何方式改变。

考虑到程序员经常需要修改他们存储的数据，这使得列表看起来更有吸引力。然而，出于这个原因完全省略元组是错误的。

尽管元组不允许你改变它的值，但它仍然比列表有一个主要的优势:内存使用。元组比列表需要更少的空间来存储相同数量的数据。

让我们用一个简单的例子来说明这一点。

这里，我们创建一个存储相同值的列表和元组，并使用 sys 模块来确定两个对象的大小。

由作者创建

代码输出(由作者创建)

如上所示，元组需要更少的内存来存储与列表相同的数据。

创建内存高效的程序是必须的，这就是为什么有必要将这种数据结构保存在您的武库中。

由于元组是不可变的，所以只能用来存储值和查找值。因此，使用元组的理想场景是当您知道元组中的值并且不需要修改它们时。

2.Numpy 数组

与列表不同，numpy 数组不是内置的数据结构。它们来自 numpy 模块，专门进行数学运算。

与列表不同，numpy 数组只存储同质值(即数组的元素必须是同一类型)。

幸运的是，它们弥补了这个缺点，允许您以更少的内存使用和更快的运行时间来执行各种计算。

下面的例子展示了 numpy 数组的快速运行时间。

假设我们希望创建 2 个包含 1，000，000 个值的列表，范围从 0 到 999，999，然后将每个列表的元素相加，形成第三组值。让我们来看看用列表和 numpy 数组实现这一点需要多少时间。

注意:运行时间将通过使用“%%timeit”神奇函数得出

运行时间:148 毫秒(由作者创建)

运行时间:3.8 毫秒(由作者创建)

运行时间的差异证明了 numpy 数组的可用性。

除了运行时间更短之外，numpy 数组的内存效率也更高。让我们使用 sys 模块来比较包含 1，000，000 个值的列表和包含 1，000，000 个值的 numpy 数组的大小。

由作者创建

代码输出(由作者创建)

当存储 1，000，000 个值时，numpy 数组使用的内存不到列表的一半。

总的来说，numpy 数组在运行时间和内存使用上都超过了 lists。虽然使用列表进行简单的计算是完全可以的，但是当涉及到计算密集型的计算时，numpy 数组是您最好的选择。

3.设置

在我看来，集合是 Python 中最容易被忽视的数据结构。

根据定义，集合存储不同值的可变集合。鉴于集合不允许重复，人们可能会选择坚持使用列表，因为他们已经习惯使用后者。

然而，忽略集合意味着抛弃所有伴随它们而来的功能。

在执行搜索时，集合是非凡的。

由作者创建

在比较在列表和第一个语料库的集合中搜索单词“believe”所花费的时间之前，为了公*比较，我将从列表中删除重复值。

删除重复项(由作者创建)

下面是两种搜索的比较:

运行时间:313ns(由作者创建)

运行时间:53.5ns(由作者创建)

运行时间的差别是白天和黑夜。

此外，集合提供了许多功能，使搜索变得更加容易。

例如，如何找到在两个文本语料库中都存在的所有单词？下面是如何使用列表来实现的。

运行时间:37.3 秒(由作者创建)

这是使用集合时的样子。

运行时间:586ns(由作者创建)

set 不仅用更少的时间完成了任务，还用更少的代码行完成了任务。集合提供了许多有用的功能，如“交集”,使程序员能够从不同的集合中提取所需的数据。

因此，在执行搜索时，设置很容易胜过列表。然而，当使用集合时，有一个必须考虑的速度-内存权衡。虽然集合可以缩短运行时间，但它们也需要更多内存。

由作者创建

代码输出(由作者创建)

是否应该使用集合取决于项目的目标和限制。如果您的首要任务是最小化运行时间，那么集合就是理想的数据结构。

结论

照片由来自佩克斯的普拉蒂克·卡蒂亚尔拍摄

总的来说，列表是非常通用的，但是仅仅依靠它们来存储数据是错误的。为了编写有效的代码，熟悉使用不同数据结构的优点和缺点是很重要的。

如果你限制自己只使用列表(即使它们足够了)，你就限制了自己作为程序员的能力，并且限制了代码的效率。

希望您现在已经学会了在执行数据操作时总是考虑可选的数据结构。

我祝你在编码工作中好运！

Python 列表有时比 NumPy 快得多。这是证据。

原文：https://towardsdatascience.com/python-lists-are-sometimes-much-faster-than-numpy-heres-a-proof-4b3dad4653ad?source=collection_archive---------4-----------------------

小心使用什么。

布拉登·科拉姆在 Unsplash 拍摄的照片

我最*在做一个数字图像处理项目。超参数调整花了相当长的时间，我才得到想要的精度。都是因为过度拟合的寄生虫和我没用的低端硬件。

对于每次执行，我的机器花费大约 15-20 分钟。20 分钟处理 20 000 个条目。我想象如果我一直在处理一个 100 万的记录数据集，我将不得不在训练结束之前等待地球完成一次完整的旋转。

我对模型的准确性感到满意。然而，在提交我的代码之前，我想尝试许多其他的卷积神经网络(CNN)架构。因此，我决定在我的代码中寻找优化空间。

因为我使用的是 PyPi 中预先构建的机器学习算法——Scikit-Learn 和 tensor flow——只剩下很少的子例程需要优化。一个选择是在数据结构方面提升我的代码。我将数据存储在列表中，由于 NumPy 非常快，我认为使用它可能是一个可行的选择。

猜猜我的列表代码转换成 NumPy 数组代码后发生了什么？

令我惊讶的是，执行时间没有缩短。相反，它飙升。

也就是说，在这篇文章中，我将带您了解列表最终比 NumPy 数组表现更好的确切情况。

数字和列表

首先，让我们讨论 NumPy 数组和列表之间的区别。

NumPy 是用于 N 维数组操作和计算的事实上的 Python 库。它是开源的，易于使用，内存友好，速度快如闪电。

NumPy 最初被称为“Numeric”，它为许多数据科学库(如 SciPy、Scikit-Learn、Panda 等)设置了框架。

Python 列表存储有序的、可变的数据对象的集合，而 NumPy 数组只存储单一类型的对象。因此，我们可以说 NumPy 数组生活在列表的保护伞下。因此，没有 NumPy 数组做不到的事情。

但是，说到 NumPy 整体。Numpy 不仅包括数组操作，还包括许多其他例程，如二元运算、线性代数、数学函数等等。我相信它涵盖了超过一个人可能需要的。

接下来要考虑的是为什么我们通常使用 NumPy 数组而不是列表。

简而言之，我相信每个阅读这篇文章的人都知道:它更快。

NumPy 确实快得离谱，尽管 Python 速度慢是众所周知的。这是因为 NumPy 是 C 和 Fortran 的包装器。而且不用说这两个有多快。

NumPy 数组比列表快

在我们讨论 NumPy 数组变得像蜗牛一样慢的情况之前，有必要验证 NumPy 数组通常比列表更快的假设。

为此，我们将使用 NumPy 和 lists 来计算一百万个元素数组的*均值。该数组是随机生成的。

以下代码是一个示例:

"""General comparison between NumPy and lists"""import numpy as np
from time import time#Random numpy array
numpy_array = np.random.rand(1000000)
list_conv = list(numpy_array)#Start timing NumPy compuation
start1 = time()
#Compute the mean using NumPy
numpy_mean = np.mean(numpy_array)
print(f"Computing the mean using NumPy: {numpy_mean}")
#End timing
end1 = time()
#Time taken
time1 = end1 - start1
print(f"Computation time: {time1}")#Start timing list computation
start2 = time()
#Compute the mean using lists
list_mean = np.mean(list_conv)
print(f"Computing the mean using lists: {list_mean}")
#End timing
end2 = time()
#Time taken
time2 = end2 - start2
print(f"Computation time: {time2}")#Check results are equal
assert abs(numpy_mean - list_mean) <= 10e-6, "Alert, means are not equal"

我的机器输出如下:

Computing the mean using NumPy: 0.4996098756973947
Computation time: 0.01397562026977539
Computing the mean using lists: 0.4996098756973947
Computation time: 0.17974257469177246

正如预测的那样，我们可以看到 NumPy 数组明显比列表快。相当大的速度差异是显而易见的。

也就是说，我们能概括地说 NumPy 数组总是比列表快吗？

事实证明 NumPy 数组并不总是超过列表。列表也有锦囊妙计，这就把我们带到了下一个环节。

NumPy 数组并不总是比列表快

如果列表与 NumPy 数组相比毫无用处，它们可能已经被 Python 社区抛弃了。

与 NumPy 数组相比，列表更出色的一个例子是append()函数。"append()"将值添加到列表和 NumPy 数组的末尾。这是一个常见且经常使用的功能。

下面的脚本演示了列表的append()和 NumPy 的append()之间的比较。这段代码只是将从 0 到 99 999 的数字添加到一个列表和一个 NumPy 数组的末尾。

"""numpy.append() vs list.append()"""
import numpy as np
from time import timedef numpy_append():
    arr = np.empty((1, 0), int)
    for i in range(100000):
        arr = np.append(arr, np.array(i))
    return arrdef list_append():
    list_1 = []
    for i in range(100000):
        list_1.append(i)
    return list_1def main ():
    #Start timing numpy array
    start1 = time()
    new_np_arr = numpy_append()
    #End timing
    end1 = time()
    #Time taken
    print(f"Computation time of the numpy array : {end1 - start1}") #Start timing numpy array
    start2 = time()
    new_list = list_append()
    #End timing
    end2 = time()
    #Time taken
    print(f"Computation time of the list: {end2 - start2}") #Testing
    assert list(new_np_arr) == new_list, "Arrays tested are not the same"if __name__ == "__main__":
    main()

我的机器产生以下输出:

Computation time of the numpy array : 2.779465675354004
Computation time of the list: 0.010703325271606445

正如我们所看到的，在这个例子中，列表比 NumPy 数组表现得更好。Numpy 表现差到被超过 2000 %的地步。

这个案例表明，无论何时涉及到速度，NumPy 都不应该被认为是“总是去”的选项。相反，需要仔细考虑。

Numpy.append 有什么问题？

为了解开这个谜，我们将访问 NumPy 的源代码。append()函数的 docstring 告知如下内容:

"Append values to the end of an array. Parameters
    ----------
    arr : array_like
        Values are appended to a copy of this array.
    values : array_like
        These values are appended to a copy of `arr`.  It must be of 
        the correct shape (the same shape as `arr`, excluding
        `axis`). If `axis` is not specified, `values` can be any 
        shape and will be flattened before use.
    axis : int, optional
        The axis along which `values` are appended.  If `axis` is 
        not given, both `arr` and `values` are flattened before use. Returns
    -------
    append : ndarray
        A copy of `arr` with `values` appended to `axis`.  Note that
        `append` does not occur in-place: a new array is allocated
        and filled.  If `axis` is None, `out` is a flattened array."

在彻底阅读了 docstring 之后，我们可以看到关于函数返回内容的“注释”。它声明追加过程不发生在同一个数组中。而是创建并填充一个新数组。

然而，在列表中，事情是非常不同的。列表填充过程停留在列表本身中，不会生成新的列表。

总之，我们可以看到numpy.append()的复制-填充过程使它成为一个开销。

外卖食品

编程没有万金油。

我们的发现证明了 NumPy 阵列并不能解决所有性能问题。在考虑所有选择之前，不应该盲目地采取行动。这样做也最大化了产生设计更好的代码的机会。

此外，通过实验探索多种途径可以确保人们最终不会后悔做出了不同的选择。更重要的是，实验会发现错误信息。

最后，作为对我坚持这一观点的奖励，这里有一段 A. Einstein 深刻的引用，总结了这篇文章的观点。

“再多的实验也无法证明我是对的；一个简单的实验就能证明我是错的。”——阿尔伯特·爱因斯坦。

如果你觉得这很有见地，可以考虑成为 高级 会员，每月 5 美元。如果用这个 链接 ，我会得到一个小切。

https://ayarmohammed96.medium.com/membership

享受您的编程日！

Python 列表、Numpy 数组和 Pandas 系列

原文：https://towardsdatascience.com/python-lists-numpy-arrays-and-pandas-series-72c4829242bf?source=collection_archive---------18-----------------------

由 Jyotirmoy Gupta 在 Unsplash 上拍摄的照片

不同数据结构的便利性

假设你有 1 到 20 之间的奇数，你用以下方式存储它们:

# Python list
my_odd_nums = [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]# Numpy array
my_odd_nums = numpy.array([1, 3, 5, 7, 9, 11, 13, 15, 17, 19])# Pandas series
my_series = pandas.Series(my_odd_nums)>>
0     1
1     3
2     5
3     7
4     9
5    11
6    13
7    15
8    17
9    19
dtype: int64

列表、数组和熊猫系列乍一看非常相似，所以人们经常会问——为什么我们需要不同的数据结构？有哪些利弊和用例？这篇简短文章的目的就是要澄清一些困惑。

1。Python 列表

列表是 Python 中存储多项的 4 种内置数据类型之一(另外 3 种数据类型是字典、元组和集合)。一个列表可以同时存储多种数据类型——整数、浮点、字符串。一个列表甚至可以存储其他列表、元组和字典。

使用列表的相关方法如下:append(), extend(), insert(), remove(), pop(), clear(), index(), count(), sort(), reverse(), copy()

例如，append()方法用于将一个条目添加到一个已有的列表中:

mylist = [10, 12, 8, 6, 14]
mylist.append(99)>> [10, 12, 8, 6, 14, 99]

2.Numpy 数组

另一方面，Numpy 是用于科学计算的核心 Python 库(因此得名“数字 Python”或 Numpy)。该库提供了创建和处理多维对象(称为数组)的方法和函数。数组是值的网格，与 Python 列表不同，它们具有相同的数据类型:

# 1-dimesional array
array([1, 2, 3])# 2-dimensional array
array([[1, 2],
       [3, 4],
       [5, 6]])

常用方法的一个例子是随机数生成器:

# generate random integers
ran = np.random.randint(0,20,5) # low, high, size
print(ran)>> array([1, 3, 5])

由于 Numpy 数组都是数字数据类型，因此可以应用一系列统计操作:

# to add all values in an array
my_array = array([1,2,3])my_array.sum()>> 6

Numpy 是一个强大的库，具有全面的数学函数和线性代数例程，因此它是许多数据科学/机器学习/深度学习库中的基础。

3.熊猫系列

Pandas 系列是一个一维数值列表(可以是混合数据类型——整数、浮点、文本),存储有一个带标签的索引。而如果多个序列组合成一个单一的指标，则称为“数据框”。换句话说，数据帧是具有相同索引的系列的集合。Pandas 是数据科学中最受欢迎的数据辩论库。

可以从现有的 Pythion 列表或 Numpy 数组创建系列:

# index
countries = ["US", "BD", "CA"]
# data
data = [100, 200, 300]
# series
myseries = pd.Series(data, index = countries)>>
US    100
BD    200
CA    300
dtype: int64

回到原来的问题:列表、数组、数列的区别和优势是什么？

一个关键的区别是存储数据所需的空间。假设我们有 0 到 20 之间的数字，存储在 3 个数据结构中。看储物空间的差异。Numpy 数组显然是赢家。

另一个区别是 Numpy 数组在向量和矩阵运算中的显著高性能。

尽管存在一些差异，但每种数据类型在数据科学中都有特定的应用案例——例如，用于存储包括文本数据在内的复杂数据类型的 Python 列表；用于高性能数值计算的 Numpy 阵列:和 Pandas 系列，用于操纵表格数据以进行可视化、统计建模以及过滤和汇总。

Python 日志记录

原文：https://towardsdatascience.com/python-logging-from-nothing-to-something-79a7f6a0c1eb?source=collection_archive---------20-----------------------

没事->有事

跟着练习，为你的编程工作装备这种不性感但重要的日志记录技能

只是一个基本的日志功能！

我们通常打印输出来检查我们的逻辑在编码时是否按预期运行。但是，在生产过程中可能会出现运行时问题，我们无法验证打印输出。这时，日志记录可以帮助我们识别运行时问题。我们开始吧！

导入日志模块

创建一个 python 文件log_utility.py并编写第一行代码:

import logging

简单，嗯？日志是软件开发的基本特性之一，所以 Python 拥有这个内置模块来支持严肃的软件开发是很好的。

定义 get_logger()函数并初始化日志记录参数

在log_utility.py中，我们定义一个函数并初始化所有参数:

def get_logger(name, log_config = None):
 log_filename = 'C:\\temp\\main_%PID%.txt'.replace('%PID%', str(os.getpid()))
 log_format = "%(asctime)s from %(name)s: %(message)s"
 log_datefmt = "%d %b %Y %H:%M:%S"
 log_level = logging.INFO
 logging.basicConfig(filename = log_filename,
      format = log_format,
      datefmt = log_datefmt,
      level = log_level)
 return logging.getLogger(name)

• filename:存储日志消息的日志文件的文件名。在这种情况下，输出的一个例子是C:\temp\main_8888.txt。我们可以使用 PID(进程 ID)作为唯一的标识符，作为文件名的一部分。因此，我们需要包含模块os:

import logging, os 

• format:日志文件中记录的消息格式。输出的一个可能的例子是14 Aug 2021 00:00:00 from __main__: Hello World!，其中asctime表示日期时间，name表示传递给函数的参数name，而message表示要记录的消息。日期时间的格式由下一个参数定义。
• datefmt:日期时间的格式。这里格式字符串%d %b %Y %H:%M:%S被翻译成14 Aug 2021 00:00:00。有关更多格式化指令，请参考时间—时间访问和转换— Python 3.9.6 文档
• level:如果消息的级别高于或等于该参数，将被记录。否则，不会。在这里，水*被设置在logging.INFO。

最后，我们通过调用logging.getLogger(name)返回一个 Logger 对象

记录器的使用

既然我们已经创建了一个基本的日志功能，我们需要将这个功能合并到我们的主应用程序中。

创建一个main.py并插入如下代码:

from log_utility import get_loggerlogger = get_logger(__name__)def run():
 logger.info('Hello World from main!')if __name__ == '__main__':
 run()

运行main.py，你将得到一个日志文件C:\temp\main_%PID%.txt，其中%PID%是一个反映运行进程 PID 的数字序列。日志文件中一个可能的输出是14 Aug 2021 00:58:46 from __main__: Hello World from main!。

就是这样！我们已经成功地实现了一个基本的日志功能，可以在项目的任何地方使用。每当我想到对这个日志记录机制的任何改进，我都会用它来更新这个页面。也欢迎分享你的想法。

Python 循环:综合指南

原文：https://towardsdatascience.com/python-loops-a-comprehensive-guide-825f3c14f2cf?source=collection_archive---------13-----------------------

遍历列表、元组、字典和字符串以及循环控制—中断、继续、传递

普里西拉·杜·普里兹在 Unsplash 上的照片

什么是循环

在编程中，循环意味着以相同的顺序多次重复相同的计算。

想想现实生活中的情况。你是一名野外生物学家，正在测量森林中的树木。你选择一棵树，测量它的直径和高度，记在你的笔记本上，估计它的总体积。

接下来，你选择另一棵树，测量它的直径和高度，记在你的笔记本上，估计它的总体积。

然后，你再选一棵树，测量它的直径和高度，记在你的笔记本上，估计它的总体积。

您不断重复相同的过程，直到样本中的所有树都用完为止。在编程行话中，你在每棵树上循环，以相同的顺序执行相同的任务。

回到编程上来，如果给你一个整数值列表，要求你对每一项求*方，然后加 5，最后报告结果——这就是循环的一个例子。

我们可以循环什么？

那么我们能循环什么呢？基本上，任何可迭代的数据类型。Python 中的可迭代对象是以不同数据格式存储的值序列，例如:

• 列表(例如[10，12，13，15])
• 元组(例如(10，12，13，15)
• 字典(例如{ '姓名':'艾伦'，'年龄':25})
• 字符串(例如“数据科学”)

什么是不同种类的循环？

你主要会遇到的两种循环:for 循环和 while 循环。其中，for 循环是数据科学问题中最常见的一种。主要区别在于:

• for 循环对 iterable 对象中的每个元素迭代有限次
• 而循环继续进行，直到满足某个条件

在列表上循环

遍历列表非常简单。给你一个值列表，要求你对每一项做些什么。假设您有:

my_list = [1,2,3,4]

并且要求您计算列表中每个值的*方:

for each_value in my_list:
    print(each_value * each_value)Out:
1
4
9
16

类似地，你可以做一些更复杂的循环(例如“嵌套循环”)。例如，给你两个列表，要求你(I)将一个列表的值与另一个相乘，(ii)将它们追加到一个空列表中，以及(iii)打印出新的列表。让我们按顺序来做:

new_list = []list1 = [2, 3, 4]
list2 = [4, 5, 6]for i in list1:
    for j in list2:
        new_list.append(i*j)

print(new_list)Out:
[8, 10, 12, 12, 15, 18, 16, 20, 24]

在元组上循环

根据元组的结构和要完成的任务，在元组上循环可能有点复杂。

让我们将一些元组存储在一个列表中，每个元组代表一个班级中学生的姓名和年龄:

students = [('Allie', 22), ('Monty', 18), ('Rebecca', 19)]

现在的任务是(I)提取所有年龄,( ii)将它们存储在一个列表中,( iii)计算*均年龄:

ages = []for i,j in students:
    ages.append(j)avg = sum(ages)/len(ages)
print(avg)Out: 
19.666666666666668

这里的每个元组包含两项(姓名和年龄)。即使你对名字不感兴趣，通过 i 和 j 你也指定了这两个项目，并要求将项目 j (年龄)添加到新列表中。叫做“元组解包”。

在字典上循环

Python 中的字典是一个键-值对的集合——这意味着字典中的每一项都有一个键和一个关联值。字典的一个例子:

# fruit price dictionary
fruit_prices = {"apple": 2.50, "orange": 4.99, "banana": 0.59}

您可以循环遍历这些字典元素，并执行各种操作。这里有几个例子:

提取字典中的所有键:

for i in fruit_prices.keys():
    print(i)Out:
apple
orange
banana

将所有值存储在列表中:

values = []
for i in fruit_prices.values():
    values.append(i)
print(values)Out:
[2.5, 4.99, 0.59]

挑战:你能在字典中找到所有价格的*均值吗？

在字符串上循环

让我们考虑字符串—“Hello”。它看起来像一个可迭代的对象吗？事实上的确如此。

for i in 'Hello':
    print(i)Out:
H
e
l
l
o

你可以用 for 循环解开字符串中的每个字符，并对它们进行各种操作。

同样，也可以迭代一个句子中的每个单词。然而，在这种情况下，需要额外的步骤来拆分句子。

sent = 'the sky is blue'# splitting the sentence into words
sent_split = sent.split()# extract each word with a loop
for i in sent_split:
    print(i)Out:
the
sky
is
blue

While 循环

与 for 循环一样，while 循环重复执行一段代码——只要条件为真。只有当循环条件为假时，循环才会中断。

while 循环的一般结构如下:

i = 0while i <=5:
    print(i)
    i = i+1 # option to break out of the loop
Out:
0
1
2
3
4
5

在上面的例子中，在每次迭代中，打印出 i 的值，直到它达到 5。此后，while 循环条件变为假(即当 i = 6 时 i ≤ 5 变为假)。

while 循环的一个实际用例是在网站上使用您的登录凭证。当您没有提供正确的用户名或密码时，您无法登录*。*

user_id = 'user101'while True:
    user = input('Enter your user ID: ')

    if user == user_id:
        print("You have entered ", user) 
        break
    else:
        print("Enter a valid user ID ")

循环控制:继续、中断、通过

所谓的循环控制关键词有三种:break、continue、pass。这些语句改变了循环的流程，并允许程序在某个外部条件被触发时退出或跳过部分循环。

破裂

如果循环中存在一个break 语句，当满足一个条件时，它将终止循环。

string = 'hello, there'for i in string:
    if i == ',':
        break
    print(i)Out:
h
e
l
l
o

在上面的代码片段中，我们要求程序在找到字符串中的逗号并执行下一条语句(打印 I)后立即存在。想想开头给出的现实生活中的例子。作为一名野外生物学家，你在反复测量树木。但是你会打破这个循环——如果下雨！

继续

continue语句没有跳出循环，而是简单地跳过一次迭代，继续下一次迭代。

让我们执行上面相同的代码，但是使用 continue 关键字。

string = 'hello, there'for i in string:
    if i == ',':
        continue
    print(i)Out:
h
e
l
l
o

t
h
e
r
e

所以在这种情况下，如果循环遇到一个逗号，循环就跳过这个逗号继续。

因此，在树木测量示例中，如果您遇到一棵枯树/断树，您只需跳过它并继续下一个。

及格

不做任何事情，它只是一个还没写完的语句的占位符。

string = 'hello, there'for i in string:
    pass

如果我们没有放一个pass在那里，它将抛出一个错误消息，其余的代码将不会执行。

摘要

本文的目的是给出 Python 中的for 循环和while 循环的直观感受。给出了如何循环遍历列表、元组、字典和字符串等可迭代对象的例子。到最后，循环控制语句的概念——break、continue 和 pass——都包含了例子。

本文旨在给出循环如何工作的初步概述。在以后的文章中，我将介绍一些数据科学家在项目中经常遇到的高级循环挑战。

希望这篇文章是有用的，如果你有意见，请写在下面，或者通过媒体、 Twitter 或 LinkedIn 与我联系。

Python 循环:一些初学者友好的循环挑战

原文：https://towardsdatascience.com/python-loops-some-beginner-friendly-looping-challenge-e112fa606493?source=collection_archive---------3-----------------------

遍历列表、元组、字典和字符串

由博尼瓦尔·塞巴斯蒂安在 Unsplash 上拍摄的照片

在编程中，循环是一种逻辑结构，它重复一系列指令，直到满足某些条件。循环允许对 iterable 对象中的每一项重复相同的任务集，直到所有项都用完或达到循环条件。

循环应用于 iterables，iterables 是以特定数据格式(如字典)存储一系列值的对象。循环的美妙之处在于，你只需编写一次程序，就可以根据需要在任意多的元素上使用它。

本文的目的是实现一些应用于四种 Python 数据类型的中间循环挑战:列表、元组、字典和字符串。选择这些挑战是为了给各种可能的操作提供一个通用的循环结构。

遍历列表

列表是 Python 中的内置数据类型。它们是可变的、无序的元素序列——也称为可迭代对象。它是 Python 循环中使用的最通用的数据类型。所以我们的第一组循环挑战是基于列表的。

挑战#1: 遍历列表中的每个数字，分离出偶数和奇数。还要确定可能的异常值。

my_list = [1, 2, 3, 4, 5, 6, 7, 100, 110, 21, 33, 32, 2, 4]even = []
not_even = []
outlier = []for i in my_list:
    if i > 90:
        outlier.append(i)    
    elif i%2 == 0:
        even.append(i)
    else:
        not_even.append(i)print('Even numbers', even)
print('Odd numbers', not_even)
print('outliers', outlier)Out:
Even numbers [2, 4, 6, 32, 2, 4]
Odd numbers [1, 3, 5, 7, 21, 33]
outliers [100, 110]

**挑战 2:找出列表中所有数字的总和**

num_sum = 0for i in my_list:
    num_sum += iprint('Sum of the elements in the list', num_sum)Out:
Sum of the elements in the list 330

**挑战 3:计算列表中偶数的和**

# step 1: find the even numbers
even = []for i in my_list:
    if i%2 == 0:
        even.append(i)# step 2: add all items in even list
sum_num = 0for i in even:
    sum_num +=iprint('The sum of even numbers', sum_num)Out:
The sum of even numbers 260

**挑战 4:计算一个列表中偶数的个数**

count = 0for i in range(len(my_list)):
    if my_list[i]%2==0:
        count +=1print('The count of even numbers in the list', count)Out:
The count of even numbers in the list 8

挑战 5:计算列表中所有元素的累积和

initial_val = 0
cumsum = []for i in my_list:
    initial_val += i
    cumsum.append(initial_val)print('The cummulative sums of the list', cumsum)Out:
The cummulative sum of the list [1, 3, 6, 10, 15, 21, 28, 128, 238, 259, 292, 324, 326, 330]

挑战#6:遍历两个不同的列表，用 **zip** 函数将它们聚合

state_id = [1,2,3]
state = ['Alabama', 'Virginia', 'Maryland']for i, j in zip(state_id, state):
    print(f'{i} {j}')Out:
1  Alabama
2  Virginia
3  Maryland

遍历元组

元组类似于列表，但关键的区别是，元组是不可变的。与列表不同，没有与元组相关联的方法来添加或移除元组中的项目。由于元组是不可变的，所以它们被广泛用于不变的数据(例如，社会保险号、出生日期等。)

挑战 7:遍历混合数据类型的元组，只提取整数值

my_tup = (1, 2, 'apple', 3, 4, 'orange')for i in my_tup:
    if type(i) == int:
        print(i)Out:
1
2
3
4

挑战 8:元组解包:提取存储在列表中的元组

list_of_tutple = [(1,2), (3, 4), (5, 6)]list1 = []
list2 = []for i,j in list_of_tutple:
    list1.append(i)
    list2.append(j)

print('List of first tuple items', list1)
print('List of second tuple items', list2)Out:
List of first tuple items [1, 3, 5]
List of second tuple items [2, 4, 6]

挑战 9:应用 **enumerate()** 函数提取元组中的元素

my_tup = ('Apple', 'Orange', 'Banana')for i,j in enumerate(my_tup, start=1):
    print(i,j)Out:
1 Apple
2 Orange
3 Banana

循环浏览字典

Python 中的字典是键值对的集合，这意味着字典中的每个条目都有一个键和一个关联值。下面是一个 Python 字典的例子，其中水果是“键”，价格是“值”。[注意:接下来的循环挑战将使用该字典作为输入。]

# Python dictionary
my_dict = {"apple": 2.50, "orange": 4.99, "banana": 0.59}

挑战 10:访问字典中的所有键

for i in my_dict.keys():
    print(i)Out:
apple
orange
banana

挑战 11:访问字典中的所有值

for i in my_dict.values():
    print(i)Out:
2.5
4.99
0.59

挑战 12:从字典中同时访问键和值

for i,j in my_dict.items():
    print('Key: ', i)
    print(f'Value: {j}')Out: 
Key:  apple
Value: 2.5
Key:  orange
Value: 4.99
Key:  banana
Value: 0.59

挑战 13:找出字典中所有值的*均值

for i in my_dict.values():
    values.append(i)

average = sum(values)/len(values)print(f'Average of values: {average}')Out:
Average of values: 2.6933333333333334

挑战 14:条件循环:根据特定条件过滤字典条目

fruits = []for i in my_dict.keys():
    if i in ["apple", "orange", "pear", "watermelon"]:
        fruits.append(i)print(fruits)Out:

['apple', 'orange']

挑战 15:更新值:将所有值减少 25%(在实际应用中，这就像给所有水果打八五折)

for i, j in my_dict.items():
    my_dict.update({i: j*.75})print(my_dict)Out:
{'apple': 1.875, 'orange': 3.7425, 'banana': 0.4425}

在字符串中循环

Python 没有单独的“字符”数据类型，而是由字符串对象表示一系列字符。字符串是不可变的——一旦创建就不能更改——但是每个元素都可以通过循环访问。

挑战 16:通过字符串访问所有元素的简单迭代

my_str = 'Matplotlib'for i in my_str:
    print(i, end=' ')Out:
M a t p l o t l i b

挑战 17:切片:遍历字符串中的替换字符

my_str = 'Matplotlib'for i in my_str[0: len(my_str): 2]:
    print(i, end=' ')Out:

M t l t i

挑战 18:迭代一个句子并打印每个单词

sent = 'It is a dark night'# splitting the sentence into words
sent_split = sent.split()# extract each word with a loop
for i in sent_split:
    print(i, end = ' / ')Out:
It / is / a / dark / night /

一锤定音

本文的目的是提供一些初学者友好的中级循环挑战，这些挑战经常出现在数据科学项目中。当然，有数百种可能的组合可以应用于各种情况和各种数据类型，但是这里给出的例子是更高级循环的基础。

Python 使电子表格 Excel'lent

原文：https://towardsdatascience.com/python-makes-spreadsheets-excellent-f48ce0c648e3?source=collection_archive---------16-----------------------

使用 Python 和 VBA 实现 Microsoft Excel 工作流的自动化

由卢卡斯·布拉塞克在 Unsplash 拍摄的照片

在这个数据时代，python 已经成为全球许多开发人员最广泛采用的语言。这意味着有许多潜在的图书馆等着被利用。

虽然 python 最*成为了分析数据的首选，并在许多任务中拥有从低到高的广泛应用；Microsoft Excel 有着悠久的历史，并且在大多数情况下仍然是用于分析/管理/可视化数据的不可或缺的工具。

想象一下，如果我们可以利用 python 中的开源库来自动化我们在 Excel 中的工作流程；这会让我们的生活变得超级方便！站在巨大的开源 python 社区的肩膀上，我们可以在 Excel 中利用他们的功能，这个社区有数千个不同用例的包。

我有一个这样的需求，我想在下面讨论一下，在xlwings的帮助下，我能够通过 VBA 将我的 Excel 前端与 python 后端集成在一起，并且只需点击一个按钮，就可以自动完成一个相当繁琐的手动过程！

因此，这篇文章的主要目的是向您展示如何利用这个名为xlwings的强大 python 包通过 VBA 与 Excel 通信，并在此过程中自动完成一些任务。python 代码可能有 VBA 的变通办法，但对于我的特殊用例，我无法规避对 python 的需求，因为 VBA 无法完成一些像nsepy这样的 python 库能够完成的任务。

问题是

我保留了一张表，用来跟踪我的股票以及它们在一天结束时的表现。为此，我需要获取我投资组合中每只股票的收盘价，并每天努力手工输入。任何手动过程都容易出错，我以前就犯过这种错误，我在更新一些股票的收盘价时犯了一个错误，我的计算显示，我的风险比我想象的高得多；但当我反复核对时，情况并非如此，我意识到我在一只股票的十位数字中错误地输入了 9，而不是 6。那些在键盘上使用数字小键盘的人可能会遇到这个问题

现在，我知道了这个名为nsepy的库，它由 Swapnil Jariwala 维护，帮助从 NSE 服务器获取与 NSE 上列出的任何给定股权/期权相关的所有历史数据，但该库完全是用 python 编写的。如果我能在 Excel 中使用 python 的能力，那该多好啊！

这是完全可能的。还有另一个叫做xlwings的 python 库，它专门解决了 excel 与 python 的集成问题，瞧！问题解决了！！

为了给你一些关于这个问题的背景，这里有一张我用来保存我的股票账户的表格的一部分。

图片由 Vinayak 提供

我有脚本/股份/股票的 ISIN 编号及其名称，从同一工作簿的其他工作表中引用的*均买入价格，我过去在一天结束时手动输入的收盘价，以及基于每个脚本的我当前的头寸。

最后，您应该能够实际创建如下内容

图片由 Vinayak 提供

设置 xlwings

像任何其他包一样，您可以简单地用 python 包安装程序安装“xlwings ”,如下所示

pip install xlwings

我建议您为这个项目创建一个虚拟环境，以避免您已经存在的包安装中的依赖冲突。这篇文章不会涉及它，但是你可以看这里如果你想用 pip 安装一个虚拟环境或者看这里如果你像我一样喜欢 conda。

设置管道的一部分，即 python 管道。接下来，您应该安装 excel 与 xlwings 集成所需的部分。为此，保存并关闭您现在从安装 xlwings 的环境中打开的所有 excel 工作簿，只需运行以下命令

xlwings addin install

这应该会无缝地发生，但有时，如果你在 Windows 10 机器上使用 Excel 2016，你可能会遇到如下错误

xlwings 0.17.0[Errno 2] No such file or directory: 'C:\\Users\\nayak\\AppData\\Roaming\\Microsoft\\Excel\\XLSTART\\xlwings.xlam'

这可以通过使用简单的 mkdir 命令创建丢失的目录来解决

mkdir C:\Users\nayak\AppData\Roaming\Microsoft\Excel\XLSTART

成功安装 xlwings 后，下次打开 Excel 时，您会看到在顶部的工具栏中为“xlwings”创建了一个选项卡。该选项卡还包含解释器和 python 路径，如果您有不同的虚拟环境要执行 python 函数，则必须指定这些路径。

图片由 Vinayak 提供

因为我使用 anaconda 来维护我的环境，所以我提供了到我的 conda 的路径和我想要使用的相应环境。默认情况下，xlwings将检测一个环境(主要是您安装了这个库的环境)，但是如果没有检测到，您就必须手动给出您的 anaconda 发行版的路径和环境名称。

要找到您的 anaconda 发行版在哪里，您可以从 Windows 开始菜单打开 anaconda 提示符，在该提示符下，首先通过运行命令激活您已经安装了xlwings的环境

conda activate your_env_name

并随后运行

where python

这可能会带来几个结果，但你需要把重点放在第一个；请看下面我的环境“分享”中的第一个结果。

图片由 Vinayak 提供

这里的路径是C:\\Users\nayak\Anaconda3\env\shares\python.exe，所以在康达路径框中是C:\\Users\nayak\Anaconda3，在康达环境框中是shares。这将有助于调用 python 函数的宏理解应该在哪个环境中执行 python 代码。如果您没有使用 anaconda 发行版来管理您的环境，那么您可以使用您的 python 环境做一个等效的练习，您可以给出解释器的路径和 python 的路径，而不是在 conda 中这样做。

接下来，您需要在 Excel 界面中启用xlwings的用户自定义函数(UDF)。打开 Excel 后，使用 Alt + L + H 导航到加载项框，然后您将看到一个带有多个复选框的屏幕，询问您需要为此工作簿启用哪些加载项。点击xlwings旁边的方框，点击确定。

在这之后需要做的最后一步是授权访问所有想要使用 xlwings 等第三方插件的宏。您可以通过导航到文件>选项>信任中心设置>宏设置来完成此操作，并在宏设置中选择启用所有宏，然后在开发者宏设置中选择信任对 VBA 项目对象模型的访问。

图片由 Vinayak 提供

至此，我们已经准备好再次转向 python 方面了。

创建项目

通过从 cmd 提示符或终端或 shell 运行以下命令，您可以快速开始一个项目

xlwings quickstart project_name

这将创建一个以 project_name 作为文件夹名称的项目，默认情况下，您将在该文件夹中获得两个文件。

• project_name.py:这是一个 python 文件，应该包含您的宏可以调用来修改工作表的代码。
• project_name.xlsm:这是一个启用宏的 excel 文件，为空，包含两张表，分别是Sheet1和xlwings.config文件。您可以在此工作簿中创建其他工作表，并向其中添加任意数量的宏。回调的逻辑必须写在上面创建的 python 文件中。

我所做的是我创建了一个项目，并将我的 excel 文件的内容复制到 xlsm 文件中，并根据我的喜好重命名该表。

python 后端逻辑

现在是你自动化你的项目所需要的代码的主要部分。在这种情况下，您可以从上面的“xlsm”工作簿的任何工作表中访问任何单元格。

您可以像在任何其他 python 脚本中一样编写任意数量的自定义函数，并在这里使用它们。我已经在 main 函数中编写了代码，我将用它来更新每日收盘价。为了便于理解，我已经给出了下面的代码。你可以在这里立刻看到完整的代码。

import xlwings as xw
wb = xw.Book.caller()

因为我是从工作簿内部调用的，所以我可以使用上面的语法并获取工作簿对象。如果您想获取对其他工作簿的引用，您可以

wb = xw.book(file_path)

这里的 file_path 指的是保存 excel 文件的路径。然后，要访问任何工作表，基本上可以使用 index 或工作表的名称，要访问工作表中某个范围的值，可以在它上面链接 range 命令。

# Refer by index
DATE = wb.sheets[0].range("B1").value# Refer by name
SHARE_NAME = wb.sheets["sheet_name"].range("C1").value

一旦你得到了一个股票的 ISIN 代码和它的名字，nsepy 就可以帮助你获取在 NSE 上列出的所有股票的 bhavcopy(价格列表),你可以在任何给定的有效 NSE 日期过滤该脚本的收盘价。nsepy 是一个由 Swapnil Jariwala 维护的库，你可以在这里参考它的文档。

from nsepy.history import get_price_list# Get the pricelist/bhavcopy for a given date and only keep the relevant info
price_list = get_price_list(DATE)
price_list = price_list[["SYMBOL", "CLOSE", "ISIN"]]# An inline function to query the close price given a script name
get_close = lambda x: price_list[price_list.ISIN == x]["CLOSE"]# Read the ISIN Code of our script name
ISIN = wb.sheets[sheet_name].range(f"A1").value
ISIN = ISIN.strip()# Use the inline function above to get the close price of our share
close_price = get_close(ISIN)# Copy the share price value to Excel
wb.sheets["sheet_name"].range(f"C1").value = float(close_price)

如果你有多个脚本，你可以循环这个代码来获得所有脚本的收盘价，并根据你的意愿将它们写到 Excel 表中。

这只是实际代码的一部分，可以在我的 github repo 上找到，这里是这个项目的。

Excel 前端逻辑

现在我们已经定义了 python 逻辑，我们需要将它连接到一个宏，并将其分配给主表单中的一个按钮。为此，您需要首先插入一个按钮。你可以去开发者>插入>按钮然后把一个按钮拖到表单中。

然后你可以点击 Alt + F11 调出 VBA 界面来定义一个宏。现在，您可以在放置按钮的同一个工作表中定义一个 sub，如下所示。

Sub CallUpdate()
    mymodule = "Python_File_Name_Here"
    RunPython ("import " & mymodule & ";" & mymodule & ".main()")
End Sub

宏中的这段代码将执行以下操作:

• 查找名为“Python_File_Name_Here”的文件
• 导入该文件中的模块
• 调用指定 python 文件中的 main 函数。

这段代码可以用许多不同的方式进行调整；如果你除了 main 之外还有另一个函数，你想调用它，你可以写

RunPython (“import “ & mymodule & “;” & mymodule & “.other_function_name()”)

这仍然可以正常工作。您可以在 VBA 中进行一些检查，在 python 中进行一些检查，并在需要时让两个接口自由通信，这不是很好吗？

最后，对于您已经创建的按钮，您可以通过右键单击该按钮并转到分配宏选项来分配该宏，并最终选择该宏CallUpdate并单击确定。

现在，每当您单击按钮(我将其命名为 Update Close)，计算将在 conda 环境shares中运行，输出将在 excel 表的 c 列中更新。这样，我就不必在网上手动查找每只股票的收盘价，然后将其填入 Excel 中，只需单击一个按钮即可完成！！

你也可以在 python 中定义函数，这些函数可以像 Excel 中的公式一样被调用，还可以做更多的事情，但我会在以后的文章中介绍这些内容…

结论

希望这篇文章能帮助你理解如何借助 python 为你的 excel 工作流插上翅膀:)

参考

• Github 代码回购帖子中的所有代码
• xlwings 官方文档

Python 映射、过滤和简化

原文：https://towardsdatascience.com/python-map-filter-and-reduce-9a888545e9fc?source=collection_archive---------12-----------------------

使用 Map、Filter、Reduce 和 lambda 函数编写优雅而高效的代码

雅各布·安德烈森在 Unsplash 上拍摄的照片

在 Python 中，可以使用def来定义函数。另一种编写小功能的方法是使用 lambda。Lambda 函数是内联匿名函数。它只包含一个没有显式 return 语句的表达式。让我们看一些例子。

from time import time_nsdef cubed(x):
        return x**3lambda_cubed = lambda x:x**3start = time_ns()print(f"Cube of 9 is {cubed(9)}")print(f"Time taken for previous method : {(time_ns()-start)//1_000} ms")start = time_ns()print(f"Cube of 9 is {lambda_cubed(9)}")print(f"Time taken for previous lambda : {(time_ns()-start)//1_000} ms")start = time_ns()
print(f"Cube of 9 is {(lambda x:x**3)(9)}")
print(f"Time taken for inline lambda : {(time_ns()-start)//1_000} ms")

在前面的片段中，我们将比较一个函数和一个 lambda 函数计算 9 的立方所需的时间。我们可以给一个 lambda 函数命名。我们可以在片段中看到它们。如果我们运行它，我们会得到这样的结果。

Cube of 9 is 729
Time taken for previous method : 18 ms
Cube of 9 is 729
Time taken for previous lambda : 3 ms
Cube of 9 is 729
Time taken for inline lambda : 2 ms

每次执行代码片段时，这些数字可能会稍有不同。但是很明显，lambda 函数比它们的替代方法要快得多。

我们现在将看到如何使用 lambda 函数来进一步优化我们的代码。要了解关于 Python lambda 函数的更多信息，可以访问这个链接。

地图

我们可以使用 Python map 函数从另一个列表生成一个新列表。我们将比较循环，并映射生成一个包含 1–10 个方块的列表。

start = time_ns()
squares=[]
for i in range(1,11):
        squares.append(i**2)
print(squares)print(f"Time taken for a for loop to generate squares: {(time_ns()-start)//1_000} ms")start = time_ns()squares=list(map(lambda i:i**2,list(range(1,11))))print(squares)
print(f"Time taken for map and lambda function to generate squares : {(time_ns()-start)//1_000} ms")

上面代码片段的输出是…

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
Time taken for a for loop to generate squares: 12 ms
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
Time taken for map and lambda function to generate squares : 9 ms

过滤器

类似地，我们可以结合使用 filter 方法和 lambda 函数来从列表中过滤出条目。在下一个例子中，我们将使用循环和过滤方法创建一个从 1 到 10 的偶数列表。

start = time_ns()
evens=[]
for i in range(1,11):
        if i%2==0:
                evens.append(i)
print(evens)
print(f"Time taken for a for loop : {(time_ns()-start)//1_000} ms")start = time_ns()squares=filter(lambda i:i%2==0,list(range(1,11)))print(evens)
print(f"Time taken for filter : {(time_ns()-start)//1_000} ms")

如果我们比较每种方法的时间，我们会看到…

[2, 4, 6, 8, 10]
Time taken for a for loop : 6 ms
[2, 4, 6, 8, 10]
Time taken for filter : 4 ms

减少

Reduce 函数的工作方式类似于聚合函数。前面的方法map和filter是 python 内置的，但是我们需要导入functools来使用 reduce 函数。

from functools import reduceprint(reduce(lambda x,y:x+y, list(range(1,11))))

输出将是55。reduce 的工作方式是首先获取列表的前两个元素，并存储在x、y中。对 x 执行 lambda 函数后，y(本例中为 sum) reduce 函数将新值存储在 x 中。然后将下一个元素分配给 y，并将相同的函数应用于 x，y &结果存储在 x 中，依此类推。

没有必要将 lambda 函数与 map、filter 和 reduce 函数一起使用。这里有一个将一列数字作为输入的例子。

a=list(map(int, input().split()))
print(a)

如您所见，它们与预定义的 Python 函数配合得很好。

一旦您熟悉了这些功能，很容易发现这些功能会导致更短和优化的代码。虽然有时使用 for 循环可以使代码更具可读性。

但是这些功能的知识并没有被浪费。下次你准备在 Pandas 中预处理一个数据集时，了解 lambda 函数的概念将会使你受益。

希望你喜欢。敬请关注更多内容。

Python、内存和对象

原文：https://towardsdatascience.com/python-memory-and-objects-e7bec4a2845?source=collection_archive---------4-----------------------

数据科学

面向数据科学家的 Python 内存管理基础

照片由查尔斯·德鲁维奥在 Unsplash 拍摄

作为数据科学家，通常情况下，我们不会关注 Python 和底层操作系统如何为我们的代码处理内存。毕竟，Python 是数据科学家中最受欢迎的语言，部分原因是它自动处理这些细节。只要我们在小数据集上工作，忽略 Python 如何管理内存(即内存分配和释放)不会影响我们的代码性能。但是，一旦我们转向大型数据集(大数据)或繁重的处理项目，关于内存管理的基础知识就变得至关重要。

举个例子，我正在做一个关于索引人类 DNA 的数据科学项目。我使用 python dictionary 对象来跟踪序列(即核苷酸序列)，并将它们的位置存储在参考人类 DNA 中。这个过程进行到大约 10%时，dictionary 对象占用了我所有的 RAM，并开始在磁盘和 RAM 之间交换。这使得该过程非常慢(因为磁盘在数据传输中要慢得多)。作为一名数据科学家，如果我了解 Python 和内存管理的基础知识，我就可以防止这种情况，并编写更多内存高效的代码。

在本文和下一篇文章中，我将解释 Python 中内存管理的一些基本概念。在本文结束时，您已经掌握了 Python 如何处理内存分配和释放的基本知识。让我们开始吧…

基础

python 程序是以下内容的集合

1. 方法
2. 参考
3. 目标

方法或操作都很容易。当您将两个数字相加时，基本上是将加法(或求和)方法应用于两个值。参考文献有点难以解释。引用是我们用来访问数据值(即对象)的名称。编程中最著名的引用是变量。定义x = 1时，x是变量或引用，1是其值(更准确地说是整数对象)。除了变量，属性和项是编程中另外两个流行的引用。

现在，让我们更深入地介绍对象。作为一名 Python 程序员，你一定听说过“Python 中的一切都是对象。”整数是一个对象。字符串是一个对象。列表、字典、元组、熊猫数据框、NumPy 数组都是对象。甚至函数也是一个对象。当我们创建一个对象时，它将被存储在内存中。当我们在前一段中定义引用时，我应该已经告诉过你，在 Python 中引用不是指向一个值，而是指向一个对象的内存地址。例如，在我们的简单示例x = 1中，引用 x 指向存储整数对象1的内存地址。

堆栈内存与堆内存

在运行时，计算机内存被分成不同的部分。三个重要的内存部分是:

1. 密码
2. 堆
3. 许多

存储器的代码(也称为文本或指令)部分以机器能够理解的形式存储代码指令。机器遵循代码部分的说明。根据指令，Python 解释器将函数和局部变量加载到堆栈存储器(也称为堆栈)中。堆栈内存是静态的和临时的。静态意味着存储在堆栈中的值的大小不能改变。临时意味着，一旦被调用的函数返回它的值，该函数和相关变量将从堆栈中删除。作为一名数据科学家和程序员，你没有访问堆栈内存的权限。Python 解释器和操作系统内存管理一起负责这部分内存。

正如您所了解的，变量(或一般的引用)只存储对象的内存地址。那么，物品在哪里？它们在堆栈内存中吗？不，它们在一个叫做“堆内存”(也叫堆)的不同内存中。为了存储对象，我们需要具有动态内存分配的内存(即，内存和对象的大小可以改变)。Python 解释器主动分配和释放堆上的内存(C/C++程序员应该手动做的事情！！！谢谢 Python！！！).Python 使用垃圾收集算法(称为垃圾收集器)来保持堆内存干净，并删除不再需要的对象。

您不需要弄乱堆，但是最好理解 Python 是如何管理堆的，因为您的大部分数据都存储在内存的这一部分。

让我们在堆上找到变量x指向的内存地址。为了找出答案，我们可以使用一个名为id()的函数。

>>> x = 1
>>> id(x)
140710407579424
>>> hex(id(x))
'0x7ff9b1dc2720'

当我们运行第一行(x = 1)时，Python 将整数对象1存储在我的电脑(与你的电脑不同)的内存地址140710407579424中。在计算机科学中，我们通常用十六进制数表示内存地址；因此，我使用了hex()函数(注:前缀0x用于计算机科学中，表示数字为十六进制)。在堆内存中存储 int 对象1后，Python 告诉引用(或变量)x记住这个地址(140710407579424或0x7ff9b1dc2720)作为它的值。

内存优化

看一下这个例子。

>>> x = 1
>>> y = 1
>>> hex(id(x))
'0x7ffdf176a190'
>>> hex(id(y))
'0x7ffdf176a190'

在这里，我定义了两个变量(x和y)。我给他们俩分配了一个整数对象(即1)。令人惊讶的是，这两个变量指向的内存地址是相同的。再看一个例子。

>>> str1 = "Python"
>>> str2 = "Python"
>>> hex(id(str1))
'0x1e3adfe2830'
>>> hex(id(str2))
'0x1e3adfe2830'

我定义了两个变量(str1和str2)，并给它们分配了一个字符串对象(Python)。两个变量指向的内存地址是相同的。如果您对布尔对象进行同样的测试，您将会看到类似的观察结果。为什么？

优化内存分配。Python 做了一个叫做“实习”的过程对于一些对象(将在后面讨论)，Python 只在堆内存中存储一个对象，并要求不同的变量在使用这些对象时指向这个内存地址。Python 在其上实习的对象是整数[-5，256]、布尔和一些字符串。实习不适用于其他类型的对象，如大整数、大部分字符串、浮点数、列表、字典、元组。

更高级的数据结构

到目前为止，我们已经展示了简单数据结构的例子，如整数、字符串或布尔值。更复杂的数据结构呢，比如列表或字典。

>>> lst = [1, 2, 3, 257]
>>> hex(id(lst))
'0x236330edf88'
>>> hex(id(lst[0]))
'0x7ffdf176a190'
>>> hex(id(lst[3]))
'0x7ffdf176a1b0'

这个例子清楚地显示了 list 对象的内存地址不同于它的条目。这是有意义的，因为列表是对象的集合，它的每一项都有自己的标识，是一个单独的对象，有不同的内存地址。

如果列表中的每一项都是一个单独的对象，那么实习(上一节)适用于列表中的每一项吗？很容易检查。

>>> a = 1
>>> b = 257
>>> hex(id(a))
‘0x7ffdf176a190’
>>> hex(id(b))
‘0x236330dc450’

如你所见，a和lst[0]都由于整型强制而指向同一个内存地址。另外，你可以看到，当整数超过 256 时，b和lst[1]都指向不同的内存地址。

当我们向列表中添加一个新项目时会发生什么。内存地址有变化吗？我们来测试一下。

>>> lst = [1, 2, 3]
>>> hex(id(lst))
'0x23633104888'
>>> lst.append(4)
>>> lst
[1, 2, 3, 4]
>>> hex(id(lst))
'0x23633104888'

有趣的是，列表的内存地址保持不变。原因是列表是一个可变的对象，如果你给它添加了条目，这个对象仍然是多了一个条目的同一个对象。

关于可变对象的另一个重要事实是，如果你从一个对象实例化不同的变量，如果你对对象做任何改变，所有的变量都会改变。让我用一个简单的代码来展示一下。

>>> lst1 = [1, 2, 3]
>>> lst2 = lst1
>>> lst1.append(4)
>>> lst2
[1, 2, 3, 4]
>>> lst2.append(5)
>>> lst1
[1, 2, 3, 4, 5]

在这个例子中，变量lst1和lst2都指向同一个可变对象(即[1, 2, 3])。如果这些变量中的任何一个改变了对象(例如，附加一个新项目)，另一个变量(它指向同一对象)的值也将改变。获得可变对象的单独副本的唯一方法是使用.copy()方法。

>>> lst1 = [1, 2, 3]
>>> lst2 = lst1.copy()
>>> lst1.append(4)
>>> lst2
[1, 2, 3]
>>> hex(id(lst1))
'0x236330dfe08'
>>> hex(id(lst2))
'0x236330e0c88'

如你所见，使用.copy()方法，我们创建了两个不同内存地址的列表对象，改变其中一个不会改变另一个。

我们所说的关于列表对象的几乎所有内容也适用于字典对象。有些细微的差别超出了本文的范围。例如，在添加新项目后，他们的内存大小增长的方式会有所不同。

要检查两个或多个变量是否指向同一个对象，不需要检查它们的内存地址。您可以使用is检查两个变量是否指向同一个对象。这里有一个例子。

>>> lst1 = [1, 2, 3]
>>> lst2 = lst1
>>> lst3 = lst1.copy()
>>> lst2 is lst1
True
>>> lst3 is lst1
False

记住，is和==不一样。is告诉你两个对象是否相同，而==告诉你它们的内容或值是否相同。例如，在前面的代码中，lst3和lst1的内容是相同的(即[1, 2, 3]，但它们是两个独立的不同对象。下面的代码清楚地展示了这一点。

>>> lst3 == lst1
True
>>> lst3 is lst1
False

摘要

本文向您介绍了 Python(更准确地说是 CPython 实现)如何为对象分配内存的基本知识。在 Python 中处理大数据时，您需要了解这些基本概念，以便编写更节省内存的代码。

在推特上关注我的最新报道:https://twitter.com/TamimiNas

Python 蒙特卡罗模拟:系综被解放

原文：https://towardsdatascience.com/python-monte-carlo-simulations-copulas-unchained-ff29d051c0a0?source=collection_archive---------6-----------------------

SciPy 中带高斯 Copulas 的相关随机变量

从上周开始，我们已经学习了四个教程，一步一步地解释了蒙特卡罗方法。今天，我们将前往蒙特卡洛的下一站。

最新的文章介绍了相关随机变量。我们使用了 MCerp 库，它应用了 Iman-Conover 方法来生成相关性(在 Python 中使用相关随机变量的蒙特卡罗模拟|走向数据科学)。

文章强调，在任何模拟模型中，反映相关结构对于准确的结果至关重要。输入变量可以显示出一前一后移动的趋势。如果不考虑*行运动，模拟模型会对不切实际的结果赋予同等的权重。我们经历了一个例子，其中当忽略相关结构时，模拟输出的标准偏差是两倍。

昨天的文章介绍了在 MCerp 中实现的 Iman-Conover 方法。今天，我们将学习另一种方法，它不需要安装额外的库，只需要 SciPy 和大约十几行代码——高斯连接函数。

几乎所有你能找到的关于高斯连接函数的资料都是用一种“编程”语言编写的，而我们很少有人能完全精通这种语言:数学。对于把数学作为第二或第三语言而非母语的人来说，维基百科的解释不容易理解。

Copula(概率论)—维基百科；右上角的情节:维基百科上的马泰奥·赞迪， CC BY-SA 3.0

几年前，我遇到了它，想知道高斯系词可能有什么用处——在脑海中把“系词”这个词用一个大大的虚拟问号夹起来。我又把它挖了出来，并着手把“数学”翻译成 Python。除了随机波动之外，Python 脚本的结果与 Iman-Conover 方法的结果相匹配。正如我们将在下面看到的，强加的相关结构等于目标。

让我们来演示一下高斯连接函数在我们的工具箱中会起到什么样的作用。

今天的示例模型将与您在昨天的文章中找到的模型相同(Python 中相关随机变量的蒙特卡罗模拟|走向数据科学)。但是我们将应用 SciPy 和 Gaussian copula 方法，而不是 MCerp 库和它的 Iman-Conover 实现。copula 方法比 Iman-Conover 方法需要更少的代码行。

1.属国

我们导入 Seaborn 的图表库，因为它的 jointplot 为我们提供了在宏伟的布局中可视化相关结构的方法。

从 SciPy 中，我们导入了一些分发对象。

• 多元正态分布对于创建高斯连接函数是不可避免的。
• 我们将使用 SciPy 的 rv_continuous 和 beta 分布来定义 PERT 分布。PERT 和正态分布将作为所谓的边际分布。我们将在三个输入变量中将它们联系在一起，copula 将在它们之间建立一个相关结构。

2.分 4 步准备高斯连接函数

copula 在 Python 中实现并不困难，这与带有大量数学符号的源代码中出现的情况相反。生成相关随机变量需要四个步骤。

开始时——第 0 步**——我们应该有一个目标矩阵，其中包含我们希望应用于每对输入变量的相关系数。理想情况下，目标相关性可以从历史观察中确定。如果不是，那么计划者应该考虑系数的三点估计。**

在步骤#1 中，我们实例化了 SciPy 的多元正态分布。

• 我们用一个零向量来设置它，这将作为它的每个列向量的*均值。
• 第二个参数是目标相关矩阵。

在实例化多正态分布之后，我们为它的三个向量绘制 N = 10，000 个随机变量，这些变量将展示目标相关结构。

在步骤#2 中，我们将这些随机变量输入到单变量标准正态分布的累积分布函数中。通过这样做，我们获得了列向量——三个输入变量中的每一个都有一个——它保留了多正态分数的相关结构，但被转换为统一分数:它们将位于区间[0；1].

在步骤#3 中，我们定义了三个边际分布，此时它们之间仍然没有相关结构。

• PERT 分布将模拟销售量的不确定性；
• 反映销售价格的正态分布；
• 材料单位成本的第二个正态分布。

在步骤#4 中，我们将在这三个输入分布上强加相关结构。

然而，在我们进行最后一步#4 之前，我们想要检查如果我们在没有应用 copula 的情况下绘制随机变量*，它们将具有哪种相关结构。以下两个笔记本单元格不属于创建高斯连接函数的 4 步序列。*

初始相关矩阵显示接*零的系数。我们从 PERT 和两个正态分布中抽取的 10，000 个随机变量的原始向量是独立的，带有一些导致小系数的随机噪声。

当我们想要绘制每个变量对的相关性图表时，我们可以从 seaborn 调用 jointplots 绘制几乎圆形的斑点——上面是销售价格和材料单位成本的例子，它们应该表现出很强的正相关性。如果他们真的展示出来，我们会看到一个从左下角延伸到右上角的椭圆形状:高价格将与高材料单位成本相关联。这里，低价格与低和高的材料单位成本相关联，这就形成了一个没有方向的形状。

在确认原始输入变量缺乏相关性后，我们进入最后一步，**步骤#4，**并实施目标结构:

• 在步骤#2 中，我们已经生成了从多元正态分布继承了目标相关结构的正态分数。
• 在步骤#4 中，我们将这 3x 万个正态分数(数组 rand_U )插入到三个输入分布的百分点函数 ppf() 中。每个 ppf()将返回 N = 10，000 个随机变量。具有随机变量的三个数组将展示目标相关结构，它们通过分数(rand_U)从多元正态分布中继承了目标相关结构。这种继承是“高斯连接函数”术语背后的原因。

这就完成了 4 步过程。

让我们想象一下两两相关。我们将为三个输入参数中的每一对调用一个助手函数， plotcorr() :

Seaborn 的关节图不再呈现圆形或无定形。相反，它们显示出反映它们正相关或负相关的省略号。

• 销量与售价:负相关——省略号从左上角延伸到右下角。高价格往往伴随着低交易量。

• 数量与材料单位成本:弱正相关——较高的数量将导致供应商给予企业一些数量折扣。

• 销售价格与材料单位成本:强正相关-企业将试图通过更高的销售价格来抵消供应商价格的上涨。省略号很紧凑，反映了 0.7 的强相关性，并且从左下到右上是目标:高材料单位成本伴随着高销售价格。

当我们计算三个耦合输入变量的相关矩阵时，我们发现它与目标相关矩阵的偏差很小≤ 0.026，本质上是随机波动。

现在，输入数据的准备工作已经完成。相关随机变量的数组——数量、价格和材料单位成本——可以传递给模拟模型。

3.准备和运行模拟模型

接下来的步骤与我们在之前的文章中讨论的 MC 模拟过程相同。

我们通过定义尽可能多的想要研究的输出变量来建立模型。每个输出变量只是一个或多个输入变量的和、积或商。任何我们串在一起包含一个或多个输入变量的函数都可以作为输出变量。

我们将毛利 GP 定义为我们要跟踪的主要输出变量，此外还有一些次要输出变量，如收入 r。输出变量是数组(列向量)，其元素是通过将相应的输入元素组合在一个函数中来计算的。

此时，因为输入向量 v、p 和 m 已经在前面的代码行中填充了它们的相关量，所以输出向量已经可用。当代码到达第 13 行时，模拟已经完成。我们可以开始绘制输出。

一个辅助函数将绘制列向量的直方图。

我们对六个输出和输入数组调用了六次绘图函数，从总利润开始。

下面的输出类似于我们在过去几天的蒙特卡罗文章中讨论的内容。

校准相关结构集中了仿真模型将在其 10，000 次迭代中生成的输出。初始模型还必须评估参数元组，这些参数元组难以置信地将极高的价格与极低的材料单位成本(反之亦然)以及巨大的销售量结合在一起

在非常高和非常低的销售价格下，许多这些不切实际的场景通过强加一个相关结构而被归入离群值的状态。在 10，000 次试验中，异常情况出现的次数较少，因此结果更紧密地围绕€ 48，589 的*均结果。

4.结论

当我们应用 MCerp 的 Iman-Conover 方法时，我们得到了与昨天文章中几乎相同的结果。

高斯连接函数作为一种继承机制。多元正态分布将目标相关结构传递给正态分数数组。我们使用分数作为输入，为不同类型的单变量分布生成几个随机变量向量，即所谓的边际，，它将作为模拟模型*的输入参数。*这些单变量随机变量将保持遗传相关性。

通过将输入值的不可信组合推到背景中，相关结构有助于将模拟输出的标准偏差减半。

• Jupyter 笔记本可以在 GitHub 上下载: h3ik0th/MC_copulas:用高斯 copulas 和 SciPy(github.com)进行 Python 蒙特卡罗模拟
• 图片: Copula(概率论)—维基百科截图|右上角情节:维基百科上的马泰奥·赞迪， CC BY-SA 3.0
• 所有其他图片:作者
• https://medium.com/subscribe/@h3ik0.th

Python 命名元组:什么、如何以及何时使用

原文：https://towardsdatascience.com/python-named-tuple-what-how-and-when-to-use-4718b0668afd?source=collection_archive---------3-----------------------

图片来自 Pixabay 的 eloiroudaire77

Python 命名 Tuple 的配方以及我们为什么要使用它

Python 中有一种“特殊”类型的元组，叫做“命名元组”。对于 Python 学习者来说，对它感到困惑是很常见的，尤其是我们应该何时以及为什么使用它。

命名元组就是元组，所以它做元组能做的一切。然而，它超出了普通的 Python 元组。它更像是 C++等其他编程语言中的“struct”。它是一个元组的特定子类，是根据您的规范以编程方式创建的，具有命名字段和固定长度。

在本文中，我将介绍名为 tuples 的 Python，并尝试演示如何使用它、何时使用它以及为什么我们应该使用它。

1.创建命名元组

图片来自 Pixabay 的 Dirk Hoenes

在我们开始之前，这里有一个小提示。从 Python 3.1 开始，有一个重要的名为 tuple 的内置常量来表示我们现在使用的 Python 版本。我们可以如下得到。

import sys
sys.version_info

如果我们想在我们的程序中使用它，我们需要从集合模块中导入它。

from collections import namedtuple

集合模块中的namedtuple是一个类工厂。换句话说，它制造类。我们需要提供下面的东西来产生我们想要的类。

• 我们要使用的类名
• 我们要分配的字段名序列，按照元组中元素的顺序。
• 我们需要在代码中将该类赋给一个变量名，这样我们就可以用它来构造实例。

例如，如果我们想要定义一个具有纬度和经度两个属性的Coords类，我们可以如下实现它。

Coords = namedtuple('Coords', ['latitude', 'longitude'])

然后，我们可以使用Coords类实例化一个对象，这将是一个命名元组。

home = Coords(latitude=-37.8871270826, longitude=144.7558373041)

我们可以验证它是一个元组，尽管它有字段名。

isinstance(home, tuple)

此外，为了从类中实例化一个命名元组，我们不必每次都指定字段名，因为命名元组的顺序和长度是固定的。

home = Coords(-37.8871270826, 144.7558373041)

1.1 定义命名元组类的简单方法

我们可以很容易地使用字符串来指定字段，而不是使用列表。例如，我们可以使用 common 来分隔字段名称。

Coords = namedtuple('Coords', 'latitude, longitude')

我们甚至可以使用空格作为分隔符，这完全没问题。

Triangle = namedtuple('Triangle', 'first_side second_side third_side')
t1 = Triangle(5, 5, 5)

1.2 使用类型提示从超类创建

从 Python 3.6 开始，我们还可以更正式地定义一个命名元组类。这也将支持命名字段的类型提示。

from typing import NamedTuple  # 3.6+class Coords(NamedTuple):
    """A coordinate consists latitude and longitude"""
    latitude: float
    longitude: floathome = Coords(-37.8871270826, 144.7558373041)

不同之处在于，我们需要使用类型模块中的NamedTuple超类。

2.字段名称自动重命名

图片来自 Pixabay

当我们定义一个命名的元组类时，虽然我们可能使用字符串作为字段名，但它们将被反映为类属性。因此，这些字段名称会有一些限制。

首先，我们不能使用以下划线开头的字段名。

MyNamedTuple = namedtuple('MyNamedTuple', ['_attr1', 'attr2'])

一些保留的关键词也被禁止，比如def。

MyNamedTuple = namedtuple('MyNamedTuple', ['def', 'attr2'])

此外，字段名称不能重复，因为一个类不能有两个同名的属性。

MyNamedTuple = namedtuple('MyNamedTuple', ['attr1', 'attr1'])

然而，从 Python 3.1 开始，我们可以将标志rename设置为 True，这样任何无效的字段名都会被自动重命名，而不会抛出错误。

MyNamedTuple = namedtuple(
    'MyNamedTuple', 
    ['_attr1', 'def', 'attr2', 'attr2'], 
    rename=True
)

上面代码中的命名元组定义违反了这三条规则，但是因为我们将 rename 标志设置为 true，所以它不会出错。

有一个小技巧来检查一个命名元组类的字段名，这个类使用它的私有属性_fields。

MyNamedTuple._fields

3.使用命名元组

图片由 Gerd Altmann 来自 Pixabay

为了演示如何使用一个命名元组，让我们重复我们在上面几节中使用的例子。我们可以定义Coords类并实例化一个命名元组home。

Coords = namedtuple('Coords', 'latitude, longitude')
home = Coords(-37.8871270826, 144.7558373041)

3.1 访问值

然后，我们可以访问命名元组中的值。非常直观地，我们可以使用字段名来访问它们对应的值。这是使用命名元组的主要好处之一。它还提高了代码的可读性。

print(home.latitude)
print(home.longitude)

另外，不要忘记命名元组就是元组。因此，我们也可以使用索引来获取值。

print(home[0])
print(home[1])

3.2 将命名元组转换成字典

就其表现形式而言，命名元组非常类似于字典。字段名可以看作是字典的键，它们都有相应的值。

事实上，一个命名的元组有一个内置的私有方法来将其自身转换为有序字典。

home._asdict()

这是有道理的。命名元组和字典之间最重要的区别可能是命名元组中字段的顺序很重要。这意味着命名元组和有序字典可以互换。

然而，如果我们不关心键的顺序，而只想要一本字典，那该怎么办呢？我们可以简单地向有序字典添加一个类型转换，如下所示。

dict(home._asdict())

3.3 替换字段的值

由于命名元组是元组，并且元组是不可变的，所以不可能改变字段的值。

home.latitude = 10

在这种情况下，我们必须使用另一个私有方法_replace()来替换字段的值。

home1 = home._replace(latitude=10)

_replace()方法将返回一个新的命名元组。这很重要，因为即使使用这种方法，我们仍然不能修改命名元组。

如果我们检查原始的命名元组，它没有改变。

3.4 具有默认值的命名元组

就像在一个普通的类中我们可以为属性设置默认值一样，一个命名的元组类也可以设置默认值。然而，由于具有默认值的字段必须在任何没有默认值的字段之后，默认值应用于最右边的参数。

例如，让我们再次定义只有一个默认值的Coords类。

Coords = namedtuple('Coords', 'latitude, longitude', defaults=[100])
home = Coords(-37.8871270826)

如果我们实例化只有一个值的命名元组，默认值100将用于经度，这是我们定义中最右边的一个。

如果我们显式地将字段设置为经度，那么默认值将用于纬度吗？

home = Coords(longitude=-37.8871270826)

答案当然是否定的。在一个命名元组中，字段的顺序是非常严格的。为了避免混淆和潜在的问题，默认值必须在最右边，即使我们明确地指定了一些东西。

如果我们给所有字段赋予默认值，这意味着所提供的默认值的数量与字段的数量相同，那么当我们实例化一个命名元组时，我们将不必传入任何值。

Coords = namedtuple('Coords', 'latitude, longitude', defaults=[-50, 100])
home = Coords()

检查命名元组类的默认值的一个技巧是使用它的私有属性_field_defaults。

Coords._field_defaults

3.5 将元组转换为命名元组

如果我们已经准备好了一个普通元组和一个命名元组类，我们可以使用私有方法_make()轻松地将元组转换为命名元组。请注意，元组的长度必须与命名元组的长度相同。

t1 = (-37.8871270826, 144.7558373041)
home = Coords._make(t1)

4.为什么以及何时使用命名元组？

图片由 Gerd Altmann 从 Pixabay 拍摄

我们已经介绍了 Python 中关于命名元组的几乎所有内容。Python 为什么会有它，我们应该什么时候使用它？

答案如下:

• 与普通元组相比，使用命名元组可以改进我们的代码，以表达元组元素的语义。
• 与 Python 类相比，使用命名元组可以提高代码可读性，并显著减少代码行数。

第一点很容易理解。对于第二个，让我们考虑下面的例子。假设我们需要定义一个Student类。它不一定有任何方法。换句话说，它只是保存一个学生对象的数据。

class Student:
    def __init__(self, student_no, first_name, last_name, birth_year, gender):
        self.student_no = student_no
        self.first_name = first_name
        self.last_name = last_name
        self.birth_year = birth_year
        self.gender = gender

如果我们使用一个命名元组，定义就像下面这样简单。

Student = namedtuple('Student', 'student_no, first_name, last_name, birth_year, gender')

因此，对于这种情况，使用命名元组比使用类要简单和整洁得多。然而，如果我们需要任何类方法，命名元组将不再适用。

使用命名元组的另一个好处是它的可迭代性。也就是说，命名元组是可迭代的，因此它可以用于许多场景，如循环和生成器。

让我们使用Student类来实例化一个命名元组

s1 = Student(123, 'Chris', 'Tao', 1900, 'Male')

然后，我们可以循环它的值。

for attr in s1:
    print(attr)

摘要

图片来自 Pixabay

在本文中，我介绍了 Python 中的命名元组，它是什么，如何创建命名元组类，以及如何将该类实例化为命名元组。然后，我举例说明了什么时候我们应该使用命名元组，什么时候不应该。希望你喜欢阅读！

https://medium.com/@qiuyujx/membership

如果你觉得我的文章有帮助，请考虑加入 Medium 会员来支持我和成千上万的其他作者！(点击上面的链接)

Python 现在支持 Switch 语句——下面是入门方法

原文：https://towardsdatascience.com/python-now-supports-switch-statements-heres-how-to-get-started-fe7da830236a?source=collection_archive---------3-----------------------

了解如何在 Python 3.10 中使用结构化模式匹配实现 Switch 语句

照片由罗伯特·威德曼在 Unsplash 上拍摄

Python 3.10 仍处于 alpha 阶段，但会带来一些令人兴奋的新特性。我们今天将看看其中的一个——switch 语句——正式名称为结构模式匹配。

Switch 语句在大多数编程语言中都很常见，它提供了一种更简洁的实现条件逻辑的方式。当有很多条件需要评估时，它们就派上用场了。

今天，我们将看看如何使用它们，并比较与更传统的方法的代码差异。

这篇文章的结构如下:

• 实现条件运算的旧方法
• python 3.10 Way-Switch 语句
• 最后的想法

实现条件运算的旧方法

我们会掩护两个。第一个是标准的 if-elif-else 语句，另一个将使用字典键值映射来完全避免 if 语句。

首先，我们需要一些代码。我们将声明一个名为get_mood(day: str) -> str的函数，它返回一个值取决于输入参数的字符串。随着周末的临*，返回值变得更加令人兴奋。愚蠢的小功能，但将做演示的目的。

让我们用经典的if方法来实现它。代码如下:

没有什么新的或开创性的。代码很容易理解，但是太冗长，尤其是当多个值可以满足一个条件时。

我们可以通过完全避免 if 语句并以键值映射的形式编写函数来“改进”或混合一些东西。这还包括一个用于设置默认返回值的try except块。

下面是代码片段:

如您所见，结果是相同的，但是我们没有使用条件运算符。这两种方法都可以很好地工作，但是 Python 一直缺少的是一个专用的switch语句。

3.10 版本解决了这个问题。

python 3.10 Way-Switch 语句

根据官方文件:

增加了结构模式匹配，形式为带有关联动作的模式的匹配语句和 case 语句。模式由序列、映射、原始数据类型以及类实例组成。模式匹配使程序能够从复杂的数据类型中提取信息，对数据结构进行分支，并基于不同形式的数据应用特定的操作。

我们今天将坚持基础知识，并在其他时间探索结构模式匹配必须提供的一切。

让我们回到我们的get_mood()函数，用类似于switch语句的语法重写它。与许多其他编程语言不同，Python 使用了match关键字，而不是switch。case关键字是相同的。

下面是代码片段:

概括一下:

• 使用case关键字评估条件(case ‘Monday’与if day == ‘Monday’相同)
• 使用管道运算符|分隔多个条件，例如，如果两个输入值应该产生相同的返回值
• 使用下划线运算符— _ —指定默认大小写。

这就是你的结构模式匹配——至少是最基本的。这只是 Python 3.10 即将推出的令人兴奋的新特性之一。

最后的想法

Python 3.10 将带来许多令人兴奋的特性，但它仍处于 alpha 阶段。因为它还不能用于生产，所以将其作为默认 Python 版本安装可能不是一个好主意。

今天我们已经介绍了可能是最激动人心的新特性，但是其他的也将在接下来的文章中介绍。请继续关注博客，了解更多信息。

喜欢这篇文章吗？成为 中等会员 继续无限制学习。如果你使用下面的链接，我会收到你的一部分会员费，不需要你额外付费。

https://medium.com/@radecicdario/membership

了解更多信息

• 我作为数据科学家卖掉我的 M1 Macbook Pro 的三大理由
• 如何用 Cron 调度 Python 脚本——你需要的唯一指南
• Dask 延迟—如何轻松并行化您的 Python 代码
• 如何用 Python 创建 PDF 报告——基本指南
• 2021 年即使没有大学文凭也能成为数据科学家

保持联系

• 在 Medium 上关注我，了解更多类似的故事
• 注册我的简讯
• 在 LinkedIn 上连接

Python 还是 R？数据科学家和数据分析师哪个好？

原文：https://towardsdatascience.com/python-or-r-which-one-is-better-for-data-scientists-or-data-analysts-3be038f6c74c?source=collection_archive---------18-----------------------

照片由西格蒙德在 Unsplash 上拍摄

简单明了的推理

这是一个很常见的问题。尤其是对新手来说。从哪里开始？即使对于中级数据科学家来说，这也是一个问题。因为不同的人有不同的选择或者不同的做事风格。有的公司更倾向于 Python，有的公司更倾向于 r，我有朋友先学了开始学 Python 然后有的招聘人员或者有的用人单位说要学 r，现在开始学 r，其实哪个更好呢？

我从 Python 开始。当我在波士顿大学开始攻读硕士学位时，我必须学习 R。因为一些数据分析课程只使用 R。开始的时候很不舒服。现在我很高兴我能学习 R。因为我现在既懂 Python 又懂 R，我想我应该在这里分享我的观点。

我自己的经历

因为我非常了解 Python，所以我可以很快学会 R。这并不太难。特别是，如果您了解 Python 中的数据操作库，您可能会发现许多命令是相似的(而不是相同的)。所以学习并不难。但这仍然需要时间。这需要大量的练习。因为有如此多的库可用于数据操作和分析，所以对于初学者来说，有时很难跟上。但是很快就变得容易了。

但问题是，值得花时间吗？

对我来说，是的！

Python 相当强大。你可以用 Python 管理 R 中的大部分人员，但是了解 R 会给你很大的灵活性。许多库在 R 中的结构比 Python 更好。如果你两个都擅长，你就有选择了。比如我喜欢用 R 做推断统计，而不是 Python。感觉 R 里的库和包比 Python 里的包好。这只是我的看法。我几乎总是用 R 进行统计分析。有些人可能比 Matplotlib 和 Seaborn 更喜欢 ggplot2。同样，如果我需要使用机器学习库，我更喜欢 Python 的 scikit-learn 库，而不是不同的 R 包。

在这一点上，我感觉，对于中级水*的学习者来说，同时学习 Python 和 r 都是不错的，如果你是自由职业者或者求职者，会打开很多门路。

初学者从哪里开始

在我看来，从 Python 入手是好的。如果你是一名有抱负的数据科学家，并且正在学习你的第一语言，那应该是 python。仅仅是因为 python 更受欢迎。此外，我还找到了更多关于 Python 的资源。如果你看一些流行的程序员网站，比如面向极客的极客、教程点或编程，你会发现他们有几种不同语言的解决方案。Python 就是其中之一。但是你在那里找不到休息。所以，学习会轻松很多。同样，如果你遇到困难，你会在 Python 中更快地找到帮助。

如果你是一名数据分析师，Python 或 R 中的任何一个都可以帮助你完成任务。但如果你是一名数据科学家，也想随着时间深入机器学习和人工智能领域，那么你绝对应该选择 Python。因为你可能需要和软件工程师合作。你不会找到很多愿意在 r 工作的软件工程师，而且我到目前为止看到的所有好的在线课程或硕士课程都使用 Python 教授机器学习。

最后一句话

如你所见，我在学习 Python 上强调了很多。但是，如果可能的话，两者都要学。如果想做数据分析师，Python 或者 R 都可以。但是如果你打算做数据科学家，还是推荐 Python。两个都学就更好了！我的建议是，先学好一门。

更多阅读

用于 NLP 的 Python 包——第 1 部分

用于 NLP 操作的 Polyglot- Python 包

米卡·博斯韦尔在 Unsplash 上的照片

自然语言处理旨在操纵人类/自然语言，使其为机器所理解。它涉及文本分析、文本挖掘、情感分析、极性分析等。有不同的 python 包可以使 NLP 操作变得简单而不费力。

所有的 NLP 软件包都有不同的功能和操作，这使得最终用户更容易执行文本分析和各种 NLP 操作。在这一系列文章中，我们将探索 python 的不同 NLP 包及其所有功能。

在本文中，我们将讨论 Polyglot，这是一个开源 python 包，用于操作文本并从中提取有用的信息。它有几个功能使得它比其他基于 NLP 的库更好更容易使用。这里我们将讨论它的不同功能以及如何实现它们。

让我们开始吧。

安装多语言和其他依赖项

为了开始，我们首先需要安装 polyglot 及其所有依赖项。对于本文，我们将使用 Google Colab，下面给出的代码将安装 polyglot 及其依赖项。

!pip3 install polyglot
!pip3 install pyicu
!pip3 install pycld2
!pip3 install morfessor

安装完这些库之后，我们还需要安装 polyglot 的一些功能，这些功能将在本文中用到。

!polyglot download embeddings2.en
!polyglot download pos2.en
!polyglot download ner2.en
!polyglot download morph2.en
!polyglot download sentiment2.en
!polyglot download transliteration2.hi

导入所需的库

下一步是导入所需的 polyglot 库和功能，我们将在本文中探讨。

import polyglot
from polyglot.detect import Detector
from polyglot.text import Text, Word
from polyglot.mapping import Embedding
from polyglot.transliteration import Transliterator

执行 NLP 操作

让我们从探索 polyglot 提供的一些 NLP 功能开始，但是在此之前，让我们输入一些我们将要处理的样本数据。

sample_text = '''Piyush is an Aspiring Data Scientist and is working hard to get there. He stood Kaggle grandmaster 4 year consistently. His goal is to work for Google.'''

1. 语言检测

Polyglot 的语言检测器可以很容易地识别文字的语言。

#Language detection
detector = Detector(sample_text)
print(detector.language)

语言(来源:作者)

2.**句子和单词**

为了从文本/语料库中提取句子或单词，我们可以使用多语言功能。

#Tokenize
text = Text(sample_text)
text.words

单词(来源:作者)

text.sentences

句子(来源:作者)

3.**位置标记**

词性标注是一项重要的自然语言处理操作，可以帮助我们理解文本及其标注。

#POS tagging
text.pos_tags

词性标注(来源:作者)

4.**命名实体识别**

NER 用于识别语料库/文本数据集中的人、组织和位置(如果有的话)。

#Named entity extraction
text.entities

NER(来源作者)

5.形态分析

#Morphological Analysis
words = ["programming", "parallel", "inevitable", "handsome"]for w in words:
     w = Word(w, language="en")
     print(w, w.morphemes)

形态学(来源:作者)

6.情感分析

我们可以分析一句话的情绪。

#Sentiment analysistext = Text("Himanshu is a good programmer.")
for w in text.words:
   print(w, w.polarity)

极性(来源:作者)

7.翻译

我们可以把文本翻译成不同的语言。

#Transliteration
transliterator = Transliterator(source_lang="en", target_lang="hi")
new_text = ""
for i in "Piyush Ingale".split():
  new_text = new_text + " " + transliterator.transliterate(i)
new_text

翻译(来源:作者)

这就是你可以轻松地探索文本数据集的不同属性的方法。

继续尝试不同的文本数据集，如果你发现任何困难，你可以在回复部分发布。

在你走之前

感谢 的阅读！如果你想与我取得联系，请随时在 hmix13@gmail.com 上联系我或我的 LinkedIn 个人资料 。可以查看我的Github简介针对不同的数据科学项目和包教程。还有，随意探索 我的简介 ，阅读我写过的与数据科学相关的不同文章。

骑着 Python 穿越 Peloton

原文：https://towardsdatascience.com/python-pandas-and-the-peloton-aa024ca74fa5?source=collection_archive---------14-----------------------

实践教程

使用基础数据分析对环法自行车赛进行分析

📸—罗伯·温盖特— Unspalsh

第一阶段:介绍

每年夏天，世界顶尖的自行车选手聚集在法国，进行一场激烈的全国比赛。再过几天，2021 年环法自行车赛将在小港口城市布列斯特开始，并像往常一样，在几周后的巴黎结束。鉴于“大数据”和“分析”的趋势正在触及体育世界的每一个部分，包括自行车，我想使用 Python 中可用的流行库组合来更深入地了解这个年度赛事。这篇文章旨在构建对历史环法自行车赛数据的现有分析，同时展示 Python 在数据分析和可视化基础方面的强大功能。

第二阶段:读入并探索数据

我们分析使用的主要数据集直接来自环法自行车赛官方网站,其中包含了从 1903 年到 2020 年的每场比赛的骑手信息(感谢杰里米·辛格-万的数据是多元的时事通讯来呈现数据集！).由于托马斯·坎米纳迪令人印象深刻的网络搜集——这是一个值得完全独立发布的有用技能组合——这些数据已经被格式化为一个方便的 CSV 文件，详细列出了每个骑手的等级、时间、团队等等。

图:数据来源网站(letour.fr/en)

我们将从 Python 中导入我们分析所需的特定库，然后使用 read_csv 方法从 Pandas 库中读入数据。

图:我们的数据帧的前五行

的。info 方法不仅详细说明了数据集的大小(9，452 行和 18 列)，还详细说明了每列的数据类型以及每列缺失的数据量。粗略地看一下，我们发现“奖金”和“积分”变量在我们的数据准备阶段很容易被删除或估算，因为每个变量都有大量的缺失值或空值。

图:我们的列的名称、数据类型和缺失数据计数

最后。describe 方法显示了我们的数字列的快速统计摘要。虽然我们正在处理的数据集不够全面，不足以证明这些步骤，但通过热图或相关矩阵图以及直方图来可视化您的数据，以了解数据分布，可以作为探索您的数据的初始模式或关系的另一种方式。

图:我们的整数类型列的一些统计度量

第三阶段:清理和准备数据

尽管耗时且*庸，数据清理和准备对于任何适当的数据深度挖掘都是必不可少的一步，因为它创建了一个适当的基础数据集来进行未来的分析。我们将删除数据集的第一列。drop 方法，因为它不提供任何值。此外，“奖金”和“积分”列似乎没有太大的帮助，因为缺少大量的值，所以让我们也放弃这些。虽然我们不会在这里触及，但各种数据插补和替换方法可用于解决数据缺失部分。将距离从千米转换成英里可以通过在阵列上运行简单的计算来实现；我们还想用。为了清楚起见，重命名方法。

图:我们的“清理”数据集的前十行

除了列名之外，在查看“team”变量时，我们遇到了一个很好的数据清理机会。特殊团队“Touriste-Routiers”(翻译为“公路游客”)与“Touristes Routiers”分开计算。

图:初始数据集中的前 10 个团队

虽然这实际上可能是两个独立的团队——关于是否存在连字符的争论很常见——让我们继续假设这只是一个错误，我们可以使用。将方法替换为地址。

图:10 大团队，使用。替换方法

阶段 4:分析数据

在这一点上，我们可以开始问——并希望回答——一些关于环法自行车赛的简单的时间序列问题。除了季节性和变化率之外，总体趋势也是时间序列分析的共同兴趣点。例如，如果我们想了解比赛的规模是如何增长的，我们可以使用。按 and 分组。数数每年乘坐的人数。

图:每年乘客总数

图:数据集中出现频率最高的骑手

看起来法国自行车手西尔万·查瓦内尔以 16 件参赛作品领跑！让我们稍微解开这一行代码…

• rider_df['rider]从我们的数据帧中选择“Rider”列，生成一个序列
• 。values_counts()是对这个新系列中的值进行计数的方法；这实际上创建了一个新的序列，其中索引是附加项，值是它们出现的频率(从最频繁开始递减)
• [:10]给出了这个系列中前 10 个最常出现的骑手；最终创建最终系列，如上所示

如果我们想快速查看每年的所有获奖者，该怎么办？我们只需创建一个列表，并在“Rank ”= 1 时进行过滤。通过过滤选择数据子集是回答此类问题或生成新问题的一个好方法。

图:显示获胜者的数据子集

换挡(不得不偷偷把至少一个糟糕的骑车双关语放到这篇文章中)，让我们看看光谱的另一端，按速度排序数据，看看历史上最慢的骑手。这可以通过。sort_values 方法应用于适当的列，在我们的例子中是“PersonalAvgPace”。

图:基于“个人空间”变量的最慢骑手

不出所料，最慢的车手名单经常出现在一些最早记录的比赛中。

阶段 5:将数据与另一个数据集合并

我们的原始数据集是全面的，但当涉及到每个骑手的有趣信息时，就相当有限了。幸运的是，我们在 Github 上看到了一个单独的数据集,列出了每年环法自行车赛的冠军，包括成绩信息以及骑手的身高、体重、年龄、国籍等等。 Python 让我们能够转换现有的骑手数据框架，并将两个数据集合并在一起。

我们的原始数据集已被修改为只显示获胜者，并被重命名为 df2 现在，我们将阅读并检查我们遇到的其他赢家数据集。

图:我们新数据集的初步观察

我们将在这个新数据集上执行一组类似的数据清理和准备活动，就像我们对原始数据集所做的那样。Year 显然是连接两组数据的主键，但是我们需要确保它们的格式相同。让我们用一个快速切片来修剪“Year”列(当我们使用 quick .str.upper 方法时，用同样的方式来格式化 riders)。确保数据类型相同很重要，因此我们将确保“Year”变量是一个带有。a 类型方法。

图:我们的两个数据框，准备合并

类似于 SQL 的 JOIN 子句。Pandas 中的 merge 方法允许在一列或多列上连接两个数据帧。默认的合并类型是内部联接，但是可以使用 how 参数覆盖它。我们知道获胜者/骑手的名字是多余的，因为它包含在两个数据集中；在 Python 中，列上的 _x 和 _y 后缀有助于指示列名的来源(x 是左边的数据集，而 _y 是右边的)。我们将删除其中一个，并在最终的合并数据集中有一个单独的“获胜者”列。

图:我们新合并的数据框架

图:我们输出的一个子集，按国家列出了获胜团队的名称

阶段 6:用 Matplotlib、Seaborn 和 Plotly 可视化数据

Python 提供了各种绘图库来帮助你创建清晰、深刻的数据可视化。在这个阶段，我们将展示一些最流行的库的功能，包括 Matplotlib、Plotly 和 Seaborn。让我们用一个简单的线形图来显示获胜者每年的*均速度。我们将添加一些参数，如绘图标题、轴标签和图例。我们还将添加一个注释来记录一段缺失的数据。

图:显示每年获胜者*均速度的线形图

毫不奇怪，随着时间的推移，比赛获胜者的速度越来越快，*年来的增长略有放缓，这可能是由于*年来对兴奋剂的打击以及骑手和自行车不断达到的身体限制的综合作用。如果我们想将这些信息与另一个不同尺度的变量进行比较，比如距离，会怎么样呢？我们只需用另一个轴创建一个图来容纳我们的新变量。我们还将确保合并标签，这样两行都可以考虑。

图:比较比赛距离和冠军配速

条形图是 Python 中可视化数据的常用方式。让我们使用此图表类型按获胜次数来比较获胜者。

我们已经可以看出这个图表不是最直观或最容易阅读的。无意冒犯许多只赢了一场比赛的车手，但让我们看看是否能把它精简到赢了多次的车手。通过对数据和标签的一些调整，我们应该能够创建一个更容易解释的图表。(点击这里查看一篇更详细的帖子，展示了构建更好图表的各个层次)

图:显示多个赢家的改进条形图

也许我们想显示一段时间内环法自行车赛“*均”获胜者的数据。创建一些变量并将它们传递到 print 语句中是一个好的开始。

让我们试着用一种更具视觉吸引力的形式来表现“普通”骑手。直方图是查看数据频率分布的有用方式。的。hist()函数有许多选项来改变数据的计算和相应图表的显示。如果我们假设我们的数据是正态分布的，一些直方图将有助于描绘一幅“*均赢家”的图画。Matplotlib 的 subplot 特性允许我们并排比较这些图表。

图:环法自行车赛获胜者*均值直方图的子图

简单地说，散点图是展示两个变量之间关系的好方法。也许我们想要一个关于获胜者身高和体重之间相关性的视觉表现。

图:身高和体重的散点图

这是一个好的开始，但让我们做一些挖掘来注释上图中的一个异常值，特别是体重最大的骑手。对我们的数据进行一些快速过滤，很快就确定了这个异常值是 1909 年环法自行车赛冠军弗朗索瓦·费伯(Francois Faber)的名字，他被恰当地称为“哥伦布巨人”。让我们对 Francois 在领奖台上穿着 XL 黄色球衣给予应有的认可，并用注释更新我们的散点图。

据其网站，“Seaborn 是一个基于 matplotlib 的 Python 数据可视化库。它提供了一个高级界面，用于绘制有吸引力且信息丰富的统计图形。”虽然 matplotlib 中的一些绘图类型非常令人满意，但 Seaborn 为其他绘图类型提供了轻微的视觉增强，希望能够提高理解能力。我们将使用 boxplots 来展示 Seaborn 的功能，这是一种非常好的异常检测方法。下图显示了 Seaborn 如何对按国籍分组的*均获奖者年龄的箱线图进行细微的视觉改进。

图:使用 matplotlib 的箱线图

图:使用 seaborn 的箱线图

虽然我们的样本量相对较小，但深入挖掘箱线图中显示的意大利获胜者的异常值会很有意思。最后但同样重要的是， Plotly 是一个图形库，允许用 Python 创建交互式图表。Plotly 在多种格式的可读性方面大放异彩，它为各种类型的情节提供了许多有趣的定制功能，但我们将使用下面的代码创建一个带有交互式悬停状态的简单的 winners age 折线图。

图:显示每年获奖者年龄的图表

阶段 7:未来分析

如前所述，这个项目在范围上相当有限，只是触及了可以在这样的数据集上运行的分析的表面。未来分析中涉及的几个有趣的问题或概念包括:

• 预测:时间序列分析的首要目标往往是预测；观察未来 15 年的冠军配速或比赛距离等因素可能会很有趣。
• 回归模型:建立多元线性回归模型，根据身高、体重、年龄、国籍等因素预测骑行者的步伐。
• 异常检测:查看哪些骑手或获胜者在人群中脱颖而出，并找出原因将是扩展我们上面展示的一些异常检测工作的一个好方法。
• 对比被禁赛车手的表现 : 兴奋剂指控和争议从环法自行车赛开始就一直困扰着它；被指控服用兴奋剂的被取消资格的骑手没有被包括在数据集中，但比较被禁赛的骑手被剥夺冠军头衔的速度和我们数据集中的获胜者的速度等指标会很有趣
• 雷达图:绘制多个雷达(或蜘蛛)图比较不同国籍的车手在各种不同因素上的表现。

当你加入生物特征数据、天气、海拔和自行车类型等因素时，在未来几年的环法自行车赛中，将会发现大量有趣且有望产生影响的见解。

第八阶段:进一步阅读和总结

如上所述，这不是第一次深入研究环法自行车赛的数据，希望不会是最后一次！如果你对这些感兴趣的话，我在研究过程中发现了更多的资源:

• 数字环法自行车赛简介
• 环法自行车赛数据分析，使用 Jupyter 笔记本中的 Strava 数据以及 Python、Pandas 和 Plotly
• 可视化环法自行车赛
• #tidytuesday:环法自行车赛冠军

希望您喜欢这个高层次的概述，并发现它对展示 Python 及其相关特性的简单方面如何揭示数据集的独特见解有所帮助。点击查看原始代码。我错过/忘记了什么，或者你会采取什么不同的做法？任何和所有的反馈都欢迎通过下面的评论，或者在 wmc342@gmail.com 给我留言。非常感谢您的阅读，并享受比赛！🚴

Python 熊猫面试数据科学的问题

原文：https://towardsdatascience.com/python-pandas-interview-questions-for-data-science-377dfac4a7a1?source=collection_archive---------23-----------------------

利用熊猫进行 Python 数据科学面试试题

在 Unsplash 上由Christina @ wocintechchat.com拍摄的照片

在上一篇文章 Python Pandas 数据科学面试问题第 1 部分 中，我们研究了如何将数据导入 Pandas 并执行基本计算，例如

• 排序数据帧
• 处理重复
• 聚集
• 合并数据帧
• 计算字段

在这一部分中，我们将基于这些知识，用它们来解决更复杂的 Python 熊猫面试问题。我们将关注以下领域

• 日期时间操作
• 文本操作
• 应用函数
• 高级聚合
• 偏移数据
• 使用熊猫的统计

如果你不熟悉熊猫图书馆，请浏览那篇文章。让我们开始吧。

应用函数

在本系列的前一部分中，我们研究了如何创建额外的字段。我们也可以使用 Python 库中的函数或用户定义的函数来操作值。为此，我们使用 apply()方法。apply()方法使用矢量化，因此与遍历序列中的每一行相比，可以更快地计算值。这里有一个来自 AirBnB 数据科学采访的简单问题。

生活设施最多的城市

从 Airbnb 上给定的房产搜索数据集中，找出主人所有房产中设施最多的城市。假设每行代表一个唯一的主机。输出城市名称作为您的解决方案。

截图来自 StrataScratch

你可以在这里解决这个 Python 熊猫面试问题。https://platform . stratascratch . com/coding/9633-拥有最多便利设施的城市？python=1

该问题使用包含这些字段的 airbnb_search_details 数据集

截图来自 StrataScratch

以下是数据的显示方式。

截图来自 StrataScratch

方法和解决方案

让我们把这个问题分解一下。给定酒店的所有便利设施都在便利设施栏中给出。便利设施以逗号分隔的字符串形式列出。我们通过简单地使用逗号分隔符分割字符串并取结果列表的长度来找到便利设施的数量。

# Import your libraries
import pandas as pd

# get the number of number of amenities
airbnb_search_details['num_amenities'] = airbnb_search_details
['amenities'].apply(lambda x : len(x.split(",")))
airbnb_search_details[['city', 'id', 'amenities', 'num_amenities']]

数据集现在看起来像这样。

截图来自 StrataScratch

我们现在可以简单地合计每个城市的设施数量，并输出设施数量最多的城市。我们可以使用方法链接将所有这些方法组合在一行中。

# Summarize by city and output the city with the most amenities
airbnb_search_details.groupby(by = ['city'], as_index = False).agg
({'num_amenities' : 'sum'}).sort_values(by = ['num_amenities'], 
ascending = False).reset_index()['city'][0]

我们不局限于内置函数。我们可以创建自己的函数，也可以动态创建 lambda 函数。让我们在下面的 Python 熊猫采访问题中尝试一下。这个出现在旧金山数据科学采访中。

划分业务类型

将每家企业归类为餐馆、咖啡馆、学校或其他。被归类为餐馆的企业名称中应包含“餐馆”一词。对于咖啡馆，企业名称中应包含“咖啡馆”、“咖啡馆”或“咖啡”。学校会有‘学校’这个词。根据上述规则，如果企业不是餐馆、咖啡馆或学校，则应归类为“其他”

截图来自 StrataScratch

你可以在这里解决这个 python 面试问题。https://platform . stratascratch . com/coding/9726-classify-business-type？python=1

此问题使用具有以下字段的SF _ restaurant _ health _ violations数据集。

截图来自 StrataScratch

数据是这样的。

截图来自 StrataScratch

方法和解决方案

这个 Python Pandas 面试问题的唯一相关字段是 business_name 列。我们编写一个 lambda 函数，并使用 apply 方法来检查企业满足了哪些业务规则。一旦我们有了类别，我们就输出问题中所需的相关字段。

# Import your libraries
import pandas as pd

# Classify as per the rules
sf_restaurant_health_violations['category'] = sf_restaurant_health_violations
['business_name'].apply(lambda x: \
'school' if x.lower().find('school') >= 0 \
else 'restaurant' if x.lower().find('restaurant') >= 0 \
else 'cafe' if (x.lower().find('cafe') >= 0 or x.lower().find('café') >= 0 \
or  x.lower().find('coffee') >= 0) \
else 'other'
    )
# Output relevant fields    
sf_restaurant_health_violations[['business_name', 'category']].drop_duplicates()

正如我们所见，apply 方法是使用用户定义的函数或 Python 库中的函数操作值和创建计算字段的一种非常强大的方法。

高级聚合

在上一篇文章中，我们已经看到了使用 groupby 方法的聚合。Pandas 也支持其他聚合，我们还可以创建一个电子表格风格的数据透视表。让我们看看如何在熊猫身上做到这一点。我们从旧金山市的一个数据科学问题开始。

制作一张数据透视表，找出每位员工每年的最高工资

查找从 2011 年到 2014 年每年每位员工的最高薪酬。以表格的形式输出结果，列中是年份，行中是按字母顺序排序的员工姓名。

截图来自 StrataScratch

你可以在这里解决这个 Python 熊猫面试问题。https://platform . stratascratch . com/coding/10145-make-a-pivot-table-to-find-the-high-payment in-year-per-employee？python=1

该问题使用具有以下字段的 sf_public_salaries 数据集。

截图来自 StrataScratch

数据是这样显示的。

截图来自 StrataScratch

方法和解决方案

虽然这个问题对于 SQL 来说可能有点困难，但是对于 Pandas 来说，这个问题可以通过使用 pivot_table()函数在一行代码中解决。我们只需传递正确的参数，并获得想要的输出。

# Import your libraries
import pandas as pd

# create the pivot table 
pd.pivot_table(data = sf_public_salaries, columns = ['year'], 
index = 'employeename', values = 'totalpay', aggfunc = 
'max', fill_value = 0).reset_index()

pivot_table()方法非常强大，可以帮助快速解决复杂的聚合问题。这是另一个例子。这是来自脸书数据科学的采访。

两个事件之间的时间

报告用户从页面加载到第一次向下滚动的最短时间。输出应该包括用户 id、页面加载时间、第一次向下滚动时间以及两个事件之间的时间间隔(秒)。

截图来自 StrataScratch

你可以在这里解决问题https://platform . stratascratch . com/coding/9784-time-between-two-events？python=1

这个问题使用了包含以下各列的 facebook_web_log 数据集。

数据是这样显示的。

截图来自 StrataScratch

方法和解决方案

同样，这个面试问题在 SQL 中可能有点复杂。然而，在熊猫中，使用数据透视表是相对简单的。我们首先创建一个数据透视表，其中包含每个 user_id 的每个动作的最早实例。因为我们只需要 page_load 和 scroll_down 事件，所以我们只在输出中保留那些列。

import pandas as pd

# Find the first instance of diffrent actions
summ_df = pd.pivot_table(data = facebook_web_log, index = 'user_id', columns = 
'action', aggfunc = 'min', values = 'timestamp').reset_index()[['user_id', 
'page_load', 'scroll_down']]

输出如下所示。

截图来自 StrataScratch

现在问题变得很简单。我们可以通过获取 scroll_down 和 page_load 时间戳之间的差值来直接计算持续时间。然后，我们输出持续时间最短的用户的 user_id 和其他必填字段。

# Caclulate duration
summ_df['duration'] = summ_df['scroll_down'] - summ_df['page_load']
# Output the user details for the user with the lowest duration
summ_df.sort_values(by = ['duration'])[:1]

如您所见，pivot_table()函数允许我们进行多个聚合，而不必像在 SQL 中那样将它们分离和合并。

日期时间操作

日期时间操作是最常被问到的数据科学面试问题之一。datetime 数据集的普遍性和一系列可以通过简单的数据实现的复杂性使其成为一个流行的数据科学测试领域。Pandas 有许多日期时间函数，涵盖了广泛的日期时间用例。一旦以日期时间格式将数据加载到 Pandas 中，就可以通过调用。dt 访问器。这为我们提供了对各种日期时间方法的访问，这些方法可以通过整个熊猫系列来访问。

让我们在一个真实世界的 Python 熊猫面试问题中使用它。这是一个来自 DoorDash 数据科学的采访。

每个工作日和每个小时的*均收入

报告一周中每天每小时的*均收入数。使用 customer_placed_order_datetime 字段计算相关的日期时间值。收益可视为“订单总额”字段的总和。把星期一当作一周的第一天。

截图来自 StrataScratch

你可以在这里解决问题:https://platform . stratascratch . com/coding/2034-avg-earnings-per-weekday-and-hour？python=1

该问题使用了具有以下字段的 doordash_delivery 数据集。

截图来自 StrataScratch

数据集看起来像这样。

截图来自 StrataScratch

方法和解决方案

为了解决这个 Python 熊猫采访问题，我们需要从相关的 datetime 字段中提取星期几和小时。如问题中所述，该字段为“客户 _ 已下单 _ 订单 _ 日期时间”。

为了获得星期几，我们使用. dt.weekday 属性。根据文档，这将为周一返回 0，为周日返回 6。因为周一我们需要从 1 开始，所以我们在结果上加 1。

# Import your libraries
import pandas as pd

# Keep relevant fields
dd_df = doordash_delivery[['customer_placed_order_datetime', 'order_total']]
# Get the day of the week (add 1 to keep have Monday = 1)
dd_df['weekday'] = dd_df['customer_placed_order_datetime'].dt.weekday + 1

同样，我们也可以提取一天中的小时。为此，我们使用 datetime 对象的. dt.hour 属性。

# Hour of the day
dd_df['hour'] = dd_df['customer_placed_order_datetime'].dt.hour

我们现在可以简单地按一周中的某一天和一天中的某个小时进行聚合，并输出相关的列。

dd_df.groupby(by = ['weekday', 'hour'], as_index = False).agg
({'order_total': 'mean'})

让我们尝试一个稍微难一点的 Python 熊猫面试问题。这一个来自 Salesforce Data Science 访谈，使用日期时间操作和数据透视表。

用户增长率

计算每个账户在 2021 年 1 月和 2020 年 12 月的活跃用户增长率。

你可以在这里解决问题。https://platform . stratascratch . com/coding/2052-user-growth-rate？python=1

该问题使用了包含以下各列的 sf_events 数据集。

数据是这样的。

截图来自 StrataScratch

方法和解决方案

我们需要汇总每个帐户在两个不同时间段的用户数量。这是数据透视表的一个完美案例。但是在我们这样做之前，我们首先从日期中提取年和月，因为我们必须对几个月进行汇总。为此，我们使用。strftime()方法。这扩展了 Python 日期时间库中可用的 strftime()方法。这非常类似于我们在 SQL Datetime 文章中讨论过的 SQL 中的 TO_CHAR()函数。​

# Import your libraries
import pandas as pd

# Create the Year - Month indicator
sf_events['month'] = sf_events['date'].dt.strftime('%Y-%m')

我们现在可以使用数据透视表对 2020 年 12 月和 2021 年 1 月进行汇总，计算增长率并输出相关列。

# Aggregate relevant months
summ_df = sf_events[sf_events['month'].isin(['2020-12', '2021-01'])].
pivot_table(
    index = 'account_id', columns = 'month', values = 'user_id', aggfunc = 
    'nunique').reset_index()
# Calculate growth rate and output relevant columns
summ_df['growth_rate'] = summ_df['2021-01'] / summ_df['2020-12']
summ_df[['account_id', 'growth_rate']]

文本操作

与 datetime 函数一样，Pandas 提供了一系列字符串函数。就像。对于日期时间函数，我们可以使用。str 访问器在整个系列中使用标准字符串函数。除了标准的字符串库之外，还有一些额外的函数可以派上用场。让我们来看几个 Python 熊猫面试问题的例子。第一个是来自洛杉矶一个城市的数据科学采访。

“面包店”自有设施

你可以在这里解决问题https://platform . stratascratch . com/coding/9697-bakery-owned-facilities？python=1

该问题使用具有以下字段的洛杉矶餐厅健康检查数据集。

截图来自 StrataScratch

数据如下所示。

截图来自 StrataScratch

方法和解决方案

虽然数据集中有许多列，但相关的是 owner_name 和 pe_description。我们首先只保留数据集中的相关列，删除重复的列(如果有的话)。

然后，我们在 owner_name 字段中搜索文本 BAKERY，在 pe_description 字段中搜索低风险。为此，我们使用 str.lower()方法将所有值转换为小写，并使用. str.find()方法查找相关文本的实例。 .str.find() 是 Python 内置方法 find()对字符串类型变量的扩展。

然后，我们使用布尔掩码输出满足这两个标准的行。

# Import your libraries
import pandas as pd

# Keep relevant fields
rel_df = los_angeles_restaurant_health_inspections
[['owner_name', 'pe_description']].drop_duplicates()
# Find the relevant text in the two fields. 
rel_df[(rel_df['owner_name'].str.lower().str.find('bakery') >= 0) &( rel_df
['pe_description'].str.lower().str.find('low risk') >=0)]

除了通常的字符串方法之外。str 访问器还有一些额外的方法。一种这样方法是 explode()。

顾名思义，该方法拆分数据帧中的系列或特定列。其他值(如果是数据帧)和索引是重复的。让我们看看这在实践中是如何使用的。我们在本文前面解决的 AirBnB 数据科学面试问题中使用了这一点。

生活设施最多的城市

从 Airbnb 上给定的房产搜索数据集中，找出主人所有房产中设施最多的城市。假设每行代表一个唯一的主机。输出城市名称作为您的解决方案。

截图来自 StrataScratch

airbnb_search_details 数据集中的相关字段是便利设施和城市

截图来自 StrataScratch

方法和解决方案

我们从保留数据集中的相关字段开始(这在实际解决方案中是不需要的。我们这样做是为了使解决方案更容易理解)。

# Import your libraries
import pandas as pd

# Keep Relevant fields
rel_df = airbnb_search_details[['amenities', 'city']]

我们通过调用 split 方法将便利设施字符串拆分成一个列表。

# Split the amenities string
rel_df['amenities'] = rel_df['amenities'].str.split(",")

现在我们调用便利设施列上的 explode()方法。

rel_df = rel_df.explode('amenities')

截图来自 StrataScratch

可以看到，explode 方法为一个 iterable 内部的每个对象创建了一个单独的行，比如 list、set、tuple 等。现在，我们可以聚合城市中的便利设施，并像前面一样输出结果。

# Summaroze by city
rel_df.groupby(by = ['city'], as_index = False).agg({'amenities' : 'count'}).
sort_values(by = ['amenities'], ascending = False).reset_index()['city'][0]

explode 是一个非常强大的函数，对于基于文本操作的问题来说非常方便。

使用熊猫的统计

考虑到处理表格数据的能力，Pandas 也是统计操作的自然选择。虽然 NumPy 被认为是统计操作的首选库，但由于 Pandas 是基于 NumPy 构建的，它继承了相当多的统计度量，可以很容易地调用这些度量来计算这些度量。让我们看几个例子。第一个是来自洛杉矶一个城市的数据科学面试问题。

求 A 级分数的方差和标准差

截图来自 StrataScratch

你可以在这里解决这个 Python 熊猫面试问题。https://platform . stratascratch . com/coding/9708-find-the-variance-and-the-standard-deviation-of-scores-that-have a grade？python=1

这个问题使用了我们之前看到的洛杉矶餐厅健康检查数据集。该数据集具有以下字段。

截图来自 StrataScratch

数据是这样显示的。

截图来自 StrataScratch

方法和解决方案

让我们自己通过计算来解决这个问题。然后我们将通过调用内置的 Pandas 方法来解决这个问题。我们首先对相关字段进行子集划分，只保留那些与 a 级相对应的分数。

# Import your libraries
import pandas as pd

# Subset relevant rows
la_df = los_angeles_restaurant_health_inspections[los_angeles_restaurant_health_
inspections['grade'] == 'A'][['grade', 'score']]
la_df

截图来自 StrataScratch

方差是*均值的均方差。人口方差被定义为

标准差是方差的*方根

我们可以通过计算等级*均值的*方差的*均值来计算方差。我们可以通过使用向量化操作一步完成。根据方差，我们可以很容易地计算出标准差。最后以期望的格式输出结果。

variance = ((la_df['score'] - la_df['score'].mean())**2).mean()
stdev = variance ** 0.5
output_df = pd.DataFrame({'variance' : [variance], 'stdev' : [stdev]})

除了从公式中计算方差，我们还可以调用内置的 Pandas 统计方法。由于我们正在计算人口方差和标准差，我们需要指定熊猫不使用贝塞尔校正。我们可以通过在方差和标准差计算中将 ddof 参数设置为 0 来做到这一点。

variance = la_df['score'].var(ddof = 0)
stdev = la_df['score'].std(ddof = 0)
output_df = pd.DataFrame({'variance' : [variance], 'stdev' : [stdev]})

让我们试试稍微复杂一点的。这是来自谷歌数据科学的采访。

邮件与活动时间的关联

找出一个用户收到的邮件数量和每天总运动量之间的相关性。每天的总运动量就是每天的用户会话数。

截图来自 StrataScratch

你可以在这里解决问题https://platform . stratascratch . com/coding/10069-correlation-between-e-mail-and-activity-time？python=1

这个问题使用了两个数据集

截图来自 StrataScratch

数据显示如下:

google_gmail_emails

截图来自 StrataScratch

google_fit_location

截图来自 StrataScratch

方法和解决方案

我们首先计算每天发送给每个用户的电子邮件数量。我们通过按用户 id 和日期合计电子邮件数量来做到这一点

# Import your libraries
import pandas as pd

# Get the number of emails per day
mail_df = google_gmail_emails.groupby(by = ['to_user', 'day'], 
as_index = False).agg({'id' : 'count'}).fillna(0)
mail_df

我们得到下面的数据集。

截图来自 StrataScratch

我们对其他数据集做同样的事情，计算每天的用户会话数。注意:我们只需要对每个用户会话计数一次。

exer_df = google_fit_location.groupby(by = ['user_id', 'day'], as_index = 
False).agg({'session_id' : 'nunique'}).rename(columns = 
{'user_id': 'to_user'}).fillna(0)
exer_df

给了我们

截图来自 StrataScratch

我们现在合并用户和日期的两个数据集

merged_df = pd.merge(mail_df, exer_df, on = ['to_user', 'day'], how = 'inner')
merged_df

截图来自 StrataScratch

我们现在可以使用内置的协方差函数来计算协方差。协方差输出将提供两个变量的协方差。例如，两个变量 x 和 y 的协方差输出将包含与此类似的内容。

我们可能需要对角线上的值(用绿色突出显示)。因此，我们对相关字段进行子集划分。

merged_df[['id', 'session_id']].corr()[:1]['session_id']

偏移数据

另一个常见的商业案例，尤其是时间序列数据，是找出它们的前一个或后一个值。Pandas 有能力支持这些 SQL 风格的滞后和超前操作。让我们在实践中使用这些方法，解决优步数据科学采访中的一个问题。

逐年流失

计算每年的司机流失率，并报告与前一年相比，人数是增加了还是减少了。

截图来自 StrataScratch

你可以在这里解决所有的问题。https://platform . stratascratch . com/coding/10017-同比-流失？python=1

该问题使用了具有以下字段的 lyft_drivers 数据集。

数据集看起来像这样。

截图来自 StrataScratch

方法和解决方案

我们从计算每年的流失率开始。为此，我们首先从 end_date 字段计算客户流失的年份，然后计算每年的客户流失数量。

# Import your libraries
import pandas as pd

# Get the year from exit date
lyft_drivers['year'] = lyft_drivers['end_date'].dt.year

# Get the number of the drivers churned for each year
summ_df = lyft_drivers.groupby(by = ['year'], as_index = False).agg
({'index' : 'count'}).sort_values(by = ['year']).rename
(columns = {'index' : 'churn'}).dropna()

这为我们提供了以下汇总数据。

截图来自 StrataScratch

检查与前一年相比，该数字是增加了还是减少了。为此，我们需要偏移或下移客户流失数量的值。我们可以通过使用 shift()方法来实现这一点。顾名思义，shift 方法将数据偏移 n 行。也可以传递负数，以便向上移动数值。

# Fetch the prev year's churn numbers
summ_df['prev_churn'] = summ_df['churn'].shift(1).fillna(0)
summ_df

截图来自 StrataScratch

我们可以将该值与前一项进行比较，并确定数字是增加了还是减少了。

# Compare the two churn numbers and output the change
summ_df['change'] = (summ_df['churn'] > summ_df['prev_churn']).apply
(lambda x : 'increase' if x == True else 'decrease')
summ_df

额外的 Python 熊猫面试问题

作者在 Canva 上创建的图像

我们最后解决了几个问题，这些问题结合了我们所学的所有知识。第一种使用窗口函数。这是来自亚马逊数据科学的采访。

收入随时间变化

求每个月的三个月移动*均线。

截图来自 StrataScratch

你可以在这里解决这个 Python 熊猫面试问题https://platform . stratascratch . com/coding/10314-收入-时间？python=1

该问题使用了具有以下字段的 amazon_purchases 数据集。

数据是这样的。

截图来自 StrataScratch

方法和解决方案

我们从相关事务的数据子集开始。我们删除问题中描述的退款交易。我们通过调用 created_date 字段上的 strftime 方法找到所需的月份指示器。我们进一步汇总每个月的购买交易。

# Import your libraries
import pandas as pd

# Remove refund transactions
pos_df = amazon_purchases[amazon_purchases['purchase_amt'] > 0]
# Create Month indicator
pos_df['month'] = pos_df['created_at'].dt.strftime("%Y-%m")
# Aggregate the purchases by month
summ_df = pos_df.groupby(by = ['month'], as_index = False).sum()
[['month', 'purchase_amt']].sort_values(by = ['month'])

截图来自 StrataScratch

为了找到移动*均线，我们使用滚动函数。滚动函数创建 n 行的移动窗口。我们可以改变参数来得到我们想要的输出。因为我们不希望前两个观察返回空值，所以我们将 min_periods 参数设置为 1。最后，我们调用 mean()方法来计算三个月的*均值，并返回相关字段。

# Calculate the rolling average, ensure that the value is calculated 
  even for the first two months
summ_df['roll_avg'] = summ_df['purchase_amt'].rolling
(3, min_periods = 1).mean()
# Output relevant fields
summ_df[['month', 'roll_avg']]

下一个来自亚马逊数据科学访谈，以创新的方式使用了 apply 方法。

连胜最久的选手

连胜是特定玩家赢得的一系列连续比赛。当一名球员输掉下一场比赛时，连胜就结束了。输出具有最长连胜的玩家的 ID 和连胜的长度。

截图来自 StrataScratch

你可以在这里解决这个 Python 熊猫面试问题。https://platform . stratascratch . com/coding/2059-连胜最长的球员？python=1

这个熊猫面试问题使用带有以下字段的玩家 _ 结果数据集。

数据是这样显示的。

截图来自 StrataScratch

方法和解决方案

为了解决这个问题，我们需要得到一个玩家的结果。假设一个玩家的结果序列是

WWLWLWWWLWWWWWWWLLLWLW

我们可以简单地通过使用字母“L”作为分隔符来拆分字符串。这将把字符串分成几个列表。类似这样的。

[WW] [W] [WWW] [WWWWWWW] [] [] [] [W] [W].

最后，我们找到最长列表的长度，我们将能够确定玩家的连胜。为了在熊猫身上做到这一点，我们需要连接结果。为此，我们只需应用 sum()方法。

当传递数字数据时，sum()方法应该给出值的总数。但是当字符串类型数据被传递时，就会执行加法运算。Python 中的加法运算符将连接字符串，这正是我们需要的！！。

我们从连接结果开始。

# Import your libraries
import pandas as pd

# Create the sequence of results
streak_df = players_results.groupby(by = ['player_id'], as_index = False).agg
({'match_result': 'sum'})

截图来自 StrataScratch

然后，我们继续使用字母 L 作为分隔符来拆分 match_result 字符串。我们还分解了结果，这样每个列表都是单独的一行。

# Split the sequence using 'L' as the separator and explode
streak_df['streak'] = streak_df['match_result'].str.split('L')
streak_df = streak_df.explode(column = 'streak')

截图来自 StrataScratch

现在剩下的问题就简单了。我们只需要合计条纹字符串的最大长度，并输出相关字段。

# Find the length of the streak
streak_df['streak_len'] = streak_df['streak'].apply(len)
# Aggregate
streaks_df = streak_df.groupby(by = ['player_id'], as_index = False).agg
({'streak_len' : 'max'})
# Output relevant fields
streaks_df['rank'] = streaks_df['streak_len'].rank(method = 
'dense', ascending = False)
streaks_df[streaks_df['rank'] == 1].drop(columns = ['rank'])

结论

在这一系列文章中，我们看了如何使用熊猫和如何解决 Python 熊猫面试问题。如果一个人真的想从事以 Python 为主要工具的数据科学领域的工作，那么他应该精通熊猫。使用 Pandas 就像使用 MS-Excel、Google Sheets、Numbers 或 LibreOffice Calc 等电子表格软件一样简单。一个人要精通熊猫只需要一点时间和好奇心。我们在 StrataScratch *台上有超过 700 个与数据科学面试相关的编码和非编码问题。这些问题来源于优步、网飞、Noom、微软、脸书等顶级公司的实际数据科学面试。查看我们最*关于 前 30 名 Python 面试问题和答案 的帖子。在 StrataScratch 上，您将有机会加入一个由 20，000 多名志同道合的数据科学爱好者组成的团体，获得协作学习体验。今天就在 StrataScratch 上注册，为全球大型科技公司和初创公司最受欢迎的职位做好准备。

原载于https://www.stratascratch.com。

Python 熊猫阅读 CSV

原文：https://towardsdatascience.com/python-pandas-reading-a-csv-7865a11939fd?source=collection_archive---------19-----------------------

学习如何阅读 CSV 文件并创建熊猫数据帧

照片由米卡·鲍梅斯特在 Unsplash 上拍摄

介绍

作为数据分析师或数据科学家，您将经常需要组合和分析来自各种数据源的数据。我经常被要求分析的一种数据类型是 CSV 文件。CSV 文件在企业界很受欢迎，因为它们可以处理强大的计算，易于使用，并且通常是企业系统的输出类型。今天我们将演示如何使用 Python 和 Pandas 打开并读取本地机器上的 CSV 文件。

入门指南

你可以通过 pip 从 PyPI 安装 Panda。如果这是你第一次安装 Python 包，请参考 Pandas 系列&数据帧讲解或 Python Pandas 迭代数据帧。这两篇文章都将为您提供安装说明和今天文章的背景知识。

句法

在学习熊猫时，对我来说最具挑战性的部分是关于熊猫功能的大量教程，比如.read_csv()。然而，教程往往忽略了处理真实世界数据时所需的复杂性。一开始，我经常发现自己不得不在 StackOverflow 上发布问题，以学习如何应用特定的参数。下面我们包括了所有的参数，以及概念上更复杂的例子。

上面的 python 片段显示了 Pandas read csv 函数的语法。

上面的语法乍一看似乎很复杂；然而，我们将只设置少数几个参数，因为大多数参数都被赋予了默认值。然而，这些参数预示着熊猫强大而灵活的天性。

因素

• filepath_or_buffer:您可以传入一个字符串或路径对象，该对象引用您想要读取的 CSV 文件。该参数还接受指向远程服务器上某个位置的 URL。

上面的 Python 片段展示了如何通过向 filepath_or_buffer 参数提供文件路径来读取 CSV。

• sep&delimiter:delimiter参数是sep的别名。你可以使用sep来告诉熊猫使用什么作为分隔符，默认情况下这是,。但是，您可以为制表符分隔的数据传入 regex，如\t。
• header:该参数允许您传递一个整数，该整数捕获 CSV 头名称所在的行。默认情况下，header被设置为infer，这意味着 Pandas 将从第 0 行获取标题。如果您打算重命名默认标题，则将header设置为0。
• name:这里您有机会覆盖默认的列标题。为此，首先设置header=0，然后传入一个数组，该数组包含您想要使用的新列名。

上面的 Python 片段重命名了原始 CSV 的头。我们在上面的例子中使用的 CSV 的副本可以在这里找到。

• index_col:对于不熟悉 DataFrame 对象的人来说，DataFrame 的每一行都有一个标签，称为索引。如果 CSV 文件包含表示索引的列，则可以传递列名或整数。或者，您可以通过False告诉 Pandas 不要使用您的文件中的索引。如果False通过，Pandas 将使用一系列递增的整数创建一个索引。
• usecols:您可以使用该参数返回文件中所有列的子集。默认情况下，usecols被设置为None，这将导致 Pandas 返回 DataFrame 中的所有列。当您只对处理某些列感兴趣时，这很方便。

• squeeze:当处理一个单列 CSV 文件时，您可以将该参数设置为True，这将告诉 Pandas 返回一个系列，而不是一个数据帧。如果对熊猫系列不熟悉，可以参考熊猫系列& DataFrame 讲解进行概述。
• prefix:如果你还没有指定要使用的列标签前缀，你可以在这里设置。当没有指定列时，默认行为是使用整数序列来标记它们。使用该参数，您可以将列0、1和2设置为column_0、column_1和column_2。

在上面的 Python 片段中，我们试图读取一个没有头文件的 CSV 文件。默认情况下，熊猫会添加数字列标签。在上面，我们已经用“column_”作为列的前缀。我们在这个例子中使用的 CSV 可以在这里找到。

• mangle_dupe_cols:如果您正在阅读的 CSV 文件包含同名的列，Pandas 将为每个重复的列添加一个整数后缀。将来mangle_dupe_cols将接受False，这将导致重复的列相互覆盖。
• dtype:您可以使用这个参数来传递一个字典，这个字典将列名作为键，数据类型作为它们的值。当您有一个以零填充的整数开头的 CSV 时，我发现这很方便。为每一列设置正确的数据类型也将提高操作数据帧时的整体效率。

上面我们已经确保了 employee_no 列将被转换为一个字符串。这还演示了保留前导零的能力，因为您会注意到数据集中的 job_no 没有被转换，因此丢失了前导零。数据集可以在这里找到。

• engine:目前熊猫接受c或python作为解析引擎。
• converters:这遵循与dtype相似的逻辑，但是，除了传递数据类型，您还可以传递在读取时操作特定列中的值的函数。

• true_values & false_values:这个参数挺俏皮的。例如，在您的 CSV 中，您有一个包含yes和no的列，您可以将这些值映射到True和False。这样做将允许您在将文件读入 Pandas 时清除一些数据。

上面的 Python 片段演示了如何定义 True & False 值。这里我们将 yes & maybe 设为 True，no 设为 False。此处可找到一个 CSV 示例。

• skipinitialspace:您可以将此参数设置为True，告诉熊猫分隔符后可能有前导空格的行。然后，Pandas 将删除分隔符之后和非分隔符之前的任何前导空格。
• skiprows:在处理系统生成的 CSV 文件时，有时文件的开头会包含参数行。通常我们不想处理这些行，而是跳过它们。您可以将skiprows设置为一个整数，表示在开始读取之前要跳过的行数。或者，您可以提供一个 callable，当函数计算结果为True时，它将导致 Pandas 跳过一行。
• skipfooter:类似于skiprows这个参数允许你告诉熊猫在文件的末尾要跳过多少行。同样，如果报告参数在 CSV 文件的末尾，这也很方便。
• nrows:您可以使用它来设置从 CSV 文件中收集的行数的限制。我发现在探索阶段，当试图对数据有所感觉时，这很方便。这意味着您可以测试您的逻辑，而不必将大文件加载到内存中。
• na_values:默认情况下，Pandas 有大量的值被映射到NaN(不是一个数字)。如果您有需要清理和映射的特定于应用程序的值，可以将它们传递给此参数。使用这个参数意味着您可以捕获所有的值，这些值都可以映射到一个默认的预处理。
• keep_default_na:该参数可以设置为True或False。如果False和 CSV 包含默认的NaN值，那么 Pandas 将保留原来的NaN值。如果True Pandas 将解析NaN值并在数据帧中用NaN屏蔽。
• na_filter:当您希望 Pandas 解释您的数据中缺失的值时，您可以将此设置为True。提示一下，当读取您知道没有任何丢失值的大文件时，将此参数设置为False。
• verbose:默认设置为False。将verbose设置为True将向控制台输出额外的数据，如NaN值的数量或特定过程花费的时间。
• 有时，我们收到的数据可能包含空行。通过将skip_blank_lines设置为True，Pandas 将跳过这些行，而不是将它们计为NaN值。
• parse_dates:使用这个参数告诉 Pandas 你希望 CSV 文件中的日期如何被解释。你可以通过True，这会让熊猫把索引解析成日期。或者，您可以传递 Pandas 将用来创建日期的列名或列列表。

上面的 Python 代码片段将第 0 列转换成索引，并将其解析为日期。用于本例的 CSV 文件可以在这里找到。运行上述脚本时，请注意针对日期时间格式对列 0 所做的更改。

• infer_datetime_format:您可以将此参数设置为True，它将告诉熊猫推断日期时间格式。当与parse_dates结合时，这样做将导致更大的处理速度。
• keep_date_col:如果您已经为parse_dates设置了一个值，您可以使用该参数来保留创建数据的列。默认行为是将这些列放到适当的位置。如果您不希望这种情况发生，请将keep_date_col设置为True。

• date_parser:如果您已经知道 CSV 中的日期格式，您可以传递一个函数给date_parser来有效地格式化日期时间，而不是推断格式。
• dayfirst:如果你的日期时间格式是DD/MM，则通过True。
• cache_dates:默认设置为True。Pandas 将创建一组独特的日期-时间字符串转换，以加快重复字符串的转换。
• iterator:将该参数设置为True将允许您调用 Pandas 函数.get_chunk()，该函数将返回要处理的记录数。
• chunksize:这将允许您设置数据帧内块的大小。这样做很方便，因为您可以循环数据帧的一部分，而不是将整个数据帧延迟加载到内存中。
• compression:如果您正在读取的数据在磁盘上被压缩，那么您可以设置动态解压缩的压缩类型。
• thousands:这是千位单位的分隔符。在 CSV 文件中，你有时可以看到用1_000_000表示的一百万，因为,被用作分隔符。将千设置为_将导致1_000_000反映为1000000。
• decimal:如果偏离.，您可以在 CSV 文件中提供代表小数的字符。
• lineterminator:如果你已经将engine设置为c，你可以用这个参数告诉熊猫你希望这些行以什么字符结束。
• quotechar:这是在整个 CSV 文件中使用的字符，表示引用元素的开始和结束。
• quoting:在这里你可以设置你想要应用到你的元素的报价级别。默认情况下，这是 0，将报价设置为最小；您也可以将其设置为 1-全部引用、2-引用非数字或 3-不引用。
• doublequote:当两个引号字符出现在一个引号元素中时，您可以使用这个参数告诉 Pandas 该做什么。当True通过时，双引号字符将变成单引号字符。
• escapechar:长度为一的字符串，熊猫将使用它来转义其他字符。
• comment:您可以使用该参数来表示您不想处理该行的剩余部分。例如，如果comment设置为#并且#出现在当前行中，熊猫到达#后将移动到下一行。
• encoding:如果您正在使用非英语的数据，请将此值设置为特定的字符编码，以便可以正确读取数据。
• dialect:CSV 方言是一组告诉 CSV 解析器如何读取 CSV 文件的参数。常见的方言有excel、excel-tab和unix另外，你可以自己创作，传给熊猫。
• error_bad_lines:如果 Pandas 遇到一个具有两个以上属性的行，通常会引发一个异常，Python 会暂停执行。如果将False传递给error_bad_lines，那么任何通常会引发此类异常的行将从数据帧中删除。
• warn_bad_lines:如果您已经将error_bad_lines设置为False，那么您可以将warn_bad_lines设置为True，这将输出每一行会引发异常的代码。
• delim_whitespace:这个参数与delimiter相似，但是它只针对空白。如果你想用空格作为分隔符，那么你可以将delimiter设置为\s+，或者将delim_whitespace设置为True。
• low_memory:默认情况下，Pandas 将此设置为True，这将导致分块处理，然而，存在不匹配类型推理的风险。通过确保设置了dtype参数，可以避免可能的类型不匹配。
• memory_map:如果你已经传递了一个文件给filepath_or_buffer Pandas 在内存中映射文件对象，以提高处理较大文件的效率。
• float_precision:您可以在这里为浮动元素的c引擎设置合适的转换器。
• storage_options:从远程位置读取 CSV 文件时，可以使用该参数传递特定选项。

接下来去哪里

摘要

作为一名数据分析师，学习如何使用 Pandas .read_csv()是一项至关重要的技能，可以将各种数据源结合起来。正如你在上面看到的,.read_csv()是一个非常强大和灵活的工具，你可以适应各种现实世界的情况来开始你的数据收集和分析。

感谢您花时间阅读我们的故事，我们希望您发现它很有价值。

Python 熊猫 vs. R Dplyr

原文：https://towardsdatascience.com/python-pandas-vs-r-dplyr-5b5081945ccb?source=collection_archive---------4-----------------------

完整的备忘单

图片由作者根据https://allisonhorst.github.io/的 Dplyr 标志和https://pandas.pydata.org/about/citing.html的熊猫标志制作

期待什么

对于许多数据科学家来说， Pandas for Python 和 Dplyr for R 是两个最流行的处理表格/结构化数据的库。关于哪个框架更好，总会有一些激烈的讨论。老实说，这真的重要吗？最后，这是关于完成工作，熊猫和 dplyr 都提供了很好的数据争论工具。**不用担心，这篇文章并不是另一个试图证明任何一个库的观点的比较！**因此，本条的目的是:

• 帮助其他人从一种语言/框架过渡到另一种语言/框架
• 探索可以作为数据科学家增加技能的新工具
• 创建一个参考备忘单，以防您需要查找两种语言中最常用的数据争论函数

数据

在本教程中，我们将使用 iris 数据集，它是 Pythons sklearn 和 base R 的一部分。

Sepal_length  Sepal_width  Petal_length     Petal_width  Species
          5.1         3.5           1.4             0.2   setosa
          4.9         3.0           1.4             0.2   setosa
          4.7         3.2           1.3             0.2   setosa
          4.6         3.1           1.5             0.2   setosa
          5.0         3.6           1.4             0.2   setosa

小抄

免责声明:长阅读

选择列

这里已经变得令人困惑了。首先，在每个框架中，如何从数据框架中选择列有多种方法。在 Pandas 中，您可以简单地传递带有列名的列表，或者使用 filter() 方法。这令人困惑，因为 dplyr 中的 filter() 函数用于根据条件而不是根据列对行进行子集化！在 dplyr 中，我们使用 select() 函数来代替:

熊猫

#Pass columns as list
dataframe[[“Sepal_width”, “Petal_width”]] #Use Filter Function
dataframe.filter(items=['Sepal_width', 'Petal_width'])

Dplyr

dataframe %>% select(Sepal_width, Petal_width)

基于条件的过滤

同样，有多种方法可以根据一列或多列的条件过滤数据帧中的记录。

熊猫

在 Pandas 中，你可以使用索引方法或者尝试方便的查询 API，这是我个人更喜欢的。

#indexing
dataframe[(dataframe["Sepal_width"] > 3.5) & (dataframe["Petal_width"] < 0.3)] #query API
dataframe.query("Sepal_width > 3.5 & Petal_width < 0.3")

Dplyr

在 dplyr 中过滤记录的标准方式是通过 filter 函数()。

dataframe %>% filter(Sepal_width > 3.5 & Petal_width < 0.3)

重命名单列

重命名听起来像是一个简单的任务，但是要小心，注意这里的细微差别。如果我们想在熊猫中将我们的列从物种重命名为类，我们提供一个字典，上面写着**{‘物种’:‘类’}，而在 Dplyr 中正好相反类=物种**:

熊猫

dataframe.rename(columns = {'Species': 'Class'}, inplace = True)

Dplyr

dataframe <- dataframe %>% rename(Class=Species)

根据条件重命名多个列

假设我们想根据一个条件一次重命名多个列。例如，将我们所有的特征列(萼片长度、萼片宽度、花瓣长度、花瓣宽度)转换为大写。在 Python 中，这实际上相当复杂，您需要首先导入另一个库，并手动迭代每一列。在 Dplyr 中，如果您想根据条件访问/更改多个列，有一个更简洁的界面。

熊猫

import re#prepare pattern that columns have to match to be converted to upper case
pattern = re.compile(r".*(length|width)")#iterate over columns and covert to upper case if pattern matches.
for col in dataframe.columns:
  if bool((pattern.match(col))):
    dataframe.rename(columns = {col: col.upper()}, inplace = True)

Dplyr

dataframe <- dataframe %>% rename_with(toupper, matches("length|width"))

结果

请注意大写特征列名:

SEPAL_LENGTH  SEPAL_WIDTH  PETAL_LENGTH     PETAL_WIDTH  Species
          5.1         3.5           1.4             0.2   setosa
          4.9         3.0           1.4             0.2   setosa

根据条件改变单元格值

假设我们想要基于条件重新编码/改变单元格值:在我们的示例中，我们将尝试将物种字符串“setosa，versicolor 和 virginica”重新编码为从 0 到 2 的整数:

熊猫

dataframe.loc[dataframe['Species'] == 'setosa', "Species"] = 0
dataframe.loc[dataframe['Species'] == 'versicolor', "Species"] = 1
dataframe.loc[dataframe['Species'] == 'virginica', "Species"] = 2

Dplyr

dataframe <- dataframe %>%
  mutate(Species = case_when(Species == 'setosa' ~ 0,
                             Species == 'versicolor' ~ 1,
                             Species == 'virginica' ~ 2))

每列的不同值

有时我们想看看一列中有哪些不同的/唯一的值。请注意这两个框架中的函数调用有多么不同:Pandas 使用 unique() 方法，dplyr()使用 distinct() 函数来获得相同的结果:

熊猫

dataframe.Species.unique()#array(['setosa', 'versicolor', 'virginica'], dtype=object)

Dplyr

dataframe %>% select(Species) %>% distinct()# Species   
# setosa    
# versicolor
# virginica

记录计数(每组)

如果您想计算数据帧中总共有多少个条目，或者获取某个组的计数，您可以执行以下操作:

熊猫

# Total number of records in dataframe
len(dataframe)#150 # Number of records per Group
dataframe.value_counts('Species')#Species
#virginica     50
#versicolor    50
#setosa        50# Note that you can also use the .groupby() method followed by size()
dataframe.groupby(['Species']).size() 

Dplyr

# Total number of records in dataframe
dataframe %>% nrow()#[1] 150 # Number of records per Group (count and tally are interchangeable)
dataframe %>% group_by(Species) %>% count()
dataframe %>% group_by(Species) %>% tally()#  Species        n
#  <fct>      <int>
#1 setosa        50
#2 versicolor    50
#3 virginica     50

对整个列进行汇总/聚合

如果要为数据框中的一列或多列创建描述性统计数据，可执行以下操作:

熊猫

#get mean and min for each column
dataframe.agg(['mean', 'min'])#      Sepal_length  Sepal_width  Petal_length  Petal_width Species
#mean      5.843333     3.057333         3.758     1.199333     NaN
#min       4.300000     2.000000         1.000     0.100000  setosa

Dplyr

不幸的是，我没有找到如何一次在多个列上使用多个聚合函数的方法。这就是为什么您需要多次调用 summarise 函数来获得相同的结果:

#first aggregation over all columns using mean
dataframe %>% summarise(across(everything(), mean))#  Sepal_length Sepal_width Petal_length Petal_width Species
#         5.84        3.06         3.76        1.20      NA#second aggregation over all columns using min
dataframe %>% summarise(across(everything(), min))#Sepal_length Sepal_width Petal_length Petal_width Species
#        5.84        3.06         3.76        1.20      NA

按组汇总/汇总

如果想要在数据集中按组聚集统计数据，必须使用 Pandas 中的 groupby() 方法和 Dplyr 中的 group_by() 函数。您可以对所有列或特定列执行此操作:

熊猫

请注意 Pandas 如何使用多级索引来清晰地显示结果:

# aggregation by group for all columns
dataframe.groupby(['Species']).agg(['mean', 'min'])#                 Sepal_length      Sepal_width       ...
#                   mean  min        mean min         ...
#Species                                                         
#setosa            5.01  4.3       3.43             ...
#versicolor        5.94  4.9       2.77             ...
#virginica         6.59  4.9       2.97             ... # aggregation by group for a specific column
dataframe.groupby(['Species']).agg({'Sepal_length':['mean']})#   Sepal_length
#                   mean
#Species                
#setosa            5.01
#versicolor        5.94
#virginica         6.59

Dplyr

由于 Dplyr 不支持多级索引，所以第一次调用的输出与 Pandas 相比看起来有点乱。在此输出中，显示了第一个函数的统计数据(mean-fn1)，然后是第二个函数的统计数据(min-fn2)。

# aggregation by group for all columns
dataframe %>% group_by(Species) %>% summarise_all(list(mean,min))Species    Sepal_length_fn1  Sepal_width_fn1         ...
setosa                 5.01            3.43          ...
versicolor             5.94            2.77          ...         
virginica              6.59            2.97          ... # aggregation by group for a specific column
dataframe %>% group_by(Species) %>% summarise(mean=mean(Sepal_length))#Species     mean
# setosa      5.01
# versicolor  5.94
# virginica   6.59

列数学/添加新列

有时，您希望创建一个新列，并通过某种数学运算将两个或多个现有列的值组合起来。以下是如何在熊猫和 Dplyr 中做到这一点:

熊猫

dataframe["New_feature"] = dataframe["Petal_width"]* dataframe["Petal_length"] / 2

Dplyr

dataframe <- dataframe %>% mutate(New_feature= Petal_width*Petal_length/2)

删除列

为了清理数据帧，删除列有时会非常方便:

熊猫

在 Pandas 中，你可以用 drop() 删除一列。您也可以使用 inplace=True 来覆盖当前数据帧。

dataframe.drop("New_feature", axis=1, inplace=True)

Dplyr

在 Dplyr 中，您可以在 select()函数中使用前导的减号来指定要删除的列名。

dataframe <- dataframe %>% select(-New_feature)

按值对记录排序

要对值进行排序，您可以在 Pandas 中使用 sort_values() ，在 Dplyr 中使用 arrange() 。两者的默认排序都是升序。请注意每个函数调用在降序排序方面的差异:

熊猫

dataframe.sort_values('Petal_width', ascending=0)

Dplyr

dataframe %>% arrange(desc(Petal_width))

重命名单列

重命名听起来像是一个简单的任务，但是要小心，注意这里的细微差别。如果我们想在 Pandas 中将我们的列从 Species 重命名为 Class ，我们提供一个字典，上面写着 {'Species': 'Class'} ，而在 Dplyr 中，情况正好相反 Class=Species :

熊猫

dataframe.rename(columns = {'Species': 'Class'}, inplace = True)

Dplyr

dataframe %>% relocate(Species)
dataframe %>% relocate(Species, .before=Sepal_width)

更改列的顺序

我不经常使用这个功能，但是如果我想为一个演示创建一个表格，并且列的排序没有逻辑意义，这个功能有时会很方便。以下是如何移动列:

熊猫

在 Python Pandas 中，您需要通过使用列表来重新索引您的列。假设我们想将列物种移到前面。

#change order of columns
dataframe.reindex(['Species','Petal_length','Sepal_length','Sepal_width','Petal_Width'], axis=1)

Dplyr

在 Dplyr 中，您可以使用方便的 relocate() 函数。同样，假设我们想将列物种移到前面。

dataframe %>% relocate(Species)#Note that you can use .before or .after to place a columne before or after another specified column - very handy!
dataframe %>% relocate(Species, .before=SEPAL_WIDTH)

限幅

切片本身就是一个完整的主题，有很多方法可以实现。下面让我们来看一下最常用的切片操作:

按行切片

有时您知道想要提取的确切行号。虽然 Dplyr 和 Pandas 中的过程非常相似**，但是请注意 Python 中的索引从 0 开始，而 R 中的索引从 1 开始。**

熊猫

dataframe.iloc[[49,50]]#  Sepal_length  Sepal_width  Petal_length  Petal_width    Species
#          5.0          3.3           1.4          0.2      setosa
#          7.0          3.2           4.7          1.4  versicolor

Dplyr

dataframe %>% slice(50,51)#  Sepal_length Sepal_width Petal_length Petal_width Species     
#1            5         3.3          1.4         0.2 setosa    
#2            7         3.2          4.7         1.4 versicolor

分割第一个和最后一个记录(头/尾)

有时我们希望看到数据帧中的第一条或最后一条记录。这可以通过提供一个固定数量 n 或一个比例 prop 值来实现。

熊猫

在 Pandas 中，您可以使用 head() 或 tail() 方法来获取固定数量的记录。如果你想提取一个比例，你必须自己计算一下:

#returns the first 5 records
dataframe.head(n=5)#returns the last 10% of total records
dataframe.tail(n=len(dataframe)*0.1)

Dplyr

在 Dplyr 中，有两个为这个用例指定的函数: slice_head() 和 slice_tail() 。请注意如何指定固定数量或比例:

#returns the first 5 records
dataframe %>% slice_head(n=5)#returns the last 10% of total records
dataframe %>% slice_tail(prop=0.1)

按值对第一条和最后一条记录进行切片

有时，选择每列具有最高或最低值的记录很有用。同样，这可以通过提供固定的数量或比例来实现。

熊猫

对于熊猫来说，这比 Dplyr 更棘手。例如，假设您想要 20 个具有最长“花瓣长度”的记录，或者 10%的总记录具有最短的“花瓣长度”。要在 Python 中进行第二个操作，我们必须做一些数学计算，首先对我们的值进行排序:

#returns 20 records with the longest Petal_length (for returning the shortest you can use the function nsmallest)
dataframe.nlargest(20, 'Petal_length')#returns 10% of total records with the shortest Petal_length
prop = 0.1 
dataframe.sort_values('Petal_length', ascending=1).head(int(len(dataframe)*prop))

Dplyr

在 Dplyr 中，这要简单得多，因为此用例有指定的函数:

#returns 20 records with the longest Petal_length
dataframe %>% slice_max(Petal_length, n = 20)#returns 10% of total records with the shortest Petal_lengthdataframe %>% slice_min(Petal_length, prop = 0.1)

按值和组对第一条和最后一条记录进行切片

有时，选择每列具有最高或最低值的记录**，但由组**分隔，这很有用。同样，这可以通过提供固定的数量或比例来实现。想象一下，例如我们想要 3 个每个物种花瓣长度最短的记录。

熊猫

对熊猫来说，这也比 Dplyr 更棘手。我们首先按照物种对数据帧进行分组，然后应用一个 lambda 函数，该函数利用了上述的 nsmallest() 或 nlargest() 函数:

#returns 3 records with the shortest Petal_length per Species
(dataframe.groupby('Species',group_keys=False)
        .apply(lambda x: x.nsmallest(3, 'Petal_length')))#Sepal_length  Sepal_width  Petal_length  Petal_width     Species
#        4.6          3.6           1.0          0.2      setosa
#        4.3          3.0           1.1          0.1      setosa
#        5.8          4.0           1.2          0.2      setosa
#        5.1          2.5           3.0          1.1  versicolor
#        4.9          2.4           3.3          1.0  versicolor
#        5.0          2.3           3.3          1.0  versicolor
#        4.9          2.5           4.5          1.7   virginica
#        6.2          2.8           4.8          1.8   virginica
#        6.0          3.0           4.8          1.8   virginica#returns 5% of total records with the longest Petal_length per Species
prop = 0.05
(dataframe.groupby('Species',group_keys=False)
        .apply(lambda x: x.nlargest(int(len(x) * prop), 'Petal_length')))#Sepal_length  Sepal_width  Petal_length  Petal_width     Species
#         4.8          3.4           1.9          0.2      setosa
#         5.1          3.8           1.9          0.4      setosa
#         6.0          2.7           5.1          1.6  versicolor
#         6.7          3.0           5.0          1.7  versicolor
#         7.7          2.6           6.9          2.3   virginica
#         7.7          3.8           6.7          2.2   virginica

Dplyr

在 Dplyr 中，这要简单得多，因为这个用例有指定的函数。注意如何提供 with_ties=FALSE 来指定是否应该返回 ties(具有相等值的记录)。

#returns 3 records with the shortest Petal_length per Species
dataframe %>% group_by(Species) %>% slice_min(Petal_length, n = 3, with_ties = FALSE)#returns 5% of total records with the longest Petal_length per Species
dataframe %>% group_by(Species) %>% slice_max(Petal_length, prop = 0.05, with_ties=FALSE)

切片随机记录(每组)—抽样

对随机记录进行切片也可以称为抽样。这也可以通过证明一个固定的数字或比例来实现。此外，这可以在整个数据集上进行，也可以基于组*均分布。因为这是一个相当频繁的用例，所以在两个框架中都有这样的函数:

熊猫

在 Pandas 中，您可以使用 sample() 函数，或者指定 n 为固定数量的记录，或者指定 frac 为一定比例的记录。此外，您可以指定替换来允许或不允许对同一行进行多次采样。

#returns 20 random samples
dataframe.sample(n=20)#return 20% of total records
dataframe.sample(frac=0.2, replace=True)#returns 10% of total records split by group
dataframe.groupby('Species').sample(frac=0.1)

Dplyr

Dplyr 中的界面非常相似。您可以使用 slice_sample() 函数，或者为固定数量的记录指定 n ，或者为一定比例的记录指定 prop 。此外，您可以指定替换以允许或不允许对同一行进行多次采样。

#returns 20 random samples
dataframe %>% slice_sample(n=20)#return 20% of total records
dataframe %>% slice_sample(prop=0.2, replace=True)#returns 10% of total records split by group
dataframe %>% group_by(Species) %>% slice_sample(prop=0.1)

连接

连接数据框架也是一个常见的用例。(join 操作范围很广，但我不打算在此详述)

但是，随后您将学习如何在 Pandas 和 Dplyr 中执行完全(外部)连接。

图像您有两个共享一个公共变量“key”的数据帧:

#Python Pandas
A = dataframe[[“Species”, “Sepal_width”]]
B = dataframe[[“Species”, “Sepal_length”]]#R Dplyr:
A <- dataframe %>% select(Species, Sepal_width)
B <- dataframe %>% select(Species, Sepal_length)

熊猫

#Join dataframe A and B (WHAT), with a full join (HOW) by making use of the key "Species" (ON) 
pd.merge(A, B, how="outer", on="Species")

Dplyr

在 Dplyr 中，语法非常相似，但是，对于每种连接类型，都有单独的函数。在本例中，我们将再次使用 full_join() 函数执行完全连接:

#Join dataframe A and B (WHAT), with a full join (HOW) by making use of the key "Species" (ON)
A %>% full_join(B, by="Species")

连接/绑定行和列

有时我们不想连接我们的数据帧，而只是通过行或列附加两个现有的数据帧。熊猫和 Dplyr 都有一个很好的界面来实现这一点:

熊猫

在 Pandas 中，可以用 concat() 方法连接两个数据帧。默认值按行连接数据帧。通过指定轴(例如轴= 1)，可以通过列连接两个数据帧。

请注意，如果某个值没有出现在其中一个数据帧中，它会自动填充 NA。

#Concatenate by rows
pd.concat([A,B])#       Species  Sepal_width  Sepal_length
#0       setosa          3.5           NaN
#1       setosa          3.0           NaN
#2       setosa          3.2           NaN
#3       setosa          3.1           NaN
# ... #Concatenate by columns 
pd.concat([A,B], axis=1)#       Species  Sepal_width    Species  Sepal_length
#0       setosa          3.5     setosa           5.1
#1       setosa          3.0     setosa           4.9
#2       setosa          3.2     setosa           4.7
#3       setosa          3.1     setosa           4.6
# ...

Dplyr

在 Dplyr 中，有两个独立的函数用于绑定数据帧: bind_rows() 和 bind_columns()。

请注意，如果某个值没有出现在其中一个数据帧中，那么在应用 bind_rows()时，它会自动填充 NA。另外，请注意 R 如何自动更改列名(以避免重复)。使用可以改变这种行为。name_repair 参数。

#Bind by rows
A %>% bind_rows(B)#   Species Sepal_width Sepal_length
# 1 setosa          3.5           NA
# 2 setosa          3             NA
# 3 setosa          3.2           NA
# 4 setosa          3.1           NA
# ...#Bind by columns
A %>% bind_cols(B)#  Species...1 Sepal_width Species...3 Sepal_length
# 1 setosa              3.5 setosa               5.1
# 2 setosa              3   setosa               4.9
# 3 setosa              3.2 setosa               4.7

Pfew！恭喜你！你可能是第一个读到这篇文章/备忘单结尾的人。您可以通过给我鼓掌或在下面给我留言来获得奖励:)

图片来自 Giphy

Python 并行性:几分钟内加速 Python 代码的基本指南

原文：https://towardsdatascience.com/python-parallelism-essential-guide-to-speeding-up-your-python-code-in-minutes-5ec71cbd88e1?source=collection_archive---------18-----------------------

Python 多重处理基本指南。

照片由 Wexor Tmg 在 Unsplash 拍摄

按顺序执行任务可能不是一个好主意。如果第二个任务的输入不是第一个任务的输出，那么你就在浪费时间和 CPU。

你可能知道，Python 的 全局解释器锁 (GIL)机制一次只允许一个线程执行 Python 字节码。这是一个严重的限制，可以通过更改 Python 解释器或实现基于进程的并行技术来避免。

今天，您将学习如何使用 Python 和concurrent.futures库并行执行任务。您将通过一个实际例子理解这个概念——从多个 API 端点获取数据。

这篇文章的结构如下:

• 问题描述
• 测试:按顺序运行任务
• 测试:并行运行任务
• 结论

你可以在这里下载这篇文章的源代码。

问题描述

目标是连接到jsonplaceholder.typicode.com——一个免费的假 REST API。

您将连接到几个端点并获取 JSON 格式的数据。总共会有六个端点。不是很多，Python 很可能在一秒钟左右完成任务。对于演示多处理能力来说不太好，所以我们将增加一些趣味。

除了获取 API 数据，程序还会在发出请求之间休眠一秒钟。由于有六个端点，程序应该在六秒钟内什么都不做——但是只有当调用按顺序执行时。

我们先测试一下没有并行的执行时间。

测试:按顺序运行任务

让我们看一下整个脚本，并对其进行分解:

在URLS变量中存储了一个 API 端点列表。你将从那里获取数据。在它下面，你会发现fetch_single()功能。它向一个特定的 URL 发出 GET 请求，然后休眠一秒钟。当获取开始和完成时，它也打印。

该脚本记下开始和结束时间，并将它们相减以获得总执行时间。在来自URLS变量的每个 URL 上调用fetch_single()函数。

运行该脚本后，您将在控制台中获得以下输出:

图 1-没有多重处理脚本输出(作者提供的图片)

简而言之，这就是顺序执行。这个脚本在我的机器上花了大约 7 秒钟完成。你可能会得到几乎相同的结果。

接下来让我们看看如何使用并行性来减少执行时间。

测试:并行运行任务

让我们看一下脚本，看看有什么变化:

concurrent.futures库用于实现基于进程的并行性。URLS和fetch_single()都是一样的，所以没有必要再重复一遍。

下面才是有趣的地方。你必须使用ProcessPoolExecutor类。根据文档，它是一个使用进程池异步执行调用的类[1]。

这里的with语句是为了确保在任务完成后所有的东西都被清理干净。

可以使用submit()函数来传递想要并行执行的任务。第一个参数是函数名(确保不要调用它)，第二个参数是 URL 参数。

运行该脚本后，您将在控制台中获得以下输出:

图 2 —多重处理脚本输出(图片由作者提供)

执行时间仅用了 1.68 秒，比之前有了显著的提高。这是任务并行运行的具体证明，因为顺序执行无法在 6 秒内完成(睡眠调用)。

结论

这就是关于 Python 基于流程的并行性的最基本指南。还有其他基于并发性的方法来加速您的脚本，这些将在下面的文章中介绍。

如果你想看更多高级并行教程，请告诉我。这些将涵盖数据科学和机器学习中的真实用例。

感谢阅读。

https://medium.com/@radecicdario/membership

了解更多信息

• 每个数据科学家必读的 3 本编程书籍
• 如何让 Python 静态类型化——基本指南
• 用 Python 进行面向对象编程——你需要知道的一切
• Python 字典:你需要知道的一切
• 介绍 f 字符串 Python 中字符串格式化的最佳选项

参考

[1]https://docs.python.org/3/library/concurrent.futures.html

Python 解析库:反转 F 字符串的简单方法

原文：https://towardsdatascience.com/python-parse-library-simple-way-for-reversing-f-strings-72ad4d59e7c4?source=collection_archive---------10-----------------------

我们有时需要反过来。

马修·斯特恩在 Unsplash 上的照片

字符串插值是使用占位符修改字符串的过程。结果字符串包括占位符的值。在 Python 中，format 方法和 f 字符串是两种常用的字符串插值方法。

在跳到解析库之前，做几个例子来演示什么是字符串插值是有帮助的。

folder = "notebook"
subfolder = "parse"file_path = f"documents/{folder}/{subfolder}"print(file_path)
documents/notebook/parse

占位符用花括号表示，它们的值包含在输出中。

这是另一个例子。

name = "John"
age = "23"print(f"{name} is {age} years old.")
John is 23 years old.

我们现在更熟悉 f 弦和一般意义上的弦插值。解析库所做的是字符串插值过程的逆过程。

可以使用解析库提取字符串中的值。我们将做几个例子来解释清楚这个过程。

解析库可以很容易地与 pip 一起安装。如果你用的是 jupyter 笔记本，就加“！”在匹普之前。

!pip install parse

从语法上分析

在第一个示例中，我们使用预定义的文件夹和子文件夹名称创建了一个文件路径。让我们使用解析库从路径中获取文件夹名。我们首先需要从解析库中导入解析函数。

from parse import parsefile_path = "documents/notebook/pandas"parse("documents/{folder}/{subfolder}", file_path)
<Result () {'folder': 'notebook', 'subfolder': 'pandas'}>

我们传递文件路径以及表示占位符的字符串。parse 函数返回一个结果对象，但是我们可以通过添加命名方法使它看起来更漂亮。

parse("documents/{folder}/{subfolder}", file_path).named
{'folder': 'notebook', 'subfolder': 'pandas'}

假设我们有一个格式相同的路径列表，我们需要提取文件夹和子文件夹的名称。这个任务可以通过解析器功能和列表理解的完美结合来轻松完成。

file_paths = [
    "documents/notebook/pandas",
    "documents/notebook/parse",
    "documents/notes/python"
][parse("documents/{folder}/{subfolder}", path).named for path in file_paths][{'folder': 'notebook', 'subfolder': 'pandas'},
 {'folder': 'notebook', 'subfolder': 'parse'},
 {'folder': 'notes', 'subfolder': 'python'}]

搜索

解析库还提供了一些其他函数，在特殊情况下会很方便。例如， search 函数在字符串中查找某种格式。因此，我们不必提供整个字符串的确切格式。

from parse import searchtxt = "Name: Jane, Department: Engineering, Age: 22"search("Name: {Name},", txt).named
{'Name': 'Jane'}

当我们不确定确切的字符串时，也可以使用搜索功能。因此，它提供了额外的灵活性。

考虑以下字符串:

txt = "The department of civil engineering has 23 employees"
txt2 = "The civil engineering department has 23 employees"

我们需要找到文本中雇员的数量。我们可以用同样的子模式找到它。

search("has {number_of_employees} employees", txt).named
{'number_of_employees': '23'}search("has {number_of_employees} employees", txt2).named
{'number_of_employees': '23'}

芬达尔

解析库中另一个有用的函数是 findall 函数。如果有多个我们感兴趣的相同模式的部分，我们可以使用 findall 而不是 parse。

以下示例显示了 findall 函数的一种可能用法。

from parse import findallpaths = "documents/notebook/pandas/ documents/notebook/parse/ documents/notes/python/"findall("documents/{folder}/{subfolder}/", paths)
<parse.ResultIterator at 0x2056556ab80>

我们有一个很长的字符串，其中包含多个格式相同的文件路径。findall 函数，顾名思义，查找给定路径结构的所有文件夹和子文件夹名称。

默认情况下，它返回一个迭代器，但我们可以很容易地将其转换成一个列表。

list(findall("documents/{folder}/{subfolder}/", paths))[<Result () {'folder': 'notebook', 'subfolder': 'pandas'}>,
 <Result () {'folder': 'notebook', 'subfolder': 'parse'}>,
 <Result () {'folder': 'notes', 'subfolder': 'python'}>]

该列表包含 3 个结果对象。我们可以将命名方法分别应用于这些对象。

a = list(findall("documents/{folder}/{subfolder}/", paths))a[0].named
{'folder': 'notebook', 'subfolder': 'pandas'}

结论

Parse 是一个非常实用的函数库。正如我们在示例中看到的，它提供了在字符串中查找模式和值的简单方法。某种意义上是字符串插值的逆向运算。

还有其他方法来执行相同的任务。例如，本文中的例子也可以用 regex 来完成。但是，对于某些操作来说，正则表达式可能太复杂了。我觉得解析库提供了更简单的解决方案。

如果你想了解更多关于解析库的知识，请随意访问官方文档。

感谢您的阅读。如果您有任何反馈，请告诉我。

带寄存器的 Python 多态性| Python 模式

学习一种模式来隔离包，同时扩展 Python 代码的功能。

照片由 N. 在 Unsplash 上拍摄

动态多态是面向对象编程最强大的特性，它允许我们针对那些实际行为只在运行时定义的抽象进行编程。根据 Robert C. Martin 的说法，这也是真正定义 OOP 的唯一特性。

多态性由两部分组成:具有类型相关实现的方法和类型不可知的方法调用。在 python 代码中:

class TypeA:
  def speak(self):
    print("Hello, this is an object of type TypeA")class TypeB:
  def speak(self):
    print("Greetings from type TypeB")def agnostic_speak(speaker):
  speaker.speak()agnostic_speak(TypeA())
agnostic_speak(TypeB())>> Hello, this is an object of type TypeA
   Greetings from type TypeB

这个简单的例子展示了多态方法 speak()和调用它的通用函数，而不知道调用该方法的对象的实际类型。

对于这样一个简单的例子，一个基于参数类型的条件语句(if/else)可以完成这个任务，但是它也有缺点。首先，条件代码使得函数更难阅读。在这个版本中，我们立即看到它做了什么，它让一个对象说话，而对于条件代码，我们需要首先理解不同的分支做什么。此外，如果将来我们想要添加更多的说话方式，我们将需要返回到这个函数并修改它以添加新的分支。反过来，新的分支将使代码越来越不可读。

假设我们有一个文本分类应用程序，它在输入中接收一行文本，并输出一个代表其主题的标签。像任何好的机器学习项目一样，我们在不同的模型上执行许多迭代，我们希望我们的代码使用它们。当然，我们不希望一个大的 switch 语句(if-elif-elif-…-else)带有运行任何单一模型的逻辑！

出于示例的原因，所有模型共享相同的输入/输出词汇表，即相同的映射 word->input index 和 output index->label。唯一的区别在于底层模型所执行的操作。

在我们代码的第一个版本中，我们只有两个模型架构:一个前馈网络和一个 LSTM 网络，它们提供多态的 forward() 方法来封装每个模型的逻辑:

# main.py
from models import FfModel, LstmModeldef main(args):
  model_type = args.model_type
  model_path = args.model_path
  if model_type == "ff":
    model = FfModel(model_path)
  elif model_type == "lstm":
    model = LstmModel(model_path)
  else:
    raise NotImplementedError("Unrecognizer type %s" % model_type) outputs = [] with open(args.input_text, 'r') as fid:
    for line in fid:
      word_ids = convert_to_id(tokenize(line)) 
      output = model.forward(word_ids)
      outputs.append(convert_to_labels(output)) show_results(outputs)

该代码包含许多未定义的函数，以便让我们专注于本文的相关部分。在这个片段中，我们可以看到模型类型是由用户提供的参数。它用于选择哪种模型类型，由一个类表示，应该用来加载和使用我们保存的模型。注意，这两个类都被导入到主文件中。在代码片段的后半部分，我们有对 forward 的多态调用，它根据深度学习模型的类型正确地执行深度学习模型操作。最后，我们有在文本和不依赖于模型的神经网络格式之间转换输入和输出的函数。

这段代码片段成功地提供了多态行为，但它显然打破了软件设计的坚实原则之一的开/闭原则。这个原则规定我们的程序应该对扩展开放，但对修改关闭。

在实践中，这意味着每当我们想在程序中添加一个新的模型类型时，我们必须为该类型创建一个新的类，然后将其导入 main.py，最后在 if/else 语句中为其添加一个新的分支。我们的程序对扩展开放，但也对修改开放。如果我们想将允许的类型添加到我们的软件帮助中，这样用户就可以很容易地发现它们。每当我们添加一个新的类型时，我们也应该把它的名字添加到允许的类型列表中，否则会给用户带来很大的困扰。

改进上述代码的第一种方法是用一个函数替换条件分支，该函数将模型类型及其路径作为输入，并返回构建的对象(类似于工厂方法)。上面的代码将变成:

# main.py
from models import model_factorydef main(args):
  model_type = args.model_type
  model_path = args.model_path model = model_factory(model_type, model_path)

  outputs = [] with open(args.input_text, 'r') as fid:
    for line in fid:
      word_ids = convert_to_id(tokenize(line)) 
      output = model.forward(word_ids)
      outputs.append(convert_to_labels(output)) show_results(outputs)

现在模型选择被移动到 init。模型包的 py 文件，在这里我们还用对字典的调用替换了条件代码:

# models.__init__.py
__all__ = ["factory_method"]from .ff_model import FfModel
from .lstm_model import LstmModel__MODEL_DICT__ = {
  "ff": FfModel,
  "lstm": LstmModel
}def factory_method(model_type, model_path):
  return __MODEL_DICT__[model_type](model_path)

这里我们只导出 factory_method，它从字典中选择正确的类型名(在 python 中是用于创建该类型对象的工厂),构建一个对象并将其返回给调用者。字典是将条件代码简化为线性流的简单有效的方法。

有了这段代码，我们的主文件就可以忽略现有的模型类型，我们可以添加或删除类，而根本不用修改主文件。然而，我们只是将开放修改代码从 main.py 移到了这个新的 __init.py 文件中。我们通过将主文件与可能的模型修改隔离开来，实现了改进，但是 init 中的代码。出于同样的原因，py 仍然可以修改。

我们能做得比这更好吗？当我们添加一个新的模型类型时，我们可以用这样的方式编写代码吗？我们只需添加新的类和一个名称来标识它，这样就足以将它添加到 MODEL_DICT 字典中了。

事实证明，这不仅在 python 中是可能的，而且只需要一堆代码就可以实现。该机制由两部分组成:

1. **类发现:**一种无需为类编写显式导入语句即可导入类的算法。
2. **注册:**被发现的类自动调用的函数，被添加到字典中，如 MODEL_DICT

让我们轮流看他们。

自动发现

我们如何导入类而不为它们或者甚至包含它们的文件(模块)写一个显式的导入呢？或者更根本地说，在给定这些约束的情况下，我们如何让 Python 解释器在运行时知道它们？

这个解决方案是通过 importlib 包中的 import_module 函数实现的。来自 importlib 官方文档:

[…]实现[import](https://docs.python.org/3/reference/simple_stmts.html#import)的组件在这个包中公开，使得用户更容易创建他们自己的定制对象(一般称为导入器)来参与导入过程。

正是我们需要的！让我们看看可以添加到 init 中的代码。py 使它成为我们模型类的自定义导入器:

# Iterate all files in the same directory
for file in os.listdir(os.path.dirname(__file__)):                                 
  # Exclude __init__.py and other non-python files
  if file.endswith('.py') and not file.startswith('_'):
    # Remove the .py extension  
    module_name = file[:-len('.py')]     
    # Assume src to be the name of the source root directory                              
    importlib.import_module('models.' + module_name)

通过这四行代码，我们的软件自动导入模型包中的所有模块。当一个模块被导入时，它的代码被执行，所以我们的下一步是实现一个机制，让我们的类把它们自己添加到我们的 MODEL_DICT。

子类注册

第一种方法修改了初始化子类的 Python 机制。幸运的是，Python 公开了在第一次执行类定义时调用的方法 init_sub_class。每个类都自动调用父类的 init_sub_class 并将其类型作为参数。因此，我们可以在父类中集中注册新类的逻辑:

# models.model.py__MODEL_DICT__ = dict()class Model:
  def __init_sub_class__(cls, **kwargs):
    assert "name" in kwargs
    super().__init_sub_class__()
    if kwargs["name"] in __MODEL_DICT__:
      raise ValueError("Name %s already registered!" % name)
    __MODEL_DICT__[kwargs["name"]] = cls

init_sub_class 接受一个名为 cls 的参数作为输入，这是类类型参数的 Python 约定，以及存储在 kwargs 附加库中的任意数量的键值对。我们首先检查 "name" 是否作为一个键存在于附加参数中，因为如果我们不知道用哪个名字注册一个类，我们就不能在字典中注册它。然后，如果以前没有注册过具有该名称的类，只需将它添加到字典中，否则程序会退出并显示一个错误，通知用户存在重复。

现在，我们只需要每个子类将其名称作为附加参数传递给 init_sub_class。这不是通过直接调用函数来完成的，而是在定义父类时完成的:

# models.ff_model.py
from .model import Modelclass FfModel(Model, name="ff"):
  def __init__(self, *args, **kwargs):
    # Construct object def forward(self, x):
    # Operations for computing output probabilities of x

类实现不知道注册过程，它只通过父类名旁边的赋值 name="ff "出现。该赋值以及您可能愿意添加的任何其他赋值将构成模型 init_sub_class 的**kwargs。

同样，对于 LstmModel:

# models.lstm_model.py
from .model import Modelclass LstmModel(Model, name="lstm"):
  def __init__(self, *args, **kwargs):
    # Construct objectdef forward(self, x):
    # Operations for computing output probabilities of x

在 init 时。py 我们需要执行发现代码并公开一个工厂方法来访问字典

# __init__.py
__all__ == ["factory_method"] import os
import importlibfrom models.model import Model, __MODEL_DICT__ def factory_method(name, path):
    return __MODEL_DICT__[name](path)

for file in os.listdir(os.path.dirname(__file__)):
    if file.endswith('.py') and not file.startswith('_'):
        module_name = file[:file.find('.py')]
        module = importlib.import_module('models.' + module_name)

寄存器功能

第二种方法是定义一个包装我们的类的“注册”函数。register 函数的内部工作有点复杂，所以请原谅我。当包含由我们的注册函数包装的类的模块第一次被执行时，它用它的参数运行包装函数。包装函数定义了一个内部函数，该函数将一个类类型作为输入，并对其进行处理。此外，内部函数可以访问包装函数中的变量，因为它是一个闭包。register 函数简单地返回它的内部函数，这个内部函数又以包装的类类型作为它的输入被立即执行。内部函数是实际注册类的函数，然后返回将由 python 解释器添加到当前名称空间的类类型。

这个过程在 init 之间再次拆分。py 文件和包含实际类的模块文件。

# models.__init__.py
__all__ = ["factory_method"]

import os
import importlib

from .model import Model

def factory_method(name):
    return __MODEL_DICT__[name]

__MODEL_DICT__ = dict()

def register_function(name):

    def register_function_fn(cls):
        if name in __MODEL_DICT__:
            raise ValueError("Name %s already registered!" % name)
        if not issubclass(cls, Model):
            raise ValueError("Class %s is not a subclass of %s" % (cls, Model))
        __MODEL_DICT__[name] = cls
        return cls

    return register_function_fn

for file in os.listdir(os.path.dirname(__file__)):
    if file.endswith('.py') and not file.startswith('_'):
        module_name = file[:file.find('.py')]
        module = importlib.import_module('models.' + module_name)

同样， factory_method 是我们的 main 调用的函数，它基本上是我们字典的包装器。请注意，在我们的内部 register_function_fn 中，我们可以执行我们通常可以在任何函数中执行的任何操作，因此我们额外检查了给定的类是 Model 的子类。这是保持基于层次结构的多态性所必需的，因为我们不能保证 register 类确实是一个模型。

另一种可能的检查可以基于鸭类型，并且将检查类中是否存在转发方法，而不是检查其类型。python 的动态性也允许我们不执行任何检查，但是当我们使用 buggy 模型时，这种勇敢会导致令人讨厌的错误出现。相比之下，在我们的注册机制中插入检查将在每次运行程序时检查所有模型的一致性。在静态类型语言中，这种检查是由类型检查器执行的，而 Python 为我们提供了更多的动态性，但也为我们清理自己的混乱提供了更多的责任。

现在，我们只需要使用 register_function 作为我们的类的装饰器，以使它的功能如上所述:

# models.ff_model.py
from models.model import Model @register_function("ff")
class FfModel(Model):
  def __init__(self, *args, **kwargs):
    # Construct object def forward(self, x):
    # Operations for computing output probabilities of x

通过使用 register_function 作为装饰器，注册机制在类的外部，因此它可以完成它的工作，然后模型类不需要任何关于注册的代码。

该示例的工作方式如下:

• register_function 以*“ff”*作为唯一参数被调用
• 它返回 register_function_fn 封闭绑定 name="ff"
• 用 cls=FfModel 调用寄存器 _ 函数 _fn
• register_function_fn 在我们的 MODEL_DICT 中注册键值对*“ff”= FfModel*，并将 ff MODEL 返回给解释器
• 现在可以通过函数 factory_method() 在应用程序中使用 FfModel，并且不需要显式导出。

第一次很难掌握像这样的注册功能的工作原理，主要是因为所有的操作都是在启动阶段执行的。然而，如果你能遵循上面的解释，你将最终掌握一个强大的工具，它的应用远远超出了这个例子。

与前面的解决方案相比，register 函数的难度为我们带来了更多的灵活性，因为它没有将我们限制在类的层次结构中，也可以用于函数而不是类。此外，从单一责任原则 (SRP)的角度来看，这段代码更好，因为注册子类的责任被交给了一个只负责注册子类的函数，而不是父模型类。

结论

类发现是一个强大的工具，它通过 Python 项目的两个组件之间的抽象接口提供多态行为。

最终的设计在不同的包之间有更少的显式依赖，而在同一个包内有更多的依赖。然后，它强制不同包及其内部内聚性的解耦。

此外，我们还看到了这种模式是如何产生更加尊重可靠原则的代码的。

当一个包主要由相同层次结构中的类组成时，我推荐使用它，这样就可以用不同的实现达到相同的目的。只有在定义代码的地方才需要修改代码，这让我们在开发的时候心情愉快。

承认

我从脸书的 FAIRseq 开源项目中学会了如何使用注册函数。你可以在这里找到他们当前的实现或者从我的老叉找到一个更简单的版本。

init_sub_class 方法的一个很好的解释可以在堆栈溢出中找到。

Python 支持的蒙特卡罗模拟

原文：https://towardsdatascience.com/python-powered-monte-carlo-simulations-fc3c71b5b83f?source=collection_archive---------6-----------------------

用 SciPy 的概率分布进行情景分析

蒙特卡洛，图片由卢卡·阮来自皮克斯拜，免费用于商业用途

本教程将演示如何在 Python 中建立蒙特卡罗模拟模型。我们将:

• 使用 SciPy 的内置分布，具体来说:正态、贝塔、威布尔；
• 为 beta-PERT 分布添加新的分布子类；
• 用拉丁超立方体抽样抽取随机数；
• 并建立三个蒙特卡罗仿真模型。

0.属国

除了我们的全天候包 pandas 和 numpy 之外，该脚本还导入了 SciPy 的 stats 库。

蒙特卡罗模拟的概念

图片由汉斯·布拉克斯米尔从皮克斯拜获得，免费用于商业用途

蒙特卡罗(MC)方法是一种模拟技术，为模型的输出变量构建概率分布，其中一些输入参数是随机变量。MC 方法有时被称为多概率模拟技术，因为它整合了多个随机变量，而这些变量的综合效应很难用封闭形式的方程来描述。

20 世纪 40 年代末，约翰·冯·诺依曼和斯坦尼斯劳·乌姆在洛斯阿拉莫斯实验室工作时发明了 MC 方法。当他们试图应用确定性方法计算中子碰撞时，他们走进了死胡同。乌姆的想法是使用随机抽样，由早期的“超级计算机”ENIAC 支持，以获得*似解。政府保密条例规定了一个代号；冯·诺伊曼和乌姆的一位同事建议把这个地方命名为蒙特卡洛，乌姆的叔叔在二战前经常去那里的赌场:他“只是必须去蒙特卡洛”赌博。( U 日上午)

MC 模拟问题的一个例子:一个企业想要模拟一个新产品的未来成功，并建立如下的模拟模型:

• 预期销售量，v，作为一个随机变量，遵循 beta-PERT 分布，从 3 点估计值得出；
• 产品的价格 p 将通过谈判确定——一些客户可能会要求批量折扣或提前付款折扣；计划者决定将公司将实现的*均价格的不确定性建模为*均值为 20、标准差为 2 的正态随机变量；
• 产品的原材料成本 m 将受到即将到来的供应商价格上涨的影响，由另一个正态分布来估计；
• 该模型应该提供多种结果:收入，利润，总成本。

一般来说，模拟模型采用被定义为随机变量的输入参数；然后，它返回每个输出变量的概率分布，每个变量都是其输入参数的函数。该函数可以是简单的和或积、输入的指数运算，或者——我们将在示例中看到——包含嵌套随机变量的高阶函数。目标变量将显示一个密度函数，描述输入变量的分布如何相互作用。

仿真模型通过从输入分布中采样来导出输出分布。1，000 或 100，000 次迭代提供了描述每个输入变量行为的数据点。输出变量的等式将这些输入转换为输出变量的尽可能多的样本。一旦我们获得了这个样本，我们就可以像任何内置的 SciPy 分布一样检查它的模式——它的*均值、分位数和离群值倾向。

2.拉丁超立方体采样

NumPy 的 random 库提供了用统一随机数填充数组的方法。SciPy 的每个分发对象都带有生成随机变量的 rvs() 方法。然而，蒙特卡罗模拟需要大量的随机数，对于这种情况，分层抽样方法，如拉丁超立方体抽样(LHS) 是更好的方法。

LHS 将样本空间分成不重叠的单元，每个单元具有相等的概率。LHS 确保从样本空间的完整范围内更均匀地抽取随机数。它防止采样随机数的聚集，这会扭曲频率曲线。LHS 样本将导致更精确的模拟结果。这将导致更低的标准误差，更少的迭代。

出于演示的目的，我们使用 SciPy 的 LatinHyperCube 采样器创建了一个由 10 个随机数组成的小数组。

制服(0；1)随机数在生成之后，可以被重新缩放以填充更大的范围，例如在 0 和 100 之间。然而，对于我们的目的，0 到 1 之间的标准随机数满足要求。

在下一章中，我们将使用 LHS 样本来生成特定分布的随机变量:PERT、正态和威布尔函数。

3.模拟中模拟不确定性的概率分布

3.1 用于专家评估建模的 PERT 分布

如果一个领域、过程或行业专家可以为一个随机过程提供所谓的三点估计(三点估计),包括最坏情况、可能情况和最好情况的结果，那么 pert 函数就可以将这些点连接起来，这是非常确切的。它会将这些点转化为概率分布，我们可以将它分配给模拟模型中的随机变量。

SciPy 的 123 个分布目录不包含 PERT 函数。因此，我们将其创建为继承自 SciPy 的 rv_continuous 父类的新子类。

对于我们的例子，我们用四个参数来实例化 PERT 子类，这四个参数预测新产品的销售量。

我们选择这个 PERT 分布来模拟预期的销售数量，最有可能的值是 12，000 个单位，最小为 8，000 个单位，最大为 18，000 个单位。

其*均预期值将为 12，333 个销售单位。它有一个小的正偏度，仍然类似于正态分布；和-0.62 的中度负过度峰度，这使其成为一个宽峰或大体积分布，其尾部的异常值比正态分布少。

第 3 行抽取 N=10，000 个均匀随机变量的 LHS 样本。然后第 4 行将该数组作为其输入参数。*百分点* *函数 ppf()* 将 10，000 个标准统一数字解释为概率，并计算 10，000 个 PERT 分位数，用这些分位数填充数组 randP。

直方图显示了模拟的 PERT 分布的形状。

3.2 正态分布

我们应用相同的方法(减去创建新的分布子类的需要)从正态分布中抽取 10，000 个 LHS 样本，我们期望这些样本反映销售价格和原材料单位成本中固有的不确定性。*均售价将为€ 20，标准差为€ 2。

第二个正态分布模拟原材料单位成本，*均值为€ 13，标准偏差为€ 1.40。

3.3 模拟 1-模拟随机变量的总和与乘积

我们创建了三个随机变量，代表三个因素的不确定性，这三个因素将决定新产品产生利润的机会或损失的风险:

• 体积 v 的 1x PERT
• 2x 正常——对于销售价格 p 和原材料单位成本 m；

我们假设其他成本，那些与供应商价格无关的成本，可以通过一个确定性变量 o 来反映。

为了计算模拟模型的目标变量——产品的毛利 GP，我们将随机变量联系在一起，如下所示:

• v =数量，p =价格，m =原材料单位成本，o =其他单位成本
• GP = v * (p — m — o)

作为第二个产出变量，我们可以模拟与 GP *行的收入 R。一般来说，一旦我们定义了输入随机变量，我们就可以用任意多的输出变量建立模拟模型。每个输出变量都可以由一个或多个输入随机变量组合而成，并由它自己的 10，000 个变量的数组来描述。

• R = v * p

这就建立了我们简单的模拟模型。

为了查看返回毛利随机变量 GP 的分布的数组的属性，我们编写了一个函数 dist_properties() ，该函数将读取数组并返回其矩和选定的分位数。

对于偏度和峰度，我们使用 SciPy 的 skew() 和峰度 () 函数，其结果需要借助 numpy 的 asscalar() 转换方法从数组转换成*面数。我们在字典 dict_moments 中收集它们的值，并在其中添加度量的名称。第 14 行中的 list comprehension 逐行打印字典的内容。

然后我们计算第 17ff 行中的分位数，将它们收集到另一个字典中， dict_quantiles ，并使用第 27 行中的 list comprehension 将其打印出来。

我们合并两个字典，矩和分位数，形成一个综合字典， dict_metrics 。

*均利润将达到€ 49，250，接*中位数。

偏度和峰度都相当适中，这意味着与正态分布相比，有适度的离群值倾向。

如果销售价格和原材料单位成本同时趋向于最坏的结果，列表中的分位数揭示了新产品将产生损失的 5%的风险。利润将以 90%的概率超过€ 10，731(10%的分位数)。

在下一章中，我们将更进一步，建立一个高阶仿真模型。虽然第一个模型仅从随机变量的和与积中组装输出变量，但我们现在将开发一个包括嵌套随机变量的模拟模型。

3.5 模拟 2 —嵌套分布

第一艘前往火星的宇宙飞船将配备电子电路板，其典型寿命可能为 5 万个工作小时。为了估计船舶设计中需要的冗余度，我们将模拟多少小时后所有电路的哪一部分会烧坏。

让我们假设，非常符合现实，威布尔分布的两个参数——形状和特征寿命——是不确定的。因此，我们将这些分布参数估计为它们自己的随机变量。威布尔形状及其标度可以在由它们的分布模式设定的边界内波动。

• 对于形状参数，工程团队估计它应该正态分布在*均值 1.5 左右，标准偏差为 0.1。
• 对于特征寿命，我们采用工程团队在 45，000、50，000 和 60，000 小时运行时提供的最大、可能和最小值的三点估算值。然后我们推导出一个 PERT 分布来反映不确定性的范围。

两个辅助函数通过拉丁超立方体采样抽取 10，000 个随机变量。

• wei_shp() 返回正态分布的形状参数。
• wei_charlife() 返回特征寿命的 PERT 变量数组。
• 我们将 Weibull 位置参数(也称为等待时间)设置为 0，这意味着产品故障会在生产完成和质量测试开始后立即出现。

在第 7 行中，我们将随机变量组合成一个威布尔输出变量，表示故障前的时间。威布尔函数调用辅助函数来获取其形状和比例参数。目标变量 rand_CL 将保存一个由 10，000 个模拟输出组成的数组，这些输出以小时为单位表示组件的寿命。

有三种嵌套分布的结果:PERT 和正态随机变量充当威布尔分布的参数。我们可以将结果标记为灵活的或随机的威布尔分布，而不是参数为点值的固定分布。

对于如何查看结果的属性，我们可以在两个选项之间进行选择:

• 将它作为一个数组进行分析，就像我们对之前的模拟结果所做的那样
• 应用 SciPy 的 rv_histogram 类，它将输出数组打包成一个直方图，并将其转换成一个“真实的”SciPy 概率分布，为此我们可以调用像 pdf 和 ppf 这样的分布函数。

让我们来看看直方图类。

图表用蓝色显示了我们在数组 rand_CL 中模拟的装箱寿命。在 orange 中，它绘制了概率密度函数，这个函数是由 rv_histogram 类从数组中得到的。

函数 histdist_properties() 计算 histdist 概率分布的属性。这个函数在某些方面与我们之前写的函数*distribution _ properties()*不同。 rv_histogram 类并不是在所有情况下都提供相同的分布属性。例如，最小值和最大值必须从。*支持()*方法。

我们调用 histdist_properties() 函数并获得列表度量。数据帧不仅包含累积分布函数和分位数，还包含一列随机变量。采样功能*。rvs()* 使我们能够从我们的输出分布中抽取一些随机数——或者如果需要的话抽取几千个，尽管没有 LHS 方法的分层抽样。

上面，我们分析了 rv_histogram 从数组中导出的连续分布。如图所示，分布曲线与阵列数据并不完全相同。

下面，我们对 10，000 个输出数字的原始数组调用函数 dist_properties() ，并解释矩和分位数。

• 部件的*均寿命将达到 45，647 小时；
• 寿命将是右偏的，自然地，异常值将持续超过 100，000 小时；
• 峰度是独特的——分布是薄峰的，其尾部有长期存活成分的倾向；
• 11，076 小时后，10%的部件将会烧坏。

任务控制中心告诉我们 11，000 小时的操作将标志着关键的阈值。在完成这些使用时间后，电路将不再是关键任务。分位数意味着，就电路板而言，飞船在设计时应该考虑到至少 10%的冗余度:增加备用电路板，这些电路板将自动打开，作为那些开始出现故障的电路板的替代品。

所以我们的太空船几乎准备好发射了。

图片作者彼得 H 来自皮克斯贝，免费用于商业用途

3.6 模型 3:固定参数模拟

作为最后一项练习，让我们检查威布尔模型对其形状和特征寿命的不确定性有多敏感。

我们将使用“固定形式”的威布尔分布进行蒙特卡罗模拟。

• 形状参数将固定为*均值 1.5；
• 特征寿命:PERT 分布的*均值:50，500 小时。

我们再次调用 dist_properties() 函数，并将其指标插入到数据帧中，这样我们就可以并排比较固定威布尔和之前嵌套的“灵活”威布尔。

正如预期的那样，我们看到固定威布尔变量的标准偏差较低，这是在形状和比例参数没有不确定性的情况下产生的。但是差别很小。显然，柔性威布尔模型的形状和尺度参数的不确定性非常接*于我们在固定威布尔模型中使用的*均值。较低的偏度和峰度显示出异常值和不对称性的倾向有所降低。

参数具有不同值或不同分布的模拟可能会显示由增加的不确定性引起的较大差异。

4.结论

今天的教程到此结束。

我们浏览了三个蒙特卡罗模拟的例子，它们是用 SciPy 库提供的工具箱创建的。

• 第一个模型——利润模拟——展示了随机变量的简单求和与乘积。
• 第二个模拟——威布尔失效时间——解释了嵌套随机变量的概念，即概率分布的参数本身就是随机变量。
• 第三次模拟大胆假设分布的参数是精确已知的。如果我们在模拟模型中忽略不确定性的来源，我们可能会低估可能结果的传播，除非不确定性浓缩为参数的*均值。

• 蒙特卡洛，图片由卢卡·阮来自皮克斯拜，免费用于商业用途
• 蒙特卡洛赌场，图片由来自 Pixabay 的 Hans Braxmeier 提供，免费用于商业用途
• 由彼得·H从皮克斯拜工厂，免费用于商业用途
• 所有其他图片:作者

Python 轻松打印彩色文本

原文：https://towardsdatascience.com/python-printing-colorful-outputs-with-ease-b4e2a183db7c?source=collection_archive---------14-----------------------

如何在 Python 中使用 Console.log、console.warn 和 console.error

让我们用一些颜色来增加那些无聊的控制台输出的趣味吧！(图片由作者提供)

上图两张截图哪个更好看？我肯定会选择正确的！这些颜色会立即将你的注意力吸引到重要的事情上，并给你额外的信息，让你一目了然。

本文涉及两个主题:首先，我们将了解如何在终端上打印颜色

• 终端中打印颜色的工作原理
• py-控制台；一个 Python 包，允许您轻松打印彩色输出

在这篇文章的结尾，你将能够打印彩色输出，那么我们还在等什么呢？我们来编码吧！

1.了解打印

首先，我们将检查终端需要什么来打印彩色文本。这将向您展示如何在最底层打印彩色文本。在接下来的部分中，我们将用更容易使用的方法来代替这种方法。

在 Python 中执行print功能时，文本出现在 终端 中。我们的目标是给这个值添加一些数据，以便我们的终端知道在显示文本时添加一些颜色。这些额外数据是ANSI escape character sequences，用于控制光标位置、颜色和字体样式，例如在终端中。终端将这些序列解释为命令，而不是仅仅显示的文本。

在下面的例子中，我们使用 Python 告诉终端打印文本“这是我们的消息”，文本为白色，背景为黄色:

print('\x1b[0;39;43m' + 'This is our message' + '\x1b[0m')

我们控制台中的输出(图片由作者提供)

ANSI 代码的第一段(\x1b[0;39;43m)是终端根据指定参数给所有后续文本着色的命令。我们可以在0;39;43部分用整数指定样式、文本颜色和背景颜色。结尾的第二段 ANSI 代码(\x1b[0m)告诉终端重新设置颜色选项，这样以后的文本就不再是白色和黄色了。

这种方法的问题是，这种方法在每个*台上都不统一；ANSI 代码可以在 Unix 和 MAC 上运行，但在 Windows 上不受支持。我们也不想打出这些具体的、难以理解的代码。让我们找到一种更简单的跨*台方法！

2.py-控制台；用 Python 轻松打印颜色

Py-console是我创建的一个软件包，它使打印颜色变得超级简单。它模仿 JavaScripts 众所周知的方法，如console.log、console.warn、console.error等。它还增加了一些更多的功能。

想创建自己的 Python 包吗？→查看 本文 获取说明。也可以查看 这篇文章 来创建你自己的私有包)

装置

首先我们将安装 py-console:

pip install py-console

记录、警告、错误、成功、信息

安装后，我们可以简单地调用 5 个函数之一，以指定的颜色打印文本:

from py_console import consoleconsole.log("log")
console.warn("warn")
console.error("error")
console.success("success")
console.info("info")

这会产生:

py-console 简单功能的输出(图片由作者提供)

切换时间和设置时间戳

我们还可以通过为控制台或 per 方法指定时间戳来为输出添加时间戳:

console.setShowTimeDefault(True)
or
console.log('log', showTime=True)

这将在您要打印的字符串前添加时间:

带时间戳的日志记录(图片由作者提供)

此外，您还可以设置时间格式。点击查看关于此的更多信息。下面的示例将时间格式设置为包括年、月和日。****

console.setTimeFormat('%y-%m-%d %H:%M:%s')

更严重的警告

在方法中，我们可以指定一个“severe”标志，以便我们有更清晰的输出，反转文本颜色和背景颜色:

from py_console import consoleconsole.log("log", severe=True)
console.warn("warn", severe=True)
console.error("error, severe=True")
console.success("success, severe=True")
console.info("info, severe=True")

这将产生以下输出:

这些消息有点严重(图片由作者提供)

突出

最后，我们还可以突出显示字符串的某些部分。看看这个我们使用 console.warn 函数的例子:

在同一个控制台中使用不同的文本颜色和背景颜色

结论

在本文中，我们主要讨论了终端如何打印彩色文本来更清晰地显示重要信息。然后我们看了一下的 py-console** 以及它如何让彩色输出变得非常容易。**

我希望我已经阐明了如何指示终端打印颜色，并且我希望我已经为您留下了一个创建漂亮的控制台输出的不错的包。如果你有建议/澄清，请评论，以便我可以改进这篇文章。

同时，请查看我的其他关于各种编程相关主题的文章:

• 用 FastAPI 用 5 行代码创建一个快速自动记录、可维护且易于使用的 Python API
• 从 Python 到 SQL——安全、轻松、快速地升级
• 创建并发布你自己的 Python 包
• 创建您的定制私有 Python 包，您可以从您的 Git 库 PIP 安装该包
• 面向绝对初学者的虚拟环境——什么是虚拟环境以及如何创建虚拟环境(+示例)
• 通过简单升级，显著提高数据库插入速度
• 在这里阅读更多关于py-console和更多关于 colorama 这里 。

编码快乐！

—迈克

页（page 的缩写）学生:比如我正在做的事情？跟我来！

让您的 Python 项目结构更优雅的 7 种方法

原文：https://towardsdatascience.com/python-project-structure-best-practices-d9d0b174ad5d?source=collection_archive---------23-----------------------

以下是易于管理、可伸缩且易于理解的 python 项目结构的最佳实践

完美 Python 项目结构的蓝图。——照片由来自 Pexels 的设计生态学家拍摄

伟大的项目从一个单一的文件脚本开始，并演变成一个社区维护的框架。但是很少有项目能达到这个水*。大多数，不管它们对其他人是否有用，最终都不会被任何人使用。

让你的项目对其他人来说方便(或者痛苦)的关键因素是它的结构。

什么是运行良好的完美 Python 项目结构？

• 伟大的项目总是<#5269>****。使用 git(或 mercurial。)
• 他们应该有一个 依赖管理 系统。Virtualenv(或康达)不是一个。
• 他们有自动化的 干净的代码实践 。让丑陋的编码对你的团队成员来说是不可能的。
• 伟大的项目总会有一个 自述 并给出更多的脉络。
• 应该有一个 配置文件 (一个 YAML 或者一个 TOML 文件)。将软件参数与硬编码分开。
• 秘密应该在一个的环境里(。env)文件。你不想让世界知道你的秘密。
• 他们应该有整洁的 文档 (可选。)

本文将介绍所有这些，并设置您的 python 项目以获得最大的可维护性。如果这看起来很难，你可以直接使用我为你创建的 蓝图 。

让每个项目都成为 git 仓库。

您可以通过一行命令将项目变成 git 存储库。做这个不会花一分钟。

git init

但是我们不常这样做。在大多数情况下，我们倾向于认为我们为一个简单的问题写了一个简单的脚本。没关系。

对你来说简单的对别人来说就复杂了。地球另一端的某人正在解决一个问题，您的简单脚本就是解决方案。

此外，你的简单问题可能会吸收其他简单问题，并变得可怕。

随着它的增长，维护您的代码变得越来越困难。你不知道你做了什么改变，为什么要做这些改变。如果你是一个团队，那么接下来的问题是谁和什么时候做了这些改变。

突然，你开始担心你最初写的剧本，而不是为它感到自豪。

开始每一行代码，就好像它是下一个脸书的开始。你需要一个版本控制系统来做这件事。

作为第一步，让您的项目成为一个 git 存储库，并包含一个. gitignore 文件。你可以使用在线工具 gitignore.io 生成一个忽略文件。

.
├── .git
│   ├── <Git managed files>
│  
├── .gitignore

随着您的进展，请确保使用说明性消息提交您的更改。提交是不同时间的检查点。它们确实是你的软件的版本，你可以在任何时候检验。

如何写好提交消息？

一个好的提交消息应该完成句子，“如果应用，这个提交将……”它们应该是句子的大小写，但是没有尾随的句号。提交消息的最佳长度约为 50 个字符。

以下是使用 git CLI 的提交消息示例。

git commit -am 'Print a hello world message'

你也可以创建更多的细节。您可以在没有提交消息的情况下运行git commit。

此操作将打开一个编辑器，您可以在其中添加多行提交消息。然而，使用上述约定来创建提交消息的标题。您可以使用空行来分隔邮件的标题和正文。

Print a hello <user> message

Print a hello world message and a hello <user> message

The main function was hardcoded with 'hello world' message.
But we need a dynamic message that takes the an argument and greet.

Amend the main function to take an argument and string formating to
print hello <user> message

这些提交消息约定将使浏览 git 日志中您所做的所有更改变得容易。

用干净的提交消息清理 git 历史——来自作者的博客

使用依赖管理工具。

大多数开发人员，尤其是新开发人员，没有对项目依赖给予足够的重视。首先什么是依赖管理？

您开发的软件可能依赖于其他开发人员创建的包。反过来，它们可能依赖于几个不同的包。这种模块化的方法有助于快速创建软件产品，而不需要一直重新发明轮子。

即使在同一个项目中，依赖关系在不同的环境中也会有所不同。您的开发团队可能有一组不属于生产系统的依赖项。

一个健全的依赖关系管理系统应该能够区分这些集合。

Python 开发人员使用虚拟(或 conda)环境来安装项目依赖项。但是 Virtualenv 不是一个依赖管理工具。它没有上面讨论的好处。这只会有助于将项目环境与您的系统隔离开来。

对于 Python 项目来说，诗歌是一个完美的依赖管理工具。它允许你，

• 分离开发和生产依赖关系；
• 分别为每个项目设置 Python 版本；
• 创建软件的入口点；
• 帮助您将其打包并发布到诸如 PyPI 之类的存储库中。

诗歌不是虚拟的替代品。它使用方便的实用程序命令创建和管理虚拟 env。

如果你喜欢这个想法，我发表了一篇关于如何使用诗歌有效管理项目依赖的完整教程。

在您的 Python 项目中自动化干净的代码实践。

Python 是最简单的编程语言。它接*自然语言，但在应用上却很强大。

但这并不意味着你的代码总是可读的。您可能最终会写出太长的代码，并且其风格对于其他人来说太难理解了。为了解决这个问题，Python 引入了一个叫做 PEP 8 的通用标准。

PEP 8 是 python 程序员简洁一致地编码的一套指南。它讲述了，

• Python 类、函数和变量的命名约定；
• 正确使用空白；
• 代码布局，如最佳线路长度，以及；
• 关于评论的约定；

尽管这一准则为 Python 程序员解决了一个大问题，但在大型项目中手动维护这一点很有挑战性。

幸运的是，像 black 和 autopep8 这样的软件包可以很容易地通过一行命令来完成。这一行格式化了 blueprint 文件夹中的每个文件。

black blueprint

Autoflake 是另一个帮助你去除脚本中无用变量的工具。我们声明但不使用的变量给阅读代码带来了不便。下面一行很神奇。

autoflake --in-place --remove-unused-variables blueprint/main.py

最后，我想提一下 isort ，这是一个优化导入的 Python 包。

isort blueprint/main.py

所有这些包在一行中清理你的代码。但是，即使这样，每次修改脚本时运行它也比我们想象的更有挑战性。

这就是为什么我更喜欢 Git 预提交钩子。

使用预提交挂钩，您可以配置为在每次提交更改时运行 black、autoflake 和 isort 来格式化您的代码库。

如何配置预提交钩子自动格式化 Python 代码？

您可以使用 poems add 或 pip 安装预提交包。您的项目根目录中应该有一个.pre-commit-config.yaml文件。您可以配置在每次提交之前运行哪些钩子。然后，您必须将预提交安装到 git 存储库中。可以通过从项目根目录运行预提交安装命令来实现。

poetry add pre-commit
# Create the .pre-commit-config.yaml file
poetry run pre-commit install

下面是您的.pre-commit-config.yaml文件应该是什么样子。

repos:
  - repo: local
    hooks:
      - id: autoflake
        name: Remove unused variables and imports
        entry: bash -c 'autoflake "$@"; git add -u' --
        language: python
        args:
          [
            "--in-place",
            "--remove-all-unused-imports",
            "--remove-unused-variables",
            "--expand-star-imports",
            "--ignore-init-module-imports",
          ]
        files: \.py$
      - id: isort
        name: Sorting import statements
        entry: bash -c 'isort "$@"; git add -u' --
        language: python
        args: ["--filter-files"]
        files: \.py$
      - id: black
        name: Black Python code formatting
        entry: bash -c 'black "$@"; git add -u' --
        language: python
        types: [python]
        args: ["--line-length=120"]

就是这样。现在试着对你的代码做一些修改并提交它。你会惊奇地发现它是如何自动纠正你的编码风格问题的。

使用配置文件来分隔项目参数。

配置文件就像应用程序的中央控制面板。您的代码的新用户只需更改配置文件就可以运行它。

配置文件中包含什么？

我们知道硬编码静态变量是一种不好的做法。例如，如果你需要设置一个服务器 URL，你不应该直接把它放在代码中。相反，最合适的方法是将它放在一个单独的文件中并从中读取。如果你或者其他人想改变它，他们只需要做一次，他们知道在哪里做。

在早期，我们习惯于从文本文件中读取配置。我甚至还用过 JSONs 和 CSV。但是我们有更先进的替代方法来管理配置。

一个完美的配置文件应该易于理解并允许注释。我发现 TOML 文件对这件事来说是不可思议的。poems 已经创建了一个 TOML 文件来管理它的配置。因此，我不必创建一个新的。

你可以用toml python 包读取一个 TOML 文件。只需要一行命令就可以将配置文件转换成字典。

下面是如何读取一个 TOML 配置文件。

1. 安装toml包。如果你使用诗歌来管理依赖关系，你可以使用add命令来安装它。如果不是*原老pip作品。

poetry add toml
# If you're still using pip and virtualenv,
# pip install toml

2.创建(或编辑，如果已经存在的话)一个 TOML 文件。你可以用任何名字。如果你使用诗歌，它会创建一个叫做pyproject.toml的。

[app]
name='blueprint'

3.将其加载到您的 python 项目中。

import toml
app_config = toml.load('pyproject.toml')# now you can access the configuration parameters
print(app_config)# {'app': {'name': 'blueprint'}}

将机密存储在环境文件中

一组机密项目不应该放在您的代码库中。常见的做法是将它们放在一个. env 文件中，并在运行时读取它们。您也不需要将. env 文件提交到代码库中。

您可以使用这个文件来存储 API 密钥和数据库凭证等信息。

如果您没有将它提交到您的存储库，那么使用您的配置文件来存储机密是非常好的。此外，您还可以使用。如果没有太多复杂的配置，可以将 env 文件作为项目配置文件。

环境文件和配置文件之间的一个关键区别是如何读取它们的值。您可以使用 Python 内置的os模块在项目的任何地方访问环境变量。但是配置文件值并不是对项目的每个模块都可见的。你必须要么读取每个模块上的文件，要么只读取一次，然后将它和函数参数一起传递。

但是我强烈建议使用两个独立的文件，因为它们有不同的用途。配置文件可以方便地配置您的项目，不需要任何硬编码。env 文件存储机密。

您可以使用。gitignore 来阻止您的 env 文件意外地潜入您的存储库。这是你在第 0 天应该做的事情之一。

下面是如何用 Python 创建和读取环境文件。

1. 在项目根目录下创建一个. env 文件

SECRET_KEY='R9p9BRDshkwzpsooPEmZS86OWjWxQvn7aPunVexFoDw'

2.安装 python-dotenv。

poetry add python-dotenv
# pip install python-dotenv

3.将 env 文件加载到项目中。

from dotenv import load_dotenvload_dotenv()
# If your env file is different from .env you can specify that too,
# load_dotenv('.secrets/.environ')

4.从项目中的任何位置访问环境变量。

import osprint(os.getenv('SECRET_KEY'))
# R9p9BRDshkwzpsooPEmZS86OWjWxQvn7aPunVexFoDw

环境文件是一个古老的约定。因此，大多数技术都预先支持它们。此外，您可以直接在操作系统上设置环境变量。

使用自述文件，并给出额外的背景。

如果你总是给阅读你的代码的人一些上下文，这将会有所帮助。它是关于什么的，你为什么要写它？

自述文件是项目的简短文档。它应该包括让另一个人在没有你的帮助下在他们的系统上设置你的项目的说明。

自述文件通常是降价文件。GitHub、Bit Bucket 和 GitLab 正在使用它在项目存储库上呈现样式化的文档。

Markdown 添加了一些约定，使普通文本显得特别。例如，你可以在一行前面加一个#标记作为标题，加一个##标记作为副标题。这里有一个备忘单，可以了解更多关于减价的信息。

记下备忘单，写出更好的自述文件——来自作者的博客。

用附带文档帮助读者(可选。)

你不必有一个多页的 web 应用程序来记录每个项目。但是有一个是个好主意。因此，我将它设为可选。

自述文件用于保存应用程序的基本信息。文档有助于给出项目的具体细节。

例如，您可以在自述文件中讨论软件包的安装和配置。但是不推荐谈论应用程序中的 101 API 端点。您可能需要在 HTML 文档中更好地组织它，并单独存放它。

Python 有几个创建 HTML 文档的优秀工具。Mkdocs(和它的材料主题)斯芬克斯和 Swagger 是最受欢迎的选择。你如何选择合适的文档工具？

如果您的应用程序涉及许多 API 端点，Swagger 是生成文档的最佳方式。如果没有，Mkdocs 工作良好。使用 Mkdocs，您可以创建自定义页面。您也可以使用mkdocstring扩展名来转换您的文档字符串。但是在我看来，你很少需要为你的代码创建文档。你的代码本身就是一个文档！

下面是如何在 Python 项目中使用 Mkdocs

1.您可以将 mkdocs 安装为一个开发依赖项。在生产系统中你不需要它。

poetry add -D mkdocs-material

2.编辑 index.md 文件(这也是一个降价文件。)

mkdocs new docs
cd docs

3.启动 mkdocs 服务器，在浏览器上查看它。

mkdos serve

你知道你可以用 GitHub 页面免费托管你的文档吗？

如果您有 GitHub 帐户，您也可以托管您的文档，并将您的主分支推送到 GitHub 存储库。它需要一个(并且只有一个)命令和几秒钟。

mkdocs gh-deploy

上述命令将构建文档的静态版本，并将其托管在 GitHub 页面上。托管的 URL 通常类似于

https://<Your username>.github.io/<Your repository name/

你也可以让它在你的主站点的自定义域或子域上运行。这里有一个来自 GitHub 的自定义域名的指南。

你可以在这里看到项目蓝图的托管文档。

如何使用 Python 项目蓝图？

我创建了几个 GitHub 库，您可以将它们作为 Python 项目的起点。第一个是一般 Python 项目的蓝图，另一个是专门针对 Django 应用程序的。

Python 项目蓝图

Django 项目蓝图

您可以克隆存储库并开始工作。每当你认为你应该把它放在远程 GitHub(或者 Bitbucket，Gitlab)上的时候，你可以创建一个远程存储库，并把它和你的本地存储库连接起来。下面是怎么做的。

git clone git@github.com:thuwarakeshm/blueprint.git git remote set-url <Your New Repository>

但是有更好的方法。

转到我上面给出的 GitHub 链接，你会在右上角看到一个按钮，上面写着“fork”分叉允许您创建您可以拥有的存储库的副本。您可以在完全不影响原始源的情况下进行更改。

因此，一定要派生存储库并将新的存储库克隆到您的本地计算机上。

这些存储库是用我上面讨论的所有最佳实践构建的。但是你可以随意把它变成你的。你可以改变任何你想改变的东西和你想改变的方式。

最后的想法，

Python 是一种优雅的语言。但是我们需要更多的训练来完成优秀的项目。如果我们把大部分都自动化了呢？

那是我们刚刚讨论完的。

我们讨论了拥有一个 git 存储库对于所有项目的重要性和原因。然后我们讨论了用诗歌管理依赖性。我们还学习了如何使用自述文件、创建文档、管理配置和环境文件。

上面提到的每一个练习本身都值得一个 30 天的课程。但是我相信这篇文章已经给出了关于这些技术以及我们为什么使用它们的想法。

一旦您意识到这些实践的好处，您就会想要创建支持它们的项目。我已经为你描绘了一幅蓝图，让你不必从头开始。

这个指南是基于我的理解和经验。如果你有什么要补充或改正的，我很乐意和你讨论。

感谢阅读，在 LinkedIn ，Twitter，Medium。

还不是中等会员？请使用此链接 成为 的会员，因为，不需要你额外付费，我为你引荐赚取一小笔佣金。

Python 项目的结构 P2C

原文：https://towardsdatascience.com/python-projets-structure-p2c-b2f92ab15c55?source=collection_archive---------31-----------------------

在 Unsplash 上由 Hitesh Choudhary 拍摄的照片

从管道到代码

作为一名程序员，我发现编码是一门艺术。当从事一个复杂的项目时，为了开发一个连贯、可靠和可持续的代码，需要遵循许多步骤，这些代码可以被其他贡献者阅读和恢复:

作者图片

• 首先，为了满足正确的需求，理解问题是至关重要的
• 这个项目可以被分割成多个子项目，这些子项目有助于完成任务，尤其是协作
• 您的管道是您的子项目的直接结果
• 代码的结构应该遵循相同的分段，这样您就可以拥有相同的管道和技术逻辑
• 为了有效地开发您的代码，可以在每个片段中遵循循序渐进的步骤

在这篇文章中，我们将看到如何从一个业务需求到一个简单易懂的全功能 python 代码。

目录

摘要如下:

1. 项目示例
2. 设计机构
3. Python 中的导入

项目示例

为了便于说明，我们将考虑以下业务需求:

作为一名高速公路经理，我希望使用给定的路线对车辆进行每日计数。为了回答这一需求，一个数据科学团队被投入到该项目中，并决定使用一个固定的摄像头，并计数车牌的唯一编号。** (其中一个建议)**

这个想法可以看作是几个步骤的顺序*(其中一个简化的分解)*:

• 车辆检测
• 车牌检测
• 车牌的光学字符识别

因此，下面的管道:

作者图片

项目的组织

给定上面的管道，可以如下组织代码:

|--**data/** *#useful to store temporary files for instance*
|--**Tests/** *#hosts the functional unit testings of your code/api*
|--**notebooks/** *#helpful for testing and developping and debugging*
|--|--develop.ipynb
|--**weights/** #weights are kept a part for easier manipulation|--**counthighwaypy/** *#folder hosting your entire code* |--|--***detectvehicle/*** *#1st brick of your pipeline*
|--|--|--detect_vehicle_main.py
|--|--|--detect_vehicle_utils.py
|--|--|--detect_vehicle_conf.py
|--|--|--Tests/ #independant unit testings relative to 1st brick
|--|--***detectlicenseplate/*** *#2nd brick of your pipeline*
|--|--|--licence_plate_main.py
|--|--|--licence_plate_utils.py
|--|--|--licence_plate_conf.py
|--|--|--Tests/ #independant unit testings relative to 1st brick
|--|--***ocrlicenseplate/*** *#3rd brick of your pipeline*
|--|--|--ocr_license_main.py
|--|--|--ocr_license_utils.py
|--|--|--ocr_license_conf.py
|--|--|--Tests/ #independant unit testings relative to 1st brick

|--|--utils.py
|--|--conf.py *#! very  important file (see below)*
|--|--main.py *#* orchestrator of the different bricks
|--|--Tests/ *#E2E technical unit testings*+--README.md
+--app.py *#hosts your API and calls the main.py*
+--packages.txt *#python environment*
+--launch_tests.sh *#functional unit testings*
+--pytest.ini
+--Dockerfile

如前一节所述，存储库的结构遵循管道中相同的逻辑。

• 每个brickhosts:
  +utils文件:包含您的 brick
  + conf 文件的所有辅助函数:包含所有常量参数(变量名称、目录、超参数值……)
  ++main 文件:通常包含一个函数，该函数集合了 utils 文件
  + Tests 文件夹:包含单元测试这是实现更快、更有效调试的基本原则。
• 当处理机器学习算法时，最好将潜在的权重存储在项目的根，因为在开发过程中它们可能会经常被替换。
• 使用**笔记本可以轻松尝试新功能。**根据给定的结构，每个都应该包含以下 python 代码，以便能够“看到”和导入模块 counthighwaypy:

import os
import sys
sys.path.insert(0, os.path.abspath("../")) #visible parents folders
from counthighwaypy import ...### your code

• 在模块 counthighwaypy 中，重要的是要有一个 utils 文件、 conf 和 main 文件，在不忘记 E2E 测试的情况下协调不同的砖块
• conf 文件非常重要，因为它设置了项目的根目录及其不同的子模块和目录**。可以这样写:**

import os
PROJECT_ROOT = os.path.realpath(os.path.join(os.path.realpath(__file__), "../.."))##### directories
DATA = os.path.join(PROJECT_ROOT, "data/")
NOTEBOOK= os.path.join(PROJECT_ROOT, "notebooks")SRC = os.path.join(PROJECT_ROOT, "counthighwaypy/")
WEIGHTS = os.path.join(PROJECT_ROOT, "weights/")MODULE_DETECT_VEHICLE = os.path.join(SRC, "detectvehicle/")
MODULE_DETECT_LICENCE_PLATE = os.path.join(SRC, "detectlicenseplate/")
MODULE_OCR_LICENSE_PLATE = os.path.join(SRC, "ocrlicenseplate/")

• app 文件将您的项目封装到一个 API 中，该 API 可供其他用户和服务使用
• 附加文件如 packages.txt 、 **pytest.ini、**和 Dockerfile 放在项目的根目录下

一旦代码的结构设置好了，最好以独立于其他模块的独立格式开发每个模块。也就是说，这里有一些你可以遵循的指导方针:

• 设置格式的输入&输出每块砖，其中输出的砖I是输入的砖I+1****
• 用简单的方式编写代码的画布(空函数)当你阅读它的时候，你会立刻明白这个脚本是做什么的
• 不要忘记的签名和的评论
• 使用 code v 版本工具， git 进行更有效的协作
• 使用 代码格式器和代码转换器 保持代码整洁
• 对于跨团队协作，将您的代码/包公开为可消费的 API

Python 中的导入

从 Python 3.3 开始，文件夹 folderame 被认为是一个模块(，不需要****_ _ init _ _。py 文件)并且可以简单地导入到 python 文件中，只要它是可见的，即在相同的树级上，通过使用:

import foldername

假设我们有以下结构:

|--**FOLDER1/** 
|--|--file1.py
|--**FOLDER2/** 
|--|--file2.py
|--main.py

• 在 main.py 中，我们可以

import FOLDER1.file1
import FOLDER2.file2

• 要在文件 1 中导入文件 2:

import os
import sys#make FOLDER2 visible to file1 (one step up in the tree)
sys.path.insert(0, os.path.abspath("../"))from FOLDER2 import file2

在一个复杂的 python 项目中，为了保持你的导入 的一致性，建议从你代码的源开始所有的**。在我们的例子中，在任何。包含以下内容的 py 文件:**

from counthighwaypy.xxx.xxx import xxx

结论

还有其他方法来构建您的 python 项目，但是我发现本文中描述的方法简单易懂，易于掌握。也可以应用于 Python 以外的语言。

我希望你喜欢阅读这篇文章，它将帮助你在未来更好地组织你的工作。欢迎所有的评论和建议！

Python 场景分析:用 beta-PERT 分布模拟专家评估

实践教程

以及如何向 SciPy 的目录中添加一个新的、用户自定义的发行版

【https://pixabay.com/images/id-1872665/】由奇莫诺、皮沙贝

关于以下内容的教程:

• 如何在情景分析中使用概率分布；
• 如何对专家评估建模——如果观察数据很难获得，我们需要从专家那里收集评估，这些专家可以提供关于行业、业务流程或领域的领域知识；或者，如果历史数据可用，但预计不会反映未来的发展，特别是趋势突变，那么我们也需要开发一个基于专家估计的模型；
• 如何在情景分析中使用 PERT 分布；并添加 PERT(或其他用户定义的分布)作为一个新的子类来完善 SciPy 库；
• 如何重新参数化 PERT 或其他分布

我的上一篇文章介绍了 SciPy 的概率分布，以及它们如何应用于随机过程的建模。(用 Python 的 SciPy 介绍概率分布| 2021 年 10 月|走向数据科学)

今天的文章将展示我们如何使用概率分布进行场景分析。

情景规划——在商业、工程或金融领域——通常涉及所谓的三点评估 : 最佳情况、可能情况、最坏情况。 ( 三分法估算——维基百科)

三点估计技术有助于避免单点估计的一些缺陷——其中之一是，如果计划者甚至在不知情的情况下过度乐观或悲观，决策者可能会发现相当大的偏差倾向。“偏向是一种不成比例的权重偏向或反对一个想法或事情”(偏向——维基百科)。如果一个企业或任何组织的团队成员感到有压力要为成功做计划，但不考虑哪怕是暂时的挫折，因为未来总是看起来更光明，那么他们的计划可能会表现出隐藏的或不太隐藏的对难以置信的好结果的偏好。

三点估计技术试图通过明确询问最坏情况的结果来揭示隐藏的偏差。

• 报告的最差情况可能仍然有正偏差，但它可以作为讨论风险的起点。
• 对最佳情况的隔离表明，所谓的可能情况并没有被置于过于乐观的假设的边缘。

然后可以启动一个调整过程，例如德尔菲法(也称为估计-讨论-估计)，以达成一致的场景。(德尔菲法—维基百科)

德尔菲法，维基百科，Czkassa(后 Maurizio Bolognini，demo copicnia elettronica，2001)，也可免费用于商业用途

如果没有数据科学家的参与，他们可以提供用概率分布模拟不确定性的专业知识，许多组织倾向于只准备三种情况:预期*均结果、悲观情况和乐观情况。然后，这三个场景将留给决策者，让他们尝试直观地将这些点联系起来。仅仅三个点，运用个人直觉。会出什么问题呢？

数据科学家可以通过概率分布来连接这些点，该概率分布在整个范围内对涉及的风险、机会和不确定性进行建模。该模型不仅会报告两个极端值(根据定义，最好和最坏的情况必须相对不太可能，有时甚至极不可能发生)，而且科学家还可以报告分位数，这些分位数描述了结果的连续谱及其相关概率。

当我们想要将 3 点情景规划过程建立在更坚实的基础上时，我们应该考虑哪些模型？

正态分布，由于其围绕均值和中值的不变对称性，并不总是显示尾部风险倾向的随机过程的最佳模型。

一个风险因素可能会导致巨大的成本或超过技术安全限制，但它是不对称的:如果风险没有或实现，就不会有同等的成本降低或超过基线的安全改进。正态分布不能解释许多不对称风险。

我们想要建模的真实世界随机过程也可能表现出过度的峰度:异常值在其两个尾部出现的频率高于正态分布的情况-具有高峰度的真实世界随机过程的中心包含不到 99.7%的在*均值周围三个标准偏差内的所有事件。

如果我们选择正态分布，我们不仅大胆地假设我们模拟了一个既不偏斜也不重尾或轻尾的随机过程。我们还使用了一个双向无界的模型；它的结果可以沿着 x 轴向负无穷大和正无穷大延伸。

我们的结论是，除了正态分布，我们还应该看看其他模型。

三角形分布在三个点之间画出直线。由此产生的概率密度函数是字面上连接三个点并获得简单随机过程模型的最直接的方法。

我们通过详细阐述 3 点估计的分布来建模的随机过程可以代表受不确定性影响的任何情况。最初的 3 点估计提供了可能结果边缘的两个极端点，根据定义，这两个极端点发生的概率较低。概率分布将采用这些点，然后显示结果的完整范围及其模式，例如:

• 新产品或现有产品在新市场或现有市场的销售量
• 顾客接受新产品的价格，相对于竞争对手的产品价格进行估计
• 供应商价格，3 个月后
• 新开发技术部件的典型寿命
• 30 天后的外汇汇率
• 拟建海上风力发电场位置的风力

然后，分布特性将使我们能够量化预期结果:

• 新部件的*均或中位故障时间，它告诉我们其未来的保修率、成本和关键安全阈值；
• 分位数，确认某个位置的风力不会超过蒲福风 6 或 27 节，概率为 99%，但它会在至少 80%的时间内以 11 节的速度驱动计划的风力涡轮机，这告诉我们涡轮机需要有多坚固才能承受大风；以及它们预期发电千瓦数的规模，以使投资物有所值；
• 投资组合的风险价值，具有预期的未来回报和估计的波动性。

0.属国

从 SciPy 中，我导入了包含 123 个发行版的庞大目录的 stats 库。具体来说，我们将在教程中使用正态、三角和贝塔分布。

我还导入了 SciPy 的优化模块，并将演示我们如何求解一个非线性方程组，在这种情况下是为了确定一些分布属性。

1.模拟专家评估的三角分布

三角形分布的自变量是最坏情况(最小值或位置参数)、可能情况(模式)和最佳情况(比例参数=最大值-最小值)。

三角形分布是建模专家意见的常用选择。它的三角形直观上很容易理解。

但是除了简单性之外，我不认为它是最佳选择。曲线的形状有着尖锐、笔直的边缘，看起来不像真实世界中的随机过程。当我们将其与下面的 beta-PERT 分布进行比较时，我们还会注意到三角形的峰度(异常值倾向的指标)是有问题的。

2.贝塔-珀特分布

2.1 PERT 概念

PERT 代表“Pprogram(或Pproject)Eevaluation 和RreviewTtechnique”PERT 分布是支持这种项目管理综合方法的工具之一。PERT 最初是由美国海军在 20 世纪 50 年代末开发的，用于管理北极星核潜艇项目。该方法很快被许多其他组织和行业采用(项目评估和审查技术——维基百科)。

对于我们今天的目的——建模不确定性——我们可以把重点放在概率分布上，但我们将跳过 PERT 的组织和方法方面，以及它如何处理关键路径分析。

原始 PERT 分布采用与三角分布相同的三个参数:

• 最坏情况或最小情况；
• 可能的情况或模式；
• 最好的情况或最大值。

PERT 概率密度函数的魅力在于它可以*似正态分布的钟形曲线。或者，如果我们将它的 lambda 权重校准为第四个超参数，它也可以模拟一个更灵活的分布形状，表示偏度和更高或更低的尾部风险。上图显示了四条可供选择的 PERT 曲线。所有这些都是基于专家估计的相同大小的最小值、可能值和最大值，但是我们应用了不同的λ因子来模拟它们的尾部。

下图比较了 PERT(1，3，8，8)和正态(3，1)分布。这些曲线彼此相似，但 PERT 并不完全对称。它是右尾的，具有 0.48 的中等正偏斜。与正态变量相比，它的右尾有更多的异常值，但左侧的异常值较少。

2.2 PERT 与三角分布

一些资料来源认为，如果缺少可以推导出λ重量的历史数据，三角形分布在 3 点方案中更可取。

三角形的*均值就是最小值、众数和最大值之和除以 3。PERT 均值也采用这个和，但是用一个因子对模式进行加权，在尝试其他权重之前，该因子通常设置为 4。如果λ保持固定为 4，则分布代表传统的 PERT 变量——而可由分析师设置的可变λ将其转变为所谓的修正 PERT 分布。

然而，对权重因子的关注并不是一个合理的论点，因为我们可以选择将 lambda 设置为 1.0 的中性值，这不会相对于最好和最坏的情况而言过重可能的结果。

下面，我将以强调 PERT 的*均值只包括一个选定的权重因子 lambda 的方式编写*均值的等式，该权重因子可以设置为 1.0，类似于三角形分布。

由于专家已经提供了最坏、可能和最好结果的估计，没有理由不向他们询问分布曲线的“尾部”:他们是否预见到分布是重尾的，异常值比正态分布的钟形曲线更经常出现，这种曲线逐渐消失在*均值的三个标准偏差之外？

在专家估计了最佳、最差和可能结果的幅度之后，Python 脚本可以立即用备选λ权重绘制 PERT 的曲线，以便专家可以选择反映他们对可能结果的真实可能性的直觉的形状；或者反过来，他们可以选择一个图形来显示尾部风险出现的频率。

该图表表明，对于可能的结果，随着λ权重的增加，PERT 曲线开始类似于正态分布——直到非常高的λ值会使其变成尖峰分布。红色曲线显示了一个 PERT 形状，其 lambda 默认值为 4.0。

任何三角形变量的过度峰度都是负的常数，-0.6，这意味着它比正态分布表现出的异常值倾向低得多。我们知道，正态分布经常低估现实世界随机过程中极端结果的尾部风险，例如在金融市场中。具有负过度峰度的三角形分布是扁峰度，或围绕中心的大体积，这意味着它假设尾部的异常值出现的频率更低，并且比正态分布预测的幅度更低。这可能是一个危险的提议。

相比之下，PERT 分布使我们能够通过修改 lambda 权重将尾部风险倾向校准到一个选定的值，例如，如果我们想要达到比正态分布高一个等级的峰度。

一个技术说明:SciPy 在单位区间[0；1].我们可以尝试用位置和比例值来定义它，以将它移动到单位间隔之外，但我的尝试导致了 NaN 值。显然，这是一个不影响除了 triang 子类之外的其他发行版的 SciPy bug。

2.3 PERT 作为转换后的 Beta 分布

SciPy 的两个类及其 123 个发行版不包含 PERT 子类。不过，我们不需要从头开始编写 PERT。SciPy 为我们提供了可以用来定义 PERT 的构件。

• beta-PERT 分布可以表示为标准 Beta 分布的变换:

• 我们需要对随机变量 X 进行移位和重标度，然后插入变换后的变量 Z，它符合单位区间[0；1]，转化为β变量:

• 我们通过转换四个 PERT 参数的两个方程推导出贝塔分布的两个形状参数α和β:

• 由此产生的*β(z；α，β)分布将等于PERT(x；最小，模式，最大，λ)*变量。

3.在 SciPy 的目录中增加一个新的分布:修改的 PERT

我们转换 SciPy 的 Beta 分布，以便在需要时为我们提供 PERT 结果。但是为了避免在我们向我们的专家询问更新的评估时走弯路，我们将把 PERT 本身作为一个新的类别添加到我们导入的 SciPy 分布目录中。

为了准备测试新类，我们选择一个参数元组:

• 最小值= 10
• 模式，最频繁或最可能的值= 20
• 最大值= 40
• λ= 4.0

这个新类将继承自连续分布的 SciPy 父类，RV _ continuous。

这将允许我们依赖与 SciPy 的内置发行版相同的语法。

继承带来了另一个特性。我们可以创建一个新的子类，只需要一个方法来定义它的概率密度函数 pdf 或累积分布函数 cdf。由于我们将它设置为子类，父类 rv_continuous 将自动填补我们在子类中留下的任何空白:父类将在运行时计算缺失属性的数值*似值。示例:如果我们没有明确定义一个方法来计算*均值，当我们应用时，SciPy 将会解决这个问题。mean() 函数在我们的代码中。然而，从 rv_continuous 继承而来的间隙填充机制是有代价的。也可以用公式表示的度量的数值*似值将花费相当多的处理时间。

我们建立了新的 PERT 生成器类，并包含了所有属性的显式方法，我们可以为这些属性写下封闭形式的表达式。

出于实验的原因，我复制了新的详细类，并从我标记为 pertm_gen_less 的副本中删除了大部分方法，除了它的累积分布函数。然后我在长班和短班之间跑了一场赛马。在实例化这两个类之后，我们将在下面看到结果。

我们编写一个函数 pertm_results() ，每当 PERT 实例调用该方法时，它将计算一组属性。该函数将返回累积分布函数、概率密度、百分点(即分位数函数 ppf)和前四个矩。

在下面的第 4 行，我们创建了一个生成器类 *pertm_gen* 的实例。第 6 行使用我们之前设置的参数 *min，mode，max，*和 *lambda* 对其进行参数化，并将实例分配给变量*RV:*PERT 随机变量。

第 8 行调用 pertm_results() 函数来报告分布的主要属性。

为了找出一个只包含 cdf 函数的类是否会有较弱的性能，我们还实例化了“不太完整”的类 pertm_gen_less 。它包含相同的累积分布函数，但它的所有其他属性必须在运行时由 SciPy 的内部解算器*似计算。我们观察到，它对同一个 pertm_results() 函数的调用花费的处理时间是我们为更详细的生成器类所测量的两倍多。因此，如果我们知道如何将一个分布属性表达为一个代数公式，我们应该将它作为一个方法添加到类定义中。

interval() 函数返回一种置信区间。它告诉我们，对于给定的概率，随机数将从中位数附*的报告区间中抽取。这种见解与我们对正态分布的了解相当:99.7%的观察值都在中位数的三个标准差范围内。对于其他非对称分布，我们事先不知道这个事实，但我们可以参考 interval() 函数。

我们将 x 轴上的选定点输入 PERT 的累积分布函数和概率密度函数。

4.使用分位数的专家估计:转换的 pert

PERT 和三角分布作为参数所期望的最大值和最小值提出了另一个潜在的问题:对于包括我们在内的规划者来说，确定一个场景的极端情况是众所周知的困难。对于长尾随机过程，即使出现的概率在三到五个标准差后会缩小到接*零，x 轴也可以被拉至接*无穷大。

为了防止对极端结果的有偏见的预测，我们不应该请领域专家来估计“真正的”最小值和最大值，而是考虑 x 轴两端的两个更现实、不太极端的点:“估计随机过程只会以 10%的概率超过哪个大值(也就是 90%的分位数)。并估计阈值，低于该阈值时，更糟糕的结果只会以 10%的概率发生(也就是 10%的分位数)。”这个(10，90)分位数对将代表更现实的最坏和最好情况，在大多数情况下可以更容易地进行估计。

我们将定义一个 PERT 分布，它可以使用分位数作为参数。

为了检查一致性，我们希望转换后的 PERT 分布与我们在第 4 章中分析的原始分布相匹配。因此，我们将 10%和 90%分位数设置为我们已经导出的值，作为修改后的 PERT 分布的属性(第 4 行到第 6 行)。

我们需要将分位数转换成参数，然后传递给(大)母分布:标准 Beta 随机变量。为此，我们将打开 SciPy 的工具箱，使用它的非线性方程系统的解算器。

在第 5 行和第 9 行之间的函数 *f，*中，我们建立了方程组。两个百分点或分位数函数 ppf() 必须进行校准，以等于专家估计的给定分位数值 q10 (14.59)和 q90 (29.33):

• 0 = ppf(0.10) — q10
• 0 = ppf(0.90) — q90

第 13 行中 SciPy 的 fsolve() 方法将搜索两个值 min 和 max ，这两个值将校准百分点函数以匹配它们的目标值 q10 和 q90。

我们的专家估计的模式不需要转变。我们还保留 lambda 的默认值 4.0。

第 12 行提供了一个初始的猜测值，这对于 fsolve()是必需的。we用 100 乘以 90%的分位数来猜测最大值；并将 10%的分位数乘以 0.01 以接*最小值。x 轴上 10%分位数的最左侧和 90%分位数的最右侧的结果起点似乎分别非常接*最小值和最大值，求解程序可以确定这两个极值的*似值。在测试过程中，解算器没有陷入死胡同解，尽管最小值和最大值有时很难在 x 轴的极端边缘找到。

元组 params 接收两个方程组的解:解算器确定的最小值和最大值。

在下一步中，我们将元组转换为可变列表，为 lambda 添加默认值 4.0，并在 min 和 max 之间插入模式。然后，字典将这四个参数值与它们的名称配对。第 10 行中的列表 comprehension 打印了这个参数字典。

这些是我们现在可以提供给 PERT 子类的输入参数。

在第 15 行和第 16 行，我们选择要计算分位数的概率。第 17 行组合了另一个字典中的概率及其相应的分位数，第 19 行中的 list comprehension 逐行打印。我们在下面的截图中看到了分布参数和分位数。

5.PERT-Q 分布

在第四章中，我们编写了代码来翻译分位数参数，以便用传统的参数化(min，mode，max，lambda)使它们易于被 PERT 理解。这需要输入和输出之间的手动步骤。

我们可以通过定义一个新的、重新参数化的 PERT-Q 分布类来简化转换步骤，该类立即接受分位数作为其参数。最终用户甚至可以自己输入估计的分位数。

新的生成器子类 pertQ_gen 继承自其父类，即修改后的 PERT 生成器 pertm_gen 。我们在第 4 章中开发的代码可以重复使用来建立这个新类，只需很少的修改。

除了模式和λ之外，累积分布函数 _cdf()还将 10%和 90%的分位数作为其参数。在第 12 行和第 16 行之间的函数 *f，*中，我们建立了非线性方程组。带有最小和最大参数的两个百分点函数 *ppf()、*被设置为等于 q10 和 q90 中的分位数值:

• 0 = ppf(0.10) — q10
• 0 = ppf(0.90) — q90

第 20 行中的 _minmax() 函数应用了 SciPy 的 fsolve() 方法。然后，行 40 导出形状参数α和β，如前几章所述。

辅助函数 _minmax 和 _shape 返回的转换结果被输入到反映 PERT 分布的标准 Beta 分布中。

为了查看结果，我们给变量 *pertQ 分配一个新的 PERT-Q 分布类的实例。*我们用之前选择的参数元组(q10，mode，q90，4.0)来设置它，并通过将它映射到变量 rvQ 来冻结实例。

现在，我们可以绘制 PERT-Q 分布的 pdf，当然，我们会发现它的曲线与我们之前准备的修正 PERT 的曲线是相同的。请记住，我们将专家估计值设置为与修改后的 pert 提供的值相同。因此，两个参数化必须导致相同的分布。

当我们计算 PERT-Q 的矩时，应用。stats()方法，我们发现它们与修改后的 PERT 分布的矩相匹配。

通过计算 x 轴上相同点的 cdf 和 pdf，我们可以进一步确认 PERT-Q 和修正的 PERT 是相同的。

在第 7 行和第 8 行中，我们通过压缩合并了它们的值。在左边，代码列出了 x 值；中间的两列比较它们的 cdf 值，它们没有显示差异；右边的两列显示 pdf 值也没有不同。

6.结论

我们模拟的随机过程可以代表任何受未来结果不确定性影响的变量:汇率；销量；价格；通货膨胀率；药物的代谢吸收率；2022 年新增 Medium.com 用户数；预计海上风电场位置的风力。

通常(但还不够经常)，我们可以依靠历史观察数据来准备预测模型。但是很多时候，我们面临着原始数据的缺乏。

我们还必须面对这样一个事实，即每个数学模型只能预测过去观察到的模式。开发能够应对趋势突变的情景——人们担心这是黑天鹅事件；或者希望如果企业想要推出新产品，那么我们需要将场景规划添加到我们的工具箱中。

当新冠肺炎在 2020 年 1 月浮出水面时，我们可以预见它会扰乱公共生活和经济。虽然我们没有数据序列，我们可以从这些数据序列中自动得出单个企业或行业的时间序列预测。上一次如此规模的全球疫情造成浩劫是在 1918 年。2020 年被破坏的供应链、市场和行业在一个世纪前并不存在，因此没有时间序列分析可以提供可靠的模型。

许多其他例子之一是电动汽车制造商特斯拉的崛起。几年前，当特斯拉开始(重新)发明电动汽车时，没有时间序列数据可以表明，当时规模相对较小的初创公司会扰乱汽车行业及其企业巨头。

在许多情况下，我们发现我们需要从领域专家那里收集评估，他们应该为我们提供对预期结果的 3 点评估。然后，我们可以启动我们的数据科学引擎，通过进入 SciPy 的概率分布工具箱，对场景中的不确定性进行建模。

下一篇文章将讨论场景规划的下一个阶段:Python 中的蒙特卡罗模拟。

• 标题图片:奇莫诺，pixabay 上免费
• 德尔菲法:维基百科，Czkassa(源自 Maurizio Bolognini，democornia elettronica，2001)，免费用于商业用途
• 所有其他图片:作者

Python 集合运算:完整指南-数据结构

原文：https://towardsdatascience.com/python-set-operations-complete-guide-data-structures-98fcd0532296?source=collection_archive---------21-----------------------

在本文中，我们将重点介绍 Python 集合操作的完整过程。

马丁·桑切斯在 Unsplash 上的照片

目录

• 介绍
• Python 集合并集
• Python 集合交集
• Python 集合差异
• Python 集对称差
• 结论

介绍

此时，读者应该熟悉 Python 集合。如果你想复习，或者对 set 不熟悉，请查看 Python sets 初学者指南。

在本教程中，让我们从数学的角度考虑集合，并考虑集合论的部分内容。集合只是不同元素(或数学对象)的集合。

出于本教程的目的，我们将使用数字集合。类似于: A = {1，2，3，5，7}和 B = {1，2，4，8，9}。

Python 集合并集

在集合论中，集合并是集合的集合。这意味着，如果我们有两个集合， A 和 B ，我们可以将它们组合起来，只取不同的元素(意味着重复的元素将被丢弃)。

但是这在数学上看起来如何呢？

这是:

作者图片

一个数值例子有助于理解它。考虑两组:

• A = {1，2，3，5，7}
• B = {1，2，4，8，9}

或者视觉上:

作者图片

在这种情况下:

作者图片

元素 1 和 A 和 B 都存在。当联合两个集合时，我们只考虑每个重复的元素一次。

下图中的黄色区域显示了集合 A 与集合 B 的联合:

作者图片

现在让我们看看如何使用 Python 来完成同样的操作。我们将首先创建两个集合， A 和 B 。然后使用**。**Python 集合的 union()【方法】执行 union 操作:

您应该得到:

{1, 2, 3, 4, 5, 7, 8, 9}

这是完全相同的集合，在上面信息图中的黄色区域有相同的元素。

Python 集合交集

在集合论中，集合交是集合的互元素的集合。这意味着，如果我们有两个集合， A 和 B ，集合交集将包含两个集合中出现的所有元素。

从数学角度来说:

作者图片

一个数值例子有助于理解它。考虑两组:

• 答 = {1，2，3，5，7}
• B = {1，2，4，8，9}

或者视觉上:

作者图片

在这种情况下:

作者图片

下图中的黄色区域显示了集合 A 与集合 B 的交集:

作者图片

现在让我们看看如何使用 Python 来完成同样的操作。我们将首先创建两个集合， A 和 B 。然后使用**。**Python 集合的交集()方法执行交集操作:

您应该得到:

{1, 2}

Python 集合差异

在集合论中，集合 B 和集合 A 之间的集合差，也称为集合 B 中集合 A 的相对补。它被定义为存在于集合 B 中但不存在于集合 A 中的元素集合。

或者，集合 A 和集合 B 之间的集合差异是集合 A 中存在但集合 B 中不存在的元素集合。

数学上:

作者图片

一个数值例子有助于理解它。考虑两组:

• A = {1，2，3，5，7}
• B = {1，2，4，8，9}

或者视觉上:

作者图片

在这种情况下:

作者图片

元素 1 和 A 和 B 是两组中唯一一起出现的。但是元素 4 ， 8 ， 9 只存在于集合 B 中。因此，集合 B 和集合 A 之间的集合差正是这些元素:{4，8，9}。

下面信息图中的黄色区域显示了器械包 B 和器械包 A 之间的器械包差异:

作者图片

现在让我们看看如何使用 Python 来完成同样的操作。我们将首先创建两个集合， A 和 B 。然后使用**。**Python 集合的 difference()【方法】执行差分运算:

您应该得到:

{8, 9, 4}

Python 集对称差

在集合论中，两个集合( A 和 B )之间的对称差也称为析取连接。它被定义为存在于集合 A 或集合 B 中，但不同时存在于两者中的元素集合(不在集合 A 和集合 B 的交集中)。

数学上，它被计算为两个差的并集:

一个数值例子有助于理解它。考虑两组:

• A = {1，2，3，5，7}
• B = {1，2，4，8，9}

或者视觉上:

作者图片

这里有三个步骤来寻找对称差:

1. 找出集合 A 和集合 B 之间的集合差:A \ B = {3，7，5}，因为这些元素出现在集合 A 中，而不出现在集合 B 中。
2. 找出集合 B 与集合 A 之间的集合差异:B \ A = {4，8，9}，因为这些元素出现在集合 B 中，而不出现在集合 A 中。
3. 在步骤 1 和步骤 2 中找到的两个集合差的并集:(A \ B)∩(B \ A)= { 3，7，5，4，8，9}

在这种情况下:

作者图片

下图中的黄色区域显示了 set A 和 set B 的对称差异:

作者图片

现在让我们看看如何使用 Python 来完成同样的操作。我们将首先创建两个集合， A 和 B 。然后使用**。**Python 集合的 symmetric_difference()【方法】执行对称差分运算:

您应该得到:

{3, 4, 5, 7, 8, 9}

结论

如果你有任何问题或对一些编辑有建议，请随时在下面留下评论，并查看更多我的数据结构文章。

最初发表于 2021 年 12 月 10 日https://pyshark.com。

面向初学者的 Python 统计

原文：https://towardsdatascience.com/python-statistics-for-beginners-pearson-correlation-coefficient-69c9b1ef17f7?source=collection_archive---------11-----------------------

皮尔逊相关系数

什么是相关性？

我们都听过“相关性”这个词。虽然我们可能不确定它的确切含义，但我们知道它是两个变量相互关联程度的某种指标。你知道吗？这非常接*事实。

相关性本身是一种数学技术，用于检查两个定量变量之间的关系，例如汽车的价格和发动机的大小。

相关类型

那么有哪些类型的相关性呢？让我们画一些图表来更好地理解:

# Import working libraries
import pandas as pd
import numpy as np# Positive correlation
x = np.arange(start=0, stop=25, step=1)
plt.plot(x, 'o')# Negative correlation
x = np.arange(start=25, stop=0, step=-1)
plt.plot(x, 'o')# No correlation
x = np.random.rand(25)
plt.plot(x, 'o')

正相关表示两个变量会向同一个方向运动。换句话说，如果一个变量增加，另一个也会增加，如果一个变量减少，另一个也会等量减少。正相关关系可以说明如下:

正相关。作者创建的图像。

负相关是两个变量之间的关系，其中一个变量的增加导致另一个变量的减少。负相关的一个很好的例子是氧气含量与海拔的关系。随着海拔的升高，空气中的含氧量会降低(极限登山运动员的通病)。负相关看起来像这样:

负相关。作者创建的图像。

最后但同样重要的是，第三种形式:**没有关联。**在这种情况下，数据图是完全随机的，没有显示任何相关的迹象。没有相关性可以这样来说明:

没有关联。作者创建的图像。

相关形式

关联有不同的形式。可以是线性、非线性、或单调。让我们再画一些图来说明不同之处 :

# Import additional working libraries
import seaborn as sns # Linear correlation plot
data1 = 20 * np.random.random(100) + 100
data2 = data1 + (10 * np.random.random(100) + 50)
sns.regplot(x=data1, y=data2) # Non-linear correlation plot
x = np.arange(0, 10, 0.1)
ytrue = np.exp(-x / 10000) + 2 * np.sin(x / 3)
y = ytrue + np.random.normal(size=len(x))
sns.regplot(x, y, lowess=True) # Monotonic non-linear correlation plot
def f(x, a, b, c, d):
    return a / (1\. + np.exp(-c * (x - d))) + ba, c = np.random.exponential(size=2)
b, d = np.random.randn(2)n = 100
x = np.linspace(-10., 10., n)
y_model = f(x, a, b, c, d)
y = y_model + a * .2 * np.random.randn(n)sns.scatterplot(x, y)
sns.lineplot(x, y_model)

线性相关性是数据中两个变量以恒定速率变化的趋势。例如，假设一个汽车经销商想要估计燃料消耗对汽车价格的影响。他们发现每多消耗一升燃料，汽车价格就会下降 1000 美元。这描述了燃料消耗和汽车价格之间的线性关系，其中汽车价格以 1000 美元的恒定比率受到燃料消耗的影响。线性相关性可以用一条直线来表示:

线性相关。作者创建的图像。

当两个变量不以恒定速率变化时，相关性为非线性**。**结果，变量之间的关系并没有用直线来表示，而是在数据中造成了某种程度的曲线模式。下图展示了这种情况:

非线性相关。作者创建的图像。

类似于线性关系，单调关系中的两个变量将沿同一方向移动。然而，变量不一定要以恒定的速率移动。下一张图显示了两个变量同时增加但速率不同的情况。

单调非线性相关。作者创建的图像。

皮尔逊相关系数

绘制数据及其关系的图表有助于我们确定我们面对的是哪种类型的相关性以及它的形式。然而，它并没有告诉我们实际上我们看到的相关性有多强。为了量化这两个变量之间的关系，我们需要计算相关系数。

相关系数是量化两个变量之间关系的统计度量。该系数的值介于-1.0 和 1.0 之间，而大于 1.0 的计算值表示函数中有错误。系数-1.0 表示完美的负相关和 1.0 表示完美的正相关。另一方面，系数 0.0 意味着两个变量之间没有关系。****

有许多不同的方法来计算两个变量的相关系数。最常见的就是所谓的皮尔逊相关系数 (r)** 。这是一种测试，用于测量两个正态分布变量之间的线性关系的强度。如果数据不是正态分布，可以使用 Kendall 和 Spearman 检验。**

由于 (r) 的取值范围在-1.0 到 1.0 之间，所以当接*零时，它的解释会变得困难。关于如何解释 (r) 的不同值，有许多经验法则，但最常见的一个可能是 2003 年由 Dennis E. Hinkle 和他的合著者在他们的《行为科学应用统计学》的介绍性文本中发表的。它旨在教导学生，并为解释相关系数的大小提供一个经验法则:

辛克尔德，威尔斯马 W，Jurs SG。行为科学应用统计学。第五版。波士顿:霍顿·米夫林；2003

意义

通过测量 (r) 值，我们量化了两个变量之间的关系有多强。但这只能告诉我们故事的一半，对吗？原因是我们计算的相关系数只代表一个样本，而不是整个群体。因此，虽然我们知道样本中的相关性，但我们不能确定我们量化的相关性是否代表整个总体。因此，我们现在要进行一个统计显著性检验**，它可以告诉我们，我们的观察结果是否可以预期在整个人口中是真实的。让我们一步一步地设置我们的测试:**

**步骤 1:制定一个假设**

在假设检验中，我们总是要提出两个假设。一个叫做零假设**，另一个叫做备择假设。他们通常陈述相反的结果:**

零假设 (Ho) 是我们试图反驳的假设。在我们的例子中，假设在给定的总体中，两个变量之间没有显著的线性相关性。

备选假设 (Ha) 是我们试图为之提供证据的假设。在这个例子中，我们将试图证明总体中存在线性相关。

**步骤 2:进行 T 检验**

不需要深入复杂的数学，T-检验(也称为学生 T-检验)允许我们在整个人口中检验一个假设。在我们的案例中，它将帮助我们发现我们在样本中观察到的相关性是否可以在整个人群中重现。

T 检验会给我们一个数字*【T】，我们必须依次解释这个数字。*【t】越高，相关性在群体内可重复的可能性越高。但这是为什么呢？

简单地说，T 检验计算两组之间的差异。在我们的例子中，我们使用 T-test 来比较一个没有相关性的组和一个有确定关系的组。如果我们观察到的相关性是由于巧合而发生的，(t)将等于 0 左右，这表明这两个群体是相同的*。*******

然而，如果两组显著不同*，则 t 值将高得多，并位于群体的极端。这表明我们观察到的相关性不是由于巧合，也不能在没有相关性的人群中找到:***

*# Creating a bell curve for illustration purposes
from scipy.stats import normx = np.arange(-4, 4, 0.001)
y = norm.pdf(x,0,1)fig, ax = plt.subplots(figsize=(9,6))
ax.plot(x,y)
plt.show()*

假设没有相关性的 Ho 的说明性总体。红色方块表示 Ha 和 a (t)值> 3.2 的交叉点，表明两组之间存在显著差异。作者创建的图像。

*****步骤 3:解释 p 值*****

由于 (t) 是一个依赖于总体的理论检验统计量，我们不知道我们观察到的 t 值是否很高。换句话说，范围从 0 到 1，000 的总体将具有不同于范围从 0 到 1 的总体的其他 t 值。为了克服这个小问题，每次 T-Test 也计算所谓的 p-value (p) 。

p 值向我们展示了我们可以在 Ho 人群中观察到该 t 值的概率。你也可以把它想象成一场飞镖游戏。 (p) 越高，你的飞镖落在上图中 0 附*的几率就越高。 (p) 越低，你打中中路的几率越低。

因此(p)越低，我们的 t 值越有可能位于其中一个极端，因此“足够高”来表明我们两个群体之间的显著差异。或者换句话说:p 越低，我们观察到的相关性由于巧合而没有发生的概率就越高。

第四步:决定假设

让我们进入最后一部分，看看最后一个问题——(p)需要多低？****

还是那句话，看情况。这取决于你为你的实验设定的显著水* (a)* 。显著性水*是 p 值的阈值。通常， (a) 被设置为 0.05 或 5% ，意味着大于该值的 p 值将导致接受零假设。或者换句话说:如果你不能 95%确定两组有显著差异，你不能拒绝零假设。***

假设当我们将 (a) 设置为 0.05 时，我们已经接收到 p 值 0.002。在这种情况下(p)低于我们的显著性水*，我们可以得出以下结论:

我们可以拒绝何而支持哈因为我们发现我们在样本中观察到的相关性可以在更大的人群中重复，并且不是巧合。

Python 示例

但是现在理论已经讲得够多了——让我们看一个现实生活中的例子，以及如何用 Python 完成所有这些！

你需要什么？

要完成本教程，您需要具备以下条件:

我们要做什么？

在本教程中，我们将看看 UCI 机器学习库提供的汽车数据集*。该数据集包括 1985 年以来汽车的技术和价格数据以及保险信息。数据集是开源的，通常用于训练/测试回归模型。***

我们将对这个数据集进行一些格式化，使其为我们所用，然后探索几个变量与变量价格的相关性*。***

***步骤 1:导入工作库***

首先，我们需要导入执行分析所需的库。如果您还没有安装它们，请在执行下面的代码之前检查相应的文档。

*# Import working librariesimport pandas as pd
import numpy as np
import seaborn as sns
from scipy import stats*

***步骤 2:加载数据***

*# Load data and show first 5 rowsdf = pd.read_csv("imports-85.csv")
df.head(5)*

数据框。作者创建的图像。

***步骤 3:格式化数据***

你有没有注意到——我们的数据集没有标题，而且有些值显示一个问号？这是我们在运行相关性分析之前应该解决的问题，否则我们的代码可能无法工作，得到的结果可能会失真。****

让我们在第一步中添加一些列名*，以便我们更容易理解数据集并使用它。***

*# Add headers to df and display first 5 rowsheaders = ["symboling", "normalized-losses", "make", "fuel-type", "aspiration", "num-of-doors", "body-style", "drive-wheels", "engine-location", "wheel-base", "length", "width", "height", "curb-weight", "engine-type", "num-of-cylinders", "engine-size","fuel-system", "bore", "stroke", "compression-ratio", "horsepower", "peak-rpm", "city-mpg", "highway-mpg", "price"]df.columns = headers
df.head(5)*

带标题的数据帧。作者创建的图像。

由于这看起来效果不错，我们现在应该看看归一化损失一栏中的这些问号。我们不能用它们来做进一步的分析，所以我们将用 NaN 值来替换值。注意，我们将在整个数据帧上调用 pandas.replace 函数，而不仅仅是在一列上。我们这样做是为了确保我们以后不会在数据集中的其他地方遇到另一个问号*。*******

*# Replace ? with NaN and show first 5 rows of dfdf = df.replace('?',np.NaN)
df.head(5)*

没有问号的数据框。作者创建的图像。

因为我们没有没有的概述，现在中缺少值，我们应该运行一个快速分析来找出 NaN 值。我们可以通过首先检查NaN 值的数据帧，然后使用 for 循环打印出我们的分析。

*# Check df for missing valuesmissing_data = df.isnull()
missing_data.head(5)*

使用 bolean 检查缺失值的数据框。作者创建的图像。

*# Run for loop to check for missing valuesfor column in missing_data.columns.values.tolist():
    print(column)
    print (missing_data[column].value_counts())
    print("")*

首先分析 for 循环的列。作者创建的图像。

如果您滚动分析，您会发现在下面的列中有个缺失值(=True)* 😗**

• 标准化损失
• 门的数量
• 钻孔
• 中风
• 马力
• 峰值转速
• 价格

因为我们需要一个有效的数据集，所以我们必须找到一种方法来处理缺失的数据。一般来说，有两种选择。要么我们丢弃带有丢失数据的列或行，要么我们替换丢失的数据。

由于我们的数据集不够大，不能简单地删除所有带有缺失值的行/列，我们将使用剩余数据的手段来替换缺失值。

唯一的例外是门的数量一栏，因为这个数据是而不是的数字。这里我们将用最常见的变体替换缺失数据。在这种情况下，那就是“四”。

*# Replacing NaNs with mean / most common variantavg_norm_loss = df["normalized-losses"].astype("float").mean(axis=0)
df["normalized-losses"].replace(np.nan, avg_norm_loss, inplace=True)avg_bore = df['bore'].astype('float').mean(axis=0)
df["bore"].replace(np.nan, avg_bore, inplace=True)avg_stroke = df['stroke'].astype('float').mean(axis=0)
df["stroke"].replace(np.nan, avg_stroke, inplace=True)avg_horsepower = df['horsepower'].astype('float').mean(axis=0)
df['horsepower'].replace(np.nan, avg_horsepower, inplace=True)avg_peakrpm = df['peak-rpm'].astype('float').mean(axis=0)
df['peak-rpm'].replace(np.nan, avg_peakrpm, inplace=True)avg_price = df['price'].astype('float').mean(axis=0)
df['price'].replace(np.nan, avg_price, inplace=True)df["num-of-doors"].replace(np.nan, "four", inplace=True)*

还剩下什么？对！检查数据表格*。我们可以通过执行以下代码轻松做到这一点:***

*# Checking df typesdf.dtypes*

数据框类型。作者创建的图像。

如你所见，一些列仍然有错误的数据类型(例如，bore 应该有整数)。所以让我们快速纠正一下:

*# Format data typesdf[["bore", "stroke"]] = df[["bore", "stroke"]].astype("float")
df[["normalized-losses"]] = df[["normalized-losses"]].astype("int")
df[["price"]] = df[["price"]].astype("float")
df[["peak-rpm"]] = df[["peak-rpm"]].astype("float")*

在数据标准化和规范化方面，我们还可以做得更多，但我们在本教程中不需要这些，所以让我们继续。

第四步:浏览数据

让我们快速回顾一下我们想要做的事情:我们想要寻找与汽车的价格有某种关联的变量，对吗？所以我们需要首先检查类型和形式这两个变量之间的关系——最简单的方法就是多画一些图！****

但事不宜迟，让我们开始看看价格与以下因素的关系:

发动机尺寸 看看下图。我们可以观察到线性回归线与绘制的数据非常吻合。我们还可以观察到回归线有一个陡峭向上的梯度。但是考虑到相关性的类型和形式，这告诉我们什么呢？****

虽然回归线的递增梯度向我们表明，我们可以预期发动机尺寸和价格之间存在正相关性，但回归线的良好拟合表明变量之间存在线性相关性。****

***# Create a plot for engine-size and pricesns.regplot(x="engine-size", y="price", data=df)***

发动机尺寸和价格的回归图。作者创建的图像。

下图向我们展示了公路每加仑英里数(mpg)与汽车价格的回归曲线。这里我们可以观察到回归线是递减，表示一个负相关。然而，我们可以看到回归线没有覆盖 x 轴上 0 到 25 之间的异常值。这表明线性回归不是一个很好的拟合，并表明数据可能是非线性的。****

***# Create a plot for highway-mpg and pricesns.regplot(x="highway-mpg", y="price", data=df)
plt.ylim(0,)***

公路回归图-mpg 和价格。作者创建的图像。

峰值转速 峰值转速和价格的图形看起来又不一样了。我们看到数据点有很大的变化，回归线几乎水*。基于这一观察，我们无法确定我们可以预期的相关形式，但是假设存在线性关系，则*乎*坦的回归线表明我们可以预期在 0 附*的相关系数。因此，我们可以得出结论，峰值转速和价格之间没有相关性。****

***# Create a plot for peak-rpm and pricesns.regplot(x="peak-rpm", y="price", data=df)
plt.ylim(0,)***

峰值转速和价格的回归图。作者创建的图像。

由于逐个查看每个变量对需要花费很长时间，我们可以使用 panda 的 corr() 函数来缩短这个过程:

***# Using pandas corr() functiondf.corr()***

熊猫的 Corr()函数。作者创建的图像。

如您所见，pandas 的 corr() 函数创建了一个相关矩阵，其中包含了我们数据集中的所有变量。你可能会问——为什么我们不从一开始就这样做呢？****

答案比较简单。虽然 corr() 函数默认计算皮尔逊相关系数，但它不会给出任何关于形式相关的信息。因此，它可以作为一个很好的起点来识别潜在的高相关性，但是单独检查变量对仍然是必要的。****

步骤 5:计算相关性和(p)值

在我们继续之前，让我们快速总结一下上述分析的结果:

• 我们可以预期发动机尺寸和价格之间存在正的线性关系
• 我们已经观察到公路里程数和价格之间的负相关性，这似乎是非线性的 T21。
• 我们假设 T22 峰值转速和价格之间没有相关性,并且我们没有相关形式的可靠信息 T24。

因此，我们可以得出这样的结论:变量 highway-mpg 和 peak-rpm 似乎不适合使用皮尔逊相关系数进行进一步分析。****

为了进一步了解引擎大小，我们可以借助 scipy.stats 库来计算皮尔逊相关系数以及 p 值。

***# Calculate pearson coefficient and p-valuepearson_coef, p_value = stats.pearsonr(df['wheel-base'], df['price'])print("The Pearson Correlation Coefficient is", pearson_coef, " with a P-value of P =", p_value)***

打印报表。作者创建的图像。

结果，我们得到的皮尔逊相关系数为 ~ 0.87 ，p 值几乎为 0 。

由于我们的系数> 0.7，但是<0.9, we conclude that we are observing a 发动机尺寸和价格之间的正相关性很高。

最后，我们可以观察到我们的 p 值肯定是低于我们的显著性水*(a)0.05。因此，我们可以得出结论，我们上面计算的相关性不是巧合，因此是重要的。****

最后的话

如果我不说出下面这句著名的话，这就不是一个好的教程:

相关性并不意味着因果关系。

我们已经知道相关性是描述两个变量之间关系程度的一种度量。因果关系另一方面是两个变量之间的因果关系。****

即使我们观察到了相关性，我们也不能断定一个变量会引起另一个变量的变化。除非我们已经能够考虑所有不同的变量，否则我们不得不假设仍然有机会巧合或者第三个因素可能导致我们两个变量都发生变化。****

因此，在得出关于相关数字的最终结论之前，进行更全面的实验总是很重要的。****

2021 年数据科学家的 Python 字符串操作

原文：https://towardsdatascience.com/python-string-manipulation-for-data-scientists-in-2021-c5b9526347f4?source=collection_archive---------27-----------------------

破解数据科学面试

使用不同的重量训练你的 Python 编码肌肉

照片由pix poeties在 Unsplash 上拍摄

数组和字符串操作是数据科学和软件工程面试中测试最多的话题之一。这是测试候选人程序性思维能力和编码流畅性的最佳面试题型。要想表现出色，我们必须熟悉数组/字符串、矩阵及其行/列结构的基本操作，以及 Python 语法。

在两篇类似的博客文章中，我已经触及了一些基本问题，并对几个真实的面试问题进行了现场编码。

</6-python-questions-you-should-practice-before-coding-interviews-f958af55ad13>

在今天的帖子中，让我们尝试一些不同的东西。正如Emma Ding(Airbnb 的数据科学家)和Rob Wang(robin hood 的数据科学家)的帖子所建议的那样，我们可以通过对同一个问题提出多种解决方案，同时比较和对比它们的优缺点，来显著提高我们对各种算法的理解。

这正是我们在这篇文章中要做的！

我每天都在用 Python 写代码，并在这里记录了我的进步。如果您是编程新手，或者正在积极准备数据科学和软件工程面试，让我们组队一起编写代码。

问题 1:在一个排序矩阵中计算负数，亚马逊和苹果

走过我的思考

亚马逊和苹果都问这个问题。作为热身，我们可以使用野蛮武力，直接迭代矩阵:检查一个元素是否为负数。

在 Python 中，我们可以做如下事情:

解决方案 1:嵌套 For 循环

8

第 3 行:使用 for 循环遍历行

第 4 行:使用 for 循环遍历列

这里，我们使用一个嵌套的 for 循环来遍历矩阵并检查单个元素:如果元素是负的，count 就加 1。这是计算计数值的典型算法。

但是，缺点是计算效率低。它的时间复杂度 O(N)在运行时间上被认为是“恐怖的”。双 for 循环方法不适用于大型矩阵(例如，一百万行/列的矩阵)。

顺便提一下，如果你不熟悉数据结构和算法(DSA) ，你可能会发现下面的各种时间复杂度的比较很方便。在绿色和黄色区域，我们有 O(1)、O(log N)和 O(N)。在红色区域，我们有 O(N！)、O(2^N)和 O(N)。

【https://www.bigocheatsheet.com 号

O(N)是第三差的算法，仅比 O(N！)和 O(2^N).在真实的面试环境中，如果答案的时间复杂度为 O(N ),你的面试官总是会要求改进。

解决方案 2:导入包

8

如果我们被允许导入一个包，我们可以把矩阵变成一个 Numpy 数组，然后把它展*。然后，我们使用 for 循环来计算负值的数量。这种方法既快速又简单。它具有线性时间复杂度 O(N)，比 O(N)好得多。

如果你是 Python Numpy 和矩阵运算的新手，请查看我关于这个主题的另一篇文章:

然而，面试官可能会禁止外包，并希望增加一些趣味。

解决方案 3:二分搜索法

重新检查原问题后，有一个隐藏的条件，即按行和列的非递增顺序排序 ，，这让我们想起了一个二分搜索法。

这是算法的基本逻辑。

我们创建一个由三个值限定的搜索空间——低(左)、中和高(右)——并找到一行中第一个负元素的位置，即-1。

如果选择的值是正数，我们向右移动并搜索更小的值，因为数组是按非递增顺序排序的。如果选择的值是负的，我们向左移动并搜索一个更大的值。

这是一个相当简单的算法总结，请查看我关于这个主题的另一篇文章:

8

与经典的二分搜索法算法(O(log(N))不同，我们将其嵌套在 for 循环(O(N))中。总的来说，其时间复杂度为 O(N*log(N)) 。就运行时间而言，它介于第一种方法 O(N)和第二种方法 O(N)之间。

问题 2:用右边最大的元素替换亚马逊的元素

走过我的思考

亚马逊包括这个问题。对于一个数组，我们必须用它右边最大的元素替换每个元素。我们可以使用野蛮的武力，如下。

解决方案 1:暴力

[18, 6, 6, 6, 1, -1]

唯一的警告是我们必须保存最后一个元素并用-1 替换它。我们省略了第 5 行的最后一个元素，并将-1 加回第 8 行的数组。

解决方案 2:反转和替换

[18, 6, 6, 6, 1, -1]

第二种解决方案是向后迭代元素，首先读取最后一个元素:如果它大于右边的元素，则更新值。虽然这两种解决方案的运行时间相同，但是第二种方法最酷的地方在于它对最后(最右边)位置的处理。很多时候，我们会错过这些特例。

#问题三:三连冠赔率，由大疆

走过我的思考

大疆问这个问题。我的首选算法是采用野蛮力法，检查三个连号是否都是奇数，如下:

解决方案 1

False

上述解决方案的唯一问题是 else 语句的缩进:它应该与 for 语句*行，而不是在 for 语句内部。另外，请不要忘记在第 2 行指定搜索边界。

解决方案 2

一种类似但更有技巧的方法是在 for 循环中设置一个计数器:如果计数达到 3，则返回 True。如果整个 for 循环不包含任何 3 个连续元素，则函数返回 False。因此，else 语句应该在 for 循环的外部，而不是内部。你的面试官可能会问这个缩进问题。

False

老实说，我只提出了第一个解决方案，并不得不检查其他人关于 Leetcode 的第二个解决方案，这是更 Pythonic 式的思维。

外卖食品

• 熟能生巧！坚持每天阅读和练习可以显著提高每个人的编码技能。
• 提高编程最有效的方法是掌握基础知识，并将它们融入到你的日常工作中。
• 与其他 Python 问题相比，数组和字符串操作更简单，并且测试考生的基础知识。破解这类面试题需要时间和练习。

Medium 最*进化出了它的 作家伙伴计划 ，支持像我这样的普通作家。如果你还不是订户，通过下面的链接注册，我会收到一部分会员费。

https://leihua-ye.medium.com/membership

我的数据科学面试序列

</5-python-coding-questions-asked-at-faang-59e6cf5ba2a0>

喜欢读这本书吗？

请在 LinkedIn 和 Youtube 找到我。

还有，看看我其他关于人工智能和机器学习的帖子。

Python 结构化模式匹配——帮助您入门的 3 大用例

Python 3.10 增加了对 switch 语句的支持——这里有 3 个实用的例子来帮助您入门

Python 的等价语句switch终于在 Python 3.10 中出现了。它隐藏在一个有趣的名字结构模式匹配的后面，做你所期望的和更多的事情。它支持处理原始数据类型、序列，甚至类和枚举。

今天我将向你展示如何开始，并讨论在什么情况下你应该使用它。我们将从创建一个基于 Python 3.10 的新环境开始。

不想看书？请观看我的视频:

如何配置 Python 3.10 环境

我们将使用 Anaconda 创建一个新的虚拟环境。如果您使用其他工具来管理 Python 工作流，请在线搜索等效的命令。

从终端逐行执行以下命令，创建一个名为py310的新 Python 3.10 虚拟环境，安装并启动 Jupyter Lab:

conda create — name py310 python=3.10
conda activate py310
conda install jupyter jupyterlab
jupyter lab

现在，您可以使用以下命令来验证您使用的是 Python 3.10(假设您使用的是 Jupyter 或 Python shell):

你应该看到3.10.0打印出来，这意味着你可以走了。

Python 结构化模式匹配-基本语法

在深入到用例之前，让我们先了解一下结构模式匹配背后的基本语法。整个事情基于两个关键词:

• match —您想要评估条件的受试者。它可能是 API 请求返回的状态代码。
• case —评估个体条件以查看是否确认匹配。

下面是来自官方文档的模式匹配的一般语法:

如您所见，Python 中的结构化模式匹配不需要在每个案例的结尾使用break 语句。如果在其他案例中没有找到精确匹配，将使用最后一个案例(_)。

您现在已经了解了基础知识，所以让我们深入到示例中。

Python 结构化模式匹配-匹配简单值

先说一个简单的。我们将编写一个名为 http_error()的函数，它接受一个状态代码。然后，我们将使用状态代码作为匹配语句的主题，并针对不同的条件编写几个案例:

仅供参考，您可以使用|在一个模式中组合多个条件。例如，状态代码 401、403 和 404 返回相同的结果，因此编写三个不同的案例没有意义。

现在让我们用不同的状态代码调用 http_error()函数来验证它是否正常工作:

图片 Python 中的基本结构模式匹配(图片由作者提供)

如你所见，即使你传入一个字符串，这个函数也不会崩溃。接下来，我们将深入更高级的用例。

Python 结构化模式匹配-匹配复杂模式

有时候匹配一个变量是不够的。好消息是——您可以在 Python 的匹配语句中加入几乎任何可以想象的东西。

看看下面的代码片段——它声明了一个名为get_service_level()的函数，该函数将用户数据作为字典接受。目标是基于用户订阅类型(免费，高级)和消息类型(信息，错误)，返回不同的服务级别。在 info 消息的情况下，不管订阅类型如何，服务级别都是 0。在有错误消息的自由用户的情况下，服务级别是 1。最后，在高级用户出现错误消息的情况下，服务级别是 2:

在一个关键词后面写一本字典有点不自然，但这是你必须习惯的事情。无论如何，以下是对所有四种可能情况的测试:

*图 2 —匹配 Python 中的复杂模式(图片由作者提供)*

您可以通过添加默认案例来进一步改进该功能，但是您已经知道如何做了。

Python 结构化模式匹配-匹配类中的模式

可以对 Python 的类和数据类使用结构模式匹配。文档向您展示了如何使用数据类，所以我将在这里介绍常规的数据类。简而言之，您可以使用一个类名，后跟一个作为 case 模式传递给构造函数的参数列表。

以下示例向您展示了如何在 Python 类中实现相同的服务级别逻辑。向构造函数传递了两个参数—订阅类型和消息类型。对于任何信息消息，级别为 0。在自由用户出错的情况下，级别为 1。最后，在高级用户出错的情况下，级别为 2。我们还将添加一个默认案例，只是为了混淆一下:

语法与第二个例子中的不同，但仍然可以理解。我认为它也更容易阅读。假设您有两个以上的参数——将它们作为字典传递会很快变得混乱。

让我们针对四种可能的场景和一种默认情况进行测试:

图片 Python 类中的结构模式匹配(图片由作者提供)

很管用。让我们在这里停止使用实际的例子，把焦点转移到一个重要的问题上——什么时候应该使用结构模式匹配？

最后的想法

Python 中早就应该有一个专用的switch语句了。结构模式匹配打包了 switch 语句所做的一切，甚至更多。这是一种书写和评估条件的新方法。但是正如科里·泰勒曾经说过的那样——新并不意味着最好。

如果你所做的只是测试简单的条件，那么在结构模式匹配上费心是没有意义的。此外，结构模式匹配仅在 Python 3.10 中可用。如果您尝试使用旧的 Python 版本，将会得到一个错误。值得升级吗？

当您有更复杂的模式要评估时，主要使用结构化模式匹配，就像今天讨论的那些。

*你们觉得结构模式匹配怎么样？你是否用它替换了你的一些旧代码，为什么？*请在下面的评论区告诉我。

https://medium.com/@radecicdario/membership

保持联系

• 注册我的简讯
• 在 YouTube上订阅
• 在 LinkedIn 上连接

Python 模板字符串格式化方法

原文：https://towardsdatascience.com/python-template-string-formatting-method-df282510a87a?source=collection_archive---------11-----------------------

关于模板字符串的详细信息，这是 python 中格式化字符串的一个选项。当使用正则表达式时，它可能更合适

照片由来自佩克斯的克里斯蒂娜·莫里洛拍摄

模板字符串是 Python 中用来格式化字符串的另一种方法。与%运算符相比，。format()和 f 字符串，它有一个(可以说)更简单的语法和功能。对于国际化(i18n) 来说，这是的理想选择，并且有一些细微差别您可能会发现是有利的——尤其是在使用正则表达式( regex )时。

我们先看看其他三个的语法，这样就可以比较了。

%运算符

>>> name = "Alfredo"
>>> age = 40
>>> "Hello, %s. You are %s." % (name, age)
'Hello, Alfredo. You are 40.'

。格式()

>>> print('The {} {} {}'.format('car','yellow','fast')) **#empty braces** The car yellow fast>>> print('The {2} {1} {0}'.format('car','yellow','fast')) **#index** The fast yellow car>>> print('The {f} {y} {c}'.format(c='car',y='yellow',f='fast')) **#keywords** The fast yellow car

f 弦

>>> name = "Peter"
>>> print(f'Nice to meet you, {name}')

模板字符串

它使用字符串模块中的模板类。它的语法有点类似于。format()，但是它没有使用花括号来定义占位符，而是使用了美元符号(\()。\)也是有效的，当占位符后出现有效字符串时，它应该出现。

参见各种情况的语法。我将开始解释 safe_substitute 和 regex 的用法。

安全替换和正则表达式

假设您想要替换包含、%和$的字符串中的某个内容。使用正则表达式时会发生这种情况。

考虑一个输入字段，该字段接受公司股票代码加上百分比形式的正(+)或负(-)值，之后不接受任何内容。并且符号加号+被动态替换。比如:AAPL: +20%或者 TSLA: -5%(我知道这可能是一个愚蠢的用例！但是请忽略。只是一个例子)。

regex:([symbol:+或-][0–9]{ 1，4}[%])$)

对于%运算符，。format()和 f 字符串—不起作用。%运算符和。format()会引发错误，f-strings 会移除{m，n}。见下文

**#% operator**
>>> print('(([%s][0-9]{1,4}[%])$)' % "AAPL: -")
*TypeError: not enough arguments for format string***#.format()** >>> print('(([{symbol_pos_neg}][0-9]{1,4}[%])$)'.format(symbol_pos_neg = 'AAPL: +'))
*KeyError: '1,4'***#f-strings** >>> symbol_pos_neg = "AAPL: +"
>>> print(f'(([{symbol_pos_neg}][0-9]{1,4}[%])$)')
(([AAPL: +][0-9]*(1, 4)*[%])$)

虽然通过对字符进行转义(将花括号或百分号加倍)可以很容易地解决这个问题，但我觉得这很不方便。使用模板字符串，您不需要这样做。和%不用于定义占位符，并且通过使用 **safe_substitute，**您不必替换所有的$。

见下文，正则表达式不变，$symbol_pos_neg 被正确替换。

>>> print(Template('(([$symbol_pos_neg][0-9]{1,4}[%])$)').**safe_substitute**(symbol_pos_neg='AAPL: -'))(([AAPL: -][0-9]{1,4}[%])$)

带关键字的常规案例

>>> from string import Template
>>> Template('$obj is $colour').substitute(obj='Car',colour='red')
'Car is red'

带字典的普通箱子

**>>>** d = dict(obj='Car')
**>>>** Template('$obj is red').substitute(d)
'Car is red'

占位符后跟无效字符

如果占位符后有无效字符串，则只考虑占位符。示例，请参见“.”$who 后面的点号。正常打印。

>>> from string import Template
>>> Template('$obj**.** is $colour').substitute(obj='Car',colour='red')
'Car. is red'

占位符后跟有效字符

如果占位符后有有效字符，则必须用花括号括起来。

>>> from string import Template
>>> Template('${noun}ification').substitute(noun='Ident')
'Identification'

请注意，下划线(_)等字符也被认为是有效的。因此，使用$的规则同样适用。

多个$$$符号

替换照常进行，并打印出一个额外的$值。

>>> Template(’$obj. is $$$colour’).substitute(obj=’Car’,colour=’red’)
'Car. is $red'

最后的想法

我仍然是 Python 的初学者，比较字符串格式化方法教会了我很多。我希望我已经清楚地向你提供了细节。尽管模板字符串的功能不如:

viniciusmonteiro$ python3 -m timeit -s "x = 'f'; y = 'z'" "f'{x} {y}'"5000000 loops, **best of 5: 82.5 nsec per loop**viniciusmonteiro$ python3 -m timeit -s "from string import Template; x = 'f'; y = 'z'" "Template('$x $y').substitute(x=x, y=y)"  # template string500000 loops, **best of 5: 752 nsec per loop**

我认为在某些情况下，它在简单和方便方面带来了一些好处。虽然我知道这些可能是主观的。

参考

[1] [string](https://docs.python.org/3/library/string.html#module-string) —常见字符串操作https://docs . python . org/3/library/string . html # template-strings

[3]Python 中不同字符串连接方法的性能——为什么 f 字符串如此出色https://grski.pl/fstrings-performance.html

Python:知道和理解它的区别

原文：https://towardsdatascience.com/python-the-difference-between-knowing-and-understanding-it-3b2ebd4e2317?source=collection_archive---------33-----------------------

你知道 Python 中列表的调整因子是什么吗？

Artem Sapegin 在 Unsplash 上拍摄的照片

我只是在开玩笑。你不需要知道 Python 的列表大小调整因子就能很好地理解它。但是如果你想了解更多，请阅读这里的！

我来自一个非计算机科学(CS)和非技术背景的人，当我刚开始机器学习(ML)的旅程和职业生涯时，我遭受了 CS 基础知识的缺乏。这包括理解渐*运行时间、内存使用、数据结构、算法等等。更糟糕的是，我在没有工程基础的情况下直接进入了 ML——我甚至不知道类中的 self 是什么意思(在 Python 上下文中)。我是*。*

足够幸运的是，有了足够的 ML 概念但缺乏工程知识，我在 ML 中获得了立足点，并开始了我的旅程学习和实践 ML。在这段旅程中，我很快意识到工程在 ML 工程中扮演着重要的角色。然而，事实上，知道如何简单地使用一种编程语言和很好地理解它之间有着明显的区别。

在你说你真正理解 Python 之前，你应该知道以下一些事情。本文分为几个部分:

1. Python 中的一切都是对象
2. 内置 Python 对象不包含 dict 属性
3. 指针在 Python 中本来就不存在
4. Python 的可变默认值是一切邪恶的根源
5. 复制 Python objects

1.Python 中的一切都是对象

好吧，我们从简单的开始。我相信大多数读者都知道 Python 是一种面向对象的编程语言。但是这到底意味着什么呢？

当我说一切时，我指的是一切*。不仅用户定义的函数和类是对象，内置类型也是对象！本质上——一切 。*

正如您将在后面的第(3)点中看到的，Python 中的对象包含元数据(也称为属性*)以及一些功能(也称为方法)。要查看与对象相关的所有关联元数据和功能，可以使用内置的dir()函数。*

*# Look at the metadata of an integer object
x = 1
dir(x)
>>> **['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']***

我们可以观察到，即使整数类型本身也是具有内置属性和方法的对象。例如，我们可以通过real和imag属性获得一个复数的实部和虚部。

*real_x, imag_x = x.real, x.imag
print(f"Complex number of {x} is: {real_x} + {imag_x}i")
>>> **Complex number of 1 is: 1 + 0i***

还有可以调用的方法包括as_integer_ratio()、bit_length()等等。

*x.as_integer_ratio()
>>> **(1, 1)**x.bit_length()
>>> **1***

此外，这些对象具有这些内置的 dunder 方法的事实允许它们执行某些操作，如加法(__add__)、转换为浮点(__float__)，甚至获得对象的可打印表示(__repr__)。

随意探索其他内置数据结构的内置属性和方法，如列表、元组、字典等等！

2.内置 Python 对象不包含 dict 属性

如果你还不知道，我们可以使用内置的vars函数返回一个对象的__dict__属性，如果它存在的话。让我们看看如果在内置 Python 对象上使用这个函数会发生什么。

*x, y, z = 1, "hello", {"hello": 1}vars(x)
>>> **TypeError**: **vars() argument must have __dict__ attribute**vars(y)
>>> **TypeError**: **vars() argument must have __dict__ attribute**vars(z)
>>> **TypeError**: **vars() argument must have __dict__ attribute***

因此，我们无法通过setattr()函数为内置 Python 对象设置新的属性和方法，也无法覆盖现有的属性和方法。之所以如此，是因为使用 C 进行了优化，防止添加额外的属性，从而允许更多的“固定”内存分配。

*setattr(x, "some_new_attr", 123)
>>> **AttributeError: 'int' object has no attribute 'some_new_attr'***

然而，对于定制对象，我们可以自由地创建新的属性，因为这些对象通常有一个__dict__属性。这是因为__dict__属性是一个映射对象，用于存储对象的可写属性。

注意:在类上调用vars时要小心，因为在类本身上调用vars和在该类的实例上调用vars是有区别的。

*vars(Animal)
>>> **mappingproxy({{'__module__': '__main__',
                   '__annotations__': {'has_eyes': bool},
                   'mammal': True, ... }})***

3.指针在 Python 中并不存在

你可能会好奇——列表、集合、字典甚至数据帧都可以修改，它们的内存地址保持不变。什么叫指针不存在？！

注 : *id()*用于获取对象的内存地址

*# Example using a list (or any other mutable data structure)
x = [1, 5, 10]
id(x)
>>> **140298465662784**x.pop()
id(x)
>>> **140298465662784***

上述数据结构作为可变类型存在的事实模仿了Python 中指针的功能。实际上，你已经为其分配了变量的可变对象并不真正拥有那个内存地址。

那么 Python 是如何跟踪对象的呢？

在 Python 中，对象被存储为 PyObject s，这实质上是所有具有 CPython 结构的 Python 对象的基础结构。当我们检查两个对象是否相等时，即a is b，我们实际上是在检查这两个对象的内存地址是否相同。

创建任何对象时，都会创建一个 PyObject，它跟踪数据类型、值以及最重要的引用计数*(即指向它的名称/变量的数量)。因此，更恰当的说法是 Python 中的每个名称/变量都是一个对 PyObject 的 引用 。*

*# As seen below, x and y point to the same PyObject
# Each of them do not own the memory addressx = "hello"
y = "hello"id(x) == id(y)
>>> **True**# The PyObject looks something like this
# Type: str; Value: "hello"; Reference Count: 2*

如上所述，像 int 、 str 和元组这样的不可变数据结构并不拥有自己的内存地址，而是将名称/变量绑定到引用(p objects)。

注:上面这个用字符串(“hello”)的例子是字符串实习的一个特例。通常情况下，不可变对象将具有不同的内存地址，其他例外情况有整数缓存或空不可变对象发生或发生。为了更清楚地理解 Python 中可变和不可变数据结构的内存管理，我强烈推荐这篇文章！

那么，可变数据结构的行为如何像指针呢？

可变数据结构是不同的，因为我们能够修改它的值而不需要修改它的内存地址。这样，包含相同值的相同列表(或任何其他可变数据结构)将而不是具有相同的内存地址。

*x = [1, 5, 10]
y = [1, 5, 10]
id(x) == id(y)
>>> **False***

RealPython 的这篇文章对于理解 Python 中的“指针”非常有用。

你可能会问，这有什么关系？嗯，这就引出了我的下一个观点。

4.Python 可变缺省值是所有罪恶的根源

因为可变对象模拟了指针的功能，所以当用作函数或方法中的默认参数时，它也可能是万恶之源。

***常见用例:*列表(或其他可变数据结构)作为默认参数

正如你在下面的例子中看到的，这个在arr中使用List作为默认参数的increment_list函数可能会导致很多问题，因为在这个函数的return之后赋值的任何变量都拥有相同的内存地址(或对象*)。这实质上意味着这个可变对象的值甚至可以在函数之外修改。*

那么，可变数据结构应该如何被用作默认参数呢？

使用None作为默认值，并在函数中检查它。这确保了在创建新列表时，总是为这个List对象创建一个新的内存地址。

如何创建可变对象的副本？

我们可以在这些数据结构中使用.copy()方法来获得对象的副本。但是请注意，复制一个对象的结果是复制它，因此会消耗额外的内存。在进行复制时请记住这一点，尤其是在复制较大的对象(在内存中)时。这就把我带到了文章的最后一点— 复制 Python 对象。

*a = {1: 'hello'}
b = a.copy()
id(a) == id(b)
>>> **False***

5.复制 Python 对象

正如我们在上面看到的，我们使用了字典数据结构的内置copy方法。这实际上是创建了对象的浅拷贝，而不是深拷贝。有什么区别？

• 一个浅拷贝意味着构造一个新的集合对象，然后用在原始对象中找到的子对象的引用填充它。本质上，浅抄只是深一级*。复制过程不会递归，因此不会创建子对象本身的副本。[4]*
• 一个深度复制使复制过程递归。它意味着首先构造一个新的集合对象，然后用原始集合中找到的子对象的副本递归地填充它。以这种方式复制对象会遍历整个对象树，从而创建原始对象及其所有子对象的完全独立的克隆。[4]

以上到底是什么意思？让我们来看一些例子。

好吧，这里刚刚发生了什么？在上面的例子中，我们看到list()和.copy()都创建了原始列表的浅层副本，而来自副本模块的deepcopy()创建了深层副本。

最初检查时，我们确实希望所有副本都有自己的内存地址，因为它们是可变对象。然而，再深入一层*(对象中的对象)，我们观察到第一个索引中的第一个列表与浅拷贝的原始列表具有相同的内存地址！这也适用于原始列表中的其他子对象(列表)。对于深层副本，这是另外一种情况，因为我们已经递归地创建了包含这个副本的列表。*

如果我们修改原始或复制的对象会发生什么？

从上面可以看出，修改原始或浅复制对象的子对象将导致原始和浅复制对象的改变。深层复制的对象不受影响。

如果我们修改一个自定义类会发生什么？

我们不仅可以从内置对象中看到这种行为，还可以从自定义对象(如自定义类)中看到这种行为。下面，我们创建一个包含三个像素值作为属性的RGB类和一个接受两种颜色的复合TwoColors类，特别是RGB类的两个不同实例。

***问题:*如果我们修改pixel的属性，你认为会发生什么？

*pixel.red, pixel.blue, pixel.green = 100, 100, 100pixel
>>> **RGB(100,100,100)**pixel1
>>> **RGB(255, 255, 255)**pixel2
>>> **RGB(255, 255, 255)***

希望你没弄错——是的，复制的对象没有**变化，因为这是一个单独的层对象。**

问题:如果我们修改复合对象colours中的子属性的属性会怎么样？

*colours.colour_one.red, colours.colour_two.blue = 111, 77colours
>>> **TwoColours(RGB(111, 0, 0), RGB(255, 255, 77)**colours1
>>> **TwoColours(RGB(111, 0, 0), RGB(255, 255, 77)**colours2
>>> **TwoColours(RGB(0, 0, 0), RGB(255, 255, 255)***

如您所料(希望如此)，深度复制的对象不会修改其值，因为它是原始对象的完整副本。

结束语

至此，我希望您从这篇文章中学到了一些东西，并巩固了您的 Python 知识。感谢您的阅读！

如果你喜欢我的内容，并且没有订阅 Medium，请考虑支持我并通过我的推荐链接订阅这里 ( 注:你的一部分会员费将作为推荐费分摊给我)。

参考

Python，系统路径以及 conda 和 pyenv 如何操纵它

原文：https://towardsdatascience.com/python-the-system-path-and-how-conda-and-pyenv-manipulate-it-234f8e8bbc3e?source=collection_archive---------5-----------------------

深入探究当您键入“python”时会发生什么，以及流行的工具是如何操作的

都铎·巴休在 Unsplash 上的照片

系统路径(在 Mac/Linux 上的echo $PATH或echo -e ${PATH//:/\\n}版本稍微漂亮一点)不仅仅是 python 的事情，它对 python 的功能也非常重要。如果你打开一个命令行，输入一个“命令”，计算机(或“操作系统”)需要知道在哪里寻找这个命令，找到它的底层代码，然后“执行”它。这些“命令文件”通常被称为可执行文件，当你键入与它们的文件名匹配的单词时，它们就会运行。

让我们以echo为例。当我们键入echo $PATH时，我们的计算机需要知道在哪里找到命令echo的代码，并通过传入一个参数$PATH来执行它。我们可以通过下面的代码看到代码在哪里:

> whereis echo
/bin/echo

其中whereis是我们的计算机知道如何定位的另一个可执行文件:

> whereis whereis
/usr/bin/whereis

有意思。他们坐在两个不同的位置。如果我们在这两个地方有相同的可执行文件名称会怎么样？我们会执行哪一个？

系统路径排序

$PATH变量决定了这一点，幸运的是，操作系统做了简单的事情，从左到右/从上到下地完成了它。作为一个例子，让我们看看我的系统变量$PATH的如下输出:

> echo -e ${PATH//:/\\n}
/usr/local/bin
/usr/bin
/bin
/usr/sbin
/sbin

假设我们去寻找一个名为myspecialexec的可执行文件。我们的系统将从顶层开始。在这种情况下，它将在目录/usr/local/bin中查找名为myspecialexec的可执行文件。如果找到了，就执行它。如果没有找到，它就移动到路径中指定的下一个目录——在这种情况下是/usr/bin,如果没有找到，就移动到/bin,依此类推。

这和 Python 有什么关系？

Python 是可执行的。当你运行brew install python或前往这里并运行 python 安装程序时，这就是你正在下载的东西(连同标准库和一些其他东西)。您正在执行以下操作之一:

• 获取 python 可执行文件，并将其粘贴到$PATH中的上述目录之一
• 获取 python 可执行文件并粘贴到其他地方，然后确保目录名现在在$PATH中

因此，当您运行命令python时，您的操作系统开始向下滑动$PATH列表，寻找它能找到的第一个匹配的名字。如果您有多个版本，那么它将使用最先找到的版本。**如果你有一个你想让它找到的版本，那么你应该把那个 python 版本的位置放在路径的顶部。**最后一点是理解(和简化)所有这些工具“管理环境”和“管理 python 版本”的关键。一旦我们理解了我们的计算机如何决定使用哪个版本的 python，像包管理这样的其他事情就非常简单了。

例 1:conda 是如何做到这一点的，所以我们使用基于 conda 环境的正确版本的 python？

它的“较轻”版本， miniconda ，是大多数人在谈论“康达”时谈论的内容。如果您要前往这里并安装它，您现在就会这样做，就像使用 python 一样:

• 在你电脑的某个地方有一个conda可执行文件
• 通过位于$PATH变量中的某个位置，该可执行文件将对您的 shell/终端可见

这意味着当你在终端中输入conda时，它会知道如何执行 conda 附带的功能。

那么 conda 如何确保你使用的是想要的 python 版本呢？

通过操作$PATH 变量，特别是利用它自顶向下的特性。为了建立一个例子，让我们做以下事情。假设安装了 conda，并且您打开了一个新的终端/外壳，您将看到:

(base) >

即，您将被定向到为您自动创建的默认基础 conda 环境。这里的目的不是谈论环境创建，而是说 conda 已经在某个地方创建了一个“基础”目录。在该目录中，它放置了:

• 该环境附加到的 python 版本(因此，每次在基本环境中键入python时，它都会运行相同版本的 python)
• 您可以为该环境下载的所有其他软件包依赖项

这个目录到底在哪里？我们可以通过使用命令which python看到:

(base) > which python
/Users/jamisonm/opt/miniconda3/bin/python

好极了。所以 conda 在某个地方创建了一个目录，并在其中放了一个我们可以调用的 python 版本。但是当我们在这个环境中的时候，我们的计算机怎么知道调用这个版本的 python 呢？因为它将该目录放在了$PATH 的顶部。我们可以证实这一点:

(base) > echo -e ${PATH//:/\\n}
/Users/jamisonm/opt/miniconda3/bin
/usr/local/bin
/usr/bin
/bin
/usr/sbin
/sbin

现在，当我停用环境，即我不想再使用这个环境和相应的 python 版本时，会发生什么？

(base) > conda deactivate

> echo -e ${PATH//:/\\n} # environment disabled so lose the (base)
/usr/local/bin
/usr/bin
/bin
/usr/sbin
/sbin

> which python
/usr/bin/python

所以conda deactivate已经从系统路径的顶部移除了/Users/jamisonm/opt/miniconda3/bin，所以我们默认使用之前的自顶向下搜索，并最终在/usr/bin/python中找到预装的 python。

创造一个新的环境怎么样？让我们创建一个名为conda-demo的新环境。

> conda create --name conda-demo
> conda activate conda-demo
(conda-demo) > echo -e ${PATH//:/\\n}
/Users/jamisonm/opt/miniconda3/envs/conda-demo/bin
/usr/local/bin
/usr/bin
/bin
/usr/sbin
/sbin

因此，康达又一次做到了以下几点:

• 在某个地方创建了一个文件夹(/Users/jamisonm/opt/miniconda3/envs/conda-demo/bin)来存放附加到这个环境中的 python 版本(以及其他潜在的下载包)
• 将该目录放在$PATH 的顶部，这样当我们键入python时，它会执行存在于该目录中的 python，而不是位于$PATH变量下方的目录

示例 pyenv 是如何做到这一点的，以便我们根据特定的环境使用正确的 python 版本？

与 conda 不同， pyenv (最初)并不是一个完全成熟的环境管理器，但更倾向于解决以下问题:

“我如何在同一台计算机上处理使用不同版本 python 的多个项目，并确保当我键入 *python* 时，我使用的是我想要使用的 python 版本？”

这是一个“python 版本管理”工具，关键是不涉及任何 Python。为了安装和管理不同的 python 版本，重要的是它本身不依赖于 python，而是主要是 bash 脚本的负载。

正如您可能已经猜到的，它通过操纵$PATH变量来完成 python 版本管理。事情比康达复杂一点，我们来看一个例子。假设您已经通过类似brew install pyenv的东西安装了，当您启动一个新的终端/shell 时，您应该准备好了(因为语句(或类似的东西)eval "$(pyenv init --path)"将被添加到您的.zshrc / .zprofile / .bash_profile / .bashrc的末尾，pyenv 命令将被加载到您的 shell 中。

树立榜样

在开始之前，让我们使用 pyenv 来建立一个示例，这样我们就可以准确地演示它是如何工作的。安装 pyenv 后，让:

**安装 2 个不同版本的 python，并将 3.9.7 设为全局版本**

在新的终端中，键入以下内容以安装 python 3.8.12 和 python 3.9.7，并将 python 3.9.7 设置为要使用的首选“全局”python 版本:

> pyenv install 3.8.12
> pyenv install 3.9.7
> pyenv global 3.9.7

然后，我们可以通过检查以下内容来检查这是否成功:

> pyenv versions
   system
   3.8.12
 * 3.9.7 (set by /Users/jamisonm/.pyenv/version)

新建一个项目，将 python 的本地版本设置为 3.8.12

为了理解 pyenv 如何同时管理多个 python 版本，我们需要创建一个“新项目”,并告诉它我们不想使用我们已经设置的“全局”python 版本——3 . 9 . 7。为此，您可以创建任何新目录并运行以下命令:

> mkdir ~/pyenv-demo    # make a new directory called pyenv-demo in my home directory
> cd ~/pyenv-demo       # cd into it
> pyenv local 3.8.12    # set 3.8.12 as the python version to be used in this directory

这做了什么？这就创建了一个只包含以下文本的.python-version文件:3.8.12。如果一切按计划进行，那么:

• 当我们在这个目录(现在是一个简单类型的“环境”)中时，我们将使用 python 3.8.12
• 当我们在它之外时，我们将使用默认的 3.9.7

现在我们已经准备好了，我们可以检查 pyenv 如何确保我们使用期望的 python 版本。

当我键入python时，pyenv 如何知道运行 python 的“本地”版本？

首先，让我们通过使用cd ~/pyenv-demo将自己转移到新目录。让我们看看当我们键入python时我们指向哪里，并且根据我们的路径，这是否有意义:

> which python
/Users/jamisonm/.pyenv/shims/python
> echo -e ${PATH//:/\\n}
/Users/jamisonm/.pyenv/shims
/usr/local/bin
/usr/bin
/bin
/usr/sbin
/sbin

因此，我们似乎在/Users/jamisonm/.pyenv/shims中使用了 python 可执行文件，正如 conda 的情况一样，这是因为 pyenv 在我们的路径顶部放置了一个名为/Users/jamisonm/.pyenv/shims的目录(因此首先搜索这个目录)。如果我们检查指定的 python 可执行文件，我们会发现它实际上不是真正的 python 可执行文件，而是一个名为“python”的 bash 脚本。这就是“填补程序”的含义——我们欺骗我们的操作系统运行这个可执行文件(它被称为 python，但实际上并不是python)，而不是进一步搜索$PATH并找到一个真正的 python 可执行文件。

那么这个“填充”python 脚本是做什么的呢？

让我们来看看:

> less /Users/jamisonm/.pyenv/shims/python

#!/usr/bin/env bash
set -e
[ -n "$PYENV_DEBUG" ] && set -x

program="${0##*/}"

export PYENV_ROOT="/Users/jamisonm/.pyenv"
exec "/usr/local/opt/pyenv/bin/pyenv" exec "$program" "$@"

简单地说，它检查一些调试标准，设置一个变量PYENV_ROOT，然后调用另一个可执行文件:/usr/local/opt/pyenv/bin/pyenv。因此，到目前为止，它所做的不是调用 python，而是拦截对 python 的调用(通过操纵$PATH)，然后调用自己。

我们可以检查这个可执行文件(/usr/local/opt/pyenv/bin/pyenv)，但是它只有大约 150 行 bash 脚本。相反，假设一切顺利，我们可以把注意力集中在底部，它有:

command="$1"
case "$command" in
"" )
  { pyenv---version
    pyenv-help
  } | abort
  ;;
-v | --version )
  exec pyenv---version
  ;;
-h | --help )
  exec pyenv-help
  ;;
* )
  **command_path="$(command -v "pyenv-$command" || true)"**
  if [ -z "$command_path" ]; then
    if [ "$command" == "shell" ]; then
      abort "shell integration not enabled. Run \`pyenv init' for instructions."
    else
      abort "no such command \`$command'"
    fi
  fi

  shift 1
  if [ "$1" = --help ]; then
    if [[ "$command" == "sh-"* ]]; then
      echo "pyenv help \"$command\""
    else
      exec pyenv-help "$command"
    fi
  else
    **exec "$command_path" "$@"**
  fi
  ;;
esac

您可以自己检查脚本，或者相信我的话，它会为您指出:

• command_path = /usr/local/Cellar/pyenv/2.2.0/libexec/pyenv-exec(这是因为我用 brew 安装了 pyenv，brew 把这个可执行文件放在了‘Cellar’目录中)
• "$@" = python

这意味着现在我们已经被引导到另一个可执行文件上，即带有参数python的/usr/local/Cellar/pyenv/2.2.0/libexec/pyenv-exec。

那么接下来会发生什么？

现在这个脚本有点短了，所以我们可以把它全部打印出来，然后用文字浏览一遍:

set -e
[ -n "$PYENV_DEBUG" ] && set -x

# Provide pyenv completions
if [ "$1" = "--complete" ]; then
  exec pyenv-shims --short
fi

**PYENV_VERSION="$(pyenv-version-name)"**
PYENV_COMMAND="$1"

if [ -z "$PYENV_COMMAND" ]; then
  pyenv-help --usage exec >&2
  exit 1
fi

export PYENV_VERSION
PYENV_COMMAND_PATH="$(pyenv-which "$PYENV_COMMAND")"
PYENV_BIN_PATH="${PYENV_COMMAND_PATH%/*}"

OLDIFS="$IFS"
IFS=$'\n' scripts=(`pyenv-hooks exec`)
IFS="$OLDIFS"
for script in "${scripts[@]}"; do
  source "$script"
done

shift 1
if [ "${PYENV_BIN_PATH#${PYENV_ROOT}}" != "${PYENV_BIN_PATH}" ]; then
  # Only add to $PATH for non-system version.
  export PATH="${PYENV_BIN_PATH}:${PATH}"
fi
exec "$PYENV_COMMAND_PATH" "$@"

重要的一点是我强调的那一点。这个位在当前目录中检查一个.python-version文件，如果它存在，它就使用它。否则，它会遍历到该目录的所有路径，寻找其他的.python-version文件，直到找到一个。否则，它将默认使用我们设置的全局 python 版本。在这种情况下，它:

• 在我们的 pyenv-demo 目录中找到.python-version文件
• 为3.8.12读取
• 转到/Users/jamisonm/.pyenv/versions，pyenv python 可执行文件实际上存储在那里
• 找到我们想要的，并将我们的可执行文件设置为/Users/jamisonm/.pyenv/versions/3.8.12/bin/python

对于它正在实现的目标来说，这似乎相当复杂

这相当复杂——尤其是来自编程 python 和尝试通读一堆 bash 脚本。然而，最终所有这些都隐藏在对pyenv的简单调用之下。有时候，确切地了解正在发生的事情是很好的，但是日常生活中没有必要知道这些。然而，要点仍然存在——理解不同的环境管理程序和 python 版本化有时看起来很复杂，但归根结底只有一件事:以一致的方式操作$PATH变量，以便您想要的 python 版本就是您得到的 python 版本。

结论

希望通过这次经历，事情开始变得简单。“环境管理”和“python 版本控制”实际上可以归结为以下几点:

• 环境管理:在某个地方创建一个目录，并将我们希望用于该环境的 python 版本放在那里
• Python 版本控制:确保当我们在特定的目录/环境中时，在浏览$PATH时，首先找到附加的 python 可执行文件的路径
• 包管理:将所需的包下载到我们想要的 python 可执行文件所在的“相同位置”,这样就可以用它们来代替其他环境中的包

最后一点我们还没有真正经历过，但是一旦我们理解了当我们键入python时，我们的计算机如何知道使用哪个版本的 python，它真的一点也不复杂。然而，要理解它，我们需要理解模块搜索路径和，正如我们将在下一篇文章中看到的，这实际上只不过是在 python 启动时对$PATH进行一些小的标准操作。

https://markjamison03.medium.com/python-and-the-module-search-path-e71ae7a7e65f [## Python 和模块搜索路径

markjamison03.medium.com](https://markjamison03.medium.com/python-and-the-module-search-path-e71ae7a7e65f)

Python 到 SQL —安全、轻松、快速地向上插入

原文：https://towardsdatascience.com/python-to-sql-upsert-safely-easily-and-fast-17a854d4ec5a?source=collection_archive---------2-----------------------

使用 Python 进行闪电般的插入和/或更新

是时候更新我们的存储空间并插入一些新东西了(图片由斯蒂夫·约翰森在 Unsplash 上提供)

当您将数据向上插入到表中时，您会更新已存在的记录并插入新的记录。阅读完本文后，您将能够将 Python 应用程序连接到数据库，并以闪电般的速度更新数据。我们将通过几个实际例子来演示实现这一点的各种方法。它们都适合处理大型数据集；关注高速度和数据有效性。我们来编码吧！

另外，我们将在本例中使用 SQL Server，但所使用的技术适用于各种数据库。

1.设置和准备

我们有一个出售各种音乐文章的网站。每小时我们都会收到一份来自所有供应商的文件，上面有他们当前的库存；他们出售的所有商品以及股票和价格信息。

在本例中，我们将关注一个供应商的文件。我们的目标是增加销量；插入所有新文章并更新已经存在的文章。也许他们有新的股票价值或不同的价格。作为奖励，我们将了解如何删除缺货的商品。

1.1 数据库准备

让我们首先在数据库中创建一个可以插入的表。

我们的音乐物品表

如你所见，我们的小网店卖不了多少东西。没关系，虽然，它会保持这篇文章漂亮和简洁。最值得注意的是 SKU 专栏。这是库存单位；每个产品都有一个独一无二的编号。

1.2 Python 加载数据

假设我们的供应商给我们发送了新的 CSV 文件和他们的文章更新。我们已经编写了一个 Python 程序，它一检测到新文件就加载该文件。现在的目标是加载 CSV，然后将其插入数据库。请记住，不需要从 CSV 中读取您的数据；任何数据结构都可以。首先，我们将加载 CSV:

将新产品从 csv 加载到字典列表中

我选择使用熊猫来阅读我的 CSV，但这不是必需的。你可以用任何你喜欢的方法。这会产生以下数据帧:

1.3 Python 创建数据库连接

我们将使用 SQLAlchemy 创建一个数据库连接，连接到在我的本地主机上运行的 SQL Server 数据库。

通知fast_executemany=True。这是一个专门针对 SQL Server 的功能，它可以确保以闪电般的速度插入数据。更多信息请见本文。

准备工作做好了，我们来插入一些数据吧！(图片由将提升到像素上)

2.向上插入

加载我们的 CSV，准备好我们的表，建立数据库连接；让我们插上！

这个计划

我们首先将所有数据插入到一个临时表中。然后，如果这成功了，我们将合并我们的表。该操作允许您在一条语句中插入、更新和删除！有关合并的更多信息，请查看本文。

执行

我们将遍历下面的代码。

我们分 4 个步骤执行升级:

1. 创建一个名为#NewProducts 的临时表。这里没什么太令人兴奋的
2. 将新数据插入临时表。
   我们使用一些好的参数将我们的新值批量插入到临时表中。在插入到 SQL Server 时，此插入操作还使用 fast_executemany 选项；这是超快的。
3. 将临时表与目标表合并(MusicArticles)
   这就是神奇的地方:合并！我们拿 SKU 来比较产品。
   -如果它们不在目标(我们的音乐物品表)中，那么我们将简单地插入新的乐器。
   -两个表中都有 SKU 的产品得到更新。我们还更新了修改后的列。
   -在 MusicalArticles 中但不在 temp 表中的产品从 MusicalArticles 中删除。所以实际上这个语句不仅插入和更新，它还删除！您可以选择删除这一部分，以保持我们的声明是一个纯粹的 upsert。
4. 删除我们的临时表

安全的

如果有更多的步骤，例如在插入或与许多表格合并后清理数据，这将非常方便。或者，您可以将 insert 语句放在不同的块中，这样大型插入就不会回滚，而只是将数据存储在临时表中。

结果

当然，这是一些不错的代码，但让我们看看一些结果！这是我们执行这个 python 脚本前后的 MusicalArticles 表。

在插入之前(红色将被删除，橙色将被修改)

向上插入后(橙色被修改，绿色被新插入)

你会注意到 SKU 123，24，33 和 34 被修改了。不是价格变了就是库存变了。此外，我们还有两款新仪器 SKU 35 和 111。还有，SKU 5577 不见了！肯定卖光了。对于 SKU 1233，一切都没有改变。

结论

通过这篇文章，我希望对如何安全、方便、快速地插入数据有所启发。如果你有建议/澄清，请评论，以便我可以改进这篇文章。与此同时，请查看我的其他关于各种编程相关主题的文章，比如:

• 删除进入另一个表
• 更新进入另一个标签页 le
• 在一条语句中插入、删除和更新
• 更新选择一批记录

编码快乐！

—迈克

页（page 的缩写）学生:比如我正在做的事情？跟我来！

Python 技巧:对照单个值检查多个变量

原文：https://towardsdatascience.com/python-tricks-check-multiple-variables-against-single-value-18a4d98d79f4?source=collection_archive---------13-----------------------

照片由克里斯里德在 Unsplash 上拍摄

如何一次用一个值比较多个变量？

欢迎阅读一系列短文，每篇短文都有方便的 Python 技巧，可以帮助你成为更好的 Python 程序员。在这篇博客中，我们将研究变量比较。

情况

你有变量x, y, z，你也有一个常量c，你想检查它是否存在于三个变量中。我们可以按照下面的逻辑用蛮力的方法来做，但是有更好的解决方案吗？

if (x == c) or (y == c) or (z == c):
    print("It exists!")
else:
    print("It does not exist!")

可能的解决方案:迭代器

if any(i == c for i in (x, y, z)):
    print("It exists!")
else:
    print("It does not exist!")

如果您想检查是否所有的x, y, z都有价值c，您也可以将any改为all。这两个函数检查所提供的迭代器中是否有一个/全部被评估为True。这意味着如果我们有一个元组t = (0, 1, 2)，那么all(t)将返回False，因为第一个元素0将被计算为False。这也提供了很大的灵活性，因为像0、None、[]、()、""、{}这样的公共值都将被评估为False。

注意x, y, z已经被合并到一个元组中，而不是一个列表中，以获得更好的内存性能。如果您想了解更多关于数据结构的内存使用情况，我以前写过一篇文章:

更好的解决方案:使用 Iterable 的成员测试

除了创建一个 tuple 并遍历它，我们还可以通过成员测试来完成它，而不需要使用any。

# Membership test with list
if c in [x, y, z]:
    print("It exists!")
else:
    print("It does not exist!")# Membership test with tuple
if c in (x, y, z):
    print("It exists!")
else:
    print("It does not exist!")# Membership test with set
if c in {x, y, z}:
    print("It exists!")
else:
    print("It does not exist!")

虽然list、tuple和set都支持成员测试，因为它们都是 Python 中的可迭代对象，但是在选择使用哪一个时还是有细微的差别。例如，假设元组中值的唯一性很高，使用tuple将占用三者中最少的内存。另一方面，set的实现允许常数成本成员测试，这意味着它在三者中具有最小的计算复杂度，尽管构建一个集合可能会超过它的好处。而对于list，在这种情况下使用变长数组没有任何优势，所以忘了它吧。

这篇博文就讲到这里吧！我希望你已经发现这是有用的。如果你对其他 Python 技巧感兴趣，我为你整理了一份简短博客列表:

• Python 技巧:拉*列表
• Python 技巧:简化 If 语句&布尔求值
• Python 技巧:如何检查与熊猫的表格合并

如果你想了解更多关于 Python、数据科学或机器学习的知识，你可能想看看这些帖子:

• 改进数据科学工作流程的 7 种简单方法
• 熊猫数据帧上的高效条件逻辑
• 常见 Python 数据结构的内存效率
• Python 的并行性
• 为数据科学建立必要的 Jupyter 扩展
• Python 中高效的根搜索算法

如果你想了解更多关于如何将机器学习应用于交易和投资的信息，这里有一些你可能感兴趣的帖子:

• Python 中用于交易策略优化的遗传算法
• 遗传算法——停止过度拟合交易策略
• 人工神经网络选股推荐系统

https://www.linkedin.com/in/louis-chan-b55b9287

特别感谢 Sander Koelstra 指出了一些误导性的陈述。

Python 技巧:扁*化列表

原文：https://towardsdatascience.com/python-tricks-flattening-lists-75aeb1102337?source=collection_archive---------28-----------------------

由 Max Duzij 在 Unsplash 上拍摄的照片

你还在遍历 for 循环吗？

欢迎阅读一系列短文，每篇短文都有方便的 Python 技巧，可以帮助你成为更好的 Python 程序员。在这篇博客中，我们将探讨如何扁*化列表。

情况

我们都处理过列表的列表，甚至更糟:嵌套列表的列表。

理论上，我们可以像剥洋葱一样一层一层地剥列表:

l = [0, 1, 2, [3, 4, 5, [6, 7, 8]]]from collections import Iterabledef unwrap(l):
    flat_list = []
    for item in l:
        if isinstance(item, Iterable):
            flat_list.extend(item)
        else:
            flat_list.append(item)
    return flat_listl = unwrap(l)
# [0, 1, 2, 3, 4, 5, [6, 7, 8]]l = unwrap(l)
# [0, 1, 2, 3, 4, 5, 6, 7, 8]

这也意味着无论有多少嵌套层，我们都需要运行unwrap。

有没有更有效的方法来展*嵌套列表？

候选解决方案:itertools

itertools是 Python 的标准库之一，它提供了创建迭代器以实现高效循环的便捷函数。其中有一个名为chain的函数，它创建了一个链式对象来连接一个可迭代列表。链对象可以理解为遍历每个可迭代对象的迭代器。因此，如果你需要的不仅仅是一个迭代器，你就需要把它显式地转换成一个链表。

from itertools import chainl = [[0, 1], [2, 3]]
list(chain(*l))# [0, 1, 2, 3]list(chain.from_iterable(l))# [0, 1, 2, 3]

然而，chain也有一些限制:它连接了一个可迭代的列表，但是没有进一步展开，并且它还要求所有元素都是可迭代的:

from itertools import chainl = [[0, 1], [2, 3, [4, 5]]]
list(chain(*l))# [0, 1, 2, 3, [4, 5]]l = [0, 1, [2, 3, [4, 5]]]
list(chain(*l))# TypeError: 'int' object is not iterable

候选解决方案:熊猫

作为itertools.chain的替代，熊猫在pandas.core.common下有一个flatten功能。与itertools.chain类似，flatten返回一个生成器而不是一个列表。生成器和迭代器在实现和好处上有一些不同。虽然我们将在以后介绍这一点，但它们之间的一个简单的区别是，生成器是使用 yield 语句的迭代器，并且只能读取一次。

from pandas.core.common import flattenl = [0, 1, [2, 3, [4, 5]]]
list(flatten(l))# [0, 1, 2, 3, 4, 5]

从上面的例子中，我们可以看到flatten也像chain一样处理嵌套列表！

结束语

那么我们应该用哪一个呢？

看情况。

如果你有一个嵌套列表的列表，要么重构代码以避免创建那个怪物，要么使用flatten一次完全展*它。

如果你有一个列表列表，那么chain就足够了。毕竟chain也比flatten快

l = [[0, 1], [2, 3, 4], [5, 6, 7, 8]]%timeit list(chain(l))
# 236 ns ± 7.68 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)%timeit list(flatten(l))
# 5.13 µs ± 164 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

这篇博文就讲到这里吧！我希望你已经发现这是有用的。如果你对其他 Python 技巧感兴趣，我为你整理了一份简短博客列表:

• Python 技巧:如何检查与熊猫的表格合并
• Python 技巧:简化 If 语句&布尔求值
• Python 技巧:对照单个值检查多个变量

如果你想了解更多关于 Python、数据科学或机器学习的知识，你可能想看看这些帖子:

• 改进数据科学工作流程的 7 种简单方法
• 熊猫数据帧上的高效条件逻辑
• 常见 Python 数据结构的内存效率
• 与 Python 并行
• 数据科学的基本 Jupyter 扩展设置
• Python 中高效的根搜索算法

如果你想了解更多关于如何将机器学习应用于交易和投资的信息，这里有一些你可能感兴趣的帖子:

• Python 中交易策略优化的遗传算法
• 遗传算法——停止过度拟合交易策略
• 人工神经网络选股推荐系统

https://www.linkedin.com/in/louis-chan-b55b9287

Python 技巧:生成器解释

原文：https://towardsdatascience.com/python-tricks-generators-explained-4b4ba00402e4?source=collection_archive---------29-----------------------

照片由大卫·卡尔波尼在 Unsplash 拍摄

Python 中的生成器是如何工作的？

欢迎阅读一系列短文，每篇短文都有方便的 Python 技巧，可以帮助你成为更好的 Python 程序员。在这篇博客中，我们将研究发电机。

介绍

生成器是 iterable 的子类。

为了理解生成器是如何工作的，我们需要首先修改 iterables 是如何工作的。

可重复的

iterable 是可以迭代的对象。

当我们写 for 循环时，它以一个for x in y:语句开始。for语句正在迭代表达式y。因此，y是可迭代的。

一些非常常见的可重复项有:列表、元组、字符串等

for i in [0, 1, 2]:
    print(i)for i in (0, 1, 2):
    print(i)for i in "012":
    print(i)

Iterables 将值存储在内存中，并允许使用__iter__和__next__方法进行迭代。以上面的例子为例，在使用__iter__进行迭代之前，首先创建一个值为"012"的字符串并存储在内存中。因此，iterables 的一个主要优点是它们可以被访问和迭代任意多次。同时，作为将它存储在内存中的折衷，当你的 iterables 变长时，它将占用更多的内存。

发电机

生成器是只能迭代一次的 iterable 的子类。

本质上，生成器生成(产出)一个值，忘记它，并生成下一个值，直到满足结束条件。

在选择使用生成器还是迭代器时，有几个关键因素值得考虑: