Python 单元测试指南——避免开发期间和之后的错误！
因为如果你在写代码的时候已经在测试了，那就把它做好
在 Unsplash 上由 Carlos Muza 拍摄的照片
为什么要测试？
单元测试是开发的一个重要方面**。没有代码的基本运行，你如何知道它是否工作？此外，由于单元测试通常快速而简短，通过正确地管理单元测试，您还可以知道您是否破坏了旧代码或其他人的代码！**
此外，提供如何使用您的代码的示例会容易得多，因为您已经有一个了！
错误而常见的方式
让我们从展示错误的和常见的方法开始。这里有一个简单的类对象:
正如你所看到的，这个类做的不多，它在给定的输入上需要一个数的幂。
现在，一个标准的开发人员会如何验证这段代码呢？
别这样。
这是不对的，为什么？原因很多。
- 这是不可持续的——只是分散在许多文件中的小测试，没有任何方法来跟踪甚至重用这些测试。
- 这很混乱，并且给我们的程序增加了未使用的代码块
- 这确保了单元测试只发生一次，而不是在每个新版本发布时被验证。
你可能会说——他可以删除它，但是他所有的单元测试工作都是徒劳的，你不会在每个版本中重用它来改进你未来的代码。
正确的方法
尼克·莫瑞森在 Unsplash 上拍摄的照片
有许多 python 测试模块，你可以为它们中的许多给出有力的论据，我喜欢 python unittest 有许多原因，它的简单、快速、有效，并且在标准库中。
如何让它工作
- 测试类必须继承自 unittest。测试案例
- 每个测试功能必须在测试 _ 中开始
- unittest.main() 是运行来测试结果的函数。
3 个小小的规则，你就有了一个合适的单元测试，很简单，不是吗？
安特·汉默斯米特在 Unsplash 上的照片
选项
您不必使用 assert equal，您可以检查任何您喜欢的东西，从数字到类型，到引发正确的异常，任何您可以想象的东西，都在一个简单的标准库模块中，由 python 开发团队维护。
最后的想法
Python 单元测试模块是每个开发人员的必备工具，它将确保您编写良好和适当的单元测试，使它们可重用，这样您就不会用新的开发来破坏旧的代码，并保持代码的整洁和维护，添加 CI 或任何自动化，并且您会得到一个维护良好的程序，只需付出较少的努力，所以开始使用 python 单元测试模块吧，它太棒了！
如果你喜欢这些文章，请发表评论，关于 Python 标准库的更多内容，请就你关心的主题发表评论，我会写的
我希望你喜欢！
计算机视觉的 Python 实用函数
如何在处理图像分类时节省一些管理图像的时间。
如果你花足够的时间使用深度学习研究计算机视觉，你会知道在管理图像时，有些代码片段会反复出现。如果你像我一样，厌倦了总是编写 python 代码来遍历数据集中按类别划分的图像列表，或者从图像构建 NumPy 数组，这篇文章将对你有用。我还将解释如何构建一个模块，该模块可以用您最常用的函数从您机器上的任何脚本中导入。
向 PYTHONPATH 添加模块
在描述我认为在处理图像时有用的函数之前，我想解释一下你如何能够从任何脚本中调用它们而不必重写代码。这将通过在脚本中编写您的所有函数并将该脚本的位置添加到您计算机的环境变量中来完成。更具体地说，您希望添加一个名为 PYTHONPATH 的新变量。当您导入模块时，您为此变量指定的路径将包含在 python 搜索的目录中。如果您想查看这些目录的列表，您可以在脚本或笔记本中使用以下代码
import sys
print(sys.path)
第一步是在脚本中编写所有的函数和类，包括导入。例如，让我们将这个脚本称为 myutils.py。其次，您必须将这个文件的位置添加到您的环境变量中。我并没有重新发明轮子，而是把你引向这个来源的,它详细解释了对于任何操作系统，如何做这件事。最后一步是从另一个脚本中导入新创建的模块，就像处理任何其他模块一样:
import myutils
myutils.some_function()
或者
from myutils import another_function
another_function()
请注意，在这种情况下，为您的函数编写一些文档非常重要。在导入模块时，您将无法访问代码，并且很难记住函数的确切作用和参数的含义。我不会在这里包括我的文档，只是为了避免弄乱代码，避免与文本中的解释重复。
要求
在直接进入函数之前，列出运行这些函数所需的包是很重要的。它们都是标准的数据科学包，应该在实用程序脚本的顶部导入。当您导入模块时，不必再次导入它们。
将图像加载到 NumPy 数组
我想介绍的第一个函数非常简单，但对其他函数也很有用，可以很容易地避免代码中的大量重复。代码如下
此函数用于加载图像，并使用特定的插值方法调整其大小。插值部分听起来不是很有用，但事实证明 tensorflow 和 tf.keras 在默认情况下并不使用相同的方法，因此跟踪使用了哪一种方法会变得很有用。然后，图像被转换成一个 numpy 数组，它的像素被归一化为 0 到 1 之间的值，并且增加了一个维度。这些最后的步骤是使用这些图像作为神经网络的输入所必需的。
将数据集拆分为定型集和验证集
所有好影像分类项目的第一步都是获取一个数据集，并将其组织到不同的文件夹中，每个文件夹对应一个类别。完成后，您会希望将这些数据分成训练集和值集，以便能够评估深度学习模型的性能。这可以通过使用 sklearn 提供的 train_test_split 函数来实现。不过，这仅适用于 numpy 阵列，但直接在您的映像上进行更永久的分割会很有用。这就是下面的函数所做的。
这个函数只是将图像的路径作为输入。这些需要放在名为“train”的目录中，其中每个文件夹代表一个类。该函数在每个类中提取一定比例的图像，由参数“split”确定，并将它们移动到一个新创建的名为“val”的目录中。
从图像目录创建 numpy 数据集
一旦有了数据集，通常有三种方法可以将图像输入到 tf.keras 神经网络中:作为 numpy 数组、使用 keras 生成器或使用 tfrecords。第一个选项可能很烦人，所以下面的函数会处理必要的步骤。
同样，要使用该功能，必须将图像分离到文件夹中，每个文件夹专用于一个类别。用作输入的目录示例是使用前面的函数“train_split”创建的 train 和 val。使用“load_image”将所有图像加载到 numpy 数组中，并组合成一个大数组。从文件夹的划分中也创建了一系列标签。类别按照文件夹的顺序进行编号(通常是按字母顺序)。如果“onehot”参数为 False，则每个标签就是类别的编号。如果“onehot”为真，则每个标签被转换为一个独热编码向量。
寻找重复的图像
有时，当您自己制作数据集时，最终会得到同一图像的多个副本。如果数据集很小，这可以手动处理，但如果有成千上万的图像，这就成问题了。这就是为什么我构建了一个类来查找重复项并删除它们。网上已经有很多这样做的脚本了。这肯定不是最好的，但我喜欢的一点是，如果你的数据已经被分割，这也没关系。即使一个图像在 train 目录中，而另一个在 val 中，也会发现重复的图像。此外，图像之间的比较是以 numpy 数组的形式进行的，因此即使它比较慢，也比使用 hash 更准确。代码如下:
这个类的唯一输入是图像所在的目录。将检查目录中的所有图像，无论它们位于哪个级别。当类被实例化时，将会创建一个字典，其中图像根据它们的大小被分开。然后，您可以使用“find_duplicates()”方法来获取出现多次的图像列表。完成后，方法“show_duplicates()”允许您可视化多次出现的图像，并且您可以使用方法“delete_duplicates()”删除这些图像。
将通用函数应用于图像
我想讨论的最后一个函数乍一看似乎很简单，但是非常通用，所以这个策略可以变得非常强大。这个想法是再次工作的图像是分开的文件夹根据类别。该函数遍历所有图像，并对它们应用一个通用函数。
第一个参数是图像所在目录的路径。又一个例子是训练或阀。参数“do”是您想要的任何函数，它将图像的路径作为第一个参数。args 部分是指您想要的任何参数。使用函数时你在那里写的任何东西都将被用作函数 do 的参数。这些必须作为未命名的参数给出。如果想要指定命名参数，就必须使用kwargs。这种区别归结为“函数(2)”和“函数(数=2)”之类的东西的区别。
我认为这里需要一个例子。假设我想打印文件名和关键字。我将定义一个函数，并将其作为“work_with_files”的参数，如下所示:
该调用的输出如下所示:
filename: image1.jpg
filename: image2.jpg
filename: image3.jpg
...
我认为这些功能很简单，但是经常使用，值得与人分享。希望有人能从我花大量时间用 python 处理图像中学到的东西中受益。如果您有任何意见或问题，请告诉我:)
Python 变量赋值
解释 Python 编程语言最基本的概念之一
本文旨在解释 Python 变量赋值是如何工作的。
阿里安·达尔维什在 Unsplash 上拍摄的照片
基础知识:变量—对象类型和范围
- 变量存储可以在程序中使用和/或更改的信息。该信息可以是整数、文本、集合等。
- 变量用于保存用户输入、程序的本地状态等。
- 变量有一个名，这样它们就可以在代码中被引用。
- 要理解的基本概念是，在 Python 中，一切都是对象。
Python 支持数字、字符串、集合、列表、元组和字典。这些是标准的数据类型。我将详细解释它们中的每一个。
声明变量并赋值
赋值给变量设置一个值。
要给变量赋值，请使用等号(=)
myFirstVariable = 1
mySecondVariable = 2
myFirstVariable = "Hello You"
- 在 Python 中，赋值被称为绑定。在上面的例子中，我们将值 2 赋给了 mySecondVariable。
注意我是如何将一个整数值 1 和一个字符串值“Hello You”赋给同一个 myFirstVariable 变量的。 这是可能的，因为数据类型在 python 中是动态类型化的。
这就是 Python 被称为动态类型编程语言的原因。
如果您想将相同的值赋给多个变量，那么您可以使用链式赋值:
myFirstVariable = mySecondVariable = 1
数字的
- 支持整数、小数、浮点数。
value = 1 #integer
value = 1.2 #float with a floating point
- 也支持长整型。它们的后缀是 L，例如 999999999999L
用线串
- 文本信息。字符串是一系列字母。
- 字符串是字符的数组
- 字符串值用引号括起来:单引号、双引号或三引号。
name = 'farhad'
name = "farhad"
name = """farhad"""
- 字符串是不可变的。一旦创建，就不能更改，例如
a = 'me'Updating it will fail:
a[1]='y'It will throw a Type Error
- 当变量被赋予一个新值时，Python 会在内部创建一个新对象来存储这个值。
因此，创建了对对象的引用/指针。然后将这个指针赋给这个变量，这样，这个变量就可以在程序中使用了。
我们也可以将一个变量赋给另一个变量。它所做的只是创建一个指向同一对象的新指针:
a = 1 #new object is created and 1 is stored there, new pointer is created, the pointer connects a to 1
b = a #new object is not created, new pointer is created only that connects b to 1
变量可以有局部或全局范围。
局部范围
- 例如，在函数中声明的变量只能存在于块中。
- 一旦块存在，变量也变得不可访问。
def some_funcion():
TestMode = Falseprint(TestMode) <- Breaks as the variable doesn't exist outside
在 Python 中，if-else 和 for/while 循环块不创建任何局部范围。
for i in range(1, 11):
test_scope = "variable inside for loop"print(test_scope)
输出:
variable inside for loop
使用 if-else 块
is_python_awesome = Trueif is_python_awesome:
test_scope = "Python is awesome"print(test_scope)
输出:
Python is awesome
全球范围
- 可以从任何函数中访问的变量都具有全局范围。它们存在于 main 框架中。
- 您可以在函数外部声明一个全局变量。需要注意的是，要给一个全局变量赋一个新值，你必须使用" global "关键字:
TestMode = True
def some_function():
global TestMode
TestMode = Falsesome_function()
print(TestMode) <--Returns False
删除“全局测试模式”这一行只会将 some_function()函数中的变量设置为 False。
注意:虽然我稍后会写更多关于模块的概念，但是如果你想在多个模块间共享一个全局变量，你可以创建一个共享的模块文件，比如 configuration.py，并在那里定位你的变量。最后，在您的消费者模块中导入共享模块。
查找变量类型
- 如果要查找变量的类型，可以实现:
type('farhad')
--> Returns <type 'str'>
整数变量中的逗号
- 逗号被视为一系列变量，例如
9,8,7 are three numeric variables
3.操作
- 允许我们对变量进行计算
数字运算
- Python 支持基本的 *、/、+、-
- Python 也支持楼层划分
1//3 #returns 0
1/3 #returns 0.333
- 此外，python 支持通过**运算符求幂:
2**3 = 2 * 2 * 2 = 8
- Python 也支持模数(余数)运算符:
7%2 = 1
还有一个 divmod 内置方法。它返回除法器和模数:
print(divmod(10,3)) #it will print 3 and 1 as 3*3 = 9 +1 = 10
字符串操作
串联字符串:
'A' + 'B' = 'AB'
记住字符串是不可变的数据类型，因此，连接字符串会创建一个新的字符串对象。
重复字符串:
‘A’*3 will repeat A three times: AAA
切片:
y = 'Abc'
y[:2] = ab
y[1:] = bc
y[:-2] = a
y[-2:] = bc
反转:
x = 'abc'
x = x[::-1]
负指数:
如果你想从最后一个字符开始，那么使用负索引。
y = 'abc'
print(y[:-1]) # will return ab
它还用于移除任何新的线路托架/空间。
数组中的每个元素都有两个索引:
- 从左到右，索引从 0 开始，增量为 1
- 从右到左，索引从-1 开始，递减 1
- 因此，如果我们做 y[0]和 y[-len(y)]那么两者都将返回相同的值:“a”
y = 'abc'
print(y[0])
print(y[-len(y)])
寻找指数
name = 'farhad'
index = name.find('r')#returns 2name = 'farhad'
index = name.find('a', 2) # finds index of second a#returns 4
对于正则表达式，使用:
- split():通过正则表达式将一个字符串拆分成一个列表
- sub():通过正则表达式替换匹配的字符串
- subn():通过正则表达式替换匹配的字符串，并返回替换次数
铸造
- str(x):到字符串
- int(x):到整数
- 浮动(x):到浮动
- 元组(列表):To 元组:print(元组([1，2，3]))
- list(tuple(1，2，3)): To list: print(list((1，2，3)))
记住列表是可变的(可以更新),元组是不可变的(只读)
集合操作
- 该集合是没有任何重复的无序数据集合。我们可以将集合变量定义为:
a = {1,2,3}
相交集
- 得到两组的共同点
a = {1,2,3}
b = {3,4,5}
c = a.intersection(b)
器械包差异
- 要检索两个集合之间的差异:
a = {1,2,3}
b = {3,4,5}
c = a.difference(b)
集合的联合
- 以获得两个集合的不同组合集合
a = {1,2,3}
b = {3,4,5}
c = a.union(b)
三元运算符
- 用于在单行中编写条件语句。
语法:
【If True】If【表情】Else【If False】
例如:
Received = True if x == 'Yes' else False
对象身份
我现在将尝试解释客体同一性的重要主题。
每当我们在 Python 中创建一个对象，比如变量、函数等，底层的 Python 解释器都会创建一个唯一标识该对象的编号。一些对象是预先创建的。
当一个对象在代码中不再被引用时，它就会被删除，它的标识号可以被其他变量使用。
- Python 代码被加载到位于堆栈中的帧中。
- 函数连同它们的参数和变量一起被加载到一个框架中。
- 随后，帧以正确的执行顺序加载到堆栈中。
- 堆栈概述了函数的执行。在函数外部声明的变量存储在 main 中
- Stacks 首先执行最后一帧。
如果遇到错误，您可以使用回溯来查找函数列表。
dir()和 help()
- dir()-显示定义的符号
- help()-显示文档
我们来详细了解一下:
考虑下面的代码:
var_one = 123
def func_one(var_one):
var_one = 234
var_three = 'abc'var_two = 456
print(dir())
var_one 和 var_two 是上面代码中定义的两个变量。与变量一起，还定义了一个名为 func_one 的函数。需要记住的重要一点是，在 Python 中，一切都是对象，包括函数。
在该函数中，我们将值 234 赋给了 var_one，并创建了一个名为 var_three 的新变量，并将值“abc”赋给了它。
现在，让我们借助 dir()和 id() 来理解代码
上述代码及其变量和函数将被加载到全局框架中。全局框架将包含其他框架需要的所有对象。例如，Python 中加载了许多内置方法，可用于所有框架。这些是功能框架。
运行上面的代码将会打印:
*[‘__annotations__’, ‘__builtins__’, ‘__cached__’, ‘__doc__’, ‘__file__’, ‘__loader__’, ‘__name__’, ‘__package__’, ‘__spec__’,* ***‘func_one’, ‘var_one’, ‘var_two’****]*
以 __ 为前缀的变量称为特殊变量。
请注意，var_three 还不可用。让我们执行 func_one(var_one)然后评估 dir():
var_one = 123
def func_one(var_one):
var_one = 234
var_three = 'abc'var_two = 456
func_one(var_one)
print(dir())
我们将再次看到相同的列表:
['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'func_one', 'var_one', 'var_two']
这意味着 func_one 内的变量只在 func_one 内。执行 func_one 时，会创建一个帧。Python 是自顶向下的，因此它总是从上到下执行代码行。
功能框架可以引用全局框架中的变量，但任何其他功能框架都不能引用在自身内部创建的相同变量。举个例子，如果我创建一个新的函数 func_two，试图打印 var_three，那么它将会失败:
var_one = 123
def func_one(var_one):
var_one = 234
var_three = 'abc'var_two = 456 def func_two():
print(var_three)func_one(var_one)
func_two()
print(dir())
我们得到一个错误，即名称错误:名称“var_three”未定义
如果我们在 func_two()内部创建一个新变量，然后打印 dir()会怎么样？
var_one = 123
def func_one(var_one):
var_one = 234
var_three = 'abc'var_two = 456 def func_two():
var_four = 123
print(dir())func_two()
这将打印 var_four，因为它是 func_two 的本地变量。
Python 中赋值是如何工作的？
这是 Python 中最重要的概念之一。Python 有一个 id()函数。
当一个对象(函数、变量等。)时，CPython 会在内存中为它分配一个地址。id()函数返回一个对象的“身份”。它本质上是一个唯一的整数。
例如，让我们创建四个变量并为它们赋值:
variable1 = 1
variable2 = "abc"
variable3 = (1,2)
variable4 = ['a',1]#Print their Ids
print('Variable1: ', id(variable1))
print('Variable2: ', id(variable2))
print('Variable3: ', id(variable3))
print('Variable4: ', id(variable4))
id 将按如下方式打印:
变量 1: 1747938368
变量 2: 152386423976
变量 3: 152382712136
变量 4: 152382633160
每个变量都被赋予一个新的整数值。
第一个假设是，每当我们使用赋值“=”时，Python 就会创建一个新的内存地址来存储变量。是不是百分百真实，不是真的！
我将创建两个变量，并将它们赋给现有的变量。
variable5 = variable1
variable6 = variable4print('Variable1: ', id(variable1))
print('Variable4: ', id(variable4))
print('Variable5: ', id(variable5))
print('Variable6: ', id(variable6))
蟒蛇皮印花:
变量 1:1747938368变量 4: 819035469000
变量 5:1747938368变量 6: 819035469000
注意 Python 没有为这两个变量创建新的内存地址。这一次，它将两个变量指向同一个内存位置。
让我们为变量 1 设置一个新值。记住 2 是整数，整数是不可变的数据类型。
print('Variable1: ', id(variable1))
variable1 = 2
print('Variable1: ', id(variable1))
这将打印:
变量 1: 1747938368
变量 1: 1747938400
这意味着每当我们使用=并给一个不是变量引用的变量赋值时，就会在内部创建一个新的内存地址来存储该变量。让我们看看它能不能坚持住！
当变量是可变数据类型时会发生什么？
变量 6 是一个列表。让我们给它添加一个条目并打印它的内存地址:
print('Variable6: ', id(variable6))
variable6.append('new')
print('Variable6: ', id(variable6))
注意，变量的内存地址保持不变，因为它是可变数据类型，我们只是更新了它的元素。
变量 6: 678181106888
变量 6: 678181106888
让我们创建一个函数，并向它传递一个变量。如果我们在函数内部设置变量的值，它在内部会做什么？让我们评估一下
def update_variable(variable_to_update):
print(id(variable_to_update)) update_variable(variable6) print(’Variable6: ', id(variable6))
我们得到:
678181106888
变量 6: 678181106888
注意 variable_to_update 的 id 指向变量 6 的 id。
这意味着如果我们在一个函数中更新变量 _to_update，并且如果变量 _to_update 是可变数据类型，那么我们将更新变量 6。
variable6 = [’new’]
print(’Variable6: ', variable6def update_variable(variable_to_update): variable_to_update.append(’inside’)update_variable(variable6)
print('Variable6: ', variable6)
这是打印的:
变量 6: [‘新’]
变量 6: [‘新’，‘内部’]
它向我们展示了同一个对象在函数中按照预期被更新，因为它们有相同的 ID。
如果我们给一个变量赋一个新值，不管它的数据类型是不可变的还是可变的，一旦我们从函数中出来，这个变化就会丢失:
print('Variable6: ', variable6)def update_variable(variable_to_update):
print(id(variable_to_update))
variable_to_update = ['inside']update_variable(variable6)
print('Variable6: ', variable6)
变量 6: [‘新’]
344115201992
变量 6: [‘新’]
现在有一个有趣的场景:Python 并不总是为所有新变量创建一个新的内存地址。让我解释一下。
最后，如果我们给两个不同的变量赋值一个字符串值，比如’ a '会怎么样。会不会产生两个内存地址？
variable_nine = "a"
variable_ten = "a"
print('Variable9: ', id(variable_nine))
print('Variable10: ', id(variable_ten))
注意，这两个变量有相同的内存位置:
变量 9: 792473698064
如果我们创建两个不同的变量并给它们分配一个长字符串值会怎么样:
variable_nine = "a"*21
variable_ten = "a"*21
print('Variable9: ', id(variable_nine))
print('Variable10: ', id(variable_ten))
这次 Python 为两个变量创建了两个内存位置:
变量 9: 541949933872
变量 10: 541949933944
这是因为 Python 在启动时会创建一个值的内部缓存。这样做是为了提供更快的结果。它为-5 到 256 之间的小整数和更小的字符串值创建了一些内存地址。这就是为什么我们例子中的两个变量有相同的 ID。
本文解释了变量是如何赋值的。
如果您想详细了解 Python，请阅读本文:
在一篇文章中你需要知道的一切
medium.com](https://medium.com/fintechexplained/everything-about-python-from-beginner-to-advance-level-227d52ef32d2)
Python vs(和)R 用于数据科学
用一组预定义的因素详细比较 Python 和 R
当承担一个新项目时，选择正确的编程语言可能是程序员经常做出的最令人生畏的决定之一。
在为数据科学项目选择编程语言时， Python 和 R 无疑是首选。多年来，R 和 Python 都从开发人员和用户那里获得了许多针对各种现代任务的积极反馈。乍一看可能很难决定两者中哪一个更好，但让我告诉你一些事情，即使它们在某些领域相似，例如是免费和开源的，它们都可以提供一些独特的和改变游戏规则的功能。
使用 Python/R 的子社区示例:
- 深度学习
- 机器学习
- 高级分析
- 预测分析
- 统计数字
- 勘探和数据分析
- 学术科学研究
在这篇文章的帮助下，我们想阐明一下 Python 和 r 的区别
Python 和 R 简介
● Python
Python 是程序员需要多大自由的一个实验。太多的自由，没人能读懂别人的代码；太少，表现力受到威胁。
吉多·范·罗苏姆
Python 作为一种高级通用编程语言自 1989 以来就一直存在，它是为了强调代码可读性而构建的。Python 鼓励开发人员为各种规模的项目编写清晰且符合逻辑的代码。Python 具有极强的可扩展性，附带了数百个库，扩展了它的核心功能，同时它的开源特性允许开发人员自由构建和共享定制库。
Python 还作为数据科学 、机器学习和深度学习的例外、工具，因为有几个包和库可用，例如 TensorFlow 、 熊猫 、Keras、 NumPy
优点
●由于其易于使用的特性，在开发人员中非常受欢迎。
●支持多种编程范式，如面向对象和过程化。
●执行时间相对较短。
●拥有大量第三方库。
缺点
● Python 可能缺少 r 中一些流行库的替代品。
●动态类型有时会导致难以正确跟踪故障。
面向数据科学的流行 Python 库概述
towardsdatascience.com](/top-python-libraries-for-data-science-c226dc74999b)
●R
由Ross Ihaka和 Robert Gentleman、 R 于 1993 年首次推出，旨在将无与伦比的统计计算和图形功能交给开发人员、统计人员、分析师和数据挖掘人员。它有一个命令行界面。
当谈到数据科学时，许多研究人员仍然更喜欢 R 而不是 Python** ，因为它具有强大的面向统计的特性和交互式可视化能力。此外，使用 R 的框架，您可以为可操作的见解创建仪表板和交互式可视化。**
作为一种过程化语言，r 允许开发人员将问题的复杂部分分解成更小的块，从而使问题的解决更容易。
优势
●配备了一套强大的分析工具。
●有一系列用于增强其核心行为和能力的软件包。
RStudio IDE 和 Jupyter 等图形用户界面可以为已经强大的工具添加图形界面，同时添加更多功能，如集成帮助、代码调试器和代码完成。
●允许强大的数据导入选项，包括文件，如 Microsoft Excel。
●支持各种第三方包的扩展性。
劣势
● R 很难学，如果不小心使用会让事情走下坡路。
●某些库缺乏适当的文档会浪费开发人员的努力。
●比 Python 表现相对较慢。
最近更新由克莱尔 d。人工智能创新的加速增长已经导致几个…
blog.digitalogy.co](https://blog.digitalogy.co/r-for-data-science/)**
Python 与 R——详细比较
为您的下一个数据科学项目选择一种语言可能具有挑战性，尤其是当两种语言可以执行相同的任务时。既然介绍已经结束，我们将在接下来的部分中讨论这两种语言之间的比较，记住一组显著的特性，大多数开发人员会发现这些特性非常有用。
1。数据收集的差异
为了方便数据收集，Python 可以支持各种常用的数据格式，比如CSV、JSON 文件，甚至 SQL 文件**。数据科学家在 Python 中广泛使用的另一个数据源是数据集。Python 还可以让你借助合适的库直接从互联网上提取数据。**
尽管不像 Python 那样灵活，R 允许您通过 Excel、CSV 和文本文件导入数据。使用 Minitab 或 SPSS 等软件包构建的文件也可以转化为 r 中使用的数据框，使用Rvest和magritter等软件包可以帮助你从网上刮取并清理数据。
2.数据探索的差异
Python 的各种库可以帮助你非常容易地分析结构化和非结构化数据。诸如熊猫、NumPy、 PyPI 等库无疑是数据探索的佼佼者。 Pandas ，例如，允许您将数据组织到数据框中，使清理更简单。此外，熊猫甚至可以保存大量数据，同时提供额外的好处。
专为数据探索而构建的 R 提供了出色的结果，因为它是专为统计学家和数据挖掘者而构建的。使用 R，您可以应用一系列的测试和技术，比如概率分布，对您的数据进行数据挖掘。r 可以执行数据优化、随机数生成、信号处理，甚至提供对第三方库的支持。
3.数据可视化的差异
使用 Python，您可以以图形和图表的形式创建有效且可定制的可视化效果。像 IPython 和matplotlib这样的库的存在是为了帮助开发者和研究人员创建强大的交互式可视化。虽然 Python 生态系统包含更多的库，但最常用的是 matplotlib。
另一方面，R 可以提供高级可视化，因为它是编程语言提供的核心功能之一。r 自带了对许多标准图形的内置支持，对于更复杂的可视化，您可以使用库，如gg plot 2，Plotly，以及Lattice**。**********
随着数据量的不断增加，没有可视化就不可能讲述故事。数据可视化是一种…
www.tatvic.com](https://www.tatvic.com/blog/7-visualizations-learn-r/)
4.数据建模的差异
对于数据建模，Python 提供了几个库来满足所需的建模类型。比方说，对于数值建模，Python 提供了其 NumPy 库，同样，对于科学计算**，我们有 SciPy 。各种其他库和技术允许 Python 中有更多的数据建模选项。**
在 R 中，由于编程语言提供了强大的统计能力，您可以高效地进行统计建模。它附带了大量的支持包来帮助您进行统计建模，甚至是特定的分析，如泊松分布、线性&逻辑回归。
5.表演
性能是任何编程语言的一个关键方面，它经常成为选择一种语言而不是另一种语言的主要原因。大多数程序员甚至数据科学家开始喜欢 Python 而不是 R 的一个关键原因是，Python 能够相对容易地快速执行大多数数据科学任务。Python 胜过 R 的另一个地方是它的执行速度相对更快。其他不利于 R 的因素可能包括缺乏特性，比如单元测试和代码可读性不够。
Python 性能提示—
https://wiki.python.org/moin/PythonSpeed/PerformanceTips
https://stack ify . com/20-simple-python-performance-tuning-tips/
[## Python vs. Node。JS:哪个最适合你的项目？
使用一组预定义的因素对 Python 和 Node.js 进行详细比较
towardsdatascience.com](/python-vs-node-js-which-one-is-best-for-your-project-e98f2c63f020)
6.图书馆
当谈到这些编程语言提供的包和库时，它们都为几乎每种情况提供了数千个有用的包。
PyPI 托管和管理 Python 的包，而 R 这边的事情则由 CRAN 处理。如果你对数字更感兴趣，Python 有超过25.7 万个包，而 CRAN 有一点超过 1.6 万个。太多了！
尽管 Python 确实提供了比 R 多 10 倍的包，但并不是所有的包都对数据科学有用。在阅读这些数字时，不要忘记 Python 是一种通用编程语言，而 R 不是。
[## 2020 年你必须使用的最好的 Python IDEs 和代码编辑器
具有显著特性的顶级 Python IDEs 和代码编辑器
towardsdatascience.com](/best-python-ides-and-code-editors-you-must-use-in-2020-2303a53db24)
7.流行
这两种编程语言在开发人员和数据科学家中相当受欢迎，是在他们的命令下添加的好选择。Python 似乎在这方面处于领先地位，因为它的通用性质和围绕数据科学的几个库的可用性，但是 R 紧随其后。
根据 StackOverflow 的说法，Python 是发展最快的主要编程语言。
每个月，大约有 5000 万人访问 Stack Overflow 来学习、分享和建立他们的职业生涯。行业估计…
insights.stackoverflow.com](https://insights.stackoverflow.com/survey/2020#technology-most-loved-dreaded-and-wanted-languages-wanted)
一些统计学家和数据挖掘者仍然更喜欢 R，因为它具有强大的数字处理和可视化功能。此外，R 提供了对数据分析的更好的控制，因为它倾向于统计和数值计算，并收集了库，提供了更高级和更深入的结果来证实这一说法。
编程语言 R 持续上升，并有望成为 TIOBE 的 2020 年编程语言。
2020 年 8 月 TIOBE 指数(来源)
Python 正被 IT 界的一些巨头积极使用
towardsdatascience.com](/10-world-class-companies-using-python-26cde24919a8)
8.工作机会
数据科学领域的工作机会正在增加，统计数据显示更多的工作需要 Python 而不是 R 。由于数据科学的快速发展，现在比以往任何时候都更需要这两种编程语言。
Python 作为一种全能的编程语言，可以成为一个可靠的总体选择，因为它可以让您进行软件工程，并提供一个进入数据科学的良好切入点。然而，如果您想在短时间内提取有价值的统计数据，制作漂亮的可视化数字，并为 web 应用程序创建图形界面，R 将是更好的选择。
9.社区
一个社区为开发者提供支持和指导，可以说它是开发者访问次数第二多的地方，仅次于项目代码。它在快速找到问题的根本原因和解决方案方面具有重要价值，同时提供了许多有用的提示。
当我们谈到一种编程语言的社区时，首先想到的是它的目标用户。通常，它包括开发人员，但是我们的案例也包括统计人员和数据挖掘人员。Python 被各种各样的受众使用，包括各种应用程序。另一方面，r 主要由企业和主要研究统计数据的研究人员使用。
不用说，这两种编程语言都提供了一个活跃的开发人员和贡献者社区，定期为其他人和语言提供宝贵的见解。
Python 社区—
Python 编程语言的官方主页
www.python.org](https://www.python.org/community/)
RStudio 社区—
一个面向所有 R 和 RStudio 的社区
community.rstudio.com](https://community.rstudio.com/)
结论
这两种语言的竞争性质可能有助于我们为我们的目的产生最简单和最有效的代码。
在整篇文章中，我们讨论了 Python 和 R 之间的一些决定性因素，这些因素在选择一种编程语言时起着主导作用。我们可以得出结论，尽管这两种语言对于数据科学来说都是值得尊敬的选择，但它们仍然各有利弊。学习 Python 可以让您灵活地处理大多数以数据科学为中心的项目，而学习 R 可以让您更好地掌握数据科学中的统计学。学习这两者无疑会让您在即将到来的数据科学项目中占据上风，但我们希望让您来做最终决策。
注: 为了消除各种各样的问题，我想提醒你一个事实，这篇文章仅代表我想分享的个人观点，你有权不同意它。
更多有趣的阅读—
我希望这篇文章对你有用！下面是一些有趣的读物，希望你也喜欢
使用谷歌人工智能中心将想法变为现实
towardsdatascience.com](/top-google-ai-tools-for-everyone-60346ab7e08) [## 机器学习和深度学习的最佳 Python 库
现代机器学习模型和项目的 Python 库
towardsdatascience.com](/best-python-libraries-for-machine-learning-and-deep-learning-b0bd40c7e8c) [## 用于自然语言处理的 Python 库
用于自然语言处理的流行 python 库概述
towardsdatascience.com](/python-libraries-for-natural-language-processing-be0e5a35dd64) [## 2020 年必读的数据科学书籍
看看吧，你为什么要读它们？
towardsdatascience.com](/data-science-books-you-must-read-in-2020-1f30daace1cb) [## 2020 年必读的机器学习书籍
看看吧，你为什么要读它们？
towardsdatascience.com](/machine-learning-books-you-must-read-in-2020-d6e0620b34d7)
关于作者
克莱尔 D 。在digital ogy—是一个内容制作者和营销人员。这是一个技术采购和定制匹配市场，根据全球各地的特定需求，将人们与预先筛选的&顶尖开发人员和设计师联系起来。连接DigitalogyonLinkedinTwitterinsta gram*。***********
巨蟒大战山羊:蒙蒂霍尔重访
在熊猫的帮助下！
伊洛娜·弗罗利希在 Unsplash 上的照片
问题是
尽管有打熊猫的照片，我们还是要在这里讨论一下天魔堂问题。这个问题在统计学中很有名，可能已经在大学、网上或任何地方介绍了大多数统计学课程。包括我在内的大多数人从这个问题中学到的是，统计或概率思维不幸是违反直觉的，因此必须加以训练。或者换句话说:仅仅学习公式并不能让你通过这门课程。
但是现在回到实际问题:你是参加游戏节目的幸运儿。主要价格是昂贵的跑车，现在可能是电池电动的。在你和开着一辆崭新的汽车离开之间有三扇门。两扇门后是山羊，一扇门后是你的梦想之车。你如何打败山羊并得到汽车？
游戏规则是:你选择一扇门。然后，脱口秀主持人蒙蒂选择了另一扇门，打开门，门后总是一只山羊。所以其中一只山羊已经不碍事了。现在你做什么？换到第二个关闭的门或者坚持让你选择你的门的幸运感觉。我的第一直觉告诉我没关系:三扇门，一辆车有三分之一的机会。蒙蒂的行动无关紧要，他总是选择一只山羊。是吗？
战略
现在数学说它有，特别是考虑到一些托马斯·贝叶斯的工作。我看了不少关于这个问题的解释，也是在媒体上。没有一个能让我立即理解。那么为什么不试一试呢？由于没有无限数量的山羊和跑车，我选择在熊猫的帮助下模拟使用 Python。
这个问题可以很容易地分解成以下几个步骤:
- 我们把一辆汽车藏在其中一扇门后，两只山羊藏在另外两扇门后。
- 我们选择一扇门，由于缺乏进一步的随机信息，只是跟随我们的幸运感觉。
- 友好的智力竞赛节目主持人蒙蒂从另外两扇门中选择一扇门，打开门，总是有一只山羊走出来。
- 他让我们换门。我们该怎么办？
- 我们的大门敞开了。我们要么开着一辆崭新的汽车驶向夕阳，要么不得不接纳一只新宠物。
步骤 4 中只有一个决策点。在这一步中，我们将通过定义三个场景并模拟所有三个场景来帮助我们的 Python:
- 场景 A :常变。
- 场景 N :永远不变，坚持那种幸运的感觉。
- 场景 S :有时会改变，因为缺乏对问题的更好理解，两个未打开的门之间有 50:50 的几率。
在什么情况下我们可以打败山羊？
解决方案
显然，我们在这里谈论的是概率。所以不幸的是，数学和 Python 都不能帮助幸运的智力竞赛节目嘉宾总是得到跑车。但是 Python 可以帮助我们获得概率，并真正相信它们。数学至少对我来说总是有困难。我将在这里解释一下代码。
目标是使代码尽可能地可读和可理解，并为此牺牲内存和性能的效率。所以你将能够找到更简洁有效的问题模拟。我们首先用熊猫数据框架来模拟蒙蒂霍尔问题。注意 number_games 是一个整数，它定义了我们想要玩的游戏的数量。
all_games = pd.DataFrame(index=range(0, number_games),
columns=['Door_A', 'Door_B', 'Door_C',
'Choice_1', 'Choice_Monty',
'Choice_A', 'Choice_N', 'Choice_S',
'Success_A', 'Success_N', 'Success_S'])for game_idx in all_games.index:
# we put goats behind all doors
all_games.loc[game_idx, ["Door_A", "Door_B", "Door_C"]] =
["Goat", "Goat", "Goat"]
# oops, we forgot the car
all_games.loc[game_idx, random.choice(["Door_A", "Door_B", "Door_C"])] = "Car"
# the first choice is purely random
all_games.loc[game_idx, "Choice_1"] = random.choice(["Door_A", "Door_B", "Door_C"])
如果你看一下生成的熊猫数据帧，你会发现在所有的游戏中，我们在门 A 到 C 中的一个门后面藏了一辆汽车，在另外两个门后面藏了两只山羊。我们已经选了一扇门。下一步是蒙蒂的选择，这就是奇迹发生的地方。他的选择绝非随意。
for game_idx in all_games.index:
game = all_games.iloc[game_idx]
# Monty will not open the door we chose
monty_choices = {"Door_A", "Door_B", "Door_C"} - {game["Choice_1"]}
monty_choices = list(monty_choices)
# Monty will not open the door with the car
if(game[monty_choices[0]] == "Car"):
monty_choice = monty_choices[1]
elif(game[monty_choices[1]] == "Car"):
monty_choice = monty_choices[0]
else:
monty_choice = random.choice(monty_choices)
# We store Monty's choice
all_games.loc[game_idx, "Choice_Monty"] = monty_choice
在 Monty 做出选择后，我们应用了上面定义的三个策略:A 代表总是改变，N 代表从不改变，S 代表有时以 50:50 的概率改变。
# never change
all_games["Choice_N"] = all_games["Choice_1"]for game_idx in all_games.index:
game = all_games.iloc[game_idx]
# always change
all_games["Choice_A"][game_idx] = ({"Door_A", "Door_B", "Door_C"} - {game["Choice_1"], game["Choice_Monty"]}).pop()
# sometimes change
all_games["Choice_S"][game_idx] = random.choice(list({"Door_A", "Door_B", "Door_C"} - {game["Choice_Monty"]}))
即使您不是 Python 爱好者，代码也应该是可读的。在总是变化的情况下，我们需要 pop() 从集合中获取唯一剩余的元素。最后一步是给我们的场景打分，如果我们真的有车，就给 1 分；如果我们的家里又多了一只有点难闻的四条腿，就给 0 分。我将把这个留给读者，或者你可以在我的 GitHub 上获得源代码。
一旦我们对模拟评分，我们可以简单地在数据帧上使用 describe() 来获得结果。在我运行的 10，000 个游戏中，我得到了以下值:
- 场景 A:如果我们总是改变，获得汽车的概率为 0.6659。
- 场景 N: 0.3341 概率如果我们从不改变，
- 情景 S: 0.4980 概率如果我们有时改变。
摘要
查看我们代码的结果，我们可以看到，场景 A 总是切换车门，这让我们有三分之二的概率得到跑车。所以从长远来看，3 次中有 2 次我们会得到一辆车，而不是一只没用的山羊。为什么会这样呢？
我们坚持三扇门的情况，没有先前的信息，三分之一的机会。但是蒙蒂给我们看了一扇有山羊的门。所以他把这个问题转化为一个双门 50:50 机会得到汽车的问题。这反映在场景 S 中，有时会更换门。
但是在场景 A 中还有第三种选择，那就是永远改变。在我们的选择中，我们将车门分成两组:我们的车门有三分之一的机会挡住汽车，另外两个车门有三分之二的机会挡住汽车。因此，我们的选择正是通过这种划分来添加信息。
现在蒙蒂只用三分之二的机会看着两扇门的隔板。经过蒙蒂的选择，我们可以肯定的是，如果汽车一开始就在那里，那扇未打开的门就藏着汽车。所以我们总是选择那扇门，继承了三分之二的概率。
还是难以理解？是的，我同意。但是看看模拟给我们的数字。用 Python 模拟帮助我打败了山羊，并对问题有了更好的理解。希望它也能为你做同样的事情！只需获得代码，然后自己尝试一万次。这会给你一个合理准确的概率估计。有多精确？为此我不得不回到我的统计学课程上。
Python vs. Node。JS:哪个最适合你的项目？
使用一组预定义的因素对 Python 和 Node.js 进行详细比较
蒂姆·范德奎普在 Unsplash 上拍摄的照片
当承担一个新项目时，选择正确的编程语言可能是程序员经常做出的最令人生畏的决定之一。
这一挑战背后的原因是，每个新项目都有一个独特的问题，在编程领域，没有什么大师是万能的。不同的编程语言有它们的优势和劣势，这使得它们适用于某些情况，但不是所有情况，这是众所周知的事实，有经验的程序员会同意这一点。在整篇文章中，我们将比较 Python 和 Node.js，以确定哪种情况下哪种更好。
Python 和 Node.js 是什么？
● Python
GitHub 第二受欢迎的语言，也是机器学习最受欢迎的语言。
Python ( 前端和后端编程语言)是由开发的通用、面向对象的编程语言，它是动态类型化的，支持多种编程范式。****
Python 可以用来创建桌面、web、移动应用程序，并且附带了一个详尽的包和库集合来简化开发。Python 的便利特性使其成为后端开发的完美选择，使其成为最常用的编程语言之一。
编写 Python 代码的乐趣应该在于看到短小、简洁、易读的类，这些类用少量清晰的代码表达了大量的动作——而不是让读者厌烦得要死的大量琐碎代码。
吉多·范·罗苏姆
Python 初学者教程—
Python 初学者教程
● Node.js-
Node.js( 主要用作后端框架)本质上是在 Google Chrome 的高性能 V8 JavaScript 引擎 上创建的 JavaScript 运行时环境，是提升 Node.js 代码效率的主要贡献者。
Node.js 由 Ryan Dahl 开发，可用于构建基于 JavaScript 的高效且可扩展的 web 应用程序，可用于前端和后端开发。
Node.js 初学者教程—
Node.js 初学者教程
Python 与 Node.js 详细比较
在本节中，我们将对 Python 和 Node.js 进行详细的比较，并记住一组预定义的因素**，以便让您更好地了解这两个竞争对手的。**
1.速度和性能
Python
Python 在性能上相对较慢，因为它在单个流中处理请求，不像 Node.js，在 node . js 中可以实现高级多线程。使用 Django 或许可以在一定程度上处理高负载，但这仍不能使其成为移动应用的可行选项。
Node.js
底层的 snappy V8 引擎极大地提高了 Node.js 代码的效率和速度，将 JavaScript 代码解释为机器语言，提供了出色的性能。
在开发实时 web 解决方案时，Node.js 应该是您的实际选项**，例如需要生成和共享关键任务更新的通知系统。此外，由于其中的一些优化，Node.js 缩短了应用程序的加载时间。**
赢家— Node.js 在这里领先。
** [## 2020 年你必须使用的最好的 Python IDEs 和代码编辑器
具有显著特性的顶级 Python IDEs 和代码编辑器
towardsdatascience.com](/best-python-ides-and-code-editors-you-must-use-in-2020-2303a53db24)
2.趋势科技
Giphy Source — SXSW 大会&节日
Python
在这个智能技术的时代，Python 已经成为趋势技术的首选，如机器学习、数据科学和物联网。对于 ML，社区中有一些工具和库以及专家为那些寻求帮助的人提供帮助。对于物联网，存在一个 Python 的口袋变体，称为 MicroPython ，它使 Python 能够支持物联网设备。
现代机器学习模型和项目的 Python 库
towardsdatascience.com](/best-python-libraries-for-machine-learning-and-deep-learning-b0bd40c7e8c)
Node.js
Node.js 也能够为物联网设备构建，但它更受欢迎的是开发包括实时通信在内的 web 应用程序。由于 JavaScipt 的流行，Node.js 越来越多地被用作服务器端框架**。**
赢家— 选择取决于程序员和项目类型。
3.架构
Python
Python 没有内置对异步编程的支持，需要特殊的工具来启用该功能。一个这样的库是asyncio，开发者可以用它来创建异步事件驱动的应用。
Node.js
Node.js 架构包含一个单线程事件循环**，当与 Node.js 的非阻塞特性结合时，允许它处理数千个并发连接，而不会导致线程上下文切换。这个特性使得 Node.js 成为实时 web 应用程序的最佳选择之一。**
赢家— Node.js 比 Pythos 赢得更多积分，因为它提供了事件驱动的架构。
4.语法
Python
Python 的语法让编写更少的代码行实现更多成为可能。Python 没有花括号，更容易理解和调试。凭借一点技术诀窍，大多数人可以轻松阅读 Python 代码，这使它成为非常适合初学者的编程语言。
Node.js
在语法方面，它与浏览器的 JavaScript 语法非常相似，在使用 Node.js 时，JavaScript 的先验知识应该不会构成挑战。
赢家— Python 因其用户友好的语法而胜出。
5.普遍性
巨蟒
Python 可以用于前端和后端跨平台开发**，并且与 macOS 和 Linux 捆绑在一起。Python 对于 web 和桌面开发来说是一种强大的编程语言，但是它在移动开发方面有所欠缺，这使得它成为一种不切实际的选择。**
Node.js
Node.js 也常用于 web 应用程序的前端和后端开发，转化为两端对 JavaScript 的一致使用。Node.js 使得在 web、移动、物联网和云上开发各种跨平台应用成为可能，降低了开发成本和工作量。
赢家— 两者都是有能力的选项，在这里都是赢家。
6.可量测性
计算机编程语言
由于一些原因，Python 缺乏适当的可伸缩性支持。Python 代码的运行时解释使其成为一种较慢的编程语言。Python 也不支持多线程，原因是内部锁机制阻止它同时运行多个任务。但是这些限制可以通过使用 Python 实现来克服，如 CPython 或 Jython、更好的架构和负载平衡机制。****
节点. js
Node.js 很自然地提供了可伸缩性，因为它被构建到运行时环境中，并且带有一个集群模块**，它能够处理你的机器的全部能力。Node.js 通过为垂直伸缩添加额外的资源和为水平伸缩添加更新的节点，使得 web 应用程序的垂直和水平伸缩更加容易。此外，可以使用下面列出的策略来管理扩展:**
- 克隆
- 分解
- 剧烈的
赢家— 与 Python 相比，Node.js 具有高度的可伸缩性，这一点很明显。
7.展开性
计算机编程语言
Python 可以通过几个框架轻松扩展，如 Django 、T3、Flask、 web2py ，以及更多用于全栈和纯 web 开发的框架。Python 也允许用 C 源文件中提供的 API 来扩展 C/C++编程语言的特性。Java 的python 实现，称为 Jython** ，可以简化脚本编写，轻松实现快速应用程序开发。**
节点. js
Node.js 附带了一个能够扩展其特性的框架池,其中一些是:****
- Loopback.js —创建连接到另一个服务器的服务器 API
- DerbyJS——创建成熟的实时网络应用程序
- KOA . js——作为中间件，为开发者提供几个功能，以加快应用程序开发
- Hapi.js —允许开发人员创建 JSON APIs
赢家——双方都赢了，因为他们能力相当。
8.错误处理
Python
Python 的可读性和紧凑的语法使开发人员更容易找到和调试错误。还有一个普遍的观点是，Python 通常更容易也更擅长异常处理，与 Node.js 相比，这使它具有优势。
Node.js
每种编程语言或运行时都提供不同程度的错误处理，因为错误可能发生在应用程序生命周期的任何一点。类似地，Node.js 具有足够的调试错误的能力，并提供了优秀的异常处理选项。
****赢家——Python 和 Node.js 都在这方面胜出。
Giphy Source — RedBul l
9.图书馆
计算机编程语言
Python 的包和库由 Python 默认的包安装程序 pip、 处理。谈到包的数量，Python 有超过 22 万个包，分布在数据科学、计算、图像处理等广泛的类别中，涵盖了您的大部分需求。
用于自然语言处理的流行 python 库概述
towardsdatascience.com](/python-libraries-for-natural-language-processing-be0e5a35dd64)
Node.js
Node.js npm 是节点包管理器的缩写，处理 Node.js 中的包。npm 拥有超过130 万个包，以惊人的数量击败了 pip，证明了 Node.js 使用正确的包是多么可扩展。npm 上的所有软件包都可以通过简单的搜索方便地获得。
赢家— Node.js 凭借其庞大的软件包数量摘得桂冠。
10.最适合的应用
Python
Python 适用于**小型和大型项目，**更重要的是，它是数据科学产业的重要组成部分，其中大多数工具都依赖于 Python。除了应用程序开发之外，Python 还用于多个领域，例如:
- 数据可视化
- 图像处理
- 神经网络
- 机器学习
- 语音和面部识别
节点. js
Node.js 基于事件的特性使其成为需要实时处理并发请求的应用程序的完美组成部分，包括从客户端到服务器的频繁数据传输。Node.js 还可以在实时解决方案中使用，例如:
- 信使
- 聊天机器人
- 复杂的单页应用程序
- 物联网实施
- 协作系统
- 流媒体平台
赢家— 两个竞争对手都因各自不同的实现而胜出。
11.社区
计算机编程语言
当谈到在线寻找支持和有用的资源时，Python 有一个大而有用的社区。论坛提供了一个很好的地方来发布你的问题，并从其他开发者那里获得建议，同时也为合作打开了新的大门。熟练的开发人员可以自由地为 Python 及其包做出贡献。对于企业来说，这是一个与顶级开发人员联系的绝佳场所。
节点. js
Node.js 社区拥有一群积极友好的开发人员，他们总是渴望为您提供帮助。该社区通过对 Node.js 及其各种软件包的开源特性做出贡献，甚至帮助您找到更好的职业机会，从而更容易展示您的才华。
赢家— 两者都有一个活跃且乐于助人的社区。
12.用例
巨蟒
Python 已经被部署到众多流行的项目中，下面是其中的一个简要列表:
- Instagram 使用 Python 作为其后端服务
- Google 从早期就开始使用 Python
- Spotify 应用程序使用 Python 进行后端服务和数据分析
- 网飞使用 Python，因为他们的开发者是这种编程语言的超级粉丝
Node.js
Node.js 是一个同样强大的平台，已经在无数的项目中使用，其中一些项目是业界知名的，例如:
- LinkedIn 使用 Node.js 是因为它的可伸缩性和高效性带来的性能提升
- PayPal 喜欢 Node.js，因为它可以让他们为超过 2 亿的用户提供服务，几乎可以使用任何一种货币，而不会有任何减速
- Ube r 在 Node.js 上运行，因为它的伸缩性很好，可以毫不费力地处理越来越多的请求
13.初学者最佳书籍
计算机编程语言
- Python 速成班
- Head-First Python(第二版)
- 艰难地学习 Python(第三版)
- Python 编程:计算机科学导论(第三版)
节点. js
- Basarat Ali Syed 的 starting node . js
- Mario Casciaro 的 Node.js 设计模式
- 实用 Node.js:构建真实世界的可伸缩 Web 应用程序
- 西蒙·霍姆斯的《蒙哥、快车、角马和节点》**
结论
Python 和 Node.js 是程序员开发 web 应用的非常强大的选项。选择其中任何一个取决于两个核心因素，项目的目的和开发人员的技能。当然，它们都提供了优于另一个的特定优势，但是这些优势不应该超过项目的需求，因为总有办法解决缺点。此外，了解您的团队在这两种技术上工作的舒适程度总是有帮助的。我们希望这能消除您对 Python 和 Node.js 的一些疑虑，并让您更接近为下一个项目选择正确的选项。
注: 为了消除各种各样的问题，我想提醒你一个事实，这篇文章仅代表我想分享的个人观点，你有权不同意它。
更多有趣的阅读—
我希望这篇文章对你有用！以下是一些有趣的读物，希望你也喜欢
使用谷歌人工智能中心将想法变为现实
towardsdatascience.com](/top-google-ai-tools-for-everyone-60346ab7e08) [## 2020 年必读的机器学习书籍
看看吧，你为什么要读它们？
towardsdatascience.com](/machine-learning-books-you-must-read-in-2020-d6e0620b34d7) [## 数据科学家的最佳数据科学工具
数据科学工具，使任务可以实现
towardsdatascience.com](/best-data-science-tools-for-data-scientists-75be64144a88) [## 选择 PyTorch 进行深度学习的理由
PyTorch 可以为深度学习程序员提供很多东西
towardsdatascience.com](/reasons-to-choose-pytorch-for-deep-learning-c087e031eaca) [## 数据科学如何助推网飞
当有效使用时，数据可以神奇的方式改变您的业务，并将它带到新的高度。
towardsdatascience.com](/how-data-science-is-boosting-netflix-785a1cba7e45)
关于作者
克莱尔丁。是Digitalogy**—的内容制作者和营销人员，这是一个技术采购和定制匹配市场，根据全球各地的特定需求，将人们与预先筛选的&顶尖开发人员和设计师联系起来。在 Linkedin ， Twitter ， Instagram 上连接 Digitalogy 。**
Python 与 R 在数据科学中的对比
两大语言的特点、群体和行业地位的比较分析。
Python 和 R 的比较多年来一直是业界的热门话题。r 已经存在了二十多年，专门用于统计计算和图形，而 Python 是一种通用编程语言，与数据科学和统计学一起有许多用途。许多初学者都有同样的问题:我应该从这两种伟大的语言中选择哪一种来开始学习数据科学？
计算机编程语言
Python 于 1991 年发布，作为一门极其简单的语言，它让你可以做几乎任何你能想象到的事情，它已经为自己建立了强大的声誉。它为网站、后端服务、本机桌面应用程序、图像处理系统、机器学习管道、数据转换系统等提供支持，并且它以语言的简单性而闻名，这使得它成为任何人最容易开始使用的编程语言之一。
这种语言的主要优点是:
- 它的语法与本土英语非常相似，如此相似以至于大多数写得好的脚本大声读起来都有意义。
- 它有一个巨大的社区围绕着它；对于你遇到的任何问题，可能有成百上千的人在网上问了同样的问题并得到了答案。
- 它为你能想到的任何应用程序提供了大量的第三方模块和库。
- 围绕这种语言有一个非常大的数据科学社区，这意味着有许多工具和库可以解决数据科学问题。
- 它既支持面向对象编程又支持过程编程范例，让您根据自己的需要自由选择。
得益于这些优势，Python 成为业界最流行的语言之一也就不足为奇了。据 Ncube 报道，谷歌、Dropbox、网飞、Stripe 和 Instagram 等大型科技公司也使用这种方法。
r 项目
R Project 是一个 GNU 项目，由 R 语言、运行时和用它们构建应用的实用程序组成， R 是在这个环境中使用的解释语言。这种语言专门围绕统计计算和图形，这意味着它直接适合许多数据科学问题，而通过内置工具和围绕它的第三方库简化了数据科学项目。
R 语言的优势是:
- 它有许多专门用于数据操作的库和工具。这种语言和这些工具允许你容易地修改你的数据结构，将它们转换成更有效的结构，或者为你的特定用例清理它们。
- 有很多非常流行的包和库，比如 tidyverse 负责端到端的数据操作和可视化。这些库允许您轻松开始数据科学任务，而无需从头开始编写所有算法。
- 它有一个设计非常好的 IDE，叫做 RStudio。与语言本身集成，RStudio 提供了语法高亮、代码完成、集成帮助、文档、数据可视化和调试器，允许您在不离开屏幕的情况下开发 R 项目。
- R 背后的团队一直非常专注于确保这些工具能够在所有平台上工作，由于这些努力 R 可以在 Windows、macOS 和 Unix 类操作系统上运行。
- 它拥有围绕构建基于网络的仪表盘进行数据分析和可视化的工具，比如 Shiny 允许直接从 r
除了这些优点及其在数据科学社区中的广泛使用，R 在数据科学项目中是 Python 的有力替代。
比较:Python 与 R
由于两种语言在理论上提供了相似的优势，其他因素可能会影响选择哪种语言的决定。
流行
这两种语言在数据科学界都很流行；然而，当谈到选择一种语言添加到您的工具链和经验中时，选择一种在行业中受欢迎的语言可能是有意义的，并且可能允许您过渡到您专业领域内的不同职位。
根据 Stack Overflow 的 2019 年开发者调查， Python 是 72525 名专业开发者中第 4 受欢迎的编程语言，最近甚至比 Java 还受欢迎。在同一次调查中， R 位于第 16 位。
Stack Overflow 2019 在专业开发者中的开发者调查结果
关于这些调查结果，需要记住的一点是，它们代表了栈溢出的开发人员社区，显然，这些数据并不特定于数据科学家；然而，这可能有助于更好地了解该行业的现状。
在同一个调查中查看全球范围内的工资，在 55，639 名参与者中，Python 和 R 似乎都站在同一点，R 的平均水平略高。
根据 Stack Overflow 2019 开发者调查的工资语言
除了调查结果，通过查看堆栈溢出趋势可以看出，就提问的问题数量而言， Python 比 R 更受欢迎。
通过查看这些数据，在整个开发者社区中，Python 似乎比 R 更受欢迎；然而，重要的是要记住 Python 是一种通用编程语言，而 R 是专门用于统计计算的，这意味着这种比较在数据科学家中的受欢迎程度并不相同。
为了更好地了解数据科学，我们可以看看 2019 年 Kaggle 用户调查。事实上，他们在仪表盘上有一个专门的页面，是关于 Python 和 R T21 的。
根据 2019 年 Kaggle 用户调查，编程语言分布情况
正如在 Kaggle 数据中所看到的，在数据科学社区中，Python 比 R 有更大的用途，尽管这两种语言在用法上都有重要的地位。
图书馆
谈到数据科学，第三方库的可用性对于帮助您轻松入门非常重要。这两种语言周围都有非常活跃的社区，以及值得一看的丰富的软件包生态系统。
Python
- NumPy: Numpy 是在数组数据结构之上实现各种数据操纵操作的基础包。它包含这些数据结构的高效实现，以及用于许多统计计算任务的通用功能，由于其高效的基础，它允许加速许多复杂任务。
- Pandas:Pandas是一个强大且易于使用的开源库，用于表格数据操作任务。它包含高效的数据结构，非常适合直观地处理带标签的数据。
- Matplotlib:Matplotlib是一个用于创建静态或交互式数据可视化的库。由于它的简单性，您可以用几行 Python 代码创建非常详细的图形。
- Scikit-learn: 作为 Python 生态系统中最受欢迎的库之一， scikit-learn 包含基于 Numpy、Pandas 和 Scipy 构建的工具，这些工具专注于各种机器学习任务，例如分类、回归和聚类。
- Tensorflow: 最初由 Google 开发并开源， Tensorflow 是一个非常受欢迎的开源库，用于开发和训练机器学习和深度学习模型。
R
- Dplyr: Dplyr 是一个用于在内存中和内存外轻松处理表格数据的库。
- Ggplot2: Ggplot2 是一个专注于的库，它以《图形的语法一书为基础，以声明方式构建数据可视化。
- data.table :类似于 dplyr， data.table 是一个为数据操作设计的包，具有表达性语法。它实现了高效的数据过滤、选择和整形选项，使您能够在将数据输入模型之前以所需的形状获取数据。
- tidy verse:tidy verse是为数据科学设计的 R 包的集合。它包括许多流行的库，仅举几个例子: ggplot2 用于数据可视化， dplyr 用于直观的数据操作，以及 readr 用于从各种来源读取矩形数据。
- Shiny: Shiny 是一个允许你从 R 构建高度交互的网页的包，它使构建仪表板变得轻而易举。
- Caret: Caret 是专门用于预测模型和机器学习以及数据操作和预处理的工具和函数的集合。
看看库的数量和这些包的功能，似乎两种语言都有相似的包来简化许多数据科学任务。总而言之，对于许多任务来说，当一个任务在 Python 中可行时，它在 R 中也是可行的，并且需要非常相似的努力。
结论
尽管它们似乎提供了不同的东西，但这两种语言都有优缺点，需要仔细了解需求。
- 如果你想从总体上进入编程领域，并寻找可以在软件开发的其他领域使用的东西，比如 T2、web 开发，那么 T4、Python、T7 是一种通用编程语言，T8 似乎是一个更好的选择。
- 如果你熟悉其他科学编程语言，比如 MATLAB ，你可能会更容易学习 R 并利用它提高效率。这些语言之间有许多相似之处，特别是向量运算和关于矩阵运算的一般思维模式，而不是过程方法。
- 如果你需要做特别的分析，并偶尔与其他数据科学家/技术人员分享，使用 Python 和Jupyter Notebooks可能会很好。如果您正在寻找为非技术利益相关者和内部使用构建快速仪表板的方法，那么利用 R 和令人惊叹的 闪亮的 库可能是个好主意。
- 如果您需要开发 API来公开您的模型，或者您需要其他软件来与您的模型进行交互，那么投资于 Python 可能会对您有所帮助，因为它拥有围绕各种编程任务的巨大工具。你可以用一个非常简单的 API 用 Flask 或 FastAPI 来暴露你的模型，或者你可以用 Django 来构建成熟的生产就绪的 web 应用程序。
- 如果你想把所有的软件包都放在手边，主要关注于你的分析来做决策，并寻找最简单的设置来开始， R 可能是那里的首选工具。由于有了 RStudio 及其集成功能，无需离开窗口即可轻松从原始数据转换到可视化分析。尽管 Python 也很容易上手并且默认安装在许多系统中，但多年来，它已经发展成不同的版本和不同的设置，因此，在您的计算机上建立一个功能良好的数据科学堆栈非常重要。
就像任何其他问题一样，解决方案主要取决于问题的需求并且除了“这取决于”之外，这个问题没有正确的答案。这两种语言都非常强大，无论你将时间投入到哪一种语言中，如果你正在长期寻找数据科学的职业生涯，没有错误的答案；学习这两种语言中的任何一种都会在未来给你带来好处，因此，不要陷入分析瘫痪，只需选择一种，继续你的工作。众所周知，这两种语言都能够处理大多数数据科学问题，剩下的归结为方法学、团队的能力和手头的资源，它们大多独立于语言。
既然你已经设法读到这里，这里有一张可爱的浣熊的照片给你，保重。
Python vs R:基础知识
一位有抱负的数据科学家关于在两种流行语言中做出选择的指南。
大多数数据科学家将 Python 或 R 称为他们的“首选”编程语言。两者都有庞大的软件生态系统和社区，所以两种语言都适合几乎任何数据科学任务。
所以问题来了，一个有抱负的数据科学家应该先学哪种语言？长话短说，答案通常是 Python。然而，在潜水之前，每种语言都有自己的优缺点。
此外，值得注意的是，Python 和 R 并不是唯一可用于数据科学的编程语言或工具。其他一些包括 Scala、SAS、Julia、MATLAB 等等。
Python 是什么？
Python 是一种面向对象的高级编程语言，语法简单易学。它于 1991 年推出。Python 3.0 的 2008 修订版使得许多基于 Python 2 的旧库不再向前兼容。大多数数据科学工作现在可以通过五个主要的库来完成: Numpy，Pandas，Scipy，Scikit-learn 和 Seaborn 。
Python 的主要优势是大规模的机器学习的植入。此外，它使可复制性和可访问性变得容易。如果您需要在应用程序或网站中使用您的分析结果，Python 是最佳选择。
R 是什么？
r 是一种用于统计计算和图形的编程语言和环境。r 基于 1976 年推出的 S。所以 R 有时候可以认为是过时的。然而，每天都有新的包被开发出来，使得这种语言能够赶上更“现代”的 Python。
R 与其他统计产品的最大区别是输出。r 有先进的工具来交流结果。例如， Rstudio 附带了库 ggplot2 ，这是一个可视化工具，可以生成盒状图、小提琴图、点状图、带状图等等。
数据科学家用的最多的语言是什么？
[我法师信用
如果你是这个领域的新手，很难知道是使用 Python 还是 r。然而，对于数据科学来说，没有“正确的”编程语言。一种语言并不比另一种更好——这完全取决于您的用例以及您试图回答的问题。
从 Kaggle 在 2019 年的研究中，很明显 Python 是目前数据科学的领先编程语言。SQL 是一种为关系数据库管理设计的语言，排在第二位。但是，在进行数据分析时，它可能会受到限制。由于 R 语言广泛的统计能力，它排在第三位。
Python vs R
[图片由作者提供]
这张图表远非详尽无遗，专家们对哪种语言是“高级”语言争论不休。但是最后，Python 程序员和 R 程序员经常互相借鉴很棒的想法。比如 Python 的 plotnine 数据可视化包，灵感来源于 R 的 ggplot2 包。而 R 的 rvest 网页抓取包的灵感来源于 Python 的 BeautfiulSoup 包。
同样值得注意的是 Python 和 R 之间的互操作性。您可以使用 rpy2 包从 Python 运行 R 代码。您可以使用 reticulate 从 R 运行 Python 代码。这意味着一种语言中的所有特性都可以从另一种语言中访问。
语法上的差异
Python 的“禅”在于有一种合适的方式来编写任何东西。r 没有这一套约定，所以对于初学者来说，编程可能不太结构化，也很难学。让我们来看四个基本的例子，看看它们的异同。
变量:
我们已经知道，我们可以用’ = '操作符在 Python 中给一个变量赋值。
python_apples = 3
在 R 中，我们必须使用一个箭头操作符来给变量赋值。
r_apples <- 3
列表:
类似地，Python 中的列表可以赋给变量，括号内可以是任何数据类型。这些列表可以用元素的索引号进行索引，从 0 开始。
python_list = [1, 'two', 3.0]
python_list[1]
> 'two'
R 中的列表有点不同。它们被括在括号中，每个元素都有一个名称。这些元素可以用“$name”进行索引，但也可以用元素位置进行索引。请注意，R 中的索引从 1 开始，而不是通常的 0。
r_list <- list(num=42, greeting='Hello')
r_list$greeting
> 'Hello'
矢量:
Python 向量只是数字数组。我们可以使用 NumPy 执行算术和附加操作，例如标量乘法和点积。
python_vec = [10,20,30,40,50]
在 R 中，我们用’ c()'而不是括号来包装向量，每个元素都可以通过索引来访问。可以通过给向量赋值“空”来删除向量。
r_vec <- c(10,20,30,40,50)
导入 CSV 文件:
对于 Python，我们必须导入流行的 pandas 库来访问数据帧。一般来说，Python 严重依赖库来执行特定的任务。
import pandas as pd
df = pd.read_csv('file_name.csv')
r 内置了 readr 库函数，优点是速度更快，数据类型解释一致。
library(readr)
r_df <- read_csv('file_name.csv')
这些只是 Python 和 r 中不同语法的基本例子。当你更深入地使用矩阵、数据帧和其他数据结构时，事情显然会变得复杂得多。尤其是 r。
但是从表面上看，每种语言的语法都有很多相似之处。例如，两种语言都使用“#”来注释。此外，单引号和双引号在两种语言中可以互换。
哪种语言最适合数据科学初学者？
对于初学者，建议使用 Python，因为这种语言的语法“可读”。它也比 R，甚至其他编程语言更有表现力，更简洁。
最终，Python 似乎是当今数据科学家最广泛使用的编程语言。它允许集成 SQL、TensorFlow 和许多其他用于数据科学和机器学习的有用函数和库。拥有超过 70，000 个 Python 库，可能性是无限的。
也就是说，数据科学家(或者一般的程序员)不应该局限于一种语言。在一个项目中结合两个领先的软件生态系统来获得一组独特的互补功能是可能的。
虽然 Python 和 R 都是数据科学的绝佳选择，但员工背景、您从事的项目以及您所在行业的文化等因素会影响您的偏好。我鼓励所有有抱负的数据科学家对这两种语言保持开放的心态。在学习 Python 时，请留意 R 可以派上用场的例子。
Python vs R:如何使用 Shiny &机器学习分析 4000 份招聘广告
来源: iStockphoto
一个带有源代码的端到端 ML 系统
作为一名 10 多年的承包商，我总是盯着招聘信息板，问自己
- 有多少角色符合我的技能组合？
- 这些角色工资多少？
- 什么技能是需要的？
- 我应该把学习的重点放在哪里？
2018 年 KDnuggets 发布了文章“Python 蚕食 R:2018 年用于分析、数据科学、机器学习的顶级软件:趋势和分析”。在我的职业生涯中，我已经转换过一次语言——也许是时候把 Python 加入进来了？
我发现自己在查看招聘信息。每一个。单身。日。
这种方法有两个问题。
- 这不太科学。
- 我想更谨慎地使用技术，减少我的屏幕时间。
因此，我在 JobServe 上建立了一个搜索“数据科学家”的网页抓取器。我安排这每天发生，处理数据(删除重复，特征工程，可视化，模型)并将输出发送到一个闪亮的应用程序，该程序可在https://apps.statcore.co.uk/trends-in-data-science/获得
在编写这个应用程序时，它有 4000 份工作的数据，并允许我
- 对古老的 Python vs R 问题做出数据驱动的决策。
- 使用应用于职位描述的主题建模来确定需求技能。
该项目的完整源代码和 docker 图片可以在https://github.com/tonyjward/trends-in-data-science和https://hub.docker.com/r/tonyjward/trends-in-data-science找到
我是这样做的。
数据收集
在 JobServe 上搜索“数据科学家”,目前会给出 35 个结果，并提供大量我们想要捕捉的有趣信息。
在 JobServe 上搜索“数据科学家”
不幸的是，由于网站动态显示内容，并不是所有的搜索结果都能立即看到。用户首先必须从边栏中选择一个作业，然后边栏会更新包含作业详细信息的主面板。这使得 web 抓取变得复杂，因为我们不能简单地抓取和解析 html——这样做只会返回当前所选作业的数据。
硒
因此，我们使用 Selenium——一种自动化的网络浏览器——我们指示它像人类一样与网页进行交互，即在框中输入文本，按 return 键，使用 down 键浏览搜索结果并保存结果。
用硒酸盐刮 Jobserve
特征工程
工资信息是以自由格式文本的形式提供的，其中包含一些需要处理的奇怪和不一致的地方。
问题:提供的薪资范围(50k—70k)
解决方法:取最大值
问题:单位不一致( 50k 对 50000*)
解决方法:如果字符数大于 4，则除以 1000*
问题:非常大的薪水( 每年 60k—900k*)
解决方法:将所有超过 3300k 的薪水除以 100，将所有超过 3300k 的薪水除以 10。*
问题:奴工( )高达 0.00 年息 )
解决方法:视为 NA
复制
由于一个广告显示了 7 天，我们每天都在刮，我们将有重复的广告在我们的数据。另外
- 可以重新公布角色
- 招聘人员可以多次发布虚假的角色来获取简历
因此，我决定使用自由格式的工作描述作为唯一标识符来删除重复的内容。
探索性数据分析
随着数据准备工作的结束，是时候进入正题了。
使用闪亮的应用程序可以访问所有 4000 份工作的数据。用户可以在永久雇佣和合同雇佣之间进行选择，执行关键字搜索或按最高工资或发布日期对数据进行排序。
作业类型
首先，我对合同工和固定工之间的区别感兴趣。
按工作类型划分的角色数量
正如你所料，大多数职位都被宣传为永久性的。不过，我很惊讶地看到，合同工占了全部工作岗位的近 40%。然而，重要的是要记住，JobServe 通常是许多承包商寻找下一个角色的地方，所以我不认为这种分裂代表了整个市场。
工具
根据工作描述中是否提到，我将每份工作分为四类
- Python 而不是 R
- r 但不是 Python
- Python 还是 R
- 两种语言都没有
然后，我观察了这一类别的工作总数是如何变化的。首先是永久性角色:
永久角色的工具流行度
然后，对于合同角色:
合同角色的工具流行度
哇！Python 刚刚在人气上狠批了 R！
薪酬呢？下面的方框图显示了每个组的几个汇总统计数据:
- 工资中位数(水平线)
- 第 25 和第 75 百分位(彩色框的底部和顶部)
对于指定 Python 而非 R 的角色，永久员工的工资中值最高(75k)。指定 R 但不指定 Python 的角色大约少付 20%(60k)。
对于指定 Python 而不是 R ( 600)的角色，承包商的平均日工资最高。指定 R 但不指定 Python 的角色工资大约低 8%(550)。
所以学习 Python 的理由很充分…
主题建模
之前，我将一种叫做潜在狄利克雷分配(LDA)的主题模型应用于客户评论和保险损失理算员笔记，取得了良好的效果，所以我很高兴将这种技术应用于工作描述，看看我能发现什么。
以下内容摘自该算法的共同发明人 David Blei 撰写的主题建模概述。
主题模型是一种算法，用于发现弥漫在大量非结构化文档集合中的主题。主题模型可以根据发现的主题组织系列。
LDA 背后的直觉是文档展示了多个主题。例如，考虑图 1 中的文章。这篇题为“寻找生命最基本的(基因)必需品”的文章是关于使用数据分析来确定一个有机体生存所需的基因数量(从进化的角度来说)。我们用手突出了文章中使用的不同单词。关于数据分析的单词，如“计算机”和“预测”，用蓝色突出显示；关于进化生物学的单词，如“生命”和“有机体”，用粉红色突出显示；关于遗传学的单词，如“测序”和“基因”，用黄色突出显示。
来源:主题建模概述
主题建模允许您“逆向工程”我们假设生成文档的潜在主题。首先，我们必须指定我们希望模型找到多少主题。因为我们正在进行无监督学习，所以这里没有正确的答案——一个好的选择往往是反复试验的结果。
20 个主题
从用 20 个主题训练的主题模型开始，我们使用 LDAvis 来理解每个主题的相关单词。我们发现话题可以按以下方式组织。
- 沟通和商业敏锐度
- 技术
- 招聘人员评论
- 角色优势和要求
- 合同角色
- 数据工程
沟通和商业敏锐度
产生洞察力和有效沟通以交付业务价值的能力是数据科学的核心能力，也是其自身的主题。
技术
该模型确定了一些技术技能，如机器学习和报告。
招聘人员评论
接下来是招聘人员在许多招聘信息中使用的各种主题。其中包括与歧视有关的免责声明，以及几项行动呼吁。
角色优势和要求
该模型已将安全审查确定为一个主题，以及员工可获得的福利(养老金计划、弹性工作制、免费健身房)。
合同角色
该数据包含永久和合同角色的混合，并且该算法已经识别出这一点。
数据工程
有趣的是，数据工程有自己的主题，相关的术语有云计算(aws，azure)和各种技术(sql，hadoop，spark，nosql，kafka)
60 个主题
如果我们想要更精细的视图，我们可以将主题的数量增加到 60 个。当我们这样做时，我们发现“数据工程”被分成了 4 个子主题。
我们也开始看到特定的数据科学应用领域/行业出现，如生物信息学和反洗钱。
整理系列
我们可以使用我们的主题模型来检索与某个主题相关的工作描述。为此，我们从下拉列表中选择一个主题，然后在概率栏中进行过滤。
我们只是带回了所有大概率话题为“aws 工程大数据架构设计”的职位描述。但是请注意，由于模型每天晚上都要重新培训，所以每天的确切主题都会发生变化。
自己试试吧，如果在评论里发现什么有趣的东西，请告诉我！
包扎
这个项目让我能够在不经常检查手机的情况下监测数据科学就业市场的趋势——事实上，在 2019 年 4 月，在阅读了加州大学新港分校的数字极简主义之后，我完全摆脱了我的智能手机。
很早就很清楚，我应该开始学习 Python。根据凯尔·麦基乌的推荐，我通过泽德·肖的艰难地学习 Python，这给了我足够的知识来开始构建东西。
我现在已经在两个客户项目(可再生电力预测和资产监控)中使用了 Python，目前我正在从事一个个人项目，以预测灰狗赛跑的结果！
找到学习一门新语言的时间和动力并不容易——但当我需要一些额外的动力时，我会加载应用程序并研究最新趋势。希望你觉得有用。
Python:学什么，学多少？
命令式、函数式、面向对象:哪种编程范式非常适合我的工作？
JESHOOTS.COM在 Unsplash 上拍照
Python 编程就像是无限的可能性。Web 和互联网开发、基于桌面 GUI 的应用程序、机器学习、深度学习、软件开发、商业应用程序开发 Python 编程的用例有很多。考虑到有这么多东西要学，很容易迷路，不知道多少是太多。
在本文中，我将带您了解 Python 支持的不同编程范例，并帮助您决定应该首先学习哪一种。
编程范式是对编程语言进行分类的一种风格或方式。
Python 支持三种编程范式:命令式、函数式和面向对象。图 1 显示了这些编程范例的特性。
图 1: Python 编程范例
必要的
命令式编程使用语句、循环等向计算机提供明确的步骤。
图 2:命令式编程范例的例子
下面是命令式编程的一个例子。这是一个简单的计算机指令，如何连接列表中提供的字符，并生成一个字符串。
如果运行上面的语句和循环，它将打印
sanrusha
在命令式编程中，命令集可以分组到一个代码块中，也称为过程。
图 3:过程化编程范例的一个例子
上述代码中的语句和循环可以分组到一个过程 (Python 方法)中，如下所示。
现在，可以使用一组字符作为参数来调用 stringc 方法。
stringc([‘s’,’a’,’n’,’r’,’u’,’s’,’h’,’a’])
上述调用将返回
sanrusha
现在，这种方法比以前更加模块化。虽然过程使命令式编程模块化，但状态更改要么局限于过程，要么局限于过程的显式参数或返回。
功能的
函数式编程范式是一种使用内置高阶函数的编程风格。高阶函数将其他函数作为参数，或者将它们作为结果返回。
Python 内置函数像 lambda、map、filter、generators、decorators、recursion都是高阶函数。只要知道自己想要什么，就可以使用最合适的内置 python 函数，用最少的代码行来完成。
图 4:函数式编程范例的例子
下面的代码展示了如何通过使用 Python 高阶函数(如 reduce 和 lambda)在不到三行的代码中将字符组合成字符串。
参考下面的链接，获得 Python 中可用的内置高阶函数的完整列表
[## functools 可调用对象上的高阶函数和运算-Python 3 . 8 . 5 文档
源代码:Lib/functools.py 该模块用于高阶函数:作用于或返回其他函数的函数…
docs.python.org](https://docs.python.org/3/library/functools.html)
面向对象
面向对象编程(OOP)范式如此著名，以至于你不得不尽最大努力去忽视它。面向对象编程如此著名的原因之一是它使代码可重用。这就像拿着一栋建筑的蓝图，按照你自己的喜好建造这栋建筑，比如层数、颜色、地板等等。
面向对象的蓝图叫做类。您可以根据自己的喜好将该类实例化为一个对象。虽然你不能用汽车的蓝图来制造自行车，但是你可以在使用蓝图的时候决定汽车的许多变化。
Python 充满了您将在程序中使用的内置类。虽然从第一天开始就掌握 OOP 并不容易，但好消息是你可能不需要在工作的第一天就从头开始编写 OOP 程序。对于一些工作，您可能永远不需要编写 OOP，您的工作可能通过使用内置类就足够了。
图 Python 面向对象编程的一个例子
下面是一个例子，如何用 OOP 来完成创建一个字符串的任务。
从哪里开始？
现在你的问题来了。
从哪里开始？
答案取决于你将要从事的工作。图 6 显示了基于您的工作应该关注的 python 编程范例。
图 6:掌握工作职能的编程范例
结论
如果你对编程一无所知，对 Python 也有一点了解，那就从命令式范式开始，了解函数式编程的知识。内置高阶 python 函数的知识会给你很大帮助。一旦您熟悉了这些范例，就开始探索面向对象编程。
参考资料:
欢迎来到 Udemy 上最受欢迎的 Python、SQL 和 Oracle 数据库课程。Python 是三大编程之一…
www.udemy.com](https://www.udemy.com/course/python-with-oracle-developer-course/?referralCode=6F68B20A8FB16A20BFE1)
Python:编写定制异常比您想象的要简单
Python 提供了许多内置的异常，然而，有时自己创建异常更有意义
在 Python 中处理运行时错误非常容易。您只需将代码放在 try-except 块中，并处理 Python 提供的许多内置异常类型中的异常。下面是一个用 Python 处理简单错误的例子。
number_followers = 40
"Hello, My name is Shivam and I have " + number_followers + " followers on Medium."
这段代码会产生一个错误，特别是 TypeError，因为+运算符不能将字符串和整数类型相加，我已经在关于魔法方法的独立文章中解释了这些运算符是如何工作的，如果你想阅读相关内容，请查看。让我们试一试这段代码。
try:
number_followers = 40
"My name is Shivam and I have " + number_followers + "on medium."
except TypeError:
print("A string and integer cannot be concatenated")
看，简单明了，但是只有我们需要写代码来连接一个字符串和一个整数。在现实生活中，管理大型代码库，许多团队使用您的代码，引发您的代码中出现的异常，这不是一个好的做法。
尽管 Python 提供了许多内置的异常类型，但有时我们不得不编写定制的异常来满足我们的目的。让我们假设一个程序来计算一个圆的面积，周长和其他一些东西，我们为此创建一个类圆。
编写新的定制异常非常简单。我们需要从内置模块中扩展异常类。
CircleException 现在可以像任何其他内置异常一样被引发
现在，我们可以在代码中出现错误的情况下抛出这个异常，而不必用确切的错误来麻烦客户团队。这样，客户端团队只需处理 CircleException，无论 Circle 类中有什么错误，都会引发该异常。除此之外，我们还可以在客户端修改错误消息，以获得更健壮的日志记录系统。
在客户端，我们只需要捕捉 CircleException 类型。
所以与其这样，
s = Circle(5)try:
s.area()
except TypeError:
print("Something wrong with the values sent")
except AttributeError:
print("Something wrong with the attributes of the class")
except KeyError:
print("Something went wrong with the keys in shape class")
我们将只处理 CircleException，这样客户端就不必处理所有可能与我们的 CircleClass 有关的错误。下面大概是这样的。
我们还可以修改它，并通过引入实例变量向自定义异常添加属性。
让我们通过在 Circle 类中引发 CircleException 时初始化方法名变量来使用它。
现在，客户端将所有的方法放在一个 try-except 下，将能够获得准确的错误消息，该错误消息可以记录在日志系统中。
s = Shape(shape_name='circle', radius=5)try: area = s.area()
circumference = s.circumference()
diameter = s.diameter()except CircleException as e:
print(e)
让我们假设 Circle 类的 area 方法出了问题，没有权限修改 Circle 类的客户端可以很好地处理它，输出将是这样的。
本文帮助您理解如何以及为什么用 Python 编写自定义异常。在很多情况下，编写自定义异常比内置异常更有意义，读完本文后，我希望您对自定义异常有更好的理解，并知道如何抓住这些机会。
如果你喜欢这篇文章并学到了一些东西，请在 twitter 和 medium 上关注我，阅读更多类似的内容。我写关于 Python，数据科学，ML，AI 等等。
使用 Julia 的 Pythonic 大数据？
车床. jl
Python 可以在 Julia 的帮助下处理大堆数据吗？
最近，我一直在尝试用 Julia 作为 Python 的后端。虽然这在理论上肯定是一个伟大的概念，但有些东西似乎在翻译中丢失了。这是我和几位 Julia 和 Python 科学家一直在进行的讨论，因为从 Python 中使用 Julia 的道路目前走得很少。我在另一篇文章中也提到了这个概念，您可以在这里阅读:
Julia 是未来的 ML 语言，还是 Python 不太为人所知的伙伴？
towardsdatascience.com](/is-julias-place-co-existence-with-python-eff2cb834f41)
在本文中，我讨论了 Julia 作为 Python 后端取代 C 的潜力。虽然在某种程度上，我确实认为这是一个奇怪的想法——因为 Julia 并不太难，并且在语法上与 Python 非常相似，这也有一个显著的优势。我认为使用 Python 与 Julia 的兼容层可能有用的原因是，Python 有更成熟的 web 框架，更容易部署，而且 Python 有更多为它创建的高级 API。能够将这些强大的工具与 Julia 的速度结合起来处理更多的数据和更大的算法将是梦想成真。
顶部加载器
作为 Python 和 Julia 共生技术的一部分，我们需要一个名为 TopLoader 的包。TopLoader 是一个 Pythonic 接口，用于管理 Julia 虚拟环境和包。您可以使用 Pip 添加 TopLoader，如下所示:
sudo pip3 install TopLoader
你可以在 Github 上找到 TopLoader:
你好，装载愉快！您可以使用以下命令安装 TopLoader:sudo pip 3 立即从 TopLoader 安装 TopLoader 您可以…
github.com](https://github.com/emmettgb/TopLoader)
要设置 TopLoader，首先需要进入 Python REPL 并导入 TopLoader。这将安装和更新 PyCall，并将 Julia 可执行文件设置为从 Python 运行。当然，你也需要正确安装 Julia 来完成这项工作。Apt 软件包管理器安装 Julia 时存在一个已知问题，TopLoader 将无法找到 Julia。
为了解决这个问题，
不要通过 APT 安装 JULIA！
以下是 Julia Computing 给出的一些 Julian 建议:直接从 Julia Computing 安装 Julia 二进制文件，或 http://julialang 。org。使用 Julia 的包管理器版本会产生以下问题:
- 你可能会有一个过时版本的朱莉娅。例如，我使用 Fedora，Dnf 只有 1.2 版的 Julia，而当前版本是 1.4。如果没有最新版本的 Julia，您将无法使用新功能，例如使用@spawn 进行并行计算，这意味着除了多行 for 循环之外，您将无法运行任何线程。
- 您的 Julia 可执行文件可能会出现在错误的位置。您的包管理器以一种特殊的方式在您的系统上放置文件，拥有一个到/opt 的可执行链接肯定比必须预测每个包管理器将 Julia 二进制文件放在哪里，然后必须通过~/在 Bash 中导出它们更好。或者在每次启动 Julia 之前运行该命令。
当您最终可以导入 TopLoader 时，请确保它是通过 REPL 来完成的。跨越 Julia 和 Python 的解释所涉及的设置不能在其他任何地方发生。
添加车床
车床使用更快的方法和简单的方法。使得包装快速、简单且轻便。许多工具和模型…
车床. ai](http://lathe.ai/)
L athe 使用 Julia 的语法表达式来模拟 Python 和 C++等典型鸭式语言中的类。这很好，因为这意味着模型在通过预测方法运行之前得到了初始化。这意味着我们可以像这样拟合一个模型:
model = LogisticRegression(trainX, trainy)
这个表达式将继续计算逻辑回归模型预测所需的任何值。然后我们可以调用 predict 方法，它是我们新模型对象的子对象，来获取我们的 ŷ.
**ŷ** = model.predict(testX)
为了演示如何使用 Python 中的 Lathe，我们将首先创建一个带有 TopLoader 的环境，然后向其中添加 Lathe:
这个环境已经存在，并且已经有车床在里面了。然而，我们将需要安装车床的不稳定分支，以便我们可以修改和测试它。虽然我们可以从 Python 中做到这一点，但我也想演示一下我们如何从朱莉娅·REPL 中做到这一点，在我看来，这要容易得多，也更有意义。我们需要做的就是在当前目录中输入朱莉娅·REPL:
然后用]进入 Pkg REPL，用激活命令激活我们的环境:
现在我们可以添加或删除任何我们想要的包。
现在，如果我们在 TopLoader 中重新加载我们的环境，并使用 List()函数，我们将获得新的更新版本的 Lathe。
我们可以从我们的环境中使用 using()方法将 Lathe 导入 Python:
每当我们创建一个模型类型的时候，一切都完全按照预期运行。
同样，predict()方法也是如此:
尝试大型数据集
为了确定我们是否真的从使用 Julia 而不是 Python 中获得了性能提升，我们需要一个基线。为了做到这一点，我把同样的线性回归函数翻译成 Python。这是一个相当基本的机器学习模型，所以幸运的是 Python 将能够自己完成我们的许多测试。
def dot(x,y):
lst = []
for i,w in zip(x,y):
lst.append(i * w)
return(lst)
def sq(x):
x = [c ** 2 for c in x]
return(x)
class LinearRegression:
def __init__(self,x,y):
# a = ((∑y)(∑x^2)-(∑x)(∑xy)) / (n(∑x^2) - (∑x)^2)
# b = (x(∑xy) - (∑x)(∑y)) / n(∑x^2) - (∑x)^2
if len(x) != len(y):
pass
# Get our Summations:
Σx = sum(x)
Σy = sum(y)
# dot x and y
xy = dot(x,y)
# ∑dot x and y
Σxy = sum(xy)
# dotsquare x
x2 = sq(x)
# ∑ dotsquare x
Σx2 = sum(x2)
# n = sample size
n = len(x)
# Calculate a
self.a = (((Σy) * (Σx2)) - ((Σx * (Σxy)))) / ((n * (Σx2))-(Σx**2))
# Calculate b
self.b = ((n*(Σxy)) - (Σx * Σy)) / ((n * (Σx2)) - (Σx ** 2))
# The part that is super struct:
def predict(self,xt):
xt = [self.a + (self.b * i) for i in xt]
return(xt)
我还导入了熊猫并读入了我的机器上的两个 CSV 文件，我用它们来进行速度测试。数据集有 10，000，000 个观察值，这可能仍然很容易执行，但几乎肯定会给 Python 一个很好的锻炼。为了给这些计算计时，我将使用 IPython 神奇的命令 timeit。
%timeit LinearRegression(df["X"],df["Y"]).predict(testdf["X"])
我们的结果是 8.78 秒。
与 Julia 在这个精确计算中的速度相比，结果是 0.362333 秒
但是使用 Python 的 TopLoader 呢？我们能期待类似于 Julia、Python 或介于两者之间的性能吗？在最坏的情况下，由于转换层的原因，性能也会受到严重影响。不幸的是，这似乎正是 TopLoader 以 1 分 10 秒的成绩出现时发生的情况。
糟糕透了。
结论
我不得不接受这个无效假设。
简短的回答是否定的，我的估计是正确的，兼容性层导致了太多的速度下降。然而，我认为这个观察可以洞察现实，如果有一个更好的系统，Python 中的 Julia 可能会很棒。TopLoader 的问题是，它需要将 Pythonic 数据转换成 Julian 数据，然后再将这些数据转换回 Julian 数据。也许如果有一种方法可以在后台运行 Julia 实例，从而更有效地从 Python 接收大量数据，那么可能有一种方法可以实现这一点。
随着对一个更好的系统的需求被清楚地阐明，也许我会开始一个新的项目来实现这个目标。然而，与此同时，在处理数据方面，Julia 肯定对 Python 没有任何帮助，而且使用兼容层似乎比使用 Python 本身要慢。虽然这个概念的未来可能是大胆的，甚至可能意味着用更少的努力获得更快的 Python 包，但未来肯定不是现在。
不管 TopLoader 在这方面有什么缺点，我仍然认为它是一个非常酷的包。用 Python 搭建 Julia 虚拟环境当然是一个很酷的想法，我只能希望最终能够确定一种方法来实现这个概念的全部功能。
具有元类的 Pythonic 元编程
你的装饰和元类生存指南。
介绍
元编程是操作代码的代码构造，可以在语法上产生一些非常有趣和富有表现力的结果。元编程并不是一个通常与 Python 联系在一起的概念，但事实是 Python 和 meta 实际上以许多很酷且独特的方式结合在一起。如果你曾经在 Python 中使用过元类或装饰器，那么你实际上是在用 Python 进行元编程。
像大多数高级编程语言一样，在 Python 中，每个单独的变量或对象都有一个类型。类型很重要，因为它们决定了每个变量的数据在内存中的存储方式。Python 中的每种类型都由一个类定义，我们可以通过使用标准库中的 type()函数来说明这一点:
string = "example"
print(type(string))<class 'str'>
string 类型的类是“str”类，它包含 split()之类的方法，这些方法通常用于解析字符。对于任何 Python 程序员来说，这可能都不是一个新概念，但是我们可以更进一步，使用元类来操纵类，而不需要编写它们。
基本用法
与 C、Java 甚至 C++中 int、char 和 float 是主要的数据类型不同，在 Python 中，它们是类中的一个对象。这对 Python 有利也有弊，因为对象是通常不可通用读取的数据类型。这意味着数据经常会卡在 Python 中，但也意味着 Python 中使用的数据是一个类的实例，也就是一个元类的实例。
我们首先需要的是一名室内装潢师。Python 中装饰者的工作是创建一个设计模式，允许我们在不修改类的情况下向类中添加新功能。使用 decorators 将使我们的类保持静态变得非常容易，同时还可以根据需要添加额外的特性。我喜欢让我的类装饰者继承函数装饰者，因为它在我们的代码之间创建了一个更大的边界，这是我们试图避免变异的。
from functools import wrapsdef debug(func):
'''decorator; debugs function when passed.'''
[@wraps](http://twitter.com/wraps)(func)
def wrapper(*args, **kwargs):
print("Full name of this method:", func.__qualname__)
return func(*args, **kwargs)
return wrapper
现在我们可以添加实际的类装饰器了:
def debugmethods(cls):
'''class decorator to use debug method'''
for key, val in vars(cls).items():
if callable(val):
setattr(cls, key, debug(val))
return cls
因此，我们的元类:
class debugMeta(type):
'''meta class which feed created class object
to debugmethod to get debug functionality
enabled objects'''
def __new__(cls, clsname, bases, clsdict):
obj = super().__new__(cls, clsname, bases, clsdict)
obj = debugmethods(obj)
return obj
现在，我们可以通过使用参数(metaclass=)创建一个新类来继承这个新类的数据。
# now all the subclass of this
# will have debugging applied
class Base(metaclass=debugMeta):pass
现在我们可以使用面向对象的继承将元类的属性继承到我们的新类中。每次修改“debugMeta”时，依赖于它的所有子元素都将继承这些更改。这产生了一些有趣的语法，我们可以在不需要修改它的情况下，自动向我们的类添加功能。
# inheriting Base
class Calc(Base):
def add(self, x, y):
return x+y
现在使用计算器:
我们的 calculator 类实际上使用了我们用元类设置的调试行为，但是注意数据不是我们对象的子对象:
结论
虽然 Python 通常不会与元编程的概念联系在一起，但它不仅能够通过其独特的装饰器完美地实现这一概念，而且还在很多方面使用它。我认为 Python 相对于元编程为标准的许多其他语言的最大优势是 Python 的继承性。对于我上面所做的，如果没有继承，这一切都是不可能的，而且在我看来 Python 继承得非常好。由于我们经常将元编程与 Lisp 或 Scheme 之类的语言联系在一起，所以看到元编程以完全不同的方式完成是非常有趣的——而且是以完全不同的语言和完全不同的范式以非常酷的方式完成。最重要的是，decorators 肯定是一个很酷的概念，我真的希望更多的语言会采用它，因为它使元编程的过程变得非常简单和直接。
当将 Python 与其他语言进行比较时，尤其是与我用于元编程的函数式语言进行比较时，情况更是如此。经常折腾宏和表达式可能是强大的，但同时它可能令人难以置信地混乱，我认为 Python 在面对那个确切的问题时很好地利用了它的语法。
Python 的到期日期
Python 这个“大男孩”还要当多久？在脚本中？
(Python 徽标由https://www.python.org/提供)
在过去的十年里，有一种语言的受欢迎程度飙升，并且超过了它所有的前辈，那就是 Python。Python 是一种易于使用、易于阅读、易于修改的面向对象编程语言，由 c 解释。Python 最近成为世界上最受欢迎的编程语言有许多原因，但也有许多原因可能会使它失去这个头衔。
Python 是用来做什么的？
Python 是一种解释型语言，这意味着没有编译器或汇编器能够将这种语言转换成机器代码。相反，另一种语言，在 Python 的情况下是 C，用于解释带有 Python.h 头的语言。通常，这会将 Python 归入脚本类，然而，我认为不要忽视 Python 作为编程主流的地位是很重要的。
可执行？
Python 的一个巨大缺点是 Python 代码不能被编译成可执行文件。任何用 Python 编写的应用程序或工具都需要将 Python 及其依赖项安装在最终用户的系统上。与此同时，每个包的所有正确版本都与用于开发所述应用程序的包相对应。
Web？
Python 已经证明了自己惊人的天赋，那就是运行网站的后端。这也是 Python 相对于很多其他语言的一个优势。Python 有大量不可思议的包来部署 API，甚至设计全功能的网络应用。
机器学习
机器学习是 Python 的另一个突出用途，这无疑有助于近年来 Python 的人气飙升。机器学习是技术的前沿，Python 以及它与 C 的密切关系对于机器学习来说是惊人的有效和有用。虽然 Python 确实缺乏一些类似语言(如 Nim、Julia 和 Go)的性能，但在很多方面，它通过快速、简单、简洁弥补了这一点，但也许更重要的是，
通用。
Unix 操作系统
如果不谈论现代的类 Unix 系统，就很难谈论 Python。Python 2.7 已经被弃用了两个月，我的桌面环境以及我的操作系统中的许多特性仍然使用 Python 2.7。Bash 和 Python 的结合可以产生一些非常有用的脚本来运行服务器、填充数据、完成请求、编辑文件等等。
Python 的缺点
尽管 Python 确实是一门伟大的语言，并对整个世界产生了巨大的影响，但每种语言都有其缺点，Python 也不例外。首先，也是最值得注意的:
Python 很慢。
表演
虽然我当然同意使用日志和 for each 方法，一般来说只是编写更好的代码肯定可以加快 Python 的速度，但在某些情况下，代码肯定会很慢。机器学习是一个很好的例子，因为训练神经网络经常需要递归的致命使用。我无法告诉你有多少次我用 Python 写了一个拉数据的脚本，然后在我的命令行界面(CLI)中经历了超时和变慢。)
通过令人印象深刻的 Cython，人们正在努力缓解这一问题，但在尝试使用 Cython 时，过渡通常并不像苹果和橙子那样简单。尽管在很多场景中 Python 的局限性是不明显的，但如果我说我从来没有为了完成某件事而不得不转向 Julia、Nim 或 C 语言，那我就是在撒谎。
属国
Python 的另一个显著缺点是依赖性和虚拟环境。关于 Python 领域的脚本语言，我认为 Python 在依赖性和虚拟环境方面做得很好。我喜欢把 Python 比作我用来做类似事情的两种语言，Julia 和 Nim，Julia 的依赖世界和 Python 的非常相似。Julia 确实有一个优势，在我看来，虚拟环境要好得多，也更容易使用。
然而，随着 Nim 的加入，Python 在水中被遗弃了。使用 Nim，您可以创建一个包含所有必需依赖项的编译后的可执行文件。在如何为最终用户和部署处理依赖和包的问题上，Nim 轻而易举地胜过了 Python 和 Julia。
Python 的优势
尽管我对 Python 有所抱怨，但我确实喜欢 Python 的许多方面。
庄严的
Python 是一种非常常用的编程语言，它有许多优点，例如:
- 易于谷歌搜索
- 容易谈论
- 伟大的包裹
- 频繁补丁
不仅如此，Python 被证明是值得尊敬和可靠的。这使得 Python 成为初学者的绝佳选择，同时也是那些希望以令人难以置信的速度构建稳定、持久的技术，同时又可以令人难以置信地轻松使用的人的绝佳选择。
看起来像英语
像 Python 这样的语言和类似的脚本语言之间的一个很大的区别就是 Python 的可读性和易理解性。通常阅读 Python 就像阅读一本奇怪的、抽象的关于变量等于数字的书。这不仅使初学者更容易，也使变异、修改和解密更容易，这些都是非常重要的，尤其是对于有数千名开发人员在其中工作的大型代码池。
说实话，我们都宁愿写 Python，也不愿写 c。
是福斯
虽然对一些人来说，他们的语言是否免费和开源并不重要，但对我来说，这当然很重要。Python 基金会的功能主要来自捐赠和教育证书，这意味着 Python 是一个完全免费和开放的软件，有人为你编写代码供你使用，这很好。
Python 要过期了吗？
我经常被问到的一个问题是“你认为 Python 会存在多久？”这个问题经常出现在机器学习领域，因为 Python 有一大堆与机器学习相关的问题。想到任何语言都可能是静态的，并在很长一段时间内保持为最常用的编程语言，这很有趣。
Fortran 是 C 之前的大事件，C 是 C++之前的大事件，C++是 Java 之前的大事件，这个列表还在继续，并将永远继续。计算机是令人兴奋的，因为它们在不断进化，它们所研究的技术也在不断进化。就在 30 年前，16GB 内存的想法还是一个完全古怪的概念，所以根本不知道编程语言的未来会如何。
虽然 Python 最终很可能会被另一种编程语言所取代，但我认为重要的是要记住，人们仍然在编写 Fortran、C、Java 和 c++；因此，Python 本身很可能会伴随我们，并在很长一段时间内被普遍使用，不管它可能变得多么不受欢迎。
其他语言
(src =http://julialang.org/
对 Python 的流行构成最大威胁的可能是其他新的编程语言。我已经讨论过的语言，Julia 和 Nim，只是我认为目前 Python 的两大竞争对手。Julia 肯定会改变我们进行机器学习的方式，而 Nim 肯定会改变高级脚本的游戏规则。
(【https://nim-lang.org/】T2
这些语言可能还没有获得那么多的动力，但是它们展示了一件我认为很重要的事情:
进步是可能的。
也就是说，Python 不是一堵坚固的砖墙，编程语言、机器学习和脚本编写的进步肯定不会就此止步。我认为这些语言不成功的部分原因是因为它们都是统计类型的，而且在大多数情况下
函数式语言，
我知道对于那些坚持使用和热爱 Python 的人来说，这可能是一个非常不和谐的概念。
结论
该不该学 Python？
我对这个问题的回答永远是肯定的。Python 是一门很棒的语言，可以让你入门并熟悉如何解决问题和开始编程。与包括 Julia 和 Nim 在内的其他语言相比，Python 还拥有大量的资源，这使得它更容易学习。
我的目标是提供一个关于编程概念的非常客观的观点，我不认为 Python 会很快消失。然而，我确实认为作为一名程序员不断成长很重要，更重要的是开阔你的视野。如果你已经使用 Python 有一段时间了，也许可以再学一门外语。尝试一种不同范式的语言，并理解这种范式和您所选择的语言的泛型编程方法是如何利用这些概念的。我认为这是有帮助的，因为你不仅可以学会使用更快的方法，还可以学到很多你以前可能不会想到的东西。
Python 的地理编码-将地址列表转换为地图
如何使用地理定位 API 接收绘制客户、工厂、车队和其他主题的地图所需的数据。
我们每个人都有一个数据库，里面有客户的地址，工厂或商店的名单，我们销售产品或合作的地区。在地图上显示这些数据是现代仪表盘的必备功能。为了做到这一点，我们必须将地址(城市名称或地区)转换成地理空间数据——纬度和经度。然后我们可以在引人注目的地图上展示它们。
你会学到什么
在本教程中，我们将探索如何:
- 选择理想的地图服务
- 使用
[requests](#c8f7)连接 API(老式方式) - 用 Python 的
[geopy](#3128)库获取位置(及更多) - 将地址列表转换为地理点
- 用
[folium](#03c6)``[plotly](#03c6)将采集的数据显示在地图上 - 将地图保存成。html 文件
你可以通过 Github-Address to location . ipynb下载这款 jupyter 笔记本，跟随我的脚步。
谁提供制图数据？
要将地址转换成坐标，你可以购买一个带有地理位置的地址数据库，或者查询一些地理定位服务提供商。任何提供地图的人通常都会提供一个地理定位 API(通常需要付费)。让我们回顾一下一些主要的提供商:
- 谷歌地图平台
- 地图框 API
- 必应 API
- OpenStreetMap API——(免费)
- Yandex 地图 API
本文回顾了一些主要的提供商:
[## 十大地图应用程序接口:谷歌地图、必应地图、地图盒子和其他地理定位应用程序接口
地图已经成为你离不开的必备追踪工具。它们是任何公司不可或缺的一部分…
medium.com](https://medium.com/rakuten-rapidapi/top-10-map-apis-google-maps-bing-maps-mapbox-and-other-geolocation-apis-cb442fec07ed)
如何连接到映射 API
大多数 API 都允许直接调用。你把你的地址发送到一个网址，然后接收地理位置信息。多年来，我们使用 python requests库来做这件事。让我们探索对 Google API 的请求。
要连接到 Google API，您需要一个 API 密钥。你必须提出要求，然后保守秘密，因为你为服务付费。谷歌每月免费提供 200 美元，足以完成 40000 次地理编码请求。
地理编码调用通常非常简单:
Base address: [https://maps.googleapis.com/maps/api/geocode/json](https://maps.googleapis.com/maps/api/geocode/json)?
Parameters:
# blank spaces are turned to %20
address=1 Apple Park Way, Cupertino, CA
key=API_KEY
你准备好你想要搜索的数据。在urllib的帮助下，你可以很容易地将参数转换成一个 URL，你调用requests.get().得到的响应要么是 XML，但更常见的是由json.loads处理的json
调用 Google API 将一个地区转换成地理位置
使用 GeoPy 简化您的工作
您可以努力利用映射提供者 API 的文档来充分利用它，但是利用像 GeoPy 这样的现有库更容易。使用 Geopy，您只需几行代码就可以完成上述操作。
Geopy 为流行的地图服务提供了一个类。nomim是广受欢迎的 OpenStreetMap 背后的服务，它允许你免费进行地理编码。但是你应该遵守的使用政策以便让每个人都能使用它:
一般来说，不鼓励对大量数据进行批量地理编码。如果遵循这些附加规则，较小的一次性批量任务是允许的
- 将您的请求限制在单线程
- 仅限 1 台机器，无分布式脚本(包括多个 Amazon EC2 实例或类似实例)
- 结果必须缓存在你这边。重复发送相同查询的客户端可能被分类为有故障和被阻止。
你是有一个小项目还是只想给老板留下好印象？让我们用 geo py . Nominatim 进行地理编码，首先，我们将 nominam 初始化为geolocator变量:
from geopy.geocoders import Nominatim
geolocator = Nominatim(user_agent="example app")
然后你需要一个地区的信息，我选择了意大利的托斯卡纳区:
[In]: geolocator.geocode("**Tuscany, Italy**").raw[Out]: {'place_id': 232933113,
'licence': 'Data © OpenStreetMap contributors, ODbL 1.0\. [https://osm.org/copyright',](https://osm.org/copyright',)
'osm_type': 'relation',
'osm_id': 41977,
'boundingbox': ['42.237615', '44.4725419', '9.6867692', '12.3713544'],
**'lat': '43.4586541'**,
**'lon': '11.1389204'**,
'display_name': 'Toscana, Italia',
'class': 'boundary',
'type': 'administrative',
'importance': 0.6870417219974091,
'icon': 'https://nominatim.openstreetmap.org/images/mapicons/poi_boundary_administrative.p.20.png'}
从响应中，您可以获得纬度和经度
[In]: geolocator.geocode("**Tuscany, Italy**").point
[Out]: Point(43.4586541, 11.1389204, 0.0)
类似地，你可以从一个完整的地址请求地理定位，例如，苹果公司的总部。
# request
geolocator.geocode("1 Apple Park Way, Cupertino, CA")# extract the coordinates:
('37.3337572', '-122.0113815')
Geopy 允许geocode操作将地址转换为坐标，而相反的reverse操作将位置转换为地址:
[In]: geolocator.reverse('37.3337572, -122.0113815')[Out]: Location(Apple Park, 1, Apple Park Way, Monta Vista, Cupertino, Santa Clara County, California, 94087, United States of America, (37.3348469, -122.01139215737962, 0.0))
完整教程使用 GeoPy 收集苹果总部的位置，然后。倒转来确认它是正确的地方
谷歌地理公园
您可以通过 Geopy 使用许多地图服务，只需提供 API 密钥或用户凭据。例如，使用谷歌地图 API:
geolocator = GoogleV3(api_key=AUTH_KEY)
请求地理位置使用与上面相同的代码:
[In]: geolocator.geocode("1 Apple Park Way, Cupertino, CA").point
[Out]: Point(37.3337572, -122.0113815, 0.0)
尽管响应 JSON 的结构将反映所使用的服务。Google 响应中的 Lat 和 Lon 存储在"geometry"."location"中。但是 Geopy 为您做了这项工作，您只需读取.point属性。
将地址列表转换为地理坐标
在地图上显示带有地址的数据集之前，您需要找到这些点的地理位置。让我们来看看这份地址名单:
data = """Name,Address
EU,"Rue de la Loi/Wetstraat 175, Brussel, Belgium"
Apple,"1 Apple Park Way, Cupertino, CA"
Google,"1600 Amphitheatre Parkway Mountain View, CA 94043"
UN,"760 United Nations Plaza; Manhattan, New York City"
"""
我们知道我们可以使用 GeoPy 的geolocator.geocode，但是将熊猫数据帧转换成坐标的最有效方法是什么呢？我喜欢 Abdishakur 在这篇文章中描述的方法
如何将物理地址转换为地理位置→经纬度
towardsdatascience.com](/geocode-with-python-161ec1e62b89)
- 我将从我们的列表中创建一个熊猫数据框架
df = pd.read_csv(io.StringIO(data))
df
2.将geolocator.geocode应用于地址栏
df["loc"] = df["Address"].apply(geolocator.geocode)
3.从地理编码的响应中获取包含纬度和经度的.point，如果它不是None。
df["point"]= df["loc"].apply(lambda loc: tuple(loc.point) if loc else None)
4.将.point拆分成单独的列'lat' 'lon'和'altitude'
df[['lat', 'lon', 'altitude']] = pd.DataFrame(df['point'].to_list(), index=df.index)
步骤 2-4 将从地理编码的响应中挖掘地理位置
数据集中有'lat'和'loc'列就足以在任何背景图上显示这些点。
将地理点转换为地图
地理坐标是没有用的，除非你把它们显示在地图上。Python 提供了几个库来使这项任务变得足够简单。
- leave库，使用leave . js在 OpenStreetMap 或任何其他地图数据提供者的顶部创建典型地图
- plotly 使用其固有的地图数据
用叶子创建地图
树叶地图是交互式的，它们包含带有弹出窗口的标记，可以聚集在具有高密度点的区域中，您可以使用图层并选择不同的源地图。这很容易编码:
# import the library and its Marker clusterization service
import folium
from folium.plugins import MarkerCluster# Create a map object and center it to the avarage coordinates to m
m = folium.Map(location=df[["lat", "lon"]].mean().to_list(), zoom_start=2)# if the points are too close to each other, cluster them, create a cluster overlay with MarkerCluster, add to m
marker_cluster = MarkerCluster().add_to(m)# draw the markers and assign popup and hover texts
# add the markers the the cluster layers so that they are automatically clustered
for i,r in df.iterrows():
location = (r["lat"], r["lon"])
folium.Marker(location=location,
popup = r['Name'],
tooltip=r['Name'])\
.add_to(marker_cluster)# display the map
m
一张有叶子的简单地图。硅谷聚集了太多的点。
使用 Plotly 创建地图
Plotly 越来越受欢迎。因为它引入了 Plotly express 接口，所以创建图表是一个单独的线性过程，这也适用于地图图表。下面我们来看看如何用 Plotly 创建一个类似的地图。
# import the plotly express
import plotly.express as px# set up the chart from the df dataFrame
fig = px.scatter_geo(df,
# longitude is taken from the df["lon"] columns and latitude from df["lat"]
lon="lon",
lat="lat",
# choose the map chart's projection
projection="natural earth",
# columns which is in bold in the pop up
hover_name = "Name",
# format of the popup not to display these columns' data
hover_data = {"Name":False,
"lon": False,
"lat": False
}
)
.scatter_geo(df)根据测向数据帧中的数据在地图上创建点，如位置或弹出窗口。我们可以为每个数据点设置不同的大小或颜色，但我们在 df 数据帧中没有这样做，所以我们可以使用.update_traces()为所有数据点指定相同的大小或颜色。
fig.update_traces(marker=dict(size=25, color="red"))
你不必像在 leav 中那样确定理想的缩放比例，只需将fitbounds设置为“位置”即可。您还可以显示国家、河流、海洋、湖泊，并用.update_geos指定它们的颜色。
fig.update_geos(fitbounds="locations", showcountries = True)
最后，让我们使用.update_layout添加一个标题，并通过fig.show()显示最终的图表。
fig.update_layout(title = "Your customers")
fig.show()
一个简单的地图。
将地图导出到 html
欣赏笔记本中的地图可能会令人满意，但偶尔您希望与没有安装 python 的人共享您的工作。幸运的是将地图导出到。html 只有一行代码。
Folium 的.save方法创建了一个文件，该文件从 CDN 获得所有必要的资源，如 jquery、bootstrap、leaflet，并且该文件只有 8 KB。
m.save("folium_map.html")
Plotly 使用带有几个可选参数的.write_html命令。最重要的是include_plotlyjs。您可以设置输出文件是否将包含超过 3 MB 的 plotly 库，以实现那些漂亮的图表效果，或者您是否只想要可以包含在另一个 plotly 项目中的数据点。在第二种情况下，大小将是 9 KB。
fig.write_html("plotly_map.html", include_plotlyjs=True)
结论
在地图上显示数据是展示公司数据的有效方式。Python 的库帮助我们快速收集必要的地理空间数据，并使用它们绘制地图。您可以使用开源数据或付费服务来完成这项任务。
你想寻找更多的灵感吗，试试 plotly 和 leav 地图集
Plotly 的 Python 图形库可以制作交互式、出版物质量的在线地图。如何使用…制作地图的示例
plotly.com](https://plotly.com/python/maps/) [## Jupyter 笔记本浏览器
编辑描述
nbviewer.jupyter.org](https://nbviewer.jupyter.org/github/python-visualization/folium/tree/master/examples/)
您喜欢本教程吗，请查看我的其他关于各种数据相关主题的文章:
sklearn 交叉验证的示例和使用案例解释了 k 折叠、洗牌、分层以及它如何影响…
towardsdatascience.com](/complete-guide-to-pythons-cross-validation-with-examples-a9676b5cac12) [## 阅读熊猫 CSV 时处理多余的空格
为什么我们关心空白？内置熊猫功能，自定义处理。创建 1M 测试数据和…
towardsdatascience.com](/dealing-with-extra-white-spaces-while-reading-csv-in-pandas-67b0c2b71e6a)
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
