Python 3.11.0中文教程：新特性与改进

需积分: 0 35 浏览量更新于2024-06-26 收藏 18.45MB PDF 举报

"Python教程3.11.0中文版 A4 pdf完整版" 这篇文档是关于Python编程语言的3.11.0版本的官方教程，涵盖了新特性、改进和模块更新等内容，非常适合学习和参考。以下是这个版本的一些关键亮点： 1. **新特性概述** Python 3.11.0引入了许多改进，旨在提高代码的可读性、错误处理效率以及类型注解的灵活性。 2. **PEP 657：细粒度的错误位置在tracebacks中** 这个改变使得调试时的错误追踪更精确，可以显示错误发生的具体行号和列号，帮助开发者更快地定位问题。 3. **PEP 654：异常组和except *** 引入了异常组，允许使用`except *`来捕获所有未被其他`except`子句捕获的异常，提高了异常处理的灵活性。 4. **PEP 678：异常可以添加注释** 现在可以在异常上添加注释，提供更多的上下文信息，便于理解异常的原因和解决方法。 5. **Windows py.exe启动器改进** 对于Windows平台，py.exe启动器进行了优化，提供了更好的脚本执行和兼容性。 6. **新特性与类型提示相关** - PEP 646：引入了变长泛型，增强了类型注解的表达能力。 - PEP 655：允许标记TypedDict中的个别项为必需或非必需，增强了数据结构的约束。 - PEP 673：自类型（Self type）使得类方法中的self参数可以明确其类型。 - PEP 675：任意字面字符串类型，允许为字符串类型添加额外的元信息。 - PEP 681：数据类转换，改进了数据类的创建和使用。 7. **其他语言变化** 包括一些语言层面的改进，如语法调整、性能提升等，旨在提高Python的使用体验。 8. **其他CPython实现变化** CPython的内部实现也有变化，可能涉及到内存管理、性能优化等方面。 9. **新模块** 新增的模块提供了更多的功能，扩展了Python的功能集。 10. **改进的模块** - `asyncio`：异步I/O库的更新，可能包括性能提升和新API的添加。 - `contextlib`：上下文管理器库的增强，可能增加了新的上下文管理器或改进了现有功能。 - `dataclasses`：数据类库的改进，可能包含对新特性的支持。 - `datetime`：日期和时间操作库的更新，可能提供了新的方法或优化了性能。 - `...` (其余模块的改进，如`enum`、`fcntl`、`fractions`等) 这些更新和改进都体现了Python社区不断追求的易用性、稳定性和性能提升。对于开发者来说，了解并掌握这些新特性将有助于编写更高效、更健壮的代码。

• typing.get_type_hints() now supports evaluating strings as forward references in PEP 585 generic

aliases. (Contributed by Niklas Rosenstein in gh-85542.)

• typing.get_type_hints() no longer adds Optional to parameters with None as a default. (Con-

tributed by Nikita Sobolev in gh-90353.)

• typing.get_type_hints() now supports evaluating bare stringi󰝘ed ClassVar annotations. (Con-

tributed by Gregory Beauregard in gh-90711.)

• typing.no_type_check() no longer modi󰝘es external classes and functions. It also now correctly marks

classmethods as not to be type checked. (Contributed by Nikita Sobolev in gh-90729.)

7.31 unicodedata

• The Unicode database has been updated to version 14.0.0. (Contributed by Benjamin Peterson in bpo-45190).

7.32 unittest

• Added methods enterContext() and enterClassContext() of class TestCase, method

enterAsyncContext() of class IsolatedAsyncioTestCase and function unittest.

enterModuleContext(). (Contributed by Serhiy Storchaka in bpo-45046.)

7.33 venv

• When new Python virtual environments are created, the venv syscon󰝘g installation scheme is used to determine

the paths inside the environment. When Python runs in a virtual environment, the same installation scheme is

the default. That means that downstream distributors can change the default syscon󰝘g install scheme without

changing behavior of virtual environments. Third party code that also creates new virtual environments should

do the same. (Contributed by Miro Hrončok in bpo-45413.)

7.34 warnings

• warnings.catch_warnings() now accepts arguments for warnings.simplefilter(), provid-

ing a more concise way to locally ignore warnings or convert them to errors. (Contributed by Zac Hat󰝘eld-

Dodds in bpo-47074.)

7.35 ziple

• Added support for specifying member name encoding for reading metadata in a ZipFile’s directory and 󰝘le

headers. (Contributed by Stephen J. Turnbull and Serhiy Storchaka in bpo-28080.)

• Added ZipFile.mkdir() for creating new directories inside ZIP archives. (Contributed by Sam Ezeh in

gh-49083.)

• Added stem, suffix and suffixes to zipfile.Path. (Contributed by Miguel Brito in gh-88261.)

8 Optimizations

This section covers speci󰝘c optimizations independent of the Faster CPython project, which is covered in its own

section.

• The compiler now optimizes simple printf-style % formatting on string literals containing only the format codes

%s, %r and %a and makes it as fast as a corresponding f-string expression. (Contributed by Serhiy Storchaka

in bpo-28307.)

• Integer division (//) is better tuned for optimization by compilers. It is now around 20% faster on x86-64

when dividing an int by a value smaller than 2**30. (Contributed by Gregory P. Smith and Tim Peters in

gh-90564.)

• sum() is now nearly 30% faster for integers smaller than 2**30. (Contributed by Stefan Behnel in gh-68264.)

• Resizing lists is streamlined for the common case, speeding up list.append() by ≈15% and simple list

comprehensions by up to 20-30% (Contributed by Dennis Sweeney in gh-91165.)

• Dictionaries don’t store hash values when all keys are Unicode objects, decreasing dict size. For exam-

ple, sys.getsizeof(dict.fromkeys("abcdefg")) is reduced from 352 bytes to 272 bytes (23%

smaller) on 64-bit platforms. (Contributed by Inada Naoki in bpo-46845.)

• Using asyncio.DatagramProtocol is now orders of magnitude faster when transferring large 󰝘les over

UDP, with speeds over 100 times higher for a ≈60 MiB 󰝘le. (Contributed by msoxzw in gh-91487.)

• math functions comb() and perm() are now ≈10 times faster for large arguments (with a larger speedup

for larger k). (Contributed by Serhiy Storchaka in bpo-37295.)

• The statistics functions mean(), variance() and stdev() now consume iterators in one pass

rather than converting them to a list 󰝘rst. This is twice as fast and can save substantial memory. (Contributed

by Raymond Hettinger in gh-90415.)

• unicodedata.normalize() now normalizes pure-ASCII strings in constant time. (Contributed by

Dong-hee Na in bpo-44987.)

9 Faster CPython

CPython 3.11 is on average 25% faster than CPython 3.10 when measured with the pyperformance benchmark suite,

and compiled with GCC on Ubuntu Linux. Depending on your workload, the speedup could be up to 10-60% faster.

This project focuses on two major areas in Python: faster startup and faster runtime. Other optimizations not under

this project are listed in Optimizations.

9.1 Faster Startup

Frozen imports / Static code objects

Python caches bytecode in the __pycache__ directory to speed up module loading.

Previously in 3.10, Python module execution looked like this:

Read __pycache__ -> Unmarshal -> Heap allocated code object -> Evaluate

In Python 3.11, the core modules essential for Python startup are ”frozen”. This means that their code objects (and

bytecode) are statically allocated by the interpreter. This reduces the steps in module execution process to this:

Statically allocated code object -> Evaluate

Interpreter startup is now 10-15% faster in Python 3.11. This has a big impact for short-running programs using

Python.

(Contributed by Eric Snow, Guido van Rossum and Kumar Aditya in numerous issues.)

9.2 Faster Runtime

Cheaper, lazy Python frames

Python frames are created whenever Python calls a Python function. This frame holds execution information. The

following are new frame optimizations:

• Streamlined the frame creation process.

• Avoided memory allocation by generously re-using frame space on the C stack.

• Streamlined the internal frame struct to contain only essential information. Frames previously held extra de-

bugging and memory management information.

Old-style frame objects are now created only when requested by debuggers or by Python introspection functions such

as sys._getframe or inspect.currentframe. For most user code, no frame objects are created at all. As

a result, nearly all Python functions calls have sped up signi󰝘cantly. We measured a 3-7% speedup in pyperformance.

(Contributed by Mark Shannon in bpo-44590.)

Inlined Python function calls

During a Python function call, Python will call an evaluating C function to interpret that function’s code. This e󰝗ec-

tively limits pure Python recursion to what’s safe for the C stack.

In 3.11, when CPython detects Python code calling another Python function, it sets up a new frame, and ”jumps” to

the new code inside the new frame. This avoids calling the C interpreting function altogether.

Most Python function calls now consume no C stack space. This speeds up most of such calls. In simple recursive

functions like 󰝘bonacci or factorial, a 1.7x speedup was observed. This also means recursive functions can recurse

signi󰝘cantly deeper (if the user increases the recursion limit). We measured a 1-3% improvement in pyperformance.

(Contributed by Pablo Galindo and Mark Shannon in bpo-45256.)

PEP 659: Specializing Adaptive Interpreter

PEP 659 is one of the key parts of the faster CPython project. The general idea is that while Python is a dynamic

language, most code has regions where objects and types rarely change. This concept is known as type stability.

At runtime, Python will try to look for common patterns and type stability in the executing code. Python will then

replace the current operation with a more specialized one. This specialized operation uses fast paths available only

to those use cases/types, which generally outperform their generic counterparts. This also brings in another concept

called inline caching, where Python caches the results of expensive operations directly in the bytecode.

The specializer will also combine certain common instruction pairs into one superinstruction. This reduces the over-

head during execution.

Python will only specialize when it sees code that is ”hot” (executed multiple times). This prevents Python from

wasting time for run-once code. Python can also de-specialize when code is too dynamic or when the use changes.

Specialization is attempted periodically, and specialization attempts are not too expensive. This allows specialization

to adapt to new circumstances.

(PEP written by Mark Shannon, with ideas inspired by Stefan Brunthaler. See PEP 659 for more information.

Implementation by Mark Shannon and Brandt Bucher, with additional help from Irit Katriel and Dennis Sweeney.)

剩余3542页未读，继续阅读

hyled

粉丝: 0
资源: 3

Python 3.11.0中文教程：新特性与改进

python基础教程 第三版 中文 高清 pdf

全网最全Python课程，从入门到精通！.pdf

python-3.11.1-docs-pdf-a4.zip

python-3.11.0-docs-pdf-a4.zip

python-3.11.0-docs-pdf-letter.zip

python-3.11.0 python-3.11.0 下载

Python-3.11.0.tgz

python-3.11.0a7.exe

python-3.11.0b2.exe

python-3.11.0.exe软件包

最新资源

python基础教程第三版中文高清 pdf