TowardsDataScience-博客中文翻译-2021-一-
TowardsDataScience 博客中文翻译 2021（一）
WordNet:英语词汇分类法
什么是 WordNet，为什么有用？
介绍
就自然语言处理(NLP)而言，自动理解和分析单词的含义以及预处理文本数据可能是一项具有挑战性的任务。为了支持这一点，我们经常使用词典。词典、词库、单词本或词库是个人、语言或知识分支的词汇。我们经常将数据中的文本映射到词典，这反过来帮助我们理解这些单词之间的关系。
一个真正有用的词汇资源是 WordNet 。它独特的语义网络帮助我们找到单词关系、同义词、语法等。这有助于支持 NLP 任务，如情感分析、自动语言翻译、文本相似性等。
这篇文章旨在展示 WordNet 的一些特性，并讨论如何获得关于语言数据的新见解。
WORDNET
WordNet 是一个大型的英语词汇数据库。名词、动词、形容词和副词被分成称为“同义词集”的认知同义词集，每个同义词集表达一个不同的概念。同素集使用概念语义和词汇关系，如上下义关系和反义词来相互联系。
搜索单词‘书’时的 WordNet 网络— OpenScience
在 WordNet 术语中，每组同义词都是一个同义词集，构成同义词集一部分的同义词是同一概念的词汇变体。比如上面的网络中，神的话语，字，经文，圣令状，圣典，好书，基督教圣经和圣经组成了与概念圣经相对应的 synset，这些形式中的每一种都是词汇变体。
WordNet 表面上看起来像一本同义词词典，它根据单词的意思将单词分组。然而，有一些重要的区别。
- 首先，WordNet 链接的不仅仅是单词形式——字母串——还有单词的特定含义。结果，在网络中发现的彼此接近的单词在语义上被消除了歧义。
- 第二，WordNet 标记单词之间的语义关系，而词库中的单词分组除了意义相似之外不遵循任何明确的模式。
荒野中的 WORDNET
自然语言工具包( NLTK )是一个用于 NLP 的开源 Python 库。它的伟大之处在于它附带了几个语料库、玩具语法、训练过的模型，以及这个博客感兴趣的主题 WordNet。NLTK 模块包括具有 155，287 个单词和 117，659 个同义词集的英语 WordNet。
导入
WordNet 可以通过以下方式从 NLTK 导入:
话
我们可以使用synset()和synsets()功能查找 WordNet 词典中的单词。
可以用以下形式的三部分名称定义一个 synset:
synset = WORD。位置 NN
其中:
- 单词—您要搜索的单词。
- 词类(POS) —特定的词类(名词、动词、形容词、副词、代词、介词、连词、感叹词、数词、冠词或限定词)，单词根据其定义和上下文与之对应。
- NN —一个感应键。一个词可以有多种含义或定义。所以“cake.n.03”是“cake”这个词的第三个名词意义。
POS 和 NN 参数是可选的。
定义和示例
从前面的例子中，我们可以看到dog和run有几种可能的上下文。为了帮助理解每个词的意思，我们可以使用definition()函数查看它们的定义。
同样，如果我们需要在上下文中澄清一些名词dog和动词run的例子，我们可以使用examples()函数。
类似
我们还可以确定单词之间的相似度。path_similarity()函数通过遍历 WordNet 网络中连接两个单词的路径，返回一个表示这两个单词相似程度的分数。
WordNet 包括几种不同的相似性度量。例如，Wu & Palmer 的 similarity 通过考虑网络中两个同素集的深度以及它们最具体的祖先节点(最小公共包含器(LCS))来计算相似性。
相似性得分在 0
例如，让我们考虑动词run和sprint与名词ship和boat之间的相似性。0.86 和 0.91 的高分表明它们确实彼此相似。注意，当比较单词ship和sprint之间的相似性时，输出是 None。这意味着无法找到这些单词之间的路径。
为什么这在 NLP 中有用？
语言是灵活的，人们会用各种不同的词语来描述同一件事情。因此，如果您有一个大型客户评论数据集，并且您想要提取那些讨论产品相同方面的评论，找到相似的评论将有助于缩小搜索范围。
上位词和下位词
上下义关系编码一个更一般的术语和它的具体实例之间的词汇关系。
一个上位词被描述为一个比给定单词更通用的单词。即它的上位词:如果 X 是 Y 的上位词，那么所有 Y 都是 X，比如动物是狗的上位词。
而上下义关系是两个概念之间的关系，其中概念 B 是概念 a 的一种类型，例如牛肉是肉的下义关系。
为什么这在 NLP 中有用？
上下义关系的知识对于诸如问题回答之类的任务是有用的，其中可以建立模型来理解非常一般的概念，但是被询问特定的问题。
同义词和反义词
以编程方式识别准确的同义词和反义词比它应该的要困难得多。然而，WordNet 很好地解决了这个问题。
同义词是同一种语言中在某些或所有意义上具有相同或非常相似的意思的单词或表达。例如，WordNet 网络中围绕单词 car 的同义词有 automobile、machine、motorcar 等。
反义关系可以定义为表示“对立”的词汇关系。此外，直接反义词对的每个成员都与一些语义相似的形容词相关联。例如胖是瘦的反义词；肥胖的反义词也是瘦因为肥胖和胖属于同一个 synset。自然，有些词没有反义词，其他词如推荐只是在 WordNet 中没有足够的信息。
为什么这在 NLP 中有用？
还是那句话，语言是灵活的。同义词和反义词有助于缩小相似和相反文本的搜索范围。
部分名和全名
部分转喻表达‘成分-of’关系。即两个概念之间的关系，其中概念 A 构成概念 b 的一部分。对于部分名称，我们可以利用两个 NLTK 函数:part_meronyms()和susbstance_meronyms()。例如，名词的部分名词包括冠和物质名词水的部分名词包括氢。**
全同词表示“隶属”关系，即两个概念之间的关系，其中概念 B 是概念 a 的成员。我们可以利用两个 NLTK 函数:part_holonyms()和susbstance_holonyms()。例如，名词车的部分全词包括轮和名词木的实体全词包括棍。
限定继承
蕴涵是两个动词之间的语义关系。如果 B 的意义符合逻辑并且严格地包含在 C 的意义中，则动词 C 必然包含动词 B。这种关系是单向的。比如打鼾需要睡觉，但是睡觉不需要打鼾。
多语言 WordNet
WordNet 也是一个非常重要的翻译资源，因为就语言数量和涵盖的单词和概念数量而言，它是当今最大的多语言词典之一。它甚至被 Google Translate 用作拥有 WordNets 的语言之间翻译过程的一部分。
目前，对于大量的语言，WordNet 有不同开发阶段的版本。这不仅包括最广泛和最著名的语言，如法语、德语、汉语、西班牙语或葡萄牙语，还包括不太知名的少数民族语言，如阿尔巴尼亚语、卡纳达语、克罗地亚语、巴斯克语、加泰罗尼亚语、加利西亚语和威尔士语。
我们可以使用langs()函数返回 NLTK 的 WordNet 版本中所有可用语言的列表，并搜索意大利语单词 dog。
为什么这在 NLP 中有用？
WordNet 可用于执行(粗略的)语言翻译。
结论
这篇文章涵盖了 WordNet 必须提供的一些主要特性，以及它独特的语义网络如何帮助支持 NLP。
关于 WordNet 特性的更多信息，请点击这里:
https://globalwordnet.github.io/gwadoc
https://www.nltk.org/howto/wordnet.html
1001 条提高人工智能的条款不会让我们有任何进展
应对人工智能挑战的竞争性定义概述
格雷格·拉科齐在 Unsplash 上的照片。作者的修改。
有很多人在努力让人工智能和机器学习变得不那么糟糕。事实上，今年早些时候，我加入了一家初创公司，该公司希望帮助人们与人工智能建立更深层次的联系，为他们提供一种更直接的方式来控制算法能为他们做什么。我们称它为“移情人工智能”。当我们试图给这个新术语赋予意义时，我开始好奇其他团体是如何称呼他们自己提出的算法解决方案的，这些算法对我们有利而不是不利。以下是我发现的概述。
移情人工智能
对于我们 Waverly 来说，同理心是指让用户控制他们的算法，并帮助他们实现自己的愿望。我只找到了一家公司使用相同术语的另一个例子，但方式不同。2019 年，Pega 使用了术语同理心 AI 来销售其客户同理心顾问(Customer Empathy Advisor)解决方案，该解决方案可以帮助企业在提供销售报价之前收集客户输入。这与电子商务网站基于用户行为进行推荐的传统方法形成了对比。
尽管 Waverly 和 Pega 都认为同理心是倾听人们，而不是基于大数据集主动推荐结果，但他们方法的关键区别是谁与人工智能交互。在 Waverly，我们开发的工具旨在供用户直接使用，而 Pega 则为企业提供工具，为用户创建和调整推荐。
N.B .同理心 AI 不应该与 人工同理心(AE) 混淆，人工同理心是一种旨在检测和响应人类情绪的技术，最常用于机器人和虚拟助手等系统中。今天这方面的实际例子并不多，但一些值得注意的尝试是具有有限模拟情感范围的机器人宠物，如 Pleo 、 艾博 和Cozmo。在软件方面，有人试图根据你的 打字行为 或 语调 等信号来推断人类的情绪。
负责任的 AI
这是投入巨资改善人工智能技术的大型组织最常用的术语。埃森哲、微软、谷歌和普华永道都有他们定义的负责任人工智能的某种框架或原则。(有趣的是，谷歌对这个术语的解释在他们自己的搜索引擎上排在第三位。)
作者截图
以下是这些公司如何诠释负责任的人工智能概念的概述:
- 埃森哲:在人工智能解决方案中建立信任的框架。这是为了帮助防止使用有偏见的数据和算法，确保自动化决策是合理的和可解释的，并帮助维护用户信任和个人隐私。
- 微软:以人为本的道德原则，包括公平、可靠&安全、隐私&安全、包容、透明和责任。
- 谷歌:在公平、可解释、隐私和安全的原则下，指导人工智能在研究和产品中的开发和使用的道德宪章。
- 普华永道:一个解决责任五个维度(治理、可解释性&可解释性、偏见&公平性、稳健性&安全性、道德规范&监管)的工具包。
虽然很难从每家公司提取一个简明的定义，但结合他们在人工智能中谈论“责任”时使用的不同术语，可以让我们了解这些公司关心什么——或者至少是他们认为可以卖给客户的东西。
人工智能公平
你可能已经注意到，公平作为负责任的人工智能的子集反复出现，但是 IBM 有最大的资源专门用于这个概念，他们有人工智能公平 360 开源工具包。公平的定义通常是指避免系统和数据集中不必要的偏差。
鉴于公众越来越关注与偏见和包容性相关的系统性问题，公平是创造更好的人工智能最相关的概念之一也就不足为奇了。尽管对这个术语的理解似乎很广泛，但围绕公平的影响仍有很多必要的对话。最近一篇关于 HBR 的文章试图证明公平不仅仅是道德的；这也将使公司更有利可图，生产率更高。为了更好地了解人工智能编程中最微小的决定如何能够在社会中引起巨大的涟漪，请查看 Nicky Case 的精彩互动演示多边形的寓言。
值得信赖的人工智能
2018 年，欧盟组建了一个关于人工智能的高级别专家组，通过四个交付品为其人工智能战略提供建议。2019 年 4 月，欧盟公布了第一个可交付成果，即一套可信人工智能的道德准则，该准则声称这项技术应该:
- 合法——遵守所有适用的法律法规
- 道德——尊重道德原则和价值观
- 稳健——既从技术角度出发，又考虑到其社会环境
该指导方针进一步细分为 7 个关键要求，涵盖了机构、透明度和隐私等主题。
几乎整整一年后，德勤发布了商标为 的可信人工智能框架。令人失望的是，他们甚至没有提及欧盟在声称对该术语拥有所有权之前所做的大量工作。然后他们重新利用它来创造他们自己的六个维度，看起来很像其他人所说的负责任的人工智能。对他们来说，Trustworthy AI 公平公正、透明可解释、负责任、稳健可靠、尊重隐私、安全可靠。该框架甚至附带了一个图表，可以轻松添加到任何高管的 PowerPoint 演示文稿中。
图片来源:德勤
最后，在 2020 年末，Mozilla 发布了他们关于可信人工智能的白皮书，其中有他们自己的定义。
Mozilla 将可信赖的人工智能定义为明显值得信任的人工智能，考虑责任、代理以及个人和集体福祉的技术。
尽管他们承认这是欧盟在可信度方面工作的延伸，但与 EU-建立的对可信人工智能的理解的偏离，延续了公司在沟通上不结盟的趋势。
可解释的人工智能(XAI)和可解释的人工智能
如果技术最终隐藏在一个黑盒子里，无法理解，那么所有这些不同的框架和原则都没有任何意义。这就是为什么上面讨论的许多框架都提到了可解释的人工智能。
这些术语指的是一个算法的代码能被理解到什么程度，以及可以用什么工具来理解它。它们经常被互换使用，比如在维基百科的页面上，可解释性被列为可解释性的一个子集。其他人有不同的观点，比如本文的作者，他讨论了两者之间的差异，并在一个光谱上提出了这些术语。
归功于康纳·奥沙利文
由于这些术语的技术性质，我对它们的区别的理解是有限的。然而，似乎需要在“可解释的人工智能”(XAI)和“可解释的模型”之间进行区分。上面的图表描述了算法可以基于的不同模型，而维基百科页面谈论的是更广泛的 XAI 概念。在这一点上，它感觉像是吹毛求疵，而不是为大多数人提供澄清，所以我将把这场辩论留给专家。
竞争的定义会让我们付出代价
当我评估所有这些术语时，我发现自己困惑多于放心。该行业正在使用在日常语言中具有相当分量的词汇，但在人工智能的背景下以相对任意的方式重新定义它们。虽然有一些共同的努力来创造共同的理解，最明显的是围绕欧盟准则，每个公司的定义的范围和重点是不同的，这可能会导致沟通和公众理解的问题。
作为一个社会，我们似乎同意我们需要符合人类最大利益的人工智能系统，但我们仍然找到了一种方法，让它成为一场比赛，看谁因这个想法而不是解决方案而获得荣誉。事实上，人工智能研究和部署公司 OpenAI(其使命是确保人工智能造福全人类)的一项分析表明，竞争压力实际上可能会推动公司在安全方面投资不足，并导致集体行动问题。
虽然结盟是理想的，但在这个早期阶段的多样性是走向集体理解的自然一步。当务之急是，我们不要陷入试图找到让我们的公司听起来不错的术语，而是采取必要的步骤来创建为我们所有人提供有利结果的人工智能系统。
如果你想直接在你的收件箱里收到我写的东西， 点击这里💌T10。
1+1=3.等等，不，1+1=2。如何让 GPT 自我检查？
在 Colab 中使用 GPT-J 使用 GPT 仔细检查其答案的 Python 演练
大型语言模型有一个问题，他们往往只是编造东西。这可能是因为训练数据、提示或者甚至仅仅是歧义。这可以通过设计让 GPT 健全检查其输出的提示来缓解，它可以与 GPT3 和 GPT-J 一起工作(后者可以免费使用)。
我所说的健全检查是什么意思？嗯，通过设置您的提示来仔细检查输出，结果是这样的:
Initial Answer: 6394 + 250 = 6643
Double Checking: 6643 looks wrong. 6394 + 250 = 6644Initial Answer: {a} + {b} =
与使用类似于以下内容的传统提示符相比，您可以提高性能:
6394 + 250 = 6644
{a} + {b}=
此外，对于像我一样不擅长阅读的人，你可以跳过这篇文章，只需使用链接的 colab 使用 GPT-J 自己运行代码。
作为背景，还有一些其他方法可以用来缓解这类问题。最流行的是手动筛选你喜欢的答案。这很无聊，而且如果您试图自动化流程，这也没有什么帮助。还有另一种方法，让一个模型通过中间步骤展示它的工作，这可以提高推理能力，这很酷。然而，我认为值得看一看自我纠正，看看 GPT 能在多大程度上审视它所发表的内容，并决定它是否需要改进，因为人们似乎没有深入研究它(尽管去年有一些有趣的关于猜测和检查随机代数解决方案的很酷的推文)。
举个玩具例子，我用算术。为什么是算术？首先，我们可以衡量一个答案是否正确，知道这一点是有好处的。第二，虽然有一种说法认为语言模型在算术上表现不佳的原因是由于 GPT 令牌的编码方式，但我怀疑多位算术存在搜索问题，你必须从右到左进行加法才能携带数字，当你只是提前预测时，很难猜测数字会被携带到哪里。GPT 不擅长这种类型的搜索，如果搜索导致了这个问题，那么做双重检查应该会有所帮助。
总之，在这篇文章中，我将向您展示如何生成包含 1-30 个示例的上下文，使用标准的少数镜头和改进的自检少数镜头运行它们的完成，然后我们将绘制错误(图 1)并看到，与传统的少数镜头相比，自检提示确实具有更低的错误和更高的精确匹配。下面是图表的样子(注意，对于精确匹配，我们获得了 16%的最高准确率，而使用逗号的 GPT3 可以获得超过 90%的最高准确率，所以可能会有很大的差异)。
图 1:在使用 GPT-J 的 4 位数算术中，与常规的少量尝试相比，自校正提示具有更低的平均绝对百分比误差(左)和更高的精确匹配(右)
设置查询功能
这适用于 GPT-J 和 GPT-3 模型，您只需以不同的方式设置您的查询函数，这就是我们将要开始的地方。当我们查询这类任务的完成情况时，我们希望使用 0 temperature，因为我们希望获得最有可能的令牌，而不是随机加入其他数字。下面是我在 J 中的查询函数的样子(借用了 GPT-J 演示笔记本中的 infer 函数，这个函数很酷):
def query(context, top_p=0, temp=0, gen_len=50):
tokens = tokenizer.encode(context)
provided_ctx = len(tokens)
pad_amount = seq - provided_ctx
padded_tokens = np.pad(tokens, ((pad_amount, 0),)).astype(np.uint32)
batched_tokens = np.array([padded_tokens] * total_batch)
length = np.ones(total_batch, dtype=np.uint32) * len(tokens)
output = network.generate(batched_tokens, length, gen_len, {"top_p": np.ones(total_batch) * top_p, "temp": np.ones(total_batch) * temp})
samples = []
decoded_tokens = output[1][0]
for o in decoded_tokens[:, :, 0]:
samples.append(tokenizer.decode(o))
return samples[0]
设置提示
现在，我们将继续设置我们的提示。我们将随机创建 30 个例子作为提示，100 个例子作为测试集。
import pandas as pd, json, randomrandom.seed(42)fourDigitDict = []
fourDigitTest = []for i in range(30):
a = int(random.random()*10**4)
b = int(random.random()*10**4)
fourDigitDict.append({'first': a, "second": b, 'sum': a+b})
fourDigitTrainDF = pd.DataFrame(fourDigitDict)for i in range(100):
a = int(random.random()*10**4)
b = int(random.random()*10**4)
fourDigitTest.append({'first': a, "second": b, 'sum': a+b})
fourDigitTestDF = pd.DataFrame(fourDigitTest)
对于纯/传统的情况，我们只是让所有的例子都按照提示排列起来，但是我们在这里要做的自我纠正是随机设置一些错误的例子。我们将错误的答案(或正确的答案)称为原始总和，这样我们可以告诉模型稍后将其纠正为正确的答案。
fourDigitTrainDF['randomlyWrong'] = fourDigitTrainDF['sum'].apply(lambda x: random.random() < .5)fourDigitTrainDF['offset'] = fourDigitTrainDF['randomlyWrong'].apply(lambda x: .5-random.random() if x==True else 0)fourDigitTrainDF['offset'] = fourDigitTrainDF['offset'] * 2000fourDigitTrainDF['originalSum'] = fourDigitTrainDF['sum'] + fourDigitTrainDF['offset']
接下来，我们只需创建我们的提示。我们将有一组提示，一组是关于纯粹的几个镜头，另一组是关于修正后的镜头。为了了解我们需要多少个示例，我们将进行网格搜索，并从 1 到 30 个示例中尝试运行。
correctionPrompts = {}
purePrompts = {}for i in range(1,30):
correctionPrompt = ""
purePrompt = ""
for row in fourDigitTrainDF[:i].iterrows():
correctionPrompt += 'Initial Answer: {} + {} = {}'.format(row[1]['first'], row[1]['second'], int(row[1]['originalSum']))
correctionPrompt += '\n'
interjection = 'looks correct.' if not row[1]['randomlyWrong'] else 'looks off by a bit.'
correctionPrompt += 'Double Checking: {} {} {} + {} = {}'.format(int(row[1]['originalSum']), interjection, row[1]['first'], row[1]['second'], row[1]['sum'])
correctionPrompt += '\n\n' purePrompt += '{} + {} = {}'.format(row[1]['first'], row[1]['second'], row[1]['sum']) + '\n'
correctionPrompt += 'Initial Answer: '
correctionPrompts[i] = correctionPrompt
purePrompts[i] = purePrompt
现在我们已经设置好了所有的提示，是时候对照测试集来试试了！
运行测试
为了运行测试，我们将开始设置实际的查询(a + b =)，然后将它添加到每个提示的末尾(有无自我纠正)。然后，我们将运行整个程序，并在它执行 6000 次查询时袖手旁观。我们还会在每次检查测试集时将它转储到 JSON，以防出现问题，以便我们可以恢复。
import json
fourDigitTestDF['formatted'] = fourDigitTestDF.apply(lambda x: "{} + {} =".format(x['first'], x['second']), axis=1)correctionResults = {}
pureResults = {}#for each size of example length in 1-30, run on the test set
for trainSize in range(1,30):
if trainSize not in correctionResults:
print(trainSize)
correctionResults[trainSize] = []
pureResults[trainSize] = []
for example in fourDigitTestDF.formatted:
correctionResults[trainSize].append( query(correctionPrompts[trainSize]+example, gen_len=50))
pureResults[trainSize].append(
query(purePrompts[trainSize]+example, gen_len=50))
with open('correctionResults.json', 'w') as fh:
json.dump(correctionResults, fh)
with open('pureResults.json', 'w') as fh:
json.dump(pureResults, fh)
评估
好，现在我们有了 6000 份文件，我们将对其进行评估。我首先将测试集重命名为 test ，因为……为什么不呢。由于我还不知道如何用 GPT J 做一个停止序列(我的学位是新闻学，数学很难)，我们必须解析出我们想要的答案。对于传统的方法，这只是出门的第一个“字”。对于自校正方法，它是第一组输出的最后一个“单词”。
def parsePureInt(x):
base = x.split('\n')[0]
try:
return int(base)
except:
return 0def parseCorrectedInt(x):
base = x.split('\n\n')[0].split(' ')[-1]
try:
return int(base)
except:
return 0
现在我们将把它应用到我们所有的结果中，并计算误差。
for key in pureResults.keys():
test[key] = pureResults[key]
test[key] = test[key].apply(lambda x: parsePureInt(x))pureMape = pd.DataFrame()
for col in test.columns[3:]:
pureMape[col] = (abs(test[col] - test['sum']))/test['sum']pureEM = pd.DataFrame()
for col in test.columns[3:]:
pureEM[col] = test[col] == test['sum']for key in correctionResults.keys():
test[key] = correctionResults[key]
test[key] = test[key].apply(lambda x: parseCorrectedInt(x))correctedMape = pd.DataFrame()
for col in test.columns[3:]:
correctedMape[col] = (abs(test[col] - test['sum']))/test['sum']correctedeEM = pd.DataFrame()
for col in test.columns[3:]:
correctedeEM[col] = test[col] == test['sum']
现在我们只是绘制结果
fig, axs = plt.subplots(ncols=2, nrows=1, figsize=(12,8), facecolor='white')
correctedMape.mean().plot(label='self correcting', ax=axs[0])
pureMape.mean().plot(ax=axs[0], label='pure few shot')
axs[0].legend()
axs[0].set_xlabel('# of examples')
axs[0].set_title('Mean Error')correctedeEM.sum().plot(label='self correcting', ax=axs[1])pureEM.sum().plot(ax=axs[1], label='pure few shot')
axs[1].legend()
axs[1].set_xlabel('# of examples')
axs[1].set_title('Exact Match')
fig.suptitle('4 Digit Arithmetic on 100 Tests')
图二。等等，不对，还是图 1。
在关闭
你可以用 GPT3 和 J 运行上面的代码，你会得到同样的改进。我把它作为一个练习留给读者，让他们也用逗号来做这件事(您可以只使用 f " { x:} "来格式化带有逗号的内容)。不过，它能工作真的很酷。
同样，如果你在 GPT3 中使用逗号，你会得到更多类似的东西，这取决于模型大小/微调。虽然不确定在 17 个例子中发生了什么。
我认为这里发生的事情是，因为它不能提前预测，有时它开始制造随机数字，直到它到达末尾，然后这给了它检查下一次应该是什么前几个数字的上下文。虽然我不完全确定。这些模型很奇怪。
一行用于数据分析的 Python 代码
现在，您不需要编写数百行代码
Python 是程序员和数据科学家最常用的编程语言之一。程序员喜欢 Python，因为它的程序员友好的行为。数据科学家热爱 Python，因为大多数机器学习和深度学习库都有 Python 版本。
当我们谈论程序员或数据科学家时，在现实世界中，当我们为任何项目或客户工作时，我们都需要理解数据。数据是每个行业的决定性因素。我们需要应用不同的编程逻辑、分析和进一步的建模练习来了解数据。
分析数据并使数据适合您的任务花费了大量时间。在 python 中，我们有一个库，可以在一行 python 代码中创建端到端的数据分析报告。
本文将介绍这个库，它可以在一行代码中为我们提供详细的数据分析报告。你唯一需要的就是数据！
熊猫 _ 简介
pandas_profiling是最著名的 python 库之一，程序员可以用一行 python 代码立即获得数据分析报告。
装置
要安装该库，可以使用 pip 命令，如下所示。
pip install pandas_profiling
导入库
一旦安装了pandas_profiling,我们可以使用下面的 import 命令导入这个库。
import pandas_profiling
import pandas as pd
我们将使用熊猫来导入数据集。
关于数据
在这篇文章中，我们将使用开源房价数据。数据可以从这里下载。
导入数据集
数据快照
获取数据分析报告
一旦我们准备好数据，我们就可以使用一行 python 代码来生成数据分析报告，如下所示。
hourse_price_report=pandas_profiling.ProfileReport(df)
运行下面的命令后，您将看到进度条根据特定参数生成数据分析报告。
生成数据分析报告
将报告保存为 HTML 格式
成功生成报告后，我们可以将报告保存为 HTML 文件并与其他人共享。
您可以使用下面一行代码将报告保存为 HTML 格式。
hourse_price_report.to_file('house_report.html')
您可以从数据分析报告中获得什么
总体数据摘要
作者截图
每个变量的详细信息
作者截图
作者截图
变量之间每个相关性的详细可视化
作者截图
作者截图
缺失值计数
作者截图
不同种类的互动
作者截图
以及更多关于数据理解的激动人心的细节。
最终结束点
我们已经看到了一行 python 代码如何帮助我们提供详细的数据分析报告。
性能分析报告可以为我们提供数据的总体摘要、关于每个特性的详细信息、组件之间关系的可视化表示、关于缺失数据的详细信息，以及许多有助于我们更好地理解数据的有趣见解。
更多精彩文章敬请期待。我通常写编程和数据科学的实践方面。
感谢您的阅读！
在你走之前……
如果你喜欢这篇文章，并希望继续关注更多关于 Python &数据科学的精彩文章——请点击这里https://pranjalai.medium.com/membership考虑成为一名中级会员。
请考虑使用我的推荐链接注册。通过这种方式，会员费的一部分归我，这激励我写更多关于 Python 和数据科学的令人兴奋的东西。
还有，可以随时订阅我的免费简讯: Pranjal 的简讯 。
创建黑仔视觉效果必须知道的 10 个高级 Matplotlib 概念
窍门和技巧
成为 Matplotlib 忍者
拍照由 Joycoast Wood 手表&太阳镜 上 防溅 。除非另有说明，所有图片均为作者所有。
其实根本没有什么高级 Matplotlib 用户。问题只是谁在文档上花了更多的时间，并且实践了他们所阅读的内容。
所以，如果你的目标是成为一名“高级 Matplotlib 用户”，那么在你的道路上只有两个障碍。第一——花几个小时沉浸在 Matplotlib 文档中，第二——接触每一个遇到的代码块。我的工作是通过教授一些你只会在 10 分钟内看到专业人士使用的关键概念，让你跳过第一个障碍。
1️⃣.rcParams
让我们从最高层的概念开始。
我们清单上的第一个是字典。它包含所有用于创建图形默认样式的 Matplotlib 设置。您直接从matplotlib名称空间导入它:
在处理不同的项目时，您将不得不在不同的环境中为不同的受众呈现图表。基于这一点，你必须事先修改这本字典，这样你未来的视觉效果才会有一致的主题和风格。这也将节省时间，因为您可以避免每次创建新的绘图时调用相同的参数。
如果你搞砸了什么或者想回到默认状态，你可以调用 PyPlot 的rcdefaults函数，它会重置一切。
>>> plt.rcdefaults()
https://ibexorigin.medium.com/membership
获得由强大的 AI-Alpha 信号选择和总结的最佳和最新的 ML 和 AI 论文:
https://alphasignal.ai/?referrer=Bex
2️⃣.Get_*函数
实际上，Matplotlib 是完全面向对象的。
来自 Matplotlib 文档的图像
你在上图中看到的每个组件都是作为一个单独的类实现的。它们都继承自名为 Matplotlib Artist 的基类。这就是为什么你会经常在 MPL 文档中读到这个词。
为一个情节的每一个方面创建一个单独的类会带来一定程度的复杂性，但是它也给了你很大的灵活性。
一个伟大的情节的关键是定制。不仅仅是对剧情的简单改动，而是最深层次的定制。你应该能够调整你的视觉效果的每一个组成部分，使之符合你的品味、主题和专业性。
为了实现这一点，您应该知道如何提取您想要定制的组件。幸运的是，Matplotlib 有许多以get_前缀开始的函数，这允许您从创建的图形或轴中检索不同的类。这里有一个例子:
假设您想要定制该图的 xticks:
这很简单，只需在 axes 对象上调用get_xticklabels，就可以得到 Matplotlib Text实例的列表:
您也可以使用get_xticklines调整刻度线，或使用get_xticks调整刻度的位置。
你可能想知道，我们实际上如何调整这些对象？我们将在下一节回答这个问题。
3️⃣.获取/设置
一旦有了想要定制的组件，就应该知道它们接受什么属性或参数。这是你使用两把瑞士军刀的地方。
首先，在你的对象上调用plt.getp函数，看看它当前有什么参数。例如，假设我们想要对下面的图l2进行样式化:
如您所见，我将每个线图存储在一个单独的变量中，以备后用。现在，我们在第二行l2上调用plt.getp:
不出所料，该函数打印出了l2的默认值。要改变一个属性，我们将使用另一个函数- plt.setp。在不带任何参数的对象上调用此函数会打印出该对象接受的属性值:
要仅打印单个属性的可能值，您可以将属性名称作为字符串提供给setp:
现在，让我们最后对第二行做一些修改:
要查看更改后的当前图形，只需调用图形对象上的get_figure:
>>> fig.get_figure()
如你所见，第二行与其余的完全不同。
简而言之，如果您想要设置绘图中特定组件的样式，您应该遵循以下步骤:
- 通过直觉或者 MPL 的文档来识别元素的名称。
- 使用相关的
get_*函数提取它 - 用
plt.getp查看其当前属性 - 用
plt.setp找出每个属性可能接受的值 - 用同一个函数改变你想要的参数。
4️⃣.传说
图例是具有许多不同组件的复杂图的组成部分。一个好的情节不会让它的观众去猜测，而在一个传奇故事中提供准确和“容易理解”的信息是实现这一点的关键。
幸运的是，您可以仅使用 PyPlot API 中的plt.legend或 OOP API 中的ax.legend中的legend函数来控制任何绘图的图例。调用不带参数的函数会创建一个带有默认值的图例:
然而，正如我所说的，我们希望定制每个组件，使它们尽可能漂亮，当涉及到 Matplotlib 默认值时，我们很少能这么说。
所以我建议看一下legend函数的 Matplotlib 文档(链接)。然而，我认为传奇最重要的参数是:
loc-图例的位置bbox_to_anchor-另一个位置参数，特定于图例的舍入框(详情请阅读文档)- 字体属性—大小、颜色、样式
ncol-当有许多元素时，图例中的列数
也可以在创建图例后更改这些参数。只需用get_legend提取并使用getp、setp功能。
5️⃣.骑机车者
你有没有想过 Matplotlib 是如何改变它的颜色或者自己在不同的风格中循环的？
原因是，在幕后，Matplotlib 使用 Python 内置的称为 Cyclers 的对象:
cycle功能非常通用。它接受任何键值参数，并创建一个字典列表:
此外，您可以使用“加”和“乘”运算符组合多个循环，以获得参数的索引到索引或穷举组合:
现在我们知道了什么是循环程序，我们可以创建自定义的循环程序并将它们传递给我们的绘图，这样 Matplotlib 就只循环我们指定的参数。下面，我们创建四种不同的线条样式，允许 Matplotlib 在不同的线条颜色、样式和粗细之间循环:
您可以使用 axes 对象的set_prop_cycle功能将该自定义循环程序传递给绘图:
如你所见，正弦波的线条完全不同。
创建循环程序时，它们的每个参数和值都必须与 Matplotlib 对齐。例如，要创建一个迭代不同颜色的 cycler，您应该知道 Matplotlib 允许它的绘图使用哪种颜色。
您也可以将您的自定义循环仪添加到rcParams字典中。以下是默认值:
>>> rcParams["axes.prop_cycle"]
6️⃣.刻度参数
我提出的关于图例的所有论点都适用于轴刻度。轴刻度应准确传达数据点的最小值和最大值及其单位，并显示几个关键检查点，以便在不同的绘图部分之间进行比较。
如图例所示，大多数刻度属性可以通过 axes 对象的tick_params ( docs link )函数来控制。以下是其中的几个例子:
您应该始终指定的第一对参数是axis和which。根据这些参数，您设置的参数将应用于 X 轴或 Y 轴刻度以及次要或主要刻度。
顺便说一句，大多数时候，小记号在 Matplotlib 中是不可见的。要快速打开它们，使用轴对象上的minorticks_on功能:
这里有一个很棒的资源，它展示了关于tick_params函数的更多信息。
7️⃣.心脏
有时，您不想麻烦地给出定制的 tick 参数。在这种情况下，您可以使用许多内置的 Matplotlib 的 tick 参数“主题”集合，称为ticker。
如你所见，在ticker子模块下有很多。我建议使用文档浏览一下它们，了解一下它们各自的功能。
一般来说，标题中带有Locator的按钮控制刻度的位置。Formatter让您设计刻度标签的样式。通常，您会根据自己的需要使用一对定位器和格式化器。一旦您从上面的列表中选择，您可以通过以下方式将它们传递到您的绘图:
使用 axes 对象的xaxis或yaxis属性，并调用set_major(minor)_formatter(locator)函数，传入类名。上面，我们使用工程符号来格式化 X 轴记号。
8️⃣.添加自定义网格
一些情节中最微妙但最有影响力的元素之一是网格线。
一个经验法则是，当图中的水平和垂直变化会向上下文传达额外的含义时，创建网格。例如，当图中有许多条时，水平网格很有用。
在 Matplotlib 中，您可以使用 axes 对象的grid函数创建和定制网格。下面是一个难看的垂直网格示例:
我建议你阅读文档了解详情。
9️⃣.plt.bar_label()
条形图在数据分析过程中很常见。他们最重要的方面是每个酒吧的高度，所以你需要让你的观众容易区分每个酒吧。这就是你需要使用条形标签的地方。
您可以使用一些算术计算在每个条上方放置一个文本注释来手动完成此操作，但是有一种更好的方法。bar_label函数接受一个 BarContainer 对象作为参数，并自动用它的高度标注每个条。
这是一个简单的 Seaborn 计数图:
每次使用 Seaborn 或使用类似于ax.bar的函数创建柱状图时，BarContainer对象都会被添加到一个图中。然后，您可以使用 axes 对象的containers属性来检索这个容器对象:
>>> ax.containers[<BarContainer object of 5 artists>]
如您所见，上面的列表中有一个包含 5 个小节的 BarContainer 对象。现在，我们只需在创建情节后将该对象传递给bar_label:
请注意，当条形标签变得狭窄时，您需要修正轴限制。
1️⃣0️⃣.佐德
最后，我们还有另一个微妙的方面——显示顺序。当你叠加不同的情节时，这是一个重要的概念。你需要确保每一个情节都以正确的顺序绘制在画布上。要实现这一点，您需要zorder参数。
下面，我们用不同的 zorders 创建三行(取自文档):
效果清晰可见。如果你注意的话，图例的 zorder 是用set_zorder函数指定的，这也是可以接受的。此外，您还可以使用之前的plt.setp功能更改任何对象的排序。
摘要
我告诉过你什么？所有这些都非常简单。现在，悲伤的部分来了。
你可以掌握每一个 Matplotlib 函数和类，但你仍然不是 Leonardo da Matplotlib。很抱歉，在你开始画这样的东西之前，还需要几个月的时间:
问题不在于你知道多少功能和“高级”概念，而在于你如何使用它们。
在你离开之前，这里有一些我的读者喜欢的帖子。查看它们:
[## 多类分类指标综合指南
towardsdatascience.com](/comprehensive-guide-on-multiclass-classification-metrics-af94cfb83fbd) </25-numpy-functions-you-never-knew-existed-p-guarantee-0-85-64616ba92fa8> </7-cool-python-packages-kagglers-are-using-without-telling-you-e83298781cf4>
岩石物理学中机器学习的 10 个应用
增强岩石物理工作流程的机器学习示例
丹·梅耶斯在 Unsplash 上的照片
几十年的油气勘探已经导致了大量与井相关的测量数据的采集和存储，这些数据已被用于表征地下地质及其油气潜力。随着计算能力的提高和新机器学习算法的采用，这些大量数据的潜力在过去几十年中得到了越来越多的利用。在岩石物理领域，机器学习已被用于加快工作流程、将地质特征划分为离散电相、进行预测等等。
这篇文章的内容于 2021 年 9 月在伦敦岩石物理学会上发表，我的 YouTube 频道上有该演讲的修改版本。一定要喜欢，订阅它更多这样的内容。
什么是岩石物理学？
岩石物理学是一门研究岩石的物理和化学性质及其与所含流体相互作用的学科。它是石油和天然气行业中的一个主要学科，旨在了解和量化储层中可移动碳氢化合物的性质和数量。导出的属性包括孔隙度(可用于储存碳氢化合物的储存空间的数量)、渗透率(孔隙相互连接的程度)和水饱和度(充满水的孔隙空间的数量，这反过来可用于计算碳氢化合物饱和度。
岩石物理项目包括分析井下测井工具获得的测量值。这些工具测量岩石的各种属性，包括它们的天然放射性，以及它们对电流、活放射源和声信号的响应。推导出的许多特性随后被转换并用于成熟的经验公式(如阿尔奇公式)中，以计算所需的储层岩石物理特性。许多作者试图绕过经验方程，建立机器学习模型，利用测井数据直接预测岩石物理性质。
此外，与任何涉及数据的项目一样，大量时间(高达 90%)可能会花在乏味但非常重要的任务上，如数据收集、数据质量控制、数据校正和数据转换。因此，许多机器学习的文章和应用都专注于提高这些阶段的效率和速度。
下面的文章涉及 10 个例子，在这些例子中，机器学习被用来帮助处理岩石物理工作流程的各个方面。每一个例子都包含了使用这些技术的关键和有趣的论文的参考列表。
1。自动异常检测
在 Equinor Volve 油田的两口井上使用隔离森林的自动异常值检测。作者创造的形象。
异常值是位于数据集的正常或预期统计分布之外的数据点，它们可能由于测井测量中的各种原因而出现。原因包括但不限于:
- 测量和传感器误差
- 钻孔冲刷
- 钻井振动影响随钻测井工具
- 意外事件和地质
识别异常值并适当处理是非常重要的。这可以通过手动方法实现，如使用 Z 值、箱线图和常规交会图(散点图)。
最近许多研究论文都集中在使用无监督的离群点检测算法来突出潜在的离群点。这些方法包括 K 均值聚类、基于角度的离群点检测、支持向量机和隔离森林。
为了完全确认一个点或一组点是否是异常值，应该使用领域知识。这将降低可能是真实数据的点的错误分类的风险。
供进一步阅读的文章:
- Akkurt 等人，(2018): 利用机器学习加速和增强岩石物理分析:测井异常值检测和重建自动化系统的案例研究
- Banas 等人(2021 年):自动识别和修复不良测井数据的新方法
- Misra 等人(2020 年):测井和地球物理数据的无监督异常值检测技术
2。测井修复
Ivan vrani在 Unsplash 上拍摄的照片
一旦识别出异常值和坏数据，通常可以在进行岩石物理解释或应用机器学习模型之前将其移除或修复。
识别和检查数据质量问题的过程可能会占用项目中大量的时间，因为许多作者都在寻找自动化/半自动化该过程的方法。模型在被认为“良好”的井段上进行训练，然后用于预测有问题的井段。
供进一步阅读的文章:
- Banas 等人(2021): 自动识别和修复不良测井数据的新方法
- Cuddy (2020): 在岩石物理学中使用人工智能的好处和危险
- Cuddy (2002): 利用模糊性修复井眼电测井曲线
- Singh 等人，2020: 机器学习辅助岩石物理测井质量控制、编辑和重建
3.测井标准化
测井标准化是岩石物理工作流程的一个常见部分。它用于消除由许多问题引起的数据不准确，包括不同的工具和传感器技术、井眼环境的差异以及工具校准问题。
标准化是重新标定或重新校准测井曲线的过程，以便它们与油田或区域内其他井的测井曲线一致。这可以通过对所需曲线应用单点标准化(线性移位)或两点标准化(“拉伸和挤压”)来手动实现。
标准化通常用于伽马射线测井，但也可用于中子孔隙度、体积密度、声波和自然电位测井。除非有足够的理由，否则电阻率测井一般不进行标准化(Shier，2004)。
供进一步阅读的文章:
- Akkurt 等人，(2019): 测井标准化的机器学习
- 麦克唐纳(2021): 岩石物理学:Python 中的伽马射线归一化
- Shier (2004): 测井曲线标准化；方法和指南
4.自动测井对比
伊利亚·格拉西缅科在 Unsplash 上拍摄的照片
井间对比是一个常见的过程，其中一个或多个地质层段根据地质相似性(如岩性、生物含量或矿物学)联系在一起。对于地质学家来说，这可能是一项耗时费力的任务，自 20 世纪 70 年代以来，许多作者一直试图将这一过程自动化(Brazell 等人，2019)。最近，机器学习已被用于进行测井曲线对比，并取得了很大的成功。
尽管井与井之间的对比通常是由地质学家进行的，但有时岩石物理学家不得不处理顶部和相关性。当进行岩石物理分析时，相同地层的不同油井通常使用相似的参数。确保测井曲线正确相关，可使这一过程更顺利地进行。
文章延伸阅读:
- Bakdi 等人(2020 年):使用机器学习和面部识别技术自动进行油井对比
- Brazell 等人(2019): 一种基于机器学习的辅助测井对比方法
- Tokpanov 等人，(2020) 基于深度学习的自动化地层对比
5。缺失测井曲线预测
多口井的可视化说明了不同程度的数据覆盖，从单点到整个曲线。作者创造的形象。
在进行地下表征时，数据集尽可能完整至关重要，但是，也存在测井测量缺失的情况。这可能包括不同年份的测井记录、测井速度超过工具采样率、井眼环境问题、数据管理不当、昂贵的采集成本和套管效应。
在这些情况下，可以使用剩余测井测量值之间的经验关系或通过使用来自当前井和/或补偿井的机器学习模型来填充数据。
供进一步阅读的文章:
- Akinnikawe 等人，(2018): 使用机器学习技术生成合成测井曲线
- Anemangley 等人，(2018): 使用岩石物理测井预测剪切波速的机器学习技术
- McDonald (2020): 使用 Matplotlib 可视化油井数据覆盖
6。测井测量的深度校准
对比两次伽马射线测井，一次来自主测井通道，另一次来自重复测井通道。测井曲线之间的偏移程度是变化的，并且通常不是固定的偏移。图片来自 McDonald(2021)——岩石物理机器学习模型的数据质量考虑。
深度是一口井成功开发和完井的关键测量指标，所有测井记录都与深度相关。它允许选择射孔间隔，并在正确的深度设置封隔器。因此，所有测量都必须使用一致的深度参考。
由于多种原因，测井测量可能彼此偏离深度，包括随钻测井和电缆测井之间的不同深度参考、电缆拉伸、工具类型和测井之间的不同采样率，甚至半潜式钻井平台上天气条件和海面膨胀的变化。在石油和天然气行业，确保多次通过和运行的测井记录一直是一个长期的挑战。
传统上，数据的对齐是手动进行的，通过在关键特征处添加的多通道和引脚，比较两条或多条测井曲线。然后将这些特征对齐，以创建彼此深度一致的数据。这一过程经常会有偏差，而且执行起来可能很耗时。
多年来已经开发了半自动和自动方法，利用两条测井曲线之间的互相关和协方差测量。然而，最近许多作者试图使用机器学习模型来自动化这一过程，并消除任何偏见。
供进一步阅读的文章:
- Bittar 等人(2020 年):多井测井深度匹配的强化学习技术产生更好的油藏描述
- 乐等(2019): 测井深度自动匹配的机器学习框架
- Zimmerman 等，(2018): 基于机器学习的测井深度自动匹配
7。根据离散岩心测量预测连续曲线
岩心孔隙度和渗透率线性回归预测结果。图片作者。
岩石物理学家的主要成果之一是渗透率。它用于指示流体(尤其是碳氢化合物)流过岩石或储层的难易程度。目前，没有测井仪器可以直接测量井下地层渗透率，而是必须根据仪器响应或经验关系进行估计。许多经验关系是从特定地理和地质区域的岩心测量中得出的，可能不完全适用于其他区域。因此，通常的做法是导出岩心孔隙度和岩心渗透率之间的关系，并将该关系应用于测井导出的孔隙度。
岩心数据并不总是可用的，可能只存在于油田或开发中的少数几口井中。这是因为取芯操作既昂贵又耗时。因此，多位作者采用了机器学习模型，这些模型在关键油井上进行训练，然后用于预测所有其他油井渗透率。
供进一步阅读的文章:
- Akinnikawe 等人，(2018): 使用机器学习技术生成合成测井曲线
- 阿尔-安纳济和盖茨(2010 年):非均质储层渗透率预测的支持向量回归:对比研究
- Arkalgud 等人(2019): 畴转移分析——岩石物理分析的一种稳健的新方法
- Elkatatny 等人，(2018): 利用人工智能网络从测井曲线预测非均质碳酸盐储层渗透率的新见解
- McDonald，2020: 使用 Python 中的线性回归分析孔隙度-渗透率关系
- Saputelli 等人，(2019): 利用自组织映射(SOM)和人工神经网络(ANN)推导渗透率和储层岩石类型——实现岩心-测井整合的最佳工作流程
8。相预测
了解地下岩性是地球科学和岩石物理学中的一项重要任务。推导岩性标志或矿物体积是经常分配给岩石物理学家的任务之一。
机器学习算法通常被用来将测井记录测量值分成不同的岩性组，称为岩相。这个过程可以使用无监督学习或监督学习算法来实现。
数据的无监督聚类是探索性数据分析(EDA)的一种常见形式，用于根据共享的特征或属性将数据分成不同的组。彼此相似的数据点被分组在同一个群集中，而不同的数据点被放在另一个群集中。
供进一步阅读的文章:
- Cuddy & Putnam，1998: 使用模糊逻辑从电测井预测岩相和渗透率。
- Hall，2016: 利用机器学习进行相分类
- McDonald，2021: 如何使用 Python 对测井数据进行无监督聚类
- 张，詹，2017: 机器学习在岩石相分类中的应用:XGBOOST
9.地质力学性质预测
照片由 Chanhee Lee 在 Unsplash 上拍摄
诸如体积密度和声波慢度之类的测井测量可用于深入了解储层的应力和岩石性质(杨氏模量、体积模量、泊松比等)。地质力学性质的推导是钻井规划中的一个重要步骤，以确保安全钻井和成功完井。它还可以让我们了解岩石如何随着应力、温度和压力的变化而变化和变形。
获取地质力学特性的最准确方法是对从油井中获取的岩心样本进行破坏性测试。这通常是在少量样本上完成的，用于校准和验证测井测量值和属性之间的经验关系。当在常规储层中获取岩心样品时，通常是在储层段上方，忽略了上覆层段。如果感兴趣，这将导致推断与这些部分的关系。
供进一步阅读的文章:
- AlBahrani 等人，(2021): 使用机器学习辅助的多孔弹塑性有限元方法建立完整的钻井地质力学模型
- 宋等，(2021): 利用机器学习方法预测和分析吉木萨尔页岩的地质力学性质
10。岩石物性预测
克里斯托弗·伯恩斯在 Unsplash 上拍摄的照片
确定关键的储层性质是岩石物理学家的主要任务之一，通常通过完善的关系和方程来实现。然而，许多研究集中在使用测井测量预测这些属性。
供进一步阅读的文章:
- Khan 等人，(2018 年):机器学习衍生的相关性，用于确定复杂岩性中的含水饱和度
- Basu 等人(2020 年):岩石物理工作流程与机器学习——威利斯顿盆地达科他集团的比较案例研究
- MacGregor 等人，(2018): 利用机器学习简化岩石物理工作流程
摘要
我们做到了！我们已经看到了 10 个机器学习可以为岩石物理工作流程带来益处和附加值的例子。这 10 个例子绝不是应用机器学习的唯一方式，在文献中还有更多。你是否遇到过机器学习在岩石物理领域的不同应用？如果是这样，请在这篇文章上留下你的评论，或者在 LinkedIn 上联系我们。
感谢阅读！
如果您觉得这篇文章有用，请随时查看我的其他文章，这些文章介绍了 Python 和测井数据的各个方面。你也可以在GitHub找到我在这篇文章和其他文章中使用的代码。
如果你想联系我，你可以在LinkedIn或者我的 网站 找到我。
有兴趣了解更多关于 python 和测井数据或岩石物理学的知识吗？跟我上 中 。
每个程序员都应该知道的 10 个基本 Shell 命令
更快更有效地使用您的计算机
照片由 Reza Namdari 在 Unsplash 上拍摄
我们都——可能——使用一些 GUI 开始了我们的数据科学或编程之旅。一个工具或一个应用程序，一切都建立起来了，我们只需要写代码，点击一些按钮来编译和运行它。瞧，结果出来了，我们结束了。
虽然图形用户界面绝对没有问题，但是随着你职业生涯的发展，你将需要一种更好、更快、更有效的方式来控制你的计算机并完成工作。它使用 shell 命令(Windows 中的命令提示符)来控制您的工作站。如果您想让自己的编程技能和职业生涯更上一层楼，使用 shell 命令是一项必须掌握的技能。
使用 shell 命令，您将能够利用计算机的真正能力，在更短的时间内完成更多的任务。一旦您掌握了 shell 命令，您将能够编写一些命令来更新您的系统，远程配置您的 web 服务器或数据库，以及更多更多的功能。
所有这些功能都始于一些基本的命令，以执行简单而重要的任务。在本文中，我将介绍 10 个基本的 shell 命令，无论从事什么领域的程序员都必须熟悉这些命令。
№1:列出目录中的所有文件
最基本和有用的命令是ls命令。我们经常将源代码文件和其他重要文件放在系统的特定目录中。ls命令将显示当前目录下的所有文件夹。
句法
$ ls
当前目录是你运行ls命令的地方。运行该命令将显示如下内容。
作者截图
№2:更改目录
如果您只想知道当前目录中有什么，使用ls命令是很好的。但是，如果您需要访问另一个目录呢？
这里是cd命令出现的地方。cd命令是“更改目录”的缩写使用该命令的方法是写入 cd，然后写入您要移动到的目录的名称或路径。
cd 命令有一些特殊的用法，主要是键入cd ..将带您回到目录树中的一个步骤，而键入没有目录名的cd将带您回到主目录。
句法
$ cd directroy_name
作者截图
№3:创建新目录
要创建一个新的目录—文件夹—您需要使用 make directory 命令(mkdir)。mkdir命令只是创建一个新文件夹；你需要给它一个名字和一个路径。然后,mkdir将在给定的路径中创建一个具有给定名称的文件夹。
如果您没有为该命令提供路径，它将在您的当前目录中创建文件夹。一旦创建了文件夹，您可以通过运行ls命令来查看它。
句法
$ mkdir directory_name
$ mkdir directory/path/newdir
作者截图
№4:创建文件
到目前为止，我们已经学习了如何更改目录、创建目录以及显示目录内容。如果你想创建一个文件呢？
然后你需要使用touch命令。这个命令可以用来创建各种类型的文件。这就是为什么在使用该命令时必须包含文件扩展名。
句法
$ touch file.extention
作者截图
№5:定位文件
如果你想在你的系统中搜索一个文件，你可以使用locate命令。哪种方式是在目录树中更快地找到文件的方法？
您可以通过添加或排除 -i 选项，让locate命令搜索一个区分大小写或不区分大小写的文件名。此外，您可以使用*来扩大搜索范围。如果您添加了 -r 选项，您甚至可以查找正则表达式。
句法
$ locate [option] file_name
№6:移动文件(mv)
如果要更改一个文件或一组文件的位置，可以使用 move (mv)命令来实现。mv 命令需要两条信息，您想要重定位的文件和新的目标位置。
句法
$ mv file_name path/to/move/to
作者截图
№7:移除文件和目录
假设您想要移除/删除一个文件或目录；您可以使用移除(rm)命令。如果您想要删除文件，您可以使用rm命令，后跟您想要删除的文件的名称或路径。
但是，如果你想删除一个文件夹，那么你需要在使用rm命令时添加 -r 选项。
作者截图
句法
$ rm [option] file/directory/name
rm命令的一个稍弱的变体是rmdir。该命令用于删除空文件夹/目录。
№8:获取当前路径
有时你会深入目录树，以至于迷失了方向，不再知道自己的确切目录。尽管 shell 命令的标题应该告诉您当前的位置，但是您可以使用pwd命令获得一个完整的位置。pwd代表打印工作目录。
句法
$ pwd
作者截图
№9:显示用户信息
您还可以使用 shell 来显示当前登录用户的信息。要做到这一点，您可以使用命令 whoami，它完全按照它所说的那样工作。
句法
$ whoami
作者截图
№10:清除外壳屏幕
在一些命令之后，你的外壳屏幕会变得混乱和拥挤。您可以从屏幕上清除旧命令及其结果，并使用clean命令开始清除。
句法
$ clear
外卖食品
作为一名程序员，无论你是一名数据科学家，一名应用程序开发人员，还是一名 web 开发人员，迟早你会发现自己需要掌握和使用 shell 命令来控制你的计算机。
使用 shell 将允许您使用计算机的全部功能并优化您的工作流程。在本文中，我介绍了每个程序员都应该熟悉的核心 10 个 shell 命令。当然，还有更多的命令，在你的职业生涯中，你会学到越来越多的命令。
掌握 shell 是您职业发展和进步的必经之路。好消息是，您实际上不需要记住这些命令；每天使用它们，你会自动做到。
shell 命令的世界是广阔的，命令本身根据您使用的系统而有所不同。本文中提到的是 Unix/ Mac 命令；它们的 Windows 版本略有不同。这可能会让事情有些混乱，但是随着练习和时间的推移，它会成为你的第二天性。
了解更多关于数据科学和机器学习的 10 个最佳免费网站
意见
分析 10 个最好的免费网站，以获得更多关于机器学习和数据科学的知识
在 Unsplash 上由 Boitumelo Phetla 拍摄的照片
随着数据科学和机器学习的流行程度不断增加，更多的有志之士和爱好者正在探索这些领域。数据科学和机器学习创造了大量的机会。
每个人都渴望了解这些领域，并最终增加一些额外的知识。对于初学者和专家来说，有一些很棒的免费网站可以学习并获得进一步的曝光。
对于试图理解任何主题并了解数据科学和机器学习的确切实体并获得进一步复杂知识的初学者来说，从一些免费资源和材料开始总是更好。
虽然最初从数据科学开始，但在你真正喜欢上它之前，你不想在这个主题上花太多钱。幸运的是，数据科学是一门拥有大量奇妙资源的学科，可以在您的旅程中为您提供帮助。
有一些网站致力于为所有用户免费提供高质量的数据科学和机器学习内容，以最大限度地利用这些资源并从中受益。
在本文中，我们将尝试探索十个免费网站，我们可以利用它们来获得更多关于机器学习和数据科学的知识。所以，事不宜迟，让我们开始分析它们。
1.卡格尔
Kaggle 也许是这个列表中最重要的条目。Kaggle 不仅仅是一个免费网站，而且 Kaggle 还是一个支持高质量数据科学、机器学习和深度学习项目的社区，以及许多其他可用的选项。
Kaggle 旨在为您提供有用的代码和资源，让您从零开始实施自己的项目，并为您提供大量数据集和数据储备，用于处理众多项目创意。
社区是支持的，并提供带有分析、探索性数据分析和代码的 Jupyter 笔记本。Kaggle 每年都会举办一系列比赛，您可以自由参加比赛，亲自探索。
Kaggle 还为您提供了一些 winners 解决方案，您可以从中阅读和学习，并在您的项目中进行实验。总的来说，Kaggle 是顶级免费网站选项之一，作为初学者或专家数据科学爱好者，你应该完全考虑利用它。
2.机器学习掌握
Jason Brownlee 的机器学习大师网站提供了一些互联网上最好的资源和内容。它涵盖了多个主题，并深入探讨了数据科学中一些最引人注目和最有趣的概念。
这个网站为每一个爱好者和渴望者提供内容和有用的资源。不管你是初学者还是专家，你访问这个网站都会获得很多难以置信的价值，而且这里的大部分内容都是免费的。
资源范围从初学者安装过程一直到复杂的机器学习、神经网络和深度学习计算和项目。如果你喜欢这个网站，作者也有很多高质量的书籍，你可以购买来支持他们。
我广泛地使用了这个网站，并从中传授了许多知识。我强烈建议每个数据科学爱好者至少访问一次这个网站，因为它涵盖了概念、代码、复杂的细节和对几个主题的理解。
3.带代码的文件
代码为的论文，顾名思义，涉及附有简明代码的研究论文。
这是一个令人惊叹的平台，也是一个完全免费的网站，所有爱好者都可以访问并了解更多关于数据科学、机器学习、深度学习等等的知识。
其中涉及的一些概念和主题对于初级用户来说可能相当高级。但由于研究论文旁边提供了代码，数据科学爱好者分析这些项目变得更加容易。我强烈推荐看看这个网站。
4.开源代码库
GitHub 是找到详细代码和编码架构的最佳地方。使用 GitHub 的主要原因是向许多优秀的人学习，他们提供详细的代码，让整个社区从中受益。
有了 GitHub，你不仅可以阅读和学习其他代码，还可以通过分叉在桌面上利用这些代码。您可以测试这些代码，验证它们，甚至根据您想要的项目修改它们以符合您的最大利益。
除了阅读他人的作品，您还可以发布您的项目和代码，供每个人使用和受益。将你的代码共享给所有人也是 GitHub 不可或缺的一部分。您可以通过更大项目的仓库或共享更小代码的简单 Gists 的形式来实现。
5.PyImageSearch
PyImageSearch(作者 Adrian Rosebrock)是帮助你开始计算机视觉项目的最佳网站之一。它还广泛涵盖了 OpenCV 和深度学习的主题，以免费构建简单和复杂的计算机视觉项目。
当我在做我的第一个计算机视觉项目时，这个网站是我发现的第一个网站，从那以后它就没有让我失望过。在我看来，该网站仍然是迄今为止构建计算机视觉项目的最佳机器学习资源之一。
如果你是一个计算机视觉项目的爱好者，并且想继续在这个领域建立更多的项目，我强烈建议你去这个网站查看更多的学习材料、知识和资源。如果你想支持作者，你也可以买他们的计算机视觉书籍。
此外，如果您对使用 OpenCV 学习计算机视觉感兴趣，并且希望从零开始学习初学者指南，我强烈建议您查看我的 21 分钟文章，该文章涵盖了这个主题。您可以通过下面提供的链接来完成。
6.走向数据科学
作者截图来自 TDS
走向数据科学是 Medium 上最大的出版物之一，Medium 是让浏览者了解与数据科学、机器学习、可视化、计算机视觉等相关的思想、想法、代码和信息的最佳网站之一。
在免费网站上列出 TDS 的主要原因是，尽管访问无限内容只需要 5 美元，但你仍然可以免费查看大量关于数据科学和机器学习的有用资源和信息。
有一些了不起的高质量的作家在研究数据科学，并且为您提供了顶级的标准内容。您可以利用这个平台来加深对数据科学各种概念的理解和掌握。
7.谷歌人工智能
Google AI 是 Google 致力于人工智能的一个部门。该网站也是免费的，提供与数据科学和机器学习相关的信息。
谷歌人工智能希望教育所有用户人工智能的好处，因此它是一个学习和获得更多人工智能知识的免费网站。
谷歌人工智能平台是一个非常有用的网站。它在其武库中提供了一系列广泛的主题，包括研究主题，人工智能领域的人员和用户教育，使用人工智能的众多工具，以及学习概念以开发人工智能技能的博客。
8.油管（国外视频网站）
YouTube 是一个通过视频内容了解更多机器学习和数据科学的绝佳平台。
你可以浏览各种渠道，疯狂观看一些令人惊叹的视频，这些视频会启发你，教会你这些领域的实用知识和实现。
我个人推荐的有 Sentdex，3Blue1Brown，TechWithTim，科里斯查费等。在众多精彩的频道中。这些是 YouTube 上最好的频道，你可以从中找到精彩的深入解释，更直观地理解概念。
9.张量流
TensorFlow 是开发一些惊人的数据科学和机器学习项目的最佳深度学习框架之一。
然而，除了这个用于解决复杂计算问题的惊人的库之外，它还有一个免费的网站来了解和获取关于 TensorFlow 的知识。
TensorFlow 网站为用户提供了官方文档、指南、有用的资源和代码，帮助他们开始使用 TensorFlow，并从头开始创建一些精彩的项目。
TensorFlow 的支持和开发工具正在快速构建。该网站还提供了基本的数据集和一些示例问题的解决方案。我强烈建议您登录网站，使用 TensorFlow 掌握深度学习。
10.Reddit、Quora 和堆栈溢出
Arnel Hasanovic 在 Unsplash 上拍摄的照片
在这一点上提到的三个资源倾向于服务于类似的目的，即，社区互动和参与，以及对几个问题的回答以获得澄清。
Reddit 是用户进行互动的地方，Reddit 中机器学习和数据科学的特定位置是非常有用的免费网站，可以了解更多信息，并获得对您可能遇到的一些问题的进一步回答。
Quora 是另一个类似的网站，有专门的 Quora 空间，致力于学习和获得更多关于数据科学或机器学习的知识。您还可以提出更多一般性问题，并免费获得答案和帮助。
堆栈溢出是接收高级问题答案的最佳资源。该网站有大量有用的内容和许多常见问题的精彩答案。它还提供了针对错误和缺陷的解决方案以及相应的修复方法。
威廉·艾文在 Unsplash 上的照片
结论:
在本文中，我们介绍了十个最好的数据科学和机器学习免费网站资源，供初学者入门，也可供更高级别的用户受益。
这里提到的每一个资源都包含了大量的内容和有价值的信息，你可以利用它们来更好地掌握这门学科，并通过获得更多的知识而从中受益。
如果你还没有的话，我强烈推荐你看看下面的免费网站资源。通过阅读、理解、分析并最终处理这些网站提供给你的信息，你可以学到很多东西。
这篇文章最好的部分是，这里提到的资源只是许多可能性中的十种。数据科学和机器学习是如此新鲜的主题，以至于你有无限的可能性。
它们的资源是无限的，在未来的文章中，我们将尝试覆盖至少十个以上这样令人惊叹和有用的网站，它们可以帮助您踏上数据科学之旅！
如果你对这篇文章中提到的各点有任何疑问，请在下面的评论中告诉我。我会尽快给你回复。
看看我的其他一些文章，你可能会喜欢读！
</11-crucial-mistakes-to-avoid-as-a-data-scientist-71c29aef028> </8-revolutionary-artificial-intelligence-technologies-of-the-modern-era-f8f22a4127d0> </5-best-ways-to-earn-income-from-data-science-a9c8fed1eee6>
谢谢你们坚持到最后。我希望你们喜欢阅读这篇文章。我希望你们都有美好的一天！
学习编程的 10 个最佳免费网站
意见
快速浏览 10 个最好的免费网站，从中学习编程并提高您的编码技能
照片由 Fotis Fotopoulos 在 Unsplash 上拍摄
“编程不在于你知道什么；而是你能想出什么。”——克里斯·派恩
编程很好玩！每个人都必须尝试参与和学习的可喜经验。编程打开了许多大门，允许新开发人员利用和实现新项目。
如果你是一个初学者爱好者或者只是想学习更多的编程语言，对你来说最好的免费资源是什么？
在当今世界，编程已经变得比以往任何时候都重要。大多数有志于编程的人都想发展他们的编码技能，并有效地提高他们的编程基础。
由于不断增长的需求，有许多盈利的组织、公司和课程为您提供关于您选择的任何特定语言的编程的深入指南和内容，大多数初学者更喜欢通过免费网站和课程来提高他们的技能。
我强烈推荐查看我以前在十大免费网站上的一篇文章，通过下面提供的链接了解更多关于数据科学和机器学习的知识。
</10-best-free-websites-to-learn-more-about-data-science-and-machine-learning-f2c6d7387b8d>
虽然可以说付费内容和课程有助于获得更有成效的结果，但在本文中，我们将看看十个最好的免费网站，它们可以让你将编程和编码技能提高到一个新的水平。
学习编码或新编程语言的首选方法是使用互联网上的免费内容。这将帮助你权衡你的选择和兴趣。所以，事不宜迟，让我们进入最好的免费网站学习编程。
1.黑客排名
Alex Kotliarskyi 在 Unsplash 上的照片
HackerRank 是互联网上最好的网站之一，因为它为初学者开发者提供了各种各样的资源。它有一些快速速成课程，包括获得更多编程语言经验的 30 天挑战。
它为编码爱好者提供了大量的编程语言，让他们了解更多并投入更多的时间。HackerRank 可能是你被公司聘用的最佳网站。大多数编码面试都是在这些网站上成功进行的。
HackerRank 是开发者和公司的地方。当程序员试图通过尝试这些网站上的众多挑战来提高他们的编码技能和增加他们的熟练程度时，这些公司同时也在招募能够解决他们面试问题的最佳候选人，并复制最佳的可能结果和结果。
2. freeCodeCamp
自由代码营是一个非营利组织，为程序员和开发人员提供一些最有用的内容和有益的资源。它为初学编程的爱好者提供了大量高质量的帖子、指南和材料来练习和掌握他们的编码技能。
列出他们在互联网上发布的一些精彩内容，包括使用 HTML、CSS 和 JavaScript 等编程语言练习 web 开发的交互式学习 web 平台。有许多作业和练习题，你可以单独或两人一组完成，以达到预期的效果。
他们网站上的一些免费认证包括响应式 web 设计系统、JavaScript 的算法和数据结构、前端开发库、数据可视化和数据科学、Python 的数据分析、信息安全、API 和微服务、Python 的机器学习等等。
3. GeeksforGeeks
Geek For Geeks 是我最喜欢的平台之一，它提供免费内容，让我了解更多编程语言和其他与编码相关的主题。它包含了精心编写的、经过深思熟虑的和解释清楚的计算机科学和编程文章、测验等等，使用户能够获得更多的经验并增强他们的编码技能。
对于极客们来说，Geek 最大的好处在于，你可以在你正在寻找的特定主题和概念上找到有用的内容，他们通常不会让你失望。如果您搜索某个特定的编程主题，很有可能会收到更新的、高质量的带代码的帖子。
获得的这些代码可用于多种编程语言，包括 C、C++、Java、Python 和其他类似的编码语言。也可以参考这个网站，学习对竞技编程更直观的认识，参加各种赛事。它还涵盖了初级开发爱好者所需的大部分基础知识。
4.代码学院
Codecademy 是初学者和编程爱好者投入时间和精力来提高编码技能的绝佳场所。Codecademy 提供 12 种不同编程语言的免费在线互动会话，包括 Python、Java、Go、JavaScript、Ruby、SQL、C++、C#、Swift 和 Sass，以及标记语言 HTML 和 CSS。
它也是学习编码的最佳平台之一，你必须完成这些任务才能进入下一阶段。这种级别的编码系统和编程的连续进展系统将有助于用户和开发人员进一步参与和学习。
您可以选择自己喜欢的编程语言，并对其进行研究，直到产生最有效的结果。您通过代码片段和自己执行这些代码块来学习。它为每一个爱好者提供了高交互性的探索和实践目的。你会收到即时反馈，这将有助于你纠正自己，更恰当地学习。
5.共同导师
DevProjects 是一个免费的社区，人们可以通过参与策划的项目来学习编程。每个项目都是由高级开发人员和导师专门设计的，以弥合理论和现实世界代码之间的学习差距。用户可以与同事和导师讨论项目细节，并分享他们的代码以获得反馈。
如果你在寻找更多与 Python 相关的具体项目，可以查看下面的链接。您可以构建大量高质量的 Python 项目，这些项目在现实世界中有许多应用。开发人员可以充分利用这些项目进行实践，发展他们的编程技能，并最终将这些项目添加到他们的投资组合或简历中。
我强烈推荐查看以下网站，因为它为您提供了构建 Python 项目的机会。最棒的是，如果你在一个特定的问题上陷入困境，你将从现有的导师那里获得帮助，他们将指导你解决问题，并取得尽可能好的结果。
6.黑客帝国
Elena Mozhvilo 在 Unsplash 上的照片
与 HackerRank 类似，HackerEarth 为开发者和公司都提供了一个平台。虽然程序员可以选择在参加众多比赛和挑战的同时练习、学习和开发各种项目，但公司通常利用该网站进行技术技能评估和远程视频面试。
还有一堆面试问题和其他方法，通过实践测验和黑客马拉松来提高你的编码技能，你可以参加并赢得令人兴奋的奖品。您可以测试您的整体编码技能，并将您的编程成就提高到一个新的水平。如果你感兴趣，你甚至可以被招聘公司录用。
7. W3Schools
W3Schools 是一个在线学习网络技术的培训网站。内容包括与 HTML、CSS、JavaScript、JSON、PHP、Python、AngularJS、React.js、SQL、Bootstrap、Sass、Node.js、jQuery、XQuery、AJAX、XML、Raspberry Pi、C++、C#和 Java 相关的教程和参考资料。
W3Schools 为开发者免费提供了一些学习内容的最佳资源。它有一个文档风格的方法来提供信息以及有用的交互式代码块，您可以单击“自己尝试”按钮并探索这些选项。
W3Schools 提供了一些最好的在线编程教程，以及用代码块进行实验的很好的例子。它还为您提供了一些最好的参考资料、练习和课程，供开发人员和其他用户参与和利用，以提高他们的工作效率。
8.编程媒体平台
图片来自 TDS
本文中讨论的其他网站有助于提高您的编程和编码技能，为不同类型的用户提供实际的练习题和其他有益的资源。虽然这可能适合大多数场景，但是您还需要研究其他选项，这些选项为您提供指导、高级教程和其他有用的工具。
像《走向数据科学》和《更好的编程》这样的媒体出版物是用户了解更多编程知识以及获得与编码相关的其他实践帮助的最佳平台。这些网站上的博客帖子和文章对初级程序员和开发人员非常有用。
下面是我在 TDS 上发表的一些编程文章的列表，你可以看看。
</10-steps-to-master-python-for-data-science-f54199bb328d>
9.油管（国外视频网站）
虽然本文中提到的所有其他资源大多包含理论文章和实践指南，但通过视觉和图像(尤其是视频形式)探索您的想法并了解更多信息总是一个好主意。YouTube 就是这样一个平台，它拥有大量免费的编程和编码内容，允许观众在视频运行时学习和直观地编码。
我个人推荐一些最好的 YouTube 视频来学习编程和提高你的编码技能，包括像 Sentdex 和科里·斯查费这样的频道来学习特定的高级编程教程。YouTube 上有大量令人惊叹的学习编程内容的频道，我们将在另一篇文章中讨论这个主题，我们将列出一些您应该订阅的最佳频道。
10.GitHub 和堆栈溢出
拉多万·纳基夫·雷汉在 Unsplash 上的照片
GitHub 是任何类型的编码相关项目的最佳网站之一。它为你提供了多种选择。如果你想分享你的代码或者在分叉后使用其他代码，这也许是你应该期待的网站的选择。无疑是每个开发者和程序员必须考虑的最佳选项之一。
在对特定代码块进行编程时，很容易卡住。在编码过程中，错误是不可避免的，当您无法自己修复错误时，向专家或其他编程爱好者求助通常是个好主意。Stack Overflow 社区就是这样一个网站，它为您提供了一个机会来解决您的疑问、疑虑和问题。
GitHub 和 Stack Overflow 都是很棒的网站，它们可以让你与编程领域的其他专家进行交流，并获得针对你的疑问和疑问的适当解决方案。这个社区非常有帮助，只要你从自己的角度努力提出问题，他们通常会提供答案。
作为一个旁注，我也强烈建议检查不和谐和松弛的节目频道。找到一个互动社区是很有用的，因为你有和你有相似兴趣的编码爱好者，你可以通过分享代码学到更多。您还可以一起或在一个小组中执行和处理复杂的项目，以创建有效的项目。
结论:
“在某些方面，编程就像绘画。你从一块空白的画布和一些基本的原材料开始。你综合运用科学、艺术和工艺来决定如何处理它们。”——T3【安德鲁·亨特】
本文中提到的大多数资源和网站都是值得信赖的，互联网上有一些最好的内容。就我个人而言，我要么广泛地使用了这些资源中的大部分，要么在为本文的目的进行研究时访问了这些网站。我希望他们能够像我开始编程之旅时那样让观众受益。
我敢肯定，在这篇文章中，我可能错过了很多令人惊奇的在线免费资源。如果你觉得我错过了一些你想在这篇文章中看到的东西，请在下面随意评论，让每个人都知道许多其他在线免费网站，每个爱好者都可以从中受益和利用。
我非常有兴趣了解其他类似的免费网站和资源，以便初学者在编程的世界中生活。我会确保在未来写另一篇文章，涵盖其他重要的网站，让编程爱好者、有志之士和爱好者可以免费查看，并充分利用这些资源来提高他们的整体编码技能。
如果你对这篇文章中提到的各点有任何疑问，请在下面的评论中告诉我。我会尽快给你回复。
看看我的其他一些文章，你可能会喜欢读！
</5-reasons-why-you-should-develop-a-game-with-python-and-ai-9f5f276e7637>
谢谢你们坚持到最后。我希望你们喜欢阅读这篇文章。我希望你们都有美好的一天！
编写可读和可维护的 SQL 代码的 10 个最佳实践
如何编写你的团队可以轻松阅读和维护的 SQL 查询？
没有适当的指导方针，很容易弄乱 SQL。由于团队中的每个人可能都有自己编写 SQL 的习惯，您很快就会得到一个没有人理解的令人困惑的代码。
您可能已经意识到遵循一系列良好实践的重要性。
愿这篇文章能给你带来你正在寻找的指导！
1.使用大写字母作为关键字
让我们从一个基本的开始:对 SQL 关键字使用大写字母，对表和列使用小写字母。在 SQL 函数(FIRST_VALUE()、DATE_TRUNC()等)中使用大写字母也是一个很好的实践，尽管这更有争议。
避免
select id, name from company.customers
偏好
**SELECT** id, name **FROM** company.customers
2.对模式、表、列使用 Snake Case
编程语言在案例类型方面有自己的最佳实践:camelCase、PascalCase、kebab-case 和 snake_case 是最常见的。
谈到 SQL，Snake Case(有时也称为下划线 Case)是使用最广泛的约定。
避免
**SELECT** Customers.id,
Customers.name,
COUNT(WebVisit.id) as nbVisit
**FROM** COMPANY.Customers
**JOIN** COMPANY.WebVisit **ON** Customers.id = WebVisit.customerId**WHERE** Customers.age <= 30
**GROUP BY** Customers.id, Customers.name
更喜欢
**SELECT** customers.id,
customers.name,
COUNT(web_visit.id) as nb_visit
**FROM** company.customers
**JOIN** company.web_visit **ON** customers.id = web_visit.customer_id**WHERE** customers.age <= 30
**GROUP BY** customers.id, customers.name
尽管有些人喜欢使用变体来区分模式、表和列，但我建议坚持使用 snake case。
3.使用别名可以提高可读性
众所周知，别名是重命名没有意义的表或列的一种便捷方式。当表和列的名称没有意义时，不要犹豫给它们起别名，也不要犹豫给聚合起别名。
避免
**SELECT** customers.id,
customers.name,
customers.context_col1,
nested.f0_
**FROM** company.customers **JOIN** (
**SELECT** customer_id,
MIN(date)
**FROM** company.purchases
**GROUP BY** customer_id
) **ON** customer_id = customers.id
更喜欢
**SELECT** customers.id,
customers.name,
customers.context_col1 **as ip_address**,
first_purchase.date **as first_purchase_date**
**FROM** company.customers **JOIN** (
**SELECT** customer_id,
MIN(date) **as date**
**FROM** company.purchases
**GROUP BY** customer_id
) **AS first_purchase**
**ON** first_purchase.customer_id = customers.id
我通常用小写字母as作为列的别名，用大写字母AS作为表的别名。
4.格式:小心使用缩进和空格
尽管这是一个基本原则，但它能让你的代码更具可读性。就像使用 python 一样，您应该标识您的 SQL 代码。
当使用子查询或派生表时，在关键字后使用 Ident。
避免
SELECT customers.id, customers.name, customers.age, customers.gender, customers.salary, first_purchase.date
FROM company.customers
LEFT JOIN ( SELECT customer_id, MIN(date) as date FROM company.purchases GROUP BY customer_id ) AS first_purchase
ON first_purchase.customer_id = customers.id
WHERE customers.age<=30
更喜欢
**SELECT** customers.id,
customers.name,
customers.age,
customers.gender,
customers.salary,
first_purchase.date
**FROM** company.customers
**LEFT JOIN** (
**SELECT** customer_id,
MIN(date) as date
**FROM** company.purchases
**GROUP BY** customer_id
) **AS** first_purchase
**ON** first_purchase.customer_id = customers.id
**WHERE** customers.age <= 30
另外，请注意我们如何在 where 子句中使用空格。
避免
SELECT id WHERE customers.age<=30
偏爱
SELECT id WHERE customers.age <= 30
5.避免选择*
不值得提醒这种好的做法。你应该明确你想要选择什么，因此避免使用Select *。
让你的请求不清楚，因为它隐藏了询问背后的意图。另外，请记住，您的表可能会发生变化并影响Select *。这就是为什么我不是一个大风扇的EXCEPT()指令。
避开
SELECT * EXCEPT(id) FROM company.customers
更喜欢
**SELECT** name,
age,
salary
**FROM** company.customers
6.使用 ANSI-92 连接语法
…而不是用于连接表的 SQL WHERE 子句。
尽管您可以使用 WHERE 子句和 JOIN 子句来连接表，但是最好使用 JOIN / ANSI-92 语法。
虽然在性能方面没有区别，但是 JOIN 子句将关系逻辑与过滤器分开，提高了可读性。
避免
**SELECT** customers.id,
customers.name,
COUNT(transactions.id) as nb_transaction
**FROM** company.customers, company.transactions
**WHERE** customers.id = transactions.customer_id
**AND** customers.age <= 30
**GROUP BY** customers.id, customers.name
偏好
**SELECT** customers.id,
customers.name,
COUNT(transactions.id) as nb_transaction
**FROM** company.customers
**JOIN** company.transactions **ON** customers.id = transactions.customer_id**WHERE** customers.age <= 30
**GROUP BY** customers.id, customers.name
“基于 Where 子句”的语法—也称为 ANSI-89 —比新的 ANSI-92 要老，这就是为什么它仍然非常普遍。如今，大多数开发人员和数据分析师都使用 JOIN 语法。
7.使用公用表表达式(CTE)
CTE 允许您定义和执行查询，其结果是临时存在的，可以在更大的查询中使用。cte 可以在大多数现代数据库中找到。
它像派生表一样工作，有两个优点:
- 使用 CTE 可以提高查询的可读性
- CTE 被定义一次，然后可以被多次引用
你用指令用…声明一个 CTE 为:
**WITH** my_cte **AS**
(
SELECT col1, col2 FROM table
)
SELECT * FROM my_cte
避免
**SELECT** customers.id,
customers.name,
customers.age,
customers.gender,
customers.salary,
persona_salary.avg_salary as persona_avg_salary,
first_purchase.date
**FROM** company.customers **JOIN** (
**SELECT** customer_id,
MIN(date) as date
**FROM** company.purchases
**GROUP BY** customer_id
) **AS** first_purchase
**ON** first_purchase.customer_id = customers.id
**JOIN** (
**SELECT** age,
gender,
AVG(salary) as avg_salary
**FROM** company.customers
**GROUP BY** age, gender
) **AS** persona_salary
**ON** persona_salary.age = customers.age
**AND** persona_salary.gender = customers.gender
**WHERE** customers.age <= 30
更喜欢
**WITH** first_purchase **AS**
(
**SELECT** customer_id,
MIN(date) as date
**FROM** company.purchases
**GROUP BY** customer_id
),persona_salary **AS**
(
**SELECT** age,
gender,
AVG(salary) as avg_salary
**FROM** company.customers
**GROUP BY** age, gender
)**SELECT** customers.id,
customers.name,
customers.age,
customers.gender,
customers.salary,
persona_salary.avg_salary as persona_avg_salary,
first_purchase.date
**FROM** company.customers **JOIN** first_purchase **ON** first_purchase.customer_id = customers.id
**JOIN** persona_salary **ON** persona_salary.age = customers.age
**AND** persona_salary.gender = customers.gender
**WHERE** customers.age <= 30
8.有时，将查询分成多个可能是值得的
小心这个。让我们给出一些背景:
我经常使用 AirFlow 在 Bigquery 上执行 SQL 查询，转换数据，并准备数据可视化。我们有一个工作流程编排器(Airflow ),它按照定义的顺序执行请求。在某些情况下，我们选择将复杂的查询分成多个较小的查询。
而不是
CREATE TABLE customers_infos AS
SELECT customers.id,
customers.salary,
traffic_info.weeks_since_last_visit,
category_info.most_visited_category_id,
purchase_info.highest_purchase_valueFROM company.customers
LEFT JOIN ([..]) AS traffic_info
LEFT JOIN ([..]) AS category_info
LEFT JOIN ([..]) AS purchase_info
你可以用
**## STEP1: Create initial table** CREATE TABLE public.customers_infos AS
SELECT customers.id,
customers.salary,
0 as weeks_since_last_visit,
0 as most_visited_category_id,
0 as highest_purchase_value
FROM company.customers**## STEP2: Update traffic infos** UPDATE public.customers_infos
SET weeks_since_last_visit = DATE_DIFF(*CURRENT_DATE*,
last_visit.date, WEEK)
FROM (
SELECT customer_id, max(visit_date) as date
FROM web.traffic_info
GROUP BY customer_id
) AS last_visit
WHERE last_visit.customer_id = customers_infos.id**## STEP3: Update category infos** UPDATE public.customers_infos
SET most_visited_category_id = [...]
WHERE [...]**## STEP4: Update purchase infos** UPDATE public.customers_infos
SET highest_purchase_value = [...]
WHERE [...]
警告:尽管这种方法在简化复杂查询时非常有用，但它可能会带来可读性/性能的损失。
如果您使用 OLAP(或任何面向列的)数据库，尤其如此，该数据库针对聚合和分析查询(选择、AVG、最小、最大等)进行了优化，但在事务处理(更新)方面性能较差。
虽然在某些情况下，它也可能提高你的表现。即使是现代的面向列的数据库，太多的连接也会导致内存或性能问题。在这些情况下，拆分请求通常有助于提高性能和内存。
此外，值得一提的是，您需要某种程序或编排器来按照定义的顺序执行查询。
9.基于您自己的约定的有意义的名称
正确命名模式和表是很困难的。使用哪种命名约定是有争议的，但是选择一种并坚持使用它是没有争议的。你应该定义你自己的惯例，并让你的团队采纳。
计算机科学只有两个硬东西:缓存失效和事物命名。—菲尔·卡尔顿
以下是我使用的惯例示例:
模式
如果您使用的分析数据库有多种用途，那么以有意义的模式组织您的表是一个很好的做法。
在我们的 Bigquery 数据库中，每个数据源都有一个模式。更重要的是，我们根据目的以不同的模式输出结果。
- 第三方工具可以访问的任何表都位于 公共 模式中。Dataviz 工具如 DataStudio 或 Tableau 从这里获取数据。
- 由于我们将机器学习与 BQML 一起使用，我们得到了一个专用的 机器学习 模式。
桌子
根据惯例，表本身应该是名称。
在 Agorapulse，我们有几个用于数据可视化的仪表板，每个仪表板都有自己的用途:营销仪表板、产品仪表板、管理仪表板等等。
我们的公共模式中的每个表都以仪表板的名称为前缀。一些例子可能包括:
product_inbox_usage
product_addon_competitor_stats
marketing_acquisition_agencies
executive_funnel_overview
当与团队合作时，花时间定义你的惯例是值得的。当涉及到命名一个新表时，千万不要用一个你以后会“改变”的又快又脏的名字:你可能不会。
请随意使用这些例子来定义您的约定。
10.最后，写一些有用的评论…但不要太多
我同意这样的观点，一个写得很好并且正确命名的代码不需要注释。阅读您的代码的人应该在代码本身之前就理解其逻辑和意图。
尽管如此，注释在某些情况下还是有用的。但是你一定要避免过多评论的陷阱。
避免
**WITH** fp **AS**
(
**SELECT** c_id, # customer id
MIN(date) as dt # date of first purchase
**FROM** company.purchases
**GROUP BY** c_id
),ps **AS**
(
**SELECT** age,
gender,
AVG(salary) as avg
**FROM** company.customers
**GROUP BY** age, gender
)**SELECT** customers.id,
ct.name,
ct.c_age, # customer age
ct.gender,
ct.salary,
ps.avg, # average salary of a similar persona
fp.dt # date of first purchase for this client
**FROM** company.customers ct# join the first purchase on client id
**JOIN** fp **ON** c_id = ct.id# match persona based on same age and genre
**JOIN** ps **ON** ps.age = c_age
**AND** ps.gender = ct.gender
**WHERE** c_age <= 30
更喜欢
**WITH** first_purchase **AS**
(
**SELECT** customer_id,
MIN(date) as date
**FROM** company.purchases
**GROUP BY** customer_id
),persona_salary **AS**
(
**SELECT** age,
gender,
AVG(salary) as avg_salary
**FROM** company.customers
**GROUP BY** age, gender
)**SELECT** customers.id,
customers.name,
customers.age,
customers.gender,
customers.salary,
persona_salary.avg_salary **as** persona_avg_salary,
first_purchase.date
**FROM** company.customers **JOIN** first_purchase **ON** first_purchase.customer_id = customers.id
**JOIN** persona_salary **ON** persona_salary.age = customers.age
**AND** persona_salary.gender = customers.gender
**WHERE** customers.age <= 30
结论
SQL 很棒。它是数据分析、数据科学、数据工程甚至软件开发的基础之一:它不会等待。它的灵活性是一种优势，但也可能是一个陷阱。
一开始你可能没有意识到这一点，尤其是如果你是唯一负责自己代码的人。但是在某些时候，当与团队一起工作时，或者如果有人必须继续您的工作，没有一组最佳实践的 SQL 代码将成为负担。
在本文中，我总结了编写 SQL 的最常见的最佳实践。当然，有些是有争议的或基于个人观点的:你可能想从这里获得灵感，并与你的团队定义一些不同的东西。
我希望它能帮助您将 SQL 质量提升到一个新的水平！
数据科学的 10 大最佳工具和技术
意见
每个数据科学家都必须考虑探索的 10 种最佳工具和技术，以获得更好的曝光率和更高的工作效率
Alesia Kazantceva 在 Unsplash 上拍摄的照片
数据科学的迅速普及导致了大量工具和技术的产生，为数据科学爱好者带来了整体利润和好处。
世界上有一个新的流行术语叫做 数据 。大多数科技巨头，如谷歌、脸书、微软、IBM 和许多其他大小公司，都在数据和数据科学领域投入了大量宝贵的时间和资源。
对数据进行测量、收集、报告和分析，然后使用图表、图像或其他分析工具进行可视化。数据作为一个一般概念，是指一些现有的信息或知识以某种形式表示或编码，以便更好地使用或处理。
数据科学是将统计学、数据分析及其相关方法统一起来，以便用数据来理解和分析实际现象的一个概念。它使用数学、统计学、计算机科学、领域知识和信息科学范围内的许多领域的技术和理论。换句话说—
数据科学是一个跨学科领域，它使用科学的方法、流程、算法和系统从许多结构化和非结构化数据中提取知识和见解。数据科学与数据挖掘、机器学习和大数据相关。
在本文中，我们将深入了解十种您必须知道的神奇工具和技术！它们对于创建一些独特而酷的 Python 和数据科学项目非常有帮助。您可以利用它们来构建模型、创建项目、分析结果、部署目的等等！
因此，废话不多说，让我们从探索这些工具和技术开始，您可以使用它们来提高创建新项目的有效性和效率。
1.GitHub(和 Git)
对 GitHub 的了解是一个数据科学家的基本要求之一。GitHub 是展示代码和与优秀社区讨论项目的最佳场所。您可以以 Gists 的形式在存储库或代码块中共享您的工作，进入您的个人资料的大量受众都可以访问这些内容。
GitHub，Inc .是微软的子公司，使用 Git 为软件开发和版本控制提供托管服务。它提供了 Git 的分布式版本控制和源代码管理(SCM)功能，以及它自己的特性。它为每个项目提供了访问控制和几个协作功能，如错误跟踪、功能请求、任务管理、持续集成和 wikis。
GitHub 免费提供基本服务。其更高级的专业和企业服务是商业性的。免费的 GitHub 账户通常用于托管开源项目。总部位于加州，自 2018 年以来一直是微软的子公司。
如果你还没有 GitHub 账户，我强烈建议你创建一个。它是完全免费的，将为您展示您的项目并与社区中其他令人惊叹的数据科学成员合作开辟一个最佳场所。你可以从这里查看我的 GitHub 简介。
2.5 月
集成开发环境(IDE)是一种软件，它为程序的编译和解释提供了全面的工具。它为编码人员、爱好者和开发人员提供了一个平台，通过源代码编辑器、自动化工具和调试器来试验和解释代码/程序。
IDE 既可以支持单一的编程语言，如 Python 独有的 Pycharm，也可以支持多种编程语言，如 Visual Studio 代码。因为 python 是现代的流行语言，所以它有很多可用的开发软件，如 Pycharm、visual studio code、Jupyter notebooks 等。
例如，Visual Studio Code 是微软为 Windows、Linux 和 macOS 开发的免费源代码编辑器。特性包括对调试、语法高亮、智能代码完成、代码片段、代码重构和嵌入式 Git 的支持。它支持包括 python 在内的各种编程语言。您可能需要一些额外的安装来开始使用 Python，但是这非常简单。它不断更新，是 Python 和其他编程语言的最佳平台之一。我经常使用它，也强烈推荐它。
Jupyter Notebook 是一个开源的 web 应用程序，允许您创建和共享包含实时代码、等式、可视化和叙述性文本的文档。用途包括:数据清理和转换、数值模拟、统计建模、数据可视化、机器学习等等。Jupyter 笔记本绝对是开始学习数据科学和机器学习的绝佳选择。
这些笔记本可以与任何人共享，有助于更高效地协作编写代码。我强烈推荐使用 Jupyter 笔记本，因为你可以单独使用每个代码块，也可以选择使用降价。它被广泛应用于许多盈利的公司。以下是关于 Jupyter 笔记本的完整指南。
荣誉奖:谷歌合作实验室
Colaboratory (也被称为 Colab)是一个免费的 Jupyter 笔记本环境，它运行在云中，并将笔记本存储在 Google Drive 上。Colab 最初是谷歌内部项目；有人试图开源所有代码，并更直接地在上游工作，导致了“在 Colab 中开放”谷歌 Chrome 扩展的开发，但这最终结束了，Colab 的开发在内部继续。
从下面提供的链接中查阅下面的文章，获得十多个 ide 的简明指南，您可以在您的项目中使用这些 IDE。
3.绘图处理器
图形处理单元是一种专门的电子电路，设计用于快速操纵和改变存储器，以加速在帧缓冲器中创建图像，用于输出到显示设备。
GPU 是现代计算的关键部分。GPU 计算和高性能网络正在改变计算科学和人工智能。GPU 的进步为今天深度学习的发展做出了巨大贡献。
GPU 针对训练人工智能和深度学习模型进行了优化，因为它们可以同时处理多个计算。它们拥有大量内核，可以更好地计算多个并行进程。
NVIDIA 提供了一种名为计算统一设备架构(CUDA) 的东西，这对支持各种深度学习应用至关重要。CUDA 是 Nvidia 创建的并行计算平台和应用编程接口模型。
它允许软件开发人员和软件工程师使用支持 CUDA 的图形处理单元(GPU)进行通用处理，这种方法称为 GPGPU。这些 CUDA 核心在人工智能领域是高度有益和进化的。
当您使用 TensorFlow 或 Pytorch 等深度学习框架时，与使用 CPU 的相同性能相比，您可以利用这些 CUDA 核心来计算您的深度学习算法，速度要快得多。
GPU 是计算机视觉和超级计算的动态资源，具有深度学习和神经网络，可以执行复杂的任务，有时甚至超出人类的想象。此外，GPU 还有许多其他应用。GPU 在嵌入式系统、移动电话、个人电脑、工作站和游戏控制台中都有应用。
您可以从下面的文章中了解更多关于 GPU 的信息，如果您确实需要一个 GPU 来进行深度学习。
4.IBM Watson 工作室
沃森工作室，以前的数据科学体验或 DSX，是 IBM 的数据科学软件平台。该平台由一个工作空间组成，其中包括用于数据科学的多种协作和开源工具。
IBM Watson Studio 允许用户使用 Auto AI 管理 AI 生命周期，准备、优化和探索模型，构建可共享的开源笔记本，在云上运行和训练模型，并最终部署您的数据科学项目。
在 Watson Studio 中，数据科学家可以与一组合作者一起创建一个项目，所有人都可以访问各种分析模型并使用各种语言(R/Python/Scala)。Watson Studio 将包括 RStudio、Spark 和 Python 在内的主要开源工具整合到一个集成环境中，并在一个安全和受监管的环境中添加了其他工具，如托管 Spark 服务和数据整形工具。
Watson Studio 提供对数据集的访问，这些数据集可通过 Watson Data Platform 在内部或云上获得。该平台还拥有一个大型社区和嵌入式资源，如关于数据科学世界和公共数据集最新发展的文章。该平台有内部、云和桌面三种形式。
IBM Watson Studio 为用户提供了许多选项，包括一个已经有多个训练模型的选项，作为一个例子，您可以利用它们来创建您的对象检测项目，而不必实际编码。
使用 IBM Watson Studio 的好处是，您可以有效地优化您的人工智能和云，预测结果并相当容易地规定行动，将人工智能的力量同步到各种应用程序中，自动化人工智能生命周期，等等。
5.亚马逊网络服务
亚马逊网络服务(AWS)是亚马逊的一家子公司，以按需付费的方式向个人、公司和政府提供按需云计算平台和 API。这些云计算 web 服务提供了各种基本的抽象技术基础设施和分布式计算构件和工具。
其中一项服务是亚马逊弹性计算云(EC2)，它允许用户通过互联网拥有一个随时可用的虚拟计算机集群。AWS 版本的虚拟计算机模拟了真实计算机的大部分属性，包括用于处理的硬件中央处理器(CPU)和图形处理器(GPUs 本地/RAM 存储器；硬盘/固态硬盘存储；操作系统的选择；联网；以及预装的应用软件，如 web 服务器、数据库和客户关系管理(CRM)。
AWS 技术在世界各地的服务器农场实施，并由亚马逊子公司维护。费用基于用户选择的使用情况(称为“随用随付”模式)、硬件、操作系统、软件或网络功能的组合，以及可用性、冗余性、安全性和服务选项。
订户可以购买一台虚拟 AWS 计算机、一台专用物理计算机或两者的集群。作为订阅协议的一部分，亚马逊为订户的系统提供安全保障。AWS 在许多全球地理区域开展业务，包括北美的 6 个区域。
我强烈推荐那些对探索、创建和部署 Amazon Web Services (AWS)模型感兴趣的初学者使用免费层。这种方法将有助于您更好地了解和全面理解在云环境中使用数据科学。
6.微软 Azure
微软 Azure，通常被称为 Azure，是微软创建的云计算服务，用于通过微软管理的数据中心来构建、测试、部署和管理应用程序和服务。它提供软件即服务(SaaS)、平台即服务(PaaS)和基础设施即服务(IaaS)，并支持许多不同的编程语言、工具和框架，包括特定于微软和第三方的软件和系统。
微软 Azure 是计算复杂数据科学项目以及用人工智能和机器学习分析工作的最佳和最受欢迎的地方之一。您还可以在与人工智能结合的物联网(IoT)上进行操作，以创作更多创新的作品。
微软 Azure 类似于文章中讨论的前两个工具，但它提供了广泛的用途和好处，这是客户和数据科学或 AI 爱好者必须考虑的。你可以使用微软来构建、训练、运行、最终部署你构建的机器学习和数据科学项目。
微软 Azure 的其他功能包括用视觉和语音检测内容的认知搜索，用 API 为应用程序添加认知应用程序，创建机器人来管理各个方面和领域，用基于 Apache Spark 的分析设计人工智能，最后用人工智能传感器构建混合现实，以及许多其他应用程序。
7.阿尔杜伊诺
Arduino 是由 ATmega 微控制器组成的开发板。是机器人和 IoT(物联网)项目的最佳入门方式之一。
Arduino 是一家开源硬件和软件公司，爱好者、修补者和专业人士可以使用它来构建令人惊叹的创新项目。从我的经验来看，Arduino 绝对是开始你的机器人梦想的最佳方式之一，因为它比其他微控制器更容易使用。
Arduino 有多种形式和尺寸，即 Arduino Nano、Arduino Uno 和 Arduino mega。Nano 是一种尺寸较小的板，可用于更简单和独特的项目。Uno 是一个中等大小的板，非常适合开始试验和尝试业余爱好者级别的项目。mega 是一个更大的开发板，可以用于稍微复杂一点的项目和场景。
在我看来，Arduino 是开始任何类型的物联网项目的最佳方式。对于一些基本项目，如传感器控制和学习设备管理，Arduino 非常有利于在该领域追求更多的创意。
开始学习很简单，因为它主要是 C 和 C++等编程语言的混合，作为初学者，它主要有两个代码块需要担心，即设置和循环功能块。因此，我的第一个建议是先试用 Arduino Uno 板，然后再开发更复杂的嵌入式设备。
8.树莓派
Raspberry Pi 是一台单板计算机，这是开始计算和编程的一种非常好的方式。Raspberry Pi 提供了很多机会，可以在计算机视觉、游戏、物联网项目等领域创造非常酷的项目。
通过摄像头附件，raspberry pi 甚至可以用于对象检测、人脸识别和监视操作等任务。如果你是一个想要开始编程和编码的初学者，那么 Raspberry Pi 是最便宜和最好的方法。它也可以被中级爱好者或专家用于更高级的项目。
使用 Raspberry Pi 和 Raspbian OS 之类的操作系统编程的最大好处是，您可以使用各种编程语言，包括 python。Thony 编辑器是操作系统中预装的程序，你可以在这里编写你的 python 项目。
树莓 Pi 中编码的所有程序，包括机器学习和深度学习程序，都可以轻松部署。像照相机、音频设备等外部附件。，也可以添加到 Raspberry Pi 中，并被控制来执行实时计算机视觉任务，如视频监控、人脸识别等。
9.Nvidia Jetson Nano
NVIDIA Jetson Nano 是机器人领域人工智能相关操作的最佳工具之一。它比 Raspberry Pi 稍贵，但 Jetson Nano 也有更高的计算能力。据英伟达:
NVIDIA Jetson Nano 支持开发数以百万计的新型小型低功耗人工智能系统。它开启了嵌入式物联网应用的新世界，包括入门级网络录像机(NVR)、家用机器人和具有完整分析功能的智能网关。
NVIDIA developer kit 允许用户运行许多神经网络操作，包括图像分类、分割、对象检测和语音处理等。
虽然 Nvidia Jetson Nano 比 Raspberry Pi 贵一点，但它具有相对更好的功能，也是开发中级和高级项目的一个很好的起点。如前所述，它功能强大，可以执行多种任务。
在我看来，这三个工具是开始使用 AIOT 的最佳设备。显然，还有许多其他令人惊叹的选项和嵌入式设备选择来开发有效的模型。
10.谷歌云平台
由谷歌提供的谷歌云平台(GCP)是一套云计算服务，运行在谷歌内部用于其最终用户产品(如谷歌搜索、Gmail、文件存储和 YouTube)的相同基础设施上。
除了一套管理工具，它还提供一系列模块化云服务，包括计算、数据存储、数据分析和机器学习。注册需要信用卡或银行账户的详细信息。Google 云平台提供基础设施即服务、平台即服务和无服务器计算环境。
谷歌云平台是谷歌云的一部分，谷歌云包括谷歌云平台公共云基础设施，以及谷歌工作空间(原 G Suite)，Android 和 Chrome OS 的企业版，以及用于机器学习和企业地图服务的应用编程接口(API)。
Google Cloud 为数据科学爱好者提供了许多可以充分利用的特性和产品。这些领域包括云计算、存储和数据库、网络、大数据、云人工智能、物联网(IoT)、API 平台和管理服务。
具体来说，大数据提供了一些功能，如 BigQuery 可扩展的托管企业数据仓库，用于分析，Cloud Dataflow 基于 Apache Beam 的托管服务，用于流和批量数据处理，Cloud Dataproc 用于运行 Apache Hadoop 和 Apache Spark 作业的大数据平台，等等。
谷歌云人工智能提供了以下功能:
- Cloud AutoML — 培训和部署定制机器、学习模型的服务。截至 2018 年 9 月，该服务处于测试阶段。
- 云 TPU — 谷歌用来训练机器学习模型的加速器。
- 云机器学习引擎— 基于主流框架训练和构建机器学习模型的托管服务。
- 云工作发现— 基于谷歌搜索和机器学习能力的招聘生态系统服务。
- Dialogflow Enterprise — 基于谷歌机器学习的开发环境，用于构建对话界面。
- 云自然语言— 基于 Google 深度学习模型的文本分析服务。
- 云语音转文本— 基于机器学习的语音转文本转换服务。
- 云文语转换— 基于机器学习的文语转换服务。
- 云翻译 API — 在数千种可用语言对之间进行动态翻译的服务
- 云视觉 API — 基于机器学习的图像分析服务
- 云视频智能— 基于机器学习的视频分析服务
特别提及:
卡格尔:
Kaggle 是数据科学家展示和展示他们独特的问题解决能力和创新思维的最佳平台。Kaggle 就是这样一个网站，它主办了一些与数据科学相关的最佳竞赛。不要担心你是第几名。只要你能学到新东西，这没多大关系。
Kaggle 是 Google LLC 的子公司，是一个由数据科学家和机器学习实践者组成的在线社区。Kaggle 允许用户查找和发布数据集，在基于网络的数据科学环境中探索和构建模型，与其他数据科学家和机器学习工程师合作，并参加竞赛以解决数据科学挑战。
堆栈溢出:
Stack Overflow 是一个面向专业和爱好者程序员的问答网站。这是一个私人网站，堆栈交换网络的旗舰网站。它的特点是在计算机编程中广泛的问题和答案。它的创建是为了更开放地替代早期的问答网站，如专家交流。
在数据科学中，陷入长期致力于解决的问题并不罕见。最棒的是，数据科学有一个非常棒的社区，里面有非常乐于助人的人和大量资源供您使用。
Stack Overflow 是一个最好的网站，你可以在这里提出你的问题，并获得一些很棒的解决方案。当你遇到困难时，不要犹豫去寻求帮助！
其他:
Discord 频道、YouTube 视频、免费在线代码营、走向数据科学等。和其他嵌入式物联网设备都是有用的资源，可供我们所有人利用和提高技能。
与他人和专家交流分享想法是学习更多知识的好方法。不能有效地沟通会导致很多问题，比如你可能会对某个特定的话题产生误解。
此外，与人交谈非常有助于分享你的观点，以及获得知识。通过与更多的人交谈，你会产生更好的想法，最重要的是互动，这在与数据科学项目团队合作的公司中非常有用。
结论:
在本文中，我们讨论了十种令人惊叹的工具和技术，您可以利用它们来创建数据科学世界的现代化时代。这篇文章中讨论的各种工具和技术从用于创建更好的数据科学项目的集成开发环境(ide)到用于加速计算和运算的显卡。
我们还讨论了各种嵌入式设备，开发人员可以利用这些嵌入式系统和微控制器来创造更新的创新和开发镜面项目。利用各种网站来提高效率和整体生产力也是一个绝妙的主意。
最后，我们讨论了大型公司提供的各种技术，用于实现、可视化、提高整体模型性能以及部署您的数据科学项目。这些都是为了鼓励数据科学爱好者开发各种独特的项目，并在该领域取得进展。
看看我的其他一些文章，你可能会喜欢读！
</15-awesome-python-and-data-science-projects-for-2021-and-beyond-64acf7930c20> </12-steps-for-beginner-to-pro-in-data-science-in-12-months-c6f6ba01f96e>
谢谢你们坚持到最后。我希望你们喜欢阅读这篇文章。我希望你们都有美好的一天！
内部数据领导者在创造创收数据产品时将面临的 10 大挑战
业内笔记
满足内部和外部客户是不一样的。关于诞生新的商业数据驱动产品的混乱世界，数据科学、分析和工程领导者需要了解什么？
让我们讨论一下数据产品——特别是由内部团队构建的产品，他们现在的任务是面向外部的产品创新工作。你知道，外面的人必须付钱才能用的那种。(是的，你的内部客户一直在使用你的解决方案获得报酬，不管质量如何)。
简而言之，我认为这项工作要困难得多，你将面临更多的困难，尤其是如果你在一家习惯于僵化流程、行动缓慢的大型企业中，并且拥有一种要求保证但喜欢自称为灵活和创新的文化。
以下是我希望你在跳进池塘时注意的 10 个想法(欢迎，水很美，但没有救生员值班！):
- 过去你有一些利益相关者；现在你有 1000 个潜在客户。这种更广泛的潜在客户群起初看起来很有吸引力，直到你意识到个人用户是多么独特，每个意见会给你的产品积压带来多少噪音——如果管理不当的话。
- 你需要做更多的用户研究来理解什么不该做，什么该做——因为意见会很多，你不能构建所有的东西，而且当你构建错误的东西时会有机会成本。
- 你会后悔没有一个专门的产品经理(DPM ),他知道客户想要的是结果，而不是功能——而且没完没了的用户故事和功能永远也做不完。来自产品营销的 DPM 将有很多关于构建产品的知识要学；产品/工程部门的人需要学习很多关于市场定位的知识，并平衡他们认为人们需要什么和人们想买什么。
- 你可能认为你的工作是构建一个数据驱动的洞察解决方案，当市场说“我们想要这个东西在这里，你能做到吗？”“在那边”可能是一个可行的产品，但如果你的团队认为“我们的工作是制造 ML 模型”，他们就会错过它。过度分析，“我知道他们应该如何处理数据”的心态会阻止你看到可能就在你面前的机会。
- 你可能会意识到解决方案的设计和 UX——特别是如果它是技术性的——将很快变得相关，除非你正在做的事情如此具有开创性和革命性，以至于客户愿意忍受高水平的初始复杂性和难度来获得你承诺的价值。事情是这样的，在你表现出牵引力后不久，你可能会发现一个竞争对手紧跟在你的后面，没有技术债务，有一个 UX 和主张是如此清晰和简单。在竞争对手的应用出现之前，CLI 界面可能看起来非常强大，突然之间，非技术用户也可以从数据和见解中获得价值。
- 如果你在一家大型、缓慢、富有的企业，你可能处在一种不支持创新的文化中。这种文化想要避免风险，并遵循过程——与敏捷、产品开发不匹配的东西。虽然你有一些好处，如你的好处(！)，薪水和缓冲，你可能缺乏创业文化的勇气和灵活性——由志同道合的人组成的团队，他们热爱客户问题，承担企业和用户需要的角色，并不懈地专注于建立产品/市场匹配——即使这不是最初计划的一部分。把你的内部流程和文化强加给一个专注于外部产品创新的团队可能会增加税收，而不是收益。风险？为此做好准备——创新领域没有承诺。
- 当你建造新的东西时，你可能会发现很难适应创造性的工作。说“不，谢谢”的反馈当你试图获得对你的想法的反馈时，你得到的是沉默。拒绝。
- 你很快就会意识到，让人们承诺为你的数据驱动解决方案按月或按年付费要困难得多，除非价值非常清楚。当你第一次告诉他们你的宝宝并要求安排一次通话时，他们并不超级兴奋，你会感到困惑——想知道为什么他们没有看到你的团队所看到的“明显”价值。
- 你不会意识到很多“产品”发生在你出货后的第一件事；以前没有。发布会被过分夸大了；这次发射是开始而不是结束。
- 如果你是技术人员，而你的购买者是“业务人员”，你会痛苦地认识到为什么设计/UX、产品和定位如此重要——即使解决方案是为技术受众设计的。精算师可能认为你的新“风险计算器”难以置信，但首席信息官是开支票的人——他们仍然不确定他们已经做的风险计算方法有什么问题。
听着:如果你走到这一步，有人已经相信你或你的团队了。问题在于，你可能需要放弃“数据就是解决方案”，放弃你的技术培训，以及一些在我们的创作过程中没有用的分析技能。
当你看到一个糟糕的技术策略时，你就知道它是什么样子了——数据产品创造的关键在于,数据部分和产品部分需要不同的技能。你很可能会偏向前者。后者可能是草率的、快速的、不可预测的、混乱的，并且有时是非理性的——但是如果您想要构建人们愿意为之付费的不可或缺的数据产品，那么这可能是您需要参与一段时间的环境。
关于作者
Brian T. O'Neill 是一名咨询产品设计师，帮助公司创建创新的 ML 和分析解决方案。他是 Designing for Analytics 的创始人和负责人，主持expering Data播客，并为麻省理工学院沙盒创新计划提供建议。想在收件箱中获得更多关于创新数据产品设计的见解吗？立即订阅。
🎧 | 网站 | LinkedIn | 推特:@rhythmspice
为数据科学学习 Python 的 10 个令人信服的理由
如果你不知道从哪里开始学习数据科学，请阅读本文
通过像素成像
数据科学是一个广阔的领域，有大量的切入点，这取决于您想从哪里以及如何开始。我开始用一种叫做 R 的语言学习基础数据科学，直到我遇到它的许多限制之一。据我所知，Python 无疑赢得了 R vs Python 的数据科学之战。当我想在我的数据科学之旅中迈出下一步时，我依赖于 Python。为数据科学学习 Python 是进入数据科学最快、最简单、最有趣的方法之一。
数据科学是一项非常有价值的技能，平均工资高和工作满意度高，然而仍然有更多的公司发布数据科学家的职位列表，而不是目前实际存在的数据科学家。
我使用 Python 涉足数据科学领域有很多原因——它被许多 FAANG 相邻的公司用来进行数据科学研究，它是一种通用的语言，初学者很容易掌握，专家也很容易学习。
尽管 Python 是一种通用语言，但本文给出了您应该学习 Python 的 10 个坚实的理由，并解释了 Python 在数据科学中的作用。
· [1\. Python is easy to learn](#02de)
· [2\. It’s easy to read](#34b2)
· [3\. It’s popular](#9629)
· [4\. Huge Community of Pythonistas](#b4f3)
· [5\. Comprehensive set of data science libraries](#a0c4)
· [6\. Teaches the basics](#f0b1)
· [7\. Data cleaning is a breeze](#1faf)
· [8\. Communication](#ec51)
· [9\. Quick prototypes](#ba88)
· [10\. Job security](#cb8b)
1.Python 很容易学
编码可能会令人生畏，尤其是对初学者来说。但是 Python 是个例外。它的语法和词汇非常简单，所以你可以相对快速地掌握它，尤其是与更复杂的语言如 C、C++和 Java 相比。对于数据科学家来说，Python 是学习语言的一个明显选择。
它如此简单，以至于 Next Academy 实际上推荐它作为儿童学习编码的绝佳选择。对于非程序员来说，有很多便宜或免费的资源可以开始学习 Python 。
如果你想进入数据科学，Python 是编码语言的一个很好的选择，因为你可以很快地把它添加到你的工具箱中，而且痛苦最小。对于初学者来说，用 Python 学习数据科学可能是一个简单的解决方案。
2.它很容易阅读
Python 有一个干净简单的语法，反映了英语，所以无论你构建什么，你和许多人都能理解，即使他们自己不是 Pythonistas。
当我开始学习 Python 时，它如此容易学习的部分原因是我可以阅读 Python 代码示例并理解它们试图做什么。如果你想进入数据科学领域，你绝对应该把可读性作为你选择的任何语言的一个关键组成部分。
您将会阅读大量代码，并与您的同事(或者当您试图在 StackOverflow 上调试某些东西时，与互联网上的陌生人)共享这些代码。Python 让这变得很容易。
3.很受欢迎
如果你学习 Python，你将成为众多人中的一员。它是数据科学(以及其他领域)中使用最广泛的语言之一。根据 TIOBE 的 2020 年指数，英语是世界上使用第三广泛的语言。特别是在数据科学领域，它的成为了领导者，超过了我以前最喜欢的语言 r
正如我上面提到的，许多公司正在使用 Python 来构建框架和项目。比如 Google，创建了 Tensorflow，基于 Python 脸书和网飞在其数据科学项目中也越来越依赖于它。
如果你想进入数据科学领域，至少了解一些 Python 是不会有太大进展的。幸运的是，学习是一种乐趣！
4.庞大的 Pythonistas 社区
我记得当我知道一个用 Python 编码的人的名字时:一个 Pythonista。我喜欢它。学习 Python 进行数据科学的一个主要好处是，你可以进入一个令人难以置信的 Python 社区，并成为其中一员。(好处不仅仅是酷炫的名字。)
因为它已经存在了三十年，因为它易于学习和构建，因为它长期以来一直与许多人和公司相关，所以有一个庞大而热情的 Pythonistas 社区，他们非常乐意分享他们的技巧，回答您的问题，纠正您的代码，并讨论新的想法。你可以在任何地方找到它们——Reddit 有一个特别活跃的社区，但是你甚至有不和谐的团体冒出来谈论 Python。
这使得学习 python 成为数据科学的一个很好的选择，因为学习任何一种语言都很难，尤其是当你感到专业压力的时候。像围绕 Python 涌现的社区使这变得更容易。
5.全面的数据科学库
Python 作为数据科学的语言独树一帜。但是除了简单的语法、简单的词汇、可读性、社区和我已经列出的其他好处之外，还有库。像 Pandas、statsmodels、NumPy、SciPy 和 Scikit-Learn 这样的库在数据科学社区中非常流行。
像 SciPy 这样的生态系统使得数据科学任务变得更加容易。(SciPy 的发音是 sigh-pie，而不是我最初认为的 skippy。)SciPy 解决了许多常见的数据科学需求，如处理数据结构、分析复杂网络、算法和机器学习工具包。用于数据科学的 Python 库很受欢迎，并且在不断发展。
真正令人兴奋的是，随着越来越多的 Python 爱好者加入社区并做出自己的贡献，用于数据科学的新 Python 包一直在发布。用于数据科学的 Python 库很受欢迎，并且在不断发展。例如，Keras 是 2015 年发布的用于深度学习的极简主义图书馆。从那时起，它就成了 Python 库生态系统的重要组成部分。
6.教授基础知识
尽管 Python 实际上有无限多的应用，但学习 Python 和数据科学之间实际上有很多重叠。只需浏览一些基础教程，您就可以轻松学习 Python 的数据科学基础知识。数据科学家使用 Python 来检索、清理、可视化和构建模型，因此，如果您想使用 Python 来学习数据科学，这是您可以开始的地方。
在学习如何用 Python 编程的标准过程中，默认情况下，您会接触到一些数据科学基础知识。例如，您将开始学习如何设置您的环境，导入数据，清理数据，对数据进行统计分析，创建一些漂亮的可视化效果，并分享您的发现。看看这个——你已经用 Python 做了一些数据科学。
只要您在寻找 Python 教程时牢记典型的数据科学任务，您将很容易找到大量教您 Python 的资源——尤其是同时教您数据科学的 Python。学习用于数据科学的基本 Python 是一种自然的学习途径。
7.数据清理轻而易举
“数据科学”这个词，对我来说，会让人联想到《黑客帝国》中尼奥穿着酷外套做酷事情的画面。很多人没有意识到数据科学是一种不那么光彩的数据清理。保守估计数据清理占数据科学家典型工作量的 80%。但是好消息是:Python 在这方面很棒！
如果你想进入数据科学，你需要接受这样一个事实:在你做出一个很酷的 viz 之前，你将会做大量的数据擦洗、清理、按摩、争论等工作。这种需求使得学习 Python 数据科学成为一个很好的选择:它是为清理而构建的。
我之前提到的两个库，NumPy 和 Pandas，在清理数据方面非常出色。
8.沟通
在你清理完数据之后，下一个最重要的部分就是交流你的发现。数据科学不仅仅是代码行，它意味着与关键利益相关方交流结果。一个好的 viz 是至关重要的。
“数据可视化通过地图或图形为信息提供可视化背景，让我们清楚地了解信息的含义。这使得人类思维理解数据更加自然，因此更容易识别大型数据集中的趋势、模式和异常值，”在 Analytiks 博客中写道。
很多人认为数据科学止于分析，但就像职业世界中的其他事情一样，你在之后做的是真正重要的事情。
Python 有很多很棒的工具来实现简单的可视化，比如非常基本的 matplotlib 和它的两个孩子 Pandas 和 seaborn(都是基于 matplotlib 构建的)。如果你能很容易地做出一个好的 viz 来交流或说明数据，战斗就成功了一半。Python 让这变得简单。
9.快速原型
一个鲜为人知的事实是，数据科学家项目是昂贵的。事实上，Gap 的数据和分析 SVP Chris Chapo 曾经说过“87%的数据项目都会失败。”建造一个有用的东西需要时间、精力、资源和极大的耐心。
为了解决这个问题，大多数数据科学家使用原型对他们的想法进行预演，并对其进行压力测试，以确保其值得正确构建。如果您一直在关注本文的主题，那么当您听说 Python 非常适合构建良好的原型来测试概念、想法和产品时，您应该不会感到惊讶。
Fuzzing Book 的作者写道:
“Python 让我们的工作效率惊人。本书中的大多数技术需要 2-3 天来实现。这比 C 或 Java 等“经典”语言快 10-20 倍。
Python 使得运行动态分析(在程序运行时分析程序执行)和静态分析(在不运行代码的情况下分析代码)变得很容易，这两种分析都让原型化成为一种梦想。
10.工作保障
这篇文章是关于为什么学习 python 对于数据科学是有意义的。但是……很多曾经看似稳如泰山的职业和职业道路逐渐消失，或者被算法取代。
数据科学没有这种萎缩的迹象，但由于公司正在花大价钱寻找数据科学家，并努力找到足够的数据科学家，你可以打赌，他们有动力寻找替代方案，而不是花费更多的时间和资源来寻找另一位数据科学家。
如果你为了数据科学而学习 Python，这些技能将足以帮助你在计算机科学领域的其他地方找到工作。Python 本身比任何职业道路都更稳定——它已经存在了 30 年，它不断地重塑自己，以便对新的工作和职业有用。数据科学的未来可能会受到质疑，或者你可能会觉得你的职业目标发生了变化。无论哪种方式，了解 Python 都将助您一臂之力。
开始学习面向数据科学的 python，但是放心，无论数据科学领域发生什么，Python 都将是一门有价值的语言。
如果您想知道在 Python 中学习数据科学的内容，本文应该已经全面涵盖了。对于想知道从哪里开始学习数据科学的人来说，使用 Python 学习数据科学基础知识是一个自然的解决方案，这可能是一个压倒性的前景！
当我开始学习 Python 时，我发现它非常适合接触基本的数据科学概念和任务。
每个人都必须知道的 10 个计算机视觉术语！
十个基本的计算机视觉术语，每个人都应该学习，以更加精通计算机视觉和示例代码
布鲁克·卡吉尔在 Unsplash 上的照片
机器或计算机能够感知现实世界中的图像并相应地解释它们的想法曾经被认为是不可能的。在当代，我们知道有一些快速的进步导致了计算机或机器视觉领域的快速发展。在接下来的几年里，计算机视觉将会有更多的发展，使其更加与众不同。
自从过去十年以来，计算机视觉已经变得特别流行。虽然理论概念已经存在了相当长的一段时间，但这是由于现代技术有助于将这门学科推向一个全新的水平。计算机视觉是人工智能的一个分支，它使系统能够衡量对图像、视频或其他实时实体和活动的整体高级理解。
虽然本文的目标是关注计算机视觉的一些重要术语，但我之前已经非常详细地介绍了 OpenCV 主题和计算机视觉的基础知识。如果您是该领域的新手，建议您首先阅读下面提供的文章，以更深入地了解该主题，并确保您可以获得阅读本文内容的最佳效果。
在本文中，我们的目标是涵盖许多计算机视觉应用所需的十个最基本的术语。有了这些方面的正确信息和知识，你就可以用机器学习或深度学习算法的混合来构建任何类型的计算机视觉项目。让我们开始探索这十个概念，并逐一了解它们。
1.图像格式:
图像格式化和图像操作是你在计算机视觉世界中最常听到的两个术语。让我们以直观的方式理解这些关键概念，以避免将来的任何混淆。我们在自然世界中感知的正常图像通常是具有一定宽度和高度的图像，并且通常具有三个通道，因为它们通常包含 RGB 图像的颜色组合。以下是图像参数的典型表示。
Height of the Image = 512
Width of the Image = 512
Number of channels = 3
通过图像操作，您可以执行各种有用的操作，这些操作将有助于降低机器学习或深度学习算法的计算要求。一些图像处理方法包括调整大小、裁剪或将其转换成灰度图像(这一点将在下一节中进一步讨论)。图像操作在计算机视觉应用中起着至关重要的作用。
对于图像格式化，我们的任务通常是实现图像的最佳表示，使其适合我们的特定任务。如前所述，该步骤可能涉及某些图像处理，并将其存储为所需的格式。常用的图像存储格式包括 PNG、JPG、JPEG、TIF 和其他类似格式。
2.灰度:
在计算机视觉中，灰度图像在大多数具有实际应用的操作中起着至关重要的作用。通常，第 0 个范围指的是黑色，随着范围的不断增加，我们开始达到更亮的色调，直到我们最终在第 255 个值上遇到白色。因此，灰度图像也可以被认为是颜色为浅灰色并且跟随不同灰度的图像范围。
将彩色 RGB 图像转换为其他格式有很多用途，尤其是转换为灰度图像，以减少计算压力并降低 CPU(有时是 GPU)的限制。将数据集转换为灰度后，您可以更快、更有效地处理计算。您还可以使用它来简化算法和提取描述符，而不会消耗太多的额外需求。转换成灰度的简单代码如下。
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) # Convert the color image to grayscale image
cv2.imshow("Gray Picutre", gray) # Display Grayscale image
cv2.waitKey(0)
另一个需要理解的基本概念是掩蔽。遮罩是由零值和非零值组成的二进制图像。如果将遮罩应用于另一个二进制图像或相同大小的灰度图像，则遮罩中为零的所有像素在输出图像中都将被设置为零。所有其他保持不变。更多信息，请参考以下参考。
3.欠条和骰子损失:
在处理图像和大多数计算机视觉任务时，我们利用某些基本的计算指标来分析模型的性能。确保模型在训练和评估阶段有效运行的两个主要指标是联合交集(IoU)分数和骰子损失。
并集上的交集(IoU)，顾名思义，是特定图像的地面实况和模型所做预测之间的重叠。它通常被认为是比精度更好的度量，广泛用于计算机视觉应用。通常情况下，对于实际应用而言，高于 0.5 的 IoU 分数可视为良好分数。
另一方面，骰子损失是在图像处理中用来理解两个或多个期望实体之间的相似性的度量之一。在考虑真正值、假正值和假负值之后，下面的公式可以写成如下:
4.锚箱和 NMS:
以下两个术语，锚盒和非最大值抑制，是计算机视觉中，尤其是物体检测算法实现中常用的两个词。因此，理解它们在特定序列中的重要性以及为什么它们被用于这些任务是非常重要的。
锚定框对于在图像中设置预定义高度和宽度的边界框非常有用。它们通常会捕捉不同对象的大量比例和纵横比，您希望将这些比例和纵横比专门整合到您的培训模型中。有许多锚箱用于此目的。
当有许多锚盒用于特定目的时，可能会导致某些问题，尤其是由于重叠。因此，非最大抑制(NMS)的概念被用于过滤掉过多的重叠瓦片，并将处理的结果传递给神经网络用于进一步的计算和处理。
5.噪音:
图像中的噪声基本上是由于污染(降低)图像质量的外部因素的干扰而可能发生的任何种类的干扰。图像中的噪声经常会成为图片或图像中不希望出现的干扰。虽然有时你可能会尝试为图像生成添加一些你自己的噪声(就像在 GANs 中)，但这通常不是你想要的完美图像。
在您认为特定图像中不需要添加噪声的情况下，您可以尝试滤除此噪声。噪声过滤是试验 OpenCV 模块中的各种技巧以消除现有噪声的方法之一。下面是一个示例代码，展示了相同的类似演示。
def custom_blur_demo(image):
kernel = np.ones([5, 5], np.float32)/25
dst = cv2.filter2D(image, -1, kernel)
cv2.imshow("custom_blur_demo", dst)src = cv2.imread("lena_noise.png")
img = cv2.resize(src,None,fx=0.8,fy=0.8,interpolation=cv2.INTER_CUBIC)
cv2.imshow('input_image', img)
custom_blur_demo(img)
6.模糊技术:
blur = cv2.GaussianBlur(gray, (19,19), 0)
cv2.imshow("Blur Picture", blur) # Display Blur image
cv2.waitKey(0)
模糊或平滑处理是计算机视觉中减少特定图像中异常值数量的关键技术。由于我们在前一节中了解了噪声，我们对图像中噪声干扰的副作用有了一个简单的了解。防止这些干扰和过滤这种噪声的一种方法是使用模糊技术。
在上面的代码块中，我们使用了一种流行的模糊技术，称为高斯模糊，它利用了高斯函数，有助于相应地平滑给定的图像。在 OpenCV 提供的特定高斯模糊代码中，目标是提供源和内核大小，它们必须始终是奇数元组，以获得平滑的图像。
7.边缘检测:
作者图片
边缘检测是用计算机视觉实现的另一个重要目标。边缘检测有助于识别图像中亮度变化或图案不连续的各个部分，从而可以找到所需的区域。它还用于从图像中提取特定对象的结构，并在其他计算机视觉应用中找到它的效用，如对象检测。
上图举例说明了如何执行边缘检测的特定操作，以及如何通过改变阈值因子来改变检测能力。虽然有许多方法来执行对象检测，并且同样有许多独特的应用，但下面是一个示例代码块，演示了在 OpenCV 中使用 Canny 边缘检测器。
# Canny Edge Detection
edges = cv2.Canny(image=img_blur, threshold1=100, threshold2=200) # Canny Edge Detection
# Display Canny Edge Detection Image
cv2.imshow('Canny Edge Detection', edges)
8.FPS:
每秒帧数(FPS)是计算机视觉的另一个基本概念，通常用于计算视频镜头或实时图像。为了更简单地理解这个概念，让我们考虑几个例子。假设你正在 YouTube 或你的本地软件等特定平台上观看视频或电影。您可以选择查看特定视频每秒播放多少帧，以及具体质量如何。
另一个例子是，当你试图玩视频游戏时，你会有一定数量的每秒帧数，这是随着游戏的进行你的设备可以处理的内容量。对于这些任务，每秒 60 帧通常被认为是一个不错的数字。同样，对于实时对象检测等计算项目，FPS 的概念对于确定特定模型的性能至关重要。
为了理解大量与计算机视觉和深度学习相关的概念，我个人认为，开发者应该在学习阶段尝试构建至少一个单一的游戏。查看我以前的一篇文章，这篇文章讨论了用 Python 构建游戏的必要性，以及你应该考虑自己这么做的五个理由，请点击下面的链接。
</5-reasons-why-you-should-develop-a-game-with-python-and-ai-9f5f276e7637>
9.细分:
迈克·多尔纳在 Unsplash 上的照片
你可以用计算机视觉和深度学习执行的最重要的操作之一是分割任务。具体来说，分割意味着从图像中分离出最基本的元素或特定的所需元素，以便您可以对图像执行进一步的计算，如分类或定位。考虑特定图像的聚类，并相应地对它们进行分割，以将它们与其他元素区分开来。
分割的正常过程包括考虑特定的数据集以及它们各自的掩码。利用相应的图像和该特定图像的基础事实，我们可以使用类似 U-Net 或其他类似架构的方法为某些样本训练模型。一旦您成功地构建了模型，您就可以对其他图像执行大量的分割测试，并隔离(分离)必要的需求。
10.物体检测:
计算机视觉的另一个重要贡献是对象检测任务，它对于解决一些现实生活中的问题至关重要。对象检测是当今世界最重要的应用之一，在许多与对象跟踪(如跟踪板球或棒球)、面部识别(用于识别面部)、机器人应用、无人驾驶汽车等相关的问题中有其使用案例，最终将在很大程度上造福人类。
由于对象检测是计算机视觉任务中最基本的元素之一，因此有几种方法、工具、算法和库来完成这项任务。一些最好的算法包括梯度方向直方图(HOG)、快速 R-CNN、YOLO 和许多其他类似的算法和技术。还有几个像 Image AI 和 Detectron2 这样的库可以有效地执行这些任务。查看以下关于对象检测算法和库的文章，以获得关于该主题的更多信息。
结论:
在 Unsplash 上由 Austin Distel 拍摄的照片
“以建设性和仁慈的方式使用计算机视觉技术有很大的潜力。”———
计算机视觉是人类取得的最伟大的成就之一。随着该领域的快速发展，现在可以轻松实现几乎任何类型的与图像、视频或实时捕捉相关的机器视觉任务。由于有一堆未来的业务和项目尚未被发现，我们在以下领域积累了巨大的潜力。
在本文中，我们探讨了与计算机视觉相关的十个最重要的术语。有了对这些资源的完美处理、理解和知识，对于大多数开发人员来说，用正确的工具和技术完成任何种类的特定计算机或机器视觉项目都成为可能。确保你记住或记下这些术语，以备将来使用。
如果你对这篇文章中提到的各点有任何疑问，请在下面的评论中告诉我。我会尽快给你回复。
看看我的其他一些文章，你可能会喜欢读！
</5-best-python-projects-with-codes-that-you-can-complete-within-an-hour-fb112e15ef44> </14-pandas-operations-that-every-data-scientist-must-know-cc326dc4e6ee> </7-best-ui-graphics-tools-for-python-developers-with-starter-codes-2e46c248b47c> </15-numpy-functionalities-that-every-data-scientist-must-know-f6d69072df68> </17-must-know-code-blocks-for-every-data-scientist-c39a607a844d>
谢谢你们坚持到最后。我希望你们都喜欢这篇文章。祝大家有美好的一天！
数据工程师的 10 个基本 PSQL 命令
了解如何使用 PSQL 通过命令行与 PostgreSQL 数据库交互。
照片由 Pexels 的 Engin Akyurt 拍摄
建议的点播课程:
你们中的许多人联系我，要求提供有价值的资源 来敲定基于 Python 的数据工程面试 。下面我分享 3 个我强烈推荐的点播课程:
- Python 数据工程纳米学位 → 精品课程！
- leet code In Python:50 个算法编码面试问题→最适合涉及算法的编码回合！
- Python 高级编码问题(StrataScratch)→**我找到的准备 Python 的最佳平台& SQL 编码面试到此为止！比 LeetCode 更好更便宜。**
希望你也会发现它们有用！现在欣赏:D 的文章
简介
在您成为数据工程师的过程中，在某些时候，您一定偶然发现了命令行(也称为终端)。
也许是一位同事向你展示如何创建环境变量？…或者教你使用本地版本控制的最佳实践？…或者你暗暗佩服他们与数据库交互的方式，看起来不费吹灰之力，也不需要现代的数据库管理系统？
无论您第一次接触命令行，您可能会想“我想要同样的超级能力……我需要学习如何做到这一点！”。**
无论您第一次遇到命令行，您可能会想“我想要同样的超级能力…我需要学习如何做到这一点！”。**
为了帮助你掌握一个最基本的数据工程技能，在本文中，我将向你介绍psql以及如何使用它通过终端与 PostgreSQL 数据库进行交互。我还将向您展示我在工作场所反复使用的 10 组命令。
但首先，什么是psql?…更重要的是，它的利弊是什么？
psql 如何给你超能力
在PostgreSQL 官方网站上，psql被定义为 PostgreSQL 交互终端。
这意味着，如果您每天使用 PostgreSQL，您可以使用psql连接到您喜欢的数据库，输入查询并通过命令行查看查询结果。但是psql有什么好处和坏处呢？
Psql 专业版
- 允许您与数据库快速交互，使您处于相同的环境中(终端)，而不像在标准 DBMS 中那样需要配置。这反过来加快了你的工作。
- 通过使用您最喜欢的编辑器或从文件中运行查询，允许您运行简短和更复杂的查询。
- 允许您通过在指定的时间间隔执行命令来跟踪表中的更改。
- 与标准 DBMS 相比，它可以帮助您几乎毫不费力地检索关于数据库、模式、表和用户的元数据和统计数据。
Psql Cons
- 当您需要显示和分析大量列或者交互地改变输出中列的顺序时，这不是最好的工具。当查询返回少量在终端上看起来很整洁的列时,
psql非常出色。 - 当您希望将查询的输出保存到特定格式的文件中时，这不是最好的工具。尽管这是可以做到的
psql( 我将在稍后展示)，现代数据库管理系统提供了更广泛和用户友好的选择范围。
既然我多解释了一点 当 psql应该是你的首选，那我也来分享一下怎么用吧！**
装置
苹果个人计算机
要在 Mac 笔记本电脑上安装psql，只需下载homebrew，然后执行以下两条命令:
**$ brew install postgresql
$ brew services start postgresql**
然后，当服务启动后，使用以下命令检查它是否已启动并正在运行:
**$ brew services**Name Status User Plist**postgresql started anbento /Users/anbento...**
窗户
要在 Windows 机器上安装psql以及其他客户端应用程序，请遵循这篇优秀的教程。
你必须知道的 10 个命令
与其他终端客户端应用程序一样，psql提供了广泛的命令来与 PostgreSQL 数据库进行交互。然而，下面我试着给出了 10 个我每天最常用的命令。
# 1 连接到 PostgreSQL 数据库
与 PG 数据库交互的第一步是连接到它。
请记住，如果您通常使用 SSH 隧道或任何其他类型的加密进行连接，您需要在运行下面的命令之前解决这个问题。
在工作场所，您很可能必须建立到驻留在特定主机上的数据库的连接。如果是这种情况，您应该使用:
**$ **psql -h host -d database -U user -W****
例如，假设您希望使用以下凭据连接到数据库:
****database name:** fin_db**host:** localhost**port:** 5000**username** = anbento**
命令和输出应该是这样的:
**$ **psql -h localhost -p 5000 -d fin_db -U anbento -W**Password for user anbento:psql (14.0, server 12.5 (Ubuntu 12.5–1.pgdg18.04+1))SSL connection (protocol: TLSv1.3, cipher: TLS_AES_256...., bits: 256, compression: off)Type “help” for help.fin_db=>**
一旦您运行它，您将被提示插入用户的密码。如果连接成功，您会看到屏幕上出现一个光标，前面有数据库名称。
现在你可以对它进行查询了！
# 2 列出模式|表|视图|函数|用户
作为一名数据工程师，有时您可能希望列出当前连接的数据库中可用的模式。
这可以通过使用\dn命令来实现:
**fin_db-> **\dn**List of schemas
Name | Owner
------------------+---------------------
audit | owner_1
fin_data | owner_2
fin_config | owner_3
fin_control | owner_4
fin_internal | owner_5
finance_analytics | owner_6
findb | owner_7
pdl | owner_8
pdl_map | owner_9
pdl_ob | owner_10
pds | owner_11
... | ...(20 rows)**
如您所见，fin_db数据库包括 20 个与特定所有者相关联的模式。然而，如果您在寻找一组特定的模式(假设所有模式都以fin_开头)，该怎么办呢？在这种情况下，您应该运行:
**db_findb-> **\dn fin_***List of schemas
Name | Owner
— — — — — — — + — — — — — — — — -
fin_adata | owner_2
fin_config | owner_3
fin_control | owner_4
fin_internal | owner_5(4 rows)**
现在，该命令只显示与提供的正则表达式匹配的 4 个模式。
非常相似的命令可用于列出您所连接的数据库的表、视图、函数和用户:
**# Display the list of tables
**\dt** or **\dt + regex**# Display the list of views
**\dv** or **\dv + regex**# Display the list of functions
**\df** or **\df + regex**# Display the list of users
**\du** or **\du + regex****
# 3 描述一张桌子
如果您希望通过列出特定表的列、数据类型以及了解哪些字段可以为空来了解更多信息，您应该使用\d table_name命令。
例如，要描述一个名为findb.transactions(其中findb是模式名)的表，您应该运行:
**db_findb-> **\d findb.transactions**Partitioned table “findb.transactions”Column | Type | Collation | Nullable | Default
---------------+-------------+-----------+----------+---------
trx_id | bigint | | not null |
source_id | bigint | | |
ops_type_id | bigint | | not null |
manual_status | integer | | not null |
source_amount | numeric | | not null |
... | ... |... | ... |**
# 4 运行前一个命令
要使用psql查询数据库，您只需键入一些 SQL 代码，后跟一个分号;。如果省略分号，客户端应用程序将无法理解代码是否准备好执行，并将使您处于编辑模式。
例如，如果您希望计算在2021-10-01上创建的findb.transactions中的事务总数，您可以运行:
**db_findb=> **select count(trx_id)**
**from findb.transactions**
**where created_at = ‘2021–10–01’;**
count
-------
512323(1 row)**
这个查询告诉我们512,323是在那个日期创建的。如果您希望再次运行相同的查询，该怎么办？你可以简单地输入\g:
**db_findb=> **\g**count
-------
512323(1 row)**
这适用于所有命令，相当于up arrow + enter。
# 5 从文件中执行命令
有时，SQL 脚本变得更长更复杂，所以您可能想先创建它们，将它们保存到一个文件中，然后用psql运行文件中包含的查询。使用\i filename可以做到这一点。
在下面的示例中，我保存了该查询的等效内容:
**select
TRX_ID
,POSTING_DATE
,SOURCE_AMOUNT
,OPS_TYPE_ID
from FINDB.TRANSACTIONS
where POSTING_DATE = current_date
limit 5;**
到一个名为query_trxs的崇高文本文件。该文件位于我的桌面上，因此为了执行它，我运行:
**db_findb=> **\i /Users/Anbento/Desktop/query_trxs**trx_id | posting_date | source_amount | ops_type_id
-----------+--------------+---------------+------------+
5122579747 | 2021-10-24 | 386.00 | 18 |
5115148908 | 2021-10-24 | 0.0 | 252 |
5115148971 | 2021-10-24 | 0.6100 | 70 |
5122580187 | 2021-10-24 | 15000.00 | 62 |
5122580337 | 2021-10-24 | 0.38 | 69 |(5 rows)**
# 6 在编辑器中编写命令
不用说，终端并不是运行长 SQL 查询的最佳工具。为此，psql不仅允许你从文件中执行命令，还允许你通过\e命令访问默认编辑器。
例如，在我的 Mac 上，该命令将打开vim编辑器，因为这是psql找到的默认编辑器。如果这也是你的情况，做这两件事:
- 键入
i进入INSERT模式。现在，您将能够键入您的查询。在这种情况下，我试图在findb.transactions中找到max(trx_id):
我的 vim 编辑器在插入模式下是什么样子
- 当您对您的查询满意时，键入
esc，然后键入:x!。这将保存您的内容并自动执行 SQL 脚本:
**db_findb=> **\e**max_id
— — — — — —
5124302389(1 row)**
但是，如果您的默认 shell 是zsh，您可以通过向您的~/.zshrc文件添加以下行来切换到您最喜欢的编辑器(例如nano),或者如果您的默认 shell 是bash，则添加~/.bash_profile:
**export EDITOR=nano
export VISUAL="$EDITOR"**
然后，运行以下命令来更新配置:
**source ~/.zshrc
#or
source ~/.bash_profile**
如果您退出psql并重新连接到数据库，当您运行\e时，您应该会看到nano编辑器正在启动:
现在 nano 是 psql 😄 的默认编辑器
# 7 启用查询执行时间
数据工程师经常忙于测试某些 SQL 脚本的性能。在这种情况下，了解一个查询运行需要多少时间非常方便。
为了在psql上显示执行时间，可以输入\timing on。例如，运行与之前相同的文件:
**db_findb=> **\timing on**
Timing is on.db_findb=> **\i /Users/Anbento/Desktop/query_trxs**trx_id | posting_date | source_amount | ops_type_id
-----------+--------------+---------------+------------+
5122579747 | 2021-10-24 | 386.00 | 18 |
5115148908 | 2021-10-24 | 0.0 | 252 |
5115148971 | 2021-10-24 | 0.6100 | 70 |
5122580187 | 2021-10-24 | 15000.00 | 62 |
5122580337 | 2021-10-24 | 0.38 | 69 |(5 rows)Time: 2673.033 ms (00:02.673)**
现在您知道运行查询需要2.67secs。
为了禁用计时，您可以键入\timing off来代替。
# 8 每隔一段时间重复命令
您是否曾经需要多次运行完全相同的 SQL 脚本？例如，通过将数据加载到特定的表中来检查 ETL 管道是否按预期工作？
如果您的答案是肯定的，那么您很幸运，因为使用psql，您可以使用\watch + interval (in secs)命令自动运行脚本，次数不限。例如:
**db_findb=> **select
max(TRX_ID) as max_id
from FINDB.TRANSACTIONS;**max_id
— — — — — —
5124378773(1 row)db_findb=> **\watch 5**
Sun Oct 24 18:55:13 2021 (every 5s)max_id
— — — — — —
5124378799(1 row)Sun Oct 24 18:55:18 2021 (every 5s)max_id
— — — — — —
5124378808(1 row)**
如您所见，我正在运行我希望以特定时间间隔执行的 SQL 查询，然后我键入\watch 5以便该查询每隔5 secs开始执行。随着新记录被插入到表中，trx_id不断增长。
相同的查询会一直运行，直到您用ctrl + c杀死它。
在:D 这篇文章描述的 10 个命令中，\watch命令非常有用，也是我最喜欢的一个
# 9 以 CSV 格式导出数据
你猜怎么着？正如我在文章开头提到的，psql确实允许您以 CSV 格式导出数据。您可以使用下面的语法通过\copy命令来实现:
**\copy (SQL query) TO 'path\file_name.csv' WITH CSV HEADER**
请记住，在这种情况下，SQL 查询不需要在末尾加上分号;(否则psql会抛出错误)。另外，如果您希望在 CSV 文件中保留列名，记得在末尾添加HEADER。
例如，假设您希望将此查询的结果导出到桌面上的 CSV 文件中:
**select
TRX_ID
,POSTING_DATE
,SOURCE_AMOUNT
,OPS_TYPE_ID
from FINDB.TRANSACTIONS
where POSTING_DATE = current_date
limit 10**
然后，您将键入:
**db_findb=> \copy (
select
TRX_ID
,POSTING_DATE
,SOURCE_AMOUNT
,OPS_TYPE_ID
from FINDB.TRANSACTIONS
where POSTING_DATE = current_date
limit 10
) TO ‘/Users/Anbento/Desktop/query_trxs_v2.csv’ WITH CSV HEADERCOPY 10**
当您运行这个命令时，它将创建一个名为query_trxs_v2的 CSV 文件，如下所示:
如你所见，标题在那里！
# 10 退出 psql
使用psql完成后，您可以使用\q + enter退出客户端应用程序。或者，您可以使用ctrl + z。这将退出客户端应用程序，您将无法在终端上继续工作。
结论
在这篇文章中，我与你分享了你在成为拥有超能力的数据工程师的旅途中应该掌握的 10 条psql命令。这些也是我每天最常使用的命令，所以我希望你按照 80/20 法则从它们开始。
然而，要知道psql提供了非常广泛的命令，为了掌握这个工具，还有很多东西需要你去学习。
坚持学习就好！
避免编程倦怠的 10 个基本技巧
我在日常工作中实施的一些实用策略来避免筋疲力尽
(src =https://pixabay.com/images/id-2158532/
介绍
在编程和数据科学的奇妙世界中，被推到绝对疯狂的边缘是很常见的。尽管我们都可能热爱软件工程，但不可否认的是，它可能是乏味的。无论是因为截止日期、硬软件、技术问题、程序错误，甚至是个人目标，这都是非常有压力的。这种压力不仅会导致心理健康状况恶化(这是人们个人生活的一个非常重要的方面)，还会导致更糟糕的编程。
许多程序员听到缺乏休息和适当的精神状态实际上会影响他们的表现时感到惊讶。对我个人来说，我发现这完全是陌生的——我是一个非常狂躁的程序员。我发现我最辉煌的时刻往往是由深夜自省和更重要的是—
咖啡。
然而，作为一个经常以这种方式工作并有这样工作的头脑的人，我也能看到它所造成的伤害。不仅是对我，还有我的软件。首先，当然是我的失眠。但其次，我的软件有时候会有比较基础的问题需要日后修改。当然，对于任何可能编写的代码来说，情况总是如此，但是每当我精疲力尽，试图找出正确编写函数的方法时，我确实会发现更多的问题和更愚蠢的错误。当然，这也渗透到写作中，因为当你的大脑被烧焦的时候，它不能够进行批判性的思考。如果你的大脑更加理性的话，在嵌套的 for 循环中用更少的代码就能完成的事情，可能会更容易做出糟糕的再现。
无论如何，现在我已经讨论了我的一些关于精疲力尽的经历以及它对软件和心理健康的影响，我发现了一些不同的东西，它们在我的旅程中帮助我避免了这种精疲力尽，同时仍然保持高效。在许多情况下，你甚至会发现你更有效率！
№1:做你喜欢的事情
尽管有些建议可能很简单，但我仍然认为下次坐下来进行一次超长的编程会议时，考虑这些建议是至关重要的。我想建议的第一件事是，你正在做的实际工作是你热爱的事情。如果工作不是编程，情况更是如此；确保你追求你的目标。你只有一次生命。
如果你像我一样热爱计算机和科学，那么数据科学是显而易见的。也就是说，数据科学并不适合所有人。此外，数据科学并不适合地球上的每个程序员。这就像 Python 不是适合地球上所有人的编程语言一样。也就是说，找到一个适合你喜欢做的事情和你喜欢编程的领域绝对是一个好主意。
即使没有数据科学，一个数据科学家可能对不同的东西比其他人更感兴趣。例如，一个人可能是数据科学家，他更多地扮演分析师的角色。这意味着他们可能更喜欢分析数据，而不是构建复杂的机器学习算法或工程数据管道。也就是说，找到一个你特别喜欢的领域肯定是一个好主意，因为做一些你会比其他事情更喜欢的事情会让你更喜欢代码。不用说，这可能是让数据科学变得非常有趣的重要一步。
第二:休息一下
程序员犯的另一个错误是休息时间不够。如果你想发挥你的最大潜能，写出优秀的代码，并在软件方面做出正确的选择，你必须休息一下。我认为一个好的规则是每小时至少休息 15 分钟。也就是说，每个人都是不同的，个人可能需要找到一个适合自己的比例。
你的大脑需要充电。重复、艰巨的任务，比如给电脑编程，会很快耗尽你的精神力量。因此，休息是非常重要的。每当我休息的时候，我也会选择做一些我真正喜欢做的事情。这可以把你的注意力从编程的世界中移开一点，让你以一种全新的眼光回到你的软件中。就我而言，我喜欢弹吉他和其他乐器，如钢琴、贝斯、小提琴或曼陀林。对我来说，这是完美的暂时逃避，然而，你的活动可以像看你最喜欢的节目一样简单。我最近开始在程序跳转的间隙看《曼达洛人》,我发现这样做同样有效——唯一的问题是你可能不得不间歇性地中断你的节目！
№3:少喝咖啡！
这对许多程序员来说可能是一个惊喜，但是更多的咖啡是一件坏事——不是一件好事。我也有责任总是挥舞着我的咖啡，好像它是一种武器，我是一个战士。虽然在某些方面，这种化学物质的效果是编程所需要的，但在其他方面却不是。我爱喝咖啡，但我觉得也应该理解为适量饮用。电池可以快速启动，但最终需要以某种方式充电。换句话说，用咖啡因剥夺自己的睡眠不是一个好的做法。
№4:拉伸
另一个我在实际做之前没有太注意的技巧是拉伸。延伸可以在一个人的软件工程程序中发挥不可思议的作用。拉伸不仅对你的肌肉有好处，对你的大脑也有好处。虽然我最初没有参与休息和编程之间的拉伸，但现在我做了，我当然可以保证结果。不仅是我的背在感谢我，我的心也真的感觉很好。拉伸可以增加和放松血液流动，这使你的大脑实际上工作得更好，因为它接收了更多的氧气。
№5:晒晒太阳！
另一个很好的建议是走出去。虽然我从个人经历中了解到，走出深渊，感受到烈日的煎熬是很可怕的，但我们不是吸血鬼。人类需要维生素 d。这也将有助于改善你的身体和大脑的功能。这样做的事情当然是参与的好主意，尤其是在处理复杂问题的时候。
№6:吃饭和编程
对我来说，个人编程放松是食物。每个人都喜欢食物，这是有充分理由的。在我看来，零食是在你浏览代码时保持多巴胺流动的好方法。每当我们吃东西时，我们的大脑内部实际上有一种复杂的化学反应。它让我们感觉良好，甚至休息。
然而，一个重要的方面是选择正确的食物。我的建议是平衡复杂碳水化合物、必需维生素和简单糖类。举例来说，一个很好的选择就是面包上的鳄梨酱。就我个人而言，我内心疯狂的意大利科学家喜欢吃意式面包。也就是说，有数以百万计的膳食是很好的选择，或者简单地吃简单的水果、蔬菜、面包，甚至三明治也可以非常有效。
№7:果酱和程序
到目前为止，防止精疲力竭并让我更想编码的最有效的方法是“干扰”播放音乐可以对你的情绪产生如此深远的影响，并使节目更流畅。我当然会建议你在编程的时候听音乐——只有一个例外。如果音乐是你非常熟悉的，而你发现自己落后于歌词——它可能不是最佳的。很难同时关注音乐和代码，在后台会更好。
№8:多任务
另一个有些人可能没想到的策略是多任务处理。在编程中，多任务似乎会对生产率产生可怕的影响。其实恰恰相反。多任务处理是一个很棒的想法，因为在不同的项目中会不断有停止点。例如，在一个项目中，你完成了一个非常困难的功能，立即进入下一个困难的功能只会使它更难继续下去。这同样适用于编写函数时遇到的困难。
与其敲着同样的代码盯着屏幕好像你在等待一个顿悟，暂时远离代码可能是有意义的。这有助于让你带着全新的视角回来，这对你真正完成大量工作非常有益。
№9:睡觉。
像我这样的夜间程序员普遍患有失眠症。有很多程序员都患有严重的失眠症。很难停止去想它，或者关闭一个人的大脑。如果你被困在一个问题上，尤其如此。有趣的是，我实际上睡着的时候想到了一个 bug，并梦想着如何修复它，然后在大约 10 分钟后迅速醒来，并对着电脑尝试梦里发生的事情。
奇怪。
我不认为我需要表达睡眠是非常重要的，但无论如何我将继续这样做。电池需要充电，这个星球上的每个人类都需要睡眠，不管是不是程序员。也就是说，为了让你的大脑发挥最大的潜能，从代码中获得你想要的结果，偶尔休息一下可能是个好主意！
№10:聪明地工作，而不是努力工作
编程时避免精疲力尽的另一个伟大策略是以一种优越的方式工作。有一些强力的方法和途径来为某些事情编程，也有一些简单的方法。如果你接近一个解决方案，并认为“这将是乏味的”，寻找另一个解决方案可能是一个好主意。
总是为你的特殊问题找到正确的解决方案。此外，在工作中始终使用正确的工具。例如，尝试用 Python 编写最大的应用程序是没有意义的——因为这不是 Python 的真正用途。说到编程，拥有一个分析和处理代码的过程也是一个好主意，团队越大，一个处理其他人代码的过程就越重要。
№11:不要逗留
我要说的最后一点是不要停留在问题上。当你遇到一个你在编程中无法解决的问题时，它可能是压倒性的。想别的，用别的，最终自己解决问题，可能都是不可能的。没有充分的理由在某些代码的一个方面花费 10 多分钟。
我建议结合使用其他一些技巧。一个很好的例子就是简单地休息一下，做一些你也喜欢的事情。例如，坐下来看电视，试着暂时放下这个问题。然而，即使你做不到，你也可能会像我一样——我有时会坐下来做别的事情，在做的时候我会想出解决方案，然后回到电脑前递归地尝试每个想法。
结论
编程倦怠是我们行业内的一个严重问题。我觉得企业场景也有基本面的问题。我认为，特别是许多行业，在最后期限方面被逼得有点太紧了。不应该是这样的，因为人们发现，让软件工程师少工作实际上是让他们多工作。如果你继续榨柠檬汁，即使你已经去了皮，那么你的柠檬水味道会很糟糕。然而，这份清单上的一些建议可能是有价值的，甚至可以在公司环境中使用。深呼吸——祝你好运。我希望这些建议和话能在你的经历中派上用场。对我来说最有效的方法之一可能是边编程边播放音乐。非常感谢您阅读我的文章，我非常感激。
让你更经常使用熊猫查询功能的 10 个例子
发现它的全部潜力
法国人 Daphné Be 在 Unsplash 上的照片
Pandas 是一个广泛使用的数据分析和操作库。它提供了许多功能和方法来简单有效地执行典型操作。
数据分析中的一个典型任务是过滤数据点(或观察值)。在使用表格数据的情况下，数据点由一行表示。我们有时需要根据一些特性(或列)值来过滤一行。
有几种熊猫方法来过滤数据点。在本文中，我们将重点介绍其中一种方法。就是查询功能。
让我们首先导入库并创建一个样本数据框。
import numpy as np
import pandas as pddf = pd.DataFrame(np.random.randint(10, size=(5,6)), columns=list("ABCDEF"))df
(图片由作者提供)
我们现在可以开始使用查询函数来过滤该数据框。
示例 1
查询函数允许以字符串形式应用过滤条件。与许多其他技术相比，它提供了更多的灵活性。
df.query("A > 4")
(图片由作者提供)
我们选择了 A 列中的值大于 4 的行。
示例 2
我们可以很容易地组合多个条件。
df.query("A > 4 and E == 5")
(图片由作者提供)
示例 3
也可以使用“或”逻辑来组合多个条件。
df.query("A > 2 or F > 4")
(图片由作者提供)
实例 4
“not”操作符也可以作为查询函数中过滤器的一部分来实现。
df.query("not (A > 2 or F > 4)")
(图片由作者提供)
实例 5
我们还可以在查询函数中使用简单的数学运算。
df.query("A*2 < 5")
(图片由作者提供)
实例 6
查询功能允许使用一些内置函数，这为我们提供了更多的灵活性。
例如，我们可以使用 abs 函数返回一个数字的绝对值。让我们首先将 F 列中的值转换为负整数，然后编写一个包含 abs 函数的查询。
df.F = -1 * df.Fdf.query("abs(F) > 6")
(图片由作者提供)
例 7
也可以使用排序(平方根)函数。
df.query("sqrt(A) > 2")
(图片由作者提供)
实施例 8
逻辑运算符也可用于过滤字符串。让我们添加一个包含字符串的列。然后，我们可以根据新列过滤数据框。
df["G"] = ["John", "Jane", "Ashley", "Luke", "Michael"]df.query("G > 'Jo'")
示例 9
在处理日期和时间时，查询功能也很方便。我们可以在 dt 访问器下实现一些函数。为了演示这个功能，我们需要一个包含日期或时间的列。
df["Date"] = pd.date_range(start="2021-04-05", periods=5, freq="M")df
(图片由作者提供)
假设我们需要选择月份值大于 6 的行。下面是我们如何完成这项任务。
df.query("Date.dt.month > 6")
(图片由作者提供)
实例 10
我们还可以创建一个比较两个或更多列的条件。
df.query("A + B < C")
(图片由作者提供)
结论
过滤值是数据分析和操作的重要部分。我们可能对符合特定条件的值感兴趣。类似地，我们可能想要基于一组过滤器来探索值。
Pandas 为过滤数据帧提供了丰富的技术选择。查询功能就是其中之一，它在很多情况下都很方便。
感谢您的阅读。如果您有任何反馈，请告诉我。
使用 Python Seaborn 掌握分布图的 10 个示例
分布图对 EDA 至关重要
莎伦·皮特韦在 Unsplash 上的照片
任何数据产品的第一步都应该是理解原始数据。对于成功和高效的产品，这一步占据了整个工作流程的很大一部分。
有几种方法用于理解和探索数据。其中之一是创建数据可视化。它们帮助我们探索和解释数据。
通过创建适当且设计良好的可视化，我们可以发现数据中的底层结构和关系。
分布图对于探索性数据分析至关重要。它们帮助我们检测异常值和偏斜度，或者获得集中趋势(平均值、中值和众数)的测量的概述。
在本文中，我们将通过 10 个例子来掌握如何使用 Python 的 Seaborn 库创建分布图。举例来说，我们将使用 Kaggle 上的墨尔本房屋数据集中的一个小样本。
让我们从导入库和将数据集读入 Pandas 数据框开始。
import pandas as pd
import seaborn as sns
sns.set(style="darkgrid", font_scale=1.2)df = pd.read_csv(
"/content/melb_housing.csv",
usecols=["Regionname", "Type", "Rooms", "Distance", "Price"]
)df.head()
(图片由作者提供)
该数据集包含墨尔本房屋的一些特征及其价格。
Seaborn 的 displot 功能允许创建 3 种不同类型的分布图，它们是:
- 柱状图
- Kde(核密度估计)图
- Ecdf 图
我们只需要调整 kind 参数来选择绘图的类型。
示例 1
第一个例子是创建一个基本的直方图。它将连续变量的值范围划分为离散的区间，并显示每个区间中有多少个值。
sns.displot(
data=df,
x="Price",
kind="hist",
aspect=1.4
)
(图片由作者提供)
我们将数据框的名称传递给数据参数。x 参数采用要绘制的列名。aspect 参数调整大小的宽高比。也可以改变高度。
示例 2
在第一个例子中，我们清楚地看到 price 列中有异常值。柱状图右侧有一条长尾，表明很少有价格非常高的房子。
减少这种异常值影响的一种方法是取值的对数。displot 函数可以使用 log_scale 参数执行此操作。
sns.displot(
data=df,
x="Price",
kind="hist",
aspect=1.4,
log_scale=10
)
(图片由作者提供)
价格表示为 10 的幂。我们现在对房价的分布有了更好的了解。
示例 3
我们还可以调整直方图中的仓数量。在某些情况下，最好使用较少数量的箱，这样我们可以获得更有条理的概览。
用于此调整的参数是箱。
sns.displot(
data=df,
x="Price",
kind="hist",
aspect=1.4,
log_scale=10,
bins=20
)
(图片由作者提供)
实例 4
数据集还包含分类变量。例如,“类型”列有 3 个类别，分别是 h(住宅)、t(城市住宅)和 u(单位)。我们可能需要分别检查每种类型的分布情况。
一种选择是在同一可视化中用不同的颜色显示它们。我们只需要将列名传递给 hue 参数。
sns.displot(
data=df,
x="Price",
hue="Type",
kind="hist",
aspect=1.4,
log_scale=10,
bins=20
)
(图片由作者提供)
该图为我们提供了两条信息:
- 每类房屋的数量。h 类是最大的一类。
- 每类房屋的价格分布。
实例 5
另一种分别检查每个类别分布的方法是创建单独的图。对于这项任务，我们可以使用 col 或 row 参数。在给定的列中，每个类别都有一个子情节。
sns.displot(
data=df,
x="Price",
col="Type",
kind="hist",
aspect=1.4,
log_scale=10,
bins=20
)
(图片由作者提供)
实例 6
displot 函数还允许生成二维直方图。因此，我们得到了关于 2 列中的值的观察值(即行)分布的概述。
让我们使用 price 和 distance 列创建一个。我们只是将列名传递给 x 和 y 参数。
sns.displot(
data=df,
x="Price",
y="Distance",
col="Type",
kind="hist",
height=5,
aspect=1.2,
log_scale=(10,0),
bins=20
)
(图片由作者提供)
较暗的区域更密集，因此包含更多的观察结果。两列看起来都呈正态分布，因为密集区域位于中心。
您可能已经注意到，我们使用了一个元组作为 log_scale 参数的自变量。因此，我们可以为每一列传递不同的标度。
例 7
Kde 图也可以用来可视化变量的分布。它们与直方图非常相似。然而，kde 图使用连续的概率密度曲线而不是离散的箱来表示分布。
kind 参数设置为“kde ”,以生成 kde 图。
sns.displot(
data=df,
x="Price",
kind="kde",
aspect=1.4,
log_scale=10
)
(图片由作者提供)
实施例 8
与直方图类似，kde 图可以针对不同的类别单独绘制。我们的数据集包含房屋的区域信息。让我们来看看不同地区的价格变化。
sns.displot(
data=df,
x="Price",
hue="Regionname",
kind="kde",
height=6,
aspect=1.4,
log_scale=10
)
(图片由作者提供)
南部大都市地区似乎有最高的平均房价。
示例 9
检查变量分布的另一种方法是使用 ecdf 图。它表示低于给定列中每个唯一值的观察值的比例或计数。
这是一种视觉化的累积总和。因此，我们能够看到更密集的值范围。
sns.displot(
data=df,
x="Distance",
kind="ecdf",
height=6,
aspect=1.4,
stat="count"
)
(图片由作者提供)
曲线斜率高的值范围由更多的观察值填充。例如，我们没有很多房子的距离高于 30。与此相反，在 10 到 15 的距离范围内有很多房子。
实例 10
ecdf 绘图也支持色调、颜色和行参数。因此，我们可以区分一列中不同类别之间的分布。
sns.displot(
data=df,
x="Distance",
kind="ecdf",
hue="Type",
height=6,
aspect=1.4,
stat="count"
)
(图片由作者提供)
结论
对于数据分析或机器学习任务，了解变量(即特征)的分布非常重要。我们如何处理给定的任务可能取决于分布。
在本文中，我们看到了如何使用 Seaborn 的 displot 函数来分析价格和距离列的分布。
感谢您的阅读。如果您有任何反馈，请告诉我。
掌握 Python 字典理解的 10 个例子
综合实践指南
一个字典是一个无序的键值对集合。每个条目都有一个键和值。字典可以被认为是一个有特殊索引的列表。
(图片由作者提供)
这些键必须是唯一且不可变的。所以我们可以使用字符串、数字(int 或 float)或元组作为键。值可以是任何类型。
在本文中，我们将关注字典理解，这是一种使用可重复项创建字典的方法。逻辑与列表理解相同，但由于词典的结构不同，语法有所不同。
为了了解列表和字典理解之间的相似性，我将在前两个例子中创建一个列表和字典理解。
示例 1
words = ['data', 'science', 'machine', 'learning']#list comprehension
[len(i) for i in words]
[4, 7, 7, 8]#dictionary comprehension
{i:len(i) for i in words}
{'data': 4, 'science': 7, 'machine': 7, 'learning': 8}
我们有一个 iterable，它是一个名为“words”的列表。在列表理解中，我们创建一个包含单词长度的列表。在字典理解中，我们需要基于迭代指定键和值。返回的字典包含作为键的单词和作为值的单词长度。
列表和词典理解的基本语法是:
(图片由作者提供)
示例 2
对于本例，我们将使用附加条件重复第一个示例中的任务。列表和字典理解都接受 if/else 条件语句。
words = ['data', 'science', 'machine', 'learning']#list comprehension
[len(i) for i in words if len(i) > 5]
[7, 7, 8]#dictionary comprehension
{i:len(i) for i in words if len(i) > 5}
{'science': 7, 'machine': 7, 'learning': 8}
返回的变量只包含长度超过 5 个字符的单词。
示例 3
在这个例子中，我们将稍微增加条件语句的复杂性。
words_dict = {i:len(i) if len(i) > 5 else 'short' for i in words}print(words_dict)
{'data': 'short', 'science': 7, 'machine': 7, 'learning': 8}
我们在字典理解中实现了 if/else 条件。如果长度大于 5，则该值成为长度。否则，我们将单词“short”指定为值。
使理解吸引人的是它们的一行语法。它看起来非常简单，比循环的等价形式更容易理解。例如，上面理解的循环的等价形式是:
对于循环版的字典理解(图片由作者提供)
实例 4
我们可以在字典理解中迭代两个条目。
words = ['data', 'science', 'machine', 'learning']
values = [5, 3, 1, 8]dict_a = {i:j for i, j in zip(words, values)}print(dict_a)
{'data': 5, 'science': 3, 'machine': 1, 'learning': 8}
键值对是通过对键和值的单独列表进行迭代来创建的。zip 函数通过组合每个列表中的项目来返回元组的可迭代表。
实例 5
我们还可以在迭代元组列表时对值设置条件。
words = ['data', 'science', 'machine', 'learning']
values = [5, 3, 1, 8]dict_a = {i:j for i, j in zip(words, values) if j > 4}print(dict_a)
{'data': 5, 'learning': 8}
实例 6
我们还可以在键值对上应用转换。
dict_b = {i.upper():j**2 for i, j in zip(words, values)}print(dict_b)
{'DATA': 25, 'SCIENCE': 9, 'MACHINE': 1, 'LEARNING': 64}
键和值都使用简单的 Python 方法进行修改。
例 7
我们可以通过使用 items 方法来访问字典中的键值对。
print(dict_b.items())
dict_items([('DATA', 25), ('SCIENCE', 9), ('MACHINE', 1), ('LEARNING', 64)])
我们可以使用现有字典中的条目作为字典理解中的条目。它允许我们基于现有的字典创建字典，并修改键和值。
dict_c = {i.lower():j%2 for i, j in dict_b.items()}print(dict_c)
{'data': 1, 'science': 1, 'machine': 1, 'learning': 0}
实施例 8
Python 的 enumerate 函数可用于创建基于列表的元组的 iterable。每个元组包含列表中具有递增整数值的项目。
names = ['John', 'Jane', 'Adam', 'Eva', 'Ashley']list(enumerate(names))
[(0, 'John'), (1, 'Jane'), (2, 'Adam'), (3, 'Eva'), (4, 'Ashley')]
我们可以在字典理解中使用枚举功能。
dict_names = {i:len(j) for i, j in enumerate(names)}print(dict_names)
{0: 4, 1: 4, 2: 4, 3: 3, 4: 6}
如果您只想创建一个基于元组列表的字典，而不对值进行任何修改，那么您不需要使用理解。dict 函数将完成这项工作。
dict(enumerate(names))
{0: 'John', 1: 'Jane', 2: 'Adam', 3: 'Eva', 4: 'Ashley'}
示例 9
这个例子包含的条件比上一个稍微复杂一些。假设我们有下面的字典和列表。
lst = ['data','science','artificial', 'intelligence']dct = {'data': 5, 'science': 3, 'machine': 1, 'learning': 8}
我们想使用上面定义的列表和字典创建一个新字典。新字典的键将是列表中的元素，所以我们将遍历列表中的元素。如果该元素也在字典中，则该值将是字典中该键的值。否则，该值将是密钥的长度。
{i:dct[i] if i in dct else len(i) for i in lst}{'artificial': 10, 'data': 5, 'intelligence': 12, 'science': 3}
单词 artificial 不在字典中，所以它的值是单词的长度。单词 data 在字典中，所以它的值取自字典。
实例 10
字典的键必须是不可变的，因此元组可以用作键。字典理解允许通过实现嵌套循环来生成元组的关键字。
a = [1,2,3,4]
b = [5,6,7]dct = {(i,j):i*j for i in a for j in b}print(dct)
{(1, 5): 5,
(1, 6): 6,
(1, 7): 7,
(2, 5): 10,
(2, 6): 12,
(2, 7): 14,
(3, 5): 15,
(3, 6): 18,
(3, 7): 21,
(4, 5): 20,
(4, 6): 24,
(4, 7): 28}
列表中的每一对条目都是字典中的一个键。该值是键中各项的乘积。
等效的 for 循环语法:
(图片由作者提供)
结论
字典是 Python 中非常重要的数据结构，在很多情况下都会用到。我们在这篇文章中做的例子将涵盖你需要知道的关于字典理解的大部分内容。它们会让你在使用和创建新词典时感到舒适。
感谢您的阅读。如果您有任何反馈，请告诉我。
理解 SQL 视图的 10 个示例
MySQL 实用指南
保罗·斯科鲁普斯卡斯在 Unsplash 上的照片
SQL 是一种编程语言，用于管理和维护存储在关系数据库中的数据。关系数据库由带有标记行和列的表组成。
SQL 最常见的操作之一是查询数据库以检索数据。典型的关系数据库包含许多表，这些表通过称为外键的列中的共享值相互关联。
随着表数量的增加，编写查询开始变得复杂。此外，我们通常需要在从数据库中检索时过滤或转换数据。因此，我们最终要编写复杂冗长的查询来获取所需的数据。
编写一两次复杂的查询是可行的。但是，如果我们需要多次使用它，就需要一种更实用的方法。一种选择是将查询保存在文本或 sql 文件中，并在需要时复制它。这很好，但是有一个更好的选择，那就是 SQL 视图或简单的视图。
视图是存储的查询。视图保存在数据库服务器中，因此我们不必从其他文件中复制它们。我们通过为查询指定一个名称来创建视图。
让我们从一个例子开始，这样我们就对视图的样子有了一个概念。之后，我将详细阐述示例，并更详细地解释观点。
我已经用模拟数据创建了一个客户和订单表。这些表包含一些关于企业客户及其订单的信息。以下是表格的概述:
客户表(图片由作者提供)
订单表(作者图片)
这些表通过客户 id (cust_id)列相关联，因此我们使用客户 id 列来连接这些表。
考虑这样一种情况，需要找到每个位置的总订单量。下面是完成这项任务的查询。
#Example 1mysql> select customer.location, sum(orders.amount)
-> from customer
-> join orders
-> on customer.cust_id = orders.cust_id
-> group by customer.location;+----------+--------------------+
| location | sum(orders.amount) |
+----------+--------------------+
| Austin | 9811.09 |
| Dallas | 23288.40 |
| Houston | 12978.33 |
+----------+--------------------+
我们从 customer 表中选择 location，从 orders 表中选择 sum amount。这些表在客户 id 列上联接。group by 子句按位置对条目(即行)进行分组。
我们可以使用如下视图存储该查询:
#Example 2mysql> create view totalAmount
-> as
-> select customer.location, sum(orders.amount)
-> from customer
-> join orders
-> on customer.cust_id = orders.cust_id
-> group by customer.location;
“create view”语句与视图的名称一起使用。然后，我们在“as”关键字后编写查询。
正如您所注意到的，创建视图不会返回任何内容，或者不会执行 select 语句。视图只有在被调用时才会生成结果集。
我们可以像查询表一样调用视图。这是如何做到的:
#Example 3mysql> select * from totalAmount;+----------+--------------------+
| location | sum(orders.amount) |
+----------+--------------------+
| Austin | 9811.09 |
| Dallas | 23288.40 |
| Houston | 12978.33 |
+----------+--------------------+
上面的例子使视图看起来像表格。就查询而言，视图可以被认为是表。但是，它们不存储任何数据。一旦执行了视图，SQL 就从视图中指定的表中检索数据。因此，视图有时被称为虚拟表。
注意:需要强调的是，我们使用 MySQL 作为关系数据库管理系统(RDBMS)。尽管不同 RDBMs 之间的 SQL 语法基本相同，但可能会有一些细微的差别。
我们可以使用 where 子句过滤视图。
#Example 4mysql> select * from totalAmount
-> where location = "Austin";+----------+--------------------+
| location | sum(orders.amount) |
+----------+--------------------+
| Austin | 9811.09 |
+----------+--------------------+
我们只能根据视图中包含的列进行筛选。例如，orders 表有一个日期列，但不能用于筛选。totalAmount 视图只涉及金额的位置和总和。这是我们可以用于过滤的仅有的两个值。
让我们创建另一个视图，它允许基于日期和金额列进行筛选。
#Example 5mysql> create view cityOrders
-> as
-> select
-> customer.location,
-> orders.date,
-> orders.amount
-> from customer
-> join orders
-> on customer.cust_id = orders.cust_id;
cityOrders 视图引用了三列，即 customer 表中的 location 和 Orders 表中的 date 和 amount。
我们可以使用 cityOrders 视图来计算特定日期每个地点的总订单量。
#Example 6mysql> select location, sum(amount)
-> from cityOrders
-> where date = '2020-01-31'
-> group by location;+----------+-------------+
| location | sum(amount) |
+----------+-------------+
| Austin | 77.94 |
| Dallas | 260.77 |
| Houston | 72.46 |
+----------+-------------+
我们还可以计算每个城市高于特定金额的订单数量。
#Example 7mysql> select location, count(amount)
-> from cityOrders
-> where amount > 20
-> group by location;+----------+---------------+
| location | count(amount) |
+----------+---------------+
| Austin | 160 |
| Dallas | 383 |
| Houston | 205 |
+----------+---------------+
尽管 totalAmount 和 cityOrders 视图都引用了 Amount 列，但我们不能在 totalAmount 视图中使用单个订单金额进行筛选。原因是 totalAmount 视图指的是金额的总和，而不是单个订单的金额。
我们可以使用“alter view”或“create or replace view”语句来更新视图。区别在于视图必须存在才能使用“alter view”语句。如果我们不确定视图是否已经存在，我们应该使用“创建或替换视图”语句。
让我们修改 cityOrders 视图。
#Example 8mysql> alter view cityOrders
-> as
-> select
-> customer.location,
-> customer.age,
-> orders.date,
-> orders.amount
-> from customer
-> join orders
-> on customer.cust_id = orders.cust_id;
我们已经将 customer 表中的 age 列添加到 cityOrders 视图中。我们现在也可以使用年龄进行过滤或聚合。以下查询返回 30 岁以上客户的平均订单额。它还根据位置对结果进行分组。
#Example 9mysql> select location, avg(amount)
-> from cityOrders
-> where age > 30
-> group by location;+----------+-------------+
| location | avg(amount) |
+----------+-------------+
| Austin | 53.740153 |
| Dallas | 47.069703 |
| Houston | 49.287771 |
+----------+-------------+
如果我们不再需要一个视图，我们可以删除它。语法与删除表相同。
#Example 10mysql> drop view totalAmount;
Query OK, 0 rows affected (0.00 sec)mysql> select * from totalAmount;
ERROR 1146 (42S02): Table 'practice.totalAmount' doesn't exist
结论
视图是 SQL 的一个重要概念。使用视图有很多好处。首先，它简化了复杂的查询。我们所做的例子包括连接两个表。对于包含许多表的大型数据库，查询可能会非常复杂。因此，视图提供了一种更实用的方法。
视图也使我们免于一遍又一遍地编写相同的查询。假设我们有一个非常复杂的例行计算，涉及多个过滤、聚合和嵌套的 select 语句。将它放在视图中比每次都编写查询要好得多。
我们还可以使用视图更好地控制对数据库的访问。表格可能包含只有特定员工才能访问的敏感信息。使用视图，我们可以只授予对表中特定列的访问权。
感谢您的阅读。如果您有任何反馈，请告诉我。
医疗保健中机器学习应用的 10 个激动人心的例子
行业使用案例
为数据科学家提供最激动人心工作的行业
全球医疗保健支出占全球国内生产总值的 10.3%，或全球近 9 万亿美元，预计未来几年的年增长率为 3.9%。
这些数字令人印象深刻，毫不奇怪，数字化和新技术正在彻底改变医疗保健行业。
人们拥有可穿戴设备，并使用技术来监控自己的健康。据估计，2022 年可穿戴设备的数量将达到 10 亿，市场规模将达到 930 亿美元。
远程医疗正在极大地扩展，现在近 30%的消费者首先进行虚拟就诊。医疗设备变得更加先进，并集成了人工智能来支持医生和内科医生。最后，为了改善提供商的服务和增强客户体验，数据生态系统是通过端到端数据集成构建的。
因此，护理模式正在发生变化，我们的健康和福祉变得由数据驱动。
医疗保健行业可分为以下 5 个领域。
- 医疗保健提供者和机构，如医院、手术中心、疗养院或医生和内科医生
- 医疗设备和装置，如诊断设备、矫形设备或医疗器械
- 分销商和批发商，如药店或医疗保健提供商的药品和设备分销商
- 健康保险和管理式医疗
- 制药、生命科学和生物技术
新冠肺炎加快了所有这些部门的创新和数字化，消费者和患者体验到了更多的便利和好处。
新冠肺炎疫苗的快速发展只能归功于数据驱动的发展方法。通过集成图像识别算法来检测微小异常(如癌症转移),放射诊断的质量得到了提高。
从社交媒体帖子到可穿戴数据和医疗记录，各种数据被用来预测健康状况和疾病。
但不仅仅是消费者一方受到了干扰。医疗从业者和保健专业人员也在改变他们的行为。
医疗游民是越来越多的人群，甚至平台也存在。数据可用性和提取的信息是这种发展的关键驱动力。它从经验和时间表匹配诊断工具开始。
因此，与健康相关的数据正在激增，医疗保健正处于相当大的混乱之中。
对工作平台的分析显示，大约 1/3 的开放数据科学家职位在医疗保健行业。毫不奇怪，看看 LinkedIn 上的数据科学家档案就会发现，这个行业的数据科学家几乎和科技行业一样多。
大多数有抱负的高级数据科学家只关注科技行业，错过了一个令人兴奋的行业。另外还有一个准入门槛，因为需要非常专业的知识。除了商业头脑的重要性之外，还需要对(生物)统计、因果关系和模型准确性有良好的经验，这超出了通常的基本要求。算法的结果影响人类的健康，在极端情况下，可以决定生死。
然而，对数据科学家的高需求给了一个独特的机会，可以在没有该领域经验的情况下进入这个令人兴奋的行业。这是一个很好的机会，我强烈推荐。
我在医疗保健行业担任了多年的数据科学顾问，为上述所有五个行业提供服务。
在下文中，我将展示 10 个机器学习应用的案例研究，涵盖所有五个医疗保健领域。
医疗保健提供者和机构
1。 癌症患者住院决策支持
癌症患者遭受许多疾病的继发性障碍和治疗的副作用。如果或何时特定的症状如体温或疾病是由癌症疾病、治疗或其他疾病如流感或感冒引起的，通常并不明显。更具挑战性的是决定病人何时需要去医院。
患者通常等待太长时间，这导致两个问题:要么他们去医院太晚，使他们的健康处于高风险中，导致更长的恢复期和更高的费用，要么他们需要在急诊室的正常开放时间之外去医院，并由不熟悉他们病史的医疗专业人员治疗，最终导致错误或不必要的治疗。
因此，根据患者输入的可穿戴数据和信息，移动应用程序会在仪表盘上给出指示和进一步的细节，以便患者可以更好、更早地决定是否需要去医院。
急性疾病管理中的机器学习支持不仅是癌症患者的发展趋势。
应用的机器学习方法有 XGBoost(一种梯度提升算法，也是 Python、Julia、Java 等的库。)，随机森林，支持向量机。当足够的数据可用时，递归神经网络给出极好的结果。
2。 个性化健康治疗
个性化治疗在医学上并不新鲜。古希腊人已经致力于开发个性化的疗法和药物。随着基于更大人口规模的更多健康数据、更精细的人均数据(如基因型和表型)以及连续数据(如心跳频率或连续血糖监测)的可用，向数据驱动型决策的转变可能会实现。
一个例子是糖尿病的个性化治疗，其中机器学习算法改善了治疗。在全球范围内，超过 4 亿人患有糖尿病。糖尿病会导致失明、心脏病发作和中风，以及肾衰竭等。
糖尿病药物治疗的有效性取决于个人生活方式、健康和身体活动的许多变量。此外，这些因素会随着时间而变化。由于医学的快速发展，治疗方法也在改变。
因此，药物治疗的最初决定是具有挑战性的，更需要不断的调整和完善。机器学习和深度学习算法越来越多地支持医生进行诊断和开出最有效的治疗方案。
支持向量机(SVM)、随机森林和 k-最近邻等方法用于临床和医疗决策支持或患者自我管理工具。逻辑回归和多层感知器支持个人治疗结果的预测。
医疗设备和器械
3。 减少诊断测试中的假阳性/假阴性
在许多应用中，如来自传感器的警报，需要减少误报。假阳性意味着测试结果被错误地分类为特定条件存在，例如疾病，而它并不存在。然而，在医学上，假阴性同样重要。如果实际上有一个条件，假阴性表示不存在该条件。
让我们看一些例子来更好地理解这个问题。
乳腺癌是导致全球大多数女性死亡的癌症类型。利用当前的乳房扫描方法，已知 10%-30%的乳腺癌被遗漏，这导致放射科医生的阳性癌症标记率更高。这导致在随后的详细诊断中高达 30%的假阳性。在这种情况下，需要减少假阳性。
另一方面，肺癌的早期检测可以挽救许多生命。最初的诊断有高达两位数百分比的假阴性。在肺癌的情况下，需要减少假阴性并且不遗漏任何肺癌。
所以，要解决的问题是高度相关的，需要完全理解。
为了改善假阳性或假阴性，机器学习方法被应用于诊断结果。这些结果通过逻辑回归或随机森林进一步分类，这两种方法在这些医学应用中效果很好，如果它们是假阳性/假阴性的话。当大量数据可用时，例如新冠肺炎数据，卷积神经网络(CNN)给出了极好的结果并极大地提高了准确性。
4。 医疗设备性能的提高和更高质量的维护
随着技术和更复杂的机器学习和人工智能应用的兴起，电子医疗设备正在成为主流，这些应用极大地提高了结果的准确性。
医疗设备的例子有诊断设备，如计算机断层扫描仪、呼吸机、起搏器、心肺机、糖尿病监测工具或婴儿保育箱。这些设备提供了有关患者状况的重要测量值，医疗专业人员需要依靠正确的操作和测量。否则，将会导致患者严重受伤或死亡。
可以理解的是，这种医疗设备的使用需要监管机构的批准以及高度的安全性和质量保证。因此，这些设备的维护成本很高。
为了获得所需安全级别的印象，考虑一个设备 99.9%的可靠性，这似乎是相对较高的。我们的心脏每天跳动大约 10 万次。因此，在 99.9%的可靠性下，这将意味着我们平均每 1000 次心跳就会错过一次，或者说一天 100 次心跳，这是一个很高的数字。
因此，医疗设备需要更高的可靠性。
随着今天的数据可用性，机器学习算法被开发来支持性能和维护预测。值得一提的是，此类支持系统需要满足标准，如IEC 60601-1-医疗电气设备-第 1 部分:基本安全和基本性能的一般要求，这些标准增加了模型开发的复杂性。
ML 模型是基于 30-50 个变量开发的，如设备年龄、制造商、电压等技术措施、性能检查结果和过去的安全检查决定。
决策树的优势在于它们是可解释的，而且通常给出最准确的结果。其他使用的方法有随机森林、支持向量机和朴素贝叶斯。由于所需的可解释性，没有使用神经网络/深度学习算法。
分销商和批发商
5。 疫苗冷链储存与配送质量控制
许多药物，尤其是疫苗，需要储存在冰箱里。最近的例子是新冠肺炎疫苗，如辉瑞/BioNTech 或 Moderna，它们必须保存在-80 至-60 摄氏度的冰箱中。这种所谓的冷链必须在从生产工厂到全球交付的整个物流过程中得到保证，并在药剂师或医生为患者使用时得到保证。
管理这样一个冷链是非常复杂的。它始于包装和使用多少干冰来确保正确的温度。当货物在卡车上或货物在飞机上几个小时时，温度需要保持在一定范围内。最后，它必须到达最终用户，通常是药剂师和医生，在那里储存直到使用。
今天，安装了许多传感器和先进的跟踪技术来测量温度和 GPS 位置。诸如交通/空中交通数据、道路状况、机场信息、车辆规格、天气状况和包装数据之类的其他数据被集成。
机器学习被用来解决几个挑战。它从交通和空中交通预测以及优化物流路线开始。基于这些条件，可以预先预测货物的温度下降并优化包装。输送过程中的连续测量能够实时监控温度并预测进一步的温度下降。尤其是当意外延迟发生时，可以预测何时需要在交付期间进行干预。
这一应用领域仍处于起步阶段，还没有一套明确的方法在特定情况下是优越的。因此，所有不同的监督、非监督、半监督和集成学习方法都得到了测试和应用。
6。 药品需求预测
目前正在开发的另一个更复杂的数据驱动方法领域是药物需求预测。多年来，预测一直基于简单的统计数据、历史销售数据和时间序列模型，如移动平均线或 ARIMA。
与消费品相比，制药业有几个特点，使得预测更加复杂。制药业受到严格监管。因此，监管和不断变化的监管会极大地影响需求。例如，当生产非专利药物时，专利和专利到期可以完全改变市场竞争。
与政府的特殊合同或特殊合同条件，例如，对于新冠肺炎疫苗，所有政府都有自己与生产商的特殊条件和价格，某一药物的新研究成果，或社会媒体的宣传，无论是积极的还是消极的，都对需求产生重大影响。
药品有严格的有效期，因此不能提前很长时间生产。但是生产过程，包括所有的法规和质量要求、强制性认证过程和法规批准，需要提前很长时间计划和执行。因此，生产可能性和需求过程之间的反应时间有很大差距。
一个例子是流感疫苗的生产，从春天开始，到秋天交货。如果像 2020 年那样，对流感疫苗有更高的需求，这种需求在 6 个月之前无法满足。
整合社交媒体数据为使用所有自然语言处理方法的机器学习开辟了一个巨大的领域。如果信息一旦被提取，例如，对特定药物的情绪，你需要预测它在接下来的，例如，90 天。情绪水平显示了对一种药物的接受程度和需求程度。这些方法从回归模型到基于树的 boosting 方法，不同核方法的支持向量机，再到神经网络。
健康保险和管理式医疗
7。 数字健身教练
缺乏锻炼会显著增加患糖尿病、心血管疾病、癌症、高血压、肥胖症和精神疾病的风险。另一方面，每周超过一小时的定期体育活动可以预防这些疾病，并使死亡率减半。
这为健康保险公司节省了大量成本，尤其是对整个社会而言。因此，有很多努力来激励人们进行有规律的体育活动。
另一方面，这是所有可穿戴设备的趋势。可穿戴设备的好处在于，它们可以持续测量健康相关因素，并实现数据驱动的教练支持。
一个重要的方面是推荐是个性化的。例如，一个几年不运动的人需要其他建议和激励，而不是一个已经有高水平活动的运动员，但可能需要一些睡眠或营养管理方面的指导。
机器学习是提供持续和实时的个性化辅导和激励系统的重要工具，以便基于活动的日常表现给出建议。
首先，必须将人们划分为响应性群体。例如，想要开始活动但需要外部推动的人，已经做了很少活动但需要被激励去做更多活动的人，等等。应用标准分类算法。
此外，根据个人的进步，必须给出进一步的建议。身体活动的预测是通过逻辑回归、AdaBoost、决策树、随机森林、支持向量机和神经网络来完成的。特别是对于行为改变的建议，使用类似长短期记忆(LSTM)的递归神经网络方法。
8。 儿科护理质量改进
保健服务的质量和治疗复杂疾病的可能性正在不断提高。尽管如此，仍然存在许多挑战，特别是基于个体特征的治疗剂量和持续时间，或针对没有许多临床研究可用的患者群体，如儿童。
幼儿药物和疗法的剂量仍然具有挑战性。剂量太高会导致永久性损伤，而剂量太低会延迟恢复并导致继发性疾病。这两种情况都可能导致死亡。此外，儿童的免疫系统没有得到充分训练，对治疗的反应可能不同于成人的反应。此外，儿童通常不能用语言表达疾病状态，以致于发现不良发展为时已晚。
因此，在过去的几年里，机器学习已经被纳入儿科护理，并在预测儿童的正确和个性化治疗方面取得了巨大成功。它仍处于起步阶段，具有很大的发展潜力。
充分利用其潜力的主要障碍之一是缺乏或没有足够的可用于检测和预测复杂模式的方法的数据。因此，目前使用更简单的方法。
首先，应用类似 k-means 的聚类算法来确定不同的群组。然后，不同队列的特征，如治疗时间、死亡率等。，进行了分析。当我们在关键健康领域工作时，队列的特征通过例如卡方检验(分类变量)和例如 Wilcoxon-Mann-Whitney 检验(连续变量)进行相互检验。
之后，应用各种分类算法，而交叉验证的随机森林是最常用的方法。
基因组数据在儿科护理中已经有一些应用，其中使用了深度学习方法。但这只是开始。
制药、生命科学和生物技术
9。 糖尿病的早期预测
世卫组织估计，全球约有 4 . 22 亿人患有糖尿病，每年有 160 万人死于糖尿病。
糖尿病的永久疗法并不存在，也无法逆转。此外，糖尿病导致严重的继发性疾病，如心脏病和中风、肾衰竭、神经损伤和肝脏脂肪变性，此外，这显著增加了肝癌的可能性。
因此，预测糖尿病并提前采取措施将预防许多疾病和死亡，并提高生活质量。
幸运的是，已经有几个模型和应用程序可以做到这一点。独立变量是例如血液中的葡萄糖浓度、血压、皮肤厚度、胰岛素、体重指数、年龄、工作类型等。应用 k 倍交叉验证。然而，像线性回归、决策树、随机森林、朴素贝叶斯或支持向量机这样的所有方法的准确度都在 75%到 80%之间，而具有两个或三个隐藏层的神经网络可以达到高达 90%的准确度。
糖尿病的应用已经给出了可靠的结果。在这一成功的基础上，对更复杂的疾病如阿尔茨海默病和多发性硬化症的预测正在发展中。
10。 临床药物开发成功的预测
一种新药的开发平均花费 13 亿美元。临床开发阶段的失败率为 90% 。
临床研究通常包含三个阶段。
第一阶段:第一阶段是在人体上测试药物。目的是测试安全性、最佳剂量和副作用。
第二阶段:在确定的治疗剂量下测试药物的疗效(对结果的影响)和副作用。
第三阶段:测试药物的安全性、有效性(疾病在实际应用中的影响)以及在确定的治疗剂量下的疗效。
每个阶段的成本都很高，在每个阶段的开始，都会对成功率进行一个估算。基于该比率，决定是继续还是放弃药物开发。
为了改进这种估计并做出更好的决策，应用了机器学习方法。
估计成功率的数据包含与临床试验相关的变量，包括来自前一阶段的数据、分子特性、监管环境、批准的药物(包括详细特征)、患者保护、医疗保健法、市场需求、公司和竞争对手信息、关于类似药物的信息，即，与类似疾病或类似设计类型相关的信息等。
主要应用且最成功的方法是基于树的方法。
数据形成复杂的模式，变量包含复杂的关系。因此，比应用的方法更重要的是特征选择、超参数调整和模型稳健性的各种测试，例如，用时间序列技术分析和减轻前瞻偏差。并且所有这些程序对于三个阶段中的每一个都不同。
这些程序相当复杂和耗时，需要项目的大部分时间，但需要确保可靠的预测结果。如果做得好，成功预测的准确率可以达到 90%。
连接圆点
医疗保健中的机器学习是最具挑战性的任务之一。应用的探索和开发还处于起步阶段。这让数据科学家非常兴奋。
这 10 个应用令人印象深刻地展示了机器学习在医疗保健领域的潜力。是真正的三赢局面。
- 这是所有患者的胜利，他们在个体的基础上获得了更有效和高效的治疗
- 用有限的资源为更多的人提供更好的服务是医疗保健行业的胜利
- 对于数据科学家来说，这是一个双赢的局面，他们可以通过应用他们所有的知识和先进的方法来解决复杂而令人兴奋的问题。
我强烈推荐以数据科学家的身份进入医疗保健行业。
你喜欢我的故事吗？在这里你可以找到更多。
</10-mistakes-you-should-avoid-as-a-data-science-beginner-ec1b14ea1bcd> [## 作为数据科学初学者应该避免的 10 个错误
towardsdatascience.com](/10-mistakes-you-should-avoid-as-a-data-science-beginner-ec1b14ea1bcd) </7-awesome-data-science-jobs-where-you-dont-need-any-coding-skills-2e08d13e84e6>
10 个神话般的 Python 装饰者
Python 编程语言中一些我最喜欢的装饰器的概述。
(src =https://pixabay.com/images/id-3359870/
介绍
Python 编程语言的一个伟大之处在于，它将所有的特性打包成一个非常有用的小软件包。许多上述特性可以完全改变 Python 代码的功能，这使得该语言更加通用。此外，如果使用得当，这些功能中的一些可以缩短编写有效软件所需的时间。Python 特性很好地实现了这些目标的一个很好的例子是 Python 的 decorators。
装饰器是快速编程宏，可用于改变 Python 对象的行为。它们可以应用于类和函数，实际上可以做很多真正有趣的事情！装饰器可以用来缩短代码，加速代码，并完全改变代码在 Python 中的行为方式。不用说，这个肯定能派上用场！今天我想展示一些我认为值得一试的装饰者。有很多装饰者，但是我选择了一些我认为功能最酷的。
№1: @lru_cache
这个列表中的第一个装饰器来自 functools 模块。这个模块包含在标准库中，非常容易使用。它还包含了比这个装饰器更酷的特性，但是这个装饰器肯定是我最喜欢的。这个装饰器可以用来加速使用缓存的函数和操作的连续运行。当然，在使用时应该注意交换和缓存，但是在一般用途的情况下，大多数时候这个装饰器是值得使用的。如果你想了解更多关于 Functools 的知识以及我喜欢它的原因，我实际上写了一整篇文章，你可以在这里阅读:
能够用一个简单的装饰器来加速代码是非常棒的。可以从这样的装饰器中获益的函数的一个很好的例子是递归函数，例如计算阶乘的函数:
def factorial(n):
return n * factorial(n-1) if n else 1
递归在计算时间上相当困难，但是添加这个装饰器可以帮助显著地加速这个函数的连续运行。
[@lru_cache](http://twitter.com/lru_cache)
def factorial(n):
return n * factorial(n-1) if n else 1
现在，每当我们运行这个函数时，前几个阶乘计算将被保存到缓存中。因此，下一次我们去调用函数时，我们只需要计算我们之前使用的阶乘之后的阶乘。当然，并不是所有的阶乘计算都会被保存，但是很容易理解为什么这是这个装饰器的一个很好的应用，可以加速一些本来就很慢的代码。
№2: @jit
JIT 是实时编译的缩写。通常每当我们在 Python 中运行一些代码时，首先发生的是编译。这种编译会产生一些开销，因为类型会被分配内存并存储为未赋值但已命名的别名。通过即时编译，我们在执行时完成了大部分工作。从很多方面来说，我们可以认为这类似于并行计算，Python 解释器同时处理两件事，以节省时间。
Numba JIT 编译器因在 Python 中提供了这一概念而闻名。与@lru_cache 类似，这个装饰器可以很容易地被调用，从而立即提高代码的性能。Numba 包提供了 jit decorator，这使得运行更密集的软件变得容易得多，而不必使用 c。如果您想阅读关于这个包的更多内容，我还有另外一篇文章，您可以在这里查看:
from numba import jit
import random
@jit(nopython=True)
def monte_carlo_pi(nsamples):
acc = 0
for i in range(nsamples):
x = random.random()
y = random.random()
if (x ** 2 + y ** 2) < 1.0:
acc += 1
return 4.0 * acc / nsamples
№3: @do_twice
do_twice 装饰器完成了它名字中的大部分工作。这个装饰器可以用来在一次调用中运行一个函数两次。这当然有一些用途，我发现它对调试特别有帮助。它可以用来测量两个不同迭代的性能。以 Functools 为例，我们可以让一个函数运行两次，以检查是否有改进。这个函数是由 Python 中的 decorators 模块提供的，它在标准库中。
from decorators import do_twice
@do_twice
def timerfunc():
%timeit factorial(15)
№4: @count_calls
伴随 do_twice 装饰器的简单性的是 count_calls 装饰器。这个装饰器可以用来提供一个函数在软件中被使用了多少次的信息。像 do_twice 一样，这对于调试来说肯定会很方便。当添加到一个给定的函数中时，我们将收到一个输出，告诉我们该函数每次运行时已经运行了多少次。这个装饰器也在标准库中的装饰器模块中。
from decorators import count_calls
@count_calls
def function_example():
print("Hello World!"function_example()
function_example()
function_example()
№5:@数据类
为了节省编写类的时间，我一直在使用的最好的装饰器之一是 dataclass 装饰器。这个装饰器可以用来快速编写我们编写的类中常见的标准方法。如果您想了解更多关于这个装饰者的信息，我也有一篇关于它的文章，您可以在这里阅读:
[## Python 的数据类被低估了
towardsdatascience.com](/pythons-data-classes-are-underrated-cc6047671a30)
这个装饰器来自 dataclass 模块。这个模块也在标准库中，所以不需要 PIP 来试用这个例子！
from dataclasses import dataclass[@dataclass](http://twitter.com/dataclass)
class Food:
name: str
unit_price: float
stock: int = 0
def stock_value(self) -> float:
return(self.stock * self.unit_price)
这段代码将自动创建一个初始化函数 init()，其中包含填充我们的类中的数据所必需的位置参数。它们也会自动提供给 self，所以没有必要仅仅为了将一些数据参数放入一个类而编写一个很长的函数。
№6:@单身
为了理解单例装饰器的目的，我们需要首先理解什么是单例。从某种意义上说，单例是全局类型的一个版本。这意味着这些类型被定义为只存在一次。尽管这些在 C++等语言中很常见，但在 Python 中却很少见。对于单例，我们创建一个只使用一次的类，并改变这个类，而不是一个初始化的构造类型。在这种情况下，类型不太像模板，而更像一个单独的受控对象。
通常情况下，单例装饰器是由用户制作的，实际上并不是导入的。这是因为 singleton 仍然是对我们的 singleton decorator 中提供的模板的引用。为了在我们的类中使用这个装饰器，我们可以命名一个单例函数并编写一个包装器:
def singleton(cls):
instances = {}
def wrapper(*args, **kwargs):
if cls not in instances:
instances[cls] = cls(*args, **kwargs)
return instances[cls]
return wrapper@singleton
class cls:
def func(self):
解决这个问题的另一种方法是使用元类。如果你想了解更多关于元类的知识，我去年写了一篇文章，更详细地介绍了这些元类以及它们的用途，你可以在这里查看:
class Singleton(type):
_instances = {}
def __call__(cls, *args, **kwargs):
if cls not in cls._instances:
cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
return cls._instances[cls]
class Logger(object):
__metaclass__ = Singleton
№7: @use_unit
对于科学计算来说，一个可能经常派上用场的装饰器是 use_unit 装饰器。这个装饰器可以用来改变方法返回的输出。对于那些不想在数据中添加测量单位，但又想让人们知道这些单位是什么的人来说，这很有用。这个装饰器在任何模块中都不可用，但是非常常见，对于科学应用程序非常有用。
def use_unit(unit):
"""Have a function return a Quantity with given unit"""
use_unit.ureg = pint.UnitRegistry()
def decorator_use_unit(func):
@functools.wraps(func)
def wrapper_use_unit(*args, **kwargs):
value = func(*args, **kwargs)
return value * use_unit.ureg(unit)
return wrapper_use_unit
return decorator_use_unit
@use_unit("meters per second")
def average_speed(distance, duration):
return distance / duration
№7:@ wrapps
函数包装器是在 Python 中处理相对复杂的函数时使用的一种设计模式。包装器函数通常用于完成一些更低级的迭代任务。包装函数的好处是它可以用来显著提高性能。和 lru_cache 装饰器一样，这个装饰器是由 FuncTools 包提供的。
import functools as ft
包装装饰器本身只是一个方便的装饰器，用于更新给定函数的包装器。当这个装饰器被调用时，这个函数将在每次使用时更新它的包装器。这对于提高性能大有帮助，FuncTools 中的许多可用工具就是如此。
**def** my_decorator(f):
**@wraps**(f)
**def** wrapper(*args, **kwds):
print('Calling decorated function')
**return** f(*args, **kwds)
**return** wrapper
包装器本身通常是装饰器，包装器装饰器调用通常用在装饰器调用中的包装器函数上。编写完代码后，我们可以用这个包装器来修饰我们的新函数:
@my_decorator
def func(x):
print(x)
№8:@静态方法
在某些情况下，可能会有这样的情况，人们可能希望能够访问在更广泛的意义上被私下定义的东西。有时，我们有一些函数包含在我们希望被系统化的类中，这正是 staticmethod decorator 的用途。
使用这个装饰器，我们可以制作 C++静态方法来处理我们的类。通常，在类的范围内编写的方法对于该类是私有的，除非作为子类调用，否则不可访问。但是，在某些情况下，您可能希望在方法与数据交互的方式上采用更具功能性的方法。使用这个装饰器，我们可以创建两个选项，而不需要创建多个函数。
**class** Example:
**@staticmethod
** **def** our_func(stuff):
print(stuff)
我们也不需要显式地提供我们的类作为参数。staticmethod decorator 为我们处理这个问题。
№9: @singledispatch
FuncTools 用非常有用的 singledispatch 装饰器再次出现在这个列表中。单一分派是一种在许多编程语言中很常见的编程技术，因为它是一种非常好的编程方式。虽然我倾向于选择多个派遣，但我认为单个派遣可以在许多方面用于扮演相同的角色。
这个装饰器使得在 Python 中处理类型更加容易。当我们处理多个类型，并且希望通过同一个方法传递时，情况就更是如此。我在我的 FuncTools 文章中写了更多关于这个的内容，所以如果你对使用单一分派方法感兴趣，我推荐你使用它(链接在#1 中)。)
[@singledispatch](http://twitter.com/singledispatch)
def fun(arg, verbose=False):
if verbose:
print("Let me just say,", end=" ")
print(arg)[@fun](http://twitter.com/fun).register
def _(arg: int, verbose=False):
if verbose:
print("Strength in numbers, eh?", end=" ")
print(arg)
[@fun](http://twitter.com/fun).register
def _(arg: list, verbose=False):
if verbose:
print("Enumerate this:")
for i, elem in enumerate(arg):
print(i, elem)
№10:@注册
寄存器函数来自模块 atexit。给定该模块的名称和手法，您可能会想到这个装饰器可能与在终止时执行某些操作有关。寄存器装饰器命名一个在终止时运行的函数。例如，这将适用于一些需要在退出时保存的软件。
from atexit import register
@register
def termin():
print(" Goodbye!")
结论
不用说，Python 的装饰器非常有用。它们不仅可以用来降低编写一些代码的时间，而且在加速代码方面也非常有帮助。当你发现装饰者时，他们不仅非常有用，而且编写自己的装饰者也是一个好主意。这些装饰器之所以强大，只是因为装饰器作为一个特性在 Python 中非常强大。感谢您阅读我的文章，我希望它能让您注意到 Python 的一些很酷的功能！
您的 Streamlit ML 应用不可或缺的 10 个特性—已实现
简化技巧和窍门
添加 Jupyter lab、会话管理、多页面、文件资源管理器、conda envs、并行处理和部署来简化应用程序
M uch 已经写了关于 Streamlit 杀手级数据应用的文章，看到 Streamlit 是该领域发展最快的平台也就不足为奇了:
图片由星史提供，作者编辑
然而，使用 Streamlit 中的CRISP-DM阶段开发一个对象分割应用程序让我意识到这个平台缺少了许多基本功能。这些功能在 Streamlit 的文章中很少被提及，可能是因为它们在后台做“脏活”,简单地说，没有那么迷人。尽管没有讨论这些功能，但我相信没有这些功能，您的数据应用程序不会成功。在我的例子中，一些功能是由应用程序的用户作为需求提出来的，而其他功能是在 R-shiny 平台上构建的，在那里我参与了另一个 AutoML 应用程序的开发。
Streamlit 缺少许多基本的应用程序功能。没有它们，你的应用程序就不会削减它。
那么我为什么要写这篇文章呢？抛开缺失的功能不谈，Streamlit 是一个很棒的平台(见这里)，可能是几乎没有应用开发经验的人用 Python 开发应用的同类平台之一。因此，我尽我所能在网上搜索那些缺失的功能，谷歌搜索了几十个解决方案，并试图实现它们。此外，当网上没有好的解决方案时，我就自己开发功能。如果我已经花时间收集了这些特征，你不应该这样做。欢迎您坐下来，放松，享受旅程…
我已经花时间收集了这些特征，所以你不应该这样做。欢迎来到坐好，放松，享受旅程……
在深入研究代码之前，让我强调这里的大多数特性都是相互依赖的。不要担心——它们是按照依赖关系的顺序提到的，,所以每个前一个特性都是独立于后一个特性的。此外，值得一提的是，我本质上是一名数据科学家，而不是一名应用程序开发人员。因此，对于应用程序开发领域的概念，我可能不会使用合适的术语。然而，我原谅自己不精确，因为我相信你们大多数人都来自与我相似的背景，这意味着你精通 Python 和建立机器学习模型，但你对开发应用程序几乎一无所知。但是，如果您是一名经验丰富的开发人员，我在此为亵渎您的职业而道歉:)
所以，事不宜迟，这里有 10 个特点:
1.保留刷新和断开连接时的工作
问题:Streamlit 用户在刷新或连接超时时丢失了她的工作。
解决方案:用会话文件自动保存并自动加载用户的会话。
该应用程序“记住”用户的选择，Image by Streamlit v0.84 演示，
任何应用程序中最重要的事情之一是会话管理功能，也就是说，无论用户何时切换页面、刷新网络浏览器，当然还有保存模型并在以后加载，应用程序都必须“记住”用户已经配置的任何设置。如果你知道一个 ML 模型类是什么样子的，一个保存的会话只是在一个更广泛的上下文中是基本相同的概念。会话不仅会保存超参数和训练模型权重，还会保存整个数据集(或其文件路径)、预测、训练日志的文件路径、绘图、用户编写的脚本以及用户在会话中完成的任何其他工作。这意味着，如果不保持会话的持久性，每当用户刷新浏览器或只是暂时失去与应用程序的连接时，她就会丢失所有的工作。
如果不保持会话的持久性，每当用户刷新浏览器或者只是暂时失去与应用程序的连接时，她就会丢失所有的工作。
即使这个特性在 Streamlit 论坛中从平台早期就不断被要求，会话管理在两年后才被引入平台。尽管如此，官方的 Streamlit 解决方案有一个很大的缺点:它只能保存用户在页面之间切换时的工作，而如果会话意外结束，它 不能保存用户的工作 。我的解决方案有，它使用了用户okld的会话管理解决方案来代替。
首先是，app 的脚本应该有这几行:
其次，此功能仅在 Streamlit 以调试模式启动并将调试消息写入日志文件时有效:
*streamlit run app.py **--logger.level=debug** log_file.log 2>&1*
日志文件应存储在文件夹**configs[' APP _ BASE _ DIR ']+'/logs/streamlit _ logs/中，因为它在was _ session _ shut down()函数中使用。**
第三个，这是您自动保存会话的方式:
****autosave_session(state)****
什么时候应该自动保存和自动加载？每当用户更改配置，甚至只是更改应用程序中的页面时，我都会调用 autosave 函数，这样当会话重新加载时，用户可以立即继续工作，而不必浏览回他正在处理的页面。加载部分应该是应用程序脚本中首先调用的命令之一，因为应用程序刷新会从头重新运行整个脚本，我们希望用户的停机时间最短。
什么时候会话不会自动加载？当用户注销时(参见下面的多页部分)，或者当 Streamlit 应用程序重启时。
官方的 Streamlit 会话解决方案是否可以添加自动保存功能？很有可能，如果你成功了，一定要告诉我！
2.保存工作以备后用
问题 : Streamlit 没有保存用户工作以备后用的选项。
解决方案:保存、加载&删除按钮
按作者保存模型、图像
加载/删除选定的模型、作者的图像
让用户保存和加载他的工作的逻辑与上面的部分完全相同，只是这次保存和加载是在用户按下动作按钮时触发的。不言而喻，您还必须提供一个表格，显示所有保存的模型，以及某种关于模型是否被成功保存/加载/删除的指示。
3.文件浏览器
问题:Streamlit 用户不能创建、删除或浏览文件夹
解决方案:文件夹操作的递归函数
创建文件夹，按作者分类的图像
浏览子文件夹，作者图像
删除文件夹，按作者分类的图像
对于任何 CRISP-DM 应用程序来说，文件浏览器都是绝对必要的，因为它用于保存文件，并在几乎所有工作阶段将它们组织到目录中。例如，您可能决定为每个用户的定型模型创建一个文件夹，为每个特定项目的数据集创建一个文件夹。尽管这是一个非常基本的要求，但如果你谷歌一下这个问题，你可能会发现一些不那么实用的简化用户的解决方案。
该解决方案使用户能够创建、删除和浏览文件夹，并查看文件夹的树形结构。最重要的是，即使你的 Streamlit 应用程序运行在用户不能直接访问文件系统的远程服务器上，它也能工作。
4.登录屏幕
问题:细流没有内置的用户认证屏幕
解决方案:验证用户和密码的 main()前的 If 语句
登录屏幕，按作者分类的图像
任何专业 app 都需要一个“保镖”把守入口。Streamlit 没有，尽管很久以前的 Streamlit 用户也要求这么做。
请记住，我的实现使用硬编码的用户和密码，但是添加 LDAP 或 MongoDB 身份验证应该很容易。
5.多页应用程序
问题 : Streamlit 没有内置的多页面功能
解决方案:在侧边栏中添加单选菜单，链接到每个页面的功能
多页应用程序，作者图片
使用 CRISP-DM 需要在不同的阶段之间来回切换。这个工作过程在应用程序中以菜单的有序选项的形式得到了最好的体现，每个选项都链接到一个不同的功能。当您对这些阶段进行编码时，每个阶段的独立功能的概念也非常有意义。
6.运行长时间并行计算
问题 : Streamlit 不能同时运行两个操作并在中途停止
解决方案:运行子流程，在侧边栏中创建流程控制表
进程表，按作者排序的图像
无论您是在功能工程中强行使用自己的方式，还是训练繁重的深度学习模型，您都需要一种并行运行的方式，在某些情况下，过早地杀死它们。添加此功能的一种方法是将每个计算作为一个子进程运行，同时拥有一个进程表，该表既可以动态更新，又有动作按钮来分别终止每个进程或一次关闭所有进程。运行独立的子进程不仅可以让您使用并行计算，还可以确保即使 Streamlit 会话突然终止，子进程仍将在服务器上继续运行而不会中断。因此，无论 Streamlit 会话发生什么情况，用户都可以再次登录并查看结果。该解决方案的另一种方法是将这些子流程发送到云服务上，而不是在您自己的机器上工作——如果您需要额外的计算能力，这可能对您有价值。
使用 Popen 运行子流程相当容易:
****try:
subprocess.Popen(command)
except:
st.write(f"Couldn't run: {command}")
e = sys.exc_info()
st.error(e)
updated_processes_table(process_table_sidebar, state)
# see updated_processes_table() implementation on the gist below****
如果您正在运行的命令要求用户输入，这就有点棘手了，但是也可以用管道来管理:**
****process = subprocess.Popen(command, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
universal_newlines=True)
try:
process.communicate("\n".join(user_arguments), timeout=0.2)
except:
pass
updated_processes_table(process_table_sidebar, state)****
下面是实现流程控制表的方法:
7.使用不同环境的模型
问题 : Streamlit 没有在不同环境下使用模型的选项
解决方案:运行子流程时激活 Conda 环境
用于切换 python 环境的 UI，图片由作者提供
当处理复杂的 CV 和 NLP 模型时，你经常需要为每个模型安装不同的编码环境，因为很多时候它们依赖于特定的 Tensorflow 或 Pytorch 版本，这些版本与其他安装不兼容。在这种情况下，您将希望从自己的环境中调用每个模型命令，并且您还应该将所有的环境输出捕获到一个日志中(下面要点中的变量 output_to_log )。当然， Conda 只是一个多 env 解决方案，你也可以考虑 Pyenv 或者甚至使用 Docker 图像来代替。
现在我们知道了如何运行子流程(参见上面的部分)，在不同的 conda 环境中运行它们是非常简单的:
8.动态标绘训练结果
问题:训练时 Streamlit 无法显示训练输出
解决方案:尾部建模日志，间隔绘图
训练模型的动态日志输出，由作者制作图像
********
训练模型指标的动态图，图片由作者提供
你是合身、合身还是刚好合身？当处理深度学习模型时(如在上面的部分)，如果不在训练期间绘制模型的度量标准，就很难知道这一点。查看正在运行的命令的文本输出，并选择将其下载到一个文件中，这可能也很有用。最后，设置刷新度量图的间隔可能很方便，因为它们通常在一个训练时期结束时更新，并且时期的持续时间因不同的模型和数据集而异。
9.在新标签上嵌入 Jupyter & Serving 许可证
问题:细流没有自由编码并且无法重定向到新标签页上的文件****
解决方案:将 Jupyter 嵌入为 HTML iframe 并在文件中添加一个 Jupyter 链接
Jupyter 笔记本中的免费编码，图片由作者提供
Jupyter 实验室的免费编码和文件探索，图片由作者提供
在应用程序的页面上嵌入 Jupyter 笔记本/实验室实例是我面临的最大挑战之一。有多种理论方法和工具可以做到这一点，但从我的经验来看，“星星需要对齐”配置才能工作。最后，我成功地嵌入了 Jupyter 来简化它，只使用了一个相当混杂的安全配置。如果这是你所关心的，从我的配置开始，试着增加一些限制，同时保持一切正常。
Jupyter 很难实现，但值得努力。这是一个非常强大的工具，因为它让知识渊博的 用户用已经训练好的模型基本上做任何他想做的事情，甚至添加一些尚未实现的阶段，如后处理、可解释性等。但是出于完全相同的原因，它也是一个危险的工具，给用户一个对服务器的终端访问，也就是说，一个命令就能摧毁它的能力——所以要小心使用！
Jupyter 构型
首先，您应该创建一个 jupyter 配置文件，包含:
****jupyter notebook --generate-config****
接下来，编辑文件，使其具有以下配置:
****c.NotebookApp.allow_origin = '*'
c.NotebookApp.disable_check_xsrf = True
c.NotebookApp.ip = '*'
c.NotebookApp.notebook_dir = <directory of datasets and outputs>
c.NotebookApp.open_browser = False
c.NotebookApp.port = 8502
c.NotebookApp.token = ''
c.NotebookApp.tornado_settings = {'headers': {
'Content-Security-Policy': "frame-ancestors http://<Server-IP>:8501/ "
}
}
c.NotebookApp.use_redirect_file = True****
最重要的配置是c . notebook app . tornado _ settings，它告诉 Jupyter 在呈现 Jupyter 的 iframe 时信任你的 Streamlit 应用。另请注意，您应该将 c.NotebookApp.port 设置为一个尚未被 Streamlit 端口占用的数字。默认的 Streamlit 端口号为 8501，任何新的 Streamlit 会话都将使用下一个空闲端口打开，即 8502、8503 等等。**
简化代码
启动 Jupyter 很简单，你所要做的就是在应用程序的开头添加以下几行:
****# in **if __name__ == "__main__":**
command = rf"""jupyter lab --allow-root"""
try:
subprocess.Popen(command, stdout=subprocess.PIPE, shell=True)
except:
st.error(f"Couldn't run {script_type}:")
e = sys.exc_info()
st.error(e)****
但是将 Jupyter 嵌入 Streamlit 是一个不同的、更长的故事:
使用 Jupyter 在新选项卡上提供许可文件
许可证链接指向一个新选项卡中的许可证文件，即按作者分类的图像
如果你希望你的应用程序的用户在打开许可文件时被重定向到一个新的单独的标签，换句话说，你需要一些网络应用程序来服务你的许可文件。幸运的是，Jupyter 完全可以做到这一点，因为它是建立在一个 Torando web 服务器之上的。
****with col9:
linespace_generator(2)
while not is_jupyter_up():
time.sleep(0)
link = f"[license](http://{state.jupyter_ip}:{state.jupyter_port}/files/Licence.html)"
st.markdown(link, unsafe_allow_html=True)****
10.部署经过训练的模型
问题 : Streamlit 没有交付训练模型的选项
解决方案:创建一个 REST API flask web 服务
使用经过训练的 FastFCN 模型预测烧瓶供应数据，图片由作者提供
建立一个模型很容易，但是服务于这个模型，以便人们可以在日常生活中直接使用它——这是一个完全不同的挑战。我在这里介绍的解决方案与 Streamlit 无关，但它是任何 CRISP-DM 应用程序的重要组成部分，因此我选择将其包含在本文中。我的解决方案是使用 Flask，这是一个相当简单的平台，可能足以满足您的 POC 需求。尽管如此，当事情变得严重，你需要管理多个会话、安全性等等时，你可能想要切换到 Django 或 Node.js 。
我的图像分割 API 有几个独立的路径:
/models:查询训练好的模型
/configs:设置预测参数
/base64:将图像文件格式转换为 base64 字符串
/predict:向模型提供数据并获取预测
下面是完整的 API 实现，以及如何使用它的说明(就在要点之后):
查询训练模型
- 查询哪些算法可用于预测:
****import requests
IP = "<IP address>"
res = requests.get(f"http://{IP}:8503/models"); res.json()****
- 查询特定模型可用的训练权重:
****params = {"algorithm":"FastFCN", "Model_path":"coco", "return_weights":"True"}
res = requests.post(f"http://{IP}:8503/models", data=params); res.json()****
- 查询特定模型在哪些类上接受训练:
****params = {"algorithm":"FastFCN", "Model_path":"coco", "return_classes":"True"}
res = requests.post(f"http://{IP}:8503/models", data=params); res.json()****
设置预测配置
首先，创建一个包含预测配置的 json 文件。这些配置将用于所有后续预测，直到新的配置文件被发送到 API。
configs.json 文件示例:
****{'algorithm': 'FastFCN',
'Model_path': 'coco',
'weight': 'FastFCN_coco1',
'IMAGE_MIN_DIM': '1024',
'IMAGE_MAX_DIM': '2048',
'DETECTION_MIN_CONFIDENCE': '0.7',
'mode': '2',
'class_show': 'None'}****
其次，发送文件并评估当前配置:
****IP = "<IP>"
files = {'file': open('configs.json', 'rb')}; json.load(files['file'])
files = {'file': open('configs.json', 'rb')}
res = requests.post(f"http://{IP}:8503/configs", files=files)
res = requests.get(f"http://{IP}:8503/configs"); res.json()****
将图像转换为 base64
可选:将图像的 zip 文件预处理为 base64 字符串列表，以便以后输入模型进行预测:
****files = {'file': open('image_to_predict.zip', 'rb')};
res = requests.post(f"http://{IP}:8503/base64", files=files); list_of_base64=res.json()
params['images'] = list_of_base64****
做预测
首先，定义一个名为 params 的字典，带有一个 images 键，其值是一个 base64 字符串列表，代表预测的图像:
params = {'images':[<image0_base64>,<image1_base64>,<image2_base64>]}
将此配置设置为 True 以获取图像文件形式的结果，而不是 base64 字符串:
params['create_images'] = True
二、提出预测请求，并评估结果:
****IP = "<IP>"
res = requests.post(f"http://{IP}:8503/predict", data=params)
res = res.json()['Responses']
predicted_image0 = res[0][1]
json_result0 = res[0][0]
print(f"Classes found: {json_result0['results']['class_name']}")
print(f"Prediction scores: {json_result0['results']['scores']}")
print(f"Bounding Boxes: {json_result0['results']['rois [y_min, x_min, y_max, x_max]']}")****
摘要
使用 Streamlit 开发一个 ML 应用程序就像乘坐游乐园里最疯狂的过山车:超级快，非常刺激，有时令人眩晕，但肯定非常有趣。然而，在 Streamlit 中快速实现您出色的机器学习想法后，几乎不可避免的是，您的应用程序将不会真正可用。这是由于 Streamlit 缺乏一些基本功能造成的:保存刷新和丢失连接的工作、保存工作以备后用、文件浏览器、登录屏幕、多页应用、运行长时间并行计算、使用不同环境的模型、动态绘制训练结果、嵌入 Jupyter 并在
你可以尝试自己实现这些功能，甚至在谷歌上“掷骰子”，但为什么要浪费时间呢？所有这些功能的代码都在上面——所以请坐好，放松，享受旅程吧:)
欢迎分享您的反馈，并通过 LinkedIn 联系我。
感谢您的阅读，祝您好运！🍀
学习自然语言处理的 10 个免费资源
使用这些神奇的资源免费学习 NLP
莱昂纳多·大久保俊郎在 Unsplash 上的照片
自然语言处理(NLP)结合了语言学、计算机科学和人工智能领域，使机器能够从文本数据中提取意义、见解并做出预测。
大多数现代组织以电子邮件、聊天、电话和许多其他互动的形式从其客户和业务运营中收集大量文本数据。这些数据对于更深入地了解客户所面临的问题是非常宝贵的，从这些数据中获得的见解有助于解决其中一些问题，以及自动化和优化面向客户的业务流程。
因此，对于数据科学家来说，理解自然语言处理领域是至关重要的。由于它是一个高度专业化的领域，并且需要一套不同于其他形式的人工智能的技术，因此它并不总是被广义数据科学课程所涵盖。
在这篇文章中，我想分享我最喜欢的学习自然语言处理的免费在线资源。
1.自然语言处理导论
https://courses.analyticsvidhya.com/courses/Intro-to-NLP
Shivam Bansal 的这个短期课程是对这个领域的一个很好的介绍。它基于 python，在一系列视频讲座和练习中涵盖了正则表达式、文本处理和文本分类。在课程的最后，有一个建立你的第一个简单的基于文本的机器学习模型的指南。完成课程后，您还可以选择参加一个简短的考试，以获得结业证书。
2。伦敦大学的学习指南
这份来自伦敦大学的 100 页的学习指南很好地介绍了用机器处理原始数据并从这些文本数据中提取见解和分析的理论。它涵盖以下核心领域:
- 访问文本语料库和词汇资源。
- 处理原始文本。
- 分类和标记。
- 从文本中提取信息。
- 分析句子结构。
3.真棒 NLP
https://github.com/keon/awesome-nlp
Awesome NLP 是一个 Github 知识库，包含了自然语言处理领域的大量精选资源。这里有各种不同的资源，包括教程、图书馆、数据集、研究论文和书籍。
4.斯坦福大学深度学习自然语言处理讲座
这个 Youtube 播放列表包含了 2019 年冬季斯坦福大学关于深度学习的自然语言处理课程的整个系列讲座。这是使用神经网络模型完成 NLP 任务的一个很好的介绍。
课程的所有幻灯片、视频、课堂讲稿和作业也可以在这个 github repo 中找到。
5.使用 pytorch 的 NLP
https://github.com/joosthub/PyTorchNLPBook
Pytorch 是一个深度学习框架，非常适合开发基于 NLP 的模型。这个知识库是 Delip Rao 和 Brian McMahan 所著的《使用 PyTorch 进行自然语言处理:使用深度学习构建智能语言应用程序》一书的姊妹篇，包含示例笔记本、数据集和笔记。
它涵盖了 Pytorch，神经网络，词嵌入和自然语言处理序列建模的介绍。是理解自然语言处理深度学习的绝佳资源。
6.语音和语言处理
https://web.stanford.edu/~jurafsky/slp3/
这个资源是丹·茹拉夫斯基和詹姆斯·h·马丁的《T4 演讲和语言处理》一书的免费阅读版。这是对一般自然语言处理的很好介绍，涵盖了从文本数据的基本处理到深度学习架构和机器翻译的所有内容。
7.用自然语言工具包分析文本
NLTK 是被称为自然语言工具包的 Python 库。这是处理文本数据的领先平台之一，包括用于文本分类、标记化、词干化和语义推理的简单接口。这本书不仅是一个非常详细的使用 NLTK 的指南，也是一个学习 NLP 的好资源，有很多实用的例子。
8.Kaggle 课程—自然语言处理
如果你完全是 NLP 领域的新手，只是想访问一些简单而简短的教程，Kaggle 的这个非常短的课程是一个很好的快速入门教程。虽然简短，但它确实涵盖了基本原理，包括文本处理、文本分类和单词嵌入。
9.Microsoft NLP 食谱
https://github.com/microsoft/nlp-recipes
这个由微软开发和维护的知识库旨在记录和标准化开发利用自然语言处理的系统的最佳实践。
它由一套 Jupyter 笔记本形式的示例和有用的实用函数组成，供任何执行自然语言处理的人使用。对于初学者和该领域中更有经验的从业者来说，这是理解最佳实践的非常有用的参考指南。
10.火花 NLP
https://github.com/JohnSnowLabs/spark-nlp
Spark NLP 严格来说并不是一个学习资源，但是因为它是一个基于 Apache Spark 构建的自然语言处理库，所以它是 Spark 开发人员大规模利用自然语言处理能力的一个很好的工具。
自然语言处理是所有数据科学家学习的重要领域。拥有从文本等非结构化数据源中获取见解并做出预测的能力，可以极大地提高组织内数据科学应用的可能性。
在这篇文章中，我简要介绍了十个我最喜欢的网上资源，以便了解这个领域。这些内容涵盖了从文本处理到 NLP 的深度学习，再到应用这些技术的最佳实践。本文中的参考资料将为您提供开始使用自然语言处理构建应用程序所需的一切。
感谢阅读！
我每月都会发一份简讯，如果你想加入，请点击此链接注册。期待成为您学习旅程的一部分
在 Python 中使用非常规 For 循环的 5 个好方法
避免基本循环和创建更快算法的简单技术
(图片由mikkekylitt在 Unsplash )
介绍
for 循环；这通常是我们介绍计算艺术的一个关键部分。for 循环是一个多用途的工具，通常用于操作和处理数据结构。对于许多操作，您可以使用 For 循环来获得相当好的性能，同时仍然完成一些重要的操作。然而，在现代 Python 中，有一些方法可以用来练习典型的 for 循环。这比 Python 中传统的 for 循环要快。也就是说，这些选项是可用的，这当然是一件好事，在某些情况下，它们可以用来加速 Python 代码！此外，如果您想查看本文的源代码，可以在这里查看:
https://github.com/emmettgb/Emmetts-DS-NoteBooks
有关 for 循环的更多信息…
在我们深入研究一些不使用 for 循环的好方法之前，让我们先来看看如何在 Python 中解决一些使用 for 循环的问题。这将使我们注意到循环在典型的编程场景中是如何使用的。此外，我们可以看看 for 循环可能导致的性能问题。让我们来看看最传统的 Pythonic for 循环，我们很多人在学习这门语言时可能都学过:
data = [5, 10, 15, 20, 25, 30, 35, 40, 45, 50]for i in data:
print(i)
这种方法有几个问题。虽然对于像这样的例子，对于这种少量的数据，这肯定会工作得很好——并且在大多数情况下可能是这样，有一些更好的——更 Pythonic 化的方法我们可以用来加速代码。这种传统意义上的 For 循环几乎可以完全避免。在某些情况下，这种语法可以压缩成一个方法调用。for 循环的问题是，它们可能会大大增加处理时间。这绝不是说“完全抛弃 for 循环”，就像有些人从他们的编程工具箱中那样。相反，我会说，拥抱目标——这是一个人在任何技术栈组件上应该有的立场。
for 循环有一个特殊的目的，但是这个列表中的一些选项也是如此。让程序员变得伟大的一点是能够选择适合他们当前团队的堆栈。这归结为选择正确的模块、函数和类似的东西。世界上没有人有足够的时间来学习每个模块和每个电话，所以权衡一下可以学习的模块，并阅读概述新选项的文章，肯定是确保一个人的技能足够多样化的好方法。
for 循环可能有问题的原因通常与处理大量数据或对所述数据执行许多步骤有关。这个列表中的一些工具在这方面或那方面特别出色，这就是这些技术的优势所在。
№1:1 行 for 循环。
单行 for 循环是我们都应该利用的语法黑客的经典例子。单行 for 循环有几个特征使它不同于常规的 for 循环。其中最明显的是它包含在一行中。
[print(i) for i in data]
关于这种循环的另一个重要的事情是，它也将提供一个回报。对于打印示例，由于每个示例都是标准输出，所以我们实际上返回的是一个空数组。这个特性值得注意，因为它使得这种循环的应用非常明显。此循环最适合对一组值执行小型运算。让我们编写一个快速函数，将一些统计数据应用到我们的值中。这里有两个支持函数，其中一个实际上使用了一行 for 循环，这是我为了演示而创建的:
import math
"""
mean(x : list)
Returns the mean of a list.
"""
def mean(x : list):
return(sum(x) / len(x))"""
std(x : list)
Returns the standard deviation (std) of a list.
"""
def std(x : list):
m = mean(x)
x = [(i - m) ** 2 for i in x]
m = mean(x)
m = math.sqrt(m)
return(m)
第一个函数是简单的均值函数，然后在下面的标准差函数中使用。这使用一行 for 循环对数据求平方，收集其平均值，然后收集该平均值的平方根。现在，对于我们的最后一个组件，我们将编写一个正态分布函数，它将对这些数据进行标准缩放。我们将在单行 for 循环中缩放每个值。
def normal(x : list):
mu = mean(x)
sigma = std(x)
我们的单行 for 循环需要这些值。语法的工作原理是在空的 iterable 中创建一个迭代器，然后将数组复制到新的数组中。另一种方法是追加或推送。让我们来看看一行代码:
return([(i - mu) / sigma for i in x])
让我们使用%timeit 来检查这样做需要多长时间。在本文的最后，我将比较这个应用程序中的所有时间，以衡量哪个选项可能是最好的。
import numpy.random as rd
x = rd.randn(10000)
%timeit normal(data)3.37 µs ± 136 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
2 号:λ
我们要研究的下一项技术是 Lambda。Lambda 是一种简单的技术，我们可以在 Python 内部使用它来创建表达式。然后可以使用 apply()方法在 iterable 上计算这些表达式。当然，使用 lambda 还有很多其他方式。对于今天的例子，我们将把 lambda 应用到我们的数组中，以便正常分布我们的数据。实际上，我不久前写了一篇文章，谈论 Lambda 的伟大之处。如果你想更深入地了解这项技术，你可以在这里做:
Lambda 非常容易使用，只需要几秒钟就可以学会。然而，当一个人刚刚开始时，很容易明白为什么各种各样的 lambda 知识会变得令人困惑。让我们看看如何将 lambda 应用到我们的函数中。我们将面临的问题是，最终 lambda 在这种实现中并不能很好地工作。然而，尽管如此，λ更多的是一个组成部分；幸运的是，在有些应用程序中，我们可以将这个列表中的另一个组件与 lambda 结合起来，以形成一个使用 lambda 来应用不同操作的工作循环。在我们函数的例子中，例如:
def normallambda(x : list):
mu = mean(x)
sigma = std(x)
首先我们定义一个 lambda 表达式:
ex = lambda x: x - mu / sigma
然后，我们使用一行 for 循环将表达式应用于我们的数据:
return([ex(y) for y in x])
№3:应用
鉴于我们中许多从事 Python 工作的人都是数据科学家，很可能我们中的许多人都与熊猫打交道。如果情况确实如此，我希望向您介绍来自 Pandas 的 apply()方法。这个函数包含在 Pandas DataFrames 中，允许使用 Lambda 表达式来完成各种令人惊叹的事情。当然，为了实际使用它，我们首先需要使用熊猫图书馆。让我们快速地将数据放入一个数据框架中:
import pandas as pd
df = pd.DataFrame({"X" : x})
现在我们将编写我们的新函数，请注意，类型更改为 pd。数据帧，调用略有改变:
def normaldfapply(x : pd.DataFrame):
mu = mean(x["X"])
sigma = std(x["X"])
现在让我们使用我们的 lambda 调用。从循环到 apply 方法没有任何变化:
ex = lambda x: x - mu / sigma
使用 apply()方法时，可以从 Series 和 DataFrame 类型调用该方法。因此，在这种情况下，由于我们使用的是一维序列，不需要将其应用于此数据帧的整个范围，因此我们将使用该序列。我们可以通过用[]索引数据帧来调用该系列。
x["X"].apply(ex)
对于最终的函数，如下所示:
def normaldfapply(x : pd.DataFrame):
mu = mean(x["X"])
sigma = std(x["X"])
ex = lambda x: x - mu / sigma
x["X"].apply(ex)
№4: Itertools
从一个更基本的实现角度来看，解决这个问题的一个好方法是使用 itertools。itertools 模块包含在 Python 标准库中，是一个非常棒的工具，我建议一直使用它。它是在 Python 中实现流行的、快速的数据处理算法，这些算法可以用更少的 Python 来完成工作。我有一整篇文章详细介绍了 itertools 的神奇之处，如果您愿意，可以点击这里查看:
问题是，这个库提供了很多东西——所以我很高兴有人能在这里更深入地研究那篇文章——因为现在我只打算写这个函数，到此为止。我肯定地认为，在大多数情况下，对这个模块进行更多的阅读是有保证的，尽管它确实是你的武器库中一个令人敬畏的多功能工具。
import itertools as its
我们在这个例子中使用的主要函数是 itertools.cycle，这个方法为这个数组创建一个新的迭代器。我们还可以在其中添加算法，这使得它非常适合这个实现。
def itsnorm(x : list):
count = 1
newx = []
mu = mean(x["X"])
sigma = std(x["X"])
z = its.cycle(x * std * m)
return(z)
№5:当
最后，也可能是意想不到的，避免在代码中使用传统 for 循环的方法是使用 while。当然，也会有这是一个糟糕的选择的情况。同样，也有这是最佳选择的例子。通常，当涉及到 iterables 时，很少使用循环。
然而，让我们想一想为什么 while 循环不用于这样的事情。首先，必须打破 while 循环。对于 iterable 循环来说也是如此，但仅仅是因为 iterable 已经完成了迭代(或者在条件之外有一些 break 设置之类的)。)也就是说，在某些实现中，while 循环确实在做一些非常迭代的事情。
def normalwhile(x : list):
count = 1
newx = []
mu = mean(x["X"])
sigma = std(x["X"])
while count <= len(x):
newx.append((x[count] - mu) / sigma)
count += 1
真正拖累 while 循环的是使它运行得更像 for 循环的所有计算。当然，在某些情况下这可能会派上用场，但是在这个例子中，我并不认为这比传统的 for 循环写得更好。有很多初始化工作，就像我们需要一个常规的 for 循环一样。
结论
当然，人们可以有更多的方法来解决这类问题。在所有应用中，没有一种解决方案比另一种更好，我认为这些不同的工具各有所长。程序员使用循环和与循环交互的方式绝对是影响代码最终结果的重要因素。让我们看看所有这些技术，以及它们在我们的分配问题中的应用，然后看看在这个特定的场景中哪种技术做得最好。这是用标准、直接的 for-loop 风格编写函数的方式:
def normalfor(x : list):
mu = mean(x)
sigma = std(x)
newx = []
for i in x:
newx.append((i - mu) / std)
return(newx)
经过快速比较，在这个实例中胜出的是 Pandas 的 df.apply()方法。这对 Python 来说意味着什么？在许多情况下，尽管使用正则 Pythonic 表达式似乎更合理，但有时你就是无法打败基于 C 的库。Pandas 可以超越我们编写的任何 Python 代码，这既展示了 Pandas 有多棒，也展示了使用 Python 中的 C 语言有多棒。然而，紧随其后的是内联 for 循环。在该选项可能需要替换的情况下，肯定会推荐使用该技术。另一点需要注意的是，没有包括实际创建所使用的类型的时间，这对于 Apply()方法来说可能是一个小小的缺点，因为您的数据必须在 DataFrame 中。非常感谢你看我的文章！我希望这是有见地的，理想的启发你的 Python 代码！编程快乐！
10 个极有可能成为数据科学家的面试问题
机器学习、Python 和 SQL
数据科学的普及吸引了来自各行各业的许多人转行，目标是成为一名数据科学家。
尽管对数据科学家的需求很高，但找到第一份工作是一项极具挑战性的任务。除非你之前有丰富的工作经验，否则面试是你展示技能和给潜在雇主留下深刻印象的地方。
数据科学是一个跨学科领域，涵盖了广泛的主题和概念。因此，在面试中你可能会被问到的问题数量是非常多的。
然而，在数据科学和机器学习的基础上有一些问题。这些是你不想错过的。在本文中，我们将讨论数据科学家面试中可能会被问到的 10 个问题。
这些问题分为 3 个主要类别，即机器学习、Python 和 SQL。我将尝试为每个问题提供一个简短的答案。然而，我建议在之后更详细地阅读或研究每一个。
机器学习
1.什么是过度拟合？
当你的模型没有被很好地概括时，机器学习中的过度拟合就会发生。该模型过于关注训练集。它捕获了训练集中的许多细节甚至噪声。因此，它无法捕捉数据中的总体趋势或关系。如果一个模型与数据相比过于复杂，它可能会过度拟合。
过度拟合的一个重要指标是训练集和测试集的准确性之间的巨大差异。过度拟合模型通常在训练集上具有非常高的精度，但是测试精度通常是不可预测的，并且远低于训练精度。
2.怎样可以减少过度拟合？
我们可以通过使模型更一般化来减少过度拟合，这意味着它应该更专注于总体趋势而不是具体细节。
如果可能的话，收集更多的数据是减少过拟合的有效方法。你将给予模型更多的能量，这样它将有更多的材料可以学习。数据总是有价值的，尤其是对于机器学习模型。
减少过拟合的另一种方法是降低模型的复杂性。如果一个模型对于一个给定的任务来说太复杂，它将可能导致过度拟合。在这种情况下，我们应该寻找更简单的模型。
3.什么是正规化？
我们已经提到过过度拟合的主要原因是模型过于复杂。正则化是一种降低模型复杂度的方法。
它通过惩罚模型中的较高条款来做到这一点。通过增加正则项，该模型试图最小化损失和复杂性。
两种主要的正则化类型是 L1 正则化和 L2 正则化。L1 正则化在每次迭代中从无信息特征的权重中减去少量。因此，它导致这些权重最终变为零。
另一方面，L2 正则化在每次迭代中从权重中移除一小部分。这些权重将越来越接近零，但实际上永远不会变成 0。
4.分类和聚类有什么区别？
两者都是机器学习任务。分类是一项受监督的学习任务，因此我们已经标记了观察值(即数据点)。我们用带标签的数据训练模型，并期望它预测新数据的标签。
例如，垃圾邮件检测是一项分类任务。我们提供了一个模型，其中有几封电子邮件被标记为垃圾邮件或非垃圾邮件。在用那些电子邮件训练模型之后，它将适当地评估新的电子邮件。
聚类是一项无监督的学习任务，因此观察值没有任何标签。该模型预计将评估观察结果，并将它们分组到聚类中。相似的观察值被放入同一个群中。
在最佳情况下，同一聚类中的观测值尽可能相互靠近，而不同的聚类尽可能相互远离。聚类任务的一个示例是根据客户的购物行为对他们进行分组。
计算机编程语言
内置数据结构至关重要。因此，你应该熟悉他们是什么，以及如何与他们互动。列表、字典、集合和元组是 Python 中 4 种主要的内置数据结构。
5.列表和元组的区别是什么
列表和元组的主要区别是可变性。列表是可变的，所以我们可以通过添加或删除条目来操作它们。
mylist = [1,2,3]
mylist.append(4)
mylist.remove(1)print(mylist)
[2,3,4]
另一方面，元组是不可变的。虽然我们可以访问元组中的每个元素，但是我们不能修改它的内容。
mytuple = (1,2,3)
mytuple.append(4)
**AttributeError**: 'tuple' object has no attribute 'append'
这里要提到的重要一点是，尽管元组是不可变的，但是它们可以包含可变的元素，比如列表或集合。
mytuple = (1,2,["a","b","c"])mytuple[2]
['a', 'b', 'c']mytuple[2][0] = ["A"]
print(mytuple)
(1, 2, [['A'], 'b', 'c'])
6.列表和集合的区别是什么
让我们做一个例子来演示列表和集合之间的主要区别。
text = "Python is awesome!"
mylist = list(text)
myset = set(text)print(mylist)
['P', 'y', 't', 'h', 'o', 'n', ' ', 'i', 's', ' ', 'a', 'w', 'e', 's', 'o', 'm', 'e', '!']print(myset)
{'t', ' ', 'i', 'e', 'm', 'P', '!', 'y', 'o', 'h', 'n', 'a', 's', 'w'}
正如我们在结果对象中注意到的，列表包含字符串中的所有字符，而集合只包含唯一的值。
另一个区别是，列表中的字符是根据它们在字符串中的位置进行排序的。但是，没有与集合中的字符相关联的顺序。
下表总结了列表、元组和集合的主要特征。
(图片由作者提供)
7.什么是词典，词典的重要特征是什么？
Python 中的字典是键值对的集合。它类似于列表，因为列表中的每一项都有一个从 0 开始的相关索引。
mylist = ["a", "b", "c"]
mylist[1]
"b"
在字典中，我们用关键字作为索引。因此，我们可以通过使用它的键来访问一个值。
mydict = {"John": 24, "Jane": 26, "Ashley": 22}mydict["Jane"]
26
字典中的键是唯一的，这很有意义，因为它们就像是值的地址。
结构化查询语言
SQL 对于数据科学家来说是一项极其重要的技能。有相当多的公司将他们的数据存储在关系数据库中。SQL 是与关系数据库交互所需要的。
您可能会被问到一个问题，这个问题涉及编写一个查询来执行一个特定的任务。您可能还会被问到一个关于一般数据库知识的问题。
8.查询示例 1
假设我们有一个包含产品日销售量的销售表。
SELECT TOP 10 * FROM SalesTable
(图片由作者提供)
根据每周总销售量找出前 5 周。
SELECT TOP 5
CONCAT(YEAR(SalesDate), DATEPART(WEEK, SalesDate)) AS YearWeek,
SUM(SalesQty) AS TotalWeeklySales
FROM
SalesTable
GROUP BY CONCAT(YEAR(SalesDate), DATEPART(WEEK, SalesDate))
ORDER BY TotalWeeklySales DESC
(图片由作者提供)
我们首先从日期列中提取年和周的信息，然后在聚合中使用它。sum 函数用于计算总销售量。
9.查询示例 2
在同一个销售表中，查找每个月销售的独特商品的数量。
SELECT
MONTH(SalesDate) AS Month,
COUNT(DISTINCT(ItemNumber)) AS ItemCount
FROM
SalesTable
GROUP BY MONTH(SalesDate) Month ItemCount
1 9 1021
2 8 1021
10.什么是数据库中的规范化和反规范化？
这些术语与数据库模式设计相关。规范化和反规范化旨在优化不同的指标。
规范化的目标是通过增加表的数量来减少数据冗余和不一致。另一方面，反规范化旨在加速查询执行。反规范化减少了表的数量，但同时也增加了一些冗余。
结论
成为一名数据科学家是一项具有挑战性的任务。这需要时间、努力和奉献。如果没有工作经验，这个过程会变得更加困难。
面试对展示你的技能非常重要。在本文中，我们讨论了您在数据科学家面试中可能会遇到的 10 个问题。
最后但同样重要的是，如果你还不是中级会员并打算成为其中一员，我恳请你使用以下链接。我将从你的会员费中收取一部分，不增加你的额外费用。
https://sonery.medium.com/membership
感谢您的阅读。如果您有任何反馈，请告诉我。
10 个 Jupyter 实验室扩展，提高您的工作效率
为你自己定制 Jupyter Lab，一个 IDE 工具
如果你是一个使用 Python 作为主要编程语言的数据科学家或数据工程师，我相信你一定会使用 Jupyter Notebook。作为 Jupyter 笔记本的“下一代”网络应用程序，Jupyter Lab 提供了比以前更方便的功能。其中之一是扩展。
现在，即使是 Jupyter 实验室开发团队也为拥有这样一个强大而繁荣的第三方扩展社区而感到兴奋。在本文中，我将介绍 10 个 Jupyter Lab 扩展，我发现它们对于显著提高典型数据科学家或数据工程师的工作效率非常有用。
Jupyter 实验室推广经理
大多数在线资源会告诉您运行如下命令来安装 Jupyter Lab 扩展。
jupyter labextension install @jupyterlab/...
嗯，使用命令行也是我的最爱。然而，如果你是 VS 代码的用户，Sublime 或者 Atom，你可能也想直接在一个“管理器”中搜索你想安装的东西。Jupyter 实验室确实提供了这个功能。
如截图所示，您可以进入左侧导航的第 4 个选项卡，这是扩展管理器。然后，您可以搜索任何您想要的，以获得适合您需求的扩展。所以，你甚至不需要事先知道扩展名。
现在，我们来看看有哪些值得推荐的扩展！
1.JupyterLab 调试器
https://blog.jupyter.org/a-visual-debugger-for-jupyter-914e61716559
我们都爱 Jupyter，因为它的互动性。然而，有时，调试功能对于编码是必要的。例如，我们可能想一步一步地运行一个 For 循环，看看里面到底发生了什么。大多数 IDE 工具都支持这种带有“单步调试”和“单步调试”功能的调试特性，但不幸的是，Jupyter 自然不支持这种特性。
这样的扩展允许我们补充 Jupyter 实验室中缺少的特性。
图片提供:https://blog . jupyter . org/a-visual-debugger-for-jupyter-914 e 61716559
2.JupyterLab-TOC
https://github.com/jupyterlab/jupyterlab-toc
有长长的笔记本？想要让您的笔记本在演示时更漂亮吗？或者，只是想为你的笔记本准备一个目录？@jupyterlab/toc前来帮忙。
图片提供:https://github . com/jupyterlab/jupyterlab-TOC/raw/master/TOC . gif
有了这个扩展，目录将基于带标题的 markdown 单元格自动生成(确保使用尖锐的符号##来指定标题级别)。这也是一种使用 Jupyter 笔记本的好方法，可以让你的工作更加系统和有条理。
3.JupyterLab-DrawIO
https://github.com/QuantStack/jupyterlab-drawio
Diagram.net(原名画画。IO)是我最喜欢的绘图工具。如果你是我的追随者之一，我可以告诉你，我文章中的大多数图表都是用这个绘制的。它确实是 MS Visio 的一个完美的开源替代方案。
现在，有了jupyterlab-drawio，我们可以把这个完美的工具带到 Jupyter 实验室。请去看看并欣赏这幅画:)
图片提供:https://github . com/quant stack/jupyterlab-draw io/raw/master/draw io . gif
4.JupyterLab 执行时间
https://github.com/deshaw/jupyterlab-execute-time
Jupyter Notebook/Lab 的一个惊人特性是它提供了许多有用的神奇命令。例如，我们可以使用%timeit来测试我们的代码运行需要多长时间。它将运行我们的代码片段数百或数千次，并获得平均值，以确保给出一个公平和准确的结果。
然而，有时候我们并不需要这么科学。此外，最好能知道每个单元运行的时间。这种情况下，每一个细胞都用%timeit绝对是矫枉过正。
jupyterlab-execute-time能在这种情况下提供帮助。
如屏幕截图所示，它不仅显示了执行该单元所用的时间，还显示了上次执行的时间。我向您保证，这是一个非常方便的特性，可以指示这些单元格的执行顺序。
5.JupyterLab 电子表格
https://github.com/quigleyj97/jupyterlab-spreadsheet
作为一名数据科学家或数据工程师，您有时必须处理电子表格。然而，Jupyter 并不支持读取 Excel 文件，这迫使我们打开多个工具在 Jupyter 编码和 Excel 查看之间切换。
jupyterlab-spreadsheet完美解决了这个问题。它在 Jupyter 实验室中嵌入了 xls/xlsx 电子表格查看功能，因此我们可以在一个地方获得所有需要的信息。
图片提供:https://github . com/quigleyj 97/jupyterlab-spread sheet/raw/main/snapshot . png
6.JupyterLab 系统监视器
https://github.com/jtpio/jupyterlab-system-monitor
Python 不是一种执行有效的编程语言，这意味着与其他语言相比，它可能会消耗更多的 CPU/内存资源。另外，Python 最常见的用例之一是数据科学。因此，我们可能希望监控我们的系统硬件资源，以意识到我们的 Python 代码可能会冻结操作系统。
jupyterlab-topbar-extension是您可能想要的分机。它将在 Jupyter Lab UI 的顶栏上显示 CPU 和内存使用情况，以便我们可以实时监控它们。
图片提供:https://github . com/JT Pio/jupyterlab-system-monitor/raw/main/doc/screen cast . gif
7.JupyterLab 风筝
https://github.com/kiteco/jupyterlab-kite
虽然我喜欢 Jupyter，但它不能像其他经典 IDE 工具那样自动完成代码。代码自动完成非常有限且缓慢。
你可能听说过 Kite，这是一个免费的人工智能代码完成服务。在 Sublime、VS Code、PyCharm 等几乎所有流行的 ide 中都有。事实上，你也可以在 Jupyter 实验室使用这项服务。
图片提供:https://github.com/kiteco/jupyterlab-kite
有了这个扩展，我们可以更流畅地在 Jupyter 实验室编码。
8.JupyterLab 变量检查器
https://github.com/lckr/jupyterlab-variableInspector
如果您是从 R studio 或 Matlab 转来的数据科学家，您可能非常熟悉这些工具提供的变量检查器。遗憾的是，Jupyter 实验室默认不提供该功能。然而，扩展jupyterlab-variableInspector把这个特性带回来了。
图片提供:https://github . com/lckr/jupyterlab-variable inspector/raw/master/early _ demo . gif
9.JupyterLab Matplotlib
https://github.com/matplotlib/ipympl
如果你是一名数据科学家，Matplotlib 是一个必须学习的 Python 库。这是一个基本但强大的 Python 数据可视化工具。然而，当我们使用 Jupyter Lab 时，交互功能已经消失了。
jupyter-matplotlib扩展可以让你的 Matplotlib 再次交互。只需使用一个神奇的命令%matplotlib widget启用它，你的花式三维图表将成为互动的。
图片提供:https://github . com/matplotlib/ipympl/raw/master/matplotlib . gif
10.JupyterLab Plotly
https://plotly.com/python/getting-started/#jupyterlab-support-python-35
虽然 Matplotlib 是最基本和最强大的数据可视化库，但 Plotly 是我在这方面最喜欢的库。它包装了许多常见的图表，我们可以在几行代码中生成惊人的图表。
为了使 Jupyter Lab 无缝支持并能够显示交互式 Plotly 图表，需要安装jupyterlab-plotly。
摘要
当然，社区中有更多精彩的 Jupyter 实验室扩展。在这篇文章中，我根据我的喜好介绍了其中的 10 种。在过去的几年里，这些扩展帮助我提高了很多效率，现在我向你推荐它们！
https://medium.com/@qiuyujx/membership
如果你觉得我的文章有帮助，请考虑加入 Medium 会员来支持我和成千上万的其他作者！(点击上面的链接)
提高 Python 速度的 10 种黑仔方法
加速 Python 代码的一些简单方法。
(src =https://pixabay.com/images/id-259815/
介绍
A 虽然 Python 是一种奇妙而简单的高级编程语言，但像大多数语言一样，它也有缺陷。Python 编程语言有几个显著的障碍，但可能是最显著的，尤其是从数据科学工作的角度来看，可能是 Python 的速度。为了理解为什么这是一个障碍，我们首先需要理解为什么会这样，以及为什么当它涉及到数据科学时会相当不方便。
Python 被定义为一种解释型、动态类型的编程语言，具有相对较强的类型。这意味着 Python 本身是由另一种编程语言解释和理解的。这使得该语言比使用编译器库从头构建的编程语言更容易构建。但是，它对性能也有很大的影响。所有其他特性都非常适合数据科学领域的工作，当涉及到数据科学的类型化时，使用相对强的类型化进行动态类型化是一个很好的设置。然而，这种被解释的障碍可能会使编程语言比编译选项慢很多。
虽然 Python 不是最慢的语言，但也不是最快的。幸运的是，Python 确实提供了一个奇妙的、不断扩展的工具生态系统。在 Python 中，有很棒的工具可以做你想做的各种不同的事情。鉴于 Python 是一种解释起来相对较慢的语言，因此很容易理解为什么人们可能希望看到一个工具生态系统来加速编程语言。不用说，在某些情况下，这些工具对于用 Python 完成一些机器学习工作可能是必不可少的。考虑到这一点，我想回顾一下让这种编程语言更快的一些我最喜欢的选项。虽然这些不是完全可靠的方法，但它们通常有助于减少计算时间。
№1:迭代工具
提高 Python 速度的一个非常普通的方法是使用标准库包 Itertools。Itertools 是一个很棒的工具库，可以用来加速迭代。因为迭代在编程中很常见，所以这个包肯定会大大提高函数、类和算法的速度。在这个列表的所有选项中，Itertools 可能是最简单、最容易使用的选项之一。此外，您甚至不需要安装一个新的包来使用它，因为它在标准库中是可用的！实际上，我有一整篇关于 Itertools 的文章，您可以在这里查看:
在这个列表的选项中，Itertools 无疑是最容易推荐的。如果你是这个包的新手，我当然会推荐你去看看并尝试这个包！在实地实际工作中也会派上用场！
№2:数字
Java 编译器和较新的 Julia 编译器普及的一个编译概念是实时(JIT)编译。JIT 编译是指编译器在执行时编译代码，并预先进行一些预编译。换句话说，当代码被编译器处理时，软件已经在执行了。结果是语言速度快了很多，因为这两件事是一起做的，而不是一次做一件。我正好有一整篇关于 Numba 的文章，你可以在这里查看:
Numba 实现的伟大之处在于它非常容易使用！Numba 使用一个简单的装饰器让 Python 在某些函数和类上激活 JIT。也就是说，使用 Numba 几乎不费吹灰之力，但它仍然对性能有重大影响。
№3:功能工具
另一个非常容易使用的解决方案是 FuncTools。这个模块在标准库中，它是如此的通用，以至于很难涵盖其中的所有内容。然而，许多函数可以很容易地用来加速 Python。缓存就是一个很好的例子。FuncTools 包允许用户缓存以前使用的函数，这对于计算后面的例子很方便。我还有另一篇关于 Functools 的文章。如果您想了解更多关于此套餐的信息，您可以点击:
№4:杯子
如果你的电脑中碰巧有一个图形处理单元(GPU)，并且这个 GPU 恰好是由 Nvidia 制造的，那么你很可能可以访问 CUDA 并行计算平台。CuPy 平台可用于通过并行计算来加速 NumPy 矩阵运算，并且工作相当自动化。这一点很重要，因为在很多情况下，CUDA 很难使用或设置，但使用 CuPy 基本上不费吹灰之力。
№5:瓶颈
下一个解决方案与 CuPy 非常相似，但幸运的是不需要 GPU 就可以使用。相反，瓶颈依赖于编写得非常好的 C 函数来调用，这可以加速 NumPy 操作。不用说，如果你是一个没有 GPU 的数据科学家，这个解决方案对于加速你的 Python 代码肯定是非常重要的。
№6: Cython
另一个可以让 Python 运行得更快的解决方案是 Cython 包。这个包采用了一种更直接的方法来加速 Python，直接将您编写的 Python 代码转换成 c。不用说，这可以显著提高给定 Python 程序的性能。然而，我想指出的是，这肯定不是加速 Python 的完全可靠的方法。使用这种方法将 Python 软件转换成 C 语言很容易遇到许多问题。此外，你的项目越复杂，依赖性越强，使用 Cython 进行简单转换的可能性就越小。因此，在使用这个包时，一定要记住这一点。
№7:达克
Dask 来自 Python 数据科学工具的 Blaze 生态系统。Dask 是另一个并行计算平台，它没有被指定为只与 NumPy 库一起工作。不用说，如果你刚好有一个 Nvidia 项目，Dask 当然是一个很棒的工具。在这个列表的选项中，这个选项是我发现比其他选项更难的选项之一。
8 号:线程
在 Python 中，提高软件速度最常见的方法之一是使用线程库。线程库包含在 Python 编程语言的标准库中，相对容易使用。不管是经常使用还是不经常使用，我都强烈建议使用线程库来加速 Python 中的某些任务。
在这方面，线程最常见的用途是用于迭代循环。正如我之前提到的，迭代循环在编程领域非常普遍。也就是说，这个工具当然可以用来提高 Python 中算法的速度。
№9:更快
Swifter 是一个简单易用的软件包。Swifter 在整个可迭代列表中应用操作的速度要快得多。这当然是使用 apply()方法，Swifter 为此应用了自己的一个新示例。只需将一个表达式和数组一起放入 apply()方法中，操作的执行速度就会比正常情况下更快。鉴于这个库使用 apply()方法，很容易理解为什么这个模块对于使用 Python 的数据科学很有价值。
№10: C
我想回顾的最后一个提高 Python 速度的突出工具是 C。我最近写了一篇文章，讲述了为什么我认为 C 是学习数据科学的好主意，我仍然相信它是。如果你想读这篇文章，你可以在这里:
[## 为什么 C 对于数据科学来说很方便
towardsdatascience.com](/why-c-comes-in-handy-for-data-science-76071206bb5)
为什么我认为 C 对于数据科学来说会派上用场？最大的原因可能是因为 Python 解释器是用 C 语言构建的。这意味着通过实际编写供 Python 访问的 C 代码，编写 C 语言可以更容易地快速运行 Python。不用说，这可能是这个列表中最难访问的选项之一。不管怎样，我认为这值得一提。
结论
总之，不管 Python 在速度和其他方面有什么问题，它仍然是一门很棒的语言。生态系统中有如此多的优秀解决方案可以用来提高 Python 的速度，有时甚至可以使用更多的代码来改善这种语言的负面属性。我相信这是这种语言在如此快速发展的行业中继续保持相关性的部分原因。我强烈推荐这个列表中的选项来提高你的 Python 代码的速度，因为它们通常非常容易使用！非常感谢您阅读这篇文章！
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
结论
要精通递归需要大量的练习。但是在去面试之前看一下这些问题是个好主意。没有人能保证面试问题，但准备不同模式的编码问题是关键。但是到目前为止，无论我面对什么样的面试，他们都没有给我任何难题。他们通常会问问题来测试知识和解决问题的整体方法。
欢迎在推特上关注我，喜欢我的脸书页面。
更多阅读
来自 CVPR 2021 的 10 篇有前途的综合论文
我们从顶级计算机视觉会议上挑选的关于人类、场景和运动合成的最有前途的最先进的论文。
2021 年计算机视觉和模式识别大会(CVPR)刚刚开始。主题涵盖从自动驾驶到医疗成像的整个领域，CVPR 2021 展示了一系列令人兴奋的最新技术，展示了巨大的实际应用潜力。在信息高度密集的文件迷宫中穿行可不是在公园里散步。因此，我们精选了十篇有前途的 CVPR 论文，涉及三大主题——图像合成、场景重建和运动合成。
图像合成中对 GANs 的控制
“我们没有更好的算法。我们有更多的数据，”谷歌的研究主管彼得·诺维格说。这恰当地反映了机器学习社区中普遍流行的“数据越多(通常)越好”的口号。在计算机视觉领域，近年来在合成和编辑真实感图像方面已经看到了生成式对抗网络(GANs)的出现和发展。
然而，计算机视觉从业者哀叹对这种生成模型合成的图像缺乏控制——这是正确的。在这里，我们探索一些 CVPR 2021 论文，这些论文吹嘘在生成图像的过程中提供更多的控制。这些进步代表了向 GAN 的广泛采用迈进了一步。
1。长颈鹿:将场景表示为合成生成神经特征场 [ Github ]
控制生成图像中的对象的任务需要模型在 3D 中推理。这对于在 2D 空间中运行的模型来说绝不是微不足道的。为了解决这个问题，本文在模型中引入了一种组合的 3D 场景表示，允许独立地控制对象的位置、方向和视角。
该模型能够首先识别前景和背景中的对象，然后改变它们的位置、方向和视角。然后，它将所有对象组合起来，生成一个输出图像。在该示例中，在汽车图像集合上训练的模型可以生成不同尺寸、位置和方向的汽车图像。长颈鹿也能够改变背景，甚至改变场景中汽车的数量。
2。想象:通过图像引导模型反演
的图像合成想象，图像引导模型反演(IMAGINE)方法从一个单一的图像生成高质量和多样的图像，而不需要训练生成器。它的一个关键特性是在合成过程中对语义(如对象的形状和位置)施加约束的能力，并为用户提供对控件的直观控制。不像它的前辈像 SinGAN 那样努力创造非重复的物体，IMAGINE 创造了非重复图像的高质量图像。
由想象生成的结果(来源)
3。HistoGAN:通过颜色直方图控制 GAN 生成的图像和真实图像的颜色纸张
GAN 难以控制的另一个方面是图像的颜色。受基于类直方图的颜色传递方法的启发，慕尼黑工业大学和谷歌的研究人员开发了 HistoGAN。
HistoGAN 通过修改 StyleGAN 的最后两个块来整合直方图特征，从而利用了 StyleGAN2 的架构。因此，通过将目标颜色直方图作为直方图输入的一部分，可以控制图像的色调。
使用直方图作为改变图像颜色的杠杆是直观的和独立于领域的，允许来自不同领域的图像和从业者潜在地使用直方图。在上面的 HistoGAN 图中可以看到目标颜色对生成图像的影响。
HistoGAN 生成的图像。每一行的图像都有不同的目标图像，目标颜色以直方图的形式从中导出(显示在左栏的左上角)。
4。用于交互式图像合成和编辑的 any cost GANs[Github | Paper]
像 StyleGAN2 这样的先进网络的高计算成本已经阻止了用户即时和交互式地生成图像。今天，一个完整的生成器大约需要 3 秒来渲染一幅图像，这对于许多用途来说都太慢了。这个问题预示着交互式自然图像编辑的任何代价。
使用 Anycost GAN，用户可以控制以较低的通道和分辨率配置生成图像，以换取更快的结果和更低的计算成本。有了这样的控制，用户可以以快 5 倍的速度生成视觉上相似的图像。
这一发现为用户在各种成本预算和硬件要求下生成图像铺平了道路，代表了向没有计算资源的用户普及 GANs 的一步。
AnycostGan 演示，重点介绍通道和分辨率设置。播放 gif ！
动态物体和人的合成
我们已经看到了 GANs 如何允许静态图像被重新创建和控制。但是动态图像呢？在下一节中，我们将看到在运动中建模和合成物体方面的进步。
5。通过隐式模块化视听表示生成姿态可控的说话人脸
“我们正在进入一个时代，在这个时代，我们的敌人可以让任何人在任何时间点说任何话，”这是一位总统奥巴马根据 2018 年几个小时的镜头重建的话。从那时起，计算机视觉社区已经实现了从音频剪辑中创建具有精确同步嘴唇运动的说话头部的壮举。然而，控制正在说话的头部的姿态的问题是具有挑战性的，并且是产生具有个性化的有节奏的头部运动的正在说话的头部的瓶颈。
姿势可控视听系统(PC-AVS)承诺通过实现自由姿势控制，同时创建带有音频的任意说话人脸来解决这一问题。PC-AVS 可以将一个演员的单张照片、音频剪辑和另一个演员姿势的源视频转换成一个逼真的说话头。这种方法优于现有的方法，如节奏头(陈等人)和 MakeitTalk(周等人)，特别是在音频的极端条件下，如当音频有噪声时。
6。神经体:具有结构化潜在代码的隐式神经表示，用于动态人的新颖视图合成[GitHub]
一个人需要多少台摄像机才能精确地再现人类的 3D 动作？过去，一个像样的机会需要一屋子的摄像机，尤其是像跳舞这样复杂的身体动作。多亏了神经体，一种带有结构化潜在代码的隐式神经表示，现在只需要四个摄像头。
这项任务，正式名称为“新视图合成”，在密集的单目摄像机阵列中是可能的，但在稀疏的多视图视频中似乎是不可能的。该模型不能完全依赖拼接多个 2D 图像来创建 3D 视图。相反，该模型学习在可变形网格上拼凑多个 2D 图像，并跨帧整合观察结果。
新观点综述
去年引入了非常流行的神经网络领域(也称为 NeRF)。NeRF 是一个经过训练的简单全连接网络，被认为是使用多张图片合成复杂场景的新颖视图的最佳解决方案之一，具有最先进的效果。今年，研究人员通过实现更快更高级的场景重建扩展了 NeRF。
7。pixelNeRF:来自一个或几个图像的神经辐射场[ 网站】
使用 NeRF，需要在同一场景的多个视图上优化模型几个小时，如果不是几天，以追求合成高质量的图像，如下所示。
使用 100 张图像优化 NeRF 渲染一个打击乐器组新视图的过程。
pixelNeRF 解决了 NeRF 的缺点，承诺在更短的时间内用更少的场景视图再现新的视图。它通过引入一种架构来实现这一点，该架构使网络能够跨多个场景进行训练，以学习先前的场景。例如，在只有三个输入视图的情况下，pixelNeRF 比 NeRF 产生了更好的结果。这可以通过需要更少的计算和更少的输入图像来潜在地降低合成视图的成本，使这种技术更容易获得。
pixelNeRF 在用少量图像合成 3D 物体方面优于 NeRF。
8。NeRV:用于重新照明和视图合成的神经反射和可见性场[ 纸张 | 视频|GitHub]【T20]虽然 NeRF 允许从新颖的视图渲染相同的场景，但它不提供用新颖的照明条件再现相同场景的方法。因此，谷歌、麻省理工和伯克利的研究人员提出了用于重新照明和视图合成的 NeRV、神经反射和可见度场。NeRV 在已知光照的情况下获取物体的图像，并在任意光照下从新的视点输出其 3D 表示。这可以重新照亮对象，甚至改变对象的材质。
NeRV 可以改变照明条件和物体的材质。
场景重建
今天，实时 3D 场景重建已经应用于创建沉浸式增强现实和虚拟现实环境。今年，研究人员对用比以前少得多的资源重建场景产生了兴趣。
当前的重建技术只有在具有深度传感器的昂贵的专用相机存在的情况下才是实用的。如果我们可以只使用像智能手机上那样的单目相机来执行 3D 场景和对象重建，会怎么样？NeuralRecon 可以通过已知相机姿态的单目相机实时捕捉视频来实现这一点。
NeuralRecon 的实时重建之所以成为可能，是因为它的计算成本比 Atlas 等现有的最先进方法相对更低。令人印象深刻的是，根据室内数据训练的 NeuralRecon 模型可以有效地重建墙壁等同质纹理，并很好地推广到室外场景。
可以想象，智能手机可以利用 NeuralRecon 网络实时创建逼真的场景，有可能在不久的将来催化 AR 和 VR 的主流采用。
蛋白质相互作用的预测
当 DeepMind 宣布其基于注意力的神经网络算法 AlphaFold 成功解决了生物学中 50 年的重大挑战——蛋白质折叠问题时，科学界感到敬畏。这证明了深度学习是解决蛋白质科学现存问题的有效方法。
10。蛋白质表面的快速端到端学习[ 论文
蛋白质科学中的另一个问题是识别蛋白质的相互作用位点，以及通过扩展蛋白质如何彼此结合(由于它们的结构和化学特征)。在这篇论文中，作者表明，计算机视觉可以用来高精度地解决这两个问题，而无需预先计算蛋白质的手工化学和几何特征。因此，计算可以在占用很少内存的情况下进行，这使得在更大的蛋白质结构集合上进行这种预测变得切实可行。
本文实现了最先进的性能，运行时间比以前的模型更快。蛋白质建模的这一突破可以预测蛋白质的功能，并催化合成蛋白质的设计。这种发展，加上其他深度学习方法，可能会被证明是解决蛋白质科学中许多开放问题的关键之一。
CVPR 2021:图像合成是未来
在这次会议上，我们了解到计算机视觉领域取得的令人印象深刻的进展。特别是，从业者可以期待在生成新图像和视频的过程中得到更好的控制，而不是将控制委托给黑盒。我们也惊叹于社区在更精确地再现运动方面的进步及其在将计算机视觉应用于蛋白质科学方面的创造力。
2021 年 CVPR 是计算机视觉社区在推进图像生成技术方面足智多谋的证明。我们相信，在未来的几年中，这个致力于实践的社区将使图像生成技术保持快速突破。
原载于 2021 年 6 月 22 日https://www . data gen . tech。**
用于全栈自动化和测试的 10 个 Python 模块
你没听错——Python 可以用于自动化和软件开发测试
在 Unsplash 上拍摄的 ThisisEngineering RAEng
在本文中，我将分享我的自动化和测试的 10 大 python 模块/工具。随着软件生产而来的是许多问题，自动化和测试是解决这些问题的最好方法，而不需要花费时间。这样我们可以测试我们的程序，检查每一个场景。在自动化和软件测试中，Java 是最著名的语言。但是作为一名 python 开发人员，我决定为自动化和测试寻找最好的 Python 模块。在这篇文章中，我将与你分享我的清单。和他们一起工作很有趣，结果也令人满意。我希望你也会发现它们很有帮助。
什么是全栈自动化？
今天，自动化对于在任何业务流程中实现优化、效率和最佳实践都是必不可少的。这一自动化流程对于我们的 IT 运营也至关重要，尤其是在将 SAP 作为组织环境中最重要的应用程序时。全栈自动化流程将处理驱动一些关键业务流程的复杂应用程序。该系统还将提供多种平台、地域、工具和技术。
为什么重要？
您将从这一全栈自动化流程中获得许多好处。它将加快开发周期，减少 It 系统中的错误，减少混乱，并更快地解决任何应用程序问题。一旦您将这种自动化应用到您的公司，您可以节省大量资金并提高业务的整体效率。如果您在业务中使用 Python，您现在可能想看看这篇文章。我们将分享一些 Python 中可用的自动化库和工具。
如果你准备好了，让我们开始吧。
1。机器人框架
如果你想用 Python 测试你公司的自动化流程，你可以看看这个框架。它使用关键字驱动的方法，因此可以使测试易于创建和阅读。Robot Framework 可以用来测试很多其他的东西，比如 Android，MongoDB，FTP，mainframe，Appium 等。
官方文档: 机器人框架
2。PyTest
它是不同语言中最流行的自动化框架之一。它非常简洁，因此可以专注于测试。你可以在使用这个平台的时候写一些其他的函数。它们被标记为 fixtures，可以用来使整个过程可重用和可伸缩。
官方文档: PyTest
好文章:PyTest 综合指南作者理查德·施。
3。碎片
Splinter 是一个奇妙的包装器类型库，它是专门为 Python 中的 Selenium 设计的。Splinter 是一个免费的开源工具，可以用来用 Python 测试 web 应用。您可以使用这个工具来自动化浏览器操作，例如与其他项目交互、访问 URL 等。
官方文档: 碎片
4。硒
Selenium 是一个优秀的功能性 Python 测试自动化。当您使用这个 Selenium 包时，可以使用它来自动化来自 Python 的网站浏览器交互。它在世界各地的许多开发人员中很流行。因此，它成为基于浏览器的自动化的行业标准。
官方文件: 硒
5。举止
当你想选择最好的行为驱动开发库时，可以看看这个平台。这个框架和黄瓜有一些相似之处。但是，这个库是专门用 Python 设计的。
官方文件: 做人
6。Pywinauto
如果您正在寻找非基于浏览器的功能自动化，可以看看这个平台。它是一组 python 模块，用于自动化 Windows GUI。这种自动化将处理复杂的操作，例如获取细节和文本数据。
官方文档: Pywinauto
7。Automagica
它是最受欢迎的开源智能机器人过程自动化或 SRPA 平台之一。您可以使用该平台来自动化一些跨平台的流程，例如，文件和文件夹操作、PDF 操作、浏览器自动化、电子邮件业务等。这个工具可以用来加速整个软件开发过程。
官方文档: Automagica
8。美汤
许多人用来从 XML 和 HTML 文件中提取数据的最流行的 Python 库之一是 Beautiful Soup。大多数开发人员通常有一系列包含一些 Python 助手脚本的框架。这些脚本确实有效地利用了这个工具。
官方文档: BeautifulSoup
9。PDFMiner
如果你需要对 PDF 文件做一系列的测试，你可以考虑使用这个工具。这个库是一个文本提取工具，可以用来提取任何 PDF 文档。当您正确使用此 PDFMiner 时，您可以验证和测试任何 PDF 文件。
官方文档: PDFMiner
10。蝗虫框架
当您使用 Python 进行测试时，Locust 是您需要了解的另一个很好的框架。它是一个易于使用的负载测试工具。它将帮助您找出系统可以处理多少用户。其友好的基于 web 的用户界面将帮助您获得该工具的许多功能和优势。
官方文档: 蝗虫框架
结论
作为一名开发人员，您可能希望找到自动化任何日常任务的最佳工具。Python 可以是你需要的一种强大的自动化语言。您可以很容易地将该工具与目前可用的其他仪器、库和平台连接起来。一旦您知道如何组合所有这些工具，您就可以轻松地自动化您的一些任务。
为您提供 Python 项目实践
让数据科学家的生活更轻松的 10 个快速数字技巧
了解数据科学的基本数字函数
照片由 Unsplash 上的 Aditya Saxena 拍摄
Numpy 是唯一让我这个铁杆 C++程序员首先转向 python 的东西。请注意，这是在我的数据科学学习曲线出现之前，没有 python，任何人都无法生存！(请不要冒犯，只是陈述我的观点，所有的 R 爱好者，我都一样尊重你们)。但是如果一个库可以改变我对编程语言的忠诚，那么它一定是一个地狱般的库。
在我曾经实习过的机器人实验室里，我们曾经就奇怪的 Numpy 命令互相测验，那时我才真正看到了这个图书馆的美丽。所以，如果你通过了下面的测试，无论如何，你不需要这个博客:p。但除此之外，继续阅读！！
测试:预测以下内容的输出
import numpy as nparr = np.arange(5)
arr = arr[-1::-1]
print(arr)
如果你已经知道了这一点，你可能已经知道了我将在这篇博客中讲述的大部分内容，但除此之外，请继续阅读。
输出为[4，3，2，1，0]
让我们深入研究 Numpy 的函数，这些函数是我们的救命稻草，尤其是对我来说，因为我讨厌编写 double for 循环来访问 2D 数组。
注意:在所有未来的例子中，我假设作为 np 的 import numpy 已经被调用
1.numpy.arange(开始、停止、步进)
此函数返回一个 numpy 数组，其中包含从 start 开始到 stop 结束并以步长差递增的数字。所以这些数字位于[开始，停止]区间。
举个例子，
**>>> np.arange(3,7,2)
array([3, 5])****>>> np.arange(5)
array([0,1,2,3,4])**
类似函数 : numpy.linspace ， numpy.repeat ， numpy.tile ， numpy.eye (是不同的用例，但在处理矩阵时很有帮助)。
如果你想看看定义和初始化数组的其他方法，我在之前的博客这里提到过。
2.numpy.random
numpy.random 是 numpy 中的一个模块，包含用于生成随机数的函数。它有多种用途，尤其是在处理基于概率的函数时。让我们看看本模块中不同功能的几个示例。当您使用相同的命令时，下面显示的输出会发生变化，因为它们是随机生成的。
**#Create an array of random numbers, size of array is (3,2)****>>> np.random.rand(3,2)
array([[ 0.14022471, 0.96360618], #random
[ 0.37601032, 0.25528411], #random
[ 0.49313049, 0.94909878]]) #random**
点击查看更多示例。
**#Return random integers from *low* (inclusive) to *high* (exclusive) or 0 (inclusive) to low(exclusive),** **random.randint****(*low*, *high=None*, *size=None*, *dtype=int*)****>>> np.random.randint(2, size=10)
array([1, 0, 0, 0, 1, 1, 0, 0, 1, 0]) # random
>>> np.random.randint(5)
1**
点击查看更多的例子。
类似功能 : numpy.random.randn ，numpy . random . sample， numpy.random.choice 。
3.numpy.argmax(arr，axis = None)
我们的许多用例，尤其是在执行优化时，要求我们知道具有最大值或最小值的变量。为了去掉跟踪这些信息的额外代码行，我们可以简单地使用 argmax 和 argmin 的 numpy 函数。让我们看一个同样的例子。以下示例包含术语轴。数组的轴是我们希望执行计算的方向。如果我们没有指定一个轴，那么默认情况下计算是在整个数组上完成的。
**>>> a = np.array([[10, 12, 11],[13, 14, 10]])
>>> np.argmax(a)
4 #since if the array is flattened, 14 is at the 4th index
>>> np.argmax(a, axis=0)
array([1, 1, 0]) # index of max in each column
>>> np.argmax(a, axis=1)
array([1, 1]) # index of max in each row**
类似功能 : numpy.argmin ， numpy.amax
4.切片和索引
这在改变 NumPy 数组的内容时起着至关重要的作用。它用于同时访问数组中的多个元素。举个例子会让你更容易理解它是如何工作的。
**>>> a = np.arange(5)
>>> print(a[4])
4 # number at index****>>> print(a[1:])
array([1, 2, 3, 4]) #it will print all element from index 1 to last (including number at index 1)****>>> print(a[:2])
array([0, 1]) #it will print all element from index 0 to index 2(excluding number at index 2)****>>> print(a[1:3])
array([1, 2]) #it will print all element from index 1 (including) to index 3 (excluding)****>>> print(a[0:4:2])
array([0,2]) # [0:4:2] represents start index, stop index, and step respectively. It will start from index 0 (inclusive) go to index 4 (exclusive) in step of 2 which will result in [0, 2] and a[0,2] will be the output.**
切片用于灵活地访问 numpy 数组的多个索引处的元素。如果使用得当，它可以大大减少代码的长度。
回到我在博客开头给出的测试，那里的魔法使用了切片。当我们写 arr[-1::-1]时，它实际上从 arr 的最后一个元素开始，然后第二个-1 确保它以步长 1 的相反顺序进行。因此我们得到了相反的数组。
5.numpy.setdiff1d ( ar1 ， ar2 )
当我们需要将数组视为集合并寻找它们的差、交或并时，numpy 通过这些内置函数使这项工作变得简单。
**#Set difference**
**>>> a = np.array([1, 2, 3, 2, 4, 1])
>>> b = np.array([3, 4, 5, 6])
>>> np.setdiff1d(a, b)
array([1, 2])****#Set intersection
>>> np.intersect1d([1, 3, 4, 3], [3, 1, 2, 1])
array([1, 3])****#Set Union
>>> np.union1d([-1, 0, 1], [-2, 0, 2])
array([-2, -1, 0, 1, 2])**
类似功能: numpy.setxor1d ， numpy.isin 。
6.numpy . shape(a， newshape ， order='C' )
在处理矩阵时，我们需要适当的维数来进行乘法等运算。或者甚至在处理复杂数据时，我不得不无数次地改变数组的形状。
**>>> a = np.arange(6).reshape((3, 2))
>>> a
array([[0, 1],
[2, 3],
[4, 5]])
>>> np.reshape(a, (2, 3)) *# C-like index ordering*
array([[0, 1, 2],
[3, 4, 5]])
>>> np.reshape(a, (2, 3), order='F') *# Fortran-like index ordering*
array([[0, 4, 3],
[2, 1, 5]])**
点击查看更多例子。(我强烈建议阅读所有示例)
类似功能: ndarray.flatten ， numpy.ravel 。这两种方法都可以将任意数组转换成 1D 数组，但是两者之间有细微的差别。此外，像 numpy.squeeze 和 numpy.unsqueeze 这样的函数用于在数组中删除或添加一个维度。
7.numpy.where( 条件 [， x ， y ] )
帮助我们根据输入到函数中的一些条件提取子数组。这里如果条件满足，则选择 x ，否则选择 y 。让我们看一些例子来了解更多
**>>> np.where([[True, False], [True, True]],
... [[1, 2], [3, 4]], #x
... [[9, 8], [7, 6]]) #y
#Here since the second element in first row was false the output contained the element from the second array at that index.** **>>> a = np.arange(10)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.where(a < 5, a, 10*a)
array([ 0, 1, 2, 3, 4, 50, 60, 70, 80, 90])**
8.numpy . concatenate((a1、 a2 、……)、 axis=0** )
该函数有助于沿现有轴连接数组。当我们预处理数据并需要多次追加或组合数据时，这是有益的。
**>>> a = np.array([[1, 2], [3, 4]])
>>> b = np.array([[5, 6]])
>>> np.concatenate((a, b), axis=0)
array([[1, 2],
[3, 4],
[5, 6]])
>>> np.concatenate((a, b.T), axis=1)
array([[1, 2, 5],
[3, 4, 6]])
>>> np.concatenate((a, b), axis=None)
array([1, 2, 3, 4, 5, 6])**
类似功能: numpy.array_split ， numpy.ma.concatenate ， numpy.split ，numpy.hsplit，numpy.vsplit，numpy.dsplit， numpy.hstack
9.numpy.power( x1 ， x2)
我无法告诉你这个功能给我的生活带来了多大的便利。它帮助我取代了所有用来写一个数组的平方或立方的循环。该函数输出一个数组，该数组包含第一个数组的元素的自乘幂，从第二个数组开始，按元素排序。让我给你举个例子来说明一下。
**>>> x1 = np.arange(6)
>>> x1
[0, 1, 2, 3, 4, 5]
>>> np.power(x1, 3)
array([ 0, 1, 8, 27, 64, 125])
>>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0]
>>> np.power(x1, x2)
array([ 0., 1., 8., 27., 16., 5.])
>>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]])
>>> x2
array([[1, 2, 3, 3, 2, 1],
[1, 2, 3, 3, 2, 1]])
>>> np.power(x1, x2)
array([[ 0, 1, 8, 27, 16, 5],
[ 0, 1, 8, 27, 16, 5]])**
在 ndarrays 上，**操作符可以用作np.power的简写。
相似函数:所有的基本数学运算符。你可以在这里查看它们。
10.numpy.allclose(a，b，rtol=1e-5，atol=1e-8)
allclose 用于确定两个数组在某个容差范围内的元素是否相等。公差值是正数，并且是一个小数字。计算为( rtol * abs( b ))和 atol 之和。a 和 b 之间的元素绝对差值应小于计算的公差。
**>>> np.allclose([1e10,1e-7], [1.00001e10,1e-8])
False
>>> np.allclose([1e10,1e-8], [1.00001e10,1e-9])
True**
事实证明，在比较包含来自两个不同模型的预测值的两个数组时，这非常有用。
类似功能: numpy.isclose ， numpy.all ， numpy.any ， numpy.equal
我很高兴现在证明你是 Numpy 的主人！！
尝试这些，你很快就会成为一名数据科学家大师！万事如意。
更多此类内容，请关注我们的媒体。请在评论中告诉我们你想了解更多的话题，我们会尝试就这些话题写博客。
成为 介质会员 解锁并阅读介质上的许多其他故事。
可以帮助您处理日期的 10 个快速 Python 片段
在 Unsplash 上由 Brad Neathery 拍摄的照片
如果您在工作中使用 Python，或者仅仅是为了编写脚本，那么很可能会有一天您需要处理日期。
它可以从一种格式转换到另一种格式，改变时区，等等。
既然你已经决定阅读这篇文章，那么我们为什么不停止浪费时间交谈，并立即开始学习呢？
1.将字符串转换为日期
尽管是工程师，我们仍然花相当多的时间使用自然语言交谈。
既然如此，我们也可以将看起来像自然短语的字符串转换成日期，如下所示:
在本例中:
- %d —表示一个月中的某一天，如 21、22、23 等。
- %B —表示月份的实际名称，如一月、二月、三月等。
- % Y-代表年份，如 2020、2021 等。
2.从一个时区转换到另一个时区
由于这些天我们大部分时间都在远程工作，我们可能也有机会和在另一个时区的人一起工作。
你当然可以谷歌一下，找出纽约市现在的时间，即使你以前从未去过，但是你自己去实现它也是一种乐趣。
让我们看看如何做到这一点。
3.找出两个日期之间的天数
由于我们仍然生活在这个时间流逝的宇宙中，我们可能需要找到从一点到另一点之间已经过去的天数。
我们当然可以拉一个日历，手动算日子，又慢又无聊。
为了快速做到这一点，我们可以在 Python 脚本中导入日期模块，并初步准备日期:
之后，我们基本上可以找到两个数字的区别:
是的，就这么简单。
您不必花费数小时在物理日历上手动完成。像这样做只需要几分钟。
4.向日期添加天数
让我们假设您正在开发一个产品的特性，其中一个用户的订阅从现在起 90 天后到期。您希望使用以下命令将该日期保存在数据库中:
5.向日期添加周数
您也可以将其更改为周，如下所示:
6.从日期中减去天数
你有没有想过回到过去，改善你生活中的一些事情，与你爱的人呆在一起，或者干脆早一点开始投资比特币？
嗯，我希望我能告诉你怎么做。
但是，如果您想查找过去的某个日期，比如说从现在起 180 天后，您可以使用以下内容轻松完成:
7.从日期中减去周数
你可能已经猜到了，你也可以通过减去星期来找到一个日期:
8.找出月份中两个日期的差异
我们也可以很快地找出这两个日期在几个月内的差异。
我们应该记住，我们可能有不同年份的日期，仅仅认为我们可以减去两个月是不够的。
例如，在 2018 年 10 月和 2021 年 11 月之间，不仅仅是一个月的差异。在年龄上也有差别。
9.把日子放在月份之前
世界上大多数国家在日期中将日期放在月份的前面:
图像:约翰·哈丁/蒙娜·沙拉比摄影:约翰·哈丁/蒙娜·沙拉比
但是，也有这样的情况，当您输入一个日期时，月份在日期的前面。
如果您想将这些日期转换成世界上大多数人使用的格式，以下是方法:
10.查找一个月的第一天
在一些公司，他们每个月的第一天给员工发工资。
如果您想知道那天是星期几，下面这个片段会很有帮助:
差不多就是这样。我希望你至少从这篇文章中学到了一些东西。
关于机器学习的 10 个真实事实
不是劝阻你学习，而是给你指明真正的道路
艾拉·德·克罗斯在 Unsplash 上拍摄的照片
机器学习的想法很久以前就提出来了。然而，机器学习的出现是最近才发生的。有两件事促成了机器学习的出现:不断增长的数据洪流和广泛可用的计算资源。
如今，机器学习是一个趋势性的话题。甚至软件工程师也开始研究机器学习，原因很大:机器学习完全是关于数据驱动的编程，在大多数情况下它可以取代传统编程。
由于机器学习的流行，大多数人都在尝试学习它。没有人想找到机器学习的真正真相。因此，在这篇文章中，我决定讨论关于机器学习的 10 个真实事实。写这个帖子的主要意图不是劝阻你学习，而是给你展示真正的道路。因此，专注于这里讨论的事情将帮助你找到正确的学习道路，并帮助你获得你梦想的机器学习相关的工作。
真相 1:数据科学家和机器学习工程师花费 60–70%的时间来解决数据质量问题。
真实世界的数据是混乱的。它们不像可从 Kaggle 或任何其他平台下载的预处理数据集。每个真实世界的数据集都是不同的，都有特定的数据质量问题。解决这些问题需要特定领域的知识。解决数据质量问题涉及处理缺失值、异常值检测、编码分类变量等。处理缺失值是数据科学家最耗时的部分。离群点检测涉及到很多领域知识。如果我们检测到一个异常值，我们下一步应该做什么？我们应该移除它吗？我们应该保留它吗？或者我们应该用一个相关的值来代替它？这取决于特定分析问题的领域知识。一个离群值背后可能有一个有趣的故事。你需要熟悉你试图解决的问题的领域知识。因此，解决数据质量问题需要大量时间。
关键要点:在做机器学习时，只需专注于处理缺失值、离群点检测、变量编码和获取问题的领域知识。这样做会帮助你获得你梦想中的机器学习相关的工作。
真相二:机器学习工程师不会把时间花在超参数调优上。
超参数调整只能少量提高模型性能。自动选项如网格搜索或随机搜索也可用于超参数调谐。这些选项避免了编写许多 for 循环，节省了时间。机器学习工程师不是专注于超参数调整，而是专注于解决数据质量问题。这是因为数据质量问题可能会终止他们的项目！
关键要点:在进行机器学习时，只需专注于解决数据质量问题。当您想要执行超参数调整时，请始终使用自动化选项，如网格搜索或随机搜索。
真相三:建模不是一次性的工作。这是一个反复的过程。
你不能马上建立一个好的模型。模型的建立不是一次性的任务。您会发现自己总是在构建一个更好的模型的各个步骤之间走来走去，这个模型捕捉到了数据中的大量可变性。首先，您可以构建一个基础模型，用于与其他模型进行比较。然后，您可以尝试一些超参数调优技术，并测量模型性能。您也可以应用一些降维方法，然后再次训练您的模型。所以，建模是一个迭代的过程。
真相 4:超参数调整在无监督学习中是一个真正的挑战。
在标签(基础真值)不可用的无监督学习中，很难测量模型的性能。因此，超参数调整在无监督学习中是一个真正的挑战。您可以尝试超参数的不同值，并获得可视化表示来验证您的选择。有时，问题的领域知识将帮助您推导出超参数的正确值。
真相 5:自动机器学习(AutoML)无法取代数据科学家。
AutoML 只是为了让数据科学家的事情变得更简单，比如协助他们完成枯燥的重复性任务，节省他们的宝贵时间，协助他们进行代码维护和一致性等！它无法取代数据科学家。 领域知识的需要 和 无监督学习中未标记数据的存在 避免了机器学习中的完全自动化过程。
要点:之前，我发表过一篇关于 AutoML 的文章。你可以阅读它来找到更多的信息。以下是链接:
[## AutoML 不会取代你的数据科学职业
towardsdatascience.com](/automl-will-not-replace-your-data-science-profession-52753a4a53ed)
真相 6: Scikit-learn 机器学习模型在业界的应用没有 TensorFlow 广泛。
即使在 Scikit-learn 估计器中有更高的一致性，它们也没有在行业中广泛使用。Scikit-learn 中的神经网络实现不够体面。Scikit-learn 不支持 GPU。Scikit-learn 中的其他算法很容易被 XGBoost 等库超越。XGBoost 的 Scikit-learn 包装器也是可用的。但是，对于大型数据集，它的实现速度很慢。相比之下，TensorFlow 为神经网络提供了不错的选择。
关键要点:如果你是机器学习新手，我推荐你先学习 Scikit-learn。这将为你的学习之路打下坚实的基础。然后，尝试学习 TensorFlow 库。以下是开始使用 Scikit-learn 的方法(由我编写):
</9-guidelines-to-master-scikit-learn-without-giving-up-in-the-middle-5102863d89d7>
真相 7:数据科学家不需要知道机器学习算法的内在数学。
虽然要求每个算法背后都有直觉，但数据科学家不需要知道算法的内在数学。他们只需要知道哪种算法最有助于完成给定的任务，以及如何应用该算法。除此之外，他们还需要知道算法接受什么格式的数据作为输入，返回什么格式的数据作为输出。他们还需要知道参数变化如何影响模型性能。了解算法的内部数学将是一个额外的优势，但这不是必需的。
真相 8:机器学习中 R 和 Python 之间没有明确的赢家。
你已经知道 R 和 Python 是数据科学和机器学习中使用最多的两种编程语言。每种语言都有自己的优点和缺点。两者都为数据分析、数据操作和机器学习任务提供了大量的高端库。没有明确的赢家。根据您的项目需求，您可能会得到这两者的帮助。但是，我个人更喜欢 Python，因为它的语法清晰易懂。
真相 9:机器学习工程师的顶级技能是 SQL。
由于 70%的机器学习都是数据角力，所以 SQL 是一个机器学习工程师的顶级技能。您甚至可以在 SQL 服务器中执行 Python 和 R 脚本。如果你搜索任何与机器学习工程师相关的工作，你可以看到 SQL 是主要要求之一。
真相 10:现实世界的机器学习模型不是建立在笔记本电脑上的。
您通常熟悉在笔记本电脑上构建机器学习模型。然而，在现实世界的应用中，情况并非如此。使用您的笔记本电脑制作模型原型或练习构建模型不成问题。您还应该熟悉模型与实际应用程序的集成和扩展过程。
感谢阅读！
在https://rukshanpramoditha.medium.com阅读我的其他文章
除封面图片外的所有图片、其他内容链接和文字内容均为作者版权所有。特别要感谢的是 Unsplash 上的艾拉·德·克罗斯，她是封面图片的所有者。非常感谢， Ella de Kross ，为我在本帖中提供了一张优秀的封面图片！
2021–05–30
如果你是学生，你应该申请的 10 个远程 2021/2022 数据科学实习
获得现实生活经验，开始你的职业生涯。
作为一名几乎一生都在学校的学生，我总是觉得我们在学校里学到的知识是理论性的。每当我和在这个行业工作或在大学之外有一些经历的朋友和同事交谈时，这种感觉只会增长。我们在学位中学到的东西和我们成功和建立职业生涯实际需要的东西之间的差距是任何学生都需要实习的原因之一。
尽管实习对任何学生来说都很重要，不管他们的专业是什么，但如果你是一名科技领域的学生，实习就更重要了。在技术方面，我们学习一个领域的历史，我们可以使用的工具，以及一些领域的应用。但是，大学课程永远不足以建立一个现实生活中的经验，这将有助于你毕业后开始职业生涯。
在这里，实习有所作为，不仅仅是帮助学生获得经验，知道毕业后找到工作后会有什么期待。不过，这也有助于他们决定获得学位后想从事什么职业。因此，如果你是一名学生，本科生或研究生，试图获得实习机会，这肯定会改变你对自己领域的看法，并有助于你以后找到工作。
每年九月，全球的公司都会开放下一年夏天的申请。所以，今天，我将带你浏览一下 2021 年秋季或 2022 年夏季的 10 个远程实习机会，你现在就可以申请。
№1: Quora 软件工程师——机器学习实习生 2022
我们名单上的第一个是由 Quora 提供的机器学习实习。在这次实习中，你将致力于改进 Quora 现有的机器学习系统，改善用户体验，并与其他机器学习工程师合作，高效地实现不同的算法和系统。要申请这份实习工作，你需要是一名了解机器学习基础知识、有 Python 或 C++经验的学生。
№2: Moyyn 机器学习| AI 实习
接下来是由 Moyyn 提供的 3 或 6 个月的机器学习和人工智能实习。Moyyn 是一个总部位于德国的招聘平台，专注于自动匹配候选人和公司。这个实习将让你研究平台的算法，同时测试算法并优化它。要申请这份实习工作，你需要是一名学生，并且知道 NLP、机器学习和 AI 基础知识。
№3: IBM 数据科学与工程实习
接下来是 IBM 提供的数据科学实习。这个远程机会对欧洲或美国的学生开放，国际申请人也有机会。申请这份实习工作，需要具备中级 Python 技能和 NLP 知识，有扎实的数据结构基础，英语流利。
</10-newsletters-you-need-to-subscribe-to-as-a-data-scientist-d12c7f33fbab>
№4: Woohoo 机器学习实习
新加坡的 Woohoo 为拥有计算机科学、分布式系统知识和软件工程硕士学位的学生提供这种远程实习。你还需要有构建、维护和扩展网络规模生产系统的经验，以及执行 AB 测试和机器学习算法的知识。
№5: Workiva 数据科学实习
Workiva 为任何居住在美国或拥有美国工作许可证的人提供远程实习机会。在实习期间，您将参与发现、收集和探索性数据分析，并帮助机器学习工程师设计、开发和优化他们的数据管道并测试大规模模型。
№6: HackerRank 软件工程师实习
如果你住在印度，接下来是来自 HackerRank 的远程实习。如果你喜欢写代码，并与世界各地的其他开发人员和工程师联系，那么这就是你的实习机会。申请这份实习工作，你需要解决 3 个测试挑战，并提交简历；就是这样。
№7: Snackpass 数据科学实习
总部位于美国的点餐和就餐应用 Snackpass 提供这种远程实习，在这里你可以帮助回答推广餐馆的重要商业问题。为数百名用户设计和构建机器学习模型，针对不同的用例测试和优化这些模型。
</5-books-to-help-you-master-the-pandas-library-acb5c305159b>
№8: 1Qbit 机器学习研究员实习
如果你对机器学习感兴趣，并且对量子计算感兴趣，那么这个在 1QBit 的实习对你来说是理想的。这 8 个月的远程实习将允许您利用您的机器学习背景来解决量子和经典方面的挑战性行业问题，并利用您的知识开发新的工具和计算能力。
№9: Shopify 数据科学实习
Shopify 让开设自己的私人企业变得像在网上购买产品一样简单。Shopify 提供了一个实习，在那里你可以建立机器学习模型，增强 Shopify 的智能，并帮助人们对他们的业务做出更好的决策。您还将有机会为开源社区做出贡献，并建立持久的联系。
№10: VidMob 数据科学/ ML 实习
接下来是由 VidMob 提供的数据科学和机器学习实习，在这里你可以将你在定量分析、机器学习和数据可视化方面的专业知识应用于现实生活中的问题。您还可以分析不同模型的结果，以更好地了解它们的性能并进一步改进它。
外卖食品
无论你上学是为了什么学位，我们在大学里学到的东西和我们毕业后开始找工作后实际要做的事情之间总是有差距的。不仅如此，通常，在我们毕业并开始经历求职噩梦之后——不过你最好在毕业之前开始——我们会意识到，我们甚至没有获得一个完整级别职位所需的经验。
</6-best-python-ides-and-text-editors-for-data-science-applications-6986c4522e61> [## 数据科学应用的 6 个最佳 Python IDEs 和文本编辑器
towardsdatascience.com](/6-best-python-ides-and-text-editors-for-data-science-applications-6986c4522e61)
值得庆幸的是，我们可以通过尝试在一家公司实习来获得我们需要的经验，并在这个过程中赚一些钱。通常大多数公司会在暑假期间开放实习机会，申请这些实习机会会在前一年的秋季开放。所以，基本上，现在是开始寻找和申请明年暑期实习的理想时机。
自从 covid 袭击以来，我们生活的各个方面都受到了干扰，包括申请国外实习的机会。然而，正因为如此，许多公司现在都允许远程实习的机会，如果明年夏天之前情况有所好转，还有可能亲自实习。
在这篇文章中，我提出了今年秋天或明年夏天的 10 个实习机会，你可以今天就申请，以获得毕业后找到理想工作所需的经验。祝你好运…
你应该马上开始使用的 10 个秘密场景
这是我从一个画面专家那里学到的…
图片由来自 AdobeStock 的 I ssaronow 提供
如果你对可视化分析感兴趣，你可能听说过 Tableau，这是一个突破性的数据可视化软件，现在大多数数据分析和数据科学角色都需要它。
我最近有机会与 Tableau 专业服务公司的一位高级顾问一起工作，我不得不说，这次经历确实使我的 Tableau 技能达到了一个新的水平(鉴于我是 Tableau 自学者)。
Tableau 的强大之处在于它的易用性。只需几次点击，您就可以拖放不同的数据字段来创建您的视图。正如所有其他工具一样，探索和掌握所有 Tableau 功能需要时间，但通过这篇文章，我旨在解释 10 个技巧和窍门，它们将帮助您及时构建引人注目的仪表板。
如果你喜欢这篇文章的视频格式，一定要在我的 YouTube 频道查看。
1.从您的提取文件。twbx 工作簿
你知道吗？twbx 扩展名其实是一种压缩的压缩文件？像任何压缩文档一样，您可以提取其中的文件。如果您想要检索用作数据源的表格、图标或嵌入到打包工作簿中的任何其他外部文件，这可能会非常有用。为此，只需将工作簿的扩展名从"。twbx "到" .twbx.zip "。右键单击该文件，并单击提取选项，您现在将看到。twb 文件、包含数据源文件的文件夹以及外部缓存中的任何其他文档。
作者图片
2.连接到另一个工作簿上的数据源
您知道可以从不同的 Tableau 工作簿中获取数据源吗？您无需在现有工作簿中重新创建数据源，只需点击顶栏上的创建新数据源，转到更多，导航到您机器上的特定工作簿，Tableau 将列出您可以连接到的该工作簿的数据源。
作者图片
3.从 Excel 中快速复制和粘贴数据
如果您需要执行快速分析或数据调查，您只需从 Excel 电子表格中复制您感兴趣的单元格，打开 Tableau 工作表，只需单击顶部栏中的文件，然后单击粘贴(您也可以使用常用的快捷键 Ctrl/Command + V)，瞧，只需几次点击，您的数据就准备好了！
作者图片
4.将工作表从一个工作簿复制并粘贴到另一个工作簿
这也非常简单，可以节省你大量的时间。要做到这一点，右键单击一个工作表，然后单击复制，转到另一个工作簿，再次右键单击，然后粘贴。这实际上会带来工作表及其数据源，这将再次允许重用您以前的工作！
作者图片
5.只需点击几下鼠标，即可从多个工作表中删除过滤器
假设您正在处理多个工作表，并且对所有工作表都应用了筛选器。现在，您希望在所有不同的视图中删除作为过滤器的字段。有一种方法可以做到这一点，不需要打开每个工作表，也不需要手动删除过滤器。只需转到其中一个工作表，右键单击过滤器，选择应用到工作表，然后选择全部使用该数据源。这将对连接到同一数据源的所有工作表应用该筛选。然后您可以从筛选器面板中删除该字段，工作就完成了，这将自动删除所有其他工作表的筛选器！
作者图片
6.复制并粘贴工作表格式
设置工作表格式后，可以复制其格式设置并将其粘贴到其他工作表中。您可以复制的设置是您可以在格式窗格中设置的任何内容，参考线和注释除外。为此，选择要从中复制格式的工作表，右键单击工作表标签并选择复制格式。现在选择您想要粘贴格式的工作表，右键单击工作表标签并选择粘贴格式。这里有一个额外的提示:如果你想一次格式化不同的工作表，使用顶栏中的格式菜单，因为那些设置将应用于工作簿级别。
作者图片
7.给工具提示添加可视化效果
当我展示 Tableau 文件时，如果有一样东西总是让用户感到惊讶的话，那就是显示在仪表板中不同工作表的工具提示上的视图。如果您想显示特定图表的更多细节，而不必牺牲仪表板的空间，这是一个非常棒的功能。只需点击标记窗格中的工具提示，插入工作表，然后选择您想要添加的工作表。
作者图片
这还不止于此！Tableau 会根据你在仪表盘上看到的内容自动过滤工具提示。例如，在下图中，如果你将鼠标悬停在办公用品类别上，工具提示会显示办公用品的销售详情。
作者图片
8.使用这些快捷键
至少有 3 个快捷方式是我一直在使用的，并且我肯定会推荐使用的。
第一个是右键拖动(对于 Mac，Option+Drag)，它允许打开拖放字段窗口，准确地指定您想要添加到画布的内容。假设您想在行货架中添加字段利润的平均值。如果您简单地将文件添加到行中，Tableau 将向您显示字段 Profit 的总和，然后您需要右键单击该字段并选择您想要显示的计算。相反，如果你右击并拖动，Tableau 会先询问你想如何显示字段，这是一个很好的时间节省。
作者图片
Ctrl +拖动(Mac 为 Command +拖动)是在画布中复制药丸并粘贴到其他任何地方的快捷方式。这将再次让您节省大量时间，而不是再次搜索特定字段，重新创建计算或重新设置格式等。
作者图片
另一个很酷的快捷方式与您必须构建包含多个度量的文本表格有关。除了将字段度量名称添加到列架中，将字段度量值添加到标记窗格中，然后选择您感兴趣的字段，还有另一种快速的方法。只需将您的维度添加到列架，然后直接从字段窗格中双击您想要添加的所有度量。
作者图片
9。隐藏所有未使用的字段
我们很少有数据连接只有我们需要的数据。通常，我们最终得到的数据连接包含许多我们分析不需要的列。有许多因素会影响提取的性能，但是从提取中删除未使用的列会产生巨大的影响。当您完成工作簿并准备共享或发布它时，单击搜索栏旁边的小箭头并确保选择了隐藏所有未使用的字段。这样，Tableau 就不会在提取中包含那些字段，这确实可以提高性能！
作者图片
10.发布时覆盖现有工作簿
最后一个技巧与 Tableau 服务器更相关，这可能会让您的 Tableau 体验压力更小。当您处理同一工作簿的不同版本，并且准备将更新的文件发布到 Tableau 服务器时，我总是建议覆盖现有的工作簿，只需将它上传到相同的文件夹并使用相同的标题。这样，如果最新版本有问题，您可以使用修订历史 Tableau 服务器功能恢复先前版本，同时更正最新版本。如果您使用不同的名称和文件夹上传版本，此功能将不适用。考虑到这一点，您可以始终依赖以前的版本，不需要创建归档文件夹、备份文件或制定计划来应对上一份出版物出现的问题。
作者图片
这就对了。这些是我给你的 10 大桌面技巧。我希望你能找到一些新的东西，并帮助你从 Tableau 中获得最大收益！
请务必联系我，告诉我你所有的建议和意见。
感谢阅读！
如果你喜欢这个内容，一定要看看我的 YouTube 频道下面的了解更多！
https://www.youtube.com/@loresowhat
成功数据科学家的 10 项技能
要成为一名优秀的数据科学家，不仅仅需要知道如何编程。
路易斯·基根在 Unsplash 上的照片
转行或者开始新的职业，往往是一段令人困惑的旅程；这是因为，在开始的时候，你通常没有足够的领域知识，也不知道做好它需要什么。如果你试图掌握的领域涉及跨学科的技能，这将变得更具挑战性。
这一领域的一个很好的例子是数据科学。数据科学基本上是一个建立在其他知识基础上的计算机科学领域，这些知识基础不一定是计算机科学的一部分。因此，要成为一名数据科学家，你需要增长编程和数学以外的知识。
这些知识实际上成为了在这个领域取得成功并最终获得你梦想中的工作的必要条件。因此，我们可以将这些技能视为成为一名成功的数据科学家所需的软技能。本文将介绍每个数据科学家为了成功的职业生涯所需要的 10 项软技能。
尽管所有这些技能都是必不可少的，但它们的重要程度因你的具体角色职责和当前项目的性质而异。
№1:有一颗好奇的心
如果你正在考虑从事数据科学方面的职业，我将从我认为最重要的技能开始这个列表，那就是好奇心。数据科学可以定义为塑造、转换和讲述由某一组数据讲述的故事的过程。
作为一名数据科学家，你需要经常质疑为什么某些事情会发生；您将需要知道为什么有些事件对数据的影响比其他事件更大，您将需要问许多关于您的数据及其行为的问题以完全理解它，并能够利用它来预测未来的数据并做出正确的决策。求知欲是所有这些问题背后的驱动力，并寻找它们各自的答案。
№2:沟通技巧
通常，当数据科学家被赋予一个新项目时，他们需要与客户或经理就项目的需求以及项目的最终目标进行沟通。因此，一个基本的技能是知道如何问正确的问题，并制定你的问题陈述。
良好的沟通技巧的重要性超越了项目的最初阶段；在项目结束时，你需要向你的客户或经理展示和交流你的发现。您的发现将用于为未来步骤做出决策，而您传达这些发现的方式将是做出正确或错误未来决策的决定性因素。
№3:讲故事
建立在前面的技巧之上的是讲故事。我已经写了很多关于使用可视化来更有效地讲故事和以更简单的方式更准确地交流你的发现的文章。数据科学就是讲述数据的故事。但是，你讲述这个故事的方式有很大的不同。
如果数据科学家是一个善于讲故事的人，他们可以以连贯和易于理解的方式传达他们的发现，这是一个重要的方面，因为不是所有人都会以相同的技术知识介绍他们的发现。因此，致力于讲故事可以让你和你的工作在数据科学社区脱颖而出。
第四:适应性
如果你在任何技术领域，尤其是数据科学领域，需要发展的一项重要技能是你适应变化和新工具的能力。数据科学是一个正在发展的领域；研究人员定期开发新的工具、算法和方法。因此，作为一名数据科学家，您需要随时准备使用新工具或新技术。
适应性包括其他较小的技能，比如在足够的时间内学习一种新工具，并将你的知识转移和应用到新的或不同的技术或风格中的能力。此外，你需要能够应对该领域不断变化的趋势。
</4-data-visualization-tools-to-transform-your-data-storytelling-e2c6fb6de8ba>
№5:商业焦点
大多数时候，来自任何数据科学项目的发现都被用于制定业务决策。因此，数据科学家需要对业务模型、它们如何工作以及客户或管理层为这个特定项目考虑的趋势范围有一个坚实的基本理解。
这项技能可能是我最不喜欢的数据科学方面，但它仍然是需要获得的基本知识。了解公司的模式、他们的视角和他们的客户群可以帮助你在分析和建模数据时做出正确的决策。
№6:批判性思维
另一项重要的技能是批判性思维，不管你从事哪个特定的技术领域。批判性思维允许数据科学家客观地思考和处理他们的分析。它使他们能够正确地构建问题，并对他们使用的算法以及他们将如何使整个项目受益做出正确的决定。
批判性思维将使数据科学家能够超越明显的趋势和异常，更仔细地观察数据及其试图传达的信息。它还减少甚至消除了项目最终结果的偏差。
</9-comprehensive-cheat-sheets-for-data-science-46005d72b485>
№7:结构化思维
数据科学中另一种重要的思维方式是结构化思维。当你第一次接受一个项目时，它可能看起来很复杂而且不可能。这就是为什么数据科学家需要知道如何将一个大问题分成更小、更易管理的部分。
能够将一个大问题分成更小的子问题需要结构化的思维。这项技能将帮助你及时有效地完成你的项目。所以，花些时间在这项技能上，将会在未来为你节省很多时间和精力。
第八名:伦理
当你决定进入数据科学领域时，你可能面临的最大问题之一是数据伦理。作为一名数据科学家，您将接触到一些机密的、有时是敏感的用户信息。您将需要使用这些信息来构建和开发您的模型。
但是，仅仅因为数据可以被收集并不意味着你应该收集它并随后使用它。问题是，在有些情况下，决策并不那么明确或容易做出。因此，解释你的选择和你为什么做出选择的能力，将使你更容易证明你的工作的价值，以及这些决定是如何基于道德准则做出的。
</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)
№9:热爱学习
正如我们之前讨论的，数据科学是一个正在发展的领域。定期开发新的技术和方法。因此，作为一名数据科学家，你需要始终处于学习模式，对学习新事物的热情将在这条职业道路上对你有很大帮助。
对学习的热情与好奇的头脑密不可分，它们共同为帮助您成为更好的数据科学家做出了巨大贡献。另一个连接技能是学习如何有效地学习。作为一名数据科学家，你需要获得的知识量可能会非常大，因此知道如何应用以前的知识来更快地学习新知识可以在你的职业生涯中产生很大的影响。
№10: 协同
我们清单上的最后一项技能是协作或团队合作的能力。当你是一名数据科学家时，你可能是团队的一员，每个人都在项目的一个特定方面工作。你将需要协作，有时与其他团队合作，以获得反馈，可能的解决方案，并建立一个可靠的项目。
你有时还需要在其他团队成员的工作基础上再接再厉，因此你需要知道如何与他人合作，以及如何在他人的工作基础上再接再厉。这项技能也与良好高效的沟通技巧相关。
最后的想法
如果你正在考虑成为一名数据科学家，或者只是想努力提高自己，你可以列出一份成为一名好的或者更好的数据科学家所需的技能清单。这个列表很可能包含两种类型的技能，技术技能和软技能。
也许当涉及到数据科学这样的技术领域时，猜测或陈述所需的技术技能根本不是一件困难的事情。即使你对这个领域不是很熟悉，你也可以猜测你需要某种编程和数学知识才能进入这个领域。
</6-best-python-ides-and-text-editors-for-data-science-applications-6986c4522e61> [## 数据科学应用的 6 个最佳 Python IDEs 和文本编辑器
towardsdatascience.com](/6-best-python-ides-and-text-editors-for-data-science-applications-6986c4522e61)
当我们讨论软技能时，挑战就出现了。因为数据科学是一个非常跨学科的领域，所需的软技能可能不会直接达到。在本文中，我们探讨了 10 个这样的软技能，它们可以让你成为更好的数据科学家，并帮助你获得应有的职业成功。
数据科学面试中你应该知道的 10 个统计概念
学习聪明，不努力。
pch.vector 创建的业务向量—www.freepik.com
介绍
统计有时真的让人不知所措，这并不奇怪，因为统计已经存在了几千年了！
然而，当谈到数据科学面试时，面试官只测试了这么多概念。在经历了成百上千的数据科学面试问题后，我整理了最常出现的 10 个统计学概念。
在这篇文章中，我将回顾这 10 个概念，它们都是关于什么的，以及它们为什么如此重要。
说到这里，我们开始吧！
1) P 值
p 值最专业、最精确的定义是，它是获得与零假设同样极端或更极端结果的概率。
仔细想想，这是有道理的。实际上，如果 p 值小于α值，比如说 0.05，那么我们说这个结果偶然发生的概率小于 5%。类似地，p 值为 0.05 相当于说“在 5%的时间里，我们会偶然看到这种情况。”
因此，如果最初的定义与你不符，请记住我上面给出的例子！
2)置信区间和假设检验
置信区间和假设检验有着非常密切的关系。置信区间建议未知参数的值的范围，然后与真实参数在建议范围内的置信水平相关联。置信区间在医学研究中通常非常重要，可以为研究人员的估计提供更有力的基础。
举例来说，置信区间可以显示为“10 +/- 0.5”或[9.5，10.5]。
假设检验是任何研究问题的基础，通常归结为试图证明一些事情不是偶然发生的。例如，你可以试着证明当滚动一种染料时，一个数字比其他数字更有可能出现。
3) Z 检验与 T 检验
理解 z-检验和 t-检验之间的区别以及如何和何时应该选择使用它们在统计学中是非常宝贵的。
一个 Z 检验是一个正态分布的假设检验，使用了一个 z 统计。当您知道总体方差或不知道总体方差但样本量很大时，可以使用 z 检验。
T 检验是一种假设检验，其 t 分布使用了 t 统计量。当不知道总体方差并且样本量很小时，可以使用 t 检验。
您可以查看下图，作为参考来指导您应该使用哪种测试:
作者创建的图像
4)线性回归及其假设
线性回归是用于对因变量和一个或多个自变量之间的关系进行建模的最基本的算法之一。简而言之，它包括找到代表两个或更多变量的“最佳拟合线”。
最佳拟合线是通过最小化点和最佳拟合线之间的平方距离找到的，这被称为最小化残差平方和。残差等于预测值减去实际值。
作者创建的图像
万一它还没有意义，考虑上面的图像。比较最佳拟合的绿线和红线，注意绿线的垂直线(残差)比红线大得多。这是有意义的，因为绿线离点太远了，根本不能很好地表示数据！
有四个与线性回归模型相关的假设:
- 线性:X 和 Y 的均值之间的关系是线性的。
- 同方差:残差的方差对于 x 的任意值都是相同的
- 独立性:观测值相互独立。
- 正态:对于 X 的任意固定值，Y 都是正态分布的。
5)逻辑回归
逻辑回归类似于线性回归，但用于模拟离散数量的结果的概率，通常为两个。例如，您可能希望根据年龄预测一个人是活着还是死了。
乍一看，逻辑回归听起来比线性回归复杂得多，但实际上只有一个额外的步骤。
首先，使用一个类似于线性回归最佳拟合直线方程的方程来计算分数。
额外的步骤是输入您之前在下面的 sigmoid 函数中计算的分数，以便您获得一个概率作为回报。这个概率可以转换成二进制输出，1 或 0。
为了找到初始方程的权重来计算分数，使用了像梯度下降或最大似然这样的方法。由于这超出了本文的范围，我就不多赘述了，但是现在您已经知道它是如何工作的了！
6)取样技术
有 5 种主要的数据采样方式:简单随机、系统、方便、整群和分层采样:
简单随机抽样
简单随机抽样要求使用随机生成的数字来选择一个样本。更具体地说，它最初需要一个抽样框架，一个群体所有成员的列表或数据库。然后，您可以使用 Excel 为每个元素随机生成一个数字，并获取您需要的前 n 个样本。
系统抽样
作者创建的图像
系统采样甚至更简单，只需从样品中取出一种元素，跳过预定的数量(n ),然后取出下一种元素。回到我们的例子，你可以选择列表中的第四个名字。
方便抽样
便利抽样从容易联系的群体中抽取样本，例如询问购物中心外的人。你只需要对你遇到的第一批人进行取样。这种技术通常被认为是不好的做法，因为您的数据可能会被视为偏见。
巢式抽样法
作者创建的图像
整群抽样从将一个群体分成组或者群开始。分层抽样的不同之处在于，每个聚类必须能够代表总体。然后，随机选择整个集群进行采样。
例如，如果一所小学有五个不同的八年级班级，可以使用整群随机抽样，例如，只选择一个班级作为样本。
分层抽样
作者创建的图像
分层随机抽样从将人群分成具有相似属性的组开始。然后从每组中随机抽取一个样本。这种方法用于确保群体中的不同部分得到平等的代表。举个例子，假设在一所学校进行了一项调查，以确定总体满意度。这里使用分层随机抽样来平等地代表每个系学生的意见可能是有意义的。
7)中心极限定理
中心极限定理是非常强大的——它指出样本均值的分布近似于正态分布。
举个例子，你可以从一个数据集中抽取一个样本，然后计算这个样本的平均值。一旦重复多次，你就可以把所有的平均值和它们的频率绘制到一个图表上，你会看到一个钟形曲线，也就是众所周知的正态分布，已经被创建出来了。
该分布的平均值将非常类似于原始数据的平均值。通过获取更大的数据样本和更多的总体样本，可以提高平均值的准确性并降低标准差。
8)组合和排列
组合和排列是从集合中选择对象以形成子集的两种略有不同的方式。排列会考虑子集的顺序，而组合则不会。
如果你从事网络安全、模式分析、运筹学等工作，组合和排列是非常重要的。让我们更详细地回顾一下这两者中的每一个:
排列
定义:n 个元素的排列是这 n 个元素按照确定的顺序的任意排列。有 n 个阶乘(n！)排列 n 个元素的方式。注意粗体字:顺序很重要！
一次取 r 的 n 个事物的排列数被定义为可以从 n 个不同元素中取出的 r 元组的数目，并且等于以下等式:
例题:一个 6 位数的车牌有多少种排列？
回答
组合
定义:从 n 个对象中选择 r 的方法的数量，其中顺序无关紧要。
一次取 r 个的 n 个事物的组合数被定义为具有 n 个元素的集合中具有 r 个元素的子集的数目，并且等于以下等式:
例题:从一副 52 张牌中抽出 6 张牌有多少种方法？
回答
请注意，这些都是非常非常简单的问题，可能会比这复杂得多，但是您应该很清楚上面的例子是如何工作的！
9)贝叶斯定理/条件概率
贝叶斯定理是一个条件概率陈述，本质上它着眼于一个事件(B)发生的概率，假设另一个事件(A)已经发生。
最受欢迎的机器学习算法之一 nave Bayes 就是建立在这两个概念之上的。此外，如果你进入在线机器学习领域，你很可能会使用贝叶斯方法。
贝叶斯定理方程
条件概率方程
10)概率分布
概率分布是一种在实验中找到不同可能结果的概率的简单方法。你应该了解许多不同的分布类型，但我推荐几个是正态分布、均匀分布和泊松分布。
正态分布
正态分布又称高斯分布，是一种钟形曲线，在很多分布中相当突出，包括人的身高、智商得分等。
正态分布的均值等于μ，方差等于σ。
泊松分布
泊松分布是一种离散分布，它给出了在固定时间内独立事件发生的概率。使用这种方法的一个例子是，如果您想确定在给定的一个小时内有 X 个病人来医院的可能性。
均值和方差都等于λ。
均匀分布
当所有结果的可能性相等时，使用均匀分布。例如，硬币具有均匀的分布以及染料。
感谢阅读！
仅此而已！我希望这对你的面试准备有所帮助，并祝你在未来的努力中好运。深刻理解这十个概念将为进一步学习数据科学和机器学习领域打下坚实的基础。
一如既往，我祝你在努力中一切顺利！
不确定接下来要读什么？我为你挑选了另一篇文章:
又一个！
特伦斯·申
通过数据科学带回家任务的 10 个步骤
确保包括以下内容，给你的面试官留下深刻印象
注意:虽然这篇文章是专门针对表格数据的任务的，但是这些步骤中的大部分也适用于非表格数据(即 NLP 或 CV 任务)。
Rich Tervet 在 Unsplash 上拍摄的照片
1.数据分析和可视化📈
这是显而易见的，这是数据科学家面对全新数据集时要经历的第一步。不幸的是，这一步没有模板，所以只要确保你的面试官能跟上你在做数据科学挑战时的思维过程就行了。你可能想要使用干净、漂亮的数据可视化来打动你的读者。
2.数据转换和特征工程🏗
这包括:
- 通过使用例如独热、目标、标签、计数或百分比编码来处理分类变量。使用
sklearn.pipeline.Pipeline将转换合并到一个管道中是一个好主意。请记住，将训练数据上训练的同一编码器或管道用于测试数据集！ - 重新采样，例如，如果数据集不平衡(例如，
y==1比y==0多得多)，则使用imblearn - 通过将日期转换成数字变量来处理日期。选择参考日期时要小心
- 特定数据集的特征工程技术。根据手头的数据集，创建您认为可能具有预测能力的要素。
3.训练最先进的预测模型
当涉及到表格数据时，梯度推进方法(或者可能是随机森林)通常被认为是最先进的分类器。目前，梯度增强的三种变体被广泛使用，在以下 Python 库中实现:
xgboostlightgbmcatboost
尽管每个数据集可能都不同，但从高层次上看，根据我的经验，当数据集有许多分类特征时，catboost的性能会更好，lightgbm的性能通常会稍差，但会快得多，xgboost的性能会很好，但通常会比lightgbm慢(尽管与其他一些方法相比非常快)。
记住也要为你的模型选择正确的度量标准。一个好的指标是 AUC，因为它是稳健的，并且考虑了特异性和敏感性。对于更具体的情况，将需要使用其他度量，这取决于误报和漏报的成本。
4.训练基本预测模型
如果您有时间，最好训练一个基本模型，如线性回归或逻辑回归，并证明性能差异是对更高级模型引入的复杂性的合理权衡。
5.使用交叉验证
这似乎是显而易见的，但请记住，当报告模型的性能或试图改进它时。特别是当在模型中进行小的、递增的改进时，具有足够数量的折叠和重复以将性能度量的波动降低到最小是有用的。
如果您使用目标编码，您可能还希望使用例如RepeatedKFold创建一个显式交叉验证循环，因为它可以让您完全控制包内数据集与包外数据集中发生的事情。
如果您想要进一步进行交叉验证，您可能想要运行几次，以查看您实际需要多少次折叠来获得模型性能的准确估计。
6.优化机器学习模型
通过为所讨论的数据集找到最佳超参数，可以实现模型的最佳性能。尽管存在经验法则，但数据集的特征(例如变量之间的交互程度)将决定最佳超参数是什么。以下三种方法通常用于超参数调整:
- 网格搜索:概念上简单但非常耗费资源，特别是在优化有大量超参数的算法时(比如
xgboost - 随机搜索:比网格搜索好很多次，但可能达不到最佳解
- 贝叶斯超参数优化:目前的最佳实践
作为超参数优化的当前最佳实践，推荐第三个选项。除了优化直接超参数之外，它还有一个重要的优势，即可以将其他变量视为超参数。例如，除了xgboost使用的超参数外，该方法还可用于确定
- 根据基数，对哪些变量进行单热编码，对哪些变量进行目标编码(这个参数在 catboost 中被命名为
onehot_max_size) - 给目标编码增加多少平滑度
- 在对一个类别进行目标编码之前，该类别中所需的最小记录量
贝叶斯优化通常分为三个步骤:
- 定义目标函数。这包括依赖于超参数的转换和交叉验证结果
- 定义超参数搜索空间，即从中采样的分布。
- 在指定的迭代次数(例如 1000 次)上运行优化
7.解释机器学习模型
通常使用三种模型可解释性的方法，由 Python 包Eli5、LIME和SHAP代表。目前SHAP被许多人认为是建立在表格数据上的模型的最佳实践。SHAP 有两个重要优势:
- 一致性:意味着我们可以比较模型之间的属性特征的重要性
- 准确性:我们可以将所有特征的重要性相加，以获得整个模型的重要性
全局特征重要性
用来解释模型的第一种方法通常是特征重要性。xgboost包有一个专用的方法，可以用来绘制每个变量的重要性。与为每个预测值生成一个系数的参数方法不同，有多种方法可以计算梯度增强的重要性。xgboost有三个选项:
- 权重:由变量在树中出现的次数给出
- 增益:因使用特定变量进行分割而获得的平均精度增益
- Cover :由受预测器影响的观察次数给出
尽管plot_importance中的默认选项是“重量”,但增益通常被认为是更好的衡量标准，并在下文中使用。
局部特征重要性
解释单个观测值的预测在很多时候是有用的。这对于调试模型以及向利益相关者解释单个客户的预测都很有用。例如，市场营销中的利益相关者，当他们知道为什么一个客户会以一种特定的方式被评分时，他们可能会对与客户沟通更有信心。shap库中的局部力图提供了一个很好的可视化效果(见下文)。红色因素是推动预测分数上升的因素，蓝色因素是拉低预测分数的因素。
8.使用 AWS 或 GCP —如果可能，使用☁️
如果这项工作需要云计算，并且您有时间，那么在您的提交中包含在云虚拟机上运行代码的脚本可能是一个好主意。
如果您收到的数据集很大并且训练需要很长时间，情况尤其如此。然而，即使不是这种情况，您仍然可以将 VM 用于资源密集型任务，例如超参数优化(如上所述)。
9.记录代码并使用 Git —如果可能的话
Git 可能不是所有数据科学工作的要求。然而，如果你申请的是一家软件公司，那么展示一下你会使用 git 并且在版本控制方面很自律也无妨。
10.包括单元测试—如果可能的话
特别是如果你申请的公司是科技类的，如果你也包括单元测试，你可能会得到加分——如果时间允许的话。Python 库将是一个不错的选择。即使你不能设法用单元测试覆盖你的所有代码，向公司展示你能够写出有弹性的、生产就绪的代码也是一个优势。
结论
取决于你有多少时间，你可能无法涵盖所有这些。不过，尽可能多的面试会让你给面试官留下深刻印象。以下是 10 个要点的清单:
- ✅展示了一些深刻分析
- ✅设计了一些巧妙的功能
- ✅训练了一个复杂模型
- ✅训练了一个简单的模型
- ✅，别忘了交叉验证！
- ✅优化模型超参数
- ✅解释这个模型
- ✅使用 AWS 或 GCP —如果可能的话
- ✅记录代码并使用 Git —如果可能的话
- ✅包括单元测试—如果可能的话
- 🎉协商工资💰
祝你好运！🤞
提升数据科学家影响力的 10 个策略
办公时间
来自学术界、自由职业者、创业公司和大公司的经验
像数据科学领域的许多其他专业人员一样，我是那些从做相关和有价值的事情的感觉中获得内在动力的人之一。我想让我的工作有所不同，让事情向前发展。然而，在我职业生涯的初期，当愿望与现实相遇时，我很快意识到我的技术知识在这里只能提供有限的帮助。因此，我将我的经验总结为 10 个策略，这些策略帮助我在过去几年作为数据科学家的工作中产生了更大的影响。
注意:这 10 个要点遵循基于数据科学产品生命周期的特定逻辑顺序，而不是按重要性或相关性排序。收集的内容主要基于我的科学生涯、作为自由职业者的各种咨询工作、在初创公司工作以及我目前在一家大型电子商务公司的职位的经验。因此，我的话自然没有完整性或普遍有效性。然而，我希望已经为尽可能多的人收集了一些有用的思考资料，并且很乐意听到你在这个话题上的经历！
1.创造和选择正确的想法
当然，好的想法是在以后的过程中做出有意义的贡献的基础。然而，我认为这一点比人们最初想象的要简单得多，也不那么重要。
为什么？因为有太多的工具和方法可以产生伟大的想法，复杂性更多的在于它们的选择和实现。几乎每个人都知道，当和朋友坐在酒吧里或者只是站在淋浴时，会有下一个 10 亿美元想法的感觉。但老实说，这通常不会产生真正的影响。这就是为什么我在这里关注一些实用的技巧，将你从一个梦想家变成一个实干家。；-)
- 比你的工作描述做得更多:有没有想过在仓库里做一名数据科学家，或者在你公司的呼叫中心实习？以我的经验来看，在你的办公桌边读论文时产生相关想法的概率，比你自己感受到同事的痛苦时要低得多。
- 寻找唾手可得的果实:最大的影响往往不是由一个同时有许多施工现场的复杂的新系统实现的，而是由一个具体的独立问题的简单解决方案实现的。如果问题太多面了，试着把它分解成核心要素，不要马上从整体上追逐大的想法。
- 从产品的角度考虑，而不是从临时分析的角度考虑:即使临时分析能够带来巨大的价值贡献，这通常也是短期的。为了真正持久的影响，你的分析或模型应该能够成为产品的一部分，如果可能的话，不需要太多努力就能产生更长期的被动价值主张。
- 一次专注于一个想法:当你正在构思一个有希望的想法时，不要试图立刻追逐每一个诱惑。
2.遵循以客户为中心的方法
有影响到底是什么意思？我没有把影响本身定义为目的，以便看到我的分析流入尽可能多的管理决策中，或者加入每个指导委员会。对我来说，影响是客户获得最大价值的时候。这里的客户一词既包括我公司产品或服务的最终客户，也包括内部客户，他们可以通过使用我的作品为最终客户创造更大的价值。
以客户为中心有助于日常工作流程，并有助于解决诸如“我做什么”“我如何做”等问题，以及在困难阶段“我为什么要做”等问题。
为了证明自己的工作对自己和他人的重要性，有必要在早期阶段定义如何衡量影响。这个问题在接下来的步骤中总是至关重要的，因此仔细考虑这个问题很重要。但有一个好消息:作为一名数据科学家，你非常适合思考关键数字、必要的数据采购和评估方法。；-)
但是请注意，在测量影响时，测量模型质量的典型数据科学方法可能会很快引入歧途。让我们以一个制造业的销售预测为例。假设你的任务是尽可能准确地预测在特定时间特定产品的销售量。现在你可能会想将你的预测与现实进行比较，以此作为衡量成功的标准。尽管这个值很重要，尤其是对于模型的优化，但是不能将它与开发的解决方案的实际影响混淆。
为此，必须提出其他问题，如“我们现在能更好地履行对客户的交付承诺吗？”或者“我们能否通过更精确的采购来降低库存成本？”。顺便说一句，你能粗略估计一下一个可能的解决方案的整体实施成本吗？
这些问题是面向客户的，甚至可能直接导致这样的结论:即使是完美的销售预测的附加值也不会像人们在想法产生之初所怀疑的那样大。或许在这种情况下，预测购买原材料最佳时间的模型的影响要大得多？
因此，为了增加你的影响力，你需要清楚你在优化什么/它能给你的客户带来什么。要做到这一点，彻底了解领域是至关重要的。为客户优化，而不是为任何型号指标优化。考虑尽可能好地反映这种好处的有意义的指标，并在早期培养“什么是足够好”的感觉。明显更好并不一定意味着更大的影响。这将帮助您以后不要过度优化，甚至优化完全错误的指标。
日常生活中的一个问题:
作为客户，您会为您的分析/产品付费吗？如果是，有多少，为什么？
在 Unsplash 上由 Austin Distel 拍摄的照片
3.试着反驳自己来获得自信
如今，许多公司的目标是采取数据驱动的行动，以避免直觉决策或不必要的讨论。这也应该是你作为数据科学家的工作目标。我们大多数人肯定都有过这样的感觉，不理智地抓住某样东西不放，因为那是我们自己的想法，或者因为我们自己的自我想为所欲为。尽管这种感觉是人之常情，但对它采取行动是有害的，因为你的时间受制于机会成本。如果你在一个低影响力的项目上工作，你就没有时间去做另一个高影响力的项目。
你在日常工作中的目标必须是让自己成为一个数据驱动的人(注意，只是就你在工作中的决策而言)。如果你预先定义的度量标准清楚地表明你的方法没有达到预期的效果，那么对这个想法的个人依恋永远不会阻止你放弃它。相反，应该高兴的是，你很早就意识到你的工作对其他地方有更大的影响。
杀死你的宝贝是至关重要的。
听起来容易做起来难。甚至基于你自己定义的客观标准，一次又一次地积极尝试反驳你的想法或你的想法的影响。是否有探索性分析的可能性或已经存在的其他/类似的实现使你的想法的影响无效？用你能想到的一切。这种从科学中得知的程序，试图一次又一次地根据实验和经验来推翻理论，应该成为第二天性。毕竟，科学家这个词在你的工作描述中……；-)
但是要小心！不要成为冒名顶替综合症的受害者。所以不要人为地贬低自己和自己的想法，也不要害怕捍卫自己的观点。相反，数据驱动的方法和不断尝试反驳你的想法会大大增加你对工作的信心和信念(如果值得的话)。做出数据驱动的决策意味着既不高估也不低估你的想法，而是对你的影响有一个现实的认识。
对于日常生活:
对自己诚实就好。
由 Jakayla Toney 在 Unsplash 上拍摄的照片
4.避免过度工程化
如果我们没有一点点热爱技术，我们可能不会成为数据科学家。就我个人而言，我发现计算机如何在没有直接的规则编程的情况下，突然根据过去的模式做出决定，这很有趣。在我看来，这种对技术的热爱永远不应该半途而废，当然也不应该是一件丢人的事情。
但是人们应该始终意识到这一点，并在正确的时间和正确的程度上使用这一特性。然而，为了最大限度地发挥一个想法的影响，尤其是在开始的时候，这种思维方式通常是一种阻碍。事实上，你的工作应该由这个问题驱动:“数据科学对此有必要吗？”或者“对于给定的问题，最简单的解决方案是什么？”。
也许确定的问题确实是高度相关的，但可以通过在现有应用程序的前端进行简单的调整来解决？如果要开发一个预测模型，它真的需要一种深度学习方法吗，或者具有可理解参数的线性回归已经足够了吗？如果更简单的方法也可以解决问题，它们通常会产生更大的影响，因为它们可以更快地实现，更不容易出错，并且更容易被其他利益相关者理解。
为了能够做出这样的评估，需要对数据科学领域之外的广泛技术理解。只有那些具有广博知识的人才能评估什么是最佳解决方案，或者，如果必要的话，结合不同领域的解决方案。因此，尽可能地跳出框框，例如，在软件工程和开发运维等领域。
对于日常生活:
不要以使用复杂的机器学习模型为荣，以不需要为荣。
尼古拉斯·托马斯在 Unsplash 上拍摄的照片
5.快速交付，少量交付，早期失败
这是我在创业公司工作期间的主要感悟。一个好主意太好了，不能花一年时间在地下室开发它，而完全忽视客户的需求。这也适用于您作为数据科学家的工作。比方说，你有一个需要使用预测模型的想法。如果你确信你的想法基于你的数据，然后寻找最快的方法进入实施，并建立第一个最小可行的产品(我们稍后会谈到概念验证陷阱；-)).
对此至关重要的是准确了解作为数据科学家的工具箱。例如，使用 Google AutoML，您可以用最少的努力获得一个已经可以接受的结果，以便根据第 2 部分的度量进一步验证您对影响的假设。您不必从超参数调整开始，就能感受到潜在的影响，并向自己和他人展示价值主张。
开发中使用的框架在这里也起着重要的作用。如果您知道如何从多个来源生成数据的初始样本，如何用一行 python 代码创建混淆矩阵，以及如何通过几个简单的步骤将列转换成正确的格式，那么您可以在最短的时间内轻松、全面地获得有意义的结果。每个 for 循环都应该是不必要复杂性的警告信号。特别是简单快速的实现需要高水平的专业知识和经验。对于日常使用，基本上假设硬问题已经被一个框架解决了。
资历的特点不一定是掌握复杂的问题，而是实现的简单性和可理解性。
非常重要的是:尽早从你的客户和/或同事那里获得反馈。这不断地确保了发展朝着正确的方向前进。让你的客户参与进来，多沟通，了解他们真正需要的是什么。同样，如果你意识到你在骑一匹死马，尽快离开。失败不是例外，而是规律。
乔恩·泰森在 Unsplash 上的照片
6.讲故事
数据科学建议中的经典…我很久以来一直在思考我是否应该将这一点纳入我的收集中，因为它是如此明显，被描述得如此频繁，并且从我的角度来看完全被高估了。
但是，我如何得出这个也许有些挑衅性的评价呢？每个人都知道这种感觉，你对某事如此着迷或兴奋，以至于你几乎不能停止谈论它。每个人都有过这样的感觉，他们不得不在大学或类似的地方为无聊的研讨会论文凭空捏造一些东西。我想说的是:
把一个好故事讲得很糟糕是极其困难的，而把一个坏故事讲好更是难上加难。
因此，当你开始展示你的想法、你的分析、你的数据驱动产品时，注意它是否很容易从你的嘴里说出，图形是否清晰明确，或者你是否无意识地试图展示一些比它更漂亮的东西。我相信，你不可能以一种糟糕的方式展示一个伟大的想法或精确的分析。
毫无疑问，你可以在蛋糕上加樱桃，但其他人已经想得够多了。内容永远是王道。千万不要用讲故事来蒙蔽自己和他人。在这里也要对自己诚实。
7.有团队精神和远见
我再怎么强调这一点也不为过。我们每个人一天只有 24 小时。这是不可扩展的，而且规模太小，无法产生真正大的影响。但是，这具体意味着什么呢？和你的团队一起工作就够了吗？在我看来，一个真正的好主意需要真正的战友。
你需要一个像你一样对这个主题充满热情的数据工程师，他甚至会在最后一个遗留数据库中搜索有用的输入因素。你需要一个前端开发人员，她已经将这个主题内在化了，以至于她可以在没有太多解释的情况下为一个演示建立一个合适的界面。根据公司的规模，你需要一个强大的同事和潜在内部客户网络，他们可以帮助你将想法公之于众，并在早期给你诚实的反馈。
影响力不是在一个人的办公桌上产生的。
你可以看到这是怎么回事。我称之为远见领导。你不需要一个正式的头衔来确认你是负责人。你只是点燃了你同事心中伟大想法的火焰。你越有信心，火就越容易燃烧，你的想法也就越有潜力发展。要做到这一点，总是依靠你的度量标准，看看这个课程是否仍然是正确的。这增强了你的信念，也增强了其他人做大事的信心。
不要纠结于具体的实现和你想法的具体组成部分。我们大多数人肯定也经历过这种情况:你想以你想象的方式实现你的想法。然而，这不一定是可取的，因为过于僵化的框架抑制了其他人积极参与想法的热情，从而削弱了结果。所有参与者都应该完全以期望的影响为导向。具体实现是次要的。因此，欣赏每一个想法和贡献，如果它服务于整体目标。
日常生活笔记:
争论和情绪不一定是一件坏事，但也可能是一种承诺的标志，是一种为值得奋斗的伟大事业而努力的感觉。
拉胡尔·布萨勒在 Unsplash 上的照片
8.关注执行和自动化
没有实施的想法是没有价值的。实施可能意味着在 Jupyter 笔记本的帮助下简洁地呈现一个特别的分析。然而，如果您专注于以数据科学产品的形式产生可持续的影响，那么在实施方面就会出现全新的问题，这超出了数据科学家的日常业务。MLOps 或 classic DevOps 等关键词以及软件工程原理在这里发挥了作用。
关于数据科学家是否应该关注模型和软件的整体运营，或者他们是否应该专注于他们能够产生最大影响的核心任务，这似乎是一场无休止的辩论。就我个人而言，我基本上赞成数据科学家必须集中处理他们的模型在生产系统中的部署和嵌入，或者至少对它有很好的理解。
模型开发和生产使用完全分离的后果是，在实验室条件下结果看起来很好，但在现实中很难集成到现有的目标系统中，或者无法满足某些服务级别协议，如最大响应时间。作为一名数据科学家，除了实际的模型优化之外，处理模型效率问题也是有意义的。例如，如何在不损害模型质量的情况下减少模型的大小，从而减少必要的响应时间？
根据公司的规模，您可能别无选择，只能熟悉必要的操作使用技术，以实现您自己的模型的真正影响。
没有可靠的操作，一个想法或最初的设计仍然停留在概念验证的陷阱中，其影响会消失，因为没有价值可以交付给客户。
因此，试着尽早找出你的想法可以在已经存在的 IT 环境中的什么地方停靠，以及这需要什么样的需求。不是每个应用程序都可以等待 REST API 的响应，也不是每个应用程序都可以直接导入 scikit-learn 管道。如果您知道这些条件，您就可以尽早地专门为它们开发您的代码、模型和基础设施，从而增加顺利操作的机会。
9.忠于你的产品
作为数据科学家，我们总是希望跟上最新的技术发展。在一定程度上，这确实是必要和有用的。然而，它绝不能导致一个想法一旦实施就不再受到关注的局面。恰恰相反。没有什么比与你的名字或团队相关的不可靠的生产系统更糟糕的了。
尤其是生产阶段应该得到你的特别照顾。
这个阶段的产品是你的旗舰产品和摇钱树，如果运行顺利，会给你研究和开发新事物的自由和合法性。
在实践中，这可能意味着花时间进行小的优化，使基础设施更加可靠，清理技术遗产或重构代码以增加可追溯性和可维护性。作为一个数据科学家，应该想到强化学习的原理。在探索和利用之间找到一个好的组合，以最大化你的整体长期影响。
虽然在这里用了很短的一段话来描述，但是这种方法对于确保你的工作真正可持续的相关性是至关重要的。
10.你们
好了，数据科学产品生命周期已完成，9 个策略…来吧，让我们把 10 个填满，让它听起来更好。不，如果有意义的话，我会把它留在 9 或 11，但我想再次明确强调一个重要因素。你。这一切背后的人。
追求影响力是一种个人特质，我认为这是我内在动力的驱动力。然而，应该清楚的是，影响本身不能成为自我的目的。当然，我们内心都有一个小小的声音，想要变得重要，想要被关注。但是记住更大的目标。你做这些事是为了什么？我不是说你的自我应该完全消失。如果我们对自己诚实的话，对我们大多数人来说，这可能是一个非常强大的动力。如果结果是一个充满激情的数据科学家做出了伟大的工作，我对此没有意见。但是自我不应该与更大的目标脱节。
问问你自己，你的自我是否仍然是做正确事情的驱动力，或者它本身是否已经成为目的。
所以，要意识到你的司机保持谦逊，把你的动力用于有意义的目的！
结论
这些是我作为数据科学家产生更大影响的 10 个策略。当然，这始终是一个快照，我期待着在未来收集更多的经验来添加或修改这个列表。
你对这个话题有什么建议、看法和体会？让我知道你对此的想法，或者你是如何设法增加你作为数据科学家或任何其他职位的影响力的。我很乐意从你的经历中学习。
10 个非常有用的基本 Python 函数
用这个令人兴奋的列表来复习你的标准模块库吧！
(图片由作者提供)
介绍
那些从事 Python 工作的人经常认为 Python 可能不是这里的主角——而是它辉煌的生态系统。通常，每当我们使用 Python 应用程序时，我们都会使用许多依赖项。Python 本身并不擅长任何事情，但是它出色的包为基础带来了功能。
每当我有这个讨论的时候，我经常会想到 NumPy 这个例子。虽然矩阵数学在普通 Python 中可能是可行的，但是使用 NumPy 会使它变得更好——甚至更快。也就是说，虽然 Python 开发人员似乎经常依赖外部工具来处理某些数据类型，尤其是数学上的工作，但 Python 语言确实有一些非常酷的技巧，使其对科学编程观众有吸引力。使用这些技巧，您可以减少依赖性，节省时间，并且通常会使 Python 编程语言的编程变得更加容易！下一次你想用 Pip 安装什么的时候，你也可以考虑一下标准库中可用的选项！
1:λ
不久前，我写了一篇文章，阐述了为什么我认为 Python 的 lambda 使其成为统计计算更可行的编程语言。此外，由于 Python 违反了一些更具限制性的面向对象规则，所以它能够非常函数化和声明性地进行操作——将对话引入 lambda，通过使用表达式求值而不是整个函数，可以将数学运算应用于任何数据类型。这可以用于编程更简单的东西，可能不需要一个完整的函数来命名。你甚至可以在全局范围内定义它们，因为它是 Python，通过在一种仍然具有类结构的语言中利用类似函数的语法和方法，将 Python 带到另一个科学层次。
虽然这个概念对某些人来说可能看起来有点小问题，但是利用它可以节省时间和内存，并且可以使您的代码看起来更加简洁。除了 lambda，由于返回是 Pythonic 表达式，我们还可以使用 apply()之类的方法在整个数据子集上快速应用表达式。不用说，对于一个数据科学家来说，这些操作非常方便，能够在一行中非常有效地完成它们使得我们在 Python 中的全局一切风格的编程变得容易得多！语法是这样的:我们首先设置一个等于 lambda 返回的值，后面是我们希望作为位置参数提供的变量。然后，我们使用提供参数作为变量来执行操作，例如平均值:
mean = lambda x : sum(x) / len(x)
现在我们可以像调用 Python 编程语言中的任何方法一样调用它:
x = [5, 10, 15, 20]
print(mean(x))
如果你想阅读更多关于 Lambda 的内容，为什么我喜欢它，以及如何使用它，我也写了另一篇关于它的文章。这篇文章的伟大之处在于，它深入地展示了 Lambda 可以在 Python 中使用的各种技巧。看看吧！：
№2:舒蒂尔
Pythonic 武库中最被低估的工具之一是 Shutil 模块。像这个列表中的其他模块一样，它包含在标准库中，可以像导入语言中的任何模块一样导入:
import shutil
那么舒蒂尔是做什么的呢？shutil 模块是 Python 编程语言的高级接口，用于操作系统上的文件系统。虽然这些调用通常是使用 os 模块进行的，但是 shutil 模块不太为人所知，我认为应该更多地使用它。您是否经常需要使用脚本将文件从一个目录快速移动到另一个目录，并且不得不做大量繁琐的工作来完成它？
Shutil 通过对一个常见问题的高级解决方案来解决文件和分配表的这些经典问题。即使与许多其他高级的、有时是戏剧性的声明式编程语言相比，这个解决方案也让它们相形见绌。对于您的所有开发-操作实现，这无疑是节省大量时间并使文件操作比其他方式快得多的关键。下面是 shutil 模块为一些基本文件操作提供的高级调用的一些示例:
**import** **shutil**
shutil.copyfile('mydatabase.db', 'archive.db')
shutil.move('/src/High.py', '/packages/High')
№3:全球
虽然 glob 模块可能不像 shutil 那样酷，或者在一般意义上不像 Lambda 那样对编程有用，但该模块在某些情况下仍然非常有用。glob 模块用于在目录中搜索通配符。这意味着它可以用来聚集关于存储在您的机器上的文件和文件扩展名的数据。当然，这个模块是按照您可能期望的方式导入的:
import glob
老实说，我不确定这个模块是否包含了一个以上的函数，但是这个函数非常常用于模块的确切用途。这个函数是 glob()函数。这个功能将采取任何典型的文件搜索。这包括使用 Unix 语法的文件搜索，例如*、/等。看看这个:
glob.glob('*.ipynb')
这将返回与 glob 搜索找到的文件相对应的文件名列表。这也可以用于聚合数据，或者用于处理存储数据的文件！
№4: argparse
argparse 模块提供了一种更健壮、更深入的方法来解析命令行参数。许多开发-操作工具利用了这一概念，因此可以从 Unix 命令行与它们进行交互。这对 Python 开发人员和数据科学家常用的许多开发-操作工具非常有用。一个很好的例子是 Python 模块 Gunicorn，它可以处理传递给 workers 的命令行参数和各种其他参数。和以前一样，必须导入该模块才能使用:
import argparse
为了使用这个模块，我们将构建一个新的类型，它将是一个参数解析器:
parser = argparse.ArgumentParser(prog = 'top',
description = 'Show top lines from the file')
现在我们使用 add an argument to 这个新的 reader 向解析器添加参数。对于这种情况，我们将创建一个参数，可以传递该参数来确定我们希望从每个文件中打印的行数:
parser.add_argument('-l', '--lines', type=int, default=10)
我添加了几个关键字参数，其中一个将提供我们期望为该参数传递的数据类型，另一个是在没有该参数的情况下调用文件时的默认值。现在，我们可以通过在新的参数解析器类型上调用 parse_args()函数来获取参数:
args = parser.parse_args()
现在我们可以调用这个 Python 文件进行编译，同时还可以从 Bash 轻松提供必要的参数。
python top.py --lines=5 examplefile.txt
不用说，这肯定会派上用场。我使用这个模块的一些值得注意的情况是在使用 Crontab 时，它可以在特定的 Unix 时间戳运行脚本。此外，这个脚本还可以用于管理员，管理员在没有用户作为工作人员在场的情况下运行 Bash 命令。如果您想了解更多关于 crontab 的信息，我有一整篇文章在这里讲述我为什么喜欢它:
此外，如果您想了解更多关于我用来部署 Pythonic 端点和网站的其他一些应用程序，我有一整篇文章详细介绍了 A-Z 部署，其中有一个自我训练的机器学习模型，您可以在这里查看:
https://medium.com/chifi-media/build-a-beautiful-model-that-trains-itself-the-easy-way-a0d31b611cee
№5: 导入 回复
到目前为止，在我今天讨论的所有工具中，re 模块是最被严重低估的。re 中的“R”和“E”是正则表达式的简称。re 模块用于解析带有正则表达式的字符串，并提供更多在 Python 中处理字符串的选项。你遇到过多少次基于 string 类拥有的函数(如 str.split())做出算法决策的情况？因为正则表达式要简单得多，也更容易使用！
import re
re 模块，不像列表中的其他模块，提供了许多非常有用的函数；特别是像科学家通常做的那样处理大量数据。也就是说，sub()和 findall()函数是两个可以帮助您入门的例子。
**import** **re**
re.findall(r'\bf[a-z]*', 'which foot or hand fell fastest')
['foot', 'fell', 'fastest']
re.sub(r'(\b[a-z]+) \1', r'\1', 'cat in the the hat')
'cat in the hat'
不用说，这对于处理这个世界上经常遇到的数据非常有用。
第六名:数学
好吧——听我说完。数学可能不是标准库历史上最伟大的模块，但它确实经常派上用场。对于科学计算来说，更是如此。数学模块可以访问从正弦和余弦到对数的所有内容。不用说，在处理算法时，所有这些都可以派上用场，而且许多包确实依赖于这个基本模块来完成许多事情。
import math
该模块通过使数学运算变得容易而不依赖，当然可以节省一些时间。在这个例子中，我将演示 log()函数，但是您可以更深入地研究这个模块，并发现一个数学能力的世界！
import math
math.log(1024, 2)
№7:统计学
对于科学计算来说，另一个几乎可以确定无疑的软件包是统计模块。这个模块提供了一些基本的统计数据，可能没有像 SciPy 这样深入，但是对于数据分析来说仍然足够了。虽然推理和贝叶斯统计可能不是本软件包的重点，但数学值(如平均值或标准偏差)可以告诉您许多有关您可能正在处理的数据的信息。我经常将这个模块别名为 st，但是我也看到它别名为 stc 或 sts，不要与 Scipy.stats 的常见别名 scs 混淆。
import statistics as st
这个模块提供了大量有用的功能，当然值得一试！这个包的伟大之处在于，无论您是否需要，它都将一直存在，并且不需要任何依赖。让我们来看一些基本的通用统计操作，这些操作很容易通过这个包提供:
import statistics as st
st.mean(data)
st.median(data)
st.variance(data)
№8: urllib
虽然这些包中有许多可能并不那么出名，但 urllib 模块肯定是这个规则的一个例外。该模块可用于处理许多常见的 web 相关任务，如请求。还是导入吧！
import urllib
通常，请求是数据科学家在依赖关系下做的事情。Flask 的请求模块也符合这一描述。这个模块是另一个常用的请求解决方案，比 urllib 提供了更多的功能，比如从 http 请求中请求查询参数的能力。也就是说，只要项目不需要这些额外的特性，使用标准库会很方便，对依赖性的担心也会少很多。
**from** **urllib.request** **import** urlopen**data = null
with** urlopen('http://example_url/') **as** response: data = response
虽然 urlopen 函数肯定是 urllib 的一个常见用法的很好的例子，但是在这个相对较小的包中有很多功能，在我看来，它绝对是一个值得学习的工具。
№9:日期
科学计算中另一个很常见的工具是日期-时间类型。数据通常会有时间戳，有时时间戳甚至是训练我们模型的预测特征。也就是说，对于数据科学家来说，处理日期和时间可能是一个相对重要的概念。我们可以完全按照您的预期导入日期-时间模块；看到这个模块别名为 dt 是很常见的，所以在这个例子中，我要做的就是:
import datetime as dt
现在，我们可以构造日期-时间类型，并使用典型的日期-时间语法处理年、月和日等属性。这对于重新格式化、解析和处理数据中的单个日期部分非常有用。让我们来看看这个包的一些基本功能:
import datetime as dt
now = dt.date.today()
print(now.year)
print(now.month)
№10: zlib
这个列表的最后一个竞争者是 zlib 模块。zlib 模块是一个使用 Python 编程语言压缩数据的全方位解决方案。这对于包分发来说很方便，特别是如果包分发是完全自动化的。Python 的一个优点是它可以被用作一个奇妙的自动化工具。也就是说，能够自动压缩一个 tarball，然后甚至将它发送到其他地方是一个非常有价值的资产。
import zlib
在 zlib 模块中，最重要的函数可能是 compress()和 decompress()。使用这些函数，我们实际上可以看到数据类型的压缩，使用下面的代码:
h = " Hello, it is me, you're friend Emmett!"print(len(h))
t = zlib.compress(h)
print(len(t))
z = decompress(t)
print(len(z))
结论
虽然在 Python 编程中经常看起来高度依赖依赖于依赖项，但是 Python 标准库中也有一些非常好的工具！通过为复杂的任务创建一个高级接口，这些工具中的许多可以很快地被用来节省大量的时间，这个接口是用编程语言本身打包的。这可以用来最小化服务器周围的依赖包、虚拟环境和一般混乱。此外，不需要 pip 安装任何软件包，因此这一举措节省了大量时间。
这些只是标准库中我最喜欢的模块中的一部分，然而还有更多！虽然这些模块肯定会派上用场，但我确信还有很多其他可用的软件包，它们会使许多编程操作变得更加容易。
我在 2021 年作为应用数据科学家探索的 10 项技术
来源:https://unsplash.com/photos/uCMKx2H1Y38
广告技术和深度学习的 ML
2021 年是我数据科学职业生涯技术技能发展的延续，重点是构建实时机器学习系统。虽然我去年开始构建生产级数据产品，正如我在 2020 年回顾中概述的那样，但今年我更加关注机器学习，重点是在生产工作流程中使用深度学习。今年，我的职称也发生了变化，这反映了我向应用科学家角色的转变，我将亲自动手构建高通量 ML 系统。
在深入研究我今年探索的技术列表之前，我想确定我在过去几年中在数据科学领域看到的两个趋势:
- 新领域中使用的自然语言处理方法
- 应用数据科学不仅仅使用 Python
我专注于在 2021 年建立广告技术，使用机器学习在这个领域建立高性能系统，并发现这个领域的系统借鉴了 NLP 研究的许多方法，我将在我的技术列表中提供更多细节。第二个趋势是，为了发布 ML 系统，应用数据科学家通常需要使用与服务于模型预测的部署相同的编程语言。虽然 Python 可以用来创作可以扩展到大量请求的 web 端点，但是工程团队可能使用不同的编程语言来服务 ML 模型。对 2021 年的我来说，这意味着学习 Golang，以便更紧密地与我们的 ML 工程团队合作，推出数据产品。
鉴于这些趋势，我专注于以下技术，以在 2021 年继续发展我的应用数据科学职业生涯:
- Go 编程语言
- AWS 上的 NoSQL
- 谷歌通用表达式语言(CEL)
- 流畅位
- 库贝特尔
- DataProc
- 分布式深度学习
- 线性模型的深度学习
- 特征嵌入
- Word2vec
对于列表中的每一项，我将讨论学习该技术的动机，并为建立熟练程度提供指导。
Go 编程语言
对我来说，2021 年最大的技术转变是学习 Golang，以便构建能够处理大量请求的 web 服务。我以前依赖 Java 编程语言来构建这些类型的系统，但是遇到了 Java 中使用的大规模线程模型的限制。对我来说，使用 Java 的最大问题是处理异步调用，比如给 NoSQL 的一家商店打电话。虽然现在 Java 对异步调用有了一些支持，但是用 Golang 编写这些类型的系统并让编程语言处理许多关于并发性的问题要容易得多。我还想学习 Golang，因为 Zynga 的许多团队现在都在使用 Go 来开发以前用 Java 编写的系统，接触 Golang 使我们的数据科学家能够直接与我们的工程团队合作来发布 ML 产品。
虽然学习 Golang 对于数据科学家来说是一项艰巨的任务，但有几种方法可以提高这门语言的熟练程度。我的方法是从在 Go 中构建小型 rest 端点开始，学习使用编程语言的基础知识。它还提供了使用struct数据类型解析 JSON 字符串的机会。一旦我能够启动并运行一个基本的端点，我就从 Redis 开始向端点添加一个 NoSQL 概要查找。我还利用了我过去用过的跨平台库，包括协议缓冲区，它可以用于 Java、Python 和 Go。接下来，我探索了用expvar进行日志记录，以使用我们现有的日志堆栈和 DataDog。然后我探索了一些用于 ML 模型推理的 Golang 模块，包括用于 LightGBM 实现的叶库。最终，我对编程语言有了足够的了解，可以开始用 Golang 设计 ML 系统。
对于初创公司的数据科学家和大型团队中的应用数据科学家来说，学习 Go 是非常好的，因为它可以帮助他们掌握生产系统的代码库。
AWS 上的 NoSQL
虽然 2020 年我的重点是 GCP，但 2021 年我主要使用 AWS 来部署系统，因为许多 Zynga 服务都在那里运行。我继续使用 Redis，但是从 GCP 管理的 MemoryStore 版本切换到 AWS 管理的 ElastiCache 版本。Redis 非常适合需要亚毫秒级读写的情况，但是缺乏对列管理和并发写的支持。在许多情况下，为 NoSQL 的商店探索诸如 DynamoDB 这样的产品是有用的，它比简单的键值存储提供了更多的灵活性。在一个项目中，我们使用 Redis 的协议缓冲区，并使用 Dynamo 为系统存储元数据。如果我们对项目有不同的延迟需求，我们可能会在系统的更多方面利用 Dynamo。
我对使用这些系统的建议是使用 Docker 来运行这些服务的本地实例。例如， dynamodb-local 使得运行本地实例进行开发变得很容易，这种方法可以用于 Python 和 Golang。
谷歌通用表达式语言(CEL)
我在 2021 年面临的挑战之一是在不同的运行时环境中处理训练模型和服务模型。在这种情况下，我们使用 PySpark 进行模型训练，使用 Golang 进行模型服务。虽然我们能够在两个运行时中使用 LightGBM 进行模型训练和模型推断，但是我们需要一种方法来确保在这些不同的环境中以一致的方式执行特性工程。
我们的方法是在 PySpark 和 Golang 中使用谷歌的通用表达式语言 (CEL)进行特征工程。CEL 程序是在运行时被翻译成高效程序表达式的小脚本。该脚本可以返回单个结果或结果列表。您可以将变量作为输入传递给脚本，输入也可以是协议缓冲区对象。因为我们已经在 PySpark 和 Golang 管道中使用协议缓冲区来存储配置文件信息，所以我们利用 CEL 程序将这些对象翻译成可以传递给 ML 库的特征向量。这种方法为探索不同的特性集提供了很大的灵活性，但是当我们的特性集增长到超过成千上万个特性时，这种方法就成了问题。
如果你对查看 CEL 感兴趣，我推荐你首先查看一下 CEL 规范，然后运行一个简单的脚本，使用一个语言实现，比如 cel-go 。
流畅位
流利位是我在 2021 年首次探索的另一项技术。它是一个日志处理器，用于将数据和指标传递到各个目的地，并且可以以各种新颖的方式使用。我们最终使用它将事件数据记录到 S3，与我过去所做的相比，这是完成这项任务的一种简单得多的方法。例如，为了记录 GCP 上的事件数据，我通常会写一个 PubSub 主题，然后在数据流管道中使用该主题，该管道将事件传输到 BigQuery 或云存储。有了 Fluent Bit，就有了一个直接将消息记录到 S3 的处理器，使得这个过程更加直接。一个警告是，消息将被写成 JSON 字符串，并且需要额外的 ETL 步骤来使数据在数据库中以结构化格式可用。
库贝特尔
当我在 2020 年使用 Kubernetes 部署 web 服务时，我依赖 GCP 控制台来执行许多部署任务，比如滚动更新。当我在 2021 年将重点转移到 AWS 时，我仍然使用 Kubernetes 进行部署，但开始使用 EKS 代替 GKE。这意味着重新学习如何执行基本任务，例如查看 pod 的日志输出，使用 Kubernetes control CLI (kubectl)而不是依赖于云提供商的控制台 UI。学习 kubectl 的一些基本命令是很有用的，因为它是跨 Kubernetes 的不同云产品的标准化 CLI。
我对使用这个工具的建议是在 GCP 上运行一个小型 GKE 集群，并尝试复制 kubectl 中的命令，您也可以通过 UI 执行这些命令。随着时间的推移，您可能会发现自己越来越不依赖控制台来检查 pod 和管理部署。
DataProc
虽然自 2018 年加入 Zynga 以来，我一直在使用 PySpark，但我一直使用 Databricks 平台来编写和部署 PySpark 工作流。2021 年，我需要在 GCP 上运行 PySpark 作业，并且没有 Databricks 作为运行作业的选项。我最终使用了 GCP 的 PySpark 集群专用解决方案 Cloud DataProc，类似于 AWS 上的 EMR。虽然 DataProc 为运行 PySpark 作业提供了一个健壮的平台，但是通过命令行界面而不是笔记本环境使用 PySpark 还有一点学习曲线。在集群上设置依赖关系还需要更多的手动步骤，比如 python 库。
对于数据科学家，我建议在使用 DataProc 或 EMR 之前，先在笔记本环境中体验一下 PySpark。我采用了一种渐进的方法来运行 spark 工作流的 DataProc。我的第一步是建立一个小型 DataProc 集群，并使用内置的 Jupyter 端点在笔记本环境中工作，并在笔记本中建立依赖关系。下一步是学习如何编写初始化动作脚本，以便在新集群上设置 Jar 依赖项和 Python 库。最后一步是安排一个工作流来初始化集群，并运行一系列 PySpark 脚本。
分布式深度学习
今年我尝试了 Horovod 图书馆。它是用于 TensorFlow 和 PyTorch 模型的分布式训练的框架。Horovod 还提供了 spark 绑定用于 PySpark 框架。结果是一个类似于 MLlib 的接口，使数据科学家能够在跨机器集群的大型数据集上训练深度学习模型。
如果您已经在使用 PySpark 进行分布式 ML 模型训练，并希望探索在管道中使用深度学习，我建议您探索 Horovod。如果你已经在使用 Databricks，这里有一个快速启动指南，帮助你使用 Horovod。
线性模型的深度学习
由于实时数据产品的延迟要求，我在 2021 年广泛使用线性模型。虽然我们的系统基于可以实时服务的 ML 模型受到限制，但我们探索了训练深度学习模型来学习简单线性模型(如逻辑回归)的系数。使用这种方法，您可以用一个信号神经元训练一个神经网络，并将训练好的权重用作线性模型中的系数。当您希望训练具有自定义损失函数的模型时，或者在训练逻辑回归模型时需要支持连续标签时，这非常有用。
您可以通过使用现有的线性模型(如使用波士顿住房数据集来预测房价)并使用自定义损失函数将结果与 Keras 模型进行比较来掌握这种方法。例如，在测量预测误差时，您可能希望使用对数标度。
特征嵌入
我今年在生产中使用的一种深度学习方法是 Keras 嵌入层，以训练用作浅层模型输入的特征嵌入。当您希望在 XGBoost 模型中使用高维度的分类特征时，这种方法非常有用，例如用户所在的国家。您可以使用嵌入图层将输入表示为少量要素，而不是为每个国家创建一个要素。例如，您可以为用户的国家/地区训练 2D 嵌入，然后用两个数字特征替换国家/地区类别。这些特征嵌入可用于深度和浅层学习模型。这个博客为模型训练提供了一个很好的特征嵌入介绍。
Word2vec
我今年探索的另一种深度学习方法是 Word2Vec，用于将分类数据转换为数字特征。虽然 Word2Vec 是为文本分析开发的，但它在 NLP 之外还有许多应用。例如，您可以将用户看过的电影表示为文本文档，其中每部电影都是文档中代表用户的一个单词。然后，您可以使用 Word2Vec 将这个文档表示转换成数字表示，并在这个新的空间中找到对电影有相似兴趣的用户。本帖很好的介绍了 Word2Rec，求推荐。
结论
2021 年是我开始将深度学习用于生产系统的一年，为了建立更高吞吐量的 ML 服务，我学习了 Golang。作为一名应用数据科学家，我开始与 ML 工程师密切合作，开发实时 ML 系统。虽然学习 Golang 对于数据科学家来说是一项艰巨的任务，但是如果您对构建实时系统感兴趣，那么学习 Golang 确实非常有用。我 2022 年的目标是继续从深度学习中学习新方法，并在生产系统中使用分布式深度学习。
掌握 Python 语言理解的 10 件事
列表理解，字典理解，等等…
Jay Patel 在 Unsplash 上拍摄的照片
我们经常使用的一个重要 Pythonic 特性是理解。最值得注意的是列表理解——一种创建列表的简明方法。但是，这个特性可能会让初学者感到困惑。此外，除了列表理解，还有其他一些相关的基于理解的技术，如字典和集合理解。
事不宜迟，让我们开始吧——探索 10 个基本的构建模块来理解 Python 中的理解。
1.列表理解的基本形式
让我们从语法开始。列表理解是从现有的 iterable 中创建列表的简洁方法。
# The syntax for list comprehension
created_list = [expression for item in iterable]
它所做的是依次将每一项应用到表达式，表达式将返回一个值，该值将作为一项进入创建的列表。为了帮助你理解它的意思，我们可以使用扩展的形式——一个for循环来说明列表理解是如何工作的。
# The expanded form using for loop
created_list = []
for item in iterable:
created_item = certain_expression_to_process_the_item
created_list.append(created_item)
在for循环中的created_list将等同于从列表理解中创建的那个。
2.从 Iterable 创建列表
最常见的用例是从现有的 iterable 创建一个 list 对象。需要注意的是，Python 有很多种可迭代对象，比如字符串、列表、集合、字典、地图对象等等。任何 iterable 都可以用于列表理解。没有必要给你看所有的例子。因此，我将简单地向您展示来自集合、字典和元组的列表理解。
列表理解(集合、字典和元组)
如果您知道列表理解的语法，那么一切都应该很简单，除了dict对象，我使用items方法来检索键值对。在表达式中，key和value都可以用来为列表对象创建项目。
3.保存需要的物品
当我们使用列表理解时，我们并不总是想要将现有列表中的每一项都发送给表达式来创建新项。在这种情况下，我们可以应用条件评估来检查是否应该包含某个项目。一般形式如下:
# condition in a list comprehension
items = [expression for item in iterable if condition]# Equivalent for loop
items = []
for item in iterable:
if condition_of_the_item:
created_item = expression
items.append(created_item)
下面是一个简单的例子，告诉你我们只保存 3 或 5 的倍数的斐波那契数列。
>>> fibonacci = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
>>> squares_fib = [x*x for x in fibonacci if x%3 == 0 or x%5 == 0]
>>> squares_fib
[0, 9, 25, 441]
4.条件赋值(三元表达式)
Python 中的一个特殊表达式是三元表达式。您可以使用一行代码，而不是编写多行版本的if…else…语句。
a if condition else b
如果条件为True，则该表达式的计算结果为a，如果条件为False，则该表达式的计算结果为b。我们可以在列表理解中应用三元表达式，它会对原列表的条目做条件赋值:[expr0 if condition else expr1 for item in iterable]。应用此语法，我们有以下示例:
列表理解:三元表达式
5.嵌套列表理解
到目前为止，你应该明白，从某种角度来说，列表理解是一种代替for循环来创建列表对象的方式。我们还知道我们可以嵌套 for 循环:
for items in items_list:
for item in items:
expression
有没有可能把这种嵌套的 for 循环转化为列表理解？是的，我们可以使用嵌套列表理解。观察下面的例子。
嵌套列表理解
觉得很难理解？你可以简单的从第一个 for 循环开始读，这是第一级，第二个 for 循环是内循环。有了这个，一切就好理解了。
从技术上讲，您可以为嵌套列表理解编写多个级别。然而，为了更好的可读性，我不认为有两个以上的层次是一个好主意。
6.替换地图()
内置的[map](https://docs.python.org/3/library/functions.html#map)函数将一个函数应用于 iterable 的每一项，创建另一个 iterable——map对象。如您所见，这与列表理解非常相似，在列表理解中，表达式应用于 iterable 的每个项目。因此，有些人使用map来创建一个列表，如下所示。
>>> animals = ['tiger', 'Lion', 'doG', 'CAT']
>>> uppercased_animals = list(map(str.upper, animals))
>>> uppercased_animals
['TIGER', 'LION', 'DOG', 'CAT']
需要注意的是，我们需要使用一个list构造函数，其中我们传递了一个不同于list对象的可迭代对象map。我们可以使用列表理解来代替使用map函数。
>>> [x.upper() for x in animals]
['TIGER', 'LION', 'DOG', 'CAT']
尽管map函数有其他用途，但是当目标是创建一个列表对象时，列表理解通常更具可读性。
7.适用时使用列表构造函数
关于列表理解，要避免的一个误用是在适当的时候使用列表构造函数。什么是列表构造函数？所谓的list功能。
*class* **list**([*iterable*])Rather than being a function, [list](https://docs.python.org/3/library/stdtypes.html#list) is actually a mutable sequence type, as documented in [Lists](https://docs.python.org/3/library/stdtypes.html#typesseq-list) and [Sequence Types — list, tuple, range](https://docs.python.org/3/library/stdtypes.html#typesseq).
正如函数签名所示，列表构造函数可以直接接受任何 iterable。因此，当您不操作 iterable 中的项目时，您应该将它直接发送给 list 构造函数。考虑下面的代码片段来进行对比。
列表理解与列表构造函数
上面的例子只是提供了一个概念证明。要点是，除非你操作 iterable 的项(例如，应用一个函数)，否则你应该直接使用 list 构造函数。以下是另一个例子，供感兴趣的读者参考。
>>> numbers_dict = {1: 'one', 2: 'two'}
>>> **# list comprehension**
>>> [(key, value) for key, value in numbers_dict.items()]
[(1, 'one'), (2, 'two')]
>>> **# list constructor**
>>> list(numbers_dict.items())
[(1, 'one'), (2, 'two')]
8.集合理解
除了列表理解，我们还可以使用理解从现有的 iterable: {expression for item in iterable}创建一个集合。与列表理解相比，集合理解使用大括号而不是方括号。当我们使用集合理解时，还有两件事需要注意。
- 创建的集合中没有重复项。即使将从表达式中创建重复项，最终的 set 对象中也只会保留一个副本。
- 按照设计，set 对象只能存储可哈希的数据，比如字符串和整数，而不能存储列表和字典。
下面的代码向您展示了集合理解的一个用例。顺便提一下，集合理解也支持上面讨论的许多其他操作，比如条件赋值。感兴趣的读者可以探索一下这些特性。
>>> numbers = [-3, -2, -1, 1, 2, 3, 4, 5]
>>> squares_set = {x*x for x in numbers}
>>> squares_set
{1, 4, 9, 16, 25}
9.词典理解
你可能已经猜到了，除了 list 和 set comprehension，你不会惊讶地知道我们可以使用 dict comprehension 来创建一个dict对象:{key_expr: value_expr for item in iterable}。与其他两种理解不同，字典理解需要两个表达式，一个表示键，另一个表示值。需要注意的一点是字典键必须是可哈希的，所以key_expr应该产生一个可哈希的对象。
>>> numbers = [-3, -2, -1, 1, 2, 3, 4, 5]
>>> squares_dict = {x: x*x for x in numbers}
>>> squares_dict
{-3: 9, -2: 4, -1: 1, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
10.生成器表达式
通常，最常用的内置数据容器是元组、列表、字典和集合。我们对后三种有所理解。有没有元组理解？可惜没有这回事。就潜在的语法而言，您可能会想到一个可能的实现:(expression for item in iterable)。
注意圆括号的用法吗？就像元组一样。有趣的是，这种用法确实存在，但它不是创建一个元组对象。相反，它创建了一个生成器，这是一种特殊的迭代器，具有更好的内存效率。因为不像其他迭代器那样在内存中加载所有的项，生成器在需要的时候呈现一个项，这避免了加载所有项的开销。因此，当您处理大量数据时，可以考虑使用生成器而不是其他迭代器，比如列表或元组。下面的代码向您展示了首选生成器的用例。
>>> numbers = list(range(10_000_000))
>>> **# Creating a list of squares using list comprehension**
>>> squares = [x*x for x in numbers]
>>> squares.__sizeof__()
89095144
>>> **# Using generator instead**
>>> squares_gen = (x*x for x in numbers)
>>> squares_gen.__sizeof__()
96
>>> # Having the same result
>>> sum(squares) == sum(squares_gen)
True
正如您所看到的，中间步骤(list vs. generator)向您展示了一个从生成器表达式创建的生成器，与 list 对象相比，它的大小微不足道，突出了生成器的性能。
结论
本文回顾了您需要了解的 Python 理解技巧的所有基本内容。这些技术是创建所需数据结构的简洁方法，只要适用，就应该使用它们。
感谢阅读这篇文章。通过注册我的简讯保持联系。还不是中等会员？用我的会员链接支持我的写作。
关于 Python 中的维基百科库，你可能不知道的 10 件事
使用 Wikipedia API 的一行代码获取数据要简单得多
介绍
在我之前的帖子你可能错过的 5 个有趣的 Python 库中，我谈到了 5 个我很少听说过的被低估的 Python 库，其中之一就是维基百科 API。随着我对这个库做了更多的阅读，我发现这比我想象的要酷得多。在本文中，我将与您分享一些使用这个简单、方便且有用的库的示例。
期待什么
由于 Wikipedia API 可以从 Wikipedia 页面中检索几乎所有内容，在这种情况下，我们不需要严重依赖不同的数据抓取技术。使用 Wikipedia API 的一行代码获取数据要简单得多。
然而，需要记住的一个重要注意事项是，这个库的最初目的不是为了高级使用。因此，正如文档所建议的，如果您打算做任何抓取项目或自动化请求，请考虑其他替代方案，如Pywikipediabot或MediaWiki API， ，它们具有其他优越的特性。
好吧，首先，安装这个很酷的库，让我们看看这个包能给我们带来什么。
!pip install wikipedia
import wikipedia
工作原理
1.获取特定关键词的摘要
如果您希望获得某个特定数量的摘要句子，只需将它作为参数传递给summary()函数。例如，我试图用 4 句话来解释新冠肺炎是什么。
输出:
图 1:摘要句子——作者图片
2.搜索文章标题
Search()功能帮助我们搜索包含特定关键字的所有标题。例如，如果我想获得与“肯德基”、相关的所有帖子标题，我将在搜索功能中传递“肯德基”。
图 2:搜索方法
因此，维基百科中包含肯德基信息的所有文章的列表都会被检索出来，如下所示。
输出:
图 3:标题列表——按作者分类的图片
您还可以说明您希望结果中出现多少个标题。
图 3: 5 个结果
3.搜索关键字
万一你有什么东西要在脑海中查找，但又记不清到底是什么，你可以考虑suggest()方法。该函数返回相关单词。
假设我想找到德国总理的准确姓名，但不记得她的名字是如何拼写的。我可以写我记得的，也就是“安吉拉·马克尔”让suggest()给我做剩下的。
图 4:拼写错误
如你所见，该函数返回一个正确的值，即“安格拉·默克尔”。
输出:
图 5:正确的拼写——作者图片
5.提取内容
如果您希望以纯文本格式提取 Wiki 页面的所有内容，请尝试使用page对象的content属性。
在下面的例子中，我演示了如何获取“肯德基的历史”文章。结果不包括图片或表格，…只有纯文本。
图 6:获取肯德基内容的历史
这是结果的样子。简单吧？
图 7:肯德基的历史——作者图片
您甚至可以通过组合search()和page().content来创建一个循环，以获取与您定义的主题相关的不同文章的不同内容。让我们试着为奥普拉·温弗瑞合并几篇文章。
图 8:组合内容
6.提取页面的 URL
你可以用page对象的url属性轻松提取维基百科中任何页面的 URL。
图 9:提取 URL
输出:
图 10:页面的 URL 作者的图片
7。提取参考网址
你甚至可以用page对象和一个不同的属性(这次是references.)提取维基百科页面上的所有引用 URL
图 11:提取引用链接
输出:
外部参考列表提取如下:
图 12:参考链接——作者图片
8.获取页面类别
如果我想知道我的文章是如何被维基百科分类的呢？使用了page对象的另一个属性，就是categories.我会尽量找出上面文章的所有外部链接，《肯德基的历史》。
图 13:获取类别
输出:
图 14:类别——按作者分类的图片
9.提取页面图像
也可以通过命令行检索图像。通过使用page().images,，你将得到图片的链接。继续我的例子，我会试着从“肯德基的历史”页面获取第二张图片。
图 15:获取图像 URL
看我这里有什么:
输出:
[https://upload.wikimedia.org/wikipedia/commons/b/b1/Col_Sanders_Restaurant.png](https://upload.wikimedia.org/wikipedia/commons/b/b1/Col_Sanders_Restaurant.png)
链接带你去桑德斯的餐馆！
图片来自维基百科上的 Acdixon
10.更改语言输出
如果页面以该语言存在，则可以将语言更改为任何语言。Set_lang()方法用于这种情况。有点跑题了，但我认为这是学习新语言的好方法。你可以尝试不同的语言来理解一个特定的段落。翻译都在屏幕上。
图 16:转换成英语
以上是我如何将关于【越南】的总结翻译成英语。
输出 :
图 17:关于越南的英文摘要——作者图片
临终遗言
这挺有意思的吧？维基百科是互联网上最大的信息源之一，是收集数据的天然场所。有了 Wikipedia API 的各种特性，这将容易得多。
如果你有任何有趣的图书馆，请不要犹豫与我分享。
参考
https://pypi.org/project/wikipedia/
对有兴趣发展数据技能的非技术背景学生的 10 个技巧
(图片由作者提供—中国重庆)
你会对自己说或者大声说，“我数学不好吗？或者，你是否在统计学入门课程中苦苦挣扎，却忘记了所学的所有内容？你是否害怕参加数据密集型课程，因为害怕它们会影响你的 GPA 或你的价值感，或者两者兼而有之？这篇文章是为那些回答了这些问题的学生写的。如果你的答案是否定的，那么不要浪费时间继续阅读了——这篇文章不适合你。我是专门为没有技术背景的学生写的，他们没有信心或信念能够获得数据技能。这些技巧基于我自己学习数据技能和教授不同背景、兴趣和技能水平的学生的经验。
- 澄清为什么要学数据技能
你为什么想学习如何处理数据？如何看待职业生涯中的数据技能？你的兴趣与特定的职业抱负有关吗？或者，你只是想在简历中列出一些通用能力？你有什么特别想完成的事情吗？首先，阐明你培养数据技能的目的和动机。随着学习的进展，你的基本原理可能会随着时间的推移而演变。这是可以接受的，也是意料之中的。明确你的目标是制定有效学习计划的重要因素。有了适当的支持，你可以从看似无限的可能性中选择最有效的学习活动。
2。不要混淆数据和统计数据
数据是信息的单位。统计可以被看作是一套处理数据的工具，但是处理数据并不意味着做统计。从关注数据的关键概念开始你的技能发展，包括不同类型的数据以及它们如何被正确地构造、组织和存储。在您学习的后期，您可能需要进行统计测试，但不是必须的。除了百分比和平均值，你实际上可以用数据做很多事情。
3。致力于参与式学习
发展一项技能需要积极的学习。阅读文章、观看视频或参加讲座是重要的学习资源，可以帮助您了解关于数据的。但是，实际的技能发展需要实践和应用。多少钱？那取决于你想完成什么。拥有专业技能无疑需要大量的练习。但是，这适用于几乎每一种技能，不仅仅是数据。没有一门课程可以在缺乏实际技能发展练习的情况下帮助你发展数据技能。
4。找一个教练或导师
事实上，有很多课程可以学习数据技能。然而，许多课程都是一刀切的，也就是说，内容和目标对所有学生都同样适用。最有可能的是，某一课程的学生在他们现有的技能水平、经验、兴趣领域和职业目标方面会有很大的差异。这并不是说你应该避免参加课程。但是，在我看来，你应该与教师或其他人密切合作，他们可以帮助你确定根据你的技能水平、兴趣和目标量身定制的学习活动和资源。
5。启动个人项目
马上运用你的技能。个人项目是理想的，尤其是如果你找到了对你个人有意义的东西，或者你有一个可以用数据解决的问题。练习收集和分析数据以应用你的技能。最有可能的是，选择对你个人有意义的东西会比老师布置的东西更有趣、更吸引人。量化自我项目是一个绝佳的起点。个人项目也是为职业作品集创造作品的基础，这对向雇主展示你的实际技能更有用。除了给你一个应用和发展自己技能的机会，个人项目还显示出对雇主来说很重要的重要特征——例如，独立工作的能力和对学习的承诺。
6。跑之前先学会走
许多开始学习数据技能的学生感到有压力，要马上开始学习统计分析。在大多数实际用例中，大多数数据工作都涉及清理、管理和准备数据。事实上，随着你越来越多地参与到数据中，你可能会听说这代表了所有工作的大约 80%。根据我的经验(以及与社区组织的合作)，这个统计数字并不准确。我估计接近 90%。
通过培养清理、管理和准备数据的扎实技能，学生可以更快地进步，并最终取得更大的进步。这项工作可能看起来不太令人兴奋，但实际上是您将使用数据做的几乎所有事情的基础。例如，创建高影响力数据可视化的大量工作与高级统计分析毫无关系。在大多数情况下，大部分工作涉及准备数据。很少有数据是以一种很好的矩形格式到达的，可以用于分析。
也就是说，对你最初的学习来说，最重要的概念之一是整齐的数据。对于新手来说，整理数据的原则可能看起来很简单，以为略读三条基本规则就够了。从来都不是这样。花时间阅读大量关于这一概念的博客文章和视频教程，然后练习创建自己的整洁数据集。
7。选择分布式学习而不是狂欢式会议
通过在较短的时间内有规律地分配你的努力，你会比定期的狂欢会议在学习中进步得更快。分布式学习有助于保持学习的动力，并减少学习过程中忘记的信息量。这不是个人观点，而是基于教育心理学领域大量证据的公认的学习原则。定期通过社交媒体接触信息是促进分布式学习的有效方式。
8。避免孤立学习
努力避免在学习中被孤立。如果您是学习数据的新手，您可能不知道在这么多不同的数据领域中有许多活跃的学习者社区。许多社区，比如专门针对数据可视化的改造星期一，非常支持所有不同层次的学习者。通过这个社区，你可以很容易地在 Twitter 上与其他学习者联系，他们定期分享资源、技巧和对自己学习的反思。您还可以在 Reddit、Discord 和脸书上找到围绕不同主题领域组织的社区，包括软件和主题领域。花时间探索与你兴趣最相关的不同社区。已经有大量的博客文章列出了不同的社区。一些简单的搜索和与他人的联系可以帮助你找到与你最相关的社区。
9。拥抱电子表格
许多学生认为，为了处理数据，他们需要了解统计软件包。出于某种原因，在我的教学经验中，一直有一个假设，即知道 SPSS 是金奖券，最近，用 r 语言编程。软件应用程序只是处理数据的工具，新的学习者必须理解重要的规则——为正确的工作选择正确的工具。作为一个新手，你的首要任务是学习。以我的观点和经验，学会在电子表格中准备数据，进行各种操作，是感受效能感最快的方法之一，这对于学习是必不可少的。
我也开始欣赏电子表格，尤其是谷歌表单，它是一个非常有用的数据工具。对于更高级的数据处理工作，其他软件应用程序显然更胜一筹，因此这不应该被认为是您获得的众多工具中的唯一工具。我发现自己一直在使用 Google Sheets 来解决各种各样的数据处理问题。Google Sheets 与我使用的许多其他数据工具无缝集成，并且功能还在继续增长。认真考虑 Google Sheets，将其作为你技能发展的起点。 DataCamp 提供了一套优秀的入门模块，让您马上上手。
10。避免用课程成绩来衡量你的学习进度
成绩对许多学生来说非常重要。对一些学生来说，成绩过于重要，干扰了学习过程。请记住，分数和你的平均绩点不足以证明你拥有可展示的技能。当我雇人做我的项目时，我希望看到一个投资组合或一些你的技能和能力的展示。我知道许多其他雇主也有同样的立场。如果你表示懂 SPSS，Excel，R，Tableau，或者别的什么——你真的需要提供证据。索赔或者出示笔录都不行。创建一个投资组合。用你最好的作品定期更新作品集。寻找将课程作业转化为文件夹工件的方法。
作为新毕业生获得第一份数据科学工作的 10 个技巧
从我的求职之旅中学到的经验
在 Unsplash 上由 Austin Chan 拍摄的照片
我的求职之旅
我最近开始了一份新工作，在我梦想的公司担任数据科学家。一年前，我还在努力争取面试机会。我从未想过一年后我会在一家财富 100 强公司工作。老实说，这是一次过山车般的旅程，尤其是由于疫情，入门级别的职位空缺下降了 68%。现在，就业市场已经开放了一些，我想分享我的故事，希望它能帮助那些正在开始求职之旅的人。
简单介绍一下我的背景。2017 年获得应用数学学士学位，2020 年获得商业分析硕士学位。大学毕业后，我做过初级数据分析师、数学教师、网站开发助理和数据科学家实习生。因为我还在上学，所以我的大部分职位都是兼职的。我还在暑假期间参加了 2019 年为期 12 周的数据科学训练营 Metis。就我个人而言，我认为这是我做过的最好的决定之一。我从训练营学到了很多。如果你有兴趣了解更多关于我的经历，请随时联系我。我愿意帮忙！😃
去年一月，我正式开始每天发送求职申请。虽然为期 12 周的研究对我的起步非常有帮助，但这远远不足以获得一个全职数据科学家的职位。我申请，面试，失败，学习，再次面试，再次失败，再次学习…这是令人兴奋的，令人沮丧的，令人不知所措的，尤其是在新冠肺炎疫情期间。我最终进入了 Visa 的最后一轮，但之后出现了招聘冻结。虽然我很失望，但事实上我有机会得到工作面试的确有助于增强我的信心。当你还在学校的时候找工作最好的一点是，它给你更多的时间准备面试过程。面试的越多，就越知道自己还有哪些方面需要学习和准备。
以下是我在整个过程中学到的 10 个技巧
1.即使你觉得自己还没有准备好，也要尽早开始申请
我注意到现在很多数据科学的空缺职位都要求在职位描述中有 3 年以上的工作经验。申请这些工作可能会令人生畏，但如果你不申请，你就会错过机会。有时，招聘经理甚至不知道他们希望应聘者有什么样的经历。要看你能给公司和团队带来什么。此外，即使你的申请没有被选中，你也不会有什么损失。
2.非常了解基础知识
面试的时候，你需要很好的了解所有的基础知识，比如统计学，概率，机器学习，产品感，编程。有很多资源可以帮助你复习基础数据科学面试。
- SQL 和 Python : 我主要用leetcode.com来练习。我发现很多公司不会为一个数据科学家职位提出中等难度的 python 问题。它们倾向于测试你清理数据的能力，比如对 pandas 使用 lambda 函数和一些数据操作函数。
- Google 的 Udacity A/B 测试课程 : 这是最受欢迎的 A/B 测试课程。如果你在下次面试前没有时间完成整个课程，我建议你看看由 Kelly Peng 撰写的本课程的总结。
- 产品感 :当谈到对一个企业产生影响时，它不是关于你能编码多少。相反，它是对需要为用户构建什么做出正确决策的能力。Stellarpeers 是一个很好的平台，可以帮助专业人士准备产品管理面试。如果你有兴趣了解更多关于咨询面试问题的知识，可以在这里查看我的总结。
- 统计与概率 : 如果你有一段时间没有接触统计，可以看看 PennState 的 STAT 414 或者 STAT 415。面试官喜欢问贝叶斯定理，条件概率，中心极限定理，I 型和 II 型误差，幂，P 值等。所以要确保你能用自己的话解释基本定理。
- 机器学习:Coursera、Udemy、Udacity 等上有很多课程可以了解更多关于机器学习的知识。我发现学习所有定理的最好方法就是自己总结。
这是我为自己整理的部分表格的截图
3.网络很重要
“重要的不是你知道什么，而是你认识谁”不仅仅是一句陈词滥调。建立一个强大的关系网并寻求推荐会带来令人兴奋的机会。当你找到第一份工作时，你需要向雇主展示你愿意付出更多的努力。尽管我们都不得不做出暂时的牺牲，但没有理由停止社交。尤其是因为网络帮助我们发展和提高我们的技能，紧跟当前的行业趋势，最重要的是，学习他人的经验。在 meetup.com 有很多虚拟活动和学习小组。不要害羞，走出你的舒适区，你会很高兴你这样做了。
4.展示你的作品
现在我们生活在一个数字世界，如果你没有把你的作品放到网上，没人知道你有多了不起。雇主希望看到你在简历之外的能力。建立一个强大的数据科学组合来展示你的技能将增加你获得面试的机会。如果你不知道从哪里开始，看看我的另一个博客来获得一些灵感！
5.充分了解你的项目
将开源项目中的代码直接复制并粘贴到您的项目中很容易，但是您真的知道项目的业务影响吗，您能解释所有的事情吗？偷别人的作品是绝对不行的！面试官可以通过问几个有深度的问题来判断你是否真的参与了这个项目。因此，了解项目的所有细节并准备好解释复杂的机器学习概念非常重要，例如为什么某种机器学习算法具有更好的预测性能，如何解释预测结果。这也表明你不仅理解了这些概念，还能向其他团队成员和风险承担者清楚地解释你的分析。
6.准备行为面试问题
信不信由你，许多雇主会问行为问题，因为他们想更好地评估候选人是否适合这份工作、团队和公司文化。
阿克谢·萨克德瓦提出了一些常见的行为面试问题:
- 描述一次你与团队成员意见相左的时候。你是如何解决这个问题的？
- 告诉我你与主管意见相左的时候。
- 告诉我你在团队项目中失败的一次经历，以及你是如何克服的。
- 告诉我你在工作中犯过的一个大错误，以及你是如何处理的。
- 你在工作场所遇到的最困难/最具挑战性的情况是什么？
- 你如何处理意想不到的变化或挑战？
在回答这类问题时，着重提供你过去如何处理某种情况的例子。如果你在面试中紧张时容易昏厥，你可以事先准备和练习你的答案。我发现研究职位描述，思考雇主可能在寻找什么样的品质，以及你如何成为他们的资产是很有帮助的。
7.准备一份要问面试官的问题清单
在面试中提问表明你对这些问题非常感兴趣，而且你已经做了功课。虽然在面试结束时问问题很重要，但不要问所有面试官同样的问题，不管他们是什么角色。相反，试着向人力资源/招聘人员询问招聘经理的期望或整个招聘过程，向招聘经理询问关于该职位的更多细节，并分享你如何能提供帮助。记住面试也是一种对话，你问问题是因为你真的对这个职位感兴趣。
8.设定每日目标
每天设定目标帮助我更好地集中注意力，并让自己负起责任。在求职过程中，拒绝是不可避免的，但不要让它定义你或决定你的价值！通过实现和庆祝每天的小目标，我开始更多地认可和欣赏自己所完成的一切。
9.要自信
我注意到成功人士和不成功人士之间最大的区别不是智力、机会或资源。这是他们能够实现目标的信念。—詹姆斯·克利尔
如果你不相信你自己，你怎么能让雇主相信你就是那个人呢？几乎每个人都在与自我怀疑或冒名顶替综合症做斗争，所以不要让它影响你！在一次面试中，我被告知，我永远不可能得到一份首席执行官的数据科学家工作，因为我不是常春藤盟校的毕业生。但最后他还是给了我一个报价。当然，我拒绝了。我们不需要别人的赞美来了解我们的价值观。所以，不要再担心自己是否足够优秀了，多关注于从错误中吸取教训。
10.现在祈祷吧
运气可能在求职中发挥作用。有时候，不管你有多努力，都不是那么回事。记住，不要把拒绝看得太个人化。相反，要感谢你有机会更多地了解这家公司，提高你的面试技巧。最适合你的职位就在外面等着你，现在当面试来临时，你更有准备去赢得它！
最终想法
在疫情期间找工作会非常有压力，让人不知所措，但是嘿，你有这个！你已经学到了这么多。我知道在没有经验的情况下很难找到第一份数据科学工作，但这并非不可能！如果我能做到，你也能做到！毕竟，成功需要努力、时间和耐心。所以现在不要放弃！
参考
- https://www . CNBC . com/2020/06/26/entry-level-jobs-down-68% what-new-grads-can-do-to-stand-out . html
- https://leetcode.com/
- 【https://www.udacity.com/course/ab-testing ud 257
- https://stellarpeers.com/
- https://online.stat.psu.edu/stat414/
- https://www . themartec . com/inside look/behavioral-interview-questions
如果你觉得这很有帮助，请关注我，看看我的其他博客。敬请关注更多内容！❤
</10-questions-you-must-know-to-ace-any-sql-interviews-2faa0a424f07>
在机器学习中使用大型数据集的 8 个技巧和诀窍
内存和代码优化基本指南
Pandas 和 Scikit-learn 是数据科学社区中流行的库，因为它们具有高性能和易于使用的数据结构和函数。熊猫为数据准备和分析提供数据分析工具。这些库可以很好地处理内存中的数据集(适合 RAM 的数据)，但是当处理大规模数据集或内存外的数据集时，它会失败，并可能导致内存问题。
在本文中，我将讨论在处理大规模数据集时可以使用的 10 个技巧和诀窍。这些技巧将帮助他们在处理内存不足或大型数据集时避免内存溢出问题，并加快他们的工作流程。
***Checklist:***
**1) Read dataset in chunks with Pandas
2) Optimize the datatype constraints
3) Prefer Vectorization
4) Multiprocessing of Functions
5) Incremental Learning
6) Warm Start
7) Distributed Libraries
8) Save objects as Pickle file**
1.)用熊猫读数据块:
Pandas 提供 API，可以在一行 Python 代码中读取 CSV、txt、excel、pickle 和其他文件格式。它一次将全部数据加载到 RAM 内存中，在处理内存不足的数据集时可能会导致内存问题。
其思想是读取/加载和处理大数据块或数据集的小样本。
(作者代码)
上面的代码示例以块的形式读取大型数据集(第 14 行)，对每个块执行处理(第 15 行)，并进一步保存处理后的数据块(第 17 行)。
2.)优化数据类型约束:
熊猫通过观察特征值，将默认数据类型分配给数据集的每个要素。对于具有整数值的要素，数据类型为 int64，而具有小数值的要素，数据类型为 float64。在分配给每个要素的默认数据类型列表下找到列表。
(作者图片)，熊猫默认数据类型
int64 值的范围在**-9,223,372,036,854,775,808 to 9,223,372,036,854,775,807.** 之间。对于大多数数据集，整型特征值不会超过该限制。想法是通过观察最大和最小特征值来降级特征数据类型。
(作者图片)，左:(作者图片)，分配的默认数据类型和内存使用量，右:降级数据类型后的内存使用量
示例数据集使用默认的数据类型约束集，占用 467.4 MB 内存。对数据类型进行类型转换后，内存使用减少了大约 70%,为 134.9 MB。
阅读我以前的一篇文章，更好地理解通过类型转换降级的数据类型。
3.)首选矢量化进行迭代:
对于数据处理任务，人们总是会遇到各种需要遍历数据集的情况。Pandas 提供了各种函数来使用iterrows()、itertuples()、iteritems()循环它们的实例，其中iterrows()是最慢的。
要素的矢量化加快了迭代过程。iterrows()遍历熊猫系列，因此是最慢的。itertuples()遍历元组列表，因此相对更快。
跟随我以前的一篇文章，了解更多关于如何让熊猫的迭代速度加快 400 倍。
</400x-time-faster-pandas-data-frame-iteration-16fb47871a0a>
4.)多重处理:
与其他编程语言相比，Python 相对较慢，因为代码是在运行时解释的，而不是在编译时编译成本机代码。即使在对特征向量进行矢量化之后，用于数据预处理的函数的执行也相对较慢。
这个想法是利用 CPU 的所有内核，并在所有内核之间扩展计算，以加速工作流。Python 提出了一个多重处理模块，它允许这样的功能。
跟随我以前的一篇文章学习如何使用多处理模块扩展 Python 函数。
</25x-times-faster-python-function-execution-in-a-few-lines-of-code-4c82bdd0f64c>
5.)增量学习:
Scikit-learn 提供了各种分类、回归和聚类机器学习算法的高效实现。对于新一批学习数据随时间而来的机器学习任务，重新训练模型的时间效率不高。此外，对于内存不足的数据集，一次性训练整个数据集是不可行的，因为不可能一次性将整个数据加载到 RAM 中
增量学习可以用于这样的任务，其中模型的过去学习将被恢复，并且相同的模型将用新的一批数据来训练。Scikit-learn 提供了[**partial_fit()**](https://scikit-learn.org/0.15/modules/scaling_strategies.html)函数，该函数为核外数据集提供了增量学习。
6.)热启动:
Scikit-learn 使用 API warm_start来重用从之前的参数值中学习到的模型方面。当warm_start为真时，分配的模型超参数用于拟合模型。例如，warm_state 可用于增加随机森林模型中的树的数量(n_estimators)。使用warm_start参数时，超参数值仅在保持训练数据集或多或少不变的情况下发生变化。
**rf = RandomForestClassifier(n_estimators=10, warm_start=True)
rf.fit(X_train, y_train)
rf.n_estimators += 5
rf.fit(X_train, y_train)**
从上面的样本代码来看，初始模型是用**n_estimator=10**对**X_train** 样本数据进行训练的。然后我们进一步增加 5 棵树**n_estimator=5** 并重新训练相同的模型。
跟随我以前的一篇关于增量学习的文章来更好地理解增量学习和 warm_state 功能。
7.)分布式库:
Pandas、Numpy、Scikit-Learn 等 Python 包提供了高级可用且灵活的 API，但在很大程度上忽略了性能和可伸缩性。在处理内存不足的数据集时，这些库可能会导致内存问题。
其思想是使用分布式库，如 Dask、Vaex、Modin 等，它们构建在 Pandas、Numpy 和 Scikit-learn 库的基础上，并专门设计为通过在所有 CPU 内核上并行化操作来扩展工作流。
8.)将对象保存为 Pickle 文件:
在处理大型数据集时，读取和保存数据或临时文件是一项单调乏味的任务。CSV、TXT 或 excel 数据格式的读写操作计算量很大。
还有其他数据格式具有相对更快的读写操作，在处理大规模数据集时可能是首选。
(图片由作者提供)，左:读取和保存时间对比(秒)，右:内存消耗(MB)
上图显示了具有 1，458，644 条记录和 12 个特性的样本数据集的读取、写入操作和内存消耗的基准数据。
Pickle 文件可能是保存和读取数据集或临时文件的首选。Pickling 可以存储列表、字典、类对象等 python 对象。
阅读我的一篇以前的文章，观察使用各种数据格式进行读取和保存操作的基准时间比较
结论:
在本文中，我们讨论了在处理内存不足或大型数据集时可以使用的 8 种不同的技术或技巧。这些技术可以加快工作流程并避免内存问题。
参考资料:
[1] Scikit-learn 文档:https://sci kit-learn . org/0.15/modules/scaling _ strategies . html
喜欢这篇文章吗？成为 中等会员 继续无限制学习。如果你使用下面的链接，我会收到你的一小部分会员费，不需要你额外付费。
https://satyam-kumar.medium.com/membership
感谢您的阅读
我用来简化数据科学学习体验的 10 个工具
这 10 个工具正在帮助我在 2021 年学习数据科学
罗伯特·卡塔林奇亚在 Unsplash 上的照片
学习数据科学很难。确定应该使用哪些资源来学习数据科学更加困难。
在过去的四年里，互联网上充斥着帮助人们学习数据科学的资源和工具，以至于看着可供您使用的资源墙并试图决定哪一个对您最有帮助可能会令人生畏。
经过一些实验和研究，我发现这十个工具和资源对我的学习过程最有帮助。最棒的是它们是免费的！
1.自由代码营
从我开始学习数据科学开始，我就知道我想尽可能多地使用 freeCodeCamp 资源和教程。作为学习任何与代码相关的东西的最值得信赖的来源之一，他们不会对他们为数据科学和科学计算量身定制的视频和教程感到失望。
回到 2020 年，我为即将到来的一年建立了一个数据科学学习课程，并发现 freeCodeCamp 课程定期填充课程。从 Python 和 SQL 的基础知识到机器学习、数据分析和可视化的教程，freeCodeCamp 是开始学习数据科学基础知识的最佳场所。
freeCodeCamp 提供的课程都是由自学成才的程序员、大学教授和行业专业人士讲授的，并且针对它们涵盖的概念进行了完美的进度安排。
freeCodeCamp 是一个为数据科学奠定基础的优秀资源，因此我建议当你准备开始更复杂的概念时，去旁听大学提供的 MOOCs。
以下是 freeCodeCamp 中一些我最喜欢的数据科学相关视频:
- 面向数据科学的 Python—初学者课程(学习 Python、Pandas、NumPy、Matplotlib) | 链接
- SQL 教程—初学者全数据库教程| 链接
- Python 数据分析—初学者的完整课程(NumPy、Pandas、Matplotlib、Seaborn) | 链接
- 程序员实用深度学习——fast . ai 和杰瑞米·霍华德全教程| 链接
2.Visual Studio 代码
在我大学学习软件开发的时候，我非常熟悉 Visual Studio 代码 IDE，这使得它成为开始学习数据科学时显而易见的选择。我最好的建议之一是，如果你的 IDE 可以在多个计算领域工作，就不要改变它。当您试图学习像数据科学中那样复杂的主题时，没有什么比不得不尝试学习新的 IDE 更糟糕的了。
当谈到版本控制、键盘快捷键和扩展时，Visual Studio 代码占主导地位，这些都可以用来简化您的数据科学体验。
以下是一些我最喜欢的 VSC 数据科学扩展，我不能没有它们:
- Python:Python for Visual Studio 代码支持 Python 语言，包含了智能感知、林挺、调试、代码导航、代码格式化、Jupyter 笔记本支持、重构、变量探索、测试探索等有用的特性。
- https://marketplace.visualstudio.com/items?itemName=ms-toolsai.jupyter:Jupyter for Visual Studio Code 为 Jupyter 笔记本中支持的语言内核提供基本的笔记本支持。这个扩展最好与 Python 扩展一起使用。
- 地理数据查看器 :地理数据查看器提供了一种简单而美观的方式来可视化全球数据。
- Rainbow CSV:Rainbow CSV 可以让你在。csv 文件。
3.Jupyter 笔记本
Jupyter Notebook 可以说是终结数据科学领域所有 IDE 的 IDE，而且理由充分。正因为如此，我开始使用它和 Visual Studio 代码只是时间问题。
每个人以前都听过对 Jupyter Notebook 的赞美，因此我将简要说明为什么它会成为我学习数据科学的首选工具:
- Jupyter 支持 40 多种语言，并且可以轻松地使用更新的数据科学语言，如 Julia。
- 您可以使用 GitHub、Dropbox、Jupyter 笔记本查看器甚至电子邮件轻松共享笔记本。
- Jupyter 可以轻松使用所有顶级的数据科学库和大数据工具，包括 pandas、scikit-learn 和 TensorFlow。
4.3 蓝色 1 棕色
我从来不擅长数学，这让我怀疑我为什么要学习数据科学。物理、化学或统计过程中出现的实用数学，我很擅长。有限数学和微积分中的理论数学，没有那么多。
自从进入大学，我已经成功地自学了有限数学，并且正在通过我的第一门大学水平的统计学课程。在那之后，我需要进入火环并通过一门大学水平的微积分课程，尽管在高中阶段从未学过。我有没有提到我必须自学？
帮助我克服数学缺陷的一个资源是 Youtube 频道。这个频道的重点是涵盖线性代数，微积分，神经网络，微分方程，几何和物理。
3Blue1Brown 经常在数据科学社区中被讨论为学习成为成功的数据科学家所需的数学知识的最佳资源之一。我可以证实这一点，因为我发现这有助于我用简单易懂的例子轻松地了解我到底需要什么。
5.Kaggle 课程
我希望在我刚开始学习数据科学的时候，我对 Kaggle 课程有更多的了解。
很少提到(虽然我不太确定为什么)，Kaggle Courses 提供免费课程，涵盖了你需要知道的每一个概念，以便能够完成数据科学项目。
Kaggle 课程是知识和教程的金矿，提供 50 多个小时的学习时间。涵盖的主题包括 python 的基础知识、机器学习、数据可视化、高级 SQL、深度学习、数据清理、地理空间分析、自然语言处理和特征工程——这只是配对的列表。
6.张量流
TensorFlow 是由谷歌创建的开源匹配学习平台，使开发和训练机器学习模型变得非常容易。
关于 TensorFlow，我最喜欢的部分之一是他们提供的教程，帮助你熟悉这个库，包括神经网络、推荐系统和生成对抗网络的漫游。此外，TensorFlow 社区非常庞大，很容易在网上找到大量的 TensorFlow 教程。
我发现 TensorFlow 在解决分类和识别问题时特别有用，这些问题构成了我完成的项目的很大一部分，以巩固我对概念的理解。
7.BigML
BigML 是另一个用于自动化决策的机器学习平台。虽然 BigML 是一项付费服务，但可以为个人项目创建一个免费帐户，允许访问 BigML 的所有功能(唯一的缺点是，根据 BigML 执行时的繁忙程度，您的任务可能会排队)。
BigML 可以很容易地实现监督和非监督学习，以完成几个测试，包括分类和回归，时间序列预测，聚类分析，异常检测和关联发现。
虽然我并不认为 BigML 是最容易使用的工具，但我认为花时间了解它的工作原理并试验它广泛的功能和开发生产级模型的能力是非常重要的。我认为这绝对是最适合中级到高级数据科学学习学生的资源。
8.擅长
作为最古老的数据分析工具之一， Excel 是一款久经考验的可靠工具，可以轻松分析和可视化数据集。作为一个刚刚入门的数据科学新手，Excel 让我很容易开始数据操作和分析任务。
虽然它不像一些较新的工具那样耀眼，但 Excel 是学习如何执行高级分析和可视化 2D 数据的一个很好的起点。Thes 最好的部分是，你甚至可以在 Excel 中使用 Python！
我强烈建议学习如何使用 Excel 进行任何快速数据分析任务，因为它仍然是希望对其数据进行分析的公司最相关的工具之一。
9.Matplotlib
Matplotlib 是我最喜欢的用于数据可视化的 Python 库之一。这个有用的小工具功能强大，可以轻松生成图表、直方图、条形图、散点图和许多其他可视化图形。
虽然 Matplotlib 不如其他更现代的库强大，如 Plotly(我将在下面提到)，但我发现它在对您的可视化进行疯狂的控制方面表现出色。Matplotlib 也比更现代的库需要稍微多一点的代码，但是我发现在使用一些更用户友好的库之前，学习如何“硬”地可视化数据是有益的。
10.Plotly
一句话，美丽。每个人都有自己喜欢的可视化工具，Plotly 可能是我的。
Plotly 是一个简单易学的库，它提供了一个直观的语法来制作交互式的和完全可定制的可视化。
虽然有些人可能认为 Plotly 与 Matplotlib 具有相似的用户友好性，但我认为这个更现代的库使得快速构建可视化变得非常容易。对于初学数据科学的我来说，我认为 Plotly 是一个很好的库，可以满足我的数据可视化需求。
最后的想法。
研究数据科学充其量是一个令人生畏的过程，但如果你选择正确的工具来帮助你，它可以变得更容易管理。这个列表不会适合所有人，但希望它能给你一些启示，让你知道什么对你有用。
找到合适工具的关键是反复试验。通过大量的研究和实验，我发现这 10 个工具在简化我学习数据科学的方法方面是最有用的。然而，我总是乐于尝试新的工具和流程，因为我相信学习过程总是可以改进的，这就是为什么我想知道哪些工具对您在数据科学领域的成功最有帮助！
你可以在这里查看我将在 2021 年学习数据科学的学习课程:
** **
在 Pandas 中将数字和字符串转换为日期时间的 10 个技巧
熊猫帮助你开始数据分析的提示和技巧
Sanah Suvarna 在 Unsplash 上拍摄的照片
在进行数据分析时，确保正确的数据类型非常重要。否则，您可能会得到意外的结果或错误。Datetime 是数据科学项目中常见的数据类型，数据通常保存为数字或字符串。在数据分析过程中，您可能需要将它们显式转换为 datetime 类型。
本文将讨论如何将数字和字符串转换为日期时间类型。更具体地说，您将学习如何使用 Pandas 内置方法to_datetime()和astype()来处理以下常见问题:
- 将数字转换为日期时间
- 将字符串转换为日期时间
- 处理第一天格式
- 处理自定义日期时间格式
- 处理分析错误
- 处理缺失值
- 从多个列组装日期时间
- 一次转换多列
- 读取 CSV 文件时解析日期列
astype()和to_datetime()的区别
源代码请查看笔记本。
1.将数字转换为日期时间
Pandas 有两个内置方法astype()和to_datetime()，可以用来将数字转换成日期时间。例如，要将表示秒的数字转换为日期时间:
df = pd.DataFrame({**'date': [1470195805, 1480195805, 1490195805]**,
'value': [2, 3, 4]})
使用to_datetime()时，我们需要从 Pandas 调用它，并设置参数unit='s':
>>> **pd.to_datetime(df['date'], unit='s')**0 2016-08-03 03:43:25
1 2016-11-26 21:30:05
2 2017-03-22 15:16:45
Name: date, dtype: datetime64[ns]
使用astype()时，我们需要从一个序列中调用它(日期列)并传入'datetime[s]':
>>> df['date'].astype(**'datetime64[s]'**)0 2016-08-03 03:43:25
1 2016-11-26 21:30:05
2 2017-03-22 15:16:45
Name: date, dtype: datetime64[ns]
同样，我们可以将表示其他单位的数字(D、s、ms、us、ns)转换为日期时间，例如，数字表示日期
df = pd.DataFrame({**'date': [1470, 1480, 1490],**
'value': [2, 3, 4]})>>> pd.to_datetime(df['date'], **unit='D'**)0 1974-01-10
1 1974-01-20
2 1974-01-30
Name: date, dtype: datetime64[ns]>>> df['date'].astype(**'datetime64[D]'**)0 1974-01-10
1 1974-01-20
2 1974-01-30
Name: date, dtype: datetime64[ns]
2.将字符串转换为日期时间
通常，您会发现日期被表示为字符串。在熊猫中，字符串显示为对象，这是熊猫内部的行话，表示字符串。
>>> df = pd.DataFrame({**'date':['3/10/2015','3/11/2015','3/12/2015']**,
'value': [2, 3, 4]})
>>> df.dtypes**date object**
value int64
dtype: object
to_datetime()和astype()都可以用来将字符串转换成日期时间。
>>> pd.**to_datetime(df['date'])**0 2015-03-10
1 2015-03-11
2 2015-03-12
Name: date, dtype: datetime64[ns]>>> df['date'].**astype('datetime64')**0 2015-03-10
1 2015-03-11
2 2015-03-12
Name: date, dtype: datetime64[ns]
3.处理第一天格式
默认情况下，to_datetime()会先解析月( MM/DD 、 MM DD、或 MM-DD )格式的字符串，这种安排在美国是比较独特的。
在世界上大多数其他地方，首先写的是日期( DD/MM 、 DD MM 或 DD-MM )。如果你想让熊猫先考虑日子而不是月份，你可以将参数dayfirst设置为True。
df = pd.DataFrame({**'date': ['3/10/2000', '3/11/2000', '3/12/2000']**,
'value': [2, 3, 4]})df['date'] = pd.to_datetime(df['date'], **dayfirst=True**)
作者图片
或者，您可以将自定义格式传递给参数format。
4.处理自定义日期时间格式
默认情况下，使用来自dateutil.parser.parse的 Pandas 内置解析器解析字符串。有时，您的字符串可能是自定义格式，例如， YYYY-d-m HH:MM:SS 。Pandas to_datetime()有一个名为format的参数，允许您传递自定义格式:
df = pd.DataFrame({**'date': ['2016-6-10 20:30:0',
'2016-7-1 19:45:30',
'2013-10-12 4:5:1']**,
'value': [2, 3, 4]})df['date'] = pd.to_datetime(df['date'], **format="%Y-%d-%m %H:%M:%S"**)
作者图片
4.处理分析错误
如果一个日期不符合时间戳限制，我们将在转换时得到一个 ParseError 。例如，一个无效的字符串a/11/2000:
df = pd.DataFrame({'date': ['3/10/2000', **'a/11/2000'**, '3/12/2000'],
'value': [2, 3, 4]})# Getting ParseError
df['date'] = pd.to_datetime(df['date'])
作者图片
to_datetime()有一个名为errors的参数，允许您忽略错误或将无效值强制给NaT。
df['date'] = pd.to_datetime(df['date'], **errors='ignore'**)
df
作者图片
并将无效值强制到NaT:
df['date'] = pd.to_datetime(df['date'], **errors='coerce'**)
作者图片
6.处理缺失值
在 Pandas 中，缺失值被赋予值NaN，这是“不是一个数字”的缩写。
df = pd.DataFrame({'date': ['3/10/2000', **np.nan**, '3/12/2000'],
'value': [2, 3, 4]})
当将缺少值的列转换为日期时间时，to_datetime()和 astype()都将 Numpy 的NaN更改为 Pandas 的NaT，这允许它成为日期时间。
>>> df['date']**.astype('datetime64')**0 2000-03-10
1 **NaT**
2 2000-03-12
Name: date, dtype: datetime64[ns]>>> pd.**to_datetime(df['date'])**0 2000-03-10
1 **NaT**
2 2000-03-12
Name: date, dtype: datetime64[ns]
或者，我们可以用另一个值替换 Numpy NaN(例如用 '3/11/2000'替换NaN)
df = pd.DataFrame({'date': ['3/10/2000', np.nan, '3/12/2000'],
'value': [2, 3, 4]})df['date'] = df['date'].fillna('3/11/2000').astype('datetime64[ns]')
了解有关使用缺失值的更多信息
7.从多个列组合日期时间
to_datetime()也可以用于从多个列组合一个日期时间。键(列标签)可以是常见的缩写，如 ['年'，'月'，'日'，'分钟'，'秒'，'毫秒'，'美国'，' ns']) 或相同的复数。
df = pd.DataFrame({'year': [2015, 2016],
'month': [2, 3],
'day': [4, 5],
'hour': [10,11]
})
从列的子集创建日期时间列
>>> pd.to_datetime(**df[['month','day','year']]**)0 2015-02-04
1 2016-03-05
dtype: datetime64[ns]
从整个数据帧创建日期时间列
>>> pd.**to_datetime(df)**0 2015-02-04 10:00:00
1 2016-03-05 11:00:00
dtype: datetime64[ns]
8.一次转换多列
到目前为止，我们一直在一次一列地转换数据类型。有一个 DataFrame 方法也叫做astype()，它允许我们一次转换多个列数据类型。当您有一大堆要更改的列时，这样可以节省时间。
df = df.astype({
**'date_start': 'datetime64',
'date_end': 'datetime64'**
})
9.读取 CSV 文件时解析日期列
如果您想在读取 CSV 文件时设置每一列的数据类型，您可以在使用read_csv()加载数据时使用参数parse_date:
注意数据类型datetime64不被dtype支持，我们应该使用parse_dates参数。
df = pd.read_csv(
'dataset.csv',
dtype={
**# datetime64[ns] is not supported**
'value': 'float16'
},
**parse_dates=['date']**
)
要了解更多关于用 Pandas read_csv()解析日期列的信息:
</4-tricks-you-should-know-to-parse-date-columns-with-pandas-read-csv-27355bb2ad0e>
10.astype('datetime64')和to_datetime()的区别
astype()是将数据类型从一种转换到另一种的常用方法。Pandas DataFrame 和 Series 都支持该方法。如果您需要转换一组列，那么astype()应该是首选，因为它:
- 可以一次转换多列
- 具有最佳性能(如下图所示)
然而，astype()对于包含无效数据的列不起作用。例如，无效的日期字符串a/11/2000。如果我们尝试使用astype()，我们会得到一个 ParseError 。从 Pandas 0.20.0 开始，这个错误可以通过设置参数errors='ignore',来抑制，但是您的原始数据将原封不动地返回。
Pandas to_datetime()函数可以更好地处理这些值。与其失败，我们可以设置参数errors='coerce'来强制无效值为NaT。
此外，在处理自定义日期时间格式时，使用astype()可能会非常困难。熊猫to_datetime()有一个叫format的说法，在习俗转换的方式上提供了更多的可能性。
结论
我们已经看到了如何使用astype()和to_datetime()将 Pandas 数据列转换为 datetime 类型。to_datetime()是最简单的方法，在自定义转换的方式中提供了错误处理和更多的可能性，而astype()具有更好的性能，可以一次转换多个列。
我希望这篇文章能帮助你节省学习熊猫的时间。我建议您查看一下astypes()和to_datetime() API 的文档，并了解您可以做的其他事情。
感谢阅读。请查看笔记本获取源代码，如果您对机器学习的实用方面感兴趣，请继续关注。
你可能会对我的其他一些熊猫文章感兴趣:
- 在 Pandas 中把数据转换成数字类型的 10 个技巧
- 熊猫 json_normalize()你应该知道的扁平化 JSON
- 所有熊猫切()你应该知道把数值数据转换成分类数据
- 使用熊猫方法链接提高代码可读性
- 如何对熊猫数据帧进行自定义排序
- 数据分析你应该知道的所有熊猫移位()
- 何时使用 Pandas transform()函数
- 你应该知道的熊猫串联()招数
- 所有的熊猫合并()你应该知道
- 在熊猫数据帧中处理日期时间
- 熊猫阅读 _csv()你应该知道的招数
- 用 Pandas read_csv() 解析日期列应该知道的 4 个技巧
更多教程可以在我的 Github 上找到
数据科学家的 10 个有用的 Jupyter 笔记本扩展
这些 Jupyter 笔记本扩展使数据科学家的生活更加轻松
每个数据科学家都把大部分时间花在数据可视化、预处理和基于结果的模型调优上。对于每个数据科学家来说，这些都是最困难的情况，因为当你精确地执行所有这三个步骤时，你将得到一个好的模型。在这些情况下，有 10 个非常有用的 jupyter 笔记本扩展可以提供帮助。
1.Qgrid
Qgrid 是一个 Jupyter 笔记本小部件，它使用 SlickGrid 在 Jupyter 笔记本中呈现熊猫数据帧。这使您可以通过直观的滚动、排序和过滤控件来浏览数据框，并通过双击单元格来编辑数据框。
安装:
pip install qgrid #Installing with pipconda install qgrid #Installing with conda
2.itables
ITables 将熊猫的数据帧和数据系列转化为你的笔记本和 HTML 格式的交互式数据表。ITables 使用基本的 Javascript，正因为如此，它只能在 Jupyter Notebook 中工作，而不能在 JupyterLab 中工作。
安装:
pip install itables
使用激活所有系列和数据帧的交互模式
from itables import init_notebook_mode
init_notebook_mode(all_interactive=True)import world_bank_data as wb
df = wb.get_countries()
df
3.Jupyter 数据表
数据科学家和实际上许多开发人员每天都在使用 dataframe 来解释和处理数据。常见的工作流程是显示数据帧，查看数据模式，然后绘制多个图来检查数据的分布情况，以便有一个更清晰的图像，也许是在表中搜索一些数据，等等...
如果这些分布图是标准数据框架的一部分，并且我们能够以最小的努力快速搜索整个表，会怎么样？如果这是默认的表示呢？
jupyter-datatables 使用 jupyter-require 来绘制表格。
安装:
pip install jupyter-datatables
使用
from jupyter_datatables import init_datatables_mode
init_datatables_mode()
4.ipy 卷
ipyvolume 使用 WebGL，基于 IPython 小部件，帮助在 Jupyter 笔记本中进行 Python 的 3d 绘图。
Ipyvolume 当前可以
- 进行(多重)体绘制。
- 创建散点图(最多约 1 百万个字形)。
- 创建箭图(类似散点图，但箭头指向特定方向)。
- 做套索鼠标选择。
- 使用谷歌 Cardboard 渲染虚拟现实的立体效果。
- 例如，如果散点图的 x 坐标或颜色发生变化，则以 d3 风格制作动画。
- 动画/序列，所有散布/颤动图属性可以是数组列表，其可以表示时间快照等。
装置
$ pip install ipyvolume #Installing with pip$ conda install -c conda-forge ipyvolume #Installing with conda
5.bqplot
bqplot 是 Jupyter 的一个二维可视化系统，基于图形语法的构造。
目标
- 用 pythonic API 为二维可视化提供统一的框架。
- 为添加用户交互(平移、缩放、选择等)提供一个合理的 API
提供了两个 API
- 用户可以使用内部对象模型构建自定义可视化，该模型受图形语法(图形、标记、轴、比例)的启发，并通过我们的交互层丰富他们的可视化。
- 或者他们可以使用基于上下文的 API，类似于 Matplotlib 的 pyplot，它为大多数参数提供了明智的默认选择。
装置
$ pip install bqplot #Installing with pip$ conda install -c conda-forge bqplot #Installing with conda
6.活线图
不要蒙着眼睛训练深度学习模型！不要急躁，看看你训练的每一个时期！
livelossplot 为 Keras、PyTorch 等框架提供了 Jupyter 笔记本中的现场训练损耗图。
装置
pip install livelossplot
使用
from livelossplot import PlotLossesKeras
model.fit(X_train, Y_train,
epochs=10,
validation_data=(X_test, Y_test),
callbacks=[PlotLossesKeras()],
verbose=0)
7.张量手表
TensorWatch 是微软研究院为数据科学、深度学习和强化学习设计的调试和可视化工具。它在 Jupyter Notebook 中工作，以显示您的机器学习训练的实时可视化，并对您的模型和数据执行其他几个关键的分析任务。
装置
pip install tensorwatch
8.多轴
Polyaxon 是一个用于构建、培训和监控大规模深度学习应用的平台。我们正在制作一个系统来解决机器学习应用的可重复性、自动化和可扩展性。Polyaxon 部署到任何数据中心、云提供商，或者可以由 Polyaxon 托管和管理，它支持所有主要的深度学习框架，如 Tensorflow、MXNet、Caffe、Torch 等。
装置
$ pip install -U polyaxon
9.手摇计算器
handcalcs 是一个在 Latex 中自动呈现 Python 计算代码的库，但是它模仿了用铅笔书写计算时的格式:编写符号公式，然后是数字替换，最后是结果。
装置
pip install handcalcs
10.jupyternotify
jupyternotify 提供了一个 Jupyter 笔记本单元格魔术%%notify，它通过浏览器推送通知在潜在的长时间运行的单元格完成时通知用户。用例包括长期运行的机器学习模型、网格搜索或 Spark 计算。这种魔力允许你导航到其他工作，并且当你的单元完成时仍然得到通知。
装置
pip install jupyternotify
感谢您的阅读！
非常感谢您的任何反馈和意见！
加速 Python 代码的 10 种方法
Python 很灵活，但也可能很慢。让我们加快速度。
Python 是我最喜欢使用的语言之一。它很容易学习，有一个优秀的开源库选择，并且有一个非常活跃和有用的社区。将所有这些添加到 Python 的灵活性中，就很容易理解为什么世界上有这么多开发人员采用 Python 了。
到目前为止，Python 也是我从事数据科学工作的首选语言。我从来不觉得 r 很有条理，Python 对机器学习库的访问历史上比 r 好得多，然而，当涉及到处理大量数据时，Python 可能真的很慢。与使用 C 和 C++这样的语言相比，Python 有时会感觉太慢。幸运的是，有一些很棒的库和内置函数可以加速 Python 代码。
列出理解
列表理解是创建列表的一种非常 Pythonic 化的方式。假设我们要对所有小于 100，000 的偶数求平方，并将它们追加到一个列表中。如果我们使用 for 循环，我们可以这样做:
时间:16.2 毫秒(作者创作)
这是可行的，但是我们可以通过使用一种叫做列表理解的东西来节省一些时间和清理我们的代码。
时间:13.9 毫秒(作者创作)
正如我们所见，Python 允许我们在[]操作符内部构造一个列表。它甚至允许我们添加一个条件语句来检查偶数。
虽然这显然节省了空间，但为什么会使它更快呢？主要原因是我们正在按需构建列表，而不需要在循环的每次迭代中调用append()。在循环示例中，我们加载了append属性，然后在循环的每次迭代中作为函数调用它。
列表理解可以被处理到许多代码库中数量惊人的地方，并且可以允许累积的巨大性能提升。它们只是可读性较差，所以在更复杂的列表理解上留下注释不失为一个好主意。
使用内置函数
python 的许多内置函数都是用 C 编写的，这使得它们比纯 Python 解决方案要快得多。拿一个简单的任务来说，就是将许多数字相加。我们可以遍历每个数字，边走边求和。然而，Python 为我们提供了sum()函数，它带来了令人难以置信的性能提升。
时间循环:389 毫秒，内置时间:245 毫秒(作者创作)
Python 中有很多内置函数，你可以在这里找到。
函数调用是昂贵的
Python 中函数调用的开销很大。虽然将代码分成函数通常是一种很好的做法，但有时您应该小心从循环内部调用函数。在函数内部迭代比每次迭代都要迭代调用一个函数要好。看看下面的例子，我们想要创建一个范围为 1–1，000，000 的平方值列表。
时间:314 毫秒(作者创作)
时间:245 毫秒(作者创作)
我们可以看到，第二种方法在所有条件都相同的情况下比使用函数来计算值的平方要快得多。函数有很多开销，所以对于像这样简单的任务，相对于总时间来说，它们会增加很多时间。
惰性模块导入
传统上，Python 文件会在顶部导入所有需要的库。这意味着无论何时文件被导入或作为脚本运行，所有这些库都会被导入。如果有只在特定情况下需要的模块，我们不一定总是需要导入它们。相反，我们可以只在需要的时候导入它们，避免在不必要的时候加载它们的开销。
利用 Numpy
Numpy 是一个用 c 语言构建的高度优化的库。将数学卸载给 Numpy 比依赖 Python 解释器几乎总是更快。Numpy 还拥有超高效的数据结构，用于保存矩阵数据，比 Python 内置的数据结构开销更少。
如果我们想对列表中的每个元素求平方，我们可以这样做:
时间:300 毫秒(由作者创作)
这很好，但是让我们看看 Numpy 能快多少。
时间:602μs(作者创作)
哇！这比在 Python 中使用列表要快得多。Numpy 用 Python 打开了科学计算的各种可能性。如果你使用大量的矩阵，那么成为一名数字大师是非常值得的。还记得之前的sum()内置函数吗？使用 Numpy，我们还可以降低它的性能:
时长:193 毫秒，时长:22.8 毫秒(作者创作)
Numpy 可以给 Python 中的数学带来难以置信的性能提升，但是，您必须非常小心地坚持使用 Numpy 数据结构和方法来实现这种级别的优化。在这种情况下，简单地错误创建阵列会抵消性能提升:
时间:952 毫秒(作者创作)
这比简单地使用内置的 Python 方法要慢得多，这是由于在 Python 和 Numpy 数据结构之间转换花费了时间。因此，请记住，虽然 Numpy 可以很好地处理 Python 数据结构，但是单独使用 Numpy 时会快得多。
尝试多重处理
多重处理可以为 Python 脚本带来巨大的性能提升，但是与本文中提到的其他方法相比，它可能很难正确实现。
大多数现代消费类计算机都有 2 到 16 个内核。Python 在处理代码时通常被限制在一个内核，但是使用multiprocessing库允许我们利用多个内核。在非常受 CPU 限制的问题中，将工作分配给几个处理器确实有助于加快速度。
由作者创建
时间:35.566 秒(由 Auth
时间:98.99 秒(作者创造)
在这种情况下，我有一个非常大的三维矩阵，由数以千计的卫星图像叠加而成。我需要对整个时间序列中的每个像素进行过滤。对图像的每个像素重复这一过程需要相当长的时间，因此我们可以使用多重处理在机器上所有可用的处理器之间分配工作。为此，我简单地将立方体分成尽可能多的可用处理器块，并将函数应用于每个块。一旦所有的块都完成了，我就简单地把它们连接起来得到一个最终的产品。
请记住，多重处理不能补偿未优化的代码。我经常把多重处理作为我运行的代码尽可能快后的最后一步。我们可以看到，尽管将工作分布在 24 个内核上，但我们只实现了 3 倍的速度提升。这是由于拆分/重组数据和管理多处理池的开销。
由于多处理池有相当大的开销，所以在我无法进一步加速代码的情况下，它们往往工作得最好。我没有进一步优化filterfunc，而是将问题分配给更多的工人。想象一下苹果公司需要加倍生产手机。他们可以花更多的时间来培训工人，以提高生产效率，或者他们可以从街上随便雇一大堆人。这两者之间可能存在一种平衡，可以达到最佳效果。
小心庞大的库
与其他编程语言相比，Python 的优势之一是开发人员可以选择丰富的第三方库。基本上，每个 Python 包都有一个依赖项列表，用来完成自己的目标。由于 Python 库的数量庞大，几乎总是有不止一个库可以完成相同的任务。
但是，我们可能不总是考虑我们作为依赖项使用的库的大小。几个月前，我正在开发一个 AWS Lambda 函数，它从数据库中获取路径数据，然后将附近的路径连接成一个往返行程。由于有太多的 Python 依赖项，我遇到了 AWS Lambda 环境的大小限制。在逐一检查了我的依赖项之后，我意识到我正在使用 scikit-learn 来完成一个简单的任务，我可能可以用其他方法来完成它。原来 Cartopy 在一个更小的库中支持一个非常相似的特性，使我的环境适合 AWS Lambda。
除了大小限制之外，减小环境的大小可以提高每次使用时的速度。如果您可以减少依赖项的数量，那么您也可以降低将来遇到依赖项冲突的风险。
避免全局变量
我们通常在计算机科学项目的早期就知道 Python 中的全局变量不是最佳实践。通常最好使用局部变量来更好地跟踪作用域和内存使用情况。但是除了内存使用，Python 在检索局部变量时也比全局变量稍快。因此，最好尽可能避免全局变量。
尝试多种解决方案
我们从 Numpy 示例中看到，花时间考虑您正在使用的数据结构和方法会对代码的速度产生重大影响。当我们第一次开始学习 Python 时，能够用多种方法解决一个问题是很好的。但是，通常有一种解决方案比其他解决方案更快，有时这归结于使用不同的方法或数据结构。
以计算一长段文本中字母的出现次数为例。collections.Counter通常是对数据结构中的唯一项进行计数的一种非常快速的方法。然而，Python 有一个专门针对字符串进行优化的方法。
由作者创建
时间:17.2 毫秒(作者创作)
318 毫秒(作者创作)
这里我们可以看到内置的str.count方法如何在这个特定的任务中快得多。这是因为Counter()是一个通用工具，可以用来计数的不仅仅是字符串中的字符，而str.count经过了大量优化，可以搜索字符串中的字符。这意味着str.count可以使用底层 C char工作，而不必处理 Python 字符串的迭代。
想想你的数据结构
Python 倾向于抽象掉一些我们很多人在最初的 C++课程中学到的数据结构，但它们仍然存在。由于 Python 处理许多常见数据结构的构造，我认为许多人倾向于忘记它们各自拥有的相对优势。
例如，Python 中的集合和字典具有 O(1)查找性能，因为它们使用哈希表。大多数 Python 用户默认使用列表，然而，有些情况下字典或集合更有意义。
搜索一个字典或集合非常快，但是列表花费的时间与列表的长度成正比。但是，集合和字典不保持顺序。如果你关心数据的顺序，你不能使用字典或集合。
举个例子，假设我们正在处理数百万个数字并存储结果。我们希望创建一个查找表，以便快速查看是否已经计算了某个值。就速度而言，列表应该是 O(n ),字典应该是 O(1)。然而，字典的内存消耗比列表大得多，因为它也存储哈希表。如果我们正在向列表中添加新的条目，我们可能需要使用字典。但是，如果我们只是把它作为一个查找表，它是可能的排序列表和使用二分搜索法可能会更快，这取决于数据类型。排序列表上的二分搜索法是 O(log n)，这对于整数/浮点数据来说可能更快。
包扎
希望其中的一些技巧能够帮助你在将来编写更快的 Python 代码。Python 可能不是我们所掌握的最快的编程语言，但它是最灵活的语言之一。我们让 Python 运行得越快，我们就越接近一种既灵活又极具性能的语言。
Python 的诀窍是利用用 c 语言构建的高度优化的函数。虽然总是实现自己的问题解决方案很诱人，但熟悉一下已经可用的令人难以置信的工具还是很有价值的。
资源
在喝完早餐咖啡之前，你可以学习 100 个有用的 Python 技巧
34.字符串和元组是不可变的
Python 现在很流行，主要是因为它简单易学。
你可以用它来完成各种各样的任务，比如数据科学和机器学习、web 开发、脚本、自动化等等。
既然这是一篇相当长的文章，而且你想在喝完咖啡之前就看完，我们为什么不直接开始呢？
好了，我们开始吧…
1.“for”循环中的“Else”条件
尽管到目前为止您已经看到了所有的 Python 代码，但是您可能错过了下面的“for-else ”,这也是我在几周前第一次看到的。
这是一个遍历列表的“for-else”方法，尽管遍历了一个列表，但是还有一个“else”条件，这很不寻常。
这是我在 Java、Ruby 或 JavaScript 等其他编程语言中从未见过的。
让我们来看一个它在实践中的例子。
假设我们试图检查一个列表中是否没有奇数。
让我们迭代一下:
numbers = [2, 4, 6, 8, 1]
for number in numbers:
if number % 2 == 1:
print(number)
break
else:
print("No odd numbers")
如果我们发现一个奇数，那么该数字将被打印，因为 中断 将被执行，而 否则 分支将被跳过。
否则，如果 break 从未执行，执行流程将继续 else 分支。
在这个例子中，我们将打印 1。
2.使用命名变量从列表中获取元素
my_list = [1, 2, 3, 4, 5]one, two, three, four, five = my_list
3.使用模块 heapq 获得列表中 n 个最大或 n 个最小的元素
import heapq
scores = [51, 33, 64, 87, 91, 75, 15, 49, 33, 82]
print(heapq.nlargest(3, scores)) # [91, 87, 82]
print(heapq.nsmallest(5, scores)) # [15, 33, 33, 49, 51]
4.将列表中的值作为方法参数传递
我们可以使用“*”提取列表中的所有元素:
my_list = [1, 2, 3, 4]print(my_list) # [1, 2, 3, 4]
print(*my_list) # 1 2 3 4
这在我们希望将列表中的所有元素作为方法参数传递的情况下很有帮助:
def sum_of_elements(*arg):
total = 0
for i in arg:
total += i
return total
result = sum_of_elements(*[1, 2, 3, 4])
print(result) # 10
5。获取列表中间的所有元素
_, *elements_in_the_middle, _ = [1, 2, 3, 4, 5, 6, 7, 8]print(elements_in_the_middle) # [2, 3, 4, 5, 6, 7]
6.仅在一行中分配多个变量
one, two, three, four = 1, 2, 3, 4
7.列出理解
您可以非常全面地在一行中遍历列表中的元素。
让我们看看下面的例子:
numbers = [1, 2, 3, 4, 5, 6, 7, 8]
even_numbers = [number for number in numbers if number % 2 == 0]
print(even_numbers) # [2, 4, 6, 8]
我们可以对字典、集合和生成器做同样的事情。
让我们看另一个例子，但现在是字典。
dictionary = {'first_element': 1, 'second_element': 2,
'third_element': 3, 'fourth_element': 4}odd_value_elements = {key: num for (key, num) in
dictionary.items() if num % 2 == 1}print(odd_value_elements) # {'first_element': 1, 'third_element': 3}
这个例子的灵感来自于这篇 文章 。
8.通过 Enum 枚举相同概念的相关项目
来自文档:
An Enum is a set of symbolic names bound to unique values. They are similar to global variables, but they offer a more useful repr(), grouping, type-safety, and a few other features.
这里有一个例子:
from enum import Enum
class Status(Enum):
NO_STATUS = -1
NOT_STARTED = 0
IN_PROGRESS = 1
COMPLETED = 2
print(Status.IN_PROGRESS.name) # IN_PROGRESS
print(Status.COMPLETED.value) # 2
9.不循环地重复字符串
string = "Abc"
print(string * 5) # AbcAbcAbcAbcAbc
10.像数学一样比较 3 个数字
如果你有一个值，你想比较它是否在其他两个值之间，有一个简单的数学表达式:
1 < x < 10
那是我们小学学的代数表达式。但是，您也可以在 Python 中使用相同的表达式。
是的，你没听错。到目前为止，您可能已经对这种形式进行了比较:
1 < x 和 x < 10
为此，您只需在 Python 中使用以下代码:
1 < x < 10
这在 Ruby 中是行不通的，Ruby 是一种为了让程序员开心而开发的编程语言。这在 JavaScript 中也同样有效。
看到这样一个简单的表达没有被更广泛地谈论，我真的印象深刻。至少，我没见过它被提到那么多。
11.将字典合并成一行
这从 Python 3.9 开始可用:
first_dictionary = {'name': 'Fatos', 'location': 'Munich'}
second_dictionary = {'name': 'Fatos', 'surname': 'Morina',
'location': 'Bavaria, Munich'}
result = first_dictionary | second_dictionary
print(result)
# {'name': 'Fatos', 'location': 'Bavaria, Munich', 'surname': 'Morina'}
12.查找元组中元素的索引
books = ('Atomic habits', 'Ego is the enemy', 'Outliers', 'Mastery')
print(books.index('Mastery')) # 3
13.将字符串转换成字符串列表
假设您在一个函数中获得的输入是一个字符串，但它应该是一个列表:
input = "[1,2,3]"
你不需要那种格式的。你需要它是一个列表:
input = [1,2,3]
或者，您可能会从 API 调用中得到以下响应:
input = [[1, 2, 3], [4, 5, 6]]
您不必为复杂的正则表达式而烦恼，您所要做的就是导入模块 ast ，然后调用它的方法 literal_eval :
import ast
def string_to_list(string):
return ast.literal_eval(string)
这就是你需要做的。
现在你将得到一个列表或列表列表，如下所示:
import ast
def string_to_list(string):
return ast.literal_eval(string)
string = "[[1, 2, 3],[4, 5, 6]]"
my_list = string_to_list(string)
print(my_list) # [[1, 2, 3], [4, 5, 6]]
14.通过使用命名参数来避免“琐碎”的错误
让我们假设你想找出两个数的区别。这种差异是不可交换的:
a - b != b -a
然而，我们可能会忘记参数的排序，这会导致“微不足道”的错误:
def subtract(a, b):
return a - b
print((subtract(1, 3))) # -2
print((subtract(3, 1))) # 2
为了避免这种潜在的错误，我们可以简单地使用命名参数，参数的顺序不再重要:
def subtract(a, b):
return a - b
print((subtract(a=1, b=3))) # -2
print((subtract(b=3, a=1))) # -2
15.用一个 Print()语句打印多个元素
print(1, 2, 3, "a", "z", "this is here", "here is something else")
16.在同一行打印多个元素
print("Hello", end="")
print("World") # HelloWorld
print("Hello", end=" ")
print("World") # Hello World
print('words', 'with', 'commas', 'in', 'between', sep=', ')
# words, with, commas, in, between
17.打印多个值，每个值之间使用自定义分隔符
您可以非常轻松地进行高级打印:
print("29", "01", "2022", sep="/") # 29/01/2022print("name", "domain.com", sep="@") # name@domain.com
18.变量名称的开头不能使用数字
four_letters = “abcd” # this works4_letters = “abcd” # this doesn’t work
19.不能在变量名的开头使用运算符
+variable = “abcd” # this doesn’t work
20.数字的第一个数字不能是 0
number = 0110 # this doesn't work
21.您可以在变量名称的任何地方使用下划线字符
这意味着，在任何你想要的地方，在一个变量的名字里，你想要多少次就有多少次:
a______b = "abcd" # this works
_a_b_c_d = "abcd" # this also works
我并不鼓励你使用它，但是如果你看到一个像那样奇怪的变量命名，要知道它实际上是一个有效的变量名称。
22.您可以用下划线分隔大数字
这样可以更容易阅读它们。
print(1_000_000_000) # 1000000000
print(1_234_567) # 1234567
23.颠倒列表的顺序
my_list = ['a', 'b', 'c', 'd']
my_list.reverse()
print(my_list) # ['d', 'c', 'b', 'a']
24.使用阶跃函数对字符串进行切片
my_string = "This is just a sentence"
print(my_string[0:5]) # This
# Take three steps forward
print(my_string[0:10:3]) # Tsse
25.反向切片
my_string = "This is just a sentence"
print(my_string[10:0:-1]) # suj si sih
# Take two steps forward
print(my_string[10:0:-2]) # sjs i
26.仅具有开始或结束索引的部分切片
指示切片的开始和结束的索引可以是可选的。
my_string = "This is just a sentence"
print(my_string[4:]) # is just a sentence
print(my_string[:3]) # Thi
27.楼层划分
print(3/2) # 1.5
print(3//2) # 1
28.==和“是”的区别
“is”检查两个变量是否指向内存中的同一个对象。
" == "比较这两个对象拥有的值是否相等。
first_list = [1, 2, 3]
second_list = [1, 2, 3]
# Is their actual value the same?
print(first_list == second_list) # True
# Are they pointing to the same object in memory
print(first_list is second_list)
# False, since they have same values, but in different objects in memory
third_list = first_list
print(third_list is first_list)
# True, since both point to the same object in memory
29.快速合并 2 本词典
dictionary_one = {"a": 1, "b": 2}
dictionary_two = {"c": 3, "d": 4}
merged = {**dictionary_one, **dictionary_two}
print(merged) # {'a': 1, 'b': 2, 'c': 3, 'd': 4}
30.检查一个字符串是否大于另一个字符串
first = "abc"
second = "def"
print(first < second) # True
second = "ab"
print(first < second) # False
31.检查字符串是否以特定字符开头，而不使用索引 0
my_string = "abcdef"
print(my_string.startswith("b")) # False
32.使用 id()查找变量的唯一 id
print(id(1)) # 4325776624
print(id(2)) # 4325776656
print(id("string")) # 4327978288
33.整数、浮点、字符串、布尔和元组是不可变的
当我们把一个变量赋给一个不可变的类型，比如整型、浮点型、字符串型、布尔型和元组型，那么这个变量就指向内存中的一个对象。
如果我们给这个变量赋另一个值，原始对象仍然在内存中，但是指向它的变量丢失了:
number = 1
print(id(number)) # 4325215472
print(id(1)) # 4325215472
number = 3
print(id(number)) # 4325215536
print(id(1)) # 4325215472
34.字符串和元组是不可变的
这一点在前一点中已经提到过了，但我想强调一下，因为这非常重要。
name = "Fatos"
print(id(name)) # 4422282544name = "fatos"
print(id(name)) # 4422346608
my_tuple = (1, 2, 3, 4)
print(id(my_tuple)) # 4499290128
my_tuple = ('a', 'b')
print(id(my_tuple)) # 4498867584
35.列表、集合和字典是可变的
这意味着我们可以改变对象而不会失去对它的绑定:
cities = ["Munich", "Zurich", "London"]
print(id(cities)) # 4482699712
cities.append("Berlin")
print(id(cities)) # 4482699712
这是另一个集合的例子:
my_set = {1, 2, 3, 4}
print(id(my_set)) # 4352726176my_set.add(5)
print(id(my_set)) # 4352726176
36.你可以把一个集合变成一个不可变的集合
这样，您就不能再修改它了:
my_set = frozenset(['a', 'b', 'c', 'd'])
my_set.add("a")
如果这样做，将会引发一个错误:
AttributeError: 'frozenset' object has no attribute 'add'
37.“if-elif”块可以在末尾没有 else 块的情况下存在
然而，如果前面没有“如果”步骤，“elif”就不能独立存在:
def check_number(number):
if number > 0:
return "Positive"
elif number == 0:
return "Zero"
return "Negative"
print(check_number(1)) # Positive
38.使用 sorted() 检查两个字符串是否是变位词
def check_if_anagram(first_word, second_word):
first_word = first_word.lower()
second_word = second_word.lower()
return sorted(first_word) == sorted(second_word)print(check_if_anagram("testinG", "Testing")) # True
print(check_if_anagram("Here", "Rehe")) # True
print(check_if_anagram("Know", "Now")) # False
39.获取 Unicode 中字符的值
print(ord("A")) # 65
print(ord("B")) # 66
print(ord("C")) # 66
print(ord("a")) # 97
40.在一行中获取字典的键
dictionary = {"a": 1, "b": 2, "c": 3}
keys = dictionary.keys()
print(list(keys)) # ['a', 'b', 'c']
41.在一行中获取字典的值
dictionary = {"a": 1, "b": 2, "c": 3}
values = dictionary.values()
print(list(values)) # [1, 2, 3]
42.交换字典的键和值
dictionary = {"a": 1, "b": 2, "c": 3}
reversed_dictionary = {j: i for i, j in dictionary.items()}
print(reversed) # {1: 'a', 2: 'b', 3: 'c'}
43.您可以将布尔值转换为数字
print(int(False)) # 0
print(float(True)) # 1.0
44.您可以在算术运算中使用布尔值
“假”是 0，而“真”是 1。
x = 10
y = 12
result = (x - False)/(y * True)
print(result) # 0.8333333333333334
45.您可以将任何数据类型转换为布尔值
print(bool(.0)) # False
print(bool(3)) # True
print(bool("-")) # True
print(bool("string")) # True
print(bool(" ")) # True
46.将数值转换成复数
print(complex(10, 2)) # (10+2j)
您也可以将一个数字转换成十六进制数字:
print(hex(11)) # 0xb
47.在列表的第一个位置添加一个值
如果您使用 append() ，您将从右边插入新值。
我们也可以使用 insert() 来指定索引和我们想要插入这个新元素的元素。在我们的例子中，我们希望将它插入第一个位置，所以我们使用 0 作为索引:
my_list = [3, 4, 5]
my_list.append(6)
my_list.insert(0, 2)
print(my_list) # [2, 3, 4, 5, 6]
48.Lambda 函数只能在一行中
lambdas 不能出现在多行中。
让我们试试下面的方法:
comparison = lambda x: if x > 3:
print("x > 3")
else:
print("x is not greater than 3")
将会引发以下错误:
result = lambda x: if x > 3:
^
SyntaxError: invalid syntax
49.lambda 中的条件语句应该总是包含“else”部分
让我们试试下面的方法:
comparison = lambda x: "x > 3" if x > 3
我们将得到以下错误:
comparison = lambda x: "x > 3" if x > 3
^
SyntaxError: invalid syntax
注意，这是条件表达式的一个特性，而不是λ本身的一个特性。
50.filter()返回一个新对象
my_list = [1, 2, 3, 4]
odd = filter(lambda x: x % 2 == 1, my_list)
print(list(odd)) # [1, 3]
print(my_list) # [1, 2, 3, 4]
51.map()返回一个新对象
my_list = [1, 2, 3, 4]
squared = map(lambda x: x ** 2, my_list)
print(list(squared)) # [1, 4, 9, 16]
print(my_list) # [1, 2, 3, 4]
52.range()包含一个可能不太为人所知的步长参数
for number in range(1, 10, 3):
print(number, end=" ")
# 1 4 7
53.默认情况下，range()从 0 开始
所以完全不需要包含。
def range_with_zero(number):
for i in range(0, number):
print(i, end=' ')
def range_with_no_zero(number):
for i in range(number):
print(i, end=' ')
range_with_zero(3) # 0 1 2
range_with_no_zero(3) # 0 1 2
54.不需要和 0 比较长度
如果长度大于 0，则默认为真，所以实际上不需要与 0 进行比较:
def get_element_with_comparison(my_list):
if len(my_list) > 0:
return my_list[0]
def get_first_element(my_list):
if len(my_list):
return my_list[0]
elements = [1, 2, 3, 4]
first_result = get_element_with_comparison(elements)
second_result = get_element_with_comparison(elements)
print(first_result == second_result) # True
55.您可以在同一范围内多次定义同一方法
然而，只有最后一个被调用，因为它覆盖了前面的。
def get_address():
return "First address"
def get_address():
return "Second address"
def get_address():
return "Third address"
print(get_address()) # Third address
56.您甚至可以在私有属性的预期范围之外访问私有属性
class Engineer:
def __init__(self, name):
self.name = name
self.__starting_salary = 62000
dain = Engineer('Dain')
print(dain._Engineer__starting_salary) # 62000
57.检查对象的内存使用情况
import sys
print(sys.getsizeof("bitcoin")) # 56
58.您可以定义一个方法，使用任意多个参数调用该方法
def get_sum(*arguments):
result = 0
for i in arguments:
result += i
return result
print(get_sum(1, 2, 3)) # 6
print(get_sum(1, 2, 3, 4, 5)) # 15
print(get_sum(1, 2, 3, 4, 5, 6, 7)) # 28
59.你可以使用 super()或者父类的名字来调用父类的初始化器
使用 super() 调用父类初始化器:
class Parent:
def __init__(self, city, address):
self.city = city
self.address = address
class Child(Parent):
def __init__(self, city, address, university):
super().__init__(city, address)
self.university = university
child = Child('Zürich', 'Rämistrasse 101', 'ETH Zürich')
print(child.university) # ETH Zürich
使用父类的名称调用父类:
class Parent:
def __init__(self, city, address):
self.city = city
self.address = address
class Child(Parent):
def __init__(self, city, address, university):
Parent.__init__(self, city, address)
self.university = university
child = Child('Zürich', 'Rämistrasse 101', 'ETH Zürich')
print(child.university) # ETH Zürich
注意，使用 init() 和 super() 对父初始化器的调用只能在子类的初始化器内部使用。
60.您可以在自己的类中重新定义“+”运算符
每当您在两个 int 数据类型之间使用 + 运算符时，您将会找到它们的和。
然而，当您在两个字符串数据类型之间使用它时，您将合并它们:
print(10 + 1) # Adding two integers using '+'
print('first' + 'second') # Merging two strings '+'
这表示操作符过载。
您也可以在自己的类中使用它:
class Expenses:
def __init__(self, rent, groceries):
self.rent = rent
self.groceries = groceries
def __add__(self, other):
return Expenses(self.rent + other.rent,
self.groceries + other.groceries)
april_expenses = Expenses(1000, 200)
may_expenses = Expenses(1000, 300)
total_expenses = april_expenses + may_expenses
print(total_expenses.rent) # 2000
print(total_expenses.groceries) # 500
61.您也可以根据自己的需要重新定义“
Here is another example of an operation overloadding that you can define yourself:
class Game:
def __init__(self, score):
self.score = score
def __lt__(self, other):
return self.score < other.score
first = Game(1)
second = Game(2)
print(first < second) # True
Similarly, like the two previous cases, we can override the eq() 函数:
class Journey:
def __init__(self, location, destination, duration):
self.location = location
self.destination = destination
self.duration = duration
def __eq__(self, other):
return ((self.location == other.location) and
(self.destination == other.destination) and
(self.duration == other.duration))
first = Journey('Location A', 'Destination A', '30min')
second = Journey('Location B', 'Destination B', '30min')
print(first == second)
您也可以类似地定义:
- sub()用于 -
- mul()为 *****
- truediv() for /
- ne() for ！=
- ge() for >=
- gt() for >
62。您可以为 类的对象定义自定义的可打印版本
class Rectangle:
def __init__(self, a, b):
self.a = a
self.b = b
def __repr__(self):
return repr('Rectangle with area=' + str(self.a * self.b))
print(Rectangle(3, 4)) # 'Rectangle with area=12'
63.交换字符串中字符的大小写
string = "This is just a sentence."
result = string.swapcase()print(result) # *tHIS IS JUST A SENTENCE.*
64.检查字符串中的所有字符是否都是空格
string = " "
result = string.isspace()print(result) *# True*
65.检查字符串中的所有字符是字母还是数字
name = "Password"
print(name.isalnum()) # True, because all characters are alphabetsname = "Secure Password "
print(name.isalnum()) # False, because it contains whitespacesname = "S3cur3P4ssw0rd"
print(name.isalnum()) # Truename = "133"
print(name.isalnum()) # True, because all characters are numbers
66.检查字符串中的所有字符是否都是字母
string = "Name"
print(string.isalpha()) *# True*string = "Firstname Lastname"
print(string.isalpha()) *# False, because it contains whitespace*string = “P4ssw0rd”
print(string.isalpha()) *# False, because it contains numbers*
67.根据参数从右侧删除字符
string = "This is a sentence with "*# Remove trailing spaces from the right* print(string.rstrip()) *# "This is a sentence with"*string = "this here is a sentence…..,,,,aaaaasd"print(string.rstrip(“.,dsa”)) # "this here is a sentence"
同样，您可以根据参数从左侧删除字符:
string = "ffffffffFirst"print(string.lstrip(“f”)) *# First*
68.检查字符串是否代表数字
string = "seven"
print(string.isdigit()) *# False*string = "1337"
print(string.isdigit()) *# True*string = "5a"
print(string.isdigit()) *# False, because it contains the character 'a'*string = "2**5"
print(string.isdigit()) *# False*
69.检查一个字符串是否代表一个中文数字
# 42673 in Arabic numerals
string = "四二六七三"
print(string.isdigit()) # False
print(string.isnumeric()) # True
70.检查字符串中的所有单词是否都以大写字符开头
string = "This is a sentence"
print(string.istitle()) # False
string = "10 Python Tips"
print(string.istitle()) # True
string = "How to Print A String in Python"
# False, because of the first characters being lowercase in "to" and "in"
print(string.istitle())
string = "PYTHON"
print(string.istitle()) # False. It's titlelized version is "Python"
71.我们也可以在元组中使用负索引
numbers = (1, 2, 3, 4)
print(numbers[-1]) # 4
print(numbers[-4]) # 1
72.将列表和元组嵌套在元组中
mixed_tuple = (("a"*10, 3, 4), ['first', 'second', 'third'])
print(mixed_tuple[1]) # ['first', 'second', 'third']
print(mixed_tuple[0]) # ('aaaaaaaaaa', 3, 4)
73.快速计算满足条件的元素在列表中出现的次数
names = ["Besim", "Albert", "Besim", "Fisnik", "Meriton"]
print(names.count("Besim")) # 2
74.使用 slice()可以很容易地获得最后 n 个元素
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
slicing = slice(-4, None)# Getting the last 3 elements from the list
print(my_list[slicing]) # [4, 5, 6]# Getting only the third element starting from the right
print(my_list[-3]) # 4
您还可以使用 slice() 执行其他常规切片任务，例如:
string = "Data Science"# start = 1, stop = None (don't stop anywhere), step = 1
# contains 1, 3 and 5 indices
slice_object = slice(5, None)print(string[slice_object]) # Science
75.计算元素在元组中出现的次数
my_tuple = ('a', 1, 'f', 'a', 5, 'a')
print(my_tuple.count('a')) # 3
76.获取元组中元素的索引
my_tuple = ('a', 1, 'f', 'a', 5, 'a')print(my_tuple.index('f')) *#* 2
77.通过跳转获得子元组
my_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)print(my_tuple[::3]) # (1, 4, 7, 10)
78.从索引开始获取子元组
my_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)print(my_tuple[3:]) # *(4, 5, 6, 7, 8, 9, 10)*
79.从列表、集合或词典中删除所有元素
my_list = [1, 2, 3, 4]
my_list.clear()
print(my_list) # []
my_set = {1, 2, 3}
my_set.clear()
print(my_set) # set()
my_dict = {"a": 1, "b": 2}
my_dict.clear()
print(my_dict) # {}
80.连接两个集合
一种方法是使用方法 union() ，该方法返回一个新集合作为连接的结果:
first_set = {4, 5, 6}
second_set = {1, 2, 3}
print(first_set.union(second_set)) # {1, 2, 3, 4, 5, 6}
另一个是方法更新，将第二个集合的元素插入到第一个集合中:
first_set = {4, 5, 6}
second_set = {1, 2, 3}
first_set.update(second_set)
print(first_set) # {1, 2, 3, 4, 5, 6}
81.打印函数内部的条件
def is_positive(number):
print("Positive" if number > 0 else "Negative") # Positive
is_positive(-3)
82.单个 if 语句中的多个条件
math_points = 51
biology_points = 78
physics_points = 56
history_points = 72
my_conditions = [math_points > 50, biology_points > 50,
physics_points > 50, history_points > 50]
if all(my_conditions):
print("Congratulations! You have passed all of the exams.")
else:
print("I am sorry, but it seems that you have to repeat at least one exam.")
# Congratulations! You have passed all of the exams.
83.在单个 if 语句中，至少满足许多条件中的一个条件
math_points = 51
biology_points = 78
physics_points = 56
history_points = 72
my_conditions = [math_points > 50, biology_points > 50,
physics_points > 50, history_points > 50]
if any(my_conditions):
print("Congratulations! You have passed all of the exams.")
else:
print("I am sorry, but it seems that you have to repeat at least one exam.")
# Congratulations! You have passed all of the exams.
84.任何非空字符串都被计算为 True
print(bool("Non empty")) # Trueprint(bool("")) # False
85.任何非空列表、元组或字典都被评估为真
print(bool([])) # False
print(bool(set([]))) # False
print(bool({})) # False
print(bool({"a": 1})) # True
86.其他计算结果为 False 的值有“无”、“False”和数字 0
print(bool(False)) # False
print(bool(None)) # False
print(bool(0)) # False
87.你不能仅仅通过在函数中提到一个全局变量来改变它的值
string = "string"
def do_nothing():
string = "inside a method"
do_nothing()
print(string) # string
您还需要使用访问修饰符全局:
string = "string"
def do_nothing():
global string
string = "inside a method"
do_nothing()
print(string) # inside a method
88.使用“集合”中的计数器计算字符串或列表中元素的数量
from collections import Counter
result = Counter("Banana")
print(result) # Counter({'a': 3, 'n': 2, 'B': 1})
result = Counter([1, 2, 1, 3, 1, 4, 1, 5, 1, 6])
print(result) # Counter({1: 5, 2: 1, 3: 1, 4: 1, 5: 1, 6: 1})
89.使用计数器检查两个字符串是否是变位词
from collections import Counter
def check_if_anagram(first_string, second_string):
first_string = first_string.lower()
second_string = second_string.lower()
return Counter(first_string) == Counter(second_string)
print(check_if_anagram('testinG', 'Testing')) # True
print(check_if_anagram('Here', 'Rehe')) # True
print(check_if_anagram('Know', 'Now')) # False
您还可以使用“排序()”检查两个字符串是否是变位词:
def check_if_anagram(first_word, second_word):
first_word = first_word.lower()
second_word = second_word.lower()
return sorted(first_word) == sorted(second_word) print(check_if_anagram("testinG", "Testing")) # True
print(check_if_anagram("Here", "Rehe")) # True
print(check_if_anagram("Know", "Now")) # False
90.使用“itertools”中的“Count”计算元素的数量
from itertools import count
my_vowels = ['a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U']
current_counter = count()
string = "This is just a sentence."
for i in string:
if i in my_vowels:
print(f"Current vowel: {i}")
print(f"Number of vowels found so far: {next(current_counter)}")
这是控制台中的结果:
Current vowel: i
Number of vowels found so far: 0
Current vowel: i
Number of vowels found so far: 1
Current vowel: u
Number of vowels found so far: 2
Current vowel: a
Number of vowels found so far: 3
Current vowel: e
Number of vowels found so far: 4
Current vowel: e
Number of vowels found so far: 5
Current vowel: e
Number of vowels found so far: 6
91.根据频率对字符串或列表中的元素进行排序
默认情况下，来自集合模块的计数器不会根据元素的频率对其进行排序。
from collections import Counter
result = Counter([1, 2, 3, 2, 2, 2, 2])
print(result) # Counter({2: 5, 1: 1, 3: 1})
print(result.most_common()) # [(2, 5), (1, 1), (3, 1)]
92.在一行中找到列表中最频繁出现的元素
my_list = ['1', 1, 0, 'a', 'b', 2, 'a', 'c', 'a']
print(max(set(my_list), key=my_list.count)) # a
93.copy()和 deepcopy()之间的区别
以下是来自文档的解释:
A *shallow copy* constructs a new compound object and then (to the extent possible) inserts *references* into it to the objects found in the original.A *deep copy* constructs a new compound object and then, recursively, inserts *copies* into it of the objects found in the original.
也许，更全面的描述可以在这里找到:
A shallow copy means constructing a new collection object and then populating it with references to the child objects found in the original. In essence, a shallow copy is only one level deep. The copying process does not recurse and therefore won’t create copies of the child objects themselves.A deep copy makes the copying process recursive. It means first constructing a new collection object and then recursively populating it with copies of the child objects found in the original. Copying an object this way walks the whole object tree to create a fully independent clone of the original object and all of its children.
以下是 copy()的示例:
first_list = [[1, 2, 3], ['a', 'b', 'c']]
second_list = first_list.copy()
first_list[0][2] = 831
print(first_list) # [[1, 2, 831], ['a', 'b', 'c']]
print(second_list) # [[1, 2, 831], ['a', 'b', 'c']]
下面是 deepcopy()的一个例子:
import copy
first_list = [[1, 2, 3], ['a', 'b', 'c']]
second_list = copy.deepcopy(first_list)
first_list[0][2] = 831
print(first_list) # [[1, 2, 831], ['a', 'b', 'c']]
print(second_list) # [[1, 2, 3], ['a', 'b', 'c']]
94.当试图访问字典中不存在的键时，可以避免抛出错误
如果您使用一个普通的字典并试图访问一个不存在的键，那么您将得到一个错误:
my_dictonary = {"name": "Name", "surname": "Surname"}print(my_dictonary["age"])
这里是抛出的错误:
KeyError: 'age'
我们可以使用 defaultdict(): 来避免这样的错误
from collections import defaultdict
my_dictonary = defaultdict(str)
my_dictonary['name'] = "Name"
my_dictonary['surname'] = "Surname"
print(my_dictonary["age"])
95.您可以构建自己的迭代器
class OddNumbers:
def __iter__(self):
self.a = 1
return self
def __next__(self):
x = self.a
self.a += 2
return x
odd_numbers_object = OddNumbers()
iterator = iter(odd_numbers_object)
print(next(iterator)) # 1
print(next(iterator)) # 3
print(next(iterator)) # 5
96.您可以在一行中删除列表中的重复项
my_set = set([1, 2, 1, 2, 3, 4, 5])
print(list(my_set)) # [1, 2, 3, 4, 5]
97.打印模块所在的位置
import torch
print(torch) # <module 'torch' from '/Users/...'
98.您可以使用“不在”来检查值是否不是列表的一部分
odd_numbers = [1, 3, 5, 7, 9]
even_numbers = []
for i in range(9):
if i not in odd_numbers:
even_numbers.append(i)
print(even_numbers) # [0, 2, 4, 6, 8]
99.sort()和 sorted()的区别
sort() 对原始列表进行排序。
sorted() 返回一个新的排序列表。
groceries = ['milk', 'bread', 'tea']
new_groceries = sorted(groceries)
# new_groceries = ['bread', 'milk', 'tea']
print(new_groceries)
# groceries = ['milk', 'bread', 'tea']
print(groceries)
groceries.sort()
# groceries = ['bread', 'milk', 'tea']
print(groceries)
100.使用 uuid 模块生成唯一的 id
UUID 代表通用唯一标识符。
import uuid
# Generate a UUID from a host ID, sequence number, and the current time
print(uuid.uuid1()) # 308490b6-afe4-11eb-95f7-0c4de9a0c5af
# Generate a random UUID
print(uuid.uuid4()) # 93bc700b-253e-4081-a358-24b60591076a
奖金:101。字符串是 Python 中的一种原始数据类型
如果你来自 Java 背景，你就知道 Java 中的 String 是非原语数据类型，因为它引用的是一个对象。
在 Python 中，字符串是一种原始数据类型。
我希望你至少从这篇文章中学到了一些东西。
编码快乐！
Python 中的 100%堆积图
使用 Matplotlib 绘制百分比堆积条形图和柱形图
作者图片
在本文中，我们将讨论如何使用 Matplotlib 在 Python 中绘制 100%堆积条形图和柱形图。我们将使用从 Tableau 公共样本数据集(并转到样本数据)下载的网飞电影和电视节目数据集。该数据集由截至 2019 年网飞可用的电视节目和电影组成，由 Tableau 从 Kaggle 获取，数据集的更新版本可在 Kaggle 上找到。然而，对于本文，我们将使用在 Tableau 样本数据集中可用的旧版本。下面是数据集的快照(为了更好地显示，进行了调换)。
转置数据集的快照(图片由作者提供)
在本文中，我们将绘制堆积条形图和柱形图，显示 2016 年至 2019 年各 release_year 上映的类型剧集的比例。在下面的代码中，我们将选择 2016 年到 2019 年之间带有 release_year 的记录/行，并对数据进行预处理。
作者图片
我们将创建一个交叉表格，显示每年 类型 节目的比例。我们将在索引中包含 发布 _ 年份 和在列中显示 类型 。使用 normalize=True 参数给出了数据的索引比例。
节目类型的年度比例(作者图片)
我们将创建一个与上面类似的交叉列表，但这次我们将保留计数，而不将它们转换成比例。这个交叉制表用于显示图上的数据标签，我们将在本文后面看到。
节目类型的年度统计(按作者分类的图片)
百分比堆积柱形图
现在，我们将创建一个堆积柱形图，显示每年节目类型的比例。我们将使用具有比例的交叉列表(我们之前创建的)来绘制图表。
作者图片
现在我们将比例数据标签添加到我们的绘图中。我们将创建一个嵌套循环，其中第一个循环遍历具有比例的交叉列表的索引。第二个循环遍历每个索引的值。在深入研究之前，我们将查看代码及其输出。
作者图片
在上面的代码中，第一个循环枚举并遍历具有比例的交叉列表的索引。我们将使用枚举的值(0，1，2，3)作为数据标签的 x 位置。让我们看看第一个循环返回了什么。
作者图片
在第二个循环中，我们将遍历交叉列表中每个有比例的索引值。让我们看看第二个循环返回了什么。
作者图片
我们可以看到内循环逐个迭代每个指标的比例。变量 比例 是我们之前创建的交叉制表中的比例。我们还将它用作数据标签的 y 轴位置(这在绘制计数时很好，但在绘制比例时不正确)。
在上图中，我们看到数据标签没有对齐，没有显示在正确的位置。我们可以通过从 x 位置减去一个值(在本例中为 0.17)来修正标签的 x 位置，这样标签就会向左移动。我们将在内循环中添加一个 y_loc 变量，它只不过是一个指数中比例的累积和。这充当数据标签的正确 y 位置，并将标签放置在其各自条的最顶端。我们将在下面看到代码和输出。
作者图片
我们可以通过在 plt.text()函数中修改数据标签的 y 位置来对齐数据标签，使它们出现在每个条形的中心，如下面的代码所示。
作者图片
我们还可以通过将每个条形的计数包含在内循环中并修改 plt.text()函数中的字符串参数( s )来添加它们，如下所示。
作者图片
百分比堆积条形图
通过稍微修改我们之前创建的代码，我们可以创建一个 100%堆积条形图。我们必须将剧情类型从 【条形】 改为 【条形】 。然后交换 x 和 y 标签，在 plt.text()函数中交换数据标签的 x 和 y 位置。其他一切保持不变。我们来看看下面的代码。
作者图片
文章到此结束。我们已经讨论了如何创建 100%堆积条形图和柱形图，添加数据标签，正确对齐和格式化这些数据标签。由于数据以比例/相对频率的形式表示，而不仅仅是计数/频率(这有时可能会产生误导)，100%堆积图提供了更可靠的数据视图，尤其是在进行组间比较时。
借助 NVIDIA GPU，CatBoost 训练速度提高 10 倍
使用 10M 行数据集比较 CatBoost CPU 和 GPU 的训练时间
我不属于这些公司中的任何一家。这是一项独立审查。
大家好！欢迎再来一次对比！你已经知道它是什么了，因为标题说得很清楚。
在我的“数据科学和机器学习任务的完美笔记本电脑的 20 个必要要求”帖子中，我提到了购买配备 NVIDIA GPU 的笔记本电脑对于数据科学和机器学习任务的重要性。你读过吗？
此外，在我的“CatBoost 的 5 个可爱特性”帖子中，我已经解释了 CatBoost 库支持 CPU 和 GPU 训练。你读过吗？
现在，是时候使用你的 NVIDIA GPU(除了游戏)在一个拥有超过 1000 万训练样本(7.8 GB)的巨大数据集上训练 CatBoost 模型了！
关于 GPU 训练数据集的大小说几句
在 CatBoost 中，可以使用任意大小的数据集进行 CPU 和 GPU 训练。但是，如果数据集不够大，即数据集包含的训练样本少于 10，000 个或包含的要素少于 10 个，则 CPU 和 GPU 训练时间不会有太大差异，或者有时会看到 GPU 训练时间更长。
为了通过 GPU 训练获得更好的加速(例如 10 倍)，您的数据集应该有数百万个训练样本或数千个特征。数据集越大，GPU 的训练速度就越高。
为了今天的比较，我决定使用希格斯数据集https://archive.ics.uci.edu/ml/datasets/HIGGS(来源:** 丹尼尔·怀特森丹尼尔' @ ' uci.edu，加州大学欧文分校物理学助理教授&天文学。见底部引文)共有 11M 个样本(10.5M 训练样本，0.5M 测试样本)，28 个特征。该数据集适用于二元分类。通过运行以下命令，可以直接从 CatBoost 包中下载它。此外，确保您已经安装了 CatBoost 包。如果没有，阅读该以获取说明。****
**from catboost.datasets import higgstrain, test = higgs()**
整个数据集约为 7.8 GB。因此，您需要再等几分钟，直到它下载完毕。为此，您还应该有一个活动的互联网连接。
下载后，两个“tsv”文件将直接保存在您的工作中。您可以随时重复使用它们，而无需再次下载。当你需要的时候，只要运行上面两行代码，数据就会被加载到工作区。
这些数据可以作为熊猫数据帧来访问。
**# Get the first few rows
train.head()
test.head()# Get the size of the data
train.shape #(10,500,000, 29)
test.shape #(500,000, 29)**
测试环境
由于模型训练(学习)速度高度依赖于测试硬件和软件，我想提一下我将用于比较的测试环境的规格。
- 笔记本电脑:华硕 TUF F17 2021 型号
- CPU: 英特尔酷睿 i5–11260h(6 核)
- GPU:NVIDIA GeForce RTX 3050 Ti(4gb，2560 CUDA 核心)
- NVIDIA 驱动程序版本: 462.42
- 内存: 8GB，3200MHz
- 存储类型: NVME 固态硬盘 PCIe 3.0
- 操作系统:64 位 Windows 10 专业版
- IDE: Anaconda 个人版(64 位，Python 3.8)
- 库: CatBoost v1.0.3 (Python)
- 其他:插上充电器，开启涡轮模式以获得更好的性能
只是提一下，对于 CatBoost 中的 GPU 训练，你只需要在电脑中安装 NVIDIA GPU 和一个驱动，不需要任何其他专门的软件进行 GPU 配置。
CPU 培训
我们将首先在 CPU 上训练我们的 CatBoost 模型。我们将测量模型训练时间，并获得测试数据的准确性分数。在 CPU 和 GPU 培训中，我们将使用以下参数设置:
- 助推轮次(迭代次数): 100
- 学习率: 0.1
- 树深: 3
稍后，我将使用 500 轮和 1000 轮助推，并测量 CPU 和 GPU 的训练时间。在本文末尾，你会在一个漂亮的条形图中看到所有的比较。
现在让我们用 100 轮助推来做比较。
CPU 上的 CatBoost 训练
(图片由作者提供)
CatBoost 在 CPU 上训练大约需要 91 秒。对于一个 10M 行的数据集来说，这是一个令人难以置信的快速度！
关于 GPU 的培训
现在，我们将在 GPU 上训练相同的 CatBoost 模型，并测量模型训练时间，获得测试数据的准确性分数。我们也将使用上述相同的参数设置。
基于 GPU 的 CatBoost 训练
(图片由作者提供)
哇！CatBoost 在 GPU 上训练只需要 12 秒。所以，
CatBoost GPU 训练比其 CPU 训练快 7.6 倍，针对希格斯数据集，采用上述参数设置和软硬件配置。
不同强化轮次的训练
我还通过改变 boosting 轮次(迭代)的数量，在 CPU 和 GPU 上训练了不同的 CatBoost 模型。这是结果。
(图片由作者提供)
- 在 100 次迭代时，CatBoost GPU 训练比其 CPU 训练快7.6 倍。
- 在 500 次迭代时，CatBoost GPU 训练比其 CPU 训练快9.8 倍。
- 在 1000 次迭代时，CatBoost GPU 训练比其 CPU 训练快9.7 倍。
增加 boosting 轮次时，CatBoost GPU 训练比其 CPU 训练快得多。
我还创建了一个漂亮的条形图来展示上述结果。这是:
(图片由作者提供)
你觉得这个条形图怎么样？
摘要
- CatBoost GPU 训练适用于具有数百万个样本或数千个特征的非常大的数据集。
- 在小数据集的情况下，CPU 和 GPU 的训练时间不会有太大的差别。
- 当你增加助推轮数时，CatBoost GPU 训练比它的 CPU 训练快得多。
- 在进行这种类型的比较之前，最好指定硬件和软件配置。
- 进行比较时，最好每次使用相同的参数设置。
- 模型的性能不受 CPU 或 GPU 训练的影响。在 100 次迭代中，我们两次都得到了相同的准确度分数 0.71。
阅读下一条(推荐):
了解 CatBoost 的特殊功能！
****</5-cute-features-of-catboost-61532c260f69>
学习在 CatBoost 中直接使用分类特性！
阅读下一条(可选):
为数据科学和机器学习任务选择合适的笔记本电脑！
</20-necessary-requirements-of-a-perfect-laptop-for-data-science-and-machine-learning-tasks-7d0c59c3cb63> [## 数据科学和机器学习任务对完美笔记本电脑的 20 项必要要求
towardsdatascience.com](/20-necessary-requirements-of-a-perfect-laptop-for-data-science-and-machine-learning-tasks-7d0c59c3cb63)
今天的帖子到此结束。我总是尽我所能以一种你能从中获得最大收益的方式来写和组织我的内容。应该有很多方法来进一步改善我的内容，你可能有很好的想法。所以，
如果您有任何反馈，请告诉我。
同时，你可以 注册成为会员 来获得我写的每一个故事，我会收到你的一部分会员费。
非常感谢你一直以来的支持！下一个故事再见。祝大家学习愉快！
特别感谢 Unsplash 上的 Nana Dua ，她为我提供了这篇文章的漂亮封面图片。
希格斯数据集引用:
[巴尔迪、p .萨多夫斯基和 d .怀特森。(2014).UCI 机器学习知识库(http://archive.ics.uci.edu/ml)。加州欧文:加州大学信息与计算机科学学院]
[巴尔迪、p .萨多夫斯基和 d .怀特森。"用深度学习在高能物理中寻找奇异粒子."《自然通讯》第 5 期(2014 年 7 月 2 日)]
鲁克山普拉莫迪塔
2021–11–17****
速度快 10 倍熊猫应用在一行代码的变化
用更快的包裹加速熊猫处理工作流程
(图片由作者提供)
Pandas 是数据科学社区中流行的 Python 包之一，因为它为数据探索和可视化提供了巨大的 API 和灵活的数据结构。当处理大规模数据集时，它失败了。
人们可以分块加载和处理大规模数据集，或者使用分布式并行计算库，如 Dask、Pandarallel、Vaex 等。可以使用 Modin 库或多处理包来并行执行 Python 函数，并加快工作流程。在我以前的文章中，我已经讨论了 Dask、Vaex、Modin、多处理库的实际实现。
有时我们不愿意使用 Dask 或 Vaex 库来代替 Pandas，或者我们不希望仅仅为了并行执行几个函数而编写所有那些无关的代码。
我们能在不做太多代码改动的情况下并行执行 Python 函数吗？——肯定是
熊猫库中的函数允许开发者传递一个函数，并将其应用于系列中的每一个值。函数的执行**apply()**带来了巨大的改进，因为它根据所需的条件分离数据。
对于 Pandas 系列，最好使用 apply()函数，而不是自定义调用该函数。在本文中，我们将讨论如何进一步并行执行***apply()***函数，并使用 Swifter 包优化时间约束。
更快:
Swifter 是一个开源包，可以加速函数的执行。为了方便使用，它可以与熊猫对象集成在一起。通过集成 swifter 包，用一行代码就可以并行执行 Python 中的任何函数。
它是如何工作的？
Swifter 通过矢量化或在后端使用 Dask 实现来并行化执行，自动选择实现**apply()**功能的最佳方式。对于小规模数据集，Swifter 可以选择执行 Pandas apply()函数。
安装:
可以使用**pip install swifter** 从 PyPl 安装 swifter 包，并使用**import swifter** 导入它。
实施和使用:
我创建了一个函数，对熊猫系列执行一些随机操作。首先，我们将使用 apply()执行函数:
# Call random_function for col1 and col2 columns using apply()**df['new_col'] = df.apply(lambda x: random_func(x['col1'], x['col2']))**
现在，为了并行执行函数，我们可以将 swifter 包与 Pandas 数据框对象相集成:
# Call random_function for col1 and col2 columns for parallel execution**df['new_col'] = df.swifter.apply(lambda x: random_func(x['col1'], x['col2']))**
只要集成关键字 swifter，就可以并行执行该函数。
基准测试:
我比较了使用 apply()和通过将 swifter 包与 Pandas 数据帧对象集成然后调用 apply()来执行函数的基准时间数。现在让我们观察一下执行速度的提高。
性能记录在一个带有RAM:64GB*10 个 CPU 核心 的系统上。*
(图片由作者提供)，执行 apply()的基准测试时间和速度
从上面的图中我们可以观察到，在使用更快的并行包后，对于6500 万个数据样本，工作流的速度几乎提高了10 倍。
结论:
Swifter 是并行执行 Python 函数的一个很好的工具。它会自动选择最快的方式来执行您的函数，通过矢量化或在后端使用 Dask。
对于 6500 万条记录，我们的执行速度提高了 10 倍，随着样本量的增加，这一速度还会进一步提高。
它是一个方便的工具，只需修改一次代码就可以优化函数的执行。您也可以使用 Python 多处理库来并行执行您的定制，但是它只需要对代码进行几行修改。
阅读我之前的一篇关于代码优化并行化的文章:
- 4 个可以并行处理现有熊猫生态系统的库
- 用摩丁加速你的熊猫工作流程
- 借助多处理模块，Python 函数执行速度提高 30 倍
- 熊猫数据帧迭代速度快 400 倍
- 速度快 3 倍的大熊猫带着 pypolar
- 为大型数据集优化 Pandas 内存使用
- 网格搜索交叉验证速度提高 20 倍
参考资料:
*[1]更迅捷的 GitHub 库:【https://github.com/jmcarpenter2/swifter *
感谢您的阅读
帮助您获得成为数据科学家所需知识的 11 本书
帮助你成为更好的数据科学家的书籍。
莎伦·麦卡琴在 Unsplash 上的照片
成为一名杰出的数据科学家往往是一条崎岖不平的道路。因为数据科学是一个跨学科的领域，你需要了解很多领域才能掌握它，全面理解它的构建模块。
你需要了解一些数学、统计学、商业模式基础、编程、可视化和科学交流技能。您还需要了解一些核心技术技能，例如处理 docker 图像，熟悉 Git，完全熟悉数据库。
我能理解这对刚加入这个领域的人来说是多么的难以承受。我不否认成为一名数据科学家的道路可能会很漫长，但成为一名数据科学家是最有成就感、最具挑战性的工作之一。
一旦你有了路线图和一些资源，你就可以了解基础知识并准备好处理现实生活中的项目，成为数据科学家的所有复杂性和麻烦就会变得更好，更少。
在本文中，我将为您提供 11 本书，您可以浏览这些书，以熟悉数据科学的所有基础知识，从编程、数学和统计开始，到自然语言处理和机器学习等核心数据科学主题的书籍结束。
我会按照我阅读的顺序来浏览这些书，这对我来说是有意义的。你可以从中间开始，也可以从学习过程中的任何地方开始。
№1:Python 的搭便车指南
迈向数据科学的第一步是学习如何编码。目前，Python 是数据科学家最熟知的编程语言。许多软件包和模块为您提供了实现最复杂的数据科学算法所需的所有技术支持。
我教 Python 已经有 5 年多了，既教孩子也教成人；我读过的关于在逻辑进程中教授 Python 的最好的书之一是的 Python 搭便车指南。
这本书讲述了从安装 Python 和选择文本编辑器来编写好的 Python 代码到虚拟环境，甚至是您可以在不同领域使用 Python 构建的应用程序，如网络、GUI、数据库和科学应用程序。
№2:机器学习的数学
我知道数学是这些倾向于让人们远离特定领域的主题之一，但是数据科学中涉及的数学一点也不复杂。事实上，这很简单，也很符合逻辑，其中一个能让你更适应的方法就是，读正确的书。
机器学习数学是一本很棒的书，涵盖了你理解数据科学算法所需的数学的所有方面。它包含关于线性代数，矩阵分解，和概率理论和分布的章。
而且，书中包含了使用 Python 和 Jupyter notebook 的应用和教程。最棒的是，你可以从官方图书网站免费获得 PDF。
№3:数据科学家实用统计学
在数据科学中，数学是用来推动决策的，但是首先你如何做出决策呢？这就是统计学发挥作用的地方。
我找到的关于统计学的最好的书以简短、简明和直接的方式涵盖了理论。Python 和 R 语言的实现是数据科学家实用统计 s。当你阅读这本书时，你会得到第一个真正的数据科学的提示。您将了解不同数据类型的含义和用法，以及它们在不同应用程序中的表现方式。
这本书的另一个好处是你可以免费获得它的 PDF 版本。
№4:实用 SQL
数据科学完全是关于数据的；它是关于收集数据，清理数据，分析数据，并从中得出模式和结论。换句话说，这是关于理解数据试图用数字告诉你的故事。这个故事需要保存在某个地方。
每个数据科学项目的一个基本步骤是从/向数据库读取或存储数据。与数据库交互的最有效方式是使用 SQL。实用 SQL 将带你从一个绝对的数据库初学者走向成为数据库和 SQL 高手。
这本书是那种你觉得看小说，而不是技术书的书。它使用了一种易于理解的方法，使得来自各种背景的人都能轻松阅读。
№5: Pro Git
一旦你进入了软件开发的世界，无论你是打算成为一名数据科学家、网络开发人员，还是仅仅热爱编码，你都会遇到 Github 和开源软件。
许多 Python 数据科学包都是开源项目，一旦你对自己的技能驾轻就熟，你就可以把它们加入到你的简历中。即使你不打算为开源项目做贡献，你也需要完全熟悉 Git 和 Github 才能在事业上取得成功。
没有什么比从源头学到东西更好的了。Pro Git 是 Git 开发人员编写的一本书，旨在教所有开发人员如何掌握版本控制的艺术。这本书将涵盖基本主题，如创建一个存储库，克隆一个，以及更高级的主题，如 Git 的内部工作。
你可以从 Git 官方网站免费获得该书的 PDF 版本。
№6:人人都有熊猫
Python 中几乎没有不使用熊猫的数据科学项目。Pandas 是一个怪物包，它允许你使用 Python 来解析、读取和操作数据。
《熊猫为大家》是一本很棒的书，关注熊猫的内在工作，如何快速有效地分析数据。这本书将涵盖许多主题，如可视化数据框架，处理丢失的数据点，和数据建模。
这本书的第一章将带你深入了解熊猫的核心构件数据框架。如何正确使用，如何轻松应对。
№7:使用 pytest 进行 Python 测试
您完成了您的项目；你很高兴让全世界都看到你的发现，但是在这之前，你需要确保你的项目是完美的，没有错误的。唯一的方法就是测试你的工作。
或许 Python 最知名的测试库是 Pytest。Pytest 是最可靠的库之一，它提供了不同的测试类型，比如单元测试和回归测试。单元测试是常用于测试数据科学应用程序的测试方法。
使用 Pytest 进行 Python 测试将向您介绍测试的概念以及如何在 Python 中利用它。它将教你如何编写简短、健壮的测试来验证你的项目，并在你与世界分享它之前确保它是完美的。
№8:数据科学的 Docker
当您开始深入研究数据科学并开始使用真实数据开发项目时，您会发现数据量每天都在呈指数级增长。数据量的增长使得软件开发人员存储和分析这些数据变得非常困难。
解决这个问题的一个方法是使用 docker 容器。 Docker for Data Science 将教你如何使用 Jupyter 作为处理核心，使用 Docker 容器作为存储和处理数据的基础设施，来创建一个交互式开发环境。
№9:使用 PyTorch 进行自然语言处理
到目前为止，我们只讨论了涵盖全面理解数据科学构建模块所需的核心技术基础的书籍。现在，我们来谈谈实际的数据科学分支。
最著名和被谈论的数据科学分支是自然语言处理。在我看来，它是一个新兴的领域，在各个领域都有许多重要的应用。使用 PyTorch 进行自然语言处理是一本向您介绍自然语言处理以及如何使用 Python 和 PyTorch 构建实际应用程序的好书。
该书对 Github 上的自然语言处理和代码项目的思想和算法进行了简单的解释。该书的 Jupyter 笔记本可以在官方图书回购上找到。
№10:使用 scikit-learn 和科学 Python 工具包进行机器学习
我们不能写一篇关于数据科学书籍的文章而不提到——至少——一本机器学习书籍。有许多机器学习书籍，但今天，我将谈论一本最近出版的书。
使用 scikit-learn 和科学 Python 工具包进行机器学习是一本适合机器学习初学者的好书。它涵盖了机器学习理论的基本知识，机器学习算法中决策背后的数学，以及许多现实生活中的应用程序及其代码实现。
这本书涵盖了机器学习的所有方面，从聚类算法到图像处理和文本处理，再到神经网络和推荐系统。想了解机器学习的所有基础算法，这本书就是给你的。
</5-types-of-machine-learning-algorithms-you-need-to-know-5ac7fce8920d>
№11: IPython 交互式计算和可视化食谱
这个列表中的最后一本书实际上是关于我最喜欢的话题，可视化。正如我经常说的，数据科学就是从数据中讲述一个故事，还有什么比将它可视化更好的方式来讲述一个故事呢？
我们大多数人——数据科学家——使用 Jupyter 笔记本来构建交互式、可复制的数据科学项目。IPython 交互式计算和可视化食谱将向您介绍 IPython，并使用 Jupyter notebook 设置它，然后使用它创建有效的可视化。
此外，这本书还教你如何编写运行得更快更好的高效 Python 代码。你可以在这本书的官方网站上免费查阅这本书的章节。
外卖食品
数据科学是目前引人注目和有趣的领域之一。这是一个什么都有点的领域，有些编程，有些数学，有些可视化，还有些商业。但是由于这个领域的性质，进入这个领域是非常困难的。尤其是在网上有这么多可用资源的情况下。
有如此多的好书，你可以通过阅读来了解数据科学的某个特定方面，或者生活中的任何事情。在这篇文章中，我关注了我读过的 11 本书，我觉得它们对我的知识库贡献最大。
我按照我推荐阅读的顺序把书呈现给你，但那只是推荐。我们每个人都有自己独特的学习和寻找新信息的方式，所以阅读可以填补你目前知识空白的书，跳过或浏览其他人关于你在学习过程中已经获得的知识。
记住，即使你知道一些东西，也总会有新的东西要学，即使你已经熟悉了这个话题。
作为数据科学家要避免的 11 个关键错误！
意见
初学数据科学的爱好者会犯的十一个关键性错误是什么？避免这些以获得更好的结果和更高的生产率！
“每个人都会犯错误。真正的辩护是在可预见的未来战胜它们。”
近年来，数据科学获得了极大的普及。这种炒作将持续到未来几年。这个领域注意到越来越多的渴望者和爱好者试图拾起这个主题。
在当代，数据科学被认为是 21 世纪最性感的工作，因此，这一新兴趋势不应令人感到惊讶。几乎每个人都想赶时髦，获得数据科学方面的专业知识。
然而，获得正确的知识和经验可能比预期的更困难。数据科学领域的初学者总是会犯一些严重的错误。有时，即使是专家也容易犯错误。
没有人想在生活的任何方面犯错误或不断重复错误。尽管如此，数据科学最棒的地方在于，随着你犯下的每一个错误，你都有机会反思并从这些错误中学到更多。
有时候，分析为什么会出现这些错误变得极其重要。重新考虑和回顾客观错误，无论是实践的、理论的还是心理的，都有助于在数据科学领域取得成功。
在本文中，我们旨在寻找答案，并理解为什么会出现如此重大的错误的潜在原因。我们将关注在使用数据科学时可能发生的实践和技术错误。本文将提供总共 11 个包含技术和实践方面的陈述。
然而，值得一提的是，数据科学是一个广阔的领域，这个主题的爱好者可能会犯更多的错误。这只是 11 个这样的例子，我觉得是数据科学爱好者犯下的最常见的例子。
如果你很想知道这些潜在的错误是什么，以及你自己犯了多少错误，那么请坚持在这篇文章中获得全面深入的分析和分解，并一直坚持到最后。
我们将详细讨论为什么会发生这些错误，以及如何修复它们！那么，事不宜迟，让我们开始吧。
1.对数据科学毫无兴趣
让我们从一开始就解决明显的非技术方面的问题。数据科学和人工智能都需要兴趣激情来学习新思想，获取更多知识。
为了理解几个棘手的话题，你需要把注意力集中在这些概念上。掌握更难的概念需要大量的时间和精力，作为数据科学爱好者的学习曲线有时会令人毛骨悚然。
好的一面是，上面的陈述可以从两个方面来理解。要么你们都不感兴趣，你去做生活中其他更好的事情。或者第二个有趣的选项，你可以选择享受旅程，在享受乐趣的同时克服抛向你的各种障碍。
如果你真的对数据科学领域充满热情，那么即使某些复杂的主题对你来说也不会是太大的负担。最终，通过一点点的奉献和努力获得解决方案。
但是，如果您缺乏兴趣，并且出于错误的原因追求数据科学，那么您很有可能无法实现您想要达到的预期结果。
我已经在另一篇文章中讨论了成为数据科学家的十个错误理由。在继续阅读本文的其他部分之前，我强烈建议您通过下面提供的链接查看一下。
</10-wrong-reasons-to-become-a-data-scientist-319531bb874e>
简单总结一下，如果你真的喜欢处理复杂的机器学习和深度学习问题，并且你真的喜欢投入时间学习数据科学的新概念和主题，请追求数据科学。
如果没有，那也完全没问题，因为世界上有那么多更好的选择供你去努力实现你的目标。对于文章中接下来的几个要点，我们将重点关注数据科学爱好者所犯错误的更多技术方面。
2.不当的数据集分析和无效的数据可视化:
作者图片
几乎每个任务都包含大量数据。有许多有用的数据集可用于解决简单或复杂的数据科学问题。
虽然开始构建机器学习或深度学习管道以完成任务的兴奋感可能很有趣，但在完成这项工作之前，必须经历几个步骤。
其中一个步骤是真正理解您的数据集以及该数据集的继承内容。手头任务背后的正确知识和理论直觉会让你提出一个清晰的思维过程和解决问题的思路。
为了获得对问题的直观理解，每个数据科学项目的一个基本步骤是探索性数据分析(EDA)。探索性数据分析是可视化数据集的最佳方法之一，有助于您清楚地了解数据集所代表的内容。
探索性数据分析是端到端数据科学项目的第一步，也可能是最重要的一步。
它有助于您理解数据集和可用数据的特征。它用于理解数据在正式建模或假设检验任务之外还能告诉我们什么。
不正确地分析数据集和无效的数据分析会导致数据集清理、数据准备、构建训练模型和构建机器学习模型时的其他重要步骤中的几个问题。
因此，对您来说，尝试各种可视化技术并清楚地了解数据集和有用的数据以解决复杂的问题或复杂的任务是非常重要的。
因此，将大部分时间花在可视化和理解数据上是至关重要的，这样您在后面的步骤中就不会那么紧张。
3.数据清理不够干脆
顾名思义，数据科学处理大量数据。
在继续进行训练和建立机器学习模型之前，要成功完成的最无聊的部分之一是确保你的数据是有效和高效的。
您不能有效地清理和准备您的数据的一个主要原因可能是由于您缺乏对数据的整体理解，并且您不知道如何实现清理过程。
另一个原因是由于执行不适当的探索性数据分析，这导致了有问题的问题，因为您不知道哪些特性和特征对于要实现的任务更重要。
因此，您更有可能保留问题不需要的无用和不必要的数据，而不是有用和必要的数据。
在研究和处理数据集以及特定任务时，您需要研究数据集的重要组成部分和特征，这将有助于遇到任务时提供令人满意的结果。
例如，如果您试图执行自然语言处理任务，如情绪分析，它提供了快乐、中立或悲伤的有效评级，您可以使用 EDA 计算出有许多不必要的单词，这些单词对完成特定任务没有帮助。
您可以删除某些停用词，如 is、an、or、a、the 等。，以及其他许多工具，用于生成更干净的数据集，并帮助您建立机器学习或深度学习模型，以更快地解决此类任务。
4.问题背后缺乏数学直觉
图片由皮克斯拜的 Gerd Altmann 提供
数学在数据科学中发挥着巨大的作用，特别是在机器学习、深度学习和计算机视觉领域。
线性代数、概率统计、微积分的概念对于理解建模的直观理解和构造机器学习模型的图形结构具有重要意义。
大部分数据科学取决于你如何利用你的数学技能来解决问题。如果您能够使用编程技能将数学知识转化为代码，那么大多数任务都可以轻松完成。
要理解机器学习算法和数据科学的其他基本概念到底是如何工作的详细结构，数学是最重要的。
我经常发现人们对数学的兴趣并不一致。虽然数学有它的粉丝和许多崇拜它的人，但有一部分观众绝对讨厌数学。
无论你处于哪个领域，数学对于数据科学都是必不可少的，不能被忽略。因此，你需要在一段时间内练习和发展这些技能。
学习和理解数学的最好方法是练习大量的问题。通过尝试自己从零开始推导理论，确保你了解每个概念。
数学是数据科学的核心概念。因此，请确保您能够通过不断提高您的数学技能和解决各种任务，将您的数学知识有效地应用到您的机器学习模型中。
5.程序错误
正如数学对于数据科学和机器学习一样重要，不可否认的是，编程技能对于确保模型的完美运行至关重要。
当你打算成为一名数据科学家时，你应该关注的第一步是提高你的编码技能，因为这是数据科学项目不可或缺的一部分。
在开发编程技能的同时，您至少能够避免数据科学项目中的语法错误。语法错误应该仅限于编程软件项目，并在数据科学项目中避免。
在数据科学项目中，您会在运行时遇到更多的错误或其他一些与模块相关的错误或导入错误。因此，应该掌握编程语言，以便能够更快地解决这些问题。
规划你们各自掌握数据科学的路线图，以及你们计划学习的各自的编程语言。如果你读过我的文章，你就会知道我为初学数据科学的爱好者推荐的编程语言是 Python。
我强烈推荐阅读我以前的一篇文章，这是一篇关于在 12 个月内掌握数据科学的简明指南，也就是说，在一年的时间框架内。你可以从下面的链接中找到这篇文章。
</12-steps-for-beginner-to-pro-in-data-science-in-12-months-c6f6ba01f96e>
编程技能是无限的，可以通过时间获得。专注于核心概念，不断学习和练习。有了坚持和兴趣，你将能够轻松解决你的大部分错误。
通过不断的练习，您甚至可以成为一名编码专家，轻松地从头开始编写难度较低的数据科学项目，而无需任何额外的要求。
6.缺乏研究和深入了解
威廉·艾文在 Unsplash 上的照片
研究是数据科学不可或缺的一部分。
在遇到复杂的任务之前，第一步必须利用互联网上的各种参考资料和资源。
在数据科学中，确保你知道自己在做什么是至关重要的。否则不久你就会迷失在黑暗的森林深处。只有深入了解你的基础知识和初学者概念，你才能跳出去，逃离这种令人厌恶的东西。
虽然上面的陈述有点吸引人，但这几行的主要目的是说明您必须对您正在处理的各种主题有清晰的概念、理论和实践理解，因为很容易迷失方向和犯错误。
如果你发现数据科学中某个特定的概念或主题很有趣，就把它捡起来，尽可能深入地思考。探索这个主题的每个组成部分，并反思各种可能性和实现。
你从持续的研究中获得的理解越深刻，你对数据科学这门学科的兴趣就会增长得越高。在这个奇妙的领域里，有数十亿难以置信的想法，你可以用来改善世界和社会。
为了让你自己和你的大脑能够处理更多有思想的想法和愿景，你必须不断研究并深入理解你在整个学习过程中遇到的各种概念。
这个过程将帮助你掌握这些话题背后的艺术，并最终取得成功！
7.放弃或失去激情
有时候，数据科学可能很难。
你可能会一遍又一遍地尝试，但你不会得到你想要的结果。事实上，这是一次令人沮丧的经历。
但是，数据科学最好的部分是，随着你犯下的每一个错误或大错，你都在学习一种全新的体验。在一定程度上，你能够找出多种方法。
随着时间的推移，你遇到的错误可以通过有效的研究和分析来解决。一旦你知道了为什么会发生下面的错误的准确原因，那么你成功的机会就会变得更高。
您可以轻松地完成任务，并且减少了在未来的场景中重复同样错误的机会。
然而，如果你每次都放弃，对数据科学领域失去热情，那么，不幸的是，这不是正确的方法。这只会降低你的信心和对这门学科的兴趣。
相反，把它当成解决手头任务的挑战吧！每个人都可以完成他们设定的目标和指定的指标。如果你在一个特定的问题上多次反复失败，那么就休息一下，因为这样做完全没问题。
在数据科学领域，每个人都容易犯错误。但是不要担心，因为你可以通过重温你没有正确理解的话题来克服它们，并且带着清晰的愿景和绝对的信心来解决这个复杂的问题！
8.过度拟合和欠拟合
作者图片
老实说，这一点可以归类到更广泛的表现领域，并被称为 “机器学习算法和模型实现的各种问题。”
在构建机器或深度学习管道的过程中，可能会出现一些错误、失误和失误。这些错误可能是由于缺乏对概念的正确理解、疏忽或真正的错误造成的。
不管在构建您的机器学习项目时为什么或如何出现这些错误，我们的首要任务是修复它们并开发这些问题的有效解决方案。
这些问题中的大部分可以通过修改你的想法或手头的数据集来解决。此外，谷歌搜索和查找错误的解决方案是了解错误和针对特定问题的各种修复的好方法。
我们这一节的重点是过度拟合和欠拟合。
过度拟合是指您开发的模型在训练过程中拟合得非常好，甚至将不必要和不需要的训练点(如离群点或噪声点)拟合到您的解决方案中。这个问题导致训练模型持续改进，但是在测试期间是一个有害的问题。
欠拟合是指你的模型完全不适合，导致几个问题。在训练期间，模型无法拟合特定的数据集，导致尽管运行了多个时期，训练和测试数据集的改进几乎为零。
修复过度拟合和欠拟合期间出现的这些问题的一些最有效的方法是使用更平衡的数据集，使用丢弃或批量归一化图层，增加或减少可训练参数的数量，更好的超参数调整等等。
这个话题非常广泛。我们将在以后的文章中更详细地讨论这些概念。所以，敬请关注！
9.没有有效地查找或寻求额外的帮助
安妮·斯普拉特在 Unsplash 上的照片
由于数据科学是一个非常庞大且有时非常复杂的领域，因此很容易陷入困境，找不到特定问题的解决方案。
你觉得你已经尝试了你能尝试的一切，你正处于失望的边缘，因为你已经完全没有主意了。反思和检查各种场景并不能为您的复杂问题提供富有成效的解决方案。
在这种情况下，最好的办法就是寻求帮助！数据科学界足智多谋，乐于助人。这是一个健康的社区，引导爱好者和初学者达到最佳效果。
如果你长时间陷入一个问题，不要过度劳累或给自己太大压力。确保你得到了一些关于如何解决手头特殊任务的帮助，在这些帮助下，你从你提到的各种资源中获得，构建你的解决方案。
不过，不要对考虑帮助有错误的想法。最终目标仍然必须是获得所需的知识，并在众多的可能性上教育自己。坚持学习和练习！
当你确实得到了所需的帮助时，一定要重温这个话题，理解具体的解决方案及其成功的原因，并分析你的解决方案在以前的场景中不起作用的原因。
提几个有帮助的资源，我主要推荐的是 Stack Overflow、discord channels、YouTube 视频、免费在线代码营、GitHub、走向数据科学等。都是有用的资源，可供我们所有人利用和提高我们的技能。
要了解更多关于如何成为成功的数据科学家的信息，并客观地从数据科学领域了解更多信息，我强烈建议通过下面提供的链接查看我以前的一篇关于该做什么和不该做什么的文章。
💔-dos-and-3-don-ts-to-become-successful-in-data-science-c49e2c293a56>
10.而不是尝试一堆机器学习算法来完成特定的任务
好吧！所以，你最终通过建立一个工作并服务于你的问题目的的机器学习模型，成功地完成了你的任务或项目。
然而，你能接受仅仅获得一个满意的结果吗？你对下面这个问题的回答应该是严厉的 【不】
尽管建立了一个机器学习或深度学习模型来帮助你获得想要的结果，但你可以对你的模型进行持续不断的测量、改进和进步。
因此，确保为部署目的创建最好的产品变得至关重要。老实说，没有好的方法来找出哪个是最有效的。所以，尽情享受，探索你在有限的时间内可以建立的各种想法和模型。
为了讨论这个主题的一个例子，让我们考虑我做的一个关于人类情感和手势识别的项目。你可以从下面提供的链接中找到关于这个项目的必要和有用的资源。
在很多情况下，我可能已经停止了项目的各种实现，因为我已经收到了这个特定项目的预期结果。
然而，这样做并没有帮助我了解更多，也没有帮助我理解有更好的方法和创新的模式来创造更出色的结果。
我试了大约 15-20 种型号，直到找到最适合我的任务的型号。但是你猜怎么着？我可以尝试更多的方法，看看是否有更好的方法适用于期望的任务和数据集。
我强烈建议你们所有人探索各种方法和技术，来改进你们的模型。不要因为你得到了一个好的解决方案就停止尝试，因为你可以找到一个更好的解决方案！
11.不保持更新
听说过 “时不我待”这句话吗 ？
嗯，数据科学和技术也差不多。它们是当代发展最快、增长最快的领域，并将在未来产生巨大影响。
当今世界数据科学的热门方面在未来可能不尽如人意。在数据科学领域有一个连续的进化谱。
今天在数据科学中流行的技术或想法可能在未来一年或未来几个月内不再流行。一个简单的例子就是机器学习中架构、结构和模型的不断发展。
如果你渴望走在时代的前沿，那么就要确保每个月都能看到最新的各种研究论文和计划。数据科学有一个陡峭和持续的学习路径。
数据科学的方法、思想、哲学、理论、概念和假设会定期改变。事实上，这就是我们所热爱的主题的真正美。它在不断更新，创造一个更美好的世界。
我强烈建议所有数据科学爱好者和有志之士提出新想法，并继续关注这个我们都热爱和喜欢的壮观领域的所有新兴趋势。
为了保持更新和学习模式，建议你不断阅读各种文章、研究论文和书籍。还有大量的 YouTube 视频，让你不断了解所有最新的方案和技术。
每当你阅读一篇研究论文或发现一种新的算法时，试着从头开始自己实现那些项目的内容。这个习惯会让你从概念上、直观上理解题目。这也有助于你更长久地记住它们。
结论:
马文·迈耶在 Unsplash 上的照片
征服和克服你的错误会把你带到成功的顶峰。但是，记住要继续努力，因为天空不是极限！
数据科学是一个巨大而广阔的领域。有如此多的想法，还有如此多的想法有待发现。在如此广泛的主题、概念和话题中，错误可能有意或无意地发生。
作为一名数据科学的追求者或爱好者，犯错误、失误或失误是完全没有问题的。你犯的错误越多，你学到的就越多。你可以通过我纠正和修正你的错误来巩固你自己。
在本文中，我们讨论了数据科学爱好者犯下的 11 个常见错误，以及如何通过对该主题的一些概念、理论和实践理解来纠正这些错误。
让我们简要地总结一下我们从阅读这篇文章中获得的众多思想意识。我们已经讨论了大多数常见错误的技术和非技术细节，让我们简要了解一下每一个错误。
数据科学初学者犯的第一个常见错误是在对该领域没有任何实际兴趣的情况下追求该主题。确保你培养了一个兴趣或者选择了一个你喜欢的不同的选择。
数据清理、数据可视化和数据分析(尤其是 EDA)在项目的开发阶段起着关键作用。确保它们的正确使用，以准备将在项目的其余部分使用的完美、干净和平衡的数据集。
数学和编程技能对于开发中级和高级项目以及解决任何复杂的问题或复杂的任务都是必不可少的。继续致力于改善这些方面。
研究各种概念，深入理解项目的所有基本主题。无论如何都不要放弃，努力达到最好的结果。
如果你陷入了一个棘手的问题，你无法解决这个问题，那么从互联网或专家那里获得一些帮助对你最有利。其他问题，如过度拟合或欠拟合，可以很容易地克服适当的研究和实施的想法。
最后，不断尝试各种创新的想法，不要在建立一个成功的解决方案后停下来。了解数据科学领域不断出现的各种研究论文和创新。
如果你对这篇文章中提到的各点有任何疑问，请在下面的评论中告诉我。我会尽快给你回复。
看看我的其他一些文章，你可能会喜欢读！
</8-revolutionary-artificial-intelligence-technologies-of-the-modern-era-f8f22a4127d0> </5-best-ways-to-earn-income-from-data-science-a9c8fed1eee6> </10-best-tools-and-technologies-for-data-science-e335fb99c2f2> </15-awesome-python-and-data-science-projects-for-2021-and-beyond-64acf7930c20>
谢谢你们坚持到最后。我希望你们喜欢阅读这篇文章。我希望你们都有美好的一天！
降维的 11 种不同用途
整个 ML 都是降维及其应用。让我们看看他们的行动吧！
“D维度还原”是谷歌搜索引擎中的热门关键词。这是因为整个机器学习充满了降维及其应用。是时候用实例来看看他们的行动了！
降维是一种无监督的机器学习技术，可以应用于您的输入数据，而无需标签列。用专业术语来说，你的数据中变量(也称为特征或属性)的数量称为数据的。如果你的数据有 3 个变量，你的数据的维数是 3。这意味着数据中的任何一点都可以在三维空间中绘制出来。
真实世界的数据有许多变量，这意味着它的维数非常高。通常，这种数据被称为 n 维数据。“n”等于变量的数量，它可以是 10、100、1000 或甚至超过 10，000。
随着数据集中变量数量的增加，我们需要减少变量数量，以获得本文即将讨论的优势。这是降维发生的地方。但是请记住，当您减少数据集中的变量数量时，您将丢失原始数据中的某些百分比的可变性。
因此，降维的有效定义是:
降维是减少高维数据中变量的数量，同时尽可能保留原始数据中的可变性的过程。它或者找到少于原始变量数的一组新变量，或者只保留少于原始变量数的最重要的变量。我们应该在要保留的变量数量和原始数据集中的可变性损失之间进行权衡。
降维的技术有很多。我不打算详细讨论它们，因为我在以前的帖子中已经讨论了 11 种这样的技术。如今，更多地强调降维的不同用途或优势。
降维的用途
降维的最终用途是获得更少的变量。这间接影响了降维的其他用途。
让我们用实例逐一讨论。
高维数据的可视化可以通过降维来实现
在 EDA(探索性数据分析)中，数据可视化扮演着重要的角色。但是我们经常很难可视化高维数据。这是因为我们只熟悉 2D 图或三维图，它们分别只适用于二维或三维数据。我们无法想象更高维度的情节，如 4D 或 5D 情节！
我们可以应用降维方法(通常是 PCA)将高维数据转换成可以在 2D 或 3D 图中绘制的 2 维或 3 维数据。
作为一个例子，考虑有 30 个变量的乳腺癌数据集。所以，数据的维数是 30。在 EDA 中，您需要绘制这些数据，以找到一些重要的模式。你怎么能这样做？显然，您不能在 30D 绘图中绘制数据！您需要将原始数据转换为二维或三维数据，然后制作 2D 和三维图，如下图所示。
(图片由作者提供)
当您将原始数据转换为二维数据时，仅捕获了原始数据中 63.24%的可变性。当您将原始数据转换为三维数据时，仅捕获了原始数据中 72.64%的可变性。但是，您能够绘制出近似捕捉原始数据的图，并在数据中找到一些模式。
这个应用的详细指南可以在这里(我写的)。
可以应用维数减少来减轻过度拟合的问题
过度拟合是数据科学家在建模时面临的最糟糕的问题。降维是可用于减轻机器学习模型中过拟合的技术之一。
现在，你可能会想它是如何工作的。降维会找到较少数量的变量，或者从模型中删除最不重要的变量。这将降低模型的复杂性，并消除数据中的一些噪声。这样，维数减少有助于减轻过度拟合。
这个应用的详细指南可以在这里找到(我写的)。
降维会自动消除多重共线性
并非数据中的所有变量都是独立的。一些输入变量可能与数据集中的其他输入变量相关。这被称为 多重共线性 ，它会对回归和分类模型的性能产生负面影响。
当我们应用降维时，它利用了变量之间存在的多重共线性。例如，PCA 将高度相关的变量组合成一组新的不相关变量。主成分分析可以自动消除数据中的多重共线性！
现在，看下面两张热图。
(图片由作者提供)
左边的热图显示了有 30 个变量的乳腺癌数据集中变量的相关系数。您可以看到数据集中有高度相关的变量。在对数据集应用 PCA 后，我们将变量的数量减少到 6 个，同时保持原始数据集中 88.76%的可变性。这 6 个变量的相关系数由右图的热图显示。你可以看到那些变量现在是而不是相关。因此，这意味着我们已经通过应用 PCA(一种降维技术)成功地消除了多重共线性。
这个应用的详细指南可以在这里找到(我写的)。
降维用于因子分析
因子分析是一种降维技术。这使用主成分方法，除了一个显著的例外，几乎与 PCA 相同。因子分析发现一些重要的变量，称为因子，它们不在原始数据集中。这些因素是通过分析主成分得出的。这也需要领域知识。
这个应用的详细指南可以在这里找到(我写的)。
降维可以用于图像压缩
降维减少了数据集的大小，同时尽可能保持原始数据的可变性。一种类似的方法可以用于图像压缩。因此，在图像压缩中，我们减少图像的像素数量，同时尽可能保持原始图像的质量。
这里，我们将图像中的总像素视为该图像的维数。现在，看下面三张图片。
(图片由作者提供)
左图是 784 维的原图。另外两个图像是压缩图像。中间的图像有 184 个维度。维数从 784 减少到 184，同时保持 96%的图像质量。右图只有 10 个维度。该图像中仅捕获了 40%的数据。
这个应用的详细指南可以在这里找到(我写的)。
上面的例子是为了压缩灰度图像。我们还可以使用降维来压缩 RGB 彩色图像。这里有一个例子。
花意象比较(作者图片)
- 左上:400 维的原始花卉图像。
- 右上:只有 40 维的压缩花图像。维数减少了 10 倍，同时保持了原始图像 91.24%的质量！我们仍然可以识别图像中的重要部分。
- 左下:只有 25 维的压缩花图像。维数减少了 16 倍，同时保持了原始图像 83.41%的质量！我们仍然可以识别图像中的重要部分。
- 右下:不做特征缩放应用 PCA 后的花朵图像输出。转换后的数据不能代表原始数据。我在这里向您展示了在应用 PCA 之前进行特征缩放的重要性。
这个应用的详细指南可以在这里找到(我写的)。
降维减少了模型的训练时间
高维空间中的数据点更有可能彼此远离。这是因为高维空间中有大量的可用空间。训练时，算法会对这些数据点进行计算。当维数很高，数据点之间距离很远时，计算会极其缓慢。因此，机器学习和深度学习算法将无法在高维数据上高效地训练模型。因此，在我们将数据输入算法之前，应该对数据应用降维技术。
在训练模型时，降维节省了大量的计算资源
这很简单！由于降维通过简化计算减少了模型的训练时间，因此训练这些模型所需的计算资源将非常少。因此，降维在训练模型时自动节省了大量的计算资源。
降维降低了模型的复杂性
只要简单模型足够强大，能够做出准确的预测，简单模型就比复杂模型好。它们也很容易解读。通过只保留数据中最重要的变量或减少变量的数量，降维降低了模型的复杂性。
降维提高了模型的准确性
数据的噪声去除可以发生在降维中，因为它去除了相关变量和最不重要的变量。这将进一步提高模型的准确性。
降维将非线性数据转换成线性可分的形式
大多数真实世界的数据不是线性可分的。在这种情况下，线性超平面(2d 空间中的直线或 3d 或更高维空间中的适当平面)无法对非线性数据进行分类。为了使线性超平面能够对非线性数据进行分类，我们应该将非线性数据转换成线性形式。
一种称为核 PCA (也称为正常 PCA 的非线性形式)的降维方法可用于将非线性数据转换为线性可分离形式。内核 PCA 分两步运行。
- 输入数据被馈送到算法中的核函数(通常是“rbf”核),并被投影到一个新的高维空间中，在该空间中，非线性数据变得可线性分离。
- 然后，将普通 PCA 应用于从上一步骤投影的较高维数据，以将数据恢复到原始的较低维空间中。
现在，看下面的情节。
(图片由作者提供)
原始数据绘制在左侧的图像中。你可以清楚地看到，原始数据是非线性的，不能用一个线性超平面(本例中是直线)来分隔。应用核主成分分析后的数据绘制在右图中。此时，转换后的数据是线性可分的。
降维可用于压缩神经网络结构
这可以通过使用一种称为 自动编码器 的特殊神经网络架构来实现，该架构将高维输入数据压缩到较低的维度。换句话说，它找到输入数据的压缩表示。
自动编码器有两个功能，也称为运算符:
- 编码器:这是一个非线性函数，它将输入数据转换成一个叫做潜在向量的低维形式。
- 解码器:这也是一个非线性函数，以潜向量为输入，构造另一个与原始输入非常相似的输出。目标是最小化重建误差。
现在，请看下图中的自动编码器。
(图片由作者提供)
编码器将 X (784-dim)作为输入，并将其转换为较低维的潜在向量(184-dim ),解码器将其作为输入。解码器的输出与原始输入 X 非常相似，但并不完全相同。输入和输出之间的不相似性由应该尽可能保持最小的重构误差或损失函数来测量。
摘要
整个 ML 充满了具有极其有用的优点的降维。有许多降维技术。你在这篇文章中已经听到了一些。PCA 是最常用的，它是一种线性方法。因子分析是 PCA 的一个特例。核 PCA 是一种可以应用于非线性数据的非线性方法。自动编码器的工作方式类似于 PCA，但应该用于非常大的数据集和神经网络应用程序。
降维方法的详细解释可以在这里(我写的)。
今天的帖子到此结束。
你以为整个 ML 都是降维及其应用？
如果你有任何反馈请告诉我。
我希望你喜欢阅读这篇文章。如果你愿意支持我成为一名作家，请考虑 注册会员 以获得无限制的媒体访问权限。它只需要每月 5 美元，我会收到你的会员费的一部分。
*https://rukshanpramoditha.medium.com/membership
非常感谢你一直以来的支持！下一个故事再见。祝大家学习愉快！*
接下来阅读(推荐)——我写的！
寻找不同的方法来减少数据集的大小，同时尽可能地保持变化。
*</11-dimensionality-reduction-techniques-you-should-know-in-2021-dcb9500d388b>
了解主成分分析(PCA)的幕后工作原理。
一站式解决您关于 PCA 的大部分问题。
https://rukshanpramoditha.medium.com/principal-component-analysis-18-questions-answered-4abd72041ccd
特别感谢 Unsplash 上的卡尼·贝内迪克托娃 ，为我提供了这篇文章的精美封面图片。
鲁克山·普拉莫迪塔
2021–12–08 (最后编辑时间:2022–04–26)*
2021 年你应该知道的 11 种降维技术
减少数据集的大小，同时尽可能保留变化
在统计学和机器学习中，数据集的属性、特征或输入变量的数量被称为其维度。例如，让我们来看一个非常简单的数据集，它包含两个属性，分别叫做高度和重量。这是一个二维数据集，该数据集的任何观察值都可以绘制成 2D 图。
(图片由作者提供)
如果我们将另一个称为年龄的维度添加到同一个数据集，它就成为一个三维数据集，任何观察都位于三维空间中。
(图片由作者提供)
同样，真实世界的数据集也有许多属性。这些数据集的观测值位于难以想象的高维空间中。以下是数据科学家、统计学家和机器学习工程师对与维度相关的数据集的一般几何解释。
在包含行和列的表格数据集中，列表示 n 维特征空间的维度，行是位于该空间中的数据点。
降维 简单来说就是减少数据集中的属性数量，同时尽可能保留原始数据集中的变异的过程。这是一个数据预处理步骤，意味着我们在训练模型之前执行降维。在本文中，我们将讨论 11 种这样的降维技术，并使用 Python 和 Scikit-learn 库在真实世界的数据集上实现它们。
降维的重要性
当我们降低数据集的维度时，我们会丢失原始数据中一定百分比(通常为 1%-15%，具体取决于我们保留的组件或特征的数量)的可变性。但是，不要担心丢失原始数据中那么多的可变性，因为维度减少将带来以下优势。
- 数据中更低的维度数量意味着更少的训练时间和更少的计算资源，并提高了机器学习算法的整体性能 —涉及许多特征的机器学习问题使得训练极其缓慢。高维空间中的大多数数据点都非常接近该空间的边界。这是因为在高维空间中有足够的空间。在高维数据集中，大多数数据点可能彼此相距很远。因此，这些算法不能有效地在高维数据上训练。在机器学习中，这种问题被称为 维数灾难——这只是一个你不需要担心的技术术语！
- 降维避免了 过拟合 的问题——当数据中有很多特征时，模型变得更加复杂，往往会对训练数据过拟合。要了解这一点，请阅读我的文章如何通过降维来减轻过度拟合。**
- 降维对于数据可视化 非常有用——当我们将高维数据降维为两个或三个分量时，数据可以很容易地绘制在 2D 或 3D 图上。要看到这一点，请阅读我的主成分分析(PCA)与 Scikit-learn文章。****
- 降维处理多重共线性 —在回归中，当一个自变量与一个或多个其他自变量高度相关时，就会出现多重共线性。降维利用了这一点，将那些高度相关的变量组合成一组不相关的变量。这将解决多重共线性问题。要看到这一点，请阅读我的如何将 PCA 应用于逻辑回归以消除多重共线性？文章。**
- 降维对于因子分析 非常有用——这是一种发现潜在变量的有用方法，这些变量不是在单个变量中直接测量的，而是从数据集中的其他变量中推断出来的。这些潜在变量被称为 因素 。要了解这一点，请阅读我的关于女性跟踪记录数据的因素分析与 R 和 Python文章。**
- 降维去除数据中的噪声——通过只保留最重要的特征并去除冗余特征，降维去除了数据中的噪声。这将提高模型精度。
- 降维可用于图像压缩 — 图像压缩是一种在尽可能保持图像质量的同时最小化图像字节大小的技术。构成图像的像素可以被认为是图像数据的维度(列/变量)。我们执行 PCA 以保持最佳数量的组件，从而平衡图像数据和图像质量中解释的可变性。要看到这一点，请阅读我的使用主成分分析(PCA)进行图像压缩文章。**
- 降维可用于将非线性数据转换成线性可分的形式 — 阅读本文的内核 PCA 部分，了解实际操作！
降维方法
有几种降维方法可用于不同类型的数据，以满足不同的需求。下图总结了这些降维方法。
(图片由作者提供)
主要有两种类型的降维方法。这两种方法都减少了维数，但方式不同。区分这两种方法非常重要。一种方法仅保留数据集中最重要的特征，并移除冗余特征。没有应用于特征集的变换。向后淘汰、向前选择和随机森林就是这种方法的例子。另一种方法是寻找新特征的组合。对该组特征应用适当的变换。新的要素集包含不同的值，而不是原始值。这种方法可以进一步分为线性方法和非线性方法。非线性方法是众所周知的流形学习。主成分分析(PCA)、因子分析(FA)、线性判别分析(LDA)和截断奇异值分解(SVD)是线性降维方法的例子。核主成分分析、t 分布随机邻居嵌入(t-SNE)、多维标度(MDS)和等距映射(Isomap)是非线性降维方法的例子。
让我们详细讨论每种方法。请注意，对于 PCA 和 FA，我包含了我以前工作内容的链接，这些内容最好地描述了这两种方法的理论和实现。对于所有其他方法，我将在本文中包括理论、Python 代码和可视化。
线性方法
线性方法包括 线性 将原始数据投影到低维空间。我们将在线性方法下讨论 PCA、FA、LDA 和截断 SVD。这些方法可以应用于线性数据，但不适用于非线性数据。
主成分分析
PCA 是我最喜欢的机器学习算法之一。PCA 是一种线性降维技术(算法)，它将一组相关变量(p)转换成较小的 k (k
主成分 ，同时尽可能多地保留原始数据集中的变化。在机器学习(ML)的背景下，PCA 是一种用于降维的无监督机器学习算法。
由于这是我最喜欢的算法之一，我以前为 PCA 写过几个内容。如果你有兴趣了解 PCA 背后的理论及其 Scikit-learn 实现，你可以阅读我写的以下内容。
因素分析
****因子分析和主成分分析都是降维技术。因子分析的主要目的不仅仅是降低数据的维度。因子分析是发现潜在变量的有用方法，这些潜在变量不是直接在单个变量中测量的，而是从数据集中的其他变量中推断出来的。这些潜在变量被称为 因素 。
如果你有兴趣了解 FA 背后的理论和它的 Scikit-learn 实现，你可以阅读我写的以下内容。
线性判别分析(LDA)
LDA 通常用于多类分类。它也可以用作降维技术。LDA 最好按类别分离或区分(因此得名 LDA)训练实例。LDA 和 PCA 之间的主要区别在于，LDA 查找优化类可分性的输入特征的线性组合，而 PCA 试图在数据集中查找一组方差最大的不相关分量。两者之间的另一个关键区别是，PCA 是一种非监督算法，而 LDA 是一种监督算法，它将类别标签考虑在内。
LDA 有一些局限性。要应用 LDA，数据应该是正态分布的。数据集还应该包含已知的类标签。LDA 可以找到的最大组件数是类数减 1。如果数据集中只有 3 个类别标签，LDA 在降维中只能找到 2(3–1)个分量。不需要执行特征缩放来应用 LDA。另一方面，PCA 需要缩放的数据。但是，PCA 不需要类别标签。PCA 可以找到的最大分量数是原始数据集中输入要素的数量。
不应将用于降维的 LDA 与用于多类分类的 LDA 相混淆。这两种情况都可以使用 Scikit-learnLinearDiscriminantAnalysis()函数来实现。在使用 fit(X，y) 拟合模型之后，我们使用 predict(X) 方法对 LDA 对象进行多类分类。这将为原始数据集中的类分配新的实例。我们可以使用 LDA 对象的 transform(X) 方法进行降维。这将找到优化类可分性的新特征的线性组合。
以下 Python 代码描述了对 Iris 数据集实施 LDA 和 PCA 技术，并展示了两者之间的差异。原始虹膜数据集有四个特征。LDA 和 PCA 将特征数量减少为两个，并实现 2D 可视化。
等到加载 python 代码！
(图片由作者提供)
截断奇异值分解
该方法通过截断奇异值分解(SVD)进行线性降维。它适用于许多行值为零的稀疏数据。相比之下，PCA 在处理密集数据时效果很好。截断 SVD 也可以用于密集数据。截断 SVD 和 PCA 之间的另一个关键区别是，SVD 的因子分解是在数据矩阵上进行的，而 PCA 的因子分解是在协方差矩阵上进行的。
截断 SVD 的 Scikit-learn 实现要容易得多。这可以通过使用 TruncatedSVD() 函数来完成。以下 Python 代码描述了对 Iris 数据集实施截断 SVD 和 PCA 技术。
等到加载 python 代码！
(图片由作者提供)
非线性方法(流形学习)
如果我们处理的是现实应用中经常使用的非线性数据，那么到目前为止讨论的线性方法在降维方面表现不佳。在本节中，我们将讨论四种可用于非线性数据的非线性降维方法。
核主成分分析
核 PCA 是一种使用 核 的非线性降维技术。它也可以被认为是正常 PCA 的非线性形式。核主成分分析可以很好地处理非线性数据集，而正常的主成分分析不能有效地使用。
内核 PCA 背后的直觉很有趣。数据首先通过一个核函数运行，并将它们临时投影到一个新的高维特征空间中，在该空间中，类变得线性可分(可以通过画一条直线来划分类)。然后，该算法使用正常的 PCA 将数据投影回低维空间。通过这种方式，核 PCA 将非线性数据转换成可以与线性分类器一起使用的低维数据空间。
在内核 PCA 中，我们需要指定 3 个重要的超参数——我们想要保留的组件数量、内核类型和内核系数(也称为 gamma )。对于核的类型，我们可以用 【线性】【poly】【RBF】【sigmoid】【余弦】 。被称为径向基函数核的 rbf 核 是最流行的一种。
现在，我们将对使用 Scikit-learnmake _ moons()函数生成的非线性数据实现一个 RBF 内核 PCA。
等到加载 python 代码！
非线性数据(图片由作者提供)
我们可以清楚地看到，上述两类非线性数据无法通过画一条直线来区分。
让我们对上述数据同时执行 PCA 和内核 PCA，看看会发生什么！
等到加载 python 代码！
(图片由作者提供)
从上图可以看出，普通的 PCA 无法将非线性数据转换成线性形式。对相同的数据应用核主成分分析后，两个类线性分离得很好(现在，可以通过画一条垂直的直线来划分类)。
这里，原始数据的维数为 2，绘制的数据的维数也为 2。那么，核 PCA 真的降低了数据的维数吗？答案是“是”因为 RBF 核函数临时将二维数据投影到一个新的高维特征空间中，在该空间中，类变得可线性分离，然后算法将该高维数据投影回二维数据中，该二维数据可绘制成 2D 图。当类变得线性可分时，降维过程在幕后发生。
使用核 PCA 进行维数缩减的一个限制是，我们必须在运行算法之前为超参数指定一个值。这需要实现超参数调谐技术，例如网格搜索，以找到 伽马 的最佳值。这超出了本文的范围。但是你可以通过阅读我的用通俗易懂的英语解释的 k 重交叉验证来获得超参数调优过程的帮助。********
t 分布随机邻居嵌入(t-SNE)
这也是一种主要用于数据可视化的非线性降维方法。除此之外，它还广泛应用于图像处理和自然语言处理。如果数据集中的要素数量超过 50，Scikit-learn 文档建议您在 t-SNE 之前使用 PCA 或截断奇异值分解。以下是在 PCA 之后执行 t-SNE 的一般语法。此外，请注意，在 PCA 之前需要进行特征缩放。
******from sklearn.decomposition import PCA
from sklearn.manifold import TSNE
from sklearn.preprocessing import StandardScalersc = StandardScaler()
X_scaled = sc.fit_transform(X)pca = PCA()
X_pca = pca.fit_transform(X_scaled)tsne = TSNE()
X_tsne = tsne.fit_transform(X_pca)******
使用 Scikit-learn 管道可以简化上述代码。
******from sklearn.pipeline import Pipeline
from sklearn.decomposition import PCA
from sklearn.manifold import TSNE
from sklearn.preprocessing import StandardScalersc = StandardScaler()
pca = PCA()
tsne = TSNE()tsne_after_pca = Pipeline([
('std_scaler', sc),
('pca', pca),
('tsne', tsne)
])X_tsne = tsne_after_pca.fit_transform(X)******
现在，我们将 t-SNE 应用于虹膜数据集。它只有 4 个特点。因此，我们不需要在 SNE 霸王龙之前运行 PCA。
等到加载 python 代码！
(图片由作者提供)
多维标度(MDS)
MDA 是另一种非线性降维技术，它试图保留实例之间的距离，同时降低非线性数据的维度。有两种类型的 MDS 算法:公制和非公制。Scikit-learn 中的 MDS() 类通过将 公制 超参数设置为 True(对于公制类型)或 False(对于非公制类型)来实现这两者。
以下代码实现了对 Iris 数据集的 MDS。
等到加载 python 代码！
(图片由作者提供)
等距映射
该方法通过等距映射进行非线性降维。它是 MDS 或内核 PCA 的扩展。它通过计算曲线或测地线到其最近邻居的距离来连接每个实例，并减少维度。可以通过实现 Scikit-learn 中 Isomap 算法的 Isomap() 类的 n_neighbors 超参数来指定每个点要考虑的邻居数量。****
下面的代码实现了 Iris 数据集的 Isomap。
等到加载 python 代码！
(图片由作者提供)
其他方法
在这一类别下，我们将讨论 3 种方法。这些方法仅保留数据集中最重要的特征，并移除冗余特征。因此，它们主要用于特征选择。但是，在选择最佳特征时，降维会自动发生！因此，它们也可以被认为是降维方法。这些方法将提高模型的精度分数，或提升高维数据集的性能。
反向消除
该方法通过递归要素消除(RFE)过程从数据集中消除(移除)要素。该算法首先尝试在数据集中的初始要素集上训练模型，并计算模型的性能(通常，分类模型的精度得分和回归模型的 RMSE)。然后，该算法一次丢弃一个特征(变量)，在剩余的特征上训练模型，并计算性能分数。该算法重复消除特征，直到它检测到模型的性能分数有小的(或没有)变化，并停止在那里！
在 Scikit-learn 中，可以通过使用sk learn . feature _ selection模块中的 RFE() 类来实现反向消除。该类的第一个参数应该是具有 fit() 方法和 coef_ 或 feature_importances_ 属性的 监督的 学习估计器 。第二个应该是要选择的特性的数量。根据 Scikit-learn 文档，如果我们不指定要选择的特征数量，则选择一半的特征( n_features_to_select 参数)。这种方法的一个主要限制是我们不知道要选择的特征的数量。在这些情况下，最好通过为 n_features_to_select 指定不同的值来多次运行该算法。****
现在，我们在虹膜数据上训练逻辑回归模型，并通过反向特征消除来识别最重要的特征。
等到加载 python 代码！
(图片由作者提供)
从输出中，我们可以看到递归特征消除(RFE)算法已经从逻辑回归模型中消除了萼片长度(cm) 。萼片长度(cm)** 是最不重要的特征。其余要素包含初始数据集中的原始值。如图所示，最好保留模型中的其他 3 个特征。******
预选
这种方法可以认为是逆向淘汰的相反过程。该算法不是递归地消除要素，而是尝试针对数据集中的单个要素训练模型，并计算模型的性能(通常，分类模型的精度得分和回归模型的 RMSE)。然后，该算法一次添加(选择)一个特征(变量)，根据这些特征训练模型，并计算性能分数。该算法重复添加特征，直到它检测到模型的性能分数有小的(或没有)变化，并停止在那里！
在 Scikit-learn 中，没有用于前进特征选择的直接功能。相反，我们可以将 f_regression (用于回归任务)和 f_classif (用于分类任务)类与 SelectKBest 类一起使用。 f_regression 返回回归任务的标签/特征之间的 F 值。 f_classif 返回分类任务的标签/特征之间的方差分析 F 值。这些 F 值可用于特征选择过程。选择测试根据基于要素 F 值的最高分数自动选择要素。 SelectKBest 的 score_func 参数应指定为 f_classif 或 f_regression 。 k 参数定义了要选择的顶部特征的数量。****
让我们对虹膜数据执行前向特征选择，并识别最重要的特征。
等到加载 python 代码！
(图片由作者提供)
从输出中，我们可以看到正向特征选择过程选择了具有较高 F 值的萼片长度(cm) 、花瓣长度(cm)** 和花瓣宽度(cm) 。******
为了基于截止 F 值定义 k 参数的值，我们可以使用下面两行代码。
******F_values = f_classif(X,y)[0]
k = len([num for num in F_values if num > 50])******
这将计算大于 50 的 F 值的数量，并将其分配给 k 。这与上面的实现完全相同。
随机森林
随机森林是一种基于树的模型，广泛用于非线性数据的回归和分类任务。它还可以通过其内置的 feature_importances_ 属性用于特征选择，该属性在训练模型时根据‘Gini’标准(内部节点分割质量的度量)计算每个特征的特征重要性分数。如果你有兴趣了解更多关于随机森林是如何进行预测的，你可以阅读我的“随机森林——决策树的集合”文章。****
以下 Python 代码实现了 Iris 数据的随机森林分类器，计算并可视化了要素重要性。
等到加载 python 代码！
(图片由作者提供)
通过查看特征重要性，我们可以决定放弃萼片宽度(cm) 特征，因为它对制作模型的贡献不足。让我们看看如何！****
等到加载 python 代码！
(图片由作者提供)
sci kit-learnSelectFromModel仅选择重要性大于或等于指定阈值的特征。由 SelectFromModel 返回的值可以用作随机森林分类器的新输入 X，该分类器现在仅在所选特征上被训练！****
******rf = RandomForestClassifier(n_estimators=100, max_depth=3,
bootstrap=True, n_jobs=-1,
random_state=0)rf.fit(features_important, y)******
今天的帖子到此结束。我的读者可以通过下面的链接注册成为会员，以获得我写的每个故事的全部信息，我将收到你的一部分会员费。
【https://rukshanpramoditha.medium.com/membership】报名链接:
非常感谢你一直以来的支持！下一个故事再见。祝大家学习愉快！
特别感谢 Unsplash 上的卡尼·贝内迪克托娃，为我提供了这篇文章的精美封面图片。****
鲁克山普拉莫迪塔
2021–04–14
11 Dplyr 函数，现在就开始在 R
大幅提高您的数据处理效率
沃克·芬顿在 Unsplash拍摄的照片
作为一名大学新生，当我的人生目标仍然是成为一名炙手可热的外交官或联合国大使时，我和一个穿着我们学校颜色的技术人员一起乘坐优步回到了我的大学，他碰巧住在离我宿舍几个街区的地方。我尽可能地和他闲聊，询问了他的生活，发现他是一名刚刚从工程专业毕业的多米诺骨牌公司的数据科学家。
“哦，太酷了……你最常用的是什么，呃，包裹？”我说，我为自己记住了暗语中的“包裹”而感到自豪。
“大部分是 Dplyr。”
“听起来……很有趣。”我说，点点头，低头看着我的手。在那之后，我试图想出一些问题来问他关于比萨饼的事情，比如他是否会终身免费获得比萨饼，以及他是否相信对奶酪上瘾是可能的，但相反，他只是看着窗外，继续用手玩了三十分钟。最后，我给了他我的号码，这样他就可以问我要我的那一半，但就像那个拼车的震耳欲聋的沉默一样，我再也没有收到他的后续短信(希望他不要在工作时看 TDS，哈哈)。
所以现在我在这里，仍然害怕四年前和一个不知名的陌生人一起坐车。但是也许，仅仅是也许，如果你和一个认识 Dplyr 的陌生人卡在一辆车里，你可以用这篇文章的内容进行对话。然后，我亲爱的读者，你将不会花四年的时间去想 Dplyr 是什么，实现你的旧梦想不再，自学如何编码，在全球疫情毕业，在研究生院探索一个全新的领域，最终成为一名数据科学家，并以 TDS 文章的形式重温最初的尴尬对话。
好吧，但说真的，Dplyr 非常酷(独一无二的哈德利·威克姆的又一项伟大发明)。就范围而言，Dplyr 是 R，就像 Pandas 是 Python 一样，但是这两种语言也与 SQL 有很强的相似性。如果你发现自己非常依赖 base R，那么 Dplyr 的%>%可能会更有效、更直观地为你解决许多日常数据争论任务。
在我开始讨论您现在需要开始实施的顶级功能之前，我们应该先讨论一下房间里的一头大象…
%>%操作员
本文的替代名称: 什么是$@ & %是% > %操作符？
作者插图
%>% ( 读作:“管道”)是 R 中的一个操作符，它将之前的内容输入到之后的内容中。这一点很重要，因为管道操作符可以按顺序用于将许多层命令链接在一起。因此，总是从他们希望修改的数据集开始，接着是另一个管道，然后是修改器。可以添加无限数量的修改器，但是必须用管道将它们分开才能工作。对我来说，我喜欢把 Dplyr 中的%>%想象成类似于熊猫中的.。或者，如果 x 表示基础数据集，那么一个%>%就好比把 x 放入函数 f(x) ，两层是 g(f(x)) ，三层是h(g(f(x))，以此类推。
像食人魔和洋葱一样，管道也有层次。【GIPHY 的 GIF
下面是 Pandas vs. Dplyr 重命名两个列的例子。依我拙见，Dplyr 实际上在可读性方面领先一点:
# pandas
df.rename(columns={'old_name1': 'new_name1',
'old_name2': 'new_name2'}, inplace=True)
--------------------------------------------------------------------
# dplyr
df %>%
rename(new_name1 = old_name1,
new_name2 = old_name2)
这里有一些将多个管道链接在一起的例子，可以进行无限次:
# in order to follow along, run these:
library(tidyverse)
library(gapminder)# one pipe
gapminder %>%
select(country, continent, year, pop)# two pipes
gapminder %>%
select(country, continent, year, pop) %>%
rename(population = pop)# three pipes
gapminder %>%
select(country, continent, year, pop) %>%
rename(population = pop) %>%
filter(year > 1985)# four pipes
gapminder %>%
select(country, continent, year, pop) %>%
rename(population = pop) %>%
filter(year > 1985) %>%
arrange(desc(population)) # for the last, notice that we say "arrange(desc(population))" because in step two it was renamed from "pop".
现在我们已经解决了这个问题，我们可以开始深入函数本身了！
#1:描述数据
glimpse(): 返回 1) # rows，2) # cols，3)每列的数据类型，以及 4)前 10 个左右的条目(取决于屏幕上的空间)。相应的熊猫功能我会把它等同于df.describe()。
library(tidyverse)
library(gapminder)gapminder %>%
glimpse()
#2:按一列或多列排序
arrange(): 关注数据有时会非常有益，所以我们使用arrange()来按升序或降序排列各个列。这与 SQL 中的ORDER BY子句或 Pandas 中的df.sort_values()非常相似。
# sort ascending (default)
gapminder %>%
arrange(lifeExp)# sort descending
gapminder %>%
arrange(desc(lifeExp))# sort on multiple columns
gapminder %>%
arrange(lifeExp, pop, country)
#3 和 4:数据选择
select()，transforme():select()函数只对原始数据集的指定列进行快照。类似地，transmute()以同样的方式工作，并具有同时创建新列的额外能力。这两个函数的工作方式与 SQL 中的SELECT子句非常相似。
如果您只是希望从数据框架中拉出未动过的列，我会坚持使用 select，而如果您要进行转换，则使用 transmute。在下面的例子中，我们有变量gdpPercap和pop，我们正在创建一个新的gdp列。
gapminder %>%
select(country, continent, year, pop)gapminder %>%
transmute(country, continent, gdp = gdpPercap * pop)
select 还有一些更高级的选项，可以帮助您准确地获得所需的列，包括一串连接的列或所有包含、开始或结束于某些字符的列:
# advanced select() tools# 1\. rename variables with select()
gapminder %>%
select(country, continent, population = pop)# 2\. Include a string of columns at once with ':'
gapminder %>%
select(country, year, lifeExp:gdpPercap)# 3\. Include any column with a given string
gapminder %>%
select(country, year, contains("gdp"))# 4\. Include any column starting with a given string
gapminder %>%
select(country, year, starts_with("co"))# 5\. Include any column ending with a given string
gapminder %>%
select(country, year, ends_with("Exp"))# Keep the last column, by any name
gapminder %>%
select(country, year, last_col())
#4 和 5:重命名/修改单个列
rename()，mutate(): 这些函数修改一个或多个列，并将它们保存回文件。顾名思义，rename()用于重命名，而mutate()则完全通过转换创建一个新函数。
有了rename()和mutate()，我们可以用逗号一次表示多个修改。Dplyr 中的重命名类似于使用df.rename()，变异类似于 Python 中使用的df[new_col] = df[old_col1] * df[old_col2]。
# rename a column to be called something else
gapminder %>%
rename(population = pop, #ex. 'pop' turns into 'population'
countries = country,
life_expectancy = lifeExp)# add a new calculated field
gapminder %>%
mutate(gdp = gdpPercap * pop) #ex. 'gdp' is created as a new var
#6:根据条件过滤数据
filter(): 类似于 SQL 中的 WHERE 子句或者 Python 中的条件表达式(df[df['country'] == 'France'])。与其他 Dplyr 函数类似，可以通过用,、&或|符号分隔每个参数来指定多个过滤器。对于字符串，建议使用%in%而不是==。
# filter for France
gapminder %>%
filter(country %in% "France")# filter for a subset of countries (c stands for 'concat')
gapminder %>%
select(pop, country, year) %>%
filter(country %in% c('France','Spain','Portugal'))# "or" operator function
gapminder %>%
select(pop, country, year) %>%
filter(pop > 50000 | pop < 100000)# "and" operator function 1
gapminder %>%
select(pop, country, year) %>%
filter(pop > 50000, pop < 100000)# "and" operator function 2
gapminder %>%
select(pop, country, year) %>%
filter(pop > 50000 & pop < 100000)
#7-9:取最大值、最小值、平均值、计数&任何中间值
count()、summarize()和 top_n(k，)
count()函数遍历数据集，并计算一个值在给定的一列或多列中出现的次数。我经常使用它一次查看一列，例如了解我正在查看的每个洲有多少个国家，或者一个城市中有多少人开车、骑自行车或乘公交车上班。
gapminder %>%
count(continent)
使用 summarize，我们可以查看聚合函数，如列的 sum、median、mean、standard deviation、variance、min 和 max，并为其命名。当与类似group_by()的函数混合使用时，这些函数在理解数据集中的子群体时会变得非常有用。
# summarize
# sum(), mean(), median(), min(), max(), sd(), var()gapminder %>%
summarize(total_gdp = sum(gdpPercap))gapminder %>%
summarize(avg_gdp = mean(gdpPercap))gapminder %>%
summarize(gdp_standard_dev = sd(gdpPercap))gapminder %>%
summarize(gdp_variance = var(gdpPercap))# we can also create many columns at oncegapminder %>%
summarize(max_gdp = max(gdpPercap),
total_pop = sum(pop),
min_lifeExp = min(lifeExp))# I use __ = __ in order to give a name to the new summary columns, # but it is not required.
最后，我们可以使用top_n(k, )只保留数据帧或组中的前 k 值。例如，我们可以看看下面每个大陆人均 GDP 最高的国家。如果我们没有首先包含group_by()函数，那么结果将是世界上人均 GDP 最高的国家，即科威特。类似地，如果我们指定了 k=4 ，那么它会显示出每个大洲预期寿命最高的前四个国家。
# top_n(k, )gapminder %>%
group_by(continent) %>%
top_n(1, gdpPercap)
#10 和 11:分组依据
group _ by()&ungroup():和所有的编程语言一样，如果没有一个好的 group by 函数，我们会怎样？与列出的其他函数结合使用，我们可以得出关于数据集中存在的子群体的有趣结论。该功能与 Pandas df.group_by()或 SQL 的GROUP BY中的功能相同，除了这些组将保持不变，直到您再次手动断开它们与ungroup()的连接。
# Using group_by
gapminder %>%
group_by(year) %>%
mutate(year_total = sum(pop))# Grouping and then ungrouping again with ungroup()
gapminder %>%
group_by(year) %>%
mutate(year_total = sum(pop)) %>%
ungroup() %>%
mutate(fraction = pop / year_total)
结论
总之，我希望这篇介绍能让你明白 Dplyr 与 SQL 和 Pandas 有很强的相似性。如果关于数据转换的某些东西让你犯了错误，Dplyr 在效率和可读性方面很强——并且在互联网上有大量的备忘单和教程为你提供！
如果你喜欢这篇关于与 Dplyr 的数据争论的文章，请鼓掌或评论让我知道——如果有足够的兴趣，那么我将做第 2 部分，在那里我将回顾 Dplyr 中更复杂的命令，并可能在这个过程中发现我过去更尴尬的故事。🙃
敬哈雷·韦翰，万物的创造者。说真的，我们什么时候让他成为我们的最高统治者了？
- *编辑:基地 R 终究是要拿烟斗的！链接:https://www.youtube.com/watch?v=wmvjxb6Gdm8
我喜欢的推荐信
- https://learn . data camp . com/courses/data-manipulation-with-dplyr
- https://www.rstudio.com/resources/cheatsheets/
- 【https://appsilon.com/pandas-vs-dplyr/】
- https://analyticsindiamag . com/python-pandas-vs-RS-tidy verse-who-wins/
- https://www . Reddit . com/r/data science/comments/d9qom 4/whats _ pandas _ missing _ that _ tidy verse _ provides/
揭开熊猫约会神秘面纱的 11 个基本技巧
使用 Python 简化日期处理的简易指南，包括 csv 文件内外。
双关:p .照片由 Raissa Lara Lütolf (-Fasel) 在 Unsplash 上拍摄
管理日期时间特性在几乎所有的数据科学中都很常见。幸运的是，熊猫通过无数有用的功能广泛地支持它。
在从我们的 csv 文件导入数据时解析和驯服日期列是一项有趣而又令人畏惧的任务，我打算在一个简单易懂的教程中向您介绍这个解决方案。
那就别磨蹭了。我们开始吧👇
日期格式基础
日期和时间的表示法是国际标准中被表示为格式的 ISO 8601。在这里，日期，例如 2021 年 12 月 25 日，将被写成:“2021–12–25”。
一般来说，用 pandas 解析日期列的最简单和最普通的方法是在读取文件时通过指定它。
*df = pd.read_csv('sample_data.csv')
df.head()*
样本数据的前五行
使用默认的read_csv()函数将 日期 列读取为对象数据类型:
日期的对象数据类型，不是我们想要的，是吗？
指定**parse_dates**参数有助于我们对所需的列进行日期解析:
*df = pd.read_csv('sample_data.csv', parse_dates=['date'])*
解析日期！
让我们感受一下日期是如何被解析的，好吗？
看看现在 ISO 格式的日期！
这是非常方便的！
但是直接这么做也有不好的一面。
请记住，只有当日期已经以 ISO 格式显示时，这才有效，
或
如果日期格式为:年/月/日或年/月/日。
然而，在某个特定国家以外的地方，情况并不总是如此。因此，我们在这里需要更加小心。
我们继续下一节，了解更多其他情况。
用指定格式解析日期
大多数时候，我们从数据中导入的日期与熊猫的首选格式有很大不同。所以我们强制它在解析日期列时遵守一个规则。
首先导入数据:
然后，给出您知道的数据格式:
在这里，我指定了格式: “%d/%m/%Y”，因为我知道文件中的日期是这种格式。“%m/%d/%Y”月初将去，以此类推。
你可以在 Python 网站的这里阅读所有类型的格式符号。
使用 dayfirst 符号快捷方式
我认为这是一种捷径，因为它是前一种方法的简化版本。
如果我们想让熊猫先考虑天而不是，我们可以将参数dayfirst设置为True。这通常在那个国家之外是有效的，但是确保首先检查你的数据。
世界其他地方的 dayfirst 通常是正确的。
使用日期作为更好的选择、聚合和分组的索引
*df = df.set_index(['date'])*
从今以后，选择一个日期范围将会非常方便。
*df.loc[start_date:end_date]*
通过索引选择日期比使用列更容易
比较函数也以同样的方式运行:
*df.loc[df.index < '03-05-2019']*
选择一年并获取汇总:
*df.loc['2019'].sum()*
如果您的索引没有排序，请使用以下方法进行排序:
*df.sort_index()*
诸如此类。应用函数的可能性只和你的想象力一样有限(当然还有熊猫文档:)！
分解日期，反之亦然
到目前为止，我们已经看到了如何使用日期来选择行，将它们用作索引，并以特定的格式解析它。现在，我们可以看到如何从一个日期以及相反的日期获得年、月和日的信息。
例如，如果你有这样一个数据:
*year month day0 2019 1 11 2019 1 22 2019 1 3*
您可以轻松地将这三列合并为一列:
*df = pd.read_csv('sample_data.csv', parse_dates= {"date" : ["year","month","day"]}, keep_date_col=True)*
其中，年、月和日是文件中单独的列名。如果您想要一个自定义名称，而不仅仅是' date '，您可以在这里指定它。
因此，作为反例，如果我们想获得日、月、年的单独列，我们可以这样做:
*df['year']= df['date'].dt.year
df['month']= df['date'].dt.month
df['day']= df['date'].dt.day*
使用日期范围
通常，您需要生成一组新的日期，以便以后制作系列或数据帧。使用**pd.date_range()**功能可以轻松实现:
您还可以指定周期，这意味着要生成的实例数量以及生成日期的频率。
举个例子，
*pd.date_range(start='1/1/2019', end='2/01/2019', freq='W')*
将生成从开始日期到结束日期的每周日期:
每周日期生成
进行日期偏移
你曾经需要给日期加上或减去几周/几天/几个月来得到新的日期吗？
嗯，熊猫也有这样的功能。
你也可以在那里使用天、周或年，还有许多其他的。完整列表见文档。
日期转换
您可能希望移动或滞后时间序列中的值。这个用例的功能是**shift()**。
你可以看到，正如我们所希望的那样，日期推迟了两周。
你可以很好地结合使用偏移和移位函数，用你的时间序列做一些巧妙的事情！
日期重采样
数据科学中最重要的数据操作之一是不同日期频率之间的转换。
让我们举一个例子。假设我们有一个商店的日期索引日销售额的时间序列数据:
**range = pd.date_range("1/1/2019", periods=28, freq="D")df = pd.Series(np.random.randint(0, 500, len(range)), index=range)**
我们的日常时间序列是这样的！
现在，我们想对此进行重新采样，以获得每周的总销售数据。这可以通过重采样功能轻松实现。
**df.resample('W').sum()**
重新取样为每周
我们已经成功地将每日数据转换为每周数据！
但是，请注意它是如何通过将一周的第一天作为周日来自动重新采样的？您可能希望今天是星期一(这在大多数真实世界的数据中是正常的)，所以执行这个小修正:
**df.resample('W-MON').sum()**
以星期一为一周的开始！
类似地，你也可以根据需要使用一周中的其他日子——W-TUE、W-星期五等等。
唷。有太多要理解的了。
我希望你仍然和我在一起。:)我保证我们快到终点了。
寻找丢失的日期
通常，我们需要在表中找到缺失的数据行。即使对于日期索引，这也很简单:
如果我们的数据帧看起来像这样:
正常 df
我们可以像这样搜索丢失的日期:
**missing_dates = df.index[~df.index.isin(range)]
missing_dates**
其中，我们的范围** =开始日期和结束日期之间的索引的日期范围。例如，它可以这样定义，考虑到您的数据在您自己的用例中的表现:**
**range = pd.date_range("1/4/2019", "4/1/2019", freq="W")**
最后——找到最近的日期
**df.index.get_loc(dt, method=“nearest”)**
它返回最近日期的索引号到 dt:
离“dt”最近的日期
你也可以这样得到确切的日期:
返回准确的最近日期
结束…
这些是熊猫的日期/时间序列操作，我总是觉得有用，并在工作中不断查找。我希望这篇文章对你也有用。
你可以把它作为参考，或者像我一样，作为处理熊猫日期的一个小备忘单。
接下来，这里是了解熊猫日期时间功能的最佳来源。这是最全面的指南，也是最好的，因为它直接来自原始资料。
我每周都写关于数据科学的文章，并努力让我的读者也觉得有趣！在 Medium 上关注我,在你的 feed 中直接获得新文章。😃
或者更好的是，你还可以订阅 我的每月/双周简讯 让自己随时掌握最新动态！
本文中的代码都打包在一个 Jupyter 笔记本中。这里是我所有文章的代码和资源。快乐学习！⭐️
我的其他文章也可能对你有用:
**</26-datasets-for-your-data-science-projects-658601590a4c> **
你应该知道的 11 个熊猫内置函数
不需要编写额外的代码—只需使用它们
我用熊猫已经有几年了，每次我觉得我打字太多，我就谷歌一下这个操作，我通常会找到一个更短的方法来做这件事——一个新的熊猫技巧！
我最近了解了这些功能，我认为它们很重要，因为它们很容易使用。
通过阅读这篇文章，你将学会:
- 如何从数据帧中检索列值
- 如何更改数据框架中的列值
- 向数据框架添加新列的正确方法
- 如何检索系列或数据帧
- 如何从熊猫系列创建数据框架
- 带 between 函数的过滤器
- 使用 reindex 函数修复行的顺序
- 描述函数的高级用法
- 使用正则表达式进行文本搜索
- 比熊猫的记忆数据集还要大
- 如何节省磁盘空间
我们开始吧
让我们创建一个简单的数据框架来展示这些技巧:
import pandas as pddf = pd.DataFrame({"col1": ["A0", "A1", "A0", "A2", "A0", "A1"]})
样本数据框(图片由作者制作)
1.如何从数据帧中检索列值
如何从 Dataframe(作者制作的图片)中获取列值
从数据帧中检索列值有两种方法:
- 基于整数位置索引(iloc)，
- 基于标签索引(loc)。
要检索 col1 列的第一列值(整数位置索引):
df.iloc[0].col1# output: 'A0'
要检索最后一列值:
df.iloc[-1].col1# output: ‘A1’
您也可以使用标签检索列值。默认情况下，pandas 数据帧具有从 0 到 n 的索引，其中 n 是数据帧中的行数。
df.loc[1, “col1”]# output: ‘A1’
参见 pandas 文档以了解更多关于 loc 和 iloc 功能的信息。
2.如何更改数据框架中的列值
如何更改 Dataframe 中的列值(图片由作者制作)
与上面的示例类似，您可以使用 loc 和 iloc 函数更改列的值。您使用哪一个取决于您是否有行的整数位置(iloc)或行的标签(loc)。
要根据整数位置更改第一列的值:
df.iloc[0].col1 = “First”
要根据整数位置更改最后一列的值:
df.iloc[-1].col1 = “Last”
要按标签更改列值:
df.loc[2, “col1”] = “Index”
通过应用这些更改，我们得到以下数据帧:
输出数据帧(图片由作者制作)
3.向数据框架添加新列的正确方法
向数据框添加新列的正确方法(图片由作者制作)
假设我们想将一个整数列表作为一列添加到我们的数据帧中。
new_column = list(range(len(df))
new_column# output: [0, 1, 2, 3, 4, 5]
如何不添加列(不起作用):
df.new_column1 = new_column
这也不是添加列的正确方式，但它是有效的。您可能会收到复制警告。
df["new_column2"] = new_column
添加新列的好方法是:
df.loc[:, ‘new_column3’] = new_column
正确的方式:
df = df.assign(new_column4=new_column)
assign 函数还将一个索引作为参数，我们可以用它来定义列中行的顺序。
您可能想在 assign 函数中添加 inplace=True 参数，以便在适当的位置添加一个新列，但这是行不通的。赋值函数也将添加就地列。
# This will add two columns
df.assign(new_column4=new_column, inplace=True)
这实际上是赋值函数的另一个好处。您可以同时添加多个列。
参见 pandas 文档，了解更多关于分配功能的信息。
4.如何检索系列或数据帧
你需要一个系列还是一个数据框架？(图片由作者制作)
在 pandas 数据帧中使用方括号时，它返回:
- 如果使用单方括号，则为一个系列
- 如果使用双方括号，则为数据帧。
让我们看一个例子。
如何从数据帧中检索系列？
df["col1"]
这是一个熊猫系列(图片由作者制作)
type(df["col1"])# pandas.core.series.Series
如何从数据帧中检索数据帧(包含列的子集)？
df[["col1"]]
这是一个熊猫的数据框(图片由作者制作)
type(df[["col1"]])# pandas.core.frame.DataFrame
5.如何从熊猫系列创建数据框架
熊猫系列数据框(图片由作者制作)
当执行带有聚合的分组时，pandas 返回一个序列。将序列转换回数据帧的最简单方法是什么？
让我们看一个例子:
df = pd.DataFrame(
{
"col1": ["A0", "A1", "A0", "A2", "A0", "A1"],
"col2": [1, 2, 3, 4, 5, 6],
}
)df_group = df.groupby("col1").col2.sum()
df_group
df_group 是一个系列。
系列具有 to_frame 功能，可将系列转换回数据帧:
df_group.to_frame()
参见 pandas 文档，了解更多关于 to_frame 函数的信息。
6.带 between 函数的过滤器
我在 SQL 中使用“between”函数已经很多年了，但是我最近才在 pandas 中发现它。
假设我们有一个包含价格的数据框架，我们想过滤 2 到 4 之间的价格。
df = pd.DataFrame({'price': [1.99, 3, 5, 0.5, 3.5, 5.5, 3.9]})
使用 between 函数，您可以减少这种过滤:
df[(df.price >= 2) & (df.price <= 4)]
对此:
df[df.price.between(2, 4)]
用 between 函数过滤数据帧(图片由作者制作)
这可能看起来不多，但在编写许多过滤器时，这些括号很烦人。带有 between 函数的过滤器可读性也更好。
功能组之间的间隔在功能之间的左侧<= series <= right.
See pandas, documentation to learn more about 。
7.使用 reindex 函数修复行的顺序
reindex 函数使系列或数据帧符合新的索引。当生成包含具有预定义顺序的列的报表时，我求助于 reindex 函数。
让我们将 T 恤衫的尺寸添加到我们的数据框架中。分析的目标是计算每个尺码的平均价格:
df = pd.DataFrame({'price': [1.99, 3, 5], 'size': ['medium', 'large', 'small']})df_avg = df.groupby('size').price.mean()
df_avg
每个尺寸的平均价格(图片由作者制作)
上表中的尺寸随机排列。应该是这样排序的:小号，中号，大号。因为大小是字符串，所以我们不能使用 sort_values 函数。重新索引功能来拯救我们了:
df_avg.reindex(['small', 'medium', 'large'])
重新索引一个数据帧(图片由作者制作)
通过在 reindex 函数中指定大小的顺序，使得结果表更容易解释。
参见 pandas，文档以了解更多关于 reindex 函数的信息。
8.描述类固醇
托马斯·凯利在 Unsplash 上拍摄的照片
描述函数是进行探索性数据分析的基本工具。它显示数据帧中所有列的基本汇总统计信息。
df.price.describe()
describe 的基本用法(图片由作者制作)
如果我们想计算 10 个分位数而不是 3 个分位数呢？
df.price.describe(percentiles=np.arange(0, 1, 0.1))
用百分位数描述(图片由作者制作)
描述函数采用百分位数参数。我们可以用 NumPy 的 arange 函数指定百分位数，以避免手工输入每个百分位数。
当与 group by 函数结合使用时，此功能变得非常有用:
df.groupby('size').describe(percentiles=np.arange(0, 1, 0.1))
用 Group by(图片由作者制作)描述
参见 pandas，文档以了解更多关于描述功能的信息。
9.使用正则表达式进行文本搜索
马库斯·温克勒在 Unsplash 上的照片
我们的 t 恤数据集有 3 个尺寸。假设我们想要过滤中小型尺寸。一种繁琐的过滤方式是:
df[(df['size'] == 'small') | (df['size'] == 'medium')]
这很糟糕，因为我们通常将它与其他过滤器结合在一起，这使得表达式不可读。有没有更好的办法？
pandas 字符串列有一个“str”访问器，它实现了许多简化字符串操作的功能。其中一个是“包含”函数，支持正则表达式搜索。
df[df['size'].str.contains('small|medium')]
具有“包含”功能的过滤器可读性更强，更易于扩展和与其他过滤器结合。
看熊猫，文档了解更多包含功能。
10.比熊猫的记忆数据集还要大
熊猫甚至不能读取比主内存数据集更大的数据。它抛出一个内存错误或 Jupyter 内核崩溃。但是要处理一个大数据集，你不需要 Dask 或 Vaex。你只需要一些独创性。听起来好得难以置信？
如果您错过了我关于 Dask 和 Vaex 使用大于主内存数据集的文章:
进行分析时，通常不需要数据集中的所有行或所有列。
在一种情况下，您不需要所有行，您可以分块读取数据集并过滤不必要的行以减少内存使用:
iter_csv = pd.read_csv('dataset.csv', iterator=True, chunksize=1000)
df = pd.concat([chunk[chunk['field'] > constant] for chunk in iter_csv])
分块读取数据集比一次全部读取要慢。我建议只对大于内存的数据集使用这种方法。
在一种情况下，您不需要所有的列，您可以在读取数据集时使用“usecols”参数指定必需的列:
df = pd.read_csv('file.csv', u*secols=['col1', 'col2'])*
这两种方法的伟大之处在于，您可以将它们结合起来。
11.如何节省磁盘空间
帕特里克·林登伯格在 Unsplash 上拍摄的照片
当处理多个数据科学项目时，您通常会从不同的实验中获得许多预处理数据集。笔记本电脑上的小型固态硬盘很快就会变得杂乱无章。
Pandas 使我们能够在保存数据集时对其进行压缩，然后以压缩格式读回。
让我们用随机数创建一个大熊猫数据框架。
import numpy as npdf **=** pd**.**DataFrame(np**.**random**.**randn(50000,300))
带有随机数的数据框(图片由作者制作)
当我们将这个文件保存为 CSV 格式时，它会占用硬盘上将近 300 MB 的空间。
df**.**to_csv('random_data.csv', index**=**False)
我们可以通过使用 gz 扩展名而不是 csv 将文件大小减少到 136 MB。
df**.**to_csv('random_data.gz', index**=**False)
我们不会失去任何功能，因为将 gzipped 数据读入 DataFrame 也很容易。
df **=** pd**.**read_csv('random_data.gz')
摘要
在本文中，我列出了 11 个我每天用来处理数据和执行分析的 pandas 函数。
我相信你已经见过其中的一些了，但是也许你用错了方法。一个很好的例子是在 DataFrame 中设置一个新列。
熊猫有多种方式来实现同一个目标——一些比另一些更正确。从长远来看，使用熊猫偏好的方法会给你带来更少的问题。
以防万一总是好的
在你走之前
- [Correlation Analysis 101 in Python](https://dataanalysis.substack.com/p/correlation-analysis-101-in-python) [Article]- [50% Off All AI Nanodegree Programs!](https://imp.i115008.net/c/2402645/998478/11298) [Course]- [Data Science for Business Leaders](https://imp.i115008.net/c/2402645/880006/11298) [Course]- [Free skill tests for Data Scientists & Machine Learning Engineers](https://aigents.co/skills)
上面的一些链接是附属链接，如果你通过它们进行购买，我会赚取佣金。请记住，我链接课程是因为它们的质量，而不是因为我从你的购买中获得的佣金。
在 Twitter 上关注我，在那里我定期发布关于数据科学和机器学习的消息。
照片由Courtney hedge在 Unsplash 拍摄
你应该知道的 11 个 Python 内置函数
无需安装、导入和初始化——只需使用它们！
我想你一定知道 Python 很出名，因为它很简单。你不需要写很多行代码来实现你的想法。此外，由于社区的蓬勃发展，有许多开源库不断扩展 Python 的这一特性。你可以用几行代码做很多事情。以下是一些例子:
- 3 行 Python 代码创建交互式新冠肺炎泡泡地图
- Python 中的三个“开箱即用”Web 内容抓取应用
- 从网页中抓取数据集的 1 行 Python 代码
- 用 3 行 Python 代码写一个 Web 服务器
- 在 Python 对象和 JSON 之间交换的 1 行代码
- 第 2 行 Python 代码编辑照片
- 1 行 Python 代码帮助你理解一篇文章
无耻广告完了:)嗯，这篇文章的题目会有点不一样。也就是说，我们有时甚至不需要导入这样的第三方库。Python 有很多内置函数，不用安装、导入甚至初始化就能实现一些有趣的功能。
1.all()和 any()
许多分享 Python 技巧的文章都有这两个功能。我不想一遍又一遍的重复。然而，它们真的很有用。
这两个函数期望一个 iterable 作为参数，比如一个布尔值列表，并将评估其中的所有布尔值。请参见下面的示例。
基本上，你可以认为all()函数对所有的布尔值使用and，而any()函数使用or。这有时候挺有用的。请参见下面的示例。假设我们想测试一个列表中的所有数字是否都是偶数。
all([num % 2 == 0 for num in [2, 4, 6, 8, 10]])
all([num % 2 == 0 for num in [2, 4, 6, 8, 9]])
2.chr()和 ord()
我在其他文章中很少看到这两个函数。我猜是因为这些不太常用。然而，根据您正在开发的东西，如果您正在处理一些 Unicode 和特殊字符，您可能会发现这些非常有用。
第一个函数chr()是根据 Unicode 表将整数转换成字符。例如，在 Unicode 列表中可以找到许多外币。
chr(165) + '3,000'
'x ' + chr(215) + ' y'
只要系统支持 Unicode，你的程序现在就可以输出特殊字符。有关 Unicode 字符的完整列表，请参考维基百科页面。
https://en.wikipedia.org/wiki/List_of_Unicode_characters
另一个函数ord()是chr()的逆函数。
3.目录()
我也在许多 Python 技巧文章中看到过这种介绍。所以，这里就不多费口舌了。函数将简单地显示一个对象的所有属性。
不要忘记 Python 中的一切都是对象。因此，这个函数实际上显示了一个对象的所有属性和方法名(没有签名)。例如，我们可以让它显示 OS 库中的所有内容。
4.枚举()
这个函数是另一个实用的函数。我打赌你一定曾经谷歌过类似“在 Python 中使用 for-时获取索引”的东西。最常见的解决方案是建议如下使用enumerate()。
for index, char in enumerate(['a', 'b', 'c']):
print(f'index: {index}, character: {char}')
学习或记忆某事的最好方法总是去理解它。你想过它是如何工作的吗？让我们看看枚举对象是什么样子的。
list(enumerate(['a', 'b', 'c']))
如图所示，该函数将元素列表转换为元组列表。每个元组的第一个元素是索引，第二个元素是原始元素。所以，我想现在你一定明白为什么for index char in enumerate(...)会起作用了:)
5.eval()
这个函数非常强大，因为它可以执行任何字符串格式的 Python 代码。例如，我们允许用户输入数学表达式，程序将计算它并返回答案。
然而，它极其危险，因为它是如此强大。它将编译任何传入的参数，并在运行时将其作为代码执行。
不小心使用eval()相当于留下一个后门，允许任何人使用你的程序运行任何东西。
6.过滤器()
在我看来，这个功能有时候非常好用。但是，我很少在其他文章里看到。它需要两个参数。第一个是一个函数，它将根据参数的一些测试结果返回一个布尔值。第二个应该是可迭代的。
def is_even(num):
if num % 2 == 0:
return True
return Falsef_even = filter(is_even, [1,2,3,4,5,6,7,8])
list(f_even)
上面的例子是过滤列表提取所有偶数。在我看来，它比下面的列表理解(做同样的事情)更具可读性。
[num for num in [1,2,3,4,5,6,7,8] if is_even(num)]
7.帮助()
如果您使用的是 PyCharm 之类的强大 IDE，您可能会忽略这一点。如果没有，你会发现help()函数很有用。它可以直接返回您传入的任何对象的文档。当然，文档需要在源代码中实现。当然，Python 中的所有内置函数都必须实现它。
8.局部变量()
如果您使用 Spyder 之类的科学 ide，您可能不需要这个函数。如果没有，这个函数可以帮助您获得在这个 Python 会话中定义的任何变量(在 RAM 中)。
当你使用没有任何扩展的 Jupyter 来帮助你列出所有定义的变量时，这也是有用的。有时，我们可能已经声明了一些东西，但是丢失了它，并且忘记了它，因为单元格甚至可能被删除。幸运的是，只要它们还在内存中，就会通过调用locals()列出。
9.范围()
我想我实际上可以跳过这个，因为它太常见了，无法使用:)
range()函数将帮助生成一个基于开始和结束数字以及步骤的数字列表。
当我们想让某个东西循环一定的时间，并且想知道我们在循环中的是哪一轮时，这个函数经常被用到。
如果我们需要一些更复杂的功能，Numpy 将是一个更好的选择，但range()是一个内置函数，永远是第一选择。
10.排序()和反转()
这两个也很常见。Python 为我们提供了一种简单而智能的方法，使用函数sorted()对任何可重复项进行排序。
另一个功能reversed()大概用的比较少。但是当你想反转一个 iterable 的时候，这就变得非常容易了。
11.zip()
我喜欢这个函数，因为它是“Pythonic 式”编程的标志性标志之一。创建它是为了方便地对应迭代两个列表中的元素。请参见下面的示例。
for num, letter in zip([1, 2, 3], ['a', 'b', 'c']):
print(num, letter)
然而，在我看来，它比它的本意更加强大。事实上，值得写一篇独立的文章来介绍zip()函数，我以前就做过:)
如果您有兴趣深入研究这个函数，强烈建议您查看上面的文章。
摘要
在这篇文章中，我列出了 11 个(实际上不止 11 个，因为其中一些是成对的，因为它们彼此相关)我认为在我们的日常编程中或多或少有用的 Python 内置函数。
作为一种编程语言，这些函数是 Python 的标志性特征。基本上，直接实施你的想法，没有任何不必要的开销。
当然还有更多 Python 内置函数。我跳过了其中的大部分，因为它们要么不太常见，要么只在非常特殊的情况下使用。别忘了，永远不要压抑自己的求知欲。你可以在官方文件中查到所有这些。
【https://docs.python.org/3.9/library/functions.htm
https://medium.com/@qiuyujx/membership
如果你觉得我的文章有帮助，请考虑加入 Medium 会员来支持我和成千上万的其他作者！(点击上面的链接)
完成 EDA(探索性数据分析)-回归任务的 11 个基本代码块
探索任何数据科学项目并获得宝贵见解的实用指南
Joshua Earle 在 Unsplash 上拍摄的照片
探索性数据分析或 EDA 是数据科学流程的首要步骤之一。它包括尽可能多地了解数据，而不需要花费太多时间。在这里，您可以获得对数据的直觉和高层次的实际理解。在这个过程结束时，您应该对数据集的结构有一个总体的概念，一些清理的想法，目标变量和可能的建模技术。
在大多数问题中，有一些通用策略可以快速执行 EDA。在本文中，我将使用来自 Kaggle 的墨尔本房屋快照数据集来演示您可以用来执行令人满意的探索性数据分析的 11 个代码块。数据集包括房地产的Address、Type、销售的Suburb、Method、Rooms、Price(目标特征)、房产中介的(SellerG)、Date销售、来自 C.B.D 的Distance，你可以在这里下载数据集跟随。
注意:如果你的项目涉及到预测一个二进制或多类特性，你可以遵循这篇文章。
</13-key-code-blocks-for-eda-classification-task-94890622be57>
第一步是导入所需的库。我们将需要熊猫， Numpy ， matplotlib 和 seaborn 。为了确保显示所有的列，使用pd.set_option(’display.max_columns’, 100)。默认情况下，pandas 显示 20 列，隐藏其余的列。
import pandas as pd
pd.set_option('display.max_columns',100)import numpy as npimport matplotlib.pyplot as plt
%matplotlib inlineimport seaborn as sns
sns.set_style('darkgrid')
Panda 的pd.read_csv(path)以数据帧的形式读入 csv 文件。
data = pd.read_csv('melb_data.csv')
基本数据集探索
- 数据框的形状(尺寸)
熊猫数据帧的.shape属性给出了数据的整体结构。它返回一个长度为 2 的元组，该元组转化为数据集有多少行观察值和多少列。
data.shape### Results
(13580, 21)
我们可以看到数据集有 13，580 个观察值和 21 个特征，其中一个特征是目标变量。
2。各列的数据类型
DataFrame 的.dtypes属性将列的数据类型显示为 Panda 的系列(系列表示一列值及其索引)。
data.dtypes### Results
Suburb object
Address object
Rooms int64
Type object
Price float64
Method object
SellerG object
Date object
Distance float64
Postcode float64
Bedroom2 float64
Bathroom float64
Car float64
Landsize float64
BuildingArea float64
YearBuilt float64
CouncilArea object
Lattitude float64
Longtitude float64
Regionname object
Propertycount float64
dtype: object
我们观察到我们的数据集结合了分类(对象)和数值(浮点和整型)特征。此时，我回到 Kaggle 页面来理解这些列及其含义。查看用 Datawrapper 创建的列及其定义的表格。
需要注意什么；
- 应该是分类的数字特征，反之亦然。
通过快速分析，我没有发现任何数据类型的不匹配。这是有意义的，因为这个数据集版本是原始墨尔本数据的干净快照。
3。显示几行
熊猫数据框有非常方便的功能来显示一些观察结果。data.head()显示前 5 个观察值，data.tail()显示后 5 个观察值，data.sample()显示从数据集中随机选择的一个观察值。您可以使用data.sample(5)显示 5 次随机观察
data.head()
data.tail()
data.sample(5)
需要注意的事项:
- 你能理解列名吗？它们有意义吗？(如果需要，再次检查变量定义)
- 这些列中的值有意义吗？
- 是否发现重大缺失值(NaN)？
- 分类特征有哪些类型的类？
我的见解；Postcode 和Propertycount 功能都根据Suburb 功能进行了更改。此外，BuildingArea 和YearBuilt的值明显缺失。
分配
这是指要素中的值是如何分布的，或者它们出现的频率。对于数字特征，我们将看到一组数字在一个特定的列中出现了多少次，对于分类特征，我们将看到每一列的类及其出现的频率。我们将使用图表和实际汇总统计数据。图表使我们能够对分布有一个总体的了解，而统计数字则给我们提供了实际的数字。这两种策略都值得推荐，因为它们是相辅相成的。
数字特征
4。绘制每个数字特征
我们将使用熊猫直方图。直方图将数字分成不同的范围(或仓),条形图的高度显示有多少数字落在该范围内。df.hist()绘制网格中数据数字特征的直方图。我们还将提供figsize和xrot参数来增加网格大小并将 x 轴旋转 45 度。
data.hist(figsize=(14,14), xrot=45)
plt.show()
作者直方图
需要注意的事项:
- 无法解释的可能异常值，或者可能是测量误差
- 应该是分类的数字特征。例如，
Gender用 1 和 0 表示。 - 没有意义的边界，如百分比值> 100。
从直方图中，我注意到BuildingArea和LandSize右侧有潜在的异常值。我们的目标特征Price也非常向右倾斜。我还注意到YearBuilt非常向左倾斜，边界开始于 1200 年，这很奇怪。为了更清楚地了解情况，让我们转到汇总统计数据。
5。数字特征的汇总统计
现在我们对数字特性有了一个直观的感觉，我们将使用df.describe()来查看实际的统计数据，它显示了它们的汇总统计数据。
data.describe()
我们可以看到，对于每个数字特征，其中值的计数、均值值、标准差或标准偏差、最小值、第 25百分位、第 50百分位或中值、第 75百分位和最大值。从计数中，我们还可以识别带有缺失值的特征；它们的计数不等于数据集的总行数。这些是Car、LandSize和YearBuilt.
我注意到LandSize和BuildingArea的最小值都是 0。我们还看到Price的范围从 85，000 到 9，000，000，这是一个很大的范围。我们将在项目后面的详细分析中探索这些列。
然而，查看YearBuilt特性，我们注意到最小年份是 1196 年。这可能是一个可能的数据输入错误，将在清理过程中删除。
分类特征
6。分类特征的汇总统计数据
对于分类特征，在我们绘制图表之前显示汇总统计数据是很重要的，因为一些特征有许多独特的类(就像我们将在Address中看到的)，如果在计数图上可视化，这些类将是不可读的。
为了只检查分类特征的汇总统计，我们将使用df.describe(include=’object’)
data.describe(include='object')
按作者分类的汇总统计
该表与数值特征表略有不同。在这里，我们得到每个特性的值的计数，唯一的类的数量，最频繁的类，以及该类在数据集中出现的频率。
我们注意到一些类有很多唯一的值，比如Address，后面跟着Suburb和SellerG。根据这些发现，我将只绘制具有 10 个或更少独特类的列。我们还注意到CouncilArea有缺失值。
7。绘制每个分类特征
使用上面的统计数据，我们注意到Type、Method 和Regionname 有不到 10 个类，并且可以有效地可视化。我们将使用 Seaborn countplot 来绘制这些特征，它类似于分类变量的直方图。计数图中的每个条形代表一个唯一的类。
我为循环创建了一个。对于每个分类特征，将显示一个计数图，以显示该特征的类分布情况。第df.select_dtypes(include=’object’)行选择分类列及其值并显示它们。我们还将包含一个 If 语句，以便使用行Series.nunique() < 10只选择包含 10 个或更少类的三列。在此阅读.nunique()文档。
for column in data.select_dtypes(include='object'):
if data[column].nunique() < 10:
sns.countplot(y=column, data=data)
plt.show()
按作者统计地块
需要注意的事项:
- 有可能影响模型性能的稀疏类。
- 类别标注错误，例如 2 个完全相同的类别有微小的拼写差异。
我们注意到Regionname有一些稀疏的类，在建模过程中可能需要合并或重新分配。
分组和分段
分割允许我们切割数据并观察分类和数字特征之间的关系。
8。通过分类特征分割目标变量。
这里，我们将在我们的主要分类特征(Type、Method和Regionname)的各个类别之间比较目标特征Price，并查看Price如何随着类别而变化。
我们使用 Seaborn 箱线图，它绘制了Price在分类特征类别中的分布。这个教程，我借用了下面的图片，清楚地解释了箱线图的特征。两端的点代表异常值。
同样，我使用循环的来绘制带有Price的每个分类特征的箱线图。
for column in data.select_dtypes(include=’object’):
if data[column].nunique() < 10:
sns.boxplot(y=column, x=’Price’, data=data)
plt.show()
按作者分类的方框图
需要注意的事项:
- 哪些类对目标变量影响最大。
注意Price仍然稀疏地分布在前面看到的 3 个稀疏的Regionname类中，这加强了我们反对这些类的理由。
还要注意SA类(最不频繁的Method类)的价格很高，几乎与最频繁出现的类S.的价格相似
9。根据每个分类特征对数字特征进行分组。
在这里，我们将通过汇总所有类别的数字特征来了解所有其他数字特征，而不仅仅是Price是如何随着每个分类特征而变化的。我们使用 Dataframe 的 groupby 函数按类别对数据进行分组，并计算各种数字特征的度量(如平均值、中值、最小值、标准值、等)。
对于少于 10 个类别的 3 个分类特征，我们将数据分组，然后跨数字特征计算mean。我们使用display()，它比print()产生一个更干净的表。
for column in data.select_dtypes(include='object'):
if data[column].nunique() < 10:
display(data.groupby(column).mean())
我们将比较数字特性中的Type, Method和Regionname类，看看它们是如何分布的。
数字特征和其他数字特征之间的关系
10。不同数字特征的相关矩阵
相关性是介于-1 和 1 之间的值，表示两个独立特征的值同时移动的接近程度。正相关性意味着一个特性增加，另一个特性也增加，而负相关性意味着一个特性增加，另一个特性减少。接近 0 的相关性表示弱关系，而接近-1 或 1 表示强关系。
图片来自 edugyan.in
我们将使用df.corr()来计算数字特征之间的相关性，并返回一个数据帧。
corrs = data.corr()
corrs
现在这可能没有多大意义，所以让我们绘制一个热图来可视化这种相关性。
11。相关性热图
我们将使用 Seaborn 热图将网格绘制成一个矩形颜色编码矩阵。我们用sns.heatmap(corrs, cmap=’RdBu_r’,annot=True)。
cmap=‘RdBu_r’参数告诉热图使用什么调色板。高度正相关显示为深红色，高度负相关显示为深蓝色。越接近白色意味着关系越脆弱。阅读这篇关于其他调色板的精彩教程。annot=True包括方框中的相关值，以便于阅读和解释。
plt.figure(figsize=(10,8))
sns.heatmap(corrs, cmap='RdBu_r', annot=True)
plt.show()
作者热图
需要注意的事项:
- 高度相关的特征；不是深红(正)就是深蓝(负)。
- 目标变量；如果它与其他特征有很强的正面或负面关系。
我们注意到Rooms、Bedrooms2、Bathrooms和Price有很强的正相关关系。另一方面，我们的目标特征Price与来自 CBD 的YearBuilt的负相关性稍弱，与Distance的负相关性更弱。
在本文中，我们研究了墨尔本数据集，并对其结构和特性有了较高的理解。在这个阶段，我们不需要做到 100%的全面，因为在未来的阶段，我们将更细致地探索数据。你可以在 Github 这里获得完整的代码。我将很快上传数据集的清理概念。
还可以查看用于 EDA 分类任务的 13 个关键代码块，用于处理二元或多类预测问题。
</13-key-code-blocks-for-eda-classification-task-94890622be57>
充分利用任何黑客马拉松的 11 个步骤
确保您拥有最佳、愉快且有教育意义的体验的步骤
Alex Kotliarskyi 在 Unsplash 上的照片
认识新朋友并充分利用你的知识的最好方式之一是参加黑客马拉松。还有比现在更好的时机吗？如今，由于 COVID 的出现，所有的活动都转移到了虚拟世界，让人们有机会从世界各地聚集起来，共同为紧急问题创造解决方案。
将国际事件搬到网上可能是疫情生活带来的唯一好处。但是如果你是第一次参加黑客马拉松，那么你可能会问自己几个等式。比如，我应该试着找一个团队吗？我知道的足以参加黑客马拉松吗？我能做些什么来为这次活动做好充分准备？而且最重要的是，我如何保证在活动过程中学习最多，同时玩得开心？
在我第一次参加黑客马拉松之前，我问了自己所有这些问题，尽管我怀疑自己知道的还不够多，还没有准备好与比我有更多知识和新经验的人竞争，但我还是参加了。
</5-data-science-hackathons-to-grow-and-improve-your-skills-ccfb41193eaa>
但是，我超越了自我怀疑，最终推动自己去体验黑客马拉松到底是怎么回事。在我的第一个之后，我开始扮演不同的角色，帮助组织黑客马拉松，参加一些，在一个案例中，我是一名法官。参加了几次黑客马拉松后，你开始制定一个计划，让你充分利用这次经历，即使你的团队没有获奖，你也能获得成功。
在这篇文章中，我将与你分享我的黑客马拉松比赛计划，它让我超越自我怀疑，享受我参加或帮助组织的每一次黑客马拉松。
№1:事件发生前
充分利用黑客马拉松甚至在你注册之前就已经开始了。以下是我在注册黑客马拉松前后做的几个步骤。
1.不要害怕以个人身份注册。
可能导致一些人(包括我自己)打退堂鼓不注册活动的一个最常见的原因是，他们没有一个已经组建好的团队来注册。我意识到单独报名参加一项活动可能有点吓人，但你不能总是坐在那里，直到你有了一个团队才开始竞争和学习。此外，以个人身份注册会让你有更好的机会结识新朋友，建立新的友谊。
2.明确你想要达到的目标。
我们一生中做任何事都有原因。加入黑客马拉松没有什么不同；你可能想加入以结识朋友，或者测试你的知识，或者解决实际问题，或者可能只是因为你想知道黑客马拉松是怎么回事。这就是为什么你需要有一个清晰的愿景和加入黑客马拉松的理由，这样你才能在活动结束时实现你的目标。
3.提前研究题目和主题。
几乎所有的黑客马拉松都围绕一个特定的主题或问题领域来解决。这个主题通常在参与者注册之前就已经知道了。确保你阅读了主题和你将在活动中试图解决的问题。了解问题集或主题的背景将有助于你在活动中做到最好，而不是浪费时间试图赶上主题。
</5-new-data-science-books-that-you-should-consider-reading-c90aec1d5b0d>
4.通过不和谐或懈怠开始与其他与会者交流
一般来说，大多数黑客马拉松和活动都为参与者和活动组织者创造了一种特定的沟通方式，无论是 Slack 或 Discord 还是任何其他平台。通常，参与者会在活动前一两天访问这些平台。确保在活动开始前介绍你自己，并试着在那里“认识”一些人。
№2:活动期间
你坚持到了活动那天。你应该如何利用你的时间？
1.不要害怕寻求帮助。
永远记住，没有人什么都知道，也没有人指望你什么都知道。所以，不要害怕寻求帮助。对于经验比你丰富的人来说，黑客马拉松也是一个绝佳的机会，比如导师或法官，他们通常很乐意帮助你更好地理解工具和概念。所以，经常问自己是否困惑，不要犹豫。
2.尽可能多地学习。
学习，学习，然后再学习一些。对我来说，黑客马拉松是在任何技术领域学习粒子知识的最佳方式。你会遇到各种知识水平的人。初学者、中间者，甚至是该领域的专家。拥有这种混合层次的知识是从不同角度看待概念和术语的好方法，有助于扩大你对它们的理解。
3.不仅仅是编码。休息和社交。
我知道，当任何人想到黑客马拉松时，他们会想到一个半黑暗的房间，一些人都在键盘上快速打字。但是，黑客马拉松不仅仅是一场速度编码竞赛。休息一下，和你的团队谈谈，和其他团队以及组织者谈谈。黑客马拉松是一个很好的机会来建立一个网络，当你未来开始找工作或实习或任何事情时，这个网络可以帮助你。
</6-data-science-slack-workshops-you-need-to-join-b0c00952105d>
4.积极主动。
不要害怕谈论和讨论你的想法。没有什么坏主意，也许你的主意能引发问题的正确答案。因此，请始终参与对话和讨论，并表明你的观点。要记住的一件重要事情是不要粗鲁或攻击他人的想法，要积极主动，尊重他人，积极参与。
5.在你有的时间里尽你所能
在我第一次参加黑客马拉松时，我所能想到的就是，我们如何才能完成这个项目。后来我意识到，完成一个项目并不是黑客马拉松的目标；而是寻找想法和开发原型。所以请关注解决方案本身，而不是完整的最终项目。因为大多数黑客马拉松都是有时间限制的，构建一个全功能解决方案的机会并不总是可行的。
№3:事后
你完了！经历不必因为事件结束而结束。
</5-youtube-playlists-that-teach-you-all-about-data-science-ea300d6d8ed5>
1.与你的关系保持联系
在黑客马拉松期间，你可能有机会认识许多新朋友，并与他们分享联系信息。试着和你的新朋友保持联系，以保持你的人际网络的繁荣和活力。
2.如果你有时间，继续做这个项目
正如我刚才在活动阶段所说的。最有可能的是，你无法在活动期间 100%完成你的项目。然而，这给了你一个机会，让你在事件发生后继续工作，并构建一个实际的应用程序或产品。
最后的想法
我必须承认，我第一次参加黑客马拉松并不是在我学习旅程的早期。事实上，我参加的第一次黑客马拉松是在我硕士期间，我的队友都是本科生。在那里，我感到非常后悔，因为我隐藏在自我怀疑的背后，浪费了许多学习和认识新朋友的机会。也让我意识到，所有让我怀疑自己的理由都不是真的，都是无效的。
在第一次黑客马拉松之后，我开始参加和组织更多的活动和比赛；不仅如此，我的主要目标是鼓励人们去争取，不要怀疑自己。毕竟，不管你的知识水平如何，在黑客马拉松中，每个人都有一些东西可以提供给团队。
</6-data-science-certificates-to-level-up-your-career-275daed7e5df>
如果你不是一个伟大的程序员，你可以成为一名设计师，如果你不是一名优秀的设计师，你可以管理团队，如果你不擅长这些事情，那么也许你可以做最后的演示。关键是，你可以为你的团队提供一些东西，所以不要怀疑自己，专注于充分利用这段经历。
HalvingGridSearch 将超参数调谐速度提高了 11 倍
连续减半彻底粉碎了 GridSearch 和 RandomSearch
介绍
一段时间以来，Scikit-learn 的GridSearchCV和RandomizedSearchCV类一直是超参数调优的首选。给定一个可能参数的网格，两者都使用蛮力方法来计算任何给定模型的最佳超参数集。虽然它们提供了非常健壮的结果，但是在大型数据集上调整较重的模型会花费太多时间(这里我们说的是几个小时)。这意味着除非你有一台 16 核以上的机器，否则你就有麻烦了。
但是在 2020 年 12 月，Scikit-learn 的 0.24 版本推出了两个新的超参数调优类— HalvingGridSearch和HalvingRandomSearchCV。在官方用户指南中，Scikit-learned 声称“他们可以更快地找到一个好的参数组合”，天哪，他们是对的吗！
在我比较GridSearchCV和HalvingGridSearchCV的第一个实验中，后者找到最佳超参数集的速度比 GridSearch 快 11 倍。在第二个实验中，我将参数网格的大小增加了 30 倍(大约 3000 个最终候选)，我使用了HalvingRandomSearchCV,结果性能提高了 6%,整个过程只花了 10 分钟。
请继续阅读，了解这两个非凡的类是如何工作的，并学习如何在自己的工作流程中使用它们。
https://ibexorigin.medium.com/membership
获得由强大的 AI-Alpha 信号选择和总结的最佳和最新的 ML 和 AI 论文:
https://alphasignal.ai/?referrer=Bex
术语注释
在我们继续之前，让我们确保我们对我今天将使用的一些术语有相同的理解。
1。超参数:应该由用户设置的模型内部设置。模型无法从训练数据中学习这些。一个例子是xgboost估计器中的学习率。
2。参数网格:一个字典，以参数名作为键，以可能的超参数列表作为值。以下是XGBClassifier的参数网格示例:
参数网格的大小或所有可能的组合通过乘以每个参数的可能值的数量来计算。所以，上面的网格有 4 * 3 * 3 = 36 种可能的组合。一般来说，参数网格会比这个大得多。
3。候选者:参数网格中所有可能的超参数集合的单一组合。
4。资源或样本:手头数据的别称。一个示例引用训练数据中的一行。
5。迭代:对训练数据使用一组超参数的任何一轮。
GridSearchCV和RanomizedSearchCV概述
因为新类的主要思想与 GridSearch 和 RandomSearch 相关，所以让我简单介绍一下它们是如何工作的。
GridSearch 是一个详尽的强力估算工具。这意味着将使用交叉验证来训练超参数的所有组合。如果有 100 个可能的候选项，并且您正在进行 5 重交叉验证，则给定的模型将被训练 500 次(500 次迭代)。当然，对于笨重的模型来说，这需要非常长的时间。
RandomizedSearch 试图通过对每次迭代中选择哪组参数做出“更聪明”的选择来控制迭代次数。它有一个额外的n_iter参数直接控制这个过程。如果有 1000 个候选项并且n_iter被设置为 100，搜索将在第 100 次迭代后停止，并从这 100 个中返回最佳结果。这种随机选择过程导致训练时间大大缩短，但其性能不如 GridSearch。
如果你想进一步了解它们，并看到它们的实际应用，请查看我关于这个主题的另一篇文章:
什么是连续减半？
虽然 GridSearch 和 RandomizedSearch 都使用所有的训练数据来训练候选人，但是 HalvingGridSearch 和 HalvingRandomSearch 采用了一种不同的方法，称为连续减半。让我们看看它在 HalvingGridSearch (HGS)方面意味着什么。
HGS 就像所有候选人之间的竞争(超参数组合)。在第一次迭代中，HGS 用一小部分训练数据训练所有候选人。在下一次迭代中，只有表现最好的候选人才会被选中，他们将获得更多的竞争资源。因此，随着每一次迭代,“幸存”的候选者将被给予越来越多的资源(训练样本),直到最佳超参数集保持不变。
现在，让我们更细化。上述过程的速度可以由两个参数控制— factor和min_samples。min_samples取一个整数来指定在第一次迭代中使用的训练数据的样本数。所有候选人都在这个数据上被训练，并且在下一次迭代中min_samples增加factor，并且候选人的数量减少factor。所有下一轮都以这种方式继续，直到找到最佳候选人。
通过一个例子让这个想法深入人心，假设我们在参数网格中有 1000 个样本和 20 个候选者。如果我们将min_samples设置为 20，并选择factor为 2，那么迭代将会这样展开:
将min_resources设置为 20，有 20 个候选，我们只能运行 4 次迭代，因为我们将在用尽所有样本之前用完所有候选。这意味着剩余的训练数据(1000 - 160 = 840)将被浪费，并且最佳候选仅通过仅在 160 行数据上进行训练来找到。
同样，我们也可能在所有候选人都被试用之前就用完了样本。例如，假设我们有 1000 个样本和 300 个候选人。我们将min_samples设置为 50，并选择因子 2:
如您所见，在第五次迭代中，我们没有足够的资源来进一步翻倍，我们只剩下 18 个最终候选项。这些最终候选人别无选择，只能在完整的数据集上接受训练，这与普通的老式网格搜索没有什么不同。这个问题在真实世界的数据集上更加明显。
例如，我们今天将使用的数据集有 145，000 个样本。因此，我们需要确保我们选择了这样一个factor和min_samples的组合，在最后一次迭代中，我们将得到尽可能多的未浪费的资源。
这听起来确实有很多猜测，但幸运的是，您可以将exhaust传递给min_samples，这样最小数量的资源将被自动确定，以创建与factor和大量候选人的最佳可能组合。例如，对于 1000 个样本和因子 2，将min_samples设置为exhaust会将其设置为 250，在我们进行每次迭代时，这将变成 250、500、1000 个样本。
官方指南称，耗尽样本数量肯定会导致参数选择更加稳健，但可能会多花一点时间。在接下来的部分中，我们将探索新的类比它们的同类好多少。
HalvingGridSearchCV 与旧 GridSearchCV 的比较
为了比较这两个类，我将使用澳大利亚的Rain数据集来预测今天是否下雨。为了只关注手头的主题，我创建了包含所有必要预处理步骤的prep.py文件:处理缺失值、缩放数字特征和编码分类变量(您可以在GitHub gist中获得该文件)。
运行preprocess函数会返回一个干净的、经过处理的特征和目标数组，我们将以传统的名称保存它们:
目标变量是RainToday，作为基本估计量，我们将使用 XGBoostClassifier。让我们首先通过用默认参数拟合来建立基础分数:
要计算 ROC_AUC 得分，应该对目标和预测进行编码，但它们不是:
让我们用LabelEncoder对它们进行编码:
我们的基本分数是 0.73。现在，我们将尝试通过仅调整 4 个超参数来对此进行改进:
如果你不熟悉 XGBoost 以及它的参数是什么，可以看看我在上面写的初学者友好的文章。
候选人数为 108 人。首先，我们将使用五重交叉验证进行详尽的 GridSearch，这是两个类中的默认设置。度量仍然是roc_auc:
一个多小时后，我们找到了最佳参数和分数:
令人惊讶的是，roc_auc的分数下降了一点。也许，我们没有提供足够好的参数网格。然而，为了便于比较，让我们使用HalvingGridSearchCV进行同样的调优。它也是从sklearn.model_selection进口的，你也应该进口enable_halving_search_cv，因为它仍然是一个实验性的功能。
如我所说，我们将把min_resources设置为exhaust，并选择 Scikit-learn 推荐的因子 3:
哇！运行时间显著减少——几乎比 GridSearch 快 11 倍。现在让我们来看看表演:
如你所见，结果几乎相同。但是 HGS 比GridSearchCV快了 11 倍！
评估 HalvingRandomSearchCV
这一次，让我们用更好的超参数创建一个更大的网格。
首先， XGBoost 文档说要考虑到类不平衡，我们应该调整scale_pos_weight。结果表明，要找到最优值，我们应该用正类的和除以负类的和。让我们开始吧:
我们找到了scale_pos_weight。现在，我们还修正了subsample和colsample_bytree的值，以避免过度拟合。这次让我们提供更多可能的值，因为模型可能受到了太多的约束。
上次，gamma的最佳值被发现是 1，这是它的范围的结尾，所以我们也应该扩展它:
现在，我们有了一个相当大的网格，有将近 3000 个候选人。让我们看看HalvingRandomSearchCV是怎么回事(通过将n_candidates设置为exhaust来耗尽该类中的所有可用资源):
在看到 HGS 碾压 GridSearch 之后，我甚至懒得去比较
HalvingRandomSearchCV和普通的RandomizedSearchCV。显然，连续减半比两种老方法都好。
对于一个相当大的网格，只需要 10 分钟就可以找到最好的分数。此外，这次我们看到了 6%的分数增长，这是 HGS 和 GridSearch 都做不到的。
你印象深刻了吗？
结论
在完成上述实验后，我已经下定决心要转到新的班级。
你应该注意到，我们只有通过调整新类的最基本设置才能达到如此高的性能。根据文档，这两个类都提供了更多的设置来控制速度和性能，所以也值得一试:
如果您感兴趣，XGBoost 参数调整的官方指南:
不要忘记进行你自己的实验并分享结果！
如果你不知道接下来要读什么，这里，我为你挑选了一些:
https://towardsdev.com/how-to-use-plotly-as-pandas-plotting-backend-123ff5378003
掌握熊猫价值排序的 11 个技巧
有效使用 Pandas sort_value()的实践教程
数据排序是将数据按某种有意义的顺序排列，使其更容易理解、分析或可视化的过程。[1]
数据排序是数据分析中最常见和最基本的过程之一。Pandas 有一个内置的方法sort_values()来根据给定的标签对数据进行排序。该方法本身使用起来相当简单，但在实践中，您可能会遇到各种排序问题，例如，缺少值、特殊字符、自定义标签(例如，t 恤尺寸 XS 、 S 、 M 、 L 、 XL 等)。
在本文中，我们将通过一些实践教程来探索熊猫sort_values()的不同用例。本文组织如下:
- 对系列进行排序
- 按单列对数据帧进行排序
- 按多列对数据帧进行排序
- 排序前应用转换
- 对多列应用转换
- 处理自定义排序
- 处理缺失值
- 就地排序值
- 忽略带有
ignore_index=True的索引 - 按行对数据帧进行排序
- 选择不同的排序算法
请查看 笔记本 获取源代码。更多教程可从Github Repo获取。
为了演示，让我们创建一个数据帧:
df = pd.DataFrame({
'product': ['keyboard', 'mouse', 'desk', 'monitor', 'chair'],
'category': ['C', 'C', 'O', 'C', 'O'],
'year': [2002, 2002, 2005, 2001, 2003],
'cost': ['$52', '$24', '$250', '$500', '$150'],
'promotion_time': ['20hr', '30hr', '20hr', '20hr', '2hr'],
})
作者图片
1.对系列进行排序
sort_values()最简单的用法就是对一个数列进行排序。例如，让我们对“年”列的值进行排序:
df['**year**'].sort_values()3 2001
0 2002
1 2002
4 2003
2 2005
Name: year, dtype: int64
df['year']将“年”列作为一个序列返回，sort_values()用于对值进行排序。默认情况下，sort_values()返回的输出是升序的。我们可以将ascending参数设置为False来获得降序结果。
df['year'].sort_values(**ascending=False**)2 2005
4 2003
0 2002
1 2002
3 2001
Name: year, dtype: int64
2.按单列对数据帧进行排序
要根据单个列中的值对 DataFrame 进行排序，需要传递该列的名称。例如，让我们按“年”列对数据集进行排序
df.sort_values(**'year'**)
# same as df.sort_values(**by='year'**)
熊猫按单个列对 _values()排序(图片按作者)
默认情况下，该方法将返回一个按升序排序的新数据帧，并且不会修改原始数据帧。
我们还可以使用ascending参数来指定我们的偏好，例如将它设置为False来获得降序结果。
df.sort_values('year', **ascending=False**)
熊猫按单个列对 _values()排序(图片按作者)
3.按多列对数据帧进行排序
有时，我们需要按多列对数据帧进行排序。熊猫sort_values()非常简单，因为第一个参数by接受一个列表作为输入:
df.sort_values(**['category', 'year']**)
熊猫按多列对 _values()排序(图片按作者)
默认情况下，它按升序对多列进行排序。ascending参数接受一个布尔值列表，每个值对应一列。因此，我们也可以指定我们的偏好如下:
df.sort_values(**['category', 'year'], ascending=[True, False]**)
熊猫按多列对 _values()排序(图片按作者)
4.排序前应用转换
有时，您的数据不能像预期的那样正确排序，例如“成本列中的符号$。
熊猫 sort_values()带变换(图片由作者提供)
问题是，如果我们调用这个方法，我们将得到按字符串而不是数字排序的结果。
Pandas sort_values()提供了一个key参数，它允许我们在排序之前传递一个自定义函数来转换值。让我们创建一个 lambda 函数来删除$并将剩余的字符串转换成一个数字:
df.sort_values(
'cost',
**key=lambda val: val.str.replace('$', '').astype('float64')**
)
熊猫 sort_values()带变换(图片由作者提供)
5.对多列应用转换
在 Pandas sort_values()中，key功能适用于每个排序列。我们来看看如何按“年”、“促销 _ 时间”、“成本【T31”)对数据帧进行排序。
df = pd.DataFrame({
'product': ['keyboard', 'mouse', 'desk', 'monitor', 'chair'],
'category': ['C', 'C', 'O', 'C', 'O'],
**'year': [2002, 2002, 2005, 2001, 2003],**
**'cost': ['$52', '$24', '$250', '$500', '$150'],**
**'promotion_time': ['20hr', '30hr', '20hr', '20hr', '2hr'],**
})
注意“成本”和“促销 _ 时间”都是字符串值，需要转换，年的值也可以。让我们继续创建一个常规函数sort_by_cost_time():
def **sort_by_cost_time**(x):
if x.name == 'cost':
return x.str.replace('$', '').astype('float64')
elif x.name == 'promotion_time':
return x.str.replace('hr', '').astype('int')
else:
return x # Pass the function to the key argument
df.sort_values(
**['year', 'promotion_time', 'cost'],**
**key=sort_by_cost_time** )
熊猫 sort_values()带变换(图片由作者提供)
sort_by_cost_time()函数检查列名并应用相应的转换。else块适用于任何其他列，并返回原始数据。
6.处理自定义排序
Pandas sort_values()使用起来相当简单，但是它不能用于自定义排序，例如，
- t 恤尺码:
XS、S、M、L和XL - 月份:
Jan、Feb、Mar、Apr、…。等等 - 星期几:
Mon、Tue、Wed、Thu、Fri、Sat和Sun。
我们已经学习了使用key参数的转换。我们当然可以用它来解决自定义排序问题，但是在处理大型数据集时，性能会非常糟糕。我们可以通过声明一个CategoricalDtype来更有效地解决这个问题。让我们来看看这个例子:
df = pd.DataFrame({
'cloth_id': [1001, 1002, 1003, 1004, 1005, 1006],
**'size': ['S', 'XL', 'M', 'XS', 'L', 'S'],**
})
首先，让我们导入CategoricalDtype。
from pandas.api.types import **CategoricalDtype**
然后，创建一个自定义类别类型cat_size_order,用
- 第一个参数设置为
['XS', 'S', 'M', 'L', 'XL']为布料尺寸的唯一值。 - 第二个变量
ordered=True将被视为有序分类变量。
cat_size_order = CategoricalDtype(
['XS', 'S', 'M', 'L', 'XL'],
ordered=True
)
之后，调用astype(cat_size_order)将尺寸数据转换为自定义类别类型。通过运行df['size']，我们可以看到 大小 列已经转换为带有顺序[XS < S < M < L < XL]的类别类型。
df['size'] = df['size']**.astype(cat_size_order)**
df['size']0 S
1 XL
2 M
3 XS
4 L
5 S
Name: size, **dtype: category**
**Categories (5, object): [XS < S < M < L < XL]**
最后，我们可以调用sort_values('size')对值进行排序。
df.**sort_values('size')**
自定义排序的 Pandas sort_values()
这里有一篇文章可以了解更多关于熊猫的自定义排序:
7.处理缺失值
在 Pandas 中，缺失值被赋予值NaN，这是“不是一个数字”的缩写。当我们对值进行排序时，默认情况下，这些NaN被放在所有其他有效值的后面。
df = pd.DataFrame({
'id': [4, 2, 3, **np.nan**, 6, 5],
'name': ['A', 'B', 'C', 'D', 'E', 'F'],
})df.sort_values('id')
Pandas sort_values()处理缺失值(图片由作者提供)
如果我们想将它们放在开头，我们可以将na_position参数设置为First。
df.sort_values('id', **na_position='first'**)
或者，我们可以考虑删除或替换丢失的值。
8.就地排序值
重要的是要记住，默认情况下，sort_values()将返回一个新的数据帧，而原始数据帧保持不变。为了避免创建新的数据帧，可以将参数inplace设置为True。
df.sort_values('id', **inplace=True**)
注意，使用inplace=True，调用将返回None。
9.用ignore_index=True忽略索引
您可能已经注意到，在结果中，每个排序的行的索引保持不变。如果您想忽略原始索引并用0到n-1标记结果(有序索引)，您可以将参数ignore_index设置为True:
10.按行对数据帧进行排序
熊猫sort_values()支持axis的说法。默认为0，即按列对值进行排序。在某些情况下，您可能希望按行而不是按列对数据帧进行排序。为此，我们可以将axis参数设置为1:
df = pd.DataFrame({
'Tom': [70, 67, 90, 50],
'Jacky': [90, 85, 76, 70],
'Lucy': [56, 60, 75, 77]
}, index=['Math', 'Chemistry', 'Physics', 'Art'])df.sort_values(**'Chemistry'**, **axis=1**)
熊猫按行排序 _ 值()
11.选择不同的排序算法
我们应该知道 Pandas sort_values()允许我们选择不同的排序算法。根据官方 API【2】，默认算法为 快速排序 。而其他可用的算法有【merge sort】heap sortstable。要改变这一点，可以将算法名传递给参数kind:
df.sort_values('Chemistry', **kind='heapsort'**, axis=1)
注意:对于数据帧，此选项仅在对单列或单行排序时适用。[2]
结论
在本文中，我们已经讨论了 11 个使用熊猫sort_values()方法对值进行排序的用例。它非常方便，是探索性数据分析和数据预处理中最受欢迎的方法之一。数据排序是数据科学中一项重要的基本技能。我希望你喜欢这篇文章，并学到一些新的有用的东西。
感谢阅读。请查看笔记本获取源代码，如果你对机器学习的实用方面感兴趣，请继续关注。更多教程可从 Github Repo 获得。
参考资料:
- [1] 什么是数据排序？
- [2] 熊猫 API 文档 sort_values()
14 个活跃的人工智能游戏比赛将于 2022 年结束(正在进行和即将进行)
这些不是普通的数据科学竞赛。
马尔科·布拉泽维奇在 Unsplash 上的照片
人工智能游戏比赛也被称为人工智能编程比赛或机器人编程比赛。它们不同于一般的数据科学竞赛。在人工智能游戏比赛中，你不会得到一个数据集。取而代之的是，你得到一个游戏或者模拟游戏，你的工作是编写一个可以在其中竞争的代理程序(有时是和其他玩家的代理进行正面交锋)。
它们可以是练习编程、算法和 AI/ML 的好地方。这些竞赛在难度、奖金、可用语言和可行策略方面有很大差异。为了帮助你找到合适的游戏，我整理了一份正在进行和即将进行的人工智能游戏比赛的列表，下面就来看看。
注: 如果你对面向强化学习的竞赛感兴趣，可以查看 活动强化学习竞赛列表 。
2021 年 12 月更新:2022 年改版！更新了战斗代码，俄罗斯 AI 杯，代码杯和 IEEE CoGs 的比赛细节。在名单上增加了武士。将 Yare.io 和 AICrowd 移至特别提及
AI 游戏比赛列表
1.https://www.kaggle.com/simulations(2010—)
由两个适马制作的石盐，现在在 Kaggle 上(截图由作者拍摄)
你可能听说过 Kaggle。他们是最受欢迎的举办数据科学竞赛的平台。但它们也是一系列模拟游乐场的所在地，如 ConnectX 、饿鹅和资源管理游戏两个适马的 Halite。玩家提交在实时排行榜上竞争的代理，奖品包括 Kaggle 商品和您的 Kaggle 个人资料的排名积分。
如果你是人工智能游戏竞赛的新手，Kaggle 是一个很好的起点，因为他们提供教程和免费的 GPU 来进行培训。目前，他们的模拟只支持 Python 中的提交。
2.AWS DeepRacer(2018—)****
AWS DeepRacer 是一款 3D 赛车模拟器，旨在帮助开发者开始强化学习。使用他们的预建模型，您将能够专注于设计奖励函数和调整超参数。
在 AWS 上开始 10 小时的培训是免费的。顶级赛车手每年都会获得一次付费旅行，在 re:Invent 参加 AWS DeepRacer 冠军杯比赛。如果你打算认真竞争，你需要为培训、评估和在 AWS 上存储你的模型付费。
除了他们的虚拟赛道，还有一个选择是花 399 美元购买他们的 deep racer Evo(1/18 比例的自动赛车),在物理赛道上尝试你的 RL 模型。
3. 编码器一个 (2020 —)
地下城和数据结构游戏(图片由作者提供)
Bomberland 是一个基于经典主机游戏 Bomberman 的多智能体 AI 竞赛。比赛目前正在进行，全年都有持续的排行榜。当前赛季的奖品包括 1000 美元的现金和定制商品。顶级球队将在 2022 年 3 月举行的决赛直播中亮相。
比赛的特点是具有挑战性的 1v1 基于网格的环境。每个特工控制一个由 3 个单位组成的小组，收集皮卡和放置炸丨药，目标是打倒对手。
参与者可以自由选择使用任何语言。初学者工具包有 Python、TypeScript、C++和 Go 版本。
4.终端通过关联一 (2018 —)
浏览器中的终端游戏(作者截图)
终端是由 Correlation One 组织的双人塔防游戏。在终端，你轮流建造建筑和移动单位来打倒你的对手。
Terminal 提供常规赛季(目前在第 8 季)，拥有可笑的奖金池(200，000 美元以上)，并以决赛锦标赛结束。
玩家可以使用 Python、Java 或 Rust 来构建他们的代理。
5.https://codingame.com(2012—)****
CodinGame 的内置 IDE(作者截图)
CodinGame 是一个面向程序员的培训平台，具有一系列基于游戏的练习、内置的 IDE 和对多种语言的支持。
他们举办季节性比赛，每次持续约两周。每个比赛都有一个新的游戏，和一个排名系统来衡量你的进步。以前的奖品包括 CodinGame T 恤、显示器和键盘以及亚马逊礼品卡。
如果你打算参加，你会有一个很好的公司，因为每个比赛都吸引了成千上万的开发者，其中一些人积极地参与其中。
6. Screeps (2014 —)
Screeps:世界(作者截图)
Screeps 是一个在线 RTS PvP 游戏，在这个游戏中，你控制一个殖民地来收获资源，建造单位，征服领土，并与其他殖民地进行贸易。
最初的 Screeps 游戏让玩家在一个持续开放的世界中竞争。最近在 2021 年末发布了“Screeps: Arena”的预发布版本，该版本将在基于比赛的竞技场环境中进行。
最初的 Screeps(改名为 Screeps: World)和 Screeps: Arena 都可以在 Steam 上购买(15-19.95 美元)。可以用 JavaScript 以及 WebAssembly 支持的其他语言(C/C++、Rust、TypeScript、Go 等等)编程。
7. Lux AI 挑战赛 (2021 —)
Lux AI 挑战赛首页(作者截图)
Lux AI 是一个新的 AI 编程比赛，于 2021 年底在 Kaggle 上首次推出。
它的特点是一个 1v1 的 RTS 游戏，白天/夜晚循环，在这个游戏中你可以控制一队可以收集资源、研究和建造城市的单位。目标是有效地管理你的资源，以维持最大的城市。
之前的比赛有 10，000 美元的奖金池，支持 Python、C++、JavaScript/TypeScript 和 Java。
9.战斗密码 (2003 —)
Battlecode 是麻省理工学院历史最长的编程竞赛。主题每年都在变化，但一般都围绕着一个回合制策略游戏。参与者用 Java 写一个人工智能玩家控制一个机器人军队去打倒他们的对手。
任何人都可以参加比赛。尽管如此，只有全日制学生团队(国际学生和麻省理工学院学生)才有资格获得锦标赛奖金(2021 年的锦标赛设有 15，000 美元的奖金池)。比赛以多阶段锦标赛的形式进行，为期一个月。
下一场比赛将于 2022 年 1 月 3 日开始。
10.俄罗斯艾杯 (2012 —)
俄罗斯人工智能杯是由邮报组织的年度比赛。茹组和My.com。比赛之间的游戏差异很大，但前几年的特色是 RTS，动作/平台游戏等。
每场比赛大约有 2，000 名参与者，奖品包括商品、MacBook 和现金(最高 250，000 卢布)。
官方支持的语言有:C++，C#，F#，D，Go，Java，Kotlin，Scala，Python，Ruby，JavaScript，Rust。
更新:他们的沙盒模式现在开放练习，但是比赛已经推迟到 2022 年 2 月。
11.战蛇 (2015 —)
战蛇主页(作者截图)
《战蛇》是一款多人贪吃蛇游戏(类似于 Kaggle 的饿鹅)。你的目标是活得最久——要么消灭别人，要么努力不挨饿。
《战蛇》每年都会举办为期几个月的季节性联赛。奖品包括礼品卡、定制商品和商品。
要参与，你需要在你自己的服务器上运行你的代理，实现 Battlesnake API。您将能够使用任何语言，官方初学者工具包可用于 Python、Go、Java、JavaScript 和 Ruby。
11. 武士 (2021 — )
武士是一年一度的国际人工智能编程比赛，总部设在日本。基于网格的游戏包括控制一个武士和狗队挖掘比你的对手更多的宝藏。压轴活动通常是 IPSJ 国民大会的一部分。
2022 年比赛的时间表尚未公布，但通常在 12 月至 3 月之间举行。参与者可以从支持的编程语言中进行选择，包括 Python、Java 等。
12.艾体育馆 (2018—)
往届 AI 体育馆比赛(作者截图)
艾体育馆是爪哇的年度比赛，将于 2021 年 7 月回归。每年都有一个新的主题，通常围绕资源管理和实时策略。
比赛分为两个部分:短跑和决赛，并伴有溪流。整个比赛将持续约 3 周，总奖金约 1000 欧元。
13. CodeCup (2000 —)
CodeCup 每年举行一次，由荷兰国家信息学奥林匹克竞赛组织。2021 年的比赛已经结束，但 CodeCup 可能会在 2022 年初回归。
每年都会推出一款新游戏。前几年包括益智和棋盘游戏，如五排和井字游戏。支持的语言有 Pascal、C、C++、Java、Python 或 Haskell。
14. IEEE 游戏大会 (2019 —)
IEEE 游戏会议(CoG)是为游戏中人工智能一般领域的研究人员举办的年度活动。它旨在帮助研究人员在游戏人工智能方面产生新的论文和研究，但也以向公众开放的人工智能游戏的竞赛轨道为特色。
在这里，你会发现一系列人工智能游戏正在研究中使用，如 Dota 2，星际争霸，愤怒的小鸟，太空入侵者等等。一些比赛还将提供 500 美元的现金奖励。
CoG 将于 2022 年 8 月回归。比赛曲目尚未公布。
特别提及
以下是一些额外的网站和平台:
- AICrowd (2018 —):举办受监督的 ML 比赛和 RL 比赛。
- yare . io(2021—):2021 年 4 月推出的类似 Screeps 的新 RTS 游戏。以一个美学的空间主题为特色，在这个主题中，你可以控制攻击、防御和从恒星获取能量的单位来创造更多的单位。
- 机器人大战(Robot Rumble)(2021—):一个简单的双人游戏，你控制多个机器人，目的是用比对手更多的机器人结束游戏。在 Alpha 中，支持 Python 和 JavaScript。
- 星际争霸 2 人工智能竞技场 (2016 —):一个为星际争霸 2 开发脚本化和深度学习代理的活跃社区。
- 【AIGaming.com】(2017—):以战舰、象棋、围棋等众多游戏为特色的网站。
结束语
我试图把所有正在进行的和即将进行的人工智能游戏竞赛综合列出来。随着新的比赛的出现，我将努力保持这个列表的更新。
无论你最终选择哪个比赛，祝你好运！
你可以用 Python 和 Plotly 免费制作 12 种常见的 JMP 图表
📊对 JMP 的图形生成器感兴趣，但是更好+免费？
用 Plotly 制作图标 JMP 图的代码模板
介绍
JMP 是由 SAS 公司开发的统计分析软件。几十年来，它一直被科学和工程界用来执行统计分析和创建可视化。
现在，你可以使用 Plotly 为免费制作那些相同的可视化效果。不需要座位或者执照。
Plotly 是一个免费的开源图形库，它允许你用很少的编码知识制作漂亮的数据可视化和图表。
在这篇文章中，我们将探索如何重新制作一些 JMP 最有用和最具代表性的数据可视化，甚至给你所有的模板开始。
我们将涵盖:
- 控制图
- 直方图
- 散点图矩阵
- 箱线图
- 剥离地块
- 三元图
- 热图
- 树形图
- +更多！
每个图表部分将有三个子部分:
- 对比图显示了 JMP 和普洛特利的情节
- 重新创建 Plotly 可视化的代码
- 嵌入式 Chart Studio 图像。Chart Studio 是 Plotly 基于网络的拖放平台，用于创建、发布和嵌入交互式图表。想想类似于 JMP 的图形生成器，多了一些附加功能。提示:如果您点击嵌入的图形，您可以在 Chart Studio 中处理数据
所以让我们开始吧！
1)控制图:
控制图比较(作者制作)
控制图用于监控过程变化。它们有助于确定过程变化是随机的、自然的，还是来自于潜在变量的变化。这些通常用于制造环境，以确保高标准的质量和效率。
代码:
chart studio 的模板:
2)彩色控制图:
彩色控制图对比(作者制作)
代码:
chart studio 的模板:
3)可变性测量图:
可变性测量图比较(由作者制作)
可变性测量图显示了过程的变化如何在多个类别之间变化。在对复杂问题进行故障排除以试图找到问题根源时，它们非常有用。在工程和制造领域，测量多种模式下的机器一致性非常有用。
代码:
chart studio 的模板:
4)散点图矩阵:
散点图矩阵比较(作者制作)
散点图矩阵是评估多个变量之间相互关系的强大工具。他们绘制了散点图的所有双变量组合，这允许快速分析在一个图像中哪些关系是强有力的。当您拥有高维多变量数据时，尤其是具有高度相关性的数据时，它们会非常有用。它们在可视化和识别异常值时也很有用。
代码:
chart studio 的模板:
5)直方图:
直方图比较(作者制作)
直方图是数字数据的近似表示。它们是查看数据集“形状”的简单方法。它们可用于查看过程是遵循高斯分布还是均匀分布。JMP 还在柱状图顶部放置了一个水平箱线图，以强调四分位数和潜在的异常值。
代码:
chart studio 的模板:
6)箱线图:
箱线图比较(作者制作)
箱线图是观察变量分布的好方法。在这种情况下，我们使用一个具有两个级别的分割分类 x 轴。数据按年龄和性别进行了划分，显示了两个分类变量的值如何变化，并允许快速了解数据中的模式。
代码:
chart studio 的模板:
7)三元图:
三元情节对比(作者制作)
三元图一次显示三个变量及其关系。三条边中的每一条都代表一个变量，通常从端到端具有 0 到 1 的值。它们在生物学、化学、地质学等经常使用组件的领域中应用广泛。
代码:
chart studio 的模板:
8)平均值的置信区间:
均值比较的置信区间(作者制作)
置信区间图可能看起来很基本，但它们是比较一个类别中变量平均值的非常简单的方法。如果所列各组之间存在显著差异，它们会迅速让眼睛消化。
代码:
chart studio 的模板:
9)热图:
热图对比(作者制作)
热图对于可视化多个变量之间的差异以及理解它们之间的关系非常有用。它们对于查看具有趋势和模式的时间序列数据以及高维数据(如制造或传感器数据)非常有用。通常他们遵循一个连续的颜色方案，允许容易消化一个可变的组合对目标结果的影响。它们也很容易允许分组和模式理解。
代码:
chart studio 的模板:
10)剥离地块:
剥离图比较(由作者制作)
条状图或点状图类似于散点图，其中一个维度是绝对的。他们使用一个叫做“抖动”的术语来稍微向左或向右移动点，这样点就不会重叠。它们用于查看异常值和跨多个类别的分布，如果点是彩色的，甚至允许使用另一个分类变量。
代码:
chart studio 的模板:
11)树形图:
树形图比较(作者制作)
树形图是显示类别和两个定量变量之间关系的有趣方式。当显示数据集有多个层的分层数据时，它们也很有用。它们的工作原理是尺寸的格式塔原理和人类区分不同尺寸矩形的能力。最常见的情况是，矩形的大小与某种形式的数量相关。
代码:
chart studio 的模板:
12)多折线图:
多折线图比较(图片由作者提供)
折线图经常被用来说明变量是如何随时间变化的。它们对于理解制造系统非常有用，可以说明之前发生的事情。
代码:
chart studio 的模板:
结论:
当使用 Plotly 时，重新制作 JMP 可视化是快速和方便的。只用了几行代码，我们就能够重新创建这些图，并几乎完全匹配格式！如果使用 Chart Studio，我们甚至不需要代码！
最棒的是。我们为你做了繁重的工作！你所需要做的就是复制 Plotly 代码，修改几行来导入你的数据，然后你就可以重新制作图表了！或者对于那些对编码不太感兴趣的人，只需点击嵌入式 Chart Studio 小部件中的“编辑图表”,就可以在 Chart Studio 中处理数据了。
你甚至可以使用 Plotly 的 Dash 来为优秀的分析应用程序创建一系列图表和用户界面小部件(Dash 这个术语是杜撰的，现在被业内许多人使用)。这些应用程序是在线托管的，可以通过简单的链接共享。
迫不及待想看看你做了什么。
你应该知道的 12 个基本 Docker 命令
简化您的软件开发
照片由 Aron Yigin 在 Unsplash 上拍摄
ocker 已经成为软件工程不可或缺的一部分。我们使用 Docker 进行开发、测试和部署，因为它易于管理环境。由于它的可移植性，它在软件行业变得流行起来。这意味着如果你的代码在开发中有效，它将在生产中有效。此外，开发人员可以更快地协作，而不必担心他们需要安装哪个软件依赖项。
在这篇文章中，我将介绍 12 个基本的 docker 命令，它们将帮助你在 Docker 的神奇世界中导航。你可以从 Docker 的文档页面找到这些命令的官方文档。
1.docker 搜索
我们可以使用命令docker search在 Docker hub 上搜索公共图像。它将返回有关图像名称，描述，明星，官方和自动化的信息。
docker search MySQL
如果你喜欢基于图形用户界面的搜索选项，使用 Docker Hub 网站。
2.码头工人拉动
现在我们知道了图像的名称，我们可以使用命令docker pull从 Docker hub 中提取它。这里，我们还设置了平台选项。
docker pull --platform linux/x86_64 mysql
标签用于识别存储库中的图像。如果我们不指定标签，Docker 引擎默认使用:latest标签。所以，在前面的例子中，Docker 提取了mysql:latest图像。
如果我们的应用程序依赖于图像的特定版本，我们可以使用标记名来指定。
docker pull --platform linux/arm64/v8 mysql:5.6
因为我们可以在一个存储库中有多个图像，所以我们可以使用--all-tags选项提取所有的图像。以下命令将从 mysql 存储库中提取所有图像。
docker pull --all-tags mysql
3.docker 图像
太棒了，现在我们的本地机器上应该有一些图像了，为了确认，让我们运行下面的命令来列出所有的本地图像。
docker images
docker 图像
在我的例子中，我有两个在上一步中下载的图像。
4.码头运行
好了，现在我们有了一些图像，我们可以试着创建一个容器。这里我们使用了--env选项来设置一个强制的环境变量，使用--detach选项来在后台运行容器。
docker run --env MYSQL_ROOT_PASSWORD=my-secret-pw --detach mysql
此外，我们可以使用--name选项为容器指定一个名称。如果我们不提供名称，Docker 会随机分配一个名称。
5.docker ps
我们可以使用以下命令列出所有正在运行的容器。
docker ps
把所有的集装箱都列出来，包括停止的，怎么样？我们可以通过添加--all选项来实现。
docker ps --all
6.码头停车
要停止一个容器，使用带有容器 id 或容器名称的docker stop命令。如果我们想改变 docker 运行命令，我们可以停止一个容器。
docker stop f8c52bedeecc
7.docker 重启
让我们使用下面的命令重新启动停止的容器。我们可能需要在重启机器后使用它。
docker restart f8c52bedeecc
8.docker 重命名
现在，让我们将集装箱名称从compassionate_fermi改为test_db。我们可能希望更改名称，以便更容易地跟踪我们的容器。
docker rename compassionate_fermi test_db
9.码头经理
通过运行以下命令来访问正在运行的容器test_db。如果我们想访问 MySQL 命令行并执行 MySQL 查询，这很有帮助。
docker exec -it test_db bash
mysql -uroot -pmy-secret-pw
SHOW DATABASES;
-i and -t选项用于在交互模式下访问容器。然后我们提供想要访问的容器的名称，在本例中是test_db。最后，bash命令用于获取容器内部的 bash shell。
10.码头日志
这个命令有助于调试我们的 Docker 容器。它将从指定的容器中获取日志。
docker logs test_db
如果我们想继续流式传输新的输出，我们可以使用选项-follow。
docker logs -follow test_db
11.码头工人室
如果我们想删除一个容器，我们可以使用下面的命令。
docker rm test_db
您可能会遇到类似这样的错误
来自守护程序的错误响应:您无法删除正在运行的容器……在尝试删除或强制删除之前停止该容器
正如它所建议的，我们可以先停止容器，然后移除它，或者使用选项-f来强制移除正在运行的容器。
docker stop test_db
docker rm test_db
# or
docker rm -f test_db
12.码头工人 rmi
最后，如果我们想释放一些磁盘空间，我们可以使用带有映像 id 的docker rmi命令来删除一个映像。
docker rmi eb0e825dc3cf
这些命令带有大量有用的选项。如果您想了解其他可用选项，运行docker command_name --help命令。例如:
docker logs --help
我几乎每天都用 Docker 进行开源开发。它允许其他人轻松地为项目做贡献，而不用担心如何运行项目。希望这 12 个 Docker 命令能帮助你入门 Docker。如果你想了解更多关于 Docker 的知识，那么看看下面的文章。编码快乐！
相关职位
12 款 Jupyter 笔记本扩展，让您的生活更加轻松
Jupyter 笔记本电脑的重要扩展功能，可提高您的工作效率。
Jupyter Notebook 是数据科学家的首选计算笔记本，您可以在其中创建不仅包含实时代码，还包含公式、可视化和文本的文档。然而，默认情况下，Jupyter Notebook 缺少一些有用的功能，如自动完成、目录、代码折叠等。
这就是为什么我决定列出一个有用的 Jupyter 笔记本扩展列表，它将使您的生活更加轻松，并提高您编写代码的效率。下面您可以找到本文中列出的所有扩展。
**Table of Contents** 1\. [How to Install Extensions](#c42a)
2\. [Move selected cell](#bdf1)
3\. [Enable autocompletion (Hinterland)](#48e1)
4\. [Shortcuts to run multiple cells (Runtools)](#ef13)
5\. [Search files inside Jupyter Notebook (Tree filter)](#26b0)
6\. [Hide input (Hide input + Hide input all)](#7f6c)
7\. [Snippet Menu](#6f02)
8\. [Add a Table of Content (Table of Content 2)](#ed76)
9\. [Scrathpad](#435e)
10\. [Codefolding](#edca)
11\. [Variable inspector](#bcb8)
12\. [Translate text inside Jupyter Notebook (nbTranslate)](#1802)
13\. [Bonus: Change Themes](#7224)
如何安装扩展
要安装扩展，请在命令提示符或终端中运行以下代码
pip install jupyter_contrib_nbextensions
然后运行下面的代码，将 nbextensions 文件添加到 Jupyter 服务器的搜索目录中。
jupyter contrib nbextension install
现在打开 Jupyter 笔记本。应该有一个名为“Nbextensions”的新选项卡。点击它，你会看到一堆扩展，你可以用它来提高你的工作效率。
作者图片
以下是我觉得最有用的扩展。
移动选定的单元格
这是一个非常有用的扩展，允许你使用快捷键Alt-up和Alt-down来移动选中的单元格。只需选中 Nbextensions 中的“移动所选单元格”框。然后，刷新笔记本，您将能够通过简单的击键来移动单元格。
作者图片
Eenable自动完成(腹地)
对于那些努力在 Jupyter 笔记本上写代码的人来说，这是一个非常有用的扩展，因为没有自动完成功能。通过选中“腹地”框，您将在 Jupyter 笔记本上启用自动完成功能，并且能够像在您最喜欢的编辑器中一样编写代码。
作者图片
运行多个单元的快捷方式(运行工具)
Runtools 提供了许多额外的功能来处理 IPython 笔记本中的代码单元。其中一些是运行上面的单元格(⌥A)、运行下面的单元格(⌥B)和运行所有单元格(⌥X).要启用它，请选中 Nbextensions 中的“Runtools”框(在那里您也可以找到完整的快捷方式列表)。一旦它被激活，你会在工具栏中看到下面的图标。
作者图片
单击它打开带有这些代码执行按钮的浮动工具栏。
作者图片
在 Jupyter 笔记本中搜索文件(树形过滤器)
此扩展允许您在 Jupyter 笔记本文件树页面中按文件名进行过滤。
作者图片
隐藏输入(隐藏输入+隐藏所有输入)
您可以通过分别选中“隐藏所有输入”和“隐藏输入”来隐藏所有单元格的输入或特定单元格的输入。之后，工具栏中会出现以下图标。左边的一个将帮助你隐藏所有代码单元格的代码，而第二个只隐藏特定的单元格。
作者图片
代码片段菜单
对于那些喜欢备忘单的人来说，“摘录菜单”是 Jupyter 笔记本中必须包含的扩展。启用它后，您会看到一个名为“Snippet”的新菜单项，它将允许您插入代码和 markdown 代码片段。例如，Pandas 库有许多可用的代码片段，可以帮助您记住有用的 Pandas 方法。
作者图片
添加目录(目录 2)
写了许多行代码后，浏览你的笔记本会变得很困难。这就是为什么您应该添加一个目录，通过收集笔记本中包含的所有标题并在侧栏中显示它们，使导航更容易。
要在 Jupyter 笔记本中启用目录，请选中 Nbextensions 中的“目录(2)”框。之后，刷新笔记本，你会在工具栏中看到下面的图标。
作者图片
点击它以显示类似图片的目录(您需要至少有一个降价 h1、h2 或 h3 才能在内容部分看到它们)
作者图片
便条簿
您是否曾经想要在不修改笔记本文档的情况下测试新的代码行？您可以使用“便签簿”扩展来完成此操作。只要启用它，您就能够在当前内核上执行代码，而无需修改笔记本文档。启用后，右下角会出现以下图标。
点击它或使用快捷键Ctrl-B 打开草稿栏。在那里，您可以通过使用Shift-Enter或任何其他应用于笔记本文档的快捷方式来执行代码。
代码折叠
这个扩展允许代码单元中的代码折叠。只需启用 nbextension 选项卡中列出的“Codefolding”扩展，然后您会在代码单元格的左边看到一个三角形。
点击它或者使用快捷键Alt+F 来折叠代码。有三种不同的折叠模式支持:缩进折叠，括号折叠，和魔术折叠。
变量检查器
如果你想跟踪你在笔记本中使用的所有变量，你应该启用“变量检查器”扩展。这将帮助您查看所有已定义的变量名称、类型、大小和形状
启用后，工具栏中应该会出现以下图标。
点击它显示一个浮动窗口，收集所有已定义的变量。窗口可拖动、可调整大小和可折叠。
注意:打开“变量检查器”后，我发现了一些小故障。如果你也找到它们，只需关闭“变量检查器”。
翻译 Jupyter 笔记本中的文本(nbTranslate)
每当你必须阅读用外语写的笔记本时，这最后一个扩展将非常有用。只需启用“nbTranslate”扩展，然后你会在工具栏中看到两个新图标。
作者图片
右边的图标帮助您配置主要和辅助语言。设置完成后，当您想要将 markdown 单元格翻译成您的母语时，请单击左侧的图标。
作者图片
奖励:改变主题
Jupyter 笔记本上有很多可用的主题。首先，你需要安装jupyterthemes.打开一个终端并写
pip install jupyterthemes
在此之后，要查看可用主题列表，请编写jt -l
对于这个例子，我将选择“onedork”主题。若要更改主题，请编写以下代码。
jt -t onedork -T -N
其中-T是工具栏可见的，-N是名称&标识可见的(您甚至可以通过在上面的代码中添加-kl来显示内核标识)
注意:你也可以在一个笔记本中完成所有这些，只需在一个命令前添加 *!* 符号(如 *!*jt -l)
作者图片
就是这样！希望本文中列出的扩展对您有用。
下面你可以找到几个你可以开始在 Jupyter 笔记本上工作的项目。
与 3k 以上的人一起加入我的电子邮件列表，获取我在所有教程中使用的 Python for Data Science 备忘单(免费 PDF)**
12 个数学窍门帮助你不用计算器就能解决问题
在你的脑子里解决它
克里斯·贾维斯在 Unsplash 上的照片
加法+减法
1.添加
第一个技巧是通过把问题分成小块来简化它。例如，我们可以重写
567 + 432
= 567 + (400 + 30 + 2)
= 967 + 30 + 2
= 997 + 2
= **999**
转换
添加一个较小的数字通常更容易，所以不要用 131 + 858，而是交换数字
858 + 131
= 858 + 100 + 30 + 1
= **989**
2.减法
使用一个数的补数有助于使减法更容易。补数是原始数和一个整数的差，比如 100，1000。
以下是一些数字及其补数与 100 比较的例子:
67:33, 45:55, 89:11, 3:97
请注意，第二个数字加起来是 10，第一个数字加起来是 9。
这很有帮助
721–387
# the complement of 87 is 13, so we can swap 387 with 400 – 13
-> 721 — (400 - 13)
= 321 - -13
= 321 + 13
= **334**
另一种方法是写出较大的数字，使其以 99 结尾。同一个例子:
721 -> (699 + 22)
= 699 – 387 + 22
= 312 + 22
= **334**
克里斯·利维拉尼在 Unsplash 上的照片
乘法运算
3.上午 11 点左右的点心
对于两位数，将数字相加，并将答案放在要相乘的数字的中间:
35 x 11
-> 3**_**5
-> 3+5 = 8
-> 3**8**5
如果总和大于 10，将十位数加到左边下一栏，并将一位数写在答案中。比如 4+8 = 12，写下 2，把 1 进位到下一列。
48 x 11
-> 4_8
-> 4+8 = 12
-> 4,12,8
-> **528**
对于三位数和更大的数字，这个过程稍微复杂一点，但是它以类似的方式工作。这次保留第一个和最后一个数字，并成对求和
725 X 11
-> 7__5
-> 7_,(7+2=9), (2+5=7), _5
-> **7975**51973 x 11
-> 5__3
-> 5_,(5+1=6),(1+9=10), (9+7=16), (7+3=10), _3
# where the sum is greater than ten we move the tens digit into the next column
-> 5,(6+1),(0+1),(6+1),(0),3
-> **571703**
4.九
乘以 9 可以简化为乘以 10 再减去原来的数
799 x 9
= 799 x (10 -1)
= 7990 – 799
= **7191**
对任何以 9 结尾的内容使用相同的方法
72 x 89
= 72 x (90–1)
= (70 x 90) + (2 x 90) — 72
= 6300 + 180–72
= **6408**
5.如何解正方形
你可以用这个公式把一个平方方程改写成更容易处理的数字
n^2 = (n+d)(n-d) + d^2
其中 n 是要平方的数字，d 是差值
这里有一个例子
57^2
= (57+3)(57–3) + 3^2
# we add 3 to 57, as 60 is easier to multiply than 57, and subtract 3 from the second 57
-> 60 x 54 + 9
= 3000 + 240 + 9
= **3249**
最终的例子是，当你平方一个以 5 结尾的数，然后将一个数向上舍入到最接近的 10，将另一个数向下舍入到最接近的 10，再加上 25。
65^2
= (60 x 70) + 5^2
= 4200 + 25
= **4225**
6.紧密结合法
相似的方法也适用于相近的数字相乘。该公式适用于所有数字，但除非数字相似，否则它不能很好地简化。
这是公式。n 是“基数”
(n+a)(n+b) = n(n + a + b) + ab
一个例子:
47 x 43
= (40 + 7)(40 + 3)
= 40 x (40 + 3 + 7) + (7 x 3)
= (40 x 50) + (7 x 3)
= 2000 + 21
= **2021**
在这个例子中，一位数加起来是十，所以我们的“基数”和乘数是整数(40 和 50)。
这是另一个例子。减少较小的数字以达到最接近的整数——我们的基数，在本例中是 40。将差额加到较大的数字上。基数的倍数和更大的数。最后，加上原始数和基数之差的乘积。
47 x 42
= (40 + 7) x (40 + 2)
= (40 + 7 + 2) x 40 + (7 x 2)
= (49 x 40) + (7 x 2)
= (40 x 40) + (40 x 9) + (7 x 2)
= 1600 + 360 + 14
= **1974**
也可以四舍五入到基数。由于原始数字小于基数，我们将两个负数的乘积相加。
47 x 42
= (50 x 39) + (-3 x -8)
= (50 x 30) + (50 x 9) + (-3 x -8)
= 1500 + 450 + 24
= **1974**
这也适用于三位数。在这种情况下，基数在我们的数之间，所以乘积是负数。
497 x 504
= (500 – 3) x (500 + 4)
= (500) x (500 + 4 - 3) + (-3 x 4)
= 500 x 501 - 12
= 250,000 + 500 – 12
= **250,488**
桑德罗·舒赫在 Unsplash 上的照片
师
7.简化计算
你甚至可以在开始之前简化一些方程。例如，将除数和被除数都除以 2。
898 / 4
= 449 / 2
= 224 and ½
注意，用这种方法，你必须把余数写成一个分数:
898/4 has a remainder of 2 — divided by 4
449/2 has a remainder of 1 — divided by 2
分数相同，但绝对数不同。
除以 5 时，将等式乘以 2。除以 10 要容易得多。例如:
1753/5
= 3506 / 10
= **350.6**
8.可分性检验
有很多方法可以快速判断一个数是否是因子。
2 :数量为偶数。
Example 28790 is even, so it is divisible by 2.
3 :位数之和能被 3 整除。
Example: 1281 -> 1+2+8+1 = 12
-> 12 is a multiple of 3, so 1281 is divisible by 3
4 :最后两位数能被 4 整除。为什么会这样？100 是 4 的倍数，所以我们只需检查后两位。
Example: 1472, 72 is divisible by 4, so 1472 is divisible by 4.
5 :数字以 5 或 0 结尾。
Example: 575 ends in 5, so it is divisible by zero
6 :数是偶数，位数之和能被 3 整除。6 是 3 x 2，所以 2 和 3 的规则适用。
Example: 774 is even and 7+7+4 = 18
-> 18 is divisible by 3, so 774 is divisible by 6.
7 :给你的数字加上或减去 7 的倍数，使其以零结尾。将最后一个数字和零一起删除，然后重复这个过程。继续，直到你能确定结果是否能被 7 整除。
Example: 2702 add 98 (7 x 14) -> 2800, drop the zeroes
-> 28 is a multiple of 7, so 2702 is divisible by 7.
8 :后三位数能被 8 整除。
Example: 79256, 256 is divisible by 8, so 79256 is divisible by 8.(Alternate rule: if the hundreds digit is **even**, last **2** digits divisble by 8, if hundreds digit is **odd**, last **2** digits **+ 4** divisible by 8)
9 :和 3 一样的规则，但是用了 9。如果数字之和能被 9 整除，那么这个数就能被 9 整除。
Example: 13671 -> 1+3+6+7+1 = 18
-> 18 is divisible by 9, so 13671 is divisible by 9
10 :数字以 0 结尾。
Example: 280 ends in 0, 280 is divisible by 10
11 :与 3、9 规则相似，从右边数字开始，其余数字交替加减。如果答案是零，或者是 11 的倍数，那么这个数可以被 11 整除。
Example: 12727 -> 1 - 2 + 7 - 2 + 7 = 11, so 12727 is divisible by 11.
你可以在这里查看一些附加的方法。
9.用 9 除大数
Example:
-> 10520/9
在等式上方写下第一个数字，在最后一个数字上方写下“R”(表示余数)。把你刚写的数字和它右下方的数字加起来。把这个新数字写在第二点上。将该数字添加到右下方的数字中。继续这个过程，直到你到达 r。
将相同颜色的数字相加，得出下一个数字
最后，将 R 下面的数字加上最后一位数，得到余数。
10520/9
= **1168 R8**
or 1168.889
这是另一个例子:
-> 57423/9
这一次，在我们完成第一步之后，我们的第一个数字和斜下方和右边的数字之和大于 10(5+7 = 12)。我们在第一个数字上加 1，然后从中减去 9。(我们以 9 为基数除数，所以我们减去 9 而不是 10)。将得到的数字放在第二个位置(12–9 = 3)。继续同样的过程。
在这个例子中，我们的余数大于 9 (9+3 = 12)。再一次，我们在前一位数上加 1，从余数中减去 9，剩下 3。现在将结果和进位数字相加。
57423 / 9
= **6380 R3** or 6380.333
百分比和分数
10.反过来问
百分比是关联的，所以有时颠倒问题的顺序会更容易计算。
Example:
What’s 36% of 25
-> is the same as 25% of 36
-> 25% is ¼
-> 36/4 = 9
36% of 25 is **9**
11.分数
正如您在上一个示例中看到的，它有助于了解分数以及它们与百分比的关系。
1/2 = 50%1/3 = 33.33%, 2/3 = 66.67%,1/4 = 25%, 3/4= 75%1/5 = 20%, 2/5 = 40% …1/6 = 16.67%, 5/6 = 83.33% (2/6 = 1/3, 3/6 = 1/2, 4/6 = 2/3)1/7 = 14.2857%, 2/7 = 28.5714%, 3/7 = 42.8571%, 4/7 = 57.1428% (note the recurring .142857 pattern)1/8 = 12.5%, 3/8 = 37.5%, 5/8 = 62.5%, 7/8 = 87.5%1/9 = 11.11%, 2/9 = 22.22%, 3/9 = 33.33% …1/10 = 10%, 2/10 = 20% …1/11 = 9.09%, 2/11 = 18.18%, 3/11 = 27.27% …1/12 = 8.33%, 5/12 = 41.67%, 7/12 = 58.33%, 11/12 = 91.67%
12.第七十二条规则
72 法则提供了在给定的百分比回报率下，一项投资翻一番需要多少年的估计。它的工作原理是将 72 除以百分比，得到的答案是翻倍所需的年数。
2% -> 72/2 = 36, approximately 36 years to double
8% -> 72/8 = 9, approximately 9 years to double
请注意，72 的规则是基于自然对数 2 的指导原则，自然对数 2 给出 0.693。所以 69.3 的规则会更准确，但是 72 更容易计算。
投资翻三倍也有 114 法则，投资翻四倍也有 144 法则。
额外资源
我发现亚瑟·本杰明的两本书在这个话题上很有帮助。这篇博客中的许多例子都是受这些书的启发。你可以在这里查阅。
https://www.amazon.com/Magic-Math-Solving-Figuring-Out/dp/0465096212/
https://www . Amazon . com/Secrets-Mental-Math-Math magicians-Calculation/DP/0307338401/
如果您觉得这有帮助，请留下评论，或者分享您遇到的任何其他有用的技巧。
我最喜欢的 12 个 Python 实践，以获得更好的功能
编写糟糕的函数很容易，但编写示例性的函数就难多了——下面是我改进自己的一些方法
(src =https://unsplash.com/photos/vc3iVL_znJ8
介绍
W 写代码可能是一件非常困难和具有挑战性的工作。当一些问题很难解决，并且有多个解决方案时，尤其如此。保持你的代码处于最佳、完美的状态并不总是容易的。尤其是当一个问题有多种解决方案时，有些是错的，有些是对的。当你听到你的教授说“永远不要这样做”，这是一个记忆深刻的教训。你编程时一直在做的事情。
也就是说，虽然编程可能很难，但最终用高级语言编程的概念非常简单。虽然事情经常会妨碍这种简单性，但是有一些基本的方法可以用来改进代码。本文将更多地针对编写函数的过程，以及一些让函数更好、让你的代码更好的有趣方法。然而，如果你想学习一些重构方法来改进已经写好的代码，我有一篇很棒的文章推荐给你:
</5-fabulous-refactoring-methods-for-prettier-code-e3bc3447c0b2> [## 更漂亮的代码的 5 个惊人的重构方法
towardsdatascience.com](/5-fabulous-refactoring-methods-for-prettier-code-e3bc3447c0b2)
还有一件事，这篇文章实际上有一个笔记本，如果他们想看这篇文章中的例子，可以浏览一下。您可以在 Github 上找到该笔记本:
https://github.com/emmettgb/Emmetts-DS-NoteBooks/blob/master/Python3/Better Function practices.ipynb
№1:输入/输出
编写函数的第一个技巧是后退一步。考虑你的函数实际上做什么。最终，一个功能的命运是回归，或者改变某些东西。在这种情况下，我们应该问的问题是
“去那里需要什么？”
没有一个明确的方向，一个函数写起来就没有意义。首先问我们需要从函数中得到什么？这是我们的产出。接下来，为了得到这个结果，我们需要在函数中输入什么？最后，我们在中间填入算术。在某些情况下，用 return 开始函数可能更有价值。虽然下面的例子相对简单，但它肯定可以用一种非常基本的方式来演示这个概念。让我们写一个函数来计算平均值。
首先，让我们确定我们的输出。在这种情况下，我们当然希望计算平均值作为回报。像这样的数据通常存储在一个向量中，或者 Python 中的一个列表中，所以我们可以假设这是我们的输入:
def mean(x : list): return(mu)
现在我们如何从列表中得到平均值？只需填写空白并返回正确的值:
def mean(x : list): mu = sum(x) / len(x) return(mu)
№2:提取
另一种我可以肯定的编写函数的方法是抽取。提取是清理代码的重要组成部分。提取只是简单地创建更多的方法，以便在一个函数中处理多种事情，而不是让所述函数成为我们需要的不同值的寻宝游戏。相反，我们编写一个函数来获取这些值。函数应该简单并且有简短的指令。这使得代码更好，就像我过去说过的，更多的方法意味着更好的代码！如果你想读一整篇关于提取的文章，我有一篇我很喜欢写的文章，你可以在这里读:
[## 更多的方法意味着更好的代码
towardsdatascience.com](/more-methods-means-better-code-1d3b237f6cf2)
在展示一个简化的 Python 示例之前，让我们看一个真实世界中我的一个函数的 Julian 示例，以便了解我是如何使用这种技术的:
function OddFrame(file_path::String)# Labels/Columnsextensions = Dict("csv" => read_csv)extension = split(file_path, '.')[2]labels, columns = extensions[extension](file_path)length_check(columns)name_check(labels)types, columns = read_types(columns)# Coldatacoldata = generate_coldata(columns, types)# Head"""dox"""head(x::Int64) = _head(labels, columns, coldata, x)head() = _head(labels, columns, coldata, 5)# Dropdrop(x) = _drop(x, columns)drop(x::Symbol) = _drop(x, labels, columns, coldata)drop(x::String) = _drop(Symbol(x), labels, columns, coldata)dropna() = _dropna(columns)dtype(x::Symbol) = typeof(coldata[findall(x->x == x,labels)[1]][1])dtype(x::Symbol, y::Type) = _dtype(columns[findall(x->x == x,labels)[1]], y)# typeself = new(labels, columns, coldata, head, drop, dropna, dtype);select!(self)return(self);end
关于这个函数，您可能会注意到，任何不能在少于三行内完成的事情都会被提取出来。如果所有这些函数都写在同一个函数中，那么它会非常长。此外，几乎不可能一步一步地跟踪所有正在发生的事情。人们可能遇到的另一个重要问题是堆栈跟踪。如果一个 bug 包含在一个一英里长的函数中，那么堆栈跟踪这个 bug 将会更加困难。每当我们收到一个堆栈跟踪，我们得到每个函数，从一个错误发生的地方出来。记住这一点，我们可以看到每个函数中发生错误的确切调用。
我明白；Julian 的例子有点过了，尤其是对于那些编写 Python 的人来说。让我们创建一个规范化函数(不，不是一个类)，它将以一种简单得多的方式利用提取方法，以便使这个概念更容易理解。旁注，当然这些函数在我们可以导入的库中都是可用的，但是这当然不是重点——这仅仅是一个实现你自己函数的例子。
from numpy import sqrtdef norm(x : list): mu = sum(x) / len(x) x2 = [(i-mu) ** 2 for i in x] m = sum(x2) / len(x2) std = sqrt(m) return([(i - mu) / std for i in x])
让我们从第一行开始。假设这个包正在计算这个数据的标准，我们可以假设这个包是面向统计的。也就是说，我们可能不仅仅在这个函数中使用均值。尽管这是一行操作，但我们可能会更多地使用它——同样，最好是尽可能少地在这样的主函数中进行操作，并且主要调用其他函数。当然，这并不是一个可怕的例子，但让我们看看接下来会发生什么。
接下来，我们开始计算 x，这是 x 中 xbar 的 xbar，我们看到这只是一个我们需要的值，以便在函数的后面得到我们的标准差。在我们得到这个值之后，我们写出算法——并重复相同的精确代码——以便计算平均值。最后，我们得到标准差，然后返回正态分布的数据。这种方法最有可能使用一些提取。我们将调用一个方法来调用它，而不是将整个标准差的算法放在这个函数中。我们也将为 mean 做同样的事情，它将共同努力把这个函数减少到只有区区三行。
def mean(x : list): return(sum(x) / len(x))def std(x : list): mu = sum(x) / len(x) x2 = [(i-mu) ** 2 for i in x] m = sum(x2) / len(x2) return(sqrt(m))def betternorm(x : list): mu = mean(x) st = std(x) return([(i - mu) / st for i in x])
这个版本唯一的缺点是平均值被计算了两次，一次在 scope 或 betternorm()内，一次在 std()的范围内。肯定有一种方法可以解决这个问题——但是尽管有一个折衷——这是一个很小的性能代价，这将是一个对任何人来说都更容易接受的代码。
№3:命名
一个经常被忽视的函数的重要性是函数的名字。名字很重要，因为在大多数情况下，它们应该告诉你函数的输出。例如，我的函数 mean 的输出。从那以后，文档字符串仅仅用于确定输入应该如何格式化，以及我们可以期望在所述输入中传递哪种类型。例如，让我们说下面的函数让“Jerry”吃了一个泡菜:
def pickle(n_pickles : int):
pass
函数名“pickle”不是很具体。这一点很重要，因为在工作环境中，你可能会和其他人一起工作。谁知道谁用这种方法得到了这个泡菜？相反，该方法应该命名为类似
def jerry_eat_pickle(n_pickles : int):
pass
当然，这仅仅是一个例子，一个愚蠢的例子——但是我认为这一点非常明显。函数需要用方便的名字命名。我甚至会说，让人们能够猜出你的函数叫什么是很好的。例如，你想合并到熊猫词典，在你的脑海中你使用这个词。这样做的函数不叫 mer()或 m()。这很有意义，只需要一秒钟。这场名称之争的另一个方面是遵循惯例，Python 使用所有小写的方法名——你不希望在你的工作中使用大写字母。大写的别名是为类型保留的。
命名的另一个方面也是命名一个人的功能的特定部分。在我的 Julia 使用提取方法的例子中，你可以看到没有过度注释——这是我最讨厌的地方之一。当然，如果你试图一步一步地解释某事是一回事，但是像
# multiply 5 by x
5 * x
真磨我齿轮！总之，我给函数的这些部分贴上了标签，因为它们都是为返回服务的，在这个例子中是一个类型。这并不是说你需要为你的函数的每一部分留一个注释，尽管这是有帮助的——例如，有人在我的 OddFrame 类型中的 head 函数上做了一些工作，并且想要改变它被构造成该类型的方式，这对于他们来说是相对容易找到的。也就是说，我认为命名还有一个好处，那就是让程序员把事情组织在一起。这对阅读代码的人来说更好，因为他们一次只需要阅读一件事。
№4:没有重写
正如我之前提到的，重复自己是不好的。当然，在许多情况下，这可以通过提取得到帮助，但是不管怎样，您可能会发现必须一遍又一遍地重写相同代码的情况。这可能会有问题。也就是说，找到某种方式来避免重复编写代码可能是个好主意。
我们不要忘记，模块是加载到内存和/或缓存中的。这意味着每次加载一个模块时，该模块的每个字符都被加载到某种内存中。记住这一点，尽量减少重复是很重要的。这是编写更好的代码的一个很好的方法，这些代码会运行得更好，工作得更好。
№5:少即是优
较少的代码总是优于较多的代码。通常，更少的代码对性能成本也有很大的好处。也就是说，代码越少越容易阅读，这在很多情况下实际上比性能更重要。让我们只考虑我们在这里写的语言是 Python。Python 并不一定因为它的速度而受人尊敬。然而，这种语言以相对简单和初学者友好而闻名。
也就是说，由于数据科学领域目前围绕着 Python，本文也是如此，所以性能可能会受到可读性的影响。即便如此，我认为大多数时候更简洁的解决方案最终会更快。
№6:限制类型
许多初学者在开始开发他们的第一个 Python 模块和函数时犯的一个巨大错误是没有限制参数的类型。有许多令人信服的理由可以解释为什么要限制类型，但是让我们从最基本的开始。考虑以下函数:
def add5(x): return(x + 5)
如果我们要通过它传递一个字符串，我们会得到一个错误，就像这样:
add5("hello")
虽然有些用户可能能够很快分辨出这个错误，并将该字符串更改为整数，但对其他人来说，这可能会令人困惑。鉴于 x 列在最前面，这一点尤其重要。这意味着 throw 认为我们为字符串的加法运算提供了错误的类型，而不是整数。因此，有些人可能读到这里会说“但是我提供的是一个字符串！”当然，我的假设是错误的，但是最终你可以通过两句话的回答来避免整个 Github 问题，只要确保最终用户知道传递一个整数，并且可以更容易地识别它。虽然在 Python 中情况可能不太一样，但在其他语言中(尤其是我唯一的语言 Julia)，设置参数的类型非常重要！
您可能希望设置参数类型的另一个原因是，在类型被传递之前，解释器知道您可能在函数中使用的类型。这对解释器很有帮助，有可能加速你的软件！
№7:文档字符串！
显然，我最喜欢读的东西之一是文档。这是因为我花了将近四分之一的时间做这件事。随着所述文档而来的是文档字符串。文档字符串是绝对重要的——没有它们你根本无法有效地操作。作为一个人，你肯定会忘记事情。你不可能记住分布在 10 个文件中的 10，000 行代码的模块在每个单独的容量中做了什么。
记住，不仅文档字符串对最终用户很重要，对开发者也很重要。当在协作中工作时，这些对于编写一个整个团队可以在你的所有代码中使用的函数是必不可少的。下一次你写函数的时候，不要让函数的头部孤独:
def add5(x: int): return(x + 5)
而是文档！
"""Adds five to an integer"""
def add5(x: int): return(x + 5)
№8:最小嵌套
编程界另一个常见的新手错误是嵌套太多。嵌套是一个术语，每当给定软件内部声明了新的范围级别时，都会用到它。例如，在 Julia 中，我们编写“module”来启动一个模块，这就创建了第一层嵌套。我们的范围不再是全球性的，现在我们在一个更小的范围内运作。我们在这个模块中声明了一个函数，这样就有了另一层。
然而，通常每当程序员在否定的上下文中谈论嵌套时，他们指的是嵌套循环和嵌套条件。每个 for 循环和 conditional 循环分别有自己的作用域，下面是一个嵌套 for 循环的示例:
for i in range(1, 5):
for i in range(1, 3):
print(i)
这个 for 循环现在会在每次调用嵌套它的循环时被调用。不用说，这对我们软件的性能来说是一个难以置信的问题。也就是说，有些时候这是不可避免的——但这是唯一应该使用的时候！这是我的建议，只写一个嵌套的 for 循环
- 样机研究
- 所有其他选择都用尽的解决方案
№9: (Python)装饰者
在我看来，Python 编程语言的一个被低估的部分是使用 Python decorators 完全改变类工作方式的能力。这些都被可笑地低估了！谁会想到仅仅通过在函数的顶部添加一个简单的装饰器就可以完全改变代码的本质或者提高代码的效率和速度呢？！
为了最大限度地利用你的函数和类，在用 Python 编程时，你绝对应该研究一下 decorators！装饰器非常容易使用，并且在各种事情上都非常有效，从提高代码速度到完全改变 Python 语言的范式。我提到过这可以通过一个简单的调用在一行中完成吗？哦，对了，如果你不熟悉 Python 中令人惊叹的装饰者世界，我也碰巧为你提供了一个我最喜欢的装饰者的庞大列表，我喜欢使用:
</10-fabulous-python-decorators-ab674a732871> [## 10 个神话般的 Python 装饰者
towardsdatascience.com](/10-fabulous-python-decorators-ab674a732871)
№10:编写你的评论
我经常看到的一个错误，也是我之前提到过的，就是一些程序员的评论是多么的荒谬。如果你有一个 500 行代码和 500 行注释的代码文件，你可能用错了注释。避免发表明显的言论，例如:
# get parameters
parameters = get_params(data)
首先，我们在这里赋值的变量是命名参数，所以我认为大多数人可能会认为我们得到了参数。其次，即使变量有一个随机的名字，这个函数也叫做 get_params。如果人们不能阅读一个简单的断言，他们可能不会阅读你的代码！在每行代码之间使用注释看起来很难看，这是一种可怕的做法——也不符合 PEP。也就是说，如果你碰巧不知道什么时候注释你的代码或者不注释它——我为 Python 程序员写了一个简短的注释指南，你可以在这里阅读:
№11:使用 lambda！
编写函数的另一个重要技巧是根本不要编写函数。相反，你可以用 lambda 关键字写一个表达式。这将有效地把您的 Python 函数变成一行可以映射到数组的语句。这远远优于——并且比您这样做的典型迭代方法更 Pythonic 化。它非常容易使用，就像这个例子一样，使用我们之前写的均值函数:
mean = lambda x: sum(x) / len(x)
现在我们可以像写出函数一样调用它:
mean([5, 10, 15])10
当然，这个简单的例子仅仅展示了 lambda 是如何被用于单行函数的。当这些表达式与其他函数一起使用时，真正的力量就来了。实际上，我有一整篇关于 lambda 及其用法的文章，以及我喜欢它的原因，如果你感兴趣，可以在这里阅读:
差不多一年前！哇哦。
№12:尽可能避免暴食
在编写 Python 函数时，我的最后一个编程技巧是避免关键字参数。当然，我并不认为关键词论证是不好的，显然我们有这样的理由。它们非常有用，尤其是对于我们用于绘图或机器学习软件的参数。不用说，他们有他们的位置。
然而，我相信我之前的声明。他们有他们的位置！他们的位置不是到处都是！当可以使用位置参数时，它们应该使用！首先，键入关键字参数很烦人…其次，它们确实对性能有很大的影响，当然不应该烦人！也就是说，我并不是在讨伐他们——只是在错误的上下文中使用关键字的论点不是一个好主意！
结论
这些是我的一些方法、过程和建议，帮助我编写更好、更高效、更简洁的 Python 函数。当然，没有一个函数在第一次完成时是完美的，但是使用这些技巧中的一些，你至少可以使你的函数的第一次重现相对地具有示范性！非常感谢你的阅读，我真的希望这些建议中的一些能派上用场，或者给一些你可能做错的事情的想法！如果你也有保持功能简洁的建议，我很乐意在回复中看到它们！谢谢大家！祝您白天或晚上休息愉快，数据管理愉快！
下一次数据科学面试中你必须知道的 12 个统计学概念
自信地赢得下一次数据科学面试
统计学提供了工具和方法来发现数据的结构和有意义的见解，还帮助我们量化隐含的不确定性，因此，拥有良好的统计学基础对任何数据科学家都至关重要。因此，对于任何数据科学面试，我们都会根据我们的统计知识进行测试。
米利安·耶西耶在 Unsplash 上拍摄的照片
在这篇文章中，我整理了 12 个统计学概念，我发现它们对破解面试非常有用。因此，我将在这里回顾这 12 个概念，并解释它们的全部内容。
- 条件概率与贝叶斯定理
对于任意两个事件 A 和 B，P(A|B)表示在事件 B 已经发生的情况下，事件 A 发生的条件概率。条件概率的公式由以下等式给出
继续条件概率的讨论，当新的信息可用时，修正我们对事件的先验概率是一个关键阶段，这就是贝叶斯定理变得有用的地方。下面的数学等式总结了贝叶斯定理。
在这个等式中，A 是一个事件，B 是从数据中获得的经验证据或信息。因此，P(A)是事件 A 的先验概率，P(B)是基于数据证据的事件 B 的概率，P(B|A)被称为可能性。因此，贝叶斯定理根据我们对事件的先验知识给出了事件的概率，并在我们获得新的信息时更新条件概率。
贝叶斯定理的一个非常简单的例子是，假设早晨多云，预测某一天下雨的概率。假设，在六月的某一天下雨的概率是 10%,如果下雨，早上多云的概率是 50%。此外，六月任何一天早晨多云的概率，即 P(云)是 40%，那么应用贝叶斯定理，我们可以得出结论，假定今天早晨多云，今天下雨的概率是:
2。取样技术
如果我们把一组中的所有元素称为总体，那么这个总体的一个子集称为样本。样本中观察值或个体的总数称为样本容量。人口的任何统计常数，例如，人口的任何特征的平均值、方差等描述性度量被称为参数。当基于样本观察值计算时，相同的统计度量将被称为统计量。从总体中选择样本的方法有两种——概率性的和非概率性的。
概率抽样方法
答:简单随机抽样
在简单随机抽样中，每个样本从总体中选取的可能性是相等的。这项技术减少了选择偏差。然而，这种技术的缺点是，我们可能无法根据任何特定的特征来选择样本，这是不常见的。
举例— 简单随机抽样的一个例子是通过抽签从一个 100 人的班级中选出 10 名学生。
b .系统采样
在系统抽样中，样本是在固定的特定时间间隔内收集的。系统抽样的优点是它有助于保持足够的抽样规模。
系统抽样的一个例子是在一家杂货店中选择每 10 个顾客进行顾客满意度调查。
c .分层抽样
在分层抽样中，整个人口被分成不同的小组，也称为具有相似特征的阶层。这种取样的主要目的是从所有在感兴趣的特征中表现出可变性的亚组中获得代表性。。
例如，如果我们有兴趣了解人们对印度任何特定话题的看法，我们可以根据城市、性别和年龄组来划分人口。基于所选特征的这些子群体被称为层，并且层中的每个样本是基于概率抽样方法(例如简单随机抽样)来选择的。
非概率抽样方法
a .方便取样
在方便抽样中，参与者是根据他们的可用性和参与研究的意愿来选择的。然而，这种技术可能会受到志愿者偏见的影响，这可能是所有非概率抽样方法的风险，因为样本是自己选择的，而不是随机挑选的。
b .配额抽样
配额抽样在市场调查中相当流行。在这种情况下，采访者只需根据任何调查/研究所需的配额选择样本。例如，一家智能手机公司可能希望调查某个城市中哪个年龄段的人使用哪个品牌的手机。然后他们申请配额，例如每个年龄组 100 人，例如 21-30 岁、31-40 岁、41-50 岁，或者他们可以进一步根据性别实行配额，例如每个年龄组 50 名男性和 50 名女性。他们将根据获取的难易程度和他们的研究预算来选择样本。然而，如前所述，配额抽样作为一种非概率方法，仍可能存在自愿偏差。
c .有目的的取样
在有目的抽样中，研究人员运用他们对目标人群的专业知识，以非随机方式选择“代表性”样本。有目的的取样无疑是省时、省钱的，但是除了志愿者的偏见之外，这种类型的取样会导致研究者在选择参与者时的判断偏差/错误。
3。概率分布
概率分布对于理解任何数据结构都是至关重要的。主要有两种分布类型——离散分布和连续分布。
答:离散概率分布
这些分布模拟了以离散值作为输出的随机变量的概率。例如，如果 X 是一个离散的随机变量，描述了一次投掷中的人头数，我们可以重复多次投掷，并记录每个可能结果的概率。如果我们用函数的形式来表示它，那么它将被称为“概率质量函数(PMF)”，它定义了离散随机变量 X 取特定值 X 的概率。这种分布的例子有伯努利分布、二项式分布、泊松分布。
b .连续概率分布:另一方面，连续概率分布模拟随机变量的概率，这些随机变量可能具有本质上连续的任何可能结果。例如，代表城镇居民体重的随机变量 X 的可能值可以是任何值，如 54.5、47.2、60.3 等。示例可以是正态分布、学生 T 分布、卡方分布、指数分布等。
4。假设检验
我们使用一个假设来对总体参数进行断言或假设。现在，为了在我们收集的样本数据的基础上验证我们的主张，我们创建了两个假设——无效假设和替代假设。
零假设反映了研究者对假设检验结果的中立观点。它基本上陈述了默认情况，例如，在药物功效实验中，无效假设可以是获得药物的患者和获得安慰剂的患者组之间的治愈率没有差异。与零假设完全相反的陈述就是替代假设。替代假设总是挑战零假设。接受或拒绝零假设的决定是基于样本数据做出的。
5。置信水平
继续假设检验的概念，理解什么是置信水平是非常重要的。假设检验中的置信水平是当原假设实际上为真时，不拒绝原假设的概率。它传达了如果我们再次重复这个实验，我们对得到同样的结果有多大的把握。因此，我们构造了一个置信区间，它是由统计推断产生的参数的区间估计。该时间间隔通过以下公式计算:
[基于选定置信水平下样本分布的点估计临界值*样本的标准偏差]
例如，如果我们有一个均值为 60、标准差为 5 的抽样分布，那么 95%的置信区间将在(60–1.96 * 5)即 50.2 和(60 +1.96*5)即 69.8 之间。这里，1.96 是临界值，其来源于这样的事实，即对于正态分布，95%的区域位于 1.96 的标准偏差内
我们永远不可能对统计数据有 100 %的信心，因为我们总会有一些不确定性。因此，在统计研究中，我们通常会遇到 99%、95%或 90%的置信度。
6。p 值和显著性水平
对于任何统计推断研究，我们都需要做出拒绝/接受零假设的决定，该决定是基于随机样本的观察值做出的。然而，我们从总体样本中得出的结论总是有可能是错误的。当零假设实际上为真时，与拒绝零假设相关的误差被称为 I 型误差，当零假设为假时，与接受零假设相关的误差被称为 II 型误差。现在，让我们假设，犯第一类错误的概率是某个数字，α，这是任何研究人员为他的研究设定的重要性水平。5%的α表示当我们拒绝零假设时，我们愿意接受 5%的错误概率。另一方面，p 值是观察到的显著性水平，它给出了当零假设为真时，我们获得与从我们的样本数据计算的结果一样极端的结果的概率。
7。A/B 测试
A/B 测试是对 A 和 B 两组进行的随机实验，用非常简单的语言来说，它是一种比较单个变量的两个变量的方法，以找出在受控环境中哪个变量的表现优于另一个变量。这种技术通常用于提高客户满意度的营销策略。
例如，可以向一家公司总客户群的 30%发送两封具有不同行动号召的营销电子邮件，以测试哪一封的点击率更高。营销团队然后等待几个小时，他们选择向其余 70%的客户发送点击量更多的电子邮件
8。z 检验和 t 检验
在假设检验中，z 检验和 t 检验都非常有用。当样本量较大(即 n ≥ 30)且总体标准差已知时，当我们想要了解两个样本均值是否存在显著差异时，通常会使用 z 检验。另一方面，对于 n >0 的小样本量，t 检验可用于比较两个样本的均值，即使我们不知道总体标准差。t 检验遵循学生的 t 分布，而 z 检验假设样本分布是正态的。在大样本的情况下，Z 检验和 t 检验往往会给出相同的结果，因为对于足够大的样本量，t 分布接近正态分布，Z 得分和 t 得分之间的差异变得可以忽略不计。现在，当我们想要了解样本均值是否与总体均值有显著差异时，可以使用 t 检验来执行单样本 t 检验。因为我们不知道 t 检验中的总体标准差，所以我们使用样本标准差。
9。协方差和相关性之间的差异
协方差度量为我们提供了两个变量之间线性关系的方向。另一方面，相关性给了我们这两个变量之间关系的强度和方向。如果我们思考一下数学公式，我们可以用这两个变量的协方差除以同一个变量的标准差的乘积来计算这两个变量的相关系数。因此，相关值是标准化的。因此，相关系数位于-1 到+1 之间，但是协方差可以位于-∞到+∞之间。
10。线性回归 vs 逻辑回归
当因变量连续时，通常使用线性回归。线性回归的关键假设之一是因变量和自变量之间存在线性关系。另一方面，当因变量是二元时，使用逻辑回归。它通过将数据拟合到 logit 函数中来预测事件发生的概率。对于逻辑回归，我们不需要因变量和自变量之间的线性关系。
线性回归拟合数据中的直线，而逻辑回归拟合数据中的曲线。线性回归假设预测误差为高斯(或正态)分布。然而，基于线性回归的模型的因变量或自变量不需要遵循正态分布。有时，当训练数据有一些异常值或因变量过于倾斜时，模型中产生的误差也可能不符合正态分布。逻辑回归假设因变量呈二项式分布。
11。中心极限定理和大数定律
中心极限定理指出，无论特定变量在总体中的分布如何，当我们从总体中收集样本时，随着样本量的增加，变量均值的采样分布将接近正态分布。中心极限定理在统计学中非常重要，原因有两个:正态性假设对于参数假设检验和估计的精度至关重要。在现实生活中，我们经常会遇到非正态分布。因此，我们可能会担心我们正在进行的假设检验或我们正在得到的参数估计没有给我们准确的结果。然而，如果我们有一个大样本量(> 30)，那么 CLT 允许我们使用测试和估计，即使数据不是正态分布。
另一方面，根据大数定律，随着实验中试验次数的增加，试验的平均结果将最终接近真实的总体平均值。例如，当我们投掷一枚公平的硬币 1000 次时，我们更有可能看到一半的时间正面朝上，而相比之下，同样的硬币只投掷 10 次。
12。最大似然估计(MLE)
最大似然估计涉及通过最大化似然函数来估计参数，以找到最好地解释观察数据的参数。MLE 就是这样一种预测性建模框架，其中模型参数是通过优化问题找到的。这里，似然函数 p(y| θ)描述了给定参数θ时观察数据 y 的似然性。我们通过最大化给我们最大似然值的参数集(θ)来解决优化问题。最大似然估计在处理大数据量时效果很好，并给出了无偏最小方差估计量。
尾注:
感谢阅读！
对统计学有非常深刻的理解是成为成功的数据科学家的先决条件。我希望这篇文章能帮助你准备下一次数据科学面试。我在这里讨论的 12 个概念将为你建立进一步学习的重点领域。
比较了 12 种 Twitter 情感分析算法
12 种情感分析算法在推文分类的准确性上进行了比较。fasText 深度学习系统胜出。
图片:Farknot Architect / iStockPhoto
情感分析用于确定一段文本中的情感是积极的、消极的还是中性的。情感分析是自然语言处理的一种形式，也是自然语言处理技术的一部分，被称为信息提取的 T2。
数据科学家的一项工作是为给定的任务选择最佳算法。通常，最好的方法是尝试许多不同的算法，看看什么效果最好。
在本文中，我将比较十几种使用 Python 编程语言的情感分析技术，包括 Google 和 Amazon 的现成情感分析服务。这些技术的 Python 代码可以在Github 库中找到。
Twitter 情感分析数据源
本文中用于分析的数据集是一组关于消费者对航空公司表现印象的推文。每条推文都被分为正面、负面或中性情绪。12 种情绪分析算法中的每一种都为每条推文计算一种情绪。然后，基于数据集中的情感得分，将计算出的情感评分为正确或不正确。使用的总体衡量标准是准确性或算法正确计算的推文百分比。
情感分析算法
12 种情感分析算法可以分为四类:
- 情感词汇的使用
- 现成的情感分析系统，包括亚马逊理解、谷歌云服务和斯坦福 CoreNLP 系统
- 经典机器学习算法
- 深度学习算法
情感词汇
第一种算法将推文中的每个单词与被标记为积极或消极情绪的单词数据库进行比较。有许多这样的数据库。为了这个分析，我从 Kaggle 下载了一个正面和负面情绪词汇的列表。
在将推文中的单词与正面和负面单词列表进行比较之前，首先需要将推文或评论拆分成一个令牌列表(主要是单词)。这是使用 NLTK 分词器完成的。NLTK 是 Python 语言中比较流行的自然语言处理工具包之一。
然后，每个令牌通过修改或移除令牌的管道(即，一系列代码转换)来运行。流水线中使用的步骤是:
- 转换为小写
- 删除推文中的@提及
- 删除超链接
- 删除缩写(例如，将“不会”转换为“会”和“不”
- 删除标点符号
- 将每个标记转换成它的基本形式，这个过程称为变元化。比如“动”转换为“动”，“脚”转换为“足”。NLTK 中可用的 WordNet Lemmatizer 就是为了这个目的而使用的。这个 lemmatizer 接受一个标记作为输入，不管它是动词、名词还是形容词，这个符号也是由上面提到的单词标记化器产生的。
- 最后，所有像“a”和“the”这样对情感没有贡献的常用词都被删除。这个“停用词”列表是从 NLTK 语料库停用词函数中获得的。
正面和负面列表中的每个单词也通过这条管道，以实现“苹果对苹果”的比较。正面词多于负面词的推文被评为正面。负面词较多的一个被评为负面，如果没有正面/负面词或相同的数字，则被评为中性。
对于推文情感分析，这种方法对推文产生了 46%的准确率。几率准确率 33%。
使用了 15000 多条推文。
使用现成系统的 Twitter 情感分析
第二类算法是现成的系统，不需要对数据进行任何预处理。你提供文本，系统计算情感。我测试了来自谷歌云和亚马逊理解的情感分析服务。
相对于下面讨论的机器学习算法，这些服务有点劣势，因为它们必须适用于所有类型的文本。相比之下，机器学习算法有机会了解是什么使推文不同于评论和其他文本。
在这一部分，我还测试了斯坦福大学的 CoreNLP 情感分析器。这个工具甚至更不利，因为它试图首先分析句子的句法结构。然而，tweets 经常不合语法，所以这个工具表现不好也就不足为奇了。
这些工具都经过了 15000 多条推文的测试。谷歌情绪分析工具表现最好，为 59%，亚马逊情绪分析工具紧随其后，为 58%，斯坦福工具为 47%。谷歌和亚马逊工具的性能比情感词典算法好得多。
使用机器学习算法的推特情感分析
用于情感分析的机器学习算法应该是表现最好的，因为它们有机会根据特定类型的数据(如推文或评论)来定制决策。
然而，机器学习算法需要比情感词典算法或现成算法大得多的数据集。除了 tweets 的测试集，还必须有一组训练数据。
为了创建训练和测试集，我从 3 万条推文开始。然后，使用上面在情感词典算法部分中讨论的流水线，对其中的每一个进行预处理。
一种标准的方法是将这些数据集分成一个训练数据集和一个测试数据集。我将这些数据集分成 70%用于训练，30%用于测试。
然而，积极、消极和中性推文在训练集中的分布远非均匀。积极的推文远远多于消极或中性的推文。这种不平衡的数据可能会导致机器学习系统发现大多数推文都是正面的，并学会依赖对每条推文的正面猜测。
为了解决这个问题，我使用 SMOTE 过采样向训练集添加负面和中性的例子，这样训练集就有大约 12，000 条正面、12，000 条负面和 12，000 条中性的推文。需要注意的是，在进行训练测试分割后进行过采样是非常重要的。如果它是在训练-测试分割之前完成的，那么在训练和测试集中都会有一些例子，这会导致误导性的高精度数字。
机器学习需要的另一个修改是将每条推文中的标记转换为一组可以由机器学习算法分析的特征。有很多方法可以做到这一点，但我选择了使用单词袋(BOW)方法。BOW 方法的特点是 tweets 中最常见的 2000 个单词。所以每条微博有 2000 个特征。每个特征值仅仅是这个词在 tweet 中出现的次数。当然，每条推文的特征向量非常稀疏，即大多数特征的值为零。
然后，我使用 scikit-learn 将这些 BOW 特征输入到几个机器学习算法中，包括:
- 朴素贝叶斯:众所周知，这种算法适用于许多文本分类问题，并且需要相对较少的训练样本。
- 支持向量机:像朴素贝叶斯分类器一样，支持向量分类器也适用于文本分类，并且需要相对较少的训练样本。
- 决策树:决策树通常在学习分类方面做得很好，并且以决策树的形式产生易于解释的结果。
- XGBoost:该算法使用一组不同的决策树，称为随机森林。众所周知，这种方法既快速又能达到很高的精度。然而，它不像简单的决策树那样具有可解释性。
- k-最近邻:该算法通过寻找最接近测试示例的训练示例来工作。
这些 ML 分类器的最高准确度是 XGBoost 和 Naive Bayes，它们都达到了 73%的准确度。线性 SVC 算法以 71%紧随其后。决策树以 63%的比例出现，k 近邻以 38%的比例远远落后。
使用深度学习的推特情感分析
深度学习算法通常优于上一节讨论的更经典的机器学习算法。然而，它们通常需要更多的数据。尽管如此，为了进行比较，我对深度学习算法使用了与上一节中对机器学习算法相同的训练和测试数据。
测试了三个深度学习算法:
- Keras: Keras 是一个简单易用的层，位于 TensorFlow 和其他深度学习框架之上。我使用了一个 3 层顺序网络。我尝试了 10 个、20 个和 50 个历元，尽管在准确性上差别不大。
- fasText: fasText 是一个由脸书 AI 开发的 NLP 库。这是一个开源、免费、轻量级的库，允许用户学习文本表示和文本分类器。它在标准的通用硬件上工作。模型可以缩小尺寸，甚至适合移动设备。在这里，我也使用了 10、20 和 50 个历元，发现在准确性上没有什么不同。
- distill BERT:distill BERT 是著名的 BERT 语言模型的一个更小、更快的版本。预训练的 DistilBERT 系统的最后一层用作逻辑回归分类器的一组特征输入，并遵循本 Google Colab 演示笔记本中使用的基本方案。这也是唯一一个我没有在电脑上运行的算法，因为它太耗费资源了。相反，我在我的 Google Colab Pro 帐户上运行了它。即便如此，我也不得不将数据集中的 tweets 数量限制在 10，000 条以内，以避免耗尽内存。
最快的算法表现最好，准确率为 71%。Keras 和 DistilBERT 网络都获得了 68%的分数。
获胜者
XGBoost 和 Naive Bayes 算法在测试的 12 种 Twitter 情绪分析方法中准确率最高。深度学习系统可能没有足够的数据来实现最佳性能。也就是说，我已经看到 XGBoost 在至少另一场烘焙比赛中胜过深度学习系统。
可能有许多方法可以提高整体性能。如果我有足够的内存来运行完整的数据集，那么 DistilBERT 方法的性能可能会更好。此外，除了使用预训练的特征，人们还可以做进一步的训练，以在 tweet 数据集上微调系统。最后，代替使用 BOW 方法，使用单词嵌入作为特征可能会产生更好的整体准确性。也许这将是未来文章的主题。
圣诞节 12 天的 12 个有用算法
所有数据科学家都应该知道的非常酷的算法
由 freepik 创建的背景向量—www.freepik.com
务必 订阅此处 千万不要错过另一篇关于数据科学的指南、诀窍和技巧、生活经验等文章！
介绍
又到了一年的这个时候了！这一次，不是圣诞节 12 天的 12 个数据科学项目，我想和你们分享 12 个非常酷、非常强大的算法，我们不只是在谈论监督算法。
我们在同一页上，一个算法是一系列用于解决问题的指令。从技术上来说，菜谱是一种算法，但我们将专注于与数据科学相关的算法。
我将更多地关注每个算法背后的逻辑，而不是数学，但我会提供额外的资源以防万一。😃
说到这里，让我们开始吧！
1.基于密度的噪声应用空间聚类
作者创建的图像
这是什么？
DBSCAN，也称为基于密度的带噪声应用程序空间聚类，是一种聚类算法，它通过查找密集聚集在一起的区域(换句话说，具有许多近邻的点)来识别聚类。
DBSCAN 是最好的聚类算法(优于 k-means 聚类或层次聚类),原因如下:
- 它可以自己确定最佳的集群数量
- 它可以发现异常形状的集群，而不仅仅是圆形的
- 它足够健壮，不会受到离群值的影响
更多资源
https://en.wikipedia.org/wiki/DBSCAN https://www.kdnuggets.com/2020/04/dbscan-clustering-algorithm-machine-learning.html
一定要 订阅这里 千万不要错过另一篇关于数据科学的指南、诀窍和技巧、生活经验等文章！
2.TF-IDF
TF-IDF 方程
这是什么？
TF-IDF 代表术语频率-逆文档频率，它用于确定一个词在语料库(文档集合)中作为文档的重要性。
具体而言，给定单词的 TD-IDF 值相对于该单词在文档中出现的次数而增加，并随着语料库中也包含该特定单词的文档数量而减少。这是为了说明一般情况下更常用的单词。
TF-IDF 是自然语言处理和信息检索领域的一种流行技术。
更多资源
https://monkeylearn.com/blog/what-is-tf-idf/ https://www.analyticsvidhya.com/blog/2021/11/how-sklearns-tfidfvectorizer-calculates-tf-idf-values/
3.Apriori 算法
这是什么？
Apriori 算法是一种关联规则算法，最常用于确定项目集中相互关联最紧密的项目组。
举个例子，假设我们有一个顾客在杂货店购物的数据库。Apriori 算法可用于确定哪些商品对或商品组最常一起购买。
主要有两个参数:支持度和信心。支持度指的是物品出现的频率，而置信度表示在一个或多个其他物品被购买的情况下，一个物品被购买的条件概率。
更多资源
https://www.educative.io/edpresso/what-is-the-apriori-algorithm
4.霍尔特-温特斯指数平滑
这是什么？
霍尔特-温特斯指数平滑法，也称为三重指数平滑法，是一种流行的预测技术，用于显示趋势和季节性的时间序列数据。
它被称为三重指数平滑，因为它考虑了数据的水平、数据的趋势和数据的季节性。
这种预测方法相对于其他方法(如 ARIMA)的优势在于:
- 理解和实现起来很简单
- 它相当准确
- 而且它的计算成本很低，也不占用太多资源
更多资源
https://machinelearningmastery.com/exponential-smoothing-for-time-series-forecasting-in-python/
务必 订阅此处 千万不要错过另一篇关于数据科学指南、诀窍和技巧、生活经验等的文章！
5.矩阵分解
这是什么？
矩阵分解算法是一种常用于构建推荐系统的协同过滤算法。
协同过滤背后的思想是基于其他相似用户的兴趣来预测给定用户的兴趣。这被称为基于记忆的方法，但另一种方法是基于模型的方法，其中使用机器学习算法来预测用户对未评级项目的评级。
更多资源
https://developers.google.com/machine-learning/recommendation/collaborative/matrix
6.莱文斯坦距离
作者创建的图像
这是什么？
Levenshtein 距离是一种简单的算法，用于确定两个字符串之间的相似性。
具体来说，它等于将一个单词更改为另一个单词的最小单字符编辑(替换、添加、删除)次数。
例如，“taco”和“eggs”之间的 Levenshtein 距离是 4。“十字”和“纵横字谜”之间的 Levenshtein 距离也是 4。直觉上，这些对排序相同是很奇怪的，这显示了这种算法的局限性。
所以，我推荐的两个更好的字符串相似性算法是 Trigram 和 Jaro-Winkler 算法。
更多资源
https://blog.paperspace.com/implementing-levenshtein-distance-word-autocomplete-autocorrect/
7.页面等级
这是什么？
PageRank 是 Google 创建的一种算法，用于对他们的网页进行搜索结果排名。根据谷歌的说法，“ PageRank 的工作原理是统计一个页面的链接数量和质量，以确定对该网站重要性的粗略估计。潜在的假设是，更重要的网站可能会从其他网站收到更多的链接。
简化公式如下:
对于链接到页面 u 的所有页面，页面 u 的页面排名等于页面 v 的页面排名之和除以来自页面 v 的链接数量
更多资源
https://en.wikipedia.org/wiki/PageRank https://www.link-assistant.com/news/google-pagerank-algorithm.html
8.Dijkstra 算法
作者创建的图像
这是什么？
Dijkstra 算法是一种用于在节点图中寻找从起始顶点(节点)到目标顶点(节点)的最短路径的算法。
Dijkstra 的算法采用贪婪的迭代方法，生成一组信息，其中包括从一个起始顶点到图形中每隔一个顶点的最短路径(见下面的视频)。
Dijkstra 的算法通常用于寻找最短的运输路线，确定最短的石油线路长度，并在一些社交媒体应用程序中使用。
更多资源
https://en.wikipedia.org/wiki/Dijkstra's_algorithm https://stackabuse.com/dijkstras-algorithm-in-python/
务必 订阅此处 千万不要错过另一篇关于数据科学的指南、诀窍和技巧、生活经验等文章！
9.ε-贪婪算法
这是什么？
ε-贪婪算法是解决多臂强盗问题的一种简单方法，该问题代表了探索与开发的两难选择。
这个问题背后的想法是，有 k 个不同的选择，每个选择都有不同的回报，但是你不知道任何一个选择的回报。所以，你从探索不同的选择开始，随着时间的推移，在探索更多的选择和开发报酬最高的选择之间有一个权衡。
使用ε-贪婪算法，在时间的一部分ε中选择一个随机的备选项。其余时间(1-ε)，选择已知最高支出(奖励)的备选项。ε是一个必须设置的参数。
更好的解决方案包括置信上限解决方案和贝叶斯汤普森抽样。
更多资源
https://www.geeksforgeeks.org/epsilon-greedy-algorithm-in-reinforcement-learning/ https://en.wikipedia.org/wiki/Multi-armed_bandit#Optimal_solutions
10.高斯朴素贝叶斯
这是什么？
朴素贝叶斯是一种基于贝叶斯定理的分类最大似然算法。
更具体地说，高斯朴素贝叶斯是一种朴素贝叶斯，它假设连续变量遵循正态分布，并由以下等式表示:
虽然朴素贝叶斯持有非常不切实际的假设，但它速度快，易于实现，并且适用于多类预测。这使得它在实时预测、多类预测、文本分类，甚至补充推荐系统方面很受欢迎。
更多资源
https://scikit-learn.org/stable/modules/naive_bayes.html
11.随机森林分类器
这是什么？
随机森林算法是一种集成学习算法，它涉及创建多个决策树，然后选择每个决策树的所有预测的模式。通过使用投票系统，或“多数获胜”模型，它减少了个别树的可能性误差。结果是一个更准确、更稳健、偏差更小的模型。
作者创建的图像
用这个图像，如果我们创建一个决策树，第三个，它会预测 0。但是通过使用所有四个决策树，预测值将是 1。
更多资源
12.哈里斯角探测器
这是什么？
Harris 角点检测器是一种在计算机视觉算法中用来识别图像中的角点的算子。这对于图像处理和计算机视觉是很重要的，因为已知角点是图像中的重要特征。
基本直觉如下:
作者创建的图像
- 在平坦的区域，任何方向都没有渐变(颜色变化)。
- 在边缘区域，边缘方向没有梯度变化。
- 只有在角区域中，在所有方向上都有梯度变化
因此，在整个图像中使用这种方法来确定图像中的角点在哪里。
更多资源
https://medium.com/data-breach/introduction-to-harris-corner-detector-32a88850b3f6
感谢阅读！
被 确定要 订阅此处 千万不要错过另一篇关于数据科学指南、诀窍和技巧、生活经验等的文章！
不确定接下来要读什么？我为你选了另一篇文章:
还有一个:
特伦斯·申
奥运会 120 年
使用 R flexdashboard、ggplot2 和 plotly 实现数据可视化
布莱恩·特纳在 Unsplash 上的照片
介绍
东京奥运会刚刚结束，我想回顾一下现代奥运会 120 年的历史。现代奥运会是主要的国际体育赛事，包括夏季和冬季体育比赛。创作灵感来自公元前 8 世纪至公元 4 世纪在希腊奥林匹亚举行的古代奥运会。第一届现代奥运会于 1896 年在雅典举行。
数据准备
数据源
数据从这个 kaggle 链接下载:https://www . ka ggle . com/hee soo 37/120-years-of-Olympic-history-sports-and-results。这个数据集是 rgriffin 在 2018 年 5 月创建的。
数据探索
该数据集下有两个 csv 文件。AthleteEvents 包含参加每项赛事的运动员的详细信息。它有运动员的身高、体重、年龄和名字，运动和事件以及结果(赢得的奖牌)。nocRegion 包含三个字母的 NOC 名称和各自的区域。基于以上信息，我得到了如下的实体关系图。
作者图片
数据分析
我决定使用 R flexdashboard 来可视化这个数据集。需要安装和加载几个 R 包。
在 flexdashboard 中，我们可以设计多个页面，每个页面用“=”表示。在每一页下面，我们可以用“-”来标记图表的区域。我决定用三页来显示结果。这三页将是:体育和事件，运动员和国家与奖牌。最终产品可以在这个环节中找到。
1.运动和事件
我想看看夏季和冬季奥运会的运动项目数量的增长。我先准备好数据，命名为 fig_dat1。1906 年被排除在外，因为它通常不被认为是正式的奥运会。我计算每届夏季和冬季奥运会的不同运动和项目。
作者图片
我们可以看到运动项目的数量有了显著的增长。我们还可以确定在 1920 年、1940 年和 1944 年，由于第一次和第二次世界大战，有三届夏季奥运会和两届冬季奥运会缺席。
我还用树状图显示了 2016 年夏季奥运会和 2014 年冬季奥运会每个项目下的赛事数量。我用 tabset 两个在这个区域显示两个图表。
作者图片
2.运动员
我想知道每届奥运会的运动员人数和性别比例。我们可以看到越来越多的运动员，尤其是女运动员参加了奥运会。
作者图片
接下来我想看看每届奥运会上每个国家的运动员人数和金牌数之间的关系。我使用散点图，每个点代表一个 NOC。
作者图片
3.奖章
在这一部分，我想看看哪个国家在每届奥运会上获得最多的金牌。
作者图片
很明显，美国正在主宰夏季奥运会。在 28 届夏季奥运会中，它 17 次蝉联冠军！冬季运动会，俄罗斯相当强。
我希望看到 2016 年夏季奥运会和 2014 年冬季奥运会的奖牌排行榜。
作者图片
作者图片
结论
数据可视化是识别模式和从数据中获取洞察力的非常有效的方式。r 有很多用于数据准备和分析的软件包。GGplot2 是一个非常强大的图表绘制包，在 flexdashboard 模板的帮助下，可以非常方便地构建仪表板并部署到 web。
奥运会 120 年——如何用 R 分析和形象化历史
实践教程
找出哪些国家赢得了最多的奖牌，以及这些国家的参与程度是如何随着时间的推移而变化的
仪表板看到生成的关于奥运会的情节。文末的链接
我最喜欢的季节之一是奥运会到来的季节。许多运动员成为整整一代人的英雄，高举他们国家的名义，更重要的是，为儿童和青年提供了一个伟大的榜样和灵感。
从公元前 776 年到公元 393 年，古代奥运会在希腊的奥林匹亚举行。1503 年后，再次出现。1896 年，第一届现代奥运会在希腊雅典举行。从 1896 年雅典奥运会到 2016 年里约奥运会，所有的奥运会都被称为“现代奥运会”。1894 年，皮埃尔·德·顾拜旦男爵提出了这个想法。
在 1912 年到 1920 年之间，以及 1936 年到 1948 年之间，有两个很长的时期没有任何游戏，分别对应于一战和二战。
也许视觉分析最重要的好处是，它使复杂的数据更容易解释，同时以清晰、简洁和合适的方式呈现出来。这篇文章对 1896 年至 2016 年的奥运会进行了有益的可视化分析。本文旨在通过具体的分析实例，为您提供一个高效、实用、方便的模型。
主要目的是演示如何从构建的系统的可视化表示中获益。在向人们介绍奥运会的同时，用户界面非常重要，而且简单，很容易用 RStudio 制作。
这篇文章的主要问题是:哪些国家最占优势？参与是如何演变的？哪些国家的各个学科奖牌最多？参加奥运会的男女比例是多少？
数据准备
数据特征:事件(夏季和冬季)，体育层面的数据，艺术比赛不包括在运动员数据中(侧重于田径)
在对各种数据集进行广泛研究后，120 年的奥运会正在接受代表性检查。它的数据集有几个优势，包括作为一个跨越 1896 年至 2016 年的大规模数据集。最后但并非最不重要的一点是，奥运会数据集被认为值得从视觉表现的角度进行研究，并提供最佳的用户体验。
此外，这篇文章旨在吸引对奥运会感兴趣的人，并直接回答他们的问题。为了回答这个主要问题，从 Kaggle 中选择了一个数据集，它由两个不同的表组成，运动员事件和事件区域。
要创建可视化效果，您将使用两种不同的数据框。在审查数据集后，决定不删除任何数据，而是使用 dplyr 软件包来操作和修改数据，使其更加适用和真实。
一些特征，比如运动员的年龄、体重和身高，在这些例子中没有实现，但是你可以用这些数据进行你自己的更广泛的分析。
也就是说，您可以开始了，首先，您需要加载将要使用的库，加载数据并进行第一次查看。
# REQUIRED LIBRARIESlibrary("gganimate")
library("data.table")
library("knitr")
library("gridExtra")
library("tidyverse")
library("plotly")# LOAD ATHLETES EVENTS DATAdataOlympics <- read_csv("datasets/athleteEvents.csv", col_types = cols(
ID = col_character(),
Name = col_character(),
Sex = col_factor(levels = c("M","F")),
Age = col_integer(),
Height = col_double(),
Weight = col_double(),
Team = col_character(),
NOC = col_character(),
Games = col_character(),
Year = col_integer(),
Season = col_factor(levels = c("Summer","Winter")),
City = col_character(),
Sport = col_character(),
Event = col_character(),
Medal = col_factor(levels = c("Gold","Silver","Bronze"))
)
)glimpse(dataOlympics)
head(dataOlympics)
您将找到 271116 个观察值，在第一个数据集中有 15 个变量。现在，您将加载第二个数据集，其中包含 NOC(国家奥委会)信息。
# LOAD DATA MATCHING NOCs (NATIONAL OLYMPIC COMMITTEE) WITH COUNTRIESNOCs <- read_csv("datasets/nocRegions.csv", col_types = cols(
NOC = col_character(),
region = col_character()
))
glimpse(NOCs)
head(NOCs)
随着时间的推移，运动员、国家和项目的数量是增加了还是减少了？
这是你可以用第一个数据集中的数据回答的第一个问题。您可以创建一个可视化图形来识别国家和运动员以及事件的参与情况是如何变化的。
# NUMBER OF NATIONS, ATHLETES AND AND EVENTS, WITHOUT ART COMPETITIONSnumbers <- dataOlympics %>%
group_by(Year, Season) %>%
summarize(Nations = length(unique(NOC)), Athletes = length(unique(ID)), Events = length(unique(Event))
)numbers <- numbers %>%
mutate(gap= if(Year<1920) 1 else if(Year>=1920 & Year<=1936) 2 else 3)plotNations <- ggplot(numbers, aes(x=Year, y=Nations, group=interaction(Season,gap), color=Season)) +
geom_point(size=2) +
geom_line() +
scale_color_manual(values=c("chocolate","deepskyblue4")) +
labs(x = " ", y = "Nations",
title="Nations, Athletes and Events",
subtitle = "Olympic Games from 1896 to 2016")
plotAthletes <- ggplot(numbers, aes(x=Year, y=Athletes, group=interaction(Season,gap), color=Season)) +
geom_point(size=2) +
geom_line() +
scale_color_manual(values=c("chocolate","deepskyblue4")) +
xlab("")plotEvents <- ggplot(numbers, aes(x=Year, y=Events, group=interaction(Season,gap), color=Season)) +
geom_point(size=2) +
geom_line() +
scale_color_manual(values=c("chocolate","deepskyblue4"))
grid.arrange( plotNations, plotAthletes, plotEvents, ncol=1)
您将得到如下结果，您可以看到它是如何随着时间的推移而增加的。
120 年的奥运会——如何用 R 分析和可视化历史:绘制国家、运动员和事件随时间的变化
哪个国家获得的奖牌最多？
这是你可以回答的第二个问题，如果能够直观地显示每个国家获得的金牌、银牌和铜牌的比例，那将会很有趣。假设你想进入前 30 名。
# THE TOTAL NUMBER OF MEDALS GIVEN TO EACH TEAMmedalCounts <- dataOlympics %>% filter(!is.na(Medal))%>%
group_by(NOC, Medal, Event, Games) %>%
summarize(isMedal=1)medalCounts <- medalCounts %>%
group_by(NOC, Medal) %>%
summarize(Count= sum(isMedal))medalCounts <- left_join(medalCounts, NOCs, by= "NOC" )medalCounts <- medalCounts %>%
mutate (Team = region)medalCounts <- medalCounts %>% select( Medal, Team, Count)# ORDERING TEAM BY TOTAL MEDAL COUNTlevelsTeam <- medalCounts %>%
group_by(Team) %>%
summarize(Total=sum(Count)) %>%
arrange(desc(Total)) %>%
select(Team) %>%
slice(30:1)medalCounts$Team <- factor(medalCounts$Team, levels=levelsTeam$Team)medalCounts <- medalCounts %>% filter(Team != "NA")# PLOT MEDAL COUNTSggplot(medalCounts, aes(x=Team, y=Count, fill=Medal)) +
geom_col() +
coord_flip() +
scale_fill_manual(values=c("gold3","gray64","sienna")) +
labs(x = "Nations", y = "Count",
title="Top 30 - Nations with the most medals won in history",
subtitle = "Olympic Games from 1896 to 2016")
你会得到如下图。你可以看到美国、俄罗斯和德国是领先的国家。你的国家在顶端吗？可悲的是，我来自的国家不是。
奥运会 120 年——如何用 R 分析和可视化历史:描绘历史上获得奖牌最多的国家
哪个国家获得的奖牌最多？—动画剧情
另一个有趣和有吸引力的方法是用动画情节来显示以前获得的奖牌，它可以详细显示每个国家多年来获得的奖牌，假设为此你只需要前 10 名。
# NUMBER OF MEDALS GIVEN TO EACH TEAMmedalCounts <- dataOlympics %>% filter(!is.na(Medal))%>%
group_by(NOC, Medal, Event, Games, Year) %>%
summarize(isMedal=1)medalCounts <- medalCounts %>%
group_by(NOC, Medal, Year) %>%
summarize(Count= sum(isMedal))medalCounts <- left_join(medalCounts, NOCs, by= "NOC" )medalCounts <- medalCounts %>%
mutate (Team = region)medalCounts <- medalCounts %>% select( Medal, Team, Count, Year)# ORDERING TEAM BY TOTAL MEDAL COUNTlevelsTeam <- medalCounts %>%
group_by(Team) %>%
summarize(Total=sum(Count)) %>%
arrange(desc(Total)) %>%
select(Team) %>%
slice(10:1)medalCounts$Team <- factor(medalCounts$Team, levels=levelsTeam$Team)medalCounts <- medalCounts %>% filter(Team != "NA")# ANIMATED PLOT MEDAL COUNT
plotMedalsAnim<- ggplot(medalCounts, aes(x=Team, y=Count, fill=Medal)) +
labs(x = "Nations", y = "Count",
title='Top 10 - Comparison over time, nations with the most medals',
subtitle = 'Olympic Games from 1896 to 2016 - Year: {frame_time}') +
transition_time(Year)+
geom_col() +
coord_flip() +
scale_fill_manual(values=c("gold3","gray64","sienna"))
animate(plotMedalsAnim,fps=2)
你将得到一个吸引人的动画情节，如下图所示，如果你想知道你加载 gganimate 库的目的，这里是原因。
奥运会 120 年——如何用 R 分析和可视化历史:历史上获得奖牌最多的国家
查看地图，看看哪些国家赢得了最多的奖牌
另一种直观显示每个国家累积奖牌数量的方法是通过地图。这也将从总体上提供整个地球的视觉概观。
# MAP NATIONS WITH MOST MEDALS WONmedalCounts <- dataOlympics %>% filter(!is.na(Medal))%>%
group_by(NOC, Medal, Event, Games) %>%
summarize(isMedal=1)medalCounts <- medalCounts %>%
group_by(NOC, Medal) %>%
summarize(Count= sum(isMedal))medalCounts <- left_join(medalCounts, NOCs, by= "NOC" ) %>%
select(region, NOC, Medal, Count)medalCounts <- medalCounts %>%
group_by(region) %>%
summarize(Total=sum(Count))data_regions <- medalCounts %>%
left_join(NOCs,by="region") %>%
filter(!is.na(region))earth <- map_data("world")earth <- left_join(earth, data_regions, by="region")# PLOT MAPplotMapMedals <- ggplot(earth, aes(x = long, y = lat, group = group)) +
geom_polygon(aes(fill = Total, label= region)) +
labs(x = "", y = "",
title="Map of nations with the most medals won",
subtitle = "Olympic Games from 1896 to 2016") +
guides(fill=guide_colourbar(title="medals")) +
scale_fill_gradient(low="white",high="gold3")
plotMapMedalsggplotly(plotMapMedals)
然后你会看到一张类似下图的地图，在那里你可以看到那些直到 2016 年里约奥运会还没有获得一枚奖牌的国家，比如洪都拉斯、玻利维亚和阿尔巴尼亚。希望 2020 年东京奥运会对这些国家来说是一个很好的机会。
奥运会 120 年——如何用 R 分析和可视化历史:历史上获得奖牌最多的国家地图
一段时间内男女运动员的参与情况
我们知道，很长一段时间以来，不幸的是纵观历史，人类在许多方面大多是性别歧视的，奥运会运动员中包括女性也不例外。你可以看看在这次全球活动中包容性是如何增加或减少的。为了更吸引人，你可以创造另一个动画情节。
# PARTICIPATION OF MALE AND FEMALE ATHLETES OVER TIME, WITHOUT ART COPETITIONSdataOlympics <- dataOlympics %>%
filter(Sport != "Art Competitions")# AFTER 1992, CHANGE THE YEAR OF THE WINTER GAMES TO COINCIDE WITH THE NEXT SUMMER GAMES. THE TERM "YEAR" CURRENTLY REFERS TO THE OLYMPICS TOOK PLACEoriginal <- c(1994,1998,2002,2006,2010,2014)new <- c(1996,2000,2004,2008,2012,2016)for (i in 1:length(original)) {
dataOlympics$Year <- gsub(original[i], new[i], dataOlympics$Year)
}dataOlympics$Year <- as.integer(dataOlympics$Year)# COUNT NUMBER OF ATHLETES BY SEX AND YEARcountsSex <- dataOlympics %>%
group_by(Year, Sex) %>%
summarize(Athletes = length(unique(ID)))countsSex$Year <- as.integer(countsSex$Year)# PLOT MALE AND FEMALE ATHLETES OVER TIMEggplot(countsSex, aes(x=Year, y=Athletes, group=Sex, color=Sex)) +
geom_point(size=2) +
geom_line() +
transition_reveal(Year)+
scale_color_manual(values=c("deepskyblue4","red4")) +
labs(x = "Year", y = "Athletes",
title="Male and Female athletes over time",
subtitle = "Olympic Games from 1896 to 2016")
正如你所看到的，女性参加比赛的人数明显增加，然而，男性仍然占主导地位，尽管今天这种差异没有以前那么大。
奥运会 120 年——如何用 R 分析和可视化历史:男女运动员随时间的情节参与
现在你知道了如何处理数据，我邀请你继续用获得的信息进行你自己的分析，并回答许多其他有趣的问题。
非常感谢您的善意阅读。和我的大部分文章一样，我在一个 flexdashboard 中分享了用plotely生成的情节，我把它放在一起更美观一点:【https://rpubs.com/cosmoduende/olympic-games】T4
在这里你可以找到完整的代码:https://github.com/cosmoduende/r-olympic-games
感谢你坚持到最后，祝你分析非常愉快，可以把一切都付诸实践，对结果感到惊讶，和我一样开心！
EDA 分类任务的 13 个关键代码块
使用本快速指南探索机器学习分类任务的任何数据集
继我上一篇关于涵盖了回归任务(预测连续变量)的 EDA11 个代码块的文章之后，下面是在分类任务(预测分类或二元特征)上执行 EDA 的 13 个代码块。
EDA 或探索性数据分析是一个重要的机器学习步骤，它涉及到在不花费太多时间或迷失其中的情况下学习数据。在这里，您将熟悉数据集的结构和一般特征、独立和从属特征及其相互作用。您还将了解要使用的数据清理过程，以及可能的建模技术。
在本文中，我们将探索来自 Kaggle 的一个数据集，该数据集是为一家为未来员工开设培训课程的公司提供的。任务是预测参加课程的学员是否打算换工作，是否会离开目前的职位加入公司，或者即使在完成课程后，是否会留在目前的工作岗位。因此，该任务是二元任务，并且目标是 0-停留(不寻找工作变化)，以及 1-离开(寻找工作变化)
数据可从 Kaggle 页面下载，在同一页面上还有和特性定义。完整的工作流程代码在我的 GitHub 页面上的这里，所以你可以跟随。
第一步是导入我们将在整个 EDA 项目中使用的库。然后，我们读入我下载并保存在 Jupyter 笔记本相同文件夹中的train.csv。我将在训练集上执行 EDA，因为它包含目标变量，我们有兴趣了解各个特征以及它们与目标特征的关系。
- 形状(数据帧的尺寸)
DataFrame 有行和列，Pandas .shape属性返回一个长度为 2 的元组，每个值显示每个维度的长度，即(rows，columns)。
(19158, 14)
我们可以看到数据集有 19，158 行和 14 列。目标要素中的其中一列。
2。各列的数据类型
我们现在将显示所有列的数据类型。这有助于我们理解我们正在处理的数据类型，即数值分布和分类分布。这也将揭示一些探索性的情节和图表使用。
需要注意什么；
- 应该是数字的分类特征，反之亦然。
我们看到几个分类(对象)特征。我们还看到目标是浮动的，对于那些离职的人来说表示为 1.0，对于那些培训后留下来的人来说表示为 0.0。这使得target成为一个二元特征。
3。显示几行
我们现在将显示一小部分数据。我们使用df.head()显示前 5 行，df.tail()显示后 5 行，或者df.sample()从数据集中随机选取 1 行。df.sample(5)显示 5 个随机选择的行。
需要注意的事项:
- 列名有意义吗？您可以再次检查列定义。
- 列中有哪些值？它们有意义吗？
- 您能看到大量缺失值(nan)吗
- 分类特征有哪些独特的类别？
该表让我们了解了不同特性中的值，列名是不言自明的。我们可以在gender和company_size等列中看到一些重要的缺失值。
数字分布
特性的分布是指该特性中的值出现的频率。对于数值(连续)要素，值按范围分组，也称为条柱。我们将使用图来绘制分布图，并直观地了解每一列中的值。我们还将显示包含实际分布数量的实际汇总统计数据。使用图表和统计数据很重要，因为它们是相辅相成的。
4。绘制数字特征的直方图网格
直方图是一种条形图的形式，它将数字按范围分组，条形的高度显示有多少个值落在该范围内。我们将使用 Panda 的 df.hist()函数来绘制数据集中每个数字特征的直方图。我们还将传递给函数figsize=(8,8)和 xrot=45来增加网格大小并旋转 x 轴以提高可读性。
需要注意什么；
- 潜在异常值
- 应该是分类(指示)特征的数字特征。例如，如果只有两个可能的值，如 0 和 1。
- 没有意义的边界，例如大于 100 的百分比值。
作者直方图
正如所料，我们看到target，我们的依赖特性，实际上是一个只有两个可能值的指示变量；0 和 1。enrollee_id是一个 ID 列，意味着每个值只出现一次，因此在所有箱中平均分布。
5。显示数字特征的汇总统计数据
我们将使用 Panda 的df.describe()函数返回每个数字特征的分析。
需要注意什么；
count，或者列中非 NaN 值的数量。如果计数小于数据框中的所有行，则该列包含缺失(NaN)值。- 平均值，或
mean。 std，或列中值的标准偏差minimum值25th百分位值- 中位数，即
50th百分位数 75th百分位数maximum值。这也可能表示极端(异常)值。
作者描述性统计
我们看到任何列中都没有缺失值或显著的异常值。
分类特征的分布
分类特征是只包含少数唯一值的列，因此每个值属于一个特定的类或组。与数字特性一样，我们将使用图表和汇总统计数据来查看每一列中不同类的分布。
6。分类特征的汇总统计
我们将使用 Panda 的df.describe(include=’object’)，它只显示数据类型为‘object’的特性的分析。
需要注意什么；
count，即非 NaN 值的个数。如果计数小于数据帧的总行数，则存在缺失值。unique类的数量。top最普通的价值或阶级。如果多个值出现次数最多，将显示任意的top(和freq)值。- 频率(
freq)，或者顶级类出现的次数。
按作者分类的汇总统计
我们可以看到许多特性都缺少值。
7。绘制分类分布图
现在，我们将绘制分类特征，以了解每个特征的类分布情况。我们将使用 Seaborn 的计数图，它就像一个条形图，其中每个条代表一个类，高度是该类中值的数量。使用上面的汇总统计数据，我们看到一些特征，如city有许多独特的类，在绘制时可能不可读。我决定用 22 个或更少的独特类来绘制它们。
需要注意什么；
- 稀疏类—值很少的类。这些会影响模型的性能。
- 不一致的名称或错别字，如标记不同的两个类似的类。
作者的分类特征
我们现在可以看到在各种分类特征中类的分布。
按目标特征进行分段和分组
我们可以将数据分组，并观察分类特征和数字特征之间的关系，尤其是关于目标的关系。
8。根据数字特征分割目标
这里，我们将按目标特征分离数据，并观察数字特征如何在离开的人(目标= 1)和留下的人(目标= 0)之间分布。
我们将使用 Seaborn 的箱线图，它显示了一个数字特征的五个数字的摘要。这五个数字是最小值、第一个四分位数(Q1 或 25%标志)、中值(Q2)、第三个四分位数(第三季度或 75%标志)和最大值。查看这篇文章，了解更多关于方框图的信息。
作者的箱线图
需要注意的事项:
- 哪个目标类受数字特征的影响最大
首先，让我们做一些清理工作，将两个分类列转换成数字列。
动态数据清理/特征工程
我们将把experience 和last_new_job 转换成数字特征，因为它们都代表学员的经验年限。这将使我们能够看到experience是如何影响受训者决定离开还是留在当前工作岗位的。下面的代码替换一列中的一些值，然后将整个列转换为浮点数据类型(int不起作用，因为这些列有NaNs
现在我们开始创建箱线图。我们首先将感兴趣的四个数字列保存在一个名为num_cols的列表中。然后，我们将遍历这些列，根据target创建每个特征的方框图。
按作者分类的方框图
我们可以看到training_hours平均分布在留下的人(target 0)和离开的人(target 1)之间。这意味着training_hours可能而不是是一个很好的目标预测器。然而，我们看到，当涉及到experience 和last_new_job时，更大比例的留下来的人倾向于更多年的经验，这些可能是很好的预测因素。
按目标类别划分类别特征
既然我们已经看到了目标如何随着数字特征而变化，我们将对分类特征做同样的事情。
9。使用 十字标签 将各种分类特征的目标制成表格
Panda 的.crosstab(col1, col2)函数构建了一个交叉制表表，显示两个分类特征之间的关系。该表显示了来自这两个特征的数据组出现的频率。您可以包含参数normalize=’index’来显示各行之间的百分比，而不是实际数字。关于交叉标签的更多信息，请点击。让我们来看看这是怎么回事。
我将遍历 3 个分类列(具有少于 4 个唯一类的列)，并显示它们与目标关系的交叉选项卡。使用display()函数是因为在运行循环时，它显示的表格比print()更清晰。
按作者交叉标签
这些表显示了分类要素的类在目标的类中是如何分割的。让我们将这些结果形象化如下。
10。跨各种分类特征的目标计数图
我们可以画出上面的分类关系，以便更好地了解相互作用。我们将使用 Seaborn 的 [catplot()](https://seaborn.pydata.org/generated/seaborn.catplot.html)函数创建数据的计数图，并提供kind=’count’作为参数，该参数选择一个计数图作为要使用的底层轴级别函数。可以使用 catplot 创建的其他图包括盒图、条形图和小提琴图。
需要注意什么；
- 随着目标类别显著变化的分类特征。
在代码中，我们使用循环只绘制目标的 3 个分类特征。记住目标 0 离开而目标 1 留在他们的工作岗位上。请注意 catplot 中的参数sharey=False,它将每个目标类的 y 轴刻度分开，以便我们可以更好地查看和比较关系。
按作者分类的 Catplots
我们可以看到，性别类别不会因目标而发生很大变化，但目标特征在relevant_experience和enrolled_university . 之间的分布存在显著差异，我们看到没有相关经验的人离职的比例更大。我们也看到更多参加全日制课程的学生离开。这表明这两个特征是目标的良好预测器。
11。按分类特征对数字特征进行分组。
既然我们已经观察到了我们的目标是如何分布在其他输入特征中的，那么让我们检查一下类别是如何与数字特征相关联的。
我们将使用 DataFrame 的.groupby()函数将我们的数据分组，并通过计算一个度量来观察数字特征是如何分布的，例如均值、中值、和标准差跨类分布。我们将使用的度量标准是mean。我们还将提供计算平均值的列。
在这里，我们将各种特性的类与数字特性进行比较。
数字特征和其他数字特征之间的相互作用
12。各种数字特征的相关矩阵
相关性矩阵是用于总结数字特征之间关联的表格。在行和列中显示相同的特征，每个单元保存两个特征的相关系数。相关系数是对两个变量之间关系的强度的度量，可以取-1 到 1 之间的任何值。特征与其自身的相关性是 1。参考下图。
图片由 www.edugyan.in
在 python 中，计算相关性就像调用数据框的.corr()函数返回数据框中所有数值变量的成对相关系数一样简单。
花点时间浏览这些数字，然后继续往下看，看它们在热图中的可视化。
13。相关性热图
热图指的是数据的颜色编码表示，其中的值用颜色表示。我们将使用 Seaborn 热图来可视化上面的网格。
代码是sns.heatmap(corr, cmap=’RdBu_r’, annot=True, vmax=1, vmin=-1),我们传递相关矩阵corr,以及其他四个可选参数。cmap=’RdBu_r’指定热图应该使用的调色板，其中暗红色单元格显示的是强正相关，而暗蓝色显示的是强负相关。更多关于 Seaborn 的调色板这里。annot=True包括每个单元格中的系数值，而vmax=1和vmin=-1设置颜色条的边界，因为我们的相关值也落在相同的范围内。
需要注意什么；
- 高度相关的特征。这些颜色要么是深红色(强阳性)，要么是深蓝色(强阴性)。
- 目标特征的强相关性。如果任何特征与目标有很强的正相关或负相关。
作者热图
我们看到experience和last_new_job有某种程度上很强的正相关性。我们也看到了target和city_development_index之间略微微弱的负相关关系。
包裹
这就结束了我们对分类任务的探索性数据分析。我们查看了 Kaggle 上人力资源分类数据集的 EDA 项目的 13 个代码块。这些代码块对于让您从顶层理解数据集及其功能非常重要。在这里找到完整的代码。您也可以查看文章 11 回归任务的 EDA 代码块。
**</11-simple-code-blocks-for-complete-exploratory-data-analysis-eda-67c2817f56cd> **
你需要知道的 13 个有用的 Python 片段
用这些日常片段优化你的工作流程
伊夫琳·克莱门特在 Unsplash上拍摄的照片
Python 是当今广泛使用的编程语言之一，在各个领域都有应用，例如数据科学、科学计算、web 开发、游戏开发和构建桌面图形界面。Python 之所以如此受欢迎，是因为它在各个领域都很有用，与其他编程语言(如 Java、C 和 C++)相比，它的效率很高，而且它的命令也像英语一样。
假设你是数据科学或编程的新手。在这种情况下，您经常会发现有人推荐 Python 作为第一个要学习的编程语言，因为它具有易于理解的语法和更好的代码可读性，使得没有编程背景的人学习起来更加简单。
当你每天用 Python 解决挑战、开发算法、构建应用的时候，你会发现自己在一遍又一遍地重复一些任务。这就是为什么为通常执行的任务准备一些代码片段是一个很好的选择，这样您就可以在项目中随时使用它们。
我知道有很多 Python 代码片段是按字段分类的。例如，有 Python 片段，特别是用于数据科学，或者用于探索性数据分析或可视化。除了数据科学，还有游戏开发、图形界面设计和网页开发的片段。但是，在这篇文章中，我将重点放在可以用于所有这些应用程序的通用代码片段上。
列出片段
我们将从我认为 Python 最常用的数据结构列表的一些片段开始。
№1:将两个列表合并成一个字典
假设我们在 Python 中有两个列表，我们想将它们合并成一个字典形式，其中一个列表的条目作为字典的键，另一个作为值。这是用 Python 写代码时经常面临的一个很常见的问题。
但是要解决这个问题，我们需要考虑几个限制，比如两个列表的大小，两个列表中的条目类型，以及其中是否有任何重复的条目，尤其是在我们将用作键的列表中。我们可以通过使用像zip这样的内置函数来克服这个问题。
№2:将两个或多个列表合并成一个列表列表
另一个常见的任务是当我们有两个或更多的列表时，我们希望将它们收集在一个大列表中，其中较小列表的所有第一个项目构成了较大列表的第一个列表。
例如，如果我有 4 个列表[1,2,3]、[‘a’,’b’,’c’]、[‘h’,’e’,’y’]和[4,5,6]，我们想为这四个列表创建一个新列表；它将是[[1,’a’,’h’,4], [2,’b’,’e’,5], [3,’c’,’y’,6]]。
№3:对字典列表进行排序
下一组日常列表任务是排序任务。根据列表中包含的项目的数据类型，我们将遵循稍微不同的方式对它们进行排序。我们先从排序字典列表开始。
№4:对字符串列表进行排序
我们经常面对包含字符串的列表，我们需要按照字母顺序、长度或任何其他我们想要或我们的应用程序需要的因素对这些列表进行排序。
现在，我应该提到这些是排序字符串列表的简单方法，但是有时你可能需要实现你的排序算法来解决这个问题。
№5:根据另一个列表对列表进行排序
有时，我们可能希望/需要使用一个列表来对另一个列表进行排序。因此，我们将有一个数字列表(索引)和一个我想用这些索引排序的列表。
№6:将列表映射到字典
在本文中，我们要解决的最后一个与列表相关的任务是，如果给我们一个列表，并把它映射到一个字典中。也就是说，我想把我的列表转换成一个有数字键的字典。
字典片段
下面我们将讨论的数据类型是字典。
№7:合并两个或更多字典
假设我们有两个或更多的字典，我们想把它们合并成一个具有唯一键的字典。
https://gist . github . com/Saram 92/86 da 0 AE 9383 f 493 ad 5680 c8f 3021 c 039
№8:反转字典
一个非常常见的字典任务是，如果我们有一个字典，并希望翻转它的键和值。所以，键会变成值，值会变成键。
当我们这样做时，我们需要确保我没有重复的键，值可以重复，但键不能，并确保所有的新键都是可哈希的。
字符串片段
№9:使用 f 弦
格式化一个字符串可能是你几乎每天都要做的头号任务。在 Python 中有多种方法可以格式化字符串；我最喜欢的是用 f 弦。
№10:检查子字符串
我以前需要多次执行的一个非常常见的任务是检查一个字符串是否在字符串列表中。
№11:获取字符串的字节大小
有时，特别是在构建内存关键的应用程序时，我们需要知道我们的字符串使用了多少内存。幸运的是，这可以用一行代码很快完成。
输入输出操作
№12:检查文件是否存在
在数据科学和许多其他应用中，我们经常需要从文件中读取数据或向文件中写入数据。但是要做到这一点，我们需要检查一个文件是否存在。因此，我们的代码不会因错误而终止。
№13:解析电子表格
另一种非常常见的文件交互是解析电子表格中的数据。幸运的是，我们有 CSV 模块来帮助我们高效地执行这项任务。
外卖食品
作为一名计算机科学教师，我遇到了许多来自不同年龄组的人，他们都想学习编程。他们通常带着一种编程语言或他们想进入的应用领域来找我。我的年轻学生通常只想学习编程，而年长的学生则想进入特定的领域，如数据科学或 web 开发。
当我教编程时，我喜欢让事情变得简单，我发现的一个成功策略是，如果我教人们如何做基础工作并构建一些积木，他们将能够使用这些积木开发更重要的项目。从那时起，我开始收集有用的 Python 代码片段，与我的学生分享，并在我的工作中使用。
在本文中，我们一起浏览了 13 个这样的代码片段，您可以将它们添加到 snippets 数据库中，或者创建一个新的数据库。这些代码片段简单、简短、高效，无论您在哪个应用领域工作，在任何 Python 项目中，您都至少会用到其中的一个。所以我希望它们对你有所帮助。
用 Python 访问数据的 13 种方法
如何从本地文件、数据库、API 和数据访问库中获取数据到您的 Python 环境中
兰斯·格兰达尔在 Unsplash 拍摄的图片
介绍
大多数 Python 分析都是从将数据导入环境开始的。但是，如果这些数据滞留在数据库中，该怎么办呢？还是背后一个 API？还是在一堆小文件里？
幸运的是，Python 非常灵活，有很多用于访问和处理数据的开源库。在本教程中，我们将学习 13 种将数据放入熊猫数据框的方法，之后可以对数据进行清理、分析和可视化。我们可以将这些方法分为四大类:
- 本地文件
- 数据库
- 蜜蜂
- 数据集访问库
唯一的主要需求是安装pandas库:
$ pip install pandas
好了，让我们开始吧！
📁本地文件
通常，您需要的数据存储在计算机的本地文件中。根据您运行 Python 环境的位置，您可以将文件名指定为相对路径或绝对路径:
# Absolute path
file1 = "~/Users/johnreid/Documents/my_project/data/example.csv"# Relative path, assuming current working directory is my_project
file2 = "./data/example.csv"
1.CSV 文件
CSV 是存储表格数据的流行选择，也是最简单的入门方式。让我们假设您已经从数据中的我们的世界下载了这个人口数据集:
import pandas as pdcsv_file = "/Users/johnreid/Downloads/population-by-country.csv"
df_from_csv = pd.read_csv(csv_file)
df_from_csv.info()
导入数据后，运行df.info()有助于了解数据的结构，例如有多少行、列和非空值。运行该代码会产生以下输出:
这种方法也适用于通过 URL 访问的文件，比如公共 Github repo 中的公共 Google Sheet 或 CSV 文件。另外，如果你一直得到一个FileNotFoundError，那么尝试重命名你的文件名，用下划线代替空格，例如“Financial Sample.xlsx”变成“Financial_Sample.xlsx”。
2.Excel 文件
您需要对 Excel 文件更加小心，因为它们可能包含不止一张数据和复杂的视觉格式，例如额外的标题行。除此之外，语法非常相似——下面是一个财务数据的例子:
import pandas as pdexcel_file = "/Users/johnreid/Downloads/Financial_Sample.xlsx"
df_from_excel = pd.read_excel(excel_file, sheet_name = "Sheet1")
df_from_excel.info()
3.文本文件
文本文件通常需要更多的数据处理——首先看看数据是如何存储的，以及您希望如何在 Python 中表示它。从那里，您可以编写代码将文本输入转换成数据帧。让我们用一个购物清单的例子，每一行包含一个项目和数量:
要将其转换为数据帧，可以运行以下命令:
shopping_list = "/Users/johnreid/Downloads/shopping_list.txt"results = []with open(shopping_list) as f:
line = f.readline() while line:
results.append(line.strip().split(" "))
line = f.readline()f.close()df_from_textfile = pd.DataFrame(results, columns = ["Item", "Quantity"])
我们一行一行地读，去掉多余的空格，把这一行分成两部分。当我们创建一个数据帧时，我们还需要指定列名。
4.多个文件/文件夹
如果需要从多个存储的文件中提取数据会怎么样？让我们结合我们学到的一些东西，从 BBC 体育文本数据集中提取数据。
我们有 5 个子文件夹，每个大约有 100 个文件。每个文件都以标题开始，然后是文章的正文。我们的目标是将所有这些文件合并成一个具有“标题”、“副标题”、“正文”和“流派”列的单一数据框架。这里的glob库列出了所有可能的文件名，非常方便:
import glob
import pandas as pdbase_path = "/Users/johnreid/Downloads/bbcsport/"
genres = ["athletics", "cricket", "football", "rugby", "tennis"]def read_and_split_file(filename):
with open(filename, 'r', encoding="latin-1") as f:
lines = f.readlines() # Get lines as a list of strings
lines = list(map(str.strip, lines)) # Remove /n characters
lines = list(filter(None, lines)) # Remove empty strings return linesdef get_df_from_genre(path, genre):
files = glob.glob(path + genre + "/*.txt")
titles = []
subtitles = []
bodies = [] for f in files:
lines = read_and_split_file(f)
titles.append(lines[0]) # First line is the title
subtitles.append(lines[1]) # Second line is the subtitle
bodies.append(' '.join(lines[2:])) # Combine all the rest return(pd.DataFrame({
'genre': genre,
'title': titles,
'subtitle': subtitles,
'body': bodies
})
)final_df = pd.concat([get_df_from_genre(base_path, g) for g in genres])final_df
我们在 glob 中使用*操作符来获取所有可能以.txt结尾的文件名。注意，您可以使用pd.concat将多个数据帧连接在一起。运行该代码会产生以下输出:
🗄数据库
大多数组织将他们的业务关键数据存储在类似 Postgres 或 MySQL 的关系数据库中，你需要知道结构化语言来访问或更新存储在那里的数据。数据库有很多优点，比如数据标准化
5.SQLite
SQLite 是一个存储为单个文件的嵌入式数据库，所以它是开始测试查询的好地方。这里我们将展示一个连接到 Chinook 数据库的 SQLite 文件的例子:
import pandas as pd
import sqlite3 as sqlconn = sql.connect('/Users/johnreid/Downloads/chinook.db')# First pattern - turn query directly into dataframe:
df1 = pd.read_sql_query("SELECT * FROM invoice", conn)# Second pattern - get row-level data, but no column names
cur = conn.cursor()
results = cur.execute("SELECT * FROM invoice LIMIT 5").fetchall()
df2 = pd.DataFrame(results)
如果你有兴趣，可以在这里阅读我关于使用 SQL 构建交互式仪表板的完整教程:
[## 使用 SQL 和 Datapane 构建交互式 Python 仪表板
towardsdatascience.com](/building-an-interactive-python-dashboard-using-sql-and-datapane-46bd92294fd3)
6.远程数据库
连接到远程数据库(如 Postgres、Redshift 或 SQLServer)使用几乎相同的语法，但需要访问凭证。出于安全原因，最好将这些凭证存储在一个配置文件中，并将其加载到 Python 脚本中。您可以使用以下信息创建一个单独的.py文件:
host = "localhost"
database= "suppliers"
user = "postgres"
password = "SecurePas$1"
然后将其导入 Python 脚本，如下所示(您还需要psychopg2库):
import psycopg2
import configconn = psycopg2.connect(
host=config.host,
database=config.database,
user=config.user,
password=config.password)df1 = pd.read_sql_query("SELECT * FROM invoice", conn)
确保保存好你的config.py文件，不要把它上传到其他地方——你可以把它添加到你的.gitignore中，以确保它不会包含在 git 提交中。
7.SQLAlchemy
如果您想要一种更“pythonic 化”的方式来查询数据库，可以尝试一下 SQLAlchemy 库，它是一个对象关系映射器。它通常用于应用程序，这样开发人员就不必编写纯 SQL 来更新他们的数据库，但是您也可以使用它来查询数据！
下面是一个使用相同 Chinook 音乐商店数据库的示例:
import sqlalchemy as dbengine = db.create_engine('sqlite:///chinook.db')
connection = engine.connect()
metadata = db.MetaData()invoice = db.Table('invoice', metadata, autoload=True, autoload_with=engine)# Get the first 10 invoices from the USA
query = (db.select([invoice])
.filter_by(billing_country = 'USA')
.limit(10)
)df = pd.read_sql(query, engine)
在这段代码中，我们连接到数据库，然后在 SQLAlchemy 中设置一些表和元数据。一旦定义好了，我们就可以用一种更“pythonic 化”的方式编写一个查询，并将结果直接读取到 Pandas 数据帧中。运行该代码会产生以下输出:
📶蜜蜂
有时候，你需要从你公司使用的特定平台获取数据，比如 Hubspot、Twitter 或 Trello。这些平台通常有一个公共 API，您可以直接在 Python 环境中从中提取数据。
基本思想是向端点发送一个请求(可能包括查询参数和访问凭证)。该端点将返回一个响应代码和您请求的数据(希望如此)。您需要查看 API 文档来了解哪些数据字段是可用的。数据通常以 JSON 格式返回，这允许深度嵌套的数据。
8。没有证件
让我们使用 OpenNotify API 来做一个最小的例子，它跟踪当前在空间中的所有人:
import requestsresponse = requests.get("http://api.open-notify.org/astros.json")print(response.status_code)
print(response.json())res = pd.DataFrame(response.json()["people"])res.head()
运行该代码会产生以下输出:
响应代码告诉您 API 调用的结果——根据 Dataquest 最常见的是:
- 一切顺利，结果已经返回(如果有的话)。
301:服务器正在将您重定向到不同的端点。当公司切换域名或端点名称更改时，可能会发生这种情况。400:服务器认为你提出了一个错误的请求。当你没有发送正确的数据时，就会发生这种情况。403:你试图访问的资源被禁止:你没有查看它的权限。404:在服务器上找不到您试图访问的资源。503:服务器未准备好处理请求。
9.使用凭据和查询参数
有时您可能需要来自 API 的更具体的信息，或者必须进行身份验证。有几种方法可以做到这一点，但是最常用的一种方法是在请求中添加 URL 参数。
假设我们有一个包含 API 密钥的config.py文件:
personal_api_key = "wouldntyouliketoknow"
然后我们为所有的参数创建一个字典(这是一个虚构的例子)并传递它:
import config
import pandas as pd
import requestsparameters = {
"personal_api_key": config.personal_api_key,
"date": "2021-09-22"
}response = requests.get(url, params = parameters)
print(response.status_code)
print(response.json())
res = pd.DataFrame(response.json()["people"])
res.head()
如果你不想处理 JSON，你可以尝试搜索该 API 的 Python 库——这些库通常是开源的，由公司或第三方维护。
📚数据集访问库
如果您需要一些参考数据来进行比较或添加上下文，该怎么办？有许多库可以将公共数据集直接下载到您的环境中——可以把它想象成从 API 中提取，而不必管理所有额外的复杂性。
10.熊猫 _datareader
Pandas_datareader 是一种将数据从互联网提取到 Python 环境中的好方法。它特别适合金融数据，但也有一些世界银行的数据源。要了解 Zoom 过去几年的每日股价，请尝试以下方法:
from pandas_datareader import data
import datetime as dtzm = data.DataReader(
"ZM",
start='2019-1-1',
end=dt.datetime.today(),
data_source='yahoo'
).reset_index()zm.head()
运行该代码会产生以下输出:
11.数据共享
Datacommons 是谷歌的一个项目，提供对标准化和清洁的公共数据集的访问。底层数据以图表的形式呈现，这使得查询和连接来自许多不同数据源的数据变得非常容易，例如美国人口普查局、世界银行、维基百科、疾病控制中心等等。这里有一个基本的例子:
!pip install datacommons datacommons_pandas --upgrade --quietimport datacommons_pandas as dc
import pandas as pdcity_dcids = dc.get_property_values(["CDC500_City"], "member", limit=500)["CDC500_City"]cdc500_df = dc.build_multivariate_dataframe(
city_dcids,
["Percent_Person_Obesity", # Prevalence of obesity from CDC
"Median_Income_Person",
"Median_Age_Person",
"UnemploymentRate_Person", # Unemployment rate from BLS
"Count_Person_BelowPovertyLevelInThePast12Months", # Persons living below the poverty line from Census
"Count_Person", # Total population from Census
],
)cdc500_df.info()
运行该代码会得到以下结果:
如果你想学习如何使用 DataCommons，请在这里阅读我的完整教程:
12.PyTrends(谷歌趋势)
PyTrends 是一个非官方但很有用的库，用于查询 Google Trends 数据——这里有一个简单的例子:
import pandas as pdfrom pytrends.request import TrendReqpytrends = TrendReq()
keywords = ["oat milk", "soy milk", "almond milk"]pytrends.build_payload(keywords, cat=0, geo='', gprop='') # Get data from the last 5 yearstop_queries = pytrends.interest_over_time()[keywords]top_queries.head()
运行该代码会产生以下输出:
13.卡格尔
Kaggle 是一个数据科学社区，它拥有大量学习 Python 的数据集和竞赛。您可以通过命令行界面下载其中的一些数据集进行实验(注意:您需要注册一个 Kaggle 帐户)。例如，假设我们想要下载一些 Zillow economics 数据，我们可以在我们的终端中运行以下命令(Jupyter 用户:用 Python 代码中的!替换$:
$ pip install kaggle
$ export KAGGLE_USERNAME=datadinosaur
$ export KAGGLE_KEY=xxxxxxxxxxxxxx
$ kaggle datasets download zillow/zecon
$ unzip zecon.zip
这将下载数据集的压缩文件，然后解压缩它们。从那里，您可以将它们作为熊猫的本地文件打开:
import pandas as pdcsv_file = "/Users/johnreid/Downloads/Zip_time_series.csv"
df_from_csv = pd.read_csv(csv_file)
df_from_csv.info()
要了解更多信息，请查看 Kaggle API 文档。
结论
图片来自 Giphy
你成功了！现在，您可以使用新获得的能力来访问多个数据源，并使用pd.merge或pd.concat将它们连接在一起，然后使用 Altair、Pandas 或 leav 等交互式库来可视化它们。
有没有我漏掉的方法？请在评论中告诉我。
选择聊天机器人解决方案的 14 个标准
选择自然语言会话辅助解决方案时，首先要考虑的标准是什么？
威廉·沃比在 Unsplash 上的照片
介绍
对话协助解决方案的实现是一个业务决策，而不是技术决策。当以自然语言执行的辅助活动是重复的和/或简单的并且因此容易自动化时，做出该决定。例如回答 IT 支持问题、在个人档案中归档支持文档、了解订单状态或了解产品信息。
自动化这些请求的主要目的是释放代理的时间来响应更复杂的需求，或者只是允许他们处理来自用户的大量问题。
其他几个好处可以补充这一目标:
- 标准答案可根据对话者使用信息系统中的数据进行定制(如订单状态、银行余额、支持文件的存款…)，
- 全天候可用性，允许在呼叫中心工作时间之外提供支持，
- 几乎即时的响应能力，无需等待代理的可用性，
- 公司的现代形象受到最新技术的启发，并适应新的信息消费行为。
一旦正确确定了要涵盖的业务领域，就有必要选择一个解决方案来完成这一辅助工作。当您想做到面面俱到，并且知道目前市场上有数百种不同的解决方案时，这个决定并不简单。
构建决策矩阵是帮助选择软件程序的最佳方法。它包括一个由相关性加权的标准列表(一个通常在 0 到 5 之间的数字)和一个要研究的解决方案列表。对每个解决方案的每个标准进行评分。加权标准的所有分数的总和给出了解决方案相对于其他解决方案的评估。由于辅助解决方案的功能丰富，一个完整的决策矩阵可以包括数百个标准，如果必须对当今市场上的所有解决方案进行分析，这将是一个天文数字的分析时间。
我的列表的目的是为您提供快速区分待详细研究的 5-10 种解决方案的方法。
标准 1:专业领域
这第一个标准既是最重要的标准之一，也是最难评估的标准。在过去的几年中，会话辅助解决方案市场发生了变化，出现了专门针对特定业务领域的解决方案:例如，银行、保险、人力资源、电子商务(电子商务和零售)…这些解决方案预先配置了一系列意图、实体和对话/响应，能够减少创建工作，从而降低成本并加快聊天机器人的部署。然而，至少要确保答案符合公司的实践。此外，将特定意图添加到公司中总是必要的。
在高度管制和立法的领域，这些解决方案带来的优势是不可否认的，将节省大量的时间。在更开放和变化的领域，这种优势要弱得多，不应该对最终的选择非常具有决定性。
市场解决方案的主要专业领域
通用解决方案可适用于所有配置，但需要更多配置工作。
标准 2:用户语言
用户语言是用户说的语言，聊天机器人必须理解这些语言才能触发正确的响应场景。用户的良好知识在这里很重要，因为有必要能够将每种语言的使用百分比联系起来。
事实上，维护一种语言是相对昂贵的，因为每种语言都有一整套数据要适应:要检测的话语(通过意图)、对话树中的不同问题以及所有答案的翻译。在低容量的情况下，必须询问维护“稀有”语言的相关性:要么像其他语言一样管理它，并支付相关费用，要么用替代语言替换它，要么必须保持当前的支持。
标准 3:对话的复杂性
当设计响应场景时，定义如何响应是很重要的。答案可以是提供一个简单的答案，也可以是提供一个复杂的对话，其中包括提出一系列问题以及在第三方应用程序中搜索信息。在第一种情况下，静态或动态 FAQ 解决方案可能就足够了。在第二种情况下，要选择的解决方案应该提供创建具有多个分支的复杂对话、管理上下文、与第三方应用程序集成的能力……这个标准必须与不同级别的场景比例相权衡。
对话复杂性等级的 4 个级别
一个有很多对话树的聊天机器人需要一个解决方案来管理这些树的复杂性。一些解决方案允许通过编程或使用技巧来规避功能的缺乏。因此，重要的是要估计创建和维护的工作量，如果必要的话，必须实现这些工作量来弥补这些功能的缺失。
标准 4:容量法
必须考虑两种容量法:
- 对话量，即潜在用户的数量和他们每月提出的请求的数量，
- 管理意图的数量，即聊天机器人必须管理的问题的数量。
对于交换的数量(以及超出平台处理负载的能力)，这是企业分析必须评估的数千甚至数百万次对话的能力，因此也是解决方案提供这种帮助的能力。
对于意向量，这是解决方案在参数设置方面促进该量的管理的能力，即管理数百个不同场景的能力。许多解决方案易于在几十种场景中使用，但无法扩展。
当这两种类型与高容量相结合时，即每月数百个意图和数万个对话，管理界面的质量和 AI 的性能在解决方案的选择中变得占优势。
解决方案的复杂程度取决于数量
标准 5:业务可访问性
这个标准背后的问题是:哪些团队将配置解决方案？哪些团队将维护解决方案？团队的技术技能是什么(开发、逻辑……)？
如果选择创建和维护聊天机器人的团队不是技术人员，则需要一个用户友好的图形用户界面。如果大部分配置是以图形方式完成的，则对话框的配置会更容易。允许管理多个管理角色也是该标准的一部分。
标准 6:人工智能调整
目前市场上存在三种主要技术:按钮导航、基于关键字的需求检测和由人工智能(AI)算法完成的自然语言处理(NLP)。第一种和第二种技术对小实例有效，但 AI 每天都在展示它对大量数据(大量意图、大量对话)的性能。在前两种情况下，AI 调整不是判别标准。
通过调整 AI，我们指的是微调 NLP 单元的能力:意图分类、实体提取、语法树的分解……当项目需要精确理解请求时，可能有必要拥有直接干预这个 AI 的能力。
当项目的一部分由数据科学家技术人员和机器学习(ML)工程师团队管理时，他们将需要能够完成这一细化工作的能力。然后，解决方案必须能够管理经过专门训练的模型的参数化和部署步骤。当解决方案完全由企业管理时，这些改进必须自动处理，或者至少通过简单的解释和指导来处理。
标准 7:基础设施
解决方案本地化的不同方法有:
- 托管基础架构模式下的云中。基础设施维护完全由解决方案提供商或获得此任务授权的第三方执行。该解决方案可以是多租户(允许通过同一个数据库管理多个 Bot)或单租户(一个 Bot = 1 个数据库)。该解决方案可以在专用/私有云上以 SaaS ( 【软件即服务】模式提供；
- 在公司现场(现场)。维护由公司的内部团队在自己的基础设施上进行。这种方法保证了处理和数据的严格保密性；
- 一部分在公司的网站上，一部分在 SaaS 模式的云中。这种混合方法将处理的一部分与解决方案的其余部分分开。例如:Livechat 的管理(让用户与可用代理联系的模块)、NLP 部分等等。
此标准应与本地团队运营解决方案的能力和技能(包括相关的基础架构成本)结合起来考虑。并非市场上的所有解决方案都支持按需本地化。
标准 8:用户界面
用户界面是请求者与聊天机器人交互的通道。该接口可以是:
- 一个模拟代理的脸(有时是身体)的虚拟角色(或多或少真实)。可以表达与对话相关的情绪(或多或少)。交流是通过语言和视觉进行的。这里寻求的是移情的一面。很快就有可能出现能够代表品牌与顾客互动的avastar(明星的化身)？
- 电话线(呼叫机器人或电话机器人)。通信通过语音通道进行，可以通过电子邮件或 SMS 发送元素来完成；
- 语音信箱(例如 Google Home、亚马逊 Alexa……)。该盒子通常与连接到该盒子的特定解决方案相关联，并且当用户有需求时，他必须明确地选择该公司的服务；
- 通过短信打电话；
- 一个社交网络。用户使用社交网络的能力来与聊天机器人通信；
- 对话窗口(或弹出窗口，也称为 webchat)。交流是通过公司网站上的一个小窗口进行的；
- 在不久的将来，直接思考。
该解决方案应促进所考虑的通道的集成。通常，解决方案附带预配置的连接器，只需点击几下鼠标即可安装。对于电话线，解决方案可能会建议一个电话号码或与公司的电话交换机(PBX)集成。每个社交网络都有自己的特性，这些特性必须反映在管理界面中。
默认情况下，解决方案通常有一个适用于任何接口的标准连接器。然而，连接器和相关配置元素的存在是一个好的实践(例如，Twitter 不接受图像)。
这里没有提到电子邮件作为一个接口，因为它通常是一个复杂而长的文本(礼貌用语、演示、上下文、请求、附件……)，因此与其他解决方案以不同的方式处理。
标准 9:一体化
富对话是一种考虑到“活”数据和用户数据(如果可能)的对话。然后，解决方案必须能够与第三方应用程序连接:
- 识别和认证系统；
- 支持相关系统，如实时聊天、信息系统、ITSM (IT 服务管理)；
- 与所涵盖的业务环境相关的系统，如:CRM(客户关系管理)、ERP(企业资源规划)、 HR(人力资源)软件、银行软件、DMS(文件管理系统)、 CMS(内容管理系统)…
- RPA(机器人过程自动化)系统对应用程序执行手动操作。
一些解决方案提供了方便集成工作的现成连接器。否则，系统必须至少有调用外部服务的方法(以 Webhook 或 REST API 设置的形式)。
标准 10:可逆性
一个解决方案的可逆性是它能够提供数据提取以用于另一个解决方案。迄今为止，还没有国际标准为解决方案之间的互操作性定义标准格式。因此，至少，解决方案必须能够授权以“可读”的格式(JSON、XML、CSV……)导出数据。必须能够输出最大量的配置数据:意图、实体、知识、对话树…
标准 11:定价模式/许可
向导解决方案的定价模式因编辑器而异:
- 每次对话的价格，
- 转换价格(电子商务)，
- 指定用户的数量，
- 当月活跃用户数(MAU 代表每月活跃用户数)，
- 每月或每年的使用套餐，
- 固定价格许可和维护(通常与现场安装相关联)，
- 全部或部分免费(有条件)。
每种价格模式都有其优点和缺点。要确定价格是否“可接受”，预计的每月成本应该与解决方案的收益相匹配。
标准 12:可持续性
这个标准指的是发行商和/或开源解决方案的长期持久性。
会话协助解决方案提供商的持久性取决于其在这个竞争异常激烈的世界中的生存能力。选择大型编辑器(大量参考资料、云的主要参与者、庞大的解决方案组合、包含在更大的软件中……)是可持续性的保证，但也是成为 lambda 客户的风险。选择一个小的出版商，或者一个初创企业，通常是保证一个定制的服务。缺点是有可能成为其最大的客户，甚至是其第一个客户。
在这个市场中，公司的规模很重要，因为迄今为止，85%已经死亡的出版商只有 1 到 10 名员工。对于初创公司来说，与管理层会面是验证财务可行性、感受真正的决策者以及检查长期解决方案愿景(路线图)的重要环节。
即使开源不一定意味着免费(查看许可证)，它的优势也是多方面的:代码的可审计性，通常是一个爱好者社区，免费使用，创新的前沿……另一方面，可持续性没有保证，因为当前的热情很可能会转向更有趣、更创新和更有前途的新解决方案。尽管如此，您仍然可以继续使用该解决方案，但缺点是必须单独维护它。
标准 13:行政人员的语言
这是解决方案用户通过管理界面使用的语言。他们需要了解要配置的各种参数，并能够阅读解决方案的文档。大多数国际解决方案通常都有英文文档。
就语言而言，您还必须包括发布者的本地化以及负责支持解决方案的人员所使用的语言。在重要的情况下，拥有会说你的语言的人是至关重要的。
标准 14:保密性和安全性
最后一个标准与交换的数据有关，特别是用户和聊天机器人之间的对话。对于高度机密的关键情况，可能有必要通过代码审核或认证来确保没有信息泄漏。
对于在欧盟使用聊天机器人，遵守 GDPR 标准(通用数据保护条例)是的必要条件。
结论
这篇文章提出了几个判别标准，可以让你相对快速和低成本地预先选择会话协助解决方案。当然，这是第一级方法，这些标准中的每一个都需要在以后详细说明。您也可以自由添加您认为重要的其他标准，记住不要在第一种方法中涉及太多细节。
然后，您可以自由选择单个解决方案或 2-3 个解决方案，然后在要涵盖的业务领域中进行测试。测试将包括实现代表要执行的不同场景的请求。
了解更多信息
对于会话助理市场的概述:
关于对话的复杂性:
数据科学家和工程师必备的 14 个 pip 命令
探索一些对日常编程最有用的 pip 命令
介绍
即使 Python 标准库提供了广泛的工具和功能，开发人员仍然需要使用广泛可用的外部(标准库)包。大多数编程语言都有标准的包管理器，允许用户管理他们项目的依赖关系。
Python 中最常用的包管理器肯定是pip。在今天的文章中，我们将探索一些有用的pip命令，您可以使用它们来正确地管理 Python 项目的依赖性。
皮普是什么
pip是一个 Python 包管理器，支持安装不包含在该语言标准库中的包。相当于 JavaScript 的npm或者. NET 的NuGet
Python 是最流行的编程语言之一，当涉及到开发服务于特定目的的包时，它的社区非常活跃。这些包通常上传到 Python 包索引(PyPI)上。默认情况下，pip使用 PyPI 作为解析特定应用程序所需的所有依赖项的来源。
如果您想知道如何分发您自己的 Python 项目并使它们广泛可用，请务必阅读下面的指南。
[## 如何将 Python 包上传到 PyPI
towardsdatascience.com](/how-to-upload-your-python-package-to-pypi-de1b363a1b3)
如果您使用的是 Python 2 >=2.7.9 或 Python 3 >=3.4，那么pip应该已经安装在您的机器上了。如果您在使用venv或virtualenv创建的虚拟环境中工作，同样适用。
用于日常编程的 14 个 pip 命令
在接下来的章节中，我们将讨论 14 个常用的pip命令，每个 Python 开发人员都必须了解这些命令。请注意，强烈建议您为每个 Python 项目创建一个单独的虚拟环境，在其中您将能够安装和管理所有必需的依赖项。
1.安装软件包
为了在您当前的环境中安装一个包，您需要运行pip install,除了包本身，它还将安装它所有的依赖项。
$ python3 -m pip install package_name
2.卸载软件包
如果出于任何原因你想卸载一个软件包，你必须使用pip uninstall命令。
$ python3 -m pip uninstall package_name
但是请注意，这个命令不会卸载这个包的依赖项。如果出于某种原因，您也希望卸载未使用的依赖项，那么看看您可以使用的[pip-autoremove](https://github.com/invl/pip-autoremove)。
3.从需求文件安装依赖项
现在让我们假设您有一个requirements.txt,它列出了一个特定包所需的所有依赖项。
# requirements.txt
pandas==1.0.0
pyspark
您可以使用下面显示的命令直接从该文件安装所有的依赖项，而不是一个一个地检查包。
$ python3 -m pip install -r requirements.txt
4.列出已安装的软件包
如果你想列出一个环境中安装的所有 Python 包，pip list命令就是你要找的。
$ python3 -m pip list
该命令将返回所有已安装的软件包，以及它们的特定版本和位置。
Package Version Location
---------------------- ----------------- -------------
pandas 1.0.0
pyspark 2.1.0
如果从远程主机(例如 PyPI 或 Nexus)安装软件包，该位置将为空。当从计算机上的某个位置安装软件包时，该特定位置将列在输出的相应列中。
如果需要，你甚至可以使用pip list命令来获取特定包的版本。您可以使用
$ python3 -m pip list | grep package_name
5.自动创建 requirements.txt
在开发 Python 应用程序时，您可能需要安装其他依赖项，这些依赖项将帮助您实现您需要的任何功能。不必在一个requirements.txt文件中一个接一个地编写包，这样其他人也可以在使用你的包时安装所需的依赖项，你可以使用pip freeze在你的环境中安装所有的包。
$ python3 -m pip freeze > requirements.txt
请注意，该命令还将对您已经安装在您的环境中的软件包的特定版本进行硬编码(例如pandas==1.0.0)，这在某些情况下可能不是您真正想要的。在这种情况下，您可能需要手动删除或修改版本。
6.在可编辑模式下安装软件包
现在，如果你正在本地开发一个包，你可能必须在可编辑模式下安装它。这意味着安装会将软件包链接到指定的本地位置，这样对软件包所做的任何更改都会直接反映到您的环境中。
$ cd /path/to/your/local/python/package
$ python3 -m pip install -e .
以上命令将以editable(或develop)模式将软件包安装在当前目录中。现在，如果您运行pip list | grep package_name，包的位置应该映射到您本地机器上的位置(例如path/to/your/local/python/package)。
7.升级软件包
如果您安装的某个软件包已经过时，并且您希望升级它(总是推荐，但是这可能会破坏与其他软件包的兼容性)，您可以通过运行
$ python3 -m pip install package_name --upgrade
8.删除 pip 安装的所有软件包
现在，如果出于某种原因你想删除 pip 安装的所有软件包，那么你可以运行下面的命令，用现有的已安装软件包创建一个中间的requirements.txt文件，然后用pip uninstall卸载所有的软件包。
$ python3 -m pip freeze > requirements.txt && python3 -m pip uninstall -r requirements.txt -y
如果您想跳过任何中间文件(即requirements.txt)的创建，那么您可以运行下面的命令。
$ python3 -m pip uninstall -y -r <(pip freeze)
9.检查已安装的软件包是否兼容
$ python3 -m pip check
如果没有发现兼容性问题，该命令的输出将是
No broken requirements found.
10.获取特定包的信息
如果你想检索关于一个特定包的信息，pip show将返回详细信息，如名称、版本、概要、许可证、依赖关系等。
$ python3 -m pip show package_name
pandas的输出示例如下所示:
**$ pip show pandas**Name: pandas
Version: 1.2.3
Summary: Powerful data structures for data analysis, time series, and statistics
Home-page: [https://pandas.pydata.org](https://pandas.pydata.org)
Author: None
Author-email: None
License: BSD
Location: /path/to/lib/python3.6/site-packages
Requires: pytz, python-dateutil, numpy
Required-by: shap, seaborn
11.搜索 PyPI 包
正如我们已经提到的，pip使用 PyPI 作为它检索包的默认来源。pip search命令用于搜索索引并识别与搜索词匹配的包。
$ python3 -m pip search <search_term>
例如，python3 -m pip search pandas将返回满足搜索词pandas的所有包。
12.为您的需求和依赖关系构建 Wheel 档案。
Wheels 是 Python 生态系统的一部分，它是内置的包格式，提供了在每次安装时不重新编译软件的优势。pip wheel命令用于为您的需求和依赖项构建 Wheel 档案。
$ python3 -m pip wheel
注意 pip 使用来自wheel包的bdist_wheel setuptools 扩展来构建单独的轮子。
13.管理本地和全局配置
pip自带配置，显然可以根据您的使用需求进行修改。pip带有config选项，允许使用edit、get、list、set或unset配置。
$ python3 -m pip config <action name>
例如，要列出启用的配置选项，可以运行
$ python3 -m pip config list
为了设置特定的配置选项，那么可以使用set方法。例如，如果您需要更改global.index配置参数，您必须运行
$ python3 -m pip config set global.index-url https://your.global.index
14.显示调试信息
现在，如果您想检索特定于 pip 的调试信息，您可以使用pip debug。该命令将返回与 pip 安装和本地系统环境相关的信息。
$ python3 -m pip debug
请注意，此命令仅用于调试，因此您不得在生产工作流程中使用它来解析或推断细节，因为该命令的输出可能会在没有通知的情况下发生变化。
最后的想法
在今天的文章中，我们快速了解了 Python 中最常用的包管理器pip。此外，我们引入了 Python 包索引(或 PyPI ),它托管了 Python 开发人员可用的所有第三方包。最后，我们探讨了 14 个不同的pip命令，为了正确管理依赖关系，您一定要知道这些命令。
对于pip选项的完整列表，只需在您的终端中运行pip --help，该命令将返回使用信息。
Usage:pip <command> [options]Commands:
install Install packages.
download Download packages.
uninstall Uninstall packages.
freeze Output installed packages in requirements format.
list List installed packages.
show Show information about installed packages.
check Verify installed packages have compatible dependencies.
config Manage local and global configuration.
search Search PyPI for packages.
cache Inspect and manage pip's wheel cache.
wheel Build wheels from your requirements.
hash Compute hashes of package archives.
completion A helper command used for command completion.
debug Show information useful for debugging.
help Show help for commands.
每个数据科学家都必须知道的 14 个熊猫操作！
关于 14 个最基本的熊猫操作的完整指南，将帮助开发人员轻松完成大多数数据科学项目
锡德·巴拉钱德朗在 Unsplash 上拍摄的照片
理解数据科学家可用的数据是数据科学最重要的方面。只有具备正确的数据知识和完成所需任务的适当数据，您才能获得最成功的结果。在数据科学中，数据的分析、可视化和操作非常重要。
在 Python 的帮助下，关于机器学习和数据科学的一切都变得极其简单。我们可以利用 Python 中一些最好的库来轻松完成任何想要的操作。一个这样的库允许我们分析和处理数据，以降低复杂性并加快计算问题的过程，这就是 熊猫 。
Pandas 库是 Python 中用于数据分析过程的最佳特性之一。您可以轻松执行各种任务。在本文中，我们将探讨每个数据科学家必须利用的不同类型的操作，以完成特定的项目，同时利用最少的资源，实现最高的效率。
建议阅读本指南的用户使用 Jupyter 笔记本来阅读本文中提到的大部分代码，以获得最佳体验。如果您不确定 Jupyter 笔记本的概念，请查看下面提供的链接，了解您需要了解的关于 Jupyter 笔记本以及如何有效利用它们的几乎所有信息。
在接下来的章节中，让我们开始探索数据科学家可以在 Pandas 库中使用的每一个功能和操作。
1.创建熊猫数据框:
### Creating a dataframe
import pandas as pddataset = {'Fruits': ["Apple", "Mango", "Grapes", "Strawberry", "Oranges"], 'Supply': [30, 15, 10, 25, 20]}# Create DataFrame
df = pd.DataFrame(dataset)
# Print the output.
df
作者图片
在 Pandas 库的帮助下，用户可以轻松创建新的数据框。熊猫图书馆允许用户以最美观的方式为数据分析和可视化创建新的材料。它允许开发人员清楚地了解他们正在工作或处理的数据的类型和格式。
尽管创建数据框的过程可以通过多种方式完成，但创建数据框的最佳方式之一是上面显示的以下代码中提到的方式。这里，我们正在导入 Pandas 框架并定义我们的数据集。dataset 变量包含一个所有元素的字典，关键字为 fruits 和 supply。
最后，您可以使用 Pandas 模块中可用的 DataFrame 函数来构建数据集，并以理想的格式存储它。在 just 列表的帮助下，下面的过程也是可能的。要了解更多关于词典的知识以及如何掌握它们，我推荐你从下面提到的链接中查阅我以前的一篇文章。
2.读取 CSV 文件:
# Importing the framework
import pandas as pd# Reading a random csv file and displaying first five elements
data = pd.read_csv("name.csv")
data.head()
在熊猫图书馆的帮助下，轻松阅读以不同格式存储的数据成为可能。存储与数据科学相关的大多数信息的最常见格式之一是。CSV 格式。在 Pandas 框架中的 read csv 命令的帮助下，人们可以很容易地阅读以特定格式存储的所有复杂和基本的细节。
除了逗号分隔值(CSV)格式之外，Pandas 库还支持 XLSX 文件、. zip 文件、JSON 文件、文本文件、HTML 文件、PDF 和 DOCx 文件以及分层数据格式。你可以通过 Pandas 库访问所有这些格式，并相应地操作它们。
3.阅读顶部元素图表:
# print the first couple of elements
df.head(2)
作者图片
在接下来的几节中，我们将了解两个基本的熊猫操作的细节。其中一个函数是 head()操作，它将默认显示前五个元素。您可以指定想要在函数中查看的元素数量，您将收到您请求的前“n”个条目。这个函数对于理解数据的基本架构很重要，但不需要深入了解数据的复杂细节。
4.阅读底部元素图表:
# print the last couple of elements
df.tail(2)
作者图片
与 head 函数类似，我们可以利用 tail()操作来读取给定数据集的最后几个数据元素。尾巴功能可以让我们快速掌握一些事情的想法。首先，我们可以用一个快捷的命令获得元素的总数。我们还可以使用这个命令来确定和验证任何其他前面的排序或附加操作，以确保正确遵循前面的过程。
5.了解数据的统计信息:
# Understand all the essential features
df.describe()
作者图片
在 Pandas 库框架的帮助下，可以可视化最基本的统计信息。Pandas 中的 describe 函数()将允许我们从数据帧中接收所有重要的统计数据。这些参数包括数据集中存在的元素总数、整个数据的平均值、最小值和最大值、各自的四分位数以及计算的标准偏差。
借助于通过一个命令收集的所有这些关键信息，我们可以利用这些统计数据来简化我们的整体数据分析过程。有了这些数据，我们还可以了解哪些是可以探索的最佳可视化技术。要了解构建数据科学项目时必须考虑的八种最佳可视化方法的更多信息，请查看下面的文章。
</8-best-visualizations-to-consider-for-your-data-science-projects-b9ace21564a>
6.编写 CSV 文件:
# Create DataFrame
dataset = {'Fruits': ["Apple", "Mango", "Grapes", "Strawberry", "Oranges"], 'Supply': [30, 15, 10, 25, 20]}
df = pd.DataFrame(dataset)# Writing the CSV File
df.to_csv('Fruits.csv')
作者图片
在 Pandas 库的帮助下，用户还可以创建和编写新的数据框，并将其保存为所需的文件格式。Pandas 库允许类似于前面讨论的读取 CSV 文件部分的保存格式。上面提到的以下代码块会将创建的数据框保存到一个. CSV 文件中。一旦您从保存该文件的相应目录中打开该文件，您应该会找到包含以下信息的 CSV 文件，如上图所示。
7.合并值:
### Creating a dataframe
import pandas as pddataset1 = {'Fruits': ["Apple", "Mango", "Grapes", "Strawberry", "Oranges"], 'Supply': [30, 15, 10, 25, 20]}
dataset2 = {'Fruits': ["Melons", "Pear"], 'Supply': [10, 20]}# Create DataFrame
df1 = pd.DataFrame(dataset1)
df2 = pd.DataFrame(dataset2)
# Print the output.
df1.merge(df2, how = "outer")
作者图片
假设我们有两个或更多的数据集，并且您想要将它们组合在一起作为一个单独的实体。在 Pandas 框架的帮助下，我们可以利用该库中可用的 merge 命令操作将所有数据帧和单个元素组合成一个实体或数据帧。上面显示的代码块很好地展示了如何执行下面的操作。
在上面的代码块中，我们声明了两个不同的数据帧，它们本身是两个不同的实体。在 Pandas 函数 merge()和它们应该如何组合的规范的帮助下，我们已经创建了特定的组合数据框。可以改变和试验 how 参数。一些选项是左，右，交叉，以及我们在上面的代码中使用的外部函数。
8.对值进行分组:
import pandas as pddataset = {'Fruits': ["Apple", "Mango", "Grapes", "Strawberry", "Oranges"], 'Supply': [30, 15, 10, 25, 20]}df = pd.DataFrame(dataset)a = df.groupby('Fruits')
a.first()
作者图片
Pandas 库的另一个令人惊奇的功能是以一种更可展示的方式将元素组合在一起。在前面几节中我们多次使用的创建的数据框中，我们可以注意到我们有一个索引列，后面跟着其他列。
然而，我们可以在 Pandas 中使用 groupby()函数，以更简洁的方式分离和可视化这些元素，以显示更重要的功能。上面的代码块和图像表示向我们展示了如何相应地完成这个过程以获得以下结果。
9.访问特定的行和列:
# Access specific rows and columns by specific positions
df.iloc[1:4, [0]]
作者图片
在 Pandas 库的帮助下，用户可以在 iloc 操作的帮助下轻松访问他们想要的任何特定元素。iloc 命令用于按指定位置选择行和列的单个值。在上面的代码块中，我们可以指定必须在第一列旁边显示的行数(在本例中为三行)。
10.通过标签访问:
# Access specific rows and columns by specific labels
df.loc[1:3, ['Supply']]
作者图片
类似于您如何在位置的帮助下访问特定的元素需求，您也可以利用特定的标签来访问您想要的任何列。在 Pandas 库中，我们可以利用 loc 命令来选择某一行和某一列的单个值，通过指定的标签。上面指定的代码块用于访问标记为 0 的行到列名指定为 supply 的第三行。
11.对数据框中的值进行排序:
import pandas as pddataset = {'Fruits': ["Apple", "Mango", "Grapes", "Strawberry", "Oranges"], 'Supply': [30, 15, 10, 25, 20]}
df = pd.DataFrame(dataset)df.sort_values(by = ["Supply"])
作者图片
Pandas 库还允许用户对他们的数据进行相应的排序，类似于列表这样的数据结构。我们可以向您推荐 Pandas 中可用的排序值功能，并提及您希望对整个数据集进行排序并按其各自的升序排列的特定列。如果你想了解更多关于掌握列表和与列表相关的大多数操作，请查看下面提到的文章。
12.应用特定计算:
import pandas as pd
import numpy as npdf = pd.DataFrame([[4, 9]] * 3, columns=['A', 'B'])
df.apply(np.mean, axis=1)
Pandas 库中的 apply 函数将允许开发人员在特定的轴上应用任何类型的特定计算，例如一个等于零的轴或一个等于一的轴。我们可以应用许多 numpy 运算，例如计算平均值的 mean、计算总和的 sum、数字的平方根以及许多其他类似的运算。最终的返回类型是从应用函数的返回类型中推断出来的。否则，它取决于结果类型参数。有关此操作的更多信息，请查看以下参考。
13.时间表达式:
import pandas as pdpd.Timedelta('6 days 3 hours 20 minutes 15 seconds')
输出:时间增量(' 6 天 03:20:15 ')
Pandas 库框架允许用户使用多种与时间相关的表达式。时间增量运算将专门计算可以用不同单位表示的时间差。时间可以用天、小时、分钟和秒来显示，如上面的代码块所示。您可以使用 Pandas 中的时间模块执行多种其他操作，例如添加时间。关于文章这一部分的更多信息，请查看下面的网站。
14.用熊猫绘制图表:
import pandas as pd
import numpy as npdf = pd.DataFrame(np.random.randn(10,4),index=pd.date_range('1/1/2000',
periods=10), columns=list('ABCD'))df.plot()
作者图片
熊猫图书馆可以执行的一个重要操作是数据可视化任务。虽然它不能直接替代其他数据绘图库，如 matplotlib 和 seaborn，但 Pandas 中的绘图功能仍然是一个有用的选项，可以与 numpy 库一起使用，以实现一些快速而有用的绘图，用于执行快速数据分析和可视化。
在上面的代码块中，我们可以创建一个由特定行和列组成的随机 numpy 数组。然后，我们用日期范围声明索引，并继续指定行和列的所有值和方法的具体含义。上面下面代码块的代码参考取自下面的网站。如果您有兴趣了解更多，请查看它以获得关于该主题的更多信息。
结论:
“如果你只是用科学的方法来处理数据密集型项目，我认为你更容易取得成功。” — 鲍勃·海斯
Pandas 库框架是 Python 编程中最好的工具之一。在该模块的帮助下，数据科学家的生活变得更加简单，因为通过正确使用该特定框架提供的所有操作和功能，数据的处理、加工、分析和操纵变得更加容易。
本文中讨论的 14 个熊猫函数是所有级别的数据科学家的必备知识，也是他们庞大的知识宝库中必须拥有的东西，用于解决他们遇到的任何类型的问题。通过正确使用这些操作和功能，大多数常见问题都可以轻松解决。
如果你对这篇文章中提到的各点有任何疑问，请在下面的评论中告诉我。我会尽快给你回复。
看看我的其他一些文章，你可能会喜欢读！
</7-best-ui-graphics-tools-for-python-developers-with-starter-codes-2e46c248b47c> </15-numpy-functionalities-that-every-data-scientist-must-know-f6d69072df68> [## 在各种预算范围内，最适合深度学习的电脑
towardsdatascience.com](/best-pc-builds-for-deep-learning-in-every-budget-ranges-3e83d1351a8) </17-must-know-code-blocks-for-every-data-scientist-c39a607a844d> </6-best-projects-for-image-processing-with-useful-resources-f860f3dfe977> [## 6 个最佳图像处理项目和有用的资源
towardsdatascience.com](/6-best-projects-for-image-processing-with-useful-resources-f860f3dfe977)
谢谢你们坚持到最后。我希望你们都喜欢这篇文章。祝大家有美好的一天！
非营利组织处理数据的 14 条建议
行业笔记
第 1 部分:数据入门
Delta Analytics 是一家全球性非营利组织— 由 Delta Analytics 拍摄的照片
在这篇博文中，我们想为刚刚开始使用数据的非营利组织分享一些技巧和最佳实践。我们的目标是帮助您开始实现您的数据目标，并分解为简单易行的小步骤和最佳实践，以充分利用您的数据。
我们是 Delta Analytics 的数据和教学研究员，这是一家旧金山湾区的非营利组织，迄今为止已经与 50 多家非营利组织合作。达美的目标很简单-我们将湾区的专业数据科学家、分析师和软件工程师与全球的非营利组织配对。我们的数据研究员与非营利赠款获得者配对 6 个月，以利用数据推动影响。我们还通过提供免费培训来帮助普及机器学习和数据工具，从而在世界各地的社区建设技术能力。
我们的目标之一是记录一些我们与非营利赠款接受者分享的最佳做法。多年来，Delta 已经看到了非营利组织在开始使用数据时面临的许多不同的障碍，从有限的技术资源到过度关注现有数据有限的人口和社区。
这是一个由三部分组成的博客系列: (1)数据入门，(2)数据质量和预处理，和 (3)数据分析。在第一部分中，我们重点帮助您:
- 构建数据问题
- 弄清楚你需要什么数据
- 获得组织认同
- 计算需要收集多少数据
1.构建数据问题
Delta Analytics 拍摄的照片
开始任何数据项目的第一步，也是最重要的一步，是确定要回答的问题。
这可能需要关注你想更好理解的非营利组织使命或目标的特定领域,或者你认为数据将提供可操作见解的问题。这可能包括诸如“你的课外教育计划如何影响学生的成绩？”到‘你的小额贷款策略在多大程度上有效地为接受者分配了他们开办小企业所需的资金？’
在您开始任何数据收集之前，准确证明为什么值得收集数据是至关重要的。非营利组织的资源通常是有限的，有一个清晰准确的问题可以避免数据收集和重复工作中代价高昂的错误。
Delta Analytics 拍摄的照片
将数据资源分配给任何认为没有必要或没有影响的项目都是低效的。
设计数据问题时，请谨记以下几条指导原则:
- 精确:尽可能详细地描述你的问题。避免使用“提高”或“成功”这样的普通词汇。如果你想改善某件事，具体说明改善多少。如果你想完成某件事，指定时间。
- 以数据为中心:考虑数据在组织中的作用。数据能帮你回答这个问题吗？你是否清楚需要收集哪些数据来回答这个问题？任务的进展可以被编码成一个可以衡量的标准吗？如果这些问题的答案是模糊的或否定的，那么投资额外的数据资源可能是一种低效的资源分配。
举例:
考虑一个以提高儿童识字率为使命的非营利组织。
这个非营利组织每周在幼儿园分发儿童书籍，努力提高早期读写能力。非营利组织希望扩大其业务，并需要增加从捐赠中获得的资金。你可能马上想到的问题是‘我们如何才能增加捐款金额？从表面上看，这似乎是一个合理的问题。但这与类似于“在过去 12 个月中，我们的哪些干预措施导致了最多的捐赠，我们如何才能效仿他们的成功，在本季度将我们的捐赠增加一倍？”让我们通过我们的指南来评估这些问题，找出答案。
2.弄清楚你需要什么数据
图像通过 去飞溅
为了提升任何项目，我们提出了收集所需数据的 4 条准则。
既然您有了问题，那么您可以开始确定您需要哪些数据来做出可行的决策。在决定回答问题时需要哪些数据时，请记住以下几条准则:
- 必要性:你正在收集的数据有必要吗？避免数据膨胀，这是为了“以防万一”而过度收集数据点。这使得维持这些领域的长期数据收集变得更加繁重。
- 可用性:是否有外部的、公开可用的数据源，比如您可以利用的政府数据？如果需要收集数据，收集起来有多容易？如果很难收集，您是否有计划和资源来确保定期收集？一次性数据收集很少有帮助，因为没有参考点来衡量干预措施的长期影响。
- 可维护性:随着时间的推移，您能否维护并轻松更新这些数据？这样做的成本是否可持续？这一点至关重要，因为标准字段的纵向数据收集是非营利组织最有价值的资源之一。避免经常改变字段名、数据收集目标的移动目标和昂贵的数据收集程序(如购买第三方数据),这些在您的总体预算中是不可持续的。
- 可靠性:如果您使用第三方数据源，您信任数据的质量吗？这些数据在哪些方面可能有偏差、不完整或不准确？
举例:
- 考虑一个以给无家可归者寻找长期住房为使命的非营利组织。这个组织可能想回答这个问题:‘在我们服务的地区，我们成功地使多少无家可归的人恢复了正常生活？’。让我们来确定对回答这个问题有用的数据点:
3.组织买入
作者拍摄的照片
组织中任何项目的认同对于项目的成功都是至关重要的。
数据项目需要时间，并且需要组织级别的支持。确保团队中的每个人都同意您要收集和测量什么数据，以及谁拥有数据收集过程。
例子:假设一所学校的教师对跟踪学生成绩的定量调查感兴趣，但教师没有动力在日常工作之外收集这些数据。因此，学校里只有一名教师自愿为他们的班级设计和管理调查。然而，调查结果现在将仅限于一门课的学生经历和结果。测量的结果会有偏差，因为它们不会捕捉到学校不同班级学生之间的任何差异。
由于收集数据可能是一个耗时且资源密集型的过程，因此值得付出额外的努力，让所有教师参与到每个班级的调查中，并定期进行检查，以确保项目的成功。
4.计算你需要收集多少数据
图像通过 去飞溅
资源有限的非营利组织可能会受益于提前考虑收集多少数据以节约资源。
收集数据来辅助决策往往是一种奢侈，而不是一种核心能力。对于不容易获得并且需要收集、获取或购买的数据，重要的是要评估完成手头的任务需要多少数据。
示例:设计和实施调查可能会耗费大量时间和资源。根据我们之前的示例，教师可以有策略地决定需要收集多少调查反馈来对调查结果进行定量分析。在这种情况下，可以计算所需的样本量。SurveyMonkey 在这里提供了一个有用的计算器。
图像通过 去飞溅
总结
在这篇博文中，我们介绍了第一次开始收集数据时需要考虑的关键原则。
这是我们三部分博客系列的第一部分。请继续关注第 2 部分——数据质量和预处理！
如果您对有关该主题的其他博客文章感兴趣，请参考我们的两部分博客系列，了解正在开始或重新评估其数据工作的社会部门组织如何更有效地将数据与其组织和使命集成:
作者&审稿人:哈尼·阿扎姆、卡伦·辛格、艾丽·王、劳尔·马尔多纳多、萨拉·胡克、阿曼达·苏、梅丽莎·法布鲁斯&肖恩·麦克弗森
浙公网安备 33010602011771号