Python 标准 REPL：快速尝试代码和想法

什么是 Python 的交互式 Shell 或 REPL？

当您以交互模式运行 Python 解释器时，您将打开一个交互式外壳，也称为交互的或一个REPL会议。在这个壳，你的键盘是输入源，你的屏幕是输出目的地。

输入由 Python 代码组成，解释器将对其进行解析和评估。完成后，解释器会自动在屏幕上显示结果，并且该过程再次作为循环开始。

因此，Python 的 REPL 是一种使用 Python 语言与计算机对话的交互式方式。这就像实时聊天。整个过程称为 REPL，因为它在幕后执行四个步骤：

1. 阅读您的输入，由 Python 代码组成表达式和声明
2. 评估你的Python代码，它生成一个结果或原因副作用
3. 印刷任何输出，以便您可以检查代码的结果并立即获得反馈
4. 循环播放返回第一步继续交互

Python 的这一功能是一个强大的工具，您在 Python 编码冒险中最终会需要它，特别是当您学习该语言或处于开发过程的早期阶段时。这是因为 REPL 提供了多项优势，接下来您将了解这些优势。

为什么使用 Python REPL？

作为一名 Python 程序员，您将花费大量时间在交互模式上。此模式提供了一种尝试想法和代码片段的快速方法。在 REPL 会话中，您可以执行以下部分或全部任务：

• 探索和学习Python语法
• 尝试并证明想法, 概念， 和实施
• 快速评估代码片段
• 潜入语言行为
• 编辑和重构您的代码供以后使用脚本模式
• 执行代码并类型自省
• 进行互动帮助关于如何使用该语言
• 运行基本代码调试
• 探索标准库和第三方模块, 图书馆， 和蜜蜂
• 检查落实情况类, 功能， 和其他物体

显然，作为一名 Python 开发人员，您有很多理由花大量时间在 REPL 会话中，与解释器交互工作。使用 REPL 会话最重要的好处是获得有关代码工作方式的即时反馈。

交互模式是Python最好的特性之一。它允许您实时测试解决方案并尝试该语言。如果您想知道某些东西是如何工作的，那么只需在交互式 shell 中尝试一下即可。

您绝对应该考虑交互式 shell 的强大功能学习工具，特别是如果您以前的编程经验是使用不提供 REPL 的编译语言。

在学习 Python 或探索新功能和概念时，您会注意到 Python 中的许多示例文档、在线教程、手册和课程是从交互式会话中复制和粘贴的。你会因为 REPL 的特性而认出它们提示，您将在运行python命令部分。

掌握了对解释器和 REPL 的介绍后，您就可以开始行动了。在接下来的课程中，您将学习如何开始和结束 Python 交互式会话。

运行python命令

一旦你已安装如果您的计算机上安装了 Python，那么您就可以立即开始从这个神奇的工具中受益。要启动 Python 交互式 shell 或会话，请打开命令行窗口并运行python不带参数的命令：

$ python

该命令使Python进入交互模式。解释器将运行，您将得到如下所示的输出：

Python 3.11.0 (main, Nov  6 2022, 13:27:29) ... on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> 

此输出的第一行显示有关当前 Python 版本以及运行解释器的平台的信息。第二行显示一条消息，其中包含命令，您可以运行这些命令来获取有关 Python 的其他一般信息。

最后一行在输出中突出显示，显示主要提示标准 Python 交互式会话或 shell 的一部分。默认情况下，此提示由三个大于号 (>>>），也称为 V 形。其目的是传达解释器已准备好接受输入。

口译员还有一个二次提示用三个点表示（...）。当您输入复合语句或续行时，会出现此提示。您将在以下内容中了解有关此提示的更多信息运行复合语句和处理显式和隐式的行延续部分。

将命令行选项传递给python命令

这python命令可以采用一堆命令行选项。其中一些在 REPL 会话中工作时可能很有用。在这种情况下最相关的选项之一是-i旗帜。该选项使解释器在运行脚本或使用以下命令执行一段代码后进入交互模式-c选项。

您可以使用-i选项来检查脚本中当前的全局变量或在程序引发异常时检查堆栈跟踪。

要尝试此选项，假设您有以下示例脚本：

# sample.py

def read_data():
    # Read data from a file or database...
    return [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

sample = read_data()

def mean(data):
    return sum(data) / len(data)

average = mean(sample)

该脚本读取文件或数据库的一些示例数据，并提供计算数据平均值的函数。

继续使用以下命令运行脚本：

$ python -i sample.py

Once you press Enter, this command runs the code in sample.py and takes you directly to an interactive session. You’ll recognize this session because your screen will present the REPL’s primary prompt (>>>).

从此时起，您可以检查、测试和调试代码sample.py如所须：

>>> globals()
{
    '__name__': '__main__',
    ...
    'read_data': <function read_data at 0x104dd4860>,
    'sample': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
    'mean': <function mean at 0x104fe3ec0>,
    'average': 5.5
}

>>> mean([2, 3, 3, 2])
2.5

>>> mean([])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File ".../sample.py", line 10, in mean
    return sum(data) / len(data)
           ~~~~~~~~~~^~~~~~~~~~~
ZeroDivisionError: division by zero

在这些示例中，您首先调用内置函数全局变量()函数来检查脚本中定义的全局名称。该函数返回一个字典，将名称映射到相应的对象。第二个例子调用mean()使用新的数据样本。

最后的例子调用mean()以空列表作为参数。在这种情况下，该函数会失败并显示ZeroDivisionError因为打电话长度（）返回空列表0.

这-bflag 是在交互模式下运行 Python 时要考虑的另一个命令行选项。当您运行比较的代码时，此选项会派上用场字节对象，并且您希望在以下情况下收到警告细绳或整数值进入比较中间：

>>> # Run python with the -b option
>>> b = b"Hello"
>>> s = "Hello"
>>> b == s
<stdin>:1: BytesWarning: Comparison between bytes and string
False

这-b第二个示例中的选项使解释器在发现比较操作时显示警告bytes与字符串或int价值观。如果您不使用此选项，则不会显示警告：

>>> # Run python without the -b option
>>> b = b"Hello"
>>> s = "Hello"
>>> b == s
False

与前面的示例一样，比较返回False因为这些值具有不同的数据类型。然而，在最后一个示例中，您不会收到任何警告来帮助您理解为什么会得到这个结果。

这只是在交互模式下使用 Python 时可能派上用场的选项的示例。有关命令行选项的完整列表，请查看Python 命令行参数.

退出当前的 Python REPL 会话

如果您习惯在命令行或终端上工作，那么您可能不喜欢一直关闭和打开终端窗口。您的常规工作流程可能会执行CLI工具，工作完成后关闭它们，并返回到当前的 shell 会话。

当您在交互模式下使用 Python 时可能会出现这种情况。一旦进入 REPL，您就无法运行正常的 shell 命令，因为您处于不同的环境中。要返回到正常 shell，您需要终止 REPL 会话。

有几种方法可以退出交互式会话。您可以使用以下任一 Python 函数：

• 辞职（）
• 出口（）

这两个函数内置于 Python 中。因此，您可以在交互式会话中随时使用它们。这两个函数都允许您通过隐式引发来退出当前会话系统退出例外。

或者，您可以明确提出SystemExit手动异常，退出代码为0。您将得到相同的结果，并且当前的 REPL 会话将终止。

这些工具中的任何一个都会让您退出当前的 Python 交互式会话，并带您返回操作系统 (OS) shell。之后，您可以再次运行常规 shell 命令。

终止 REPL 会话的另一个选项是使用以下键盘快捷键之一，具体取决于您当前的操作系统：

• Ctrl+D on Unix systems, such as Linux or macOS
• Ctrl+Z and then Enter on Windows systems

这些组合键代表文件结束符 (EOF)在相应的操作系统中。它们允许您退出当前的交互式会话，因为解释器在一个名为的特殊文件中运行__main__，您可以通过检查来确认__name__属性：

>>> __name__
'__main__'

交互式会话中的所有 Python 代码都将包含在__main__文件，该文件运行直到读取到 EOF 字符。这意味着当解释器找到这个字符时，它会立即终止当前的 REPL 会话。

评估表达式和简单语句

从命令行启动 Python 交互式会话后，您可以立即开始输入并执行 Python 代码。为此，请返回命令行窗口并运行python命令。

When the REPL’s primary prompt (>>>) appears on your screen, type in the following expressions, pressing the Enter key after each of them:

>>> 5 - 2
3

>>> sum([1, 2, 3, 4])
10

>>> 42 > 7
True

>>> number = 42

>>> 7 / 0
Traceback (most recent call last):
    ...
ZeroDivisionError: division by zero

第一个表达式将两个数字相减并显示结果。第二个表达式是对内置函数的调用和（）函数，它采用一系列值和回报它的总和。在第三个示例中，您执行布尔值比较两个数字的表达式。

第四个示例使用赋值语句定义并初始化多变的被称为number。由于赋值不返回任何值，因此 Python 解释器不会在屏幕上显示任何输出。相反，它会立即退回到主提示。最后一个示例展示了当代码出现问题时 Python 如何显示错误。

运行这些示例时，请注意执行每个表达式后解释器如何循环回主提示符（>>>)，它可以让您引入新的表达式。现在您已经看到了正在运行的 REPL 周期。 Python 解释器已读取您的表达式，执行它们，并打印其相应的结果，最终循环回到主提示符。

运行复合语句

通过上一节中的示例，您已经执行了简单的陈述在 Python 交互式会话中。这些表达式被称为简单语句，因为它们没有缩进的代码块。

Python也有复合语句， 例如条件句、循环和和声明。复合语句需要缩进的代码块。 Python 解释器有一个辅助提示符，可让您输入复合语句的代码块。

考虑以下条件语句示例：

>>> number = -42

>>> if number < 0:
...     print("negative")
... elif number > 0:
...     print("positive")
... else:
...     print("equal to 0")
...
negative

在此代码片段中，您首先定义一个变量来保存数字。接下来，您开始条件语句。

Once you type the colon character (:) and press Enter, you get three dots (...) on your screen. These dots represent the REPL’s secondary prompt. This prompt on your screen means that you can enter the required indented blocks of your current compound statement.

在输入缩进代码块时，请记住标准 REPL 不支持自动缩进：

>>> if number < 0:
... print("negative")
  File "<stdin>", line 2
    print("negative")
    ^
IndentationError: expected an indented block after 'if' statement on line 1

在Python标准REPL中，您必须提供适当的缩进手动输入您需要输入的任何缩进代码块。否则，您将得到一个IndentationError，就像上面的例子一样。

处理显式和隐式的行延续

REPL 的辅助提示出现的另一种情况是当你需要使用行延续。当您执行以下操作时，会发生续行显式加入多种的物理线路成一个单一的逻辑线使用反斜杠 (\） 特点：

>>> number = 42

>>> assert isinstance(number, int) and number > 0, \
...     f"number greater than 0 expected, got: {number}"
...

这断言语句执行两项检查number。首先，它使用内置的isinstance()检查值是否为整数的函数数字。然后检查输入值是否大于0。如果这些条件中的任何一个失败，则该语句将引发断言错误以提供的消息作为参数。

当您使用多个物理行来编写由一对括号分隔的表达式时，也会发生行延续，例如，当您定义列表、元组， 或者字典:

>>> fruits = [
... "apple",
... "banana",
... "orange",
... "grape",
... "lemon",
... ]

>>> inventory = {
... "mouse": 120,
... "keyboard": 50,
... "laptop": 200,
... "headphones": 240,
... }

Once you open a bracket, such as [], (), or {}, and press Enter, you get the REPL’s secondary prompt. This is known as implicit line joining.

您还可以在其他上下文中使用隐式行连接，例如数学和布尔值表达式,功能定义和调用，列表推导式， 和生成器表达式。简而言之，隐式续行将出现在所有接受某种类型的括号的 Python 结构中，包括[], ()， 或者{}.

打印与评估

当您以交互模式运行 Python 时，您会注意到解释器立即显示评估或执行任何表达式或语句的结果值。对于生成返回值的所有语句和表达式都是如此。

对于不生成返回值的语句，解释器不会显示任何内容。正如您已经了解到的，赋值语句就是这种情况。

Python 解释器之所以如此，是因为它的主要目标是提供有关代码工作方式的即时反馈。这种行为使得使用内置打印（）当你进行交互工作时，这个功能几乎是不必要的。

然而，至少有一个用例print()在 REPL 会话中。你需要使用print()当您想要显示可以或将要返回的表达式或语句的结果时没有任何.

例如，一些 Python 初学者在开始学习列表时犯的一个常见错误是期望从调用中获得新列表列出方法， 例如。附加（）, 。种类（），等等：

>>> numbers = [2, 4, 1, 3]

>>> numbers.sort()
>>> numbers.append(5)

由于这些方法调用不会向屏幕发出任何输出，因此它们看起来似乎没有执行任何实际操作。然而，他们做到了。

大多数列表方法都会运行其预期的转换或计算到位。换句话说，列表方法通常会修改底层列表对象，而不是创建新的列表对象。因此，大多数列表方法都会返回None，REPL 自动忽略它。结果，屏幕上什么也没有显示。

如果您需要显示None在 REPL 会话中，那么您必须使用print()功能：

>>> print(numbers.append(6))
None

>>> numbers
[1, 2, 3, 4, 5, 6]

>>> value = None
>>> value
>>> print(value)
None

在此代码片段中，您使用print()显示返回值.append()，即None， 如你看到的。

Note that you can always access the content of a given variable by typing the variable’s name and pressing Enter after it, as you did with numbers. However, if the variable is currently set to None, then you won’t get anything on your screen. You’ll have to use print(), as you did with value.

标记和理解错误

当 REPL 会话发生错误时，解释器会自动打印相应的错误消息并追溯。然后，它循环回到 REPL 的主提示符。在以下示例中，您将看到此行为的实际效果：

>>> greeting = "Hello, World!
  File "<stdin>", line 1
    greeting = "Hello, World!
               ^
SyntaxError: unterminated string literal (detected at line 1)

>>> 42 / 0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero

>>> sum()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: sum() takes at least 1 positional argument (0 given)

在第一个示例中，字符串文字未正确用双引号 ("）。这就提出了一个语法错误。第二个例子提出了一个ZeroDivisionError例外，因为你试图划分42经过0。在最后一个示例中，您调用内置函数sum()不带参数的函数，这会引发TypeError.

所有这些错误都会立即打印在屏幕上。此行为使您可以快速、仔细地检查错误消息和回溯，以便跟踪根本问题并修复代码。

使用_特殊变量

每次运行返回值的语句时，解释器都会在内部将该值存储在一个用单个下划线命名的特殊变量中（_）。您可以像 Python 中的任何其他变量一样访问和使用该变量。

这里有几个例子显示了隐含的_使用表达式时变量的作用：

>>> 42 < 7
False
>>> _
False

>>> 12 + 30
42
>>> _
42

在这些示例中，您正在评估表达式。表达式总是有一个返回值，该值会自动分配给_每次都有变化。

当涉及到函数调用时，如果目标函数返回的值不同于没有任何， 然后_将保持该值。相反，如果函数返回None，那么_变量将保留前面操作的值：

>>> pow(4, 2)
16
>>> _
16

>>> print("Hello, World!")
Hello, World!
>>> _
16

内置的战俘（）函数计算一个数字给定指数的幂，并返回结果。因为函数的结果不同于None， 这_变量会自动重新分配。相反，如果您调用一个返回的函数None， 喜欢print()，那么_变量保持不变。

在下面的示例中，您使用赋值语句创建并初始化counter多变的：

>>> counter = 0
>>> _
16

>>> counter
0
>>> _
0

赋值不会返回任何值。相反，它们存储对变量中值的引用。在这种情况下，_运行该语句后变量不会更新。这就是为什么变量仍然包含数字16从前面的例子来看。

请注意，在交互式会话中访问变量会返回该变量引用的值。在这种情况下，该值也被分配给_多变的。

因为_是一个常规的Python变量，你可以在表达式和语句中使用它：

>>> numbers = [1, 2, 3, 4]

>>> len(numbers)
4

>>> sum(numbers) / _
2.5

在此示例中，您首先创建一个值列表。然后你打电话长度（）获取列表中值的数量。 Python 自动将该值存储在_多变的。最后，你使用_计算值列表的平均值。

当使用_REPL 会话中的变量，请记住该变量仅出现在交互模式中。如果您在脚本模式下运行代码，则不会出现这种隐式行为。

重新加载导入的模块

假设你正在编写一个 Python模块为您的项目之一提供一些功能。同时，您可以在交互模式下使用 Python 来实时测试模块的代码。例如，假设您有以下模块：

# greeting.py

def greet(name="World"):
    print(f"Hello, {name}!")

在此文件中，您定义一个greet()在屏幕上打印问候消息的功能。以下是如何从 REPL 会话加载和使用此代码：

>>> import greeting

>>> greeting.greet()
'Hello, World!'
>>> greeting.greet("Pythonista")
'Hello, Pythonista!'

现在假设您想向函数添加一个新参数。参数将是一个布尔标志，允许以大写字母打印问候消息。为此，您可以将该函数修改为如下所示：

# greeting.py

def greet(name="World", upper=False):
    greeting = f"Hello, {name}!"
    if upper:
        greeting = greeting.upper()
    print(greeting)

此更新允许您致电greet()与upper争论。如果将参数设置为True，则消息将以大写字母显示。现在，您渴望在当前的 REPL 会话中尝试所做的更改。所以，你再次导入模块，希望能够运行新版本的greet()如下：

>>> import greeting

>>> greeting.greet("Pythonista", upper=True)
Traceback (most recent call last):
  File "<input>", line 1, in <module>
    greeting.greet("Pythonista", upper=True)
     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
TypeError: greet() got an unexpected keyword argument 'upper'

什么？你们有意想不到的争吵吗？为了效率原因，更新某些内容后再次运行导入greeting.py不重新加载模块。当您重新运行导入时，Python 不会再次加载导入的模块。

如果您想在不关闭当前 REPL 会话并打开新会话的情况下解决此问题，那么您可以使用重新加载()函数来自导入库:

>>> import importlib
>>> importlib.reload(greeting)
<module 'greeting' from '.../greeting.py'>

>>> greeting.greet("Pythonista", upper=True)
HELLO, PYTHONISTA!

现在你的函数可以运行了！这reload()函数已负责加载您的新版本greeting模块。当你在你的模块中工作时，你可以使用这个技巧。代码编辑器并在 REPL 会话中测试您的更改。

现在您已经了解了在 Python 交互式 shell 中输入和执行代码的基础知识，是时候探索和了解标准 REPL 提供的一些编辑功能了。

代码历史

标准 REPL 记录您在交互模式下工作时键入和运行的所有代码的完整历史记录。该历史记录保存到一个名为.python_history，通常位于您的主目录中。

While in interactive mode, you can browse this history by using the arrow keys on your keyboard. With the Up key, you can go back in history. With Down, you can go forward in history.

Once you find the desired line of code, you can press Enter to confirm your selection and reuse the target instruction:

Note how the code in your REPL’s history immediately becomes available for reuse. To navigate the code history, use the Up and Down keys until you find the desired snippet.

The navigation starts from the end of the history file and goes up. Every time you press the Up key, you jump to the previous line of code in your history.

Once you find the line of code that you want to reuse or modify, press Enter to accept it. Remember that every line in your code history keeps the original indentation that you used when you first typed the code, which is convenient and saves time.

代码完成

The standard REPL provides basic completion capabilities for variable, object, and module names. This feature is automatically enabled when you start an interactive session. To invoke the available code completions, you can type the starting characters of a given name and press the Tab key. This action triggers the completion search.

If the search finds a match, then the name will automatically be completed for you. If the search finds more than one match, then you’ll have to press Tab again to get the entire list of matching names. If nothing appears after pressing Tab twice, then your search didn’t find any result.

代码完成系统在运行搜索时会查看以下对象：

• Python关键词
• 内置功能, 班级， 和目的名字
• 当前定义的名称，例如变量, 功能， 和类
• 进口模块和包裹名字

以下是 REPL 代码完成系统在实践中如何工作的示例：

When you type the first character or characters of your target name and press Enter, you get an automatic completion if the REPL finds a unique match. When the completion system finds more than one name that matches your search, you need to press Tab again to get the list of matching names.

You can type a few more characters and press Tab again, or you can just type the complete name or keyword.

当涉及到访问属性时点符号， 像obj.attr，代码补全系统将建议目标对象的属性和方法的补全：

Once you type the name of an object followed by a dot, you can press Tab to quickly inspect the list of attributes and methods of that object. Then you can start typing the name of your target attribute or method and press Tab again for completion.

标准 REPL 提供了一组相当有限的代码编辑功能。但是，当您需要使用交互式会话并且没有更高级的 REPL 时，它们可能非常有用。这些代码编辑功能可以提高您的工作效率并使您的编码体验更加愉快。

有用的键盘快捷键

Leaning useful keyboard shortcuts can significantly boost your productivity and efficiency when you’re working in a REPL session. For example, pressing Ctrl+C on the REPL’s primary or secondary prompt cancels the input and returns to the primary prompt:

>>> print(
KeyboardInterrupt

>>> if True:
...
KeyboardInterrupt

When you press Ctrl+C on the primary or secondary prompt, the interpreter raises a KeyboardInterrupt exception and immediately returns to the primary prompt.

If you press Ctrl+C while some piece of code is running, then the interpreter raises a KeyboardInterrupt exception, interrupting the code’s execution and returning to the primary prompt.

当您启动一个您不愿意完成的长时间运行的任务或当您意外遇到一个问题时，后一种行为非常有用。无限循环:

>>> while True:
...     print("Hello!")
...
Hello!
Hello!
Hello!
^CTraceback (most recent call last):
  File "<stdin>", line 2, in <module>
KeyboardInterrupt
Hello!

This example presents an infinite while loop. You can break the loop by pressing Ctrl+C on your keyboard. After this key combination, you’re again back to the primary prompt, and your REPL session is ready for new input.

标准 REPL 提供了许多其他有趣且有用的键盘快捷键。下表显示了其中一些：

这些键盘快捷键将帮助您在交互式会话中更熟练地键入和编辑代码。您可以在官方文档中找到更多键盘快捷键GNU 阅读线图书馆。

使用Python的内置帮助系统

内置的帮助（）函数使您可以访问Python的内置帮助系统。您可以通过两种方式调用该函数来使用它：

1. 与目的或一个细绳作为参数，它使您可以访问该对象的帮助页面
2. 和没有参数，进入Python的帮助系统

对象的帮助页面通常包含对象文档字符串中的信息。它还可能包括方法和属性的列表。例如，这是页面的一个片段str您可以通过键入来访问的类help(str)在您的 REPL 会话中：

>>> help(str)

Help on class str in module builtins:

class str(object)
 |  str(object='') -> str
 |  str(bytes_or_buffer[, encoding[, errors]]) -> str
 |
 |  Create a new string object from the given object. If encoding or
 |  errors is specified, then the object must expose a data buffer
 |  that will be decoded using the given encoding and error handler.
 |  Otherwise, returns the result of object.__str__() (if defined)
 |  or repr(object).
 |  encoding defaults to sys.getdefaultencoding().
 |  errors defaults to 'strict'.
 |
 |  Methods defined here:
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __contains__(self, key, /)
 |      Return key in self.
...

In this example, you use the str class object as an argument to help(). This way, you access the class’s help page. You can use the Up and Down keys to move through the page. When you get the desired information, you can press the Q key to exit the help viewer.

如果您使用字符串作为参数help()，然后帮助系统将其作为模块、函数、类、方法、关键字或文档主题的名称进行查找。屏幕上打印相应的帮助页面。通过这种方式调用help()当目标对象在当前中不可用时会派上用场名称空间.

例如，假设您想获得以下方面的帮助：路径库模块，但你还没有导入它。然后你就可以运行help()用字符串"pathlib"作为一个论点。你会得到类似下面的内容：

>>> help("pathlib")

Help on module pathlib:

NAME
    pathlib

MODULE REFERENCE
    https://docs.python.org/3.11/library/pathlib.html

    The following documentation is automatically generated from the Python
    source files.  It may be incomplete, incorrect or include features that
    are considered implementation detail and may vary between Python
    implementations.  When in doubt, consult the module reference at the
    location listed above.
...

致电给help()和"pathlib"作为参数显示模块的帮助页面。请注意，如果您致电help()与pathlibname 作为参数，那么你会得到一个NameError因为您还没有将该模块导入到当前的命名空间中。

第二种使用方式help()就是不带参数调用函数。这样就进入了内置帮助系统：

>>> help()

此调用允许您进入帮助模式。一旦你运行它，你会立即注意到提示符从>>>到help>。这个新提示提醒您您正处于交互式帮助模式。

In help mode, you can enter keywords, module names, function names, or any other name. The help system will search for the target name and present the associated documentation page. To try this functionality out, go ahead and type sys on the help> prompt, then press Enter. You’ll get the following page on your screen:

help> sys

Help on built-in module sys:

NAME
    sys

MODULE REFERENCE
    https://docs.python.org/3.11/library/sys.html

    The following documentation is automatically generated from the Python
    source files.  It may be incomplete, incorrect or include features that
    are considered implementation detail and may vary between Python
    implementations.  When in doubt, consult the module reference at the
    location listed above.
...

Again, to exit the page, you can press the Q key on your keyboard. The help system allows you to search for different topics. Just type the desired topic and press Enter. If the topic has a documentation page, then you’ll get it on your screen. Otherwise, you’ll get an ImportError that’ll bring you back to the primary prompt:

help> keywords

Here is a list of the Python keywords.  Enter any keyword to get more help.

False               class               from                or
None                continue            global              pass
True                def                 if                  raise
and                 del                 import              return
as                  elif                in                  try
assert              else                is                  while
async               except              lambda              with
await               finally             nonlocal            yield
break               for                 not

help> iterable
Traceback (most recent call last):
    ...
ImportError: No Python documentation found for 'iterable'.
Use help() to get the interactive help utility.
Use help(str) for help on the str class.

在此示例中，您首先搜索术语keywords。此搜索查找并显示有关 Python 关键字的页面。然后，您搜索该词iterable。不幸的是，这个主题没有文档页面，所以你会得到一个ImportError这会让您退出帮助系统。

Once you’ve found the required information, then you can exit the help system by typing q or quit and then pressing Enter. This way, you’ll be back to your REPL session.

动态自省你的代码

当您在 REPL 会话中工作时，您可以直接访问一些很酷的 Python 内置工具，您可以使用它们来内省代码并获取有关您正在使用的对象的更多信息和上下文。

其中一些内置工具包括：

您可以使用这些内置函数中的任何一个来检查您的代码并检索稍后可以在编码过程中使用的有用信息。

例如，假设您正在使用字典并希望获取此类中所有方法和属性的列表。你可以这样做：

>>> dir(dict)
['__class__', ..., 'popitem', 'setdefault', 'update', 'values']

此示例中的输出将名称列表显示为字符串。该列表将包括中定义的属性和方法dict班级。您可以将此内置函数与任何 Python 对象一起使用。

这vars()函数的工作原理类似于dir()但返回名称-对象对的字典而不是列表。

这locals()和globals()当您想知道代码中给定范围内定义的名称时，函数也很有用。最后，type()函数可帮助您确定代码中给定对象的数据类型或类。

提供启动文件

标准 REPL 接受启动文件，您可以使用该文件来调整某些当前功能或向交互式会话添加新功能。该文件仅在交互式会话中运行。当您使用以下命令执行程序时它不会运行python命令。因此，您不必担心会损坏重要的程序。

启动文件可以包含任何Python代码。此代码将在交互模式下显示第一个提示之前执行。

需要强调的是，启动文件运行在与运行交互式代码相同的命名空间中。因此，在此文件中定义或导入的对象将在您的交互式会话中可用。当您想要加载工具并自定义交互式 shell 的功能时，此行为非常有用。

在使用启动文件做一些很酷的事情之前，您需要学习如何告诉解释器您想要使用哪个文件作为启动文件。您可以通过设置Python启动系统 shell 中的环境变量。

如果您使用的是 Linux 或 macOS，则可以转到主文件夹并打开 shell 的配置文件。打开该文件后，在其末尾添加以下行：

• Linux
• 苹果系统

# .bashrc

# ...

export PYTHONSTARTUP=~/.pythonstartup

# .zshrc

# ...

export PYTHONSTARTUP=~/.pythonstartup

每当您启动终端或命令行窗口时，Linux 和 macOS shell 都会自动加载相应的配置文件。这样，您就可以确保PYTHONSTARTUP变量在您的系统上始终可用。

在此示例中，您设置PYTHONSTARTUP变量为~/.pythonstartup，这是目标启动文件的路径。在这种情况下，该文件将位于您的主目录中，其文件名将是.pythonstartup.

请注意，文件名并不重要。您可以将其命名为任何您想要的名称。您还可以将该文件放在您想要的任何目录中。只需确保您的PYTHONSTARTUP环境变量保存正确的文件路径。

如果您使用的是 Windows，请查看配置环境变量部分在Windows 上的 Python 编码环境：设置指南创建系统变量的完整指南。按照说明进行操作并添加PYTHONSTARTUP具有合适路径的系统变量。

一旦你设置了PYTHONSTARTUP变量，继续并在所需的文件夹中创建文件。在文本编辑器中打开文件并准备添加一些代码。要开始使用自定义启动文件，您将首先添加一些导入：

# .pythonstartup

from importlib import reload
from pprint import pp

正如您已经了解到的，reload()函数允许您在修改模块内容时重新加载模块，以便您可以测试更改。在交互式会话中始终使用此功能会很棒。它将防止重复工作并节省您的时间。

这pp()函数从印刷品模块允许您打印格式漂亮的数据结构，例如列表和字典。

要尝试这些新增功能，请继续打开新的终端或命令行窗口。然后以交互模式运行Python。到达那里后，运行以下代码：

>>> pp(globals())
{'__name__': '__main__',
 ...
 '__builtins__': <module 'builtins' (built-in)>,
 'reload': <function reload at 0x101455c60>,
 'pp': <function pp at 0x1014f3380>}

凉爽的！这pp()功能已经可以使用了。注意reload()也显示为当前全局命名空间中的条目。

您可以在 REPL 的启动文件中添加所需的任何导入。这是一种很好且快速的方法，让您在运行交互式会话时可以使用有用的工具。

您在 REPL 的启动文件中进行的另一个有趣的自定义是更改用于标识主要的字符（>>>）和次要（...) 提示。为此，您可以更改系统.ps1和系统.ps2变量。

继续将以下代码添加到您的启动文件中：

# .pythonstartup

import sys
from importlib import reload
from pprint import pp

sys.ps1 = "py$ "
sys.ps2 = "py> "

在这种情况下，你告诉口译员使用"py$ "作为主要提示和"py> "作为辅助提示。要尝试这种新的外观和感觉，请启动新的 REPL 会话。你的 shell 看起来像这样：

py$ numbers = [
py> 1,
py> 2,
py> 3,
py> ]
py$

更改 REPL 的提示可能是一个令人兴奋的探索技巧。然而，在实践中，使用不同的提示可能会让其他查看您屏幕的 Python 开发人员感到困惑。因此，您最好遵循标准提示。

您会发现许多其他有趣的调整和自定义可以添加到 REPL 的启动文件中。不要害羞！当您在交互模式下工作时，请继续尝试以改善您的用户体验和工作效率。

使用 Rich 对 REPL 输出进行着色

丰富的库允许您使用富文本并在终端中进行漂亮的格式化。丰富5.1.0包括突出显示的漂亮印刷。您可以使用此功能对标准 REPL 的输出进行着色。但是，您首先需要pip安装 Rich 从PyPI，Python 包索引，使用以下命令：

$ python -m pip install rich

运行此命令后，您就可以为 REPL 的输出着色了。以下是在交互式会话中执行此操作的方法：

>>> from rich import pretty, traceback
>>> pretty.install()
>>> traceback.install(show_locals=False)

从现在开始，每次您在当前 REPL 会话中获得输出时，该输出都会被着色和格式化：

请注意，此添加的功能是暂时的。它仅适用于您运行上述代码的交互式会话。如果您希望每个部分都提供此功能，请使用您的启动文件：

# .pythonstartup

import sys
from importlib import reload
from pprint import pp

try:
    from rich import pretty, traceback
except ModuleNotFoundError:
    pass
else:
    pretty.install()
    traceback.install(show_locals=False)

# ...

通过对 REPL 启动文件的更新，您可以在所有可访问 Rich 库的交互式会话中复制输出着色和格式化行为。这try … except … else块保证如果 Rich 在您使用的 Python 环境中不可用，您的启动文件不会抛出错误。