python基础-内置函数4-输入输出流-编译与执行

文章目录

- 其他
- 输入输出流
- - input()
  - print()
  - open()
- 数学
- - divmod()
  - pow()
  - round()
  - abs()
- 编译与执行
- - compile()
  - eval()
  - exec()
- 其他
- - help()
  - globals()
  - locals()
  - breakpoint()
  - format()
  - import()

其他

输入输出流

input()

python 复制代码

input()
input(prompt)

如果存在 prompt 实参，则将其写入标准输出，末尾不带换行符。接下来，该函数从输入中读取一行，将其转换为字符串（除了末尾的换行符）并返回。当读取到 EOF 时，则触发 EOFError。例如:

python 复制代码

>>> a=input("输入a的值:")
输入a的值:12
>>> a
'12'

print()

python 复制代码

print(*objects, sep=' ', end='\n', file=None, flush=False)

将 objects 打印输出至file指定的文本流，以 sep 分隔并在末尾加上 end。 sep 、end 、 file 和 flush 必须以关键字参数的形式给出。

所有非关键字参数都会被转换为字符串，就像是执行了 str() 一样，并会被写入到流，以 sep 分隔并在末尾加上 end。 sep 和 end 都必须为字符串；它们也可以为 None，这意味着使用默认值。如果没有给出 objects，则 print() 将只写入 end。
file 参数必须是一个具有 write(string) 方法的对象；如果参数不存在或为 None，则将使用 sys.stdout。由于要打印的参数会被转换为文本字符串，因此 print() 不能用于二进制模式的文件对象。对于这些对象，应改用 file.write(...)。

输出缓冲通常由 file 确定。但是，如果 flush 为真值，流将被强制刷新。

在 3.3 版本发生变更: 增加了 flush 关键字参数。

python 复制代码

>>> print(1)
1
>>> a = [print(i, sep = " ", end="\n") for i in range(10)]
0
1
2
3
4
5
6
7
8
9
>>> a = [print(i, sep = " ", end="\t") for i in range(10)]
0       1       2       3       4       5       6       7       8       9

open()

python 复制代码

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

在 Python 中，可以使用内置的 open() 函数打开文件，并返回对应的文件对象。

其中：

file 是一个 path-like object，表示要打开的文件的路径（绝对路径或相对于当前工作目录的路径），也可以是要封装文件的整数类型文件描述符。如果该文件不能被打开，则会引发 OSError 异常。
mode 是一个可选字符串参数，用于指定文件的打开模式。默认值为 'r'，表示以文本模式读取文件。其他常见模式包括：
- 'w'：写入模式，会先清空文件内容。
- 'x'：排它性创建，如果文件已存在则失败。
- 'a'：追加模式，在文件末尾追加内容。
- 'b'：二进制模式。
- 't'：文本模式（默认）。
- '+'：打开文件用于更新（读取与写入）。
buffering 是一个可选整数，用于设置缓冲策略。传入 0 表示关闭缓冲（仅在二进制模式下允许），传入 1 表示选择行缓冲（仅在文本模式下写入时可用），传入一个整数大于 1 表示固定大小的块缓冲区的字节大小。如果没有给出 buffering 参数，则默认的缓冲策略取决于文件的类型和操作系统。
encoding 是一个可选字符串参数，用于指定文件的编码格式。默认值为 None，表示使用平台默认的编码格式。对于文本模式下的读写操作，可以通过指定 encoding 参数来明确指定编码格式。
errors 是一个可选字符串参数，用于指定如何处理编码和解码错误。默认值为 None，表示使用默认的错误处理策略。常见的错误处理方案包括 'strict'、'ignore'、'replace' 等。
newline 是一个可选字符串参数，用于决定如何解析来自文件流的换行符。它可以为 None、''、'\n'、'\r'、'\r\n' 中的任意一个。newline 的具体工作原理取决于操作系统和文件模式。
closefd 是一个可选布尔值参数，用于指定在文件对象关闭时是否同时关闭底层的文件描述符。默认值为 True，表示关闭底层文件描述符。
opener 是一个可选的可调用对象，用于自定义文件的打开器。如果指定了 opener 参数，则会使用它来获取文件对象的基础文件描述符。
打开文件后，可以对文件对象执行读取、写入等操作。完成操作后，应该使用 close() 方法关闭文件对象，以释放资源。
在 Python 中，使用 open() 函数可以打开文件，并返回对应的文件对象。open() 函数的返回类型取决于所用的模式。当以文本模式（如 'w'、'r'、'wt'、'rt' 等）打开文件时，返回的对象是 io.TextIOBase 的一个子类，通常是 io.TextIOWrapper。而当以二进制模式打开文件时，返回的对象是 io.BufferedIOBase 的一个子类，具体取决于操作系统和文件模式。
在不同的模式下，返回的文件对象可能是以下几种之一：
在只读的二进制模式下，返回的是 io.BufferedReader。
在写入二进制和追加二进制模式下，返回的是 io.BufferedWriter。
在读/写模式下，返回的是 io.BufferedRandom。
如果禁用了缓冲，返回的对象将是原始流，即 io.RawIOBase 的一个子类，通常是 io.FileIO。
下面是一些示例，演示了不同模式下 open() 函数返回的文件对象类型：

python 复制代码

# 以文本模式打开文件，返回的是 io.TextIOWrapper 对象
with open('example.txt', 'r') as f:
    print(type(f))  # 输出: <class '_io.TextIOWrapper'>

# 以二进制模式打开文件，返回的是 io.BufferedWriter 对象
with open('example.bin', 'wb') as f:
    print(type(f))  # 输出: <class '_io.BufferedWriter'>

# 禁用缓冲后，返回的是 io.FileIO 对象
with open('example.txt', 'r', buffering=0) as f:
    print(type(f))  # 输出: <class '_io.FileIO'>

除了 open() 函数外，还有一些其他文件操作模块，如 fileinput、io（声明了 open() 函数）、os、os.path、tempfile 和 shutil，提供了更多文件处理的功能和工具。

数学

divmod()

python 复制代码

divmod(x, y)

以两个（非复数）数字为参数，在作整数除法时，返回商和余数。若操作数为混合类型，则适用二进制算术运算符的规则。对于整数而言，结果与 (a // b, a % b) 相同。对于浮点数则结果为 (q, a % b)，其中 q 通常为 math.floor(a / b)，但可能比它小 1。在任何情况下， q * b + a % b 都非常接近 a，如果 a % b 非零，则结果符号与 b 相同，并且 0 <= abs(a % b) < abs(b)。

python 复制代码

>>> result = divmod(10, 3)
>>> print(result)  
(3, 1)

pow()

python 复制代码

>>> pow(base, exp, mod=None)

返回 base 的 exp 次幂；如果 mod 存在，则返回 base 的 exp 次幂对 mod 取余（比 pow(base, exp) % mod 更高效）。两参数形式 pow(base, exp) 等价于乘方运算符: base**exp。

参数必须为数值类型。对于混用的操作数类型，则适用二元算术运算符的类型强制转换规则。对于 int 操作数，结果具有与操作数相同的类型（转换后），除非第二个参数为负值；在这种情况下，所有参数将被转换为浮点数并输出浮点数结果。例如，pow(10, 2) 返回 100，但 pow(10, -2) 返回 0.01。对于 int 或 float 类型的负基和一个非整数的指数，会产生一个复数作为结果。例如， pow(-9, 0.5) 返回一个接近于 3j 的值。

对于 int 操作数 base 和 exp，如果给出 mod，则 mod 必须为整数类型并且 mod 必须不为零。如果给出 mod 并且 exp 为负值，则 base 必须相对于 mod 不可整除。在这种情况下，将会返回 pow(inv_base, -exp, mod)，其中 inv_base 为 base 的倒数对 mod 取余。

python 复制代码

>>> result = pow(2, 3)
>>> print(result) 
8
>>> result = pow(2, 3, 3)
>>> print(result) 
2

round()

python 复制代码

round(number, ndigits=None)

round() 函数用于对浮点数进行四舍五入。它接受两个参数：要进行四舍五入的数字和要保留的小数位数。

对于一般的 Python 对象 number, round 将委托给 number.__round__。

python 复制代码

>>> result = round(3.1415926, 2)
>>> print(result)
3.14
>>> round(2.675, 2)
2.67

对浮点数执行 round() 的行为可能会令人惊讶：例如，round(2.675, 2) 将给出 2.67 而不是期望的 2.68。这不算是程序错误：这一结果是由于大多数十进制小数实际上都不能以浮点数精确地表示。

abs()

python 复制代码

abs(x)

返回一个数的绝对值。参数可以是整数、浮点数或任何实现了 __abs__() 的对象。如果参数是一个复数，则返回它的模。

python 复制代码

>>> result = abs(-10)
>>> print(result) 
10
>>> abs(4+1j)
4.123105625617661

编译与执行

compile()

在Python中，compile()函数用于将源代码编译成字节码，以便它可以被执行。这个函数通常用于动态执行代码，例如当你需要在运行时生成代码或者从外部源（如文件或数据库）加载代码时。

compile()函数的基本语法如下：

python 复制代码

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

参数说明：

source: 要编译的代码。它可以是一个字符串（包含Python代码的字符串）或者AST（抽象语法树）对象。
filename: 代码文件的名称，或者如果代码不是从文件中获取的，则是一个说明代码来源的字符串。
mode: 编译模式，可以是 'exec'（执行一个语句块）、'eval'（求值一个表达式）或 'single'（执行单个交互式语句）。
flags: 可选的标志位，用于控制编译器的某些行为。这是ast.PyCF_*常量的位掩码。
dont_inherit: 如果为True，则忽略flags参数中的PyCF_ONLY_AST标志位，以及任何从父作用域继承的标志位。
optimize: 指定编译器的优化级别（默认值为-1），这通常是0（没有优化）、1（断言调用移除）或2（文档字符串移除）。
下面是一些使用compile()函数的例子：

python 复制代码

# 编译一个表达式
>>> code = "1+1"
>>> code_obj = compile(code, "<string>", "eval")
>>> code_obj
<code object <module> at 0x000001B7AD294E40, file "<string>", line 1>
>>> eval(code_obj)
2
# 编译一个语句块
>>> code_block = '''
... a = 5
... b = 10
... print(a + b)
... '''
>>> code_obj_block = compile(code_block, '<string>', 'exec')
>>> exec(code_obj_block)
15

eval()

python 复制代码

eval(expression, globals=None, locals=None)

参数:

expression (str | code object) -- 一个 Python 表达式。
globals (dict | None) -- 全局命名空间 (默认值: None)，非关键字参数。
locals (mapping | None) -- 局部命名空间 (默认值: None)，非关键字参数。
表达式解析参数 expression 并作为 Python 表达式进行求值（从技术上说是一个条件列表），采用 globals 和 locals 字典作为全局和局部命名空间。如果存在 globals 字典，并且不包含 __builtins__ 键的值，则在解析 expression 之前会插入以该字符串为键以对内置模块 builtins 的字典的引用为值的项。这样就可以在将 globals 传给 eval() 之前通过向其传入你自己的 __builtins__ 字典来控制可供被执行代码可以使用哪些内置模块。如果 locals 字典被省略则它默认为 globals 字典。如果两个字典都被省略，则将使用调用 eval() 的环境中的 globals 和 locals 来执行该表达式。注意，eval() 无法访问闭包环境中的嵌套作用域 (非局部变量)。
该函数还可用于执行任意代码对象（比如由 compile() 创建的对象）。这时传入的是代码对象，而非一个字符串了。如果代码对象已用参数为 mode 的 'exec' 进行了编译，那么 eval() 的返回值将为 None

python 复制代码

>>> eval("1+1")
2
>>> code = compile("1+1", "<string>", "eval")
>>> eval(code)
2
>>> eval("a+b", {'a':1}, {'b':2})
3

exec()

这个函数支持动态执行 Python 代码。对象必须是一个字符串或一个代码对象。如果它是一个字符串，那么这个字符串将被解析为一组 Python 语句，然后执行（除非发生语法错误）。如果它是一个代码对象，它将被简单地执行。在所有情况下，被执行的代码都应该是作为文件输入有效的（请参阅参考手册中的 "文件输入" 部分）。请注意，即使在传递给 exec() 函数的代码中，非本地（nonlocal）、yield 和 return 语句也不能在函数定义之外使用。返回值是 None。

在所有情况下，如果省略了可选部分，代码将在当前作用域中执行。如果只提供了 globals，它必须是一个字典（而不是字典的子类），它将用于全局和局部变量。如果给出了 globals 和 locals，它们将分别用于全局和局部变量。如果提供了 locals，它可以是任何映射对象。请记住，在模块级别，globals 和 locals 是相同的字典。

python 复制代码

>>> exec("1+1") # 并不会返回计算结果
>>> exec("print(1)")
1

其他

help()

python 复制代码

help()
help(request)

启动内置的帮助系统（此函数主要在交互式中使用）。如果没有实参，解释器控制台里会启动交互式帮助系统。如果实参是一个字符串，则在模块、函数、类、方法、关键字或文档主题中搜索该字符串，并在控制台上打印帮助信息。如果实参是其他任意对象，则会生成该对象的帮助页。

请注意，如果在调用 help() 时，目标函数的形参列表中存在斜杠（/），则意味着斜杠之前的参数只能是位置参数。

该函数通过 site 模块加入到内置命名空间。

在 3.4 版本发生变更: pydoc 和 inspect 的变更使得可调用对象的签名信息更加全面和一致

globals()

返回实现当前模块命名空间的字典。对于函数内的代码，这是在定义函数时设置的，无论函数在哪里被调用都保持不变。

python 复制代码

>>> globals()
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'C': <class '__main__.C'>, 'c': <__main__.C object at 0x7f874f3d7f90>, 's': '', 'func': <function <lambda> at 0x7f874f4db9c0>, 'Person': <class '__main__.Person'>, 'a': [None, None, None, None, None, None, None, None, None, None], 'X': <class '__main__.X'>, 'code': <code object <module> at 0x7f874f32a070, file "<string>", line 1>}

locals()

更新并返回一个字典，表示当前的局部符号表。当在函数块中调用 locals() 时，自由变量会被返回，但在类块中则不会。请注意，在模块级别，locals() 和 globals() 是相同的字典。

这个字典的内容不应该被修改；修改可能不会影响解释器使用的局部变量和自由变量的值。

python 复制代码

>>> locals()
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'C': <class '__main__.C'>, 'c': <__main__.C object at 0x7f874f3d7f90>, 's': '', 'func': <function <lambda> at 0x7f874f4db9c0>, 'Person': <class '__main__.Person'>, 'a': [None, None, None, None, None, None, None, None, None, None], 'X': <class '__main__.X'>, 'code': <code object <module> at 0x7f874f32a070, file "<string>", line 1>}

breakpoint()

此函数会在调用点进入调试器。具体来说，它调用 sys.breakpointhook() ，直接传递 args 和 kws 。默认情况下， sys.breakpointhook() 调用 pdb.set_trace() 且没有参数。在这种情况下，它纯粹是一个便利函数，因此您不必显式导入 pdb 且键入尽可能少的代码即可进入调试器。但是， sys.breakpointhook() 可以设置为其他一些函数并被 breakpoint() 自动调用，以允许进入你想用的调试器。如果 sys.breakpointhook() 不可访问，这个函数将会引发 RuntimeError。

在默认情况下，breakpoint() 的行为可使用 PYTHONBREAKPOINT 环境变量来改变。请参阅 sys.breakpointhook() 了解详细用法。

请注意这并不保证 sys.breakpointhook() 会被替换。

引发一个审计事件 builtins.breakpoint 并附带参数 breakpointhook。

Added in version 3.7.

format()

python 复制代码

format(value, format_spec='')

将 value 转换为"格式化后"的形式，格式由 format_spec 进行控制。format_spec 的解释方式取决于 value 参数的类型；但大多数内置类型使用一种标准的格式化语法：参考文档

import()

python 复制代码

__import__(name, globals=None, locals=None, fromlist=(), level=0)

此函数会由 import 语句发起调用。它可以被替换（通过导入 builtins 模块并赋值给 builtins.__import__）以便修改 import 语句的语义，但是强烈不建议 这样做，因为使用导入钩子通常更容易实现同样的目标，并且不会导致代码问题，因为许多代码都会假定所用的是默认实现。同样也不建议直接使用 __import__() 而应该用 importlib.import_module()。

本函数会导入模块 name，利用 globals 和 locals 来决定如何在包的上下文中解释该名称。fromlist 给出了应从 name 模块中导入的对象或子模块的名称。标准的实现代码完全不会用到 locals 参数，只用到了 globals 用于确定 import 语句所在的包上下文。

level 指定是使用绝对还是相对导入。0（默认值）意味着仅执行绝对导入。level 为正数值表示相对于模块调用 __import__() 的目录，将要搜索的父目录层数。

当 name 变量的形式为 package.module 时，通常将会返回最高层级的包（第一个点号之前的名称），而不是以 name 命名的模块。但是，当给出了非空的 fromlist 参数时，则将返回以 name 命名的模块。

例如，语句 import spam 的结果将为与以下代码作用相同的字节码:

python 复制代码

spam = __import__('spam', globals(), locals(), [], 0)

语句 import spam.ham 的结果将为以下调用:

python 复制代码

spam = __import__('spam.ham', globals(), locals(), [], 0)

请注意在这里 __import__() 是如何返回顶层模块的，因为这是通过 import 语句被绑定到特定名称的对象。

另一方面，语句 from spam.ham import eggs, sausage as saus 的结果将为：

python 复制代码

_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)
eggs = _temp.eggs
saus = _temp.sausage

在这里，spam.ham 模块会由 __import__() 返回。要导入的对象将从此对象中提取并赋值给它们对应的名称。

如果您只想按名称导入模块（可能在包中），请使用 importlib.import_module()。

在 3.3 版本发生变更：level 的值不再支持负数（默认值也修改为 0）。
在 3.9 版本发生变更：当使用了命令行参数 -E 或 -I 时，环境变量 PYTHONCASEOK 现在将被忽略。