TowardsDataScience-博客中文翻译-2016-2018-二百三十五-TowardsDataScience

TowardsDataScience 博客中文翻译 2016~2018（二百三十五）

原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

在 Excel 中提取股票数据并创建高效的前沿

原文：towardsdatascience.com/pulling-sto…

我在之前的一篇文章中提到了如何从 Google Finance 获得(几乎)实时股票数据。然而，如果你开始从不同的市场提取数据，每日历史汇率将没有意义，因为不同的市场在不同的日子休市。这在试图弄清楚股票之间的相关性时会产生问题。解决这个问题的一个办法是拉每月的利率，因为每个月调整后的股票价格将是一个更好的相关性指标。

Python 有一个很棒的库，叫做 pandas_datareader ，它允许你将历史信息拉入 pandas 数据帧。唯一的缺点是，如果一个 API 被否决，你的代码会崩溃。因此，我选择使用雅虎财经的历史数据下载功能来创建这个教程。本文的目标是提取大量全球历史数据(超过 20 年的价值)，然后使用现代投资组合理论(均值方差优化)创建一个有效的前沿。有效边界有助于根据给定的风险承受能力和预期回报来决定投资组合中的资产配置。

概观

投资组合优化的目标是获取给定风险容忍度下的年化预期回报。回报与权重组合(资产配置)相关联，以帮助决定投资策略。在这种分析中将使用的优化策略是现代投资组合理论(Markowitz，1952)，通常称为均值方差优化(MVO)，由 Harry Markowitz 于 1952 年提出。MVO 模型只考虑历史结果，因此仅限于此。它将无法考虑其他可能影响模型的因素，如“观点”或对未来市场预测的洞察力。一个更强大的模型，可以纳入未来的优化是布莱克-利特曼模型(布莱克&利特曼，1992 年)，通过引入用户输入的具体意见，对市场回报的资产配置过程。

数据收集

在这篇文章中，我将通过一个 excel 工作簿来指导你，这样你就可以准确地理解发生了什么。如果你愿意，你可以在这里下载 excel 工作簿。

为了避免高昂的主动管理成本，我选择使用指数基金作为优化的精选资产。市场指数拥有最长的股票信息历史，不会有单个公司股票的风险。历史上，市场一直在增长，通过使用市场指数，预期回报将处于市场平均水平，这远远好于年复一年地试图跑赢市场。此外，指数有助于在地理位置和资产类型方面提供更大的风险敞口。选择以下指数进行优化(表 1)。

[Excel Workbook sheet: Names]

Table 1. Breakdown of assets chosen for optimization

由于投资者将是加拿大人，我着眼于三个不同地区的地理前景:加拿大、美国和国际。此外，根据资产类型，选择了股票、固定收益和商品的混合。

由于优化将着眼于未来 30 年以上，收集的数据越多越好。数据收集自 1996 年 7 月 1 日至 2018 年 3 月 1 日，涵盖约 22 年的数据。这是一种权衡，要么获取更多年的数据，要么排除固定收益基金，因为这些资产的可用数据有限。为了避免由于世界各地不同的市场关闭而导致数据收集日期不一致，收集了每月数据。这一时间框架涵盖了一些市场崩溃，包括 1997 年的亚洲金融危机(迈克尔和约翰，未注明日期)，2000 年至 2002 年的互联网崩溃(贝蒂，市场崩溃:互联网崩溃(2000 年至 2002 年)，以及 2007 年至 2009 年的房地产泡沫/信贷危机(贝蒂，市场崩溃:房地产泡沫和信贷危机(2007 年至 2009 年)，未注明日期)。

调整后的月度收盘价来自雅虎财经(历史股票数据)，通过应用过滤器从以下参数中提取:

时间段:1996 年 7 月 1 日—2018 年 3 月 1 日
显示:历史价格
频率:每月

每项资产的数据以指数各自的货币形式收集，并输出到 csv 文件中。不需要货币转换，因为百分比回报是为退货计算的。

How to pull historical stock data from Yahoo Finance

优化过程

月度回报

[Excel Workbook sheet: Adjusted Closing]

调整后的收盘价取自每个指数，然后整理成表格。

[Excel Workbook sheet: Returns]

在那之后，月度回报以百分比的形式计算，即从当月的收盘价中减去上月的收盘价，然后除以上月的收盘价。

R i =(收盘价 i-收盘价 i-1) /收盘价 i-1

取所有回报的平均值，得到每项资产的平均月回报。然后将这些平均值乘以 12，得到年平均回报率。

协方差和标准差

[Excel Workbook sheet: Cov-STD-Cor]

通过将每个资产与所有其他相应的资产进行比较来创建协方差矩阵。该矩阵对于理解每项资产的风险及其与其他资产的关系至关重要。

每项资产的标准差是通过查看月度回报得出的。然后用它来计算相关矩阵。

该公式的上半部分是 excel 工作簿中的协方差矩阵，下半部分是 D 矩阵。将这两者相除，就得到了相关矩阵。

相互关系

相关性对于理解两个资产有多相似很重要。相关性越高，它们就越有可能向同一方向移动。负相关意味着如果一种资产上升，另一种资产就会下降，反之亦然。

不出所料，资产与自身有 100%的相关性。此外，S&P500 (GSPC)与道琼斯工业股票交易所(DJI)的相关度为 95%。这很直观，因为两个指数之间有很多重叠。另一个有趣的发现是，美国国债与公司债券指数高度负相关。

效率限界

[Excel Workbook sheet: Efficient Frontier]

为了创建一个有效的边界，期望收益 E(R p)最大化，同时将标准差σ p 限制在特定值。每个资产 I 的权重是 w i。相关系数ρ ij 是资产 I 和 j 之间的相关性。

在我们做任何事情之前，重要的是要记住每年的预期收益和标准差。因为我们采用了月收盘价，所以将它们乘以 12，如工作表中单元格 A2 所示。

Excel 的求解器插件用于计算这些最大值。如果您尚未在中添加规划求解，请转到文件->选项->加载项->管理:Excel 加载项转到->单击规划求解加载项，然后选择确定。如果操作正确，现在应该可以在 excel 的数据窗格中看到规划求解选项。

每项资产的权重被限制为正值，以避免卖空，上限为 20%，以确保多样化。针对投资组合(STD_P)的标准差的多个不同迭代运行求解器，以获得有效边界的不同点。在大约 15 个场景之后，投资组合的预期收益(E(R_P))被绘制成相对于 STD_P 的图，从而得到你的有效边界。为了确保你得到一个好的边界，确保你最大化预期收益，但也最小化它。当然你只会关心最大预期收益，因为你为什么想要更少的钱？

正如预期的那样，回报率较高的投资组合全部是风险较高的股票，风险最小的投资组合在固定收益资产中的权重较大。

风险最小的最佳点是年预期收益率为 4.55%，投资组合由以下资产组成:

Optimal point with minimal risk is an annual Expected Return of 4.55%

引用的作品

贝蒂(未注明日期)。市场崩溃:房地产泡沫和信贷危机(2007-2009)。从 Investopedia 检索到:【www.investopedia.com/features/cr…

贝蒂(未注明日期)。市场崩盘:互联网崩盘(2000 年至 2002 年)。从 Investopedia 检索:www.investopedia.com/features/cr…

布莱克，f .和利特曼，R. (1992 年)。全球投资组合优化。财务分析期刊，28–43 页。

历史库存数据。(未注明)。检索 2017 年 03 月 16 日，来自雅虎财经:finance.yahoo.com/quote/%5EN2…

马尔科维茨(1952 年)。投资组合选择。金融杂志，77–91。

免责声明— 本文内容仅供参考。这不是买卖任何证券或实施任何投资策略的建议。

迈克尔和约翰。亚洲金融危机。检索自美联储历史:https://www . federalreservehistory . org/essays/Asian _ financial _ crisis

原载于 2018 年 3 月 21 日https://www.shafquatarefeen.com。

Pusha T vs. Drake:用数据备份他们的 diss 轨迹

原文：towardsdatascience.com/pusha-t-vs-…

也许没有必要花太多时间来写一篇关于德雷克和普沙塔之间的争论的介绍，实际上网上没有一个地方没有报道过这个。如果你错过了；这两个说唱歌手多年前就开始争吵，在《出埃及记 23:1》和《一石二鸟》等歌曲中互相攻击。有了这种新的“红外线”轨道，Pusha T 似乎重新点燃了牛肉。

在过去一周左右的时间里，共发行了四首歌曲，其中两首由 Pusha T 发行，两首由 Drake 发行，不过据推测，Drake 发行的第二首歌曲是官方单曲，与这两位说唱歌手之间的恩怨无关。

在阅读了他们的歌词并理解了他们在 genius.com 的含义后，我认为对他们互相射击的镜头做一些数据检查会很有趣。

数据集

像往常一样，简要描述所有提取和收集的数据，以便进行实际分析；

我们需要以前发行的专辑中所有单曲的歌词。通过 Genius 的 API，我能够从 Drake 和 Pusha T 的最后 7 张专辑中提取所有歌词。
我想了解他们的音乐听起来怎么样。我们可以通过 Spotify 的 API 获得这些信息，并使用他们的音频功能端点。
由于有人向所谓的代笔人、、开枪，我也想知道这两位艺术家发行的歌曲的所有相关贡献者。这一信息是通过 genius.com 收集的。

做愤怒检查

普莎 T 在他的音乐中提到德雷克生气的地方有两行。第一个是指德雷克的音乐在过去几年里一直很愤怒。第二个出现在 Pusha T 的《T4》的结尾，讲述了 Adidon 的故事，他提到了德雷克的新单曲，他很沮丧。

好，进入愤怒检查！我们可以通过 Spotify 的音频功能进行一些调查。他们的衡量标准之一被称为“效价”分数，从 0(悲伤/愤怒)到 1(快乐)不等。

下图显示了这两位艺术家多年来的平均价态度量。计算出每张专辑和发行年份的平均值，未收录到专辑中的单曲不包括在此图表中。

德雷克的平均化合价为 0.35 分。他的专辑的浏览量在这一指标上得分最低，效价得分为 0.27。然而，在他的最新发行的专辑中，德雷克提升了他的情绪，拥有比《更多生命》之前的 4 张专辑更高的评分。我很想知道我们会在他即将发行的专辑中得到什么分数。

Drake’s valence scores throughout the years (album average)

如果我们看一下 Pusha T 的化合价分数，我们会看到的平均值为 0.44 。然而，他的最新版本 DAYTONA 显示了他迄今为止最低的化合价得分，比他的平均得分低 0.14。

Pusha T’s valence scores throughout the years (album average)

很有可能这种特殊的体裁平均来说在化合价上得分很低。为了对这些化合价分数有一个准确的印象，最好将这些分数与其他大型嘻哈歌手的分数进行比较。因此，我提取了 Spotify 最大的 Hip Hop 播放列表 RapCaviar 的化合价分数，因为这个播放列表展示了这个流派中最大的艺术家。结果发现，纳入播放列表的所有曲目的平均效价分数为 0.44 ，略高于两位说唱歌手最新发布的平均效价分数。

推广援助和职业复兴

在德雷克的“Duppy free style”中的一句台词上，他估计普沙·T 的专辑《DAYTONA》将获得的额外关注将导致额外的 20，000 张销量。他还提到，Pusha T 的标签 G.O.O.D. Music 可以期待发票。德雷克接着在他的 Instagram 上发布了这张发票。

在谷歌了一下T21 之后，我设法计算出相当于 1 张专辑销量的流量是 1500 次流量。这意味着德雷克声称将为普沙·T 的新专辑《代托纳》带来额外的 3000 万个视频流。Pusha T 之前的专辑在 Spotify 上产生了 6200 多万个流，所以我们必须看看他最新的 DAYTONA 项目的流计数是多少，该项目已经推出了 9 天。

那么，如果 G . o . o . d . Music 很高兴他们获得了 Pusha T 的额外推广，并愿意支付发票，那又怎么样呢？据数字音乐新闻报道，Spotify 上每次音频播放的费用估计为 0.00397 美元。如果我们认为这些信息是真实的，我们可以计算出 G . o . o . d . music 需要产生多少个流来回馈 OVO 声音(德雷克的标签)。如果我们看看他们标签上的三位艺术家，我们会看到一些重要的每月听众人数。Kanye West 每月有 2600 万听众，而大肖恩有 1400 万听众，Pusha 有 500 万。

假设所有这些听众只播放这三位艺术家的两首歌曲(考虑到他们中的两位在本月发行了新专辑，这可能是最少的)，那么你每个月就已经积累了9000 万次播放。将这个数额乘以每次播放的预计支出，你会得到仅一个月的357.000 美元的收入，仅 Spotify 一家。虽然这只是收入，没有考虑版税，但基于 Spotify 一个月的流媒体播放量，支付发票应该不会太难，对吗？；-)

“我的钩子做到了，我的歌词做到了，我的精神做到了，我无所畏惧”

两位艺术家都多次提到所谓的代笔人。因此，我很想知道每张专辑的作者和制作人的数量。下面的可视化显示了一个散点图，y 轴上是制作者的数量，x 轴上是作者的数量。

The amount of writers vs. amount of producers per album

当谈到写歌词时，另一件要检查的事情是**词汇密度；**独特词数除以总词数(也称词重复)。我已经包括了两位艺术家最近两张专辑的歌词，并查看了总字数和不同单词的数量(不包括所有单词长度低于 3 个字符的单词)。

德雷克的字数为14381而普莎 T 的字数为6016(这确实受一张专辑的曲目数量影响)。
在单词统计中，德雷克有 2793 个独特单词，而普沙有 2139 个独特的单词。
当计算词汇密度时，我们得到 Drake 的分数为 0.20，Pusha 的分数为 0.35。
德雷克的平均字长为 4.44，普莎 T 的平均字长为 4.62。

“让史蒂文谈谈流媒体和 Shazam 数字”

这一个太难抵抗了，在他的“红外线”轨道中有一个 Pusha T 线，实际上指的是流式数字。然而，德雷克在流数据方面胜过 Pusha T 可能不会让你们感到惊讶。因为这篇文章的目的是检查事实，所以我在下面列出了一些不同之处。

Drake 在 Spotify 上每月有 4800 万听众(世界第一)，而 Pusha T 每月有近 600 万听众。鉴于 Pusha T 发行了新专辑，他的听众可能会在下个月增加。德雷克在 Spotify 上有 2000 万粉丝，普沙 T 有 78 万粉丝。最后，自从提到了 Shazam，我还查看了每个艺术家的 Shazam 总数:Drake 积累了 6300 万 Shazam，而 Pusha T 积累了 670 万 Shazam。

Drake vs. Pusha T — Streaming Stats

放弃

这绝不是一种选择立场的方式，因为我喜欢 G.O.O.D .的音乐和德雷克，而只是一种有趣的方式来看待这两位艺术家之间的牛肉。
除了 Shazam 总数之外，Spotify 是唯一考虑的流媒体服务。

感谢阅读！如果你喜欢读这篇文章👏🏻很感激。

在这里找到更多我写的关于音乐的故事。

展现你最好的一面:沟通的新领域

原文：towardsdatascience.com/put-your-be…

Data Science Popup LA @ FullScreen HQ

2013 年，当我开始在多米诺数据实验室担任营销主管时，我不太确定如何制定我们的增长战略。我尝试、测试和重复了许多不同的策略，直到有一个被卡住。多米诺数据科学弹出窗口起飞了，行业趋势过去和现在都很清楚:更小、更专注的会议带来更大的想法、更好的网络和更光明的前景。我离开了达美乐，让其发展壮大 Formulated.by ，该公司最初是一家数字营销机构，后来发展成为一家提供数字和面对面体验的机构。在面对面方面，我们制定了关注价值和内容的亲密会议，将思想和行业领袖面对面地聚集在一起，以建立新的关系，并获得人才、前景和客户。我很高兴接到杰克·帕尔默的电话，他是 Plotly 的首席执行官，他也看到并理解了行业趋势——私人会议——我们一起创建了 PLOTCON 。在超额销售了第一个 PLOTCON(我们在纽约杀死了它！)我们的一个赞助商找到了我；营销副总裁 Stephanie Mcreynold 聘请我们为 Alation 开发一个名为“策划”的新活动系列。酷的是，我们的模型在许多领域都是可适应和可访问的。

我们已经与顶级品牌合作并得到它们的支持，如:思科、Salesforce、Capital One、戴尔、维亚康姆、奥瑞利媒体、美国银行、全屏、红牛媒体、亚马逊、IBM、AWS、英特尔软件、微软、Groupon、Ebay 和许多其他品牌。

我们的客户名单也在稳步增长:AWS、O'Rielly Media、IBM、Domino Data Lab、Plotly、Data。World、Reltio、Pariveda、Alation、Dataversity +其他。

我也组建了一个很棒的顾问团队。O'Reilly Media 的业务战略和分析副总裁 Roger Magoulas 让我们的业务战略保持专注，并始终领先一步。脸书活动的顾问 Mike Sly 为我们的销售战略注入了活力，并帮助我们找到了优秀的人才。Domino 的首席数据科学家 Eduardo Arino de la Rubia 是我们的行业专家和数据科学专家。我们的顾问团由 Plotly 的创始人兼首席执行官 Jack Palmer 和 O'Reilly Media 的高级顾问 Q McCallum 组成。这些影响者共同推动我们加速前进，引领我们走向成功。

我们的活动以人为本，将品牌、影响者和人才聚集在一个空间，只有一个目标:解决所有值得解决的问题。我们计划前端有趣和轻松的会议，后端组织和优化。

在数字方面，我们使用科学的方法，通过研发来推动合格的销售线索。我们整合了搜索引擎优化(SEO)、点击付费(PPC)、公共关系(PR)、电子邮件营销、有针对性的展示广告和社交媒体活动，以及一点点科学知识，只推动最合格的线索，最重要的是传播您的品牌意识。我们的团队将与您的团队合作，围绕您的品牌/产品建立一个强大的社区。瞄准本地、全国或全球的客户，以满足您的需求。

给我们写封短信:info@formulated.by 并顺道拜访formulated.by/

真诚地

~ 安娜·安妮辛 &团队

将“优步运动”数据付诸行动—机器学习方法

原文：towardsdatascience.com/putting-ube…

“一切都与其他一切相关。但近的东西比远的东西更有关联。”

地理第一定律

优步于 2017 年初推出了其优步机芯服务。它由数十亿条行程数据组成，并提供对所选城市不同区域之间行程时间汇总的访问。它创造了巨大的热情，但同时也引起了研究人员、移动专家和城市规划者的怀疑。那么，优步是否正在将数据民主化，并提供免费工具来访问其庞大的数据库？也许没有那么多，但它仍然做出了巨大的努力来聚合和可视化世界各地不同城市的数据量。

Uber Movement Tool

那么我们这里有什么？我们有一个基于所选原点的旅行时间的等时线映射的好例子。对于一天中的不同时间，行进时间也被分段。让我们只指定工作日和早高峰。

Range

对于数据科学家和分析师来说，最重要的是，这些数据可以以 CSV 格式下载。但是问题是，可以下载的数据没有按照“一天中的时间”进行分段因此，您可以下载一年中某个季度的所有出发地到所有目的地的旅行时间数据，但是可用的聚合仅限于一周中某一天的每月、每小时和每天。我们稍后会谈到这一点。

Download Options

移动评估即服务

移动性是智能城市项目和位置智能的朗朗上口的术语。可以把它看作是一项服务，它根据您旅行的起点和目的地以及一天中的时间，为您提供在您居住的城市中的估计旅行时间。一天中的时间甚至可以涵盖季节性，因为你不会期望在炎热的夏季午后和灰色的冬季晨雾中有相同的旅行时间。此外，选择一个精确的日期可能会产生无尽的搜索:5 月份的周末是早上的高峰，因为你在一年中的这个时候去巴塞罗那旅行；或者是夏天的中午，周五下午 15:20 左右，因为你在伦敦进行暑期实习。优步的运动数据仅仅是个开始。

Not that mobile, is it?

这种服务的潜力对于试图将位置智能整合到其服务中的公司来说意义重大。零售和批发企业正试图评估他们所在地区的集水区，房地产公司希望评估位置的可达性，物流和货运公司希望(并且需要)知道旅行时间，因为他们运输货物。

挑战:旅行时间预测

那么，为了提供这样的服务并根据到达不同地区的时间来评估位置，我们需要知道什么呢？简而言之，旅行时间。我们要么需要一个旅行时间矩阵，要么能够即时创建一个。机器学习方法是基于足够大的历史旅行时间数据集来训练您的模型，以便它可以准确预测具有源位置、目的地位置和日期的新旅行查询的旅行时间。基本上，我们需要一个给定城市内的庞大数据集和一个合适的机器学习模型。

作为一家科技公司，优步将这个问题称为价值十亿美元的问题。旅行时间，或者用他们的行话来说，ETA(预计到达时间)，是他们业务的关键绩效指标之一。

Not time travel! Travel time! (That’s also a billion-dollar question, though.)

机器学习爱好者可能已经记得几个 Kaggle 比赛中的这个挑战，例如这个关于识别纽约出租车旅行持续时间的比赛，以及最近的这个关于纽约出租车费用预测的比赛。他们都广泛关注纽约市，主要覆盖曼哈顿和布鲁克林。

我的问题是，我们应该在优步运动数据的基础上建立我们的模型，这个数据的主要挑战是什么？为什么我们要对它建模而不仅仅是查询呢？

动机

首先，我们需要定义我们的视角。我们的移动性评估需要能够为感兴趣的城市创建月、日、甚至小时精度的高精度旅行时间预测。我们正在使用机器学习方法，所以我们需要一个大的数据集。

然而，优步的数据集存在几个问题:

它没有涵盖每个时间间隔的所有源和目标对。因为有时给定路线上没有足够的行程供他们汇总并添加到他们的 CSV 中，所以存在缺口。
它不提供可下载格式的特定日期时间范围的聚合数据。这意味着 3 个月内所有周一或下午 1 点从出发地到目的地的平均旅行时间。
它是按地区汇总的。它没有行程起点和终点的位置(经度/纬度)。
当然，它只涵盖了世界上选定的城市。它可能不包括你感兴趣的那个。

Kaggle / NYC 旅行数据也有重要问题:

它主要覆盖曼哈顿，这是一个比伦敦这样的大都市小得多的地区。仅仅了解整个城市的动态是不够的。
曼哈顿有曼哈顿距离！它涉及一个相对简单的计算模型。为世界上大多数城市构建模型时，计算两个位置之间的距离并不容易。你需要路由软件。

Finding your way in Manhattan

最后，为大城市创建行程时间预测的主要问题是历史数据并对其进行智能过滤。在这个领域，数据非常有价值，非常大，而且很难获取。你需要缩小它的尺寸来模拟它。想出一条特定的路线和这条路线上的旅行时间。如果你想得到每小时的精度，你的数据要乘以 24。对于周精度，乘以 7，对于一个季度的日精度，再乘以 90。它呈指数增长。然后，想想在一个大城市可能有成千上万条路线。

The exponential growth of spatiotemporal data

您可能会很快想到，您需要对这些数据进行建模，而不是将这些组合中的每一个都存储在数据库中。即使对于建模，您也可以通过选择特定的起点和终点来缩减数据，因为在一个城市中几乎有无限多种不同路线的组合。

优步运动数据和建模在这一点上发挥了作用:

使用优步移动数据可以帮助您了解如何在大城市选择 OD(起点-终点)矩阵对，以便有最少的路线组合来定义最大旅行时间(因此交通拥堵)可变性。

1-问问你自己:你需要选择多少个原点？

2-然后问:有几个目的地？

3-最后，你可以:为城市的不同部分优化你的选择。

以这种方式使用的优步流动数据可以帮助您了解大城市中人员的真实流动和流动性。
对于建模，有了模型后，只需搜索特定的位置对作为路径，而忽略数据集中缺失的数据。机器学习已经帮你解决了这个问题。

开拍。

介绍完毕，我将总结一下我将要向您展示的步骤:

1-下载并浏览伦敦的每周汇总数据集。(因为它是一个足够大的数据集，而且我喜欢伦敦！)

2-对于数据准备，整合和格式化数据。

3-选择一个模型并应用它。评估准确性指标。

4-在地图上可视化预测误差。将其与数据探索中的发现进行比较。

5-比较谷歌地图和模型之间的一些旅行时间结果。

6-评论模型中可能的改进。包括我们所学的部分。

数据理解

我们将首先访问优步运动网站并导航至伦敦。然后，我们将下载“每周汇总”的 CSV 文件在这种情况下，我们将选择截至目前的最新季度:2018 年第 1 季度。

我们还需要地理边界文件来设置区域坐标。

我们将汇总数据。如你所见，那里有将近 300 万张唱片！从起点区域到终点区域，我们可以找到编码为 1 到 7 的一周中每一天的平均行程时间(dow)。

str(my_london_mv_wa)'data.frame':	2885292 obs. of  7 variables:
 $ sourceid                                : int  705 137 131 702 
 $ dstid                                   : int  167 201 261 197 131 232 157 451 302 137 ...
 $ dow                                     : int  7 7 7 7 7 1 7 7 
 $ mean_travel_time                        : num  1699 1628 3157 
 $ standard_deviation_travel_time          : num  600 541 688 206 
 $ geometric_mean_travel_time              : num  1621 1556 3088 
 $ geometric_standard_deviation_travel_time: num  1.34 1.34 1.23

我们需要将“sourceid”和“dstid”映射到区域。我们会读 geoJSON 文件。它有伦敦 983 个地区的定义。对于它们中的每一个，都有一个限定该区域的边界多边形。 多边形 表示定义边界的一列路段。每个线段都有一个由经度和纬度定义的起点和终点。

library(jsonlite)library(geosphere)# load objects
my_london_regions<-jsonlite::fromJSON("london_lsoa.json")# check your region list
head(my_london_regions$features$properties)# polygon coordinates for each region
str(my_london_regions$features$geometry$coordinates)

现在让我们变戏法，然后解释这里发生了什么。

my_london_polygons=my_london_regions$features$geometry$coordinates
my_temp_poly<-my_london_polygons[[1]]
poly_len<-length(my_temp_poly)/2
poly_df<- data.frame(lng=my_temp_poly[1,1,1:poly_len,1], lat=my_temp_poly[1,1,1:poly_len,2])
my_poly_matrix<- data.matrix(poly_df)
temp_centroid<-centroid(my_poly_matrix)

我们将多边形坐标保存到一个对象中。作为演示，开始区域 1 的程序。因为我们的形状是一个多边形，我们可以用它的形心来定义这个多边形。这是因为我们需要每个区域有一个单一的位置坐标。我们来自“地圈”包的质心函数可以计算出来。我们以要求的格式给出输入。最后，我们得到了该区域的质心。让我们想象一下，看看我们做了什么。我们将使用传单包装。

leaflet(temp_centroid) %>% 
 addTiles() %>% 
 addMarkers() %>% 
 addPolygons(lng= poly_df$lng, lat=poly_df$lat)

Geometrical center of the polygon is centroid.

这是我们所期望的。区域 1 有一个边界多边形，我们已经计算了它的质心。现在，区域 1 由这个位置中心定义:质心纬度和经度。很容易对每个区域重复此过程，并准备一个最终列表:

head(my_london_centroids_450,3)
   id         lng      lat
1 212 -0.16909585 51.49332
2  82 -0.04042633 51.39922
3 884 -0.02818667 51.45673
...

数据准备

我们的最终数据集需要有一个源位置、目的位置、日期和距离。我们已经在上一节中准备了区域的质心坐标，以便在地图上看到我们的区域。剩下的就是选择一个区域子集，然后计算每个起点和终点对之间的距离。让我们开始吧。

a-子集化

为什么我们不用所有的 983 地区呢？如果你还记得文章开头的那段话，近的东西更相关。附近地区的旅行时间相似。如果我们对区域进行子集划分，我们的最终数据集将会更小，建模时间也会缩短。我们还对这些区域进行了子集划分，因为计算距离的成本很高，并且子集划分会导致要计算的路线组合数量减少。

现在，我们的数据集有 983 个不同的地区，平均而言，它们有大约 450 个目的地。经过几次子集设置和建模试验(为了评估准确性)，我们将随机选择 450 个起始区域，并为每个区域选择 150 个随机目的地。让我们看看这是什么样子:

Randomly selected 450 origin region centroids inside London city boundaries.

Here are 150 trips (destinations) from region 1. The circle has a 15km radius.

因此，大多数行程的半径为 15 公里，也包括一些到希思罗机场的行程。我们可以很容易地说，通过检查其他地区，我们的模型将足够好地预测行程的旅行时间(1)大约 15 公里的距离和(2)到机场。

我们还对 450 个产地的密度分布感兴趣。r 有强大的地理空间软件包来帮助我们。

library(spatstat)
## create a point pattern object
my_london_centroids_450_pp<-ppp(my_london_centroids_450[,2],my_london_centroids_450[,3],c(-0.4762373 , 0.2932338) ,c(51.32092 ,51.67806))#visualize densityplot(density(my_london_centroids_450_pp))

The density of our origin locations (regions).

The rasterized density image on top of London map

因此，我们的原点位置的密度在中心较高，在外围较低。同样，我们可以在建模之前进行粗略的猜测，并且可以说预测误差在中心会更小，因为有更多的原点位置(区域)。

再次使用强大的“spatstat”和“geosphere”软件包，我们可以进一步分析到目的地的距离的细节。他们可以使用点模式对象、“nnwhich”和“geoDist”函数轻松地为我们提供附近邻居的 kth:

# closest first 5 neighbor distance to destination idshead(my_london_centroids_450_nd3[,c(1,5,6,7,11,12)]) id       gd1       gd2       gd3      gd4      gd5
1 212  573.0708  807.4307  710.0935 1694.490 1325.124
2  82 1086.2706 1370.0332 1389.9356 3018.098 2943.296
3 884  641.8115  767.1245 1204.1413 2428.555 2320.905
...

b-距离计算

让我们在建模之前考虑最后一件事:我们需要计算起点和终点对之间的距离。我们不能依赖曼哈顿距离或直线距离。它需要是一个人开车走的真实距离，所以我们需要一个路由软件，可以根据城市中的特定路线计算两点之间的距离。

为此，我们有几个选择。像谷歌地图 API 这样的付费选项可能会很贵(数百美元)，因为我们将有大约 67500 条路线(450 个起点*150 个目的地)。路由最全的免费软件是 OSRM (开源路由机) OpenStreetMap 用的。

library(osrm)#calculate distance
my_route_d<-osrmRoute(src=my_london_centroids_450[my_r1,] , dst=my_london_centroids_450[my_r2,], overview = FALSE)# route segments if needed to draw a polyline
my_route<-osrmRoute(src=my_london_centroids_450[my_r1,] , dst=my_london_centroids_450[my_r2,])

Calculations from OSRM results are drawn with Leaflet

OSRM 软件包默认使用演示 OSRM 服务器，并且仅限于合理和负责任的使用。我们不希望通过发送成千上万的请求在演示服务器中造成瓶颈。我们需要自己的路由服务器！

这里有一个简洁的教程描述了如何在 Ubuntu 机器上设置你自己的 OSRM 服务器。好消息是你不需要成为一个 Unix 专家来设置它。菜鸟级别的熟悉就够了。我个人用的是 Ubuntu Xenial 16.04 的 m4.xlarge 类型的亚马逊 EC2 实例。

完成后，我们可以将 OSRM 服务器选项设置为新的服务器 IP:

options**(**osrm.server **=** "http://xxx.xx.xx.xx:5000/"**)**

现在，我们已经准备好计算起点和终点对的每个路线组合的距离。

建模

最后，我们准备好了有趣的部分。准备完毕后，让我们看看我们的数据集:

head(my_london_sample_wa450150)lng_o    lat_o      lng_d    lat_d     dow distance   travel_time
-0.374081 51.5598 -0.4705937 51.54076   5    10.92        1048.46
-0.399517 51.4904 -0.4705937 51.54076   3    27.86         947.94
-0.368098 51.5900 -0.4705937 51.54076   4    14.30         1550.46
...

我们有起点/目的地坐标、星期几、距离和以秒为单位的旅行时间。这个数据集有 421，727 行。

在行程时间预测中，有两种受欢迎的算法。同样在的同一场演讲中，优步将它们列为:

The four preferred algorithms by Uber in Travel Time Prediction

我们将尝试随机森林。这是一种开箱即用的算法，需要最少的特征工程。为数据集的 70%(大约 290，000 行)创建训练集后:

modFitrf<-randomForest(travel_time ~ dow+lng_o+lat_o+lng_d+lat_d+distance,data=training_shuf[,c(3:9)],ntree=100)# resultrandomForest(formula = travel_time ~ dow + lng_o + lat_o +      lng_d + lat_d + distance, data = training_shuf[, c(3:9)],      ntree = 100) 
               Type of random forest: regression
                     Number of trees: 100
No. of variables tried at each split: 2Mean of squared residuals: 18061.1
                    % Var explained: 96.84

在类型为 m4.2xlarge 的亚马逊 EC2 实例中，这个过程需要大约 2 个小时。

训练误差为 3.2%，测试误差为 5.4%。我们还有一个维持数据集，它引用了在对它们进行子集化时没有包含在我们的模型中的区域。对于维持数据集，从剩余区域中随机选择 100 个区域，错误率为 10.8%。

模型评估

让我们在伦敦地图上直观地显示我们的预测误差。

Test error rates grouped.

事实证明，我们的直觉是正确的。我们在中心区域的错误更少，希思罗机场也有一个黑点，这意味着它的错误率更低。

在数字上，我们也可以计算相关性。到中心的距离和预测误差之间的相关性是公平的。

cor(my_london_centroids_450_hm$distc,  my_london_centroids_450_hm$testprc)[1] 0.5463132

我们可以再次使用我们的空间包“spatstat”来可视化我们的错误率。这一次，我们将使用空间插值来平滑 2 维空间上的错误率。

library(spatstat)# assign corresponding prediction errors to our coordinates in 2-d
marks(my_london_centroids_450_pp) <-my_london_centroids_450_hm$testprc## apply inverse distance weighting / spatial interpolation
plot(idw(my_london_centroids_450_pp))

Our interpolation graphic is worth the effort. Again we can observe the regions with a low error rate

我们现在可以试试我们的伦敦旅行时间预测器。我们来做个随机对比。我们将在谷歌地图中随机选择两个点:

Google Maps calculates 21 minutes travel time on Monday evening

然后，我们将使用 OSRM 计算相同点之间的距离，并将所需的参数传递给我们的模型，以预测旅行时间。

library(osrm)lon_o<-0.054089 ; lat_o<-51.591831
lon_d<-0.114256 ; lat_d<-51.553765# calculate distance
my_distance<-osrmRoute(src = data.frame(id=1,lon= lon_o , lat=lat_o) ,
                       dst= data.frame(id=2,lon=lon_d  , lat=lat_d), overview = FALSE)[2]# get route
my_route<-osrmRoute(src = data.frame(id=1,lon= lon_o , lat=lat_o) ,
                       dst= data.frame(id=2,lon=lon_d  , lat=lat_d))# calculate travel time with our model for monday
travel_time<-predict(modFitrf, data.frame(dow=1, lng_o= lon_o,lat_o=lat_o,
                                     lng_d=lon_d ,lat_d=lat_d,distance=my_distance) )

让我们来看看结果:

Prediction from our model visualized on Leaflet

即使在一个不靠近中心的地区，我们的模型也做出了相当不错的预测，只差几分钟就错过了谷歌地图的预测。

通过使用插值测试误差率，我们可以找到原点位置的预期测试误差率。

my_image[list(x= 0.054089,y=51.591831)]
[1] 0.06567522

因此，根据 2 维空间中测试误差率的分布，我们预计该区域的传播时间误差约为 6%。

自然，我们面临着更高的错误率，因为我们使用的优步运动数据集没有每小时的精度。我们只是对周一做了一个整体预测，无法捕捉高峰或非高峰时间。此外，请注意，我们使用的是第一季度的数据，这意味着我们主要是对冬季进行预测，但这一比较是在 2018 年 9 月进行的。我们没有真正捕捉到季节变化。

最终注释

基于伦敦 2018 年第一季度的优步运动数据，我们使用随机森林算法通过机器学习制作了一个旅行时间预测器。

可能的改进:

可以分析每小时汇总的数据。有了这些数据，我们就可以将我们的模型与来自每小时聚合数据的模型相结合，以获得更精确的结果来捕捉交通拥堵的每日变化。
现在我们有了第一批结果，可以更有策略地进行子集化。很明显，我们需要更多的郊区区域来进一步降低错误率。
我们可以为中心和郊区创建单独的模型。可以针对不同的型号单独调整型号。喜欢在随机森林的郊外有更多的树的深度。
我们可以尝试其他算法(KNN、XGboost 或神经网络),并将它们组合成一个整体。
可以对一年中的其他季度进行相同的建模，以捕捉季节性。

我们可以从中学到什么:

因为我们有时空数据，所以需要空间分析。
插值是探索和使用此类数据的强大转换工具。
起点和终点区域的选择是一种优化问题。我们正试图捕捉旅行时间预测中的最大可变性，同时将始发地和目的地的数量保持在最小。

想听听大家的意见和建议！

请随时通过 LinkedIn 和 Github 联系我。

PyCon India 2018 —数据科学家的体验

原文：towardsdatascience.com/pycon-india…

The team behind PyCon India 2018

每年秋天来临的时候，它都会在世界各地掀起一场大规模的会议、研讨会和黑客马拉松。其中之一是派康的非常自己的派康印度

PyCon India 汇集了技术专家、科学家、一般开发人员和 Python 开发人员、开源贡献者、数据极客和软件开发人员(具体而言)

今年，PyCon India 十周年庆典在海得拉巴市的海得拉巴国际会议中心(HICC)举行，约有 16000 名与会者在不同领域使用 Python，从为科学图书馆做出贡献到自动化和维护发电厂。

那么，我们开始吧，让我们看看 2018 年印度 PyCon 上发生了什么😍：

一般来说，PyCon India 从各种 Python 库和框架的研讨会和实际操作开始，这些库和框架用于解决许多问题的各个领域。激动吗？什么问题？谁解决？怎么解决？…🤔🙄

让我们看看他们🤗研讨会…👨🏻‍💻

Exploring PyTorch for AI assistance in medical imaging

这个人是深度学习工程师(哇，工程师🙃)解决医疗保健面临的问题。他说，“就像在我们的日常生活中一样，人工智能和机器人越来越成为我们医疗保健生态系统的一部分。目前医疗保健被打破了；医生短缺；护理质量差。迫切需要为整个医疗行业提供援助，以改善医疗保健”(嗯，没错😌)

这个会议说明了我们作为工程师有多棒，今天谁关心健康(如果你关心的话👏🏻)? Abhishek Kumar 和 Aditya Bagari 震撼了本次会议，他们带领观众从介绍 PyTorch 到解释卷积神经网络以及如何在充满挑战的敏感医疗保健领域使用它。

Decoding Bollywood with Python and Data Science

敲门敲门。这是马克·加西亚和他的朋友希曼舒。Marc 是 Python 数据分析库 Pandas 的核心开发人员🐼🐼 但是，等等！告诉我谁更受欢迎，卡特里娜·卡伊夫和迪皮卡·帕度柯妮？从故事情节来看，什么电影最像 PK ？

惊讶吗？好奇想知道？😃

在这个工作室中，他们收集 IMDB 数据，在熊猫中进行处理，制作美丽的图案，并在散景和其他带有宝莱坞数据的酷东西中可视化，看看他们的 github repo 并享受吧！！！

本次研讨会展示了 Python 及其开源库的另一个令人惊叹的应用，这个人展示了 Python 如何简化地理空间数据(矢量数据和栅格数据)的分析。

他说，“地理空间表示在日常生活中非常普遍，例如甚至在简单的与地图、航空/卫星图像等旅行相关的对话中。在数字时代，地理空间数据被广泛生产和消费，其比例越来越大。Python 及其免费和开源库提供了各种简单有效的工具来可视化和分析地理空间数据"

他向我们介绍了一个名为 GeoPandas 的出色的 python 库，这是一个开源项目，旨在使使用 Python 处理地理空间数据变得更加容易。GeoPandas 扩展了熊猫使用的数据类型，允许对几何类型进行空间操作。几何运算由 shapely 完成。Geopandas 进一步依赖 fiona 进行文件访问，依赖 descartes 和 matplotlib 进行绘图。(酷😍，没有？).别忘了留意他的 GitHub 报告。

JupyterHub and Binder

Carol Wiling 是 Project Jupyter(是的，你没看错)和 CPython 的核心开发人员之一，也是 Python 软件基金会的前主任。

她参加了一个关于 Python 中科学计算以及 JupyterLab 如何用于此目的的精彩会议

她用 JupyterLab 和它在数据科学和科学计算中的应用告诫与会者(是的，哈哈)

在本次会议中，我们了解了 JupyterLab 用户可以使用的新用户界面功能。稍后，我们将超越 JupyterLab 的个人工作流，看看 JupyterHub 如何将 JupyterLab 带给用户组。最后，我们讨论了 Binder 及其为 Jupyter 笔记本和其他设备提供短暂计算环境的能力。这是她对案例研究的幻灯片

嘿，你认识照片上的这个人吗(不认识？😱)?他是 SciPy，NumPy 和 Numba 的创造者。特拉维斯·奥列芬特是你在 Python 中进行科学和数值计算的原因。(你用 anaconda 吗？他也是幕后黑手🤓)

是的，他拿走了车间！他说所有使用 Numba，NumPy 的人都是“他的人”

在这个研讨会上，他讨论了用 Numba 和 Dask 扩展 Python，他解释了 Python 的编译器是如何工作的(什么？编译器？)并使用 JIT 编译器增强 Python 的计算能力💪🏻

这些是 2018 年印度 PyCon 第一天的几个研讨会的亮点！

现在怎么办？发布会！！！😻😻

Conference Hall (empty, han?)

人们为什么参加会议🤔？嗯，也许是因为以下原因？ 1。走廊对话 2。伟大的会谈(我知道你不看网上会谈) 3。潜在的职业机会(许多人通过 PyCon 找到工作) 4。与创业公司和公司建立关系网。开始进入开源领域，这样的例子不胜枚举…🚀

在会议期间，我必须在登记处管理门票、t 恤和礼品，我们做得很好(你可以问与会者🤷🏻‍).我真的很喜欢登记的匆忙(等等😼)

会议以开幕致辞开始，以 2018 年印度 PyCon 主席 Manivannan Elangovan 的闭幕致辞结束。 但是等等！这中间发生了什么？好了，让我们来看看亮点！

主题会议、机构群体讲座、赞助商讲座、照明讲座和各种平行讲座都在这两天举行。人们分散在 HICC 的各个房间和大厅。

这四位传奇人物是主题演讲人，他们都让我和众多与会者着迷。

着迷？怎么会？这些人是我们今天所看到的人工智能的原因，这些人是我们今天如何处理数据的原因！

阿明·罗纳彻(Flask framework 的创始人，用 Python 编写的令人敬畏的 web 应用程序框架)是第一个主旨发言人，随后是特拉维斯、卡罗尔和西杜。我永远不会忘记在这两天的会议中我看到并记下的一些精彩内容

这个闪电谈话中的传奇展示了他如何运用自己的天赋、技能和热情去营救喀拉拉邦洪水的受害者。他是 Django 的开发者 Biswas，在喀拉拉邦洪水灾民的大量请求中，他帮助 keralarescue.in 运行。

Carol Wiling 在她的演讲中分享了一些关于 Python 及其未来的很酷的统计数据。她已经编码 41 年了！

她说1989 年的 Python， 154，293 个项目， 1，094，879 个版本， 1，503，765 个文件， 268，049 个用户

在这里你可以看到很多谦卑，人们坐下来听数据科学家达薇亚关于自然语言处理的演讲。

阿明·罗纳切尔讨论了 Python 的“T2”对复杂性的恐惧。

阿明 @mitsuhiko 在 @pyconindia 的主题演讲中表示愿意应对 #Python 及其社区的挑战，这非常了不起。我们只有通过深入看待我们的挑战来学习。向 Rust 等其他社区学习是个好主意。

给你，在会议的第二天晚上，玛琳·姆汉加米与卡罗尔和阿明进行了激烈的讨论。

Marlene 是 Python 软件基金会的主任，也是津巴布韦 Python 用户组的联合创始人

嗯，有一个 Durgaput Linux 用户组 的聚会，这是一个大多数学生在开源和自由软件基金会的海洋中开始他们职业生涯的地方。

在这里，我开始了我的数据科学之旅，学到了技术伦理，学到了自由软件运动的遗产和许多东西。十年前，库沙尔·达斯创立了 DGPLUG，帮助学生在从事牙线工作后最终找到工作

Alumni and Community of Durgapur Linux User Group’s very own Summer training

👨🏻‍💻👨🏻‍💻👨🏻‍💻👨🏻‍💻👨🏻‍💻发展冲刺👨🏻‍💻👨🏻‍💻👨🏻‍💻👨🏻‍💻👨🏻‍💻

在 PyCon 的 Devsprints 上又是一个伟大的日子(但不是最后一天),开发人员聚集在一起，通过贡献他们天赋的编码技能来解决问题

数据人马克·加西亚激励我们为熊猫做贡献，并简化这个令人敬畏的数据工具

令人敬畏的 Jupyter 女人 Carol Willing 坐在椅子上指导开发人员，并指导我们解决 Jupyter 项目中的问题

阿明(烧瓶创建者)、特拉维斯·奥列芬特(T1)(Scipy 创建者)、卡罗尔·威林(CPython 核心开发人员和 Jupyter 核心开发人员)、马克·细川玉子(熊猫核心人员)都非常谦逊，乐于助人。他们站了几个小时来回答与会者的问题，吃饭的时候，休息的时候，会议结束后，哇！编码，交谈，指导，吃，享受这个 PyCon 。

Jobs Board at PyCon

那么，这就是 2018 年印度 PyCon 的结束。人们编码、指导、建立联系、交谈等等

无论如何，我只见过创业的人和研究员，他们给了我很多关于我们(我和我亲爱的朋友)即将到来的商业想法的建议(上帝保佑)

这一次，人们聚集在这个国家最好的会议中心之一，它以热情好客而闻名

人们得到了工作推荐，初创公司和跨国公司展示了他们的产品，Python 核心开发人员、Pandas 核心开发人员和 Jupyter、Scipy 开发人员来到现场，与开发人员互动

人们寻求他们的指导来为这些令人敬畏的项目做贡献，一些公开的问题已经在 Devsprints 中解决了

开源人员听到了一个好消息，他们将获得一份有报酬的工作(如果他们将自己的想法转化为业务，并拥有自己的创业公司，而不是免费提供他们的想法，这将更加有益，也许他们可以成为独角兽🦄)

为语言而来，为社区而留——布雷特

PyData 伦敦 Meetup 2017 年 4 月评论，由初学者。

原文：towardsdatascience.com/pydata-lond…

Will it be totally beyond me? Or not?

PyData London Meetup ，一场众所周知很难买到票的聚会。PyData London 每个月都有一个重要的等候名单，你必须非常迅速地确认你的出席。在之前的活动后，我在酒吧见过组织者和与会者(这是 Meetup 的传统)，我知道社区和会谈的质量将是高质量的，我在正确的地方继续我的数据科学教育。如果你没有买到活动的门票，但仍然想与社区成员见面，请关注 PyData LondonTwitterfeed，了解聚会后他们去的酒吧的位置。

位置

聚会不动了。有免费的食物和啤酒你为什么要喝？这是因为 meetup 一直由 AHL 的慈善团队主办。这使得组织者可以将更多的精力花在聚会的其他方面，而不是每月寻找新的地点。因此，聚会的质量每个月都在提高。

但是，因为地点没有改变，meetup 现在经常在宣布的几天内达到最大容量。).不幸的是，这意味着每次只有 230 人可以参加，人们确实错过了。组织团队知道这一点，几乎所有的谈话都在网上结束，并分享给 meetup 小组。一个重要的小组还会在会后去附近的酒吧喝一杯。你没有参加只是错过了一点点，这要归功于组织者和演讲者。尽管由于这种制度，meetup 将存在更长时间，但难以参加的方面确保了获得门票的行为将被视为更重要的事件，实际与会者与提供的位置的比率在可预见的未来将保持高水平。

主要会谈

Ju Lui 用机器学习预测泰坦尼克号幸存者

Are they even looking into each others eyes!?

用他的第二选择语言 Python 现场编码 45 分钟？对朱露来说没问题。从初学者的角度来看，这是对机器学习的完美介绍。前半部分致力于通过使用熊猫包来可视化和理解泰坦尼克号幸存者的数据，房间里的每个人都能够与演讲者保持在同一水平上。全部实时编码，没有错误。强壮。

Ju Lui visualising the data focusing on variables such as sex, class and survival.

我的统计学教育已经深入到多元线性回归分析，演讲的最后三分之一超出了我的理解范围，但并没有多到让我与演讲脱节。在达到这一步之前理解了数据，我可以理解 90%的讨论内容，并理解正在进行的监督学习。总的来说，这次谈话质量很高，富有教育意义和娱乐性。鉴于这场演讲 95%都是现场直播的，后续演讲的门槛已经定得很高了。相关 GitHub 。

叶戈尔·克拉夫——用于实时分析的异步流式 Python

The Push approach with added silhouette. The addition of Keeping up with the Kardashians on the right is a unique aspect of PyData London.

叶戈尔·克拉夫，在两家大银行做了 10 年的量化分析师，现在是人工智能的负责人和 Dagon Analytics 的创始人。这个演讲集中在人工智能的另一个非常重要的部分。数据系统允许数据结构化和可访问，因此算法可以轻松完成任务。

The Logic for swapping from a Push approach to a Pull approach.

该讲座重点讨论了数据框架内的推方法，然后将其改为由 asyncio 和 Kafka 支持的拉方法。决定从推式系统转变为拉式系统背后的逻辑得到了很好的解释和可视化。讲座以一个快速演示结束，展示了在笔记本电脑上运行的系统。这次讲座比上一次的水平更高，但仍然允许那些没有相关经验的人理解和学习。又是精彩的谈话！

The Pull Solution

闪电谈话

最多 5 分钟。走吧。

马蒂·莱拉——戴着手套的手

Matti Lyra 从德国赶来参加这次演讲，并通知 PyData 伦敦社区 PyData 柏林，这是继 PyData 伦敦之后的另一场会议。在 5 分钟之内向一群人传达有用的信息是很难的。马蒂用了 2 分钟。我没有经验，所以我会给你一个描述和一个合适的 GitHub 工具的链接。

word 2 vec 和 GloVe 形式的分布式单词表示在过去 5 年中变得非常流行。虽然斯坦福大学 NLP 小组已经发布了他们训练过的手套向量，但数据格式并不方便。我将展示一个我编写的小工具“GloVe2H5 ”,它使访问预先训练好的向量变得更加容易。

Adam Hill——构建企业所有权数据的图表模型以揭露潜在的腐败

Eric Pickles publically acknowledged the work done by DataKind.

Adam Hill 从 Matti 的演讲中抽出空闲时间，让他讨论 DataKind 如何使用公司的公开数据来了解公司所有权。最初是一个 15 分钟的演讲，将信息压缩到 7 分钟并没有降低工作的重要性。通过能够可视化和分析公司的所有权图表，可以研究许多关于避税天堂和部分所有权的见解。结果已传达给政府，政府公开承认这一良好工作，目前正在调查中使用。这里有的幻灯片。

Celine bou dier——谷歌数据工作室测试版生活教育工具数据代码仪表板

Celine Boudier 向我们介绍了 Ocado 的一项名为“ Code for Life 的非营利计划，旨在创建免费的开源游戏，帮助儿童学习计算。第一局快速路由器已经在行动了！席琳想让我们了解谷歌数据工作室。Celine 和他的团队使用该软件将他们收集的数据可视化，并使其更易于与其他人交流。这些易于制作的可视化让他们能够理解他们网站上的行为，因为它是基于网络的，这有助于他们解决选择使用基于 Linux 的系统可能带来的问题(没有表格)。幻灯片。

围捕

聚会很棒，组织得很好，主题和社区都以高质量相互匹配。在聚会期间，我遇到了许多优秀的人，我期待在以后的活动中遇到更多的人！

判决:到社区报名就走！初学者或有经验者。

下一个事件: PyData 伦敦会议。在这里买票。五月没有聚会。

截至 2017 年 7 月 4 日，我既不是数据科学家，也不是 APM。我的宏伟目标是成为一名拥有良好数据科学知识和/或背景的产品经理。如果你愿意帮助我，哪怕只是一点点，请通过 LinkedIn 联系我，或者通过 Twitter 联系我，Twitter 是 T2，robwin 是 T3。我会肯定地回答，这将是巨大的赞赏。我正在寻找一个可以一起学习和创造价值的团队。

在 Kaggle Titanic 数据集上测试 PySpark ML 和 XGBoost 完全集成

原文：towardsdatascience.com/pyspark-and…

在本教程中，我们将讨论如何使用标准的机器学习管道来集成 PySpark 和 XGBoost。

我们将使用来自“泰坦尼克号:机器从灾难中学习”的数据，这是众多 Kaggle 比赛之一，在 T2 举行。

本文的新版本包括 PySpark 和 XGBoost 1.7.0+之间的原生集成，可以在 这里 找到。

在开始之前，请了解您应该熟悉 Apache Spark 和 Xgboost 和 Python。

本教程中使用的代码可以在 github 上的 Jupyther 笔记本中找到。

如果你对本教程的设置有任何问题，你可以查看另一篇解释如何在 docker 中运行的文章。

步骤 1:下载或构建 XGBoost jars

python 代码需要两个 scala jars 依赖项才能工作。您可以直接从 maven 下载它们:

如果你想自己建造它们，你可以从我以前的教程中找到方法。

步骤 2:下载 XGBoost python 包装器

你可以从这里下载 PySpark XGBoost 代码。这是我们将要编写的部分和 XGBoost scala 实现之间的接口。我们将在教程的后面看到如何将它集成到代码中。

第三步:开始一个新的 Jupyter 笔记本

我们将开始一个新的笔记本，以便能够编写我们的代码:

jupyter notebook

步骤 4:将定制的 XGBoost jars 添加到 Spark 应用程序中

在启动 Spark 之前，我们需要添加之前下载的 jar。我们可以使用--jars标志来做到这一点:

import os
os.environ['PYSPARK_SUBMIT_ARGS'] = '--jars xgboost4j-spark-0.72.jar,xgboost4j-0.72.jar pyspark-shell'

步骤 5:将 PySpark 集成到 Jupyther 笔记本中

使 PySpark 可用的最简单的方法是使用[findspark](https://github.com/minrk/findspark)包:

import findspark
findspark.init()

步骤 6:开始 spark 会话

我们现在准备开始 spark 会话。我们正在创建一个 spark 应用程序，它将在本地运行，并将使用与使用local[*]的内核一样多的线程:

spark = SparkSession\
        .builder\
        .appName("PySpark XGBOOST Titanic")\
        .master("local[*]")\
        .getOrCreate()

步骤 7:添加 PySpark XGBoost 包装器代码

现在我们有了 spark 会话，我们可以添加之前下载的包装器代码:

spark.sparkContext.addPyFile("YOUR_PATH/sparkxgb.zip")

步骤 8:定义模式

接下来，我们定义从 csv 读取的数据的模式。这通常是一个比让 spark 推断模式更好的实践，因为它消耗更少的资源，并且我们完全控制字段。

schema = StructType(
  [StructField("PassengerId", DoubleType()),
    StructField("Survival", DoubleType()),
    StructField("Pclass", DoubleType()),
    StructField("Name", StringType()),
    StructField("Sex", StringType()),
    StructField("Age", DoubleType()),
    StructField("SibSp", DoubleType()),
    StructField("Parch", DoubleType()),
    StructField("Ticket", StringType()),
    StructField("Fare", DoubleType()),
    StructField("Cabin", StringType()),
    StructField("Embarked", StringType())
  ])

步骤 9:将 csv 数据读入数据帧

我们将 csv 读入一个DataFrame，确保我们提到我们有一个头，并且我们还用 0:

df_raw = spark\
  .read\
  .option("header", "true")\
  .schema(schema)\
  .csv("YOUR_PATH/train.csv")df = df_raw.na.fill(0)

步骤 10: C 将标称值转换为数值

在浏览这一步的代码之前，让我们简单地浏览一下 Spark ML 的一些概念。他们引入了 ML pipelines 的概念，ML pipelines 是建立在DataFrames之上的一组高级 API，使得将多个算法合并到一个进程中变得更加容易。管道的主要元件是Transformer和Estimator。第一个可以表示一个可以将一个DataFrame转换成另一个DataFrame的算法，而后者是一个可以适合一个DataFrame来产生一个Transformer的算法。

为了将标称值转换成数值，我们需要为每列定义一个Transformer:

sexIndexer = StringIndexer()\
  .setInputCol("Sex")\
  .setOutputCol("SexIndex")\
  .setHandleInvalid("keep")

cabinIndexer = StringIndexer()\
  .setInputCol("Cabin")\
  .setOutputCol("CabinIndex")\
  .setHandleInvalid("keep")

embarkedIndexer = StringIndexer()\
  .setInputCol("Embarked")\
  .setOutputCol("EmbarkedIndex")\
  .setHandleInvalid("keep")

我们使用StringIndexer来转换这些值。对于每个Transformer,我们将定义包含修改值的输入列和输出列。

步骤 11: A 将列组装成特征向量

我们将使用另一个Transformer将 XGBoost Estimator分类中使用的列组装成一个向量:

vectorAssembler = VectorAssembler()\
  .setInputCols(["Pclass", "SexIndex", "Age", "SibSp", "Parch", "Fare", "CabinIndex", "EmbarkedIndex"])\
  .setOutputCol("features")

步骤 12:定义 XGBoostEstimator

在这一步中，我们将定义产生模型的Estimator。这里使用的大多数参数都是默认的:

xgboost = XGBoostEstimator(
    featuresCol="features", 
    labelCol="Survival", 
    predictionCol="prediction"
)

我们只定义了feature, label(必须匹配来自DataFrame的列)和包含分类器输出的新的prediction列。

步骤 13: B 建立管道和分类器

在我们创建了所有单独的步骤之后，我们可以定义实际的管道和操作顺序:

pipeline = Pipeline().setStages([sexIndexer, cabinIndexer, embarkedIndexer, vectorAssembler, xgboost])

输入DataFrame将被转换多次，最终将产生用我们的数据训练的模型。

步骤 14:训练模型并根据新的测试数据进行预测

我们首先将数据分为训练和测试，然后我们用训练数据拟合模型，最后我们看看我们为每个乘客获得了什么预测:

trainDF, testDF = df.randomSplit([0.8, 0.2], seed=24)model = pipeline.fit(trainDF)model.transform(testDF).select(col("PassengerId"), col("prediction")).show()

PySpark UDFs 和恒星膨胀

原文：towardsdatascience.com/pyspark-udf…

在很大程度上，我发现从主要从事 SQL 工作到主要从事 Spark 工作的转变是平稳的。熟悉 SQLalchemy 和 Django 这样的 ORM，适应起来并不难。选择、过滤、连接、分组以及诸如此类的事情都或多或少地按照它们在 SQL 中的方式工作。我认为构建一个数据查询是有逻辑的，对这种逻辑的感觉是战斗中最困难的部分——剩下的只是实现。

在我看来，Spark 的难点在于资源管理。找出内核、内存(堆内和堆外)和执行器的正确平衡是一门艺术，而不是科学，Spark 给你的错误消息通常只能提供最少的信息。我发现很少有好的 Spark 培训材料。也许我因为主要使用 PyData 和 SQL 堆栈而被宠坏了:当我有关于 Pandas 或 Postgres 的问题时，我会搜索它，它几乎总能给我一些相当完整的文档和工作示例，经常给我一些信息丰富的博客帖子，并且通常给我至少一个有用的堆栈交换问题。当我有一个关于 Spark 的问题时，我会在 Google 上搜索它，通常会得到一个文档页面，简单地确认该方法在技术上是存在的。仅此而已。

当涉及到 PySpark 用户定义函数(UDF)时，我发现资源管理特别棘手。Python UDFs 是在 Spark 中进行数据科学研究的一种方便且经常必要的方式，尽管它们不如使用内置 Spark 函数甚至 Scala UDFs 高效。使用 Python UDF 时，了解 Spark 如何评估它很重要。考虑下面的例子，该例子假设火花数据帧‘SDF’具有两个数字列‘col 1’和‘col 2 ’:

**import** pyspark.sql.functions as f
**import** pyspark.sql.types as t**def** my_function(arg1, arg2):
    argsum **=** arg1 **+** arg2
    argdiff **=** arg1 **-** arg2
    argprod **=** arg1 ***** arg2
    **return** argsum, argdiff, argprodschema **=** t.StructType([
    t.StructField('sum', t.FloatType(), False),
    t.StructField('difference', t.FloatType(), False),
    t.StructField('product', t.FloatType(), False),
])my_function_udf **=** f.udf(my_function, schema)results_sdf **=** (
    sdf
    .select(
        my_function_udf(
            f.col('col1'), f.col('col2')
        ).alias('metrics'))   # call the UDF
    .select(f.col('metrics.*')) # expand into separate columns
)

如果在执行上述代码块后调用` results_sdf.explain()'，您应该会看到这样一行内容:

BatchEvalPython [my_function(col1#87, col2#88), my_function(col1#87, col2#88), my_function(col1#87, col2#88)]

这意味着，为了对度量字段进行星形扩展，Spark 将调用您的 udf 三次——对模式中的每个项目调用一次。这意味着你将使用一个已经低效的函数并多次运行它。

通过对代码做一点小小的修改，就可以让 Spark 只计算一次 UDF:

results_sdf **=** (
    sdf
    .select(
        f.explode(
            f.array(
                my_function_udf(f.col('col1'), f.col('col2'))
            )
        ).alias('metrics')
    )
    .select(f.col('metrics.*'))
)

将结果封装在一个数组中，然后分解该数组会产生一些开销，但是与只计算一次 UDF 所节省的资源相比，这些开销是微不足道的:

BatchEvalPython [my_function(col1#87, col2#88)]

您可以通过在进行 star 扩展之前对数据帧进行持久化或检查点操作来获得相同的结果，但是这样会耗尽内存和磁盘空间，您可能不希望这样做。

Python 和 Slack:天生一对

原文：towardsdatascience.com/python-and-…

(Source)

如何使用 Python 以编程方式发送 Slack 消息、发布绘图和监控机器学习模型

当你知道你能用 Python 做多少事情时，生活就会变得更加美好。当我阅读 用 Python 自动化枯燥的东西，并看到有一些例行任务——比如任何与电子表格有关的事情——我不再需要浪费时间时，我的日常工作流程发生了第一次转变。相反，我可以花几分钟写一个 Python 程序(好吧，一开始可能要花几个小时)，运行脚本，然后坐下来看乏味的工作自行完成。

第二个转变发生在我意识到几乎任何带有 API 的服务— 应用编程接口 —都可以用 Python 操作的时候。你可以在 Spotify ( Spotipy 库)、Twitter(python-Twitter)、Wikipedia(Wikipedia API)和 Slack(Slackerfor Python)等应用中做的任何事情，都可以通过 Python 代码来完成。

这意味着您不必局限于在应用程序中与这些服务进行交互，而是可以编写代码来自动化复杂的工作流或构建新工具。

在本文中，我们将看到如何使用 Slacker Python 库以编程方式与 Slack 交互。我们将能够从工作区检索任何数据，更改频道和用户的设置，发布消息，上传文件，创建应用程序，甚至实时监控机器学习结果。完整的代码可以在 GitHub 的 Jupyter 笔记本上获得。

Real-time monitoring of machine learning in Slack.

懒鬼入门

Slacker 是 Slack API 的 Python 接口。它包装了 Slack API 服务(完全由 Slack 支持)，并允许我们编写 Python 代码，而不是自己格式化对 API 的请求。这意味着构建查询的时间要少得多，与 Slack 的交互也更容易。在使用 Slacker 库时,Slacker API 方法文档非常有用(它的文档相对较少)。无论你想在闲暇时做什么，只要你愿意做一点搜索，你都可以通过这个库来做！

入门指南

首先，您需要创建一个松弛工作空间。我假设如果你有信心编写 Python 代码，你可以自己处理这一步。我建议创建一个新的工作空间，在这里你是测试交互的管理员。下一步是获取遗留 API 令牌。如果您已登录工作区，请前往此链接。确保将您的令牌放在安全的地方！

使用您的 API 令牌向 Slacker 进行身份验证，如下所示:

from slacker import Slacker# Authenticate with slacker
slack = Slacker(slack_api_token)

通过打印出工作区的名称来检查您是否已连接:

# Check for success
if slack.api.test().successful:
    print(
        f"Connected to {slack.team.info().body['team']['name']}.")
else:
    print('Try Again!') **Connected to Data Analysis.**

与时差互动

在 slack 中你可以做的任何事情(好的，几乎任何事情)都可以通过 Python 与 API 的接口来完成。(点击查看完整的方法列表)。例如，下面是我们可以对渠道做的一切:

信息检索

让我们从一些简单的数据检索开始。每次我们在Slacker中使用不同的函数时，我们都会得到一个响应对象，其中body保存结果(如果请求成功)。我们可以检索很多不同的信息。例如，以下是渠道和目的:

# Make a request to get the channels
r = slack.channels.list()
channels = r.body*# Iterate through channels*
for c in channels['channels']:
    print(f'Channel {c["name"]} Purpose: {c["purpose"]["value"]}') **Channel general Purpose: This channel is for workspace-wide communication and announcements. All members are in this channel.**

**Channel python_content Purpose: Data Science and Python**

**Channel random Purpose: Deep philosophical discussions****Channel testing_exp Purpose: Experimental testing of interactions.**

如果我们想检查用户(成员)，下面是代码和结果:

from IPython.display import Image# Find all users
users = slack.users.list().bodyfor u in users['members']:
    *# Print some information*
    print(f'User: {u["name"]}, Real Name: {u["real_name"]},                  
            Time Zone: {u["tz_label"]}.')
    print(f'Current Status: {u["profile"]["status_text"]}')

    *# Get image data and show*
    Image(user['profile']['image_192'])

Users in our workspace

这个工作区挺寂寞的！我们可以在频道中搜索文件或消息，查看频道的历史记录，甚至查看“请勿打扰”设置:

(在这种情况下，用户是指 id。我们可以找到带有slack.users.get_user_id(username)的用户名的用户 id。

更改设置和属性

我们不仅可以找到我们想要的任何信息，还可以改变属性。也许我想告诉我的团队让我一个人呆着:

# Set do not disturb for 2 hours
slack.dnd.set_snooze(num_minutes=120)

我还可以更改我的个人资料设置:

slack.users.profile.set(user = 'wjk68', name = 'status_text', 
                        value = 'Writing some code')
slack.users.profile.set(user = 'wjk68', name = 'status_emoji',
                        value = ':male-technologist')

关于表情符号的话题，你可以使用表情符号代码来指定你想要的图标。最简单的方法就是去 Slack，搜索你想要的表情符号，然后复制出现的代码:

Searching for an emoji code.

想创建一个新的频道并设定目的？两行 python 代码:

# Create a new channel and set purpose
slack.channels.create('python_content_new')
slack.channels.set_purpose('python_content_new', 'Data Science and Python')

发布消息

当然，我们不只是想成为信息的被动消费者。我们要和世界对话！幸运的是，Slacker让我们可以轻松发布到任何频道:

# Post a message
slack.chat.post_message(channel='python_content',
                            text='Have a great day!',
                            username='Python Test',
                            icon_url='http://devarea.com/wp-content/uploads/2017/11/python-300x300.png')

如果我们设置了username,那么消息将作为机器人发布。我们可以通过指定 url 或表情符号来选择图标。我们也可以用<@user_id>提到具体用户或者犯下终极之罪通知大家:

slack.chat.post_message(channel='python_content',
                            text='<!everyone> *This is not atest!*',
                            username='Alert',
                            icon_emoji=':female-firefighter:')

消息可以像我们想要的那样复杂。使用附件，我们可以格式化消息，甚至创建游戏！有关所有选项，请参考 Slack API 关于格式化消息的文档。

Message formatting

App created via a message

您可以使用交互消息构建复杂的应用程序工作流。

上传文件

上传本地文件是另一个单行程序:

slack.files.upload(file_='images/volcano_crater.jpg',
                   channels=['random'], title='Volcano Crater',
                   initial_comment='This would make a great          
                                    display background')

Uploaded files.

如果我们已经做了一些很酷的分析，并想与团队分享这些图，我们保存这些数字并上传:

我们还可以使用 API 删除文件或消息、添加评论、创建私人聊天、邀请用户、设置提醒等等。

监控机器学习训练

好了，是时候认真对待一些真正的工作了。在这里，我们将发送消息来监控卷积神经网络(CNN)的训练进度。我正在使用 Keras 的脚本来训练 CNN 识别 MNIST 数字。有了 Keras 中的自定义回调，我们可以在每个时期结束时用当前统计数据向 Slack 发送一条消息。S ee 笔记本完整代码，但基本轮廓在下面(这是伪代码，不会太跑):

现在，我们可以在 Slack 中获得实时深度学习更新！

在训练结束时，我们可以创建一些训练曲线并发布出来:

发布预测

最后，一旦我们的模型训练完毕，我们就可以发布来自测试集的预测:

Predictions from convolutional neural network on test set.

这款做的相当不错！对于这个简单的例子，监控可能是不必要的，但是有很多用例跟踪一个模型或者发布持续集成结果。我整夜运行模型，当我不想去命令窗口查看进度时，只查看 Slack 是有用的。

当有事情需要你注意时，自动发布到 Slack 或通知你的写作工具可以让你把注意力转移到更重要的事情上。最终，程序化的工作流减少了花费在繁琐任务上的时间和精力。

Reduce the amount of tedium in your life with Python! (Book available for free).

结论

虽然 Slack 等应用程序可以用来娱乐，但如果使用得当，它们也可以提高生产率。此外，如果我们意识到这些应用程序可以通过 Python 访问它们的 API，我们就可以通过编程来控制它们，从而提高效率。

在本文中，我们看到了如何通过 Python 中的Slacker库与 Slack 交互。这个库让我们可以访问 Slack API，这意味着我们几乎可以控制工作空间的每个方面。除了其他事情，我们可以

检索频道、消息和用户信息
更改和管理用户、渠道和团队设置
发布包括应用程序在内的消息
跟踪机器学习的进度并绘制结果

如果 Slack 不是你最喜欢的应用程序(尽管它应该取代你的电子邮件)，看看 Python API 接口的列表。即使这个特殊的用例对你来说没有吸引力，但是我们可以使用 Python 来完成日常任务的想法是很有说服力的，因为它使我们更有效率。

一如既往，我欢迎反馈和建设性的批评。可以通过 Twitter @koehrsen_will 或者通过我的个人网站 willk.online 找到我。

基于 Python 的 Matplotlib 绘图

原文：towardsdatascience.com/python-base…

如果你是一个使用 Python 的分析师，你的面包和黄油可能由 matplotlib、pandas、numpy 和 sklearn 组成。在这篇博客中，我将讲述使用 matplotlib 绘图的基础知识。所有的 Jupyter 笔记本都在这里: https://github . com/snaz rul 1/PyRevolution/tree/master/matplotlib

介绍

图形和轴

2D 策划

三维绘图

数据科学的 Python 基础

原文：towardsdatascience.com/python-basi…

Source: www.quora.com/Can-you-sug…

Python 数据类型

在 Python 中，我们有许多数据类型。最常见的有 float(浮点)、int(整数)、str(字符串)、bool(布尔)、list、dict(字典)。

浮点数-用于实数。
int——用于整数。
str -用于文本。我们可以用单引号'value'，双引号"value"，或者三引号"""value"""来定义字符串。用三重引号括起来的字符串可以在多行上，新行将包含在变量值中。它们也用于编写函数文档。
bool -用于真值。用于对数据执行过滤操作。
list -用于存储值的集合。
dict -用来存储一个键值对。

我们可以使用type(variable_name)函数来检查特定变量的类型。Python 中的运算符根据变量的类型有不同的行为，并且每种类型都有不同的内置方法。

这里我们可以看一些用 Python 创建浮点、整数、字符串和布尔值的例子。

Python 列表

Python 列表是一种基本的序列类型。我们可以使用这种类型来存储值的集合。一个列表可以包含任何类型的值。一个列表可能包含另一个值的嵌套列表。这并不常用，但是您可以拥有一个混合了 Python 类型的列表。您可以使用方括号创建一个新的，如下所示:

fruits = ["pineapple", "apple", "lemon", "strawberry", "orange", "kiwi"]

子集列表

您可以使用索引从列表中获取一个或多个元素。在 Python 中，索引从0.开始，因此列表中的第一个元素将有一个索引0。我们也可以使用负索引来访问元素。列表中的最后一个元素将有一个索引-1，最后一个元素之前的元素将有一个索引-2，依此类推。Python 中还有一个叫做列表切片的东西，可以用来从一个列表中获取多个元素。我们可以这样用:sliceable[start_index:end_index:step].

start_index是切片的起始索引，该索引处的元素将包含在结果中，默认值为0。
end_index是切片的结束索引，该索引处的元素将不包含在结果中，默认值为length of the list。此外，如果步长为负，默认值可以是- length of the list -1。如果跳过这一步，您将获得从开始索引到结尾的所有元素。
step是指数增加的量，默认值为1。如果我们为步长设置一个负值，我们将向后移动。

列表操作

我们可以使用append方法或plus operator向列表中添加一个或多个元素。如果在两个列表上使用加号运算符，Python 将给出两个列表内容的新列表。
我们可以使用已经用于索引和列表切片的方括号将一个或多个元素更改为 list。
我们可以用remove(value)方法从列表中删除一个元素。此方法将删除带有传递值的列表的第一个元素。

理解 Python 中列表的幕后工作方式很重要。当你创建一个新的列表my_list时，你将列表存储在你的计算机内存中，列表的地址存储在my_list变量中。变量my_list不包含列表中的元素。它包含对列表的引用。如果我们像这样复制一个只有等号的列表my_list_copy = my_list，你将在my_list_copy变量中复制引用，而不是列表值。所以，如果你想复制实际值，你可以使用list(my_list)函数或切片[:]。

Python 词典

字典用于存储键值对。当你想用唯一键索引你的值时，它们会很有帮助。在 Python 中，你可以使用花括号创建一个字典。此外，键和值由冒号分隔。如果我们想得到给定键的值，我们可以这样做:our_dict[key]。

字典与列表

让我们看一个例子，将列表和字典进行比较。假设我们有一些电影，你想为它们存储收视率。此外，我们希望通过电影名称快速访问电影的分级。我们可以通过使用两个列表或一本字典来做到这一点。在示例中,movies.index(“Ex Machina”)代码返回“ex 玛奇纳”电影的索引。

Movie rating using lists.

Movie ratings using a dictionary.

在这种情况下，使用字典是一种更直观和方便的方式来表示评级。

字典操作

我们可以添加、更新、从我们的字典中删除数据。当我们想要添加或更新数据时，我们可以简单地使用这个代码our_dict[key] = value。当我们想要删除一个键-值对时，我们这样做del(our_dict[key])。

我们还可以像这样检查给定的键是否在我们的字典中:key in our_dict。

功能

函数是解决特定任务的一段可重用代码。我们可以像这样使用def关键字来编写函数:

但是 Python 中有很多内置函数，比如max(iterable [, key]), 、min(iterable [, key])、type(object)、round(number [, ndigits])等。因此，在许多情况下，当我们需要一个函数来解决一个给定的任务时，我们可以研究一个内置的函数来解决这个任务或者一个 Python 包来解决这个问题。我们不必“多此一举”。

大多数函数接受一些输入并返回一些输出。这些函数有参数，Python 将函数调用中传递的输入与参数匹配。如果一个参数用方括号括起来，那么它就是可选的。

我们可以使用函数help([object])或?function_name来查看任何函数的文档。如果我们使用 Jupyter Notebook，help函数将显示当前单元格中的文档，而第二个选项将显示页面中的文档。

方法

我们已经看到，我们有字符串，浮点，整数，布尔，等等。在 Python 中。这些数据结构的每一个都是一个对象。方法是根据对象类型对给定对象可用的函数。因此，每个对象都有一个特定的类型和一组依赖于该类型的方法。

不同类型的对象可以有相同名称的方法。根据对象的类型，方法有不同的行为。

小心！一些方法可以改变它们被调用的对象。例如，在列表类型上调用的append()方法。

包装

模块是包含 Python 定义和语句的文件。模块指定了解决特定问题的函数、方法和新的 Python 类型。

包是目录中模块的集合。Python 有许多可用的包，涵盖了不同的问题。比如“NumPy”、“matplotlib”、“seaborn”、“scikit-learn”都是非常著名的数据科学包。

“NumPy”用于高效地处理数组
“matplotlib”和“seaborn”是用于数据可视化的流行库
“scikit-learn”是一个强大的机器学习库

默认情况下，Python 中有一些可用的包，但也有很多我们需要但默认情况下没有的包。如果我们想使用某个包，我们必须已经安装了它，或者只是使用 pip(Python 的包维护系统)来安装它。

然而，还有一种东西叫做“蟒蛇”。

Anaconda 发行版是一个免费的、易于安装的包管理器、环境管理器和 Python 发行版，包含 1，000 多个开源包，并有免费的社区支持。

所以，如果你不想安装很多包，我会推荐你使用“Anaconda”。这个发行版中有这么多有用的包。

导入报表

一旦安装了所需的包，就可以将它们导入到 Python 文件中。我们可以从中导入整个包、子模块或特定功能。此外，我们可以为包添加别名。从下面的例子中，我们可以看到导入语句的不同方式。

Simple Import Statement

Import statement With an Alias

Import Submodule From a Package With an Alias

Import Only One Function From a Package

我们也可以做这样的事情from numpy import *。这里的星号表示从该模块导入所有内容。这个 import 语句在当前名称空间中创建对由numpy模块定义的所有公共对象的引用。换句话说，我们可以使用numpy中所有可用的函数，只使用不带前缀的名字。例如，现在我们可以使用 NumPy 的绝对函数，如absolute()而不是numpy.absolute()。但是，我不建议您使用它，因为:

如果我们像那样从一些模块中导入所有的函数，那么当前的名称空间将会充满如此多的函数，如果有人查看我们的代码，他或她可能会搞不清哪个包是特定的函数。
如果两个模块有一个同名的函数，第二个导入将覆盖第一个的函数。

NumPy

NumPy 是使用 Python 进行科学计算的基础包。它非常快而且容易使用。这个软件包帮助我们逐元素地进行计算。

常规的 Python 列表不知道如何对元素进行操作。当然，我们可以使用 Python 列表，但是它们很慢，并且我们需要更多的代码来实现想要的结果。在大多数情况下，更好的决定是使用NumPy。

与常规 Python 列表不同，NumPy 数组总是只有一种类型。如果我们将不同类型的数组传递给np.array()，我们可以使用参数dtype选择想要的类型。如果未给定此参数，则类型将被确定为保存对象所需的最小类型。

NumPy Array — Type Converting

NumPy 数组自带属性和方法。还记得 Python 中的操作符对不同的数据类型有不同的行为吗？在 NumPy 中，操作符的行为是基于元素的。

Operators on NumPy Array

如果我们检查 NumPy 数组的类型，结果将是numpy.ndarray。Ndarray 表示 n 维数组。在上面的例子中，我们使用了一维数组，但是没有什么可以阻止我们制作 2 维、3 维、4 维或更多维的数组。我们可以在一个数组上做子集化，与这个数组的维数无关。我将给你们展示一些二维数组的例子。

Subsetting 2-dimensional arrays

如果我们想知道数组有多少个维度，每个维度有多少个元素，我们可以使用shape属性。对于二维数组，元组的第一个元素是行数，第二个元素是列数。

NumPy Shape Attribute

基本统计

分析数据的第一步是熟悉数据。NumPy 有很多方法可以帮助我们做到这一点。我们将看到一些对数据进行统计的基本方法。

np.mean() -返回算术平均值(元素之和除以元素长度)。
np.median() -返回中间值(传递的数组的排序副本的中间值，如果数组的长度是偶数-将计算两个中间值的平均值)
np.corrcoef() -返回一个相关矩阵。当我们想知道数据集中的两个变量之间，或者换句话说，两个长度相同的数组之间，是否存在相关性时，这个函数非常有用。
np.std() -返回标准偏差

Generating Basic Statistics using NumPy

从上面的例子中，我们可以看到学习时间和成绩之间有很高的相关性。同样，我们可以看到:

学习时间的平均值为 4.6 小时
学习时间的中位数是 4.0
学习时间的标准偏差是 3.2

NumPy 也有一些基本的函数，如np.sort()和np.sum()，它们也存在于基本的 Python 列表中。这里需要注意的一点是，NumPy 在数组中强制使用单一类型，这样可以加快计算速度。

练习

我已经准备了一些练习，包括子集，元素操作和基本统计。如果你愿意，你可以试着解决它们。

互动版

这里的是在 Deepnote (云托管 Jupyter 笔记本平台)上传的这篇文章的交互版本。请随意查看并使用示例。

我的其他博客文章

商务化人际关系网

这是我在 LinkedIn 上的简介，如果你想和我联系的话。我将很高兴与你联系在一起。

最后的话

谢谢你的阅读。如果你喜欢这个帖子，请按住拍手键分享给你的朋友。另外，我很高兴听到你的反馈。如果你想在我写新博客时得到通知，你可以订阅我的简讯。

Python 基础:迭代、可迭代对象、迭代器和循环

原文：towardsdatascience.com/python-basi…

Source: www.quora.com/Can-you-sug…

看完这篇博文，你就知道了:

Python 中的迭代如何工作幕后
什么是迭代器和迭代器以及如何创建它们
什么是迭代器协议
什么是懒评
什么是发生器函数和发生器表达式

Python 的 for 循环

Python 没有传统的for循环。让我们来看一段伪代码，看看传统的 for 循环在许多其他编程语言中是什么样子的。

A Pseudocode of for loop

在进入循环之前，初始化器部分只执行一次。
条件段必须是一个布尔表达式。如果该表达式的计算结果为 True，则执行下一次循环迭代。
迭代器部分定义了每次迭代后发生的事情。

现在，让我们看看如何用 JavaScript 编写传统的 for 循环。

Simple For Loop in JavaScript

输出:

许多其他编程语言都有这种 for 循环，但是 Python 没有。不过， Python 有个叫**for** 循环的东西，但是它的工作方式就像是 foreach 循环 。

Simple For Loop in Python

输出:

从上面的例子中，我们可以看到在 Python 的for循环中，我们没有任何我们之前见过的部分。没有初始化、条件或迭代器部分。

可重复的

iterable 是一个能够让逐个返回其成员 的对象。换句话说，iterable 是可以用 Python 中的for循环遍历的任何东西。

顺序

序列是非常常见的类型的可迭代。内置序列类型的一些示例有列表、 字符串 和元组。

Lists, Tuples, and Strings in Python

它们通过__getitem()__特殊方法(索引)使用整数索引支持高效的元素访问，并定义一个返回序列的长度的__length()__方法。

Element access using indices.

输出:

10
blueberry
❤

同样，我们可以对它们使用切片技术。如果你不知道什么是切片，可以在我讲解的时候查一下我之前文章的一篇。切片技术的解释在“子集列表”一节中。

Slicing Sequences.

输出:

[10, 12]
('pineapple', 'blueberry')
love Python ❤️

其他可重复项目

Python 中的很多东西都是可迭代的，但并不都是序列。字典、文件对象、集合、生成器都是可迭代的，但没有一个是序列。

Sets, Dictionaries, Files, and Generators.

Python 的 for 循环不使用索引

让我们考虑一下如何在不使用 Python 中的for循环的情况下循环遍历一个 iterable。我们中的一些人可能认为我们可以使用一个while循环并生成索引来实现这一点。

输出:

这种方法似乎对列表和其他序列对象非常有效。非序列对象呢？他们不支持索引，所以这种方法对他们不适用。

输出:

**--------------------------------------------------------------------**
**TypeError**                          Traceback (most recent call last)
**<ipython-input-22-af1fab82d68f>** in <module>**()**
      2 numbers **=** **{1,** **2,** **3,** **4,** **5,** **6,** **7,** **8,** **9,** **10}**
      3 **while** index **<** len**(**numbers**):**
**----> 4** print**(**numbers**[**index**])**
      5     index **+=** **1**

**TypeError**: 'set' object does not support indexing

嗯，但是 Python 的 for 循环是如何处理这些可重复项的呢？我们可以看到它适用于集合。

Iterate over a set.

输出:

迭代器

迭代器是一个表示数据流的对象。您可以通过将iter()内置函数应用于可迭代对象来创建迭代器对象。

输出:

<list_iterator object at 0x000001DBCEC33B70>
<tuple_iterator object at 0x000001DBCEC33B00>
<str_iterator object at 0x000001DBCEC33C18>

你可以使用一个迭代器来手动循环到它来自的可迭代。迭代器向内置函数next()的重复传递会返回流中的连续项。一旦你消费了迭代器中的一个条目，它就消失了。当没有更多的数据可用时，产生一个StopIteration异常。

输出:

10
20
30**--------------------------------------------------------------------**
**StopIteration**                      Traceback (most recent call last)
**<ipython-input-14-fd36f9d8809f>** in <module>**()**
      4 print**(**next**(**iterator**))**
      5 print**(**next**(**iterator**))**
**----> 6** print**(**next**(**iterator**))**

**StopIteration**:

在幕后，Python 的for循环正在使用迭代器。

理解 Python 的 for 循环是如何工作的

Source: www.incredible-web.com/blog/perfor…

现在，我们知道了什么是 iterables 和迭代器，以及如何使用它们。我们可以尝试定义一个循环遍历 iterable 的函数，而不使用for循环。

为此，我们需要:

从给定的可迭代对象创建一个迭代器
从迭代器中反复获取下一个项目
执行想要的动作
停止循环，如果我们在尝试获取下一个项目时遇到了Stop iteration异常

Custom For Loop in Python. Source: opensource.com/article/18/…

让我们试着用一组数字和print内置函数来使用这个函数。

Custom For Loop in Python - Usage.

输出:

我们可以看到，我们定义的函数非常适合集合，集合不是序列。这一次我们可以通过任何可迭代的并且它将工作。在幕后，Python 中所有形式的循环遍历 iterables 都是这样工作的。

迭代器协议

迭代器对象需要支持以下两种方法，它们共同构成迭代器协议:

迭代器。iter() 返回迭代器对象本身。这是允许容器(也称为集合)和迭代器与for和in语句一起使用所必需的。
迭代器。next() 从容器中返回下一个项目。如果没有更多的项目，引发 StopIteration 异常。

从上面的方法描述中，我们看到我们可以在迭代器上循环。所以迭代器也是可迭代的。

记住，当我们将iter()函数应用于一个可迭代对象时，我们得到了一个迭代器。如果我们在迭代器上调用iter()函数**，它总是返回给我们自己。**

输出:

True
100
200
300

关于迭代器的附加注释

这听起来可能有点令人困惑。但是，如果第一次的事情没有全部理解，也不用担心。让我们回顾一下！

一个可迭代的是你可以循环遍历的东西。
一个迭代器是一个代表数据流的对象。它在一个 iterable 上进行迭代。

此外，在 Python 中，迭代器也是可迭代的，充当它们自己的迭代器。

然而，区别在于迭代器没有一些可迭代的特性。它们没有长度并且不能被转位。

例子

Iterators No Length Error

输出:

**--------------------------------------------------------------------**
**TypeError**                          Traceback (most recent call last)
**<ipython-input-15-778b5f9befc3>** in <module>**()**
      1 numbers **=** **[100,** **200,** **300]**
      2 iterator **=** iter**(**numbers**)**
**----> 3** print**(**len**(**iterator**))**

**TypeError**: object of type 'list_iterator' has no len()

Indexing Iterators Error

输出:

**--------------------------------------------------------------------**
**TypeError**                          Traceback (most recent call last)
**<ipython-input-16-64c378cb8a99>** in <module>**()**
      1 numbers **=** **[100,** **200,** **300]**
      2 iterator **=** iter**(**numbers**)**
**----> 3** print**(**iterator**[0])**

**TypeError**: 'list_iterator' object is not subscriptable

迭代器很懒

Source: giphy.com/gifs/animal…

迭代器允许我们使用和创建惰性可迭代对象，它们不做任何工作，直到我们向它们请求下一项。

来源:https://open source . com/article/18/3/loop-better-deep-look-iteration-python

由于它们的懒惰，迭代器可以帮助我们处理无限长的迭代器。在某些情况下，我们甚至不能在内存中存储所有的信息，所以我们可以使用迭代器，它可以在我们每次请求时给出下一项。迭代器可以为我们节省大量内存和 CPU 时间。

这种做法叫做懒评。

迭代器无处不在

我们已经看到了一些迭代器的例子。此外，Python 有许多内置的迭代器类。例如，enumerate和reversed对象是迭代器。

列举例子

输出:

<class 'enumerate'>
(0, 'apple')

反例

输出:

<class 'reversed'>
blueberry

Python 的zip、map和filer对象也是迭代器。

Zip 示例

输出:

<class 'zip'>
(1, 1)
(2, 4)

地图示例

输出:

<class 'map'>
1
4

过滤器示例

输出:

<class 'filter'>
3

而且 Python 中的文件对象也是迭代器。

输出:

<class '_io.TextIOWrapper'>
This is the first line.

This is the second line.

This is the third line.

我们还可以使用items()方法迭代 Python 字典的键值对。

输出:

<class 'dict_items'>
name Ventsislav
age 24

很多人用 Python 解决数据科学问题。在某些情况下，您处理的数据可能非常大。在这种情况下，我们无法将所有数据加载到内存中。

解决方案是将数据分块加载，然后对每个块执行所需的操作，丢弃该块并加载下一个数据块。换句话说我们需要创建一个迭代器。我们可以通过使用熊猫中的read_csv函数来实现这一点。我们只需要指定块大小。

大型数据集示例

在这个例子中，我们将看到一个名为“鸢尾物种的小数据集的想法，但同样的概念也适用于非常大的数据集。我已经更改了栏目名称，你可以在这里找到我的版本。

输出:

{'Iris-setosa': 50, 'Iris-versicolor': 50, 'Iris-virginica': 50}

Python 标准库中和第三方库中有许多迭代器对象。

通过定义类创建自定义迭代器

在某些情况下，我们可能想要创建一个自定义迭代器。我们可以通过定义一个具有 init 、 next 和 iter 方法的类来做到这一点。

让我们试着创建一个自定义迭代器类，生成最小值和最大值之间的数字。

输出:

<class '__main__.generate_numbers'>
40
41
42

我们可以看到这是可行的。然而，使用生成器函数或生成器表达式来创建定制迭代器要容易得多。

生成器函数和生成器表达式

通常，当我们想要创建一个自定义迭代器时，我们使用一个生成器函数或生成器表达式。它们使用起来更简单，并且需要更少的 T21 代码来达到同样的效果。

发电机功能

让我们从 Python 文档中看看什么是生成器函数。

返回一个生成器迭代器的函数。它看起来像一个普通的函数，除了它包含用于产生一系列值的[**yield**](https://docs.python.org/3.7/reference/simple_stmts.html#yield) 表达式，这些值可在 for 循环中使用，或者可以用[**next(**](https://docs.python.org/3.7/library/functions.html#next)**)** 函数一次检索一个。

来源:docs.python.org/3.7/glossar…

现在，我们可以尝试使用生成器函数来重新创建我们的自定义迭代器。

输出:

<class 'generator'>
10
11
12

产量表达式是将生成函数与普通函数分开的东西。这个表达式帮助我们利用迭代器的惰性。

每个[yield](https://docs.python.org/3.7/reference/simple_stmts.html#yield)会暂时挂起处理，记住位置执行状态(包括局部变量和挂起的 try 语句)。当生成器迭代器恢复时，它从停止的地方继续(与每次调用都从头开始的函数相反)。

来源:https://docs . python . org/3.7/glossary . html # term-generator-iterator

生成器表达式

生成器表达式非常类似于****列表理解。就像列表理解一样，一般表达都是简洁。在大多数情况下，它们是用一行代码编写的。

返回迭代器的表达式。它看起来像一个普通表达式，后跟一个定义循环变量、范围的[for](https://docs.python.org/3.7/reference/compound_stmts.html#for)表达式和一个可选的[if](https://docs.python.org/3.7/reference/compound_stmts.html#if)表达式。

来源:https://docs . python . org/3.7/glossary . html # term-generator-expression

通式为: (iterable 中迭代器变量的输出表达式)

让我们看看如何定义一个简单的生成器表达式。

输出:

<class 'generator'>
1
4
9

我们还可以在的 iterable 上添加一个条件表达式。我们可以这样做:

输出:

<class 'generator'>
[4, 16]

它们可以通过多个条件表达式 对****可迭代进行更复杂的过滤。

输出:

<class 'generator'>
[16]

同样，我们可以在的输出表达式上添加一个 if-else 子句 ，如下所示:

输出:

<class 'generator'>
['odd', 'even', 'odd', 'even', 'odd']

要点/总结

一个可迭代的是你可以循环遍历的东西。
序列是可迭代的一种非常常见的类型。
Python 中的很多东西都是可迭代的，但并不都是序列。
一个迭代器是一个代表数据流的对象。它对一个 iterable 进行迭代。您可以使用迭代器来获取的下一个值或对其进行循环。一旦，你在一个迭代器上循环，就没有流值了。
迭代器使用惰性评估方法。
Python 中很多内置的类都是迭代器。
生成器函数是返回迭代器的函数。
一个生成器表达式是返回一个迭代器的表达式。

接下来读什么？

你可以看看 itertools 库。这个库包括创建迭代器的函数，用于有效的循环。
你也可以阅读文档或者阅读/观看下面的一些资源。
我的下一篇文章是关于 Python 中的列表理解。

资源

我的其他博客文章

你也可以看看我以前的博文。

Jupyter 笔记本快捷键
面向数据科学的 Python 基础知识
Python 基础:列表理解
Python 数据科学:Matplotlib 数据可视化简介
使用 Python 的数据科学:使用 pandas 加载、子集化和过滤数据简介
[文本自然语言处理导论](http://Introduction to Natural Language Processing for Text)

时事通讯

如果你想在我发表新的博客文章时得到通知，你可以订阅我的简讯。

商务化人际关系网

这是我在 LinkedIn 上的简介，如果你想和我联系的话。我将很高兴与你联系在一起。

最后的话

谢谢你的阅读。我希望你喜欢这篇文章。如果你喜欢，请按住拍手键，分享给你的朋友。我很高兴听到你的反馈。如果你有什么问题，尽管问。😉

Python 基础:列表理解

原文：towardsdatascience.com/python-basi…

阅读本文后，您将了解到:

Python 中的列表理解是什么
什么是集合理解和字典理解

什么是列表理解？

List comprehensions 为我们提供了一个简单的方法来创建一个基于一些 iterable 的列表。在创建过程中，来自 iterable 的元素可以有条件地包含在新列表中，并根据需要转换。

一个可迭代是你可以在上循环的东西。如果你想要更详细的解释，你可以阅读我之前的博客文章。

列表理解的组成部分包括:

输出表达式 ( 可选)
可迭代
迭代器变量，代表可迭代对象的成员

例子

输出:

[1, 4, 9, 16, 25]

我们还可以创建更高级的列表理解，其中包括在 iterable 上的条件语句。

例子

输出:

[9, 16, 25]

列表理解 vs 循环

列表理解在计算上以及在编码空间和时间上都比循环for更有效。通常，它们是用单行代码编写的。****

让我们看看使用一个for循环得到与上一个例子相同的结果还需要多少空间。

我们可以清楚地看到，上面的列表理解要容易得多。但是，请记住:

每个列表理解都可以重写为 for 循环，但不是每个 for 循环都可以重写为列表理解。

来源:https://trey hunner . com/2015/12/python-list-comprehensions-now-in-color/

计算速度呢？我们可以使用timeit库来比较for循环的速度和列表理解的速度。我们还可以使用number参数传递执行的数量。我们将这个参数设置为 100 万。

输出:

**6.255051373276501
3.7140220287915326**

我已经在我的机器上运行过了，所以你可以得到不同的结果。然而，列表理解的实现在所有情况下都会更快。

列表理解与映射和过滤

列表理解是从函数式编程语言 Haskell 借用来的简洁符号。我们可以把它们看作是filter和map函数的语法糖。

我们已经看到，列表理解可以很好地替代for循环，因为它们更紧凑、更快。

λ函数

Lambda 函数是小型匿名函数。它们可以有任意数量的参数，但只能有一个表达式。

大多数情况下，lambda 函数是作为参数传递给函数的，这些函数需要一个函数对象作为它们的参数之一，比如map和filter。

地图功能

map 函数返回一个迭代器，该迭代器将函数应用于 iterable 的每一项，并产生结果。我们来对比一下列表理解。

输出:

**[1, 4, 9, 16, 25]
[1, 4, 9, 16, 25]**

过滤功能

filter 函数从传递的函数返回 true 的 iterable 的元素中构造一个迭代器。同样，让我们比较一下过滤函数和列表理解。

输出:

**[2, 4]
[2, 4]**

更复杂的列表理解

此外，当我们创建一个列表理解时，我们可以在 iterable 上有许多条件语句。

输出:

**[6, 18]**

而且，我们还可以在输出表达式上有一个 if-else 子句。

输出:

**['small', 'big']**

可读性

我们可以看到一些列表理解可能非常复杂，很难读懂。Python 允许在括号和大括号之间换行。我们可以利用这一点使我们复杂的理解更具可读性。

例如，我们可以把上一个例子转换成这样:

输出:

**['small', 'big']**

然而，要小心列表理解，在某些情况下使用for循环更好。如果你的代码不可读，最好使用 for 循环。

嵌套 For 循环

在某些情况下，我们需要嵌套的for循环来完成一些任务。在这种情况下，我们也可以使用列表理解来达到同样的结果。

假设我们有一个矩阵，我们想把它展平。我们可以像这样用两个for循环轻松做到这一点:

输出:

**[1, 2, 3, 4, 5, 6, 7, 8, 9]**

我们可以使用列表理解来达到同样的结果。提示:for 子句的顺序与原 for 循环中的保持不变。

输出:

[1, 2, 3, 4, 5, 6, 7, 8, 9]

嵌套列表理解

在其他情况下，我们可能需要创建一个矩阵**。我们可以用嵌套列表理解做到这一点。这听起来有点疯狂，但概念很简单。**

一个列表理解返回一个列表，对吗？因此，如果我们将一个列表理解放在另一个列表理解的输出表达式中，我们将得到一个矩阵作为结果。

输出:

[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]

[range](https://docs.python.org/3/library/stdtypes.html#range)类型表示不可变的数字序列，通常用于在[for](https://docs.python.org/3/reference/compound_stmts.html#for)循环中循环特定的次数

来源:docs.python.org/3/library/s…

其他理解

在 Python 中，我们还有字典理解和集合理解**。我们看到的所有原则对于这些理解也是一样的。我们只需要知道一些非常小的细节就可以创建一个字典或一套理解。**

词典释义

为了创建字典理解，我们只需要将括号[]改为花括号{}。另外，在输出表达式中，我们需要用冒号:分隔键和值。

输出:

{'beer': 2.0, 'fish': 5.0, 'apple': 1.0}

集合理解

为了创建一个集合理解，我们只需要将括号[]改为花括号{}。

输出:

{0, 1, 100, 144, 400, 900}

生成器表达式

在这里，我只想提一下，Python 还有一个叫生成器表达式的东西。它们与列表理解非常相似。不同的是，它们使用圆括号().并且，它们不在内存中存储列表。他们使用懒评手法。

如果你使用返回无限流或大量数据的迭代器，那么列表理解是没有用的。在这些情况下，生成器表达式更可取**。**

来源:docs.python.org/3/howto/fun…

如果你想了解更多关于生成器表达式的知识，你可以查看我在之前的博客文章。

摘要

列表理解为我们提供了一个简单的方法来创建一个基于一些可迭代的列表。
这种理解比在循环中使用 a 更加有效。
我们可以在理解中使用条件语句。
对于内置的map和filter 函数，理解是一个很好的选择**。**
我们可以有嵌套的理解。
在 Python 中，我们还有字典理解和集合理解**。**
当我们处理大量数据的无限流时，生成器表达式更好。

资源

我的其他博客文章

你也可以看看我以前的博文。

Jupyter 笔记本快捷键
数据科学的 Python 基础知识
Python 基础:迭代、可迭代、迭代器和循环
Python 数据科学:Matplotlib 数据可视化简介
使用 Python 的数据科学:使用 pandas 加载、子集化和过滤数据简介
[文本自然语言处理导论](http://Introduction to Natural Language Processing for Text)

时事通讯

如果你想在我发表新的博客文章时得到通知，你可以订阅我的简讯。

商务化人际关系网

这是我在 LinkedIn 上的简介，如果你想和我联系的话。我将很高兴与你联系在一起。

最后的话

谢谢你的阅读。我希望你喜欢这篇文章。如果你喜欢，请按住拍手键，分享给你的朋友。我很高兴听到你的反馈。如果你有什么问题，尽管问。😉

用于识别季节性客户的 Python 代码

原文：towardsdatascience.com/python-code…

我以前写过如何使用时间序列来识别数据库中具有季节性使用模式的客户。如果你想详细了解，你可以在这里找到文章。

如果您想长话短说:为了识别具有季节性使用模式的客户，我采用了按月汇总的 customer_id、月、年和使用数据，并按 id、年和月排序。我们只能评估与我们在一起至少 2 年的客户的季节性，以允许算法识别模式。所以数据(完全虚构，只是为了说明)看起来像这样:

您会注意到数据中缺少了五月、八月、九月和十月。这意味着该客户在那几个月没有任何使用。因此，第一项任务是填补数据集中缺失的零。我把数据库里的数据拉进来，命名为“原创”。这里我没有提供连接数据库的代码，因为我们使用 Netezza SQL。

代码如下(有些缩进对于较长的行是不正确的，抱歉！)🙂

import pandas as pa 
import numpy as np ## Outfile is just because we're going to export our results as a .csv to save them. outfile = '[put your file path here].csv' ## Headings in the .csv that I'm going to output filledIn = pa.DataFrame(columns=['customer_id','yr','mnth','usage']) ##original was just the name of my dataframe with data grouped = original.groupby(by='customer_id') 
def yearmonth_to_justmonth(year, month): 
     return year * 12 + month - 1 ##Defining a function to fill in the zeros. def fillInForOwner(group): 
     min = group.head(1).iloc[0] 
     max = group.tail(1).iloc[0]       
     minMonths = yearmonth_to_justmonth(min.yr, min.mnth) 
     maxMonths = yearmonth_to_justmonth(max.yr, max.mnth)
     filled_index = pa.Index(np.arange(minMonths, maxMonths, 1),
       name="filled_months") 
     group['months'] = group.yr * 12 + group.mnth - 1 
     group = group.set_index('months') 
     group = group.reindex(filled_index) 
     group.customer_id = min.customer_id 
     group.yr = group.index // 12 group.mnth = group.index % 12 + 1
     group.usage = np.where(group.usage.isnull(), 0,
       group.usage).astype(int) 
     return group filledIn = grouped.apply(fillInForOwner) 
newIndex = pa.Index(np.arange(filledIn.customer_id.count())) ## Printing out the results to a .csv 
filledIn = filledIn.set_index(newIndex) 
filledIn.to_csv(outfile) ## I also print results on the screen 
print(filledIn)

接下来，我选择在 Python 中为时间序列部分运行 R。实际上，我遇到了一个值得一提的小问题。我在我的计算机上安装了 64 位和 32 位版本的 R，并指向还没有安装我的所有包的 R 版本(来自 Python)。尴尬的真相:我手动将文件从一个文件夹复制粘贴到另一个文件夹。我确信有一种更“正确”的方法，但是将它们复制并粘贴到目录中正确的文件夹是可行的。

还有一个小问题，值得一提的是，用 Python 运行 R 代码并不是我尝试的第一种方法。您实际上可以使用 Python 语言来运行 R 代码，但是我很难做到这一点，所以我选择了 rpy2 路线。

这里我导入 rpy2 来利用 Python 中的 R 代码。这些也是我需要的所有库。

import rpy2 as r 
     from rpy2.robjects.packages import importr 
     from rpy2.robjects import r, pandas2ri, globalenv
     pandas2ri.activate() base = importr('base') 
colorspace = importr('colorspace') 
forecast = importr('forecast') 
times = importr('timeSeries') 
stats = importr('stats')

接下来，我逐一查看了每位顾客。我会找到他们的开始月份/年份和结束月份/年份，并为每个客户创建一个时间序列对象。我包含了一个 try/except 语句，因为我最初尝试在没有 try/except 语句的情况下运行它，在它已经运行了几个小时之后，它被一个客户卡住了，不太理想。

在创建了时间序列对象之后，我简单地询问 R 模型中是否有季节性成分，并打印出客户 id 以及它们是否是季节性的。

 ##Again, this is just for saving your results to a .csv 
outfile = '[put your file path here].csv' 
seasonal_output = pa.DataFrame(columns=['customer_id', 'seasonal']) ### Now we're going to loop through our customers 
for customerid, dataForCustomer in filledIn.groupby(by=['customer_id']): 
     startYear = dataForCustomer.head(1).iloc[0].yr 
     startMonth = dataForCustomer.head(1).iloc[0].mnth 
     endYear = dataForCustomer.tail(1).iloc[0].yr 
     endMonth = dataForCustomer.tail(1).iloc[0].mnth #Creating a time series object 
     customerTS = stats.ts(dataForOwner.SENDS.astype(int),
          start=base.c(startYear,startMonth), 
          end=base.c(endYear, endMonth), frequency=12)
     r.assign('customerTS', customerTS) ##Here comes the R code piece 
     try:  
          seasonal = r(''' 
          fit<-tbats(customerTS, seasonal.periods = 12, use.parallel
          = TRUE) 
          fit$seasonal 
          ''') 
     except: 
          seasonal = 1 
     seasonal_output = seasonal_output.append({'customer_id':
          customerid, 'seasonal': seasonal}, ignore_index=True) 
     print(f' {customerid} | {seasonal} ') print(seasonal_output) 
seasonal_output.to_csv(outfile)

这个输出将成为我正在进行的聚类分析的一个特征。我还将做一些工作来确定每个客户的最小和最大使用月数，并将其存储在数据库中。很快，市场营销将能够利用这一点来开展更加个性化的活动。

如果你想订阅我未来的文章，你可以在这里订阅。

原载于 2018 年 7 月 1 日【datamovesme.com】。

如何设置 Python 数据科学环境—设置使用 Python 处理数据科学问题的 Anaconda 环境

原文：towardsdatascience.com/python-data…

最初发表于【softwarejargon.com】 在我的博客上找到这篇文章的更新版本【https://softwarejargon.com/blog】

在本文中，我将解释并展示如何使用 python 和 Anaconda 以及 PyCharm 来建立一个 Python 数据科学环境，为使用最流行的 Python 库进行机器学习/数据科学的本地实验做好准备。

这篇文章主要针对 Mac 用户，但是，不要惊慌，我将对如何在 Windows 上实现相同的结果进行简短的评论。我自己两个都用，所以没有偏好。

要求—您应该熟悉以下主题:

具备 bash 命令或命令行的基本知识(取决于操作系统，Mac 或 Windows)

将安装以下软件。

下面是感兴趣的 Python 库。如果您有兴趣阅读更多内容，我提供了每个库文档的链接。

安装 Anaconda

Anaconda 可以从这里下载。遵循安装说明。安装没有什么特别的，因此，如果你按照屏幕上的安装说明，一切都会好的。

安装 PyCharm

PyCharm 可以从这里下载。我推荐安装社区版的 PyCharm，因为它是免费的。

至于 Anaconda 安装，同样适用于 Pycharm 安装。安装软件时按照屏幕上的说明操作，一切都会好的。

使用 Conda CLI 创建环境

安装 Anaconda 后，打开一个终端窗口，键入conda并按回车键。如果你看到类似下图的东西，那么你已经成功安装了 Anaconda 和 Conda CLI。

Envs 文件夹的默认路径是/Users/<your user name>/anaconda/envs/，所有创建的环境都将放在这个文件夹中。

在创建一个新环境之前，我总是将 cd 放到 envs 文件夹中。所以如果你想继续 cd 到 envs 文件夹。执行以下命令。

cd /Users/<your user name>/anaconda/envs/

请记住，只有在默认目录下安装了 Anaconda，这种方法才有效。否则，导航到您的安装位置。

为了创建新的环境，请执行以下命令。

conda create --name TestEnv python=3

在我们可以在新环境中安装任何新的 python 库之前，我们需要激活该环境。要激活创建的环境，请执行以下命令。

conda activate TestEnv

接下来，我们要安装四个第三方 Python 库。为此，请执行以下命令。

conda install numpy pandas scikit-learn matplotlib

这应该会安装四个库 numpy、pandas、scikit-learn 和 matplotlib。就开始学习机器学习而言，这四个库应该会让你走得很远。

当库安装完成后，您可以通过启动 Python 控制台来检查一切是否正常。这是通过执行以下命令来实现的。

python

Python 控制台启动并运行后，对四个库分别执行以下命令并按 enter 键。

>>>import numpy 
>>>import pandas 
>>>import sklearn
>>>import matplotlib

如果库安装正确，您应该不会得到任何错误。

在 PyCharm 中创建项目

现在您已经安装了 Anaconda 并创建了一个环境。现在我们想使用 PyCharm 创建一个项目，并使用创建的环境执行 Python 代码。这里我假设您已经安装了 PyCharm。

首先，我们想创建一个文件夹，作为我们的项目文件夹。您可以在计算机上的任意位置创建该文件夹。我经常使用 Dropbox，因此，我所有的本地项目文件夹都是在/Users/<your user name>/Dropbox/project_folders/路径下创建的。

创建一个项目文件夹，例如，名为 ProjectTestEnv。

现在打开 PyCharm 点击打开。当 PyCharm 打开时，您应该会看到类似下图的内容。

浏览到最近创建的项目文件夹，然后单击打开。PyCharm 现在将开始一个新项目。

在 PyCharm 中为我们的项目设置解释器

现在，每次我们执行 Pycharm 项目中的代码时，我们都希望代码使用我们新创建的 Conda 环境，在那里我们已经安装了我们想要使用的库。

当 PyCharm 完成启动新项目时，导航到“py charm”->“Preferences”。

一个新窗口将会打开。选择“翻译”，点击右上角的图标，然后点击“添加…”

一个新窗口将会打开。在这里选择“虚拟环境”，然后单击“现有环境”，然后单击包含“…”的图标。一个新窗口将会打开。在这里，您必须导航到创建的环境，例如/Users/<your user name>/anaconda/envs/TestEnv/bin/python3。现在对所有三个打开的窗口按“确定”。PyCharm 现在应该将创建的环境设置为您的项目解释器。

仅此而已。现在，您可以使用 PyCharm 在项目文件夹中创建 python 文件，只需右键单击文件夹概述并添加新的 python 文件。然后，您可以执行项目文件夹中的任何 python 文件，方法是右键单击该文件并选择“Run ' '”

我发现最有用的 Conda 命令列表

conda create --name <my environment name> python=<python version>

该命令由两部分组成。第一部分conda create --name后面是您想要为您的环境指定的名称，它创建了 conda 环境。下一部分python=3指定您希望在环境中安装哪个版本的 python。通过执行conda create --name TestEnv python=2.7，conda CLI 将创建一个安装了 Python 2.7 的名为 TestEnv 的环境。

source activate <my environment name>

该命令激活特定的环境。如果我们已经创建了一个名为 TestEnv 的环境，我们可以通过执行下面的命令source activate TestEnv来激活这个环境。该命令在 Windows 上略有不同。在 Windows 上，你会写activate TestEnv。

source deactivate

该命令停用环境。在 Windows 上也略有不同。在 Windows 上你会写deactivate。

conda install <library name>

激活已创建的环境后，您可能需要安装额外的库，除非您可以使用预安装的核心 Python 库进行管理。但是，当您需要安装第三方库时，您将希望使用上面的 Conda CLI 命令。例如，在激活环境 TestEnv 之后，您需要安装 pandas 库，这是通过执行conda install pandas来完成的。这将安装最新的可用熊猫图书馆版本。

conda update <library name>

如果您在某个时候需要更新您已经安装的库，您可以通过使用上面的命令来完成。例如，您已经安装了 pandas 库，过一会儿，您需要将库更新到一个新的版本，这是通过执行conda update pandas来完成的。这将把熊猫图书馆更新到最新版本。

conda remove --name <my environment name> <library name>

当您想要从激活的环境中删除已安装的库时，可以使用此命令。例如，您已经创建了环境 TestEnv 并激活了该环境，此外，您还在活动环境中安装了库 pandas。现在你需要删除图书馆熊猫。这是通过执行conda remove --name TestEnv pandas完成的。

conda remove --name <my environment name> --all

当您需要删除已创建的环境及其安装的第三方库时，可以使用此命令。例如，在创建环境 TestEnv 并安装库 pandas 之后。为了删除这个环境及其安装的库，您可以执行conda remove --name TestEnv --all。

conda update

如果需要将整个 Anaconda 安装更新到最新版本，可以执行上面的命令。

如果你有兴趣了解我更多。请访问我在 LinkedIn 上的个人简介【www.linkedin.com/in/vedranma…

感谢阅读。如果你对我将来写的关于机器学习和类似主题的帖子感兴趣，请在媒体和 LinkedIn 上关注我。更多文章即将发表。