比较世界上最流行的两种编程语言，并在投票中让我们知道你喜欢哪一个。

让我们比较一下世界上两种最受欢迎、最强大的编程语言：Java 和 Python！这两种语言有巨大的社区支持和库来执行几乎任何编程任务，尽管选择编程语言通常取决于开发人员的场景。在比较和对比之后，请投票分享你的观点。

是什么？

• Java 是一门通用面向对象的编程语言，主要用于开发从移动端到 Web 到企业级应用的各种应用。
• Python 是一门高级面向对象的编程语言，主要用于 Web 开发、人工智能、机器学习、自动化和其他数据科学应用。

创建者

• Java 是由 James Gosling（Sun Microsystems）创造的。
• Python 是由 Guido van Rossum 创造的。

开源状态

• Java 是免费的，（大部分）开源，但商业用途除外。
• Python 对于所有场景都是免费、开源的。

平台依赖

• Java 根据它的 WORA (“ 一次编写，到处运行 write once, run anywhere ”)哲学，它是平台无关的。
• Python 依赖于平台。

编译或解释

• Java 是一门编译语言。Java 程序在编译时转换为字节码，而不是运行时。
• Python 是一门解释性语言。Python 程序在运行时进行解释。

文件创建

• Java：编译后生成 <filename>.class 文件。
• Python：在运行期，创建 <filename>.pyc 文件。

错误类型

• Java 有 2 种错误类型：编译和运行时错误。
• Python 有 1 种错误类型：回溯（或运行时）错误。

静态或动态类型

• Java 是静态类型。当初始化变量时，需要在程序中指定变量的类型，因为类型检查是在编译时完成的。
• Python 是动态类型。变量不需要在初始化时指定类型，因为类型检查是在运行时完成的。

语法

• Java：每个语句都需要以分号（; ）结尾，并且代码块由大括号（ {} ）分隔。
• Python：代码块通过缩进分隔（用户可以选择要使用的空格数，但在整个块中应保持一致）。

类的数量

• Java：在 Java 中的单个文件中只能存在一个公有顶级类。
• Python：Python 中的单个文件中可以存在任意数量的类。

代码多少？

• Java 通常比 Python 要写更多代码行。
• Python通常比 Java 要写更少代码行。

多重继承

• Java 不支持多重继承（从两个或多个基类继承）。
• Python 支持多重继承，但由于继承复杂性、层次结构、依赖等各种问题，它很少实现。

多线程

• Java 多线程可以支持同时运行的两个或多个并发线程。
• Python 使用全局解释器锁 （GIL），一次只允许运行单个线程（一个 CPU 核）。

执行速度

• Java 的执行时间通常比 Python 快。
• Python 的执行时间通常比 Java 慢。

Hello world

Java 的：

public class Hello {
   public static void main([String][3][] args) {
      [System][4].out.println("Hello Opensource.com from Java!");
   }
}

Python 的：

print("Hello Opensource.com from Java!")

运行程序

要运行 java 程序 Hello.java，你需要先编译它，这将创建一个 Hello.class 文件。只需运行类名 java Hello。对于 Python，只需运行文件 python3 helloworld.py。

via: https://opensource.com/article/19/12/java-vs-python

作者：Archit Modi 选题：lujun9972 译者：geekpi 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

将一个 awk 脚本移植到 Python 主要在于代码风格而不是转译。

脚本是解决问题的有效方法，而 awk 是编写脚本的出色语言。它特别擅长于简单的文本处理，它可以带你完成配置文件的某些复杂重写或目录中文件名的重新格式化。

何时从 awk 转向 Python

但是在某些方面，awk 的限制开始显现出来。它没有将文件分解为模块的真正概念，它缺乏质量错误报告，并且缺少了现在被认为是编程语言工作原理的其他内容。当编程语言的这些丰富功能有助于维护关键脚本时，移植将是一个不错的选择。

我最喜欢的完美移植 awk 的现代编程语言是 Python。

在将 awk 脚本移植到 Python 之前，通常值得考虑一下其原始使用场景。例如，由于 awk 的局限性，通常从 Bash 脚本调用 awk 代码，其中包括一些对 sed、sort 之类的其它命令行常见工具的调用。 最好将所有内容转换为一个一致的 Python 程序。有时，脚本会做出过于宽泛的假设，例如，即使实际上只运行一个文件，该代码也可能允许任意数量的文件。

在仔细考虑了上下文并确定了要用 Python 替代的东西之后，该编写代码了。

标准 awk 到 Python 功能

以下 Python 功能是有用的，需要记住：

with open(some_file_name) as fpin:
    for line in fpin:
        pass # do something with line

此代码将逐行循环遍历文件并处理这些行。

如果要访问行号（相当于 awk 的 NR），则可以使用以下代码：

with open(some_file_name) as fpin:
    for nr, line in enumerate(fpin):
        pass # do something with line

在 Python 中实现多文件的 awk 式行为

如果你需要能够遍历任意数量的文件同时保持行数的持续计数（类似 awk 的 FNR），则此循环可以做到这一点：

def awk_like_lines(list_of_file_names):
    def _all_lines():
        for filename in list_of_file_names:
            with open(filename) as fpin:
                yield from fpin
    yield from enumerate(_all_lines())

此语法使用 Python 的生成器和 yield from 来构建迭代器，该迭代器将遍历所有行并保持一个持久计数。

如果你需要同时使用 FNR 和 NR，这是一个更复杂的循环：

def awk_like_lines(list_of_file_names):
    def _all_lines():
        for filename in list_of_file_names:
            with open(filename) as fpin:
                yield from enumerate(fpin)
    for nr, (fnr, line) in _all_lines:
        yield nr, fnr, line

更复杂的 FNR、NR 和行数的 awk 行为

如果 FNR、NR 和行数这三个你全都需要，仍然会有一些问题。如果确实如此，则使用三元组（其中两个项目是数字）会导致混淆。命名参数可使该代码更易于阅读，因此最好使用 dataclass：

import dataclass

@dataclass.dataclass(frozen=True)
class AwkLikeLine:
    content: str
    fnr: int
    nr: int

def awk_like_lines(list_of_file_names):
    def _all_lines():
        for filename in list_of_file_names:
            with open(filename) as fpin:
                yield from enumerate(fpin)
    for nr, (fnr, line) in _all_lines:
        yield AwkLikeLine(nr=nr, fnr=fnr, line=line)

你可能想知道，为什么不一直用这种方法呢？使用其它方式的的原因是总用这种方法太复杂了。如果你的目标是把一个通用库更容易地从 awk 移植到 Python，请考虑这样做。但是编写一个可以使你确切地了解特定情况所需的循环的方法通常更容易实现，也更容易理解（因而易于维护）。

理解 awk 字段

一旦有了与一行相对应的字符串，如果要转换 awk 程序，则通常需要将其分解为字段。Python 有几种方法可以做到这一点。这将把行按任意数量的连续空格拆分，返回一个字符串列表：

line.split()

如果需要另一个字段分隔符，比如以 : 分隔行，则需要 rstrip 方法来删除最后一个换行符：

line.rstrip("\n").split(":")

完成以下操作后，列表 parts 将存有分解的字符串：

parts = line.rstrip("\n").split(":")

这种拆分非常适合用来处理参数，但是我们处于偏差一个的错误场景中。现在 parts[0] 将对应于 awk 的 $1，parts[1] 将对应于 awk 的 $2，依此类推。之所以偏差一个，是因为 awk 计数“字段”从 1 开始，而 Python 从 0 开始计数。在 awk 中，$0 是整个行 —— 等同于 line.rstrip("\n")，而 awk 的 NF（字段数）更容易以 len(parts) 的形式得到。

移植 awk 字段到 Python

例如，让我们将这个单行代码“如何使用 awk 从文件中删除重复行”转换为 Python。

awk 中的原始代码是：

awk '!visited[$0]++' your_file > deduplicated_file

“真实的” Python 转换将是：

import collections
import sys

visited = collections.defaultdict(int)
for line in open("your_file"):
    did_visit = visited[line]
    visited[line] += 1
    if not did_visit:
        sys.stdout.write(line)

但是，Python 比 awk 具有更多的数据结构。与其计数访问次数（除了知道是否看到一行，我们不使用它），为什么不记录访问的行呢？

import sys

visited = set()
for line in open("your_file"):
    if line in visited:
        continue
    visited.add(line)
    sys.stdout.write(line)

编写 Python 化的 awk 代码

Python 社区提倡编写 Python 化的代码，这意味着它要遵循公认的代码风格。更加 Python 化的方法将区分唯一性和输入/输出的关注点。此更改将使对代码进行单元测试更加容易：

def unique_generator(things):
    visited = set()
    for thing in things:
        if thing in visited:
            continue
        visited.add(things)
        yield thing

import sys
   
for line in unique_generator(open("your_file")):
    sys.stdout.write(line)

将所有逻辑置于输入/输出代码之外，可以更好地分离问题，并提高代码的可用性和可测试性。

结论：Python 可能是一个不错的选择

将 awk 脚本移植到 Python 时，通常是在考虑适当的 Python 代码风格时重新实现核心需求，而不是按条件/操作进行笨拙的音译。考虑原始上下文并产生高质量的 Python 解决方案。虽然有时候使用 awk 的 Bash 单行代码可以完成这项工作，但 Python 编码是通往更易于维护的代码的途径。

另外，如果你正在编写 awk 脚本，我相信您也可以学习 Python！如果你有任何疑问，请告诉我。

via: https://opensource.com/article/19/11/awk-to-python

作者：Moshe Zadka 选题：lujun9972 译者：wxy 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

Python 2 将在几周内走到生命终点，这篇文章是你迁移到 Python 3 之前应该知道的。

从 2020 年 1 月 1 日开始，Python 2.7 将不再得到正式支持。在此日期之后，将会发布一个最终错误修复计划，但是仅此而已。

Python 2 的生命终点（EOL）对你意味着什么？如果正在运行着 Python 2，你需要迁移。

是谁决定 Python 2 的生命终点？

在 2012 年，维护 Python 编程语言的团队审查了其选项。有两个越来越不同的代码库，Python 2 和 Python 3。这两者都很流行，但是较新的版本并未得到广泛采用。

除了 Python 3 中完全重写的 Unicode 支持改变了处理数据的底层方式造成的断层，这个主要版本的变化还一次性出现了一些非向后兼容的更改。这种断层的决定成文于 2006 年。为了减轻该断层的影响，Python 2 继续保持了维护，并向后移植了一些 Python 3 的功能。为了进一步帮助社区过渡，EOL 日期从 2015 年延长至 2020 年，又延长了五年。

该团队知道，维护不同的代码库是必须解决的麻烦。最终，他们宣布了一项决定：

“我们是制作和照料 Python 编程语言的志愿者。我们已决定 2020 年 1 月 1 日将是我们停止使用 Python 2 的日子。这意味着在这一天之后，即使有人发现其中存在安全问题，我们也将不再对其进行改进。你应尽快升级到 Python 3。”

Nick Coghlan 是 CPython 的核心开发人员，也是 Python 指导委员会的现任成员，在他的博客中添加了更多信息。由 Barry Warsaw（也是 Python 指导委员会的成员）撰写的 PEP 404 详细说明了 Python 2.8 永远不会面世的原因。

有人还在支持 Python 2 吗？

提供者和供应商对 Python 2 的支持会有所不同。Google Cloud 宣布了它计划未来如何支持 Python 2。红帽还宣布了红帽企业 Linux（RHEL）的计划，而 AWS 宣布了 AWS 命令行界面和 SDK 的次要版本更新要求。

你还可以阅读 Vicki Boykis 在 Stack Overflow 撰写的博客文章“为什么迁移到 Python 3 需要这么长时间？”，其中她指出了采用 Python 3 缓慢的三个原因。

使用 Python 3 的原因

不管是否有持续的支持，尽快迁移到 Python 3 是一个好主意。Python 3 将继续受到支持，它具有 Python 2 所没有的一些非常优雅的东西。

最近发布的 Python 3.8 包含 海象运算符、位置参数和自描述的格式化字符串等功能。Python 3 的早期版本引入的功能，例如 异步 IO、格式化字符串、类型提示 和 pathlib，这里只提及了一点点。

下载最多的前 360 个软件包已迁移到 Python 3。你可以使用 caniusepython3 软件包检查你的 requirements.txt 文件，以查看你依赖的任何软件包是否尚未迁移。

将 Python 2 移植到 Python 3 的参考资源

有许多参考资源可简化你向 Python 3 的迁移。例如，“将 Python 2 移植到 Python 3 指南”列出了许多工具和技巧，可帮助你实现与 Python 2/3 单一源代码的兼容性。在 Python3statement.org 上也有一些有用的技巧。

Dustin Ingram 和 Chris Wilcox 在 Cloud Next ‘19上作了一个演讲，详细介绍了向 Python 3 过渡的一些动机和迁移模式。Trey Hunner 在 PyCon 2018 演讲上介绍了 Python 3 最有用的功能，鼓励你进行迁移，以便你可以利用它们。

加入我们！

距 2020 年 1 月 1 日仅有几周了。如果你需要每天提醒一下它即将到来的时间（并且你使用 Twitter 的话），请关注 Python 2 日落倒计时 Twitter 机器人。

via: https://opensource.com/article/19/11/end-of-life-python-2

作者：Katie McLaughlin 选题：lujun9972 译者：wxy 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

最好将文档作为开发过程的一部分。Sphinx 加上 Tox，让文档可以轻松书写，并且外观漂亮。

Python 代码可以在源码中包含文档。这种方式默认依靠 docstring，它以三引号格式定义。虽然文档的价值是很大的，但是没有充足的文档的代码还是很常见。让我们演练一个场景，了解出色的文档的强大功能。

经历了太多在白板技术面试上要求你实现斐波那契数列，你已经受够了。你回家用 Python 写了一个可重用的斐波那契计算器，使用浮点技巧来实现 O(1) 复杂度。

代码很简单：

# fib.py
import math

_SQRT_5 = math.sqrt(5)
_PHI = (1 + _SQRT_5) / 2

def approx_fib(n):
    return round(_PHI**(n+1) / _SQRT_5)

（该斐波那契数列是四舍五入到最接近的整数的几何序列，这是我最喜欢的鲜为人知的数学事实之一。）

作为一个好人，你可以将代码开源，并将它放在 PyPI 上。setup.py 文件很简单：

import setuptools

setuptools.setup(
    name='fib',
    version='2019.1.0',
    description='Fibonacci',
    py_modules=["fib"],
)

但是，没有文档的代码是没有用的。因此，你可以向函数添加 docstring。我最喜欢的 docstring 样式之一是 “Google” 样式。标记很轻量，当它放在源代码中时很好。

def approx_fib(n):
    """
    Approximate Fibonacci sequence

    Args:
        n (int): The place in Fibonacci sequence to approximate

    Returns:
        float: The approximate value in Fibonacci sequence
    """
    # ...

但是函数的文档只是成功的一半。普通文档对于情境化代码用法很重要。在这种情况下，情景是恼人的技术面试。

有一种添加更多文档的方式，专业 Python 人的方式通常是在 docs/ 添加 rst 文件（ reStructuredText 的缩写）。因此 docs/index.rst 文件最终看起来像这样：

Fibonacci
=========

Are you annoyed at tech interviewers asking you to implement
the Fibonacci sequence?
Do you want to have some fun with them?
A simple
:code:`pip install fib`
is all it takes to tell them to,
um,
fib off.

.. automodule:: fib
   :members:

我们完成了，对吧？我们已经将文本放在了文件中。人们应该会看的。

使 Python 文档更漂亮

为了使你的文档看起来更漂亮，你可以利用 Sphinx，它旨在制作漂亮的 Python 文档。这三个 Sphinx 扩展特别有用：

• sphinx.ext.autodoc：从模块内部获取文档
• sphinx.ext.napoleon：支持 Google 样式的 docstring
• sphinx.ext.viewcode：将 ReStructured Text 源码与生成的文档打包在一起

为了告诉 Sphinx 该生成什么以及如何生成，我们在 docs/conf.py 中配置一个辅助文件：

extensions = [
    'sphinx.ext.autodoc',
    'sphinx.ext.napoleon',
    'sphinx.ext.viewcode',
]
# 该入口点的名称，没有 .rst 扩展名。
# 惯例该名称是 index
master_doc = "index"
# 这些值全部用在生成的文档当中。
# 通常，发布（release）与版本（version）是一样的，
# 但是有时候我们会有带有 rc 标签的发布。
project = "Fib"
copyright = "2019, Moshe Zadka"
author = "Moshe Zadka"
version = release = "2019.1.0"

此文件使我们可以使用所需的所有元数据来发布代码，并注意扩展名（上面的注释说明了方式）。最后，要确保生成我们想要的文档，请使用 Tox 管理虚拟环境以确保我们顺利生成文档：

[tox]
# 默认情况下，`.tox` 是该目录。
# 将其放在非点文件中可以从
# 文件管理器或浏览器的
# 打开对话框中打开生成的文档，
# 这些对话框有时会隐藏点文件。
toxworkdir = {toxinidir}/build/tox

[testenv:docs]
# 从 `docs` 目录内运行 `sphinx`，
# 以确保它不会拾取任何可能进入顶层目录下的
# 虚拟环境或 `build/` 目录下的其他工件的杂散文件。
changedir = docs
# 唯一的依赖关系是 `sphinx`。
# 如果我们使用的是单独打包的扩展程序，
# 我们将在此处指定它们。
# 更好的做法是指定特定版本的 sphinx。
deps =
    sphinx
# 这是用于生成 HTML 的 `sphinx` 命令。
# 在其他情况下，我们可能想生成 PDF 或电子书。
commands =
    sphinx-build -W -b html -d {envtmpdir}/doctrees . {envtmpdir}/html
# 我们使用 Python 3.7。
# Tox 有时会根据 testenv 的名称尝试自动检测它，
# 但是 `docs` 没有给出有用的线索，因此我们必须明确它。
basepython = python3.7

现在，无论何时运行 Tox，它都会为你的 Python 代码生成漂亮的文档。

在 Python 中写文档很好

作为 Python 开发人员，我们可以使用的工具链很棒。我们可以从 docstring 开始，添加 .rst 文件，然后添加 Sphinx 和 Tox 来为用户美化结果。

你对好的文档有何评价？你还有其他喜欢的方式么？请在评论中分享它们！

via: https://opensource.com/article/19/11/document-python-sphinx

作者：Moshe Zadka 选题：lujun9972 译者：geekpi 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

使用 Python 开展数据科学为你提供了无限的潜力，使你能够以有意义和启发性的方式解析、解释和组织数据。

数据科学是计算领域一个令人兴奋的新领域，它围绕分析、可视化和关联以解释我们的计算机收集的有关世界的无限信息而建立。当然，称其为“新”领域有点不诚实，因为该学科是统计学、数据分析和普通而古老的科学观察派生而来的。

但是数据科学是这些学科的形式化分支，拥有自己的流程和工具，并且可以广泛应用于以前从未产生过大量不可管理数据的学科（例如视觉效果）。数据科学是一个新的机会，可以重新审视海洋学、气象学、地理学、制图学、生物学、医学和健康以及娱乐行业的数据，并更好地了解其中的模式、影响和因果关系。

像其他看似包罗万象的大型领域一样，知道从哪里开始探索数据科学可能会令人生畏。有很多资源可以帮助数据科学家使用自己喜欢的编程语言来实现其目标，其中包括最流行的编程语言之一：Python。使用 Pandas、Matplotlib 和 Seaborn 这些库，你可以学习数据科学的基本工具集。

如果你对 Python 的基本用法不是很熟悉，请在继续之前先阅读我的 Python 介绍。

创建 Python 虚拟环境

程序员有时会忘记在开发计算机上安装了哪些库，这可能导致他们提供了在自己计算机上可以运行，但由于缺少库而无法在所有其它电脑上运行的代码。Python 有一个系统旨在避免这种令人不快的意外：虚拟环境。虚拟环境会故意忽略你已安装的所有 Python 库，从而有效地迫使你一开始使用通常的 Python 进行开发。

为了用 venv 激活虚拟环境, 为你的环境取个名字 (我会用 example) 并且用下面的指令创建它:

$ python3 -m venv example

导入 source 该环境的 bin 目录里的 activate 文件以激活它：

$ source ./example/bin/activate
(example) $

你现在“位于”你的虚拟环境中。这是一个干净的状态，你可以在其中构建针对该问题的自定义解决方案，但是额外增加了需要有意识地安装依赖库的负担。

安装 Pandas 和 NumPy

你必须在新环境中首先安装的库是 Pandas 和 NumPy。这些库在数据科学中很常见，因此你肯定要时不时安装它们。它们也不是你在数据科学中唯一需要的库，但是它们是一个好的开始。

Pandas 是使用 BSD 许可证的开源库，可轻松处理数据结构以进行分析。它依赖于 NumPy，这是一个提供多维数组、线性代数和傅立叶变换等等的科学库。使用 pip3 安装两者：

(example) $ pip3 install pandas

安装 Pandas 还会安装 NumPy，因此你无需同时指定两者。一旦将它们安装到虚拟环境中，安装包就会被缓存，这样，当你再次安装它们时，就不必从互联网上下载它们。

这些是你现在仅需的库。接下来，你需要一些样本数据。

生成样本数据集

数据科学都是关于数据的，幸运的是，科学、计算和政府组织可以提供许多免费和开放的数据集。虽然这些数据集是用于教育的重要资源，但它们具有比这个简单示例所需的数据更多的数据。你可以使用 Python 快速创建示例和可管理的数据集：

#!/usr/bin/env python3

import random

def rgb():
    NUMBER=random.randint(0,255)/255
    return NUMBER

FILE = open('sample.csv','w')
FILE.write('"red","green","blue"')
for COUNT in range(10):
    FILE.write('\n{:0.2f},{:0.2f},{:0.2f}'.format(rgb(),rgb(),rgb()))

这将生成一个名为 sample.csv 的文件，该文件由随机生成的浮点数组成，这些浮点数在本示例中表示 RGB 值（在视觉效果中通常是数百个跟踪值）。你可以将 CSV 文件用作 Pandas 的数据源。

使用 Pandas 提取数据

Pandas 的基本功能之一是可以提取数据和处理数据，而无需程序员编写仅用于解析输入的新函数。如果你习惯于自动执行此操作的应用程序，那么这似乎不是很特别，但请想象一下在 LibreOffice 中打开 CSV 并且必须编写公式以在每个逗号处拆分值。Pandas 可以让你免受此类低级操作的影响。以下是一些简单的代码，可用于提取和打印以逗号分隔的值的文件：

#!/usr/bin/env python3

from pandas import read_csv, DataFrame
import pandas as pd

FILE = open('sample.csv','r')
DATAFRAME = pd.read_csv(FILE)
print(DATAFRAME)

一开始的几行导入 Pandas 库的组件。Pandas 库功能丰富，因此在寻找除本文中基本功能以外的功能时，你会经常参考它的文档。

接下来，通过打开你创建的 sample.csv 文件创建变量 FILE。Pandas 模块 read_csv（在第二行中导入）使用该变量来创建 数据帧 dataframe 。在 Pandas 中，数据帧是二维数组，通常可以认为是表格。数据放入数据帧中后，你可以按列和行进行操作，查询其范围，然后执行更多操作。目前，示例代码仅将该数据帧输出到终端。

运行代码。你的输出会和下面的输出有些许不同，因为这些数字都是随机生成的，但是格式都是一样的。

(example) $ python3 ./parse.py
    red  green  blue
0  0.31   0.96  0.47
1  0.95   0.17  0.64
2  0.00   0.23  0.59
3  0.22   0.16  0.42
4  0.53   0.52  0.18
5  0.76   0.80  0.28
6  0.68   0.69  0.46
7  0.75   0.52  0.27
8  0.53   0.76  0.96
9  0.01   0.81  0.79

假设你只需要数据集中的红色值（red），你可以通过声明数据帧的列名称并有选择地仅打印你感兴趣的列来做到这一点：

from pandas import read_csv, DataFrame
import pandas as pd

FILE = open('sample.csv','r')
DATAFRAME = pd.read_csv(FILE)

# define columns
DATAFRAME.columns = [ 'red','green','blue' ]

print(DATAFRAME['red'])

现在运行代码，你只会得到红色列：

(example) $ python3 ./parse.py
0    0.31
1    0.95
2    0.00
3    0.22
4    0.53
5    0.76
6    0.68
7    0.75
8    0.53
9    0.01
Name: red, dtype: float64

处理数据表是经常使用 Pandas 解析数据的好方法。从数据帧中选择数据的方法有很多，你尝试的次数越多就越习惯。

可视化你的数据

很多人偏爱可视化信息已不是什么秘密，这是图表和图形成为与高层管理人员开会的主要内容的原因，也是“信息图”在新闻界如此流行的原因。数据科学家的工作之一是帮助其他人理解大量数据样本，并且有一些库可以帮助你完成这项任务。将 Pandas 与可视化库结合使用可以对数据进行可视化解释。一个流行的可视化开源库是 Seaborn，它基于开源的 Matplotlib。

安装 Seaborn 和 Matplotlib

你的 Python 虚拟环境还没有 Seaborn 和 Matplotlib，所以用 pip3 安装它们。安装 Seaborn 的时候，也会安装 Matplotlib 和很多其它的库。

(example) $ pip3 install seaborn

为了使 Matplotlib 显示图形，你还必须安装 PyGObject 和 Pycairo。这涉及到编译代码，只要你安装了必需的头文件和库，pip3 便可以为你执行此操作。你的 Python 虚拟环境不了解这些依赖库，因此你可以在环境内部或外部执行安装命令。

在 Fedora 和 CentOS 上：

(example) $ sudo dnf install -y gcc zlib-devel bzip2 bzip2-devel readline-devel \
sqlite sqlite-devel openssl-devel tk-devel git python3-cairo-devel \
cairo-gobject-devel gobject-introspection-devel

在 Ubuntu 和 Debian 上：

(example) $ sudo apt install -y libgirepository1.0-dev build-essential \
libbz2-dev libreadline-dev libssl-dev zlib1g-dev libsqlite3-dev wget \
curl llvm libncurses5-dev libncursesw5-dev xz-utils tk-dev libcairo2-dev

一旦它们安装好了，你可以安装 Matplotlib 需要的 GUI 组件。

(example) $ pip3 install PyGObject pycairo

用 Seaborn 和 Matplotlib 显示图形

在你最喜欢的文本编辑器新建一个叫 vizualize.py 的文件。要创建数据的线形图可视化，首先，你必须导入必要的 Python 模块 —— 先前代码示例中使用的 Pandas 模块：

#!/usr/bin/env python3

from pandas import read_csv, DataFrame
import pandas as pd

接下来，导入 Seaborn、Matplotlib 和 Matplotlib 的几个组件，以便你可以配置生成的图形：

import seaborn as sns
import matplotlib
import matplotlib.pyplot as plt
from matplotlib import rcParams

Matplotlib 可以将其输出导出为多种格式，包括 PDF、SVG 和桌面上的 GUI 窗口。对于此示例，将输出发送到桌面很有意义，因此必须将 Matplotlib 后端设置为 GTK3Agg。如果你不使用 Linux，则可能需要使用 TkAgg 后端。

设置完 GUI 窗口以后，设置窗口大小和 Seaborn 预设样式：

matplotlib.use('GTK3Agg')
rcParams['figure.figsize'] = 11,8
sns.set_style('darkgrid')

现在，你的显示已配置完毕，代码已经很熟悉了。使用 Pandas 导入 sample.csv 文件，并定义数据帧的列：

FILE = open('sample.csv','r')
DATAFRAME = pd.read_csv(FILE)
DATAFRAME.columns = [ 'red','green','blue' ]

有了适当格式的数据，你可以将其绘制在图形中。将每一列用作绘图的输入，然后使用 plt.show() 在 GUI 窗口中绘制图形。plt.legend() 参数将列标题与图形上的每一行关联（loc 参数将图例放置在图表之外而不是在图表上方）：

for i in DATAFRAME.columns:
    DATAFRAME[i].plot()

plt.legend(bbox_to_anchor=(1, 1), loc=2, borderaxespad=1)
plt.show()

运行代码以获得结果。

你的图形可以准确显示 CSV 文件中包含的所有信息：值在 Y 轴上，索引号在 X 轴上，并且图形中的线也被标识出来了，以便你知道它们代表什么。然而，由于此代码正在跟踪颜色值（至少是假装），所以线条的颜色不仅不直观，而且违反直觉。如果你永远不需要分析颜色数据，则可能永远不会遇到此问题，但是你一定会遇到类似的问题。在可视化数据时，你必须考虑呈现数据的最佳方法，以防止观看者从你呈现的内容中推断出虚假信息。

为了解决此问题（并展示一些可用的自定义设置），以下代码为每条绘制的线分配了特定的颜色：

import matplotlib
from pandas import read_csv, DataFrame
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from matplotlib import rcParams

matplotlib.use('GTK3Agg')
rcParams['figure.figsize'] = 11,8
sns.set_style('whitegrid')

FILE = open('sample.csv','r')
DATAFRAME = pd.read_csv(FILE)
DATAFRAME.columns = [ 'red','green','blue' ]

plt.plot(DATAFRAME['red'],'r-')
plt.plot(DATAFRAME['green'],'g-')
plt.plot(DATAFRAME['blue'],'b-')
plt.plot(DATAFRAME['red'],'ro')
plt.plot(DATAFRAME['green'],'go')
plt.plot(DATAFRAME['blue'],'bo')

plt.show()

这使用特殊的 Matplotlib 表示法为每列创建两个图。每列的初始图分配有一种颜色（红色为 r，绿色为 g，蓝色为 b）。这些是内置的 Matplotlib 设置。 - 表示实线（双破折号，例如 r--，将创建虚线）。为每个具有相同颜色的列创建第二个图，但是使用 o 表示点或节点。为了演示内置的 Seaborn 主题，请将 sns.set_style 的值更改为 whitegrid。

停用你的虚拟环境

探索完 Pandas 和绘图后，可以使用 deactivate 命令停用 Python 虚拟环境：

(example) $ deactivate
$

当你想重新使用它时，只需像在本文开始时一样重新激活它即可。重新激活虚拟环境时，你必须重新安装模块，但是它们是从缓存安装的，而不是从互联网下载的，因此你不必联网。

无尽的可能性

Pandas、Matplotlib、Seaborn 和数据科学的真正力量是无穷的潜力，使你能够以有意义和启发性的方式解析、解释和组织数据。下一步是使用你在本文中学到的新工具探索简单的数据集。Matplotlib 和 Seaborn 不仅有折线图，还有很多其他功能，因此，请尝试创建条形图或饼图或完全不一样的东西。

一旦你了解了你的工具集并对如何关联数据有了一些想法，则可能性是无限的。数据科学是寻找隐藏在数据中的故事的新方法。让开源成为你的媒介。

via: https://opensource.com/article/19/9/get-started-data-science-python

作者：Seth Kenlon 选题：lujun9972 译者：GraveAccent 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

使用 Python 类使你的代码变得更加模块化。

在我上一篇文章中，我解释了如何通过使用函数、创建模块或者两者一起来使 Python 代码更加模块化。函数对于避免重复多次使用的代码非常有用，而模块可以确保你在不同的项目中复用代码。但是模块化还有另一种方法：类。

如果你已经听过 面向对象编程 object-oriented programming （OOP）这个术语，那么你可能会对类的用途有一些概念。程序员倾向于将类视为一个虚拟对象，有时与物理世界中的某些东西直接相关，有时则作为某种编程概念的表现形式。无论哪种表示，当你想要在程序中为你或程序的其他部分创建“对象”时，你都可以创建一个类来交互。

没有类的模板

假设你正在编写一个以幻想世界为背景的游戏，并且你需要这个应用程序能够涌现出各种坏蛋来给玩家的生活带来一些刺激。了解了很多关于函数的知识后，你可能会认为这听起来像是函数的一个教科书案例：需要经常重复的代码，但是在调用时可以考虑变量而只编写一次。

下面一个纯粹基于函数的敌人生成器实现的例子：

#!/usr/bin/env python3

import random

def enemy(ancestry,gear):
    enemy=ancestry
    weapon=gear
    hp=random.randrange(0,20)
    ac=random.randrange(0,20)
    return [enemy,weapon,hp,ac]

def fight(tgt):
    print("You take a swing at the " + tgt[0] + ".")
    hit=random.randrange(0,20)
    if hit > tgt[3]:
        print("You hit the " + tgt[0] + " for " + str(hit) + " damage!")
        tgt[2] = tgt[2] - hit
    else:
        print("You missed.")


foe=enemy("troll","great axe")
print("You meet a " + foe[0] + " wielding a " + foe[1])
print("Type the a key and then RETURN to attack.")

while True:
    action=input()

    if action.lower() == "a":
        fight(foe)

    if foe[2] < 1:
        print("You killed your foe!")
    else:
        print("The " + foe[0] + " has " + str(foe[2]) + " HP remaining")

enemy 函数创造了一个具有多个属性的敌人，例如谱系、武器、生命值和防御等级。它返回每个属性的列表，表示敌人全部特征。

从某种意义上说，这段代码创建了一个对象，即使它还没有使用类。程序员将这个 enemy 称为对象，因为该函数的结果（本例中是一个包含字符串和整数的列表）表示游戏中一个单独但复杂的东西。也就是说，列表中字符串和整数不是任意的：它们一起描述了一个虚拟对象。

在编写描述符集合时，你可以使用变量，以便随时使用它们来生成敌人。这有点像模板。

在示例代码中，当需要对象的属性时，会检索相应的列表项。例如，要获取敌人的谱系，代码会查询 foe[0]，对于生命值，会查询 foe[2]，以此类推。

这种方法没有什么不妥，代码按预期运行。你可以添加更多不同类型的敌人，创建一个敌人类型列表，并在敌人创建期间从列表中随机选择，等等，它工作得很好。实际上，Lua 非常有效地利用这个原理来近似了一个面向对象模型。

然而，有时候对象不仅仅是属性列表。

使用对象

在 Python 中，一切都是对象。你在 Python 中创建的任何东西都是某个预定义模板的实例。甚至基本的字符串和整数都是 Python type 类的衍生物。你可以在这个交互式 Python shell 中见证：

>>> foo=3
>>> type(foo)
<class 'int'>
>>> foo="bar"
>>> type(foo)
<class 'str'>

当一个对象由一个类定义时，它不仅仅是一个属性的集合，Python 类具有各自的函数。从逻辑上讲，这很方便，因为只涉及某个对象类的操作包含在该对象的类中。

在示例代码中，fight 的代码是主应用程序的功能。这对于一个简单的游戏来说是可行的，但对于一个复杂的游戏来说，世界中不仅仅有玩家和敌人，还可能有城镇居民、牲畜、建筑物、森林等等，它们都不需要使用战斗功能。将战斗代码放在敌人的类中意味着你的代码更有条理，在一个复杂的应用程序中，这是一个重要的优势。

此外，每个类都有特权访问自己的本地变量。例如，敌人的生命值，除了某些功能之外，是不会改变的数据。游戏中的随机蝴蝶不应该意外地将敌人的生命值降低到 0。理想情况下，即使没有类，也不会发生这种情况。但是在具有大量活动部件的复杂应用程序中，确保不需要相互交互的部件永远不会发生这种情况，这是一个非常有用的技巧。

Python 类也受垃圾收集的影响。当不再使用类的实例时，它将被移出内存。你可能永远不知道这种情况会什么时候发生，但是你往往知道什么时候它不会发生，因为你的应用程序占用了更多的内存，而且运行速度比较慢。将数据集隔离到类中可以帮助 Python 跟踪哪些数据正在使用，哪些不在需要了。

优雅的 Python

下面是一个同样简单的战斗游戏，使用了 Enemy 类：

#!/usr/bin/env python3

import random

class Enemy():
    def __init__(self,ancestry,gear):
        self.enemy=ancestry
        self.weapon=gear
        self.hp=random.randrange(10,20)
        self.ac=random.randrange(12,20)
        self.alive=True

    def fight(self,tgt):
        print("You take a swing at the " + self.enemy + ".")
        hit=random.randrange(0,20)

        if self.alive and hit > self.ac:
            print("You hit the " + self.enemy + " for " + str(hit) + " damage!")
            self.hp = self.hp - hit
            print("The " + self.enemy + " has " + str(self.hp) + " HP remaining")
        else:
            print("You missed.")

        if self.hp < 1:
            self.alive=False

# 游戏开始
foe=Enemy("troll","great axe")
print("You meet a " + foe.enemy + " wielding a " + foe.weapon)

# 主函数循环
while True:
   
    print("Type the a key and then RETURN to attack.")
        
    action=input()

    if action.lower() == "a":
        foe.fight(foe)
                
    if foe.alive == False:
        print("You have won...this time.")
        exit()

这个版本的游戏将敌人作为一个包含相同属性（谱系、武器、生命值和防御）的对象来处理，并添加一个新的属性来衡量敌人时候已被击败，以及一个战斗功能。

类的第一个函数是一个特殊的函数，在 Python 中称为 init 或初始化的函数。这类似于其他语言中的构造器，它创建了类的一个实例，你可以通过它的属性和调用类时使用的任何变量来识别它（示例代码中的 foe）。

Self 和类实例

类的函数接受一种你在类之外看不到的新形式的输入：self。如果不包含 self，那么当你调用类函数时，Python 无法知道要使用的类的哪个实例。这就像在一间充满兽人的房间里说：“我要和兽人战斗”，向一个兽人发起。没有人知道你指的是谁，所有兽人就都上来了。

CC-BY-SA by Buch on opengameart.org

类中创建的每个属性都以 self 符号作为前缀，该符号将变量标识为类的属性。一旦派生出类的实例，就用表示该实例的变量替换掉 self 前缀。使用这个技巧，你可以在一间满是兽人的房间里说：“我要和谱系是 orc 的兽人战斗”，这样来挑战一个兽人。当 orc 听到 “gorblar.orc” 时，它就知道你指的是谁（他自己），所以你得到是一场公平的战斗而不是斗殴。在 Python 中：

gorblar=Enemy("orc","sword")
print("The " + gorblar.enemy + " has " + str(gorblar.hp) + " remaining.")

通过检索类属性（gorblar.enemy 或 gorblar.hp 或你需要的任何对象的任何值）而不是查询 foe[0]（在函数示例中）或 gorblar[0] 来寻找敌人。

本地变量

如果类中的变量没有以 self 关键字作为前缀，那么它就是一个局部变量，就像在函数中一样。例如，无论你做什么，你都无法访问 Enemy.fight 类之外的 hit 变量：

>>> print(foe.hit)
Traceback (most recent call last):
  File "./enclass.py", line 38, in <module>
    print(foe.hit)
AttributeError: 'Enemy' object has no attribute 'hit'

>>> print(foe.fight.hit)
Traceback (most recent call last):
  File "./enclass.py", line 38, in <module>
    print(foe.fight.hit)
AttributeError: 'function' object has no attribute 'hit'

hit 变量包含在 Enemy 类中，并且只能“存活”到在战斗中发挥作用。

更模块化

本例使用与主应用程序相同的文本文档中的类。在一个复杂的游戏中，我们更容易将每个类看作是自己独立的应用程序。当多个开发人员处理同一个应用程序时，你会看到这一点：一个开发人员负责一个类，另一个开发人员负责主程序，只要他们彼此沟通这个类必须具有什么属性，就可以并行地开发这两个代码块。

要使这个示例游戏模块化，可以把它拆分为两个文件：一个用于主应用程序，另一个用于类。如果它是一个更复杂的应用程序，你可能每个类都有一个文件，或每个逻辑类组有一个文件（例如，用于建筑物的文件，用于自然环境的文件，用于敌人或 NPC 的文件等）。

将只包含 Enemy 类的一个文件保存为 enemy.py，将另一个包含其他内容的文件保存为 main.py。

以下是 enemy.py：

import random

class Enemy():
    def __init__(self,ancestry,gear):
        self.enemy=ancestry
        self.weapon=gear
        self.hp=random.randrange(10,20)
        self.stg=random.randrange(0,20)
        self.ac=random.randrange(0,20)
        self.alive=True

    def fight(self,tgt):
        print("You take a swing at the " + self.enemy + ".")
        hit=random.randrange(0,20)

        if self.alive and hit > self.ac:
            print("You hit the " + self.enemy + " for " + str(hit) + " damage!")
            self.hp = self.hp - hit
            print("The " + self.enemy + " has " + str(self.hp) + " HP remaining")
        else:
            print("You missed.")

        if self.hp < 1:
            self.alive=False

以下是 main.py：

#!/usr/bin/env python3

import enemy as en

# game start
foe=en.Enemy("troll","great axe")
print("You meet a " + foe.enemy + " wielding a " + foe.weapon)

# main loop
while True:
   
    print("Type the a key and then RETURN to attack.")

    action=input()

    if action.lower() == "a":
        foe.fight(foe)

    if foe.alive == False:
        print("You have won...this time.")
        exit()

导入模块 enemy.py 使用了一条特别的语句，引用类文件名称而不用带有 .py 扩展名，后跟你选择的命名空间指示符（例如，import enemy as en）。这个指示符是在你调用类时在代码中使用的。你需要在导入时添加指示符，例如 en.Enemy，而不是只使用 Enemy()。

所有这些文件名都是任意的，尽管在原则上不要使用罕见的名称。将应用程序的中心命名为 main.py 是一个常见约定，和一个充满类的文件通常以小写形式命名，其中的类都以大写字母开头。是否遵循这些约定不会影响应用程序的运行方式，但它确实使经验丰富的 Python 程序员更容易快速理解应用程序的工作方式。

在如何构建代码方面有一些灵活性。例如，使用该示例代码，两个文件必须位于同一目录中。如果你只想将类打包为模块，那么必须创建一个名为 mybad 的目录，并将你的类移入其中。在 main.py 中，你的 import 语句稍有变化：

from mybad import enemy as en

两种方法都会产生相同的结果，但如果你创建的类足够通用，你认为其他开发人员可以在他们的项目中使用它们，那么后者更好。

无论你选择哪种方式，都可以启动游戏的模块化版本：

$ python3 ./main.py 
You meet a troll wielding a great axe
Type the a key and then RETURN to attack.
a
You take a swing at the troll.
You missed.
Type the a key and then RETURN to attack.
a
You take a swing at the troll.
You hit the troll for 8 damage!
The troll has 4 HP remaining
Type the a key and then RETURN to attack.
a
You take a swing at the troll.
You hit the troll for 11 damage!
The troll has -7 HP remaining
You have won...this time.

游戏启动了，它现在更加模块化了。现在你知道了面向对象的应用程序意味着什么，但最重要的是，当你向兽人发起决斗的时候，你知道是哪一个。

via: https://opensource.com/article/19/7/get-modular-python-classes

作者：Seth Kenlon 选题：lujun9972 译者：MjSeven 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出