如果连这10个Python缩写都不知道，那你一定是Python新手

 简介

对于许多开始学习编程的人来说，Python已经成为他们的首选。Python有非常直观的语法和支持动态类型的灵活性。此外，它是一种解释语言，这使得使用交互式控制台进行学习成为可能。基本上，我们只需使用命令行工具(如Mac中的Terminal)来启动Python学习，因为Python在macOS中是默认附带安装的。

 

 

我们在学习Python时，会逐渐熟悉它的数据结构、控制流、类、函数和其他基本内容。我发现了一件很有趣的事情，那就是Python中我们经常会遇到的各种首字母缩略词。在本文中，我将介绍十个这样的缩略词。其中有一些是通用的编程原理，还有一些是针对Python的特定编码。然而，每一种方法都有非常有趣的地方。

1. OOP(面向对象编程)

我们一定要知道的第一个缩写是OOP--面向对象编程，这也是Python编程设计的基础。我们知道编程本身是关于编码的，但是程序本身应该是关于数据的。我们的程序需要获取输入数据、过程数据和输出数据。注意，这里讨论的数据是一般意义上的数据，包括表格数据、字符串、用户操作(例如，单击按钮)、图像以及具有信息的任何形式的数据。我们代码的工作任务是处理各种形式的数据，并以所需的方式呈现它们。

为了完成我们的工作，我们需要能够处理这些数据的代码，而现代编程语言(包括Python)中的一种常见设计模式就是采用OOP范式。这个想法非常直观-我们用特定的对象包装数据。更具体地说，对象可以保存数据(例如，属性)并且可以操作数据(例如，方法)。例如，如果我们开发一个赛车游戏。我们可以构建汽车对象，并且每个对象都可以具有特定的属性，例如颜色，最大速度和重量。此外，这些对象还可以进行制动和加速等操作。这些数据的逻辑组织以对象(汽车)为中心。

让我们看一下Python中的特定示例。我们可以使用内置的 str 类包装字符串数据，这不仅允许我们使用string对象传递字符串数据，还可以改变字符串的表示方式。让我们在下面看到一个非常简单的示例。

 

>>> # 创建str类型的变量 
... hello = "Hello Python!" 
...  
... # 将数据发送到函数调用 
... print(hello) 
...  
... # 使用字符串方法操作字符串数据 
... hello_lower = hello.lower() 
... hello_upper = hello.upper() 
... print('lowercased:', hello_lower) 
... print('uppercased:', hello_upper) 
...  
Hello Python! 
lowercased: hello python! 
uppercased: HELLO PYTHON! 

2.DRY(不要重复)

DRY原则(不要重复)是每个程序员应该实践的最基本的规则之一。这个规则很简单：如果你注意到你的代码中有任何重复，这是代码需要进行重构的信号，尽量减少重复代码，或者尽可能完全删除重复代码。下面的伪代码向你展示了通过应用DRY原则重构某些代码。

 

def do_something(item): 
    pass 
 
# 重复性工作 
do_something(item0) 
do_something(item1) 
do_something(item2) 
 
# 应用DRY 
for item in (item0, item1, item3): 
    do_something(item) 

代码重构还有另外一个应用场景：你发现自己要处理的是一堆具有相同结构的数据。与其使用一系列字典、列表或元组来存储每个人的数据，不如考虑使用自己的类来处理这些数据。这不仅是为了减少代码出错的可能性，而且有利于长期的可维护性。

3. PIP(Python软件包安装程序)

Python的流行最重要的原因可能是它的开源特性，这就导致大量免费的Python程序包源源不断地开放出来。根据Wikipedia的介绍，在Python软件包索引(PyPI)中索引了235,000多个软件包。 我们可以使用 pip 工具从 PyPI 安装任何软件包。 该安装过程非常轻松，只需在命令或终端中使用一行代码即可。 以下代码段总结了一些常用用法。

 

# 安装最新版本 
pip install package_name 
 
# 安装特定版本 
pip install package_name==version_number 
 
# 卸载软件包 
pip uninstall package_name 
 
# 显示已安装的软件包 
pip list 
 
# 显示有关特定包的信息 
pip show package_name 
 
#安装依赖项列表，例如克隆虚拟环境 
pip install -r requirements.txt 

4. LEGB(本地，封闭，全局和内置)

LEGB规则引用 Python 中的变量查找顺序，如下图所示。 具体来说，当解释程序尝试解析变量时，Python 具有四层作用域--了解将哪些值绑定到变量。 首先从本地范围开始，该范围可以是函数或类。 如果解释器找到了变量的相应绑定值，它将停止查找并将变量与该特定值一起使用。

 

 

可变分辨率规则

否则，它将在更高的级别上查找它—封闭范围。封闭范围只存在于函数的嵌套结构中。具体地说，当一个函数在另一个函数中声明时，我们称内部函数为内部函数，而外部函数称为外部函数。当解释器试图解析在内部函数的作用域内使用的变量时，如果不能在局部范围内解析，它将转到封闭的作用域，即外部函数的局部作用域。

如果它仍然无法解析封闭范围内的变量，它将转到全局范围。全局范围通常是模块级的，通常是一个独立的 Python 文件。值得注意的是，当我们将包导入当前文件时，导入的函数和类也将成为全局范围的一部分。内置范围是指当启动解释器时加载的函数、类和其他模块，以使这些最基本的对象始终可用(例如打印和其他内置函数)。

5. MRO(方法解析顺序)

方法解析顺序表示 Python 或编程语言通常如何解析方法或属性。 与上面讨论的 LEGB 规则关注的是解决变量不同，MRO关注的是对象以及对象的方法调用或特定属性的获取方式。MRO 主要是在多继承的上下文中讨论的--从多个类(即超类)和/或多层继承继承的类(即子类)。因为子类和超类都共享某些实现方法可能不同的通用方法，所以 Python 解释器需要一种机制来确定在特定调用中应使用哪种方法或属性，而这正是MRO的职责。下面的代码段显示了一个示意性示例。

 

>>> class X: 
...     def bin(self): 
...         print(f"bin called in X") 
...  
... class Y(X): 
...     def go(self): 
...         print(f"go called Y") 
...  
... class Z(X): 
...     def go(self): 
...         print(f"go called Z") 
...  
... class W(Y, Z): 
...     def bin(self): 
...         super().bin() 
...         print(f"bin called W") 
...  
...     def bingo(self): 
...         self.bin() 
...         self.go() 
...  
... w = W() 
... w.bingo() 
...  
bin called in X 
bin called W 
go called Y 

对于W类的实例(第22行)，当我们调用 bingo()方法时，此方法将在其自己的类中解析，因为它是在类中定义的(第18-20行)。但是，此方法将进一步调用 bin()和go()方法。以类似的方式，bin()方法在其自己的类上解析，但是，它调用超类的 bin()方法，如第15行所示。但是在其直接超类(即Y和Z)中，都没有实现 bin()方法，因此 Python 会比超类的超类(即X)高一个级别，在超类中实现并调用 bin()方法。

值得注意的是，对于 W 的 go()方法，其两个超类都实现了此方法，但是如你所见，只有 Y 类中使用的实现才被调用。这是因为当我们定义 W 类时，继承顺序为 Y 和 Z，这将使 MRO 遵循相同的顺序。与此相关，我们可以使用特殊方法 __mro__ 找出特定类的 MRO，如下所示。另外，为了向大家展示类继承顺序的重要性，我们创建了另一个类，其中Z类位于Y类之前，这将更改 W_类的MRO。

 

>>> print('W Class MRO:', W.__mro__) 
...  
... class W_(Z, Y): 
...     pass 
...  
... print('W_ Class MRO:', W_.__mro__) 
...  
W Class MRO: (<class '__main__.W'>, <class '__main__.Y'>, <class '__main__.Z'>, <class '__main__.X'>, <class 'object'>) 
W_ Class MRO: (<class '__main__.W_'>, <class '__main__.Z'>, <class '__main__.Y'>, <class '__main__.X'>, <class 'object'>) 

6.&7.EAFP(请求原谅比请求许可更容易)和LBYL(三思而后行)

EAFP(请求原谅比请求许可更容易)编码风格正是 Python 蓬勃发展的方向。因为 Python 是一种动态编程语言，所以在运行时，实现以及对现有实例对象、类甚至模块的修改都是可能的。因此，建议大家在假定特定属性或功能可用的情况下编写代码。换言之，如果某些代码可能存在特定的问题，那么就让问题浮出水面并相应地解决它们。通过应用 EAFP 规则，如果我们想更进一步，我们可以简单地使用 try…except 语句编写特定的代码来处理代码可能引发的潜在异常。基本上，我们的想法是发生意外的事情，我们会事后处理。

与 EAFP 原则相反，还有另一种编码样式称为 LBYL，它代表“跨越式”。使用这种编码方式，程序员应该在某些代码可以运行之前排除所有可能的不希望出现的情况。因此，大家可以在项目中看到更多遵循 LBYL 原则的 if 语句。这种编码方式基本上可以用特别的方式来防止任何问题。

下面的代码片段向大家展示了一个使用 EAFP 与 LBYL 的可能场景。对于 EAFP 编码样式，我们只需在 try…except 语句中包装代码和预期可能的异常，而对于 LBYL 编码样式，我们必须在划分之前使用自省方法和值检查来验证适用的条件。如你所见，EAFP 代码看起来更加整洁，而且没有创建嵌套结构。当然，如果你愿意，也可以在项目中应用 LBYL，而且不会改变项目最终的工作方式。

 

def with_EAFP_divide_ten_by(number): 
    try: 
        print(f'10 divided by {number} is {10 / number}.') 
    except ZeroDivisionError: 
        print("You can't divide zero.") 
    except TypeError: 
        print("You can only divide a number.") 
 
 
def with_LBYL_divide_ten_by(number): 
    if isinstance(number, int) or isinstance(number, float): 
        if number == 0: 
            print("You can't divide zero.") 
        else: 
            print(f'10 divided by {number} is {10 / number}.') 
    else: 
        print("You can only divide a number.") 

8. PEP(Python增强建议)

在上一节中，我们讨论了编码风格。 但是，最具影响力的Python编码风格指南之一是 PEP 8--Python增强建议#8，由 BDFL(将在下面讨论)和其他几个 Python 核心维护者共同编写。PEP涵盖了所有与 Python 相关的内容。 大家可以在官方网站上找到整个列表。 以下为一些著名的文章：

PEP 8：Python代码样式指南(https://www.python.org/dev/peps/pep-0008/)

PEP 257：文档字符串惯例(https://www.python.org/dev/peps/pep-0257/)

PEP 20：Python之禅(https://www.python.org/dev/peps/pep-0257/)

PEP 498：文字字符串插值(https://www.python.org/dev/peps/pep-0498/)

PEP 202：列表理解(https://www.python.org/dev/peps/pep-0202/)

PEP 405：Python虚拟环境(https://www.python.org/dev/peps/pep-0405/)

9.BDFL(仁慈的生命独裁者)

什么是BDFL?当然，标题已经告诉了你它代表什么，但它实际上意味着什么?

在维基百科上，它的定义是：

仁慈的生命独裁者(BDFL)是给少数开源软件开发领导人的称号，他们通常是在社区内部的争议或争论中保留最终发言权的项目创始人。

尽管这个定义通常适用于开源软件开发，但它首先在 Python 社区中使用，作为对 Guido van Rossum(GvR)的引用，GvR 是 Python 编程语言的创建者。在担任 BDFL 职位 20 多年后，于 2018 年卸任。

10. REPL(读--评估--打印循环)

在我看来，REPL(读取-评估-打印循环)是让我们能够这么轻松学习Python的便捷工具。 正如我们所知道的，我们甚至可以开始像使用命令或终端窗口一样简单地学习Python编程。 你可以使用pip工具如前所示的方法来安装任何软件包。 更重要的是，我们可以立即编写第一行Python代码，不需要使用其他编程语言配置任何 IDE 工具。

 

>>> print("Hello World!") 
Hello World! 
>>> 3 * 2 
6 
>>> type(5) 
<class 'int'> 

REPL工作流非常简单——在控制台中读取代码、对其进行求值并打印出任何适用的结果，然后反复重复这三个步骤，用于探索 Python 的各种特性。REPL 是在标准 Python 或其他常见 Python 开发工具(如ipython)中作为默认模式实现的，ipython 是著名的 Python 学习和编码工具 Jupiter Notebook 的基础。

结论

Python是一种灵活而强大的 OOP 语言，由 BDFL GvR 创建。 利用 PIP 命令，我们可以轻松地管理 Python 软件包，并通过 REPL 在控制台中学习语言和各种软件包。 当我们使用 Python 进行编程时，必须遵循 PEP 8 概述中的样式。其他重要的编码原理包括 DRY 和 EAFP 。 如果你愿意，也可以在编码中做一些LBYL。 LEGB 规则和 MRO 能够帮助你了解如何解析变量、属性和函数，让你的代码按照自己的预期来运行。