数据工程:是什么？
基于数据和历史背景的定义
数据工程正在迅速崛起。在过去的两年里，数据工程在英国招聘的职位中所占的比例增加了一倍多。在 1.5%的水平上，有近 2200 个未平仓头寸。相比之下，“软件工程师”约占 4.6%。以及“项目经理”3.1%。
数据工程甚至比网页开发更受欢迎(1.2%)。
**更新【2020 年 11 月 09 日】😗*在 11 月 09 日之前的六个月期间，这一比例目前为 1.86%，高于本文最初发表日期 2020 年 5 月 11 日之前的 1.5%，也高于 2019 年同期的 1.13%。然而，由于疫情期间就业市场整体放缓，1.86%现在仅代表约 900 个开放职位。
英国数据工程师职位空缺趋势来源: IT 职位观察 (CC BY-NC-SA 4.0)
很明显，数据工程是一项有价值的技能，但它是什么呢？和其他类似的技能组合有什么不同？
概述
大多数职位描述都提到了 Python (66%)和 SQL (56%)。许多人提到像 AWS 这样的平台(42%)和像 T21 这样的过程(42%)。但是数据工程的本质是创建移动数据的管道。
你的每一个人、每一项业务都会不断产生数据。每个事件记录公司的功能(和功能障碍)——显示赚到的钱和损失的钱；社交媒体、第三方合作伙伴、收到的货物、发货的订单。但是，如果这些数据从未被看到，就不会有任何见解。
数据工程要求知道如何从数据中获取价值，以及将数据从 A 点移动到 B 点而不掺杂的实际工程技能。
对于数据工程师来说，知道如何访问所有这些数据(无论其来源或格式如何)是一项关键技能。访问数据可能需要抓取 web、pdf 或半打不同风格的 SQL 和非 SQL 数据库。另一项技能是知道如何高效地移动和存储数据(在时间和成本方面)。处理大量数据是一项专业技能。然而，最重要的是保存数据的价值。
并非所有的数据都是信息
数据只有能被理解才有价值。如果我告诉你今天的天气是 0 级，气温是 0.756743 度，T4 会打我一巴掌。电脑通常会给出更隐晦的回应。解密它们需要两样东西:背景和专业知识。
此外，将数据从一个系统转移到另一个系统会删除大量上下文。专家解释数据时通常需要这种环境。许多不同的系统，许多不同的专家，许多解释。好的数据工程是关于收集解释和数据，并呈现所有用户都能理解的统一视图。
数据工程是商业智能的发展
另一个用来描述上述概念的术语是 BI 或“商业智能”。
商业智能是大型国际公司的领域。很久以前，只有他们有钱存储大量数据，也有足够的经济实力这么做。巨大的 SQL 服务器在由巨大的存储区域网络(SAN)支持的大型企业主机上飞速运转。数据将从纽约、洛杉矶、伦敦、香港和新加坡的系统中被转储进来，因为每个人都去睡觉了，以便在第二天早上之前进行处理。分析师会使用 PowerBI 和 Crystal Reports 等成熟供应商提供的昂贵工具来分析数据。
但是，如果“商业智能”这个术语如此成熟，为什么会出现重复的术语呢？简短的回答是互联网。
随着互联网的兴起，出现了许多使用和收集数据的新应用。对于其中的一些应用程序，数据量对于任何一台数据库服务器来说都太大了。它们被称为 webscale 应用。与此同时，存储数据的价格呈指数级下降(已经下降了一段时间)。然后在 2002 年，塞斯·吉尔伯特和南希·林奇发表了一份现在被称为上限定理的正式证明。
资料来源:Khazaei、Hamzeh & Fokaefs、Marios & Zareian、Saeed & Beigi、Nasim & Ramprasad、Brian & Shtern、Mark & Gaikwad、Purwa & Litoiu、Marin。(2015).我如何选择合适的 NoSQL 解决方案？全面的理论和实验调查。大数据和信息分析杂志(BDIA)。2.10.3934/bdia
它指出，当您跨多个服务器对数据进行分区时，在数据立即可用和跨这些分区获得一致之间存在不可避免的权衡。为了利用这些新的 webscale 机会，需要新的工具。由此开始了 大数据 的时代。
大数据工程师的崛起
最初的成功是像谷歌的大桌子这样的科技巨头的内部解决方案；但很快，开源解决方案如 Memcached(2003)、CouchDB(2005)和 Hadoop(2006)充斥了这个领域。第二波浪潮在 2008-2009 年出现，出现了 No-SQL 数据库，如 HBase、Cassandra、Redis、Riak 和 MongoDB。销售硬件和服务来支持这些开源软件，对于像 Datastax 和 Hortonworks 这样的公司来说，过去和现在都是有利可图的。
那么，你如何称呼为大数据问题设计解决方案的人呢？当然，你称他们为“大数据工程师”。
数据工程和大数据的相对衰落
英国大数据工程师的职位空缺趋势来源: IT 职位观察 (CC BY-NC-SA 4.0)
随着这么多人用“大数据”赚了这么多钱，它变得不仅仅是值得讨论的了。宣传列车开足马力，所有人都上车了。许多销售“大数据”的公司没有 webscale 数据。其他更便宜的解决方案会更好地服务于一些客户——回避这个问题，“大数据到底有多大”？
来源:谷歌趋势，大数据，美国 2004–2020
冷静的头脑现在将这些工具视为工具箱的一部分，并明智地使用它们。将“大”从“大数据工程师”中去掉，重新关注寻找正确的解决方案。这也更符合“数据科学家”这个术语——我从未听到有人自称为“大数据科学家”。
数据工程师 Vs 数据科学家
有些人喜欢狗。还有人爱猫。许多人两样都喜欢。
所有的数据工程师都会做一些分析。所有的数据科学家都会做一些编程。有的人两者兼而有之；他们进行复杂的分析和编写生产质量的软件。再看一下就业统计数据，差异就很明显了。
技能在招聘广告中出现的频率，数据来源: IT 职位观察 (CC BY-NC-SA 4.0)
数据科学家被期望精通机器学习和统计学，但不是敏捷软件工程师。他们应该知道 SQL，但不是数据库专家(因此没有 ETL 或数据仓库)。
数据工程仍在发展
随着技术的发展和我们面临的挑战的变化，这些术语将继续变化。这个行业的乐趣在于它是动态的。总有新的东西要学。
让我们保持联系。你可以在data unboundTwitterLinkedIn找到我。感谢阅读。**
数据工程师不仅仅是技术专家
为什么数据工程师不仅仅是某项特定技术的专家
数据工程师通常被描述为所有数据角色中的*“专注于技术/技术专家”*角色。然而，如果这是真的，那么一个数据工程师应该专注于什么技术呢？这个角色是如何在技术的发展中存活下来的？
嗯，我认为这并不简单，这个角色不仅仅是“专注于技术”，这个角色的一些核心方面随着时间的推移保持不变，即使技术不再存在。
不同的技术
数据工程可能涉及不同的技术取决于你工作的公司/团队，范围可能相当大: Spark ， Apache Beam ， Step functions ， Airflow ， Google Dataprep ， Kafka ， Hive ， Python ， Java ，
出于演示的目的，我将从 Linkedin Jobs 获取两个标题为亚马逊数据工程师的职位，我将用黄色强调需要的技术。
- 亚马逊英国公司的数据工程师
- Spotify 的一名数据工程师
如果我继续举更多的例子，我可能会填充数据& AI 景观
正如你所猜测的，没有人，没有数据工程师可以在他的简历中包含所有这些技术。即使某人的简历上有其中的三分之一，你会认为他是所有这些方面的专家吗？而如果他不是所有这些技术的专家，又怎么可能专注于技术呢？
不同技术之间有一些共享的核心软件工程方面，可以帮助从一种技术转换到另一种技术。
例如，airflow 和 spark 可以用同一种语言 python 编写，尽管它们的目的不同:spark 用于数据处理，airflow 用于工作流管理。
另一个基于语言的例子是在 Hive、 Presto 、 Athena 、Postgres、 InfluxDB 、 Impala 、 BigQuery 和 SparkSQL …
技术不仅共享语言，还共享核心概念，例如:
- 数据建模技术:分区、索引…
- 数据争论方法:过滤、清理、正则表达式…
- 优化技术，如执行计划
- 设计模式: python 和 java 设计模式，数据处理模式
- 批量数据处理的范例
语言/框架/技术之间的共同联系有助于工程师转向更新、更有效的技术。这就像使用 android 手机一样，如果你学会了如何使用 android 手机，你就会很容易知道如何使用 iPhone。
技术、术语和产品生命周期
来源:丹尼尔·弗雷斯·派克斯
技术，就像任何其他商业产品一样，会出现，直到更好的出现，然后，如果没有创新出现，它们就会慢慢消失。
在数据处理领域，如果我们查找 2010 年至 2014 年用于数据处理的技术，我们会看到大多数平台/ERP，如 SAP 或 Oracle。
如今，数据处理更多地是通过 spark、hive、kafka 和其他运行在 AWS 或 Google 等平台上的“大数据”技术来完成的。这些技术允许我们像以前一样处理数据，但让我们更加灵活，以更低的成本处理更多的数据，实时处理数据，点击一下就可以进行机器学习， A/B 测试等等。
用于处理和分析数据的人的数据角色或术语也遵循相同的“生命周期”:如果我们之前谈论 ETL 开发人员或数据集成专家，我们现在谈论的是数据工程师。
这个“以技术为中心”的角色发生了什么变化？工具改变了，它们进化了，它们遵循了技术生命周期，但是这个角色的核心方面仍然存在。作为数据工程师的 ETL 开发人员必须处理数据，对数据处理管道进行质量检查，提取数据并使其可用于其他平台。就编码语言而言，是的，数据工程师必须知道至少一种编程语言，但他还必须对 SQL 有深入的了解。
笑点是
随着人类能够处理的数据处理工具越来越多，技术的不断发展，数据工程师仍然被认为是“以技术为中心”的。当然，数据工程师必须使用技术来完成事情，但他使用技术并不只是为了好玩，他使用技术来收集、存储和处理某个 用例 的数据，以一种 工业化的方式 。
用例、数据量及其速度、数据收集频率和数据交付方法将帮助您定义所使用的技术。例如，实时可视化不能基于 Hive 表，其他数据库和数据处理框架适合这种用例。
工业化的方式意味着数据工程师通常不负责特别分析，但是他参与为特别分析负责人创建/建立一个平台。
最后但同样重要的是，处理数据是为一个特定用例完成的。因此，如果您想避免树摇摆案例，数据工程师必须了解业务需求。
来源:树摇摆迷因的简短修改版
熊猫数据探索 101
Pandas 是访问和使用数据的最强大的图书馆之一。有大量的功能涵盖数据操作，快速绘图以及读取和写入数据。
如果你是数据科学的新手，一个考试前时间不多的学生，或者你只是想看看其他人如何使用熊猫来探索和分析 数据，请跟随我。对于这个快速介绍，我们将使用通过 Kaggle.com获得的主要城市的每日气温数据集。
作为每个数据探索任务的起点，导入数据集是必要的。Python 通过“open()”函数使这变得非常容易，然而不管怎样，因为我们要使用 pandas 库，传统的开放不是办法。Pandas 提供了各种各样的 read_ 函数，允许同时打开文件并将其转换成数据帧。
输入数据
只用两行代码，您就可以导入数据并创建一个 dataframe 对象，这个对象非常适合使用。除了常见的 Python 数据结构(比如字典)，操作可以在所有数据点上执行，也可以在经过过滤甚至分组的数据点上执行。想象一下，你必须只用普通的数据结构来完成这项任务，这将是一场噩梦。
不要错过任何关于熊猫的数据细节
Pandas 为您提供了令人难以置信的方便和易于应用的预览、修改和导出数据的可能性。在接下来的几行中，我们将通过几个非常有用的例子来操作数据帧。您可能会观察到， pandas 相当一致(过滤、访问行等。)和其他著名的 Python 库，还有像 r。
描述数据
几乎每次分析新数据集时，您都可能会考虑两件事:
- 您的数据点位于什么范围内——这对于获得数据的“感觉”以及检查一致性、可靠性和异常值至关重要
- 您是否在数据框架中看到无效或缺失的值
仅使用这些 to 行将允许您检查您的数据集并估计您是否需要做更多的数据清理。明确描述()对月、日或年没有意义，但掌握 AvgTemperature 是必不可少的。正如我们在这里看到的，这个度量很可能不是摄氏度(平均温度是 56 度)，而是华氏度。
Month Day Year AvgTemperature
count 2.906327e+06 2.906327e+06 2.906327e+06 2.906327e+06
mean 6.469163e+00 1.571682e+01 2.006624e+03 5.600492e+01
std 3.456489e+00 8.800534e+00 2.338226e+01 3.212359e+01
min 1.000000e+00 0.000000e+00 2.000000e+02 -9.900000e+01
25% 3.000000e+00 8.000000e+00 2.001000e+03 4.580000e+01
50% 6.000000e+00 1.600000e+01 2.007000e+03 6.250000e+01
75% 9.000000e+00 2.300000e+01 2.013000e+03 7.550000e+01
max 1.200000e+01 3.100000e+01 2.020000e+03 1.100000e+02
有时，有些用例要求数据提取可以很容易地复制和插入，我推荐使用 to_markdown() 函数，它为此提供了很好的结果——确实是我的最爱之一。
| | Country | AvgTemperature |
|--------:|:----------|-----------------:|
| 2906322 | US | 28 |
| 2906323 | US | 27.6 |
| 2906324 | US | 29 |
| 2906325 | US | 28.8 |
| 2906326 | US | 28.7 |
我们需要进一步检查是否有“非数字”值。如我们所见，只有 State 有缺失字段，这对我们来说完全没问题。请记住，对于机器学习等更复杂的任务，删除以及内插或外推丢失的数据可能是数据科学家的一项关键工作。
Region False
Country False
State True
City False
Month False
Day False
Year False
AvgTemperature False
dtype: bool
为了获得一列的唯一值, unique() 函数非常有用——我们也可以在分组对象上使用它。
data.Region.unique()array(['Africa', 'Asia', 'Australia/South Pacific', 'Europe',
'Middle East', 'North America',
'South/Central America & Carribean'], dtype=object)
当数据被图解或总结时，你可能会对数据有更好的感觉。如果您的数据是数字，您可能会发现散点图或箱线图非常方便。
箱线图中的平均温度。包括异常值。
旁白:有许多不同的库允许以非常漂亮和快速的方式绘制数据。从个人的角度来看，没有可视化的数据探索通常是困难的，而且要花费更多的时间，因为数据的不规则性可能会在过程的后期被发现。
这是另一个直观的例子，它能让你立即感受到异常值，一个结合了数字和分类变量的非常密集的散点图:
修改数据
正如我们在最初创建的描述表中看到的，温度以华氏温度为单位，对于非美国居民来说，处理数据可能会有点困难，尤其是当涉及到“这里似乎有什么不对劲”这一部分时。
Pandas 允许我们以一种非常简单直接的方式在列上执行操作。
更通用的方法是对列应用函数。结果和上面一样，但是，我们可以通过这种方式更有创造性地应用函数。
Apply( ) 允许用户创建复杂的函数，并将它们应用到一列甚至几列上。还要注意，除了定义一个函数(如我们的 to_celsius 函数)， lambda 表达式也可以很容易地使用——这可能是只使用一次时最有用的。
如果您更频繁地面对复杂的修改任务，您可能希望构建能够通过正则表达式解析单元格值的函数。在这种情况下，你可能想把正则表达式和 pandas 的应用函数结合起来。如果您觉得需要复习一下数据科学的正则表达式，可以看看下面的链接:
可以使用正则表达式的用例非常多。不管你是不是数据科学家收藏…
towardsdatascience.com](/mastering-regular-expressions-for-your-day-to-day-tasks-b01385aeea56)
分组数据— groupby()
当数据被分组在一起时，Pandas 创建一个 groupby 对象。有很多函数可以应用到一个分组的对象上，比如 unique()、mean()、min()或 max()——仅举几个例子。请注意，您不能直接“显示”groupby 对象，因为这将导致如下输出:
<pandas.core.groupby.generic.DataFrameGroupBy object at 0x000001F2B6879CD0>
为了获得平均值，下面这条线将有所帮助:
data.groupby([‘Region’,’Country’,’State’,’City’,’Year’]).mean()
显示平均值的重新编制索引的分组对象
同样，平均值对于月或日没有任何意义，因此省略这些列是有用的。还请注意，上表需要重置索引，以便正确显示每行条目。
更干净的输出
过滤数据
通常，您可能只对给定数据的一小部分感兴趣。为此，可以通过简单的过滤操作将数据帧最小化为较小的数据帧:
vienna = data[data['City']=='Vienna'].copy() # great city
数据帧的创建副本将只包含“城市”为“维也纳”的值。如果我们需要额外的过滤要求，pandas 允许通过“与”或“管道”来连接标准。
一般来说，我们可以使用主数据框架来绘制相关信息，但是我更喜欢在较小的数据集上使用简单的绘制操作。plot 函数中的过滤数据使其难以阅读和理解。当我们看下面几行代码时，使用数据帧的专用副本的优势变得非常明显:
只需 3 行代码，我们就能生成一个包含线性趋势的折线图:
1995 年至 2020 年维也纳平均气温的简单线形图
如果我们计算一下我们在这里使用的代码行数和我们用这些代码进行的数据操作次数，毫无疑问 Pandas 是一个非常强大的数据操作工具，不需要大量的文档阅读和实践。
有用的文档
如果您想更好地理解我们在本文中所涉及的内容，我建议您从下面的文档开始，仔细阅读与您相关的细节。请记住，就像每一项学习任务一样，做比(仅仅)阅读要好。
[## 熊猫。数据框架- pandas 1.0.5 文档
数据结构还包含带标签的轴(行和列)。算术运算在行和列上都对齐…
pandas.pydata.org](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.html) [## Pyplot 教程- Matplotlib 3.2.2 文档
pyplot 接口介绍。是一个命令风格函数的集合，它使 matplotlib 像…
matplotlib.org](https://matplotlib.org/tutorials/introductory/pyplot.html) [## NumPy 滤波器阵列
从现有数组中取出一些元素，然后用它们创建一个新数组，这叫做过滤。在 NumPy，你…
www.w3schools.com](https://www.w3schools.com/python/numpy_array_filter.asp)
一如既往，下次再见，注意安全！
图片由古斯塔夫·古尔斯特兰德提供，谢谢！
使用 Python 进行数据探索和分析
让您的数据说话的简单方法
数据探索是数据分析和模型构建的一个关键方面。如果不花大量时间去理解数据及其模式，就无法构建高效的预测模型。在由数据清理和预处理组成的数据科学项目中，数据探索占据了大部分时间。
在本文中，我将通过简单的解释和 Python 代码片段来解释数据探索中涉及的各个步骤。数据探索中涉及的关键步骤有:
加载数据
识别变量
变量分析
处理缺失值
处理离群值
特征工程
加载数据并识别变量:
数据来源可能因数据库和网站而异。数据源被称为原始数据。原始数据不能直接用于建模，因为它不一致，不适合预测。必须对异常和缺失值进行处理。变量可以是不同的类型，如字符、数字、分类和连续。
可变类型
确定预测值和目标变量也是建立模型的关键步骤。 **Target 是因变量，predictor 是独立变量，基于该变量进行预测。**分类变量或离散变量是那些无法用数学方法处理的变量。它由 0 和 1 等固定值组成。另一方面，连续变量可以用数学函数来解释，比如求所有值的平均值或总和。您可以使用一系列 Python 代码来理解数据集中的变量类型。
**#Import required libraries**
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns**#Load the data**
titan=pd.read_csv("../input/titan.csv")**#get an overview of the data**
titan.head()
titan.tail()
titan.sample(10)
**#identify variable type**
titan.dtypes
titan.info()
titan.describe()
变量分析:
变量分析有三种方式，单变量分析，双变量分析，多变量分析。
变量分析
单变量分析用于突出缺失值和异常值。这里对每个变量的范围和分布进行单独分析。**分类变量和连续变量的单变量分析不同。**对于分类变量，您可以使用频率表来了解每个类别的分布情况。对于连续变量，你必须了解变量的中心趋势和扩散。可以用均值、中值、众数等来衡量。它可以使用箱线图或直方图来可视化。
**#Understand various summary statistics of the data**
include =['object', 'float', 'int']
titan.describe(include=include)
titan.describe()**#Get count of values in a categorical variable**
titan.survived.value_counts()titan.age.hist(figsize=(10,5))
柱状图
双变量分析用于找出两个变量之间的关系。可以对分类变量和连续变量的组合进行分析。**散点图适合分析两个连续变量。**表示变量之间的线性或非线性关系。**条形图有助于理解两个分类变量之间的关系。**某些统计测试也用于有效理解双变量关系。Scipy 库有大量的模块可以在 Python 中执行这些测试。
双变量分析
Matplotlib 和 Seaborn 库可用于绘制不同的关系图，帮助可视化不同类型变量之间的二元关系。
散点图
**iris = sns.load_dataset("iris")**
sns.relplot(x = 'sepal_length', y = 'petal_length', hue='species',data = iris)relplot = sns.catplot(x="pclass", hue="who", col="survived",
data=titan, kind="count",
height=4, aspect=.7);
relplot
处理缺失值:
数据集中缺少的值会降低模型拟合度。**由于无法对数据进行全面分析，这可能会导致模型出现偏差。**行为以及与其他变量的关系无法正确推导。它会导致错误的预测或分类。缺失值可能是由于数据提取或数据收集中的问题造成的，这些问题可分为 MCAR、马尔和 NMAR。
缺少值
缺失值可以通过删除、均值/众数/中位数插补、KNN 插补或使用预测模型来处理。
处理缺失值
您可以使用 Python 中名为 Missingno 的库直观地分析缺失的数据。
import missingno as msno
msno.bar(titan)
msno.heatmap(titan)np.mean(titan['age'])from scipy import stats
stats.mode(titan['embarked'])titancopy['age'].fillna(29,inplace=True)
titancopy['embarked'].fillna("S", inplace=True)
处理异常值:
异常值可能自然出现在数据中，也可能是由于数据输入错误造成的。它们可以彻底改变数据分析和统计建模的结果。**异常值很容易通过可视化方法检测，如箱线图、直方图和散点图。**异常值的处理类似于缺失值，通过删除观察值、转换观察值、宁滨或分组观察值、将其视为单独的组或输入值。
箱形图
import plotly.express as px
fig = px.box(titan,x='survived',y='age', color='pclass')
fig.show()px.box(titan, y='age')px.box(titan,x='survived',y='fare', color='pclass')*#Adding trendline to the data*
x=iris.sepal_length
y=iris.petal_width
plt.scatter(x, y)
z = np.polyfit(x, y, 1)
p = np.poly1d(z)
plt.plot(x,p(x),"y--")
plt.show()
特征工程:
特征工程是从现有数据中提取更多信息的过程。特征选择也可以是它的一部分。特征工程的两种常用技术是变量转换和变量创建。在变量转换中，使用特定函数转换现有变量。例如，一个数可以用它的对数值来代替。另一种技术是从现有变量创建一个新变量。例如，将 dd/mm/yy 格式的日期字段拆分为日期、月份和年份列。
变量变换
titancopy = titan.copy()**#variable transformation**
titancopy['alive'].replace({'no':0,'yes':1}, inplace=True)**#Convert boolean to integer**
titancopy["alone"]=titancopy["alone"].astype(int)
另外两种数据转换技术是对分类变量进行编码和对连续变量进行缩放以使数据标准化。这取决于用于评估的模型，因为有些模型接受分类变量。
**不相关的特征会降低模型的准确性。**可以自动或手动选择功能。相关矩阵用于可视化特征之间的相互关系或与目标变量的关系。
相关矩阵
titancopy.corr()plt.figure(figsize=(10,10))
corr = titan.corr()
ax = sns.heatmap(
corr,
vmin=-1, vmax=1, center=0,
cmap=sns.diverging_palette(20, 220, n=200),
square=True, annot=True
)
ax.set_xticklabels(
ax.get_xticklabels(),
rotation=45,
horizontalalignment='right'
)
ax.set_yticklabels(
ax.get_yticklabels(),
rotation=45,
);
scikit-learn 库提供了一些好的类，比如 SelectBest，用于从给定的数据集中选择特定数量的特征。同一库中的基于树的分类器可用于获得特征重要性分数。
这涵盖了数据探索中涉及的一些关键步骤。根据数据的大小和模型的要求，每个步骤都可以重复。数据科学家在数据预处理上花费的时间最多，因为数据质量直接影响模型的成功。
这里显示的所有代码片段都在探索性数据分析和可视化 Kaggle 笔记本中执行。
利物浦足球俱乐部 2019–2020 EPL 赛季的数据探索
确定“运气”并使用“预期”指标
肖恩·唐纳利在 Unsplash 上的照片
受到 Soner Yildirim 的文章(链接)的启发，他谈到了 EPL 2019-2020 赛季的一些探索性数据分析，我想看看我是否能收集到任何专门针对利物浦的见解。毕竟这是他们赢得冠军的赛季！
我用了他从 kaggle 那里得到的同样的数据集。
2019-2020 赛季所有英超联赛的球队和球员统计数据
www.kaggle.com](https://www.kaggle.com/idoyo92/epl-stats-20192020)
当我浏览数据集时，我脑海中有一个问题——利物浦真的赢得了胜利吗？有量化的证据来支持或反驳利物浦这个赛季只是运气好的说法吗？
准备环境
最初的比特相对简单。我使用 Jupyter 笔记本作为我的主要分析环境，并导入了常用的工具(numpy，pandas)。然后，像 Sonor 一样，我从 kaggle 下载了 csv 文件，并将其读入 dataframe。
import numpy as np
import pandas as pd
df_epl = pd.read_csv(“epl2020.csv”)
df_epl = df_epl.reset_index(drop=True)
df_epl.drop([‘Unnamed: 0’], axis=1)
结果是这样的:
576 行和 44 列的数据。从一个团队的角度来看，每一行都代表一场特定比赛的数据。这意味着每场比赛实际上都是两行数据，而不是一行。使用该数据集时需要记住的一些事情。
关键指标
在浏览数据集时，我决定关注 6 个特定的列——进球、失球、预期进球、预期失球、得分和预期得分。
围绕“预期”指标的一些解释可能是必要的。
- 预期进球得分—Opta(EPL 官方统计追踪器)根据几个变量(助攻类型、射门角度、距离球门的距离等)来衡量一场比赛中一个球队特定射门的质量。).这给出了“每次射门的预期目标”指标。在一场比赛中，将一个球队的每杆预期进球加起来，我们就得到了每场比赛的预期进球，这是我们数据集中的统计数据。(链接)
- 预期失球 —基本上是预期失球的反序。注意，对于一场比赛来说，每支球队的预期进球得分就是对方球队的预期失球。
- 期望分数 —一个队在一场比赛中应该获得的期望分数。我找到了这个指标的一个合适的解释，但是它基本上是预期目标指标的一个衍生物。
预期点数(预期点数、xPts 等。)是预期目标(xG)模型的扩展…给定每支球队在比赛中创造的预期目标值，人们可以取这些值并模拟它数千次，以计算比赛将导致赢/平/输的概率。从这些概率(比赛赔率)中，我们可以将它们转换成一个团队在给定他们和他们的对手累积的 xG 的情况下可以赢得多少分(0 到 3 之间的任何值)
点数减去预期点数
因此，为了尝试回答这个问题——“利物浦幸运吗”，我需要找出一个可能“代表”运气的指标，看看利物浦与同行相比如何。
我的第一个想法是用“点数减去预期点数”。这似乎很合理。如果“分数”是一个团队实际上获得了多少分，而“预期分数”是一个团队认为获得了多少分，那么两者之差将代表一个团队是幸运(正数)还是不幸(负数)。任何一个方向上的大量数据都代表着与“应该”发生的情况的重大偏离。
有了这个想法，我可以开始分析了:
步骤 1:创建一个标签为“点数-预期点数”的列。这反映了团队在每场比赛中低于或超过预期的程度。
第二步:得出每个团队的平均值和总和(即一个团队整个赛季的平均和总“分数减去预期分数”)
**//Step 1
df_epl['pts-xpts'] = df_epl['pts']-df_epl['xpts']//Step 2 - Mean
df_epl[['teamId','pts-xpts']].groupby('teamId').mean().sort_values(by='pts-xpts', ascending=False)//Step 2 - Sum
df_epl[['teamId','pts-xpts']].groupby('teamId').sum().sort_values(by='pts-xpts', ascending=False)**
每个团队的平均值(“pts-xpts”)和总和(“pts-xpts”)的递减比较
如你所见，结果相当惊人。利物浦和下一个最幸运的竞争对手纽卡斯尔之间有着巨大的差距。在整个赛季中，利物浦每场比赛的得分都大大超出了预期。
实际净胜球(每场比赛)减去预期净胜球(每场比赛)
在看了积分-期望积分比较之后，我觉得有必要做更多的工作。毕竟，预期分数看起来仍然是一个相当不透明的指标，因为它是预期目标统计的衍生物。
因此，我决定评估“运气”的下一个基准是“实际净胜球减去预期净胜球”。
背后的想法很简单:
- 一个队在一场比赛中的实际净胜球仅仅是他们进的球和丢的球之差。如果你进的球比失球多，你自然会表现得更好。
- 考虑到创造的得分机会的数量和质量，一支球队的预期净胜球将是一支球队应该取得的进球和他们应该取得的失球之间的差异。
- 实际净胜球和预期净胜球之间的差异可能再次指向“运气”因素。像以前一样，一个大的正数将代表一个队在特定比赛中的幸运(正数)或不幸(负数)。
清楚了这一点，我们可以开始分析了。
第一步:创建一个标签为“实际目标差异减去预期目标差异”的列。这反映了球队在每场比赛中低于或高于净胜球期望值的程度。
请记住，数据集不会直接给出目标差异和预期目标差异。这些必须从(1)进球数，(2)失球数，(3)预期进球数(xG)，(4)预期失球数(xGA)中得出，其方式如下: (进球数-失球数)——(xG-xGA)
步骤 2:得出每个团队的平均值和总和
**//Step 1
df_epl['Expected Goal Difference per Match'] = df_epl['xG']-df_epl['xGA']df_epl['Actual Goal Difference per Match'] = df_epl['scored']-df_epl['missed']df_epl['Actual Goal Diff - Expected Goal Diff'] = df_epl['Actual Goal Difference per Match']- df_epl['Expected Goal Difference per Match']//Step 2
df_epl[['teamId','Actual Goal Diff - Expected Goal Diff']].groupby('teamId').mean().sort_values(by='Actual Goal Diff - Expected Goal Diff', ascending=False)df_epl[['teamId','Actual Goal Diff - Expected Goal Diff']].groupby('teamId').sum().sort_values(by='Actual Goal Diff - Expected Goal Diff', ascending=False)**
每个团队的平均值(“实际目标差异-预期目标差异”)和总和(“实际目标差异-预期目标差异”)的降序比较
这种方法讲述了一个类似于“积分减去预期积分”方法的故事，利物浦在这些积分榜上仍然接近榜首。在整个赛季中，利物浦大大超出了预期的净胜球。
这里的一个特点是莱斯特。我不记得他们有一个特别出色的赛季，那么为什么他们在这个指标上遥遥领先呢？
**leicester_results = df_epl[df_epl['teamId']=='Leicester']leicester_results[['teamId', 'Actual Goal Diff - Expected Goal Diff']]**
莱斯特的每场比赛数据(不完整)
很明显，有一场比赛确实扭曲了数据。这是他们 9 比 0 战胜南安普顿的比赛——英格兰顶级足球历史上最大的客场胜利。这场比赛的“实际进球差异——预期进球差异”高达 5.07。
限制
这些数字无法说明问题。我们为他们说话，我们赋予他们意义。—内特·西尔弗
那么经过这么多的分析之后，我们是否有了利物浦是否“幸运”的答案呢？乍一看，似乎是这样。尽管是莱斯特，利物浦在相关的“运气”指标上领先于竞争对手。
然而，如果我们再深入一点，就可以清楚地看到，这些“运气”指标并不一定反映随机机会。生成的两个基准“分数减去预期分数”和“目标差异减去预期目标差异”都严重依赖于预期进球得分(xG)和预期失球(xGA)统计数据。虽然运气肯定会影响 xG 和 xGA 的偏差，但其他因素也会起作用。
例如，如果一支球队创造了相对较少的高质量机会(低 xG)，但成功地打进了大量进球(高实际进球)，这可以解释为运气，但也可以解释为一支球队只是拥有转换速度很快的伟大前锋。
反之亦然——如果一支球队给了对手很多高质量的机会(高 xGA ),但实际上并没有失球太多(失球率低),这可能是运气使然，但也可能是一支防守令人难以置信的球队或世界级门将阻止了实际失球。
结论
所以如果数据没有告诉我们利物浦是幸运的，我们能从中得出什么合理的结论呢？
对我来说，分析表明，利物浦在 2019-2020 赛季期间，没有创造出大量“高质量”的机会，也没有独特地扼杀对手。
这似乎与视力测试相一致——当我实际观看利物浦本赛季的比赛时，我记得有很多艰难的胜利。利物浦通过创造大量高质量的机会将对手轰下球场的情况并不常见。
然而，仅仅从数据上来看，很难断定是什么样的运气、精彩的射门或精彩的停球组合让利物浦获得了冠军。
我希望你喜欢这个！请随意发表评论。我也喜欢任何关于我将来可以使用的有趣数据集的建议！
Airbnb 新加坡数据探索:01
用 Python 对 Airbnb 新加坡数据进行探索性数据分析
介绍
嗨！我叫阿格拉，我是一名建筑师，对建筑、城市设计、房地产和技术知识的整合感兴趣。本文是我在使用 python 编程语言学习数据科学的几个星期中，对我的个人数据科学项目的一个总结。
如今，我们生活在一个数据大量产生和流通的时代。这些数据可以收集起来，让我们推断出有意义的结果，并做出明智的决定。然而，随着数据数量的增加，我们需要将数据可视化，以帮助我们进行数据分析。通过使用可视化工具，我们能够向我们的观众传递信息，并告知他们我们的发现。
本文的目的是探索一家技术公司的公开数据集，通过可视化工具清晰地绘制结果，并为公众和其他相关方提供新的见解。为了使每篇文章的主题更加集中，本文将分成一系列的几篇文章。
对于第一篇文章，我们将使用基本的探索性数据分析技术来探索和可视化来自新加坡 Airbnb 的数据集。我们将根据每个 Airbnb 房源的位置找出它们的分布，包括价格范围、房间类型、房源名称和其他相关因素。
什么是探索性数据分析？
我指的是数据科学家 Terence S 对探索性数据分析的解释。简而言之，探索性数据分析(EDA)，也称为数据探索，是数据分析过程中的一个步骤，其中使用了多种技术来更好地了解所使用的数据集。
一些技术是:
- 提取重要变量，留下无用变量
- 识别异常值、缺失值和人为错误
- 理解数据，最大限度地提高我们对数据集的洞察力，并最大限度地减少流程后期可能出现的潜在错误
通过进行 EDA，我们可以将几乎可用或不可用的数据集变成可用的数据集。
探索性数据分析的主要组成部分:
- 获取和加载数据
- 清洗数据集
- 探索和可视化数据
为什么选择 Airbnb？
自 2008 年以来，客人和主人一直使用 Airbnb 来拓展旅行的可能性，并提供一种更独特、更个性化的体验世界的方式。今天，Airbnb 成为一种被全世界使用和认可的服务。通过 Airbnb 提供的数百万房源的数据分析对该公司来说是一个至关重要的因素。这些数以百万计的列表产生了大量的数据——可以分析的数据。
为什么选择新加坡？
Airbnb 在新加坡有着长期且相当复杂的关系。从五年前开始，新加坡政府就将 Airbnb 提供的短租贴上了非法服务的标签。虽然被贴上了这样的标签，但是到目前为止，只有两个案例发现房东因违反租赁法而被罚款。
此外，在疫情危机冲击全球旅游业之前。Airbnb 在新加坡发展迅速，并在东南亚范围内产生了高度综合的数据。
1.获取和加载数据
对于这个项目，我们使用 jupyter 笔记本 IDE 和 python 编程语言来编写我们的脚本。IDE 或集成开发环境是用于软件开发的软件应用程序。
为了获取数据，我们使用 Airbnb 数据，这些数据是在知识共享许可下在互联网上公开共享的。在我们能够将数据加载到我们的 IDE 之前，首先我们需要导入可视化和分析所需的各种外部库/模块。
a .加载 python 库
- 用于数据分析的熊猫和 Numpy 库
- 用于数据可视化的 Matplotlib 和 Seaborn 库
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
%matplotlib inline
import seaborn as sns
b .加载数据集
为了加载数据集，我们使用 pandas 库和函数从http://insideairbnb.com/读取新加坡 Airbnb 2019–2020 数据集的 CSV 文件，将其转换为 DataFrame 并检查排名前 5 的索引数据。
airbnb = pd.read_csv('listings_sum.csv')
**airbnb.head()**
c .了解数据
在我们加载数据集之后，我们需要通过使用各种技术来理解数据集。首先，我们需要寻找关于我们的数据集有多大的信息。通过使用 shape 属性，我们从包含列表索引的若干行和包含与该索引相关的每个特征的内容的若干列中了解我们的数据大小。
airbnb.shape
(行数、列数)
然后我们检查每一列的所有数据类型，如果它已经符合我们的要求。例如，我们需要经度和纬度上的数字数据类型(整数和浮点),为了列出名称，我们需要确保数据使用的是字符串/对象数据类型。
airbnb.dtypes
数据类型信息
我们发现我们的数据集有 7395 个列表。这些特性包括列表名称、主机 id、位置信息、位置坐标、房间类型、每晚价格等等。
接下来，我们查找由所有新加坡地区列表组成的“neighbourhood _ group”的所有唯一值
airbnb['neighbourhood_group'].unique()
区域地图
从上面的列表中，我们看到新加坡有 5 个区域。
城市重建局(URA)将该地区进一步划分为 55 个区域，称为城市规划区。我们将使用“邻居”列来查看哪个规划区域有 Airbnb 列表。
airbnb['neighbourhood'].unique()
邻近
规划区地图
现在，我们知道有 43 个规划区有 Airbnb 房源。
我们还查找列表中每个房间类型的“房间类型”列
airbnb['room_type'].unique()
房间类型
从上面的列表中，我们看到 Airbnb 有 4 种房型。根据 Airbnb 网站上的信息，每种房间类型的定义如下:
- 包间
客人可以单独进入酒店的卧室/睡眠区。其他区域如客厅、厨房和浴室也可能对主人开放，甚至对其他客人开放。
- 整个家/公寓
客人们可以独享整个地方。它通常包括卧室、浴室和厨房。
- 共享房间
游客睡在卧室或可以与他人共享的公共区域。
- 酒店房间
典型的酒店房间及其设施。自 2018 年以来，Airbnb 允许一些精品酒店和高评级独立酒店在其网站上列出他们的房间。
2.清洗数据集
下一步是清理数据，我们加载的数据经常会有各种各样的错误，比如打字错误、缺少值、数据不完整等等。通过清理，数据质量将有更好的质量用于进一步的分析。
a .检查缺少值的列
让我们首先检查我们的数据集中是否有任何丢失的值
**airbnb.isnull().sum()**
b .删除冗余变量
在我们的例子中，观察到的缺失值不需要过多的处理。查看我们的数据集，我们可以声明列“name”和“host_name”，“last_review”对于进一步的数据探索分析是不相关和不道德的。因此，我们可以去掉那些列。
airbnb.drop(['id','host_name','last_review'],axis=1,inplace=True)
**airbnb.head()**
c .替换所有缺失值
接下来，我们需要用 0(零)替换“review_per_month”列中所有缺失的值，以确保缺失的值不会干扰我们的分析
airbnb['reviews_per_month'].fillna(0,inplace=True)
3.探索和可视化数据
清理完数据后，下一步是通过可视化和分析要素值来探索数据，解释过程和结果。
对于我们的例子，我们将查找由每个最大值组成的各种列表类别，使用地图可视化列表分布，为每个区域创建房间类型比例，从列表名称中查找销售值，并找到最受欢迎的列表的平均价格。
a .热门列表计数
首先，我们跳过“名称”的第一列，从“主机 id”列开始。然后，我们根据列表计数对前 10 个主机进行切片
top_host_id = airbnb['host_id'].value_counts().head(10)
接下来，我们设置图形大小，并使用条形图为数据可视化绘图进行设置
sns.set(rc={'figure.figsize':(10,8)})viz_bar = top_host_id.plot(kind='bar')
viz_bar.set_title('Hosts with the most listings in Singapore')
viz_bar.set_xlabel('Host IDs')
viz_bar.set_ylabel('Count of listings')
viz_bar.set_xticklabels(viz_bar.get_xticklabels(), rotation=45)
从上面的图表中，我们可以看到**前 10 名主机的总数几乎是整个数据集(7395 个列表)**的 20%( 1416 个列表)。甚至其中一个主机有 350 多个房源！
b .顶部区域面积
接下来，我们使用“neighbourhood _ group”列来可视化每个区域中列表计数的比例
labels = airbnb.neighbourhood_group.value_counts().index
colors = ['#008fd5','#fc4f30','#e5ae38','#6d904f','#8b8b8b']
explode = (0.1,0,0,0,0)shape = airbnb.neighbourhood_group.value_counts().valuesplt.figure(figsize=(12,12))
plt.pie(shape, explode = explode, labels=shape, colors= colors, autopct = '%1.1f%%', startangle=90)
plt.legend(labels)
plt.title('Neighbourhood Group')
**plt.show()**
从上面的图表中，我们可以看到中心区域拥有最多的房源，有近 6000 个房源，占全部房源的 80%以上。
c .顶级规划领域
接下来，我们查找列表数量最多的前 10 个规划区域
airbnb.neighbourhood.value_counts().head(10)
我们可以看到， Kallang 的列表数最高。我们还发现前 10 个规划区中有 9 个位于中部地区，Bedok 位于东部地区是个例外。
d .列表图
为了创建列表位置的地图，我们将使用“经度”和“纬度”列。但是首先，我们需要检查列中的值
coord = airbnb.loc[:,['longitude','latitude']]
**coord.describe()**
从上面的数据中，我们可以看到最小和最大指标的经度和纬度的外值。
接下来，我们可视化每个列表的散点图，并根据每个不同区域的颜色对其进行分组
plt.figure(figsize=(18,12))
plt.style.use('fivethirtyeight')BBox = (103.5935, 104.0625, 1.1775, 1.5050)sg_map = plt.imread('map_bnw.png')
plt.imshow(sg_map,zorder=0,extent=BBox)
ax = plt.gca()groups = airbnb.groupby('neighbourhood_group')
for name,group in groups :
plt.scatter(group['longitude'],group['latitude'],label=name,alpha=0.5, edgecolors='k')plt.xlabel('Longitude')
plt.ylabel('Latitude')
plt.legend()
列表映射
现在我们可以看到列表是如何被绘制到地图中的。为了更好地理解列表密度，我们可以使用 follow 热图
**import folium
from folium.plugins import HeatMap**map_folium = folium.Map([1.35255,103.82580],zoom_start=11.4)HeatMap(airbnb[['latitude','longitude']].dropna(),radius=8,gradient={0.2:'blue',0.4:'purple',0.6:'orange',1.0:'red'}).add_to(map_folium)
display(map_folium)
列表密度图
从上面的地图中，我们可以清楚地看到最密集的列表所在的位置，在中央区域的南部区域用红色显示。离中心区域越远，上市密度越低。
e .价格图
在我们可视化价格图之前，我们需要通过移除一些异常数据来更新数据集，因为一些数据价格的值远离 IQR(四分位数范围)。
airbnb_1 = airbnb[airbnb.price < 300]
接下来，我们使用价格热图中的经度和纬度点来可视化每个列表的散点图和价格范围的差异。
plt.figure(figsize=(18,12))sg_map = plt.imread('map_bnw.png')
plt.imshow(sg_map,zorder=0,extent=BBox)
ax = plt.gca()airbnb_1.plot(kind='scatter',x='longitude',y='latitude',label='Listing Location', c='price', ax=ax, cmap=plt.get_cmap('jet'), colorbar=True, alpha=0.4, zorder=5)**plt.legend()
plt.show()**
列表价格图
从上面的地图中，我们观察到价格朝着中心区域的中心部分相对上升，因为该区域是新加坡的 CCR 区域。
从房地产的角度来看，URA 将新加坡分为三个主要区域，他们称之为“细分市场”。核心中心区(CCR)，用黄色表示，是中心区的主要区域，在这里可以找到大多数高端和豪华的物业。中部地区(RCR)其余部分的红色被视为位于外部中部地区(OCR)的大众市场公寓和 CCR 中的高价值物业之间的中间层市场。最后一个是 OCR，由灰色表示，覆盖了新加坡四分之三的面积，基本上是低端大众市场公寓所在的区域。
通过查看上面的两张地图，我们可以认为 Airbnb 的挂牌价格与房地产细分市场有关。但要得出这样的结论，我们需要更多的数据来做进一步的分析。
f .价格分布
根据我们对价格热图的观察，我们需要使用一个方框图来显示价格分布，以便更好地了解按“neighborhood _ group”/region 区域分组的标价范围。
plt.style.use('fivethirtyeight')
plt.figure(figsize=(14,12))
sns.boxplot(y='price',x='neighbourhood_group',data = airbnb_1)
plt.title('Neighbourhood Group Price Distribution < S$ 300')
**plt.show()**
从上面的数据中，我们看到中部地区每晚的价格最贵，中位数为130新元。
g .顶级列表词
接下来，我们将通过找出清单名称中最常用的词来更深入地探索属性细节。最常用的词可以代表他们的财产对潜在客人的销售价值。首先，我们将创建一个收集单词的函数。
**#Crete empty list where we are going to put the name strings**
names=[]**#Getting name string from 'name' column and appending it to the empty list**
for name in airbnb.name:
names.append(name)**#Setting a function to split name strings into seperate words**
def split_name(name):
s = str(name).split()
return s**#Create empty list where we are going to count the words**
names_count = []**#Getting name string to appending it to the names_count list**
for n in names:
for word in split_name(n):
word = word.lower()
names_count.append(word)
我们需要导入计数器库来计数并生成包含主机使用的前 25 个字的原始数据
**from collections import Counter**top_25 = Counter(names_count).most_common()
top_25 = top_25[:25]
然后，我们将数据转换成数据帧，并将我们的发现可视化
word_count_data = pd.DataFrame(top_25)
word_count_data.rename(columns={0:'Words',1:'Counts'},inplace=True)viz_count = sns.barplot(x='Words',y='Counts', data = word_count_data)
viz_count.set_title('Top 25 used words for listing names')
viz_count.set_ylabel('Count of words')
viz_count.set_xlabel('Words')
viz_count.set_xticklabels(viz_count.get_xticklabels(),rotation = 90)
列出姓名时最常用的 25 个单词
从上面的图表中，我们看到了列表名称中使用的前 25 个单词。我们可以用文字云可视化的方法来帮助我们更好地理解图表。
**from wordcloud import WordCloud, ImageColorGenerator**text = ' '.join(str(n).lower() for n in airbnb.name)**#Generate wordcloud image**
wordcloud = WordCloud(max_words=200, background_color = 'white').generate(text)
plt.figure(figsize=(25,20))**#Display the image**
plt.imshow(wordcloud, interpolation='bilinear')
plt.axis('off')
plt.show()
正如我们所看到的，大多数列表销售价值与公共设施(如 mrt 和活动中心)的邻近度或连接度有关，通过“MRT”、“near”、“to”、“city”、“walk to”关键字显示。有趣的是，看到房间条件如何落后于这些值，在图表的较低等级上显示为“宽敞”、“舒适”、“惬意”。
h .房型详情
接下来，我们将使用 Plotly API 图形可视化库来可视化每个地区的所有房型比例
**import plotly.offline as pyo
import plotly.graph_objs as go****#Setting up the color pallete**
color_dict = {'Private room': '#cc5a49', 'Entire home/apt' : '#4586ac', 'Shared room' : '#21908d', 'Hotel room' : '#C0C0C0' }**#Group the room type using 'neighbourhood_group' as an index**
airbnb_types=airbnb.groupby(['neighbourhood_group', 'room_type']).size()**#Create function to plot room type proportion on all region area**for region in airbnb.neighbourhood_group.unique():
plt.figure(figsize=(24,12))
airbnb_reg=airbnb_types[region]
labels = airbnb_reg.index
sizes = airbnb_reg.values
colors = [color_dict[x] for x in labels]
plot_num = 321
plt.subplot(plot_num)
reg_ch = go.Figure(data = [go.Pie(labels = labels, values = sizes, hole = 0.6)])
reg_ch.update_traces(title = reg, marker=dict(colors=colors))
reg_ch.show()
plot_num += 1
房间类型
我们可以看到，中心区域是唯一由整个住宅/公寓类型主导的区域，其余区域由私人房间类型主导。总体而言，酒店类型是每个地区上最少的房源，因为 Airbnb 在 2018 年才开始接受酒店房源。
一.最受关注的 10 个名单
我们将根据评论数量找出前 10 名的房源，以了解新加坡最受欢迎的 Airbnb 房源。
airbnb.nlargest(10, 'number_of_reviews')
瞧啊。这是 10 个最受欢迎的列表。同样，我们发现大多数最受关注的列表位于中部地区，10 个列表中有 7 个位于中部地区。
j .每晚平均价格
最后，我们将计算 10 个最受欢迎的房源每晚的平均价格
price_avg = top_review.price.mean()
print('Average price per night: S$ {}'.format(price_avg))
从这个输出中，我们可以观察到Airbnb Singapore 上最受欢迎的前 10 个房源的平均价格为 99.9 新元，大多数房源的价格都低于 90 新元，其中 6/10 是“私人房间”类型，热门评论房源总共有 3111 条评论。
结论
简单地通过对数据集执行 EDA，我们已经识别出关于 Airbnb 房源如何在新加坡分布的各种新见解，我们知道房源位于哪里，发现中心区域支配着房源数量并具有最高的价格范围，房源价格可能如何与周围的房地产价格相关，并发现房源与其周围的连接性成为共同的销售价值之一。
在下一篇文章中，我们将使用更详细的版本来探索数据集。我们将重点关注中心区域，以了解更深层次的背景，了解该区域每个房源之间的关系，以及它们与外部变量的关系，例如与公共设施的连接，以及房地产价格对房源租赁价格的影响。
感谢您的阅读！请随时给予任何反馈！
参考:
- https://towards data science . com/an-extensive-guide-to-explorative-data-analysis-DDD 99 a 03199 e
- https://www . channelnewsasia . com/news/business/Airbnb-records-30-第一季度预订增长率-11817260
- https://www . property guru . com . SG/property-guides/CCR-ocr-rcr-region-Singapore-ura-map-21045
- https://www . Airbnb . com/help/article/5/the room-type-of-a-listing-是什么意思
数据探索，简化。
厌倦了在互联网上查找数百个方法和函数来探索您的数据集吗？Xplore 将探索性数据分析过程的速度提高了 10 倍，所有这一切都只需要一行代码。
xplore logo 设计由**Divine alor vor**
什么是数据探索？
根据维基百科的定义，数据探索是一种类似于初始数据分析的方法，数据分析师通过视觉探索来了解数据集中的内容和数据的特征，而不是通过传统的数据管理系统。
正是在数据分析过程的这个阶段，数据科学家或分析师、人工智能或人工智能工程师试图真正理解他们正在处理的数据。在这一点上，他们试图熟悉他们正在处理的数据，以便能够知道它在解决手头的问题时有多有效，以及他们还需要做多少处理。在这个阶段，数据分析师或科学家、人工智能或 ML 工程师使用如此多的工具和库来有效地探索他们的数据集。这使得数据探索的过程很难完全完成，特别是如果你不知道许多必要的工具，库和方法来很好地探索你的数据集。有一个好消息，想象一下，只需一行代码就能高效快速地浏览数据集！
探险
考虑到与有效探索您的数据相关的这么多问题，我的队友、Benjamin acqua ah、 Adam Labaran 和我自己编写了一些自动化脚本，可以极大地自动化和简化数据探索过程。我们使用 Pandas 开源库编写了这个脚本，利用了该库附带的许多方法和函数。在修复了几个错误、优化了代码并运行了一系列测试之后，我们最终构建并打包了 xplore 🎉。
xplore 是为数据科学家或分析师、AI 或 ML 工程师构建的 python 包，用于在单行代码中探索数据集的特征，以便在数据争论和特征提取之前进行快速分析。 xplore 还利用了 pandas-profiling 的全部功能，如果用户需要，可以生成非常高级和详细的数据探索报告。
xplore 完全开源，感兴趣的贡献者或代码爱好者可以在Github上找到完整的源代码和测试文件。该项目也已经发布在 PyPi 上，因此任何感兴趣的人都可以轻松地将它安装并导入到他们的本地项目中。****
xplore logo 由Divine alor vor设计****
如何使用 xplore 浏览您的数据
在本节中，我将通过一个演练教程来指导您如何在您的本地项目中安装、导入和使用 xplore 包。
安装 xplore 包
使用 xplore 包成功浏览数据的最低要求是在计算机上安装 Python。一个额外的好处是可以在您的计算机上安装 Anaconda 并添加到 PATH 中。完成这些工作后，您可以轻松地导航到您的命令提示符(Windows)、终端(Linux/macOS)或 anaconda 提示符并运行命令:
****pip install xplore****
通过运行这个命令，最新版本的 xplore 及其依赖项将会完全存储在您的本地计算机上，这样您就可以方便地在以后的 python 文件中导入和使用它。
将 xplore 模块导入到代码中
在任何想要使用 xplore 包探索数据的 python 文件中，您都必须将 xplore 模块直接导入到代码文件中，这样您就可以轻松地访问和使用该模块附带的内置方法。这可以通过在代码中进行必要的导入时添加以下行来实现:
****from xplore.data import xplore****
为探索准备数据
在这篇文章发表的时候， xplore 包已经过优化，只能处理带标签的数据。使用 xplore 包准备您的数据，就像将您读入代码的数据赋给任何变量名一样简单。
****import pandas as pddata = pd.read_csv('name_of_data_file.csv')****
使用 xplore 方法
实际探索数据的过程被简化为一行代码。其他要做的事情将由我们编写的自动化脚本自动完成。您可以使用以下命令浏览您的数据:
****xplore(data)****
通过运行该程序，您将看到从数据探索中得出的分析输出。几乎所有您需要的重要分析都将被打印出来，但是对于那些希望从他们的数据分析中看到非常详细和高级的报告的人，当提示询问您是否希望看到关于您的数据探索的详细报告时，请键入“y”。否则，如果您对打印出来的输出感到满意，当您看到该提示时，您可以轻松地键入“n”。
运行 xplore 方法的示例输出
在运行了使用 xplore 方法浏览数据的代码之后，您的输出应该是这样的:
****------------------------------------
The first 5 entries of your dataset are:
rank country_full country_abrv total_points ... three_year_ago_avg three_year_ago_weighted confederation rank_date
0 1 Germany GER 0.0 ... 0.0 0.0 UEFA 1993-08-08
1 2 Italy ITA 0.0 ... 0.0 0.0 UEFA 1993-08-08
2 3 Switzerland SUI 0.0 ... 0.0 0.0 UEFA 1993-08-08
3 4 Sweden SWE 0.0 ... 0.0 0.0 UEFA 1993-08-08
4 5 Argentina ARG 0.0 ... 0.0 0.0 CONMEBOL 1993-08-08
[5 rows x 16 columns]
------------------------------------
The last 5 entries of your dataset are:
rank country_full country_abrv total_points ... three_year_ago_avg three_year_ago_weighted confederation rank_date
57788 206 Anguilla AIA 0.0 ... 0.0 0.0 CONCACAF 2018-06-07
57789 206 Bahamas BAH 0.0 ... 0.0 0.0 CONCACAF 2018-06-07
57790 206 Eritrea ERI 0.0 ... 0.0 0.0 CAF 2018-06-07
57791 206 Somalia SOM 0.0 ... 0.0 0.0 CAF 2018-06-07
57792 206 Tonga TGA 0.0 ... 0.0 0.0 OFC 2018-06-07
[5 rows x 16 columns]
------------------------------------
Stats on your dataset:
<bound method NDFrame.describe of rank country_full country_abrv total_points ... three_year_ago_avg three_year_ago_weighted confederation rank_date
0 1 Germany GER 0.0 ... 0.0 0.0 UEFA 1993-08-08
1 2 Italy ITA 0.0 ... 0.0 0.0 UEFA 1993-08-08
2 3 Switzerland SUI 0.0 ... 0.0 0.0 UEFA 1993-08-08
3 4 Sweden SWE 0.0 ... 0.0 0.0 UEFA 1993-08-08
4 5 Argentina ARG 0.0 ... 0.0 0.0 CONMEBOL 1993-08-08
... ... ... ... ... ... ... ... ... ...
57788 206 Anguilla AIA 0.0 ... 0.0 0.0 CONCACAF 2018-06-07
57789 206 Bahamas BAH 0.0 ... 0.0 0.0 CONCACAF 2018-06-07
57790 206 Eritrea ERI 0.0 ... 0.0 0.0 CAF 2018-06-07
57791 206 Somalia SOM 0.0 ... 0.0 0.0 CAF 2018-06-07
57792 206 Tonga TGA 0.0 ... 0.0 0.0 OFC 2018-06-07
[57793 rows x 16 columns]>
------------------------------------
The Value types of each column are:
rank int64
country_full object
country_abrv object
total_points float64
previous_points int64
rank_change int64
cur_year_avg float64
cur_year_avg_weighted float64
last_year_avg float64
last_year_avg_weighted float64
two_year_ago_avg float64
two_year_ago_weighted float64
three_year_ago_avg float64
three_year_ago_weighted float64
confederation object
rank_date object
dtype: object
------------------------------------
Info on your Dataset:
<bound method DataFrame.info of rank country_full country_abrv total_points ... three_year_ago_avg three_year_ago_weighted confederation rank_date
0 1 Germany GER 0.0 ... 0.0 0.0 UEFA 1993-08-08
1 2 Italy ITA 0.0 ... 0.0 0.0 UEFA 1993-08-08
2 3 Switzerland SUI 0.0 ... 0.0 0.0 UEFA 1993-08-08
3 4 Sweden SWE 0.0 ... 0.0 0.0 UEFA 1993-08-08
4 5 Argentina ARG 0.0 ... 0.0 0.0 CONMEBOL 1993-08-08
... ... ... ... ... ... ... ... ... ...
57788 206 Anguilla AIA 0.0 ... 0.0 0.0 CONCACAF 2018-06-07
57789 206 Bahamas BAH 0.0 ... 0.0 0.0 CONCACAF 2018-06-07
57790 206 Eritrea ERI 0.0 ... 0.0 0.0 CAF 2018-06-07
57791 206 Somalia SOM 0.0 ... 0.0 0.0 CAF 2018-06-07
57792 206 Tonga TGA 0.0 ... 0.0 0.0 OFC 2018-06-07
[57793 rows x 16 columns]>
------------------------------------
The shape of your dataset in the order of rows and columns is:
(57793, 16)
------------------------------------
The features of your dataset are:
Index(['rank', 'country_full', 'country_abrv', 'total_points',
'previous_points', 'rank_change', 'cur_year_avg',
'cur_year_avg_weighted', 'last_year_avg', 'last_year_avg_weighted',
'two_year_ago_avg', 'two_year_ago_weighted', 'three_year_ago_avg',
'three_year_ago_weighted', 'confederation', 'rank_date'],
dtype='object')
------------------------------------
The total number of null values from individual columns of your dataset are:
rank 0
country_full 0
country_abrv 0
total_points 0
previous_points 0
rank_change 0
cur_year_avg 0
cur_year_avg_weighted 0
last_year_avg 0
last_year_avg_weighted 0
two_year_ago_avg 0
two_year_ago_weighted 0
three_year_ago_avg 0
three_year_ago_weighted 0
confederation 0
rank_date 0
dtype: int64
------------------------------------
The number of rows in your dataset are:
57793
------------------------------------
The values in your dataset are:
[[1 'Germany' 'GER' ... 0.0 'UEFA' '1993-08-08']
[2 'Italy' 'ITA' ... 0.0 'UEFA' '1993-08-08']
[3 'Switzerland' 'SUI' ... 0.0 'UEFA' '1993-08-08']
...
[206 'Eritrea' 'ERI' ... 0.0 'CAF' '2018-06-07']
[206 'Somalia' 'SOM' ... 0.0 'CAF' '2018-06-07']
[206 'Tonga' 'TGA' ... 0.0 'OFC' '2018-06-07']]
------------------------------------
Do you want to generate a detailed report on the exploration of your dataset?
[y/n]: y
Generating report...
Summarize dataset: 100%|████████████████████████████████████████████████████████████████████████████| 30/30 [03:34<00:00, 7.14s/it, Completed]
Generate report structure: 100%|█████████████████████████████████████████████████████████████████████████████████| 1/1 [00:31<00:00, 31.42s/it]
Render HTML: 100%|███████████████████████████████████████████████████████████████████████████████████████████████| 1/1 [00:12<00:00, 12.07s/it]
Export report to file: 100%|█████████████████████████████████████████████████████████████████████████████████████| 1/1 [00:00<00:00, 8.00it/s]
Your Report has been generated and saved as 'output.html'****
Python 是你能读懂的最强大的语言。
—保罗·杜布瓦
作为一个狂热的学习者，我非常热衷于为下一代学习者提供更简单的东西，自动化是实现这一点的最简单的方法之一。为自己省去在数据探索上浪费大量时间的压力。当你下一次浏览你的数据时，一定要 浏览 你的数据😉
如果你喜欢我的队友和我在这个项目中所做的，请花几分钟时间给明星⭐️on 留下 GitHub repo ，并通过点击这个链接在 twitter 上告诉你的朋友关于 xplore 。
感谢您抽出几分钟时间阅读本文。我希望它是有教育意义和有帮助的😊如果你想在推特和 T2 的 LinkedIn 上私下聊天，我随时奉陪。编程快乐！
我衷心感谢 安娜·阿伊库 校对并纠正了我写这篇文章时犯的许多错误。
数据探索与洞察
(来源: PxHere )
Pytolemaic 系列
为什么您应该停止数据探索，转而使用自动洞察生成。
动机
一个 ll 数据项目从数据开始，工作从数据探索开始。通过执行数据探索，探索者旨在熟悉和理解数据，发现有趣的事实和趋势，如数据中的损坏、相关性、类别不平衡。
然而，数据浏览器的最终目标不是有趣的事实或趋势，而是可操作的*见解。*这些数据洞察随时可用——可能用于清理数据、提高模型性能或支持业务 KPI。
这不是一个容易的过程。即使是很小的数据集(包含几千个样本和仅仅十几个特征的表)也很难理解，筛选见解就更难了。在这篇文章中，我将讨论为什么数据探索是发现有用数据洞察的错误方法，并建议用自动洞察生成方法来取代它。我将分享这种洞察力生成方法的一些结果以及我的结论。
数据探索，以及为什么你不应该这样做
人们通常通过查看一些样本来开始数据探索过程，这很好，但最多限于几百个样本。接下来，他/她会查看一些统计数据(例如最小值、最大值、频率、计数)并绘制一些直方图，以寻找有趣的见解。根据一个人的创造力和好奇心，为数据集中的每个要素生成一打统计数据和图表是相当容易的，这些数据可以累积到数百甚至数千个图表。
比如我们来看看 UCI 的成人数据集(链接)。这是一个小数据集——大约 50K 个实例和 15 个特征——这个 Kaggler 已经为其训练了一个简单的逻辑回归模型，但在此之前绘制了 20 多个统计表和图表。
只见树木不见森林
成人数据集中所有特征的直方图(来源:作者)
我们贫乏的人类头脑无法处理太多的信息。太多的统计数据/图表会导致浏览时看不到它们。
在 Data Exploration 干草堆中寻找针
成人数据集中所有特征的最大值(来源:作者)
抛开创建统计表/图表所需的工作不谈，阅读和理解其中的内容需要付出大量的努力。例如，计算每个特征的最大值是微不足道的，但是要注意到一个特定的特征，(例如，成人数据集中的‘资本收益或‘每周小时数’)有一个可疑的最大值——这几乎是不可能的。
信息只有在你能付诸行动时才是有用的
数据探索旨在通过各种功能和技术获取数据信息。然而，我们需要所有这些信息吗？答案是不，我们没有。任何不会引发行动的信息都是无用的，我们不需要无用的信息，不管它多么有趣。
例如，让我们看看成人数据集中职业特征的直方图。我们可以看到每个职业有多少人。
成人数据集中特征占用的直方图(来源:作者)
如果那是你的数据集——你会在意数据集有 994 个渔民样本和 3650 个销售人员样本吗？可能分别是 1515 年和 2317 年，对吗？那么，如果一个箱子高度的 50%的差异没有影响，也不会引发第二个想法，为什么要首先查看直方图呢？
洞察力，以及如何获得洞察力
答案很简单——我们在搜索有趣的信息时进行数据探索，我们可以根据这些信息采取行动，换句话说，就是洞察力。看着上面的例子，我们可以发现一些有趣的事实:
- “职业为‘武装部’的只有 9 人”。
- 职业不明的有 1500 人。
- “管理者比渔民多 4 倍”。
然而，只有前两句话应被视为见解，因为它们会引发行动。
- “职业为‘武装部’的只有 9 人”。→触发*“从数据集中删除这些样本”动作或“将‘职业’类与另一类合并”*。
- 职业不明的有 1500 人。→触发“验证数据正确性”动作，随后触发“处理缺失值”动作。
如果你先画一张图表，然后问自己能从中学到什么，那么你就做错了。相反，首先决定你想学什么，然后绘制图表。
绘制一个有趣的图表，然后试图发现洞察力是大多数人做的事情。很有挑战性，也很好玩，但不是很有效。更好的方法是根据问题的答案来定义“问题”( Q )或“假设”( H )以及相应的“动作”( A )。例如:
- H: 超出 5-sigma 范围的异常值数量应≤1。
**答:**降样。
在这种方法中，洞察力( I )很容易被发现，因为它们是触发行动的事实——对未实现的问题( Q )或假设( H )的回答。基于成人数据集的一些示例:
- H: 超出 5-sigma 范围的异常值数量应≤1。
I : 709 个异常值超出了特性“资本收益”的 5-sigma 范围。
I : 244 个异常值在特征“资本损失”的 5-sigma 范围之外。
**答:**滴样品。 - H: 数字特征的最大值不是 10**k-1 的格式。
I :存在‘资本收益’为 99999 的样本。
I :存在“每周小时数”为 99 的样本。
**答:**验证这些值的正确性。 - **问:**唯正特征有没有负值？
I : 无(没有这样的值)。
A :如果有，更换为 N/A
让我们看看如何将它写入代码:
3 种洞察的代码示例
洞察力不仅限于数据
在前面的示例中，我们重点关注了来自数据集的见解。然而，如果我们定义一些 ML 假设，我们可能会发现额外的见解。例如:
- H :测试集和训练集具有相似的数据分布
- H :数据集中没有重要性为 0 的特征
- H :如果主要指标显示良好的结果，那么其他指标也有合理的值。
在大多数情况下，回答这些问题或检验假设是很容易的，不需要使用图形方式，甚至不需要人参与。因此，这一过程通常可以自动化，并且由于许多假设不依赖于数据集，因此不难扩展。人们甚至可以继承这个概念，为数据集定义一套单元测试。
自动洞察生成
我已经开始尝试实现这样的自动洞察生成器，作为 Pytolemaic 包的一部分(在这里阅读更多)。我定义并实现了一组通用的假设，后来我在几个数据集上进行了尝试。在讨论我的结论之前，让我们看看那些试验的结果。
见解示例
- Titanic 数据集— 900 个样本 X 11 个特征
泰坦尼克号数据集的自动生成洞察
洞察力告诉我们:存在 5-sigma 异常值——需要检查。此外，一些功能(姓名/机票/客舱)使用不正确。
- 加州房价数据集— 20k 样本 X 8 特征
加州房价数据集的自动生成洞察
洞察力告诉我们:存在 5-sigma 异常值——需要检查。
- 成人数据集— 32K 样本 X 14 个特征
成人数据集的自动生成洞察
洞察力告诉我们:存在 5-sigma 异常值——需要检查。此外，每周小时数( 99.0)和资本收益 (99999.0)也有可疑值。
- Sberbank 房产市场 — 3 万个样本 X 291 个特征(一场卡格尔竞赛)
Sberbank 房产市场数据集的自动生成洞察
洞察告诉我们:大约有 250 个洞察，其中大部分是 5-sigma 离群值——需要检查。另外，在子区域的小类应该合并到一个‘其他’类*。*
下面给出了使用 Pytolemaic 包生成 Titanic insights 的代码，如果您想亲自尝试的话。
我的结论
这些见解的实现非常有趣，并不像我预期的那么难。它向我展示了实现通用的自动生成的见解并获得对数据的有用见解是可能的。产生这种见解的要求是经验、创造力和编码技能——任何高级数据科学家都具备的技能组合。然而，在创建 insight 模块时，我不得不面对几个挑战，使得这个过程充满挑战。
- 有用性 由于定义问题/假设所涉及的过程，使见解变得有用并不是一个很大的挑战。因为行动是定义的一部分，所以获得的任何洞察都是可操作的，因此是有用的。然而，动作应该是 insight 模块输出的一部分，因为读者可能不知道要执行什么动作。
- 简短、清晰、干净且易于理解 通过查看这些自动生成的见解，很明显选择正确的格式至关重要。对于一些见解，我很难选择一个好的格式，这是显而易见的。难以阅读或难以理解的见解会被忽视和忽略，错过它们包含的信息。
例如，在上述示例中，insight 分析是在分类特征已经通过序号编码的数据集上执行的，这使得“class '1.0 '只有 3 个表示”这样的句子非常模糊，因为人们很难弄清楚 class '1.0 '到底是什么？ - 完整信息 洞察应该包含数据科学家采取行动所需的所有相关信息。例如，离群值的“# ”洞察不提供遇到的最大值和最小值。因此，要由读者来查找(即编写一些代码)这些带有离群值洞察力的特性的数字——有很多这样的特性。然而，请注意，如果一个人想要保持简短清晰的洞察力，提供额外的信息并不像看起来那么简单。
- 洞察力的质量和有用性很大程度上取决于投入到分析中的努力。例如， ‘# of outliers’ 假设正态分布，这可能不是许多特征的情况(例如，“年龄”，“每周小时数”)。可以定义高级假设来揭示隐藏的见解，例如特征之间的高度相关性、数据中的异常、时间漂移等等。
- 全面性 由于数据集/模型中可能出现的问题数量接近于无穷大，因此要创建一套全面的见解几乎是不可能的。全面性只能通过从经验教训中不断改进来实现。
- 太多的洞见 克服了上面所有的挑战之后，还有一个主要的挑战——如何避免产生太多的洞见。当有太多的洞见时，用户将很难浏览所有的洞见。Sberbank 的例子展示了这样的行为。我相信我们需要实现一些算法来帮助我们筛选列表中更重要的见解。
总结一下
由于人类能力有限，数据探索无法扩展。因此，我们需要使用不同的方法——自动洞察生成。在这种方法中，我们定义了一组问题-行动或假设-行动对。然后将问题/假设应用于数据集，提供可操作的答案。
通过几个例子，我们看到了这种方法的潜力和挑战。我相信，在不久的将来，世界将超越人工数据探索，代之以强大的算法，能够以可扩展的方式提供可操作的见解。
COVID 跟踪项目的数据探索
如何使用新冠肺炎最全面的美国数据库之一轻松进行探索性数据分析(EDA)。
编者按: 走向数据科学 是一份以数据科学和机器学习研究为主的中型刊物。我们不是健康专家或流行病学家，本文的观点不应被解释为专业建议。想了解更多关于疫情冠状病毒的信息，可以点击 这里 。
什么是 COVID-tracking-project？
根据他们的网站,COVID 跟踪项目收集并发布了美国各州和地区最完整的测试数据。
图片来源:截图来自 Covid-tracking-project 网站
了解区域疫情的发展动态和精确位置需要完整的测试图——每个州/地区实际上有多少人接受了测试，测试是何时进行的，结果是什么。
艾德亚多·桑奇兹博士是美国心脏协会负责预防的首席医疗官，也是前州卫生局局长
www.heart.org](https://www.heart.org/en/news/2020/04/02/covid-19-science-why-testing-is-so-important)
事实上，该项目已被全国各大媒体公司和机构引用和使用。
图片来源:截图来自 Covid-tracking-project 网站
如何验证数据的质量和准确性？
该网站进一步补充道“…o 我们的数据团队使用网站抓取器和追踪器来提醒我们发生的变化，但对我们数据集的 实际更新是由细心的人 手动完成的，他们会仔细检查每一项变化，并广泛地注释不明确的变化区域。
流行新闻媒体中的一些可视化内容(例如纽约时报、政治、华尔街日报等。)都是从这些数据中创建出来的。
图片来源:截图来自 Covid-tracking-project 网站
在本文中，我们将了解简单的 Python 脚本如何帮助您阅读该数据集并创建有意义的可视化效果，从而追踪和了解新冠肺炎在美国的传播情况
了解区域疫情的发展动态和精确位置需要一个完整的测试图…
代码和演示
代码可以在这个 Jupyter 笔记本 在我的 新冠肺炎分析 Github 回购 中找到。
提取数据并加载到数据帧中
第一部分是从网站上提取数据，并将其加载到熊猫数据框架中，以便于分析。
幸运的是，他们以 CSV 格式为此目的提供了一个简单的 API 端点。
这意味着，为了分析最新的数据，你只需要实时运行脚本，从网站上获取最新的数据。不依赖于旧的下载数据文件！
一些家务
我们可能希望将日期字段转换成特定的格式，删除不必要的列，并确保state字段有字符串值。
有什么样的数据？
这是数据集列的快照，
请注意，并非所有数据都以相同的数量/频率出现。记录阳性/阴性病例，定期维护测试结果，而住院数据(呼吸机、ICU 等。)都有些稀疏。
我们预计在数据帧中会有很多 NaN 或 voids，所以我们可以简单地用一个特殊的数字来替换它们，比如-1，以便稍后签入我们的验证代码。
给定变量/状态的条形图
条形图是最常见的这种类型的视觉分析。我们编写了一个自定义函数来绘制任何给定状态下数据集中的任何变量随时间的变化。
我们不会在这里乱码，但这里有例子。请注意，并非所有系列都具有相同数量的数据点，或者并非所有系列都从相同的时间点开始。但是代码只是简单地处理它，并为用户选择的特定状态绘制可用数据。
散点图检查相关性
相关性的一个基本检查是通过创建双变量散点图来完成的。因此，我们编写一个自定义函数来为任何一对变量创建散点图。
总检测数和阳性病例数之间是否存在正相关关系？
死亡人数是否随住院率单调增加？
跟踪测试的进度
正如我们在开始时提到的，COVID-tracking 项目主要用于测试相关数据。因此，毫不奇怪，我们想要创建一个可视化来跟踪测试工作中各种状态的进展。
我们甚至可以使用折线图在同一个图上比较多个状态。该函数还为我们计算平均测试/日指标，并将其放入图例中。
计算各种比率的函数
我们编写了一组函数来计算各种有用的比率，
- :死亡总人数与阳性总人数之比
- 住院率 :住院总人数与总阳性病例数之比
- 阳性病例比率 :总阳性病例数与总检测数的比率
一旦对这些函数进行了编码，就可以在标准的可视化脚本中使用它们来绘制条形图，比较各种状态的比率。这将回答一些问题，比如哪个州的死亡率最高？哪个州的住院率最低？
为什么这些比率对计算和跟踪很重要？
这是因为，稍后，公共卫生官员和社会科学家可以查看这些数字，并假设当地因素——医疗保健系统准备情况、测试/跟踪能力、政治权宜之计、人均 GDP 等。影响了每个州的死亡率和住院率。
这里有一些比较图表的例子。请注意，并非所有图表都有相同数量的条形，也并非所有状态都报告相同的指标。
就人口或新冠肺炎病例而言，纽约州或加利福尼亚州比密歇根州大得多并不重要。该比率清楚地表明，在新冠肺炎阳性病例中，心肌梗死的死亡率最高，而在所有检测中，纽约的阳性病例比例最高。
这些断言中的每一个，通过简单的条形图被可视化，都是一个可以跟随和分析的故事，以理解这种疾病的本质和动态。
…公共卫生官员和社会科学家可以查看这些数字，并假设当地因素——医疗保健系统准备情况、检测/跟踪能力、政治权宜之计、人均 GDP 等。影响了每个州的死亡率和住院率。
用于比较所有状态的气泡图
相同的比率可以绘制在气泡图中，以便一起比较所有的状态。
**
哪些州有 14 天病例数下降？
我们需要编写几个自定义函数来从数据集中提取这些数据或趋势，并将其可视化。
基本上，我们可以看看最近 14 天新新冠肺炎病例的连续差异。如果所有的数字都是负数，那么新的病例会单调下降。即使事实并非如此，那么负数越多越好，因为这表明总体趋势在下降*。***
代码在笔记本中，但当我们比较四种状态(CA、GA、LA 和 MI)时，结果显示在这里。事实上，没有一个州显示出一组完整的负数。
摘要和其他文章
我们展示了如何从美国最受尊敬的新冠肺炎数据库中提取数据，并使用简单的 Python 代码创建有意义的可视化。
同样，代码可以在我的新冠肺炎分析 Github repo 中的这个 Jupyter 笔记本中找到。这个回购里还有其他有用的笔记本，大家可以叉一下，探索一下。
这不是一个预测模型，将来也不会是。这个脚本的目标是只做可视化分析。如果没有扎实的流行病学知识或没有合作，就不应该仅仅从时间序列数据中建立任何预测模型。
自第二次世界大战以来最大的全球性危机和自 1918-1919 年西班牙流感以来最大的全球性疫情今天降临了。每个人都在关注死亡人数的每日增长和这种新型病毒的快速指数传播。
数据科学家，像其他各行各业的许多人一样，也可能感到焦虑。知道数据科学和统计建模的熟悉工具与分析关键测试和疾病相关数据非常相关，这可能有点令人放心。
我的几篇文章与新冠肺炎有关。
创建一个简单的 Python 类来分析和可视化来自纽约时报的新冠肺炎数据集。
towardsdatascience.com](/analyze-ny-times-covid-19-dataset-86c802164210) [## 新冠肺炎检验的假阳性/假阴性和贝叶斯规则
为什么假阳性和假阴性都不利于新冠肺炎测试。为什么贝叶斯规则对这些很重要…
towardsdatascience.com](/false-positives-negatives-and-bayes-rule-for-covid-19-testing-750eaba84acd) [## “拉平曲线”和“解除锁定”的简单建模
一个基本流行病学模型的简单 Python 脚本，用于演示社交距离的影响。
towardsdatascience.com](/simple-modeling-of-flattening-the-curve-and-lifting-lockdown-1a774a248e68)
注意安全，各位！
作者注 : 我是一名半导体技术专家，对将数据科学和机器学习应用于与我领域相关的各种问题感兴趣。我没有医学、分子生物学、流行病学或任何与新冠肺炎相关的专业知识。 请不要给我发那种查询的邮件 。
答同样，你可以查看作者的 GitHub 知识库获取机器学习和数据科学方面的代码、思想和资源。如果你像我一样，对人工智能/机器学习/数据科学充满热情，请随时在 LinkedIn 上添加我，或者在 Twitter 上关注我。
[## Tirthajyoti Sarkar - Sr .首席工程师-半导体、人工智能、机器学习- ON…
通过写作使数据科学/ML 概念易于理解:https://medium.com/@tirthajyoti 开源和有趣…
www.linkedin.com](https://www.linkedin.com/in/tirthajyoti-sarkar-2127aa7/)*
从具有半结构化布局的 PDF 表格中提取数据
实践教程
了解如何使用 pdfminer、numpy 和 pandas 处理特定于上下文的数据结构
图片来自 https://wiki.atlan.com/unstructured-data/
什么是半结构化数据？
在当今的工作环境中，PDF 文档被广泛用于内部以及与贸易伙伴交换商业信息。很自然，你已经看到了相当多的 pdf 格式的发票、采购订单、发货单、价目表等。尽管 PDF 文档作为纸质文档的数字替代物，但对其存储的数据的自动化操作提出了挑战。它就像写在纸上的数据一样容易获取，因为有些 pdf 是为了向我们人类传递信息而设计的，而不是计算机。此类 pdf 可能包含没有预定义数据模型或没有以预定义方式组织的非结构化信息。它们通常以文本为主，可能包含数字、日期和数字的组合。
使用大多数可用的工具，您通常必须处理整个 PDF 文档，无法将数据提取限制在最有价值的数据所在的特定部分。然而，一些 PDF 表格提取工具就是这样做的。遗憾的是，即使你足够幸运，在你的 PDF 中有一个表格结构，也不意味着你能够无缝地从中提取数据。
例如，让我们看看下面的基于文本的 PDF，其中有一些虚假的内容。它有非常明显和明显的(虽然没有边界)行和列:
作者图片
只要稍加观察，您就可能会忽略一个重要的模式:一些行和列相交处的文本被堆叠和移动，因此很难将其识别为同一数据行的附加特征。
尽管如此，任何不适合列或行的数据都被广泛认为是非结构化的，我们可以将这种特殊的现实世界现象称为半结构化数据。
对于任何现成的提取算法来说，从给定的表中解析数据并不容易。虽然这些工具可能有相当有效的结果，但在这种特殊情况下，我们需要额外的开发工作来满足您的要求。继续学习本教程，您将会找到解决这一挑战的有效方法。
本教程的范围
在本教程中，您将学习如何:
- 使用现成的解决方案从 PDF 中提取表格
- 使用真实的文档布局从 PDF 获取原始文本
- 使用 numpy 和 pandas 执行文本操作
更一般地说，您将了解如何在一系列数据提取任务中处理特定于上下文的数据结构。
用于表格提取的现成解决方案
为了证实上述陈述的真实性，我们将尝试使用现成的 Python 模块解析半结构化数据，专门用于从 pdf 中提取表格。最受欢迎的开箱即用算法有 camelot-py 和 tabula-py 。他们都证明了自己在许多复杂的环境中是有效的。让我们看看他们如何应对我们的挑战:
看来我们最初的选择变成了悲惨的失败！虽然 tabula-py 在检测我们的表格的网格布局方面似乎稍好一些，但它仍然提供了许多额外的工作来分割第二列中的文本，并不是说它已经完全开始了原始表格的最后一行。
关于 camelot-py 的输出，很明显，所有关于在列中插入文本的相关信息都已经完全消失了。
从现在开始，我们将继续构建我们的自定义解析算法。
使用真实的布局处理 PDF 中的原始文本
首先，我们需要一个自定义算法的基础。这应该是一个字符串输入，完全代表原始文档的布局。同样，您有相当多的选项(想想 python 模块)可供选择。在我们的教程中，我们将决定使用 pdfminer 和pdf text进行实验。以下是他们的工作成果:
看起来两个模块都产生了相当令人满意的结果，除了 pdftotext 去掉了第 5 和第 6 列之间的一些空白。
但最重要的是，在这两种情况下，我们都能够保留垂直对齐的文本块之间的可见间隔(你好，monospace 字体！)
用 numpy 和 pandas 操作文本数据
另一个好消息是，这些空格在某种程度上使您将垂直对齐的文本视为一个完整的元素，即我们的表格布局中的一列！这是一个作用中的邻近定律。如果你之前没有听说过视觉设计的格式塔理论，请参考链接。你尤其应该明白的是，邻近定律与任何物理定律都相去甚远。它只是在你的脑海中，所以每次你都必须明确地告诉计算机元素的排列应该有多接近才能有接近度。在我们的例子中，有一条宽度至少为一个空格的垂直直线就足够了，可以均匀地将列彼此分开。我们所需要的就是显示我们的自定义算法，那些空白行分隔符在哪里。
将字符串输入转换成字符矩阵
为了达到这个目的，我们将把来自 pdfminer 的字符串输出转换成一个 char 矩阵，即每个字符串元素在各自的单元格中包含空格的结构。利用下面代码块中的一些辅助函数，我们依次执行转换并搜索上述除法器:
将原始文本拆分成列
看起来我们已经准备好将输入行分割成新定义的列:
处理行中的堆叠数据
太神奇了！我们的下一步将是把那些堆叠在“悬挂”(偶数)行中的文本块向右移动，并向上移动到(⤴)与它们真正属于的相应奇数行相同的水平上。此外，我们将把第一行作为表格的标题分开，单独处理它:
将列与原始标题匹配
您是否注意到我们的表格是如何自然而一致地为额外的列(如 3–3 和 5–5)设置了双重标题？
为了进一步将所有列引用到表的原始标题，我们将执行下面的重命名技巧:我们将根据它们的父元素(最左边的元素)为所有重复条目分配新的唯一字幕(后缀)。比如一个序列[0，1，2，3，3，4 …]会变成[0，1，2，3，3_1，4 …]。
我们将对表的原始标题执行的有点类似的转换(与上一步中的数据分离)。假设您已经注意到了一个特殊的模式:所有带有堆叠文本的列的标题中都有“/”，这表示我们从数据拆分中获得的列的名称。为了将列与其标题相匹配，我们需要某种查找表，以便标题引用并执行最后的处理:
当您确切知道表格的位置时，应该将上述方法视为从基于文本的 pdf 中提取数据的专用解决方案。尽管您可以尝试采用另一种解决方案来大规模解析 pdf 中的半结构化数据。
参见 GitHub 上的完整代码。
从 GitHub 提取数据，并自动运行或调度 Python 脚本
博客的第一部分—
T 他的博客是LIVE Tableau 公共可视化自动化 ETL的一部分，分为两个部分，即:
- 从原始数据中提取数据。GitHub 用户内容的 csv 文件
- 使用 Windows 上的任务调度程序自动化 Python 脚本
1.从原始数据中提取数据。GitHub 用户内容的 csv 文件
数据来源于 https://github.com/CSSEGISandData/COVID-19 JHU CSSE GitHub 库:
import numpy as np
import pandas as pd
导入了相关的库。
df_names = ['confirmed_global', 'deaths_global', 'recovered_global']
df_list = [pd.DataFrame() for df in df_names]
df_dict = dict(zip(df_names, df_list))
因为我们需要提取 3。csv 文件，我创建了一个包含数据帧名称的列表’ df_names’ 。注意，声明的名称是根据下面解释的url_part选择的。
然后，声明一个列表’ df_list ‘来保存创建的 3 个空数据帧。注意，for df in df_names只需确认创建的空数据帧的数量=列表’ df_names '中的元素数量。
然后，使用关键字:值对创建字典’ df_dict ‘，作为’ df_names: df_list '。也就是说，每个名称都链接到具有各自位置的空数据帧。
url_part = '[https://raw.githubusercontent.com/CSSEGISandData/COVID-19/master/csse_covid_19_data/csse_covid_19_time_series/time_series_covid19_'](https://raw.githubusercontent.com/CSSEGISandData/COVID-19/master/csse_covid_19_data/csse_covid_19_time_series/time_series_covid19_')
根据需要创建 URL 部件。*以上申报的名称将成为申报的url_part的后缀。
for key, value in df_dict.items():
value = pd.read_csv(url_part+key+'.csv', parse_dates=[0])
value.rename(columns={'Province/State': 'Province_State', 'Country/Region': 'Country_Region'}, inplace=True)
dim_col = value.columns[0:4]
date_col = value.columns[4:]
value = value.melt(id_vars = dim_col, value_vars = date_col, var_name = 'Date', value_name = key)
value['Date'] = pd.to_datetime(value['Date'])
df_dict[key] = value
为了加载数据，我在上面声明的字典’ df_dict ‘中的条目中用’ for 循环’。使用 pandas read_csv函数一个接一个地输入空的数据帧，该函数从使用url_part +键(它们是各自声明的名称)+'生成的 URL 中读取数据。csv。然后，重命名列名，使其对 Python 友好。
现在有趣的部分来了——pandas
[**melt**](https://pandas.pydata.org/docs/reference/api/pandas.melt.html)函数，它发挥了魔力，使我能够为我的 Tableau 仪表板转换数据。基本上，melt函数将数据帧从宽格式转换为长格式。请参考下面的调试打印输出:
因此，melt函数将 77 个日期列从宽格式转换为长格式，这些列的标题被输入到使用value_vars = date_col, var_name = 'Date'参数创建的新列’ Date ，数字数据被输入到使用melt函数的value_name = key参数创建的新列’ confirmed_global 。
然后，将“ Date ”列数据类型更改为 datetime，并为之前声明的字典的键分配相应的加载和转换数据帧。
join_on_col = ['Province_State','Country_Region','Lat','Long','Date']df_COVID = df_dict['confirmed_global'].merge(df_dict['deaths_global'], on=join_on_col, how='outer').merge(df_dict['recovered_global'], on=join_on_col, how='outer')df_COVID.rename(columns = {'confirmed_global':'Confirmed', 'deaths_global':'Deaths', 'recovered_global':'Recovered'}, inplace = True)
现在，pandas [merge](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.merge.html)函数被用来合并 3 个不同的文件，它们共同具有’省 _ 州’、国家 _ 地区’、纬度’、经度’、日期。然后，合并的数据帧’ df_COVID '的列名被重命名。
# to fill the NaN in 'Province_State' columns with Countries name in 'Country_Region'
df_COVID['Province_State'] = np.where(df_COVID['Province_State'] == 'nan', df_COVID['Country_Region'], df_COVID['Province_State'])# to fill the NaN in last three columns
df_COVID.iloc[0:,-3:] = df_COVID.iloc[0:,-3:].fillna(0)
这最后一行代码有助于根据需要从数据帧*‘df _ COVID’*中删除 NaN 。稍后，可以使用 pandas 的to_csv 功能将该数据帧提取为. csv 文件。
但是我计划将它导出到Google Sheets——查看博客的第二部分—LIVE Tableau 公共可视化的自动化 ETL
2.使用 Windows 上的任务调度程序自动化 Python 脚本
现在我已经创建了一个. py python 脚本文件来 ETL(提取、转换和加载)数据，我意识到用于获取数据的 GitHub 存储库每天都在更新。
在寻找每天运行 python 脚本的需求时，我看到了一个博客——用任务调度器自动化你的 Python 脚本，作者是 Vincent Tatan。不过，如果你是 Linux 用户，请参考 Ratik Sharma 写的在 macOS 上用 Crontab 调度作业。
这一部分是从以前的博客中简单整理出来的:
- 创建 Windows 可执行文件。运行 Python 的 bat 文件
- 在 Windows 任务计划程序中配置任务
跑步。任务计划程序中创建的任务的 bat 文件
2.1 创建 Windows 可执行文件。运行 Python 的 bat 文件
一个 BAT 文件是一个 DOS 批处理文件用来执行 Windows 命令提示符(cmd.exe)下的命令。它包含一系列通常可能在 DOS 命令提示符下输入的行命令。 BAT 文件最常用于在 Windows 中启动程序和运行维护实用程序。资料来源:https://fileinfo.com/extension/bat
创建新的。bat 文件(例如:etl-covid-data.bat)并对其进行编辑，以如下格式编写您的命令:
***<python.exe location> <python script location>***
C:\Users\eklav\AppData\Local\Programs\Python\Python37\python.exe "C:\Users\eklav\Documents\My Tableau Repository\Datasources\COVID-DataSource\COVID-19\COVID-DataExtraction.py"
请确保您的Python37\Lib\site-packages已经安装了所有相关的库或模块。否则，在 cmd.exe 上执行pip install <module>来下载所需的依赖项。
调试:保存并运行此。双击 bat 文件。您可以在声明的命令前键入**cmd /k**。bat 档。这将在执行后保持 Windows 命令提示符(cmd.exe)窗口打开。蝙蝠文件
2.2 在 Windows 任务计划程序中配置任务
- 从’开始菜单中搜索并打开’ 任务调度器
- 单击“任务调度器”
右侧“操作”选项卡下的“ 创建基本任务… ”，声明“名称:”(例如:COVID-ETL-PyScriptRun)和“描述:’(例如:此任务将执行 COVID 实时更新所需的 python 脚本) - 任务触发 :
选择’您希望任务何时开始？'(例如:每日) - 为之前的选择声明频率参数
- 动作 :
选择’你希望任务执行什么动作？'(例如:启动程序) - 通过浏览到声明“程序/脚本:”。先前创建的 bat 文件位置。此外，您可以将“ Start in(可选):”声明到应用程序文件夹的位置，以访问相关的依赖项
- 完成 :
显示上述所有申报的’汇总。当我点击完成时，你可以勾选复选框*打开该任务的属性对话框，以发现对你的预定任务的有趣和有用的改变。当我的代码中断时，一个有帮助的编辑是——在任务属性的’ General '选项卡上，我选中了’Run with high privileges*
下面是。上述 7 个步骤的 gif 动画:
上述 7 个步骤的 GIF 动画
参考
- 关于。BAT 文件扩展名
- Vincent Tatan @ Medium 写的博客
- Python 数据帧构造器文档
感谢您的阅读！我希望这篇博客揭示了如何在 windows 上自动化 python 脚本的有趣方面。如果你觉得这有帮助或者没有帮助，请在评论中告诉我。如果这篇文章是有帮助的，分享它。
来自 JHU CSSE GitHub Repo 的 ETL 创建 Tableau 可视化。ETL: Extract 中执行的步骤。GitHub 中的 csv 文件…
github.com](https://github.com/eklavyasaxena/COVID-19) [## Eklavya Saxena -印度|职业简介| LinkedIn
精通数据的分析师和有抱负的数据科学家，拥有 2 年以上的销售或客户行业经验…
www.linkedin.com](https://www.linkedin.com/in/eklavyasaxena/)
有益的数据有益于灵魂
数据科学家如何回馈
迈克尔·阿莱奥在 Unsplash 上的照片
想象一下所有的数据…
在约翰·列侬的歌曲《想象》中，他唱到了一个没有饥饿、没有痛苦、没有贪婪的世界，在那里他想象着所有的人过着和平的生活，一个共享整个世界的人类兄弟。
想象一下这个世界上所有等待分析、可视化的数据，想象一下将要做出的预测和将要开发的算法。想象一下，通过数据驱动的决策，可以讲述哪些有见地的故事来提高对社会问题以及对人类影响的认识。
数据正以前所未有的速度被创建和增长。根据 IDC 白皮书预测，整个数字世界有望在 2025 年达到 175 兆字节。
IDC:世界的数字化——从边缘到核心
绝大多数慈善组织、非营利组织和基金会只能 想象 拥有数据和分析来影响决策和推动他们的事业。
慈善事业竞争极其激烈，捐赠者要求透明度
捐助者、赞助商和公民越来越要求公开他们的时间和资金贡献的影响。
人们期望慈善组织展示出切实的社会影响和可衡量的成果。慈善监督机构继续深入调查，并根据透明度和影响力对慈善机构进行评级。
通过降低项目、筹资和管理费用的百分比来证明财务效率已经不够了。社会影响报告使慈善机构能够传达他们对社会事业或他们所支持的人的影响。如果做得好，社会影响报告可以增进志愿者、支持者、受益者和捐助者的信任。
引人注目的故事需要用数据、分析和可视化来讲述
慈善机构面临的挑战并不仅仅是获取经过筛选的、易于获取的数据。由于他们面临着维持低运营成本的巨大压力，他们没有能力雇佣数据管理和数据科学领域的熟练员工。数据在电子表格中捕获和/或分散在各种系统中。将数据拼接在一起，使其有意义，并获得有意义的见解是耗时的，并需要正确的技能。
有许多非营利和慈善组织，如联合国难民署、T2 世界粮食计划署，已经利用数据可视化的力量讲述故事，在几秒钟内吸引观众的注意力。
“数据换好”机芯
虽然每个人都为数据的创造做出了贡献，但并不是每个人都从中受益。企业部门继续受益于以创新方式利用其数据来增加利润。
我们都需要关注三重底线——为人、地球和利润做正确的事情。
当使命驱动的组织拥有合适的人才、工具和知识时，他们可以产生切实的人类影响。
Gartner 将数据定义为“人们和组织超越组织界限，利用数据改善社会的运动”
数据科学在行动中的力量继续得到证明。
危机短信热线由儿童求助电话提供给处于危机中的年轻人免费短信服务。数据是他们的生命线，多年来，危机文本热线已经收集了世界上最大的健康数据集之一。这些数据用于推动他们的服务产品和整体危机空间的改进。
危机文本行
利用他们丰富的数据集，他们开发了一种算法，根据短信的初始内容评估短信者的自杀风险。高风险短信发送者被标记为“橙色代码”,并被移到队列的顶部，以减少他们的等待时间。更短的等待时间可以拯救更多的生命。
个人可以通过以下几种方式自愿贡献自己的时间、技能和才能，对数据产生影响。无论是在数据管理、分析、数据可视化、高级分析、机器学习还是人工智能领域，都有大量参与的机会。
通过以下组织之一做出贡献:
DataKind 由 Jake Porway 于 2011 年创立，被认为是 Data for Good 机芯的开创者。他们与社会变革组织合作，在数据科学方面进行协作，以最大限度地发挥社会影响。DataKind 通过 DataCorps、DataDives 和社区活动与全球志愿者合作。
Chloe Tseng 于 2017 年创建了一个在线数据可视化社区。Viz 与世界各地的使命驱动型组织合作，利用数据可视化的力量来影响社会变革。世界各地的志愿者使用他们选择的工具，如 Tableau 、 Power BI 、 Qlik 和 D3 来强调有助于推动组织发展的趋势和机遇。
Kaggle 是全球最大的数据科学社区，拥有强大的工具和资源。Kaggle 为在线学习和数据科学竞赛提供公共数据集。2017 年，Kaggle 推出了“数据科学为善”，并为社会事业举办在线竞赛。
数据和分析供应商通过捐赠免费软件和他们自己的专业知识来促进社会事业，从而为良好的计划提供数据支持。一些提供志愿者和非营利组织之间的在线匹配服务。
Tableau 服务团 隶属于 Tableau 基金会，Tableau 的全球慈善组织。这是一个由 Tableau 专家组成的志愿者网络，他们有兴趣帮助非营利组织完成少于 10 小时的项目。非营利组织可以在 Tableau 服务团注册，并有机会根据项目的性质和所需的技能选择志愿者。
Alteryx for Good Co-lab是一个由 Alteryx 客户、员工和合作伙伴组成的网络，他们通过合作来改变数据。专门从事 Alteryx 的志愿者可以在网上注册，并与非营利组织或教育工作者配对。在整个分析生命周期中，志愿者帮助为报告准备数据，提供关于工具的见解，培训员工或完成项目。
剪贴画库
志愿服务的惊人好处
除了支持社会事业或社区的明显好处之外，志愿服务还提供许多其他好处。优秀志愿者的数据能够提高他们的技能，学习新的工具，并与志同道合的专业人士建立联系。一些人选择利用他们的志愿工作来提升他们的职业形象和寻找新的工作机会。
分析与某项事业或慈善机构相关的数据的过程为志愿者提供了一个全新的视角，非常令人大开眼界。使用数据可以深入主题，这是讲述有意义的故事或提出可行建议所必需的。
根据 BMC 健康研究的一份报告，志愿活动改善了心理和身体健康，增加了自尊和快乐，提高了生活满意度。
如果你是数据爱好者、数据科学家或对任何数据都有热情，那么世界就在你的脚下。支持你的事业，贡献你的才能，加入运动。
你可能会说我是一个梦想家，但我不是唯一的一个。我希望有一天你会加入我们，世界将会像一个人一样生活——约翰·列侬
数据框 EDA 软件包比较:Pandas Profiling、Sweetviz 和 PandasGUI
哪些熊猫数据框 EDA 包适合你？
作者创建的 GIF
作为一名数据科学家，我们的工作总是涉及探索数据，或者通常称为探索性数据分析(EDA)。探索数据的目的是为了更好地了解我们的数据，掌握我们在处理什么。
以前，使用 pandas 数据框探索数据是一件很麻烦的事情，因为我们需要从头开始编写每一个分析。这不仅要花很多时间，还需要我们集中注意力。
以下面的 mpg 数据集为例。
import pandas as pd
import seaborn as sns
mpg = sns.load_dataset('mpg')
mpg.head()
作者创建的图像
虽然数据看起来很简单，但是探索这个数据集仍然需要很多时间。
幸运的是，在当今时代，许多伟大的人已经开发了很棒的软件包来简化 EDA 过程。这些包的例子有熊猫简介、 Sweetviz 和 PandasGUI 。
了解了许多 EDA 软件包，我很想知道它们之间是如何比较的，以及哪些软件包更适合每种情况。
让我们看看每个包是如何工作的，它们的主要特点是什么。
熊猫简介
我以前写了一篇关于熊猫概况的完整文章，但是为了比较起见，让我们从头到尾回顾一下。
将您的基本报告提升到下一个级别
towardsdatascience.com](/fantastic-pandas-data-frame-report-with-pandas-profiling-a05cde64a0e2)
对我来说，熊猫简介是三个软件包中最简单的一个。它提供了一个很好的数据集快速报告。让我们试着看看大熊猫侧写在野外是如何工作的。首先，我们需要安装软件包。
#Installing via pip
pip install -U pandas-profiling[notebook]#Enable the widget extension in Jupyter
jupyter nbextension enable --py widgetsnbextension#or if you prefer via Conda
conda env create -n pandas-profiling
conda activate pandas-profiling
conda install -c conda-forge pandas-profiling#if you prefer installing directly from the source
pip install [https://github.com/pandas-profiling/pandas-profiling/archive/master.zip](https://github.com/pandas-profiling/pandas-profiling/archive/master.zip)#in any case, if the code raise an error, it probably need permission from user. To do that, add --user in the end of the line.
在安装了必要的包之后，我们可以使用 Pandas Profiling 来生成我们的报告。
from pandas_profiling import ProfileReportprofile = ProfileReport(mpg, title='MPG Pandas Profiling Report', explorative = True)profile
熊猫简介报告(GIF 由作者创建)
正如我们在上面看到的，使用 Pandas Profiling 产生了一个快速的报告，有很好的可视化效果，便于我们理解。报告结果直接显示在我们的笔记本中，而不是在单独的文件中打开。让我们来剖析一下大熊猫特征分析给了我们什么。
作者创建的图像
Pandas Profiling 给出了六个部分— 概述、变量、交互、相关性、缺失值、和样本。
Pandas Profiling 的完整部分是变量部分，因为它们为每个变量生成了详细的报告。
作者创造的形象
从上图可以看出，仅仅是那一个变量就有这么多的信息。你可以得到描述性信息和分位数信息。
让我们看看我们能从熊猫档案中得到的其他信息。首先是交互。
作者创建的 GIF
交互作用是我们可以得到两个数值变量之间散点图的部分。
接下来是关联。在这个部分，我们可以得到两个变量之间的关系信息。目前，我们只能得到四个相关分析。
作者创建的 GIF
下一部分是缺失值。你应该已经猜到我们能从这里得到什么信息了。是的，它是每个变量的缺失值计数信息。
作者创建的 GIF
最后是样品部分。这只显示了我们数据集中的样本行。
作者创建的 GIF
这是我们从熊猫报告中能得到的粗略信息。它很简单，但为我们提供了快速重要的信息。
现在，我喜欢熊猫简介的一点是:
- 生成快速报告
- 每个变量的详细信息
虽然有些部分，我感觉不太倾向。有:
- 相当高的内存使用率
- 变量之间没有太多详细信息，只有相关性和散点图。
- 样本部分是不必要的。
对我来说，熊猫概况对于快速获得我们需要的详细信息非常有用。对于想要掌握我们在处理什么样的数据的人来说已经足够了，但是我们还需要做更详细的信息。
Sweetviz
Sweetviz 是另一个 Sweetviz 是另一个开源 Python 包，可以用一行代码生成漂亮的 EDA 报告。与 Pandas Profiling 不同的是，它的输出是一个完全独立的 HTML 应用程序。
让我们试着安装这个包并生成我们的报告。
#Installing the sweetviz package via pippip install sweetviz
安装完成后，我们可以使用 Sweetviz 生成报告。让我们使用下面的代码来尝试一下。
import sweetviz as sv#You could specify which variable in your dataset is the target for your model creation. We can specify it using the target_feat parameter.my_report = sv.analyze(mpg, target_feat ='mpg')
my_report.show_html()
作者创建的图像
从上图中可以看出，Sweetviz 报告生成的内容与之前的 Pandas Profiling 相似，但使用了不同的用户界面。让我们看看下面 GIF 中的整体 Sweetviz 报告。
作者创建的 GIF
我们知道，当你点击上面 GIF 中的变量时，每个变量都有完整的信息。不过，这些信息也可以通过熊猫档案获得。
如果您还记得以前，我们在代码中设置了目标特性(“mpg”)。这是使用 Sweetviz 的优势之一。我们可以获得关于目标特征的更详细的信息。例如，让我们关注位移变量，并查看右侧的详细报告。
作者创建的图像
我们可以从上面的图像中看到目标特征(“mpg”)和位移变量之间的关系。条形图显示位移分布，而折线图是位移变量后目标特征的平均值。如果我们想知道这两个变量之间的关系，这是一个很好的报告。
在报告的最右侧，我们得到了所有现有变量的数值关联和分类关联的相关信息。有关向我们展示的关联分析信息的更多说明，请参考 Sweetviz 主页。
现在，Sweetviz 的优势不在于针对单个数据集的 EDA 报告，而在于数据集比较。Sweetviz 的主页解释说，Sweetviz 系统是围绕快速可视化目标值和比较数据集而构建的。
有两种方法可以比较数据集；要么我们分割它，比如训练和测试数据集，要么我们用一些过滤器子集化群体。要试用，让我们试试子集化数据。
我想知道当我的数据集是美国汽车的数据与非美国汽车的数据相比有多大的不同。我们可以用下面一行生成报告。
#Subsetting are happen by using the compare_intra. We input the condition in the parameter and the name as well.my_report = sv.compare_intra(mpg, mpg["origin"] == "usa", ["USA", "NOT-USA"], target_feat ='mpg')my_report.show_html()
作者创建的 GIF
从上面的 GIF 可以看出，我们现在比较美国子集数据和非美国子集数据。对我来说，这种报告比较是如此强大，因为我们可以获得人口之间的信息，而不用编码这么多。
让我们更仔细地检查变量。
作者创建的 GIF
从上面的 GIF 中，我们可以了解到，变量被用两种不同颜色(蓝色和橙色)表示的两个子集总体划分。让我们再来看看位移变量。
作者创建的图像
我们可以看到，非美国(橙色)排水量远小于美国排水量。这是我们可以通过比较两个数据集立即得到的信息。
协会怎么样？我们可以通过使用数据集名称上的关联按钮来仔细查看关联。
作者创建的图像
作者创建的 GIF
从上面的 GIF 中，我们可以很容易地得到两个变量之间的关系信息。请参考主页以获得对关联分析的完整理解。
所以，我喜欢 Sweetviz 的是:
- 视觉效果不错
- 易于理解的统计信息
- 分析与目标值相关的数据集的能力
- 两个数据集之间的比较能力
对我来说，就数据集和变量比较而言，Sweetviz 是一个比分析熊猫更高级的包。有几件事我对没什么感觉，那就是:
- 变量之间没有可视化，如散点图
- 该报表将在另一个选项卡中打开
虽然我感觉这些东西一点都不差，但是实力，我猜，盖过了弱点。
在我看来，Sweetviz 非常适合用于旨在创建预测模型的比较分析或数据集，因为 Sweetviz 的优势就在这些问题上。
PandasGUI
PandasGUI 不同于我上面解释的前几个包。 PandasGUI 没有生成报告，而是生成了一个 GUI(图形用户界面)数据框，我们可以用它来更详细地分析我们的 Pandas 数据框。
让我们试试这个包裹。首先，我们需要安装 PandasGUI 包。
#Installing via pippip install pandasgui#or if you prefer directly from the sourcepip install git+https://github.com/adamerose/pandasgui.git
安装完成后，让我们看看 PandasGUI 能做什么。要生成数据框 GUI，我们需要运行以下代码。
from pandasgui import show#Deploy the GUI of the mpg dataset
gui = show(mpg)
就像那样，GUI 应该单独显示出来。
作者创建的图像
在这个 GUI 中，您可以做一些事情。主要是过滤，统计 信息，创建变量之间的图，以及重塑你的数据。
作为提醒，您实际上可以根据需要拖动标签。看看下面的 GIF 就知道了。
作者创建的 GIF
现在，让我们仔细看看每个特性，从过滤数据开始。
作者创建的 GIF
使用 PandasGUI 过滤数据需要我们查询条件，就像我们在 Pandas 数据框中写入它一样。看一下上面的例子；我编写“72 年模型”查询。结果是带有勾选框的查询。在这种情况下，如果我们不想再用预期的条件过滤数据，我们需要取消选中该框。
如果您在编写查询时出错了，该怎么办？这很容易；您需要双击您的查询并重写它。就这么简单。
现在，让我们来看看统计选项卡。
作者创建的 GIF
如果我们将从这个 GUI 获得的统计信息与前一个包进行比较，我们在这里获得的信息要比其他两个包少得多。尽管如此，这个选项卡向我们显示了数据集的基本信息。
提醒一下，我们之前所做的任何筛选都会在您在另一个选项卡中进行的下一个活动中出现，所以不要勾选任何您认为不必要的筛选。
从统计开始，我们现在进入图表生成器标签或者绘图 GUI。对我来说，PandasGUI 的优势就在这个标签上。让我告诉你这是为什么。
作者创建的 GIF
从上面的 GIF 中我们可以看到，创建 plot 只是拖拽我们想要的一切。由于绘图资源依赖于 plotly 包，我们可以通过将光标悬停在图形上来浏览图形。
最后，可用的标签是整形标签。在这个选项卡中，我们可以通过创建一个新的数据透视表来重塑或者融化数据集。
pivot 和 melt 函数会产生一个新的表格，如下图所示。
作者创建的图像
作为附加信息，您可以将过滤或整形后的数据导入到新的 CSV 中。您需要从编辑下拉列表中单击导入选择。
如果要将新的 CSV 文件导出到 PandasGUI，也可以单击下图所示的导出选项。
作者创建的图像
现在，我喜欢 PandasGUI 的什么地方:
- 拖放的能力
- 轻松过滤查询选择
- 快速剧情创作
虽然，我现在有一些低谷，那就是:
- 我们能得到的统计信息很少
- 没有生成自动报告。
在我看来，PandasGUI 是一个很棒的包，尤其是对于喜欢用自己的方式分析数据的人来说。毕竟，这个软件包适合进行深入分析。
我认为 PandasGUI 的目的更多的是我们自己的探索，而不是自动生成报告。然而，它仍然可以与前两个包相媲美，因为这些包在 EDA 过程中对我们有所帮助。
结论
Pandas Profiling、Sweetviz 和 PandasGUI 是为简化 EDA 处理而开发的令人惊叹的软件包。在不同的工作流程中，每个包都有自己的优势和适用性。如果我需要总结我的比较，那就是:
- Pandas Profiling 适合对单个变量进行快速分析生成，
- Sweetviz 适用于数据集和目标特征之间的分析，
- PandasGUI 适用于具有手动拖放功能的深入分析。
那是我对这三个 EDA 包的比较；我不会推荐什么适合你的工作，因为只有你自己知道。
如果你想了解更多关于我对其他 EDA 包的评论，你可以看看下面的文章。
通过基于一行建议的数据探索，轻松探索您的数据
towardsdatascience.com](/quick-recommendation-based-data-exploration-with-lux-f4d0ccb68133)
如果您喜欢我的内容，并希望获得更多关于数据或数据科学家日常生活的深入知识，请考虑在此订阅我的简讯。
如果您没有订阅为中等会员，请考虑通过我的介绍订阅。
Python 中的数据分组
检查“困难”的任务，并尝试给出替代的解决方案
按列对记录进行分组是数据分析的常见需求。这样的场景包括统计公司各个部门的员工，分别计算各个部门男女员工的平均工资，计算不同年龄段员工的平均工资。熊猫有分组功能，可以方便地处理大部分分组任务。但是该职能部门发现有些任务很难管理。在这里，让我们检查这些“困难”的任务，并尝试给出替代的解决方案。
分组是熊猫最重要的功能之一。它用于根据拆分-应用-组合策略对记录进行分组和汇总。下图显示了工作流程:
作者图片
I .按单个字段分组和聚合
您按特定字段对记录进行分组，然后对每个组执行聚合。
这是上述策略最简单的用法。例如，根据员工信息计算每个部门的员工数:
问题分析:以 department 为关键字，按其对记录进行分组，统计每组中的记录。
以下是部分员工信息:
Python 脚本:
import pandas as pd#Import data
employee = pd.read_csv("Employees.csv")#Grouping and perform count over each group
dept_emp_num = employee.groupby('DEPT')['DEPT'].count()print(dept_emp_num)
解释:groupby('DEPT ')按部门对记录进行分组，count()计算每组中的雇员数。
II 按多个字段分组和聚合
您按多个字段对记录进行分组，然后对每个组执行聚合。
我们以类似的方式处理它。根据前一个实例中相同的员工信息计算每个部门中男性和女性员工的平均工资。
问题分析:分组键有两个，部门和性别。我们将组合键作为一个整体来进行分组和聚合。
Python 脚本:
import pandas as pdemployee = pd.read_csv("Employees.csv")#Group by two keys and then summarize each group
dept_gender_salary = employee.groupby(['DEPT','GENDER'],as_index=False).SALARY.mean()print(dept_gender_salary)
解释:表达式 groupby([‘DEPT ‘，’ GENDER’])将两个分组字段作为列表形式的参数。表达式 as_index 使用 True 或 False 指定是否将分组字段用作索引(这里 False 表示不将它们用作索引)。mean()函数计算平均工资。
III 按计算列分组和聚合
分组键不是显式数据，需要根据已有数据进行计算。这样的键称为计算列。例如，要计算不同年份员工的平均工资:
问题分析:员工信息中没有年份一栏。我们需要根据员工的生日来计算，按计算列对记录进行分组，并计算平均工资。
Python 脚本:
import pandas as pdimport numpy as npemployee = pd.read_csv("Employees.csv")#Convert the BIRTHDAY column into date format
employee['BIRTHDAY']=pd.to_datetime(employee['BIRTHDAY'])#Calculate an array of calculated column values, group records by them, and calculate the average salary
years_salary = employee.groupby(np.floor((employee['BIRTHDAY'].dt.year-1900)/10)).SALARY.mean()print(years_salary)
说明:由于原始数据中不存在年值，Python 使用 NP . floor((employee[’ BIRTHDAY ']. dt . year-1900)/10)来计算年列，按新列对记录进行分组，并计算平均工资。
四多重集合
您可以对多列中的每一列执行一种类型的聚合操作，或者对一列或多列执行几种类型的聚合操作。
1.多列中的每一列都有一个聚合
对多列中的每一列执行一种类型的聚合。计算每个部门的雇员数和平均工资，例如:
问题分析:count 聚合在 EID 列上，average 聚合在 salary 列上。每个列都有自己的一个聚合。
Python 脚本:
import pandas as pdemployee = pd.read_csv("Employees.csv")#Group records by DEPT, perform count on EID and average on SALARY
dept_agg = employee.groupby('DEPT',as_index=False).agg({'EID':'count','SALARY':'mean'})#Rename the columns
print(dept_agg.rename(columns={'EID':'NUM','SALARY':'AVG_SALARY'}))
解释:Pandas agg()函数可以用来处理这类计算任务。相关的列和涉及的聚合操作以字典的形式传递给函数，其中列是键，聚合是值，以完成聚合。
2.一根色谱柱上的多种聚合
您在单个列上执行多种类型的聚合。对于之前的任务，我们也可以把工资加起来，然后算出平均值。这样，我们在 salary 列上执行两个聚合，count 和 average。
Python 脚本:
import pandas as pdemployee = pd.read_csv("Employees.csv")#Perform count and then average on SALARY column
dept_agg = employee.groupby('DEPT').SALARY.agg(['count','mean']).reset_index()#Rename columns
print(dept_agg.rename(columns={'count':'NUM','mean':'AVG_SALARY'}))
说明:我们可以把聚合操作组合成一个列表，并把它作为参数传递给 agg()函数。
3.多个色谱柱上的多个聚合
您汇总了多个列，在此期间，单个列上有多个聚合。聚合操作可以由用户定义。
以获取每个部门的员工人数、平均工资和最大年龄为例:
问题分析:统计员工人数，计算平均工资，都是对工资列(一列多个合计)的操作。查找最大年龄需要对生日列进行自定义操作。
Python 脚本:
import pandas as pdimport datetime#The user-defined function for getting the largest age
def max_age(s):
#Year
today = datetime. datetime.today().year
#Get ages
age = today-s.dt.year return age.max()employee = pd.read_csv("Employees.csv")employee['BIRTHDAY']=pd.to_datetime(employee\['BIRTHDAY'\])#Group records by DEPT, perform count and average on SALARY, and use the user-defined max_age function to get the largest age
dept_agg = employee.groupby('DEPT').agg({'SALARY':['count','mean'],'BIRTHDAY':max_age})#Rename columns
dept_agg.columns = ['NUM','AVG_SALARY','MAX_AGE']print(dept_agg.reset_index())
说明:要汇总的列和聚合操作以字典的形式通过参数传递给函数。对于需要多个聚合操作的列，我们需要将这些操作组合成一个列表，用作字典值。
复制分组和汇总结果
您可以将每个聚合结果扩展到相应组的长度。这相当于将聚合结果复制到其组中的所有行。向员工信息中添加包含每个部门平均工资的新列，例如:
问题分析:按部门对记录进行分组，计算每个部门的平均工资，在保持原有顺序的情况下，将每个平均值填充到相应的组中。
Python 脚本:
import pandas as pdemployee = pd.read_csv("Employees.csv")#Group records by DEPT and calculate average on SLARYemployee['AVG_SALARY'] = employee.groupby('DEPT').SALARY.transform('mean')print(employee)
说明:按部门对记录进行分组，并计算每组的平均工资。transform()函数计算每个组的聚合，返回结果并按照原始索引的顺序将其填充到所有行中。这确保了记录保持原始顺序。
VI 处理分组子集
您可以在每个组中执行一个或多个非聚合操作。例如，为了对每个组进行排序，我们关心的是记录的顺序，而不是集合。要按聘用日期以升序对每个部门的记录进行排序，例如:
问题分析:按部门对记录进行分组，并在每个组中循环，按雇用日期对记录进行排序。
Python 脚本:
import pandas as pdemployee = pd.read_csv("Employees.csv")#Modify hire date format
employee['HIREDATE']=pd.to_datetime(employee['HIREDATE'])#Group records by DEPT, sort each group by HIREDATE, and reset the index
employee_new = employee.groupby('DEPT',as_index=False).apply(lambda x:x.sort_values('HIREDATE')).reset_index(drop=True)print(employee_new)
说明:要对每个组中的记录进行排序，我们可以使用 apply()函数和 lambda 的组合。lambda 表达式通过组进行循环，使用 sort_values()函数对每个组中的记录进行排序，并返回排序结果。
还有更复杂的计算目标。例如，要找出每个部门中年龄最大的员工和年龄最小的员工之间的工资差异:
问题分析:将记录按部门分组，定位最年长的员工记录和最年轻的员工记录，计算他们的工资差异。
Python 脚本:
import pandas as pd#salary_diff(g)function calculates the salary difference over each group
def salary_diff(g):
#The index of the eldest employee record
max_age = g['BIRTHDAY'].idxmin() #The index of the youngest employee record
min_age = g['BIRTHDAY'].idxmax() #Calculate the salary difference
diff = g.loc[max_age]['SALARY']-g.loc[min_age]['SALARY'] return diffemployee = pd.read_csv("Employees.csv")employee['BIRTHDAY']=pd.to_datetime(employee['BIRTHDAY'])#Group by DEPT and use a user-defined function to get the salary difference
salary_diff = employee.groupby('DEPT').apply(salary_diff)print(salary_diff)
解释:该脚本使用 apply()和一个用户定义的函数来获取目标。apply()将分组结果作为参数传递给用户定义的函数。自定义函数 salary_diff()中的参数 g 本质上是熊猫 data frame 格式的一个数据帧，这里是分组结果。该脚本通过参数获取最老员工记录的索引和最年轻员工记录的索引，然后计算 salary 字段的差异。
概要:
掌握 Pandas groupby 方法对处理数据分析任务特别有帮助。
让我们进一步看看 Pandas groupby 的使用，尽管现实世界中的问题来自堆栈溢出。
VII 基于职位的分组
您按位置对记录进行分组，也就是说，使用位置作为键，而不是按某个字段。这种情况包括将每三行放入同一组，并将奇数位置的行放入一组，偶数位置的行放入另一组。下面是一个例子:
来源:https://stack overflow . com/questions/59110612/pandas-group by-mode-every-n-rows
以下是部分源数据:
time a b
0 0.5 -2.0
1 0.5 -2.0
2 0.1 -1.0
3 0.1 -1.0
4 0.1 -1.0
5 0.5 -1.0
6 0.5 -1.0
7 0.5 -3.0
8 0.5 -1.0
我们希望每隔三行对数据进行分组和组合，并保持每组中每列的模式。预期结果如下:
time a b
2 0.5 -2.0
5 0.1 -1.0
8 0.5 -1.0
问题分析:这个分组任务与列值无关，但涉及位置。我们通过位置执行整数乘法来获得一个计算列，并将其用作分组条件。
Python 脚本:
import pandas as pdimport numpy as npdata = pd.read_csv("group3.txt",sep='\\t')#Group records by the calculated column, calculate modes through the cooperation of agg function and lambda, and get the last mode of each column to be used as the final value in each groupres = data.groupby(np.arange(len(data))//3).agg(lambda x: x.mode().iloc[-1])print(res)
说明:表达式 NP . arange(len(data))//3 生成一个计算列，其值为[0 0 1 1 1 2 2]。该脚本使用它作为每三行对数据进行分组的键。表达式 agg(lambda x: x.mode())从每个组中的每一列获取模式。在第一组中，时间列中的模式是[0，1，2]，a 和 b 列中的模式分别是[0.5]和[-2.0]。然后，该脚本使用 iloc[-1]来获取它们的最后模式，以用作最终的列值。
VIII 按变化值分组
您可以根据特定字段中的值是否更改来对有序数据进行分组。也就是说，每次出现新值时，都会创建一个新组。这里有一个例子:
来源:https://stack overflow . com/questions/41620920/group by-conditional-sum-of-adjacent-rows-pandas
以下是部分原始数据:
duration location user
0 10 house A
1 5 house A
2 5 gym A
3 4 gym B
4 10 shop B
5 4 gym B
6 6 gym B
数据按用户分组后，对位置值连续相同的持续时间值求和，并在位置值改变时对持续时间执行下一次求和。以下是预期结果:
duration location user
15 house A
5 gym A
4 gym B
10 shop B
10 gym B
问题分析:订单是为位置列导入的。具有连续相同位置值的记录被放入同一个组，一旦值改变，一个记录被放入另一个组。当用户为 B 时，第 4 行(其索引为 3)中的位置值为[健身房、商店、健身房、健身房]。这里我们不应该把三个健身房放在一个组里，而应该把第一个健身房放在一个单独的组里，因为第一个健身房之后的位置值是商店，这是一个不同的值。商店应该另设一个小组。然后，其他两个健身房应该在同一组，因为他们一直是相同的。所以用户 B 的分组结果应该是[[健身房]，[商店]，[健身房，健身房]]。这就是为什么我们不能用 df.groupby([‘user ‘，’ location’]).duration.sum()来得到结果。相反，我们需要一个计算列作为分组条件。
他们的 Python 脚本:
import pandas as pd#Generate data for computation
df = pd.DataFrame({'user' : ['A', 'A', 'A', 'B', 'B', 'B','B'], 'location' : ['house','house','gym','gym','shop','gym','gym'], 'duration':[10,5,5,4,10,4,6]})#Create a calculated column
derive = (df.location != df.location.shift()).cumsum()#Group records by user, location and the calculated column, and then sum duration values
res = df.groupby(['user', 'location', derive], as_index=False, sort=False)['duration'].sum()print(res)
解释:计算列 derive 通过在每次位置值发生变化之前累计位置值来获取其值。累积值为[1 1 2 2 3 4 4]。然后按用户、位置和计算出的数组对原始数据进行分组，并对持续时间进行求和。
IX 按条件分组
当对有序数据进行分组时，只要某个字段的值满足指定的条件，就会创建一个新组。下面是一个例子:
来源:https://stack overflow . com/questions/62461647/choose-random-rows-in-pandas-data fram
以下是部分原始数据:
ID code
333_c_132 x
333_c_132 n06
333_c_132 n36
333_c_132 n60
333_c_132 n72
333_c_132 n84
333_c_132 n96
333_c_132 n108
333_c_132 n120
999_c_133 x
999_c_133 n06
999_c_133 n12
999_c_133 n24
998_c_134 x
998_c_134 n06
998_c_134 n12
998_c_134 n18
998_c_134 n36
997_c_135 x
997_c_135 n06
997_c_135 n12
997_c_135 n24
997_c_135 n36
996_c_136 x
996_c_136 n06
996_c_136 n12
996_c_136 n18
996_c_136 n24
996_c_136 n36
995_c_137 x
我们希望在代码列中的每两个 x 值之间得到一个随机行。
预期结果如下:
333_c_132 n06
999_c_133 n12
998_c_134 n18
997_c_135 n36
996_c_136 n18
问题分析:从两个 x 值中随机获取一行，我们可以根据代码值是否为 x 对行进行分组(即每当代码值变为 x 时创建一个新组)，从当前组中随机获取一行。所以我们仍然需要一个计算列作为分组键。
Python 脚本:
import pandas as pddf = pd.read_csv("data.txt")#Generate a calculated column
derive = df.code.eq('x').cumsum()#Group records by the calculated column and get a random record from each groupthrough the cooperation of apply function and lambda
res=df[df.code.ne('x')].groupby(derive).apply(lambda x : x.sample(1))#Reset the index
res=res.reset_index(level=0, drop=True)print(res)
解释:code.eq(x)当 code 为 x 时返回 True，当 code 不是 x 时返回 False，cumsum()累加真值和假值的个数，生成计算列[1 1 1 1 1 1 1 1 1 2 2…]。然后，该脚本查找 code 为 x 的记录，根据这些 x 值对记录进行分组，并从每个组中获得一个随机记录。
概要:
在上述所有例子中，原始数据集根据指定的条件被分成若干子集，并具有以下两个特征:
1)没有子集是空的；
2)原始数据集中的每个成员属于且只属于一个子集。
我们称这种类型的分组为全分。也有偏科的。
以下是一些例子。
x 对齐分组
路线编组有一个基础集。它将待分组集合的成员的属性(字段或表达式)与基本集合的成员进行比较，并将与基本集合的成员匹配的成员放入同一子集中。子集的数量与基本集中的成员数量相同。路线分组有三个特征:
1)可能存在空的子集(例如，基本集合的一个或多个成员不存在于要分组的集合中)；
2)可能存在未被放入任何组的待分组集合的成员(例如，它们并不重要到包括在基本集合中)；
3)待分组集合中的每个成员最多属于一个子集。
1.空子集
一家公司想知道每个部门员工的准确人数。如果一个部门没有男性员工或女性员工，它会将他们的人数记录为 0。
问题分析:如果我们直接按部门和性别分组数据，也就是 groupby([‘DEPT ‘，’ GENDER’])，那么一个部门中没有女性员工或者男性员工的员工都会被放到一个组中，缺失性别的信息就会缺失。很容易想到一个替代方案。该解决方案按部门对记录进行分组，生成一个[男性，女性]基集以左连接每个组，按性别对每个连接结果进行分组，然后计算男性和女性员工的数量。这将确保每个小组都包括女性雇员和男性雇员。
Python 脚本:
import pandas as pd#Alignment grouping function
def align_group(g,l,by):
#Generate the base dataframe set and use merge function to perform the alignment grouping
d = pd.DataFrame(l,columns=[by]) m = pd.merge(d,g,on=by,how='left')return m.groupby(by,sort=False)employee = pd.read_csv("Employees.csv")#Define a sequence
l = ['M','F']#Group records by DEPT, perform alignment grouping on each group, and perform count on EID in each subgroupres = employee.groupby('DEPT').apply(lambda x:align_group(x,l,'GENDER').apply(lambda s:s.EID.count()))print(res)
解释:
用户自定义函数 align _ groupuses 使用 merge()函数生成基集，并对基集和要分组的集执行左连接，然后按合并列对每个连接结果集进行分组。记录按部门分组后，apply()函数和 lambda 表达式的配合通过自定义函数对每组进行对齐分组，然后对 EID 列进行计数。(注意:您不应该对性别执行计数，因为在合并操作期间，所有性别成员都会保留。当有一个空的子集时，对性别计数的结果将是 1，而其余的列在左连接时将被记录为 null。这将导致 EID 计数的结果为零)。
2.未放入任何组的待分组集合的成员
任务是按指定的部门[‘管理’，‘人力资源’，‘营销’，‘销售’]对记录进行分组，计算它们的员工数，并按指定的部门顺序返回结果。
问题分析:我们可以使用 left join 过滤掉未包含在指定部门集合中的记录。
Python 脚本:
import pandas as pd#Alignment grouping function
def align_group(g,l,by): d = pd.DataFrame(l,columns=[by]) m = pd.merge(d,g,on=by,how='left') return m.groupby(by,sort=False)employee = pd.read_csv("Employees.csv")#The specified subset of departments
sub_dept = ['Administration', 'HR', 'Marketing', 'Sales']#Use the alignment function to group records and perform count on EID
res = align_group(employee,sub_dept,'DEPT').apply(lambda x:x.EID.count())print(res)
说明:Pandas 并不直接支持对齐分组功能，所以实现起来比较迂回。此外，使用合并函数会导致性能下降。
XI 计数分组
枚举分组指定一组条件，通过将待分组集合的每个成员作为参数传递给它们来计算条件，并将使条件为真的记录放入同一子集中。结果集中的子集和指定的条件有一对一的关系。枚举分组的一个特点是，要分组的集合中的成员可以放入多个子集中。
这里有一个例子
任务是根据雇佣期限对员工进行分组，雇佣期限为[雇佣期限<5 years, 5 years<= employment duration<10 years, employment duration> =10 年，雇佣期限> =15 年]，并统计每组中的女性和男性员工(列出每个枚举条件的所有符合条件的员工记录，即使他们也满足其他条件)。
问题分析:列举条件任职年限> =10 年和任职年限> =15 年有重叠期间。在公司工作了至少 15 年的员工也符合另一个条件。计算列不支持将一条记录放入多个组中。我们需要遍历所有条件，为每个条件搜索符合条件的记录，然后执行计数。
import pandas as pdimport datetime#The function for converting strings into expressions
def eval_g(dd:dict,ss:str): return eval(ss,dd) emp_file = 'E:\\txt\\employee.txt'emp_info = pd.read_csv(emp_file,sep='\\t')employed_list = ['Within five years','Five to ten years','More than ten years','Over fifteen years']#Grouping conditions
employed_str_list = ["(s<5)","(s>=5) & (s<10)","(s>=10)","(s>=15)"]today = datetime.datetime.today().yeararr = pd.to_datetime(emp_info['HIREDATE'])#Calculate employment durations
employed = today-arr.dt.yearemp_info['EMPLOYED']=employeddd = {'s':emp_info['EMPLOYED']}group_cond = []#Loop through grouping conditionsfor n in range(len(employed_str_list)): #Group records by conditions
emp_g = emp_info.groupby(eval_g(dd,employed_str_list[n])) #Grouping indexes
emp_g_index = [index for index in emp_g.size().index] #If there are not eligible records Then the number of female or male employees are 0 if True not in emp_g_index: female_emp=0 male_emp=0
#If there are records meeting the current condition Then create a group for them And count the female and male employees else: group = emp_g.get_group(True) sum_emp = len(group) female_emp = len(group[group['GENDER']=='F']) male_emp = sum_emp-female_emp group_cond.append([employed_list[n],male_emp,female_emp])#Summarize the count results for all conditionsgroup_df = pd.DataFrame(group_cond,columns=['EMPLOYED','MALE','FEMALE'])print(group_df)
说明:已雇佣是根据雇佣日期列新计算的雇佣期限列。用户定义的函数 eval_g()将枚举条件转换为表达式。列举条件<5, for instance, is equivalent to the eval_g(dd,ss) expression emp_info[‘EMPLOYED’]<5. The new calculated column value will then be used to group the records. The script loops through the conditions to divide records into two groups according to the calculated column. get_group(True) gets eligible groups. Finally the script uses concat() function to concatenate all eligible groups.
汇总
Python 可以优雅地处理大多数分组任务。在处理基于顺序的分组任务时，它需要生成一个满足分组条件的计算列，例如按更改的值/条件分组。有点复杂。当面对排列分组和枚举分组任务时，它变得很尴尬，因为它需要采取非常迂回的方式，例如使用合并操作和多重分组。那很费时间和精力。熊猫在处理分组任务方面仍有弱点
esProc SPL 巧妙地处理分组任务。esProc 是专门的数据计算引擎。它所基于的语言 SPL 提供了丰富的分组函数，以更加一致的代码风格方便地处理分组计算。
两个 esProc 分组函数 group()和 group()用于实现按组聚合和子集处理。他们能够以简洁的方式处理上述六个简单的分组问题:
Python 在处理它们时也很方便，但通过涉及许多其他函数，包括 agg、transform、apply、lambda 表达式和用户定义的函数，它具有不同的编码风格。SPL 以组的形式采取一致的编码风格(x；y)和组(x)。(y)。
Python 脚本在处理以下三个涉及计算列的问题时有点复杂。基于有序集的 SPL 通过提供处理基于有序的分组任务的选项，能够保持优雅的编码风格
根据是需要分组后聚合还是希望进一步处理每个子集中的数据，可以选择使用组或组函数来处理分组和聚合任务。
Python 在通过使用合并函数和多重分组操作来管理最后两个类型组任务(对齐分组和枚举分组)时确实有些笨拙。SPL 有专门的对齐分组函数 align()和枚举分组函数 enum()，以保持其优雅的编码风格。
Python 的致命弱点是对大数据分组的处理(数据放不进内存)。该语言需要外部存储读/写和哈希分组。对于一个非专业程序员来说，用 Python 来完成几乎是不可能的。阅读Python 如何处理大文件了解更多信息。
那篇文章指出了 Python 在计算大数据(包括大数据分组)方面的问题，并介绍了 esProc SPL 的游标机制。该机制提供了 group 函数和 groupx()函数，以优雅的方式处理大数据计算。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
