学习朱莉娅——最简单的开始
亚历山大·杜默在 Unsplash 上拍摄的照片
如何使用 FizzBuzz 执行循环和条件函数
在本帖中，我们将创建一个函数来解决过于流行的 FizzBuzz 编程挑战。
看完这篇文章，你会知道:
- 如何在 Julia 中创建函数
- 如何执行 for 循环
- 如何创建 if-else 块
- 1:5 意味着什么
- 如何计算一个数被除后的余数
这篇文章是为初级程序员或者那些以前从未听说过 Julia 的人写的。看完这篇文章后，不要指望做惊天动地的大规模并行科学工作负载。就当这是你在茱莉亚这个令人敬畏的世界里卑微的开始。
FizzBuzz 是什么？
如果你从未听说过它， FizzBuzz 是一个简单的计数游戏，旨在教孩子们乘法表。参与者围成一圈，有人从 1 开始计数。下一个人继续 2 等，绕圈。诀窍在于，如果这个数能被 3 整除，那么玩家应该说 Fizz 而不是说这个数。如果这个数字能被 5 整除，那么他们应该说 Buzz 。如果这个数字能被 3 和 5 整除，那么他们应该说 FizzBuzz 。
我猜你可以用任何其他 2 个数字玩这个游戏，但是 3 和 5 是最受欢迎的选择。
这个简单的游戏已经被翻译成一个折磨初学者的编程挑战。这也给了我们一个在 Julia 中练习循环和 if 语句的好机会。让我们看看如何创建一个函数来打印前 n 个数的解。
我之前已经在 BigQuery 中解决了 FizzBuzz，所以如果你有兴趣知道如何使用 PB 级数据仓库解决这个问题，请在这里查看我的文章。
一步一步来
让我们一步一步来，看看如何解决这个问题，而不是简单地讨论这个问题。
我们在做什么？
我发现对这个功能应该实现什么有一个清晰的概念是非常重要的。在我们的例子中，我们希望打印第一个n数字，但是用 Fizz 替换能被 3 整除的数字，用 Buzz 替换能被 5 整除的数字，用 FizzBuzz 替换能被 3 和 5 整除的数字(或者用 Fizz Buzz 替换能被 3 和 5 整除的数字)。
例子？
有一个关于我们想要达到的目标的想法是很好的，但是有时候通过例子来理解一个任务更容易。对于n=3或n=6，我们的函数会输出什么？写下例子将有助于我们找到解决方案，还能让我们检验我们的结果。
因此对于n=3,我们期望得到:
1
2
Fizz
对于 n=6，我们也希望出现“嗡嗡声”:
1
2
Fizz
4
Buzz
Fizz
同样，当我们达到 15 岁时，我们应该说“嘶嘶”。我们也不要忘记这一点！
你的第一个朱莉娅函数
让我们现在开始编码。既然我们正在一个接一个地打印数字，让我们做一个 for 循环。首先，让我们只打印前 n 个数字，然后我们可以稍后将它们更改为嘶嘶声和嗡嗡声。
这是你的第一个 Julia 函数。让我们把它分解一下，看看它有什么作用:
- 功能以
function关键字开始，以end结束。中间的一切都是你的功能块。该函数有一个输入n并且不返回任何内容，因为我们只打印数字。 - 说到打印，我们用的是
println，内置的 Julia 函数，代表 print line。这个打印给定的值并开始新的一行，所以我们所有的数字将整齐地打印在彼此下面。 - 我们这里还有一个 for 循环。这以关键字
for开始，以end结束。我们正在循环的数字是i，所以在每次迭代中，i的值将在 for 循环中改变。 i会有怎样的变化？这由1:n位给出，即定义了从 1 到 n 的范围，每一步递增 1。要了解更多信息，请在此处搜索使用范围对象创建数组。
显然，这个函数不会给出我们需要的东西，但至少我们有一些基本的函数。让我们来测试一下:
julia> fizzbuzz(5)1
2
3
4
5
分步解决
迈克尔·卡鲁斯在 Unsplash 上的照片
让我们修改上面的内容，这样我们就可以为所有能被 3 整除的数字打印出 Fizz 。
我们如何做到这一点？我们可以检查，当除以 3 时，余数是否为 0。这叫做一个数的模。有一个函数可以做到这一点— rem()(或者您可以使用%运算符)！
以下是一些关于rem如何运作的例子:
rem(1,3) -> remainder of 1, when devided by 3 -> 1
rem(3,3) -> remainder of 3, when devided by 3 -> 0
rem(8,3) -> remainder of 8, when devided by 3 -> 2
修改我们的函数给我们:
更好看！所以现在，每当i除以 3 的余数为 0 时，我们打印“Fizz”而不是 I。
Julia 中 if 块的条件部分必须始终计算为布尔值—真或假。
如果你明白上面是怎么回事，你就知道 Julia 里的 if-else 块了！👏
继续下一个
同样的逻辑也适用于能被 5 整除的数字。我们只需要把rem的第二个参数改成 5。
再测试一次，看看我们是否还可以:
julia> fizzbuzz(5)1
2
Fizz
4
Buzz
差不多了，现在我们有嘶嘶声和嗡嗡声了！最后一步是添加当数既可被 3 又可被 5 整除时的情况，即被 15 整除:
julia> fizzbuzz(15)1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
Fizz
不对不对。15 岁还有“嘶嘶”声！这是因为 15 能被 3 整除，所以我们的if-else块只到达第一位，检查这个数是否能被 3 整除，然后愉快地终止，只打印“Fizz”。
我们必须确保先检查 FizzBuzz 案件，然后再做其他事情:
如果你不想被 15 整除，你也可以说:(rem(i，3) == 0) & (rem(i，5) == 0
julia> fizzbuzz(15)1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz
成功！🎉
通过阅读这篇关于 Julia 的介绍性文章，您了解到:
- 功能
- If-else 块
- 对于循环
- 余数函数
你还解决了 FizzBuzz 挑战👏！
我真的很喜欢茱莉亚，所以希望将来能从我这里看到更多关于茱莉亚的内容。如果你对学习这种令人敬畏的语言感兴趣，一定要关注我！
学习机器学习为第四次工业革命做准备
ML 和 AI 课程的相关资料
机器学习——图片来自 freepik
这篇文章将探索关于 ML 和 AI 课程的评论和其他相关材料。我根据自己的经验对它们进行了排名。此外，我还附上了我记得的所有有用的资料，以及一些我觉得非常有用的网站的链接。
概述
第四次工业革命
第四次工业革命将迎来一个全新的商业格局。承诺改变我们与自身和环境互动的方式
这场工业革命超越了技术驱动的变革。它实际上是关于新流程、技术和商业模式的诞生，这些都将颠覆商业。
第四次工业革命(4IR)由几个领域组成，包括:
- 物联网
- 机器人学
- 数据科学
- 机器学习
- 人工智能
- 三维打印
- 商业分析
- 和许多其他技术。
第四次工业革命的关键组成部分之一是大量的数据。每天都有大量的数据被存储和收集。机器学习和人工智能算法可以优化和自动化几个分析过程，这将带来商业上的革命性进步。
随着数据的指数级增长，伴随着技术的快速进步，我们迫切需要成为数据专家。考虑到这一点，我组织了一些与数据科学领域相关的开发课程。
数据科学和机器学习
数据科学旨在从数据中提取尽可能多的洞察力和信息，用于解决复杂的业务流程和辅助决策。
借助数据科学，人们可以发现以前从未想象过的数据中的未知模式和趋势。当有大量数据可以分析以提供更准确的结果时，数据科学是有效和有益的。
机器学习 (ML)是 AI 的一个子集。它是一门让计算机执行和学习没有明确编程的任务的科学。机器学习用于发现数据中的模式并进行预测。
如何开始学习
机器学习和人工智能领域的所有可能性都激起了我的兴趣。即将到来的技术革命的想法是我希望成为其中的一部分。因此，学习和建立我在人工智能和机器学习方面的技能是必不可少的。
我想分享我对最近完成的一些课程的反馈。我参加了一些线下的课程，但是在线学习给了我在任何时候想学什么就学什么的选择。
先决条件
有几个先决条件可以帮助您更好地理解这些概念。在继续之前，您需要了解以下几个方面:
- 微积分基础知识
- 线性代数
- 概率与统计
- 算法和 Python 也是机器学习的先决条件
有益资源/建议
- 机器学习专用数学— Coursera
本课程由伦敦帝国理工学院教授。我必须提到，它们是繁琐的课程，需要大量的奉献和努力才能完成。但是在学习 ML 之前，学习其中解释的概念是至关重要的。
- Josh Starmer 的 stat quest—YouTube
本课程非常适合学习 ML 概念和统计学。本课程将非常复杂的 ML 和统计概念分解成易于理解的部分，便于掌握。我打赌你会喜欢这门课，尤其是有趣的歌唱部分。
- Python for every one—Coursera
这门课程很容易学习和理解。对于学习 Python 来说，这也是一门优秀的初学者课程，它将教授你在开始学习 ML 课程之前需要知道的大部分知识。
- Jupyter 笔记本初学者教程 by Dataquest
我没有选这门课。但是既然强烈推荐，那就应该试一试。
一旦您的 Python 技能很好，您就会想要轻松地使用和操作数据。NumPy、熊猫、Matplotlib 和 Matplotlib 是一些帮助你开始的有用资源。
学习机器学习概念
- 数据分析师 Nanodegree — Udacity
很多人都推荐这门课程，幸运的是，Udacity 最近与沙特 MSK 学院合作。因此，我注册了这个纳米学位。如果你更喜欢实践而不是理论，那么你应该参加更多关于 Udacity 的课程。他们的课程非常注重实践。但是我发现这门课比其他课容易。如果你是一名年轻的开发人员，首先这是一门很好的课程。
- CS221:人工智能:技术与原理—斯坦福
我对这门课程没有任何抱怨；作业和实习都很完美。我们每周都有有趣的编码作业。
- CS229:机器学习—斯坦福
我去年夏天在斯坦福注册了这门课程和 CS221。我分享了我的经验，课程也在网上提供。
这门课很棒。但是如果你不太擅长线性代数，我建议你在选修这门课之前先温习一下。另外，不要把这门课作为你的第一门 ML 入门课。
你可能会发现这个备忘单很有帮助。它是由斯坦福大学毕业生谢尔维·阿米迪设计的。
- 机器学习— Coursera
由吴恩达教授的这门课程无疑是目前最受欢迎的机器学习课程。这门课程理论性很强，所以如果你在注册之前先上一些实践课程，你会更欣赏它。
- 数据科学沉浸式—总装
大会最近与沙特 MSK 学院合作。因此，我注册了这个课程。本课程为离线课程，但由于疫情，本课程不得不在线上进行。然而，它仍然是一个非常好的。这门课的及格与否取决于你是否完成了作业和期末专题。好的一面是这门课程需要大量的编码。
- 深度学习专业化——Coursera
这个专精很神奇，如果你对 AI 有兴趣的话，我建议你上这门课。吴恩达教授解释了人工智能的价值及其带来的改进。本课程简单易学，定义明确。如果你需要一个很好的 AI 职业基础，那就从这门课开始吧。
- 数据科学伦理— Coursera
该课程由密歇根大学提供，它解释了围绕数据科学的一些道德和法律框架。在使用数据时，理解道德是有好处的
结束了！
机器学习是一个非常实用的研究领域，所以最好的学习方法是边做边学。你可以在 Kaggle 找到很多项目
结论！
随着数据科学继续被用于各种技术和业务流程，它将继续导致数字中断。这不再是是否的问题，而是何时的问题。如果你不能快速适应，你就有被落下的危险。
企业必须现在就开始规划未来，并专注于如何利用第四次工业革命来提高其业务能够为客户提供的价值。
学习多维指数:OLAP DBs 的下一件大事
弗兰基·查马基在 Unsplash 上拍摄的照片
世界上数据的泛滥为学习和分析世界各地人们的行为提供了大量的机会。大多数分析至少需要几天的数据，这就需要一个快速的可查询存储引擎。OLAP 数据库的存在仅仅是为了服务于这个目的，也就是说，使大量的数据能够以最小的延迟被容易地查询。
为了最大限度地减少延迟，所有数据库都对数据创建了索引。索引通常是基于树的结构，例如 B 树、R 树等。它基于某个固定的键直接向您提供包含数据的行或块，而不是让您扫描所有的行。
OLAP 数据库的独特之处在于，可以一次对多个列进行查询，例如，通过用户、日期和城市获得订单总数的查询。从技术上讲，您也可以在多个维度上创建索引，但是您必须假设用户将遵循什么样的查询模式。您还必须假设每列将容纳的数据量，以做出有效的索引决策。
如果数据库本身根据插入的数据修改了索引会怎么样？有学问的多维索引是回答这个特殊问题的一种努力。在这篇博客中，我们将看看其中的一种算法。
洪水
Flood 算法是为内存索引设计的。也可以对其进行修改，以便在 OLTP 数据库中使用。洪水背后有两个关键思想:
- 使用示例查询筛选器工作负荷来确定某些维度的使用频率、哪些维度一起使用以及哪些维度比其他维度更具选择性。基于这些信息，定制整个布局以优化性能。
- 使用经验 CDF 模型将多维倾斜数据展平到统一空间中。
让我们假设需要在 d 维数据上创建索引。在这样的数据中，没有自然的排序顺序。因此，该算法首先选择一个将用于排序的维度。然后，该算法创建一个 d-1 维网格，其中每个维被分成等间距的列。这种网格中的每个单元格都包含多个数据点。
为了确保数据点均匀分布，使用特定维度的最小值和最大值对其进行标准化。最后一个维度用于对每个单元格中的数据进行排序。
询问
一个查询通常由 k 个维度组成，其中 k < d. Since the query already contains the range of values for each dimension that need to be queried, we can simply select all the cells which lie within that range along with cells that have partial overlap. This step is known as Projection.
For the cells which have partial overlap, we can use the fact that the data in them is sorted and select the relevant data using binary search. This is only possible when you have the sort dimension as a part of the query. This step is known as Refinement.
Once we have all the data, we can refine it further to check if any out of range data is there or not and then return the result to the user. This step is known as Scan.
Layout optimization
The primary strength of FLOOD lies in its ability to optimize the data layout to minimize the query latency. To minimize the latency, you first need a proxy to determine the query performance. The algorithm uses a custom cost function to serve the purpose. The cost function is composed of three parts:
- wpNc ，其中 wp 是对一个单元执行细化的平均时间，Nc 是网格中单元的总数。
- wrNc 其中 wr 是对一个单元执行细化的平均时间，Nc 是网格中单元的总数。
- wsNs ，其中 ws 是执行每次扫描的平均时间，Ns 是扫描数据点的总数。
然后，查询时间的模型可以计算为
wpNc + wrNc + wsNs
下一步是计算权重 wp、wr 和 ws。对于该洪水，使用一个简单的模型，该模型采用像元总数、可过滤像元大小的平均值、中间值和尾部分位数、维数等特征。Flood 仅训练权重模型一次，并将其重新用于多个数据布局。
最后一步是优化布局，包括调整排序维度的维度和每个维度中的列数。
在每次迭代中，该算法选择 d 维中的一个作为排序维。其余所有维度都用来创建 d-1 维网格。然后，它运行梯度下降算法来确定最小化查询时间的列数。
Flood 为每个新工作负载重新调整数据布局。由于 DB administrator 不可能生成最可能的查询作为模型的输入，因此 Flood 本身会生成用于训练的查询，方法是将一些维度随机分组，将其他维度随机过滤，而将其余维度置之不理。group by 聚合函数也是随机的。
结论
Flood 算法标志着自学习索引道路上的一个重要里程碑。它具有很高的实用性，可以在真实世界的数据库中使用。然而，Flood 仍然存在一些缺点，需要解决这些缺点以使其成为一个完全通用的算法。其中一些缺点是-
- 它不支持插入新数据。在新数据到达的情况下，需要再次拟合整个数据集。当前版本仅适用于只读工作负载。
- 它是单线程的，在其当前实现中不支持并发。
- 尽管 Flood 针对新的工作负载进行了自我调优，但它仍然很难确定工作负载何时发生了足以触发重新调优操作的变化。
最后，我希望这些问题将在未来得到解决，OLAP 数据库最终将变得至少比本文中展示的快一个数量级。
您可以使用以下参考资料来了解有关已学数据结构和索引的更多信息:
- 维克拉姆·内森，丁嘉林，穆罕默德·阿里扎德，蒂姆·菲利普·克拉斯卡
- 蒂姆·菲利普·克拉斯卡、亚历克斯·比特尔、Ed H. Chi、Jeffrey Dean、Neoklis Polyzotis 撰写的学习指数结构案例
以最简单的方式学习 Python 中的一键编码
在本教程中，我们将从头开始学习特征工程中的一个重要概念，即一键编码。
我们先了解一下情况，然后定义一热编码。有时候解决问题是理解概念的最快方法之一。好吧，我们先创造一个情境(我刚刚虚构的情境)。只需一个平视就可以在我的 GitHub 资源库中找到下面给出的 :
permalink dissolve GitHub 是 4000 多万开发人员的家园，他们一起工作来托管和审查代码，管理…
github.com](https://github.com/Tanu-N-Prabhu/Python/blob/master/Learning_One_Hot_Encoding_in_Python_the_Easy_Way.ipynb)
情况
假设您正在解决一个简单的数据科学问题。现在，实际问题是什么并不重要，但您会陷入这样一种情况:您有一个很小的数据集，其中有 7 个实例，每个实例有 4 个特征。用蹩脚的话说，数据集有 7 行和 4 列。其中三列为类型object，意味着这些列包含字符串值。另一列是类型int,这意味着它只有整数值。现在说得够多了，让我们实际看看数据集是什么样子的。而不是给你看原始数据。CSV 格式)。我用熊猫库把它格式化成一个数据帧。
为了安全起见，让我们看看列的数据类型。
现在实际情况开始了，因为一些学习算法只处理数字数据，你必须以某种方式处理这些object数据。处理这种情况有两种选择:
- 删除所有三列然后睡觉
- 阅读本教程并实现一键编码
我知道选项 1 效果很好，但是有时候你必须集中精力，为了生计而努力工作。现在解决这种情况的方法是将这种object类型的数据转换成几种binary类型的数据。我的意思是要仔细观察数据集。列最喜欢的颜色有 6 个独特的值，如**红色、橙色、黄色、绿色、紫色和蓝色。**现在我们可以将这个特征转换成一个六个数值的向量，如下所示:
同样，你不认为我们也可以将最喜欢的日子列转换成一个六个数值的向量吗？因为这一栏有 7 个独特的日子，比如周一、周二、周三、周四、周五、周六、周日。
现在你可能会想，我们能不能不做同样的事情呢？但这里的关键是不。不要做同样的事情。在这里，我们将学习一个叫做顺序的新概念。既然有体面，好，更好，最好，优秀。我们将它们排序为{过得去，好，更好，最好，优秀} 为 {1，2，3，4，5} 或 {0，1，2，3，4}。
这是因为当一些值的排序很重要时，我们可以通过只保留一个变量来替换这些值。
请记住，这种技术并不是在所有情况下都有效。例如，你们中的一些人可能会想，我们不能用同样的技术来填充其他两列的值吗？通过这样做，你肯定会降低特征向量的维数，但是这意味着在该类别中的值之间有一个顺序，并且它经常会混淆学习算法。当没有规则时，学习算法将试图找到一个状态或规则，并且该算法很可能过拟合。所以要明智地思考和使用这种技巧。仅当值的顺序很重要时才使用此选项。这种技术可以用在一篇文章的质量、用户对产品的评论、食物的味道等方面。
因此，有意或无意地，你已经学习并掌握了一键编码的概念，以及在哪里使用它。这就是如何将分类或对象类型数据转换成数值类型数据。让我们看看如何实际编码并摆脱这种情况。
从头开始创建数据集
如前所述，这是一个虚构的数据集。为本教程创建。不是针对你。
import **pandas** as **pd****# Creating a list with some values** **studentID** = [1000, 1001, 1002, 1003, 1004, 1005, 1006]**color** = ['Red', 'Orange', "Yellow", 'Green', 'Yellow', 'Purple', 'Blue']**DaysOfTheWeek** = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']**Attitude** = ['Best', 'Decent', 'Better', 'Excellent', 'Excellent', 'Good', 'Best']
现在我们有了列表，让我们将其转换为数据框。为此，我们需要压缩所有列表值，然后存储它。
**# Converting the list into a data frame and simultaneously renaming the columns.****df** = pd.DataFrame(list(zip(studentID, color, DaysOfTheWeek, Attitude)), **columns** =['Student ID', 'Favourite Color', 'Favourite Day', 'Attitude'])print(**df**)
将对象类型数据转换成分类类型
这是因为在大多数情况下，您可能会得到分类类型的数据。但是在这里，上面看到的三个都是一个object类型。如果是这种情况，那么您需要手动将它们转换为分类类型。
**# Converting the object type data into categorical data column**for **col** in ['**Favourite Color**','**Favourite Day**', '**Attitude**']:
df[**col**] = df[**col**].astype('**category**')print(**df.dtypes**)
将二进制代码分配给分类值
如前所述，我们将只把最喜欢的颜色和最喜欢的日子列转换成二进制值列。我们可以使用 pandas get_dummies方法，而不是手动操作。
**# Assigning the binary values for Favourite Day and Favourite Color columns****df** = pd.get_dummies(data=df,columns=['Favourite Color','Favourite Day'])print(df)
通过这样做，你显然会增加数据集的维度，但是你的学习算法会执行得更好。
将订单分配给名为“态度”的分类列
有两种方法可以做到这一点:
- 使用字典手动赋值。
- 使用
LabelEncoder方法
选项 1 是没有用的，因为如果你有超过 1000 个唯一值，那么你可能会使用一个循环语句，使你的生活变得复杂。现在是 2020 聪明思考，使用sklearn库来做这件事。
**# Assigning order to the categorical column** from **sklearn.preprocessing** import **LabelEncoder****# Initializing an object of class LabelEncoder
labelencoder** = LabelEncoder() df['**Attitude**'] = labelencoder.fit_transform(df['Attitude'])print(df)
好了，现在你可以使用你最喜欢的学习算法，然后告诉fit(X, y)或其他什么，然后愉快地睡觉。
好了，伙计们，我希望你们今天学到了新东西。这真的是一个非常重要的概念，也是你将会遇到的特性工程技术。这是数据科学面试中最常被问到的问题之一。如果你对本教程有任何疑问，那么评论区就是你的了。在那之前保持安全，再见。下次再见。
学习熊猫简介
使用 Python 进行 Pandas Profiling 的全面入门指南
照片由 Sid Balachandran 在 Unsplash 上拍摄
介绍
在当今时代，成为一名数据科学家是一份令人难以置信的令人兴奋和有益的职业。随着技术的爆炸式发展以及每天创建的大量数据和内容，数据科学家需要不断学习新的方法来有效地分析这些数据。任何新数据项目最关键的部分之一是探索性数据分析阶段。作为一名数据科学家，这一阶段允许您学习和熟悉手头的数据，数据从哪里收集，数据中的任何缺口，任何潜在的异常值以及所使用的数据类型的范围。一个已经成为数据科学家常用的工具是 熊猫概况 。Pandas Profiling 是一个用 Python 编写的开源工具，能够生成详细描述数据集中数据类型的交互式 HTML 报告；突出显示缺少的值；提供描述性统计数据，包括平均值、标准差和偏斜度；创建直方图并返回任何潜在的相关性。
安装熊猫档案
对于本文，我们使用的是由 JetBrains 创建的集成开发环境 PyCharm 。PyCharm 是一个非常好的工具，因为它可以处理一些任务，包括为项目创建一个虚拟环境，以及安装代码中引用的包。
要开始，打开 PyCharm 并选择File > New Project，将出现一个对话框，您可以在其中命名项目并创建一个相关的虚拟环境。虚拟环境允许您安装项目可以引用的特定 python 包，而不必在您的机器上全局安装这些包。当您有多个项目需要同一个包的不同版本时，这是很方便的。
一旦在虚拟环境中安装了默认包，我们需要安装 Pandas Profiling。为此，导航至File > Settings > Project > Project Interpreter，选择右上角的+按钮，搜索pandas-profiling，然后按下Install Package。
使用 PyCharms 项目解释器安装 Pandas Profiling。
入门指南
对于这个例子，我们已经创建了一个简单的 Python 脚本，您可以使用它开始学习。如果这是你第一次使用 Python，请阅读 入门——Python 熊猫 ,我们在下面的脚本中解释了代码。
一个 Python 脚本将使用假数据生成一个 HTML 熊猫概况报告。
在执行脚本之后，一个名为pandas_profile_text.html的新 HTML 文件将会在您的项目根目录中创建。要查看报告*，右击 HTML 文件上的*并选择Open in Browser > Default。
熊猫概况报告
概观
熊猫概况报告中的概述部分
Pandas Profiling 报告的第一部分“概述”部分显示了整个数据集的汇总统计数据。它返回变量的数量，即传递的数据帧中包含的列数。观察次数是接收到的行数。该概览还提供了缺失单元格或重复行的数量以及受影响记录总数的百分比。丢失的单元格和重复的行统计数据对于数据科学家来说非常重要，因为这些可能表明更广泛的数据质量问题或用于提取数据的代码问题。概述部分还包括内存中数据集大小的数据、内存中平均记录大小以及任何可识别的数据类型。
在 Overview 部分的 Warnings 选项卡下，您可以找到数据集内任何变量的校对警告。在这个例子中，我们收到了一个关于名称、电子邮件和城市的高基数警告。在这个上下文中，高基数意味着被标记的列包含非常多的不同值，在现实世界中，对于雇员编号和电子邮件，您可能会遇到这种情况。
变量—类别
Pandas 特征分析报告分类变量的结果
Pandas Profiling 报告中的变量部分分析传递的数据帧中的列。分类变量是包含表示 Python 字符串类型的数据的列。
为分类变量返回的典型度量是列中字符串的长度。要查看生成的直方图，选择Toggle Details，然后导航至Length选项卡。“长度”选项卡还包含关于字符串长度的最大值、中值、平均值和最小值的统计数据。
变量—数字
Pandas 分析报告数字变量的结果
Pandas Profiling 提供了令人难以置信的对数字变量的深入分析，涵盖了分位数和描述性统计。它返回数据集中的最小值和最大值以及之间的范围。它显示四分位值，这些值通过将集合分成四个箱来测量数据集中有序值在中位数上方和下方的分布。当考虑四分位数值时，如果四分位数 1 和中位数与中位数和四分位数 3 之间的距离更大，那么我们将其解释为较小值比较大值的分散性更大。四分位数间距就是四分位数三减去四分位数一的结果。
标准差反映了数据集相对于其平均值的分布。较低的标准差意味着数据集中的值更接近平均值，而较高的标准差意味着数据集值分布在更大的范围内。**变异系数，**也称为相对标准差，是标准差与平均值的比值。峰度可用于通过测量相对于有序数据集均值的分布尾部的值来描述数据的形状。峰度值根据数据的分布和极端异常值的存在而变化。中位数绝对偏差是另一种统计方法，它反映了数据在中位数周围的分布，并且在出现极端异常值时，它是一种更为可靠的分布测量方法。偏斜度反映了标准钟形概率分布的失真程度。正偏度被认为是向右偏度，在分布的右侧有一个较长的尾部，而在左侧有一个负值。
互动和相互关系
熊猫概况报告中的交互图。
交互和相关性部分是 Pandas Profiling 真正领先于其他探索工具的地方。它将所有变量成对分析，并使用 Pearson、Spearman、Kendal 和 Phik 方法突出任何高度相关的变量。它提供了一个强大的、易于理解的可视化表示，可以显示任何紧密相关的数据。作为一名数据科学家，这是一个很好的起点，可以问为什么这些数据对可能相关。
缺少值
熊猫概况报告中的缺失值条形图
缺失值部分基于概述部分的缺失单元格指标。它直观地表示数据帧中所有列的缺失值出现的位置。这一部分可能会强调数据质量问题，并且可能需要将缺失的数据映射到一个缺省值，我们将在后面的文章中讨论这个问题。
样本部分
示例部分显示了数据集头部和尾部的结果快照。如果数据集是按特定列排序的，您可以使用这一部分来了解最小和最大列值所关联的记录类型。
摘要
Pandas Profiling 是一个令人难以置信的开源工具，每个数据科学家都应该考虑将其添加到任何项目的数据探索阶段的工具箱中。通过提供深入的描述性统计数据、可视化分布图和一套强大的关联工具，这是消化和分析不熟悉的数据集的有效方法。
感谢您花时间阅读我们的文章，我们希望您发现它有价值。
深度神经网络的学习过程
人工神经网络是如何学习的？[更新版本]
(来源: https://torres.ai )
这是我两年前写系列的第五帖(帖 3 ，帖 4 )的更新版**。在这篇文章中，我将以 Keras为例，直观地展示神经网络学习过程的主要组成部分，Keras 已经成为 TensorFlow 的高级 API ，用于构建和训练深度学习模型。**
最后，我们将通过一个名为 TensorFlow Playground 的交互工具来实践这里提出的一些概念。
神经网络的学习过程
神经网络由个神经元相互连接而成；与此同时，我们神经网络的每个连接都与一个权重相关联，该权重在乘以输入值时决定了这种关系在神经元中的重要性。
一个神经元可以被形象化为这张图(来源: https://torres.ai )
每个神经元都有一个激活函数**，它定义了神经元的输出。激活函数用于在网络的建模能力中引入非线性。我们有几个激活函数的选项，我们将在本帖中展示。**
(a)先前人工神经元的简化表示。(b)更简化的代表性。(来源: https://torres.ai )
根据之前的简化表示，我们可以将前一篇文章中提出的模型表示为将 MNIST 数字分类为:
(来源: https://torres.ai )
训练我们的神经网络，即学习我们的参数值(权重 wij 和 bj 偏差)是深度学习最真实的部分，我们可以将神经网络中的这一学习过程视为神经元层的“往返”迭代过程。“去”是信息的前向传播，“回”是信息的后向传播。
第一阶段前向传播发生在网络暴露于训练数据时，这些数据穿过整个神经网络以计算它们的预测(标签)。也就是说，通过网络传递输入数据，使得所有神经元将它们的变换应用于它们从前一层神经元接收的信息，并将它发送到下一层神经元。当数据已经穿过所有层，并且其所有神经元已经进行了它们的计算时，将到达最后一层，具有那些输入示例的标签预测的结果。
接下来，我们将使用一个损失函数来估计损失(或误差),并比较和衡量我们的预测结果相对于正确结果的好坏程度(请记住，我们是在一个受监督的学习环境中，我们有一个标签来告诉我们期望值)。理想情况下，我们希望成本为零，也就是说，估计值和期望值之间没有偏差。因此，随着模型被训练，神经元互连的权重将被逐渐调整，直到获得良好的预测。
一旦计算出损失，该信息就被反向传播。因此，它的名字:反向传播。从输出层开始，损失信息传播到隐藏层中直接对输出做出贡献的所有神经元。然而，基于每个神经元对原始输出的相对贡献，隐藏层的神经元仅接收总损失信号的一部分。这个过程一层一层地重复，直到网络中的所有神经元都接收到描述它们对总损失的相对贡献的损失信号。
视觉上，我们可以用这个阶段的视觉方案来总结我们所解释的内容(基于我们神经网络的先前视觉表示):
(来源: https://torres.ai )
现在我们已经将这些信息传播回来，我们可以调整神经元之间连接的权重。我们正在做的是，在下次使用网络进行预测时，让损失尽可能接近于零。为此，我们将使用一种叫做梯度下降的技术。这种技术在损失函数的导数(或梯度)的计算的帮助下以小增量改变权重，这允许我们看到朝着全局最小值“下降”的方向；这通常是在我们在每次迭代中传递给网络的所有数据集的连续迭代(历元)中的成批数据中完成的。
概括地说，学习算法包括:
(来源: https://torres.ai )
- 从网络参数的值(通常是随机的)开始( wij 权重和 bj 偏差)。
- 取一组输入数据的例子，并通过网络传递它们以获得它们的预测。
- 将获得的这些预测值与预期标签值进行比较，并用它们计算损失。
- 执行反向传播，以便将这种损失传播到构成神经网络模型的每一个参数。
- 使用这种传播的信息来更新具有梯度下降的神经网络的参数，从而减少总损失并获得更好的模型。
- 继续迭代前面的步骤，直到我们认为我们有一个好的模型。
下面，我们将更详细地介绍我们在本节中强调的每个元素。
激活功能
记住，我们使用激活函数来向前传播神经元的输出。该输出由该神经元所连接的下一层的神经元接收(直到包括输出层)。正如我们已经说过的，激活函数用于在网络的建模能力中引入非线性。下面我们将列举现今使用最多的；都可以在一层 Keras 中使用(我们可以在他们的网站上找到更多信息)。
线性的
线性激活函数基本上是恒等函数，实际上，它意味着信号不变。
(来源: https://torres.ai )
乙状结肠的
sigmoid 函数已经在之前的文章中介绍过了。它的兴趣在于它允许减少有效数据中的极端或非典型值，而不消除它们:它将几乎无限范围的独立变量转换成 0 到 1 之间的简单概率。它的大部分输出将非常接近 0 或 1 的极端值。
(来源: https://torres.ai )
双曲正切
不赘述，我们可以总结一下，tanh 表示双曲正弦和双曲余弦的关系: tanh(x)=sinh(x)/cosh(x) 。与 sigmoid 函数不同，tanh 的归一化范围在-1 和 1 之间，这是一些神经网络的输入。tanh 的优点是负数更容易处理。
(来源: https://torres.ai )
Softmax
softmax 激活函数在之前的文章中也有介绍，用于推广逻辑回归，因为它可以包含多个决策限制，而不是二进制分类。正如我们所见，softmax 激活函数通常位于神经网络的输出层，并返回互斥输出类的概率分布。
热卢
激活函数整流线性单元(ReLU)是一种非常有趣的变换，如果输入高于某个阈值，它会激活单个节点。默认的和更常见的行为是，只要输入值小于零，输出就为零，但是当输入值大于零时，输出与输入变量成线性关系，形式为 f(x)=x 。ReLU 激活函数已经被证明在许多不同的情况下都有效，并且目前被广泛使用。
(来源: https://torres.ai )
反向传播组件
总之，我们可以认为反向传播是一种在正确方向上改变神经网络参数(权重和偏差)的方法。它首先通过计算损失项开始，然后考虑到这个计算的损失，用优化算法以相反的顺序调整神经网络的参数。
请记住，在 Keras 中， compile() 方法允许我们定义我们希望学习过程中涉及的组件如何:
model.compile(loss=’categorical_crossentropy’,
optimizer=’sgd’,
metrics=[‘accuracy’])
具体来说，在这个例子中，有三个参数被传递给这个方法:一个优化器、一个损失函数和一个度量列表。在像我们的例子这样的分类问题中，精确度被用作一种度量。让我们更深入地探讨一下这些论点。
损失函数
损失函数是量化特定神经网络在训练过程中有多接近理想权重所需的参数之一。
在 Keras 手册页中，我们可以找到所有可用的损失函数类型。有些有其具体的超参数，必须指出；在前一篇文章的例子中，当我们使用分类 _ 交叉熵作为损失的函数时，我们的输出必须是分类格式。损失的最佳函数的选择在于理解什么类型的误差对于特定的问题是可接受的或不可接受的。
优化者
优化器是 compile() 方法中需要的另一个参数。Keras 目前有不同的优化器可以使用: SGD ， RMSprop ， Adagrad ， Adadelta ， Adam ， Adamax ， Nadam 。你可以在 Keras 文档中找到更多关于它们的细节。
一般而言，我们可以将学习过程视为一个全局优化问题，其中参数(权重和偏差)必须以最小化上述损失函数的方式进行调整。在大多数情况下，这些参数无法解析求解，但一般来说，它们可以通过优化算法很好地逼近，例如上面提到的那些算法。
梯度下降
我们将解释其中一个具体的优化器，以便您理解优化器的整体操作。具体来说就是梯度下降，很多优化器的基础，也是机器学习和深度学习中最常见的优化算法之一。
当更新参数时，梯度下降使用损失函数的一阶导数(梯度)。记住梯度给出了函数在该点的斜率。在不能深入细节的情况下，该过程包括将每个隐藏层的损失的导数与其上层损失的导数链接起来，在计算中结合其激活函数(这就是为什么激活函数必须是可导的)。在每一次迭代中，一旦所有的神经元都具有对应于它们的损失函数的梯度值，参数值就以与梯度指示的方向相反的方向更新。事实上，梯度总是指向损失函数值增加的方向。因此，如果使用梯度的负值，我们可以得到我们倾向于减少损失函数的方向。
让我们以直观的方式来看这个过程，假设只有一维:假设这条线代表损失函数对于每个可能的参数值所取的值，并且梯度的负值由初始点中的箭头来表示:
(来源: https://torres.ai )
为了确定参数的下一个值，梯度下降算法将初始权重的值修改为与梯度相反的方向(因为它指向损失增加的方向，我们希望减少损失)，并在此基础上增加一个比例量。这种变化的幅度由梯度值和我们可以指定的学习率超参数决定(我们将很快介绍)。因此，从概念上讲，就好像我们沿着斜坡向下走，直到我们到达局部最小值:
(来源: https://torres.ai )
梯度下降算法重复这个过程，越来越接近最小值，直到参数值达到一个点，超过这个点，损失函数不能减小:
(来源: https://torres.ai )
随机梯度下降
在前面的章节中，我们已经了解了参数值是如何调整的，但没有了解调整的频率:
- 每个条目示例后？
- 在每一轮的整套训练实例(epoch)之后？
- 在训练集的例子样本之后？
在第一种情况下，我们称之为在线学习，即从每个训练实例的观察损失中估计梯度；当我们谈到随机梯度下降(SGD)时也是如此。第二种称为批量学习，称为批量梯度下降。文献表明，通常情况下，在线学习可以获得更好的结果，但有理由证明使用批量学习是正确的，因为许多优化技术只能使用批量学习。
但是，如果数据分布良好，其中的一小部分应该会给我们一个很好的梯度近似值。我们可能得不到最好的估计，但它更快，而且，考虑到我们正在迭代的事实，这种方法非常有用。出于这个原因，经常使用第三个选项，称为小批量。该选项通常与在线一样好，但是更新神经网络的参数需要较少的计算。此外，许多输入示例的梯度的同时计算可以使用矩阵运算来完成，这些运算可以通过 GPU 非常有效地实现，正如我们在之前的帖子中所看到的。
这就是为什么在现实中，许多应用使用随机梯度下降(SGD)和几个例子的迷你巴赫。要使用所有数据，需要做的是将数据分成几批。然后我们取第一批，通过网络，计算其损失的梯度并更新神经网络的参数；这将依次进行，直到最后一批。现在，在一次通过所有输入数据的过程中，只有一些步骤与批次数量相等。
SGD 在 Keras 中非常容易实现。在 compile() 方法中，指出优化器是 SGD(参数中的值 sgd )，然后必须做的就是在训练过程中用 fit() 方法指定批量大小，如下所示:
model.fit(X_train, y_train, epochs=5, batch_size=100)
在这个使用 fit() 方法的代码示例中，我们使用 batch_size 参数将数据分成 100 个一批。通过历元的数量，我们可以显示对所有数据执行该过程的次数。在本文的后面，当我们已经介绍了常用的优化器参数时，我们将回到这两个参数。
模型参数化
如果前一篇文章末尾的读者已经用我们在那里使用的超参数执行了一个模型，我假设该模型的准确性将超过 90%。这些结果好吗？我认为它们非常棒，因为这意味着读者已经用 Keras 编写并执行了他的第一个神经网络。恭喜你！
另一件事是，还有其他模型可以提高精确度。这取决于拥有丰富的知识和大量的实践来处理好我们可以改变的许多超参数。例如，通过简单改变第一层的激活函数，从s 形变为如下所示的 relu :
model.add(Dense(10, activation=’relu’, input_shape=(784,)))
我们可以在差不多相同的计算时间内获得 2%以上的精度。
也可以增加时期的数量，在一层中增加更多的神经元或者增加更多的层。然而，在这些情况下，准确性的提高具有增加学习过程的执行时间的副作用。例如，如果我们向中间层添加 512 个节点，而不是 10 个节点:
model.add(Dense(512, activation=’relu’, input_shape=(784,)))
我们可以用 summary() 方法检查，参数数量增加(是一个全连接)执行时间明显变高，甚至减少了历元数。利用该模型，准确率达到 94%。如果我们增加到 20 个历元，可以达到 96%的准确率。
简而言之，在下一节中，我们将更详细地了解一个无限可能的世界，读者可以意识到，鉴于我们拥有的多种可能性，找到激活函数的最佳参数和超参数的最佳架构需要一些专业知识和经验。
参数和超参数
到目前为止，为了简单起见，我们还没有明确注意区分参数和超参数，但是我认为现在是时候了。通常，我们将模型的参数视为模型内部的配置变量，其值可以根据数据进行估计。相比之下，超参数指的是模型本身外部的配置变量，其值通常无法从数据中估计，并由程序员指定以调整学习算法。
当我说深度学习更像是一门艺术而不是一门科学时，我的意思是找到这些超参数的最优值需要大量的经验和直觉，这些最优值必须在开始训练过程之前指定，以便模型训练得更好更快。鉴于本书的介绍性质，我们不会详细介绍所有这些参数，但我们有值得简要提及的超参数，包括神经网络的结构和拓扑水平(层数、神经元数、它们的激活函数等)。)和学习算法级别(学习速率、动量、时期、批量大小等)。).
接下来，我们将介绍其中一些，其余的将在我们进入卷积神经网络时出现在 futuro 帖子中。
纪元
正如我们已经做的，epochs 告诉我们在训练过程中所有训练数据通过神经网络的次数。一个很好的线索是增加历元的数量，直到验证数据的准确性度量开始降低，即使训练数据的准确性继续增加(这是当我们检测到潜在的过度拟合时)。
批量
正如我们之前说过的，我们可以将训练数据划分为小批量，以便通过网络传递它们。在 Keras 中， batch_size 是指示这些批的大小的参数，这些批将在训练的迭代中的 fit() 方法中使用，以更新梯度。最佳大小取决于许多因素，包括我们用来计算的计算机的内存容量。
学习率
梯度向量有方向和大小。梯度下降算法将梯度的大小乘以一个称为学习率(有时也称为步长)的标量，以确定下一个点。
以更正式的方式，反向传播算法计算误差相对于每个权重如何变化:
为了使用简单的更新规则来更新网络的每个权重:
其中，α是学习率。
例如，如果梯度的大小为 1.5，学习率为 0.01，那么梯度下降算法将选择距离前一点 0.015 的下一点。
这个超参数的适当值非常依赖于所讨论的问题，但是一般来说，如果这个值太大，那么就要迈出巨大的步伐，这有利于在学习过程中走得更快。但在这种情况下，我们可能会跳过最小值，使学习过程难以停止，因为当搜索下一点时，它会永远随机地在“井”的底部跳动。在该图中，我们可以直观地看到可能发生的影响，其中从未达到最小值(在图中用小箭头表示):
(来源: https://torres.ai )
相反，如果学习率很小，将会取得很小的进步，有更好的机会达到局部最小值，但是这会导致学习过程非常慢。一般来说，如果我们的学习模式不起作用，一个好的规则是降低学习速度。如果我们知道损失函数的梯度很小，那么测试它用学习率补偿梯度是安全的。
学习率衰减
但是一般来说，最好的学习速率是随着模型接近一个解而降低的速率。为了实现这种效果，我们有另一个超参数，学习率衰减，它用于随着时代的推移降低学习率，以允许学习在开始时以更大的学习率更快地前进。随着进展，进行越来越小的调整，以促进训练过程收敛到损失函数的最小值。
动力
在我们已经解释的下降梯度算法的可视例子中，为了最小化损失函数，我们保证找到全局最小值，因为没有局部最小值，优化过程会被卡住。然而，在现实中，真实情况更加复杂，从视觉上看，我们似乎可以找到几个局部最小值，损失函数的形式如下图所示:
(来源: https://torres.ai )
在这种情况下，优化器很容易陷入局部最小值，并且算法可能认为已经达到了全局最小值，从而导致次优结果。原因是当我们卡住的时候，梯度是零，我们不再能严格地沿着梯度的路径走出局部最小值。
解决这种情况的一种方法可以是从不同的随机位置重新开始该过程，并且以这种方式增加达到全局最小值的概率。
为了避免这种情况，通常使用的另一种解决方案涉及动量超参数。以一种直观的方式，我们可以看到，如果要前进，它将采取前面步骤的加权平均来获得一点动力，并克服“颠簸”，作为一种不陷入局部最小值的方法。如果我们认为以前的平均值更好，也许这将允许我们进行跳跃。
但是使用平均值已经被证明是一个非常激烈的解决方案，因为，也许在前面步骤的梯度中，它比仅仅在前面步骤中更不相关。这就是为什么我们选择加权先前的梯度，并且动量是用于该加权的 0 和 1 之间的常数。已经表明，使用动量的算法在实践中效果更好。
一种变体是内斯特罗夫动量，这是最近流行的动量更新的稍微不同的版本，当它接近解决方案时，它基本上减慢梯度。
参数权重的初始化
参数权重的初始化并不完全是一个超参数，但它与其中任何一个参数一样重要，这就是我们在本节中做一个简短段落的原因。建议用小的随机值初始化权重，以打破不同神经元之间的对称性，如果两个神经元具有完全相同的权重，则它们将总是具有相同的梯度；这假设两者在随后的迭代中具有相同的值，因此它们将不能学习不同的特征。
按照标准正态分布随机初始化参数是正确的，但它可能会导致渐变消失(当渐变的值太小而模型停止学习或因此花费太长时间时)或渐变爆炸(当算法为权重分配过高的重要性时)的问题。
一般来说，考虑到我们的网络具有的激活功能的类型，可以使用试探法。深入这些细节超出了本书的介绍范围，但是，如果读者想要更深入，我建议你访问斯坦福 Andrej Karpathy 的 CS231n 课程网站，在那里你将获得这一领域非常有价值的知识，这些知识以一种非常说教的方式展现出来。
Keras 中超参数和优化器
我们如何指定这些超参数？回想一下，优化器是模型的 compile() 方法中需要的参数之一。到目前为止，我们都是通过它们的名字来调用它们(用一个简单的字符串来标识它们)，但是 Keras 也允许将优化器类的一个实例作为一个参数来传递，并指定一些超参数。
例如，随机梯度下降优化器允许使用动量、学习率衰减和内斯特罗夫动量超参数:
keras.optimizers.SGD(lr=0.01, momentum=0.0, decay=0.0,
nesterov=False)
上一个方法的参数中指示的值是默认采用的值，其范围可以是:
- lr:浮点> = 0。(学习率)
- 动量:浮点> = 0
- 衰减:浮点> = 0(学习率衰减)。
- nesterov: boolean(表示是否使用内斯特罗夫动量)。
正如我们已经说过的，Keras 中有几个优化器，读者可以在他们的文档页面上探索。
张量流游乐场
TensorFlow Playground 是一个用 JavaScript 编写的交互式可视化 web 应用程序，允许我们模拟在浏览器中运行的简单神经网络，并实时查看结果:
使用该工具，我们可以试验不同的超参数，并观察它们的行为。事实上，神经网络中超参数所提供的灵活性是它的优点之一，同时也是它的缺点之一，对于那些刚开始学习这个主题的人来说:有许多参数需要调整！
二元分类问题
为了开始理解这个工具是如何工作的，我们可以使用前一篇文章中提出的第一个感知器的例子，一个简单的分类问题。
从这个例子开始，我们选择了上图中“数据”部分所示的数据集，然后单击“播放”按钮。现在我们可以看到 TensorFlow Playground 是如何解决这个特殊问题的。蓝色和橙色区域之间的线开始慢慢移动。你可以按下“重置”按钮，重新测试几次，看看这条线在不同初始值下是如何移动的。
在这种情况下，应用程序会尝试找到允许正确分类这些点的参数的最佳值。如果将光标放在弧上，读者将看到分配给每个参数的值出现(甚至允许我们编辑它):
请记住，当这个权重乘以输入值时，它决定了神经元中这种关系的重要性。
在第一次接触之后，我们将展示一点工具，让我们了解神经网络如何运作。在菜单的上半部分，我们基本上找到了超参数，其中一些我们已经在上一节中评论过:纪元、学习率、激活、正则化率和问题类型。它们都是下拉菜单，我们可以在其中选择这些超参数的值。
在“问题类型”选项卡中，平台允许我们指定两种类型的问题:回归(连续问题)和分类。总的来说，我们可以选择四种类型的数据用于分类，两种类型的数据用于回归:
蓝色和橙色的点构成了数据集。橙色点的值为-1，蓝色点的值为+1。在左侧，在数据类型下面，有不同的参数，我们可以修改这些参数来调整我们的输入数据。
使用“训练与测试数据的比率”选项卡，我们可以控制分配给训练集的数据百分比(如果我们修改它，我们会看到屏幕右侧“输出”中出现的点是如何交互变化的)。数据的噪声水平也可以由“噪声”字段定义和控制；随着噪声的增加，数据模式变得更加不规则。正如我们可以体验到的，当噪声为零时，问题数据在它们的区域中被清楚地区分。但是当达到 50 以上的时候，我们可以看到蓝点和橙点是混在一起的，所以分类起来非常困难。
顾名思义，通过“批量大小”，我们可以确定每个训练批次将使用的数据量。
然后，在下一个专栏中，我们可以选择特性。我建议我们使用“X1”和“X2”这两个可用的词:“X1”是水平轴上的值，“X2”是垂直轴上的值。
神经元网络的拓扑可以在下面的列中定义。我们最多可以有六个隐藏层(通过点击“+”号来添加隐藏层)，每个隐藏层最多可以有八个神经元(通过点击相应层的“+”号):
最后，请记住，在训练神经网络时，我们希望最小化“训练损失”,然后将其与测试数据进行比较,“测试损失”也会最小化。在屏幕的右上部分，在一个小图中交互地显示了每个时期中两个度量的变化，其中，如果损失减少，曲线向下。损失测试用黑色画，训练损失用灰色画。
超参数设置基础
用单个神经元分类
现在我们对这个工具有了更多的了解，让我们回到第一个分类示例，它将数据分成两组(聚类)。
我建议我们在前进之前修改一些参数来使用该工具进行练习。例如，我们可以用 0.03 的学习率和一个 ReLU 激活函数来修改一些参数(正则化将不被使用，因为它超出了本书的范围)。
我们将问题保持为分类，并且我建议我们将“训练与测试的比率”设为数据的 50%,并且我们还将“噪声”参数保持为零，以促进解决方案的可视化(尽管我建议稍后您自己练习)。我们可以将“批量大小”保留为 10。
和以前一样，我们将使用“X1”和“X2”作为输入。我建议从单个神经元的单个隐藏层开始。我们可以通过使用“-”或“+”按钮来实现:
在右上方，我们看到“测试损失”和“训练损失”的初始值很高(读者可以得到不同的值，因为初始值是以随机方式生成的)。但是在按下“播放”按钮之后，可以看到“训练损失”和“测试损失”都以非常低的比率收敛，并且保持不变。此外，在这种情况下，黑色和灰色的两条线完全重叠。
用多于一个神经元分类
让我们选择另一组类似于附图中的起始数据:
我们现在想把两个数据集分开:橙色的必须归入一组，蓝色的归入另一组。但问题是，在这种情况下，他们将有一个圆形，橙色点将在外圆，蓝色点将在内。现在，这些点不能像以前那样用一条线分开。如果我们用具有单个神经元的隐藏层作为先前分类的模型进行训练，那么在这种情况下分类将会失败。
我建议我们用隐藏层的多个神经元进行测试。例如，尝试两个神经元:你会发现你还没有调够。我建议你试着用三个。你会看到，最终，你可以得到一个好得多的训练和测试损失:
让我们看看左边的另一个数据集，其中的数据被分成四个不同的正方形区域。现在，这个问题无法用以前的网络解决，但我建议您尝试一下:
可以看出，我们不能得到一个好的分类(虽然在某些情况下，可能发生只有 3 个神经元的情况，因为初始化是随机的，但是如果你做几次测试，你会发现这在一般情况下是不能实现的)。然而，如果我们有 5 个神经元，如下图所示，读者可以看到该神经网络如何获得这种情况下的良好分类:
多层分类
现在，我们将尝试使用该工具中最复杂的模式对数据集进行分类。橙色和蓝色数据点的漩涡结构是一个具有挑战性的问题。如果我们依赖前面的网络，我们看到甚至没有 8 个神经元，工具留给我们的最大值，我们得到一个好的分类结果:
如果读者已经尝试过，在这种情况下，我想你会得到一些测试损失的好值。是时候多放几层了；我向您保证，如果您使用该工具允许的所有层，您将得到它:
但是你会看到，很明显，学习参数的过程需要很长时间。
实际上，用更少的层或神经元你可以得到好的结果；我要求你自己玩一点，比如改变激活函数来得到一个更简单的模型。您还可以考虑测试任何其他参数。
这个工具只考虑密集的神经网络；稍后我们将看到卷积神经网络(和递归神经网络)呈现更复杂的困境。但只有在这些密集的网络中，我们才能看到最难调整的超参数之一是决定模型有多少层以及每层有多少神经元。
在隐藏层中使用非常少的神经元将导致所谓的欠拟合，即缺乏模型拟合，因为隐藏层中只有非常少的神经元来正确检测复杂数据集中的信号。
另一方面，在隐藏层中使用太多的神经元会导致几个问题。首先，它会产生过拟合，当神经网络具有如此大的信息处理能力，以至于训练集中包含的有限信息量不足以训练隐藏层中的所有神经元时，就会发生过拟合。但另一方面，隐藏层中的大量神经元会增加训练网络所需的时间，以至于无法在必要的时间内正确训练神经网络。
显然，我们必须在隐藏层中太多和太少的神经元之间达成妥协，这就是为什么我已经评论说，我们面临的挑战需要更多的艺术而不是科学。
我希望这篇文章对你有所帮助，你会在工作或大学中用到它们。你可以在这里阅读下一篇关于卷积神经网络的文章。
** [## 卷积神经网络初学者使用 Keras 和 TensorFlow 2
边做边学:包含 GitHub 代码的实用指南
towardsdatascience.com](/convolutional-neural-networks-for-beginners-using-keras-and-tensorflow-2-c578f7b3bf25)**
通过探索和可视化 Google App 数据学习 PySpark
帮助你将熊猫技能移植到 PySpark 的实用指南
Rami Al-zayat 在 Unsplash 上拍摄的照片
Apache Spark 是每个人在处理大数据时都应该知道的不可或缺的数据处理框架。当我们试图对大数据进行数据分析时，我们可能会遇到一个问题，即由于单台计算机的处理能力和内存资源有限，您当前的计算机无法满足处理大数据的需求。虽然我们可以尝试升级我们的计算机以满足大数据处理的需要，但我们很快就会发现，当处理不断增加的数据集时，计算机可以轻松地再次达到其最大容量。
解决这个问题的一个方法是将我们的大数据提取到一个分布式并行处理平台，该平台由一个计算机集群支持，而不是依赖于单个机器。这就是 Apache Spark 在大数据处理中发挥作用的地方。
" Apache Spark 基本上是一个统一的分析引擎，用于并行和批处理系统中的大规模数据处理。" ( 来源)。
Apache Spark 最初是用 Scala 语言编写的，但它也提供了 Python API，即 PySpark 。PySpark 的发布简化了数据科学社区的工作，他们深深扎根于 Python 编程，利用 Apache Spark 的强大功能，而无需学习另一种编程语言，如 Scala。人们可以只编写 Python 脚本来访问 Apache Spark 提供的功能，并对大数据执行数据探索性分析。
照片由 Christina Morillo 从 Pexels 拍摄
此外，学习 PySpark 并不是一项艰巨的任务，尤其是如果您已经在现有的数据分析工作中使用了 Pandas 一段时间。Spark 提供了一个与熊猫数据帧非常相似的数据帧数据结构。
在本文中，我将通过一个例子来说明我们如何在一个表示为 Spark Dataframe 的 Google App 数据集上执行数据探索和可视化。
数据集
我们将要使用的样本数据集可以从 Kaggle 下载。网站上有两个 csv 文件，我们将只使用其中的一个，即“ googleplaystore.csv ”。数据集是关于谷歌 Play 商店应用程序的，其中包含应用程序名称、类别、评级、价格等信息。
想象一下，如果你打算开发一个移动应用程序，并希望在应用程序开发之前了解更多关于市场趋势的信息，探索这个数据集可能是有用的。
分布式计算平台
我们将需要一个分布式计算平台来托管我们的数据集，并使用 PySpark 处理它。在早期，建立一个分布式计算平台是一项非常复杂和艰巨的任务。
幸运的是，由于云服务的存在，整个设置过程已经大大简化为点击几个按钮。我们将在这里使用云服务之一，即 数据块 。我们将通过 Databricks 建立一个分布式计算环境，以完成本文中介绍的数据探索任务。
设置数据块
**第一步:**拜访https://databricks.com/
Databricks 网站
**第二步:**注册一个 Databricks 账户。只需点击右上角的“尝试数据块”。我们将被重定向到一个页面，在那里我们可以继续填写我们的详细信息以注册帐户。
数据块注册页面
第三步:完成注册后，登录社区版。只需点击“在此签名”的小链接。
数据块登录页面
Databricks 提供完全免费的社区版。社区版为我们提供了一个具有 15.3 GB 内存、2 个内核和 1 个 DBU 的集群。这对于学习和实验目的是足够的。
但是，请注意Community Edition 集群将在空闲两小时后自动终止。这意味着我们必须不时地在数据块中重新构建一个新的集群。
(不要担心，在 Databricks 中重建新集群只需点击几下按钮，即可在 1 分钟内完成)。
第四步:建立一个集群。在 Databricks 的主页中，从左侧的面板中选择“集群”。
导航至集群设置页面
接下来，填写下一页中的“集群名称”字段。我们可以根据自己的喜好提供一个集群名。
数据块创建集群页
等待大约 2-3 分钟，然后 Databricks 将集群分配给我们。
数据块簇列表
**第五步:**上传数据集。从左侧面板中选择“数据”。
导航至添加数据页面
点击“添加数据”。
我们可以选择删除 Kaggle 数据集，或者浏览我们的目录来上传数据集。
将数据上传到数据块
**第 6 步:**从 Databricks 主页创建一个空白笔记本。为我们的笔记本命名。
在数据块中创建笔记本
新笔记本将自动连接到我们在上一步中刚刚创建的集群。
将群集连接到笔记本电脑
只需点击几下按钮，我们就可以在 Databricks 中建立一个分布式计算平台，并将数据上传到平台上。此外，我们还创建了一个笔记本，我们可以在其中编写 Python 脚本来执行数据分析工作。PySpark 已经内置在笔记本中，这里不需要进一步安装框架。
(请注意 Databricks 中的笔记本，就像我们常用的 Jupyter 笔记本一样，它提供了一个交互式编程接口来编写我们的脚本并可视化输出)
我们现在已经准备好使用 PySpark 开始我们的数据探索之旅。
探索谷歌应用数据
在本节中，我们将开始在 Databricks 笔记本中编写 Python 脚本，以使用 PySpark 执行探索性数据分析。这一节将被分成七个部分，同时还将介绍一些常见的 PySpark 方法。
您可以通过此 链接 访问在线版笔记本，或者您也可以从我的Github下载离线版笔记本。
第 1 部分:导入库
第一步从导入必备的库/模块开始。
用于导入库的 Python 脚本
第 1–5 行:
- 导入本文介绍的数据探索任务所需的所有 PySpark 模块。
第 7 行:
- PySpark 需要一个 SQLContext 来启动 Spark SQL 的功能。Spark SQL 是用于处理结构化数据的 Spark 模块之一。在后面的阶段，我们将使用它从我们的数据集执行数据查询。
- 关键字“ sc ”表示 SparkContext。SparkContext 表示到 Spark 集群的连接，被认为是 Spark 功能的主要入口点。
第 2 部分:读取文件并计算记录的总行数
接下来，我们从外部来源(在本例中是一个 CSV 文件)获取数据。
读取文件和计算总行数的 Python 脚本
第一行:
- 在 PySpark 中，我们使用 SQLContext 模块中的 read.csv 方法从前面步骤中上传到 Databricks 的数据中读取 csv 文件。请注意，默认情况下，csv 文件存储在 Databricks 中的“FileStore/tables”目录下。
- read.csv 方法返回一个 Spark 数据帧，并将其赋给变量 df_spark 。Spark 数据帧类似于熊猫数据帧。
第二行:
- PySpark 使用 count 方法获取从 csv 文件中读取的记录的行数。
记录的总行数
第 3 部分:检查数据
一旦我们从 CSV 文件中读取了原始数据，我们可能会有兴趣通过快速浏览一些记录来了解数据集的一些基本细节。
3.1 显示列细节
打印列详细信息的 Python 脚本
- printSchema 方法显示每一列的数据类型，也显示一列是否可以为空。此时，我们可以观察到所有的列都是字符串并且可以为空。
列详细信息
3.2 显示前几行记录
显示前五行记录的 Python 脚本
- 显示 的方法是显示前几行记录。我们可以灵活地向 show 方法传递不同的值，以调整我们想要显示的行数。
前五行记录
3.3 显示特定列
显示特定列的 Python 脚本
- 我们也可以使用“方法与“ show ”方法连锁，只显示某些指定的列，而不是显示所有的列。
选定列的前五行
第 4 部分:数据争论
乍一看从 CSV 文件中读取的原始数据，我们可能会注意到几个问题:
- 由于所有列都可以为空，因此某些列中可能存在空值或缺失值。空值或缺失值会导致分析错误。
- 所有的列都是字符串。当我们希望使用数据进行统计分析或绘制图表时，这将带来问题。
- 此外，一些列没有以允许数值分析的格式呈现。例如，“尺寸栏中的值在数字后附加一个字母“M”。“安装列的值与逗号和加号字符混合。“价格”值前面也有“$”字符。
一些错误数据格式的例子
这里需要数据清理和转换，以便于数据访问和分析。
4.1 删除空值
在删除空值之前，我们需要确定可以找到空值的列。
Python 脚本显示每列中的空值
- 上面的代码检查每一列是否存在空值，并计算其频率，然后以如下表格格式显示出来。
每列中存在大量的空值
输出显示“内容分级”、“当前版本”和“ Android 版本”列中有一个空值。接下来我们将使用 dropna 方法从列中删除空值。
移除空值的 Python 脚本
4.2 删除不需要的字符
在 PySpark 中，我们可以将指定列中的数据转换成对我们有用的格式。为此，我们可以用 与 和 翻译 的方法。
移除不需要的字符的 Python 脚本
第 1–3 行:
- withColumn 的方法是指定我们要转换的列(如 Size 、 Installs 、 Price )
- 翻译 的方法是用目标字符替换字符模式。例如，translate(‘Size ‘，’ Mk ‘，’’)会将’ Size ‘列中的所有字符’ M ‘或’ k ‘替换为空字符串’ '。这意味着附加了大小值的所有字符“M”或“k”都将被删除。采用类似的方法，从安装列中去掉“+”或“，”并从价格列中去掉“$”。
第 5 行:
- 数据转换后再次显示前五条记录。
转换数据的样本
4.3 过滤不需要的值
此时，我们已经成功地从“大小”列中删除了不想要的字符“M”或“k”。然而，还有一个问题。该栏中存在值随设备变化。这是因为一些应用程序的大小会因设备而异。这样的字符串值与列中的其余值(数值)不一致，因此我们必须删除它们。
移除不需要的值的 Python 脚本
- 要从一列中过滤出一个特定的值，我们可以使用 where 方法来设置一个过滤条件，其中只有指定列的值(例如" Size ")满足特定的条件(例如！= “随设备变化”)将被选择并将其分配回 df_spark。
- 这种方法将筛选出所有大小值等于“因设备而异”的记录。
4.4 改变列的数据类型
请记住，即使我们已经完成了上面的数据清理和转换步骤，所有的列仍然是字符串格式。我们必须将一些列从字符串转换成数值。
用于更改列的数据类型的 Python 脚本
第 1–4 行:
- 我们再次使用 和 列来设置我们将要使用的特定列。接下来，我们使用 cast 方法来设置一个特定的数据类型( IntegerType 或 FloatType )，我们打算将字符串转换为该数据类型。
第 5 行:
- 再次使用 printSchema 显示每一列中更新的数据类型。
更新的数据类型
4.5 重命名列
现在，我们可以对刚刚转换了值的列进行重命名，以反映这些更改。
用于重命名列的 Python 脚本
第 1–3 行:
- 要重命名一个列，我们可以用 与 的方法来重命名。这个方法有两个参数，1)原始列名和 2)新列名。
第 4 行:
- 显示记录的前五行，以查看列名的变化。
重命名的列
4.6 删除不需要的列
并非所有的列都与这里的研究相关，我们可以删除那些不相关的列。
删除列的 Python 脚本
- 删除列很简单。只需使用 drop 方法，并将目标列名(例如评论、流派&当前版本)作为参数传递给该方法。
删除所选列后的数据帧
第五部分:查询数据
最后，我们设法以一种可用的格式获得了一个干净的数据，现在我们准备更深入地研究我们的数据。在本部分中，我们将使用 过滤 的方法，根据不同类型的条件进行数据查询。
5.1 单条件查询
一般来说，我们可以在 filter 方法中设置一个条件，这将返回所有符合条件的记录。让我们看看下面的例子:
用于搜索青少年专用应用程序的 Python 脚本
- 这个查询是为了搜索青少年专用的应用程序。
过滤记录
用于搜索评分高于 4.2 的应用程序的 Python 脚本
- 上面的查询是为了搜索“”评分大于 4.2 的记录。
过滤记录
5.2 按值范围查询
PySpark 提供了一个方法，之间，使我们能够搜索一个下限和一个上限之间的记录。
按值范围搜索的 Python 脚本
- 上面的代码返回“价格”在 1 美元到 3 美元之间的记录。
过滤记录
5.3 关键字查询
也可以根据特定列中存在的某些特定关键字来搜索记录。我们可以通过三种方法之一来实现: startswith ， endswith ， 包含 。下面我们来看几个例子:
****5.3.1 从开始
使用 startswith 查询数据的 Python 脚本
- 上面的 startswith 方法返回以“4”开头的“ Android Ver 的记录。这意味着只有运行在 Android 4 上的应用程序的记录才会被返回。
过滤记录
5.3.2 端盖
使用 endswith 查询数据的 Python 脚本
- 上面的 endswith 方法返回“ Last Updated ”结束于“2018”的记录。这意味着只会返回该应用程序在 2018 年最后更新的记录。
过滤记录
5.3.3 包含
使用包含来查询数据的 Python 脚本
- 上面的 包含 方法返回的记录中带有 App 包含关键字“照片”。这意味着只会返回名称中包含“照片”关键字的应用程序的记录。
过滤记录
5.4 多条件查询
**我们可以在数据查询中使用逻辑运算符，如 **&、|、和 ~ 来连接多个搜索条件。
使用逻辑运算符连接多个搜索条件进行查询的 Python 脚本
- 上面的代码使用了 & 运算符来连接三个搜索条件，以便只返回属于游戏类别并且最后更新年份是 2018 年并且运行在上面的 Android 5 上的 app 的记录。
过滤记录
第 6 部分:描述性统计
我们可以使用 py sparkdescribe方法轻松地对我们的数据集进行快速描述性统计研究。
用于计算描述性统计数据的 Python 脚本
- 在单行代码中， describe 方法显示了每一列的描述性统计摘要。
描述性统计概要
第 7 部分:数据可视化
我们将进入一个有趣的部分，我们将看到 PySpark 如何提供一些非常用户友好的特性，使用户能够创建不同类型的图表来可视化他们的数据。
在本部分中，我们将使用 PySparkdisplay函数绘制一些图表，以解决一些与 app 开发相关的问题。下面我们来看一些例子。
7.1 饼状图
假设我们想知道哪一类应用程序的市场份额最高。一个简单的解决方案是创建一个饼图，按类别显示安装总数。从那里，我们可以很容易地确定最主要的应用类别。
用于聚合数据和生成图表的 Python 脚本
第一行:
- 我们使用 groupby 将我们的数据按“类别分组，然后使用 agg 方法应用“ sum ”函数来计算每个类别的安装总数。聚合结果将作为新的数据帧返回，并赋给变量 df_cat_sum 。
第二行:
- 我们将 df_cat_sum dataframe 传递给 display 函数。当我们运行上面的代码时，我们将首先看到数据帧以如下表格格式显示:
列入总汇表的数据
- 如果我们看一下表格的底部，我们会看到有一个下拉列表。当我们点击它时，我们会看到有几个内置的图，我们可以选择来呈现我们的数据。
图的下拉列表
- 让我们选择“饼图，我们将看到一个饼图正在生成。
(默认情况下，图表的原始大小可能非常小。我们可以通过拖动图表右下角来放大图像来调整大小。)
圆形分格统计图表
从饼状图中可以明显看出，游戏几乎占据了应用程序市场的一半，与其他游戏相比，其市场份额最高。
如上所示，我们不需要编写额外的代码来生成绘图。相反，我们可以使用 显示 功能来处理我们的数据帧，并从下拉列表中选择一个绘图选项来显示我们的数据。
7.2 直方图
另一个问题可能会引起我们的兴趣:应用程序的大小会影响安装率吗？
我们可以预测，用户通常更喜欢轻量级应用程序，它消耗的移动设备存储资源更少。让我们通过绘制直方图来验证它。
用于聚合数据和生成图表的 Python 脚本
- 上面给出的两行代码类似于 7.1 节中的代码，只是我们试图按大小对整个安装进行分组。
- 对于这一轮，我们将从下拉列表中选择“直方图”。
从下拉列表中选择直方图
- 接下来，单击下拉列表旁边的另一个按钮“绘图选项”。
PySpark 绘图选项
- 将弹出一个定制绘图向导。将“尺寸(M) ”拖至数值字段，点击右下角的“应用”按钮。
自定义绘图向导
- 我们将看到一个直方图生成如下。
柱状图
从柱状图来看，小于 50 兆的应用最受社区欢迎。超过 100 兆字节的大小往往会驱使一大群用户远离使用它。
7.3 条形图
在开发应用程序时，我们倾向于确保我们的应用程序能够覆盖尽可能大的社区群体。我们应用的接受度高度依赖于能够支持我们应用的 Android 版本。
这就是为什么对当前最广泛支持的 Android 平台的调查非常有助于我们做出更好的决定，为我们的应用程序设置最低操作系统平台。为此，我们可以选择绘制一个条形图，显示不同 Android 版本支持的应用程序的出现次数(最低级别)。
用于计算出现次数并生成图表的 Python 脚本
- 在上面的代码中，我们使用 count 方法来获得每个应用程序的出现次数，这些应用程序按其支持的最低 Android 版本分组。我们还尝试按降序对结果进行排序。
- 从图的下拉列表中，选择“条形图”图表。
从下拉列表中选择栏
- 单击“绘图选项打开“自定义绘图”向导，然后确保我们将“ Android Ver ”拖至系列分组字段，并将“ count ”拖至值字段。最后，单击“应用”按钮。
自定义绘图向导
- 最后，我们将看到一个条形图生成如下。
条形图
从上面的条形图中，我们了解到 Android 版本 4.1、4.0.3、4.0 和 4.4(最低级别)支持大多数当前应用程序。因此，如果我们打算瞄准更大的市场，明智的做法是让我们的应用程序得到 Android 版本 4 及更高版本的支持。
7.4 堆积条形图
现在，我们希望为我们的应用程序设定一个合理的价格。虽然定价在很大程度上取决于开发和维护成本，但另一个值得考虑的重要因素是用户的承受能力。高昂的价格标签会阻止许多用户使用我们的应用程序，即使我们的应用程序开发和维护得很好。
在这里，我们创建了一个堆积条形图，向我们展示不同用户群的支付能力的一些线索。
仅选择付费应用程序并生成图表的 Python 脚本
- 在上面的代码中，我们使用 filter 方法只选择那些付费应用的记录，返回的数据帧被赋给一个变量df _ app _ payed。
- 从图的下拉列表中，再次选择“条图”。
选择栏选项
- 单击“绘图选项”打开“自定义绘图”向导，然后确保我们将“内容分级”拖到“关键字”字段，“价格($) ”拖到“系列分组”字段，“T24”安装(+) ”拖到“值”字段。确保选中“堆叠”单选按钮。最后，单击“应用”按钮。
自定义绘图向导
- 我们将看到一个堆积条形图生成如下。
堆积条形图
显然，0.99 美元的价格标签最广泛地被所有年龄组接受。10 美元以上的价格标签很难获得显著的公共市场份额。
7.5 盒图
最后，我们还有一个问题:应用程序的价格会影响应用程序的评级吗？如果用户付费多了，会不会对 app 寄予更高的期望？
为了解决这个问题，让我们创建一系列的方框图。
基于类别和评级选择记录并绘制图表的 Python 脚本
- 我们只是通过使用逻辑操作符来应用上一节中介绍的类似步骤&选择属于游戏类别和评级为 5 或更低的记录(这个条件是必需的，因为评级列中有一些异常)。我们还根据评级对过滤后的记录进行降序排序，然后将数据帧赋回变量df _ app _ payed。
- 从图的下拉列表中，选择“方框图”。
选择“方框图”
- 单击“绘图选项”以打开“自定义绘图”向导，然后确保我们将“评级”拖至 Keys 字段，并将“价格($) ”拖至 Values 字段。最后，单击“应用”按钮。
自定义绘图向导
- 一系列评级的箱线图如下所示。
箱线图
箱线图没有显示出明显的模式，即中值价格越高，评级越低，反之亦然。价格为 0.99 美元的应用程序可以获得 3.4 到 5 的评级。
结论
在本文中，我们看到了如何使用 PySpark 在分布式计算环境中执行数据探索和可视化。如果您熟悉 Pandas Dataframe，您可以很容易地适应 PySpark Dataframe，因为除了语法上的一些细微差别之外，它们之间有许多相似之处。然而，了解 Pandas 不是为并行处理而设计的，而是基于单线程操作，这一点很重要。因此，Pandas 并不是在大数据环境中处理大量数据集的理想选择。另一方面，PySpark 还提供了一种非常用户友好的方式来从它的数据帧中绘制一些基本的图形。基本上，数据可视化工作可以通过如上所述的图形用户界面来完成。
值得一提的是，还有很多 PySpark 特性没有在本文中讨论，其中两个是弹性分布式数据集(RDD)** 和 Spark MLlib ，它们太宽泛了，无法在一篇文章中涵盖。我在这里的目的是通过主要关注 PySpark 的数据框架来介绍 PySpark，我希望这可以帮助那些已经熟悉 Pandas 的人将数据技能迁移到 py spark。**
我希望你喜欢这篇文章并从中受益。
参考
每天 10 分钟学习 Python 10
每天 10 分钟 Python 速成班
Python，IPython，Jupyter lab 是什么？
这是一个系列的 10 分钟 Python 短文，帮助你开始学习 Python。我试着每天发一篇文章(没有承诺)，从最基础的开始，到更复杂的习惯用法。如果您想了解关于 Python 特定主题的问题或请求，请随时通过 LinkedIn联系我。
根据 PYPL(编程语言的流行程度)，Python 是目前最流行的编程语言。这是有充分理由的，因为它是为通用快速编程而设计的，可读性是核心规则。许多成功的公司，如 Reddit 和 Dropbox，都是围绕 Python 建立的。虽然易学从来就不是设计目标，但许多人都这样描述，很可能是因为 Python 社区非常欢迎初学者。
从主网站来看，Python 自称是一种解释的、面向对象的、具有动态语义的高级编程语言。它被解释，因此，不需要编译步骤，减少了编辑-测试-调试周期的时间。这种语言不仅支持面向对象的编程(函数式编程也很好)，而且在 Python 中一切都由一个对象表示。高级别意味着您不必担心低级别的系统细节，如内存分配和垃圾收集。Python 是动态类型的，这意味着变量是对对象的引用(或标签),它们可以在运行时自由改变。对于像 C 这样的静态类型语言来说，情况就不一样了，在 C 语言中，变量类型必须在编译时声明。
我可以想象这些通用的设计规则目前很难掌握，但随着时间和更多的经验，它最终会变得清晰，我保证！我一般建议人们记住的是，Python 被设计得非常简单。我不止一次惊讶于简单的 Python 如何解决一些问题。如果您想快速掌握 Python，您必须亲自动手编写代码。
要开始使用 Python，需要安装一个版本(Mac 和很多 Linux 发行版上已经有预装版本)。虽然最直接的方法是去 Python.org 下载最新版本，但我推荐使用 Miniconda。为此，我写了一篇关于如何和为什么的简短指南。python 安装后，就可以开始使用“Python”了，比如从终端。这就打开了一个所谓的 REPL:阅读、评估、打印、循环。它只是某种直接与 Python 交互的命令行界面(CLI)。您可以直接执行任何 python 代码和/或打开文件来运行 Python 脚本。python 解释器通常用于从 CLI 运行脚本，除了一个快速计算器，我不知道有谁直接使用 REPL 界面。为了更交互地使用 Python，几乎所有人都使用 IPython。
您的终端可能看起来不同，但在这里我启动了两个 REPLs。
IPython 提供了一个增强的交互式 Python shell，开始时只需在终端中键入“ ipython ”(您可能需要使用“ pip install ipython ”来安装它)。IPython 的另一个惊人特性是从 REPL 中分离出“E ”,它称之为“内核”。内核接收执行指令并发回结果。虽然使用内核有很多好处，但广泛使用的一个好处是其他应用程序(如 Spyder 和 Jupyter)连接到 IPython 内核。需要与内核交互的应用程序通常会自己启动。
如果您喜欢使用简单的文本编辑器进行开发，IPython 可能就是您所需要的。你想有一个更成熟的 IDE，有 pyCharm 或 Visual Studio 代码(VSC)。我认为开发人员在那里感觉很自在。对我来说，作为一名数据科学家，我在 Jupyter 笔记本上感觉最舒服。这是 IPython 交互式 shell 和一个文档的组合，您可以将您的代码与结构化的解释片段结合起来。几个星期后，我的记忆会变得模糊，有时我会忘记自己打算做什么。因此，对我来说，围绕代码的文档是非常宝贵的。为了给它一点 IDE 的感觉，他们创建了 Jupyter lab(“pip install Jupyter lab”)，这是 Jupyter 的一个扩展，具有更多的功能。用你觉得最舒服的方式工作，或者如果你没有偏好，用你同事最常用的方式。对于内部工作，这都是 IPython，它本身就是 Python。
今天的练习:
如果你还没有，我强烈建议你使用 Miniconda 设置 Python，就像这个指南中建议的那样。
- 启动基本的 Python REPL 并运行“打印(’ hello world ')”命令。您可以使用“quit()”或“exit()”退出它(注意括号？).
- 启动 IPython REPL 并运行“print('hello world ')”命令。您可能需要安装 IPython。在这里，您可以使用“退出”或“退出”来退出。
- 设置您的首选 Python 环境，即 Jupyter、VSC、Spyder、pyCharm，或者如果您只是从文本编辑器和终端工作，则不设置任何环境。这对于示例来说并不重要，但是我们将展示来自 Jupyter 实验室或简单的 IPython 的所有内容。
如果您有任何问题，欢迎通过 LinkedIn 联系我。
每天 10 分钟学习 Python 10
每天 10 分钟 Python 速成班
测试你的新技能:编写一个快速排序算法
这是一个系列10 分钟的简短 Python 文章，帮助您提高 Python 知识。我试着每天发一篇文章(没有承诺)，从最基础的开始，到更复杂的习惯用法。如果您对 Python 的特定主题有任何问题或要求，请随时通过 LinkedIn 联系我。
今天，我们不会讨论一个新的话题，而是有一个简短的任务来强化你的知识。大约十年前，我参加了一个演讲，在演讲中，Python 因为做科学计算而得到了推广。在这次演讲中，有一个例子展示了快速排序算法。快速排序是一种相对简单但有效的排序算法。在演讲中让我惊讶的是，在讨论了算法如何使用伪代码工作后，python 解决方案几乎与伪代码完全相同。希望您也能惊讶于用 Python 实现该算法是多么简单。
快速排序算法图。
快速排序是一种所谓的分治算法。首先，它从列表中选择一个元素，这个元素称为 pivot。然后，它遍历剩余的元素，并将它们分成三组:小于透视值、等于透视值和大于透视值。它通过调用本身对更小和更大的部分重复这个过程。最后，它将所有列表合并在一起，得到一个排序后的列表。在伪代码中，它看起来像这样:
仅使用这些信息和我们到目前为止讨论的所有主题，您应该能够编写自己的快速排序算法。您可能需要的唯一东西是一个很好的值排序列表。有许多方法可以创建它们，但是我们还没有讨论可能有助于生成随机数的包。因此，我将提供创建随机数列表的代码:
代码片段从 Python 标准库中导入 random 模块，并用于生成随机数。random()函数返回一个介于 0 和 1 之间的随机数。为了让它们更大一些，我们将它们乘以 100，这样更容易阅读。在实现您的解决方案时，我会保持 N(即值的数量)较小。当一切正常时，可以随意试验排序列表的大小。在 IPython 中测试代码的一个好方法是使用 %timeit 魔法命令。魔术命令是内置于 IPython(而不是 Python 本身)的特殊函数，用于帮助完成各种事情。 %timeit 函数将一个函数重复几次，并给出每次迭代的平均值。这是测试代码执行速度在改变步骤时是否有所提高的一个很好的方法。如果你已经解决了，这里的就是我的解决方案。
我希望你在实现快速排序算法的过程中获得了乐趣。它仍然经常被使用，当然有一些优化。你注意到和伪代码的相似之处了吗？
如有任何问题，欢迎通过 LinkedIn 联系我。
下一次会议将于星期一再次提供。
每天 10 分钟学习 Python 10
每天 10 分钟 Python 速成班
用 Python 读写文件
这是一个系列10 分钟的简短 Python 文章，帮助您提高 Python 知识。我试着每天发一篇文章(没有承诺)，从最基础的开始，到更复杂的习惯用法。如果您对 Python 的特定主题有任何问题或要求，请随时通过 LinkedIn 联系我。
imgflp.com 的热图生成器
Python 可以被看作是一把瑞士军刀，附带了许多方便的工具来快速完成工作。一个经常出现的任务是与文件交互。从文本文件加载数据以用于分析，或将计算结果写入日志文件等任务。文件可以被看作是一大串数字，它们被保存在磁盘上的 0 和 1(二进制)中。当人与文件交互时，格式被翻译回我们理解的东西，例如 ASCII 字符(对于一个简单的文本文件)。所有这些实际的存储和翻译都是由我们的操作系统完成的。
有不同类型的文件，例如文本文件、二进制文件、图像等。每种类型都有自己的格式，可能需要特定的处理方法。例如，图像文件可以分成不同的部分:存储一般元数据的头部和存储图像实际数据的数据部分(很可能使用某种压缩)。在一个简单的文本文件中，字节代表字符。这些字符如何被编码取决于所使用的编码。早期使用的是 ASCII，能够表示 128 个字符。如今，UTF-8 是事实上的标准人物代表。这种编码与 ASCII 兼容，但将字符数扩展到超过一百万。UTF-8 使用 8 位进行编码，但可以组合多达 4 个字节来表示一个字符。您可能会想到为文件设置错误的编码会导致错误。尽管如此，从 UTF-8 开始是一个不错的猜测，因为 95%的网络使用这种编码。
处理文本文件时需要注意的另一件事是行尾。虽然这看起来微不足道，但由于历史原因，在如何编码新行方面存在差异。Windows 使用 ASA(美国标准协会)标准，并要求文本文件中的每一行都使用回车符(表示为 \r )和换行符(表示为 \n )结束。基于 Unix 的系统(包括 Linux 和 Mac)只需要换行符 (ISO 标准)。将文本文件从 Linux 发送到 Windows 可能会有些复杂，反之亦然，所以如果您从另一个系统获得文本文件，请注意。
对于其他文件格式，即非文本文件，您很可能会使用软件包。虽然您可以在二进制模式下打开文件，但您必须手动处理文件格式。社区已经提供了处理许多文件的包，很可能也是你想要打开的文件格式。例如 hdf5、jpg、json 或 csv，但是还有很多其他的包来帮助处理文件。在本教程中，我们将只关注文本文件。
要打开文本文件(实际上任何文件都可以打开)，我们使用内置的 open() 函数。该函数至少需要一个文件名作为参数，并返回一个文件对象。它有模式作为可选的第二个参数，我们可以设置读取、写入和其他一些特殊模式。我们可以使用 file 对象提供的方法与文件进行交互。让我们从几个例子开始:
在这个例子中，我们以三种不同的模式打开了一个文件。默认情况下，当不提供模式字符串时，文件以读取模式打开( r )。这意味着该文件需要存在，否则 Python 将出现错误:“FileNotFoundError”。要写入一个文件，我们必须使用字符串’ w '显式声明写入模式。现在，如果文件存在，它将被打开写入，如果它不存在，一个新的文件将被创建。小心，因为写模式会覆盖现有文件。要追加现有文件，open 函数具有追加模式(a)。
使用可以将字符串写入文件。写()的方法。 print() 函数自动给字符串添加一个换行符 (\n)。向文件中写入行时，情况并非如此。如果你想有一个新的行，你必须显式地添加特殊字符到字符串中。我们称之为单个字符，因为它将被编码为单个字符。反斜杠是表示特殊字符的特殊字符，像换行符 (\n)或者制表符 (\t)。它也可以用来“转义”字符，意思是将字符用作文本而不是语法。例如，在引号前使用反斜杠，不会将其标识为字符串的开头，而只是作为引号字符(“转义”语法定义)。
文件的读取可以使用。read()方法。Python 将文本文件视为可迭代的，并通过换行符(\n)分隔每个项目。因此，我们可以使用 for 循环来遍历整个文件。file 对象还提供了同时处理所有行的方法: readlines ()和 writelines ()。 readlines() 方法读取由换行符分隔的所有行，并将这些行作为列表返回(包括每个字符串中的\n 指示符)。类似地， writelines() 方法将字符串列表写入文件。后者不在列表中的每个字符串之间添加换行符。这可以使用 join 方法来修复: '\n '。加入(我的 _ 列表)。
处理完一个文件后，您必须关闭 file 对象。如果您不这样做，根据您的操作系统，您可能会丢失数据。一些操作系统缓存必须写入磁盘的数据。当文件关闭时，操作系统会将其作为一个大块写入磁盘，以最大限度地减少磁盘访问。这有助于最大限度地减少 IO 操作，在某些情况下还可以更快。这也意味着您必须确保正确关闭文件。每个 file 对象都有一个. close()方法。通过简单地调用该函数，文件被关闭，所有文件被保存。
今天的练习:
我从维基百科复制/粘贴了葡萄酒生产国的数据，并把它们放在一个文本文件中。你可以在这里下载文件，或者自己复制/粘贴表格到一个文件中。这张桌子上有行号、国名和以吨为单位的葡萄酒产量。
作业:
阅读文件，汇总世界上生产的葡萄酒总量。
提示:
——列由一个特殊字符分隔(记住。split()方法？)
-你要把字符串转换成数字。你也注意到令人讨厌的小数点分隔符了吗？(.有一个内置的 sum()可以对你新创建的数字列表求和。
如有任何问题，欢迎通过 LinkedIn 联系我。
每天 10 分钟学习 Python 10
每天 10 分钟 Python 速成班
尝试，除了，最后，和上下文管理器
这是一个系列10 分钟的简短 Python 文章，帮助您提高 Python 知识。我试着每天发一篇文章(没有承诺)，从最基础的开始，到更复杂的习惯用法。如果您对 Python 的特定主题有任何问题或要求，请随时通过 LinkedIn 联系我。
当你用 Python 写代码时，你会(很可能)犯错误。有些会导致语法错误，这是因为您很可能拼错了某个单词，从而导致无效的 Python 代码。这些错误并不难改正。Python 中的其他类型的错误是异常。这些错误在将 Python 代码转换成字节码时完全没问题(没有语法错误)，但是当试图执行某些东西时，就会出现无效的东西。例如，不能用圆周率除一个字符串。这对我们来说没有什么意义，Python 也不知道该做什么，并引发了一个异常。其中一些例外非常明显。例如，打开一个不存在的文件进行读取会引发 FileNotFound 异常。不是所有的例外都那么明确，甚至都是你的错。例如，尝试联系关闭的 restAPI 也会导致异常。当然，最好是尽量避免所有的错误和异常，但是 Python 中的一个习语总是让我吃惊:
请求原谅比请求允许容易( EAFP )
在 Reddit 上发现的模因是正确的。
Python 有一个用于捕捉异常的结构，即 try/except 块。顾名思义，它将尝试执行 try 块中的所有语句。如果成功了，一切都完成了。如果由于某种原因引发了异常，它将执行 except 块，并且所有错误都被抑制。虽然我们可以讨论这是否是一种好的编程方式，但它是一种非常有效的方式，因为它比试图首先检查所有可能的错误要快得多。try-except 块可以通过提供异常类型来检查许多特定的异常，或者通过将异常类型留空来捕捉任何异常。异常实际上是 exception 类型的对象(你惊讶吗？).让我们从一个如何使用这个结构的例子开始。
在这个例子中，我们有一个有效的函数来除两个数。这将很好地工作，除非你有第二个数字等于零。我们都听说过除数为零是没有定义的，我们从 Siri 那里了解到，你不能在零个朋友之间分配五块饼干。如上面的代码所示，除以零会导致 ZeroDivisionError:
哎呦……
ZeroDivisionError 是一个对象，通过使用 try-except 构造，我们可以捕获错误并阻止我们的脚本崩溃。在示例中，我们创建了 secure_divide ，它将尝试对值进行除法运算。在第一个 except 语句中，我们将专门捕捉 ZeroDivisionError。如果我们除以零，Python 将结束执行这个块中的语句。会不会有另一个问题，例如，如果我们引用一个不存在的变量，它会在第二个 except 块中结束，该块捕获所有(其他)异常。我们可以根据需要测试尽可能多的异常，或者只是捕获所有异常，而不提供异常。
如果您看到一个错误(或异常)，我发现最简单的方法是从下到上阅读错误。最后一行显示了异常和错误的简短描述。然后，错误消息在前面有错误的行周围显示代码块。有错误的行显示错误发生在哪一行。如果错误发生在函数中，上面的每个代码段都比高一级*，直到第一个代码块是代码的顶层。这有时会令人困惑，因为这些代码块的一部分来自导入的库，即不是您创建的代码。诀窍是忽略这些，并向更高的层次前进，直到你达到自己的代码层次。虽然从技术上讲，错误可能出现在一个包中，但更常见的是我们错误地使用了代码，并在导入的函数中输入了错误的参数。*
对于特定的情况，try-except 构造是一个很好的方法，但是我建议尽量少用它。然而，非常有用的一点是 try-(except)-finally 结构。except 在括号之间，因为它是可选的。一个简短的例子:
在本例中，第一个代码片段显示了 try-finally 构造。它将尝试执行 try-block 中的所有代码，不管代码是成功还是失败，它将总是执行 finally 块中的部分。第二部分演示了这一点，我们故意让 try 块失败。在这两种情况下，都会打印“done”字符串。
try-finally 构造非常有用，在 Python 中使用得很多，但可能不是直接可见的。例如，当处理文件时，我们必须确保在完成后关闭文件。这可以通过 try-finally 构造来实现:
不管成功还是失败，try-finally 总是确保文件被关闭。这是一个非常棒的概念，Guido 决定创建一个特殊的构造来使它更加紧凑(并且在脚本的底部没有一个或多个 finally-clauses)，即带有关键字的*。带有关键字的打开(或连接，或…)一个对象，并将其连接到一个标识符。在下一个缩进的代码块中，变量是可用的，我们可以执行任意多的语句。当我们退出代码块时，或者当一个错误发生时，文件(或者连接，或者……)被关闭，与我们之前创建的 try-finally 构造相同(只是方式更短)。Python 中的这种语法称为上下文管理器，并且不仅仅适用于文件。它也经常与数据库一起使用。对数据库的更改通常会被收集起来，直到您提交它们。上下文管理器可以确保这些行被提交，并且数据库连接被正常关闭，而不管是否有错误。请记住，上下文管理器(使用和关键字)确保代码的最后部分总是在代码段的末尾执行。最容易记住的方法是打开文件+关闭文件的例子。*
今天的练习:
在 Python 中，获得交互式用户输入的最简单方法是使用 input() 函数。用户可以键入一个值，然后按 enter 键提交该值。该值是一个字符串。
input_value = input() # *this also works in a Jupyter Notebook*
赋值:
询问用户年龄，测试是否小于 42。因为输入值是一个字符串，所以需要将其转换为整数。使用 EAFP 原理捕捉无效输入，例如，如果用户输入字符串而不是数字。
如有任何问题，欢迎通过 LinkedIn 联系我。
每天 10 分钟学习 Python 10
每天 10 分钟 Python 速成班
字典:键值存储
这是一个系列10 分钟的简短 Python 文章，帮助您提高 Python 知识。我试着每天发一篇文章(没有承诺)，从最基础的开始，到更复杂的习惯用法。如果您对 Python 的特定主题有任何问题或要求，请随时通过 LinkedIn 联系我。
模因生成与imgflip.com
Python 中几乎所有的数据类型都是不可变的(不能改变)。到目前为止，我们只看到了强大的列表，它是可变的列表之一。列表是一个有序的容器，可以保存任何类型的数据，包括其他列表。今天，我们将使用另一种可变数据类型:字典。字典是 Python 的另一匹马，它的作用就像一个键值存储。字典中的条目是通过键来访问的。与列表类似，值可以是任何对象，包括其他列表或字典(dictionary-ception)。第一次看到这个可能有点奇怪，但关键也可以是几乎任何东西。几乎任何东西，因为密钥必须是不可变的。可以是整数，字符串，浮点，复数，元组，任何对象，只要是不可变的。让我们看一些例子来说明这一切意味着什么。
使用 dict() 关键字或更短的花括号符号来创建字典。要定义值，您必须提供键-值对，用分号分隔。如前所述，键可以是任何不可变的东西。在这个例子中，我们当然使用了通常没有意义的键(除了一些非常特殊的情况)。要访问这些值，您必须提供括号之间的键。在这个例子中，我们有五个不同的键，我们需要使用确切的标识符。如果您未能提供正确的密钥，将会出现密钥错误。使用字典无法进行切片。因为 Python 中的一切都是对象，所以您也可以将函数用作键或值。因此，使用 key_value[5] 是对打印函数的引用，我们可以立即使用括号为该函数提供参数。如果这是令人困惑的，不要担心。了解这些结构很好，但不经常使用。需要记住的最重要的一点是，列表是有序的，因此可以通过列表中的整数位置来访问，而字典是无序的，只能通过它们的键来访问。从 Python 3.7 开始，保留了字典的顺序(所以它们现在是有序的)，而早期版本则不是这样。
我们为列表学习的内置函数和操作符也适用于字典。我们可以用 len() 检查键值对的数量，并使用简单的布尔测试检查字典是否为空。对于列表，我们可以使用关键字中的来检查列表中是否有值。对于字典，这将测试字典中是否存在一个键。此外，字典还附带了一些附加到对象上的方法:
对于字典的迭代，我们必须做一些特殊的事情，因为我们有键值对。对于这一点，字典里有*。items()* 方法，该方法将键和值压缩在一起。在 for 循环中，您可以对每次迭代的键和值进行解包。要追加到字典中，可以直接使用括号符号。如果这个键不存在，它将被创建一个新的条目，如果存在，它将被更新。为了获得键的列表，字典有*。keys()方法。这是检查钥匙使用情况的方便快捷的检查。有一个类似的方法可以得到所有的值:。values()* 。
字典是在一个单一的结构中收集各种信息的好方法，并且经常被使用。这对于链接到其他值的值非常有用。例如，一个城市的居民或一顿饭的热量。与列表一起，字典是 Python 中数据结构的核心，并且在许多情况下足以解决问题(与数据类等更复杂的结构相比)。
今天的练习:
较早的加密技术之一是所谓的张敬利密码。这是一种替代密码，其中每个字符移动一个固定的数字。据说朱利叶斯·张敬利用密码对他的具有军事意义的信息进行了编码。据说他用了右移三，意思是所有的 A 都变成了 D，所有的 B 都变成了 E，等等。今天的作业是，你必须解密一条加密信息。
alphabet = 'abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890!?' # one long string
n = 13 # cipher shift (to the right)encrypted_message = 'VMyAHrM3KFuA MHrDKMzGpul'
任务:
使用字典创建解密密钥，解密秘密消息。
提示:
1。您可以应用切片来相应地移动字母表。你必须将字母切分两次(从 n 移动到结尾+从 n 开始)并连接它们。
2。要创建解密字典，请使用 for 循环来填充它。为此，您可以将两个字符串(alphabet 和 shifted _ alphabet)压缩在一起，并对字符进行迭代。
3。最后，您可以迭代加密的字符，并使用您的解密字典将该字符替换为可读字符。
我已经在我的 Github 上发布了解决方案。
如有任何问题，欢迎通过 LinkedIn 联系我。
每天 10 分钟学习 Python 10
每天 10 分钟 Python 速成班
元组和集合
这是一个系列10 分钟的简短 Python 文章，帮助您提高 Python 知识。我试着每天发一篇文章(没有承诺)，从最基础的开始，到更复杂的习惯用法。如果您对 Python 的特定主题有任何问题或要求，请随时通过 LinkedIn 联系我。
我们已经对 lists()和 dict()有了一些了解，但是还有另外两种数据类型你会经常遇到:元组和集合。让我们首先从元组开始。元组几乎与列表相同，但是它们是不可变的。这意味着它们在创建后不能改变，因此失去了动态的属性。因为列表是灵活的，所以它们也可能有些慢。如果不需要列表的灵活性，元组可以稍微加快脚本的速度。就我个人而言，我从未注意到任何速度上的差异，因为我使用的列表相对较小。因为元组是不可变的，所以您也可以将它们用作字典键，并使用多个值创建特殊的标识符。这当然是一个特殊的用例，但非常酷。元组最常见的用途是组合多个对象作为函数的返回值。当我刚开始使用 Python 时，我根本没有意识到我在使用元组。首先，让我们从一些例子开始:
元组是使用 tuple() 关键字、更短的括号符号以及我很久以后才意识到的东西创建的，只是通过使用逗号分隔对象。在这个例子中，我们创建了空元组。这当然没有多大意义，因为它们是不可改变的，它们注定永远是空的。如果一个元组有一个或多个值，可以使用括号符号和顺序整数索引像访问列表一样访问它们。然而，更常见的用法是直接将元组解包成多个变量。在这个例子中，我们创建了一个非常有用的函数，它返回两个值。我们没有在 return 语句中包含括号，但是 Python 仍然创建了一个元组。返回值可以被“捕获”为一个元组，或者我们可以将它们解包为两个值。我认为后者更具可读性。如果函数返回许多值，直接使用元组是有意义的。
最后一个基本数据类型是集合。该集合是一种无序的数据类型，也是可变的。我们可以在集合中添加或删除项目，但是只有唯一的项目会被保存，根据定义，集合中没有重复的项目。为了实现这一点，一个集合只能包含不可变的数据类型。这意味着您不能拥有包含列表、词典或其他集合的集合。集合本身的工作方式也非常类似于列表。您可以使用关键字中的来检查列表中是否有值，并使用布尔测试来检查列表是否为空。 len() 函数也像预期的那样工作。有很多方法:例如，添加、删除、弹出等等。使用制表符补全可以很容易地找到这些方法，并且它们都有一个 DocString。
集合可能有许多不同的用例，但我只使用它来获取列表中的唯一条目。例如，如果你有一段文字，很容易将文字分割成一个单词列表。现在，把这个列表转换成一个集合，我们就有了所有独特的单词。要创建集合，我们可以使用 set()关键字或更短的花括号符号。花括号也用于字典，但是，要得到字典，你必须提供键值对。要创建一个集合，只需在花括号内提供用逗号分隔的值。集合不保持顺序(集合是无序的)。因为也没有键，所以我们不能使用括号符号来访问这些值。试图使用 my_set[1] 访问一个值将导致一个 TypeError 异常，因为一个集合是不可订阅的。集合主要用于检查一个项目是否包含在集合中。还有一些运算与集合的数学定义有关，如并、差、交。
虽然集合很少被使用，但是在特定的用例中它们会很方便。元组被经常使用，但是我们可能没有意识到。解释完这两个类后，您现在知道了 Python 中所有的基本数据类型。当然还有许多其他类型的对象，你甚至可以使用类定义来创建自己的数据类型。但这是未来会议的事情。
今天的练习:
在自然语言处理(NLP)任务中，一种常见的分析是词频分析。一段文本(通常称为语料库)由单词(有时称为标记)组成。检查哪些单词比其他单词用得更频繁可能会很有趣。为此我们可以做一个词频分析。第一步是从文本中找到独特的单词。这闻起来像一套伟大的用法。我从维基百科上复制了一小段文字，并提供了排序功能:
作业:
找出出现频率最高的十个单词及其出现频率。
提示:
1。语料库包含大写和小写字符以及一些标点符号。为了获得更好的结果，你应该把它们都做成同样的大小写，并去掉标点符号()。替换()，。upper()，。下() )
2。语料库是一个巨大的字符串。你可以用把它拆分成单词。split() 功能。
3。使用集合，您可以在列表中找到唯一的项目。我们可以遍历一个列表，统计每个单词在原始单词列表中的出现次数。为此，列表中有*。*计数()方法。将结果填充到一个新的字典中，该字典使用单词作为键，使用频率作为值。
4。我们不必数每个单词。为了获得更好的结果，我们应该排除停用字词集中的字词。
5。如果您有词频字典，使用提供的函数获得元组的排序列表并打印前十个条目。
我已经在我的 Github 上发布了解决方案。
如果你有任何问题，请随时通过 LinkedIn 联系我。
每天 10 分钟学习 Python 10
每天 10 分钟 Python 速成班
在 Python 中使用文件和路径
这是一个系列10 分钟的简短 Python 文章，帮助您提高 Python 知识。我试着每天发一篇文章(没有承诺)，从最基础的开始，到更复杂的习惯用法。如果您对 Python 的特定主题有任何问题或要求，请随时通过 LinkedIn 联系我。
我们已经学习了处理文件的基本知识。使用 open()函数我们可以打开或创建一个文件对象，使用这个文件对象我们可以读写一个文本文件。但是如果我们需要访问多个文件呢？我们需要处理的数据通常不在单个文件中，而是分布在多个文件甚至多个目录中。为了处理文件和路径，我们可以使用几个标准的库包。几年前，我总是用 glob 包来做文件列表，用 os 包来做文件系统操作，比如删除文件。现在我大多使用标准库的 pathlib 包，它结合了前面两个，是平台无关的。pathlib 包引入了 Path() 类，一个表示路径或文件的对象。
要使用 Path() 类，我们需要导入它。下周我们将花一节课来讨论进口实际上是做什么的。现在，我们将只使用 import 语句向 Python 添加额外的功能。我们使用特殊的 from … import … 语句来实现这一点，该语句将一个选择性的部分导入到当前名称空间中(不要担心，我们将在下周讨论这些术语)。让我们来看几个例子:
可以看到， Path() 类非常方便。它带有路径或文件的大量信息。例如，它有一个关于词干文件名或者扩展名的属性。内置了许多方法来提取信息，例如创建日期、文件大小、检查是否存在、它是文件还是目录等等。此外，许多文件系统操作还是可用的。其中一些操作返回一个新的 Path()对象。在我看来，所有的例子都相对容易理解。有一些小的微妙之处值得了解。Path()对象是不可变的数据类型。这意味着您可以将它用作字典键。这很可能也是重命名文件时对象中的路径不变的原因。在接下来的例子中，我们将展示如何处理多个文件。
为了处理多个文件， pathlib 合并了*。glob()* 方法。它和 glob 包是一样的，在这里你可以根据一个模式找到所有的名字。在这个例子中，我们找到了所有以结尾的文件。txt 扩展名。结果是一个 Path 对象列表，这些对象依次打开前面讨论的所有选项。您可能会注意到，这些文件不是整齐有序的，而是按照它们在文件系统中出现的顺序排列的。你可能注意到的另一件事是“/”操作符。Path()对象定义了“/”运算符，以便您可以连接路径。在我们的例子中，我们用一个目录(一个 Path()对象)和一个文件名(一个字符串)来实现这一点。
Pathlib 将标准库中的许多包组合成一个对象，几乎可以处理任何文件系统。因此，我强烈推荐使用这种方式，而不是使用 os 包的旧标准。虽然这些方法也不错，但是 pathlib 给了你一个更简洁的格式，几乎所有你需要的功能都在手边。
今天的练习:
Path()有许多很好的用例，今天我们也将练习一个。我提供了一个带有文件夹的 zip 文件(这里是)。文件夹中的文件属于“word”类型，每个文件都是包含一个单词的文本文件。
赋值:
使用 pathlib 遍历所有文件，读取所有单词。有一个问题:glob 结果没有按升序排序。因此，你必须从文件名开始按升序排列单词。你能按正确的顺序打印这些单词吗？你可能会发现一个低级的笑话；-).
提示:
1。使用 glob 获取文件列表。
2。当遍历每个文件时，将文件编号作为关键字，将单词存储在字典中。您可以从文件的词干中提取文件号，并使用。split()方法。确保将数字转换为整数。
3。接下来，您必须遍历已排序的键，并打印每个单词，以空格(')作为结束字符(使用 print() 中的 end=’ ’ 参数)。下面是一个如何对字典键排序的例子，因为我们还没有讨论过 sorted() 。
my_dict = {4: 'ba', 6: 'bing', 5: 'da', 8:'!!!'}
for key in sorted(my_dict.keys()):
print(my_dict[key], end=' ')
我已经在我的 Github 上发布了解决方案。
如有任何问题，欢迎通过 LinkedIn 联系我。
每天 10 分钟学习 Python 10
每天 10 分钟 Python 速成班
导入、模块、包、库和框架
这是一个系列10 分钟的简短 Python 文章，帮助您提高 Python 知识。我试着每天发一篇文章(没有承诺)，从最基础的开始，到更复杂的习惯用法。如果您对 Python 的特定主题有任何问题或要求，请随时通过 LinkedIn 联系我。
我们已经引入了一些东西，但没有真正解释发生了什么。今天我们将学习 Python 中的导入实际上非常简单。使用导入，我们可以向 Python 添加功能。因为 Python 是一个如此活跃和开放的社区，所以有很多东西需要导入。甚至 Python 本身也附带了丰富的标准特性库(包括电池)。例如， pathlib 库给了你文件系统的超能力。但是也有无数的第三方包和库扩展了 Python 或者使得某种功能非常容易实现。例如，Flask 是创建动态网站的一种非常简单的方法。熊猫增加了一个新的数据帧结构，这对于数据科学来说是惊人的。几乎对于任何用例，都有某种可用的包。
在imgflp.com创造的迷因。
在我们开始之前，我们需要澄清一些术语。包含 Python 代码的文件被称为模块，具有*。py* 分机。模块可以被导入，通常由一个或多个函数或类组成。如果您导入一个模块(另一个。py 文件)到当前脚本中，这些函数和/或类在当前脚本中变得可用。这是一个很好的方式来编码干燥和共享代码。要为多个模块提供结构，您可以将它们组合成一个包。Python 中的包只不过是一个目录，其中包含所有模块和一个名为 init.py 的特殊文件。如果该文件位于目录中，则可以使用目录名导入包。当包变得越来越大时，您可以将它们组织到更多的文件夹中，并创建一个库。在幕后，库在概念上等同于包。框架是库的集合。例如，Flask 有许多用于授权和数据库交互的子包。通常，您导入的所有内容都可以追溯到 Python 脚本。
另一个重要的概念是名称空间。一个名称空间定义了一个名称在哪里是已知的(作用域)。Python 有一个全局内置名称空间，这使得像 print 这样的函数随处可见。在这个名称空间中，我们有模块名称空间。我们创建的 Python 程序也称为模块。我们定义的每个变量在这个模块名称空间中都是已知的。这意味着如果我们在脚本顶部定义 banana=3，从现在开始，这个变量在整个模块中都是已知的。每次创建函数时，它都有自己的名称空间。这意味着每个变量的定义只有函数内部知道，不能从函数外部访问。然而，来自模块命名空间的变量在函数内部是可用的。
对于下一个例子，我们首先需要创建一个模块。为此，我们将使用 IPython 中一个名为%%writefile 的神奇命令。顾名思义，它会将单元格的内容写入一个文件。该文件包含一个包含变量和函数的简短 Python 脚本:
有两种方法可以导入我们的新模块。第一个是常规导入，它将整个文件导入到其词干文件名命名空间(不带扩展名的名称)下。因为模块名可能很长(我们懒得键入)，我们可以使用作为关键字将名称空间重命名为较短的名称。很多热门包都有众所周知的缩写:import pandas 为 pd， import matplotlib.pyplot 为 plt 等。另一种导入方法是使用 from … import …构造。通过这种方法，你可以将模块的一部分导入到当前的名称空间中。导入的项目就像在当前模块中定义的一样可用。
当模块变得太大时，明智的做法是将它们分成更小的部分。通常它们以某种方式组合在一起。为此，创建了包。如前所述，包只是一个目录中模块的集合。当存在名为 init 的文件时，目录被检测为包。init 两边的双下划线)。然后使用<directory_name>访问每个模块。<module_name>。</module_name></directory_name>
这是软件包和模块的全部内容。更大的类型(库和框架)是包的集合，组合在一个目录中，访问方式与模块相同。因此，当您使用 pip 安装包时，会创建一个包含 Python 文件的文件夹。这个文件夹位于您的 Python 路径中，这个路径是一个字符串，包含在哪里查找模块和包的目录。当我们导入一个模块时，Python 将首先在当前工作目录中寻找该模块。接下来，它将检查 Python 标准库。如果仍然找不到模块，它将遍历 Python path 环境变量中定义的路径。在 Python 中，这个路径很容易通过 sys 包来访问。使用 sys.path，您可以检查所有路径，甚至可以添加另一个路径，以便可以找到该目录中的包。
当编辑模块时，您会遇到一个有趣的情况:当导入已经导入的模块时，它会一直引用以前导入的模块。这意味着，如果您更改了一个模块并再次导入它，而不重新启动内核，您将仍然使用该模块的旧版本。我不得不艰难地意识到这一点，这花了我几个小时才明白发生了什么。为了解决这个问题，Python 有一个名为 importlib 的附加包，使用 importlib.reload() 函数我们可以强制重新加载一个模块。
我认为现在，我们已经对导入系统以及模块和包的工作原理有了一些了解。当然，还有更多微妙之处需要学习但是现在，这可能就足够了。需要知道的最重要的事情是，您可以使用包来扩展 Python。这个社区非常活跃，几乎任何你想做的事情，都可能有一个包可以帮助你。几乎所有的包都在 Python 包索引( PyPi )中，所以这是一个开始寻找的好地方。如果你偶然发现一些不存在的东西，一般来说创建起来并不困难。如果你想获得不朽的地位，你可以把你的包上传到 PyPi，让其他人使用。分享就是关爱！
今天的练习:
今天的任务是创建你自己的包，它包含两个模块。第一个模块包含字符串函数，第二个模块包含数字函数(如下所述)。测试您的软件包是否正常工作。
# String functions (in a separate module)
def split_string(sentence):
return sentence.split(' ')def is_long(sentence):
if len(sentence) > 10:
return True
return False# Numeric functions (in a separate module)
def square_root(number):
return number**0.5def square(number):
return number * number
如有任何问题，欢迎通过 LinkedIn 联系我。
每天 10 分钟学习 Python 10
每天 10 分钟 Python 速成班
列表理解和地图:一个惊人的捷径
这是一个系列10 分钟的简短 Python 文章，帮助您提高 Python 知识。我试着每天发一篇文章(没有承诺)，从最基础的开始，到更复杂的习惯用法。如果您对 Python 的特定主题有任何问题或要求，请随时通过 LinkedIn 联系我。
Python 的关键元素之一是它的可读性。这种语言迫使你使用缩进来应用结构，这在我看来非常赏心悦目。Python 的关键思想也可以在Python 的禅 中找到。它是解释器中众多复活节彩蛋中的一个(只需键入’ import this ')。其中一个非常酷的习惯用法是理解。理解，或者更经常被称为列表理解，因为它们最经常与列表一起使用，是创建列表的一种有点抽象的方式。它们将某种处理步骤与一个循环结合在一起，以填充一个新的列表。为了更清楚地说明这一点，让我们把传统的舞步和积木上的酷小子做个比较:
在传统的循环中，首先需要定义一个空列表。接下来是一个 for 循环，遍历所有计算，并将所有计算结果追加到新的列表中。这三行可以使用 list comprehension 合并成一行，但不会牺牲可读性。在列表理解中，即在由括号标识的列表定义中，有一个 for 循环。这个 for 循环定义了一个用于迭代的变量，我们可以自由选择。我们常常很懒，选择短字母，如 x 、 y 和 z 。尽管如此，使用描述性名称是更好的做法。for 循环的行为与常规 for 循环相同，并在整个 iterable 上迭代。我们可以压缩多个 iterables 或者使用 enumerate，但是我们也需要解包所有额外的变量(或者将它们作为一个元组使用)。需要记住的一件事是，列表理解会创建一个新的列表，即使我们复制了每一个条目并且有相同的列表。理解几乎可以在任何地方工作，并且可以在函数中使用。他们也可以使用字典和集合，但是当然，每个数据类型的定义必须是正确的。
一般来说，理解的语法是:iterable中项目的表达式。由于理解的结果又是可重复的，我们也可以将多个理解嵌套成一个。虽然这很好，但是要记住可读性可能会下降。因此，将你的超级一行改为两行并不是一个坏习惯。
与内联 for 循环一样，我们也可以使用内联 if 语句。我认为对于一般的用法，内联 if 语句会增加代码的混乱，降低可读性。然而，我们可以在理解中使用 if 语句，对于这种用例，它们有时非常简洁。
列表理解是缩短代码的一个很好的方法，而且通常不会牺牲可读性。与内联的 if 语句一起，这是一种创建过滤项目列表的简单方法。另一个非常类似的方法是 map() 函数。这个函数在列表的每一项上映射一个函数，并返回一个包含所有返回值的新列表。使用 for 循环或理解也可以达到同样的效果，但是 map 函数的可读性更好一些，因此，我认为了解以下内容是很有用的:
函数的第一个参数是对函数的引用，第二个参数是 iterable。然而，它返回的结果不是一个列表，而是一个 map-object。map-object 是一种生成器，所以它只在被请求时计算值。这在大多数情况下效率更高，消耗的内存更少。为了查看完整的列表，我们将 map-object 转换成一个列表。正如我们在这里所做的，处理容易映射的数据也更容易并行化(在计算机的多个内核上并行运行)。Python 有多处理包，为 CPU 密集型任务提供了多处理映射功能。
今天的练习:
理解是过滤列表结构数据或组合相似任务的一个好方法。我经常做的事情是，例如在列表理解中读取 CSV 文件，产生 CSV 熊猫数据帧列表。使用 Pandas 中的 concat 功能，我可以在一行中合并所有导入的文件，得到一个包含所有数据的组合数据框。另一个很好的用法是有选择地将值放入列表中。这就是我们今天要练习的，用它来近似圆周率。
作业: 今天我们要用莱布尼茨公式来近似π的值。莱布尼茨公式是一个交替的级数(它改变每个值的符号),当对无穷多个值的级数求和时，你得到圆周率。问题是，我们没有无限的内存，因此，我们截断了这个值，并近似圆周率。莱布尼茨公式指出圆周率 4 等于下面给出的交替级数:
π / 4 = 1/1 - 1/3 + 1/5 - 1/7 + 1/9 - 1/11 + .....
为了解决这个问题，我们可以将它分成几个步骤:
a)为所有奇数
创建一个列表理解 b)使用另一个列表理解使每个第二个值为负
c)使用另一个列表理解，将每个值转换为 1 除以 x
d)将整个列表求和并乘以 4 以获得π的近似值 e)增加数字的数量( n )以获得更好的近似值。
提示:
1。使用 range 获得一个数值 n 以内的数字列表(range(n))。
2。用 2 的模数检查是否是偶数/奇数
3。要获得每一秒的数字，请将 enumerate 与模数一起使用。
import math
actual_pi = math.pin = 100 # amount of numbers
我已经在我的 Github 上发布了解决方案。
如有任何问题，欢迎通过 LinkedIn 联系我。
每天 10 分钟学习 Python 10
每天 10 分钟 Python 速成班
关于生成器以及如何创建它们的更多信息
这是一个系列10 分钟的简短 Python 文章，帮助您提高 Python 知识。我试着每天发一篇文章(没有承诺)，从最基础的开始，到更复杂的习惯用法。如果您对 Python 的特定主题有任何问题或要求，请随时通过 LinkedIn 联系我。
我们已经遇到了生成器，它是一个 iterable，可以在需要的时候缓慢地计算值。这在速度上有好处，但最大的好处是减少了内存。常规列表需要一次性分配，一百万个值的列表可能会占用大量内存。当我们一次处理一个(或几个)值时，使用生成器要聪明得多。我们已经看到了 range() 函数，然而这并不是一个正式的生成器(但还是有点类似)。关于生成器，有一点是它只能在 iterable 上迭代一次。范围()可以重复完整迭代。当然，这只是一个细微的差别，但是要牢记在心。在上节课中，我们讨论了理解，但我们没有提到一种特殊类型:生成理解(或生成表达)。这种类型的理解看起来与列表理解相同，但是使用圆括号而不是方括号，并且顾名思义，返回一个生成器。
发电机没有长度，因此不能使用 length() 功能。在这个例子中，我们知道长度，因为我们已经定义了它( range(10) )。然而，如果我们使用生成器来一行一行地遍历一个大文件，根据定义，生成器没有长度。实际上，要获得长度，即要读取的行数，您需要读取整个文件并计算’ \n '个字符。这已经花费了一个完整的迭代周期。
从生成器获取下一个值的另一种方法是使用 next() 函数。你必须记住，如果生成器是空的，即完整的迭代已经完成， next() 函数将引发一个 StopIteration 异常。这可能会让您想知道 for 循环是如何工作的，因为您无法检查是否还有剩余的项。原来 for-loop 抓到了 StopIteration 异常:先请求原谅再请求许可 。
我们了解到，生成器对于减少 Python 程序的内存占用非常有用，甚至可以读取 100GB 的文件。为了完成这些专门的任务，您需要定义自己的生成器函数。生成器函数看起来像一个常规函数，它计算当前值。然后返回这个值，但是我们不使用 return 关键字，而是使用 yield 。通常，当使用 return 时，函数的状态是垃圾收集。这意味着函数中的所有变量都被删除了。使用产量，功能的状态被保持，保持所有变量完整。当 for-loop 或 next()调用请求下一个值时，生成器函数将继续生成下一个值。让我们创建一个简单的生成器:
从生成器函数本身来看，已经很清楚为什么生成器在一次完整的迭代后是空的了。到达 max_number 后，该功能结束，不能产生新的值。为了再次迭代生成器，我们需要再次重新启动生成器。
函数本身可以是任何东西。我们已经提到的例子是一个大于内存的文件的逐行迭代，但是还有许多其他的用法。生成器可以组合一个或多个数据库调用，可以从互联网下载信息，并且可以被定义为可以无限期运行。
生成器是 Python 中的一个高级特性，在某些情况下非常有用。正如我已经提到的，当内存是一个问题时，生成器是一个可能的解决方案。值是动态计算的。如果你只需要几个值(比如 100 个值中的前 10 个)，你可以省略不需要的计算，这样可以提高速度。你可以用发电机做更高级的事情，例如堆叠发电机。组合生成器可以模仿管道，这是一种高效的技术，例如在 Unix 世界中。
今天的练习:
当讨论更高级的话题时，作业也会变得更有趣。因为我喜欢数字，今天我们要产生斐波纳契数。斐波那契数列(或斐波那契数列)非常神奇，因为它们在自然界中经常出现。该序列定义了当前的斐波那契数列是前两个数列的和:
F = [0, 1, 1, 2, 3, 5, 8, 13, ....... ]
赋值: 创建一个无限生成器来生成斐波那契数。使用 while 循环(和 break)测试您的函数。由于生成器是无限的，您可以继续第二个循环。
提示 :
a)无限循环可以用永远为真的 while 循环来创建。
b)生成器函数需要跟踪最后两个值并得出总和。
我已经在我的 Github 上发布了解决方案。
如有任何问题，欢迎通过 LinkedIn 联系我。
每天 10 分钟学习 Python 10
每天 10 分钟 Python 速成班
在 Python 中读取错误和异常
这是一个系列10 分钟的简短 Python 文章，帮助您提高 Python 知识。我试着每天发一篇文章(没有承诺)，从最基础的开始，到更复杂的习惯用法。如果您对 Python 的特定主题有任何问题或要求，请随时通过 LinkedIn 联系我。
当我们编码时，犯错是不可避免的。这些错误使得 Python 生成了大量的打印输出，这可能有些令人不知所措。今天的目标是更加熟悉错误读数，并了解它们实际上非常具有描述性。下面是一段相对容易发现错误的代码:
这里我们有两个函数，它们相互嵌套，并被顺序调用。首先我们调用 my_function 并提供一个字符串。在 my_function 中我们调用了另一个叫做 sub_function 的函数。在创建 sub_function 时，我们还没有足够的咖啡，并且犯了一个错别字: print - > pint 。这将创建这个大的打印输出:
我们没能找到绳子！
对于一个丢失的字母来说，这是一个很大的信息，对于新来的人来说可能有点令人生畏。在 IPython 和 Jupyter 中，这种消息被正式称为回溯，是用颜色解析的。如果你运行 vanilla Python，这将会是同样的颜色，看起来更可怕。尽管如此，这条消息实际上是相当翔实的，并与正确的步骤，真的很容易阅读。
从底部到顶部读取一个 Python 回溯。最后一行告诉您异常的名称和简短描述。在很多情况下，这就是你需要知道的全部。在这个例子中，我们得到一个 NameError ，并告诉我们名称‘品脱’没有被定义。当我编码时，我不断地测试我的代码，因此，记住我只是添加了一行带有 print() 函数的代码。所以，这么小的错别字很快就被识别出来了。如果您不确定这个异常发生在哪里，Python 会给我们提供额外的信息，这些信息分为代码深度的不同级别。每一次，我们调用一个函数，我们就深入一层。基础层是我们调用 my_function()函数的主要代码层。my_function 引入了对 sub_function 进行另一个函数调用的另一个级别。sub_function 创建发生错误的第三个也是最后一个级别。这三个级别在回溯中是可见的，最深的级别(错误实际发生的地方)在底部。在每个级别中，都可以看到一个箭头，指出发生错误的行。它还打印出行号以及有错误的行的前后两行，以便在实际代码中更好地识别这段代码。
你可能会问，如果错误发生在底层，为什么我们需要更高的代码级别。原因是发生了错误，因为我们可能在更早的步骤(更高级)中提供了错误类型的参数。让我们创建另一段错误代码，并一步一步地进行追溯:
阅读回溯消息的步骤。
我们必须自下而上地分析这种追溯。首先(1)我们看到我们有一个值错误。当函数或类获得它不期望的值时，会引发值错误。在这种情况下，int()类需要一个数字的字符串表示。描述使这一点变得更加清楚:基数为 10 的 int()的无效文字:“25beer3”。事实上，从该字符串生成整数是不明确的。添加了基数 10，因为数字也可以是基数 2(二进制)、基数 8(八进制)或基数 16(十六进制)。
接下来，我们需要检查这个错误发生在哪里。在倒数第一个块(2)中，我们确实看到我们试图将变量 number_in_string 转换为整数。就代码而言，这里没有任何错误，所以我们更上一层楼(3)。在这个函数中，同样没有任何错误，所以我们继续到顶层(4)。这里我们发现了错误:我们提供了错误类型的参数。
在这个例子中，很容易修复，因为我们自己提供了一个错误的字符串。在现实生活中，这个字符串可能是从另一个从文件导入的字符串中提取出来的，所以是不可见的。例如，我们正在读取的 CSV 文件可能没有所有行的合理值(只是简单的错误值)。解决方案是在第一次函数调用之前检查字符串是否是我们所期望的，否则替换字符串。根据函数得到错误参数的可能性，可以增加测试。开发人员已经使用单元测试解决了这个问题。测试以检查函数是否按预期工作。在这些单元测试中，我们都可以测试数据的有效性。我的观点是，你需要用常识来判断要测试什么，你可以假设什么是好的。如果有麻烦，你总会有值得信赖的线索来指引你。
本文描述的方法是在代码中查找错误的典型工作流程。大多数时候，最底层的信息就是你所需要的。如果您需要检查异常发生的位置，那是因为我们向函数提供了错误的参数类型。诀窍是找到导致问题的函数。回溯是找到有问题的函数的完美工具。这些类型的错误通常可以通过快速检查要调用的函数的 DocString 来修复。
今天的练习:
发现错误是每个程序员都要掌握的技能。下面我提供了一段可怕的周一早晨的代码。使用错误对话框找到并消除所有的错误。尽量不要直接找到它们，而是真正使用回溯来识别错误，以获得对其格式的一些练习。
如有任何问题，欢迎通过 LinkedIn 联系我。
每天 10 分钟学习 Python # 2
每天 10 分钟 Python 速成班
使用 Jupyter 实验室和导航笔记本
这是一个系列的 10 分钟 Python 短文，帮助你开始学习 Python。我试着每天发一篇文章(没有承诺)，从最基础的开始，到更复杂的习惯用法。如果您想了解关于 Python 特定主题的问题或请求，请随时通过 LinkedIn联系我。
希望从第一堂课开始，你已经对 Python 的工作原理有了大致的了解，并且已经成功安装了 Python(还记得我在本指南中关于使用 Miniconda 安装 Python 的建议吗？).在这篇短文中，我们将讨论 Jupyter 笔记本环境。
笔记本是使用单元格构建的交互式文档。有两种类型的细胞，即输入细胞和输出细胞。输入单元格由我们(用户)创建，可以是三种类型:代码单元格、降价单元格或原始单元格。顾名思义，代码单元是一段可以被评估的代码。评估的输出显示在该代码单元格正下方的输出单元格中。降价单元格是带有以降价语言格式化的文本的单元格。有许多不同的格式功能可用，如标题，列表，字体粗细选项。markdown 的好处是，即使不渲染，也非常易读。原始像元是一种特殊类型的像元，Jupyter 不会对其求值，但如果您使用另一个名为 nbconvert 的工具，则可以对其求值。我从未使用过后者，但是当使用像 Sphinx 这样的自动文档套件时，它会很方便。code 单元格和 markdown 单元格的组合使得拥有一个将代码和解释结合起来的优秀分析文档成为可能。这使得笔记本成为分享结果的首选方式。
要安装 Jupyter，有两个选项。只有 Jupyter，它可以让您访问笔记本电脑环境，或者 Jupyter lab，它有更多的功能。两个都好。唯一要记住的是，Jupyter 实验室有时需要更多的步骤来安装定制的小部件。两种方法都安装 Jupyter 笔记本服务器。与 Jupyter 交互的标准方式是通过网络浏览器，但由于它是一种客户端-服务器结构，其他应用程序也可以与之交互。例如，有一个 Visual Studio 代码插件也可以与笔记本服务器交互，可能还有许多其他选项。如果你喜欢，可以随意使用其他的。现在，让我们使用终端在新环境中安装并启动 Jupyter lab:
conda create --name tutor python=3.7
conda activate tutor
pip install jupyterlabjupyter lab
Jupyter 实验室启动后，左侧栏打开。
浏览器应该会打开并显示 Jupyter 实验室的主页。该窗口由三部分组成:与其他应用程序类似的顶部菜单栏、侧菜单选项卡栏和主编辑器窗格。侧边栏由标签组成:文件导航，运行内核，命令，属性检查器，打开标签，如果安装了扩展管理器。目前我们只谈前两个。“导航”选项卡帮助您导航计算机上的文件。您可以浏览和创建目录。出于安全原因，Jupyter 实验室开放时，您不能进入更低的目录。Jupyter 是作为服务器创建的，所以也有上传的选项。“加号”符号在主窗口中打开一个新的启动器选项卡，当 Jupyter lab 启动时，它也会自动打开。在 launcher 选项卡中，您可以创建新的笔记本，在选项卡中打开 IPython 控制台，创建文本文件，甚至是终端。回到侧边栏，另一个选项卡显示活动的内核。每次你打开或创建一个笔记本，一个内核就被启动了。关闭笔记本不会停止内核，除非你关闭 Jupyter lab 或者转到这个标签并关闭它们。如果您不小心关闭了标签，您可以从这里再次打开它。同样值得一提的是，主编辑器面板可以定制为通过拖动标签并排显示文件。一定要试一试。
让我们使用启动器在当前目录中创建新的笔记本。创建后，您可以在文件导航器中右键单击新文件来重命名它。您也可以右键单击选项卡名称来实现相同的目的。还要注意文件导航器中的小绿点，它显示该文件当前作为内核运行。新笔记本相当空，因为它只有一个电池。顶部是一个小菜单栏，显示了一些基本功能，如复制/粘贴、单元格选项和一些内核选项。Jupyter lab 是一个模态编辑器，类似于 vim。它有一个命令模式，您可以在其中导航或编辑单元格，还有一个单元格编辑模式，您可以在其中键入内容。在命令模式下，您可以轻松地添加、删除、剪切或复制单元格。为此，有一些便于记忆的快捷方式(它们也可以在顶部菜单中找到):
- 箭头键在单元格内移动。按住 shift 键选择单元格。
- “a”和“b”添加当前单元格上方的单元格或下方的单元格*。*
- “c”、“x”、“v”到复制、剪切，或者粘贴单元格。
- “y”或“m”分别将单元格类型更改为编码或降价。
- “shift + enter”计算当前单元格。
花些时间了解降价的基本知识是有用的。它们非常简单，你可能只需要几个。看看这个备忘单，你会直观地看到它的语法。
今天的练习:
- 创建一个新的笔记本，并将其重命名为合理的名称。
- 做一些简单的计算，并评估细胞。
- 将单元格更改为 markdown，并编写描述，包括标题。
- 在笔记本上移动，复制和粘贴单元格。
作为数值运算符的建议:
+(加法):10 + 12，
-(减法):20 - 30，
*(乘法):3 * 3，
/(除法):49 / 7，
(幂):28。
如有任何问题，欢迎通过 LinkedIn 联系我。
每天 10 分钟学习 Python 10
每天 10 分钟 Python 速成班
让我们进行分类排序
这是一个系列10 分钟的简短 Python 文章，帮助您提高 Python 知识。我试着每天发一篇文章(没有承诺)，从最基础的开始，到更复杂的习惯用法。如果您对 Python 的特定主题有任何问题或要求，请随时通过 LinkedIn 联系我。
两周前我们写了一个快速排序算法，这是一个相对高效的排序算法。当我们需要对一个列表进行排序时，Python 自带了一个名为 sorted() 的内置排序函数。实现的算法叫做 Timsort ，由 Tim Peters 在 2002 年实现。该函数采用 iterable，默认情况下按升序对值和字符进行排序。sorted()的语法如您所料:
数字按照您预期的方式排序。如果要反转顺序，我们需要将反转参数设置为真。Sorted()返回一个新的列表，因此，我们也可以使用 reverse() 函数来反转列表。反向函数返回一个反向迭代器对象。要打印列表，我们需要首先转换它。Sorted()也可以对字符串进行排序，并且会一个字符一个字符地进行排序，从数字开始，然后是字母表。现在，结果是一个字符列表。对字符串列表进行排序时，sorted()会按字母顺序对每一项进行排序。需要记住的是，字符串中的数字是在字符级别上排序的，因此，对文件的排序可能不是您所期望的顺序:
对字符串进行排序时，Python 使用字符的 Unicode 值。这意味着 Unicode 编码的低值(如大写字母)出现在高值字符(如小写字母)之前。如果一个字符串包含一个数字，而你想按这个数字排序，我们需要提供一个键。一个键是一个函数(或者 lambda 函数，我们仍然需要在以后的课程中讨论这个函数),它可以转换条目，使其以不同的方式排序。key-function 的结果可以是排序后可以对其执行排序逻辑的任何内容。在我们的示例中，我们创建了一个从文件名中提取数字并将其转换为整数的函数。Sorted 现在对这些整数进行排序，并按顺序返回原始列表。这使得 key-parameter 成为一种非常强大的列表排序方式。
需要注意的是，sorted()只能对可以与列表中所有其他项目进行比较的项目进行排序。当你提供一个混合类型的列表，比如整数和字符串，说 25 比‘香蕉’大是模棱两可的。字典列表也是如此。它不知道如何比较每个包含不同值的字典。这些问题可以通过定义一个键函数来解决。
今天的练习:
作业 1:
第一个作业你要按照库存水果的多少来排列字典的清单。为此，您需要定义一个键(一个函数)来选择相关的值，并再次明确排序。
fruit_types = [
{'name': 'banana', 'amount': 123, 'price': 2.50},
{'name': 'strawberry', 'amount': 23, 'price': 1.75},
{'name': 'apple', 'amount': 87, 'price': 2.10},
{'name': 'pear', 'amount': 3, 'price': 1.50},
]
任务 2:
在第二部分中，我们将实现另一种排序算法:冒泡排序。冒泡排序是(剧透)一种效率低得多的排序方式。该算法反复遍历一个列表，比较两个相邻的值，如果它们的顺序不正确，就交换它们。下面是两次迭代的示意图:
该图从比较前两个值开始，当 24 大于 4 时，交换这两个值。接下来的两个值不变。这个过程一直持续到所有值都比较完为止。第一次迭代后，最后一个值是固定的，因为这是列表中最大的值。这意味着对于下一次迭代，我们可以忽略最后一个值，只需比较 75 之前的值。第二次迭代后，最后两个值是固定的。伪代码中的全部代码(读作:几乎是 Python 代码)看起来是这样的:
现在，使用这个伪代码来实现冒泡排序算法，并比较它与我们之前的快速排序算法相比慢了多少。您可以使用神奇的命令 %timeit 来评估排序算法的性能:
解决方案发布在我的 Github 账户上的这里。
下一篇文章将在我两周后的假期后发布，也就是 8 月 10 日。
如果您有任何问题，请随时通过 LinkedIn 联系我。
每天 10 分钟学习 Python # 21
每天 10 分钟 Python 速成班
匿名函数也叫λ函数
这是一个系列10 分钟的简短 Python 文章，帮助您提高 Python 知识。我试着每天发一篇文章(没有承诺)，从最基础的开始，到更复杂的习惯用法。如果您对 Python 的特定主题有任何问题或要求，请随时通过 LinkedIn 联系我。
对于新手来说，lambda 函数可能有点吓人。我也避免使用这些函数有一段时间了，因为我从来不知道它们的真正用途。如今，我确实看到了这种结构的好处，但这种好处相当小。你会遇到这些功能，因此，知道发生了什么是很好的。Lambda 函数也被称为匿名函数或无名函数，这更好地描述了它们。lambda 函数是没有名字的函数的内联定义。除了没有名字，常规函数和 lambda 函数有什么区别？*几乎没有！*那么下一个问题是:当一个常规函数做同样的事情时，为什么要使用 lambda 函数？事实上，在大多数情况下，常规函数是可行的。但是，有时候你只需要做一次手术。虽然您仍然可以使用常规函数，但是内联函数(lambda 函数)可能会更容易一些。
lambda 函数的定义很简短:它以关键字 lambda 开始，后跟一个或多个用逗号分隔的参数。分号后面是函数本身的步骤。让我们来看一个例子:
在这个例子中，我们有一个费用清单。每笔费用都是一个元组，包含名称和成本。虽然有其他方法(如列表理解)，但我们选择使用 map()来选择所有成本。Map()需要一个函数和一个 iterable。我们现在可以创建一个选择元组第二项的正则函数，但是我们只使用它一次。这意味着 lambda 函数在这里是完美的。map()在每个元组上执行我们的函数，并返回所有成本的列表，后跟一个总和。现在我们来看看更多的例子(免责声明:并非所有都有用):
在示例中，我们展示了 lambda 表达式返回对匿名函数的引用。该函数现在被一个变量捕获，它将不会被“垃圾收集”。这消除了 lambda 函数的好处，即一次性匿名函数，它将在使用后被丢弃。如果添加对 lambda 函数的引用，只需编写一个常规函数即可。常规函数可读性更好。尽管如此，您可以将 lambda 函数捕获到一个引用中，然后该变量就充当一个常规函数(只是不要这样做(-；).
imgflp.com 上产生的模因
只是为了好玩，您也可以直接调用引用，而不用在变量中捕获它。虽然这没有多大意义，但它是可能的，而且完全有效。需要额外的括号，否则将返回函数标识符。
为了证明常规函数和 lambda 函数是相同的，我们可以检查来自 Python 解释器的字节码。为此，我们可以利用 dis 模块，它将实际执行的字节码可视化。所有 Python 命令都可以分解成少量的字节码操作。这里我们比较了常规和 lambda 之间的字节码，看到我们有一个精确的匹配。它们的字节码是一样的！
前面的例子展示了两个有用的新函数:filter()和 reduce()。顾名思义，filter()用于过滤 iterable。iterable 的每一项都被放入一个必须返回布尔值的函数中。如果布尔值为真，则保留该值。如果布尔值为 false，则忽略该值。我们可以提供一个常规函数，但如果是一次性的，lambda 函数可能更容易。
Reduce()是许多其他语言中常见的方法。它接受一个 iterable，并使用提供的函数将 iterable 简化为一个值(同一类型)。实际情况是，它接受 iterable 的前两个值，并根据提供的函数创建一个新值。它重复这个操作，直到只剩下一个值。同样，这可能是一个 lambda 函数的绝佳位置。
今天的练习:
虽然没有 lambda 函数的生活是很可能的，但我认为这是一个很好的很高兴知道。你偶尔会遇到他们。在这个任务中，我们将使用 reduce()找到一组值中的最大值。
赋值:
用 reduce 求 1000 个值中的最大值。
提示:
1。λ函数有两个参数
2。使用内联 if 返回正确的值
一个解决方案是发布在我的 Github 上。
如有任何问题，欢迎通过 LinkedIn 联系我。
每天 10 分钟学习 Python # 22
每天 10 分钟 Python 速成班
在 Python 中，我们修饰函数以使它们更好
这是一个系列10 分钟的简短 Python 文章，帮助您提高 Python 知识。我试着每天发一篇文章(没有承诺)，从最基础的开始，到更复杂的习惯用法。如果您对 Python 的特定主题有任何问题或要求，请随时通过 LinkedIn 联系我。
装饰者是另一个令人困惑的话题，他们的使用肯定会让人感觉有些不可思议。虽然修饰函数这个术语非常恰当，但它也模糊了正在发生的事情，即:将一个函数包装在另一个函数中。首先，我们将创建一个示例函数:
imgflp.com 上产生的模因
这个函数非常简单，我想每个人都很清楚。我们的工作包括编写许多函数，有时我们需要对函数计时，例如，如果我们想检查一个新的实现是否更快。一种方法是简单地使用时间函数:
希望明确这不是真的干。当然，我们可以使用 iPython 的神奇语句%timeit，但是现在让我们忽略这种可能性。当检查这些步骤时，我们看到我们在实际函数之前添加了几个步骤，在函数完成之后添加了几个步骤。解决这个问题的一个方法是将计时放在 square_value 函数中。但是如果你还想为其他功能计时呢？因为很大一部分代码是活的，所以我们可以很容易地将函数包装在函数周围。让我们进行第一次尝试:
这里我们创建了一个新函数，它将函数及其参数作为参数。还记得让捕捉所有未命名参数的 *args 方法吗？我们将这些传递给被调用的函数。与我们之前创建的非常湿的代码相比，这已经是一个很大的改进了。然而，为每个调用包装一个函数仍然令人感觉乏味。难道我们不能定义它让它一直存在吗？你可能猜到我们可以。我们利用了这样一个事实，即我们可以在任何地方定义一个函数，并返回新的定义。这听起来可能很奇怪，但在下一个例子中会很清楚:
timer 函数现在是一个包装函数，它围绕我们的 square_values 创建一个新函数，并返回包装后的函数。这种方法的最大优点是，我们现在可以通过简单地将任何函数封装在我们的 timer()中来为它计时。在这里，我们通过包装状态覆盖了对原始函数的引用。这一步称为修饰函数。因为这一步是非常常见的操作，Python 创建了一个特殊的语法来使用@符号修饰函数:
所以@符号只是语法，没有什么真正神奇的。这是一种用包装函数覆盖原始函数引用的简写符号。
对于初学者来说，装饰者的用例不是那么明显。在我使用 Python 的最初几年，我从未使用过它们。现在，我偶尔使用它们。除了计时功能，日志记录也是一个很好的用例。使用装饰器，您可以在函数级监控您的代码。
有相当多的软件包在它们的语法中使用了装饰器。例如，塞巴斯蒂安·拉米雷斯的 FastApi 使用 decorators 来创建与 RestFull api 端点的链接。Django 和 Flask ，这两个伟大的 web 框架都使用装饰器来做各种事情。例如，确保某个功能仅在用户登录时使用。另一个近乎神奇的用法是与 Numba 一起使用。当用 Numba 装饰函数时，它使用实时(JIT)编译来加速函数，使它们在速度上与编译语言相当。还有很多其他用法，这里的是一个精选列表。
今天的练习:
今天我们将练习装饰者的另一个用例，即改变现有的功能。有时，您会遇到一个您导入的函数，它几乎可以完成您想要的功能。差不多了，但是需要稍微调整一下。为此，您可以编写另一个函数来完成它，或者您可以使用 decorators。如果您需要更改许多以相同格式返回值的函数，则特别方便。让我们看看今天作业的功能。
任务:
编写一个 decorator 函数并修饰 current_temperature()，以便它返回以摄氏度为单位的温度。
提示:
- 你可以复制/粘贴我们之前的定时器装饰函数的结构。
- 摄氏度=(华氏 32 度)* 5 / 9
我的 Github 上发布了一个解决方案。
如果您有任何问题，请随时通过 LinkedIn 联系我。
每天 10 分钟学习 Python # 23
每天 10 分钟 Python 速成班
一种全新的程序设计
这是一个系列10 分钟的简短 Python 文章，帮助您提高 Python 知识。我试着每天发一篇文章(没有承诺)，从最基础的开始，到更复杂的习惯用法。如果您对 Python 的特定主题有任何问题或要求，请随时通过 LinkedIn 联系我。
当深入了解编程时，你会遇到两大范例:函数式编程和面向对象编程(OOP)。到目前为止，我们主要做的被称为函数式编程。我还没有为这两个术语找到一个令人满意的全面定义。然而，关键的区别是，函数式编程，顾名思义，是以函数为中心的，程序结构就像一步一步的食谱，而 OOP 是以数据为中心的，数据是以对象为结构的。这主要是处理问题的不同方式。这两种范式之间没有真正的好与坏，因为人们更喜欢网球而不是足球。有时，一种方法似乎更容易解决问题，但我相信你可以用两种方法获得相同的结果。OOP 和函数式方法都与 Python 兼容。
OOP 的核心思想是将程序抽象成对象。对象是将数据和与特定数据相关的代码结合在一起的结构。OOP 的鼓吹者声称这减少了重复的次数，使代码更具可读性。我必须承认，这个想法非常好，确实有一些好处。作为一个很好的入门例子，让我们为一个动物创建一个对象，看看 OOP 在 Python 中是如何工作的。
这个结构看起来并不困难，但是有一些新的概念。要开始一个类定义，首先要有 class 关键字，然后是一个名称。按照惯例，类名以大写字母开头，但是从 Python 的角度来看，任何名称都可以(但是请务必大写)。类似于函数定义，我们有一个分号，所有缩进的代码都属于这个定义。提供一个 DocString 来描述该类是一个很好的做法。在定义本身中，我们现在可以创建变量和方法。方法是类定义中函数的名字。
了解类定义和类实例之间的区别很重要。我们在前面的例子中创建的代码从类定义开始，为我们的对象创建一个蓝图。当我们想要使用特定类型的对象时，我们需要创建一个实例。在定义了我们的动物类之后，我们创建了该类的两个实例: animal1 和 animal2 。虽然蓝图定义了哪些数据和方法是可用的，但它并不包含数据本身。当创建类的实例时，我们创建包含实际数据的对象。在我们的示例中， animal1 和 animal2 都属于类型 Animal ，但是它们包含不同的数据:青蛙代表 animal1 ，犀牛代表 animal2 。您可以为以前定义的类创建任意多个实例。
当创建一个类的实例时，我们调用 Python 的一个特殊方法:构造函数。我们可以看到它的特别之处，因为它的名字被双下划线所包围。这些所谓的 dunder-methods 在 Python 中被给予了特殊处理。init dunder-method 表示构造函数，一个在创建类实例时调用的方法。方法可以像常规函数一样接受参数，但是类有一个强制的第一个参数: self 。Python 中的任何类方法都需要这个参数，原因是这个特定的对象包含实例的数据。当我们在 Python 中定义一个类时，我们有一个对该类的引用。这个定义对每个物体都是一样的。为了让每个实例拥有自己的数据集，比如我们有一只青蛙和一只犀牛，每个类都有一个保存实际数据的 self 对象。在构造函数中，我们定义了创建的变量并将数据添加到这个 self 对象中。该对象在实例之间共享，但不在不同的实例之间共享。现在，我们可以在类中定义的其他方法中使用该实例数据，比如在 description() 方法中。这是 Python 开发人员想出的在实例级别存储数据的解决方案。虽然您可以在类级别定义变量(其他编程语言会这样做)，但这可能会导致不希望的结果:
这不是一个 bug，而是 Python 的工作方式。该列表是在定义类时定义的。每个实例都获得一个对该列表的引用，因此所有实例共享该列表。这只适用于可变对象。不可变对象通常会在再次更改时获得一个新的引用，因此会覆盖以前的引用。请注意，不要使用默认方法在构造函数中定义所有参数(通常应该使用这种方法)。
我们添加到 self 对象的所有变量都可以使用点符号来访问。一般来说，对象中的所有变量都称为属性，而所有函数都称为方法。两者都应该有唯一的名称，并且可以使用<object name>.<attribute name>或<object name>.<method name>()来访问。这与 Python 中任何对象的符号相同。字符串和整数都是具有相同方法论的对象。然而，这些类定义了更多的方法。如果对象被加在一起，或者如果对象被相乘，有一些特殊的方法来处理对象的打印。我们还可以定义这些，并根据这些定义制定我们自己的规则:
该类还有两个 dunder-方法。第一个负责类的表示。如果我们简单地输入代表类实例的变量名，即 number1，它将调用 repr dunder-method 并返回它的表示。这个方法必须返回一个字符串，但是这个字符串是什么，我们可以自由定义。第二个 dunder-method 定义了如何添加两个对象。它期望作为一个参数，紧挨着强制的 self 对象，也就是另一个对象。从技术上来说，这可能是任何对象，我们必须在做加法之前测试它是哪种类型。现在，我们假设它将是相同的类型。这可以是任何定义，甚至是我们在这个例子中所做的其他东西。这是非常强大的，因为你可以定义对象，例如联系卡，并使用添加功能，合并两个联系人。当我们使用 Pathlib 模块中的 Path 时，我们看到了一个有趣的例子。路径定义了 divide dunder-method，它将路径:
对于每个数学运算，都有一个可以定义或重载的 dunder-method 。重载意味着你用一个新的定义覆盖一个现有的方法，这个方法可以是一个常规的方法或者是一个 dunder-methods 中的一个。还有几个其他的 dunder-methods ，例如迭代相关的主题。不需要很努力地去了解他们，但是知道他们的存在确实很好。
今天的练习:
作为一种抽象形式，类是很棒的，特别适合于表示我们在现实生活中知道的对象。许多游戏都需要骰子来玩，有各种各样的骰子可供选择。有些人只有四张脸，而有些人可能有 100 张脸。
赋值:
创建一个骰子类，输入面的数量作为参数。它应该有一个 throw()函数来掷骰子，当然是使用正确的骰子，即一个四面骰子只能掷出 1、2、3 或 4 个骰子。它还应该包含一个 history()方法来显示过去的骰子点数()和一个漂亮的 repr dunder 函数来告诉我们是哪个骰子。
提示:
1。作为 randint(a，b)函数的随机模块在(a，b)之间(包括两个边界)生成随机数。可能对掷骰子有用；-).
2。你可以使用一个列表来跟踪所有以前的滚动。
在我的 Github 上发布了一个解决方案。
如有任何问题，欢迎通过 LinkedIn 联系我。
每天 10 分钟学习 Python # 24
每天 10 分钟 Python 速成班
父母、子女和遗产
这是一个系列10 分钟的简短 Python 文章，帮助您提高 Python 知识。我试着每天发一篇文章(没有承诺)，从最基础的开始，到更复杂的习惯用法。如果您对 Python 的特定主题有任何问题或要求，请随时通过 LinkedIn 联系我。
昨天，我们讨论了类以及如何使用面向对象编程(OOP)范例来解决问题。我们创建的对象可以模仿现实生活中的对象，数据和方法都捆绑在类中。我们还讨论了 Python 的一些内部工作方式:它使用 dunder-methods 来定义对象之间的交互。我们还没有提到的东西被认为是 OOP 的主要好处:继承。继承是创建一个新的所谓子类的能力，该子类从其父类继承属性。让我们看一个例子来说明这是什么意思:
虽然这很好，但我们都知道正方形是一种特殊类型的长方形，其长度和宽度都相同。编写两个单独的类看起来很湿，因为对象非常相关，我们可以利用继承:
在代码方面，我们有一个小小的好处，因为我们不必重复周长和面积的方法。然而，最大的好处是我们在一个地方而不是两个地方有这些方法的定义。如果我们在这两个方法中的一个上犯了错误，我们只需要修正一个定义。
现在让我们分析这里实际发生了什么。Rectangle 类没有改变，所以没什么好讨论的。然而，在主定义中，Square 类在括号之间添加了 Rectangle 类。使用这种语法，我们定义 Square 类是以矩形为基础构建的，因此继承了它的所有属性。接下来，我们定义一个构造函数，但是当我们从 Rectangle 类继承所有属性时，我们实际上覆盖了继承的构造函数。新的构造函数只取长度，因为正方形的所有边大小相等。现在来点特别的:我们调用构造函数或父类。为了访问父类，Python 有 super()函数。它返回父类的定义，通过直接调用 dunder init 方法，我们可以调用原始构造函数。原始构造函数需要一个长度和宽度，我们通过输入两次长度来提供。原始构造函数将这些值添加到保存实例数据的 self 对象中。新定义也覆盖了 repr dunder 方法。如果我们没有覆盖该方法，它将使用 Rectangle 类中的方法。这是另一个例子:
在这个例子中，我们还有一个更一般的类叫做 Animal，还有一个类是 Animal 类的子类。由于继承，Bird 类从 Animal 类获得所有属性。因为它是一只鸟，所以它得到了另一个名为 Fly()的方法，我们覆盖了这个构造函数，这样就简单了一些。
使用 Imgflip.com 生成的迷因
我们可以让它变得更有趣。一个子类可以有多个父类，因此可以从多个其他类继承属性。虽然这听起来很神奇，但很快就会变得非常混乱。让我们来看一个有三个不同父类的子类，它们实际上是独立的类，即不是专门为多类继承设计的:
这里我们有三个独立工作的类。使用多重继承，我们将这三个类组合成一个定义:HeavyRedSquare 类。新类必须调用所有其他构造函数来初始化这些值。我们可以使用 super()函数来做到这一点，但是这看起来很混乱。第一个 super()调用，不带任何参数，调用第一个父类构造函数(括号中最左边的那个)。在第二个 super()调用中，我们传递了两个参数。第一个参数是几何类，第二个参数是该类的实例对象。这里发生的事情是，我们在几何类中，它本身有颜色类作为父类。调用 super()，现在访问 Color()的构造函数。同样的情况发生在第三个 super()调用中。在这个定义中，权重类是颜色类的父类。以这种方式调用 super，可以访问 Weight 类的构造函数。对于更高级别的构造函数，我们需要传递 self 对象。在第一级，即普通超级()中，它被自动传递。这种写作方式让我很困惑。因此，还有另一种方式我更喜欢，在我看来更干净:
这种方式直接调用类构造函数。因此，我们需要传递 self 对象，即属于这个实例的数据。这是一种我们可以组合对象的方式，也可以独立工作。大多数情况下，当使用继承时，类被设计成一起工作。从这个简单的例子可以看出，它很快就会变得非常复杂。
更常见的是对象是链式继承的。这意味着一个类有一个父类，这个类本身也有一个父类，等等。在 Python 中，一切都是对象，我们已经多次提到过。但我们实际上是指字面意思。Python 中的所有类型都基于对象类型。有一个特殊的 dunder 属性(它不是一个方法)跟踪所有的父节点，顺序是:
所有这些继承的一个恼人之处是在对象中找到方法的源代码。当手动查找特定方法的源代码时，我经常不得不在层次结构中从一个类向上查找另一个类。当使用更高级的 IDE 时，这可能更简单一些。
了解最后一种特殊类型的继承是很重要的:mixins。mixin 是一种设计用来与其他类结合的类，单独实例化没有意义。除了没有构造函数之外，与常规类没有太大区别:
Mixins 非常适合在函数中添加一个通用的保存到磁盘的函数，同样有助于集中您的代码。从这一课中可以学到很多东西。如果你没有得到全部，不要太担心。掌握正在发生的事情是最重要的。继承经常被使用，多重继承不太多。看到后者大多是一个很好的了解。
今天的练习:
继承和混合是很好的概念。让我们一起玩吧。这里有两类形状:
赋值:
写一个 Mixin 来数每个形状的角。
一个解决方案是在我的 Github 上发布。
如有任何问题，欢迎通过 LinkedIn 联系我。
每天 10 分钟学习 Python # 25
每天 10 分钟 Python 速成班
应得的自创证书
这是一个系列10 分钟的简短 Python 文章，帮助您提高 Python 知识。我试着每天发一篇文章(没有承诺)，从最基础的开始，到更复杂的习惯用法。如果您对 Python 的特定主题有任何问题或要求，请随时通过 LinkedIn 联系我。
今天是每天学习 Python 10 分钟的第 25 集。如果你在这里，你应该感到自豪，因为我们已经讨论了 Python 语言的基本、中级和一些高级习惯用法。足以启动您的 Python 开发生涯。我的第一个想法是用一些真实的例子(使用一些库)来结束这个系列。这些例子包括数据可视化、使用矩阵、神奇熊猫图书馆和一些 Scikit-Learn 主题。虽然，我可能仍然会创作这些文章，但它们会在今年晚些时候以一个独立的系列发表(当然不是每天都发表)。如有任何要求或建议，请随时联系我。
当完成一门在线课程时，你经常会在你的 LinkedIn 上获得一个证书来分享。既然你已经做到了这一步，我认为你在这个系列中得到一个也是很重要的。为了证明 Python 是一种通用语言，我们将自己创建一个令人印象深刻的证书！如果你真的把这个贴在你的 LinkedIn 上就太好了，请不要忘记给我加标签。我将祝贺你的成就！好了，让我们尽可能用 Python 的方式创建我们的 Python 证书吧！首先我们需要三个库: matplotlib 和 pillow 用于处理图像，以及 wget 用于下载所需的字体。
使用 Linux 的人可能已经听说过 wget ，这是一个用于从互联网下载文件的命令行界面(CLI)实用程序。在这里，我们已经下载了 wget 的 Python 版本，它可以在任何机器上工作，并使用它来下载字体。现在让我们介绍生成证书的函数:
这是一段很长的代码，但是它确实创建了一个完整的证书，具有人们所期望的所有功能。我们首先导入 pillow 的三个部分，缩写为 PIL: Image、ImageDraw 和 ImageFont。第一个模块保存图像，第二个模块添加许多绘图功能，最后一个模块添加文本绘制功能。另一个新的东西是魔术选项%matplotlib inline，它确保我们将绘图写入笔记本(这在早期是必需的，不确定是否仍然需要)。证书功能本身利用了 pillow 的绘图功能。我们添加了一个双线边框，并在顶部和底部添加了一些矩形。接下来，我们添加两种不同字体的居中文本。为了正式起见，我在底部加上了当前日期和我的签名。我们可以用幸运儿的名字来调用函数 We，它会把图像和写到屏幕上。它应该是这样的:
我们非常正式的证书。
嗯，这看起来是合法的(-:。这项工作的最大部分是微调设计。创建单独的组件相对容易。函数中的最后一个操作是将证书作为便携网络图形(PNG)写到磁盘上。所以现在在 LinkedIn 上分享，给我贴标签，超级容易；-).
现在怎么办？
你的下一个问题可能是，现在怎么办？从普通 Python 的角度来看，您现在已经知道了所需的大部分内容。但是在现实生活中，大多数人都是用包来解决自己的问题，有无数的包可以探索。如果你想进入科学计算或数据科学/机器学习领域，下一个合乎逻辑的探索步骤是 Numpy 。
Numpy 在 Python 中增加了对大型多维数组和矩阵的支持。如果没有 Numpy，我们可能会创建一个列表，这将非常好。Numpy 牺牲了列表中包含任何对象的灵活性，而将固定类型(通常是数字)作为数组，并以惊人的速度编译代码来处理它们。Numpy 比普通 Python 快得多。但是和普通 Python 一样，学习概念需要一些时间。Pablo Carares 为 Numpy 制作了一个惊人的指南，强烈推荐您从那里开始。
Imgflip.com 上产生的模因
如果你知道 Numpy 是如何工作的(你不必是一个 Numpy 大师)，下一步肯定是熊猫。就个人而言，我是熊猫的超级粉丝！它提供了一种与你的数据交流的语言。掌握流利的熊猫语有很多好处，我真的建议在这项技能上投资。从熊猫开始，在熊猫文档中有熊猫 10 分钟。每年，PyCon 上都有很棒的教程。我非常喜欢 Brandon Rhodes 在 2015 年的演讲。陈琦程也做了一个很好的关于熊猫的初学者教程。变得擅长熊猫！我保证你会喜欢的！
当你对熊猫感到舒适的时候，接下来的事情就是做数据可视化。绘图本身可以用许多不同的库来完成。一开始，几乎所有人都使用 Matplotlib。它很容易使用，但有其微妙之处。现在，我通常使用 Seaborn ，这是一个基于 Matplotlib 的框架，具有更好的默认设置和更简单的语法。这些不是唯一的选择，还有和以及散景，实际上还有更多。我还是觉得从 Matplotlib 开始比较有用。在那之后，如果你想要更多的视觉享受，就选择其他的。
有了所有这些，我们终于准备好看看一些机器学习的东西。虽然我们可以马上去 Scikit-Learn ，我还是建议你去Kaggle.com吧。Kaggle 是以基于问题/项目的方式学习数据科学和机器学习的终极资源。如果这是你的第一次，点击过去最喜欢的泰坦尼克号比赛。这是一个介绍性的比赛，做起来很有趣，你可能还会从比赛中学到一些历史事实。
你成功了！
这是 Python 每天 10 分钟系列的结尾。肯定有一些主题我们没有讨论，比如多处理/多线程或者许多优秀的库和框架的例子。然而，这些确实需要超过 10 分钟。在不久的将来，我可能会写一些这样的教程。如果你有兴趣，请随时联系我。
现在，谢谢你们能走到这一步。我已经通过 LinkedIn 收到了一些积极的信息和反馈。但是，我仍然不知道到底是谁制作了这个系列。所以，如果你想帮我一个忙，把你辛苦挣来的证书放在 LinkedIn 上，给我加个标签。我保证祝贺每个人的成就！一如既往，如果有任何问题、意见或评论，请随时联系我！
每天 10 分钟学习 Python # 3
每天 10 分钟 Python 速成班
评论:Python 忽略的对你有用！
这是一个系列的 10 分钟 Python 短文，帮助你开始学习 Python。我试着每天发一篇文章(没有承诺)，从最基础的开始，到更复杂的习惯用法。如果您想了解关于 Python 特定主题的问题或请求，请随时通过 LinkedIn联系我。
每个人都知道评论是重要的，对于每个项目，你可能会对自己说:‘在下一个项目中，我会更加注意评论’。有了笔记本，你已经有了一个很好的结构，但是定期的评论还是很有用的。有时，注释可以帮助解释某个假设或为什么选择某个设置。或者简单地对参数进行内嵌解释。此外，当从一开始就添加特殊的注释(比如 docstrings)时，如果您需要将笔记本转换成常规的 Python 脚本(这非常简单)，您可以立即嵌入解释。
Python 中的注释以“#”开头。当 Python 看到 hashtag 时，它会忽略该部分后面的所有内容。此外，在调试或尝试不同的算法编码方式时，注释掉代码是很有用的。在许多编辑器中，包括 Jupyter，您可以使用“ctrl-/”来注释/取消注释一行。这适用于当前行或选定的多行。
作为一种格式标准，建议在内联注释和实际注释之间留两个空格，就像前面代码中所做的那样。添加评论很棒，尽量做到完整。然而，要避免的一件事是过度评论。过度评论意味着你评论了显而易见的东西。对于 Python 来说尤其如此，它被设计成可读的。例如，做一个注释，说您将导入包，然后输入 import 关键字，这显然是过度注释，没有添加信息。
其他语言，如 C 或 Java，能够创建多行注释。Python 本身没有多行注释，最好的方法是在每一行的开头使用一个标签。在特殊情况下，您可以使用三重引号创建多行注释。这实际上不是注释而是多行字符串，没有赋给标签。如果没有赋值，Python 解释器会忽略它。从技术上讲，您可以将这些未赋值的字符串放在代码中的任何地方，但是当将它们放在类或函数定义中时，它们就有了 DocString 的含义。文档字符串是描述函数的一小段特殊注释。虽然您可以自由地为 DocString 创建自己的格式，但是一些大型项目(如 Pandas 或 Numpy)已经对这些格式进行了标准化。熊猫有一个很好的关于如何构建它们的指南。然后这些被用来自动创建文档。我们还没有讨论创建函数，但是我认为这个例子会很清楚:
有不同的方式来设计它们，但是关键的元素是可读性。获得前面代码片段中描述的函数是非常清楚的。我们可能会认为函数名已经足够清楚了，因此，我们做了一些过度注释，但是你可能会创建更复杂的函数，你的同事和很可能还有你未来的自己，会感谢你做出高质量的注释和文档字符串。
DocStrings 通常是个好主意的原因是，在 IPython 和相关的任何地方都可以访问它们。如果您不确定某个函数的参数是什么，或者完全忘记了该函数是做什么的，您总是可以使用“？”来访问 DocString。通过键入函数，而不是写括号，您添加一个问号，您将获得该函数的 DocString。如果您使用的是成熟的 IDE，当您将鼠标悬停在某个函数上时，或者当您在括号之间时，有时会显示这些信息。我发现这些东西会让人分心，通常会把它们关掉。如果你喜欢这些东西，Visual Studio 代码当然不错，我还记得 Jupyter 实验室有一个插件可以做到这一点。
要获得 Python 中某个函数的帮助，只需添加一个？而不是括号。
今天的练习:
- 在一个新的笔记本上创建一些简单的计算。
- 围绕您的计算添加注释，并添加行内注释
- 使用 ctrl-/注释和取消注释行。
- 为以下函数创建一个 DocString:
5.使用“？”获取您自己函数的帮助
如果您有任何问题，欢迎通过 LinkedIn 联系我。
每天 10 分钟学习 Python # 4
每天 10 分钟 Python 速成班
数字变量以及如何在 Python 中给它们赋值
这是一个系列的 10 分钟 Python 短文，帮助你开始学习 Python。我试着每天发一篇文章(没有承诺)，从最基础的开始，到更复杂的习惯用法。如果您想了解关于 Python 特定主题的问题或请求，请随时通过 LinkedIn联系我。
在这节课中，我们将讨论变量赋值和数字。正如您在之前的几次会议中所记得的，Python 是动态类型化的。这意味着您不必将类型赋给变量，而是在赋值时自动分配类型。如果我们指定一个没有点的数字，它将被指定为类型 int (整数)，如果它有点或小数，它将被指定为类型 float (浮点):
动态类型的一个好处是，一般来说，你不必担心类型转换。如果需要，该值将被转换为类型 float 。与 Python 中的几乎所有类型一样，类型 int 和 float 是不可变的，并且在创建后不能更改。当进行基本算术运算时，输入值用于创建新的实例，即新的 int 或 float 值。如果这替换了对前一个结果的引用(变量),垃圾收集将删除该对象。
当然，显式地改变类型是可能的。例如，要将 float 转换为 int，可以使用 int()对它们进行强制转换。但是，此操作将截断所有小数。如果该值为 4.999，int(4.999)将返回 4。如果要四舍五入，可以使用 builtin round()函数。对于向上舍入( ceil )和向下舍入( floor )，您可以从标准库中导入它们(在后面的会话中将详细介绍导入)。使用截断或舍入时要小心。1982 年，范库弗峰证券交易所意外地使用了截断而不是舍入，因此，神秘地降低了他们的指数(钱正在消失)。这种类型转换也用于将文本转换为值，但是要小心，因为字符串应该是有效的数字。
我们刚刚看到了内置方法 round，还有几个，即整数除法、绝对值、模数和复数。这些不常用，但值得一提。
使用变量时，需要先对变量赋值，然后才能使用它们。这可能不足为奇。令人惊讶的是你分配变量的方式。您可以将多个赋值链接起来，也可以使用一种叫做元组解包的技术。当我们讨论元组时，后一个术语将更有意义。下面的例子展示了元组解包，这可能不难理解。
Python 中的 int 值是不受限制的，也就是说，你可以在一个 int 变量中存储任意大的值，它只受系统内存大小的限制。这与许多其他语言不同，在这些语言中，如果不使用额外的包，您只能使用 64 位。float 类似于 double 的 C 实现，它是一个 64 位浮点变量。限制相对较大，但如果您需要更大的数字或更高的精度，您可以使用标准库中的十进制包。float 类型也有特例，它们本身就是有效的 float。比如可以将 infinity 或者 -infinity 定义为 float(a = float(’ infinity '))。另一种特殊情况是 nan，它代表“不是一个数”，当一个数没有被定义时(如果没有出现异常)，它被赋值。NaNs 也常用来表示缺失的数字。将来，我们会花一些时间处理 nan，因为有时会很棘手。这些特殊情况是通过在内置的 float 类中放入一个字符串(不区分大小写)来调用的。
今天的练习:
- 在新的笔记本中，分配各种 int 和 float 值。
- 使用新变量进行一些计算。
- 测试所有讨论过的舍入策略。
- 算“1.2 - 1”。解释为什么这不是一个错误。
- 你觉得 float(‘nan’) == float('nan ')等于 False 很奇怪吗？
如有任何问题，欢迎通过 LinkedIn 联系我。
扫一扫
722
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
