Databricks Apache Spark 3.0 开发人员考试前要练习的 10 个问题
在这篇文章中，我分享了真正的 mcq，以及我为考试做准备的 3 个顶级技巧。
认证徽章由credential.net
我的读者请注意
这个帖子包括附属链接，如果你购买的话，我可以在不增加你额外费用的情况下赚取一小笔佣金。
>>>还不是中等成员？考虑与我的 推荐链接 签约，以获得 Medium 提供的一切服务，价格低至【5 美元一个月 ！
缺乏练习的资源？
如果你正在为 Apache Spark 3.0 认证 而学习 Databricks 协理开发人员，你可能正面临着我几周前面临的同样问题:缺乏模拟测试来评估你的准备情况。
现在，你应该知道考试由 60 道 mcq 组成，你将有 120 分钟的时间答对至少 42 道题(70%)。
另一个我想你已经注意到的细节是考试将花费你 240 美元(包括增值税)但是你将被允许一次尝试，这样如果你失败了，你将不得不再次支付重考。有了这些前提，我猜你真的希望第一次就通过考试。
但你可能会疑惑:“如果我找不到任何代表考试难度水平的问题示例，我又怎么能真正理解自己是否准备好了呢？”。
这也是我在参加考试前遇到的同样的困境:我不确定自己是否准备好超过 70%的门槛，可能我没有，因为我发现真题比预期的更具挑战性。
我发现真题比预期的更有挑战性。
尽管有一些困难(也是技术性的，因为我的考试被监考人暂停了 30 分钟)，在准备了大约 2 个月之后，我设法以一个好分数通过了认证。
在 Medium 上至少还有十几篇关于这个主题的文章(我把它们都读了，作为我准备工作的一部分)，我发现其中有 3-4 篇文章非常有见地(文章结尾的链接)，但没有一篇包含任何模拟选择题，帮助我测试我的知识。
在本文中，我将与您分享 PySpark 认证版本的 10 个 MCQs】、，您可以在真正的考试中找到它们。
为此，在本文中，我与大家分享 PySpark 版认证、的 10 个 mcq，你有望在真题考试中找到。请注意，我不允许透露确切的问题，所以我通过保持难度不变的方式重新表述了这些问题，因此您可以相信它们是一个有价值的学习资源。
在开始真正的问题之前，让我给你 3 个提示，你可能在其他文章中找不到，但我认为它们会对你的最终分数产生巨大的影响。
https://medium.com/codex/4-full-practice-tests-to-prepare-databricks-associate-certification-pyspark-2021-eab289b1ea0c 💔-ways-to-create-tables-with-apache-spark-32aed0f355ab>
我通过考试的诚实建议
不，我不会建议你阅读 Spark -权威指南 或 2d 版学习 Spark 因为……你已经知道它们了……对吗？我要给你的是 3 个技巧，它们将极大地增加你成功的机会——所以请仔细阅读！
#1 学会用心浏览 PySpark 文档
这可能是我能给 excel 的最好建议了。实际上，在考试期间，你可以参考右边屏幕上的pyspark.sql 文档，但是你不能使用 CTRL+F 来搜索关键词。
考试期间你可以参考的课程。
这意味着，除非您知道在哪里可以找到特定的方法或特定的函数，否则您可能会浪费大量的时间来来回回地滚动，相信我，这会让您感到紧张。相反，我建议你把重点放在以下三堂课的内容上:
- **py spark . SQL . data frame:**比如 你应该能定位到
*coalesce()*和*join()*函数。 - py spark . sq . column:比如你要知道
*when()**between()**otherwise*是应用于 DataFrame 的列，而不是直接应用于 DataFrame。 - *****py spark . SQL . functions:*例如，您应该知道用于操作时间字段的函数，如
*date_add()*、*date_sun()*和*from_unixtime()*(是的，我对这个函数有疑问！书上无处可寻……)在此描述。
我在测试前两天接触并研究了文档的结构，但我希望我能更早地这样做，因为这些知识帮助我正确回答了至少 7-8 个问题。****
因此，我在这里试图传达的是不要高估你在 PySpark 语法上的知识，因为你的记忆可能会在考试中背叛你。充分利用文档。
#2 在 Udemy 上查看本课程:data bricks Spark 3.0 实践考试认证开发人员
事实证明，实际上Python/Pyspark的两个完整模拟测试在 Udemy 上可用，并且包括 Apache Spark 3.0 认证考试的 120 个模拟考试测验！
***
我在考试前两个月购买了测试权限，因为我想研究基于真题的材料，并复习我得到错误答案的主题。
与真正的考试一样，您有 2 个小时的时间来完成测试，并且每个题目的权重也受到尊重，这意味着:
- Spark DataFrame API 应用(~72%)
- Spark 架构:概念理解(~17%)
- Spark 架构:应用理解(~11%)
就我而言，实际考试中至少有 12-15 个问题与我在这些考试中练习的问题 ( 在措辞和解决方案方面)非常相似，所以我认为这是你在学习认证时的一项出色投资。
#3 不要只运行官方指南中的代码示例。更进一步。
事后看来，有一件事我在准备时可以做得更好，那就是尝试运行更多属于Spark****data frame API的函数和方法，并仔细检查它们的语法细节，而不是只关注书本上的代码片段。
想想看:你会发现至少有 40-43 个关于 Spark DataFrame API 的问题，因此有理由期待大量不同的概念将被测试(甚至是你在书中找不到的概念——生活糟透了！)。
此外，记住这 40-43 个问题中有 30%会特别棘手**，至少有两个非常相似的选项，所以你需要非常确定语法。但是请记住:最坏的情况下，你可以随时查阅文档资料(让我们回到第一点)。**
现在是进行一些测验的时候了！
**💔-nanodegrees-you-should-consider-to-advance-your-data-engineering-career-in-2021-baf597debc72>
问题 1
*Given a dataframe* ***df****, select the code that returns its number of rows:*A. df.take('all')
B. df.collect()
C. df.show()
D. df.count() --> **CORRECT**
E. df.numRows()
正确答案是 D ，因为df.count()实际上返回了一个数据帧中的行数，正如你在文档中看到的。这是一个热身问题，但不要忘记它，因为你可以找到类似的东西。
问题 2
*Given a DataFrame* ***df*** *that includes a number of columns among which a column named* ***quantity*** *and a column named* ***price****, complete the code below such that it will create a DataFrame including all the original columns and a new column* ***revenue*** *defined as* ***quantity*price:***df._1_(_2_ , _3_)A. withColumnRenamed, "revenue", expr("quantity*price")
B. withColumn, revenue, expr("quantity*price")
C. withColumn, "revenue", expr("quantity*price") --> **CORRECT**
D. withColumn, expr("quantity*price"), "revenue"
E. withColumnRenamed, "revenue", col("quantity")*col("price")
正确答案是 C ，因为代码应该是:
df.withColumn("revenue", expr("quantity*price"))
你至少会被问到 2-3 个问题，涉及到在 DF 中添加一个新列或者重命名一个现有的列，所以要很好地学习withColumn()和withColumnRenamed()的语法。
问题 3
# *Given a DataFrame* ***df*** *that**has some null values in the column* ***created_date,*** *complete the code below such that it will sort rows in ascending order based on the column* ***creted_date*** *with null values appearing last.*df._1_(_2_)A. orderBy, asc_nulls_last("created_date")
B. sort, asc_nulls_last("created_date")
C. orderBy, col("created_date").asc_nulls_last() --> **CORRECT**
D. orderBy, col("created_date"), ascending=True)
E. orderBy, col("created_date").asc()
正确答案是 C ，因为代码应该是:
df.orderBy(col("created_date").asc_null_last())
而且df.orderBy(df.created_date.asc_null_last())也会起作用。
实际上，与答案 E 中的asc()一样，asc_null_last()不接受任何参数，而是应用于 column 以返回基于列的升序的排序表达式，null 值出现在非 null 值之后。
问题 4
Which one of the following commands does NOT trigger an eager evaluation?A. df.collect()
B. df.take()
C. df.show()
D. df.saveAsTable()
E. df.join() --> **CORRECT**
正确答案是 E 因为在 Apache Spark 中，所有的转换都被缓慢地求值，所有的动作都被急切地求值*。在这种情况下，唯一会被延迟评估的命令是df.join()。*
下面，您会发现一些经常出现在类似问题中的附加转换和操作:
**Transformations Actions**
orderBy() show()
groupBy() take()
filter() count()
select() collect()
join() save()
limit() foreach()
map(), flatMap() first()
sort() count(), countByValue()
printSchema() reduce()
cache()
问题 5
Which of the following statements are NOT true for broadcast variables ?A. Broadcast variables are shared, immutable variables that are cached on every machine in the cluster instead of being serialized with every single task.B. A custom broadcast class can be defined by extending org.apache.spark.utilbroadcastV2 in Java or Scala or pyspark.Accumulatorparams in Python. --> **CORRECT**C. It is a way of updating a value inside a variety of transformations and propagating that value to the driver node in an efficient and fault-tolerant way.--> **CORRECT**D. It provides a mutable variable that Spark cluster can safely update on a per-row basis. --> **CORRECT**E. The canonical use case is to pass around a small table that does fit in memory on executors.
正确的选项是 B 、 C 和 D ，因为这些是 累加器 ( 分布式共享变量的替代类型)的特征。
对于考试，请记住，广播变量是不可变的，并且在触发一个动作时会在集群中的所有节点上延迟复制。广播变量在规模上是有效的，因为它们避免了为每个任务序列化数据的成本。它们可以用在 rdd 或结构化 API 的上下文中。
问题 6
The code below should return a new DataFrame with 50 percent of random records from DataFrame **df** without replacement. Choose the response that correctly fills in the numbered blanks within the code block to complete this task.**df._1_(_2_,_3_,_4_)**A. sample, False, 0.5, 5 --> **CORRECT** B. random, False, 0.5, 5
C. sample, False, 5, 25
D. sample, False, 50, 5
E. sample, withoutReplacement, 0.5, 5
正确答案是 A 因为代码块应该是df.sample(False, 0.5, 5)事实上sample()的正确语法是:
df.sample(withReplacement, fraction, seed)
在这种情况下,seed是一个随机数，与答案无关。你应该记住它是顺序中的最后一个。
问题 7
Which of the following DataFrame commands will NOT generate a shuffle of data from each executor across the cluster?A. df.map() --> **CORRECT**
B. df.collect()
C. df.orderBy()
D. df.repartition()
E. df.distinct()
F. df.join()
正确答案是 A ，因为map()是列表中唯一的窄变换。
特别地，转换可以被分类为具有 窄依赖性 或 宽依赖性 。任何可以从单个输入分区计算出单个输出分区的转换都是窄转换。例如，filter()、contains()和map()表示窄转换，因为它们可以在单个分区上操作，并在没有任何数据交换的情况下产生结果输出分区。
下面你会发现一个列表，包括许多狭义和广义的变换，在考试前复习一下很有用:
**WIDE TRANSORM NARROW TRANSFORM**
orderBy() filter()
repartition() contains()
distinct() map()
collect() flatMap()
cartesian() MapPartition()
intersection() sample()
reduceByKey() union()
groupByKey() coalesce() --> when numPartitions is reduced
groupBy() drop()
join() cache()
问题 8
When Spark runs in Cluster Mode, which of the following statements about nodes is correct ?A. There is one single worker node that contains the Spark driver and all the executors.B. The Spark Driver runs in a worker node inside the cluster. **--> CORRECT**C. There is always more than one worker node.D. There are less executors than total number of worker nodes.E. Each executor is a running JVM inside of a cluster manager node.
正确答案是 B，因为在 集群模式 中，除了执行器进程之外，集群管理器还在集群内的工作节点上启动驱动程序进程。这意味着集群管理器负责维护所有 Spark 工作节点。因此，集群管理器将驱动程序放在一个工作节点上，将执行器放在不同的工作节点上。
问题 9
The DataFrame **df** includes a time string column named **timestamp_1**. Which is the correct syntax that creates a new DataFrame **df1** that is just made by the time string field converted to a unix timestamp?A. df1 = df.select(unix_timestamp(col("timestamp_1"),"MM-dd-yyyy HH:mm:ss").as("timestamp_1"))B. df1 = df.select(unix_timestamp(col("timestamp_1"),"MM-dd-yyyy HH:mm:ss", "America/Los Angeles").alias("timestamp_1"))C. df1 = df.select(unix_timestamp(col("timestamp_1"),"America/Los Angeles").alias("timestamp_1"))D. df1 = df.select(unixTimestamp(col("timestamp_1"),"America/Los Angeles").alias("timestamp_1"))E. df1 = df.select(unix_timestamp(col("timestamp_1"),"MM-dd-yyyy HH:mm:ss").alias("timestamp_1"))
正确答案是 E ，因为unix_timestamp()的正确语法是:
unix_timestamp(timestamp, format)
这个函数不包括时区参数，因为它意味着使用默认的时区。同样，在 PySpark 中，在函数内部重命名列的正确方法是alias()。
问题 10
If you wanted to:1\. Cache a **df** as SERIALIZED Java objects in the JVM and;
2\. If the **df** does not fit in memory, store the partitions that don’t fit on disk, and read them from there when they’re needed;
3\. Replicate each partition on two cluster nodes.which command would you choose ?A. df.persist(StorageLevel.MEMORY_ONLY)
B. df.persist(StorageLevel.MEMORY_AND_DISK_SER)
C. df.cache(StorageLevel.MEMORY_AND_DISK_2_SER)
D. df.cache(StorageLevel.MEMORY_AND_DISK_2_SER)
E. df.persist(StorageLevel.MEMORY_AND_DISK_2_SER) --> **CORRECT**
正确答案是 E ，因为正确的命令应该是:
df.persist(StorageLevel.MEMORY_AND_DISK_2_SER)
事实上，对于 Spark 数据帧，默认情况下，cache()命令总是将数据放在内存和磁盘中(MEMORY_AND_DISK)。相反，persist()方法可以接受一个StorageLevel对象来指定缓存数据的确切位置。
请记住， 数据存储在磁盘上时总是被序列化，而您需要指定是否希望在内存 中序列化数据(例如MEMORY_AND_DISK_2_SER)。
结论
在这篇文章中，我分享了 **10 个 mcq(选择题)**你应该用来准备 Databricks Apache Spark 3.0 开发者认证。这些问题与你在真实考试中遇到的问题极其相似，因此我希望这对你来说是一个有价值的学习资源。
如果你觉得这份材料有用，请随时在评论中告诉我，因为我很乐意写一份包括 10 个小测验的第 2 部分。
现在，我将留给你一些关于媒体的其他文章，这些文章涉及与认证相关的更一般的主题。**
其他有用的文章
- 通过 Shruti Bhawsar 的【Apache Spark 3.0 认证助理开发人员】考试(Python) 的学习指南
- Apache Spark 3.0/2.4 data bricks 认证准备指南和提示由 Anoop Malayamkumarath
- Crack data bricks Apache Spark 3.0 认证助理开发人员-准备提示，信息&澄清由 Sriram Narayanan
作为数据科学初学者应该避免的 10 个错误
初学者指南
如何在数据科学就业市场获得竞争优势
图片来自 Pixabay
数据科学是成功的。全球成千上万的学生注册了在线课程，甚至是数据科学硕士课程。
数据科学领域是一个竞争非常激烈的市场，尤其是为了在大型科技公司获得一份(假定的)理想工作。积极的消息是，通过充分的准备，你有机会获得这个职位的竞争优势。
另一方面，有太多的 MOOCs、硕士项目、训练营、博客、视频和数据科学学院。作为一个初学者，你会感到迷茫。我应该参加哪门课程？应该学什么题目？我需要关注哪些方法？我必须学习什么工具和编程语言？
事实是，每个数据科学家都有她/他的个人旅程，并且偏向于那条学习道路。所以，在不了解你的情况下，很难说哪种方法最适合你。
但是所有的数据科学家都会一遍又一遍地犯一些常见的错误。即使你知道它们，你也不会完全避免它们，但最终，在做它们的时候早点停下来，找到更快回到成功之路的方法。
基于我在数据科学领域 20 多年的经验，领导着多达 150 人的团队，并且仍然在全球领先的大学之一兼职讲课，我为您总结了避免更快实现梦想的核心错误。
错误是按照初学数据科学家的学习进度顺序排列的。
#1 在你最终开始之前，花太多时间评估所有不同类型和选项的课程——或者最终永远不开始
我知道你被所有的课程压得喘不过气来，你努力不犯任何错误。你想要有效地投资你的时间和金钱，选择保证最快最好成功的正确方法。
不幸的是，没有像在任何技术和科学领域那样的立竿见影的成功，为了尽可能最好的成功，你将没有任何比较。
事实是，今天，所有已建立的平台、学院和研究所都有很好的课程。所以，不要过度思考和过度分析课程。勇敢的选择一个，完成那个课程，然后选择另一个。
最关键的方面是开始和行动。你不能在这里犯错误，因为你既不知道你的旅程，也不知道如果选择另一个旅程会有什么不同。没人能告诉你。句号。
认识到学习是循环的而不是线性的也很重要。参加一门数据科学课程并不排除您正在参加另一门课程。
我仍然做数据科学、机器学习和人工智能培训。在每一个仍然如此“简单”的初学者课程中，我都能发现这个话题的一个新的方面和一个新的观点。这正是最终造就一名高要求数据科学家的原因。而是要了解一个话题的所有不同角度。
#2 你想一次学习太多的方法和工具，而不是一个一个地学习和理解方法
许多有抱负的数据科学家认为，在简历中尽可能多地提到方法有助于更快找到工作。但事实恰恰相反。申请工作时，你六个月前才开始为每个招聘人员提供数据科学，很明显，这只是一句空话，没有任何实质内容。
如果我们看回归模型，有很多书只讲回归。有 50 多种回归类型，每一种都有不同的前提条件。所以，简历中只有“回归”并不能说明什么。此外，回归模型仍然是应用程序中最重要的模型，并为一般数据科学的理解奠定了基础。
你必须明白一个方法解决的是什么；有哪些假设；参数是什么意思；什么是陷阱；如此等等。
根据简历和回归知识的描述，每一位有经验的招聘人员——或者今天，流程背后的算法——都可以确定你理解的深度。
只对少数几种方法有深入的了解和经验，比知道许多没有实质内容的方法要好。
#3 你从一开始就编码所有东西，因为你认为这有助于你更好更快地编程
当开始编码时，人们认为他们必须快速开始编码，并重新编程尽可能多的算法。还有，这里你要着重理解几个而不是数量。
首先，你需要了解编码的先决条件:线性代数、数学归纳法、离散数学、几何学——没错，这是优秀程序员的强项但却经常被数据科学家遗忘，统计与概率论、微积分、布尔代数、图论。
我并没有通过编写更多的代码变得更好更快。通过理解数学基础，回顾他人的代码，并在不同的数据和问题上运行和测试它们，我变得擅长编程。
是的，编码是必不可少的，但更重要的是理解代码的(好的)架构。而这只能通过复习其他代码来学习。
一个事实是，代码越来越成为一种商品，甚至出现了无代码工具。区别不再是会编码的人和不会编码的人之间的区别，而是理解架构的人和不理解架构的人之间的区别。
我给你看另一个例子:我假设你已经使用了 TensorFlow。但你明白这是什么吗？它是做什么的？又为什么叫“张量流”？你知道张量是什么吗？不仅仅是张量积的机械计算，它在几何上意味着什么？
#4 通过学习理论，你以为自己什么都懂，却错过了足够的实践经验
学习数据科学需要不断尝试和犯错。只有当你尽可能多地制造经验，制造所有的错误并解决它们时，你才会有更深的理解。
这个理论很好，也很重要。你需要了解基本原理。
不幸的是，在实践中，它很少像理论上那样工作。相反，它经常以一种精确的方式工作，因为你已经知道你不应该这样做。
所以，你必须从实际例子开始。通常，你会觉得没有准备好做实际工作:没有足够的基础知识或者没有足够的编程经验。
但是我强烈建议:即使你没有准备好做练习，也要从头开始。它不必是一整天或一周的项目。一个 1-2 小时的小项目就足够了。
你可以从 RapidMiner 或 KNIME 这样的无代码工具开始，也可以采用别人的代码并加以应用。例如，使用一个简单的情感分析代码，并将其用于推文或产品描述。然后，您可以开始修改其他示例的代码，并比较结果。
当你还是个小孩子的时候，你开始学说话的时候，是从单个单词或者两三个单词的表达开始。一步一步地，你建立了对语言的感觉。数据科学的实践经验也是如此。
专家提示:学习是循环的。所以，储存你的作品。以后你可以回来，改进它，把它移到 GitHub，并用 Tableau 添加可视化效果。
#5 你认为证书是获得数据科学工作的竞争优势
证书是可以的。有很多声音告诉你，你不应该做认证。但它们可以作为一种动力，最后，它们正式显示了你的进步和你对学习的渴望。我还是做证书的。没有错，而且当你投入时间的时候，拥有它是正当的。
但这并不是市场上的差异化因素。事实是，有成千上万的人有相同的认证。因此，要获得竞争优势，你必须超越这一点。
例如，我的一个学生向我寻求金融领域实习机会的支持。他希望应用他所学的知识，并了解数据科学团队的文化和合作。我可以把他放在一家银行，然后他用它写一篇学期论文。是的，平行地做研究和实习和学期论文是有压力的。但这会给他提供一个无价的竞争优势。
你担心别人的看法，而不是根据事实建立自己的观点
大多数有抱负的数据科学家担心其他数据科学家的看法。而他们听到的争论越多，就越困惑。即使清晰之路需要混乱，它也不应该保持稳定的状态。
每个数据科学家都是一个个体，有着自己的经验、学习和职业道路及观点。我习惯说，“如果你有两个数据科学家在一个房间里，你至少有四种不同的意见。”
把观点作为灵感和搜索信息的指南是好的，但不是作为信息本身。
寻找确凿的事实。得出你的逻辑结论，验证并再次更新它们。这是在您的数据科学职业生涯中取得成功的一项重要技能。
#7 不关心业务和领域知识
许多数据科学家认为他们可以将这些方法应用于每个问题和行业，但根据 20 多年的经验，我可以告诉你这是错误的。
我经常看到数据科学家向业务人员展示他们的发现，而他们的反应是，“哦，我们已经知道了。我们需要的是“为什么会这样”和“如何解决”或者，在最糟糕的情况下，“这完全是胡说八道，因为这不是我们的业务运作方式。”嘣！
拥有领域知识比知道所有性别歧视和最花哨的方法更重要。数据科学家解决的是业务问题，而不是技术问题。通过解决一个业务问题，你为公司的业务带来了价值，而你的价值只有这么多，因为你的解决方案的价值。当你了解业务时，你就成功地做到了这一点。
我在许多不同的行业工作过。每次在我开始接触这个行业之前，我都会阅读很多关于这个行业的资料。
- 我从维基百科开始，了解了大背景和公司
- 我查阅了某行业前 10 名公司的年报和投资者关系信息
- 我阅读了过去几年所有关于这个行业和公司的新闻报道
- 我联系了在这个行业工作的 LinkedIn 联系人
才开始和商家互动。
你一半的学习应该包含产业和商业知识的发展。
#8 你没有持续不断地学习和学习
很容易因为不理解题目而分心或者提前放弃。学习数据科学是一场马拉松，而不是短跑。因此，有必要建立一个日常学习的持续和一致。就像马拉松训练一样，你以小单位进行训练，但是每天都进行。
还有，如前所述，学习是循环的。曾经研究过一个题目，并不代表你已经掌握了。
我给你举个例子。在数学金融讲座中，我不得不学习许多极限定理。考试进行得很顺利，我确信我理解了他们。但是七年后，当我不得不审查复杂结构金融产品估值的代码时，天平从我眼前滑落，我意识到直到审查代码的那一刻我才理解了它。
所以，每天，或者至少每周，花几个小时学习。不管你是一名有抱负的还是已经是一名资深数据科学家。
学习内容应包括新的数据科学主题、已经学习过但来自另一个角度的主题，例如另一门课程或另一本书、新技术和技术趋势、行业和业务知识、数据可视化和数据故事讲述以及数据应用。
它增加了一层又一层的理解，在工作面试中，你将能够通过从不同角度呈现整体观点来给出令人信服的答案。
#9 不用数据讲故事
在数据科学工作中，你将主要与非技术人员交流你的发现，特别是业务人员。企业为你的工作提供资金。没有他们的承诺，您的工作和数据科学团队就不会存在。
你的工作是给企业带来价值。不是为了应用而应用花哨的方法。
我的一个朋友是一家全球银行的数据科学主管。当他们雇用数据科学家时，他们会提前两周给他们发送数据集，并要求他们做 20 分钟的演示。没有给出进一步的输入。他们想看讲故事。他们对所用的方法不感兴趣——除非候选人会对所用的方法胡说八道。首先，他们想看到的是业务问题的框架，以及为什么解决这个问题很重要。第二，应该解决什么和持续什么，如何解决，以及在商业环境中的结果。“这是我们一整天做的最重要的工作。候选人不能在这方面做到完美，但要表现出她/他已经理解了我们工作中的重要内容。”
因此，学习数据讲故事——甚至有关于这方面的免费课程——并学习商业环境中的数据可视化。
#10 无需与数据科学社区互动，自主学习
很多人认为可以通过自己的努力学习数据科学。所有其他数据科学家都被视为竞争对手，其中一个不愿意交流知识。
但是，生活在你的世界里，你只根据你的选择来阅读和学习，这是非常偏颇的，并且会丢失许多关于某个主题或方法的观点。此外，关于某个主题的公开讨论和在论证中获得经验是缺失的，这是任何数据科学家都需要的技能。
任何有经验的招聘人员都会在一两个问题后知道你是一个人表演，还是你有一个生动的网络来帮助你成倍地获取知识。这有利于公司，增加你的市场价值和需求。
所以，发展一个网络是至关重要的。这可以通过参加训练营、黑客马拉松和聚会来实现。
现在，理论上你知道你应该避免什么。
这些错误中的任何一个都有可能成为你数据科学工作的绊脚石。
我知道你仍然会犯一些这样的错误。我没有不同。认为“我与众不同”是人类的天性——尽管数据显示情况恰恰相反。但意识到这些潜在的错误将帮助你更快地重新调整你的道路，从而更有效地成为一名受欢迎的数据科学家。
你喜欢我的故事吗？在这里你可以找到更多。
面向 R 程序员的 10 本最出色的机器学习书籍
R 中我最喜欢的 10 本统计学习用书！
(图片由作者提供)
介绍
当涉及到数据科学和统计计算时，很少有语言像 R 语言一样专注于这个领域。R 编程语言已经存在很长时间了，对于任何想从事数据科学的人来说，它肯定是一个可行的选择。令人惊讶的是，这甚至在 2021 年仍然如此。虽然在许多情况下，对于复杂的机器学习模型和神经网络等工作，有比 R 更好的选择，但 R 的生态系统尤其擅长事物的分析方面。
很难否认闪闪发光的仪表盘或 ggplot2 的威力。不用说，很难想象如果没有 R 编程语言，统计学习会是什么样子。尤其是 R 保持了概念和领域的生命力，多年来它是实现这一目的最流行的语言。如果您想了解更多关于这种实践中常用的所有语言，以及 R 的优缺点，我有一篇关于 2021 年数据科学最佳语言的文章，您可以在这里查看:
用 R 编程语言可以做很多很棒的事情。此外，我想说，R 将很快成为任何数据科学家或有抱负的数据科学家的宝贵财富。关于 R 编程语言的一个伟大的事情是，随着它的生态系统，它真的已经存在了相当长的时间！这意味着在互联网上找到帮助往往相对容易。这意味着的另一件事更符合我在这篇文章中想要谈论的内容，
书籍。
在过去的几年里，书籍已经有点过时，这已经不是什么秘密了。也就是说，总的来说，现在写的书要少得多，而销售的文章和电子书要比精装书多得多。这是一件很棒的事情，因为我们可以拯救树木，但是使用 R，我们还可以受益于多年来为编程语言编写的整个教育书籍库！很难确定哪本书是我最喜欢的，因为我认为阅读编程是学习编程的最好方式——这些书已经派上了用场！如果你也想看看我最喜欢的几本 Python 书籍之间的类似比较，我这里有一本你可以看看:
</7-ground-breaking-machine-learning-books-for-python-ea6db967e36c>
№1:用 R 进行深度学习
难度:中级—高级
这本书不仅封面很棒，内容也相当有趣和有用。虽然与 R 语言更强的分析能力和生态系统相比，深度学习可能不是这种语言的最大用途，但这本书实在太棒了。这本书的伟大之处在于，它给出了使用机器学习和深度学习技术的清晰、明确和定义的途径，并让你用简单的英语熟悉这些概念。
这本书对来自 r 的 Keras 库进行了相对深入的概述和常见用法。这个库当然是一个行业标准工具。这使得这本书更有价值，因为它将教授一种广泛使用的工具的用法，并从本质上为你在该领域使用该工具做准备。总的来说，这本书将为机器学习和深度学习概念提供坚实的基础，这将为整个数据科学职业生涯提供价值，我想说这当然值得一读！
综合评分:8/10
“这本书不仅将提供 R 编程和机器学习的基础知识，因为它是 R 语言，而且还将提供深度学习概念，这将极大地有利于数据科学职业生涯。”
№2: R 用于数据科学
难度:初学者
R for Data Science 是 O’Reilly 对数据科学教育社区的另一个重大贡献，就有价值的教育而言，这一次肯定与其他任何一次没有什么不同。这本书绝对精彩，我发现这本书实际上非常令人兴奋和有趣，这超过了许多教育文学作品。这本书的伟大之处在于，它将把基本上具有基本编程经验的人变成一台分析机器！
这本书也更加关注数据科学的数据方面。我以前说过，我认为理解干净的数据、统计如何工作以及如何处理数据将是数据科学家最有价值的资产。这本书通过提供一个在 R 中处理复杂数据集的具体基础，并将那些观察结果转化为知识，将这种方法论铭记于心。另一个伟大的事情是，这本书真正进入了数据科学的核心，即数据科学周期。
这个循环涉及所有重要且至关重要的数据科学技能，例如获取数据、处理和整理数据，然后用这些数据建模并有效地交流结果。如果你仔细想想，所有这些技能都是绝对必要的，很容易明白为什么它们都同等重要。如果不能扯皮数据，怎么清理？如果你不能清理它，你打算如何建模？这本书采取了一个伟大的方法来解决这些问题，通过在整本书中重复同样的循环，并真正强调要一路骑着它回家。
总体评分:9/10
“这本书提供了一些优秀的数据科学技能，为构建 R 编程语言打下基础。它全面地审视了数据科学通常涉及的整个过程，不会让人不知所措，既平易近人又令人愉快。”
№3: R 在行动
作者:罗布·卡巴科夫
难度:初学者
《R in action》是另一本很棒的书，我肯定会推荐给 R 编程语言的新手。这本书的伟大之处在于，它真正着眼于在商业中使用语言进行数据科学和分析应用。这是机器学习的一个方面，我认为它经常被忽视，尤其是在使用编程语言和机器学习模型的时候。
我认为这本书和后一本书都提出了很多关于展示研究的想法，数据科学的R是很重要的想法，可能会被初学者忽略。也就是说，这两本书都提供了对这些概念的坚实的基础理解，这对任何试图从事数据科学工作的人都有价值。
总体评分:8/10
“R in action 不仅涵盖了统计分析和一般 R 用法的广泛主题，还全面概述了与科学和研究演示相关的主题。我认为这是书中经常忽略的东西，所以不用说，这本书对这些主题进行了有效的关注，这意味着这本书对于那些试图熟悉这些概念的人来说是一笔巨大的财富。”
№4:高级 R
作者:哈德利·韦翰
难度:中等
虽然这本书可能会将自己标榜为高级 R，但我仍然认为书中提供的许多概念和编程技巧可以由只广泛熟悉 R 的人来解释。也就是说，这本书可能不会深入研究机器学习、分析或 R 的任何统计能力，但确实在让程序员熟悉和有效使用 R 编程语言方面做了令人难以置信的工作。
实际上，在拿起这本书之前，我已经使用 R 有一段时间了。看到封面，我很兴奋能深入了解 R 作为一门语言的能力。相反，我惊喜地了解到 R 更多的声明性特性，这使我更好地使用了这种语言，这对于我使用这种语言进行数据科学工作无疑是有价值的。
总体评分:7/10
“我认为这本书对于那些已经使用 R 语言有一段时间，但感觉需要更好地学习这门语言的人来说是一个很好的选择。这本书的伟大之处在于它解构了许多 R 的特性，使读者成为一个更善于利用语言中已有的特性的程序员。”
№5: R 食谱
保罗·蒂特
难度:初学者
排在第五位的是奥莱利的另一个可爱的贡献，而《男人》是一个值得挑选的作品！从我这里得到 10/10 的评分是很难的，但是 R cookbook 采用了一种非常类似于烹饪书的方法来提供关于 R 语言的信息。对于那些可能不太熟悉这门语言，但希望更多地使用它的人来说，这无疑是一个很好的选择。
这本书是无法用语言来描述的，因为它太棒了，但是我会给你一个基本的概述，你可以期望通过书中的某些章节来实现。这本书从 R 的安装开始，在速成这门语言中可用的软件和数据结构之前，快速进入基础部分。这本书以做什么结束
我真正喜欢这本书的是，它将提供一个非常全面的知识基础，告诉我如何有效地利用 R 编程语言。这本书做到了这一点，同时还保持了良好的解释，非常容易阅读。我想说这本书最大的缺点是它是针对初学者的。虽然我想说，许多有经验的用户可以获得某种形式的启示，在 438 页，它可能只值得浏览更多的前 R 用户。
综合评分:10/10
“这本书将以一种非常平易近人和简单的格式提供大量 R 和统计的基础知识，也可用于整个数据科学和统计工作的参考。”
№6:实用数据科学与 R
约翰·芒特和尼娜·祖默
难度:初学者
《实用数据科学与 R》是另一本用 R 语言进行数据科学研究的好书。这本书唯一的缺点是，我不认为它比这份清单上的其他选择好多少。我发现写作风格相对黑白和简单，没有留下太多的想象力。
尽管如此，这仍然是一本很棒的书，它将让你熟悉分析知识，特别是 R。记住这一点，它真正进入了 R 在 2021 年最常被用于数据科学的面包和黄油。
综合评分:7/10
“这本书肯定会提供一些关于数据科学的很棒的课程，读者可以在他们的整个职业生涯中珍藏这些课程。这本书还深入研究了数据分析，并为概念提供了具体的解释，尽管它以相对直接和简单的方式格式化——这在某些学习环境下可能是一个优势。”
№7:统计学习导论:R
难度:初学者
我很久以前在另一个数据科学书籍综述中提到的一本书是统计学习导论:r 中的应用这本书的伟大之处在于它非常关注我认为非常重要的统计概念。如果你也想看看我在这篇文章中提到的其他一些很棒的书，你可以在这里查阅整篇文章:
</5-great-data-science-books-for-lifelong-learners-3a6405a7f890>
这本书的伟大之处在于它所涵盖的内容。本书涵盖的概念仍然完全适用于当前的 R 包生态系统。此外，这本书确实着眼于 R 编程语言的许多优势，并利用它们进行统计学习。围绕这本书的是对统计计算的深入研究，以及一些用 r。
总体评分:9/10
“这本书可能有点旧了，但它肯定还在马鞍上。这本书的伟大之处在于，它可以教授很多关于 R 在今天应该用于什么的知识，并且这种语言的许多应用在今天仍然很有意义。”
№8: R 图形食谱:可视化数据的实用食谱
温斯顿·张
难度:初学者
奥赖利的另一本令人敬畏的“食谱”是 R 图形食谱。这本书深入研究了 R 中的图形处理，对于可视化策略肯定会派上用场。这是当今 R 程序员使用的另一种非常流行的分析方法，所以我认为这本书也非常适用于现代技术和数据科学。
这本书的伟大之处在于它真正关注了 R 数据科学难题中的一个元素。很多书试图涵盖机器学习问题的整个范围，而在一本书中全面涵盖这些问题并不容易，这本书的范围是我非常欣赏的。这本书还深入研究了数据和数据分布的工作，这当然非常适用于数据科学，并且将在数据科学的任何领域中派上用场。
总体评分:8/10
“这本书在展示数据分析的 R 编程语言中常见的许多不同的可视化风格方面做得很好。这本书的伟大之处在于，它的范围相对有限，因此学习目标更少，但占用空间的东西也更少。涵盖的主题非常全面，这也使这本书更容易理解。”
№9:数据分析软件:用 R 编程
作者:约翰·钱伯斯
难度:初学者
约翰·钱伯斯实际上是 S 编程语言的主要设计者，而 R 编程语言本质上是以它为模板的。在某种程度上，r 对于 S 就像 C++对于 C 一样，所以不言而喻，这个基本上创造了这种语言的家伙对这种语言如何工作以及如何有效地使用有很多见解。
这本书的伟大之处在于它对 R 中的一切进行了广泛的概述。这本书将用相对较长但全面的 515 页篇幅带您了解 R 中的可视化模式、统计学和软件工程。这本书的很多页面也使用了 R 包，这些包在今天仍然被广泛使用！
总的来说，这本书很棒——如果你是 R 的新手，这本书绝对值得一读，因为它对软件包的全面概述有助于你熟悉 R 的生态系统。虽然我不会说 R 有我最喜欢的数据科学生态系统，但我会说它确实有一些值得拥有的古老技术，这本书通过实际利用模块来解决现实的统计问题证明了这一点。
总体评分:8/10
“对于有经验的程序员来说，这本书将是一个很好的 R 语言入门书。此外，我认为有很多关于数据的知识，更具体地说是在 R 中处理数据，这对于任何数据科学工作来说都肯定会派上用场。”
№10: R 数据科学编程
罗杰·彭
难度:初学者
我将第一个承认，这本书有点怪异——但这是它的魅力之一。从伸出的企鹅的奇怪封面，到我非常确定企鹅是因为作者的姓氏而出现在封面上的事实(我希望是这样)，这本书一开始可能有点令人不快……然而，我认为这本书肯定值得一读，这就是我为什么相信这一点的原因。
彭有一种非常独特的文风，那就是既直接，又含蓄的风格。很多教育类书籍让我感到不安的是，作者缺乏一种有效的写作风格，让读者既能参与又能理解。
为了真正让人们学习数据科学，他们需要寻找信息。这可能将是他们生活中彻底改变一切的一段时间，他们需要对技术、统计数据、数据、见解，当然还有机器学习真正感到兴奋、着迷和开心。我喜欢这本书的原因是，它确实持有一些我认为在学习时需要考虑的核心价值观，并采取了一种实践的方法来欣赏这些价值观。这就是我将如何写我的书，因为我认为一种让人们进入做科学的最佳状态，同时也展示为什么它很棒的方法，才是真正让人们想要学习更多的东西。
综合评分:8/10
虽然这不是我读过的最好的书，但它确实让读者对主题感到兴奋和有动力，而不是保持单调，这是值得赞赏的
结论
我认为 R 编程令人难以置信地棒，其中一些书可以提供一个非常好的关于利用机器学习语言的基础结构。尽管最近这种语言对 Python 的支持有所下降，但从分析来看，它仍然比以往任何时候都更强大。我对使用大量 R 模块感到兴奋，因为对我来说，它们的一些实现是如此完美，可能是因为这些年来这些技术变得如此古老。
我可以第一个告诉你，作为一个主要的 Julian 程序员，我们有许多生物医学类型的科学家在工作——其中许多类型的分析都是在 R 中完成的。我要说的是，R 在这些方面肯定比 Julia 有更好的生态系统，所以不难理解为什么教你使用像 R 这样强大的工具的书非常棒。我当然会建议从这个列表中挑选一些，可能是烹饪书。非常感谢您的阅读，我希望这个列表有助于您更加熟悉奇妙的 R 编程语言！
每个数据分析师都需要知道的 10 个最重要的 SQL 命令
从数据库中查询数据并不复杂
作为一名数据分析师或数据科学家，无论你在创建奇特的可视化效果方面有多擅长，或者在构建复杂的模型方面有多熟练，都没有关系——从本质上讲，你需要数据来做这些事情。
在大公司工作时，这些数据通常存储在数据库中，这样每个人都可以轻松地访问和查询他们工作所需的数据。
你如何查询这些数据？这就是 SQL 的用武之地。
SQL 是结构化查询语言的缩写，顾名思义，它是一种用于从关系数据库中查询或检索数据的标准化语言。此外，它还可以用于对数据执行各种操作，如过滤行和列以及简单的数据操作。
当我开始作为一名数据分析师工作时，我最早的观察之一是我周围的每个人都知道如何使用 SQL，我指的是几乎每个人。无论你是刚入队不久的实习生，还是从业已久的资深分析师，这都是大家需要了解的技能。这表明了 SQL 在数据科学分析领域的重要性。
有鉴于此，我想在这篇博客文章中重点介绍 10 大 SQL 命令，以帮助您开始使用 SQL 的旅程，但更重要的是，我将使用实际示例演示每个命令，以模拟实际使用数据库的感觉。
为此，我们将使用 SQL Fiddle ，这是一个方便的在线测试和共享 SQL 查询的应用程序。出于本教程的目的，我创建了两个模拟表 transaction 和 customers，它们分别代表一个连锁超市的事务和客户概要。
1.选择和从
SELECT和FROM构成了所有 SQL 查询的基础。最基本的 SQL 查询将涉及这两个命令，随着查询变得越来越复杂，将在它们之上添加更多的命令。
SELECT通知您想要选择哪些列，而FROM指定您想要从哪个表中查询数据。
现在让我们看一些与事务表相关的例子。
要查看事务表中的所有列，请执行以下操作:
SELECT *
FROM transaction;
假设我们只需要事务表中的特定列:
SELECT transaction_id, purchase_date, sales
FROM transaction;
2.明显的
DISTINCT用于查看一列中的唯一值。例如，假设我们希望看到交易的唯一日期:
SELECT DISTINCT purchase_date
FROM transaction;
3.在哪里
WHERE用于过滤符合特定条件的行。此外，它还经常与其他运算符如AND、OR、BETWEEN、IN、LIKE一起使用，将多个条件组合在一起。
以下是一些例子:
SELECT *
FROM transaction
WHERE purchase_date = '2021-10-15';
SELECT *
FROM transaction
WHERE purchase_date = '2021-10-15'
AND store_location = 'Melbourne CBD';
SELECT *
FROM transaction
WHERE purchase_date = '2021-10-15'
OR store_location = 'Melbourne CBD';
SELECT *
FROM transaction
WHERE store_location IN ('Richmond', 'Brunswick', 'Kew');
4.%通配符
在LIKE操作符中使用了%通配符来匹配字符串模式。
在我们研究这个通配符如何工作之前，让我们首先检查一下 customer profile 表。这张表告诉我们一个特定客户的生命阶段和保费状况。
SELECT *
FROM customers;
假设现在我们要过滤掉客户表中客户生命阶段以单词 Young 开始的行。
SELECT *
FROM customers
WHERE customer_lifestage LIKE 'Young%';
同样，如果我们想要查看客户生命阶段以单词 families 结束的行。
SELECT *
FROM customers
WHERE customer_lifestage LIKE '%families';
正如您所看到的，SQL 提供了一种快速而直接的方法来匹配字符串模式，这在许多情况下过滤掉行时非常方便。
5.以…排序
ORDER BY可用于按字母顺序或数字顺序对特定列的查询结果进行排序。可以有两种排序方式:DESC降序，或者ASC升序。尽管您会注意到大多数人不会在他们的查询中写ASC,因为 SQL 默认设置了这一点。
为了演示这一点，假设我们希望根据销售额对交易进行升序排序。
SELECT store_location, sales
FROM transaction
ORDER BY sales;
或者，我们也可以根据销售额对交易进行降序排序。
SELECT store_location, sales
FROM transaction
ORDER BY sales DESC;
6.如同
AS使我们能够重命名列或表。请注意，这不会直接改变其原始列或表中的名称。
给定的查询将从事务表中返回日期列，其中购买日期被重命名为日期。
SELECT purchase_date as date
FROM transaction;
7.CASE WHEN，ELSE and THEN
如果您以前使用过任何其他编程语言，这与 if-else 语句非常相似。
实际上，用简单的英语来说，这个命令听起来有点像这样:如果满足一个条件，就这样做，否则就那样做。
让我们看一个例子来巩固这个想法。
假设我们想要创建一个新列，告诉我们特定交易的销售额是否超过 20 美元。
SELECT transaction_id, sales,
CASE WHEN sales < 20 THEN 'Sales amount is less than $20'
ELSE 'Sales amount is greater than $20' END AS sales_threshold
FROM transaction;
8.分组依据和聚合函数
GROUP BY将根据相同的值对数据进行分组。它经常与聚合函数一起使用，以总结特定数据组的属性。
另一方面，聚合函数对一系列值执行计算，并返回单个值。聚合函数的一些示例包括:
COUNT:返回总行数SUM:返回所有值的总和MAX:返回最大值MIN:返回最小值AVG:返回平均值
现在让我们来看一些例子。
假设我们想知道事务数据集中的行数。
SELECT COUNT(*)
FROM transaction;
交易数据集中最高销售额是多少？
SELECT MAX(sales) as max_sales
FROM transaction;
最后，如果我们想知道每天的总销售额，四舍五入到最接近的美元，该怎么办？
SELECT purchase_date, ROUND(SUM(sales)) as total_sales
FROM transaction
GROUP BY purchase_date;
9.加入
在我们讨论连接的概念之前，我认为首先区分主键和外键是很重要的。
在关系数据库中，主键用于唯一标识表中的每一行。例如，事务表的主键是 transaction_id 列，而客户概要表的主键是 customer_id 列。
另一方面，外键提供了两个表中数据之间的链接。具体来说，一个表中的外键将链接到另一个表中的主键。例如， customer_id 列是事务表中的外键，但它是客户概要表中的主键。
给定主键和外键之间的关系，我们可以在这个特定场景中执行LEFT JOIN。
SQL 中还有其他类型的连接，比如INNER JOIN、RIGHT JOIN和FULL JOIN，这里就不赘述了。如果你有兴趣了解更多，查看这篇博文了解更多细节。
现在，假设我们想要在基于 customer_id 列的事务表上执行一个LEFT JOIN。
SELECT a.*, b.customer_lifestage, b.customer_premium
FROM transaction AS a
LEFT JOIN customers AS b
ON a.customer_id = b.customer_id;
在我们执行了LEFT JOIN之后，总是检查行数也是一个很好的实践，以确保新表与连接之前的左表具有相同的行数，在本例中左表是事务表。
10.联盟
最后但同样重要的是，UNION用于组合来自多个SELECT语句的查询结果。请注意，您希望联合的表必须具有相同的列数，同样重要的是，这些列必须是相同的数据类型。
我不得不承认，我在这个练习中放在一起的两个表可能都不能最好地说明UNION的威力，但是，为了完整起见，我将在这里演示一下。
假设我们想要将来自事务表的 customer_id 列和 quantity_purchased 列联合起来。
SELECT customer_id AS sample_union
FROM transaction
UNION
SELECT quantity_purchased FROM transaction;
至此，我们总结了开始使用 SQL 时需要的 10 个最重要的 SQL 命令。
我希望，通过这篇博文，你已经更好地理解了什么是 SQL，以及它在数据科学分析中的重要性，但更重要的是，认识到一旦你掌握了基础知识，学习起来实际上相对容易。
对于任何有抱负的数据分析师或数据科学家来说，这绝对是您应该考虑添加到您的工具包中的技能之一，因为 SQL 已经存在。
不知道接下来要读什么？这里有一些建议。
2022 年你应该知道的 10 个最实用的数据科学技能
实际上能让你就业的技能
介绍
许多“如何进行数据科学”的课程和文章，包括我自己的，倾向于强调基本技能，如统计、数学和编程。然而，最近，我通过自己的经历注意到，这些基本技能可能很难转化为让你能够就业的实用技能。
因此，我想创建一个独特的实用技能列表，让你有工作能力。
我谈到的前四项技能对于任何数据科学家来说都是至关重要的，不管你专攻什么。以下技能(5-10)都是重要的技能，但是会根据你的专业不同而有所不同。
例如，如果你最有统计学基础，你可能会花更多的时间在推断统计学上。相反，如果你对文本分析更感兴趣，你可能会花更多的时间学习 NLP，或者如果你对决策科学感兴趣，你可能会专注于解释性建模。你明白了。
话虽如此，让我们深入了解我认为最实用的 10 项数据科学技能:
1.编写 SQL 查询和构建数据管道
学习如何编写健壮的 SQL 查询，并在像 Airflow 这样的工作流管理平台上调度它们，会让你成为一名非常受欢迎的数据科学家，这就是为什么它是第一点。
为什么？原因有很多:
- 灵活性:公司喜欢数据科学家，他们能做的不仅仅是数据建模。公司喜欢全栈数据科学家。如果您能够介入并帮助构建核心数据管道，您将能够改进收集的洞察力，构建更强大的报告，并最终使每个人的生活更轻松。
- **独立性:**有些情况下，您需要一个不存在的模型或数据科学项目的表或视图。能够为您的项目编写健壮的管道，而不是依赖数据分析师或数据工程师，这将节省您的时间，并使您更有价值。
因此，作为一名数据科学家，你必须精通 SQL。没有例外。
资源
https://mode.com/sql-tutorial/
2.数据争论/功能工程
无论您是在构建模型、探索要构建的新功能，还是进行深度探索，您都需要知道如何处理数据。
数据争论意味着将你的数据从一种格式转换成另一种格式。
特征工程是数据争论的一种形式，但特指从原始数据中提取特征。
无论您是使用 Python 还是 SQL，如何操作数据并不重要，但是您应该能够以自己喜欢的方式操作数据(当然是在可能的范围内)。
资源
3.版本控制
当我说“版本控制”时，我特别指的是 GitHub 和 Git 。Git 是世界上使用的主要版本控制系统，GitHub 本质上是一个基于云的文件和文件夹存储库。
虽然一开始 Git 不是最直观的学习技能，但对于几乎每一个与编码相关的角色来说，了解它都是必不可少的。为什么？
- 它允许您与其他人并行协作并处理项目
- 它跟踪你代码的所有版本(以防你需要恢复到旧版本)
花时间学习 Git。它会带你走得很远！
资源
4.讲故事(即交流)
建立一个视觉上令人惊叹的仪表板或一个精确度超过 95%的复杂模型是一回事。但是如果你不能把你的项目的价值传达给其他人，你就不会得到你应得的认可，最终，你不会在你的职业生涯中取得你应该取得的成功。
讲故事指的是你“如何”传达你的见解和模型。从概念上讲，如果你考虑一本图画书，洞察力/模型就是图片,“讲故事”指的是连接所有图片的叙述。
在科技界，讲故事和交流是被严重低估的技能。从我的职业生涯来看，这种技能是初级、高级和经理的区别。
资源
5.回归/分类
建立回归和分类模型，即预测模型，不是你将总是在做的事情，但如果你是一名数据科学家，雇主会希望你知道这一点。
即使这不是你经常会做的事情，这也是你必须擅长的事情，因为你希望能够构建高性能的模型。举个例子，在我的职业生涯中，到目前为止，我只生产了两个机器学习模型，但它们是对业务有重大影响的关键任务模型。
因此，您应该对数据准备技术、增强算法、超参数调优和模型评估指标有很好的理解。
资源
6.解释性模型
您可以构建两种类型的模型。一种是预测模型，它根据一些输入变量来猜测结果。另一个是解释模型，它不是用来做预测的，而是用来更好地理解输入变量和输出变量之间的关系。
解释性模型通常是使用回归模型创建的。这是因为它们在理解变量之间的关系时提供了大量有用的统计数据。
解释性模型被难以置信地低估和有用，如果你想进入决策科学领域，它是必不可少的。
资源
7.A/B 测试(实验)
A/B 测试是一种实验形式，你可以根据给定的标准比较两个不同的组，看哪一组表现更好。
A/B 测试可以说是企业界最实用、最广泛使用的统计概念。为什么？A/B 测试允许您将 100 或 1000 个小的改进组合起来，随着时间的推移，会产生重大的变化和改进。
如果你对数据科学的统计方面感兴趣，A/B 测试对于理解和学习是必不可少的。
资源
8.使聚集
就我个人而言，我在职业生涯中没有使用过集群，但它是数据科学的一个核心领域，每个人至少应该熟悉它。
集群很有用，原因有很多。您可以找到不同的客户群，可以使用聚类来标记未标记的数据，甚至可以使用聚类来找到模型的分界点。
下面是一些资源，介绍了您应该知道的最重要的集群技术。
资源
[## 数据科学家需要知道的 5 种聚类算法
towardsdatascience.com](/the-5-clustering-algorithms-data-scientists-need-to-know-a36d136ef68) https://machinelearningmastery.com/clustering-algorithms-with-python/
9.建议
虽然我还没有建立推荐系统，但这是数据科学中最实际的应用之一。推荐系统是如此强大，因为它们有能力推动收入和利润。事实上，亚马逊声称在 2019 年由于他们的推荐系统，他们的销售额提高了 29%。
因此，如果你曾经在一家公司工作，在那里用户必须做出选择，而有很多选项可以选择，推荐系统可能是一个值得探索的有用应用。
资源
10.自然语言处理
NLP，或自然语言处理，是人工智能的一个分支，专注于文本和语音。与机器学习不同，我要说 NLP 远未成熟，这就是它如此有趣的原因。
NLP 有很多用例…
- 它可用于情感分析，了解人们对企业或企业产品的感受。
- 它可以通过区分正面和负面评论来监控公司的社交媒体。
- NLP 是构建聊天机器人和虚拟助手的核心
- NLP 也用于文本提取(筛选文档)
总的来说，NLP 在数据科学领域是一个非常有趣和有用的领域。
资源
https://www.projectpro.io/article/10-nlp-techniques-every-data-scientist-should-know/415
感谢阅读！
我希望这有助于指导你的学习，给你来年一些方向。有很多东西需要学习，所以我肯定会选择一些你听起来最感兴趣的技能，并从那里开始。
请记住，这更多的是一篇有轶事经验支持的自以为是的文章，所以从这篇文章中获取你想要的。但一如既往，我祝你学习一切顺利！
不确定接下来要读什么？我为你挑选了另一篇文章:
[## 六分钟内解释所有概率分布
towardsdatascience.com](/all-probability-distributions-explained-in-six-minutes-fe57b1d49600)
又一个！
特伦斯·申
熊猫中最有用的 10 个字符串函数
这些简单的熊猫函数使字符串处理变得容易
简介
如果您一直在使用 python 中的 pandas 库，您可能已经注意到许多数据是以文本形式出现的，而不是像一些人想象的那样是纯数字。
这意味着需要清理和预处理字符串，以便它可以被分析、被算法使用或向公众显示。幸运的是，熊猫图书馆有自己的字符串处理部分。
在本文中，我们将带您浏览 pandas 库的这一部分，并向您展示最有用的 pandas 字符串处理函数。您将学习如何使用:
- 上部()
- 下部()
- isupper()
- 较慢()
- isnumeric()
- 替换()
- 拆分()
- 包含()
- 查找()
- findall()
准备好了吗？
让我们开始吧。
代码设置
为了演示我们的第一个函数是如何工作的，我们应该创建一个我们将要使用的 pandas 数据框。您可以使用下面的代码来做到这一点:
import pandas as pd
client_dictionary = {'name': ['Michael Smith', 'Ana Kors', 'Sean Bill', 'Carl Jonson', 'Bob Evan'],
'grade': [['A', 'A'], ['C'], ['A', 'C', 'B'], [], ['F']],
'age': ['19', '19', '17', '18', '-'],
'group': ['class 1', 'class 2', 'class 2', 'class 1', 'class 2'],
'suspended': [True, False, True, False, True]
}
df = pd.DataFrame(client_dictionary)
df
这样一来，你就创建了一个包含五列的数据框:姓名、年级、年龄、组别、和暂停。我们将关注的列是由字符串值表示的姓名、年龄和组。
1。上()
我们将讨论的第一个函数将一个字符串中的所有字母转换成大写。我们可以使用下面的代码将它应用到 name 列。
df.name.str.upper()
正如你所看到的，名字中的所有字母都被改成了大写。
注意用于转换字符串的代码的语法。你需要先打电话。请在调用 upper()函数之前调用“str”。的’。“str”将 series 对象转换为可以执行实际字符串操作的字符串形式。
在列上执行的所有字符串操作函数都需要这样做。
2。lower()
Lower()函数的工作方式与 upper()函数类似，但它的作用正好相反，它降低了字符串中的所有字符。在这里你可以看到在名字栏调用它的结果。
df.name.str.lower()
3。isupper()
在*‘之后，可以用与 upper()或 lower()相同的方式调用该函数。str’* 列上。它将检查一列中的每个字符串条目，如果它的所有字符都是大写的。再叫上名栏吧。
df.name.str.isupper()
如您所见，这会返回一个包含所有假值的序列。这是有意义的，因为 name 列中的条目只有名字和姓氏的首字母大写。
要查看不同的行为，请尝试以下代码:
df.name.str.upper().str.isupper()
正如您现在看到的，函数 isupper()现在返回一个只有真值的序列。这是因为我们在事先用 upper()函数大写的名称列上调用了它。
4。islower()
这个函数的工作原理与 isupper()相同，但是它检查是否所有字符都是小写的。
您可以看到，当在 name 列上调用时，它将返回一个包含所有 Flase 值的序列。
df.name.str.islower()
5。isnumeric()
这个函数检查字符串中的字符是否实际上是数字。它们都必须是数字，isnumeric()才能返回 True。
在我们的数据框中，我们有用一些字符串填充的年龄列。让我们调用年龄列的 isnumeric()函数。
df.age.str.isnumeric()
正如你所看到的，我们得到了一系列真值，除了最后一项是假的。如果您没有记错，数据框中最初的年龄栏除了最后一项是’-'(破折号)之外，其他都是数字。
6。replace()
另一个非常有用的函数是 replace()。它可以用来替换字符串的一部分与另一个。让我们演示一下如何在组列中使用它。如果你还记得组列由‘1 类’和‘2 类’条目组成。
df.group.str.replace('class ', '')
在上面的代码中，我们用两个参数调用 replace()函数。第一个参数是需要替换的字符串(在我们的例子中是“class”)，第二个参数是我们想要替换的内容(在我们的例子中是一个空字符串)。对组列执行此操作的结果是我们得到一个只有数字的序列，(‘1’和‘2’)。
注意，replace 也可以和正则表达式一起使用。我们上面所做的(删除“class”部分)可以通过以下方式使用正则表达式来完成:
df.group.str.replace(r'[a-z]+ ', '')
在本教程中，我们不打算详细介绍 python 中的正则表达式，但是上面的代码会用空字符串替换每个字母数字单词后面的空格。
使用 replace()还可以使用 case 参数来设置匹配是否区分大小写。
7。split()
函数的作用是:将一个字符串分割成所需的字符。如果你有一个句子和一个单词列表，这将非常有用。您可以通过在空白位置(“”)拆分字符串来实现这一点。
在我们的例子中，我们可能希望获得人名和姓氏作为单独的字符串。请注意，现在它们作为一个字符串列在*‘name’*列中。这将通过以下方式完成:
df.name.str.split()
注意，在这种情况下，split 甚至不需要参数。默认行为是在空白区域拆分。如果你想在别的地方拆分字符串，你必须把它传递给 split 函数。例如，下面的代码演示了在字符“a”上拆分同一列。
df.name.str.split('a')
8。包含()
Contains()函数可以检查字符串是否包含特定的子串。该函数与 replace()非常相似，但它不替换字符串本身，而是返回布尔值 True 或 False。
让我们通过在组列上调用该函数来演示该函数是如何工作的，以便找出字符串是否包含数字‘1’:
df.group.str.contains('1')
如你所见，结果是一系列的布尔。
类似于 replace()的 Contains()也可以与 case 参数一起使用，使其区分大小写或不区分大小写。
它也可以与正则表达式一起使用。下面是一个检查字符串在组列中是否有数字字符的例子:
df.group.str.contains(r'[0-9]')
如您所见，结果是一个只有真值的 Series 对象。这是正确的，因为组列包含了字符串中含有 1 或 2 的条目。
9。find()
Find()是另一个在清理字符串数据时非常方便的函数。这个函数将返回给定子串在字符串中的位置索引。
用一个例子更容易理解。让我们尝试使用 name 列来找出它的功能。我们将在字符串中搜索字母“s”。
df.name.str.find('s')
如果您不记得名称列，这是一个原始数据框。
如你所见，索引 1 处的条目(Ana Kors)的第 7 个字符是“s”。此外，索引 3 处的条目(Carl Jonson)的第 8 个字符是“s”。其余条目的结果是’-1 ‘，因为它们根本不包含’ s '字符。
请注意，如果找到了多个“s”字符，find()将返回第一个字符的索引。
10。findall()
与 find()类似，Findall()将在字符串中搜索现有的子字符串，但它将返回匹配子字符串的列表，而不是一个索引。
同样，最好使用真实的例子。让我们在 name 列中搜索‘an’子字符串。
df.name.str.findall('an')
我们可以看到在第 1 行和第 4 行出现了一次“an”。
findall()函数的默认行为是不区分大小写的。如果您想忽略这种情况，您可以使用 flags 参数并导入 re 模块。
import re
df.name.str.findall('an', flags=re.IGNORECASE)
正如您现在看到的，索引 1 处的条目也返回‘An’。
总结
这篇文章介绍了我最喜欢的 pandas 模块中的字符串处理函数，你做到了！恭喜你。
我希望你现在能够使用本教程中的函数来清理你自己的数据集。
编码快乐！
原载于 about datablog . com:2021 年 5 月 31 日熊猫 中最有用的 10 个字符串函数。
PS:我正在 Medium 和aboutdatablog.com上撰写以简单易懂的方式解释基本数据科学概念的文章。你可以订阅我的 邮件列表 在我每次写新文章的时候得到通知。如果你还不是中等会员，你可以在这里加入https://medium.com/@konkiewicz.m/membership。
下面还有一些你可能喜欢的帖子
* </9-things-you-did-not-know-about-jupyter-notebook-d0d995a8efb3> *
数据科学的 10 个必知 Python 主题
熊猫或 Matplotlib 没有教你的
纳文·拉伊在 Unsplash 上拍摄的照片
Python 正在主宰数据科学生态系统。我认为这种优势的两大原因是相对容易学习和丰富的数据科学库选择。
Python 是一种通用语言，所以它不仅仅用于数据科学。Web 开发、移动应用程序和游戏开发是 Python 的一些用例。
如果您仅将 Python 用于与数据科学相关的任务，您不必是 Python 专家。但是，有一些核心概念和特性，我认为你必须具备。
我们在本文中讨论的内容不是特定于库的。它们可以被认为是数据科学的基础 Python。即使你只是使用 Pandas、Matplotlib 和 Scikit-learn，你也需要对 Python 基础有一个全面的了解。这些库假设您熟悉 Python 基础知识。
我将用几个例子简要解释每个主题，并提供一个链接，链接到大多数主题的详细文章。
1.功能
函数是 Python 中的构建块。它们接受零个或多个参数并返回值。我们使用 def 关键字创建一个函数。
这是一个简单的将两个数相乘的函数。
def multiply(a, b):
return a * bmultiply(5, 4)
20
这是另一个基于单词长度评估单词的例子。
def is_long(word):
if len(word) > 8:
return f"{word} is a long word."is_long("artificial")
'artificial is a long word.'
函数应该完成一个单一的任务。创建一个执行一系列任务的函数违背了使用函数的目的。
我们还应该为函数指定描述性的名称，这样我们就可以在不看代码的情况下知道它在做什么。
2.位置和关键字参数
当我们定义一个函数时，我们指定它的参数。当调用一个函数时，必须向它提供所需参数的值。参数的值也称为自变量。
考虑上一步中创建的乘法函数。它有两个参数，所以我们在调用函数时提供这些参数的值。
- 位置参数仅由名称声明。
- 关键字参数由名称和默认值声明。
调用函数时，必须给出位置参数的值。否则，我们会得到一个错误。如果我们没有为关键字参数指定值，它将采用默认值。
让我们用关键字参数重新定义乘法函数，这样我们就可以看到不同之处。
def multiply(a=1, b=1):
return a * bprint(multiply(5, 4))
20print(multiply())
1
3.*args 和**kwargs
函数是 Python 中的构建块。它们接受零个或多个参数并返回值。就参数如何传递给函数而言，Python 相当灵活。*args 和**kwargs 使处理参数变得更加容易和简洁。
- *args 允许函数接受任意数量的位置参数。
这里有一个简单的例子:
def addition(*args):
result = 0
for i in args:
result += i
return resultprint(addition(1,4))
5print(addition(1,7,3))
11
- **kwargs 允许函数接受任意数量的关键字参数。
默认情况下，kwargs 是一个空字典。每个未定义的关键字参数都作为键值对存储在kwargs 字典中。
这里有一个简单的例子:
def arg_printer(a, b, option=True, **kwargs):
print(a, b)
print(option)
print(kwargs)arg_printer(3, 4, param1=5, param2=6)
3 4
True
{'param1': 5, 'param2': 6}
</10-examples-to-master-args-and-kwargs-in-python-6f1e8cc30749>
4.班级
面向对象编程(OOP)范式是围绕拥有属于特定类型的对象的思想而构建的。在某种意义上，类型是向我们解释对象的东西。
Python 中的一切都是整数、列表、字典、函数等类型的对象。我们使用类来定义对象的类型。
类拥有以下信息:
- 数据属性:创建一个类的实例需要什么
- 方法(即过程属性):我们如何与类的实例交互。
5.列表
List 是 Python 中内置的数据结构。它表示为方括号中的数据点集合。列表可用于存储任何数据类型或不同数据类型的混合。
列表是可变的，这也是它们被广泛使用的原因之一。因此，我们可以删除和添加项目。也可以更新列表中的项目。
下面是一些如何创建和修改列表的例子。
words = ['data','science'] #create a listprint(words[0]) #access an item
'data'words.append('machine') #add an itemprint(len(words)) #length of list
3print(words)
['data', 'science', 'machine']
</11-must-know-operations-to-master-python-lists-f03c71b6bbb6>
6.列表理解
列表理解基本上是基于列表、元组、集合等其他可迭代对象创建列表。它还可以被描述为用更简单、更吸引人的语法来表示 for 和 if 循环。列表理解相对来说比循环要快。
(图片由作者提供)
下面是一个简单的列表理解，它根据给定的条件从另一个列表创建一个列表。
a = [4,6,7,3,2]b = [x for x in a if x > 5]
b
[6, 7]
下面的列表理解将一个函数应用于另一个列表中的项目。
words = ['data','science','machine','learning']b = [len(word) for word in words]
b
[4, 7, 7, 8]
</11-examples-to-master-python-list-comprehensions-33c681b56212>
7.字典
Dictionary 是一个无序的键值对集合。每个条目都有一个键和值。字典可以被认为是一个有特殊索引的列表。
这些键必须是唯一且不可变的。所以我们可以使用字符串、数字(int 或 float)或元组作为键。值可以是任何类型。
考虑这样一种情况，我们需要存储学生的成绩。我们可以将它们存储在字典或列表中。
(图片由作者提供)
创建字典的一种方法是用花括号写键值对。
grades = {'John':'A', 'Emily':'A+', 'Betty':'B', 'Mike':'C', 'Ashley':'A'}
我们可以使用它的键来访问字典中的值。
grades['John']
'A'grades.get('Betty')
'B'
</12-examples-to-master-python-dictionaries-5a8bcd688c6d>
8.设置
一个集合是不同可散列对象的无序集合。这是官方 Python 文档中对 set 的定义。让我们打开它。
- 无序集合:它包含零个或多个元素。集合中的元素没有关联的顺序。因此，它不像我们处理列表那样支持索引或切片。
- 独特的可散列对象:一个集合包含独特的元素。hashable 的意思是不可变的。虽然集合是可变的，但是集合的元素必须是不可变的。
我们可以通过将逗号分隔的对象放在花括号中来创建一个集合。
a = {1, 4, 'foo'}print(type(a))
<class 'set'>
集合不包含重复的元素，因此即使我们尝试多次添加相同的元素，结果集合也将包含唯一的元素。
a = {1, 4, 'foo', 4, 'foo'}print(a)
{1, 4, 'foo'}
</12-examples-to-master-python-sets-71802ea56de3>
9.元组
元组是由逗号分隔并包含在括号中的值的集合。与列表不同，元组是不可变的。不变性可以被认为是元组的识别特征。
元组由括号中的值组成，用逗号分隔。
a = (3, 4)print(type(a))
<class 'tuple'>
我们也可以在不使用括号的情况下创建元组。由逗号分隔的值序列将创建一个元组。
a = 3, 4, 5, 6print(type(a))
<class 'tuple'>
元组最常见的一个用例是使用返回多个值的函数。
import numpy as npdef count_sum(arr):
count = len(arr)
sum = arr.sum()
return count, sumarr = np.random.randint(10, size=8)
a = count_sum(arr)print(a)
(8, 39)print(type(a))
<class 'tuple'>
</10-examples-to-master-python-tuples-6c606ed42b96>
10.λ表达式
λ表达式是函数的特殊形式。一般来说，lambda 表达式是不带名字的。
考虑以下返回给定数字的平方的函数。
def square(x):
return x**2
等效的λ表达式为:
lambda x: x ** 2
考虑一个需要做一次或很少几次的操作。此外，我们对这个操作进行了许多修改，与原来的略有不同。在这种情况下，为每个操作定义一个单独的函数是不理想的。相反，lambda 表达式提供了一种更有效的方式来完成任务。
结论
我们已经讨论了 Python 的一些关键概念和主题。大多数数据科学相关任务都是通过第三方库和框架完成的，如 Pandas、Matplotlib、Scikit-learn、TensorFlow 等等。
然而，我们应该对 Python 的基本操作和概念有一个全面的理解，以便有效地使用这样的库。它们假设您熟悉 Python 的基础知识。
感谢您的阅读。如果您有任何反馈，请告诉我。
作为数据科学家，您需要订阅的 10 份简讯
直接通过电子邮件获取有用的知识。
布雷特·乔丹在 Unsplash 上的照片
在科技领域，我们总是在学习。有时候感觉我们永远不会到达我们领域的尽头，这是真的。技术发展和进步非常快。每天都在开发新的进步和工具。作为一名开发人员/数据科学家，我们日常工作的一个重要部分就是跟上所有的新闻，始终保持最新状态。
但是，通常，努力跟上技术世界的发展，磨练自己的技能，做好自己的日常工作并不容易。因此，我们倾向于优先考虑工作、放松、花时间与家人和朋友一起浏览网页、寻找最新消息和学习新东西。这个选择是正确的，我也几乎一直在做这个选择。
这就是为什么我最喜欢的东西之一是时事通讯。我不需要每天去查找信息；我只需要定期检查我的电子邮件，以获得我需要的关于这个领域的所有信息，也许还能在旅途中学到一些新东西。如果我想特别谈论数据科学，那么试图跟上该领域的各个方面可能有些不可能。
</9-discord-servers-for-math-python-and-data-science-you-need-to-join-today-34214b93d6b8> [## 9 台用于数学、Python 和数据科学的 Discord 服务器，您需要立即加入
towardsdatascience.com](/9-discord-servers-for-math-python-and-data-science-you-need-to-join-today-34214b93d6b8)
在这篇文章中，我将与你分享我最喜欢的 10 个数据科学相关的时事通讯。时事通讯可以跟上最新的数据科学研究、数据科学工具、新的可视化工具、可视化灵感，甚至可以磨练和提高您的编程、版本控制和 Python 技能。
那么，我们开始吧。
№1:黑客之夜
让我们从一份面向所有阶段的开发人员的时事通讯开始吧，不管他们的专业是什么， HackerNoon 时事通讯。这是一份旨在增加专业软件开发知识和创新传播的周刊。这份时事通讯包含各种信息，从工程师的故事到新工具和详细的教程。此外，HackerNoon 提供了不同的标签，您可以根据自己的兴趣单独订阅。
№2: Git Rev 新闻
接下来，我们有 Git Rev News ，这是一份由 Git 志愿者撰写的时事通讯，旨在帮助开发人员磨练他们的版本控制技能。这篇时事通讯的主要目标是帮助人们更多地了解 Git，对它产生兴趣，并希望参与其中。它还旨在展示 Git 生态系统和社区。有时时事通讯包括职位空缺和一些与 Git 相关的自由职业者的工作。
№3:更好的开发者
Better Developers 简讯是我最喜欢的简讯之一，由最优秀的 Python 培训师之一鲁文·m·勒纳撰写和维护。鲁文有着惊人的教学风格；他能用通俗易懂的术语解释复杂的概念。所以，如果你是 Python 的新手，或者想提高你的 Python 技能，看看这篇令人惊叹的每周时事通讯就知道了。
</6-data-science-slack-workshops-you-need-to-join-b0c00952105d>
№4:讲故事的数据
数据可视化是数据科学的一个重要方面。我认为这是最重要的方面。如果你不能展示你的发现，那么人们——你的老板、上级或客户——可能不会意识到你付出了多少努力，甚至不知道你是否应用了正确的算法。了解如何使用可视化来更好地展示您的发现并帮助您探索数据对于每个数据科学家来说都是至关重要的。讲故事数据简讯将帮助你创造更好的可视化效果。
№5:流动数据
另一个很棒的数据可视化时事通讯是 FlowingData 。这份时事通讯关注图表、它们的类型、何时使用它们，以及如何使它们更好、更具描述性和更有效。新闻简报提供了一些数据可视化工具工作的重点介绍和可视化指南的组合，适用于初学者和寻求提高可视化技能的人。
№6:今日数据
我们的第三份也是最后一份数据可视化简讯是 DataVizToday 。本期时事通讯由数据即设计师阿利·托班主持。她是一个伟大的可视化者，旨在分享她在工作中发现的可视化技巧、诀窍、最新工具和方法。因此，如果你是一名数据科学家、分析师、记者或设计师，并希望提高你的可视化和创造力，这份简讯是为你准备的。
</6-data-science-podcasts-to-learn-something-new-on-the-go-aa9f7628d951>
第七名:玛奇纳数据
数据科学领域最著名的时事通讯之一是数据玛奇纳。数据玛奇纳解决了许多数据科学主题，从专注于特殊的编程语言，如 Python 和 R，到算法和更高级的主题，如区块链和大数据。玛奇纳数据是一份每两周发送一次的时事通讯，它通常充满了有用的信息。
№8:奥莱利数据/编程
O’Reilly 是科技领域所有专业的知名出版商之一。O’Reilly 提供 4 种不同的每周简讯，关注编程、数据科学、经济和基础设施，您可以单独订阅或一次订阅。但是，对于这篇文章，我想把重点放在编程和数据科学上。因此，通过关注这些时事通讯，了解更多关于编程范例和数据科学领域的热点。
№9: KDnuggets
谈到数据科学时事通讯，我不能不提到 KDnuggets 时事通讯。KDnuggets 时事通讯拥有超过 6 万名订阅者，它关注所有对任何数据科学家都很重要的事情。从研究新闻到讨论数据科学主题的最新会议、研讨会、活动和网络研讨会。不仅如此，它还包括职业建议，面试准备，有时还有职位空缺。
№10:数据药剂
最后但同样重要的是数据灵丹妙药简讯。这份每周 30，000 多份的订阅者简讯涵盖了广泛的主题，涉及见解、工具、技术、资源和数据可视化技巧。
最后的想法
作为数据科学家，我们总是在学习，总是在改进，总是在寻找新的技能、工具和算法来学习和实施。但是，不幸的是，我们经常被要求在完美地完成日常工作的同时不影响我们的个人生活。
我们可以通过订阅时事通讯和经常查看我的邮件来获取信息。时事通讯是新信息的重要来源，也可能是更新现有信息的一种方式。但是，有很多很多的时事通讯，订阅一大堆时事通讯也不是一个理想的情况。
然而，你不希望那天你的电子邮件被 100 封来自随机简讯的邮件攻击。但是，这并不意味着您可以订阅少量简讯来保持您的知识新鲜，并帮助您了解数据科学领域的最新动态。所以，我希望你能发现我推荐的一个或多个时事通讯是有帮助的，并决定订阅它们并从中获得新的知识。
每个数据科学家都应该知道的 10 个 NLP 术语
了解术语对于理解任何教程都是必不可少的。
由 Raphael Schaller 在 Unsplash 拍摄的照片
当你决定学习一项新技能时，通常会有许多挑战需要你去克服，直到你掌握了那项技能。你需要有一个坚实的想法，知道你需要做什么/学会掌握这个想法；你需要知道你可以使用什么资源，你需要能够区分好的和坏的资源，这样你就不会把时间浪费在错误的资源上。
也许你需要采取的最艰难的一步是学习技能的语言。如果我们确切地说自然语言处理(NLP)是你想要学习的新技能，那么在你开始浏览教程和视频之前，你需要学习这个领域的语言。
当开发人员和数据科学家编写关于特定主题的在线教程或创建视频时，总会有一个假设，如果你在这里(在教程或视频旁边)，那么你就知道发生了什么。因此，他们会使用技术术语，假设读者/观察者知道它们的意思。
如果你不知道这些术语的意思，阅读或观看这些教程可能会很麻烦。因为那样的话，你需要停下来，谷歌一下这个术语，然后回到教程。你可以想象，或者经历过，这并不理想。
我写这篇文章的目标是为所有对自然语言处理感兴趣的人提供一篇一站式文章，让他们了解该领域常用术语的含义。因为一旦你这样做了，你将能够阅读任何关于自然语言处理的文章或观看任何视频，而不会感到困惑。
让我们开始吧…
№1:文集
自然语言处理是一个独特的领域，它将计算机科学、数据科学和语言学结合在一起，使计算机能够理解和使用人类语言。从这个角度来看，文集——拉丁文中的正文——是一个用来指文本的正文的术语。单词的复数形式是语料库。
该文本可以包含一种或多种语言，并且可以是书面或口头语言的形式。语料库可以有特定的主题，也可以是概括的文本。无论哪种方式，语料库都用于统计语言分析和语言计算。
如果您正在使用 Python 来构建您的项目， Gensim 包可以帮助您从 Wiki 或基于 Wiki 的文章中构建语料库。
</6-web-scraping-tools-that-make-collecting-data-a-breeze-457c44e4411d>
2 号:词干
在自然语言处理中，词干提取是一种通过去除所有前缀、词缀和后缀来提取单词来源的技术。词干提取的主要目的是让算法能够从巨大的来源(如互联网或大数据)中寻找和提取有用的信息。
各种算法用于执行词干分析，包括:
- **查找表格。**包含所有单词的所有可能变体的形式(类似于字典)。
- **剥离后缀。**去掉单词的后缀，构建其词源形式。
- 随机建模。一种独特的算法理解后缀的语法规则，并利用它来提取新词的来源。
您可以通过使用 NLTK 包中的预定义方法在 Python 中执行词干提取。
№3:词汇化
虽然词干提取是提取单词来源的好方法，但有时去除修正不足以获得正确的单词来源。举个例子，如果我用词干分析器得到支付的起源，它会给我 pai 。这是不正确的。
词干分析器的缺点经常出现在处理不符合标准语法规则的不规则单词时。在这里，术语化可以派上用场。
词汇化是一个用来表达某事做得很好的词。这种情况指的是提取单词的原始形式——也就是词条。因此，在我们前面的例子中，lemmatizer 将根据单词在句子中的位置返回 pay 或payed。
NLTK 包还提供了可以用来提取单词的词条的方法。
图片由作者提供(使用 Canva 制作)
№4:标记化
在自然语言处理中，标记化是将句子砍成单个单词或标记的过程。在形成记号的过程中，标点符号或特殊字符通常被完全删除。
标记由特定的文本主体构成，用于统计分析和处理。值得一提的是，令牌不一定是一个单词；例如，“摇滚”，“3d 打印机”是令牌，它们是由多个单词构成的。
简而言之，标记化是一种用于简化语料库的技术，为下一阶段的处理做准备。
在 Python 中，NTLK 包提供了执行标记化的方法，比如 sent_tokenize 和 word_tokenize。此外，NLTK 为除英语之外的其他语言提供了标记器。
№5:词汇
当面对自然语言处理任务时，我们需要考虑的不仅仅是语言。我们需要考虑如何在特定的上下文中使用一些术语来表示特定的意思。例如，“混战线”、“踢球者”和“闪电战”是用来描述美式足球不同方面的术语。
在语言学和自然语言处理中，词汇是包括所有词汇实体的语言语法的一部分。词汇实体处理一个词在不同情况和环境下使用时的含义。
词汇对于从自然语言处理模型中获得更准确的结果是必不可少的。例如，在对一些推文进行情感分析时，了解推文周围的主题，描述事物的口语化方式可以在分析结果中产生很大的差异。
</6-nlp-techniques-every-data-scientist-should-know-7cdea012e5c3>
№6:单词嵌入
计算机不理解单词，所以如果我们想让它们分析并正确使用我们的语言，我们需要将它们呈现出来，让它们能够理解。此外，分析文本可能具有挑战性，而数字对于算法和计算机来说可能更容易。
在自然语言处理中，单词嵌入是一种用于将单词映射到实数值向量以供分析的技术。这些向量一旦形成，就可以用于训练模型、构建神经网络和使用深度学习技术。
可以使用各种算法来实现单词嵌入，主要有:
- 嵌入层。在神经网络前端实现的层，用于提取单词嵌入。在将语料库应用于该层之前，必须对其进行清理和准备。
- **Word2vec。**一种统计技术，它从语料库中有效地学习单词嵌入，从而有效地训练神经网络。
№7: N-grams
在文本分析任务中，n 元语法指的是将语料库分成 n 个单词的组块。这些词块通常是通过一次移动一个单词来构建的。当 n =1 时，我们使用术语单字码而不是 1 字码。在 n = 2 的情况下，我们称之为 bigams，当 n = 3 时，我们称之为 trigrams。
你可以用一个简单的等式计算出一个句子有多少克:
其中 x 是句子中的字数，n 是期望的克数。
在 Python 中，编写一个构造句子的 n 元语法的函数相对容易。但是，如果您不想自己实现，NTLK 和 textblob 包提供了一些方法，可以帮助您自动生成 n 元语法。
图片由作者提供(使用 Canva 制作)
№8:标准化
当我们出于任何目的想要分析文本时，如果我们使用的文本是标准格式的，那么分析过程会更加准确。将文本放入标准格式就是所谓的标准化。例如，如果我们在一个文本中搜索，如果整个文本是大写或小写会更好。
规范化通常在对文本和查询进行标记化之后进行。然后，我们可能有两个相似的短语，但不是 100%相同，例如 USA 和 U.S.A。但是，您希望您的模型将这两个术语匹配在一起，而不管微小的差异。
规范化文本对您的自然语言处理模型既有好的影响，也有不好的影响。一方面，规范化导致搜索任务中更好的匹配。另一方面，将所有内容都转换成小写或大写可能会影响整个应用程序的可靠性。
№9:命名实体识别(NER)
在任何自然语言处理任务中，我们经常被要求阅读、清理和分析一个巨大的语料库。这就是为什么这个列表中的大多数术语是可以使分析更容易和更有效的技术。
命名实体识别是另一种自然语言处理技术，它通过将不同的单词标记为预定义的类别，如人物、地点、时间、电子邮件等，来提取关于某些文本的更多信息。
图片由作者提供(使用 Canva 制作)
执行 NER 可以使对文本的进一步分析更加准确。您可以使用 Spacy 和 NLTK 之类的包在 Python 中执行 NER。
№10:词性标注
另一种有用的分析技术是识别特定文本或句子中的不同词类。词性标注产生元组列表；每个元组包含单词及其标签。标签是对单词词性的描述，是动词、名词、形容词等等。
在大多数应用程序中，我们最初使用一个默认的 tagger 来获得基本的 POS 标记，然后我们可以增强它。NLTK 包提供了一个默认的标记器，可以为您提供任何文本的基本标记。
图片由作者提供(使用 Canva 制作)
外卖食品
每个领域都有自己的一套术语，该领域的人们经常使用这些术语来描述特定的过程和步骤，以便于相互交流和有效地解释他们的工作。
有时这些术语是你以前可能遇到过的词，知道它们的大概意思。但是，对于特定领域，这种含义可能不是 100%准确的。其他时候，这些术语是一组放在一起指向有时新的词。
不管它们的来源如何，理解这些术语是理解该领域、阅读任何讨论该领域的资源并最终掌握该领域的必要步骤。
</7-tips-for-data-science-newbies-d95d979add54>
本文向您介绍了自然语言处理的基本术语，您可以在大多数描述任何领域方面的文章和视频中找到这些术语。希望了解这些术语的含义会让你更容易接触到资源，建立新的项目，在你的学习之旅中前进，并实现你的梦想职业。
原始数据科学的 10 大特性
用这 30 个伟大的数字技巧完善你的代数
(图片由作者提供)
介绍
除非你是数据科学的新手，或者以某种方式使用拨号连接并生活在装有过时软件的终端中，否则你很可能听说过 NumPy。NumPy 是 Python 编程语言中典型的数据科学包之一。简单地说，NumPy 是一个库，可以用来执行线性代数和算术。然而，由于该软件的用户肯定能够迭代，它做的还不止这些！
NumPy 是一个巨大的库，已经被构建和迭代。一件很棒的事情是，所有 Pythonic 数据科学生态系统，甚至数学生态系统都已经使用 NumPy 进行线性代数。一个很好的例子是像 SkLearn 这样的包，甚至更多；熊猫。对于许多科学程序员来说，NumPy for Python 的强大功能甚至可能会将他们引入这种语言。
虽然 NumPy 是一个很棒的库，但它也是广泛的，并且已经开发了多年！虽然这意味着 NumPy 是一项古老的技术，肯定可以用于生产，但这也意味着对于没有经验的数据科学家来说，NumPy 可能很难接近。此外，你可以用 NumPy 做很多非常有趣和棒的事情，这些事情往往被掩盖起来，或者并不经常被想到。这当然是有害的，但也是可以理解的错误。
也就是说，让一个庞大而多样的包变得更熟悉的最有效的方法就是探索它！NumPy 是一个可以花上几个小时进行讨论的库，但是今天我决定用 NumPy 模块带来一些我最喜欢的函数和技巧，并把它们展示出来，这样我们就可以更加熟悉 NumPy 了！
类型
NumPy 为 Python 编程语言中的表带来的最酷的属性之一是它对类型的处理。Python 中的类型可能很复杂，因为在这种语言中处理和使用某些数据类型的方式。虽然这些概念在普通 Pythonic 编程中很容易实现，但在处理大量数据时很快就会出现问题。
这就是 NumPy 的用武之地。NumPy 提供了细化的标量类型、新的类型层次结构和完全不同的类函数来帮助支持他们的方法。使用普通的 Pythonic 列表可能会很乏味，为了有效地使用模型，通常需要将它调整到不同的维度。NumPy 之所以伟大，是因为它在一个相对高级的接口下提供了所有这些类型，这个接口包含了线性代数的所有内容。
№1:内置标量类型
虽然 Python 可能有一些很好的数据类型，但这些类型通常很难用线性代数来处理。这是因为 Python 列表通常不用于矩阵乘法。幸运的是，有了 NumPy，我们有了一种新的数组类型，它支持科学程序员所期望的这种数学语法。
关于这些新的 NumPy 数组，一个非常棒的特性是标量类型。Python 只定义了一种类型的数据类，例如 int 或 str。这是一个很好的想法，因为对于不太复杂的应用程序(这正是使用 Python 的初衷)，您真的不需要担心计算机可能处理数据的所有不同方式。另一方面，对于科学计算，可能需要规范和更强制性的控制。
也就是说，NumPy 集成了这些新的标量类型，这些类型非常有用，可以用来存储 Python 的数据类型，具有更像 C 的控制。这些标量存在于类型层次结构中。例如，我们可以在给定的 NumPy 数组上运行 isinstance()函数，这将告诉我们该类型是否是 np.generic 的子类型，在本例中是层次结构的顶部。
import numpy as npval = np.array([5, 10, 15])
print(isinstance(val, np.generic))True
如果您想了解更多关于编程中的类型层次结构，我用 Julia 编程语言写了一篇文章，您可以在这里查看:
№2:屏蔽阵列
在许多情况下，数据集可能是不完整的，或者被坏数据污染。这些数据会破坏统计推断，因为不完整的观察值不是观察值。此外，这当然是机器学习模型的一个完全杀手。NumPy.ma 模块提供了一种快速、简单、方便的方法来解决科学计算中使用掩码数组的这些常见问题。
掩码数组是标准 NumPy 标量数组和掩码的组合。什么是口罩？掩码是表示是否满足条件的布尔类型列表。这意味着，通过在整个观察集上应用条件语句，可以快速有效地处理数据。例如，我们可以创建一个如下所示的数组:
**import** **numpy.ma** **as** **ma** x = np.array([1, 2, 3, -1, 5])
maskx = ma.masked_array(x, mask=[0, 0, 0, 1, 0])
№3:数据类型(数据类型)
虽然数据类型通常是大多数编程语言的属性，但 NumPy 因拥有库附带的更加精细的数据类型对象而获得了额外的荣誉。NumPy 有一个更好的、更专注于数据的方法来识别数据类型，与它们的 Python 等价物相比，这些各自的数据类型有不同的属性。同样的概念有许多不同的应用，包括 Pandas 库中 Pythonic 数据帧的突出特性。
此外，这个函数可以更时尚地用于 NumPy 标量数据类型。也就是说，在处理大型数据集时，该函数通常主要应用于处理各种数据类型，如果某些数据被读取为可能不期望的类型，该函数肯定会派上用场。NumPy 的伟大之处在于，它真正关心其生态系统中的类型，使用这些类型可以很快使它们在不同模块和目标的整个范围内变得非常有用。
№4:空
这种场景已经上演了多少次；您找到了一个很棒的数据集，兴奋地将数据拉入 Python，然后最终接触到一个巨大的失望——缺少值。缺失值是数据科学家或数据工程师最大的敌人，是坏数据或“脏”数据的明显标志。
虽然 Python 当然有工具来处理没有值的数据类型，但是 Python 本身带来的实现对于处理单一数据类型和对象要有用得多。也就是说，如果只给缺失数据分配了通用空值，那么很难对其进行排序。这个 NumPy 解决方案通过在熊猫图书馆的使用得到了进一步的认可。Pythonic 数据科学中检查空值最常见的语法是
df.isnull().sum()
这将给出给定数据帧中所有缺失值的总和。事实上，这是在 Python 中读入数据后最常运行的代码行之一，非常有价值，这肯定说明了 NumPy 模块的采用和可用性。我们还可以将它与掩码、循环和其他工具(如 Pandas 的 apply()函数)一起使用，只需一行代码就可以毫不费力地创建处理一维数据堆的调用。由于 Pandas 模块与 NumPy 紧密集成，我们甚至可以使用 fillna()函数轻松填充缺失的值！
*df = df.fillna(value=mean(df["X"]))*
如果您想为熊猫图书馆学习更多类似的技巧，我写了一篇文章，详细介绍了该图书馆能够做的 20 件令人兴奋的事情，任何有抱负的数据爱好者都可能会感兴趣:
</20-great-pandas-tricks-for-data-science-3a6daed71da0>
№5:真实
在科学计算的奇妙世界中，另一个非常常见的概念是实数和虚数之间的差异。NumPy 带来了对复杂类型的强大支持，即既有实数值又有虚数值的数字。这些在 vanilla Python 中是不支持的，这一添加在原本作为高级脚本接口的语言和科学计算之间建立了一座真正的桥梁。对于科学家来说，拥有虚拟的边界来浮动数据类型是一个重要的概念，NumPy 包含了真实的、虚拟的和复杂的数据类型，这使得 Python 编程语言总体上对科学观众更有吸引力。
真正的“类型”本质上只是一系列数据类型，它们符合数学中的现实维度。也就是说，实数数据类型的主要例子是整数和浮点数。幸运的是，使用 NumPy 我们可以快速地在数据维度之间切换，并通过使用 real()函数消除虚部。虽然这是一个函数，而不是一个类型，但我认为重要的是要包括实数类型仍然只是一个概念，因为 NumPy 能够处理具有虚拟和实数维度的复杂浮点。最棒的是，他们给了我们这个函数来快速将适当的数据类型转换为复杂的浮点型:
np.real(np.conjugate(1+2j))
功能
虽然 NumPy 的类型非常有价值、有组织并且非常有用，但是 NumPy 也有一些很好的全局函数来执行一些很好的数学运算。这些运算的范围从点积到复数的倒数。不用说，模块作用域中的函数更有条理，是函数调用，尽管通常可以在 np.array 类的子类中找到等价的函数。
№1: np.log()
NumPy 模块中的 log()函数是一个简单的函数，可以调用它来执行对数运算。这些对于创建数值算法非常有用，当与其他编程概念一起有效使用时，可以节省大量时间。对数是 NumPy 中的另一个特性，它为 Python 处理数值计算提供了更大的灵活性。这个 log()函数当然会使用所提供数据的自然对数。
np.log(x, 2)
№2: np.recipricol()
NumPy 模块中的 recipicol()函数是一个简单的单函数调用，可用于获取值、分数、矩阵和数组的 recipicol。虽然这可能不是 Numpy 提供的最有用的函数，但它肯定是一个很好的例子，说明了 NumPy 对线性代数的深入研究。
np.recipricol(2.)
№3: np.mod()
NumPy 模块引入 Python 的另一个非常重要的数学函数是 mod()函数。mod 函数将返回除法的元素余数。也就是说，通常需要两个矩阵、数组或向量来用函数进行除法运算。让我们试试这个:
x = [5,10,15,20]
x2 = [5,10,15,20]
np.mod(x, x2)
№4: np.convolve()
np.convolve()函数用于获得两个一维序列的离散线性卷积。这意味着传递的数组的形状必须是(-1，1)或(1，-1)。卷积是一个数学概念，作为数据科学家，我们可能都很熟悉。回顾一下，卷积是指两个函数共同创建一个新函数。这当然是指微分方程，通常是某些分布的累积函数。
这意味着该函数旨在制定一组新的线性数据，这些数据遵循这些数组分布的卷积。换句话说，这两个变量的和在多维意义上分布在卷积上。不用说，我们很熟悉机器学习中的卷积，并且经常使用它，即使这个函数对于普通用户来说从来没有派上用场，它仍然是一个很好的工具！
x = [5,10,15,20]
x2 = [5,10,15,20]
np.convolve(x, x2)
№5: np.conj()
如果你熟悉复数，那么你可能也熟悉复数的共轭概念。简单来说，一个复数的共轭就是虚维数的反转。这意味着为了计算共轭，复数的虚维度的符号被翻转。通常对于复数，我们可能会看到这样的情况:
5.5 + 0.2im
这个复数的共轭是
5.5 - 0.2im
奖金:nan_to_num()
nan_to_num()函数是 NumPy 模块中绝对被低估的数据科学资产。这个函数是做什么的？该函数接受缺失值或无穷大值，并将它们转换为数字。这对于有大量无效数据的数据集非常有用。缺失值被转换为零和具有大的有限值的无限值，或者由用户定义的值。
np.nan_to_num(np.inf)
结论
NumPy 无疑是一个非常棒的线性代数库。该模块使 Python 中的任何科学计算变得容易得多，如果不是这样，这种语言不太可能在科学计算领域被广泛采用。NumPy 最大的优点就是它的影响力。因为这个包很有影响力，所以维护得很好。此外，它还集成了整个 Python 工具生态系统。这意味着通用的 NumPy 函数可以在整个 Python 包中使用，大约有 250，000 个。对 NumPy 库的一个真正的赞美是，其他完全不同语言的生态系统也开始调整它们的语法，使之更像 NumPy，例如 C++的 XTensor，我写了一个简短的教程，你可以在这里查看:
NumPy 带来了许多对科学家来说非常有用的优秀类型和方法，这确实使它成为对整个社区有益的包。很容易理解为什么越来越多的科学家继续专门转向 Python 来使用这个模块，因为它可能是所有计算中如此高级的线性代数的最完善和精炼的解决方案之一！
我最喜欢的 10 个 Python 装饰者
Python 编程语言中更多优秀装饰者的概述。
介绍
如果说在计算领域有一件事真正让我着迷，那就是编程语言。我对编程语言很感兴趣，因为它们实际上只是硬件的抽象层。我们人类从这些抽象层中发现的与硬件交互的方式真的很神奇。我们想和非常人性化的东西一起工作:文字、关系和事物；我们在电脑里模拟了我们大脑的定义过程。虽然这与硬件编程类似，但我认为这些抽象层确实使语言变得有趣，因为有各种各样的方法来处理不同的场景和类型，看到人们提出的这种想法是非常有趣的。
每当我们谈论一种非常具有声明性的脚本语言——在这里是 Python——时，我认为这种魅力会变得更加强烈。像 Python 这样的语言的伟大之处在于它是声明性的，因为它是抽象的。这种语言非常容易使用，所有的底层硬件和内核调用都远离程序员。但是从底层发生的 push 和 pop 中抽象出这么多，看到如何操纵语法来处理这些类型真的很酷。
在上一篇文章中，我深入研究了 Python 中的多重调度。多重分派模块使用一个简单的装饰器将 Python 语言变成多重分派。如果你想了解更多，文章在这里:
顺便说一下，我喜欢多态性。
但是写了那篇文章，并对那个包进行了一些探索，确实让我的大脑再次开始关注装饰者——我想这是有充分理由的……装饰者很棒！它们在许多不同的场景中都非常有用，而且非常容易使用。我写的另一篇很棒的文章反映了这篇文章——可以被认为是某种类型的先驱，在这篇文章中，我详细介绍了我喜欢使用的 10 个很棒的 Python 装饰器，如果你也想看的话，这里有一个链接:
</10-fabulous-python-decorators-ab674a732871> [## 10 个神话般的 Python 装饰者
towardsdatascience.com](/10-fabulous-python-decorators-ab674a732871)
鉴于 Python decorators 令人敬畏的本质，以及它们的能力，我认为用一些新的难以置信的 decorator 来编写一个新的故事，以便在您的 Python 代码中使用，是非常合适的。其中很多都改变了 Python 的范式，并且真的可以让您的 Python 代码更上一层楼！这份名单上的装饰家不包括在最后一份里，所以如果你想加倍努力，你可以看看这两份名单，看看你的军火库里有没有一些非常理想的装饰家。此外，Github 上有一个笔记本，上面有我在本文中使用的所有代码和装饰器，链接如下:
https://github.com/emmettgb/Emmetts-DS-NoteBooks/blob/master/Python3/10 Python Decorators.ipynb
№1:多重分派:分派
毫无疑问，我刚刚写了一篇文章，介绍了多重调度模块及其功能。不用说，由于我倾向于大声地表达我的多重派遣观点和我的朱莉娅观点，如果有一件事我喜欢的话，那就是多重派遣。这似乎是一种非常自然的编程方式，不会真正妨碍到你。每当我写 Python 的时候，我经常错过这个非常 Julian 的编程概念，所以偶然发现这个包是一件非常高兴的事情。
在讨论如何使用这个装饰器之前，让我们先讨论一下多重分派是什么以及为什么。首先，多重分派是一个函数和类型系统，它允许方法按照它们的类型对应部分列出。通常，在面向对象的方法中，所有 Python 函数都将在 Python 类的范围内定义。这基本上就是面向对象编程的定义。然而，让 Python 成为一种更有用的语言的原因之一是，它不强迫人们使用这种范式。在 Pythonic 生态系统中，许多数据科学代码都非常有条理，在许多方面对类型的关注比第一次听说这种语言是“面向对象的”时所期望的要少得多。
我认为通过多重分派实现多态性确实可以将系统化带到下一个层次。正如我们将在我的例子中看到的，在一个类中也是如此。我之所以推荐在某些情况下使用这个装饰器，是因为它只是一个简单的调用，就可以从根本上改变代码，并产生一些非常棒的语法。让我们考虑下面的例子:
**from** multipledispatch **import** dispatchclass Pasta:
def __init__(self, width, height, classification):
self.width, self.height = width, height
self.classification = classification
def classify():
if self.width > 3 and height < 2:
self.classification = "Linguine"
elif self.width == self.height and self.width < 3:
self.classification = "Spaghetti"
elif width > 2 and height == 1:
self.classification = "Fettuccine"
else:
self.classification = "Dough"class Bread:
def __init__(self, width, height, classification):
self.width, self.height = width, height
self.classification = classification
def classify():
if self.width > 3 and height < 2:
self.classification = "Pizza Crust"
elif self.width == self.height and self.width < 3:
self.classification = "White bread"
elif width > 2 and height == 1:
self.classification = "Flatbread"
else:
self.classification = "Dough"class Roller:
def __init__(self):
pass
def roll_thinner(x : Pasta):
x.height -= 1
x.width += 1
x.classify()
def cut(x : Pasta):
x.width -= 1
x.classify()
def fold(x : Pasta):
x.width += 1
x.classify()
我们这里有三个班级。第一个对象是意大利面，它只是可以用我们的擀面杖(滚筒)擀出来的意大利面。)接下来是面包。面包和面食有许多相同的属性。然而，对于这个例子，我们在 bread 类中缺少了一样东西，唯一的问题是，如果我们包含了这个值，那么没有一个 Roller 函数会对 bread 起作用！在正常情况下，要么必须有专门处理这种类型的新函数，例如我们分别有 roll_thinnerbread()和 roll_thinnerpasta()，要么需要第二个擀面杖，我们只用于面包
class BreadRoller:
然而，有了多重分派，这些担心就可以消除了——我们可以使用多重分派来处理不同函数的不同类型。在这个例子中，我将只改变 Bread 类中的一个函数名。我将把 classify()函数的名称改为 bake()。还有我做的这个函数，它会用一些预设的“面团”设置为我们吐出一个新的对象:
def make_dough(pasta = False):
if pasta:
return(Pasta(10, 10, "Dough"))
else:
return(Bread(10, 10, "Dough"))
让我们赚些钱吧！
dough = make_dough()print(dough.classification)'Dough'
我们还会做一些面团:
pasta_dough = make_dough(pasta = True)
现在让我们把意大利面擀成一条美味的扁面条，和我们刚刚做好的比萨饼皮一起食用。
rollingpin = Roller()while pasta_dough.height >= 3:
rollingpin.roll_thinner(pasta_dough)while pasta_dough.width > 2:
rollingpin.cut(pasta_dough)print(pasta_dough.classification)Linguine
太好了！我们做了些扁面条！但是看着这一切分崩离析，因为我们的另一种类型有一个稍微不同的结构:
rollingpin.roll_thinner(dough)---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-132-b755ead4a785> in <module>
----> 1 rollingpin.roll_thinner(dough)
<ipython-input-118-1af4dc2d94f2> in roll_thinner(self, x)
**5** x.height -= 1
**6** x.width += 1
----> 7 x.classify()
**8** def cut(self, x : Pasta):
**9** x.width -= 1
AttributeError: 'Bread' object has no attribute 'classify'
哦不！
我真的很期待那个比萨饼…幸运的是，我们现在可以通过修改我们的擀面杖类中的函数来展示多重分派，以接受两种类型。我们将通过简单地克隆函数，更改需要更改的内容，然后使用 dispatch decorator 使代码只在传递正确的类型时执行，如下所示:
class Roller:
def __init__(self):
pass
[@dispatch](http://twitter.com/dispatch) (Pasta)
def roll_thinner(self, x : Pasta):
x.height -= 1
x.width += 1
x.classify()
[@dispatch](http://twitter.com/dispatch) (Pasta)
def cut(self, x : Pasta):
x.width -= 1
x.classify()
[@dispatch](http://twitter.com/dispatch) (Pasta)
def fold(self, x : Pasta):
x.width += 1
x.classify()
[@dispatch](http://twitter.com/dispatch) (Bread)
def roll_thinner(self, x : Bread):
x.height -= 1
x.width += 1
x.bake()
[@dispatch](http://twitter.com/dispatch) (Bread)
def cut(self, x : Bread):
x.width -= 1
x.bake()
[@dispatch](http://twitter.com/dispatch) (Bread)
def fold(self, x : Bread):
x.width += 1
x.bake() rollingpin.roll_thinner(dough)
现在这段代码执行了。不用说，这在许多不同类型的场景中都非常方便！就个人而言，我发现多重分派是一种非常明显编程方式。它非常灵活，可以创建一些非常出色的语法。更好的是，用这个装饰器很容易做到——我强烈推荐！
№2:芹菜
在 Python 中处理任务时，芹菜是必不可少的。Celery 本质上是 Python 的一个任务管理器。它可以跟踪任务队列，任务队列是一系列计算机或线程接下来要执行的操作。计算世界中的字队列应该总是对数据应用先进先出的思想。打个更隐喻的角度来说，我们在叠煎饼，但我们先吃最下面的那个。
芹菜的唯一问题是它很难展示。为了使用这个库，我需要有一个生产服务器供我使用。当然，我没有这个，但我过去确实用过几次芹菜。以下是使用芹菜创建任务的基本示例，来自文档:
**from** **celery** **import** Celery
app = Celery('tasks', broker='pyamqp://guest@localhost//')
**@app**.task
**def** **add**(x, y):
**return** x + y
不用说，芹菜非常容易使用。只需创建一个芹菜茎类，然后使用 decorators 对您的任务进行排队。然后，代理中的可用服务器将承担这些任务。
№3:咔嚓:咔嚓
Click 是另一个我认为非常棒的模块。Click 帮助 Python 开发人员构建命令行界面，即 CLI。最棒的是，它可以用于向 Python 提供 CLA 或命令行参数。当然，这不会在我的笔记本上很好地着陆，但不管怎样，我认为它可能仍然是一个重要的工具来添加到一个人的武器库中。下面是一个示例，它会在将某人的姓名解析为 CLI 后问候该人:
import click[@click](http://twitter.com/click).command()
[@click](http://twitter.com/click).option("--name", prompt="Your name", help="The person to greet.")
def hello(count, name):
click.echo(f"Hello, {name}!")if __name__ == '__main__':
hello()
Click 非常酷，因为在很多方面它都像 bash 代码一样与 Python 并行工作。然而，用 Click 实现这一点的好处还在于，代码将不仅在类 Unix 操作系统上工作。
№4:已弃用:
进行反对是非常令人讨厌的。你想摆脱一个功能，但每个人都还在试图使用它。在正常情况下，您可能需要键入一点代码来创建弃用警告。为此，我们将使用模块 warn:
warnings.warn(
"this function is deprecated... etc.",
DeprecationWarning
)
然而，使用 deprecated，我们只需要用一个简单的调用做一件事。我们通过装饰器调用这个函数，可以立即给出弃用警告。
from deprecated import deprecated[@deprecated](http://twitter.com/deprecated) ("This function is deprecated, please do not make dough here")
def make_dough(pasta = False):
if pasta:
return(Pasta(10, 10, "Dough"))
else:
return(Bread(10, 10, "Dough"))
现在，当我们试图运行这个函数时，我们将得到一个不赞成使用的警告:
z = make_dough()
(图片由作者提供)
现在每个试图使用这个功能的人都会知道有
不允许生面团！
№5:装饰:并发
Deco 是 Python 的并行计算模块。如果你在附近看我做的关于装饰者的最后一个列表，我提到了一个叫做 Numba 的包。Numba 可以 JIT 编译和 GPU 编译 Python 软件。Deco 很像 Numba，但是允许同步和并发进程。现在，我们专门来看看并发装饰器。并发选项使用 multiprocessing.pool 使事情并发。然后与另一个装饰器一起使用，在后台的一个线程中运行该函数，同时继续处理该函数。让我们看看前面 pasta roller 上并发函数的一个简单用法。
from deco import concurrent, synchronizeddef roll_linguine(count : int):
rollingpin = Roller()
pastas = []
for i in range(0, count):
dough = make_dough(pasta = True)
while dough.height >= 3:
rollingpin.roll_thinner(dough)
while dough.width > 2:
rollingpin.cut(dough)
pastas.append(dough)
return(pastas)
我还为比萨饼做了一个等价物！：
def roll_pizzas(count : int):
rollingpin = Roller()
pizzas = []
for i in range(0, count):
dough = make_dough()
while dough.height > 3:
rollingpin.roll_thinner(dough)
while dough.width > 2:
rollingpin.cut(dough)
为了使这些功能并发，我们只需添加装饰器:
[@concurrent](http://twitter.com/concurrent)
def roll_linguine(count : int):
rollingpin = Roller()
pastas = []
for i in range(0, count):
dough = make_dough(pasta = True)
while dough.height >= 3:
rollingpin.roll_thinner(dough)
while dough.width > 2:
rollingpin.cut(dough)
pastas.append(dough)
return(pastas)
[@concurrent](http://twitter.com/concurrent)
def roll_pizzas(count : int):
rollingpin = Roller()
pizzas = []
for i in range(0, count):
dough = make_dough()
while dough.height > 3:
rollingpin.roll_thinner(dough)
while dough.width > 2:
rollingpin.cut(dough)
№6:装饰:同步
恐怕我们在披萨和扁面条的制作上犯了一个错误…不幸的是，今晚我们将有 500 多位客人！如果我们想确保每位客人都有饭吃，我们就需要做很多比萨饼和扁面条。每位客人需要 2 个披萨(我邀请了披萨爱好者大会，)和至少 20 个扁面条(披萨爱好者在大多数情况下也是面食爱好者。)幸运的是，因为我为这两种能力使用的两个函数是并发的，所以我可以使用 deco 的 synchronized decorator 来同步它们！
# linguine e pizza? molta bellisima!
[@synchronized](http://twitter.com/synchronized)
def prepare_meal(count : int):
roll_linguine(count * 200)
roll_pizzas(count * 2)
%timeit prepare_meal(500)
披萨/意大利面工厂有相当多的风扇噪音，但好消息是这一切都在运行——尽管在每个连续的循环中我都收到了早期的反对警告，完全破坏了我的输出。
№7:缓存工具:缓存
缓存工具是另一个有助于提高 Python 性能的优秀包。这样的包很棒，因为它们确实让 Python 体验变得更好。写得非常好的 Python 代码可以非常快，但事实是我们是在脚本语言中。我们需要尽可能多的性能。此外，我们不能总是写出完美的代码！记住这一点，让我们看看另一个装饰器，它将增强我们的 Python 包的性能！装饰器被称为 cached，它可以使用许多不同的参数来改变所使用的缓存类型，以及这些缓存的可能大小。
所有这些对我们已经开始的小通心粉/比萨饼生意来说都将会派上用场。因为该函数可用于存储以前的计算以备将来调用。好消息是，这意味着我们现在可以让我们的比萨饼滚筒非常擅长滚动比萨饼，但他们在滚动 100 个比萨饼后仍然会感到疲劳，或者不管设定的数量是多少。
from cachetools import cached, LRUCache, TTLCache
我们可以提供一个缓存关键字参数，以确定使用哪种缓存。需要注意的一点是，这些缓存都以不同的方式运行。如果您将此代码用于一个大型应用程序，该应用程序可能会有很多这样的代码，但是您不希望您的缓存在使用时被覆盖，那么您可能希望使用 TTL 缓存。该缓存将在 10 分钟后消失，但不会被覆盖。另一方面，LRU 缓存可以被覆盖，但可以永久保存，这是通用用例的更好选择。还有一个版本，它没有类似于 LRU 的论证，我相信，只是可能使用一些其他的算法——坦白说，我不完全确定。
№8:明天:线程
Tomorrow 是另一个可以用来提高 Python 编程语言性能的库。这个装饰器叫做线程。可以用一个位置参数来调用它，以指示我们希望为该任务分配多少个线程，然后我们可以设置关键字参数—例如，超时。
from tomorrow import threads
[@threads](http://twitter.com/threads)(5)
def prepare_meal(count : int):
roll_linguine(count)
roll_pizzas(count)
下面是一个使用超时关键字参数的示例:
[@threads](http://twitter.com/threads)(5, timeout = 1)
def prepare_meal(count : int):
roll_linguine(count)
roll_pizzas(count)
№9:坚韧
Tenacity 是一个更独特的包，可以用来在某些代码不能正确执行的情况下再次尝试一些东西。它可以用于开发中的软件，或者如果请求没有得到满足，也可以用于请求。这样的东西有数百种用途，最棒的是，因为它被包装到这个装饰器中，所以可以非常容易地使用它！鉴于这种包装的性质，我在笔记本上构思演示的唯一方法就是用指纹进行投掷。
from tenacity import retry[@retry](http://twitter.com/retry)
def ohno():
print("function ran once")
try:
2 == 3 - 5 == 6
except ValueError:
print("Idk what that was even meant to do")ohno()
每当我运行它时，它运行一次，然后使我的内核崩溃，也就是说，我在笔记本之外重试了一次，所以关于这个包有一些需要注意的地方，它在笔记本中不太可用。
№10:财产
我们要看的最后一个模块装饰器是属性装饰器。这个来自标准库，decorator 部分用于将一个方法变成同名只读属性的“getter”。换句话说，我们只是让这个属性成为前一个属性的只读副本。
class PowerLine:
def __init__(self):
self._voltage = 100000
[@property](http://twitter.com/property)
def voltage(self):
return self._voltage
结论
装饰器是 Python 编程语言中一个非常棒的特性。它们特别棒，因为它们可以用来改变给定类型与其周围方法的交互方式。我个人觉得这非常令人兴奋。装饰者的另一个优点是他们经常可以提高 Python 的速度，鉴于 Python 的脚本特性，我相信这是非常可取的。
希望有了这个装饰器列表，你的 Python 函数将会加速和改变！非常感谢您阅读我的文章，它意味着世界！我希望这些装饰者中的一些能让你成为一个更好的大画家！
在数据行业大展拳脚的 10 个点
人们想在这里发展事业。但是他们经常被周围的噪音震聋。
约书亚·索蒂诺在 Unsplash 上拍摄的照片
假设你刚刚对人工智能、机器学习和数据科学这些华而不实的术语感到敬畏，并决定要么获得其中一个领域的学位，要么改变职业生涯，进入数据行业。你参与炒作，赶时髦，在 Coursera 上注册吴恩达的课程，在 Udacity 上注册更多的课程，买一些详细的书籍并浏览它们，开始旅行，实施一些项目并发表研究论文。你开始为自己的成就感到高兴。但当你去申请工作或实习时，你没有得到它，你想知道为什么。
嗯，问题是你上面所做的一切有助于了解基础知识，并接触到这个行业所能提供的东西。然而，数据行业本质上是跨学科的，广泛的，不断发展的，其周围的生态系统非常嘈杂。我的意思是，只要搜索任何热门词汇，你就会找到成千上万篇文章——它们都声称与众不同；这一个没有——爆破意见，建议，教程等等。我最近读了一篇文章，作者哀叹该领域专家缺乏有用的在线资源。几乎所有的东西都是针对新来者的。想象一下！
新来者实际上需要的是培养在这个巨大的行业中导航的能力，自己决定他们在这个行业中想要什么以及如何得到它。
在数据行业，做纵向的专家，而不是横向的‘专家’
磨练思维过程
为了让数据变大并过滤噪音，每个人都有必要在他们永无止境的学习过程的每个阶段都知道:
- 数据产业如何运作
- 它使用什么技术
- 它是如何向前发展的
并将其与个人的行为联系起来:
- 想象他们在行业中的角色
- 已经计划好到达他们想要的位置
- “知道”是他们可以利用的资源，所有这些都是一个循环的过程。
一位数据行业资深人士的思维过程(图片由作者提供)
也就是说，这里是对可用的互联知识资源类型的深入探究。
10 种资源
- MOOCs 认证:在线课程和认证是一种很好的入门方式，很像速成课程。这里噪音的一个优点是有大量的选择。鉴于人们从一门强烈推荐的课程开始，MOOCs 让人们熟悉数据行业及其各个子行业的概念、术语、差异和布局。最重要的是，有一个证书——许多大学已经开始承认这些学分——来证明它！
- **参考书:**关于人工智能、深度学习和机器学习的参考书可以很好地深入研究任何选定的主题。这种类型的资源将涵盖深入的理论，并给出对基础概念的坚实理解。此外，还有基础数学的介绍！
- **数学:**数学，本身是没有必要的。然而，要全面理解数据行业中的任何概念、算法或技术，必须了解基础数学。这将允许他们在基层理解这个概念，以及在编程层面理解和调整这个概念的工作方式(想想:实现库)
- **技术:**对于开发人员来说，每天都有许多不同语言的更好、更优化的库和框架建立在数据行业的概念之上。对于希望从事 ML 模型或数据管道开发的人来说，他们必须了解最新的产品，同时还要理解基本的概念和数学，以便能够最大限度地使用它们。
- **研究论文:**相反，对于那些期待成为行业研究员的人来说，从理论的角度跟上最新的产品势在必行。这就是为什么阅读研究论文和出版他们自己的作品大有帮助。在这里，数学上的理解也很有帮助。
- Kaggle: 在了解了理论和概念之后，接下来的事情就是利用理论和库来处理一些实际数据。Kaggle 是处理来自真实世界用例的真实世界数据的最佳平台——从数据分析到超参数调整。唯一的缺点——也是最大的缺点——是模型部署和围绕模型构建应用程序在平台上是不可能的。Kaggle 可以证明最适合未来的数据分析师和机器学习工程师。
- **项目:**为了克服 Kaggle 的劣势，需要构建独立的项目。同样，来自 Kaggle 的数据可以被利用，但是在任何没有在 Kaggle 上完成的项目中，都要注意围绕模型包装应用程序并部署它。通过这种方式，人们可以在数据行业的端到端应用程序开发中获得一些经验。
- **云:**说到端到端开发，现在很多开发和提供的服务都利用了云。因此，想要在部署数据应用程序方面有所作为的人(比如 MLOps)必须熟悉该领域的各种云技术。
- **实习:**最后，所有的实施和理论知识都可以在实习或工作中加以利用，以便根据客户的要求从零开始构思、规划、设计和构建一些东西。这和项目的区别在于，在项目中，问题定义已经给出，不需要从业务角度思考。本质上，实习和工作提供了一个机会来扩展一个人的头脑风暴能力，因为要求很少是直截了当的。对于未来的数据科学家来说，这可能是一种理想的体验
- **领域知识:**记住，数据行业就像跑马拉松。将任何类型的业务需求与数据结合起来都是困难的，并且获得足够的知识来始终为业务领域做到这一点需要时间和与业务领域的多年联系。一旦实现，你将处于该领域数据金字塔的顶端！
这篇文章是基于我迄今为止在这个行业的经历和经验。如果有人在帖子上有所改进，或者指出我遗漏或错误的地方，我会觉得很丢脸。
最后，我想在 Linkedin 上联系一下！
10 个流行的递归编码面试问题
聪明工作
准备编码面试需要相当长的时间。有这么多不同的主题、数据结构和算法要讨论。递归是最重要的算法类型之一。因为它是许多重要算法的基础，如分治算法、图算法、动态编程、一些基于树的搜索和排序算法等等。这是不可避免的。因此，在参加编码面试之前进行一些练习是很重要的。
这篇文章将集中在递归的基本问题上，这些问题在基本编码访谈中非常普遍和流行。如果你在谷歌上搜索，你会发现这些问题到处都有。**我只是为你整理了一些常见的面试问题。**你会在这里看到几种不同模式的递归算法。
本文并不保证你只会看到这些问题。这些是一些常见的类型，这应该给你一些很好的实践！
我会从容易到难。这不是一个递归教程。我只是在这里提供一些练习材料。由于我大部分时间都在使用 python，所以这些解决方案将以 python 语言提供。
建议你先自己试着解决所有问题，再看解决方案。
问题 1
编写一个递归函数，该函数接受一个数字，并返回从零到该数字的所有数字的总和。
我将称这个函数为’**累计’。**如果我提供 10 作为输入，它应该返回从 0 到 10 的所有数字的总和。那是 55。
以下是 python 解决方案:
def cumulative(num):
if num in [0, 1]:
return num
else:
return num + cumulative(num-1)
问题 2
编写一个递归函数，将一个数字作为输入，并返回该数字的阶乘。
我相信我们都知道阶乘是什么。我将把这个函数命名为“阶乘”。
以下是 python 解决方案:
def factorial(n):
assert n >=0 and int(n) == n, 'The number must be a positive integer only!'
if n in [0,1]:
return 1
else:
return n * factorial(n-1)
问题 3
编写一个递归函数，它接受一个数字“n ”,并返回斐波那契数列的第 n 个数字。
提醒一下，斐波那契数列是以 0 和 1 开始的正整数序列，其余的数字是前两个数的和:0，1，1，2，3，5，8，11…
以下是 python 解决方案:
def fibonacci(n):
if n in [0, 1]:
return n
else:
return fibonacci(n-1) + fibonacci(n-2)
第四题
编写一个递归函数，它将一组数字作为输入，并返回列表中所有数字的乘积。
如果您不是 python 用户，python 中的列表就像 Java、JavaScript 或 PHP 中的数组。
以下是 python 解决方案:
def productOfArray(arr):
if len(arr) == 0:
return 0
if len(arr) == 1:
return arr[0]
else:
return arr[len(arr)-1] * productOfArray(arr[:len(arr)-1])
第五题
写一个函数，接受一个字符串，如果这个字符串是回文就返回。
提醒一下，如果一个字符串等于它的倒数，就叫做回文。比如 Madam，civic，kayak。如果你颠倒这些单词中的任何一个，它们都保持不变。
以下是 python 中的递归解决方案:
def isPalindrom(strng):
if len(strng) == 0:
return True
if strng[0] != strng[len(strng)-1]:
return False
return isPalindrome(strng[1:-1])
如果字符串是回文，这个函数返回 True，否则返回 false。
第六题
编写一个递归函数，它接受一个字符串，并反转该字符串。
如果输入是’惊人的’，它应该返回’ gnizama '。
以下是 Python 解决方案:
def reverse(st):
if len(st) in [0, 1]:
return st
else:
return st[len(st)-1] + reverse(st[:len(st)-1])
问题 7
编写一个递归函数，该函数采用一个可能包含更多数组的数组，并返回一个所有值都已展平的数组。
假设这是输入数组:
[[1], [2, 3], [4], [3, [2, 4]]]
输出应该是:
[1, 2, 3, 4, 3, 2, 4]
以下是 python 解决方案:
def flatten(arr):
res = []
for i in arr:
if type(i) is list:
res.extend(flatten(i))
else:
res.append(i)
return res
问题 8
编写一个递归函数，它接受一个单词数组，并返回一个包含所有大写单词的数组。
如果这是输入数组:
['foo', 'bar', 'world', 'hello']
输出数组应该是:
['FOO', 'BAR', 'WORLD', 'HELLO']
以下是 python 解决方案:
def capitalizeWords(arr):
if len(arr) == 0:
return []
else:
return [arr[0].upper()]+capitalizeWords(arr[1:])
问题 9
编写一个递归函数，它接受一个数组和一个回调函数，如果该数组的任何值从该回调函数返回 True，则返回 True，否则返回 False。
在这个解决方案中，我使用函数‘isEven’作为回调函数，如果一个数字是偶数，则返回 True，否则返回 False。
下面是回调函数:
def isEven(num):
if num%2==0:
return True
else:
return False
如果输入数组中有一个元素从‘isEven’函数返回 True，那么我们的主递归函数应该返回 True，否则返回 False。这是一个数组:
[1, 2, 3, 5]
这里递归函数应该返回 True，因为这个数组有一个偶数元素。
以下是 python 解决方案:
def anyEven(arr, cb):
if len(arr) == 0:
return False
if cb(arr[0]):
return True
return anyEven(arr[1:], cb)
第十题
写一个递归函数，返回一个字典中所有正数的和，这个字典可能包含更多的嵌套字典。
这里有一个例子:
obj = {
"a": 2,
"b": {"x": 2, "y": {"foo": 3, "z": {"bar": 2}}},
"c": {"p": {"h": 2, "r": 5}, "q": 'ball', "r": 5},
"d": 1,
"e": {"nn": {"lil": 2}, "mm": 'car'}
这应该会返回 10。因为这本字典包含五个 2，没有其他偶数。
以下是 python 解决方案:
def evenSum(obj, sum=0):
for k in obj.values():
if type(k) == int and k%2 ==0:
sum += k
elif isinstance(k, dict):
sum += evenSum(k, sum=0)
return sum
结论
要精通递归需要大量的练习。但是在去面试之前看一下这些问题是个好主意。没有人能保证面试问题，但准备不同模式的编码问题是关键。但是到目前为止，无论我面对什么样的面试，他们都没有给我任何难题。他们通常会问问题来测试知识和解决问题的整体方法。
欢迎在推特上关注我，喜欢我的脸书页面。
更多阅读
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
