Python 3.7 (CloudMonk.io)

Python 3.7

Return to Python Versions, Python Version History, Python, Python DevOps

PEPs Implemented in Python 3.7

Python 3.7 introduced several key features and enhancements that improved the language's usability, performance, and robustness. These features were guided by various Python Enhancement Proposals (PEPs), ensuring the continued evolution of Python as a modern programming language. Below is a list of the significant PEPs implemented in Python 3.7, along with raw URLs for each proposal. Similar to how standards like RFC 7231 guide web protocols, these PEPs drive improvements and new functionality in the Python ecosystem.

PEP 563 introduces postponed evaluation of type annotations, meaning that type annotations are stored as strings and not evaluated until explicitly needed. This feature improves runtime performance and reduces circular import issues by postponing the evaluation of type annotations until runtime. This change makes Python's type system more efficient, especially in large codebases where type annotations are used extensively. More details can be found at https://peps.python.org/pep-0563/.

PEP 553 introduces the `breakpoint()` function, simplifying the process of setting breakpoints in code for debugging. This feature makes debugging easier by providing a built-in, standard way to invoke a debugger without needing to import `pdb` explicitly. The `breakpoint()` function improves developer productivity by streamlining the debugging process. Learn more at https://peps.python.org/pep-0553/.

PEP 552 adds deterministic bytecode generation for `.pyc` files, allowing for reproducible builds. This feature ensures that the `.pyc` files generated during the compilation of Python modules are consistent across different environments. Deterministic bytecode generation is important in scenarios where reproducibility is critical, such as in packaging and distribution of Python applications. More information can be found at https://peps.python.org/pep-0552/.

PEP 562 allows module-level `__getattr__()` and `__dir__()` to be defined, improving the flexibility of modules. This feature allows module authors to control the behavior of attribute access and introspection at the module level, similar to how classes can control attribute access. This change is especially useful for dynamically generated modules or modules that need to provide custom behavior for attribute lookup. See more at https://peps.python.org/pep-0562/.

PEP 564 introduces a new `time` function for nanosecond resolution, improving the precision of time measurements in Python. This feature is particularly useful in performance-critical applications where precise timing information is required. The new `time` functions, such as `time.time_ns()`, provide better granularity for measuring time in high-resolution scenarios. Learn more at https://peps.python.org/pep-0564/.

PEP 539 adds a new C-API for thread-local storage, providing a more robust and flexible way to manage thread-specific data in C extensions. This change improves the handling of thread-local data in Python, making it easier to write thread-safe C extensions. The new API provides better performance and safety when working with multithreaded applications. More information is available at https://peps.python.org/pep-0539/.

PEP 565 modifies how `DeprecationWarning` is handled, making it more visible by default. This change ensures that developers are more likely to see deprecation warnings during development, improving code maintenance and encouraging the timely removal of deprecated features. This behavior change helps developers stay up-to-date with language changes and avoid relying on outdated features. More details are available at https://peps.python.org/pep-0565/.

PEP 545 introduces a global configuration option for running code in locales other than Python's default ASCII locale. This feature allows Python applications to run in locales with different character encodings, improving support for internationalization. It makes Python more flexible and better suited for applications that need to handle non-ASCII text, especially in globalized environments. Learn more at https://peps.python.org/pep-0545/.

PEP 536 introduces a clearer specification for `async` and `await` in the language. This feature formalizes the behavior of these keywords in Python, ensuring that their usage is well-defined and consistent across different versions. The `async` and `await` syntax, introduced in earlier versions, is central to writing asynchronous code in Python, and this update clarifies their behavior in the language specification. See more at https://peps.python.org/pep-0536/.

PEP 560 improves the performance of `__class_getitem__()` in generic classes, making it easier and faster to use generic types in Python's type hinting system. This change enhances the performance of code that makes heavy use of generics, such as libraries for data processing and machine learning. The improvements to `__class_getitem__()` make type hinting more efficient and scalable. More details are available at https://peps.python.org/pep-0560/.

Conclusion