走出舒适区，我了解了 Go 的交叉编译功能。

在 Linux 上测试软件时，我使用各种架构的服务器，例如 Intel、AMD、Arm 等。当我 分配了一台满足我的测试需求的 Linux 机器，我仍然需要执行许多步骤：

1. 下载并安装必备软件
2. 验证构建服务器上是否有新的测试软件包
3. 获取并设置依赖软件包所需的 yum 仓库
4. 下载并安装新的测试软件包（基于步骤 2）
5. 获取并设置必需的 SSL 证书
6. 设置测试环境，获取所需的 Git 仓库，更改配置，重新启动守护进程等
7. 做其他需要做的事情

用脚本自动化

这些步骤非常常规，以至于有必要对其进行自动化并将脚本保存到中央位置（例如文件服务器），在需要时可以在此处下载脚本。为此，我编写了 100-120 行的 Bash shell 脚本，它为我完成了所有配置（包括错误检查）。这个脚本通过以下方式简化了我的工作流程：

1. 配置新的 Linux 系统（支持测试的架构）
2. 登录系统并从中央位置下载自动化 shell 脚本
3. 运行它来配置系统
4. 开始测试

学习 Go 语言

我想学习 Go 语言 有一段时间了，将我心爱的 Shell 脚本转换为 Go 程序似乎是一个很好的项目，可以帮助我入门。它的语法看起来很简单，在尝试了一些测试程序后，我开始着手提高自己的知识并熟悉 Go 标准库。

我花了一个星期的时间在笔记本电脑上编写 Go 程序。我经常在我的 x86 服务器上测试程序，清除错误并使程序健壮起来，一切都很顺利。

直到完全转换到 Go 程序前，我继续依赖自己的 shell 脚本。然后，我将二进制文件推送到中央文件服务器上，以便每次配置新服务器时，我要做的就是获取二进制文件，将可执行标志打开，然后运行二进制文件。我对早期的结果很满意：

$ wget http://file.example.com/<myuser>/bins/prepnode
$ chmod  +x ./prepnode
$ ./prepnode

然后，出现了一个问题

第二周，我从资源池中分配了一台新的服务器，像往常一样，我下载了二进制文件，设置了可执行标志，然后运行二进制文件。但这次它出错了，是一个奇怪的错误：

$ ./prepnode
bash: ./prepnode: cannot execute binary file: Exec format error
$

起初，我以为可能没有成功设置可执行标志。但是，它已按预期设置：

$ ls -l prepnode
-rwxr-xr-x. 1 root root 2640529 Dec 16 05:43 prepnode

发生了什么事？我没有对源代码进行任何更改，编译没有引发任何错误或警告，而且上次运行时效果很好，因此我仔细查看了错误消息 format error。

我检查了二进制文件的格式，一切看起来都没问题：

$ file prepnode
prepnode: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, not stripped

我迅速运行了以下命令，识别所配置的测试服务器的架构以及二进制试图运行的平台。它是 Arm64 架构，但是我编译的二进制文件（在我的 x86 笔记本电脑上）生成的是 x86-64 格式的二进制文件：

$ uname -m
aarch64

脚本编写人员的编译第一课

在那之前，我从未考虑过这种情况（尽管我知道这一点）。我主要研究脚本语言（通常是 Python）以及 Shell 脚本。在任何架构的大多数 Linux 服务器上都可以使用 Bash Shell 和 Python 解释器。总之，之前一切都很顺利。

但是，现在我正在处理 Go 这种编译语言，它生成可执行的二进制文件。编译后的二进制文件由特定架构的 指令码 或汇编指令组成，这就是为什么我收到格式错误的原因。由于 Arm64 CPU（运行二进制文件的地方）无法解释二进制文件的 x86-64 指令，因此它抛出错误。以前，shell 和 Python 解释器为我处理了底层指令码或特定架构的指令。

Go 的交叉编译

我检查了 Golang 的文档，发现要生成 Arm64 二进制文件，我要做的就是在运行 go build 命令编译 Go 程序之前设置两个环境变量。

GOOS 指的是操作系统，例如 Linux、Windows、BSD 等，而 GOARCH 指的是要在哪种架构上构建程序。

$ env GOOS=linux GOARCH=arm64 go build -o prepnode_arm64

构建程序后，我重新运行 file 命令，这一次它显示的是 ARM AArch64，而不是之前显示的 x86。因此，我在我的笔记本上能为不同的架构构建二进制文件。

$ file prepnode_arm64
prepnode_arm64: ELF 64-bit LSB executable, ARM aarch64, version 1 (SYSV), statically linked, not stripped

我将二进制文件从笔记本电脑复制到 ARM 服务器上。现在运行二进制文件（将可执行标志打开）不会产生任何错误：

$ ./prepnode_arm64  -h
Usage of ./prepnode_arm64:
  -c    Clean existing installation
  -n    Do not start test run (default true)
  -s    Use stage environment, default is qa
  -v    Enable verbose output

其他架构呢？

x86 和 Arm 是我测试软件所支持的 5 种架构中的两种，我担心 Go 可能不会支持其它架构，但事实并非如此。你可以查看 Go 支持的架构：

$ go tool dist list

Go 支持多种平台和操作系统，包括：

• AIX
• Android
• Darwin
• Dragonfly
• FreeBSD
• Illumos
• JavaScript
• Linux
• NetBSD
• OpenBSD
• Plan 9
• Solaris
• Windows

要查找其支持的特定 Linux 架构，运行：

$ go tool dist list | grep linux

如下面的输出所示，Go 支持我使用的所有体系结构。尽管 x86\_64 不在列表中，但 AMD64 兼容 x86-64，所以你可以生成 AMD64 二进制文件，它可以在 x86 架构上正常运行：

$ go tool dist list | grep linux
linux/386
linux/amd64
linux/arm
linux/arm64
linux/mips
linux/mips64
linux/mips64le
linux/mipsle
linux/ppc64
linux/ppc64le
linux/riscv64
linux/s390x

处理所有架构

为我测试的所有体系结构生成二进制文件，就像从我的 x86 笔记本电脑编写一个微小的 shell 脚本一样简单：

#!/usr/bin/bash
archs=(amd64 arm64 ppc64le ppc64 s390x)

for arch in ${archs[@]}
do
        env GOOS=linux GOARCH=${arch} go build -o prepnode_${arch}
done

$ file prepnode_*
prepnode_amd64:   ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, Go BuildID=y03MzCXoZERH-0EwAAYI/p909FDnk7xEUo2LdHIyo/V2ABa7X_rLkPNHaFqUQ6/5p_q8MZiR2WYkA5CzJiF, not stripped
prepnode_arm64:   ELF 64-bit LSB executable, ARM aarch64, version 1 (SYSV), statically linked, Go BuildID=q-H-CCtLv__jVOcdcOpA/CywRwDz9LN2Wk_fWeJHt/K4-3P5tU2mzlWJa0noGN/SEev9TJFyvHdKZnPaZgb, not stripped
prepnode_ppc64:   ELF 64-bit MSB executable, 64-bit PowerPC or cisco 7500, version 1 (SYSV), statically linked, Go BuildID=DMWfc1QwOGIq2hxEzL_u/UE-9CIvkIMeNC_ocW4ry/r-7NcMATXatoXJQz3yUO/xzfiDIBuUxbuiyaw5Goq, not stripped
prepnode_ppc64le: ELF 64-bit LSB executable, 64-bit PowerPC or cisco 7500, version 1 (SYSV), statically linked, Go BuildID=C6qCjxwO9s63FJKDrv3f/xCJa4E6LPVpEZqmbF6B4/Mu6T_OR-dx-vLavn1Gyq/AWR1pK1cLz9YzLSFt5eU, not stripped
prepnode_s390x:   ELF 64-bit MSB executable, IBM S/390, version 1 (SYSV), statically linked, Go BuildID=faC_HDe1_iVq2XhpPD3d/7TIv0rulE4RZybgJVmPz/o_SZW_0iS0EkJJZHANxx/zuZgo79Je7zAs3v6Lxuz, not stripped

现在，每当配置一台新机器时，我就运行以下 wget 命令下载特定体系结构的二进制文件，将可执行标志打开，然后运行：

$ wget http://file.domain.com/<myuser>/bins/prepnode_<arch>
$ chmod +x ./prepnode_<arch>
$ ./prepnode_<arch>

为什么？

你可能想知道，为什么我没有坚持使用 shell 脚本或将程序移植到 Python 而不是编译语言上来避免这些麻烦。所以有舍有得，那样的话我不会了解 Go 的交叉编译功能，以及程序在 CPU 上执行时的底层工作原理。在计算机中，总要考虑取舍，但绝不要让它们阻碍你的学习。

via: https://opensource.com/article/21/1/go-cross-compiling

作者：Gaurav Kamathe 选题：lujun9972 译者：MjSeven 校对：wxy

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

在家玩流行的英国游戏节目 “Countdown” 中的数字游戏。

像许多人一样，我在大流行期间看了不少新的电视节目。我最近发现了一个英国的游戏节目，叫做 Countdown，参赛者在其中玩两种游戏：一种是 单词 游戏，他们试图从杂乱的字母中找出最长的单词；另一种是 数字 游戏，他们从随机选择的数字中计算出一个目标数字。因为我喜欢数学，我发现自己被数字游戏所吸引。

数字游戏可以为你的下一个家庭游戏之夜增添乐趣，所以我想分享我自己的一个游戏变体。你以一组随机数字开始，分为 1 到 10 的“小”数字和 15、20、25，以此类推，直到 100 的“大”数字。你从大数字和小数字中挑选六个数字的任何组合。

接下来，你生成一个 200 到 999 之间的随机“目标”数字。然后用你的六个数字进行简单的算术运算，尝试用每个“小”和“大”数字计算出目标数字，但使用不能超过一次。如果你能准确地计算出目标数字，你就能得到最高分，如果距离目标数字 10 以内就得到较低的分数。

例如，如果你的随机数是 75、100、2、3、4 和 1，而你的目标数是 505，你可以说 2+3=5，5×100=500，4+1=5，以及 5+500=505。或者更直接地：(2+3)×100 + 4 + 1 = 505。

在命令行中随机化列表

我发现在家里玩这个游戏的最好方法是从 1 到 10 的池子里抽出四个“小”数字，从 15 到 100 的 5 的倍数中抽出两个“大”数字。你可以使用 Linux 命令行来为你创建这些随机数。

让我们从“小”数字开始。我希望这些数字在 1 到 10 的范围内。你可以使用 Linux 的 seq 命令生成一个数字序列。你可以用几种不同的方式运行 seq，但最简单的形式是提供序列的起始和结束数字。要生成一个从 1 到 10 的列表，你可以运行这个命令：

$ seq 1 10
1
2
3
4
5
6
7
8
9
10

为了随机化这个列表，你可以使用 Linux 的 shuf（“shuffle”，打乱）命令。shuf 将随机化你给它的东西的顺序，通常是一个文件。例如，如果你把 seq 命令的输出发送到 shuf 命令，你会收到一个 1 到 10 之间的随机数字列表：

$ seq 1 10 | shuf
3
6
8
10
7
4
5
2
1
9

要从 1 到 10 的列表中只选择四个随机数，你可以将输出发送到 head 命令，它将打印出输入的前几行。使用 -4 选项来指定 head 只打印前四行：

$ seq 1 10 | shuf | head -4
6
1
8
4

注意，这个列表与前面的例子不同，因为 shuf 每次都会生成一个随机顺序。

现在你可以采取下一步措施来生成“大”数字的随机列表。第一步是生成一个可能的数字列表，从 15 开始，以 5 为单位递增，直到达到 100。你可以用 Linux 的 seq 命令生成这个列表。为了使每个数字以 5 为单位递增，在 seq 命令中插入另一个选项来表示 步进：

$ seq 15 5 100
15
20
25
30
35
40
45
50
55
60
65
70
75
80
85
90
95
100

就像以前一样，你可以随机化这个列表，选择两个“大”数字：

$ seq 15 5 100 | shuf | head -2
75
40

用 Bash 生成一个随机数

我想你可以用类似的方法从 200 到 999 的范围内选择游戏的目标数字。但是生成单个随机数的最简单的方案是直接在 Bash 中使用 RANDOM 变量。当你引用这个内置变量时，Bash 会生成一个大的随机数。要把它放到 200 到 999 的范围内，你需要先把随机数放到 0 到 799 的范围内，然后加上 200。

要把随机数放到从 0 开始的特定范围内，你可以使用模数算术运算符。模数计算的是两个数字相除后的 余数。如果我用 801 除以 800，结果是 1，余数是 1（模数是 1）。800 除以 800 的结果是 1，余数是 0（模数是 0）。而用 799 除以 800 的结果是 0，余数是 799（模数是 799）。

Bash 通过 $(()) 结构支持算术展开。在双括号之间，Bash 将对你提供的数值进行算术运算。要计算 801 除以 800 的模数，然后加上 200，你可以输入:

$ echo $(( 801 % 800 + 200 ))
201

通过这个操作，你可以计算出一个 200 到 999 之间的随机目标数：

$ echo $(( RANDOM % 800 + 200 ))
673

你可能想知道为什么我在 Bash 语句中使用 RANDOM 而不是 $RANDOM。在算术扩展中, Bash 会自动扩展双括号内的任何变量. 你不需要在 $RANDOM 变量上的 $ 来引用该变量的值, 因为 Bash 会帮你做这件事。

玩数字游戏

让我们把所有这些放在一起，玩玩数字游戏。产生两个随机的“大”数字, 四个随机的“小”数值，以及目标值：

$ seq 15 5 100 | shuf | head -2
75
100
$ seq 1 10 | shuf | head -4
4
3
10
2
$ echo $(( RANDOM % 800 + 200 ))
868

我的数字是 75、100、4、3、10 和 2，而我的目标数字是 868。

如果我用每个“小”和“大”数字做这些算术运算，并不超过一次，我就能接近目标数字了：

10×75 = 750
750+100 = 850

然后：

4×3 = 12
850+12 = 862
862+2 = 864

只相差 4 了，不错！但我发现这样可以用每个随机数不超过一次来计算出准确的数字：

4×2 = 8
8×100 = 800

然后：

75-10+3 = 68
800+68 = 868

或者我可以做 这些 计算来准确地得到目标数字。这只用了六个随机数中的五个：

4×3 = 12
75+12 = 87

然后：

87×10 = 870
870-2 = 868

试一试 Countdown 数字游戏，并在评论中告诉我们你做得如何。

via: https://opensource.com/article/21/4/math-game-linux-commands

作者：Jim Hall 选题：lujun9972 译者：geekpi 校对：wxy

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

PyPI 的 JSON API 是一种机器可直接使用的数据源，你可以访问和你浏览网站时相同类型的数据。

PyPI（Python 软件包索引）提供了有关其软件包信息的 JSON API。本质上，它是机器可以直接使用的数据源，与你在网站上直接访问是一样的的。例如，作为人类，我可以在浏览器中打开 Numpy 项目页面，点击左侧相关链接，查看有哪些版本，哪些文件可用以及发行日期和支持的 Python 版本等内容：

但是，如果我想编写一个程序来访问此数据，则可以使用 JSON API，而不必在这些页面上抓取和解析 HTML。

顺便说一句：在旧的 PyPI 网站上，还托管在 pypi.python.org 时，NumPy 的项目页面位于 pypi.python.org/pypi/numpy，访问其 JSON API 也很简单，只需要在最后面添加一个 /json ，即 https://pypi.org/pypi/numpy/json。现在，PyPI 网站托管在 pypi.org，NumPy 的项目页面是 pypi.org/project/numpy。新站点不会有单独的 JSON API URL，但它仍像以前一样工作。因此，你不必在 URL 后添加 /json，只要记住 URL 就够了。

你可以在浏览器中打开 NumPy 的 JSON API URL，Firefox 很好地渲染了数据：

你可以查看 info，release 和 urls 其中的内容。或者，你可以将其加载到 Python Shell 中，以下是几行入门教程：

import requests
url = "https://pypi.org/pypi/numpy/json"
r = requests.get(url)
data = r.json()

获得数据后（调用 .json() 提供了该数据的 字典），你可以对其进行查看：

查看 release 中的键：

这表明 release 是一个以版本号为键的字典。选择一个并查看以下内容：

每个版本都包含一个列表，release 包含 24 项。但是每个项目是什么？由于它是一个列表，因此你可以索引第一项并进行查看：

这是一个字典，其中包含有关特定文件的详细信息。因此，列表中的 24 个项目中的每一个都与此特定版本号关联的文件相关，即在 https://pypi.org/project/numpy/1.20.1/#files 列出的 24 个文件。

你可以编写一个脚本在可用数据中查找内容。例如，以下的循环查找带有 sdist（源代码包）的版本，它们指定了 requires_python 属性并进行打印：

for version, files in data['releases'].items():
    for f in files:
        if f.get('packagetype') == 'sdist' and f.get('requires_python'):
            print(version, f['requires_python'])

piwheels

去年，我在 piwheels 网站上实现了类似的 API。piwheels.org 是一个 Python 软件包索引，为树莓派架构提供了 wheel（预编译的二进制软件包）。它本质上是 PyPI 软件包的镜像，但带有 Arm wheel，而不是软件包维护者上传到 PyPI 的文件。

由于 piwheels 模仿了 PyPI 的 URL 结构，因此你可以将项目页面 URL 的 pypi.org 部分更改为 piwheels.org。它将向你显示类似的项目页面，其中详细说明了构建的版本和可用的文件。由于我喜欢旧站点允许你在 URL 末尾添加 /json 的方式，所以我也支持这种方式。NumPy 在 PyPI 上的项目页面为 pypi.org/project/numpy，在 piwheels 上，它是 piwheels.org/project/numpy，而 JSON API 是 piwheels.org/project/numpy/json 页面。

没有必要重复 PyPI API 的内容，所以我们提供了 piwheels 上可用内容的信息，包括所有已知发行版的列表，一些基本信息以及我们拥有的文件列表：

与之前的 PyPI 例子类似，你可以创建一个脚本来分析 API 内容。例如，对于每个 NumPy 版本，其中有多少 piwheels 文件：

import requests

url = "https://www.piwheels.org/project/numpy/json"
package = requests.get(url).json()

for version, info in package['releases'].items():
    if info['files']:
        print('{}: {} files'.format(version, len(info['files'])))
    else:
        print('{}: No files'.format(version))

此外，每个文件都包含一些元数据：

方便的是 apt_dependencies 字段，它列出了使用该库所需的 Apt 软件包。本例中的 NumPy 文件，或者通过 pip 安装 Numpy，你还需要使用 Debian 的 apt 包管理器安装 libatlas3-base 和 libgfortran。

以下是一个示例脚本，显示了程序包的 Apt 依赖关系：

import requests

def get_install(package, abi):
    url = 'https://piwheels.org/project/{}/json'.format(package)
    r = requests.get(url)
    data = r.json()
    for version, release in sorted(data['releases'].items(), reverse=True):
        for filename, file in release['files'].items():
            if abi in filename:
                deps = ' '.join(file['apt_dependencies'])
                print("sudo apt install {}".format(deps))
                print("sudo pip3 install {}=={}".format(package, version))
                return

get_install('opencv-python', 'cp37m')
get_install('opencv-python', 'cp35m')
get_install('opencv-python-headless', 'cp37m')
get_install('opencv-python-headless', 'cp35m')

我们还为软件包列表提供了一个通用的 API 入口，其中包括每个软件包的下载统计：

import requests

url = "https://www.piwheels.org/packages.json"
packages = requests.get(url).json()
packages = {
    pkg: (d_month, d_all)
    for pkg, d_month, d_all, \*_ in packages
}

package = 'numpy'
d_month, d_all = packages[package]

print(package, "has had", d_month, "downloads in the last month")
print(package, "has had", d_all, "downloads in total")

pip search

pip search 因为其 XMLRPC 接口过载而被禁用，因此人们一直在寻找替代方法。你可以使用 piwheels 的 JSON API 来搜索软件包名称，因为软件包的集合是相同的：

#!/usr/bin/python3
import sys

import requests

PIWHEELS_URL = 'https://www.piwheels.org/packages.json'

r = requests.get(PIWHEELS_URL)
packages = {p[0] for p in r.json()}

def search(term):
    for pkg in packages:
        if term in pkg:
            yield pkg

if __name__ == '__main__':
    if len(sys.argv) == 2:
        results = search(sys.argv[1].lower())
        for res in results:
            print(res)
    else:
        print("Usage: pip_search TERM")

有关更多信息，参考 piwheels 的 JSON API 文档.

本文最初发表在 Ben Nuttall 的 Tooling Tuesday 博客上，经许可转载使用。

via: https://opensource.com/article/21/3/python-package-index-json-apis-requests

作者：Ben Nuttall 选题：lujun9972 译者：MjSeven 校对：wxy

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

Cython 创建的 C 模块可以加速 Python 代码的执行，这对使用效率不高的解释型语言编写的复杂应用是很重要的。

Cython 是 Python 编程语言的编译器，旨在优化性能并形成一个扩展的 Cython 编程语言。作为 Python 的扩展，Cython 也是 Python 语言的超集，它支持调用 C 函数和在变量和类属性上声明 C 类型。这使得包装外部 C 库、将 C 嵌入现有应用程序或者为 Python 编写像 Python 一样简单的 C 语言扩展语法变得容易。

Cython 一般用于创建 C 模块来加速 Python 代码的执行。这在使用解释型语言编写的效率不高的复杂应用中非常重要。

安装 Cython

你可以在 Linux、BSD、Windows 或 macOS 上安装 Cython 来使用 Python：

$ python -m pip install Cython

安装好后，就可以使用它了。

将 Python 转换成 C

使用 Cython 的一个好的方式是从一个简单的 “hello world” 开始。这虽然不是展示 Cython 优点的最好方式，但是它展示了使用 Cython 时发生的情况。

首先，创建一个简单的 Python 脚本，文件命名为 hello.pyx（.pyx 扩展名并不神奇，从技术上它可以是任何东西，但它是 Cython 的默认扩展名）：

print("hello world")

接下来，创建一个 Python 设置脚本。一个像 Python 的 makefile 一样的 setup.py，Cython 可以使用它来处理你的 Python 代码：

from setuptools import setup
from Cython.Build import cythonize

setup(
    ext_modules = cythonize("hello.pyx")
)

最后，使用 Cython 将你的 Python 脚本转换为 C 代码：

$ python setup.py build_ext --inplace

你可以在你的工程目录中看到结果。Cython 的 cythonize 模块将 hello.pyx 转换成一个 hello.c 文件和一个 .so 库。这些 C 代码有 2648 行，所以它比一个一行的 hello.pyx 源码的文本要多很多。.so 库也比它的源码大 2000 倍（即 54000 字节和 20 字节相比）。然后，Python 需要运行单个 Python 脚本，所以有很多代码支持这个只有一行的 hello.pyx 文件。

要使用 Python 的 “hello world” 脚本的 C 代码版本，请打开一个 Python 提示符并导入你创建的新 hello 模块：

>>> import hello
hello world

将 C 代码集成到 Python 中

测试计算能力的一个很好的通用测试是计算质数。质数是一个比 1 大的正数，且它只有被 1 或它自己除后才会产生正整数。虽然理论很简单，但是随着数的变大，计算需求也会增加。在纯 Python 中，可以用 10 行以内的代码完成质数的计算。

import sys

number = int(sys.argv[1])
if not number <= 1:
    for i in range(2, number):
        if (number % i) == 0:
            print("Not prime")
            break
else:
    print("Integer must be greater than 1")

这个脚本在成功的时候是不会提醒的，如果这个数不是质数，则返回一条信息：

$ ./prime.py 3
$ ./prime.py 4
Not prime.

将这些转换为 Cython 需要一些工作，一部分是为了使代码适合用作库，另一部分是为了提高性能。

脚本和库

许多用户将 Python 当作一种脚本语言来学习：你告诉 Python 想让它执行的步骤，然后它来做。随着你对 Python（以及一般的开源编程）的了解越多，你可以了解到许多强大的代码都存在于其他应用程序可以利用的库中。你的代码越 不具有针对性，程序员（包括你）就越可能将其重用于其他的应用程序。将计算和工作流解耦可能需要更多的工作，但最终这通常是值得的。

在这个简单的质数计算的例子中，将其转换成 Cython，首先是一个设置脚本：

from setuptools import setup
from Cython.Build import cythonize

setup(
    ext_modules = cythonize("prime.py")
)

将你的脚本转换成 C：

$ python setup.py build_ext --inplace

到目前为止，一切似乎都工作的很好，但是当你试图导入并使用新模块时，你会看到一个错误：

>>> import prime
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "prime.py", line 2, in init prime
    number = sys.argv[1]
IndexError: list index out of range

这个问题是 Python 脚本希望从一个终端运行，其中参数（在这个例子中是要测试是否为质数的整数）是一样的。你需要修改你的脚本，使它可以作为一个库来使用。

写一个库

库不使用系统参数，而是接受其他代码的参数。对于用户输入，与其使用 sys.argv，不如将你的代码封装成一个函数来接收一个叫 number（或者 num，或者任何你喜欢的变量名）的参数：

def calculate(number):
    if not number <= 1:
        for i in range(2, number):
            if (number % i) == 0:
                print("Not prime")
                break
    else:
        print("Integer must be greater than 1")

这确实使你的脚本有些难以测试，因为当你在 Python 中运行代码时，calculate 函数永远不会被执行。但是，Python 编程人员已经为这个问题设计了一个通用、还算直观的解决方案。当 Python 解释器执行一个 Python 脚本时，有一个叫 __name__ 的特殊变量，这个变量被设置为 __main__，但是当它被作为模块导入的时候，__name__ 被设置为模块的名字。利用这点，你可以写一个既是 Python 模块又是有效 Python 脚本的库：

import sys

def calculate(number):
    if not number <= 1:
        for i in range(2, number):
            if (number % i) == 0:
                print("Not prime")
                break
    else:
        print("Integer must be greater than 1")

if __name__ == "__main__":
    number = sys.argv[1]    
    calculate( int(number) )

现在你可以用一个命令来运行代码了：

$ python ./prime.py 4
Not a prime

你可以将它转换为 Cython 来用作一个模块：

>>> import prime
>>> prime.calculate(4)
Not prime

C Python

用 Cython 将纯 Python 的代码转换为 C 代码是有用的。这篇文章描述了如何做，然而，Cython 还有功能可以帮助你在转换之前优化你的代码，分析你的代码来找到 Cython 什么时候与 C 进行交互，以及更多。如果你正在用 Python，但是你希望用 C 代码改进你的代码，或者进一步理解库是如何提供比脚本更好的扩展性的，或者你只是好奇 Python 和 C 是如何协作的，那么就开始使用 Cython 吧。

via: https://opensource.com/article/21/4/cython

作者：Alan Smithee 选题：lujun9972 译者：ShuyRoy 校对：wxy

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

了解 Linux 如何使用库，包括静态库和动态库的差别，有助于你解决依赖问题。

Linux 从某种意义上来说就是一堆相互依赖的静态和动态库。对于 Linux 系统新手来说，库的整个处理过程简直是个迷。但对有经验的人来说，被构建进操作系统的大量共享代码对于编写新应用来说却是个优点。

为了让你熟悉这个话题，我准备了一个小巧的 应用例子 来展示在普通的 Linux 发行版（在其他操作系统上未验证）上是经常是如何处理库的。为了用这个例子来跟上这个需要动手的教程，请打开命令行输入：

$ git clone https://github.com/hANSIc99/library_sample
$ cd library_sample/
$ make
cc -c main.c -Wall -Werror
cc -c libmy_static_a.c -o libmy_static_a.o -Wall -Werror
cc -c libmy_static_b.c -o libmy_static_b.o -Wall -Werror
ar -rsv libmy_static.a libmy_static_a.o libmy_static_b.o
ar: creating libmy_static.a
a - libmy_static_a.o
a - libmy_static_b.o
cc -c -fPIC libmy_shared.c -o libmy_shared.o
cc -shared -o libmy_shared.so libmy_shared.o
$ make clean
rm *.o

当执行完这些命令，这些文件应当被添加进目录下（执行 ls 来查看）：

my_app
libmy_static.a
libmy_shared.so

关于静态链接

当你的应用链接了一个静态库，这个库的代码就变成了可执行文件的一部分。这个动作只在链接过程中执行一次，这些静态库通常以 .a 扩展符结尾。

静态库是多个 目标 object 文件的 归档 archive （ar）。这些目标文件通常是 ELF 格式的。ELF 是 可执行可链接格式 Executable and Linkable Format 的简写，它与多个操作系统兼容。

file 命令的输出可以告诉你静态库 libmy_static.a 是 ar 格式的归档文件类型。

$ file libmy_static.a
libmy_static.a: current ar archive

使用 ar -t，你可以看到归档文件的内部。它展示了两个目标文件：

$ ar -t libmy_static.a
libmy_static_a.o
libmy_static_b.o

你可以用 ax -x <archive-file> 命令来提取归档文件的文件。被提出的都是 ELF 格式的目标文件：

$ ar -x libmy_static.a
$ file libmy_static_a.o
libmy_static_a.o: ELF 64-bit LSB relocatable, x86-64, version 1 (SYSV), not stripped

关于动态链接

动态链接指的是使用共享库。共享库通常以 .so 的扩展名结尾（“ 共享对象 shared object ” 的简写）。

共享库是 Linux 系统中依赖管理的最常用方法。这些共享库在应用启动前被载入内存，当多个应用都需要同一个库时，这个库在系统中只会被加载一次。这个特性减少了应用的内存占用。

另外一个值得注意的地方是，当一个共享库的 bug 被修复后，所有引用了这个库的应用都会受益。但这也意味着，如果一个 bug 还没被发现，那所有相关的应用都会遭受这个 bug 影响（如果这个应用使用了受影响的部分）。

当一个应用需要某个特定版本的库，但是 链接器 linker 只知道某个不兼容版本的位置，对于初学者来说这个问题非常棘手。在这个场景下，你必须帮助链接器找到正确版本的路径。

尽管这不是一个每天都会遇到的问题，但是理解动态链接的原理总是有助于你修复类似的问题。

幸运的是，动态链接的机制其实非常简洁明了。

为了检查一个应用在启动时需要哪些库，你可以使用 ldd 命令，它会打印出给定文件所需的动态库：

$ ldd my_app
        linux-vdso.so.1 (0x00007ffd1299c000)
        libmy_shared.so => not found
        libc.so.6 => /lib64/libc.so.6 (0x00007f56b869b000)
        /lib64/ld-linux-x86-64.so.2 (0x00007f56b8881000)

可以注意到 libmy_shared.so 库是代码仓库的一部分，但是没有被找到。这是因为负责在应用启动之前将所有依赖加载进内存的动态链接器没有在它搜索的标准路径下找到这个库。

对新手来说，与常用库（例如 bizp2）版本不兼容相关的问题往往十分令人困惑。一种方法是把该仓库的路径加入到环境变量 LD_LIBRARY_PATH 中来告诉链接器去哪里找到正确的版本。在本例中，正确的版本就在这个目录下，所以你可以导出它至环境变量：

$ LD_LIBRARY_PATH=$(pwd):$LD_LIBRARY_PATH
$ export LD_LIBRARY_PATH

现在动态链接器知道去哪找库了，应用也可以执行了。你可以再次执行 ldd 去调用动态链接器，它会检查应用的依赖然后加载进内存。内存地址会在对象路径后展示：

$ ldd my_app
        linux-vdso.so.1 (0x00007ffd385f7000)
        libmy_shared.so => /home/stephan/library_sample/libmy_shared.so (0x00007f3fad401000)
        libc.so.6 => /lib64/libc.so.6 (0x00007f3fad21d000)
        /lib64/ld-linux-x86-64.so.2 (0x00007f3fad408000)

想知道哪个链接器被调用了，你可以用 file 命令：

$ file my_app
my_app: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, BuildID[sha1]=26c677b771122b4c99f0fd9ee001e6c743550fa6, for GNU/Linux 3.2.0, not stripped

链接器 /lib64/ld-linux-x86–64.so.2 是一个指向 ld-2.30.so 的软链接，它也是我的 Linux 发行版的默认链接器：

$ file /lib64/ld-linux-x86-64.so.2
/lib64/ld-linux-x86-64.so.2: symbolic link to ld-2.31.so

回头看看 ldd 命令的输出，你还可以看到（在 libmy_shared.so 边上）每个依赖都以一个数字结尾（例如 /lib64/libc.so.6）。共享对象的常见命名格式为：

libXYZ.so.<MAJOR>.<MINOR>

在我的系统中，libc.so.6 也是指向同一目录下的共享对象 libc-2.31.so 的软链接。

$ file /lib64/libc.so.6
/lib64/libc.so.6: symbolic link to libc-2.31.so

如果你正在面对一个应用因为加载库的版本不对导致无法启动的问题，有很大可能你可以通过检查整理这些软链接或者确定正确的搜索路径（查看下方“动态加载器：ld.so”一节）来解决这个问题。

更为详细的信息请查看 ldd 手册页。

动态加载

动态加载的意思是一个库（例如一个 .so 文件）在程序的运行时被加载。这是使用某种特定的编程方法实现的。

当一个应用使用可以在运行时改变的插件时，就会使用动态加载。

查看 dlopen 手册页 获取更多信息。

动态加载器：ld.so

在 Linux 系统中，你几乎总是正在跟共享库打交道，所以必须有个机制来检测一个应用的依赖并将其加载进内存中。

ld.so 按以下顺序在这些地方寻找共享对象：

1. 应用的绝对路径或相对路径下（用 GCC 编译器的 -rpath 选项硬编码的）
2. 环境变量 LD_LIBRARY_PATH
3. /etc/ld.so.cache 文件

需要记住的是，将一个库加到系统库归档 /usr/lib64 中需要管理员权限。你可以手动拷贝 libmy_shared.so 至库归档中来让应用可以运行，而避免设置 LD_LIBRARY_PATH。

unset LD_LIBRARY_PATH
sudo cp libmy_shared.so /usr/lib64/

当你运行 ldd 时，你现在可以看到归档库的路径被展示出来：

$ ldd my_app
        linux-vdso.so.1 (0x00007ffe82fab000)
        libmy_shared.so => /lib64/libmy_shared.so (0x00007f0a963e0000)
        libc.so.6 => /lib64/libc.so.6 (0x00007f0a96216000)
        /lib64/ld-linux-x86-64.so.2 (0x00007f0a96401000)

在编译时定制共享库

如果你想你的应用使用你的共享库，你可以在编译时指定一个绝对或相对路径。

编辑 makefile（第 10 行）然后通过 make -B 来重新编译程序。然后 ldd 输出显示 libmy_shared.so 和它的绝对路径一起被列出来了。

把这个：

CFLAGS =-Wall -Werror -Wl,-rpath,$(shell pwd)

改成这个（记得修改用户名）：

CFLAGS =/home/stephan/library_sample/libmy_shared.so

然后重新编译：

$ make

确认下它正在使用你设定的绝对路径，你可以在输出的第二行看到：

$ ldd my_app
    linux-vdso.so.1 (0x00007ffe143ed000)
        libmy_shared.so => /lib64/libmy_shared.so (0x00007fe50926d000)
        /home/stephan/library_sample/libmy_shared.so (0x00007fe509268000)
        libc.so.6 => /lib64/libc.so.6 (0x00007fe50909e000)
        /lib64/ld-linux-x86-64.so.2 (0x00007fe50928e000)

这是个不错的例子，但是如果你在编写给其他人用的库，它是怎样工作的呢？新库的路径可以通过写入 /etc/ld.so.conf 或是在 /etc/ld.so.conf.d/ 目录下创建一个包含路径的 <library-name>.conf 文件来注册至系统。之后，你必须执行 ldconfig 命令来覆写 ld.so.cache 文件。这一步有时候在你装了携带特殊的共享库的程序来说是不可省略的。

查看 ld.so 的手册页 获取更多详细信息。

怎样处理多种架构

通常来说，32 位和 64 位版本的应用有不同的库。下面列表展示了不同 Linux 发行版库的标准路径：

红帽家族

• 32 位：/usr/lib
• 64 位：/usr/lib64

Debian 家族

• 32 位：/usr/lib/i386-linux-gnu
• 64 位：/usr/lib/x86_64-linux-gnu

Arch Linux 家族

• 32 位：/usr/lib32
• 64 位：/usr/lib64

FreeBSD（技术上来说不算 Linux 发行版）

• 32 位：/usr/lib32
• 64 位：/usr/lib

知道去哪找这些关键库可以让库链接失效的问题成为历史。

虽然刚开始会有点困惑，但是理解 Linux 库的依赖管理是一种对操作系统掌控感的表现。在其他应用程序中运行这些步骤，以熟悉常见的库，然后继续学习怎样解决任何你可能遇到的库的挑战。

via: https://opensource.com/article/20/6/linux-libraries

作者：Stephan Avenwedde 选题：lujun9972 译者：tt67wq 校对：wxy

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

“遴选”可以解决 Git 仓库中的很多问题。以下是用 git cherry-pick 修复错误的三种方法。

在版本控制系统中摸索前进是一件很棘手的事情。对于一个新手来说，这可能是非常难以应付的，但熟悉版本控制系统（如 Git）的术语和基础知识是开始为开源贡献的第一步。

熟悉 Git 也能帮助你在开源之路上走出困境。Git 功能强大，让你感觉自己在掌控之中 —— 没有哪一种方法会让你无法恢复到工作版本。

这里有一个例子可以帮助你理解“ 遴选 cherry-pick ”的重要性。假设你已经在一个分支上做了好几个提交，但你意识到这是个错误的分支！你现在该怎么办？你现在要做什么？要么在正确的分支上重复所有的变更，然后重新提交，要么把这个分支合并到正确的分支上。等一下，前者太过繁琐，而你可能不想做后者。那么，还有没有办法呢？有的，Git 已经为你准备好了。这就是“遴选”的作用。顾名思义，你可以用它从一个分支中手工遴选一个提交，然后转移到另一个分支。

使用遴选的原因有很多。以下是其中的三个原因。

避免重复性工作

如果你可以直接将相同的提交复制到另一个分支，就没有必要在不同的分支中重做相同的变更。请注意，遴选出来的提交会在另一个分支中创建带有新哈希的新提交，所以如果你看到不同的提交哈希，请不要感到困惑。

如果您想知道什么是提交的哈希，以及它是如何生成的，这里有一个说明可以帮助你。提交哈希是用 SHA-1 算法生成的字符串。SHA-1 算法接收一个输入，然后输出一个唯一的 40 个字符的哈希值。如果你使用的是 POSIX 系统，请尝试在您的终端上运行这个命令：

$ echo -n "commit" | openssl sha1

这将输出一个唯一的 40 个字符的哈希值 4015b57a143aec5156fd1444a017a32137a3fd0f。这个哈希代表了字符串 commit。

Git 在提交时生成的 SHA-1 哈希值不仅仅代表一个字符串。它代表的是：

sha1(
    meta data
        commit message
        committer
        commit date
        author
        authoring date
    Hash of the entire tree object
)

这就解释了为什么你对代码所做的任何细微改动都会得到一个独特的提交哈希值。哪怕是一个微小的改动都会被发现。这是因为 Git 具有完整性。

撤销/恢复丢失的更改

当你想恢复到工作版本时，遴选就很方便。当多个开发人员在同一个代码库上工作时，很可能会丢失更改，最新的版本会被转移到一个陈旧的或非工作版本上。这时，遴选提交到工作版本就可以成为救星。

它是如何工作的？

假设有两个分支：feature1 和 feature2，你想把 feature1 中的提交应用到 feature2。

在 feature1 分支上，运行 git log 命令，复制你想遴选的提交哈希值。你可以看到一系列类似于下面代码示例的提交。commit 后面的字母数字代码就是你需要复制的提交哈希。为了方便起见，您可以选择复制前六个字符（本例中为 966cf3）。

commit 966cf3d08b09a2da3f2f58c0818baa37184c9778 (HEAD -> master)
Author: manaswinidas <[email protected]>
Date:   Mon Mar 8 09:20:21 2021 +1300

   add instructions

然后切换到 feature2 分支，在刚刚从日志中得到的哈希值上运行 git cherry-pick：

$ git checkout feature2
$ git cherry-pick 966cf3.

如果该分支不存在，使用 git checkout -b feature2 来创建它。

这里有一个问题。你可能会遇到下面这种情况：

$ git cherry-pick 966cf3
On branch feature2
You are currently cherry-picking commit 966cf3d.

nothing to commit, working tree clean
The previous cherry-pick is now empty, possibly due to conflict resolution.
If you wish to commit it anyway, use:

   git commit --allow-empty

Otherwise, please use 'git reset'

不要惊慌。只要按照建议运行 git commit --allow-empty：

$ git commit --allow-empty
[feature2 afb6fcb] add instructions
Date: Mon Mar 8 09:20:21 2021 +1300

这将打开你的默认编辑器，允许你编辑提交信息。如果你没有什么要补充的，可以保存现有的信息。

就这样，你完成了你的第一次遴选。如上所述，如果你在分支 feature2 上运行 git log，你会看到一个不同的提交哈希。下面是一个例子：

commit afb6fcb87083c8f41089cad58deb97a5380cb2c2 (HEAD -> feature2)
Author: manaswinidas <[[email protected]][4]>
Date:   Mon Mar 8 09:20:21 2021 +1300
   add instructions

不要对不同的提交哈希感到困惑。这只是区分 feature1 和 feature2 的提交。

遴选多个提交

但如果你想遴选多个提交的内容呢？你可以使用：

git cherry-pick <commit-hash1> <commit-hash2>... <commit-hashn>

请注意，你不必使用整个提交的哈希值，你可以使用前五到六个字符。

同样，这也是很繁琐的。如果你想遴选的提交是一系列的连续提交呢？这种方法太费劲了。别担心，有一个更简单的方法。

假设你有两个分支：

• feature1 包括你想复制的提交（从更早的 commitA 到 commitB）。
• feature2 是你想把提交从 feature1 转移到的分支。

然后：

1. 输入 git checkout <feature1>。
2. 获取 commitA 和 commitB 的哈希值。
3. 输入 git checkout <branchB>。
4. 输入 git cherry-pick <commitA>^..<commitB> （请注意，这包括 commitA 和 commitB）。
5. 如果遇到合并冲突，像往常一样解决，然后输入 git cherry-pick --continue 恢复遴选过程。

重要的遴选选项

以下是 Git 文档 中的一些有用的选项，你可以在 cherry-pick 命令中使用。

• -e、--edit：用这个选项，git cherry-pick 可以让你在提交前编辑提交信息。
• -s、--signoff：在提交信息的结尾添加 Signed-off by 行。更多信息请参见 git-commit(1) 中的 signoff 选项。
• -S[<keyid>]、--pgg-sign[=<keyid>]：这些是 GPG 签名的提交。keyid 参数是可选的，默认为提交者身份；如果指定了，则必须嵌在选项中，不加空格。
• --ff：如果当前 HEAD 与遴选的提交的父级提交相同，则会对该提交进行快进操作。

下面是除了 --continue 外的一些其他的后继操作子命令：

• --quit：你可以忘记当前正在进行的操作。这可以用来清除遴选或撤销失败后的后继操作状态。
• --abort：取消操作并返回到操作序列前状态。

下面是一些关于遴选的例子：

• git cherry-pick master：应用 master 分支顶端的提交所引入的变更，并创建一个包含该变更的新提交。
• git cherry-pick master~4 master~2'：应用master` 指向的第五个和第三个最新提交所带来的变化，并根据这些变化创建两个新的提交。

感到不知所措？你不需要记住所有的命令。你可以随时在你的终端输入 git cherry-pick --help 查看更多选项或帮助。

via: https://opensource.com/article/21/3/git-cherry-pick

作者：Manaswini Das 选题：lujun9972 译者：wxy 校对：wxy

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