Moshe Zadka 发布的文章

这是 Python 之禅特别系列的一部分,重点是第十和第十一条原则:沉默的错误(或不沉默)。

 title=

处理“异常情况”是编程中争论最多的问题之一。这可能是因为风险很大:处理不当的错误值甚至可以使庞大的系统瘫痪。由于“异常情况”从本质上来说,是测试不足的,但发生的频率却令人不快,因此,是否正确处理它们往往可以将一个噩梦般的系统与一个“可以工作”的系统区分开来。

从 Java 的 checked 异常,到 Erlang 的故障隔离,再到 Haskell 的 Maybe,不同的语言对错误处理的态度截然不同。

这两条 Python 之禅是 Python 对这个话题的冥思。

错误绝不应该悄悄传递... Errors should never pass silently…

当 Python 之禅在 Tim Peters 眼里闪烁而出之前,在维基百科被俗称为“维基”之前,第一个维基网站 C2 就已经存在了,它是一个编程指南的宝库。这些原则大多来自于 Smalltalk 编程社区。Smalltalk 的思想影响了许多面向对象的语言,包括 Python。

C2 维基定义了 武士原则 Samurai Principle :“胜利归来,要么不归。”用 Python 人的术语来说,它鼓励摒弃 哨兵值 sentinel value ,比如用返回 None-1 来表示无法完成任务,而是采用引发异常的方式。一个 None 是无声的:它看起来像一个值,可以放在一个变量中,然后到处传递。有时,它甚至是一个有效的返回值。

这里的原则是,如果一个函数不能完成它的契约,它应该“高调失败”:引发一个异常。所引发的异常永远不会看起来像是一个可能的值。它将跳过 returned_value = call_to_function(parameter) 行,并上升到调用栈中,可能使程序崩溃。

崩溃的调试是很直接的:有一个堆栈跟踪来指示问题以及调用堆栈。崩溃可能意味着程序的必要条件没有满足,需要人为干预。它可能意味着程序的逻辑有问题。无论是哪种情况,高调失败都比一个隐藏的、“缺失”的值要好。用 None 来感染程序的有效数据,直到它被用在某个地方,就如你可能已经知道的,错误信息会说 “None 没有方法进行拆分”。

除非显式消除 Unless explicitly silenced

有时需要显式地捕获异常。我们可能会预见到文件中的某些行格式错误,并希望以特殊的方式来处理它们,也许可以把它们放在一个“需要人来看看的行”的文件中,而不是让整个程序崩溃。

Python 允许我们用 except 来捕获异常。这意味着错误可以被显式消除。这种明确性意味着 except 行在代码审查中是可见的。质疑为什么应该在这里显式消除异常并从异常中恢复,是有意义的。自问一下我们是否捕获了太多或太少的异常也是有意义的。

因为这些全都是明确的,所以有人可以阅读代码并了解哪些异常是可以恢复的。


via: https://opensource.com/article/19/12/zen-python-errors

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

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

本文是 Python 之禅特别系列的一部分,重点此篇着眼于第七、八、九条原则:可读性、特殊情况和实用性。

 title=

软件开发是一门充满了取舍的学科。每一个选择,都有一个同样合理但相反的选择。将一个方法私有化?你在鼓励复制粘贴。将一个方法公开?你在过早地对一个接口做出承诺。

软件开发者每时每刻都在做艰难的选择。虽然 Python 之禅 中的所有原则都在一定程度上涵盖了权衡,但下面的原则对一些权衡进行了最艰难、最冷酷的审视。

可读性很重要 Readability counts

从某种意义上说,这一中间原则确实是整个 Python 之禅的中心。这条原则与编写高效的程序无关。在大多数情况下,它甚至与编写健壮的程序也无关。它讲的是编写出别人能读懂的程序

阅读代码,就其本质而言,发生在代码被添加到系统中之后。通常,它会发生在很久很久以后。忽略可读性是最简单的选择,因为它对现在没有伤害。无论添加新代码的原因是什么,它都会对现在造成影响,无论是一个令人痛苦的 bug 还是一个被强烈要求的功能。

如果面对巨大的压力,把可读性扔到一边,只管“解决问题”,而 Python 之禅提醒我们:可读性很重要。编写代码让它适合阅读,无论是对自己还是他人,都是一种慈悲。

特殊情况不足以违反规则 Special cases aren't special enough to break the rules

总是有各种借口:这个 bug 特别麻烦,先简单处理一下吧;这个功能特别紧急,别管美观了;这种情况下所涉及的领域规则特别复杂,嵌套深点也没关系。

一旦我们对特例的借口妥协,大坝就会破裂,就丧失了原则;事情就会演变成一个疯狂麦克斯的荒诞症,每个程序员都会为自己试图找到最好的借口。

纪律需要承诺。只有当事情艰辛、有强烈的诱惑时,才是对一个软件开发人员的考验。总是有合理的借口来破坏规则,这就是为什么必须坚守规矩的原因。纪律就是向例外说不的艺术。没有任何解释可以改变这一点。

虽然,实用性胜过纯洁性 Although, practicality beats purity

“如果你只想着击打、弹跳、撞击、触碰敌人,你将无法真正打倒他。” —— 《宫本武藏:水之卷

归根结底,软件开发是一门实用的学科。它的目标是解决真实的人所面临的实际问题。实用性比纯粹性更重要:首先,我们必须解决问题。如果我们只考虑可读性、简单性或美观性,我们将无法真正解决问题

正如宫本武藏所说的,每一次代码修改的首要目标应该是解决问题。这个问题需要我们心心念念地去解决它。如果我们不以解决问题为目标,只想着 Python 之禅,我们就辜负了这些原则。这是 Python 之禅所固有的另一种矛盾。


via: https://opensource.com/article/19/12/zen-python-trade-offs

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

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

如果你的程序需要一段时间才能显示结果,可通过显示它的进度来避免让用户感到沮丧。

阿拉米语,希伯来语和阿拉伯语中的闪米特语根 q-d-m 通常与前进或进度有关。阿拉伯语 taqaddum (تقدّم)的意思是“进度”。进度是很重要的。正如每部感觉良好的电影都会告诉你,旅程和目的地同样重要。

大多数程序都有一个明确的目标,一个期望的最终状态。有时,计算这个最终状态可能需要很长的时间。虽然计算机没有感情不在乎,但人却在乎。人类并不乐意坐在原地等待,而看不到任何明显的进展迹象。疑问不断蔓延。程序崩溃了吗?磁盘性能是否抖动?操作系统是否把所有的计算资源都分配给了其他任务?

就像正义一样,进度必须被看到,而不仅仅是完成。Python 库 tqdm 有助于使进度变得明确。

tqdm 模块可在控制台下工作,但它也专门支持了我最喜欢的环境之一 Jupyter。要在 Jupyter 中使用 tqdm,你需要导入 notebook 子模块并安装 ipywidgetsnotebook 子模块与 tqdm 接口兼容。

这意味着你可以做一些导入时操作来导入正确的模块,同时保持 tqdm 的用法不变。诀窍是检查 __main__ 模块是否具有全局变量 get_ipython。虽然这只是一个启发式的方法,但却是一个相当准确的方法:

import sys
if hasattr(sys.modules["__main__"], "get_ipython"):
    from tqdm import notebook as tqdm
else:
    import tqdm

最简单的情况是,某件事情需要运行一定的迭代次数(事先已知),而每一次迭代的时间都差不多。例如,有一个计算任何数字的平方根的算法,通过从 1 作为猜测值开始,然后计算出一个改进后的猜测值:

def improve_guess(rt, n):
    return (rt + n/rt) / 2

一点点的改进可以让你更加接近该平方根。例如,你可以计算 2 的平方根:

guess = 1
target = 2
for i in tqdm.trange(10):
    guess = improve_guess(guess, target)

 title=

精确了到小数点后 10 位!

round(2 - guess*guess, 10)
0.0

一个稍微复杂一点的例子是,当元素的数量是已知的,而处理每个元素需要类似的时间。例如,你可以计算一些数字的乘积。为此,你需要一些随机数:

import random
numbers = [random.uniform(0, 2.8) for i in range(100)]
numbers[:5]
[2.6575636572230916,
0.1286674965830302,
1.0634250104041332,
1.1760969844376505,
0.45192978568125486]

现在有了这些数字,可以将它们相乘了。使用 tqdm 最简单的方法是包装一个 Python 迭代函数。数值是一样的,但是 tqdm 会显示一个进度条:

result = 1
for num in tqdm.tqdm(numbers):
    result *= num
result
2.4081854901728303

 title=

然而,并不是所有的事情都可以预测。最不容易预测的事情之一就是网络速度。当你下载一个大文件时,衡量进度的唯一方法就是检查已经下载了多少:

url = "https://www.python.org/ftp/python/3.9.0/Python-3.9.0.tgz"
import httpx
with httpx.stream("GET", url) as response:
    total = int(response.headers["Content-Length"])
    with tqdm.tqdm(total=total) as progress:
        for chunk in response.iter_bytes():
            progress.update(len(chunk))

 title=

有时,“嵌套”进度条是有意义的。例如,如果你要下载一个目录,你就需要一个进度条来跟踪文件,并为每个文件设置一个进度条。

下面是一个例子(但没有实际下载一个目录):

files = [f"vid-{i}.mp4" for i in range(4)]
for fname in tqdm.tqdm(files, desc="files"):
    total = random.randrange(10**9, 2 * 10**9)
    with tqdm.tqdm(total=total, desc=fname) as progress:
        current = 0
        while current < total:
            chunk_size = min(random.randrange(10**3, 10**5), total - current)
            current += chunk_size
            if random.uniform(0, 1) < 0.01:
                time.sleep(0.1)
            progress.update(chunk_size)

 title=

所以,如果你的程序需要一段时间才能显示最终结果,为避免让你的用户感到沮丧。请显示它的进度!


via: https://opensource.com/article/20/12/tqdm-python

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

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

你可以尝试以多种语言编程一个简单的游戏来开始编程之路。

 title=

当你想学习一门新的编程语言时,不妨关注一下编程语言的共同点。

  • 变量
  • 表达式
  • 语句

这些概念是大多数编程语言的基础。一旦你理解了它们,你就可以开始弄清楚其余的东西。

因为编程语言通常具有相似性,一旦你懂了一种语言,你就可以通过理解其差异来学习另一种语言的基础知识。

学习新语言的一个好方法是使用一个你可以用来练习的标准程序。这可以让你专注于语言,而不是程序的逻辑。我在这一系列文章中使用了一个“猜数字”的程序,在这个程序中,电脑会在 1 到 100 之间选一个数字让你猜。程序一直循环,直到你猜对数字为止。

这个程序锻炼了编程语言的几个概念:

  • 变量
  • 输入
  • 输出
  • 条件评估
  • 循环

这是学习一门新编程语言的很好的实践实验。

安装 Rust

你可以使用 Rustup 安装一个 Rust 工具链,或者你可以在线尝试 Rust 而不在本地安装它。

如果你在本地安装,你应该定期用 rustup update 来更新它,以保持你的工具链的新鲜,并使用 cargo update 来保持你的库的最新版本。

Rust 语言版本的猜数字

Rust 是一门赋予任何人构建可靠和高效的软件能力的语言。你可以通过编写一个 Rust 版本的“猜数字”游戏来探索 Rust。

第一步是编写一个 Cargo.toml 文件。你可以使用 cargo new 命令生成一个骨架 Cargo.toml。这几乎是开始一个 Rust 项目的最佳方式。

$ cargo new guess
$ cd guess
$ ls -1
Cargo.toml
src/

Cargo.toml 文件为你的包命名,并给它一些元数据,最重要的是,指明了它依赖于 rand crate

[package]
name = "guess"
version = "2020.11.0"
authors = ["Moshe Zadka <[email protected]>"]
edition = "2018"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
rand = "*"

Rust 中的许多东西不是由语言或标准库提供的。取而代之的是,你可以从某个外部 crate 得到它们,这些 crate 可以做许多事情。

程序逻辑在 src/main.rs 中:

use rand::Rng;
use std::io::BufRead;

fn main() {
    let mut rng = rand::thread_rng();
    let random = rng.gen_range(1..101);
    println!("Guess a number between 1 and 100");
    for line in std::io::stdin().lock().lines() {
        let parsed = line.ok().as_deref().map(str::parse::<i64>);
        if let Some(Ok(guess)) = parsed {
            match guess {
                _ if guess < random => println!("Too low"),
                _ if guess > random => println!("Too high"),
                _ => {
                    println!("That's right");
                    break;
                }
            }
        }
    }
}

代码的前两行声明你要做什么。在本例中,rand::Rng 生成一个猜测值,而 trait std::io::BufRead 使得可以从标准输入中读取。

Rust 代码的入口在 main() 函数中,所以下一步就是定义 main()

要给一个变量赋值,先放 let,再放变量的名字,后面放 = 号。这样就创建了一个不可变变量。

Rust 中大多数变量都是不可变的,但是 rng 对象必须是可变的(mut)。例如,语句 let random = 0random 变量分配一个零值。

函数的第一行创建了一个线程安全的 Rng 对象,并将其分配给变量 rng。Rust 是建立在线程和内存安全的基础上的,所以你必须在开始写代码时就考虑到这些事情。

程序的下一行读取函数 gen_range() 的结果,并将其分配给名为 random 的变量。该函数取一个最小值(包含)和一个上界(不包含)。为了也包含上界,你可以用一个等号来标记较大的数字(例如,1...=100),或者你也可以像我在代码中做的那样,将上界设置为比你的预期最大值大 1。在这种情况下,该范围是 1100,使得游戏刚好有足够的挑战性。

中央循环在 std::io::stdin() 中迭代行。由于有各种可能导致行不能读取的例外情况,Rust 要求你用一个 Result 来包裹一行。有时候可能无法将一行解析为一个整数。

这段代码使用条件模式匹配来忽略所有会导致错误的行:

        let parsed = line.ok().as_deref().map(str::parse::<i64>);
        if let Some(Ok(guess)) = parsed {
            // ...
        }

第一行创建了一个 Result<Option<i64>, ...> 对象,因为它可能在读取或解析步骤中失败。由于下一行只在 Some(Ok(guess)) 上匹配,每当一行的结果是一个不匹配的值时,它就会跳过 if 语句。这是一种强大的忽略错误的方法。

Rust 支持条件表达式和流程控制,比如循环。在“猜数字”游戏中,只要猜中的值不等于 random,Rust 就会继续循环。

if 语句的主体包含一个 Rust 的 match 语句的三向分支。虽然 match 最常用于模式匹配,但它也可以检查任意条件。在这种情况下是打印一个适当的信息,如果猜测是正确的,则中断(break)循环。

示例输出

现在你已经写好了你的 Rust 程序,你可以运行它来玩“猜数字”游戏。每次运行程序时,Rust 都会选择一个不同的随机数,所以继续猜,直到找到正确的数字。

$ cargo run
   Compiling guess v2020.11.0 (/Users/mzadka/src/guess)
    Finished dev [unoptimized + debuginfo] target(s) in 0.70s
     Running `target/debug/guess`
Guess a number between 1 and 100
50
Too high
25
Too high
12
Too low
18
Too high
15
Too high
13
Too low
14
That's right

典型的做法是用 cargo run 来测试程序。最终,你可能会使用 cargo build 分成两个独立的步骤构建一个可执行文件并运行它

学习 Rust

这个“猜数字”游戏是学习一门新的编程语言的一个很好的入门程序,因为它以一种相当直接的方式锻炼了几个常见的编程概念。通过在不同的编程语言中实现这个简单的游戏,你可以展示语言的一些核心概念,并比较它们的细节。

你有喜欢的编程语言吗?你会如何用它来写“猜数字”游戏呢?请关注本系列文章,看看你可能感兴趣的其他编程语言的例子吧!


via: https://opensource.com/article/20/12/learn-rust

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

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

通过编写一个“猜数字”游戏来探索 Python(和其他编程语言)。

在这个系列中,我们要用不同的编程语言编写相同的应用,以比较各种语言是如何工作的,并说明使用标准测试程序是学习新编程好方法。

当你学习一门新的编程语言时,关注它们的共同点是件好事。变量、表达式和语句是大多数编程语言的基础。一旦你理解了这些概念,你就可以开始弄清楚其余的东西。

因为编程语言有许多相似之处,一旦你知道一种语言,你通常可以通过观察它与你所知道的语言的不同之处来学习另一种语言的基础知识。使用你用其他语言编写的标准测试程序,可以让你专注于语言,而不是程序的逻辑。

为了证明这点,我们正在测试如何用多种语言编写一个“猜数字”程序。计算机选择一个 1 到 100 之间的数字,然后让你猜。程序循环,直到你猜出正确答案。

“猜数字”程序练习了编程语言的几个概念:

  • 变量
  • 输入
  • 输出
  • 条件判断
  • 循环

这是一个很好的学习新编程语言的实践实验。

用 Python 猜数字

Python 软件基金会的话来说。“Python 是一种解释性的、交互式的、面向对象的程序设计语言,它包含了模块、异常、动态类型、非常高层的动态数据类型和类。”它是一种很好的通用编程语言,从简单的脚本到复杂的 GUI 应用都很适用。

你可以通过编写一个版本的“猜数字”游戏来探索 Python。这是我的实现:

import random as randomlib
random = randomlib.randint(1, 100)
print("Guess a number between 1 and 100")
while True:
    guess = int(input())
    if guess < random:
        print("Too low")
    elif guess > random:
        print("Too high")
    else:
        print("That's right!")
        break

要给一个变量赋值,请列出变量的名称,然后是 = 号。例如,语句 random = 0random 变量分配了一个零值。

脚本的第一行就导入了 random 模块。由于本系列中的所有程序都使用 random 作为变量的名称,你可以使用 import random as randomlib 以别名导入它,以避免命名冲突。

很少有函数被内置到 Python 中,大多数函数必须从标准库中显式导入。random 标准库模块有生成各种随机值的功能。

脚本的第二行读取函数 randint() 的结果,并将其赋值给名为 random 的变量。函数需要两个参数:一个最小值和一个最大值。在本例中,范围是 1100,以使游戏具有足够的挑战性。

你可以使用 input() 函数提示用户输入一个值。如果你写 guess = int(input()),Python 会等待用户输入一些文本,将其转换为一个整数,然后将值存储在 guess 变量中。

Python 支持条件表达式和循环等流程控制。在“猜数字”游戏中,只要 guess 中的值不等于 random,Python 就会继续循环。

如果猜测值小于随机数,Python 会打印 Too low,如果猜测值大于这个数字,Python 会打印 Too high

示例输出

现在你已经写好了 Python 程序,运行它来玩“猜数字”游戏。每次运行程序,Python 都会随机选取一个不同的数字。为了完成这个游戏,你需要猜测,直到找到正确的数字:

$ python guess.py
Guess a number between 1 and 100
 50
Too high
 25
Too high
 12
Too high
 7
Too high
 3
Too low
 5
Too low
 6
That's right!

在学习一门新的编程语言时,这个“猜数字”游戏是一个很好的入门程序,因为它以一种相当直接的方式练习了几个常见的编程概念。通过在不同的编程语言中实现这个简单的游戏,你可以展示不同编程语言的一些核心概念,并比较每种语言的细节。

你有喜欢的编程语言吗?你会如何编写“猜数字”游戏?请关注本系列文章,看看你可能感兴趣的其他编程语言的例子吧!


via: https://opensource.com/article/20/12/learn-python

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

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

用 Jupyter 和 Python 在你的日常写作背后实现一些自动化。

有些人会遵循传统,制定一年的计划。不过,一年的时间很长,所以我以季节性的主题或轨迹来规划。每个季度,我都会坐下来,看看即将到来的三个月的季节,并决定在这段时间里我将努力做什么。

对于我最新的主题,我决定要每天写一篇日记。我喜欢有明确的承诺,所以我承诺每天写 5 分钟。我也喜欢有可观察的承诺,哪怕只是对我而言,所以我把我的记录放在 Git 里。

我决定在写日记的过程中实现一些自动化,于是我使用了我最喜欢的自动化工具:Jupyter。Jupyter 有一个有趣的功能 ipywidgets,这是一套用于 Jupyter Notebooks、JupyterLab 和 IPython 内核的交互式 HTML 组件。

如果你想跟着本文的代码走,请注意,让你的 JupyterLab 实例支持组件可能有点复杂,请按照这些说明来进行设置。

导入 ipywidgets 模块

首先,你需要导入一堆东西,比如 ipywidgets 和 Twisted。Twisted 模块可以用来创建一个异步时间计数器:

import twisted.internet.asyncioreactor
twisted.internet.asyncioreactor.install()
from twisted.internet import reactor, task
import ipywidgets, datetime, subprocess, functools, os

设置定时条目

用 Twisted 实现时间计数器是利用了 task.LoopingCall。然而,结束循环调用的唯一方法是用一个异常。倒计时时钟总会停止,所以你需要一个自定义的异常来指示“一切正常;计数器结束”:

class DoneError(Exception):
    pass

现在你已经写好了异常,你可以写定时器了。第一步是创建一个 ipywidgets.Label 的文本标签组件。循环使用 divmod 计算出分和秒,然后设置标签的文本值:

def time_out_counter(reactor):
    label = ipywidgets.Label("Time left: 5:00")
    current_seconds = datetime.timedelta(minutes=5).total_seconds()
    def decrement(count):
        nonlocal current_seconds
        current_seconds -= count
        time_left = datetime.timedelta(seconds=max(current_seconds, 0))
        minutes, left = divmod(time_left, minute)
        seconds = int(left.total_seconds())
        label.value = f"Time left: {minutes}:{seconds:02}"
        if current_seconds < 0:
            raise DoneError("finished")
    minute = datetime.timedelta(minutes=1)
    call = task.LoopingCall.withCount(decrement)
    call.reactor = reactor
    d = call.start(1)
    d.addErrback(lambda f: f.trap(DoneError))
    return d, label

从 Jupyter 组件中保存文本

下一步是写一些东西,将你输入的文字保存到一个文件中,并提交到 Git。另外,由于你要写 5 分钟的日记,你需要一个能给你提供写字区域的组件(滚动肯定是可以的,但一次能看到更多的文字就更好了)。

这就用到了组件 Textarea,这是一个你可以书写的文本字段,而 Output 则是用来给出反馈的。这一点很重要,因为 git push 可能会花点时间或失败,这取决于网络。如果备份失败,用反馈提醒用户很重要:

def editor(fname):
    textarea = ipywidgets.Textarea(continuous_update=False)
    textarea.rows = 20
    output = ipywidgets.Output()
    runner = functools.partial(subprocess.run, capture_output=True, text=True, check=True)
    def save(_ignored):
        with output:
            with open(fname, "w") as fpout:
                fpout.write(textarea.value)
            print("Sending...", end='')
            try:
                runner(["git", "add", fname])
                runner(["git", "commit", "-m", f"updated {fname}"])
                runner(["git", "push"])
            except subprocess.CalledProcessError as exc:
                print("Could not send")
                print(exc.stdout)
                print(exc.stderr)
            else:
                 print("Done")
    textarea.observe(save, names="value")
    return textarea, output, save

continuous_update=False 是为了避免每个字符都保存一遍并发送至 Git。相反,只要脱离输入焦点,它就会保存。这个函数也返回 save 函数,所以可以明确地调用它。

创建一个布局

最后,你可以使用 ipywidgets.VBox 把这些东西放在一起。这是一个包含一些组件并垂直显示的东西。还有一些其他的方法来排列组件,但这足够简单:

def journal():
    date = str(datetime.date.today())
    title = f"Log: Startdate {date}"
    filename = os.path.join(f"{date}.txt")
    d, clock = time_out_counter(reactor)
    textarea, output, save = editor(filename)
    box = ipywidgets.VBox([
        ipywidgets.Label(title),
        textarea,
        clock,
        output
    ])
    d.addCallback(save)
    return box

biu!你已经定义了一个写日记的函数了,所以是时候试试了。

journal()

 title=

你现在可以写 5 分钟了!


via: https://opensource.com/article/20/11/daily-journal-jupyter

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

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