Python:用图形和机器学习检测 Twitter 机器人
具有 Graph2Vec、XGBoost 等特性！
艾莉娜·格鲁布尼亚克在 Unsplash 上的照片
在最近的封锁期间，Twitter 用户活动的上升，这似乎是一个开始寻找隔离项目以提高我的机器学习能力的好地方。具体来说，随着错误信息和令人困惑的阴谋控制了美国的网民，试图找出识别坏人的新方法似乎越来越成为一项相关的任务。
在这篇文章中，我将借助一些有用的 Python 网络图形和机器学习包，展示如何构建一个模型来预测 Twitter 用户是人类还是机器人，只使用每个用户的最小可行图形表示。
概述
1。初步研究
2。数据收集
3。数据转换
4。训练分类模型
5。收尾思路/改进空间
技术札记
所有编程、数据收集等。是在一个笔记本上完成的。
使用的库:
tweepy
pandas
igraph
networkx
numpy
json
csv
ast
itemgetter (from operator)
re
Graph2Vec (from karateclub)
xgboost
最后，四个资源是这项任务的关键，我将在本文后面讨论:
- 印第安纳大学网络科学研究所的 Bot 资源库，
- Jacob Moore 关于识别 Twitter 影响者的教程，使用特征向量中心性作为衡量标准，
- 空手道俱乐部，NetworkX 的延伸，
- 以及 XGBoost 梯度提升库。
让我们开始吧！
初步研究
虽然将 bot 检测作为一个目标并不是什么新鲜事，但是如果没有前面提到的重要工作，像这样的项目是不可能完成的，我认为问题空间中有几个主题可以进一步探讨。
首先是规模和缩减。我不会在“业余爱好者”以上的任何级别描述我的数据科学专业知识，因此，处理能力和 Twitter API 访问都是我必须记住的因素。我知道我无法通过更大、更成熟的群体来复制模型的准确性，因此我开始研究的事情之一是，在这些限制下，如何实现分类模型的可伸缩性和准确性。
第二是分类中使用的用户数据类型。我发现了几个模型，它们借鉴了用户档案的各种不同元素，从推文的文本内容到用户名的长度或使用的档案图片。然而，我发现只有少数 尝试基于用户社交网络的图表做同样的事情。碰巧的是，这种基于图表的方法也是我收集每个用户的足够数据用于以后分类的最佳方式，而不会违反 Twitter 的 API 限制。
数据收集
首先，当使用 Twitter 时，您需要开发人员 API 访问。如果你还没有，你可以在这里申请，Tweepy(我将在这篇文章中使用的 Twitter API 包装器)的文档中有更多关于认证过程的信息。
完成后，您需要用您的凭证创建一个 API 实例，如下所示。
输入您的凭证
为了训练一个模型，我需要一个 Twitter 用户名和现有标签的数据库，以及一种快速收集每个用户相关数据的方法。
我最终选定的数据库是 IUNI 优秀的机器人知识库，其中包含数千个 TSV 和 JSON 格式的已标记人类和机器人账户。第二部分有点难。起初，我试图生成每个用户的整个时间表的图形表示，但由于 API 的限制，对于一些更多产的用户来说，这可能需要一天多的时间*。小型图表的最佳格式是 Jacob Moore 的教程，使用特征向量中心性识别 Twitter 影响者。*
我不会重复他的脚本如何工作的完整解释，或者什么是特征中心性，因为这两个东西在他的教程中比我能说的更好，但是从一个高层次的角度来看，他的脚本将一个 Twitter 用户(或者一个关键字，但我最终没有使用该功能)作为输入，并输出一个 CSV，其中包含一个用户边缘列表，该列表根据他们对给定用户在 Twitter 上的交互的“影响”进行加权。它还输出一个 iGraph 对象，我们将把它写入一个 GML 文件，我们将用它作为每个用户的唯一表示。
您将需要他的教程中的 TweetGrabber、RetweetParser 和 TweetGraph 类的功能。下一步是用您的 API 键创建一个 TweetGrabber 实例，并对您选择的 Twitter 用户执行搜索。
创建用户与其网络关系的 GML 文件
上述代码的第 27 行和第 28 行为每个顶点创建了一个“size”属性，该属性保存了其特征中心值，这意味着当我们将创建的 iGraph 对象写入 GML 文件时，正如我们在第 31 行中所做的那样，该文件将包含我们需要的关于用户的所有信息，并且可以丢弃之前创建的 CSV。此外，如果您愿意，您可以取消对第 33–38 行的注释来绘制和查看图形，它可能看起来像这样:
我跟踪的抽动流光的图形输出。
为了构建我将在其上训练分类模型的数据库，我将从 Bot 存储库中收集的每个用户名和标签添加到 pandas 数据帧中，并遍历该数据帧，以每个用户名作为输入运行该脚本。这个过程的这一部分是最耗时的，需要几个小时，但在从框架中删除空的或被删除的帐户后，结果是超过 20，000 个带有“基础事实”标签的用户图表用于分类。下一步:格式化这些数据来训练模型。
数据变换
但是首先，简单回顾一下什么是模型(如果你熟悉，你可以跳到‘在过程的这个点……’)。
机器学习模型的目标是查看关于某物的一系列信息(特征)，然后使用这些信息尝试并预测关于该物的特定陈述(或标签)。
例如，这可能是一个模型，它获取一个人的日常饮食，并试图预测他们牙齿上的菌斑数量，或者这可能是一个模型，它获取一个人经常购物的商店类型，并试图预测他们的头发颜色。像第一种模型，个人信息与被预测的特征更紧密相关(饮食对牙齿健康的影响可能比购物习惯对头发颜色的影响更大)，通常会更成功。
创建这样一个模型并“教会”它更准确地做出这些预测的方法是，将它暴露给大量的事物，这些事物已经有了它们的特征和标签。通过“研究”这些提供的例子，模型理想地“学习”什么特征与一个标签或另一个标签最相关。
例如，如果你的模型正在“研究”的数据库包含一群具有“早餐吃棉花糖”特征的人的信息，而这些人中的大多数碰巧都有较高的牙菌斑量，那么你的模型很可能能够预测，如果一个没有标签的人也在早餐吃棉花糖，他们的牙齿就不会看起来这么热。
为了更好更全面的解释，我推荐这个视频。
在这个过程中的这一点上，我们有一个关于 somethings (Twitter 用户)的数据库，每个用户都有信息(他们的图表)和一个是/否声明(他们是否是机器人)。然而，这将我们带到下一步，这是创建模型的关键步骤-如何将这些图表转换为输入要素。为模型提供太多不相关的信息会使它花更长的时间从输入中“学习”,或者更糟，使它的预测不太准确。
在不丢失任何重要信息的情况下，在我们的模型中表示每个用户图表的最有效方式是什么？
这就是空手道俱乐部的由来。具体来说， Graph2Vec ，这是一个完整的图形“嵌入”库，它采用任意大小的图形，比如上图中的图形，并将其嵌入为一个低维向量。关于图形嵌入的更多信息(特别包括 Graph2Vec)，我推荐这篇文章，以及这篇白皮书。
长话短说，Graph2Vec 将图形转换成更密集的表示，保留结构和信息等属性，这正是我们想要的输入特征。
为此，我们需要将图形转换成与 Graph2Vec 兼容的格式。对我来说，这个过程是这样的:
创建用户图形的矢量嵌入
最终结果将如下所示:
[[-0.04542452 0.228086 0.13908194 -0.05709897 0.05758724 0.4356743
0.16271514 0.09336048 0.05702725 -0.2599525 -0.44161066 0.34562927
0.3947958 0.30249864 -0.23051494 0.31273103 -0.26534733 -0.10631609
-0.44468483 -0.17555945 0.07549448 0.38697574 0.2060106 0.08094891
-0.30476692 0.08177203 0.35429433 0.2300599 -0.26465878 0.07840226
0.14166194 0.0674125 0.0869598 0.16948421 0.1830279 -0.17096592
-0.17521448 0.18930815 0.35843915 -0.19418521 0.10822983 -0.25496888
-0.1363765 -0.2970226 0.33938506 0.09292185 0.02078495 0.27141875
-0.43539774 0.23756032 -0.11258412 0.01081391 0.44175783 -0.19365656
-0.04390689 0.09775431 0.03468767 0.06897729 0.2971188 -0.35383108
0.2914173 0.45880902 0.22477058 0.12225034]]
对人类的眼睛来说并不漂亮，但是结合我们的标签，正是我们创建分类模型所需要的。我对每个被标记的用户重复这个过程，并将结果存储在另一个 pandas 数据帧中，因此现在我有一个大约 20，000 行和 65 列的数据帧，其中 64 列是描述用户图形的向量，第 65 列是用户是机器人还是人类的“基本事实”标签。现在，到了最后一步。
训练分类模型
因为我们的目标是分类(预测每个“东西”是否应该被放在两个类别中的一个，在本例中是机器人或人)，所以我选择使用 XGBoost 的 XGBClassifier 模型。XGBoost 使用梯度推进来优化回归和分类问题的预测，以我的经验来看，这比其他大多数选项的预测更准确。
从这里开始，有两种不同的选择:
如果您的目标是训练您自己的模型来进行预测和修改，并且您有一个用户图形向量和标签的数据库来完成此任务，则您需要使分类模型适合您的数据库。这是我的过程:
训练你自己的分类模型
如果你的目标只是试图预测你已经绘制和矢量化的单个用户的人性或机器人性，那也没问题。我已经包含了一个 JSON 文件，您可以从我的 GitHub 中加载我的模型，它链接到我的个人资料中。这个过程大概是这样的:
加载我的分类模型
就是这样！您应该会看到您开始使用的帐户的预测标签。
关闭思路/改进空间
我的模型有很多可以改进的地方，我希望有一天能再去看看。
首先也是最重要的是准确性。虽然 IUNI 根据他们的 Bot 存储库构建的 Botometer 分类模型在测试数据集上显示了近 100%的分类准确性，但我的模型显示了 79%的准确性。这是有意义的，因为我使用较少的特征来预测每个用户的标签，但我相信在我的极简方法和 IUNI 的方法之间有一个中间地带，我会有兴趣尝试结合基于图形、基于文本和基于简档的分类方法。
另一个与准确性相关的因素是图表本身的结构。Igraph 能够计算图中每个节点的特征向量中心性，但也包括许多其他基于节点的测量，如接近度、介数或多个测量的优化组合。
最后，有两件事使得测试和改进这个模型的准确性变得困难。首先，由于我对向量嵌入的理解有限，我很难识别哪些特征会导致准确或不准确的标记。第二个问题是，测试数据集的结果对 Twitter 今天的生态系统有多准确。随着机器人被检测到，这个领域也在发展，检测方法也必须发展。为此，我在整个隔离期间从 Twitter 上浏览了一些趋势话题，供用户应用这个模型，但我认为这必须等到以后的帖子。
感谢您的阅读！如果你有任何问题或反馈，请在评论中告诉我。
用于可视化和建模 covid 19-数据的 Python 开发工具包
数据可视化—开发套件—覆盆子— Python
用您自己的方法创建您的新冠肺炎数据分析
介绍
新冠肺炎冠状病毒疫情正在影响 213 个国家，并造成严重破坏。人们因被感染而死亡；世界经济缩减了；失业以每周数百万的速度增长，许多人正在制造混乱，开始反抗。因此，对 Covid19 数据的分析和模拟对于对抗新型冠状病毒病毒是重要的。这不仅对病毒学家、医生很重要，对其他学科的其他专家也很重要，对我们所有人也很重要。
人们可以使用计算软件，如微软 Excel (桌面)、 LibreOffice (桌面，免费)、谷歌工作表(在线)来处理数据，但最好使用编程来进行复杂方法的计算。因此我开发了一个开源包TAV uong/covid 19-datakit，它是 MIT 授权的，用 Python 编写。您可以使用该套件根据套件库中已实现的模型来可视化、分析或模拟数据。您也可以将自己的模型实现到工具包中。
那么就让我们来看看怎么用吧！
covid 19-数据套件
数据下载和处理
Covid19-Datakit 将处理冠状病毒疫情的数据，这些 csv 文件可以从冠状病毒源数据、 openZH/covid_19 或从互联网下载，例如 JainXu- list 。
Covid19-datakit 可以处理具有以下结构和格式的 csv 文件数据:
- 第一名。列是数据-时间，该列中的数据将绘制在 x 轴上。第一列中的日期时间必须采用 yyyy-mm-dd 格式，例如 2020–01–01。
- 2nd- nte 列是时间序列数据，绘制在 y 轴上。
如果您的 csv 文件不符合这些要求，您应该使用计算软件，如 MicroSoft Excel、LibreOffice Calc 或 Google sheet，来更改格式或结构。
套件—描述
麻省理工学院许可的开源软件 tavuong/covid19-datakit 包含以下部分:
- covid19-datakit.py 是一个仪表板，有一个用户界面，通过对话框获取数据 csv 文件的位置和模型参数值。它管理工作流程:读取数据，使用模型模块计算数据，并在计算机屏幕上显示结果或将结果打印为图像(png 文件)。仪表盘有一个**“我”模式**，用户可以将仪表盘切换到与自己的车型一起工作。还有内置的命令行，因此您可以编写 shell 脚本来可视化许多功能的数据，例如许多国家的新案例。
- 默认套件库是TAV uong _ visual . py中的可视化模块，开发模型处理TAV uong _ model . py中的 covid19- data。您可以使用这些模块来立即可视化您的数据，例如，每日新增病例的总和或根据恢复率估计的每日感染人数的总和(我的开发模型)。
- **用户库:**是您开发自己的模型和自己的所有者演示文稿的模块。您可以使用user _ model . py和user _ visual . py中的模板来开发集成在仪表板中的“me-mode”，这样您就可以获得数据和参数，而不必编写新的对话框和管理工作流。测试一下，你会喜欢的。
哪个计算机系统可以使用该工具包？
要运行这个工具包，你需要一个 Python 解释器，你可以从 Python.org 下载 Python 用于 Windows 、 Linux/UNIX 、 Mac OS X 、其他。该套件由 Windows 10 (PC)、由“Raspbian Buster with desktop and recommended software”(Raspberry Pi)和由 Termux(UNIX fortable t)进行测试
安装
在命令提示符(Windows X)或 LX 终端(Raspberry PI)中给出以下命令
$ github 克隆https://github.com/tavuong/covid19-datakit.git
$ pip 安装费用
$ pip 安装 Matplotlib
*$ cd ~\covid19-datakit*
$ python。\ covid 19-data kit . py[通过 PC]
$ python3。\ covid 19-data kit . py[by Raspberry PI]
它将要求:数据 csv 文件的数据读取位置，你想可视化其数据的国家，可视化或模拟的模型和我的模型’ gc ‘或’ gs '的恢复率，模拟感染与估计恢复率的情况。
将对话框用于套件的示例
*对于这个例子，我们在。\ covid 19-数据工具包\数据*
*$ CD ~ \ covid 19-数据套件*
$ python。\ covid 19-data kit . py[通过 PC]
试剂盒>病例数据文件？。\data\new_cases.csv
(请求 csv 文件的位置)
csv 文件中的国家列表将被读取并显示:
套件>国家？世界
(您想要处理的国家数据请求)
将显示可视化模式列表:
ac :实际案例:每日新增案例曲线
sr :每日病例总数
gc :实际案例，包括预计回收率:这是模拟
gs :每日案例总数，包含预计回收率:这是模拟
我 :我的型号:切换到自己的型号
t2 : 测试图
KIT >您的计算模型是什么？sr
(要求您选择模式)
然后它将绘制:
命令行
命令行刚刚实现。它有以下选项:
$ python。\covid19-datakit.py -h
covid19-datakit
-i <输入文件> -o <输出文件>
-c 国家
-m 模式
-g 恢复
示例呼叫 gs 模式
$ python。\ covid 19-data kit . py-I。\ data \ new _ cases . CSV-c Italy-o test.png-m GS-g 0.8
切换到用户模式:我的模式
您可以使用模板模块开发自己的所有者模型，该模型通过仪表板集成为“我”模式(covid19-datakit.py)。
通过从仪表板请求(covid19-datakit.py)中选择“我”,套件将调用我模式的可视模块:
my_collection_1(x，y，y1，y2，namecountry，gesund)。
名称国家:国家参数
gesund :回收率
x [ ] :从 csv 文件输入时间数据**
y [ ] :输入，CSV 文件中所选国家的 covid 数据，范围同 x [ ]
Y1 [ ] : 读取生成的缓冲字段，范围与 x [ ] 相同
y2 [ ] : 读取生成的缓冲区，范围与 x [ ] 相同
现在，您已经完成了用于可视化和/或建模的数据
根据 my_collection_1(…)中的 y[ ]，您可以通过调用模块来计算另一个 y2 [ ]:
my_model_1(y2，y，factor，Tau，gesund)
Tau:孵化时间，尚未实现从仪表板读取
因子:R 因子，尚未实现从仪表板读取
gesund:来自控制板请求的回收率
y [ ]:输入 csv 文件中所选国家的 covid 数据
y2 [ ]:输出，与 y [ ]范围相同
Me 模式示例
要研究 user-visual.py 和 user_model.py 中两个模板模块的代码，先从这个例子开始理解它是如何工作的。
$ python。\ covid 19-data kit . py-I。\ data \ new _ cases . CSV-c Italy-o test.png-m me-g 0.8
摘要
软件包 covid19-datakit 专注于处理 covid19 数据。它很容易使用对话框或命令行。您可以将自己的模型集成到仪表板中。
covid19 数据的可视化和建模一直在不断发展，将来还会更新。如果您已经开发了一个新的有趣的模型-模块或演示-模块，请不要犹豫与我联系进行咨询开发，并可能将您的模块贡献给开源和麻省理工学院许可的项目TAV uong/covid 19-data kitovergithub。
玩得开心！
鸣谢:简范博士教授
Python 词典
像专家一样使用 Python 字典
Python 编程语言在数据科学项目中被开发者广泛使用。要完成这样的项目，理解数据结构起着重要的作用。Python 有几个内置的数据结构，如列表、集合、元组和字典，以支持开发者使用现成的数据结构。
在这篇文章中，我将尝试解释为什么以及何时使用 Python 字典，同时给你一些关于正确使用字典方法的提示。
让我们通过一步一步的解释和例子来详细理解 Python 字典。
什么是 Python 字典？
简而言之，一个字典可以被定义为存储在键/值对中的数据集合。键必须是不可变的数据类型(如字符串、整数或元组)，而字典中的值可以是任何 Python 数据类型。
不允许出现重复的键。如果同一个键在同一个字典中使用了两次，那么最后一次出现的将覆盖第一次出现的。
存储在字典中的数据可以被修改，所以它们被称为可变对象。它们是无序的，这意味着我们没有保持指定项目的顺序。(从 3.7 版本开始订购)
因为它们是动态的，它们可以在需要的时候收缩。
什么时候使用 Python 字典？
既然您现在已经知道了什么是 Python 字典，那么是时候探索何时在您的代码中使用它们了。
这里有一个帮助你理解何时使用 Python 字典的列表。
- 当数据具有可以与值相关联的唯一引用时。
- 当快速访问数据项很重要时。字典被设计成让我们立即找到一个值，而不需要搜索整个集合。
- 当数据顺序不重要时。
- 因为字典是可变的，所以使用字典来存储不应该被修改的数据并不是一个好主意。
- 当内存考虑不是应用程序的重要因素时。与列表和元组相比，字典占用更多的内存空间。
如何创建 Python 字典？
有许多创建和初始化字典的方法。如下面的代码片段所示，创建字典最简单的方法是直接使用花括号或 dict() 方法；
如果你有两个可迭代的对象(例如列表对象)，你可以使用 zip() 函数来创建一个字典。参见下面的例子；
fromkeys() 方法是另一种创建字典的方法。它接受一个 iterable 对象并创建一个具有指定值的字典，如下面的代码片段所示；
什么是 Python 词典释义？
Python 字典理解提供了一种创建字典的优雅方式。它们使你的代码更容易阅读，更有 Pythonic 风格。它们缩短了字典初始化所需的代码，并可用于用代替循环。
字典理解的一般语法是:
dictionary = {key:value for (key, value) in iterable}
将条件句添加到词典理解中
你可以用条件语句扩展字典理解的使用。你可以在下面看到多个**‘if’条件句、‘else-if’**条件句在字典理解中的用法；
字典操作的时间复杂度
获取、设置和删除字典中的一个条目具有 O(1) 的时间复杂度，这意味着无论你的字典有多大，访问一个条目所花费的时间都是恒定的。
在一个字典上迭代具有 O(n) 的时间复杂度意味着执行这个任务所花费的时间与字典中包含的条目数量成线性比例。
如何访问字典中的值
如果你试图用一个字典中不存在的键访问一个元素，你会得到一个 KeyError 。了解访问字典中元素的正确方法对于在运行时不出现 KeyErrors 非常重要。
为了避免 **KeyError，**用 get() 方法访问字典的元素。或者，您可以使用’关键字中的’ T45 '来检查该键是否存在。
如何将一个条目插入词典？
没有add()、insert()或append()方法可以用来将条目添加到字典中。相反，您必须创建一个新的键来存储字典中的值。如果字典中已经存在该键，则该值将被覆盖。
下面的代码片段展示了许多向字典中添加条目的例子；
字典方法有哪些？
Python 字典中包含许多方法，帮助您在字典对象上执行不同的任务。我在下面列出了它们的简短定义；
- popitem() :从字典中删除最后一项
- pop( key，defaultvalue ) :从字典中移除并返回给定键的元素
- keys(): 返回键
- values(): 返回数值
- items(): 返回字典的键值对
- get( key[，value] ): 如果指定键在字典中，则返回该键的值
- fromkeys( keys，value ): 返回具有指定键和指定值的字典
- setdefault( key，value ) :返回具有指定键的项目的值。如果键不存在，则插入具有指定值的键
- update(iterable):如果关键字不在字典中，则将指定的项目插入字典，否则更新值
- copy(): 返回字典的浅层副本
- clear(): 从字典中删除所有项目
如何从字典中删除一个条目？
要从 dictionary 对象中删除一个条目，可以使用 ‘del’ 关键字或 pop() 方法。此外，您可以使用字典理解删除字典中的条目。请查看下面的代码片段，了解这些方法的实现示例；
如何抄字典？
您可以使用 copy() 方法获得一个现有字典的浅层副本。浅拷贝意味着一个新的字典将用对现有字典中对象的引用来填充。
要创建深层副本，应使用 ‘copy.deepcopy(dict)’ 方法。它用原始字典的所有元素创建一个完全独立的副本。
参见下文，了解如何在字典对象上实现浅拷贝和深拷贝方法；
如何合并字典？
您可以使用包含 dict.copy() 和 dict.update() 方法的自定义函数来合并字典。
在 Python 3.5 及更高版本中，您可以使用’ **’ 操作符通过解包来合并字典。
合并字典最简单、最容易的方法是使用 Python 3.9+中可用的合并操作符 ‘|’
下面的代码片段通过示例展示了上述所有方法的实现；
如何对字典中的条目进行排序？
Python 字典在 3.7 版之前是无序的，所以即使对(键，值)对进行排序，也不能通过保留顺序将它们存储在字典中。为了保持排序，我们可以将排序后的字典存储在一个[OrderedDict](http://docs.python.org/library/collections.html#collections.OrderedDict)中
参见下文，了解如何通过键和值对字典进行排序；
如何在字典中循环？
Python 字典方法； **values()、keys()、**和 items() 提供了对字典中包含的元素的访问。您可以在 for 循环中使用它们来遍历字典。
另外，字典理解也可以用于迭代，如下所示；
结论和关键要点
因为数据结构是我们程序的基础部分，所以对 Python 字典有一个坚实的理解对于创建高效的程序是非常重要的。
我解释了为什么以及什么时候使用字典，下面列出了一些要点；
- 当数据具有可以与值关联的唯一引用时，可以使用 Python 字典。
- 由于字典是可变的，使用字典来存储那些一开始就不应该被修改的数据并不是一个好主意。
- Python 字典在 3.7 版本之前是无序的，所以即使你对(键，值)对进行了排序，你也不能通过保留顺序来将它们存储在字典中。
- Python 字典理解提供了一种创建字典的优雅方式。它们使你的代码更容易阅读，更有 Pythonic 风格。
感谢您的阅读！
Python 目录和文件管理
了解如何用 Python 处理目录和文件操作
伊利亚·巴甫洛夫在 Unsplash 上的照片
在这篇文章中，你将学习到用 Python 处理文件和目录的各种方法，比如
- 创建、更改、删除和重命名目录
- 获取当前目录或列出文件，同时统计目录中的文件数量
- 读取和提取 zip 文件
- 复制文件并将文件从一个目录移动到另一个目录
为什么要学习目录和文件管理？
- 在机器学习和深度学习中，您将处理作为数据集一部分存储在目录中的大量文件，或者您将在文件中存储模型的训练权重。因此，学习文件和目录管理将会很有帮助
- 目录和文件管理还将有助于在一致的目录结构中组织训练、测试和验证数据集，用于所有类型的数据，如数字数据、图像数据或文本数据。
我们将导入所需的库 os 和 shutil ，它们将提供处理操作系统相关功能的方法。
创建目录:mkdir(路径)
要创建一个目录，我们将使用 mkdir() ，我们需要向其传递要创建的目录的路径。
如果目录已经存在，则引发’ 文件存在错误’
***import os
try:
os.mkdir('c:\\test_1')
except FileExistsError:
print("Directory already exists")***
如果目录 test_1 不存在，那么将创建一个新的目录 test_1。如果目录 test_1 已经存在，则出现错误，'filexistserror ’
重命名文件或目录:重命名(源，目标)
要重命名文件或目录，我们需要指定源，即您要重命名的文件，以及目标，即该目录下文件的新名称。
如果源文件或目录 test_1 不存在，那么我们得到一个“FileNotFoundError”错误
如果目标 test_2 目录已经存在，那么我们得到“filexistserror”错误
***try:
os.rename('c:\\test_1\\', 'c:\\test_2')
except :
print(sys.exc_info())***
删除目录:rmdir(路径)
删除指定为参数的目录。
如果要删除的目录不存在，那么会得到一个’FileNotFoundError’错误。
如果该目录包含文件，并且您正试图删除该目录，那么您将得到一个“ OSError ”消息“该目录不是空的”。’
***try:
os.rmdir('c:\test_2\\abc')
except:
print(sys.exc_info())***
更改目录:chdir(路径)
将当前工作目录更改为指定路径。
如果目录 test_1 不存在，那么你会得到一个’ FileNotFoundError ’ 如果指定文件名而不是目录，则会出现“**OSError”**消息“文件名、目录名或卷标语法不正确。’
***try:
os.chdir('c:\\test_1')
except:
print(sys.exc_info())***
打印当前工作目录:getcwd()
os.getcwd() 以字符串形式返回当前工作目录
**print(os.getcwd())**
列出目录中的文件:listdir(路径)
列出指定目录路径中的文件。文件列表在列表中以任意顺序返回。
如果没有指定路径，那么 listdir()返回当前工作目录下的文件列表
***os.listdir('c:\\test_2\\test')***
目录***’ c:\ test _ 2 \ test '***中的文件列表
计算目录中文件的数量
***len(os.listdir('c:\\test_2\\test'))***
您将得到输出 4，因为我们在如上所示的目录中有四个文件
从 zip 文件中读取和提取文件
您将接收或下载压缩在 zip 文件中的数据，因此知道如何从 zip 文件中读取和提取所有文件将是一个非常有用的工具。
你需要导入 zipfile 库。
我有从 Kaggle 下载的狗和猫的数据集，放在一个 zip 文件中。读取 zip 文件，然后使用 extractall ()方法提取指定的目标文件夹中的所有数据
***import zipfile
zipfile_path='c:\\Datasets\\CV\\dogs-vs-cats.zip'******zip_f= zipfile.ZipFile(zipfile_path, 'r')
zip_f.extractall('c:\\Datasets\\CV\\dogs-vs-cats')******zip_f.close()***
复制文件:复制文件(源，目标)
使用 shutil copyfile()方法将文件从源文件复制到目标文件。目的地应该是完整的目标文件名。
下面的代码一次复制一个文件，从 base_dir 到 dest_dir 。我们用***OS . path . join()***来加入目录和文件名。
***from shutil import copyfile***
***try:
base_dir='c:\\Datasets\\CV\\dogs-vs-cats\\test1'
dest_dir='c:\\test_2\\'
for file in os.listdir(base_dir):
copyfile(os.path.join(base_dir, file), os.path.join(dest_dir, file))
except:
print(sys.exc_info())***
移动文件:移动(源，目标)
shutil 库中的 Move()方法可用于移动文件。在源参数和目标参数中都包含文件名。
***import shutil******base_file='c:\\Datasets\\CV\\dogs-vs-cats\\test1\\1.jpg'
dest_file='c:\\test_2\\test\\1.jpg'
shutil.move(base_file, dest_file)***
如果目标文件名被更改，文件将被重命名和移动
***import shutil******base_file='c:\\Datasets\\CV\\dogs-vs-cats\\test1\\100.jpg'
dest_file='c:\\test_2\\test\\dog_2.jpg'
shutil.move(base_file, dest_file)***
结论:
库 os 和 shutil 用于目录和文件管理，帮助在一致的目录结构中组织文件，以便使用 ML/DL 算法训练、测试和验证数据集
参考资料:
[## os —其他操作系统接口— Python 3.8.3rc1 文档
该模块提供了一种使用操作系统相关功能的可移植方式。如果你只是想阅读或…
docs.python.org](https://docs.python.org/3/library/os.html)
https://docs.python.org/3/library/shutil.html
Python 采用了 R (Markdown)方式
照片由维特·加布雷拍摄
介绍
开始使用一种新工具可能并不容易，尤其是当那个*“工具”*意味着一种新的编程语言的时候。与此同时，可能会有机会在已知的基础上再接再厉，让过渡更平稳，痛苦更少。
对我来说，是从 R 到 Python 的过渡。不幸的是，我以前的同事 pythonians 没有分享我对 R 的真正喜爱。此外，不管 R 爱好者喜欢与否， Python 是数据分析/工程/科学等领域广泛使用的工具。因此，我得出结论，至少学习一些 Python 是一件合理的事情。
对我来说，最初的步骤可能是最困难的。在舒适的 RStudio 中，像 Pycharm 或 Atom 这样的 ide 并不熟悉。这一经历促使我们决定从众所周知的环境开始，并在使用 Python 时测试它的极限。
说实话，我最终并没有将 RStudio 作为在一般环境下使用 Python 的首选武器。希望下面的文字能传达为什么的信息。然而，我确信对于一些用例，比如以特别分析 R Markdown 的方式集成 R 和 Python， RStudio 仍然是一条可行的道路。
更重要的是，对于在 R 有初级背景的人来说，这可能是一个方便的起跑线**。**
那么，我发现了什么？
分析
包装和环境
首先，让我们设置环境并加载所需的包。
- 全球环境:
*# Globally round numbers at decimals*
**options**(digits=2)*# Force R to use regular numbers instead of using the e+10-like notation*
**options**(scipen = 999)
- R 库:
*# Load the required packages.*
*# If these are not available, install them first.*
ipak <- **function**(pkg){
new.pkg <- pkg[!(pkg %in% **installed.packages**()[, "Package"])]
**if** (**length**(new.pkg))
**install.packages**(new.pkg,
dependencies = TRUE)
**sapply**(pkg,
require,
character.only = TRUE)
}packages <- **c**("tidyverse", *# Data wrangling*
"gapminder", *# Data source*
"knitr", *# R Markdown styling*
"htmltools") *# .html files manipulation***ipak**(packages)tidyverse gapminder knitr htmltools
TRUE TRUE TRUE TRUE
在这个分析中，我将使用 RStudio 开发的包reticulate 库。但是，可以随意寻找的替代品。
此外，为了更清晰的流程，我将单独导入reticulate包。
- Python 激活:
*# The "weapon of choice"*
**library**(reticulate)*# Specifying which version of python to use.*
**use_python**("/home/vg/anaconda3/bin/python3.7",
required = T) *# Locate and run Python*
- Python 库:
import pandas as pd *# data wrangling*
import numpy as np *# arrays, matrices, math*
import statistics as st *# functions for calculating statistics*
import plotly.express as px *# plotting package*
在 R (Studio) 中使用 Python 的一个限制是，在某些情况下，默认情况下你不会收到 Python 回溯。这是一个问题，因为，如果我把事情过于简化，追溯可以帮助你确定问题出在哪里。意思是它能帮你解决问题。所以，把它当作一个错误信息(或者没有它)。
- 例如，当调用一个您没有安装的库时，R Markdown 中的 Python 块给了您绿灯(所以一切看起来都在运行)，但这并不意味着代码以您期望的方式运行(例如，它导入了一个库)。
为了解决这个问题，我建议确保你已经在Terminal中安装了你的库。如果没有，您可以安装它们，然后再导入。
例如，我将首先导入已经安装在我的机器上的json包。我将在 RStudio 中使用端子来完成此操作。另外，让我试着导入TensorFlow 包。
从下图可以看出没有包TensorFlow。所以，让我切换回 bash 并安装这个包:
然后转到新安装的包TensorFlow所在的目录，切换到 Python ，再次导入包:
好吧。有关更多信息，请查看安装 Python 模块页面。
数据
现在我们已经有了 R 和 Python 集合，让我们导入一些数据来玩玩。我将使用来自 Gapminder 的样本，这是一个关于世界人口社会人口学的有趣项目。更具体地说，我将使用 GapMinder 库中最新的可用数据。
- R 中的数据导入:
*# Let us begin with the most recent set of data*
gapminder_latest <- gapminder %>%
**filter**(year == **max**(year))
所以，现在我们在 R 中加载了一个数据。不幸的是，无法通过 Python 直接访问 R 对象(例如向量odtibles)。所以，我们需要先转换 R 对象。
- Python 中的数据导入:
*# Convert R Data Frame (tibble) into the pandas Data Frame*
gapminder_latest_py = r['gapminder_latest']
当使用 Python 对象(例如数组或pandas 数据帧)时，要意识到的一件重要事情是，它们是而不是 显式地存储在环境中的，就像 R 对象一样。
- 换句话说，如果我们想知道工作区中存储了什么，我们必须调用像
dir()、globals()或locals()这样的函数:
['R', '__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'contact_window_days', 'contact_window_days_style', 'fig', 'gapminder_latest_count_py', 'gapminder_latest_max_lifeExp_py', 'gapminder_latest_mean_lifeExp_py', 'gapminder_latest_median_lifeExp_py', 'gapminder_latest_min_lifeExp_py', 'gapminder_latest_py', 'gapminder_latest_shape', 'gapminder_latest_stdev_lifeExp_py', 'lifeExpHist', 'np', 'pd', 'px', 'r', 'st', 'sys', 'variable', 'variable_grouping', 'variable_name']
太好了，在现在的对象中，我们可以清楚地看到数据(gapminder_latest_py)或库(如px)。
那么，让我们来探究一下这些数据吧！
预期寿命
出于演示的目的，我将把重点放在预期寿命(T21)或一个人预期的平均寿命上。
描述统计学
让我们从使用 Python 计算一些描述性统计数据开始，如表示、中位数或数据中的行数:
*# Descriptive statistics for the inline code in Python**## Data Frame Overview**### Number of rows*
gapminder_latest_shape = gapminder_latest_py.shape[0]
*### Number of distinct values within the life expectancy variable*
gapminder_latest_count_py = gapminder_latest_py['lifeExp'].nunique()*## Life Expectancy**### Median (Life Expectancy)*
gapminder_latest_median_lifeExp_py = st.median(gapminder_latest_py['lifeExp'])
*### Mean*
gapminder_latest_mean_lifeExp_py = st.mean(gapminder_latest_py['lifeExp'])
*### Minimum*
gapminder_latest_min_lifeExp_py = min(gapminder_latest_py['lifeExp'])
*### Maximum*
gapminder_latest_max_lifeExp_py = max(gapminder_latest_py['lifeExp'])
*### Standard deviation*
gapminder_latest_stdev_lifeExp_py = st.stdev(gapminder_latest_py['lifeExp'])
很好。不幸的是，我们无法使用 Python 对象进行内联编码，这是中 R Markdown 的关键特性之一。因此，如果我们想要将结果用于内联代码，我们需要将 Python 对象转换回 R :
*# Descriptive statistics for the inline code in Python - transformed to R**## Data Frame Overview**## Number of rows*
gapminder_latest_nrow_r = py$gapminder_latest_shape
*### Number of distinct values within the life expectancy variable*
gapminder_latest_count_r = py$gapminder_latest_count_py*## Life Expectancy**### Median (Life Expectancy)*
gapminder_latest_median_lifeExp_r = py$gapminder_latest_median_lifeExp_py
*### Mean*
gapminder_latest_mean_lifeExp_r = py$gapminder_latest_mean_lifeExp_py
*### Minimum*
gapminder_latest_min_lifeExp_r = py$gapminder_latest_min_lifeExp_py
*### Maximum*
gapminder_latest_max_lifeExp_r = py$gapminder_latest_max_lifeExp_py
*### Standard deviation*
gapminder_latest_stdev_lifeExp_r = py$gapminder_latest_stdev_lifeExp_py
那么，关于 2007 中的寿命**，我们能说些什么呢？**
首先，有 142 个国家上榜。预期寿命的最小值为 39.61 岁，最大值 82.6 岁。
平均预期寿命值为 67.01 岁，平均预期寿命中位数为 71.94 岁或更长。最后，标准差是 12.07 年。
图表(使用 Plotly)
好吧，我们换个话题，比如图表。
例如，我们可以使用Plotly来看看全球的预期寿命是如何分布的:
fig = px.histogram(gapminder_latest_py, *# package.function; Data Frame*
x="lifeExp", *# Variable on the X axis*
range_x=(gapminder_latest_min_lifeExp_py,
gapminder_latest_max_lifeExp_py), *# Minimum and maximum values for the X axis*
labels={'lifeExp':'Life expectancy - in years'}, *# Naming of the interactive part*
color_discrete_sequence=['#005C4E']) *# Colour of fill* lifeExpHist = fig.update_layout(
title="Figure 1\. Life Expectancy in 2007 Across the Globe - in Years", *# The name of the graph*
xaxis_title="Years", *# X-axis title*
yaxis_title="Count", *# Y-axis title*
font=dict( *# "css"*
family="Roboto",
size=12,
color="#252A31"
))lifeExpHist.write_html("lifeExpHist.html") *# Save the graph as a .html object*
遗憾的是，无法通过 Python 在 R Markdown 中打印交互式Plotly图形。或者，更准确地说，你将通过打印(如print(lifeExpHist))得到一个Figure object:
Figure({
'data': [{'alignmentgroup': 'True',
'bingroup': 'x',
'hovertemplate': 'Life expectancy - in years=%{x}<br>count=%{y}<extra></extra>',
'legendgroup': '',
'marker': {'color': '#005C4E'},
'name': '',
'offsetgroup': '',
'orientation': 'v',
'showlegend': False,
'type': 'histogram',
'x': array([43, 76, 72, 42, 75, 81, 79, 75, 64, 79, 56, 65, 74, 50, 72, 73, 52, 49,
59, 50, 80, 44, 50, 78, 72, 72, 65, 46, 55, 78, 48, 75, 78, 76, 78, 54,
72, 74, 71, 71, 51, 58, 52, 79, 80, 56, 59, 79, 60, 79, 70, 56, 46, 60,
70, 82, 73, 81, 64, 70, 70, 59, 78, 80, 80, 72, 82, 72, 54, 67, 78, 77,
71, 42, 45, 73, 59, 48, 74, 54, 64, 72, 76, 66, 74, 71, 42, 62, 52, 63,
79, 80, 72, 56, 46, 80, 75, 65, 75, 71, 71, 71, 75, 78, 78, 76, 72, 46,
65, 72, 63, 74, 42, 79, 74, 77, 48, 49, 80, 72, 58, 39, 80, 81, 74, 78,
52, 70, 58, 69, 73, 71, 51, 79, 78, 76, 73, 74, 73, 62, 42, 43]),
'xaxis': 'x',
'yaxis': 'y'}],
'layout': {'barmode': 'relative',
'font': {'color': '#252A31', 'family': 'Roboto', 'size': 12},
'legend': {'tracegroupgap': 0},
'margin': {'t': 60},
'template': '...',
'title': {'text': 'Figure 1\. Life Expectancy in 2007 Across the Globe - in Years'},
'xaxis': {'anchor': 'y', 'domain': [0.0, 1.0], 'range': [39.613, 82.603], 'title': {'text': 'Years'}},
'yaxis': {'anchor': 'x', 'domain': [0.0, 1.0], 'title': {'text': 'Count'}}}
})
所以，我们导入先前创建的*。html* 文件(例如使用htmltools包中的includeHTML功能):
htmltools::**includeHTML**("lifeExpHist.html") *# Render the graph*
所以，这里有一个基本的，然而是用 Python 版本的Plotly制作的交互式直方图。
然而，在 RStudio 中生成这个图表需要一种变通方法。同时，以这种方式产生的图形的大小可以很容易地达到几十兆字节。
- 因此，包含这些图表的. html 报告需要大量数据来下载给读者，并且需要更多时间来呈现页面**。**
汇总表(使用熊猫)
pandas的一个常见用例是提供数据描述。各自的代码运行良好。但是，由于您在pandas中使用了样式，因此无法对输出进行样式化。
- 说到
pandas，我们可以很容易地为常用的统计数据创建一个汇总表，如个大洲的预期寿命的平均值或标准差:
*# Create a pandas Data Frame object containing the relevant variable,*
*# conduct formatting.*
gapminder_latest_py['continent'] = gapminder_latest_py['continent'].astype(str)
variable = 'continent'
variable_name = 'Continents'
gapminder_latest_py['lifeExp'] = gapminder_latest_py['lifeExp'].astype(int)
variable_grouping = 'lifeExp'
contact_window_days = gapminder_latest_py.groupby([
pd.Grouper(key=variable)])\
[variable_grouping]\
.agg(['count',
'min',
'mean',
'median',
'std',
'max'])\
.reset_index()
contact_window_days_style = contact_window_days\
.rename({'count': 'Count',
'median': 'Median',
'std': 'Standard Deviation',
'min': 'Minimum',
'max': 'Maximum',
'mean': 'Mean',}, axis='columns')
输出:
continent Count Minimum Mean Median Standard Deviation Maximum
0 Africa 52 39 54.326923 52.0 9.644100 76
1 Americas 25 60 73.040000 72.0 4.495183 80
2 Asia 33 43 70.151515 72.0 7.984834 82
3 Europe 30 71 77.100000 78.0 2.916658 81
4 Oceania 2 80 80.500000 80.5 0.707107 81
另外，请注意 Python 环境设置覆盖了 R 中的设置。例如，看看均值或标准差的位数。有六个数字，而不是开头的两个数字。
结束语
好了，现在够了。如果你渴望更高级的东西，比如使用 R 中的scikit-learn 包进行无监督学习，看看的。
然而，在结束这篇文章之前，让我说一下，如果你考虑切换到 Python 并经常使用它，考虑一下 IDE 替代 RStudio 。
许多分析师相信 Jupyter 笔记本 的交互性，集成markdown或选择运行各种语言的代码，如R、Julia或JavaScript。 JupyterHub 是基于 Jupyter 笔记本的平台，增加了版本控制。通常，用户在集装箱环境中运行分析)。另一个关于交互性和协作的例子可能是 Colab ，基本上就是运行在谷歌云上的 Jupyter 笔记本。
最后，有一个伟大的软件叫做 Visual Studio 代码 。它不仅允许你用多种语言创建和运行代码，或者在纯 Python 代码和交互式 Jupyter 笔记本之间无缝流动。也许更重要的是，它为您提供了非常有效的版本控制管理(比如 Git 集成和扩展)。如果选择这个 IDE，可以像 RStudio 一样设置 VS 代码进行 Python 开发。
但是不管你选择什么样的 Python 之路，不要忘记它是一个适合某些情况的工具，而对其他人可能就不那么适合了。就像 r 一样，在了解不同工具的优点的同时，尽量利用它的优点。
Python 环境 101
pyenv 和 pipenv 有何不同，何时应该使用它们
作者图片
**Table of Contents**
🐍 [Introduction](#9ea4)
🐍 [TL;DR](#39b6)
🐍 [pyenv](#f3ad)
🐍 [pipenv](#c002)
🐍 [Conclusion](#e4c6)
[更新:2021 年 8 月 15 日 pyenv 安装]
简介:pyenv vs pipenv vs virtualenv
我当时用的是 Python 3.7.7 + virtualenv，有一天安装了 3.8.2。这给 Jupyter 笔记本带来了麻烦。它不工作，我得到了各种错误信息。
我想我应该整理一下 Python 环境。我需要知道 pyenv、pipenv 和 virtualenv 是做什么的。所以这是我所学到的文章。
Python 在 2019 年发布了 13 个版本，在 2018 年发布了 12 个版本。大多数编程语言都有一些版本管理。
Node 有nvmRuby 有 RVM 等。 pyenv 是 Python 版本管理。
它安装/卸载不同的 Python 版本，设置全局和本地(目录)Python 版本。
pyenv-virtualenv 是一个 pyenv 插件，用于管理类 UNIX 系统上的 Python 虚拟环境。
依赖项管理是管理项目中所有相关库和包的过程，以确保项目成功运行。
pipenv 是 Python 应用的打包工具，管理包依赖关系及其子依赖关系。
pipenv通过在开发环境中使用 Pipfile，在生产环境中使用 aPipfile.lock，简化了开发过程。pipenv 还管理虚拟环境。
virtualenv 是一个创建隔离 Python 环境的工具。如果您在 python 3.8 下安装 virtualenv，virtualenv 将默认创建也是 3.8 版本的虚拟环境。
这意味着如果您升级您的系统 python，您的虚拟环境可能会中断。我升级到 Python3.7.7 的时候也遇到过。
您可以在您的 Python 项目中使用 pyenv 和 pipenv，在本文中，您将了解到从它们的安装到使用的所有内容。正如我之前提到的，pyenv 有自己的 virtualenv，pyenv-virtualenv。
当您单独使用 virtualenv 时，它使用系统 Python 版本。virtualenvwrapper 为 virtualenv 提供了一套有用的脚本。
在本文中，我将重点关注 pyenv 和 pipenv，因为当您更新系统 Python 版本时， virtualenv 会出现问题。
pyenv 是 Python 版本管理+虚拟环境工具，pipenv 是 Python 包管理和虚拟环境工具。
TL；速度三角形定位法(dead reckoning)
pyenv、pipenv 和 virtualenv 图。作者图片
pipenv 创建独立的 pip 环境，而 pyenv+virtualenv 创建多个项目可以使用的 virtualenv。
pyenv
如果您正在处理您的个人项目或者使用一个以上的系统，比如团队或服务器和本地，那么您应该使用 pyenv。
安装 pyenv
可以将 pyenv 安装到 macOS 和其他 Linux OS 。(如果您有任何安装问题，请参见 Github pyenv 安装页面。)
# for macOS
$ brew install pyenv
将以下内容添加到 bash_profile/zshrc 将定义环境变量PYENV_ROOT。
对于 zsh，在您的终端中运行以下命令。
$ echo 'eval "$(pyenv init --path)"' >> ~/.zprofile
(这部分可能已经不相关了，我留下来做参考。)
pyenv 的工作原理是在你的路径前面插入一个由垫片组成的目录。一个 shim 是一个小的库，它拦截并改变对另一个库的调用。添加以下内容可以启用填充和自动完成。
$ echo -e 'if command -v pyenv 1>/dev/null 2>&1; then\n eval "$(pyenv init -)"\nfi' >> ~/.zshrc
安装 python 版本
列出可用的 Python 版本
$ pyenv install -l
Available versions:
2.1.3
2.2.3
...
安装新的 Python 版本
$ pyenv install 3.7.7
$ pyenv install 3.8.2
显示系统中的所有 Python 版本
$ pyenv versions
3.7.7
3.8.2
设置全局 Python 版本
$ pyenv global 3.7.7
验证活动 Python 版本
$ pyenv version
3.7.7 (set by /Users/shinokada/.pyenv/version)
pyenv 快速参考。作者图片
pyenv 本地
pyenv local在目录中创建或修改.python-verion。例如，pyenv local 3.7.7用Python 3.7.7. pyenv local 3.8.2创建.python-verion并将.python-verion修改为Python 3.8.2
。python 版本文件
如何创建虚拟环境
如果您正在处理您的个人项目，并且没有安装 pipenv，我建议您安装 pyenv-virtualenv 。
如果您在一个团队中工作，或者使用不止一个系统，我建议您安装 pipenv，我将在下面介绍它。
pyenv-virtualenv是一个 pyenv 插件，它提供了在类 UNIX 系统上管理 Python 的 virtualenvs 和 Conda 环境的特性。
下面是如何安装 pyenv-virtualenv 的说明。
# For Homebrew users
$ brew install pyenv-virtualenv
然后，您需要将以下内容添加到您的。bash_profile 或. zshrc。
# pyenv-virtualenv
eval "$(pyenv init -)"
eval "$(pyenv virtualenv-init -)"
您可以通过用 virtualenv 目录的名称指定 Python 版本来创建 virtualenv。
# Create a virtualenv called py377 using Python 3.7.7
$ pyenv virtualenv 3.7.7 py377
# Create a virtualenv called py382 using Python 3.8.2
$ pyenv virtualenv 3.8.2 py382
# Create a virtualenv called jupy based on the global Python version
$ pyenv virtualenv jupy
我经常使用这个命令来创建一个 virtualenv。
$ pyenv virtualenv 3.8.6 py386
本地虚拟
一旦创建了不同的 virtualenv，就可以为一个目录设置一个本地 virtual env。这里我用的是 Oh-My-Zsh 内置命令 [take](/the-ultimate-guide-to-your-terminal-makeover-e11f9b87ac99)。
$ take py377
# Set a local(direcotry) python environment to 377
$ pyenv local py377
(py377)$ cat .python-version
py377
设置本地虚拟环境
设置本地虚拟环境
每个 virtualenv 都有不同的 pip 存储
下图中，我在 virtualenv py377 下升级了 pip。在将本地改为 3.7.7 并检查 pip 列表后，它显示了不同的 python 包。
每个 pyenv virtualenv 都有不同的 pip
如何删除本地虚拟机:
通过移除.python-version你可以移除一个本地虚拟。
# remvoing .python-version will set the directory to the global Python version
$ rm .python-version
删除虚拟设备
$ pyenv uninstall my-virtual-env
# or
$ pyenv virtualenv-delete my-virtual-env
pyenv activate 是做什么的？
您可以激活虚拟设备:
# Activate py382
$ ~/pythonproject: pyenv activate py382
# cd to py377 which has local virtualenv py377\.
# Activated version py382 overrides the local
(py382) $ ~/pythonproject: cd py377
# confirming the local virtualenv is py377
(py382) $ ~/pythonproject/py377: cat .python-version
py377
# Deactivate py382
(py382) $ ~/pythonproject/py377: pyenv deactivate
# Now the local virtualenv py377 is used
(py377) $ ~/pythonproject/py377:
当你
activate a virtulaenv时，virtualenv 会覆盖本地 virtualenv。
pipenv
如果您的项目依赖于 Python 包版本及其依赖项，那么 pipenv 适合您。
pipenv 创建了一个 Pipfile.lock，您可以在移动到不同的系统时使用它。
Pipfile.lock 包含所有的依赖项及其版本。
当您使用 Pipfile.lock 安装 Python 包时，它将创建与您的原始系统完全相同的环境。
当一个 repo 有一个 Pipfile.lock 时，可以用
pipenv install安装所有的包和依赖项。
让我们用自制软件安装 pipenv。你可以在这里找到其他操作系统的安装。
# macOS
brew install pipenv
使用 Python 3.7 创建新项目:
$ pipenv --python 3.7 install
pipenv-python 3 . 7 . 7 安装创建 Pipfile 和 Pipfile.lock
在上图中，我用pipenv --python 3.7.7创建了一个新的虚拟人。它显示虚拟位置:
Virtualenv location: /Users/shinokada/.local/share/virtualenvs/pi37-AdrjAtjU
它创建了 Pipfile 和 Pipfile.lock。pipenv 使用这些 Pipfile 和 Pipfile . lock 来控制 Python 版本和包版本。
pip 文件内容:
cat Pipfile
[[source]]
name = "pypi"
url = "https://pypi.org/simple"
verify_ssl = true[dev-packages][packages][requires]
python_version = "3.7"
[source]告诉您的包来源。[包裹]是您的包裹信息。[dev-packages]适合您的开发需求。[requires]是所需的 Python 版本。
Pipfile.lock 内容:
cat Pipfile.lock
{
"_meta": {
"hash": {
"sha256": "7e7ef69da7248742e869378f84218111f8f0017fddf94d086813baa518a65489"
},
"pipfile-spec": 6,
"requires": {
"python_version": "3.7"
},
"sources": [
{
"name": "pypi",
"url": "https://pypi.org/simple",
"verify_ssl": true
}
]
},
"default": {},
"develop": {}
}
一旦你安装了一个包，你可以在 Pipfile.lock 中的default下找到这个包和散列。
作者快速参考
pipenv 与 pyenv 一起工作
如果您的系统没有特定的 Python 版本，它会询问您是否要安装 Python 版本。
$ pipenv --python 3.6
Warning: Python 3.6 was not found on your system…
Would you like us to install CPython 3.6.10 with pyenv? [Y/n]: Y
Installing CPython 3.6.10 with pyenv (this may take a few minutes)…
⠼ Installing python...
$ ls
Pipfile
pipenv 与 pyenv 一起工作
这将在目录中创建一个 Pipfile。
cat Pipfile
[[source]]
name = "pypi"
url = "https://pypi.org/simple"
verify_ssl = true[dev-packages][packages][requires]
python_version = "3.6"
安装软件包
我们用pipenv代替pip来安装包。
$ pipenv install numpy
$ cat Pipfile
...
[packages]
numpy = "*"
...
这就创建了 Pipfile.lock 并将numpy ="*"添加到 Pipfile 中。您可以使用 Pipfile.lock 在不同的系统中创建相同的环境。
安装项目的所有依赖项(包括开发):
$ pipenv install --dev
创建包含预发行版的锁定文件:
$ pipenv lock --pre
显示已安装依赖项的图表:
$ pipenv graph
numpy==1.18.4
检查您安装的依赖项是否存在安全漏洞:
$ pipenv check
Checking PEP 508 requirements…
Passed!
Checking installed package safety…
An error occurred:
Your API Key '1ab8d58f-5122e025-83674263-bc1e79e0' is invalid. See [https://goo.gl/O7Y1rS](https://goo.gl/O7Y1rS)
它返回一个错误，我希望未来的版本可以修复它。
将本地 setup.py 安装到您的虚拟环境/Pipfile 中:
$ pipenv install -e .
使用低级 pip 命令:
$ pipenv run pip freeze
管道外壳和出口
您可以通过运行pipenv shell激活项目的 virtualenv，通过运行exit停用它。
升级软件包的 pipenv shell
如上图所示，可以使用pipenv shell并使用list和-U等 pip 命令来升级包。
作者的一些 pip 命令
拆卸管道虚拟管道
$ pipenv --rm
Removing virtualenv (/Users/shinokada/.local/share/virtualenvs/pi37-AdrjAtjU)…
所以你所有的 pipenvs 都存储在~/.local/share/virutlaenvs目录下。
ls ~/.local/share/virtualenvs
pi36-JaecZ40h pi37-AdrjAtjU
如果您愿意，可以从该目录中删除 pipenv。
pipenv 和 pyenv 虚拟冲突
如果你试图在 pyenv 下使用 pipenv，就会发生这种情况。它将显示一个礼貌通知。
$ mkdir demo
$ cd demo
# Python version
$ python --version
Python 3.7.7
# create a virtualenv
$ pyenv virtualenv 3.8.2 demo382
Looking in links: /var/folders/17/2xhf1tw15xzd8sz_0hw3gp2h0000gn/T/tmpcn78j8xb
...
# Set the local virtualenv
$ pyenv local demo382
(demo382) $ python --version
Python 3.8.2# Create pipenv
$ pipenv --python 3.8
Courtesy Notice: Pipenv found itself running within a virtual environment, so it will automatically use that environment, instead of creating its own for any project. You can set PIPENV_IGNORE_VIRTUALENVS=1 to force pipenv to ignore that environment and create its own instead. You can set PIPENV_VERBOSITY=-1 to suppress this warning.
Pipfile.lock
当您准备将其投入生产时，您需要锁定您的环境，以便您可以确保在生产中使用相同的环境。
$ pipenv lock
这将创建或更新您的Pipfile.lock。
一旦您在生产环境中获得了代码和Pipfile.lock，您就可以安装所有的包:
$ pipenv install --ignore-pipfile
这将忽略Pipfile进行安装，并使用Pipfile.lock安装所有软件包。Pipenv 将创建与您的开发环境完全相同的环境，包括子依赖项。
结论
pyenv，pipenv 图。作者图片
上图左侧，pyenv + pyenv-virtualenv 可以容纳不同的项目。
这意味着 pyenv-virtualenv 可以与不同的项目共享包。而在 pyenv+pipenv 上，每个项目都拥有自己的 pip/包，没有共享。
如果你在一个团队中工作，那么你应该一起使用 pyenv+pipenv。
如果您的项目涉及多个系统，比如本地和远程服务器，那么您也应该使用它们。
因此，简而言之，如果您的项目涉及多个系统，您应该使用 pyenv+pipenv。
pyenv 和 pipenv 创建 virtualenvs 的方式不同，但您可以同时使用这两种方式。
还有其他可用的工具，它们有不同的范围和用途，如下图所示。
从https://github.com/David-OConnor/pyflow
通过 成为 会员，可以完全访问媒体上的每一个故事。
适合每个开发人员的现代 Linux 命令
towardsdatascience.com](/awesome-rust-powered-command-line-utilities-b5359c38692) [## 终端改造的终极指南
今天你将度过的最好的 11 分钟:程序员的终端提示
towardsdatascience.com](/the-ultimate-guide-to-your-terminal-makeover-e11f9b87ac99) [## 为您的数据科学项目安排任务的分步指南
macOS/Linux 中 cron 和 launchd 的完整指南
towardsdatascience.com](/a-step-by-step-guide-to-scheduling-tasks-for-your-data-science-project-d7df4531fc41)
参考
Python ETL 工具:最佳 8 个选项
想用 Python 做 ETL？这里有 8 个很棒的图书馆
ETL 是从一个或多个系统获取数据，并在进行一些中间转换后将其加载到目标数据仓库的过程。市场上有各种 ETL 工具可以执行这个过程。
一些工具提供完整的端到端 ETL 实现，一些工具帮助您从头开始创建自定义 ETL 过程，还有一些选项介于两者之间。在本帖中，我们将看到一些常用的 Python ETL 工具，并了解在哪些情况下它们可能非常适合您的项目。
在浏览 Python ETL 工具列表之前，让我们首先了解任何 ETL 工具都应该具备的一些基本特性。
ETL 工具的特性
ETL 代表提取、转换和加载，因此任何 ETL 工具至少应该具有以下特性:
提取
这是从各种来源提取数据的过程。一个好的 ETL 工具支持各种类型的数据源。这应该包括大多数数据库(基于 NoSQL 和 SQL 的)和文件格式，如 csv、xls、xml 和 json。
改变
提取的数据通常保存在暂存区，原始数据在这里被清理并转换成有意义的形式，以便存储在数据仓库中。标准的 ETL 工具支持所有基本的数据转换特性，如行操作、连接、排序、聚合等。
负荷
在加载过程中，转换后的数据被加载到目标仓库数据库中。标准 ETL 工具支持各种数据库的连接器，如 Snowflake、MS SQL 和 Oracle。
其他附加功能
除了基本的 ETL 功能之外，一些工具还支持额外的特性，比如用于可视化和跟踪各种 ETL 管道的仪表板。事实上，除了 ETL 之外，一些工具还提供了执行并行或分布式处理的能力，在某些情况下甚至是基本的分析，根据您的项目需求，这些都是很好的附加组件。
Python ETL 工具
Python 是一种相对容易学习和使用的编程语言。Python 在 GitHub 上有一个非常活跃的开源社区，定期推出新的 Python 库和增强功能。由于这个活跃的社区和 Python 的低难度/功能比，Python 现在在许多不同的领域都引人注目，如游戏开发、web 开发、应用程序开发、NLP 和计算机视觉等等。
近年来，Python 已经成为数据处理、数据分析和数据科学(尤其是强大的 Pandas 数据科学库)的流行编程语言选择。因此，有大量的 Python ETL 工具可供选择就不足为奇了。我们来看看最常见的。
Petl
Petl(代表 Python etl)是一个基本工具，它提供了从不同来源(如 csv、XML、json、text、xls)向数据库导入数据的标准 ETL 功能。就功能而言，它微不足道，并且不像列表中的其他工具那样提供数据分析功能。但是，它支持所有标准的转换，如行操作、排序、连接和聚合。
对于一个简单的工具来说，Petl 还不错，但是它可能会遇到性能问题；尤其是与其他一些选择相比。因此，如果您只需要构建一个简单的 ETL 管道，并且性能不是主要因素，那么这个轻量级工具应该可以完成这项工作。但是对于任何更复杂的东西，或者如果你期望项目的范围扩大，你可能想要继续寻找。
熊猫
熊猫标志，一个对 ETL 有用的 Python 库
Pandas 是当今最流行的 Python 库之一，也是我个人的最爱。我用它来处理水文数据、天体物理数据和无人机数据。它越来越受欢迎很大程度上是因为它在数据科学中的使用，这本身就是一个快速发展的领域，也是我第一次遇到它的原因。
Pandas 使用数据帧作为数据结构来保存内存中的数据(类似于 R 编程语言中处理数据的方式)。除了常规的 ETL 功能，Pandas 还支持大量的数据分析和可视化特性。
Pandas 相对容易使用，并且具有许多丰富的功能，这就是为什么它是数据科学家进行简单 ETL 和探索性数据分析的常用工具。如果您已经在使用 Pandas，它可能是部署概念验证 ETL 管道的一个好的解决方案。
玛拉
Mara 是一个轻量级的 Python ETL 工具，但是仍然提供了创建 ETL 管道的标准特性。它还提供了其他内置功能，如基于 web 的 UI 和命令行集成。Web UI 有助于可视化 ETL 管道执行，这也可以集成到基于 Flask 的应用程序中。它使用 PostgreSQL 作为数据处理引擎。
如果你正在寻找一个简单的 ETL 工具，但仍然有一些复杂的功能，那么 Mara 可能是一个不错的选择。
气流
阿帕奇气流的标志
Apache Airflow 由 Airbnb 创建，是一款开源的工作流管理工具。它可以用来创建数据 ETL 管道。严格地说，它本身不是一个 ETL 工具，相反，它更像是一个编排工具，可以用来创建、调度和监控工作流。这意味着您可以使用 Airflow 通过整合您的 ETL 过程的各种独立编写的模块来创建管道。
气流工作流遵循 DAG(有向无环图)的概念。与列表中的其他工具一样，Airflow 也有一个基于浏览器的仪表板，用于可视化工作流和跟踪多个工作流的执行。如果您想通过将独立的和现有的模块链接在一起来创建一个复杂的 ETL 工作流，Airflow 是一个不错的选择
Pyspark
PySpark 标志
Pyspark 是运行在 Python 上的 spark 版本，因此得名。根据他们的网站，“Spark 是用于大规模数据处理的统一分析引擎。”
Spark 内核不仅为创建 ETL 管道提供了强大的功能，还支持数据流(Spark Streaming)、SQL (Spark SQL)、机器学习(MLib)和图形处理(Graph X)。
使用 Pyspark 的主要优点是可以快速处理大量数据。因此，如果您希望创建一个 ETL 管道来快速处理大数据或处理数据流，那么您绝对应该考虑 Pyspark。也就是说，它不是现成的 ETL 解决方案，而是 ETL 管道部署的一部分。
倭黑猩猩
Bonobo Python ETL 工具的徽标
Bonobo 是一个使用 Python 构建的轻量级 ETL 工具。它很简单，也相对容易学习。它使用图形概念来创建管道，并且还支持管道中多个元素的并行处理。它还有一个可视化界面，用户可以在其中跟踪 ETL 管道的进度。
总而言之，它只是另一个易于使用的 ETL Python 工具，对于简单的用例来说，这可能是一个很好的选择，但没有太多突出的功能来将其与包分开。
(是的，我们的名单中既有熊猫也有倭黑猩猩)
路易吉
Luigi Python ETL 工具的徽标
Luigi 是一个基于 Python 的 ETL 工具，由 Spotify 创建，但现在作为开源工具提供。它是一个比这个列表中的许多工具更复杂的工具，并且具有创建复杂 ETL 管道的强大功能。根据他们的 Github 页面，“它处理依赖关系解析、工作流管理、可视化、处理故障、命令行集成等等”。
它还带有一个 web 仪表板来跟踪所有的 ETL 作业。如果你正在寻找建立一个企业解决方案，那么 Luigi 可能是一个不错的选择。
奥多
Odo 是一个 Python 工具，可以将数据从一种格式转换成另一种格式。但是它主要值得注意的特性是在将巨大的 csv 数据集加载到各种数据库时的性能。
正如他们在自己的网站上描述的:“Odo 使用它所支持的数据库的本地 CSV 加载能力。这些装载机速度极快。在加载大型数据集时，Odo 将击败任何其他纯 Python 方法。”
我没有做过性能测试来验证这些说法，但如果有人做过，请在评论中分享。但是不管怎样，它的用例似乎很清楚:如果您正在寻求创建一个简单的管道，重点是将巨大的 csv 数据集加载到您的数据仓库中，那么您应该尝试 Odo。
惊喜选项:通过数据虚拟化跳过 ETL
听起来可能很奇怪，一些公司已经完全放弃使用 ETL，转而支持通过 数据虚拟化 进行直接集成。
数据虚拟化是一个逻辑数据层，它跨不同的孤岛集成数据。数据虚拟化管理统一数据，并通过集中的安全性和治理将数据交付给用户。
Denodo 提供数据虚拟化作为数据管理/工程选项。
结论
正如您所看到的，有很多 Python ETL 工具可供选择，每种工具都有自己的特点和缺点。无论您只是在寻找标准的 ETL 功能，还是在寻找更多的附加功能和复杂性，Python 都可能是一个不错的选择。
Python ETL 与 ETL 工具
你应该自己编码还是授权一个 ETL 工具？
选择你的方向:自己编码你的 ETL 管道或者使用现有的 ETL 工具
如果你正在研究 ETL 解决方案，你将不得不决定是使用现有的 ETL 工具，还是使用其中一个 Python ETL 库构建自己的 ETL 工具。在这篇文章中，我们来看看在做决定时需要考虑的一些因素。
ETL(提取转换负载)是为数据仓库创建数据管道的最重要的方面。市场提供了各种现成的 ETL 工具，可以很容易地在数据仓库中实现。然而，最近 Python 也成为创建定制 ETL 管道的一个很好的选择。在本文中，我们将快速比较 Python ETL 和 ETL 工具，以帮助您在项目中选择两者。
ETL 工具
市场上有许多现成的 ETL 工具可以用来构建容易复杂的数据管道。大多数提供友好的图形用户界面，具有丰富的管道构建功能，支持各种数据库和数据格式，有时甚至包括一些有限的商业智能功能。最棒的是，所有这些都是现成的。
这些工具可以是许可的，也可以是开源的。他们中的大多数都采用订阅模式，从每月几百美元到每月几千美元不等。另一方面，开源工具是免费的，它们也提供了一些许可工具所提供的特性，但是通常需要更多的开发才能达到类似的结果。
市场上一些可用的 ETL 工具如下。
信息动力中心
Informatica 的 ETL 解决方案是目前最常用的数据集成工具，用于连接和检索来自不同数据源的数据。Informatica 在这个行业已经有很长时间了，并且是这个领域的一个成熟的参与者。他们有针对 ETL、数据屏蔽、数据质量、数据复制、数据管理等的数据集成产品。
阿洛玛
Alooma 是一款授权的 ETL 工具，专注于将数据迁移到云中的数据仓库。Alooma 似乎是许多企业的一个很好的解决方案，它的自动化数据管道以及与 Amazon Redshift、Microsoft Azure 和 Google BigQuery 的简单集成。然而，在 2019 年被谷歌收购后，Alooma 在很大程度上放弃了对非谷歌数据仓库解决方案的支持。这可能会给依赖多个云平台的公司带来问题。
Xplenty
Xplenty 是一个基于云的 ETL 和 ELT(提取、加载、转换)工具。它使用可视化界面来构建数据管道，并连接到 100 多个常见数据源。
AWS 胶水
AWS Glue 是亚马逊基于 AWS 平台的无服务器 ETL 解决方案。如果你已经在 AWS 生态系统中根深蒂固，AWS Glue 可能是一个不错的选择。
Python ETL
Python 无需介绍。每年 Python 在越来越多的领域变得无处不在，从天体物理学到搜索引擎优化。所以 Python 有 ETL 的解决方案也就不足为奇了。
对于 ETL，Python 提供了一些健壮的开源库。得益于不断增长的 Python 开源社区，这些 ETL 库提供了大量特性来开发健壮的端到端数据管道。
如果您对 Python 了如指掌，您可以创建复杂的 ETL 管道，类似于使用 ETL 工具所能完成的事情。但是要准备好消耗一些开发时间。这些库功能丰富，但不像上面列出的一些 ETL 平台那样现成可用。
一些流行的 python ETL 库有:
- 熊猫
- 路易吉
- Petl
- 倭黑猩猩
- 气泡
这些库已经在关于 Python ETL 选项的其他帖子中进行了比较，所以我们在这里不再重复讨论。相反，我们将关注是使用这些还是使用已建立的 ETL 平台。
Python ETL 与 ETL 工具
在设计数据仓库策略时，必须仔细选择 ETL 的策略。一旦你选择了一个 ETL 过程，你就被套牢了，因为将它移植到另一个平台需要花费大量的开发时间。对于具有许多模式和复杂体系结构的企业数据仓库来说尤其如此。
因此，让我们比较一下定制 Python ETL 和 ETL 工具的有用性，以帮助做出选择。
费用
ETL 工具(尤其是大型企业数据仓库)的许可成本可能很高——但这一费用可能会被您的工程师在其他事情上节省的时间所抵消。较小的公司或创业公司可能不总是能够负担得起 ETL 平台的许可费用。在这种情况下，创建一个定制的 Python ETL 可能是一个不错的选择。但是，同样重要的是，要考虑这样节省的成本是否值得推迟产品上市。初创公司的另一个考虑因素是，像 Avik Cloud 这样定价更灵活的平台可以保持成本与使用成比例——这将使 ETL 需求有限的早期初创公司更加负担得起。
数据仓库的规模和复杂性
如果它是一个具有复杂模式的大型数据仓库，从头开始编写一个定制的 Python ETL 过程可能会很有挑战性，尤其是当模式更改更加频繁时。在这种情况下，您应该从各种 ETL 工具中探索适合您的需求和预算的选项。
简单和灵活
如果数据仓库很小，您可能不需要企业 ETL 工具的所有特性。编写一个定制的轻量级 Python ETL 过程可能是一个好主意，因为它既简单又能让您更灵活地根据自己的需要进行定制。
可量测性
数据库的初始大小可能不大。但是如果您预计在不久的将来会有增长，那么您应该判断您的定制 Python ETL 管道是否也能够随着数据吞吐量的增加而扩展。如果有疑问，您可能希望更仔细地研究一些 ETL 工具，因为它们更容易扩展。
用户友好性
正如您可能猜到的那样，要将 Python 用于您的 ETL 过程，需要 Python 方面的专业知识。但是 ETL 工具通常有用户友好的图形用户界面，即使对于非技术人员来说也很容易操作。因此，这是一个根据项目需求做出的选择。
增值和支持
ETL 工具，尤其是付费工具，在多种特性和兼容性方面提供了更多的附加值。他们还提供客户支持——这似乎是一个不重要的考虑，直到你需要它。然而，开源工具确实有很好的文档和大量也能提供支持的在线社区。
如果您使用定制的 Python ETL，您将会错过这些东西。将如此多的市场 ETL 工具的特性整合到具有相同健壮性的定制 Python ETL 过程中是一项具有挑战性的工作。
令人惊讶的第三个选项:数据虚拟化
另一个越来越受欢迎的选择是完全放弃 ETL，转而支持 数据虚拟化 。数据虚拟化是一个逻辑数据层，它跨不同的孤岛集成数据。数据虚拟化管理统一数据，并通过集中的安全性和治理将数据交付给用户。
Denodo 提供数据虚拟化作为数据管理/工程选项。
结论
谈到 Python ETL 和 ETL 工具，没有明显的赢家，它们都有各自的优点和缺点。最后，这一切都归结为基于我们上面讨论的各种参数做出选择。但是，如果您强烈考虑使用 Python 进行 ETL，至少要看看现有的平台选项。如果你觉得特别大胆，可以考虑深入兔子洞，学习一些关于数据虚拟化的知识。同样，如果您正在考虑将 ETL 工具用于简单的 ETL 用例，那么仔细研究一下 Python 可能是值得的。
Python 日常
招数、代码优化、面试问题等
在 Unsplash 上由 Hitesh Choudhary 拍摄的照片
Python 是初学者觉得非常容易上手的语言之一。它是一种解释的、面向对象的高级编程语言。
在本帖中，我们将讨论面试问题、执行操作的 python 技巧、如何优化代码等等。
那么，事不宜迟，让我们开始吧:
1)优化和分析:
我在采访中经常遇到这个问题——如何优化 python 代码。嗯，我通常更喜欢依靠标准的最佳实践尽早构建数据处理管道(我将在本文后面讨论)。然后，开始识别可能以下列形式存在的低效率:
- 一条语句— timeit (在结尾的多个示例中演示了这一点)
- 代码的某一部分——cProfile
让我们先学习代码剖析。
什么是个人资料？根据 python 文档:
概要文件是一组统计数据，描述了程序的各个部分执行的频率和时间。
我们将看到如何使用标准库 cProfile 对给定的 python 函数评估概要文件。
让我们以斐波那契数列为例来说明轮廓是怎样的:
斐波那契数列剖析
轮廓输出
输出中的第一行告诉我们总共监控了多少个调用，其中有多少是原始的。这表明代码中存在递归(因为 180 个调用中只有 4 个是原语调用)。
PyCallGraph 是剖析代码的另一种方式，并且更容易解释，因为输出是 png 图形图像的形式。我们不会在这里讨论太多，因为这超出了这篇文章的范围，更多的可以在这里阅读。
2) 用装饰器缓存结果:
继续上面关于优化的讨论，它需要分析代码的运行时间和内存配置文件。如果代码有较长的运行时间和大量的内存使用，它被称为是昂贵的。
然后对应用程序进行分析，以识别具有优化空间的昂贵代码。提高代码速度的典型方法是缓存罪魁祸首(是的！！！，对我们来说是)。
缓存的目的是存储计算量很大的结果。因此，它们只需计算一次，通过称为 Decorators 的包装器进行缓存和检索。
装饰器是一个函数，它的输入和输出也是一个函数。
装饰斐波那契示例
3) Join()组合字符串:
字符串是不可变的。这意味着每当 2 个字符串被连接时；由于不能就地修改，因此会创建一个新的表示。还要注意，字符串连接的时间度量是连接操作次数和字符串平均长度的函数。
使用“Join”连接字符串，因为它比“+”运算符更快
串并置
4)计数器
如果您想通过添加公共关键字的值来合并两个字典，则“+”运算符不起作用。
例如，A+B 在下面的代码中抛出错误，但可以使用计数器实现:
合并两个字典的计数器
同样，我们也可以找到 A 和 B 的交集和并集。
使用“Counter”的另一个非常基本的应用是当我们传递一个字符串作为输入来计算字符串中每个字母的出现次数时，例如“python”:
字符串计数
可以使用 OrderedDict 来计算每个字母表在字典中出现的顺序:
有序直接
计数器也可以通过展平来计算字典中每个元素的出现次数:
对字典值进行扁平化后的元素进行计数
5)变量交换
避免创建临时变量来交换变量。为了通过一个例子来理解它，让我们看看表达式的交换是如何发生的
x，y = y，x
步骤 1:首先计算右边的 y，x，这在内存中创建了一个 2 元素元组。这两个元素是被标识为 y 和 x 的对象，供 Python 内部处理。
步骤 2:在左侧表达式的求值过程中，元组被分配到左侧，并首先被解包到 x 中，然后是 y 中
变量交换
6) 列表 vs 德格:
Deque 是双端队列，支持内存高效追加和从两边弹出。
**列表:**在列表的末尾插入是有效的，但是，当一个新元素被插入到列表的前面时，所有后面的元素索引都移动 1
这里 deque 派上了用场，它是一个双链表，速度更快。
列表与队列
7) ’ in '关键字
“in”关键字是检查元素是否存在的最快、最干净的方法。
在’与’得到’中
8)映射、减少和过滤关键字
过滤器输出包含满足给定条件的元素的新列表。
Map 对象用于将给定的函数，在我们下面的例子中，一个指数函数，投射到指定的 iterable 的每一项。
Reduce 通过将函数应用于 iterable 返回单个值。它被标记为 reduce，因为它将 iterable 中的元素减少到一个累积值
映射、减少和过滤
9) 发电机的使用:
为了理解生成器，让我们首先理解可迭代的。例如，逐个读取列表的元素被称为迭代，其中列表是可迭代的。但是 iterable 的问题是，它将所有可能并不总是需要的值存储在内存中，因此产生了生成器的角色。
生成器是迭代器的一个子类，它可以动态生成值。这可以节省内存并提高性能。
例如，在视频流以记录盗窃的情况下，人们不是对每个图像都感兴趣，而是只对可能发生盗窃的图像感兴趣。因此，它就像一个正在进行的过程，其中只有某个事件相关的信息需要分析，而不是整个输入需要预先存储。
也可能是这样的情况，我们最初生成一个数字列表，但是基于算法，只使用了一些元素。这导致了在生成这些数字时 CPU 周期的浪费。不仅如此，大量内存被用来同时存储对象中的这些数字。
更多关于提高代码效率的提示不言自明:
- Python 检索局部变量比检索全局变量更快。每次需要全局对象时，访问全局对象都要进行一次完整的查找，从而降低了速度。
- 列表理解更快，因为它不需要加载 append 并作为函数调用。查找、加载和函数调用是一个耗时的过程，它会增加迭代次数。
- 在‘if else’之上尝试 except
- 交集 vs ’ &'运算符:
“交叉点”上的“&”
- 开箱操作员:
使用*作为解包运算符
而且，还有很多。正如他们所说，学习是永无止境的。我将继续写更多关于 Python 及其海量的文章。
在那之前，继续你的旅程，成为一个狂热的“Pythonista”。
PS: 我添加了 python 代码片段来说明概念，而不是创建多个 gists。如果能知道创建多个更小的 gists 来解释每个概念是唯一的演示方式还是有更快的解决方法，那就太好了。
全部代码放在 jupyter 笔记本这里。
感谢阅读。
参考资料:
Python 初学者-基础知识
了解变量、集合、循环等等
通过 Unsplash 的原始图像
- 介绍
- 入门指南
- 变量
- 基本操作
- 收集
- 经营者
- 环
- 条件语句
- 有用的东西
介绍
Python 是一种面向对象的、解释性的高级语言，具有简单的语法和强大的功能。使用 Python，我们可以用更少的努力和更多的可读性来构建复杂的应用程序。
既然我们知道了什么是 Python？我们来探讨一下为什么要用？
- 高级 大部分 Python 组件都取自自然语言——我们用来交流的语言。与其他语言相比，这使得 Python 更容易学习。
- 解释 Python 逐行编译代码——这使得识别错误变得容易，同时，与其他代码相比，速度有点慢。
- 简单的语法
如果你是一名经验丰富的开发人员，现在正试图学习 Python，这将比你已经在学习的语言更加直接和简单。但是如果你是编程新手，我认为你从 Python 开始是幸运的。你找不到比 Python 更简单又强大的语言了。 - 动态语义
如果你是一个典型的传统编码者，你知道我们应该在使用之前初始化任何东西。在 Python 中，这一切都是动态发生的。
入门指南
我建议您使用 PyCharm IDE，因为您正在学习 Python，您可以从这里的下载它。安装和配置 IDE 很简单，但是当涉及到解释器时，不要浪费你的时间试图自己做所有的事情，相反，看这个视频。它提供了如何正确设置 Python 环境的分步说明。
现在我们已经完成了 IDE 安装，让我们从底层开始编程。
变量
变量不过是一个带有值的词。就这么简单；与 java 不同，我们不需要提及变量的数据类型，如int、String和Float。
假设你想在一个变量中存储一个值 10——请看:
声明变量
Python 的动态语义自动将变量视为Int。现在我们知道了如何声明一个变量并给它赋值，下一步是探索不同的变量类型。
Int、Float、String和Boolean 是 python 支持的基本数据类型。看看如何声明它们并给它们赋值:
Python 中的基本数据类型
多亏了 Python 的简单语法——我们可以用不同的数据类型在单个变量中声明多个变量。看一看:
基本操作
既然我们已经学习了如何创建变量，是时候探索基本的功能了——找出字符串的长度，将字符串转换成大写或小写，等等。
- 字符串长度: Python 包含一个名为
len()的函数，返回给定容器中的物品数量。在我们的例子中，容器是字符串，返回值是它的长度。看一看:
寻找字符串的长度
- **索引:**我们可以使用索引找到字符串中特定位置的值或字符。我们需要记住的主要事情是索引是从零开始的。看一看:
索引演示
- **连接:**我们可以使用加号(+)在 python 中连接两个字符串。它类似于 Java 和 Kotlin 语法。看一看:
串并置
- **切片:**切片是 Python 中的一个优秀特性，通过它我们可以使用它们的索引得到字符串的各个部分，如下所示:
分割字符串
- Strip: 使用
strip我们可以删除字符串中的前导和尾随空格。如果你只想删除前导空白，我们可以使用lstrip()或者删除尾随空白；我们可以用rstrip()。
条形函数的用法
- **查找&替换:**这些是任何编程语言中的标准功能—
find用于验证期望值是否在实际值中，而replace用于删除特定值，然后在该位置添加期望值。看一看:
查找和替换用法
- **转换:**我们可以分别使用
upper()、lower()和title()函数将字符串转换成大写、小写或标题大小写。
转换函数的使用
收集
到目前为止，我们已经看到了可以保存单个值的变量的不同用法。但是，如果我们想要存储一个值列表，那该怎么办呢——这就是集合的用途。
Python 中有四种集合类型:
1)列表
该列表是可以随时更新的值的集合。在 Python 中，列表用方括号表示。看一看:
列出具有相同数据类型的集合
列表可以包含任何数据类型，如下所示:
具有不同数据类型的列表集合
我们可以在列表上执行一些有用的操作，比如添加或删除数据、对列表进行排序以及在特定索引处插入数据。看一看:
对列表的操作
2)元组
tuple 类似于 list，但是一旦初始化就不能添加数据，它由圆括号表示，如下所示:
元组演示
我们可能不会添加/删除元组中的数据，但是我们可以做一些有用的事情，比如查找最大/最小值、元组中某个项目的计数以及某个项目的索引。看一看:
元组上的操作
3)设置
集合是一个没有索引和无序的集合。In 集合不允许重复值。Set 由大括号表示，如下所示:
简单集合用法
与其他集合类型类似，我们可以添加、删除和更新集合中的数据。看一看:
布景上的操作
4) 字典
与其他类型相比，字典是一种不同的集合类型。集合包含键值对形式的数据。如果你是一个 java 或 Kotlin 程序员，重复的条目是不允许的——就像hashmap。
基本词典用法
我们可以分别用两个独特的函数keys()和values()来获取字典中的所有键或值。看一看:
字典上的操作
经营者
逻辑运算符
逻辑运算符是任何语言中的基本运算符之一。Python 有三个逻辑运算符，比如and、or、not。
- and: 如果所有状态都为真，则返回真。
和操作员行为
- **或:**如果任一语句为真，则返回 true。
或者操作员行为
- not: 反转结果，假设为真，则返回 false。
标识运算符
python 中有两个标识操作符— is和is not
- is:如果两个变量相同，则返回 true。
- is not:如果两个变量不相同，则返回 true。
标识运算符
环
这里我们将探索 Python 中的while 和for 循环。两者功能相似，但语法不同。
while 循环
while 循环重复执行一系列语句，直到满足给定条件。看一下语法:
while condition:
statement(s)
while 循环用法
这里的i ≤ 5是条件。最初，I 值为 1，并且在每次迭代中，I 增加 1。在第 5 次迭代时，I 值为 6，条件失败，因此循环终止。
for 循环
for 循环用于顺序迭代。它主要用于迭代集合。
for iterator_var in sequence:
statements(s)
这里的序列是一个集合，对于每次迭代，集合中该索引处的值将被赋给iterator_var，我们可以在内部语句中访问它。迭代在列表的最后一个索引处终止。
让我们来做一个简单的 for 循环示例——我们有一个编号为 1、2、3、4 的列表，这里的目标是使用 for 循环获得列表中各项的总和。看一看:
对于循环使用
条件语句
一些基本的 Python 条件语句有if、elif、continue和break。让我们看看如何使用它们:
如果
一个if语句是用if关键字写的，后跟条件，以冒号结尾。如果条件满足，那么里面的语句就会执行。与条件相反，我们可以使用else关键字执行另一组语句，如下所示。
if-else 用法
否则如果
当我们需要满足两个以上的条件时，关键字就派上了用场。让我们以上面的例子为例，如果i是零，它显示为偶数，但 0 既不是偶数也不是奇数——这可以使用如下所示的elif来解决:
elif 用法
继续
continue是循环中派上用场的关键字。有了这个关键字，我们可以跳过当前的迭代。看一看:
继续使用
破裂
break 类似于continue，但是当你调用break而不是跳过当前的迭代时，它将终止整个循环。
中断使用
有用的东西
打印
我们已经看到了使用 print 在控制台中显示数据的两种方法——一种是将值直接传递给打印函数，另一种是传递逗号分隔的参数。看看吧，如果你不记得了:
基本打印用法
我们需要在静态字符串中间打印动态值。这可以通过两种方式实现，比如字符串格式和百分比符号的使用。看一看:
print 语句中的字符串格式
如果您观察清楚，在第一种方法中有额外的尾随零，这是因为 Python 将值显示为浮点数。我们可以限制小数点，如下所示:
评论
在使用任何语言时，开发人员都会在代码中加入注释，以便其他开发人员能够理解。Python 提供了两种类型的注释——单行和多行。
- **单行:**这类评论以#开头，如下图:
单行注释
- **多行:**这种类型的注释对于编写关于函数的冗长解释或者注释一段代码非常有用。三重引号表示消息开头和结尾的多行注释。看一看:
多行注释
范围
range()是 Python 中的内置函数。简单来说，range()允许用户在给定范围内生成一系列数字。一般来说，它是用来循环的，看看:
范围使用
希望你学到有用的东西，感谢阅读。
你可以在中、 Twitter 、 Quora 和 LinkedIn 上找到我。
Python 初学者——控制语句
了解从基础到高级的条件执行
介绍
对于编写顺序执行的程序来说，这个世界通常是一个复杂的地方。不管你在做什么项目，都需要跳过一些语句，然后递归地执行一系列语句。
这是任何语言中条件语句出现的地方；通常，大多数语言都有一个 if 语句作为开始的基本步骤，Python 也是如此。不再拖延，让我们探索用 Python 编写条件语句的不同方法。
If声明
简单来说，if 语句是两个部分的组合:表达式和语句。
**表达式:**需要计算并返回布尔值(真/假)的条件。
语句:语句是一个通用的 python 代码，当表达式返回 true 时执行。
if 语句的语法如下所示:
if <**expression**>:
<**statement**>
请始终记住，表达式后面的冒号(:)是强制的，要将它放到操作中，我们可以做如下所示的事情:
python 中简单的 if 语句
如果表达式返回 true，我们还可以执行多个语句，请看:
if 块用多个语句执行
为了有趣，我们可以在一行中编写各种语句，用分号分隔，请看:
在单行中包含多个语句的 if 块
我们还可以使用 if 语句，通过使用in操作符来检查一个值是否在字典中。看一看:
“else”和“elif”
使用 if 语句，我们可以执行一组选定的语句，但是如果我们希望在条件失败时执行另一组语句，该怎么办呢？这时候else进来了。看一下语法:
if <**expression**>:
<**statement1**>
else:
<**statement1**>
类似于 if 语句我们需要在 else 后面使用冒号(:)并保持缩进，看一个简单的例子:
简单的 if / else 执行
让事情变得复杂一点，如果我们需要检查不止一个条件呢？那就是elif曝光的时候。elif充当 if /else 块的组合。
如果前面的条件不满足，并且满足当前表达式，则执行elif块下的语句块。看一下语法:
if <expression>:
<statement1>
**elif** <expression>:
<statement2>
**elif** <expression>:
<statement3>
...
else:
<statement4>
让我们写一段简单的代码来更好地理解它。
简单 elif 分组码
使用“get”进行条件执行
到目前为止，我们已经看到了通用的解决方案；为了让事情变得更复杂一点，我们可以在字典上使用get函数。这个过程包括将必要的条件和输出作为键值对包含在字典中。
为了更好地理解它，让我们写一个简单的例子，看一看:
在这里，字典表情符号充当指示表达式和语句执行的键值对。当我们以 input 作为第一个参数调用字典上的 get 函数时，它将检查具有该值的键。如果找到了，它打印键值，否则打印第二个参数。这里，第二个参数充当 else case。
三元运算符
Python 引入了一个三元运算符来保持最小化。换句话说，我们可以说它是 if / else 块的最简单的书写形式。
当我们深入研究控制语句时，我们需要考虑三件主要的事情:条件表达式、肯定结果和否定结果。整个条件执行都围绕着他们。让我们看看 Python 中三元运算符的语法:
<**positive_result**> if <**conditional_****expression**> else <**negative_result**>
这个操作符旨在减少样板代码，创建一个更简洁、可读性更强的程序。让我们用三元运算符写一个简单的例子:
奖金
要了解更多关于 Python 从基础到高级的知识，请阅读以下文章
就这些了，希望你能学到一些有用的东西，感谢阅读。
你可以在 Medium 、 Twitter 、 Quora 和 LinkedIn 上找到我。
面向初学者的 Python 函数
python 中的函数式编程
- 什么是函数式编程？
- Python 中的第一个函数
- 函数和变量
- 带参数的函数
- 有返回值的函数
- 用作参数和返回值
- 内部函数
- λ函数
- 地图和过滤功能
- 装饰者
#1 什么是函数式编程？
函数式编程是一种编码范式，其中我们定义做什么，而不是执行动作。这个想法最初来自数学——我们定义函数的输入和我们期望的输出。
函数式编程很少依赖于状态管理——这意味着当我们传递相同的参数时，无论输出多少次都是相同的。它可以被解释为数据正在经历一些转换，最终导致所需的输出。
#2 你在 Python 中的第一个函数
虽然 Python 主要不是函数式语言，但它支持相对简单的函数式编程，因为 Python 中的一切都是对象。这意味着函数可以被赋给变量并传递。
为了简单起见，让我们从打印 Hello world 的简单函数开始。看一看:
简单的 python 函数
函数的语法以一个def关键字开始，后跟函数名，然后是循环括号。定义函数以冒号(:)结尾。然后在有四个空格缩进的下一行，函数体开始。缩进是我们在使用函数时需要记住的最重要的事情。
#3 函数和变量
全局变量和函数变量
当我们在一个函数中有一个同名的变量时，在全局范围内，当我们试图访问这个变量时，就会产生歧义——无论我们访问的是全局变量还是函数范围内的变量。
所以 Python 提供了一个名为globals()的函数，通过它我们可以访问函数内部同名的全局变量。看一看:
在函数内部访问全局变量
将函数赋给变量
在 Python 中，我们可以将一个函数赋给一个变量，然后调用它。看一看:
将函数赋给变量并调用
#4 带参数的函数
现在我们知道了如何定义一个函数，是时候进入下一阶段了，我们将输入传递给函数——参数。为了快速理解它，我们将从一个计算两个数之和的数学函数开始。看一看:
带参数的函数
这是一个简单的函数，就像第一个一样，但是有两个输入— a和b。
调用函数
可以通过两种方式调用带参数的函数，只需调用函数并按照函数中提到的顺序传递参数，或者使用命名参数。看一看:
调用函数
具有默认值的参数
在上面的示例中，a和b是两个强制参数——这意味着开发人员必须传递两个参数来调用函数。在 Python 中，我们可以用默认值指定参数。所以这些参数是可选参数。调用函数时，如果没有传递任何可选参数，Python 会考虑该参数的默认值。看一看:
具有默认值的参数
我们可以通过三种方式调用上述函数，如下所示:
使用默认值参数调用函数
#5 个具有返回值的函数
我们已经看到了如何将输入传递给函数；是时候实现函数的输出了。这类似于 Java、Kotlin 等大多数语言——我们需要使用 return 关键字并提及值。看一看:
带输出的函数
Python 有一种独特的能力，可以返回多个值作为输出，这是大多数语言都做不到的。看一看:
具有多个输出值的函数
x、y和z变量将分别被赋予加号、减号和乘号的值。
#6 函数作为参数和返回值
Python 函数式编程能够将函数作为输出返回，或者作为参数传递。
作为一个参数
到目前为止，我们已经看到了如何将变量作为参数传递给函数。现在我们将学习如何将函数作为参数传递给其他函数——类似于 Kotlin 中的高阶函数。看一看:
使用函数作为参数
用作返回值(输出)
类似于将函数作为参数传递，我们也可以将其作为输出返回——这是 Python 中的一个独特功能。看一看:
使用函数作为返回值
#7 内部函数
我们可以在另一个函数内部编写一个函数，这是我直到现在才在其他编程语言中看到的。内部函数的作用域是外部函数，只能从外部函数访问内部函数。看一看:
✅访问内部函数的正确方法
内部函数
✖️不能从包装函数的外部访问内部函数:
非法访问内部函数
# 8λ函数
Lambda 是具有单行表达式的函数的最简单形式，它没有名称。在 Python 中，我们必须使用lambda关键字而不是def来创建 lambda 函数。看一看:
λ函数
这里变量f是一个简单的 lambda 函数，而a和b是f的参数。语法类似于普通函数。唯一的变化是关键字和单行表达式。
下面是一个简单的例子，展示了我们如何使用普通函数和 lambda。看一看:
普通函数和 lambda 函数的功能相同
#9 映射和过滤功能
到目前为止，我们已经看到了如何创建函数和其他策略。Python 自带的默认功能包括 map 和 filter，这在一些用例中非常方便。
地图
map是一个函数，它需要另一个函数对象和任意数量的iterables，如列表和字典。map用提供给它的函数对象迭代列表中的每一项，并返回一个列表。看一看:
地图功能
我们可以向 map 传递多个列表，如下所示:
带有多个列表的地图
过滤器
filter函数需要两个参数——一个函数对象和一个 iterable。Filter通过返回一个boolean值的函数对象迭代每一项。最后，filter返回一个列表，其中包含从函数对象返回 true 的项目。
滤波函数
#10 室内装潢师
装饰器是一种设计模式——它接受一个对象并向其添加新的功能，而无需从调用点进行任何更改。正如我前面说过的，Python 中的一切都是对象——所以我们可以将函数用作装饰器，并且可以应用于其他函数。看一看:
装饰者用法
希望你学到有用的东西，感谢阅读。
你可以在 Medium 、 Twitter 、 Quora 和 LinkedIn 上找到我。
面向数据记者的 Python:从网络上获取数据
使用 Python 和 Pandas 在网络上发现、读取和分析 CSV、Excel 电子表格中的数据
摄于 Unsplash 上的粘土堤岸。所有其他图像由阿兰·琼斯。
作为一名记者，你的工作是讲述一个故事，让你的读者觉得有吸引力、有娱乐性和知识性。作为一名数据记者，你可以从网上的数据中找到这个故事。你找到数据，研究它，并得出结论，告知你的叙述。也许你还会制作一些有趣的图表或插图。
如果你知道去哪里找，并且有检索、处理和分析数据的技能，那么就会有大量的数据存在。
我们将探索如何找到、读取、分析和可视化这些数据。
更准确地说，我们将:
- 使用 Python 和 Pandas 从网上读取电子表格文件
- 提取我们感兴趣的数据
- 为我们的特定目的操纵数据
- 探索数据中的关系
- 画一些说明图
开放数据，什么和哪里？
许多政府和组织开放了他们的数据，任何人都可以访问。例如，美国和英国政府拥有涵盖政府、经济和社会各个方面的公开数据。欧盟也有类似的资源。
大型非政府组织以及私营组织也免费或收费提供数据。其中包括世界银行、世界经济论坛、世界卫生组织和联合国。数据也有学术来源。位于英国牛津大学的“我们的数据世界”就是一个很好的例子，美国约翰·霍普金斯大学的新冠肺炎仪表板提供了疫情的最新数据(尽管这些数据不能直接下载)。
但是，如果你不确定从哪里开始，一个好的地方是谷歌的公共数据浏览器，你可以在那里搜索特定提供商或特定主题的数据。
数据格式
你会发现数据有多种格式。最常见的可能是可下载的电子表格。这些通常是 Excel 格式或 CSV 文件。
API(应用程序编程接口)也是有用的数据源，这些数据通常以 CSV 或 JSON 的形式出现。API 有时会限制您可以检索的数据，并且通常要求您注册。API 使用“免费增值”模式并不罕见，在这种模式下，有限的访问是免费提供的，但如果你想访问大量数据，则需要付费。
使用 Python 和熊猫
我们将看看如何处理不同类型的数据，以及如何使用 Python 和 Pandas 来整理、分析和可视化这些数据。
为了提供一个焦点，我们来看看英国的人口数据。我们将追踪过去几十年人口的增长情况，以及移民对人口的影响(如果有的话)。我们将使用两个不同的数据源，并将它们连接起来，看看这些数字之间是否有任何关系。
使用网络上的数据只需要很少的编程知识，但是你确实需要对 Python 和 Pandas 的基础有一点熟悉，或者至少愿意学习它们。
在下面的代码中，我将使用 Jupyter 笔记本(您可以使用标准的 Python 编辑器或 IDE，但我发现 Jupyter 更容易构建这些简单例程的原型)。
如果您的计算机上还没有 Python 工具，我建议您安装 Anaconda。有了 Anaconda，你可以在一个包中获得 Python 以及大量有用的库，如 Pandas、Jupyter 笔记本和代码编辑器。有关如何获取它的说明，请参见下面的文章:
Jupyter 笔记本是一个伟大的和相当简单的方式来探索数据和创造可视化的互动…
towardsdatascience.com](/setting-up-jupyter-notebooks-for-data-visualisation-e287e2688af6)
入门指南
假设你已经准备好了工具，我们就开始吧。
我将把每一点代码都呈现为一个 Jupyter 笔记本代码单元，我建议你也这样做。
因此，我们需要做的第一件事是输入我们将要使用的 Python 库。
import pandas as pd
import matplotlib.pyplot as plt
这几乎是我们操作数据和产生可视化所需的一组标准库。
如果由于某种原因你还没有安装这些，你将需要从命令行安装 conda 或 pip ，例如
conda install pandas
或者
pip install pandas
注意，如果您没有使用 Anaconda，您可能需要使用命令 pip3 而不是 pip 进行安装。
让我们从电子表格数据、CSV 和 Excel 文件开始探索。
CSV 和 Excel
每当您找到一个为您提供 Excel 文件下载的数据源时，您通常会发现他们也提供了一个 CSV 替代文件。对于简单的电子表格，我们使用哪个并不重要。
尽管如此，CSV 文件更容易被人阅读——它们是纯文本表格，表格中的每个值或标题用逗号(或其他字符)分隔。当然，您可以用电子表格打开它们，但是如果需要，您也可以用简单的文本编辑器编辑它们。
另一方面，Excel 文件是一种专有格式，需要用兼容 Excel 的电子表格程序来查看或编辑。
电子表格文件有时可以直接从 url 中读取，其他的则必须从浏览器中手动下载。
为了使我们这里的目的更容易，我已经将我们将要使用的文件复制到一个存储库中，您可以从您的程序中直接访问它。
首先，我们要看看英国人口在过去 50 年左右的时间里是如何增长的。我们将使用英国国家统计局的数据。
您可以在此下载该文件:
将其保存在与笔记本或程序相同的目录中。
下面的程序片段将该数据加载到 Pandas 数据帧中。真正的工作由 pd.read_csv 完成，它从您的目录中读取文件，第二行显示表格的前 10 行。
当我下载这个文件时，它被命名为 series-100520.csv
然而，当你下载文件时，你可能会得到一个反映你下载日期的文件名。所以检查文件名并适当调整代码。
代码如下:
data = pd.read_csv(‘series-100520.csv’)
data.head(10)
好了，现在我们有了从 CSV 文件加载的数据帧，我们已经执行了命令 data.head(10) ，它显示了数据表的前 10 行。它基本上由两列组成:年份和那一年的人口，但是包含了一些关于文件的注释。
这就是问题。这些额外的行可能对人类读者有用，但对我们的分析并不十分有用。此外，我们希望这两列的标题有意义。也许我们可以称它们为“年”和“流行”。
这很容易解决。我们只是跳过头几行，标题和编号为 0 到 6 的行，自己定义标题是什么。
下面是再次读取该文件的代码，但是添加了一些额外的参数，这将完全符合我们的要求。
data=pd.read_csv(‘series-100520.csv’,skiprows=8,names=[‘Year’,’Pop’], index_col=0)data.head(10)
那更好。一个简单的表，有两列和合理的列标题。我们告诉 Pandas，我们将使用第一列作为数据帧的索引(否则 Pandas 将添加一个额外的编号索引)。
现在我们可以用它做一些有用的事情。例如，我们可以画一个这样的图。
data.plot(title=’UK Population in millions, 1970 to 2018', grid=True);
这是一个简单的线形图，显示了从 1971 年到 2018 年的人口增长。代码相当简单明了，我们只需调用 plot 函数，它会自动使用索引(年份)作为 X 轴，并将“Pop”列绘制为 Y 值。
我们可以看到，在这一时期有一个逐渐上升的增长。
另一件我们很容易做的事情是查看实际的增长是多少。该表有 48 行，标记为 1971 年至 2018 年，因此我们可以像这样访问人口的第一个值:数据[‘Pop’][1971] 和最后一个像这样的数据[‘Pop’][2018] 。所以人口的变化是一个减去另一个。
data[‘Pop’][2018]- data[‘Pop’][1971]
我们得到的结果是
10507600
这比 48 年前增加了 1000 多万。或者以百分比表示:
percentageIncrease = round((data[‘Pop’][2018]- data[‘Pop’][1971])/data[‘Pop’][1971]*100,2)print(‘The UK population has increased by’, percentageIncrease,’% from 1971 to 2018')
从中我们可以得到
从 1971 年到 2018 年，英国人口增长了 18.79%
所以现在我们知道有多少人生活在英国，以及在过去的几十年里人口是如何增长的。
移居
现在我们将使用来自下议院图书馆的不同数据源。根据开放议会许可，这些数据可以免费下载，您可以在这里找到:
https://www . parliament . uk/site-information/copyright/open-parliament-licence/
这次数据是以 Excel 电子表格的形式出现的。这类似于读取 CSV 文件，但是我们可以指定的参数有一些不同。例如，这个电子表格中有许多不同的工作表，为了将它读入熊猫数据帧，我们需要指定哪一个。
我们感兴趣的工作表叫做“摘要”。
所以从这个网址下载文件
http://research briefings . files . parliament . uk/documents/sn 06077/CBP 06077-data . xlsx
和以前一样，保存在您的工作目录中。
同样，该文件包含几行没有用的内容，所以我们将标题指定为第 2 行，将索引作为第一列(和前面一样)，并跳过表的最后 10 行(使用 skipfooter )。
immData=pd.read_excel(‘CBP06077-data.xlsx’,sheet_name=’Summary’,index_col=1,header=2, skipfooter=10)immData.head(10)
生成的数据帧如下图所示。还可以，但是有一些我们不需要的列。不过，这没有太大关系，因为我们要做的是将我们感兴趣的数据复制到保存人口数据的原始数据帧中。
本质上，我们将复制用于净迁移的列的一部分，并将其粘贴到 dataframe 数据中的新列中。
为此，我们使用一个名为 iloc 的函数。这允许我们使用行和列的位置来选择数据帧的矩形部分。例如，iloc[x，y] 会从列 y 中选择行 x 。
但是 x 和 y 可以是范围，所以 iloc[x1:x2，y1:y2 会为列 y1 到 y2 选择行 x1 到 x2 。
更具体地说，代码 immData.iloc[0:10，2:4] 将选择 immData 的一部分，从第 0 行到第 10 行，从第 2 列到第 4 列。或者 iloc[0:10，5] 将选择第 1 行到第 10 行，但只选择第 5 列。
我们想要的是第 5 列的净迁移，但是因为我们想要将其粘贴到数据数据帧中，所以它需要与数据的大小相同，所以我们只想要 1971 年到 2018 年的数字。1971 是第 8 行，2018 是从表格底部向上一行，我们可以将此选择表示为 [8:-1，5] ，其中-1 表示“从最后一行向后一行”。
我们将在数据 calle Imm 中创建一个新列，并将 iloc ed 副本粘贴到其中，如下所示:
data[‘Imm’]=immData.iloc[8:-1,5]*1000data.head(10)
结果是添加了新列的原始表。我们将移民数据乘以 1000，得到与人口数据相同的形式。
让我们用图表来描绘移民的增长。这与我们之前看到的非常相似，但是我们将 Y 值指定为“Imm”。
data.plot(y=’Imm’)
你可以看到，尽管有起有落，但在此期间，英国的净移民一直在增加。
我们可能做的另一件有趣的事情是将移民数字表示为总人口的百分比。在这里，我们创建另一个新列，并用百分比填充它。
data[‘Imm as % of Pop’] = data[‘Imm’]/data[‘Pop’]*100data
你可以看到，作为总人口的一个百分比，移民增加的百分比相当小。但这一比例也在上升。
data.plot(y=’Imm as % of Pop’)
所以看起来每年的移民数量和总人口数量之间可能有关系。让我们通过绘制总人口和移民水平的散点图来对此进行研究。
data.plot.scatter(x=’Pop’,y=’Imm’)
嗯，是的，似乎有一个线性的关系。随着人口的增加，移民也在增加。
由于移民导致的总人口增长看起来很小，所以一定还有其他原因。也许移民越多，移民就越多，因为现在的移民往往会带着他们的家人一起生活。我们没有考虑过这种关系，也不会考虑！
我们的目标
我认为我们已经达到了这篇文章的目标。我们已经了解了如何下载和读取 CSV 文件或 Excel 电子表格形式的数据。我们对这些数据进行了处理，以提供一些可能值得研究的信息，我们还研究了不同数据之间的关系。我们还绘制了一些说明性的图表。
我希望这是有用的，你会发现这里使用的技术与你未来的工作相关。感谢阅读。
你可以在这里找到更多关于绘制熊猫图的信息:
如果您是一名初露头角的数据科学家或数据记者，能够可视化您的数据会让您有能力…
towardsdatascience.com](/plotting-with-pandas-an-introduction-to-data-visualization-8bd7c0831650)
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
