Contenu de la documentation Python
**********************************

* Nouveautés de Python

  * What's New In Python 3.6

    * Summary -- Release highlights

    * Nouvelles fonctionnalités

      * PEP 498: Formatted string literals

      * PEP 526: Syntax for variable annotations

      * PEP 515: Underscores in Numeric Literals

      * PEP 525: Asynchronous Generators

      * PEP 530: Asynchronous Comprehensions

      * PEP 487: Simpler customization of class creation

      * PEP 487: Descriptor Protocol Enhancements

      * PEP 519: Adding a file system path protocol

      * PEP 495: Local Time Disambiguation

      * PEP 529: Change Windows filesystem encoding to UTF-8

      * PEP 528: Change Windows console encoding to UTF-8

      * PEP 520: Preserving Class Attribute Definition Order

      * PEP 468: Preserving Keyword Argument Order

      * New *dict* implementation

      * PEP 523: Adding a frame evaluation API to CPython

      * PYTHONMALLOC environment variable

      * DTrace and SystemTap probing support

    * Other Language Changes

    * New Modules

      * secrets

    * Improved Modules

      * *array*

      * ast

      * asyncio

      * binascii

      * cmath

      * collections

      * concurrent.futures

      * contextlib

      * datetime

      * decimal

      * distutils

      * email

      * encodings

      * enum

      * faulthandler

      * fileinput

      * hashlib

      * http.client

      * idlelib and IDLE

      * importlib

      * inspect

      * json

      * logging

      * math

      * multiprocessing

      * os

      * pathlib

      * pdb

      * pickle

      * pickletools

      * pydoc

      * random

      * re

      * readline

      * rlcompleter

      * shlex

      * site

      * sqlite3

      * socket

      * socketserver

      * ssl

      * statistics

      * struct

      * subprocess

      * sys

      * telnetlib

      * time

      * timeit

      * tkinter

      * traceback

      * tracemalloc

      * typing

      * unicodedata

      * unittest.mock

      * urllib.request

      * urllib.robotparser

      * venv

      * warnings

      * winreg

      * winsound

      * xmlrpc.client

      * zipfile

      * zlib

    * Optimizations

    * Build and C API Changes

    * Autres Améliorations

    * Deprecated

      * Nouveaux mot-clefs

      * Deprecated Python behavior

      * Deprecated Python modules, functions and methods

        * asynchat

        * asyncore

        * dbm

        * distutils

        * grp

        * importlib

        * os

        * re

        * ssl

        * tkinter

        * venv

      * xml

      * Deprecated functions and types of the C API

      * Deprecated Build Options

    * Removed

      * API and Feature Removals

    * Porting to Python 3.6

      * Changes in 'python' Command Behavior

      * Changes in the Python API

      * Changes in the C API

      * CPython bytecode changes

    * Notable changes in Python 3.6.2

      * New "make regen-all" build target

      * Removal of "make touch" build target

    * Notable changes in Python 3.6.4

    * Notable changes in Python 3.6.5

    * Notable changes in Python 3.6.7

    * Notable changes in Python 3.6.10

  * Nouveautés de Python 3.5

    * Summary -- Release highlights

    * Nouvelles fonctionnalités

      * PEP 492 - Coroutines with async and await syntax

      * PEP 465 - A dedicated infix operator for matrix multiplication

      * PEP 448 - Additional Unpacking Generalizations

      * PEP 461 - percent formatting support for bytes and bytearray

      * PEP 484 - Type Hints

      * PEP 471 - os.scandir() function -- a better and faster
        directory iterator

      * PEP 475: Retry system calls failing with EINTR

      * PEP 479: Change StopIteration handling inside generators

      * PEP 485: A function for testing approximate equality

      * PEP 486: Make the Python Launcher aware of virtual
        environments

      * PEP 488 : Élimination des fichiers PYO

      * PEP 489: Multi-phase extension module initialization

    * Other Language Changes

    * New Modules

      * typing

      * zipapp

    * Improved Modules

      * argparse

      * asyncio

      * bz2

      * cgi

      * cmath

      * code

      * collections

      * collections.abc

      * compileall

      * concurrent.futures

      * configparser

      * contextlib

      * csv

      * curses

      * dbm

      * difflib

      * distutils

      * doctest

      * email

      * enum

      * faulthandler

      * functools

      * glob

      * gzip

      * heapq

      * http

      * http.client

      * idlelib and IDLE

      * imaplib

      * imghdr

      * importlib

      * inspect

      * io

      * ipaddress

      * json

      * linecache

      * locale

      * logging

      * lzma

      * math

      * multiprocessing

      * operator

      * os

      * pathlib

      * pickle

      * poplib

      * re

      * readline

      * selectors

      * shutil

      * signal

      * smtpd

      * smtplib

      * sndhdr

      * socket

      * ssl

        * Memory BIO Support

        * Application-Layer Protocol Negotiation Support

        * Other Changes

      * sqlite3

      * subprocess

      * sys

      * sysconfig

      * tarfile

      * threading

      * time

      * timeit

      * tkinter

      * traceback

      * types

      * unicodedata

      * unittest

      * unittest.mock

      * urllib

      * wsgiref

      * xmlrpc

      * xml.sax

      * zipfile

    * Other module-level changes

    * Optimizations

    * Build and C API Changes

    * Deprecated

      * Nouveaux mot-clefs

      * Deprecated Python Behavior

      * Unsupported Operating Systems

      * Deprecated Python modules, functions and methods

    * Removed

      * API and Feature Removals

    * Portage vers Python 3.5

      * Changes in Python behavior

      * Changes in the Python API

      * Changes in the C API

    * Notable changes in Python 3.5.4

      * New "make regen-all" build target

      * Removal of "make touch" build target

  * Nouveautés de Python 3.4

    * Summary -- Release Highlights

    * Nouvelles fonctionnalités

      * PEP 453: Explicit Bootstrapping of PIP in Python Installations

        * Bootstrapping pip By Default

        * Documentation Changes

      * PEP 446: Newly Created File Descriptors Are Non-Inheritable

      * Improvements to Codec Handling

      * PEP 451: A ModuleSpec Type for the Import System

      * Other Language Changes

    * New Modules

      * asyncio

      * ensurepip

      * enum

      * pathlib

      * selectors

      * statistics

      * tracemalloc

    * Improved Modules

      * abc

      * aifc

      * argparse

      * audioop

      * base64

      * collections

      * colorsys

      * contextlib

      * dbm

      * dis

      * doctest

      * email

      * filecmp

      * functools

      * gc

      * glob

      * hashlib

      * hmac

      * html

      * http

      * idlelib and IDLE

      * importlib

      * inspect

      * ipaddress

      * logging

      * marshal

      * mmap

      * multiprocessing

      * operator

      * os

      * pdb

      * pickle

      * plistlib

      * poplib

      * pprint

      * pty

      * pydoc

      * re

      * resource

      * select

      * shelve

      * shutil

      * smtpd

      * smtplib

      * socket

      * sqlite3

      * ssl

      * stat

      * struct

      * subprocess

      * sunau

      * sys

      * tarfile

      * textwrap

      * threading

      * traceback

      * types

      * urllib

      * unittest

      * venv

      * wave

      * weakref

      * xml.etree

      * zipfile

    * CPython Implementation Changes

      * PEP 445: Customization of CPython Memory Allocators

      * PEP 442: Safe Object Finalization

      * PEP 456: Secure and Interchangeable Hash Algorithm

      * PEP 436: Argument Clinic

      * Other Build and C API Changes

      * Autres Améliorations

      * Significant Optimizations

    * Deprecated

      * Deprecations in the Python API

      * Fonctionnalités obsolètes

    * Removed

      * Operating Systems No Longer Supported

      * API and Feature Removals

      * Code Cleanups

    * Portage vers Python 3.4

      * Changes in 'python' Command Behavior

      * Changes in the Python API

      * Changes in the C API

    * Changed in 3.4.3

      * PEP 476: Enabling certificate verification by default for
        stdlib http clients

  * Nouveautés de Python 3.3

    * Summary -- Release highlights

    * PEP 405: Virtual Environments

    * PEP 420: Implicit Namespace Packages

    * PEP 3118: New memoryview implementation and buffer protocol
      documentation

      * Features

      * API changes

    * PEP 393: Flexible String Representation

      * Functionality

      * Performance and resource usage

    * PEP 397: Python Launcher for Windows

    * PEP 3151: Reworking the OS and IO exception hierarchy

    * PEP 380: Syntax for Delegating to a Subgenerator

    * PEP 409: Suppressing exception context

    * PEP 414: Explicit Unicode literals

    * PEP 3155: Qualified name for classes and functions

    * PEP 412: Key-Sharing Dictionary

    * PEP 362: Function Signature Object

    * PEP 421: Adding sys.implementation

      * SimpleNamespace

    * Using importlib as the Implementation of Import

      * New APIs

      * Visible Changes

    * Other Language Changes

    * A Finer-Grained Import Lock

    * Builtin functions and types

    * New Modules

      * faulthandler

      * ipaddress

      * lzma

    * Improved Modules

      * abc

      * *array*

      * base64

      * binascii

      * bz2

      * codecs

      * collections

      * contextlib

      * crypt

      * curses

      * datetime

      * decimal

        * Features

        * API changes

      * email

        * Policy Framework

        * Provisional Policy with New Header API

        * Other API Changes

      * ftplib

      * functools

      * gc

      * hmac

      * http

      * html

      * imaplib

      * inspect

      * io

      * itertools

      * logging

      * math

      * mmap

      * multiprocessing

      * nntplib

      * os

      * pdb

      * pickle

      * pydoc

      * re

      * sched

      * select

      * shlex

      * shutil

      * signal

      * smtpd

      * smtplib

      * socket

      * socketserver

      * sqlite3

      * ssl

      * stat

      * struct

      * subprocess

      * sys

      * tarfile

      * tempfile

      * textwrap

      * threading

      * time

      * types

      * unittest

      * urllib

      * webbrowser

      * xml.etree.ElementTree

      * zlib

    * Optimizations

    * Build and C API Changes

    * Deprecated

      * Unsupported Operating Systems

      * Deprecated Python modules, functions and methods

      * Deprecated functions and types of the C API

      * Fonctionnalités obsolètes

    * Portage vers Python 3.3

      * Portage de code Python

      * Porting C code

      * Building C extensions

      * Command Line Switch Changes

  * Nouveautés de Python 3.2

    * PEP 384: Defining a Stable ABI

    * PEP 389: Argparse Command Line Parsing Module

    * PEP 391:  Dictionary Based Configuration for Logging

    * PEP 3148:  The "concurrent.futures" module

    * PEP 3147:  PYC Repository Directories

    * PEP 3149: ABI Version Tagged .so Files

    * PEP 3333: Python Web Server Gateway Interface v1.0.1

    * Other Language Changes

    * New, Improved, and Deprecated Modules

      * email

      * elementtree

      * functools

      * itertools

      * collections

      * threading

      * datetime and time

      * math

      * abc

      * io

      * reprlib

      * logging

      * csv

      * contextlib

      * decimal and fractions

      * ftp

      * popen

      * select

      * gzip and zipfile

      * tarfile

      * hashlib

      * ast

      * os

      * shutil

      * sqlite3

      * html

      * socket

      * ssl

      * nntp

      * certificates

      * imaplib

      * http.client

      * unittest

      * random

      * poplib

      * asyncore

      * tempfile

      * inspect

      * pydoc

      * dis

      * dbm

      * ctypes

      * site

      * sysconfig

      * pdb

      * configparser

      * urllib.parse

      * mailbox

      * turtledemo

    * Fils d'exécution

    * Optimizations

    * Unicode

    * Codecs

    * Documentation

    * IDLE

    * Code Repository

    * Build and C API Changes

    * Portage vers Python 3.2

  * Nouveautés de Python 3.1

    * PEP 372: Ordered Dictionaries

    * PEP 378: Format Specifier for Thousands Separator

    * Other Language Changes

    * New, Improved, and Deprecated Modules

    * Optimizations

    * IDLE

    * Build and C API Changes

    * Portage vers Python 3.1

  * Nouveautés de Python 3.0

    * Common Stumbling Blocks

      * Print Is A Function

      * Views And Iterators Instead Of Lists

      * Ordering Comparisons

      * Integers

      * Text Vs. Data Instead Of Unicode Vs. 8-bit

    * Overview Of Syntax Changes

      * New Syntax

      * Changed Syntax

      * Removed Syntax

    * Changes Already Present In Python 2.6

    * Library Changes

    * **PEP 3101**: A New Approach To String Formatting

    * Changes To Exceptions

    * Miscellaneous Other Changes

      * Operators And Special Methods

      * Builtins

    * Build and C API Changes

    * Performances

    * Portage vers Python 3.0

  * Nouveautés de Python 2.7

    * The Future for Python 2.x

    * Changes to the Handling of Deprecation Warnings

    * Python 3.1 Features

    * PEP 372: Adding an Ordered Dictionary to collections

    * PEP 378: Format Specifier for Thousands Separator

    * PEP 389: The argparse Module for Parsing Command Lines

    * PEP 391: Dictionary-Based Configuration For Logging

    * PEP 3106: Dictionary Views

    * PEP 3137: The memoryview Object

    * Other Language Changes

      * Interpreter Changes

      * Optimizations

    * New and Improved Modules

      * New module: importlib

      * New module: sysconfig

      * ttk: Themed Widgets for Tk

      * Updated module: unittest

      * Module mis-à-jour : ElementTree 1.3

    * Build and C API Changes

      * Capsules

      * Port-Specific Changes: Windows

      * Port-Specific Changes: Mac OS X

      * Port-Specific Changes: FreeBSD

    * Autres changements et corrections

    * Portage vers Python 2.7

    * New Features Added to Python 2.7 Maintenance Releases

      * Two new environment variables for debug mode

      * PEP 434: IDLE Enhancement Exception for All Branches

      * PEP 466: Network Security Enhancements for Python 2.7

      * PEP 477: Backport ensurepip (PEP 453) to Python 2.7

        * Bootstrapping pip By Default

        * Documentation Changes

      * PEP 476: Enabling certificate verification by default for
        stdlib http clients

      * PEP 493: HTTPS verification migration tools for Python 2.7

      * New "make regen-all" build target

      * Removal of "make touch" build target

    * Remerciements

  * Nouveautés de Python 2.6

    * Python 3.0

    * Changes to the Development Process

      * New Issue Tracker: Roundup

      * New Documentation Format: reStructuredText Using Sphinx

    * PEP 343: The 'with' statement

      * Écrire des gestionnaires de contexte

      * Le module *contextlib*

    * PEP 366: Explicit Relative Imports From a Main Module

    * PEP 370: Per-user "site-packages" Directory

    * PEP 371: The "multiprocessing" Package

    * PEP 3101: Advanced String Formatting

    * PEP 3105: "print" As a Function

    * PEP 3110: Exception-Handling Changes

    * PEP 3112: Byte Literals

    * PEP 3116: New I/O Library

    * PEP 3118: Revised Buffer Protocol

    * PEP 3119: Abstract Base Classes

    * PEP 3127: Integer Literal Support and Syntax

    * PEP 3129: Class Decorators

    * PEP 3141: A Type Hierarchy for Numbers

      * The "fractions" Module

    * Other Language Changes

      * Optimizations

      * Interpreter Changes

    * New and Improved Modules

      * The "ast" module

      * The "future_builtins" module

      * The "json" module: JavaScript Object Notation

      * The "plistlib" module: A Property-List Parser

      * ctypes Enhancements

      * Improved SSL Support

    * Deprecations and Removals

    * Build and C API Changes

      * Port-Specific Changes: Windows

      * Port-Specific Changes: Mac OS X

      * Port-Specific Changes: IRIX

    * Portage vers Python 2.6

    * Remerciements

  * Nouveautés de Python 2.5

    * PEP 308 : Expressions conditionnelles

    * PEP 309 : Application partielle de fonction

    * PEP 314: Metadata for Python Software Packages v1.1

    * PEP 328: Absolute and Relative Imports

    * PEP 338: Executing Modules as Scripts

    * PEP 341: Unified try/except/finally

    * PEP 342: New Generator Features

    * PEP 343: The 'with' statement

      * Écrire des gestionnaires de contexte

      * Le module *contextlib*

    * PEP 352: Exceptions as New-Style Classes

    * PEP 353: Using ssize_t as the index type

    * PEP 357: The '__index__' method

    * Other Language Changes

      * Changements de l’interpréteur interactif

      * Optimizations

    * Modules ajoutés, modifiés, et supprimés

      * The ctypes package

      * The ElementTree package

      * The hashlib package

      * The sqlite3 package

      * The wsgiref package

    * Build and C API Changes

      * Port-Specific Changes

    * Portage vers Python 2.5

    * Remerciements

  * Nouveautés de Python 2.4

    * PEP 218: Built-In Set Objects

    * PEP 237: Unifying Long Integers and Integers

    * PEP 289: Generator Expressions

    * PEP 292: Simpler String Substitutions

    * PEP 318: Decorators for Functions and Methods

    * PEP 322: Reverse Iteration

    * PEP 324: New subprocess Module

    * PEP 327: Decimal Data Type

      * Why is Decimal needed?

      * The "Decimal" type

      * The "Context" type

    * PEP 328: Multi-line Imports

    * PEP 331: Locale-Independent Float/String Conversions

    * Other Language Changes

      * Optimizations

    * New, Improved, and Deprecated Modules

      * cookielib

      * doctest

    * Build and C API Changes

      * Port-Specific Changes

    * Portage vers Python 2.4

    * Remerciements

  * Nouveautés de Python 2.3

    * PEP 218: A Standard Set Datatype

    * PEP 255 : Générateurs simples

    * PEP 263: Source Code Encodings

    * PEP 273: Importing Modules from ZIP Archives

    * PEP 277: Unicode file name support for Windows NT

    * PEP 278: Universal Newline Support

    * PEP 279: enumerate()

    * PEP 282: The logging Package

    * PEP 285 : Un type booléen

    * PEP 293: Codec Error Handling Callbacks

    * PEP 301: Package Index and Metadata for Distutils

    * PEP 302: New Import Hooks

    * PEP 305: Comma-separated Files

    * PEP 307: Pickle Enhancements

    * Extended Slices

    * Other Language Changes

      * String Changes

      * Optimizations

    * New, Improved, and Deprecated Modules

      * Date/Time Type

      * The optparse Module

    * Pymalloc: A Specialized Object Allocator

    * Build and C API Changes

      * Port-Specific Changes

    * Autres changements et corrections

    * Portage vers Python 2.3

    * Remerciements

  * Nouveautés de Python 2.2

    * Introduction

    * PEP 252 et 253 : Changements concernant les types et classes

      * Anciennes et nouvelles classes

      * Descripteurs

      * Héritage multiple : la règle du diamant

      * Attribute Access

      * Related Links

    * PEP 234 : Itérateurs

    * PEP 255 : Générateurs simples

    * PEP 237: Unifying Long Integers and Integers

    * PEP 238: Changing the Division Operator

    * Unicode Changes

    * PEP 227: Nested Scopes

    * New and Improved Modules

    * Interpreter Changes and Fixes

    * Autres changements et corrections

    * Remerciements

  * Nouveautés de Python 2.1

    * Introduction

    * PEP 227: Nested Scopes

    * PEP 236 : Directives __future__

    * PEP 207: Rich Comparisons

    * PEP 230: Warning Framework

    * PEP 229: New Build System

    * PEP 205: Weak References

    * PEP 232 : Attributs de fonctions

    * PEP 235: Importing Modules on Case-Insensitive Platforms

    * PEP 217: Interactive Display Hook

    * PEP 208: New Coercion Model

    * PEP 241: Metadata in Python Packages

    * New and Improved Modules

    * Autres changements et corrections

    * Remerciements

  * Nouveautés de Python 2.0

    * Introduction

    * À propos de Python 1.6

    * Nouveau processus de développement

    * Unicode

    * Compréhensions de listes

    * Augmented Assignment

    * Méthodes de chaînes de caractères

    * Garbage Collection of Cycles

    * Other Core Changes

      * Changements mineurs du langage

      * Changements concernant les fonctions primitives

    * Porting to 2.0

    * Extending/Embedding Changes

    * Distutils: Making Modules Easy to Install

    * Modules XML

      * Support de SAX2

      * Support du DOM

      * Relationship to PyXML

    * Module changes

    * Nouveaux modules

    * IDLE Improvements

    * Deleted and Deprecated Modules

    * Remerciements

  * Changements

    * Python 3.6.11 final

    * Python 3.6.11 release candidate 1

      * Security

      * Core and Builtins

      * Library

    * Python 3.6.10 final

      * macOS

    * Python 3.6.10 release candidate 1

      * Security

      * Library

    * Python 3.6.9 final

      * Library

      * macOS

    * Python 3.6.9 release candidate 1

      * Security

      * Library

      * Documentation

      * Tests

      * macOS

    * Python 3.6.8 final

      * Library

      * Build

      * C API

    * Python 3.6.8 release candidate 1

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

    * Python 3.6.7 final

    * Python 3.6.7 release candidate 2

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * macOS

      * C API

    * Python 3.6.7 release candidate 1

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.6.6 final

    * Python 3.6.6 release candidate 1

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.6.5 final

      * Tests

      * Build

    * Python 3.6.5 release candidate 1

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.6.4 final

    * Python 3.6.4 release candidate 1

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.6.3 final

      * Library

      * Build

    * Python 3.6.3 release candidate 1

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * IDLE

      * Tools/Demos

    * Python 3.6.2 final

    * Python 3.6.2 release candidate 2

      * Security

    * Python 3.6.2 release candidate 1

      * Core and Builtins

      * Library

      * Security

      * Library

      * IDLE

      * C API

      * Build

      * Documentation

      * Tools/Demos

      * Tests

      * Windows

    * Python 3.6.1 final

      * Core and Builtins

      * Build

    * Python 3.6.1 release candidate 1

      * Core and Builtins

      * Library

      * IDLE

      * Windows

      * C API

      * Documentation

      * Tests

      * Build

    * Python 3.6.0 final

    * Python 3.6.0 release candidate 2

      * Core and Builtins

      * Tools/Demos

      * Windows

      * Build

    * Python 3.6.0 release candidate 1

      * Core and Builtins

      * Library

      * C API

      * Documentation

      * Tools/Demos

    * Python 3.6.0 beta 4

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

    * Python 3.6.0 beta 3

      * Core and Builtins

      * Library

      * Windows

      * Build

      * Tests

    * Python 3.6.0 beta 2

      * Core and Builtins

      * Library

      * Windows

      * C API

      * Build

      * Tests

    * Python 3.6.0 beta 1

      * Core and Builtins

      * Library

      * IDLE

      * C API

      * Tests

      * Build

      * Tools/Demos

      * Windows

    * Python 3.6.0 alpha 4

      * Core and Builtins

      * Library

      * IDLE

      * Tests

      * Windows

      * Build

    * Python 3.6.0 alpha 3

      * Core and Builtins

      * Library

      * Security

      * Library

      * Security

      * Library

      * IDLE

      * C API

      * Build

      * Tools/Demos

      * Documentation

      * Tests

    * Python 3.6.0 alpha 2

      * Core and Builtins

      * Library

      * Security

      * Library

      * Security

      * Library

      * IDLE

      * Documentation

      * Tests

      * Windows

      * Build

      * Windows

      * C API

      * Tools/Demos

    * Python 3.6.0 alpha 1

      * Core and Builtins

      * Library

      * Security

      * Library

      * Security

      * Library

      * Security

      * Library

      * IDLE

      * Documentation

      * Tests

      * Build

      * Windows

      * Tools/Demos

      * C API

    * Python 3.5.3 final

    * Python 3.5.3 release candidate 1

      * Core and Builtins

      * Library

      * Security

      * Library

      * Security

      * Library

      * IDLE

      * C API

      * Documentation

      * Tests

      * Tools/Demos

      * Windows

      * Build

    * Python 3.5.2 final

      * Core and Builtins

      * Tests

      * IDLE

    * Python 3.5.2 release candidate 1

      * Core and Builtins

      * Security

      * Library

      * Security

      * Library

      * Security

      * Library

      * Security

      * Library

      * Security

      * Library

      * IDLE

      * Documentation

      * Tests

      * Build

      * Windows

      * Tools/Demos

      * Windows

    * Python 3.5.1 final

      * Core and Builtins

      * Windows

    * Python 3.5.1 release candidate 1

      * Core and Builtins

      * Library

      * IDLE

      * Documentation

      * Tests

      * Build

      * Windows

      * Tools/Demos

    * Python 3.5.0 final

      * Build

    * Python 3.5.0 release candidate 4

      * Library

      * Build

    * Python 3.5.0 release candidate 3

      * Core and Builtins

      * Library

    * Python 3.5.0 release candidate 2

      * Core and Builtins

      * Library

    * Python 3.5.0 release candidate 1

      * Core and Builtins

      * Library

      * IDLE

      * Documentation

      * Tests

    * Python 3.5.0 beta 4

      * Core and Builtins

      * Library

      * Build

    * Python 3.5.0 beta 3

      * Core and Builtins

      * Library

      * Tests

      * Documentation

      * Build

    * Python 3.5.0 beta 2

      * Core and Builtins

      * Library

    * Python 3.5.0 beta 1

      * Core and Builtins

      * Library

      * IDLE

      * Tests

      * Documentation

      * Tools/Demos

    * Python 3.5.0 alpha 4

      * Core and Builtins

      * Library

      * Build

      * Tests

      * Tools/Demos

      * C API

    * Python 3.5.0 alpha 3

      * Core and Builtins

      * Library

      * Build

      * Tests

      * Tools/Demos

    * Python 3.5.0 alpha 2

      * Core and Builtins

      * Library

      * Build

      * C API

      * Windows

    * Python 3.5.0 alpha 1

      * Core and Builtins

      * Library

      * IDLE

      * Build

      * C API

      * Documentation

      * Tests

      * Tools/Demos

      * Windows

* Le tutoriel Python

  * 1. Mise en bouche

  * 2. Mode d'emploi de l'interpréteur Python

    * 2.1. Lancement de l'interpréteur

      * 2.1.1. Passage d'arguments

      * 2.1.2. Mode interactif

    * 2.2. L'interpréteur et son environnement

      * 2.2.1. Encodage du code source

  * 3. Introduction informelle à Python

    * 3.1. Utilisation de Python comme une calculatrice

      * 3.1.1. Les nombres

      * 3.1.2. Chaînes de caractères

      * 3.1.3. Listes

    * 3.2. Premiers pas vers la programmation

  * 4. D'autres outils de contrôle de flux

    * 4.1. L'instruction "if"

    * 4.2. L'instruction "for"

    * 4.3. La fonction "range()"

    * 4.4. Les instructions "break", "continue" et les clauses "else"
      au sein des boucles

    * 4.5. L'instruction "pass"

    * 4.6. Définir des fonctions

    * 4.7. D'avantage sur la définition des fonctions

      * 4.7.1. Valeur par défaut des arguments

      * 4.7.2. Les arguments nommés

      * 4.7.3. Listes d'arguments arbitraires

      * 4.7.4. Séparation des listes d'arguments

      * 4.7.5. Fonctions anonymes

      * 4.7.6. Chaînes de documentation

      * 4.7.7. Annotations de fonctions

    * 4.8. Aparté : le style de codage

  * 5. Structures de données

    * 5.1. Compléments sur les listes

      * 5.1.1. Utilisation des listes comme des piles

      * 5.1.2. Utilisation des listes comme des files

      * 5.1.3. Compréhensions de listes

      * 5.1.4. Compréhensions de listes imbriquées

    * 5.2. L'instruction "del"

    * 5.3. Tuples et séquences

    * 5.4. Ensembles

    * 5.5. Dictionnaires

    * 5.6. Techniques de boucles

    * 5.7. Plus d'informations sur les conditions

    * 5.8. Comparer des séquences avec d'autres types

  * 6. Modules

    * 6.1. Les modules en détail

      * 6.1.1. Exécuter des modules comme des scripts

      * 6.1.2. Les dossiers de recherche de modules

      * 6.1.3. Fichiers Python "compilés"

    * 6.2. Modules standards

    * 6.3. La fonction "dir()"

    * 6.4. Les paquets

      * 6.4.1. Importer * depuis un paquet

      * 6.4.2. Références internes dans un paquet

      * 6.4.3. Paquets dans plusieurs dossiers

  * 7. Les entrées/sorties

    * 7.1. Formatage de données

      * 7.1.1. Anciennes méthodes de formatage de chaînes

    * 7.2. Lecture et écriture de fichiers

      * 7.2.1. Méthodes des objets fichiers

      * 7.2.2. Sauvegarde de données structurées avec le module "json"

  * 8. Erreurs et exceptions

    * 8.1. Les erreurs de syntaxe

    * 8.2. Exceptions

    * 8.3. Gestion des exceptions

    * 8.4. Déclencher des exceptions

    * 8.5. Exceptions définies par l'utilisateur

    * 8.6. Définition d'actions de nettoyage

    * 8.7. Actions de nettoyage prédéfinies

  * 9. Classes

    * 9.1. Objets et noms : préambule

    * 9.2. Portées et espaces de nommage en Python

      * 9.2.1. Exemple de portées et d'espaces de nommage

    * 9.3. Une première approche des classes

      * 9.3.1. Syntaxe de définition des classes

      * 9.3.2. Objets classes

      * 9.3.3. Objets instances

      * 9.3.4. Objets méthode

      * 9.3.5. Classes et variables d'instance

    * 9.4. Remarques diverses

    * 9.5. Héritage

      * 9.5.1. Héritage multiple

    * 9.6. Variables privées

    * 9.7. Trucs et astuces

    * 9.8. Itérateurs

    * 9.9. Générateurs

    * 9.10. Expressions et générateurs

  * 10. Survol de la bibliothèque standard

    * 10.1. Interface avec le système d'exploitation

    * 10.2. Jokers sur les noms de fichiers

    * 10.3. Paramètres passés en ligne de commande

    * 10.4. Redirection de la sortie d'erreur et fin d'exécution

    * 10.5. Recherche de motifs dans les chaînes

    * 10.6. Mathématiques

    * 10.7. Accès à internet

    * 10.8. Dates et heures

    * 10.9. Compression de données

    * 10.10. Mesure des performances

    * 10.11. Contrôle qualité

    * 10.12. Piles fournies

  * 11. Survol de la bibliothèque standard -- Deuxième partie

    * 11.1. Formatage de l'affichage

    * 11.2. Gabarits (*templates* en anglais)

    * 11.3. Traitement des données binaires

    * 11.4. Fils d'exécution

    * 11.5. Journalisation

    * 11.6. Références faibles

    * 11.7. Outils pour les listes

    * 11.8. Arithmétique décimale à virgule flottante

  * 12. Environnements virtuels et paquets

    * 12.1. Introduction

    * 12.2. Création d'environnements virtuels

    * 12.3. Gestion des paquets avec *pip*

  * 13. Pour aller plus loin

  * 14. Édition interactive des entrées et substitution d'historique

    * 14.1. Complétion automatique et édition de l'historique

    * 14.2. Alternatives à l'interpréteur interactif

  * 15. Arithmétique en nombres à virgule flottante : problèmes et
    limites

    * 15.1. Erreurs de représentation

  * 16. Annexe

    * 16.1. Mode interactif

      * 16.1.1. Gestion des erreurs

      * 16.1.2. Scripts Python exécutables

      * 16.1.3. Configuration du mode interactif

      * 16.1.4. Modules de personnalisation

* Installation et utilisation de Python

  * 1. Ligne de commande et environnement

    * 1.1. Ligne de commande

      * 1.1.1. Options de l'interface

      * 1.1.2. Options génériques

      * 1.1.3. Options diverses

      * 1.1.4. Options à ne pas utiliser

    * 1.2. Variables d'environnement

      * 1.2.1. Variables en mode débogage

  * 2. Utilisation de Python sur les plateformes Unix

    * 2.1. Récupérer et installer la dernière version de Python

      * 2.1.1. Sur Linux

      * 2.1.2. Sur FreeBSD et OpenBSD

      * 2.1.3. Sur OpenSolaris

    * 2.2. Compiler Python

    * 2.3. Fichiers et chemins liés à Python

    * 2.4. Divers

    * 2.5. Éditeurs et IDEs

  * 3. Utilisation de Python sur Windows

    * 3.1. Installer Python

      * 3.1.1. Versions supportées

      * 3.1.2. Étapes d'installation

      * 3.1.3. Suppression de la limitation *MAX_PATH*

      * 3.1.4. Installation sans l'interface utilisateur

      * 3.1.5. Installation sans téléchargement

      * 3.1.6. Modification d'une installation

      * 3.1.7. Autres plateformes

    * 3.2. Paquets alternatifs

    * 3.3. Configurer Python

      * 3.3.1. Digression : Définition des variables d'environnement

      * 3.3.2. Trouver l'exécutable Python

    * 3.4. Lanceur Python pour Windows

      * 3.4.1. Pour commencer

        * 3.4.1.1. Depuis la ligne de commande

        * 3.4.1.2. Environnements virtuels

        * 3.4.1.3. À partir d'un script

        * 3.4.1.4. À partir d'associations de fichiers

      * 3.4.2. Lignes Shebang

      * 3.4.3. Arguments dans les lignes *shebang*

      * 3.4.4. Personnalisation

        * 3.4.4.1. Personnalisation via des fichiers INI

        * 3.4.4.2. Personnalisation des versions Python par défaut

      * 3.4.5. Diagnostics

    * 3.5. Recherche de modules

    * 3.6. Modules supplémentaires

      * 3.6.1. PyWin32

      * 3.6.2. cx_Freeze

      * 3.6.3. WConio

    * 3.7. Compiler Python sous Windows

    * 3.8. Embedded Distribution

      * 3.8.1. Application Python

      * 3.8.2. Embarquer Python

    * 3.9. Autres ressources

  * 4. Utilisation de Python sur un Macintosh

    * 4.1. Obtenir et installer MacPython

      * 4.1.1. Comment exécuter un script Python

      * 4.1.2. Lancer des scripts avec une interface graphique

      * 4.1.3. Configuration

    * 4.2. L'*IDE*

    * 4.3. Installation de paquets Python additionnels

    * 4.4. Programmation d'interface graphique sur le Mac

    * 4.5. Distribuer des Applications Python sur le Mac

    * 4.6. Autres ressources

* La référence du langage Python

  * 1. Introduction

    * 1.1. Autres implémentations

    * 1.2. Notations

  * 2. Analyse lexicale

    * 2.1. Structure des lignes

      * 2.1.1. Lignes logiques

      * 2.1.2. Lignes physiques

      * 2.1.3. Commentaires

      * 2.1.4. Déclaration d'encodage

      * 2.1.5. Continuation de ligne explicite

      * 2.1.6. Continuation de ligne implicite

      * 2.1.7. Lignes vierges

      * 2.1.8. Indentation

      * 2.1.9. Espaces entre lexèmes

    * 2.2. Autres lexèmes

    * 2.3. Identifiants et mots-clés

      * 2.3.1. Mots-clés

      * 2.3.2. Classes réservées pour les identifiants

    * 2.4. Littéraux

      * 2.4.1. Littéraux de chaînes de caractères et de suites
        d'octets

      * 2.4.2. Concaténation de chaînes de caractères

      * 2.4.3. Chaînes de caractères formatées littérales

      * 2.4.4. Littéraux numériques

      * 2.4.5. Entiers littéraux

      * 2.4.6. Nombres à virgule flottante littéraux

      * 2.4.7. Imaginaires littéraux

    * 2.5. Opérateurs

    * 2.6. Délimiteurs

  * 3. Modèle de données

    * 3.1. Objets, valeurs et types

    * 3.2. Hiérarchie des types standards

    * 3.3. Méthodes spéciales

      * 3.3.1. Personnalisation de base

      * 3.3.2. Personnalisation de l'accès aux attributs

        * 3.3.2.1. Personnalisation de l'accès aux attributs d'un
          module

        * 3.3.2.2. Implémentation de descripteurs

        * 3.3.2.3. Invocation des descripteurs

        * 3.3.2.4. "__slots__"

          * 3.3.2.4.1. Note sur l'utilisation de *__slots__*

      * 3.3.3. Personnalisation de la création de classes

        * 3.3.3.1. Méta-classes

        * 3.3.3.2. Détermination de la méta-classe appropriée

        * 3.3.3.3. Préparation de l'espace de nommage de la classe

        * 3.3.3.4. Exécution du corps de la classe

        * 3.3.3.5. Création de l'objet classe

        * 3.3.3.6. Uses for metaclasses

      * 3.3.4. Personnalisation des instances et vérification des
        sous-classes

      * 3.3.5. Émulation d'objets appelables

      * 3.3.6. Émulation de types conteneurs

      * 3.3.7. Émulation de types numériques

      * 3.3.8. Gestionnaire de contexte With

      * 3.3.9. Recherche des méthodes spéciales

    * 3.4. Coroutines

      * 3.4.1. Objets *attendables* (*awaitables*)

      * 3.4.2. Objets coroutines

      * 3.4.3. Itérateurs asynchrones

      * 3.4.4. Gestionnaires de contexte asynchrones

  * 4. Modèle d'exécution

    * 4.1. Structure d'un programme

    * 4.2. Noms et liaisons

      * 4.2.1. Liaisons des noms

      * 4.2.2. Résolution des noms

      * 4.2.3. Noms natifs et restrictions d'exécution

      * 4.2.4. Interaction avec les fonctionnalités dynamiques

    * 4.3. Exceptions

  * 5. Le système d'importation

    * 5.1. "importlib"

    * 5.2. Les paquets

      * 5.2.1. Paquets classiques

      * 5.2.2. Paquets espaces de nommage

    * 5.3. Recherche

      * 5.3.1. Cache des modules

      * 5.3.2. Chercheurs et chargeurs

      * 5.3.3. Points d'entrées automatiques pour l'importation

      * 5.3.4. Méta-chemins

    * 5.4. Chargement

      * 5.4.1. Chargeurs

      * 5.4.2. Sous-modules

      * 5.4.3. Spécificateurs de modules

      * 5.4.4. Attributs des modules importés

      * 5.4.5. module.__path__

      * 5.4.6. Représentation textuelle d'un module

    * 5.5. Le chercheur dans *path*

      * 5.5.1. Chercheurs d'entrée dans *path*

      * 5.5.2. Protocole des chercheurs d'entrée dans *path*

    * 5.6. Remplacement du système d'importation standard

    * 5.7. Cas particulier de "__main__"

      * 5.7.1. "__main__.__spec__"

    * 5.8. Idées d'amélioration

    * 5.9. Références

  * 6. Expressions

    * 6.1. Conversions arithmétiques

    * 6.2. Atomes

      * 6.2.1. Identifiants (noms)

      * 6.2.2. Littéraux

      * 6.2.3. Formes parenthésées

      * 6.2.4. Agencements des listes, ensembles et dictionnaires

      * 6.2.5. Agencements de listes

      * 6.2.6. Agencements d'ensembles

      * 6.2.7. Agencements de dictionnaires

      * 6.2.8. Expressions génératrices

      * 6.2.9. Expressions "yield"

        * 6.2.9.1. Méthodes des générateurs-itérateurs

        * 6.2.9.2. Exemples

        * 6.2.9.3. Fonctions génératrices asynchrones

        * 6.2.9.4. Méthodes des générateurs-itérateurs asynchrones

    * 6.3. Primaires

      * 6.3.1. Références à des attributs

      * 6.3.2. Sélections

      * 6.3.3. Tranches

      * 6.3.4. Appels

    * 6.4. Expression "await"

    * 6.5. L'opérateur puissance

    * 6.6. Arithmétique unaire et opérations sur les bits

    * 6.7. Opérations arithmétiques binaires

    * 6.8. Opérations de décalage

    * 6.9. Opérations binaires bit à bit

    * 6.10. Comparaisons

      * 6.10.1. Comparaisons de valeurs

      * 6.10.2. Opérations de tests d’appartenance à un ensemble

      * 6.10.3. Comparaisons d'identifiants

    * 6.11. Opérations booléennes

    * 6.12. Expressions conditionnelles

    * 6.13. Expressions lambda

    * 6.14. Listes d'expressions

    * 6.15. Ordre d'évaluation

    * 6.16. Priorités des opérateurs

  * 7. Les instructions simples

    * 7.1. Les expressions

    * 7.2. Les assignations

      * 7.2.1. Les assignations augmentées

      * 7.2.2. Les assignations annotées

    * 7.3. L'instruction "assert"

    * 7.4. L'instruction  "pass"

    * 7.5. L'instruction "del"

    * 7.6. L'instruction "return"

    * 7.7. L'instruction "yield"

    * 7.8. L'instruction "raise"

    * 7.9. L'instruction "break"

    * 7.10. L'instruction "continue"

    * 7.11. L'instruction "import"

      * 7.11.1. L'instruction future

    * 7.12. L'instruction "global"

    * 7.13. L'instruction "nonlocal"

  * 8. Instructions composées

    * 8.1. L'instruction "if"

    * 8.2. L'instruction "while"

    * 8.3. L'instruction "for"

    * 8.4. L'instruction "try"

    * 8.5. L'instruction "with"

    * 8.6. Définition de fonctions

    * 8.7. Définition de classes

    * 8.8. Coroutines

      * 8.8.1. Définition de fonctions coroutines

      * 8.8.2. L'instruction "async for"

      * 8.8.3. L'instruction "async with"

  * 9. Composants de plus haut niveau

    * 9.1. Programmes Python complets

    * 9.2. Fichier d'entrée

    * 9.3. Entrée interactive

    * 9.4. Entrée d'expression

  * 10. Spécification complète de la grammaire

* La bibliothèque standard

  * 1. Introduction

  * 2. Fonctions natives

  * 3. Constantes natives

    * 3.1. Constantes ajoutées par le module "site"

  * 4. Types natifs

    * 4.1. Valeurs booléennes

    * 4.2. Opérations booléennes --- "and", "or", "not"

    * 4.3. Comparaisons

    * 4.4. Types numériques — "int", "float", "complex"

      * 4.4.1. Opérations sur les bits des nombres entiers

      * 4.4.2. Méthodes supplémentaires sur les entiers

      * 4.4.3. Méthodes supplémentaires sur les nombres à virgule
        flottante

      * 4.4.4. Hachage des types numériques

    * 4.5. Les types itérateurs

      * 4.5.1. Types générateurs

    * 4.6. Types séquentiels — "list", "tuple", "range"

      * 4.6.1. Opérations communes sur les séquences

      * 4.6.2. Types de séquences immuables

      * 4.6.3. Types de séquences muables

      * 4.6.4. Listes

      * 4.6.5. Tuples

      * 4.6.6. *Ranges*

    * 4.7. Type Séquence de Texte — "str"

      * 4.7.1. Méthodes de chaînes de caractères

      * 4.7.2. Formatage de chaines à la "printf"

    * 4.8. Séquences Binaires --- "bytes", "bytearray", "memoryview"

      * 4.8.1. Objets *bytes*

      * 4.8.2. Objets *bytearray*

      * 4.8.3. Opérations sur les *bytes* et *bytearray*

      * 4.8.4. Formatage de *bytes* a la "printf"

      * 4.8.5. Vues de mémoires

    * 4.9. Types d'ensembles — "set", "frozenset"

    * 4.10. Les types de correspondances — "dict"

      * 4.10.1. Les vues de dictionnaires

    * 4.11. Le type gestionnaire de contexte

    * 4.12. Autres types natifs

      * 4.12.1. Modules

      * 4.12.2. Les classes et instances de classes

      * 4.12.3. Fonctions

      * 4.12.4. Méthodes

      * 4.12.5. Objets code

      * 4.12.6. Objets type

      * 4.12.7. L'objet Null

      * 4.12.8. L'objet points de suspension

      * 4.12.9. L'objet *NotImplemented*

      * 4.12.10. Valeurs booléennes

      * 4.12.11. Objets internes

    * 4.13. Attributs spéciaux

  * 5. Exceptions natives

    * 5.1. Classes de base

    * 5.2. Exceptions concrètes

      * 5.2.1. Exceptions système

    * 5.3. Avertissements

    * 5.4. Hiérarchie des exceptions

  * 6. Services de Manipulation de Texte

    * 6.1. "string" — Opérations usuelles sur des chaînes

      * 6.1.1. Chaînes constantes

      * 6.1.2. Formatage personnalisé de chaîne

      * 6.1.3. Syntaxe de formatage de chaîne

        * 6.1.3.1. Mini-langage de spécification de format

        * 6.1.3.2. Exemples de formats

      * 6.1.4. Chaînes modèles

      * 6.1.5. Fonctions d'assistance

    * 6.2. "re" — Opérations à base d'expressions rationnelles

      * 6.2.1. Syntaxe des expressions rationnelles

      * 6.2.2. Contenu du module

      * 6.2.3. Objets d'expressions rationnelles

      * 6.2.4. Objets de correspondance

      * 6.2.5. Exemples d'expressions rationnelles

        * 6.2.5.1. Rechercher une paire

        * 6.2.5.2. Simuler *scanf()*

        * 6.2.5.3. search() vs. match()

        * 6.2.5.4. Construire un répertoire téléphonique

        * 6.2.5.5. Mélanger les lettres des mots

        * 6.2.5.6. Trouver tous les adverbes

        * 6.2.5.7. Trouver tous les adverbes et leurs positions

        * 6.2.5.8. Notation brutes de chaînes

        * 6.2.5.9. Écrire un analyseur lexical

    * 6.3. "difflib" --- Helpers for computing deltas

      * 6.3.1. SequenceMatcher Objects

      * 6.3.2. SequenceMatcher Examples

      * 6.3.3. Differ Objects

      * 6.3.4. Differ Example

      * 6.3.5. A command-line interface to difflib

    * 6.4. "textwrap" --- Encapsulation et remplissage de texte

    * 6.5. "unicodedata" — Base de données Unicode

    * 6.6. "stringprep" — Préparation des chaines de caractères
      internet

    * 6.7. "readline" — interface pour GNU *readline*

      * 6.7.1. Fichier d'initialisation

      * 6.7.2. Tampon de ligne

      * 6.7.3. Fichier d'historique

      * 6.7.4. Liste d'historique

      * 6.7.5. Fonctions de rappel au démarrage

      * 6.7.6. Complétion

      * 6.7.7. Exemple

    * 6.8. "rlcompleter" — Fonction de complétion pour *GNU readline*

      * 6.8.1. Objets pour la complétion (*Completer Objects*)

  * 7. Services autour des Données Binaires

    * 7.1. "struct" — manipulation de données agrégées sous forme
      binaire comme une séquence d'octets

      * 7.1.1. Fonctions et exceptions

      * 7.1.2. Chaînes de spécification du format

        * 7.1.2.1. Boutisme, taille et alignement

        * 7.1.2.2. Caractères de format

        * 7.1.2.3. Exemples

      * 7.1.3. Classes

    * 7.2. "codecs" — Registre des codecs et classes de base associées

      * 7.2.1. Classes de base de codecs

        * 7.2.1.1. Gestionnaires d'erreurs

        * 7.2.1.2. Stateless Encoding and Decoding

        * 7.2.1.3. Incremental Encoding and Decoding

          * 7.2.1.3.1. IncrementalEncoder Objects

          * 7.2.1.3.2. IncrementalDecoder Objects

        * 7.2.1.4. Stream Encoding and Decoding

          * 7.2.1.4.1. StreamWriter Objects

          * 7.2.1.4.2. StreamReader Objects

          * 7.2.1.4.3. StreamReaderWriter Objects

          * 7.2.1.4.4. StreamRecoder Objects

      * 7.2.2. Encodings and Unicode

      * 7.2.3. Standard Encodings

      * 7.2.4. Python Specific Encodings

        * 7.2.4.1. Text Encodings

        * 7.2.4.2. Binary Transforms

        * 7.2.4.3. Text Transforms

      * 7.2.5. "encodings.idna" --- Internationalized Domain Names in
        Applications

      * 7.2.6. "encodings.mbcs" --- Windows ANSI codepage

      * 7.2.7. "encodings.utf_8_sig" --- UTF-8 codec with BOM
        signature

  * 8. Types de données

    * 8.1. "datetime" — Types de base pour la date et l'heure

      * 8.1.1. Types disponibles

      * 8.1.2. Objets "timedelta"

      * 8.1.3. Objets "date"

      * 8.1.4. Objets "datetime"

      * 8.1.5. Objets "time"

      * 8.1.6. Objets "tzinfo"

      * 8.1.7. Objets "timezone"

      * 8.1.8. Comportement de "strftime()" et "strptime()"

    * 8.2. "calendar" --- General calendar-related functions

    * 8.3. "collections" — Types de données de conteneurs

      * 8.3.1. Objets "ChainMap"

        * 8.3.1.1. Exemples et cas pratiques utilisant "ChainMap"

      * 8.3.2. Objets "Counter"

      * 8.3.3. Objets "deque"

        * 8.3.3.1. Cas pratiques utilisant "deque"

      * 8.3.4. Objets "defaultdict"

        * 8.3.4.1. Exemples utilisant "defaultdict"

      * 8.3.5. "namedtuple()": fonction de construction pour
        *n-uplets* (*tuples*) avec des champs nommés

      * 8.3.6. Objets "OrderedDict"

        * 8.3.6.1. Exemples et cas pratiques utilisant "OrderDict"

      * 8.3.7. Objets "UserDict"

      * 8.3.8. Objets "UserList"

      * 8.3.9. Objets "UserString"

    * 8.4. "collections.abc" --- Classes de base abstraites pour les
      conteneurs

      * 8.4.1. Classes de base abstraites de collections

    * 8.5. "heapq" — File de priorité basée sur un tas

      * 8.5.1. Exemples simples

      * 8.5.2. Notes d'implémentation de la file de priorité

      * 8.5.3. Théorie

    * 8.6. "bisect" — Algorithme de bissection de listes

      * 8.6.1. Chercher dans des listes triées

      * 8.6.2. Autres Exemples

    * 8.7. "array" — Tableaux efficaces de valeurs numériques

    * 8.8. "weakref" --- Weak references

      * 8.8.1. Objets à références faibles

      * 8.8.2. Exemple

      * 8.8.3. Finalizer Objects

      * 8.8.4. Comparing finalizers with "__del__()" methods

    * 8.9. "types" --- Dynamic type creation and names for built-in
      types

      * 8.9.1. Dynamic Type Creation

      * 8.9.2. Standard Interpreter Types

      * 8.9.3. Additional Utility Classes and Functions

      * 8.9.4. Coroutine Utility Functions

    * 8.10. "copy" — Opérations de copie superficielle et récursive

    * 8.11. "pprint" — L’affichage élégant de données

      * 8.11.1. Les Objets PrettyPrinter

      * 8.11.2. Exemple

    * 8.12. "reprlib" --- Alternate "repr()" implementation

      * 8.12.1. Repr Objects

      * 8.12.2. Subclassing Repr Objects

    * 8.13. "enum" — Énumerations

      * 8.13.1. Contenu du module

      * 8.13.2. Création d'une *Enum*

      * 8.13.3. Accès dynamique aux membres et à leurs attributs

      * 8.13.4. Duplication de membres et de valeurs

      * 8.13.5. Coercition d'unicité des valeurs d'une énumération

      * 8.13.6. Valeurs automatiques

      * 8.13.7. Itération

      * 8.13.8. Comparaisons

      * 8.13.9. Membres et attributs autorisés dans une énumération

      * 8.13.10. Restricted subclassing of enumerations

      * 8.13.11. Sérialisation

      * 8.13.12. API par fonction

      * 8.13.13. Énumérations dérivées

        * 8.13.13.1. IntEnum

        * 8.13.13.2. IntFlag

        * 8.13.13.3. Option

        * 8.13.13.4. Autres

      * 8.13.14. Exemples intéressants

        * 8.13.14.1. Omettre les valeurs

          * 8.13.14.1.1. Avec "auto"

          * 8.13.14.1.2. Avec "object"

          * 8.13.14.1.3. Avec une chaîne de caractères de description

          * 8.13.14.1.4. Avec une méthode ad-hoc "__new__()"

        * 8.13.14.2. OrderedEnum

        * 8.13.14.3. DuplicateFreeEnum

        * 8.13.14.4. Planet

      * 8.13.15. En quoi les *Enums* sont différentes ?

        * 8.13.15.1. Classes *Enum*

        * 8.13.15.2. Membres d'Enum (c.-à-d. instances)

        * 8.13.15.3. Aspects approfondis

          * 8.13.15.3.1. Noms de la forme "__dunder__" disponibles

          * 8.13.15.3.2. Noms de la forme "_sunder_" disponibles

          * 8.13.15.3.3. Type des membres de "Enum"

          * 8.13.15.3.4. Valeur booléenne des classes "Enum" et de
            leurs membres

          * 8.13.15.3.5. Classes "Enum" avec des méthodes

          * 8.13.15.3.6. Combinaison de membres de "Flag"

  * 9. Modules numériques et mathématiques

    * 9.1. "numbers" — Classes de base abstraites numériques

      * 9.1.1. La tour numérique

      * 9.1.2. Notes pour implémenter des types

        * 9.1.2.1. Ajouter plus d'ABC numériques

        * 9.1.2.2. Implémentation des opérations arithmétiques

    * 9.2. Fonctions mathématiques — "math"

      * 9.2.1. Fonctions arithmétiques et de représentation

      * 9.2.2. Fonctions logarithme et exponentielle

      * 9.2.3. Fonctions trigonométriques

      * 9.2.4. Conversion angulaire

      * 9.2.5. Fonctions hyperboliques

      * 9.2.6. Fonctions spéciales

      * 9.2.7. Constantes

    * 9.3. Fonctions mathématiques pour nombres complexes — "cmath"

      * 9.3.1. Conversion vers et à partir de coordonnées polaires

      * 9.3.2. Fonctions logarithme et exponentielle

      * 9.3.3. Fonctions trigonométriques

      * 9.3.4. Fonctions hyperboliques

      * 9.3.5. Fonctions de classifications

      * 9.3.6. Constantes

    * 9.4. "decimal" — Arithmétique décimale en virgule fixe et
      flottante

      * 9.4.1. Introduction pratique

      * 9.4.2. Les objets Decimal

        * 9.4.2.1. Logical operands

      * 9.4.3. Context objects

      * 9.4.4. Constantes

      * 9.4.5. Rounding modes

      * 9.4.6. Signals

      * 9.4.7. Floating Point Notes

        * 9.4.7.1. Mitigating round-off error with increased precision

        * 9.4.7.2. Special values

      * 9.4.8. Working with threads

      * 9.4.9. Cas pratiques

      * 9.4.10. FAQ *decimal*

    * 9.5. "fractions" — Nombres rationnels

    * 9.6. "random" --- Génère des nombres pseudo-aléatoires

      * 9.6.1. Fonctions de gestion d'état

      * 9.6.2. Fonctions pour les entiers

      * 9.6.3. Fonctions pour les séquences

      * 9.6.4. Distributions pour les nombre réels

      * 9.6.5. Générateur alternatif

      * 9.6.6. Remarques sur la reproductibilité

      * 9.6.7. Exemples et recettes

    * 9.7. "statistics" --- Mathematical statistics functions

      * 9.7.1. Averages and measures of central location

      * 9.7.2. Measures of spread

      * 9.7.3. Function details

      * 9.7.4. Exceptions

  * 10. Modules de programmation fonctionnelle

    * 10.1. "itertools" — Fonctions créant des itérateurs pour boucler
      efficacement

      * 10.1.1. Fonctions d'*itertool*

      * 10.1.2. Recettes *itertools*

    * 10.2. "functools" --- Fonctions de haut niveau et opérations sur
      des objets appelables

      * 10.2.1. Objets "partial"

    * 10.3. "operator" — Opérateurs standards en tant que fonctions

      * 10.3.1. Correspondances entre opérateurs et fonctions

      * 10.3.2. Inplace Operators

  * 11. Accès aux Fichiers et aux Dossiers

    * 11.1. "pathlib" — Chemins de système de fichiers orientés objet

      * 11.1.1. Utilisation basique

      * 11.1.2. Chemins purs

        * 11.1.2.1. Propriétés générales

        * 11.1.2.2. Opérateurs

        * 11.1.2.3. Accéder aux parties individuelles

        * 11.1.2.4. Méthodes et propriétés

      * 11.1.3. Chemins concrets

        * 11.1.3.1. Méthodes

    * 11.2. "os.path" — manipulation courante des chemins

    * 11.3. "fileinput" --- Iterate over lines from multiple input
      streams

    * 11.4. "stat" --- Interpreting "stat()" results

    * 11.5. "filecmp" – Comparaisons de fichiers et de répertoires

      * 11.5.1. La classe "dircmp"

    * 11.6. "tempfile" — Génération de fichiers et répertoires
      temporaires

      * 11.6.1. Exemples

      * 11.6.2. Fonctions et variables obsolètes

    * 11.7. "glob" --- Recherche de chemins de style Unix selon
      certains motifs

    * 11.8. "fnmatch" — Filtrage par motif des noms de fichiers Unix

    * 11.9. "linecache" — Accès direct aux lignes d'un texte

    * 11.10. "shutil" --- Opérations de haut niveau sur les fichiers

      * 11.10.1. Opérations sur les répertoires et les fichiers

        * 11.10.1.1. copytree example

        * 11.10.1.2. rmtree example

      * 11.10.2. Archiving operations

        * 11.10.2.1. Archiving example

      * 11.10.3. Querying the size of the output terminal

    * 11.11. "macpath" — Fonctions de manipulation de chemins pour Mac
      OS 9

  * 12. Persistance des données

    * 12.1. "pickle" --- Module de sérialisation d'objets Python

      * 12.1.1. Relations aux autres modules python

        * 12.1.1.1. Comparaison avec "marshal"

        * 12.1.1.2. Comparison with "json"

      * 12.1.2. Data stream format

      * 12.1.3. Module Interface

      * 12.1.4. What can be pickled and unpickled?

      * 12.1.5. Pickling Class Instances

        * 12.1.5.1. Persistence of External Objects

        * 12.1.5.2. Dispatch Tables

        * 12.1.5.3. Handling Stateful Objects

      * 12.1.6. Restricting Globals

      * 12.1.7. Performances

      * 12.1.8. Exemples

    * 12.2. "copyreg" — Enregistre les fonctions support de "pickle"

      * 12.2.1. Exemple

    * 12.3. "shelve" — Objet Python persistant

      * 12.3.1. Limites

      * 12.3.2. Exemple

    * 12.4. "marshal" --- Internal Python object serialization

    * 12.5. "dbm" --- Interfaces to Unix "databases"

      * 12.5.1. "dbm.gnu" --- GNU's reinterpretation of dbm

      * 12.5.2. "dbm.ndbm" --- Interface based on ndbm

      * 12.5.3. "dbm.dumb" --- Portable DBM implementation

    * 12.6. "sqlite3" — Interface DB-API 2.0 pour bases de données
      SQLite

      * 12.6.1. Fonctions et constantes du module

      * 12.6.2. Objets de connexions

      * 12.6.3. Cursor Objects

      * 12.6.4. Row Objects

      * 12.6.5. Exceptions

      * 12.6.6. SQLite and Python types

        * 12.6.6.1. Introduction

        * 12.6.6.2. Using adapters to store additional Python types in
          SQLite databases

          * 12.6.6.2.1. Letting your object adapt itself

          * 12.6.6.2.2. Registering an adapter callable

        * 12.6.6.3. Converting SQLite values to custom Python types

        * 12.6.6.4. Default adapters and converters

      * 12.6.7. Controlling Transactions

      * 12.6.8. Using "sqlite3" efficiently

        * 12.6.8.1. Using shortcut methods

        * 12.6.8.2. Accessing columns by name instead of by index

        * 12.6.8.3. Using the connection as a context manager

      * 12.6.9. Common issues

        * 12.6.9.1. Fils d'exécution

  * 13. Compression de donnée et archivage

    * 13.1. "zlib" — Compression compatible avec **gzip**

    * 13.2. "gzip" — Support pour les fichiers **gzip**

      * 13.2.1. Exemples d'utilisation

    * 13.3. "bz2" — Prise en charge de la compression **bzip2**

      * 13.3.1. (Dé)compression de fichiers

      * 13.3.2. (Dé)compression incrémentielle

      * 13.3.3. (Dé)compression en une fois

    * 13.4. "lzma" — Compression via l'algorithme LZMA

      * 13.4.1. Lire et écrire des fichiers compressés

      * 13.4.2. Compresser et décompresser une donnée en mémoire

      * 13.4.3. Divers

      * 13.4.4. Préciser des chaînes de filtre personnalisées

      * 13.4.5. Exemples

    * 13.5. "zipfile" — Travailler avec des archives ZIP

      * 13.5.1. Objets ZipFile

      * 13.5.2. Objets *PyZipFile*

      * 13.5.3. Objets *ZipInfo*

      * 13.5.4. Interface en ligne de commande

        * 13.5.4.1. Options de la ligne de commande

    * 13.6. "tarfile" --- Read and write tar archive files

      * 13.6.1. TarFile Objects

      * 13.6.2. TarInfo Objects

      * 13.6.3. Interface en ligne de commande

        * 13.6.3.1. Options de la ligne de commande

      * 13.6.4. Exemples

      * 13.6.5. Supported tar formats

      * 13.6.6. Unicode issues

  * 14. Formats de fichiers

    * 14.1. "csv" — Lecture et écriture de fichiers CSV

      * 14.1.1. Contenu du module

      * 14.1.2. Dialectes et paramètres de formatage

      * 14.1.3. Objets lecteurs

      * 14.1.4. Objets transcripteurs

      * 14.1.5. Exemples

    * 14.2. "configparser" --- Configuration file parser

      * 14.2.1. Quick Start

      * 14.2.2. Supported Datatypes

      * 14.2.3. Fallback Values

      * 14.2.4. Supported INI File Structure

      * 14.2.5. Interpolation of values

      * 14.2.6. Mapping Protocol Access

      * 14.2.7. Customizing Parser Behaviour

      * 14.2.8. Legacy API Examples

      * 14.2.9. ConfigParser Objects

      * 14.2.10. RawConfigParser Objects

      * 14.2.11. Exceptions

    * 14.3. "netrc" — traitement de fichier *netrc*

      * 14.3.1. Objets *netrc*

    * 14.4. "xdrlib" --- Encode and decode XDR data

      * 14.4.1. Packer Objects

      * 14.4.2. Unpacker Objects

      * 14.4.3. Exceptions

    * 14.5. "plistlib" --- Generate and parse Mac OS X ".plist" files

      * 14.5.1. Exemples

  * 15. Service de cryptographie

    * 15.1. "hashlib" --- Algorithmes de hachage sécurisés et synthèse
      de messages

      * 15.1.1. Algorithmes de hachage

      * 15.1.2. Synthèse de messages de taille variable SHAKE

      * 15.1.3. Dérivation de clé

      * 15.1.4. BLAKE2

        * 15.1.4.1. Création d'objets hachés

        * 15.1.4.2. Constantes

        * 15.1.4.3. Exemples

          * 15.1.4.3.1. Hachage simple

          * 15.1.4.3.2. Usage de tailles d'empreintes différentes

          * 15.1.4.3.3. Code d'authentification de message

          * 15.1.4.3.4. Hachage randomisé

          * 15.1.4.3.5. Personnalisation

          * 15.1.4.3.6. Mode Arbre

        * 15.1.4.4. Crédits

    * 15.2. "hmac" — Authentification de messages par hachage en
      combinaison avec une clé secrète

    * 15.3. "secrets" — Générer des nombres aléatoires de façon
      sécurisée pour la gestion des secrets

      * 15.3.1. Nombres aléatoires

      * 15.3.2. Génération de jetons

        * 15.3.2.1. Combien d'octets mon jeton doit-il comporter ?

      * 15.3.3. Autres fonctions

      * 15.3.4. Recettes et bonnes pratiques

  * 16. Services génériques du système d'exploitation

    * 16.1. "os" — Diverses interfaces pour le système d'exploitation

      * 16.1.1. Noms de fichiers, arguments en ligne de commande, et
        variables d'environnement

      * 16.1.2. Paramètres de processus

      * 16.1.3. Création de fichiers objets

      * 16.1.4. Opérations sur les descripteurs de fichiers

        * 16.1.4.1. Demander la taille d'un terminal

        * 16.1.4.2. Héritage de descripteurs de fichiers

      * 16.1.5. Fichiers et répertoires

        * 16.1.5.1. Attributs étendus pour Linux

      * 16.1.6. Gestion des processus

      * 16.1.7. Interface pour l'ordonnanceur

      * 16.1.8. Diverses informations sur le système

      * 16.1.9. Nombres aléatoires

    * 16.2. "io" --- Core tools for working with streams

      * 16.2.1. Aperçu

        * 16.2.1.1. Text I/O

        * 16.2.1.2. Binary I/O

        * 16.2.1.3. Raw I/O

      * 16.2.2. High-level Module Interface

        * 16.2.2.1. In-memory streams

      * 16.2.3. Class hierarchy

        * 16.2.3.1. I/O Base Classes

        * 16.2.3.2. Raw File I/O

        * 16.2.3.3. Buffered Streams

        * 16.2.3.4. Text I/O

      * 16.2.4. Performances

        * 16.2.4.1. Binary I/O

        * 16.2.4.2. Text I/O

        * 16.2.4.3. Fils d'exécution

        * 16.2.4.4. Reentrancy

    * 16.3. "time" — Accès au temps et conversions

      * 16.3.1. Fonctions

      * 16.3.2. Constantes d’identification d’horloge

      * 16.3.3. Constantes de fuseau horaire

    * 16.4. "argparse" -- Parseur d'arguments, d'options, et de sous-
      commandes de ligne de commande

      * 16.4.1. Exemple

        * 16.4.1.1. Créer un analyseur (*parser* en anglais)

        * 16.4.1.2. Ajouter des arguments

        * 16.4.1.3. Analyse des arguments

      * 16.4.2. Objets "ArgumentParser"

        * 16.4.2.1. Le paramètre *prog*

        * 16.4.2.2. Le paramètre *usage*

        * 16.4.2.3. Le paramètre *description*

        * 16.4.2.4. Le paramètre *epilog*

        * 16.4.2.5. Le paramètre *parents*

        * 16.4.2.6. Le paramètre *formatter_class*

        * 16.4.2.7. Le paramètre *prefix_chars*

        * 16.4.2.8. Le paramètre *fromfile_prefix_chars*

        * 16.4.2.9. Le paramètre *argument_default*

        * 16.4.2.10. Le paramètre *allow_abbrev*

        * 16.4.2.11. Le paramètre *conflict_handler*

        * 16.4.2.12. Le paramètre *add_help*

      * 16.4.3. La méthode *add_argument()*

        * 16.4.3.1. Les paramètres *name* et *flags*

        * 16.4.3.2. Le paramètre *action*

        * 16.4.3.3. Le paramètre *nargs*

        * 16.4.3.4. Le paramètre *const*

        * 16.4.3.5. Le paramètre *default*

        * 16.4.3.6. Le paramètre *type*

        * 16.4.3.7. Le paramètre *choices*

        * 16.4.3.8. Le paramètre *required*

        * 16.4.3.9. Le paramètre *help*

        * 16.4.3.10. Le paramètre *metavar*

        * 16.4.3.11. Le paramètre *dest*

        * 16.4.3.12. Classes Action

      * 16.4.4. La méthode *parse_args()*

        * 16.4.4.1. Option value syntax

        * 16.4.4.2. Arguments invalides

        * 16.4.4.3. Arguments contenant "-"

        * 16.4.4.4. Arguments abrégés (Par comparaison de leurs
          préfixes)

        * 16.4.4.5. Au-delà de "sys.argv"

        * 16.4.4.6. L'objet namespace

      * 16.4.5. Autres outils

        * 16.4.5.1. Sous commandes

        * 16.4.5.2. Objets "FileType"

        * 16.4.5.3. Groupes d'arguments

        * 16.4.5.4. Exclusion mutuelle

        * 16.4.5.5. Valeurs par défaut de l'analyseur

        * 16.4.5.6. Afficher l'aide

        * 16.4.5.7. *Parsing* partiel

        * 16.4.5.8. Personnaliser le *parsing* de fichiers

        * 16.4.5.9. Exiting methods

      * 16.4.6. Mettre à jour du code "optparse"

    * 16.5. "getopt" – Analyseur de style C pour les options de ligne
      de commande

    * 16.6. "logging" — Fonctionnalités de journalisation pour Python

      * 16.6.1. Objets Enregistreurs

      * 16.6.2. Niveaux de journalisation

      * 16.6.3. Handler Objects

      * 16.6.4. Formatter Objects

      * 16.6.5. Filter Objects

      * 16.6.6. LogRecord Objects

      * 16.6.7. LogRecord attributes

      * 16.6.8. LoggerAdapter Objects

      * 16.6.9. Thread Safety

      * 16.6.10. Fonctions de niveau module

      * 16.6.11. Module-Level Attributes

      * 16.6.12. Integration with the warnings module

    * 16.7. "logging.config" --- Logging configuration

      * 16.7.1. Configuration functions

      * 16.7.2. Configuration dictionary schema

        * 16.7.2.1. Dictionary Schema Details

        * 16.7.2.2. Incremental Configuration

        * 16.7.2.3. Object connections

        * 16.7.2.4. User-defined objects

        * 16.7.2.5. Access to external objects

        * 16.7.2.6. Access to internal objects

        * 16.7.2.7. Import resolution and custom importers

      * 16.7.3. Configuration file format

    * 16.8. "logging.handlers" --- Logging handlers

      * 16.8.1. StreamHandler

      * 16.8.2. FileHandler

      * 16.8.3. NullHandler

      * 16.8.4. WatchedFileHandler

      * 16.8.5. BaseRotatingHandler

      * 16.8.6. RotatingFileHandler

      * 16.8.7. TimedRotatingFileHandler

      * 16.8.8. SocketHandler

      * 16.8.9. DatagramHandler

      * 16.8.10. SysLogHandler

      * 16.8.11. NTEventLogHandler

      * 16.8.12. SMTPHandler

      * 16.8.13. MemoryHandler

      * 16.8.14. HTTPHandler

      * 16.8.15. QueueHandler

      * 16.8.16. QueueListener

    * 16.9. Saisie de mot de passe portable

    * 16.10. "curses" --- Terminal handling for character-cell
      displays

      * 16.10.1. Fonctions

      * 16.10.2. Window Objects

      * 16.10.3. Constantes

    * 16.11. "curses.textpad" --- Text input widget for curses
      programs

      * 16.11.1. Textbox objects

    * 16.12. "curses.ascii" --- Utilities for ASCII characters

    * 16.13. "curses.panel" --- A panel stack extension for curses

      * 16.13.1. Fonctions

      * 16.13.2. Panel Objects

    * 16.14. "platform" ---  Access to underlying platform's
      identifying data

      * 16.14.1. Cross Platform

      * 16.14.2. Java Platform

      * 16.14.3. Windows Platform

        * 16.14.3.1. Win95/98 specific

      * 16.14.4. Mac OS Platform

      * 16.14.5. Unix Platforms

    * 16.15. "errno" — Symboles du système *errno* standard

    * 16.16. "ctypes" — Bibliothèque Python d'appels à des fonctions
      externes

      * 16.16.1. Didacticiel de *ctypes*

        * 16.16.1.1. Chargement des DLL

        * 16.16.1.2. Accès aux fonctions des DLL chargées

        * 16.16.1.3. Appel de fonctions

        * 16.16.1.4. Types de données fondamentaux

        * 16.16.1.5. Appel de fonctions, suite

        * 16.16.1.6. Appel de fonctions avec des types de données
          personnalisés

        * 16.16.1.7. Définition du type des arguments nécessaires
          (prototypes de fonction)

        * 16.16.1.8. Types de sortie

        * 16.16.1.9. Passage de pointeurs (passage de paramètres par
          référence)

        * 16.16.1.10. Structures et unions

        * 16.16.1.11. Alignement et boutisme des structures et des
          unions

        * 16.16.1.12. Champs de bits dans les structures et les unions

        * 16.16.1.13. Tableaux

        * 16.16.1.14. Pointeurs

        * 16.16.1.15. Conversions de type

        * 16.16.1.16. Types incomplets

        * 16.16.1.17. Fonctions de rappel

        * 16.16.1.18. Accès aux variables exportées depuis une DLL

        * 16.16.1.19. Pièges

        * 16.16.1.20. Types de données à taille flottante

      * 16.16.2. Référence du module

        * 16.16.2.1. Recherche de bibliothèques partagées

        * 16.16.2.2. Chargement des bibliothèques partagées

        * 16.16.2.3. Fonctions externes

        * 16.16.2.4. Prototypes de fonction

        * 16.16.2.5. Fonctions utilitaires

        * 16.16.2.6. Types de données

        * 16.16.2.7. Types de données fondamentaux

        * 16.16.2.8. Types de donnée dérivés de Structure

        * 16.16.2.9. Tableaux et pointeurs

  * 17. Exécution concourante

    * 17.1. "threading" — Parallélisme basé sur les fils d’exécution
      (*threads*)

      * 17.1.1. Données locales au fil d'exécution

      * 17.1.2. Objets *Threads*

      * 17.1.3. Verrous

      * 17.1.4. RLock Objects

      * 17.1.5. Condition Objects

      * 17.1.6. Semaphore Objects

        * 17.1.6.1. "Semaphore" Example

      * 17.1.7. Event Objects

      * 17.1.8. Timer Objects

      * 17.1.9. Barrier Objects

      * 17.1.10. Using locks, conditions, and semaphores in the "with"
        statement

    * 17.2. "multiprocessing" — Parallélisme par processus

      * 17.2.1. Introduction

        * 17.2.1.1. La classe "Process"

        * 17.2.1.2. Contextes et méthodes de démarrage

        * 17.2.1.3. Échange d'objets entre les processus

        * 17.2.1.4. Synchronisation entre processus

        * 17.2.1.5. Partager un état entre les processus

        * 17.2.1.6. Utiliser un réservoir de *workers*

      * 17.2.2. Référence

        * 17.2.2.1. "Process" et exceptions

        * 17.2.2.2. Tubes (*pipes*) et Queues

        * 17.2.2.3. Divers

        * 17.2.2.4. Objets de connexions

        * 17.2.2.5. Primitives de synchronisation

        * 17.2.2.6. Objets "ctypes" partagés

          * 17.2.2.6.1. Le module "multiprocessing.sharedctypes"

        * 17.2.2.7. Gestionnaires

          * 17.2.2.7.1. Gestionnaires personnalisés

          * 17.2.2.7.2. Utiliser un gestionnaire distant

        * 17.2.2.8. Objets mandataires

          * 17.2.2.8.1. Nettoyage

        * 17.2.2.9. Bassins de processus

        * 17.2.2.10. Auditeurs et Clients

          * 17.2.2.10.1. Formats d'adresses

        * 17.2.2.11. Clés d'authentification

        * 17.2.2.12. Journalisation

        * 17.2.2.13. Le module "multiprocessing.dummy"

      * 17.2.3. Lignes directrices de programmation

        * 17.2.3.1. Toutes les méthodes de démarrage

        * 17.2.3.2. Les méthodes de démarrage *spawn* et *forkserver*

      * 17.2.4. Exemples

    * 17.3. Le paquet "concurrent"

    * 17.4. "concurrent.futures" --- Launching parallel tasks

      * 17.4.1. Executor Objects

      * 17.4.2. ThreadPoolExecutor

        * 17.4.2.1. ThreadPoolExecutor Example

      * 17.4.3. ProcessPoolExecutor

        * 17.4.3.1. ProcessPoolExecutor Example

      * 17.4.4. Future Objects

      * 17.4.5. Module Functions

      * 17.4.6. Exception classes

    * 17.5. "subprocess" — Gestion de sous-processus

      * 17.5.1. Utiliser le module "subprocess"

        * 17.5.1.1. Arguments fréquemment utilisés

        * 17.5.1.2. Constructeur de *Popen*

        * 17.5.1.3. Exceptions

      * 17.5.2. Considérations de sécurité

      * 17.5.3. Objets *Popen*

      * 17.5.4. Utilitaires *Popen* pour Windows

        * 17.5.4.1. Constantes

      * 17.5.5. Ancienne interface (*API*) haut-niveau

      * 17.5.6. Remplacer les fonctions plus anciennes par le module
        "subprocess"

        * 17.5.6.1. Remplacement des *backquotes* des *shells /bin/sh*

        * 17.5.6.2. Remplacer les *pipes* du *shell*

        * 17.5.6.3. Remplacer "os.system()"

        * 17.5.6.4. Remplacer les fonctions de la famille "os.spawn"

        * 17.5.6.5. Remplacer "os.popen()", "os.popen2()",
          "os.popen3()"

        * 17.5.6.6. Remplacer les fonctions du module "popen2"

      * 17.5.7. Remplacement des fonctions originales d'invocation du
        *shell*

      * 17.5.8. Notes

        * 17.5.8.1. Convertir une séquence d'arguments vers une chaîne
          de caractères sous Windows

    * 17.6. "sched" --- Event scheduler

      * 17.6.1. Scheduler Objects

    * 17.7. "queue" — File synchronisée

      * 17.7.1. Objets "Queue"

    * 17.8. "dummy_threading" --- Module de substitution au module
      "threading"

    * 17.9. "_thread" — API bas niveau de gestion de fils d'exécution

    * 17.10. "_dummy_thread" --- Module de substitution pour le module
      "_thread"

  * 18. Communication et réseau entre processus

    * 18.1. "socket" --- Low-level networking interface

      * 18.1.1. Socket families

      * 18.1.2. Module contents

        * 18.1.2.1. Exceptions

        * 18.1.2.2. Constantes

        * 18.1.2.3. Fonctions

          * 18.1.2.3.1. Creating sockets

          * 18.1.2.3.2. Autres fonctions

      * 18.1.3. Socket Objects

      * 18.1.4. Notes on socket timeouts

        * 18.1.4.1. Timeouts and the "connect" method

        * 18.1.4.2. Timeouts and the "accept" method

      * 18.1.5. Exemple

    * 18.2. "ssl" — Emballage TLS/SSL pour les objets connecteurs

      * 18.2.1. Fonctions, constantes et exceptions

        * 18.2.1.1. Création de connecteurs

        * 18.2.1.2. Création de contexte

        * 18.2.1.3. Random generation

        * 18.2.1.4. Certificate handling

        * 18.2.1.5. Constantes

      * 18.2.2. SSL Sockets

      * 18.2.3. SSL Contexts

      * 18.2.4. Certificates

        * 18.2.4.1. Certificate chains

        * 18.2.4.2. CA certificates

        * 18.2.4.3. Combined key and certificate

        * 18.2.4.4. Self-signed certificates

      * 18.2.5. Exemples

        * 18.2.5.1. Testing for SSL support

        * 18.2.5.2. Client-side operation

        * 18.2.5.3. Server-side operation

      * 18.2.6. Notes on non-blocking sockets

      * 18.2.7. Memory BIO Support

      * 18.2.8. SSL session

      * 18.2.9. Security considerations

        * 18.2.9.1. Best defaults

        * 18.2.9.2. Manual settings

          * 18.2.9.2.1. Verifying certificates

          * 18.2.9.2.2. Protocol versions

          * 18.2.9.2.3. Cipher selection

        * 18.2.9.3. Multi-processing

      * 18.2.10. LibreSSL support

    * 18.3. "select" --- Waiting for I/O completion

      * 18.3.1. "/dev/poll" Polling Objects

      * 18.3.2. Edge and Level Trigger Polling (epoll) Objects

      * 18.3.3. Polling Objects

      * 18.3.4. Kqueue Objects

      * 18.3.5. Kevent Objects

    * 18.4. "selectors" --- High-level I/O multiplexing

      * 18.4.1. Introduction

      * 18.4.2. Classes

      * 18.4.3. Exemples

    * 18.5. "asyncio" — Entrées/Sorties asynchrone, boucle
      d’évènements, coroutines et tâches

      * 18.5.1. Base Event Loop

        * 18.5.1.1. Exécuter une boucle d'évènements

        * 18.5.1.2. Appels

        * 18.5.1.3. Appels différés

        * 18.5.1.4. Futurs

        * 18.5.1.5. Tâches

        * 18.5.1.6. Créer des connections

        * 18.5.1.7. Attendre des connections

        * 18.5.1.8. Surveiller des descripteurs de fichiers

        * 18.5.1.9. Opérations bas niveau sur les *socket*

        * 18.5.1.10. Résout le nom d'hôte

        * 18.5.1.11. Connect pipes

        * 18.5.1.12. Signaux UNIX

        * 18.5.1.13. Exécuteur

        * 18.5.1.14. API de gestion d'erreur

        * 18.5.1.15. Mode débogage

        * 18.5.1.16. Serveur

        * 18.5.1.17. Handle

        * 18.5.1.18. Exemples de boucles d'évènements

          * 18.5.1.18.1. "Hello World" avec "call_soon()"

          * 18.5.1.18.2. Afficher la date actuelle avec "call_later()"

          * 18.5.1.18.3. Watch a file descriptor for read events

          * 18.5.1.18.4. Définit les gestionnaires de signaux pour
            *SIGINT* et *SIGTERM*

      * 18.5.2. Boucles d'évènements

        * 18.5.2.1. Fonctions des boucles d'évènements

        * 18.5.2.2. Boucles d'évènements disponibles

        * 18.5.2.3. Support des plateformes

          * 18.5.2.3.1. Windows

          * 18.5.2.3.2. Mac OS X

        * 18.5.2.4. Event loop policies and the default policy

        * 18.5.2.5. Event loop policy interface

        * 18.5.2.6. Access to the global loop policy

        * 18.5.2.7. Customizing the event loop policy

      * 18.5.3. Tâches et coroutines

        * 18.5.3.1. Coroutines

          * 18.5.3.1.1. Exemple : Coroutine "Hello World"

          * 18.5.3.1.2. Exemple : Coroutine affichant la date actuelle

          * 18.5.3.1.3. Exemple : Chaîner des coroutines

        * 18.5.3.2. InvalidStateError

        * 18.5.3.3. TimeoutError

        * 18.5.3.4. Future

          * 18.5.3.4.1. Exemple : Futur avec "run_until_complete()"

          * 18.5.3.4.2. Exemple : Futur avec "run_forever()"

        * 18.5.3.5. Task

          * 18.5.3.5.1. Exemple : Exécution parallèle de tâches

        * 18.5.3.6. Task functions

      * 18.5.4. Transports et protocoles (APi basée sur des fonctions
        de rappel)

        * 18.5.4.1. Transports

          * 18.5.4.1.1. BaseTransport

          * 18.5.4.1.2. ReadTransport

          * 18.5.4.1.3. WriteTransport

          * 18.5.4.1.4. DatagramTransport

          * 18.5.4.1.5. BaseSubprocessTransport

        * 18.5.4.2. Protocols

          * 18.5.4.2.1. Protocol classes

          * 18.5.4.2.2. Connection callbacks

          * 18.5.4.2.3. Streaming protocols

          * 18.5.4.2.4. Protocoles de datagrammes

          * 18.5.4.2.5. Flow control callbacks

          * 18.5.4.2.6. Coroutines et protocoles

        * 18.5.4.3. Exemples de protocole

          * 18.5.4.3.1. Protocole "*echo client*" en TCP

          * 18.5.4.3.2. Protocole "*echo serveur*" en TCP

          * 18.5.4.3.3. Protocole "*echo client*" en UDP

          * 18.5.4.3.4. Protocole "*echo serveur*" en UDP

          * 18.5.4.3.5. Register an open socket to wait for data using
            a protocol

      * 18.5.5. Streams (coroutine based API)

        * 18.5.5.1. Stream functions

        * 18.5.5.2. StreamReader

        * 18.5.5.3. StreamWriter

        * 18.5.5.4. StreamReaderProtocol

        * 18.5.5.5. IncompleteReadError

        * 18.5.5.6. LimitOverrunError

        * 18.5.5.7. Stream examples

          * 18.5.5.7.1. TCP echo client using streams

          * 18.5.5.7.2. TCP echo server using streams

          * 18.5.5.7.3. Récupère les en-têtes HTTP

          * 18.5.5.7.4. Register an open socket to wait for data using
            streams

      * 18.5.6. Subprocess

        * 18.5.6.1. Boucle d'évènements Windows

        * 18.5.6.2. Créer un processus fils : API de haut niveau
          utilisant "Process"

        * 18.5.6.3. Create a subprocess: low-level API using
          subprocess.Popen

        * 18.5.6.4. Constantes

        * 18.5.6.5. Process

        * 18.5.6.6. Processus fils et fils d'exécution

        * 18.5.6.7. Subprocess examples

          * 18.5.6.7.1. Subprocess using transport and protocol

          * 18.5.6.7.2. Subprocess using streams

      * 18.5.7. Primitives de synchronisation

        * 18.5.7.1. Locks

          * 18.5.7.1.1. Lock

          * 18.5.7.1.2. Event

          * 18.5.7.1.3. Condition

        * 18.5.7.2. Sémaphores

          * 18.5.7.2.1. Sémaphore

          * 18.5.7.2.2. BoundedSemaphore

      * 18.5.8. Queues

        * 18.5.8.1. Queue

        * 18.5.8.2. PriorityQueue

        * 18.5.8.3. LifoQueue

          * 18.5.8.3.1. Exceptions

      * 18.5.9. Programmer avec *asyncio*

        * 18.5.9.1. Mode de débogage d'*asyncio*

        * 18.5.9.2. Annulation

        * 18.5.9.3. Concourance et *multithreading*

        * 18.5.9.4. Gérer les fonctions bloquantes correctement

        * 18.5.9.5. Journalisation

        * 18.5.9.6. Détecte les coroutines qui ne sont jamais
          exécutées

        * 18.5.9.7. Detect exceptions never consumed

        * 18.5.9.8. Chaîner les coroutines correctement

        * 18.5.9.9. Pending task destroyed

        * 18.5.9.10. Close transports and event loops

    * 18.6. "asyncore" — Gestionnaire de socket asynchrone

      * 18.6.1. Exemple de client HTTP basique avec "asyncore"

      * 18.6.2. Serveur *echo* basique avec "asyncore"

    * 18.7. "asynchat" --- Gestionnaire d'interfaces de connexion
      (*socket*) commande/réponse asynchrones

      * 18.7.1. Exemple *asynchat*

    * 18.8. "signal" --- Set handlers for asynchronous events

      * 18.8.1. General rules

        * 18.8.1.1. Execution of Python signal handlers

        * 18.8.1.2. Signals and threads

      * 18.8.2. Module contents

      * 18.8.3. Exemple

    * 18.9. "mmap" --- Memory-mapped file support

  * 19. Traitement des données provenant d'Internet

    * 19.1. "email" — Un paquet de gestion des e-mails et MIME

      * 19.1.1. "email.message": Representing an email message

      * 19.1.2. "email.parser" : Analyser des e-mails

        * 19.1.2.1. API *FeedParser*

        * 19.1.2.2. API de *Parser*

        * 19.1.2.3. Notes complémentaires

      * 19.1.3. "email.generator": Generating MIME documents

      * 19.1.4. "email.policy": Policy Objects

      * 19.1.5. "email.errors": Exception and Defect classes

      * 19.1.6. "email.headerregistry": Custom Header Objects

      * 19.1.7. "email.contentmanager": Managing MIME Content

        * 19.1.7.1. Content Manager Instances

      * 19.1.8. "email": Exemples

      * 19.1.9. "email.message.Message": Representing an email message
        using the "compat32" API

      * 19.1.10. "email.mime": Creating email and MIME objects from
        scratch

      * 19.1.11. "email.header": Internationalized headers

      * 19.1.12. "email.charset": Representing character sets

      * 19.1.13. "email.encoders" : Encodeurs

      * 19.1.14. "email.utils": Miscellaneous utilities

      * 19.1.15. "email.iterators": Itérateurs

    * 19.2. "json" — Encodage et décodage JSON

      * 19.2.1. Utilisation basique

      * 19.2.2. Encodeurs et décodeurs

      * 19.2.3. Exceptions

      * 19.2.4. Conformité au standard et Interopérabilité

        * 19.2.4.1. Encodage des caractères

        * 19.2.4.2. Valeurs numériques infinies et NaN

        * 19.2.4.3. Noms répétés au sein d'un objet

        * 19.2.4.4. Valeurs de plus haut niveau autres qu'objets ou
          tableaux

        * 19.2.4.5. Limitations de l'implémentation

      * 19.2.5. Interface en ligne de commande

        * 19.2.5.1. Options de la ligne de commande

    * 19.3. "mailcap" — Manipulation de fichiers Mailcap

    * 19.4. "mailbox" — Manipuler les boîtes de courriels dans
      différents formats

      * 19.4.1. Objets "Mailbox"

        * 19.4.1.1. "Maildir"

        * 19.4.1.2. "mbox"

        * 19.4.1.3. "MH"

        * 19.4.1.4. "Babyl"

        * 19.4.1.5. "MMDF"

      * 19.4.2. "Message" objects

        * 19.4.2.1. "MaildirMessage"

        * 19.4.2.2. "mboxMessage"

        * 19.4.2.3. "MHMessage"

        * 19.4.2.4. "BabylMessage"

        * 19.4.2.5. "MMDFMessage"

      * 19.4.3. Exceptions

      * 19.4.4. Exemples

    * 19.5. "mimetypes" --- Map filenames to MIME types

      * 19.5.1. MimeTypes Objects

    * 19.6. "base64" — Encodages base16, base32, base64 et base85

    * 19.7. "binhex" — Encode et décode les fichiers *binhex4*

      * 19.7.1. Notes

    * 19.8. "binascii" --- Conversion entre binaire et ASCII

    * 19.9. "quopri" — Encode et décode des données *MIME quoted-
      printable*

    * 19.10. "uu" — Encode et décode les fichiers *uuencode*

  * 20. Outils de traitement de balises structurées

    * 20.1. "html" — Support du HyperText Markup Language

    * 20.2. "html.parser" --- Simple HTML and XHTML parser

      * 20.2.1. Example HTML Parser Application

      * 20.2.2. "HTMLParser" Methods

      * 20.2.3. Exemples

    * 20.3. "html.entities" — Définitions des entités HTML générales

    * 20.4. Modules de traitement XML

      * 20.4.1. Vulnérabilités XML

      * 20.4.2. Les paquets "defusedxml" et "defusedexpat"

    * 20.5. "xml.etree.ElementTree" --- The ElementTree XML API

      * 20.5.1. Tutoriel

        * 20.5.1.1. XML tree and elements

        * 20.5.1.2. Parsing XML

        * 20.5.1.3. Pull API for non-blocking parsing

        * 20.5.1.4. Finding interesting elements

        * 20.5.1.5. Modifying an XML File

        * 20.5.1.6. Building XML documents

        * 20.5.1.7. Parsing XML with Namespaces

        * 20.5.1.8. Additional resources

      * 20.5.2. XPath support

        * 20.5.2.1. Exemple

        * 20.5.2.2. Supported XPath syntax

      * 20.5.3. Référence

        * 20.5.3.1. Fonctions

        * 20.5.3.2. Objets Elements

        * 20.5.3.3. ElementTree Objects

        * 20.5.3.4. QName Objects

        * 20.5.3.5. TreeBuilder Objects

        * 20.5.3.6. XMLParser Objects

        * 20.5.3.7. XMLPullParser Objects

        * 20.5.3.8. Exceptions

    * 20.6. "xml.dom" — L'API Document Object Model

      * 20.6.1. Contenu du module

      * 20.6.2. Objets dans le DOM

        * 20.6.2.1. Objets DOMImplementation

        * 20.6.2.2. Objets nœuds

        * 20.6.2.3. Objet NodeList

        * 20.6.2.4. Objets DocumnentType

        * 20.6.2.5. Objets Document

        * 20.6.2.6. Objets Elements

        * 20.6.2.7. Objets Attr

        * 20.6.2.8. Objets NameNodeMap

        * 20.6.2.9. Objets Comment

        * 20.6.2.10. Objets Text et CDATASection

        * 20.6.2.11. Objets ProcessingInstruction

        * 20.6.2.12. Exceptions

      * 20.6.3. Conformité

        * 20.6.3.1. Correspondance des types

        * 20.6.3.2. Méthodes d'accès

    * 20.7. "xml.dom.minidom" --- Minimal DOM implementation

      * 20.7.1. DOM Objects

      * 20.7.2. DOM Example

      * 20.7.3. minidom and the DOM standard

    * 20.8. "xml.dom.pulldom" --- Support for building partial DOM
      trees

      * 20.8.1. DOMEventStream Objects

    * 20.9. "xml.sax" — Prise en charge des analyseurs SAX2

      * 20.9.1. Les objets SAXException

    * 20.10. "xml.sax.handler" --- Base classes for SAX handlers

      * 20.10.1. ContentHandler Objects

      * 20.10.2. DTDHandler Objects

      * 20.10.3. EntityResolver Objects

      * 20.10.4. ErrorHandler Objects

    * 20.11. "xml.sax.saxutils" — Utilitaires SAX

    * 20.12. "xml.sax.xmlreader" --- Interface for XML parsers

      * 20.12.1. XMLReader Objects

      * 20.12.2. IncrementalParser Objects

      * 20.12.3. Locator Objects

      * 20.12.4. InputSource Objects

      * 20.12.5. The "Attributes" Interface

      * 20.12.6. The "AttributesNS" Interface

    * 20.13. "xml.parsers.expat" --- Fast XML parsing using Expat

      * 20.13.1. XMLParser Objects

      * 20.13.2. ExpatError Exceptions

      * 20.13.3. Exemple

      * 20.13.4. Content Model Descriptions

      * 20.13.5. Expat error constants

  * 21. Gestion des protocoles internet

    * 21.1. "webbrowser" --- Convenient Web-browser controller

      * 21.1.1. Browser Controller Objects

    * 21.2. "cgi" --- Common Gateway Interface support

      * 21.2.1. Introduction

      * 21.2.2. Using the cgi module

      * 21.2.3. Higher Level Interface

      * 21.2.4. Fonctions

      * 21.2.5. Caring about security

      * 21.2.6. Installing your CGI script on a Unix system

      * 21.2.7. Testing your CGI script

      * 21.2.8. Debugging CGI scripts

      * 21.2.9. Common problems and solutions

    * 21.3. "cgitb" — Gestionnaire d'exceptions pour les scripts CGI

    * 21.4. "wsgiref" — Outils et implémentation de référence de WSGI

      * 21.4.1. "wsgiref.util" — outils pour les environnements WSGI

      * 21.4.2. "wsgiref.headers" -- WSGI response header tools

      * 21.4.3. "wsgiref.simple_server" -- a simple WSGI HTTP server

      * 21.4.4. "wsgiref.validate" --- WSGI conformance checker

      * 21.4.5. "wsgiref.handlers" -- server/gateway base classes

      * 21.4.6. Exemples

    * 21.5. "urllib" — Modules de gestion des URLs

    * 21.6. "urllib.request" --- Extensible library for opening URLs

      * 21.6.1. Request Objects

      * 21.6.2. OpenerDirector Objects

      * 21.6.3. BaseHandler Objects

      * 21.6.4. HTTPRedirectHandler Objects

      * 21.6.5. HTTPCookieProcessor Objects

      * 21.6.6. ProxyHandler Objects

      * 21.6.7. HTTPPasswordMgr Objects

      * 21.6.8. HTTPPasswordMgrWithPriorAuth Objects

      * 21.6.9. AbstractBasicAuthHandler Objects

      * 21.6.10. HTTPBasicAuthHandler Objects

      * 21.6.11. ProxyBasicAuthHandler Objects

      * 21.6.12. AbstractDigestAuthHandler Objects

      * 21.6.13. HTTPDigestAuthHandler Objects

      * 21.6.14. ProxyDigestAuthHandler Objects

      * 21.6.15. HTTPHandler Objects

      * 21.6.16. HTTPSHandler Objects

      * 21.6.17. FileHandler Objects

      * 21.6.18. DataHandler Objects

      * 21.6.19. FTPHandler Objects

      * 21.6.20. CacheFTPHandler Objects

      * 21.6.21. UnknownHandler Objects

      * 21.6.22. HTTPErrorProcessor Objects

      * 21.6.23. Exemples

      * 21.6.24. Legacy interface

      * 21.6.25. "urllib.request" Restrictions

    * 21.7. "urllib.response" --- Response classes used by urllib

    * 21.8. "urllib.parse" --- Parse URLs into components

      * 21.8.1. URL Parsing

      * 21.8.2. Parsing ASCII Encoded Bytes

      * 21.8.3. Structured Parse Results

      * 21.8.4. URL Quoting

    * 21.9. "urllib.error" --- Classes d'exceptions levées par
      *urllib.request*

    * 21.10. "urllib.robotparser" — Analyseur de fichiers *robots.txt*

    * 21.11. "http" — modules HTTP

      * 21.11.1. Codes d'état HTTP

    * 21.12. "http.client" --- HTTP protocol client

      * 21.12.1. HTTPConnection Objects

      * 21.12.2. HTTPResponse Objects

      * 21.12.3. Exemples

      * 21.12.4. HTTPMessage Objects

    * 21.13. "ftplib" --- FTP protocol client

      * 21.13.1. FTP Objects

      * 21.13.2. FTP_TLS Objects

    * 21.14. "poplib" --- POP3 protocol client

      * 21.14.1. POP3 Objects

      * 21.14.2. POP3 Example

    * 21.15. "imaplib" --- IMAP4 protocol client

      * 21.15.1. IMAP4 Objects

      * 21.15.2. IMAP4 Example

    * 21.16. "nntplib" --- NNTP protocol client

      * 21.16.1. NNTP Objects

        * 21.16.1.1. Attributes

        * 21.16.1.2. Méthodes

      * 21.16.2. Fonctions utilitaires

    * 21.17. "smtplib" --- SMTP protocol client

      * 21.17.1. SMTP Objects

      * 21.17.2. SMTP Example

    * 21.18. "smtpd" --- SMTP Server

      * 21.18.1. SMTPServer Objects

      * 21.18.2. DebuggingServer Objects

      * 21.18.3. PureProxy Objects

      * 21.18.4. MailmanProxy Objects

      * 21.18.5. SMTPChannel Objects

    * 21.19. "telnetlib" --- Telnet client

      * 21.19.1. Telnet Objects

      * 21.19.2. Telnet Example

    * 21.20. "uuid" --- UUID objects according to **RFC 4122**

      * 21.20.1. Exemple

    * 21.21. "socketserver" --- A framework for network servers

      * 21.21.1. Server Creation Notes

      * 21.21.2. Objets Serveur

      * 21.21.3. Request Handler Objects

      * 21.21.4. Exemples

        * 21.21.4.1. "socketserver.TCPServer" Example

        * 21.21.4.2. "socketserver.UDPServer" Example

        * 21.21.4.3. Asynchronous Mixins

    * 21.22. "http.server" --- HTTP servers

    * 21.23. "http.cookies" — gestion d'état pour HTTP

      * 21.23.1. Objets *Cookie*

      * 21.23.2. Objets *Morsel*

      * 21.23.3. Exemple

    * 21.24. "http.cookiejar" --- Cookie handling for HTTP clients

      * 21.24.1. CookieJar and FileCookieJar Objects

      * 21.24.2. FileCookieJar subclasses and co-operation with web
        browsers

      * 21.24.3. CookiePolicy Objects

      * 21.24.4. DefaultCookiePolicy Objects

      * 21.24.5. Objets *Cookie*

      * 21.24.6. Exemples

    * 21.25. "xmlrpc" — Modules Serveur et Client XMLRPC

    * 21.26. "xmlrpc.client" --- XML-RPC client access

      * 21.26.1. ServerProxy Objects

      * 21.26.2. Objets DateTime

      * 21.26.3. Binary Objects

      * 21.26.4. Fault Objects

      * 21.26.5. ProtocolError Objects

      * 21.26.6. MultiCall Objects

      * 21.26.7. Convenience Functions

      * 21.26.8. Example of Client Usage

      * 21.26.9. Example of Client and Server Usage

    * 21.27. "xmlrpc.server" --- Basic XML-RPC servers

      * 21.27.1. SimpleXMLRPCServer Objects

        * 21.27.1.1. SimpleXMLRPCServer Example

      * 21.27.2. CGIXMLRPCRequestHandler

      * 21.27.3. Documenting XMLRPC server

      * 21.27.4. DocXMLRPCServer Objects

      * 21.27.5. DocCGIXMLRPCRequestHandler

    * 21.28. "ipaddress" --- IPv4/IPv6 manipulation library

      * 21.28.1. Convenience factory functions

      * 21.28.2. IP Addresses

        * 21.28.2.1. Address objects

        * 21.28.2.2. Conversion to Strings and Integers

        * 21.28.2.3. Opérateurs

          * 21.28.2.3.1. Comparison operators

          * 21.28.2.3.2. Arithmetic operators

      * 21.28.3. IP Network definitions

        * 21.28.3.1. Prefix, net mask and host mask

        * 21.28.3.2. Network objects

        * 21.28.3.3. Opérateurs

          * 21.28.3.3.1. Logical operators

          * 21.28.3.3.2. Itération

          * 21.28.3.3.3. Networks as containers of addresses

      * 21.28.4. Interface objects

        * 21.28.4.1. Opérateurs

          * 21.28.4.1.1. Logical operators

      * 21.28.5. Other Module Level Functions

      * 21.28.6. Custom Exceptions

  * 22. Services multimédia

    * 22.1. "audioloop" — Manipulation de données audio brutes

    * 22.2. "aifc" — Lis et écrit dans les fichiers AIFF et AIFC

    * 22.3. "sunau" --- Read and write Sun AU files

      * 22.3.1. AU_read Objects

      * 22.3.2. AU_write Objects

    * 22.4. "wave" --- Lecture et écriture des fichiers WAV

      * 22.4.1. Objets Wave_read

      * 22.4.2. Objets Wave_write

    * 22.5. "chunk" --- Read IFF chunked data

    * 22.6. "colorsys" — Conversions entre les systèmes de couleurs

    * 22.7. "imghdr" --- Determine the type of an image

    * 22.8. "sndhdr" — Détermine le type d'un fichier audio

    * 22.9. "ossaudiodev" --- Access to OSS-compatible audio devices

      * 22.9.1. Audio Device Objects

      * 22.9.2. Mixer Device Objects

  * 23. Internationalisation

    * 23.1. "gettext" — Services d'internationalisation multilingue

      * 23.1.1. API GNU **gettext**

      * 23.1.2. API basée sur les classes

        * 23.1.2.1. La classe "NullTranslations"

        * 23.1.2.2. La classe "GNUTranslations"

        * 23.1.2.3. Support du catalogue de message de Solaris

        * 23.1.2.4. Le constructeur *Catalog*

      * 23.1.3. Internationaliser vos programmes et modules

        * 23.1.3.1. Localiser votre module

        * 23.1.3.2. Localiser votre application

        * 23.1.3.3. Changer de langue à la volée

        * 23.1.3.4. Traductions différées

      * 23.1.4. Remerciements

    * 23.2. "locale" --- Services d'internationalisation

      * 23.2.1. Contexte, détails, conseils, astuces et mises en garde

      * 23.2.2. Pour les auteurs d'extensions et les programmes qui
        intègrent Python

      * 23.2.3. Accéder aux catalogues de messages

  * 24. *Frameworks* d'applications

    * 24.1. "turtle" — Tortue graphique

      * 24.1.1. Introduction

      * 24.1.2. Résumé des méthodes de *Turtle* et *Screen*

        * 24.1.2.1. Les méthodes du module *Turtle*

        * 24.1.2.2. Methods of TurtleScreen/Screen

      * 24.1.3. Methods of RawTurtle/Turtle and corresponding
        functions

        * 24.1.3.1. Les mouvements dans le module *Turtle*

        * 24.1.3.2. Tell Turtle's state

        * 24.1.3.3. Settings for measurement

        * 24.1.3.4. Pen control

          * 24.1.3.4.1. Drawing state

          * 24.1.3.4.2. Color control

          * 24.1.3.4.3. Filling

          * 24.1.3.4.4. More drawing control

        * 24.1.3.5. Turtle state

          * 24.1.3.5.1. Visibility

          * 24.1.3.5.2. Appearance

        * 24.1.3.6. Using events

        * 24.1.3.7. Special Turtle methods

        * 24.1.3.8. Compound shapes

      * 24.1.4. Methods of TurtleScreen/Screen and corresponding
        functions

        * 24.1.4.1. Window control

        * 24.1.4.2. Animation control

        * 24.1.4.3. Using screen events

        * 24.1.4.4. Input methods

        * 24.1.4.5. Settings and special methods

        * 24.1.4.6. Methods specific to Screen, not inherited from
          TurtleScreen

      * 24.1.5. Public classes

      * 24.1.6. Help and configuration

        * 24.1.6.1. How to use help

        * 24.1.6.2. Translation of docstrings into different languages

        * 24.1.6.3. How to configure Screen and Turtles

      * 24.1.7. "turtledemo" --- Demo scripts

      * 24.1.8. Changes since Python 2.6

      * 24.1.9. Changes since Python 3.0

    * 24.2. "cmd" — Interpréteurs en ligne de commande.

      * 24.2.1. Objets Cmd

      * 24.2.2. Exemple

    * 24.3. "shlex" --- Simple lexical analysis

      * 24.3.1. shlex Objects

      * 24.3.2. Parsing Rules

      * 24.3.3. Improved Compatibility with Shells

  * 25. Interfaces Utilisateur Graphiques avec Tk

    * 25.1. "tkinter" — Interface Python pour Tcl/Tk

      * 25.1.1. Modules Tkinter

      * 25.1.2. Guide de survie Tkinter

        * 25.1.2.1. Mode d'emploi

        * 25.1.2.2. Un simple programme *Hello World*

      * 25.1.3. Un (très) rapide aperçu de Tcl/Tk

      * 25.1.4. Correspondance entre *Basic Tk* et *Tkinter*

      * 25.1.5. Relations entre Tk et Tkinter

      * 25.1.6. Guide pratique

        * 25.1.6.1. Définition des options

        * 25.1.6.2. L'empaqueteur

        * 25.1.6.3. Options de l'empaqueteur

        * 25.1.6.4. Association des variables de l'objet graphique

        * 25.1.6.5. Le gestionnaire de fenêtres

        * 25.1.6.6. Types de données des options Tk

        * 25.1.6.7. Liaisons et événements

        * 25.1.6.8. Le paramètre index

        * 25.1.6.9. Images

      * 25.1.7. Gestionnaires de fichiers

    * 25.2. "tkinter.ttk" --- Tk themed widgets

      * 25.2.1. Using Ttk

      * 25.2.2. Ttk Widgets

      * 25.2.3. Widget

        * 25.2.3.1. Standard Options

        * 25.2.3.2. Scrollable Widget Options

        * 25.2.3.3. Label Options

        * 25.2.3.4. Compatibility Options

        * 25.2.3.5. Widget States

        * 25.2.3.6. ttk.Widget

      * 25.2.4. Combobox

        * 25.2.4.1. Options

        * 25.2.4.2. Virtual events

        * 25.2.4.3. ttk.Combobox

      * 25.2.5. Notebook

        * 25.2.5.1. Options

        * 25.2.5.2. Tab Options

        * 25.2.5.3. Tab Identifiers

        * 25.2.5.4. Virtual Events

        * 25.2.5.5. ttk.Notebook

      * 25.2.6. Progressbar

        * 25.2.6.1. Options

        * 25.2.6.2. ttk.Progressbar

      * 25.2.7. Separator

        * 25.2.7.1. Options

      * 25.2.8. Sizegrip

        * 25.2.8.1. Platform-specific notes

        * 25.2.8.2. Bugs

      * 25.2.9. Treeview

        * 25.2.9.1. Options

        * 25.2.9.2. Item Options

        * 25.2.9.3. Tag Options

        * 25.2.9.4. Column Identifiers

        * 25.2.9.5. Virtual Events

        * 25.2.9.6. ttk.Treeview

      * 25.2.10. Ttk Styling

        * 25.2.10.1. Layouts

    * 25.3. "tkinter.tix" --- Extension widgets for Tk

      * 25.3.1. Using Tix

      * 25.3.2. Tix Widgets

        * 25.3.2.1. Basic Widgets

        * 25.3.2.2. File Selectors

        * 25.3.2.3. Hierarchical ListBox

        * 25.3.2.4. Tabular ListBox

        * 25.3.2.5. Manager Widgets

        * 25.3.2.6. Image Types

        * 25.3.2.7. Miscellaneous Widgets

        * 25.3.2.8. Form Geometry Manager

      * 25.3.3. Tix Commands

    * 25.4. "tkinter.scrolledtext" — Gadget texte avec barre de
      défilement

    * 25.5. *IDLE*

      * 25.5.1. Menus

        * 25.5.1.1. Menu *File* (Console et Éditeur)

        * 25.5.1.2. Menu *Edit* (console et éditeur)

        * 25.5.1.3. Menu *Format* (fenêtre d'édition uniquement)

        * 25.5.1.4. Menu *Run* (fenêtre d'édition uniquement)

        * 25.5.1.5. Menu Shell (fenêtre de console uniquement)

        * 25.5.1.6. Menu *Debug* (fenêtre de console uniquement)

        * 25.5.1.7. Menu *Options* (console et éditeur)

        * 25.5.1.8. Menu *Windows* (console et éditeur)

        * 25.5.1.9. Menu *Help* (console et éditeur)

        * 25.5.1.10. Menus Contextuels

      * 25.5.2. Édition et navigation

        * 25.5.2.1. Editor windows

        * 25.5.2.2. Key bindings

        * 25.5.2.3. Indentation automatique

        * 25.5.2.4. Complétions

        * 25.5.2.5. Info-bulles

        * 25.5.2.6. Fenêtre de console Python

        * 25.5.2.7. Coloration du texte

      * 25.5.3. Démarrage et exécution du code

        * 25.5.3.1. Utilisation de la ligne de commande

        * 25.5.3.2. Échec au démarrage

        * 25.5.3.3. Running user code

        * 25.5.3.4. User output in Shell

        * 25.5.3.5. Développer des applications *tkinter*

        * 25.5.3.6. Exécution sans sous-processus

      * 25.5.4. Aide et préférences

        * 25.5.4.1. Help sources

        * 25.5.4.2. Modifier les préférences

        * 25.5.4.3. IDLE on macOS

        * 25.5.4.4. Extensions

    * 25.6. Autres paquets d'interface graphique utilisateur

  * 26. Outils de développement

    * 26.1. "typing" --- Support for type hints

      * 26.1.1. Type aliases

      * 26.1.2. NewType

      * 26.1.3. Callable

      * 26.1.4. Generics

      * 26.1.5. User-defined generic types

      * 26.1.6. The "Any" type

      * 26.1.7. Classes, functions, and decorators

    * 26.2. "pydoc" — Générateur de documentation et système d’aide en
      ligne

    * 26.3. "doctest" --- Test interactive Python examples

      * 26.3.1. Simple Usage: Checking Examples in Docstrings

      * 26.3.2. Simple Usage: Checking Examples in a Text File

      * 26.3.3. How It Works

        * 26.3.3.1. Which Docstrings Are Examined?

        * 26.3.3.2. How are Docstring Examples Recognized?

        * 26.3.3.3. What's the Execution Context?

        * 26.3.3.4. What About Exceptions?

        * 26.3.3.5. Option Flags

        * 26.3.3.6. Directives

        * 26.3.3.7. Avertissements

      * 26.3.4. Basic API

      * 26.3.5. Unittest API

      * 26.3.6. Advanced API

        * 26.3.6.1. DocTest Objects

        * 26.3.6.2. Example Objects

        * 26.3.6.3. DocTestFinder objects

        * 26.3.6.4. DocTestParser objects

        * 26.3.6.5. DocTestRunner objects

        * 26.3.6.6. OutputChecker objects

      * 26.3.7. Debugging

      * 26.3.8. Soapbox

    * 26.4. "unittest" — *Framework* de tests unitaires

      * 26.4.1. Exemple basique

      * 26.4.2. Interface en ligne de commande

        * 26.4.2.1. Options de la ligne de commande

      * 26.4.3. Découverte des tests

      * 26.4.4. Organiser le code de test

      * 26.4.5. Réutilisation d'ancien code de test

      * 26.4.6. Ignorer des tests et des erreurs prévisibles

      * 26.4.7. Distinguer les itérations de test à l'aide de sous-
        tests

      * 26.4.8. Classes et fonctions

        * 26.4.8.1. Scénarios de tests

          * 26.4.8.1.1. Alias obsolètes

        * 26.4.8.2. Regroupement des tests

        * 26.4.8.3. Chargement et exécution des tests

          * 26.4.8.3.1. Protocole de chargement des tests (*load_tests
            Protocol*)

      * 26.4.9. Classes et modules d'aménagements des tests

        * 26.4.9.1. Classes de mise en place (*setUpClass*) et de
          démantèlement des tests (*tearDownClass*)

        * 26.4.9.2. Module de mise en place (*setUpModule*) et de
          démantèlement des tests (*tearDownModule*)

      * 26.4.10. Traitement des signaux

    * 26.5. "unittest.mock" — Bibliothèque d'objets simulacres

      * 26.5.1. Guide rapide

      * 26.5.2. La classe *Mock*

        * 26.5.2.1. Calling

        * 26.5.2.2. Deleting Attributes

        * 26.5.2.3. Mock names and the name attribute

        * 26.5.2.4. Attaching Mocks as Attributes

      * 26.5.3. The patchers

        * 26.5.3.1. patch

        * 26.5.3.2. patch.object

        * 26.5.3.3. patch.dict

        * 26.5.3.4. patch.multiple

        * 26.5.3.5. patch methods: start and stop

        * 26.5.3.6. patch builtins

        * 26.5.3.7. TEST_PREFIX

        * 26.5.3.8. Nesting Patch Decorators

        * 26.5.3.9. Where to patch

        * 26.5.3.10. Patching Descriptors and Proxy Objects

      * 26.5.4. MagicMock and magic method support

        * 26.5.4.1. Mocking Magic Methods

        * 26.5.4.2. Magic Mock

      * 26.5.5. Helpers

        * 26.5.5.1. sentinel

        * 26.5.5.2. DEFAULT

        * 26.5.5.3. call

        * 26.5.5.4. create_autospec

        * 26.5.5.5. ANY

        * 26.5.5.6. FILTER_DIR

        * 26.5.5.7. mock_open

        * 26.5.5.8. Autospeccing

    * 26.6. "unittest.mock" --- getting started

      * 26.6.1. Utilisation de Mock ou l'art de singer

        * 26.6.1.1. Simulation des méthodes

        * 26.6.1.2. S'assurer de la bonne utilisation d'un objet

        * 26.6.1.3. Simulation des classes

        * 26.6.1.4. Naming your mocks

        * 26.6.1.5. Tracking all Calls

        * 26.6.1.6. Setting Return Values and Attributes

        * 26.6.1.7. Raising exceptions with mocks

        * 26.6.1.8. Side effect functions and iterables

        * 26.6.1.9. Creating a Mock from an Existing Object

      * 26.6.2. Patch Decorators

      * 26.6.3. Further Examples

        * 26.6.3.1. Mocking chained calls

        * 26.6.3.2. Partial mocking

        * 26.6.3.3. Mocking a Generator Method

        * 26.6.3.4. Applying the same patch to every test method

        * 26.6.3.5. Mocking Unbound Methods

        * 26.6.3.6. Checking multiple calls with mock

        * 26.6.3.7. Coping with mutable arguments

        * 26.6.3.8. Nesting Patches

        * 26.6.3.9. Mocking a dictionary with MagicMock

        * 26.6.3.10. Mock subclasses and their attributes

        * 26.6.3.11. Mocking imports with patch.dict

        * 26.6.3.12. Tracking order of calls and less verbose call
          assertions

        * 26.6.3.13. More complex argument matching

    * 26.7. *2to3* — Traduction automatique de code en Python 2 vers
      Python 3

      * 26.7.1. Utilisation de *2to3*

      * 26.7.2. Correcteurs

      * 26.7.3. "lib2to3" — la bibliothèque de *2to3*

    * 26.8. "test" --- Regression tests package for Python

      * 26.8.1. Writing Unit Tests for the "test" package

      * 26.8.2. Running tests using the command-line interface

    * 26.9. "test.support" --- Utilities for the Python test suite

  * 27. Débogueur et instrumentation

    * 27.1. "bdb" — Framework de débogage

    * 27.2. "faulthandler" --- Dump the Python traceback

      * 27.2.1. Dumping the traceback

      * 27.2.2. Fault handler state

      * 27.2.3. Dumping the tracebacks after a timeout

      * 27.2.4. Dumping the traceback on a user signal

      * 27.2.5. Issue with file descriptors

      * 27.2.6. Exemple

    * 27.3. "pdb" — Le débogueur Python

      * 27.3.1. Commande du débogueur

    * 27.4. The Python Profilers

      * 27.4.1. Introduction to the profilers

      * 27.4.2. Instant User's Manual

      * 27.4.3. "profile" and "cProfile" Module Reference

      * 27.4.4. The "Stats" Class

      * 27.4.5. What Is Deterministic Profiling?

      * 27.4.6. Limitations

      * 27.4.7. Calibration

      * 27.4.8. Using a custom timer

    * 27.5. "timeit" — Mesurer le temps d'exécution de fragments de
      code

      * 27.5.1. Exemples simples

      * 27.5.2. Interface Python

      * 27.5.3. Interface en ligne de commande

      * 27.5.4. Exemples

    * 27.6. "trace" --- Trace or track Python statement execution

      * 27.6.1. Utilisation en ligne de commande.

        * 27.6.1.1. Main options

        * 27.6.1.2. Modifiers

        * 27.6.1.3. Filters

      * 27.6.2. Programmatic Interface

    * 27.7. "tracemalloc" --- Trace memory allocations

      * 27.7.1. Exemples

        * 27.7.1.1. Display the top 10

        * 27.7.1.2. Compute differences

        * 27.7.1.3. Get the traceback of a memory block

        * 27.7.1.4. Pretty top

      * 27.7.2. API

        * 27.7.2.1. Fonctions

        * 27.7.2.2. DomainFilter

        * 27.7.2.3. Filter

        * 27.7.2.4. Frame

        * 27.7.2.5. Snapshot

        * 27.7.2.6. Statistic

        * 27.7.2.7. StatisticDiff

        * 27.7.2.8. Trace

        * 27.7.2.9. Traceback

  * 28. Paquets et distribution de paquets logiciels

    * 28.1. "distutils" — Création et installation des modules Python

    * 28.2. "ensurepip" --- Bootstrapping the "pip" installer

      * 28.2.1. Command line interface

      * 28.2.2. Module API

    * 28.3. "venv" — Création d'environnements virtuels

      * 28.3.1. Création d'environnements virtuels

      * 28.3.2. API

      * 28.3.3. Un exemple d'extension de "EnvBuilder"

    * 28.4. "zipapp" --- Manage executable python zip archives

      * 28.4.1. Exemple de base

      * 28.4.2. Interface en ligne de commande

      * 28.4.3. API Python

      * 28.4.4. Exemples

      * 28.4.5. Spécification de l'interprète

      * 28.4.6. Création d'applications autonomes avec *zipapp*

        * 28.4.6.1. Création d'un exécutable Windows

        * 28.4.6.2. Mises en garde

      * 28.4.7. Le format d'archive d'application Zip Python

  * 29. Environnement d'exécution Python

    * 29.1. "sys" — Paramètres et fonctions propres à des systèmes

    * 29.2. "sysconfig" --- Provide access to Python's configuration
      information

      * 29.2.1. Configuration variables

      * 29.2.2. Installation paths

      * 29.2.3. Autres fonctions

      * 29.2.4. Using "sysconfig" as a script

    * 29.3. "builtins" — Objets natifs

    * 29.4. "__main__" — Point d'entrée des scripts

    * 29.5. "warnings" --- Contrôle des alertes

      * 29.5.1. Catégories d'avertissement

      * 29.5.2. Le filtre des avertissements

        * 29.5.2.1. Default Warning Filters

      * 29.5.3. Suppression temporaire des avertissements

      * 29.5.4. Tester les avertissements

      * 29.5.5. Updating Code For New Versions of Python

      * 29.5.6. Fonctions disponibles

      * 29.5.7. Gestionnaires de contexte disponibles

    * 29.6. "contextlib" --- Utilities for "with"-statement contexts

      * 29.6.1. Utilitaires

      * 29.6.2. Exemples et Recettes

        * 29.6.2.1. Gérer un nombre variable de gestionnaires de
          contexte

        * 29.6.2.2. Simplifying support for single optional context
          managers

        * 29.6.2.3. Attraper des exceptions depuis les méthodes
          "__enter__"

        * 29.6.2.4. Nettoyer dans une méthode "__enter__"

        * 29.6.2.5. Remplacer un "try-finally" avec une option
          variable

        * 29.6.2.6. Utiliser un gestionnaire de contexte en tant que
          décorateur de fonction

      * 29.6.3. Gestionnaires de contexte à usage unique,
        réutilisables et réentrants

        * 29.6.3.1. Gestionnaires de contexte réentrants

        * 29.6.3.2. Gestionnaires de contexte réutilisables

    * 29.7. "abc" — Classes de Base Abstraites

    * 29.8. "atexit" — Gestionnaire de fin de programme

      * 29.8.1. Exemple avec "atexit"

    * 29.9. "traceback" --- Print or retrieve a stack traceback

      * 29.9.1. "TracebackException" Objects

      * 29.9.2. "StackSummary" Objects

      * 29.9.3. "FrameSummary" Objects

      * 29.9.4. Traceback Examples

    * 29.10. "__future__" — Définitions des futurs

    * 29.11. "gc" --- Garbage Collector interface

    * 29.12. "inspect" --- Inspect live objects

      * 29.12.1. Types and members

      * 29.12.2. Retrieving source code

      * 29.12.3. Introspecting callables with the Signature object

      * 29.12.4. Classes et fonctions

      * 29.12.5. The interpreter stack

      * 29.12.6. Fetching attributes statically

      * 29.12.7. Current State of Generators and Coroutines

      * 29.12.8. Code Objects Bit Flags

      * 29.12.9. Interface en ligne de commande

    * 29.13. "site" --- Site-specific configuration hook

      * 29.13.1. Readline configuration

      * 29.13.2. Module contents

    * 29.14. "fpectl" --- Floating point exception control

      * 29.14.1. Exemple

      * 29.14.2. Limitations and other considerations

  * 30. Interpréteurs Python personnalisés

    * 30.1. "code" --- Interpreter base classes

      * 30.1.1. Interactive Interpreter Objects

      * 30.1.2. Interactive Console Objects

    * 30.2. "codeop" — Compilation de code Python

  * 31. Importer des modules

    * 31.1. "zipimport" — Importer des modules à partir d'archives Zip

      * 31.1.1. Objets *zimporter*

      * 31.1.2. Exemples

    * 31.2. "pkgutil" --- Package extension utility

    * 31.3. "modulefinder" — Identifie les modules utilisés par un
      script

      * 31.3.1. Exemples d'utilisation de la classe "ModuleFinder"

    * 31.4. "runpy" --- Locating and executing Python modules

    * 31.5. "importlib" --- The implementation of "import"

      * 31.5.1. Introduction

      * 31.5.2. Fonctions

      * 31.5.3. "importlib.abc" -- Abstract base classes related to
        import

      * 31.5.4. "importlib.machinery" -- Importers and path hooks

      * 31.5.5. "importlib.util" -- Utility code for importers

      * 31.5.6. Exemples

        * 31.5.6.1. Importing programmatically

        * 31.5.6.2. Checking if a module can be imported

        * 31.5.6.3. Importing a source file directly

        * 31.5.6.4. Setting up an importer

        * 31.5.6.5. Approximating "importlib.import_module()"

  * 32. Services du Langage Python

    * 32.1. "parser" — Accès aux arbres syntaxiques

      * 32.1.1. Creating ST Objects

      * 32.1.2. Converting ST Objects

      * 32.1.3. Queries on ST Objects

      * 32.1.4. Exceptions and Error Handling

      * 32.1.5. ST Objects

      * 32.1.6. Example: Emulation of "compile()"

    * 32.2. "ast" — Arbres Syntaxiques Abstraits

      * 32.2.1. Les classes nœud

      * 32.2.2. Grammaire abstraite

      * 32.2.3. Outils du module "ast"

    * 32.3. "symtable" --- Access to the compiler's symbol tables

      * 32.3.1. Generating Symbol Tables

      * 32.3.2. Examining Symbol Tables

    * 32.4. "symbol" — Constantes utilisées dans les Arbres
      Syntaxiques

    * 32.5. "token" --- Constantes utilisées avec les arbres d'analyse
      Python (*parse trees*)

    * 32.6. "keyword" — Tester si des chaînes sont des mot-clés Python

    * 32.7. "tokenize" — Analyseur lexical de Python

      * 32.7.1. Analyse Lexicale

      * 32.7.2. Utilisation en ligne de commande.

      * 32.7.3. Exemples

    * 32.8. "tabnanny" — Détection d'indentation ambiguë

    * 32.9. "pyclbr" --- Python class browser support

      * 32.9.1. Objets classes

      * 32.9.2. Objets fonctions

    * 32.10. "py_compile" --- Compile Python source files

    * 32.11. "compileall" --- Byte-compile Python libraries

      * 32.11.1. Command-line use

      * 32.11.2. Public functions

    * 32.12. "dis" – Désassembleur pour le code intermédiaire de
      Python

      * 32.12.1. Analyse du code intermédiaire

      * 32.12.2. Analyse de fonctions

      * 32.12.3. Les instructions du code intermédiaire en Python

      * 32.12.4. Opcode collections

    * 32.13. "pickletools" --- Tools for pickle developers

      * 32.13.1. Utilisation de la ligne de commande

        * 32.13.1.1. Options de la ligne de commande

      * 32.13.2. Programmatic Interface

  * 33. Services divers

    * 33.1. "formatter" --- Generic output formatting

      * 33.1.1. The Formatter Interface

      * 33.1.2. Formatter Implementations

      * 33.1.3. The Writer Interface

      * 33.1.4. Writer Implementations

  * 34. Services spécifiques à MS Windows

    * 34.1. "msilib" --- Read and write Microsoft Installer files

      * 34.1.1. Database Objects

      * 34.1.2. View Objects

      * 34.1.3. Summary Information Objects

      * 34.1.4. Record Objects

      * 34.1.5. Errors

      * 34.1.6. CAB Objects

      * 34.1.7. Directory Objects

      * 34.1.8. Features

      * 34.1.9. GUI classes

      * 34.1.10. Precomputed tables

    * 34.2. "msvcrt" --- Useful routines from the MS VC++ runtime

      * 34.2.1. File Operations

      * 34.2.2. Console I/O

      * 34.2.3. Other Functions

    * 34.3. "winreg" --- Windows registry access

      * 34.3.1. Fonctions

      * 34.3.2. Constantes

        * 34.3.2.1. HKEY_* Constants

        * 34.3.2.2. Access Rights

          * 34.3.2.2.1. 64-bit Specific

        * 34.3.2.3. Value Types

      * 34.3.3. Registry Handle Objects

    * 34.4. "winsound" --- Sound-playing interface for Windows

  * 35. Services spécifiques à Unix

    * 35.1. "posix" — Les appels système POSIX les plus courants

      * 35.1.1. Prise en charge de gros fichiers

      * 35.1.2. Contenu du Module

    * 35.2. "pwd" --- The password database

    * 35.3. "spwd" — La base de données de mots de passe *shadow*

    * 35.4. "grp" --- The group database

    * 35.5. "crypt" --- Function to check Unix passwords

      * 35.5.1. Hashing Methods

      * 35.5.2. Module Attributes

      * 35.5.3. Module Functions

      * 35.5.4. Exemples

    * 35.6. "termios" — Le style POSIX le contrôle TTY

      * 35.6.1. Exemple

    * 35.7. "tty" — Fonctions de gestion du terminal

    * 35.8. "pty" — Outils de manipulation de pseudo-terminaux

      * 35.8.1. Exemple

    * 35.9. "fcntl" --- The "fcntl" and "ioctl" system calls

    * 35.10. "pipes" — Interface au *pipelines* shell

      * 35.10.1. L'Objet *Template*

    * 35.11. "resource" --- Resource usage information

      * 35.11.1. Resource Limits

      * 35.11.2. Resource Usage

    * 35.12. "nis" — Interface à Sun's NIS (pages jaunes)

    * 35.13. "syslog" --- Unix syslog library routines

      * 35.13.1. Exemples

        * 35.13.1.1. Simple example

  * 36. Modules remplacés

    * 36.1. "optparse" --- Parser for command line options

      * 36.1.1. Background

        * 36.1.1.1. Terminology

        * 36.1.1.2. What are options for?

        * 36.1.1.3. What are positional arguments for?

      * 36.1.2. Tutoriel

        * 36.1.2.1. Understanding option actions

        * 36.1.2.2. The store action

        * 36.1.2.3. Handling boolean (flag) options

        * 36.1.2.4. Other actions

        * 36.1.2.5. Valeurs par défaut

        * 36.1.2.6. Generating help

          * 36.1.2.6.1. Grouping Options

        * 36.1.2.7. Printing a version string

        * 36.1.2.8. How "optparse" handles errors

        * 36.1.2.9. Putting it all together

      * 36.1.3. Reference Guide

        * 36.1.3.1. Creating the parser

        * 36.1.3.2. Populating the parser

        * 36.1.3.3. Defining options

        * 36.1.3.4. Option attributes

        * 36.1.3.5. Standard option actions

        * 36.1.3.6. Standard option types

        * 36.1.3.7. Analyse des arguments

        * 36.1.3.8. Querying and manipulating your option parser

        * 36.1.3.9. Conflicts between options

        * 36.1.3.10. Nettoyage

        * 36.1.3.11. Other methods

      * 36.1.4. Option Callbacks

        * 36.1.4.1. Defining a callback option

        * 36.1.4.2. How callbacks are called

        * 36.1.4.3. Raising errors in a callback

        * 36.1.4.4. Callback example 1: trivial callback

        * 36.1.4.5. Callback example 2: check option order

        * 36.1.4.6. Callback example 3: check option order
          (generalized)

        * 36.1.4.7. Callback example 4: check arbitrary condition

        * 36.1.4.8. Callback example 5: fixed arguments

        * 36.1.4.9. Callback example 6: variable arguments

      * 36.1.5. Extending "optparse"

        * 36.1.5.1. Adding new types

        * 36.1.5.2. Adding new actions

    * 36.2. "imp" --- Access the *import* internals

      * 36.2.1. Exemples

  * 37. Modules non Documentés

    * 37.1. Modules spécifiques à une plateforme

* Extension et intégration de l'interpréteur Python

  * Les outils tiers recommandés

  * Création d'extensions sans outils tiers

    * 1. Étendre Python en C ou C++

      * 1.1. Un exemple simple

      * 1.2. Intermezzo: Les erreurs et exceptions

      * 1.3. Retour vers l'exemple

      * 1.4. La fonction d'initialisation et le tableau des méthodes
        du module

      * 1.5. Compilation and Linkage

      * 1.6. Calling Python Functions from C

      * 1.7. Extracting Parameters in Extension Functions

      * 1.8. Keyword Parameters for Extension Functions

      * 1.9. Building Arbitrary Values

      * 1.10. Reference Counts

        * 1.10.1. Reference Counting in Python

        * 1.10.2. Ownership Rules

        * 1.10.3. Thin Ice

        * 1.10.4. NULL Pointers

      * 1.11. Writing Extensions in C++

      * 1.12. Providing a C API for an Extension Module

    * 2. Defining Extension Types: Tutorial

      * 2.1. The Basics

      * 2.2. Adding data and methods to the Basic example

      * 2.3. Providing finer control over data attributes

      * 2.4. Supporting cyclic garbage collection

      * 2.5. Subclassing other types

    * 3. Defining Extension Types: Assorted Topics

      * 3.1. Finalization and De-allocation

      * 3.2. Object Presentation

      * 3.3. Attribute Management

        * 3.3.1. Generic Attribute Management

        * 3.3.2. Type-specific Attribute Management

      * 3.4. Object Comparison

      * 3.5. Abstract Protocol Support

      * 3.6. Weak Reference Support

      * 3.7. More Suggestions

    * 4. Construire des extensions C et C++

      * 4.1. Construire les extensions C et C++ avec *distutils*

      * 4.2. Distribuer vos modules d'extension

    * 5. Construire des extensions C et C++ sur Windows

      * 5.1. Une approche "recette de cuisine"

      * 5.2. Différences entre Unix et Windows

      * 5.3. Utiliser les DLL en pratique

  * Intégrer l'interpréteur CPython dans une plus grande application

    * 1. Intégrer Python dans une autre application

      * 1.1. Intégration de très haut niveau

      * 1.2. Au-delà de l'intégration de haut niveau : survol

      * 1.3. Intégration pure

      * 1.4. Étendre un Python intégré

      * 1.5. Intégrer Python dans du C++

      * 1.6. Compiler et Lier en environnement Unix ou similaire

* Manuel de référence de l'API Python/C

  * Introduction

    * Include Files

    * Objects, Types and Reference Counts

      * Reference Counts

        * Reference Count Details

      * Types

    * Exceptions

    * Embarquer Python

    * Debugging Builds

  * ABI Stable

  * The Very High Level Layer

  * Reference Counting

  * Gestion des exceptions

    * Printing and clearing

    * Lever des exceptions

    * Issuing warnings

    * Querying the error indicator

    * Traitement des signaux

    * Exception Classes

    * Objets exception

    * Objets exception Unicode

    * Contrôle de la récursion

    * Exceptions standards

    * Standard Warning Categories

  * Utilitaires

    * Operating System Utilities

    * System Functions

    * Process Control

    * Importer des modules

    * Data marshalling support

    * Analyse des arguments et construction des valeurs

      * Analyse des arguments

        * Chaînes et tampons

        * Les nombres

        * Autres objets

        * Fonction de l'API

      * Construction des valeurs

    * Conversion et formatage de chaînes

    * Réflexion

    * Codec registry and support functions

      * Codec lookup API

      * Registry API for Unicode encoding error handlers

  * Couche d'abstraction des objets

    * Protocole Objet

    * Number Protocol

    * Sequence Protocol

    * Mapping Protocol

    * Protocole d'itération

    * Protocole tampon

      * La structure *buffer*

      * Buffer request types

        * request-independent fields

        * readonly, format

        * shape, strides, suboffsets

        * contiguity requests

        * compound requests

      * Complex arrays

        * NumPy-style: shape and strides

        * PIL-style: shape, strides and suboffsets

      * Fonctions relatives aux tampons

    * Ancien *Buffer Protocol*

  * Couche des objets concrets

    * Objets fondamentaux

      * Objets type

      * L'objet "None"

    * Objets numériques

      * Objets *Integer*

      * Les objets booléens

      * Objets représentant les nombres à virgule flottante

      * Objets nombres complexes

        * Nombres complexes en tant que structures C

        * Nombres complexes en tant qu'objets Python

    * Objets séquences

      * Objets *bytes*

      * Objets tableau d'octets

        * Macros de vérification de type

        * Fonctions directes sur l'API

        * Macros

      * Unicode Objects and Codecs

        * Unicode Objects

          * Unicode Type

          * Unicode Character Properties

          * Creating and accessing Unicode strings

          * Deprecated Py_UNICODE APIs

          * Locale Encoding

          * File System Encoding

          * wchar_t Support

        * Built-in Codecs

          * Generic Codecs

          * UTF-8 Codecs

          * UTF-32 Codecs

          * UTF-16 Codecs

          * UTF-7 Codecs

          * Unicode-Escape Codecs

          * Raw-Unicode-Escape Codecs

          * Latin-1 Codecs

          * ASCII Codecs

          * Character Map Codecs

          * MBCS codecs for Windows

          * Methods & Slots

        * Methods and Slot Functions

      * Tuple Objects

      * Struct Sequence Objects

      * List Objects

    * Objets conteneurs

      * Objets dictionnaires

      * Set Objects

    * Objets fonctions

      * Objets fonctions

      * Instance Method Objects

      * Objets méthode

      * Objets Cellules

      * Objets code

    * Autres objets

      * Objets fichiers

      * Module Objects

        * Initializing C modules

          * Single-phase initialization

          * Multi-phase initialization

          * Low-level module creation functions

          * Support functions

        * Module lookup

      * Itérateurs

      * Les descripteurs

      * Slice Objects

      * Ellipsis Object

      * Objets de type MemoryView

      * Objets à références faibles

      * Capsules

      * Objets générateur

      * Objets coroutines

      * Objets DateTime

  * Initialization, Finalization, and Threads

    * Initializing and finalizing the interpreter

    * Process-wide parameters

    * Thread State and the Global Interpreter Lock

      * Releasing the GIL from extension code

      * Non-Python created threads

      * High-level API

      * Low-level API

    * Sub-interpreter support

      * Bugs and caveats

    * Asynchronous Notifications

    * Profiling and Tracing

    * Support avancé du débogueur

  * Memory Management

    * Aperçu

    * Raw Memory Interface

    * Memory Interface

    * Object allocators

    * Customize Memory Allocators

    * The pymalloc allocator

      * Customize pymalloc Arena Allocator

    * Exemples

  * Implémentation d'objets

    * Allouer des objets dans le tas

    * Common Object Structures

    * Objets type

    * Number Object Structures

    * Mapping Object Structures

    * Sequence Object Structures

    * Buffer Object Structures

    * Async Object Structures

    * Supporting Cyclic Garbage Collection

  * Version des API et ABI

* Distribuer des modules Python

  * Vocabulaire

  * Licence libre et collaboration

  * Installer les outils

  * Lire le manuel

  * Comment puis-je ...?

    * ... choisir un nom pour mon projet ?

    * ... créer et distribuer des extensions binaires ?

* Installation de modules Python

  * Vocabulaire

  * Utilisation de base

  * Comment puis-je … ?

    * ... Installer "pip" avec une version de Python antérieures à la
      3.4 ?

    * ... Installer des paquets juste pour l'utilisateur actuel ?

    * ... Installer des paquets Python scientifiques ?

    * ... Travailler avec plusieurs versions de Python installés en
      parallèle ?

  * Les problèmes d'installation typiques

    * Installer dans le Python du système sur Linux

    * "Pip" n'est pas installé

    * Installation d'extensions binaires

* Les HOWTOs de Python

  * Portage de code Python 2 vers Python 3

    * La version courte

    * Détails

      * Abandon de la compatibilité Python 2.6 et antérieures

      * Assurez vous de spécifier la bonne version supportée dans le
        fichier "setup.py"

      * Obtenir une bonne couverture de code

      * Apprendre les différences entre Python 2 et 3

      * Mettre à jour votre code

        * Division

        * Texte et données binaires

        * Utilisez la détection de fonctionnalités plutôt que la
          détection de version

      * Prévenir les régressions de compatibilité

      * Vérifier quelles dépendances empêchent la migration

      * Mettre à jour votre fichier "setup.py" pour spécifier la
        compatibilité avec Python 3

      * Utiliser l'intégration continue pour maintenir la
        compatibilité

      * Envisager l'utilisation d'un vérificateur de type statique
        optionnel

  * Portage des modules d'extension vers Python 3

    * Compilation conditionnelle

    * Modifications apportées aux API des objets

      * Unification de *str* et *unicode*

      * Unification de *long* et *int*

    * Initialisation et état du module

    * CObject remplacé par Capsule

    * Autres options

  * Curses Programming with Python

    * What is curses?

      * The Python curses module

    * Starting and ending a curses application

    * Windows and Pads

    * Displaying Text

      * Attributes and Color

    * User Input

    * For More Information

  * Guide pour l'utilisation des descripteurs

    * Résumé

    * Définition et introduction

    * Protocole descripteur

    * Invocation des descripteurs

    * Exemple de descripteur

    * Propriétés

    * Fonctions et méthodes

    * Méthodes statiques et méthodes de classe

  * Guide pratique : programmation fonctionnelle

    * Introduction

      * Preuves formelles

      * Modularité

      * Facilité de débogage et de test

      * Composabilité

    * Itérateurs

      * Types de données itérables

    * Expressions génératrices et compréhension de listes

    * Générateurs

      * Transmettre des valeurs au générateur

    * Fonctions natives

    * Le module *itertools*

      * Créer de nouveaux itérateurs

      * Appliquer des fonctions au contenu des itérateurs

      * Sélectionner des éléments

      * Fonctions combinatoires

      * Grouper les éléments

    * Le module *functools*

      * Le module *operator*

    * Expressions lambda et fonctions courtes

    * Historique des modifications et remerciements

    * Références

      * Général

      * Spécifique à Python

      * Documentation Python

  * Tutoriel sur la journalisation

    * Les bases de l'utilisation du module *logging*

      * Quand utiliser *logging*

      * Un exemple simple

      * Enregistrer les évènements dans un fichier

      * Employer *logging* à partir de différents modules

      * Journalisation de données variables

      * Modifier le format du message affiché

      * Afficher l'horodatage dans les messages

      * Étapes suivantes

    * Usage avancé de Logging

      * Flux du processus de journalisation

      * Loggers

      * Handlers

      * Formatters

      * Configuration de *Logging*

      * Comportement par défaut (si aucune configuration n'est
        fournie)

      * Configuration de la journalisation pour une bibliothèque

    * Niveaux de journalisation

      * Niveaux personnalisés

    * Gestionnaires utiles

    * Exceptions levées par la journalisation

    * Utilisation d'objets arbitraires comme messages

    * Optimisation

  * Logging Cookbook

    * Using logging in multiple modules

    * Logging from multiple threads

    * Multiple handlers and formatters

    * Logging to multiple destinations

    * Configuration server example

    * Dealing with handlers that block

    * Sending and receiving logging events across a network

    * Adding contextual information to your logging output

      * Using LoggerAdapters to impart contextual information

        * Using objects other than dicts to pass contextual
          information

      * Using Filters to impart contextual information

    * Logging to a single file from multiple processes

    * Using file rotation

    * Use of alternative formatting styles

    * Customizing "LogRecord"

    * Subclassing QueueHandler - a ZeroMQ example

    * Subclassing QueueListener - a ZeroMQ example

    * An example dictionary-based configuration

    * Using a rotator and namer to customize log rotation processing

    * A more elaborate multiprocessing example

    * Inserting a BOM into messages sent to a SysLogHandler

    * Implementing structured logging

    * Customizing handlers with "dictConfig()"

    * Using particular formatting styles throughout your application

      * Using LogRecord factories

      * Using custom message objects

    * Configuring filters with "dictConfig()"

    * Customized exception formatting

    * Speaking logging messages

    * Buffering logging messages and outputting them conditionally

    * Formatting times using UTC (GMT) via configuration

    * Using a context manager for selective logging

  * Guide des expressions régulières

    * Introduction

    * Motifs simples

      * Correspondance de caractères

      * Répétitions

    * Utilisation des expressions régulières

      * Compilation des expressions régulières

      * La maudite barre oblique inverse

      * Recherche de correspondances

      * Fonctions de niveau module

      * Options de compilation

    * Des motifs plus puissants

      * Plus de métacaractères

      * Regroupement

      * Groupes non de capture et groupes nommés

      * Assertions prédictives

    * Modification de chaînes

      * Découpage de chaînes

      * Recherche et substitution

    * Problèmes classiques

      * Utilisez les méthodes du type *string*

      * *match()* contre *search()*

      * Glouton contre non-glouton

      * Utilisez *re.VERBOSE*

    * Vos commentaires

  * Socket Programming HOWTO

    * Interfaces de connexion (*sockets*)

      * Historique

    * Créer un connecteur

      * Communication Entre Processus

    * Using a Socket

      * Données binaires

    * Déconnexion

      * When Sockets Die

    * Non-blocking Sockets

  * Guide pour le tri

    * Les bases du tri

    * Fonctions clef

    * Fonctions du module *operator*

    * Ascendant et descendant

    * Stabilité des tris et tris complexes

    * La méthode traditionnelle utilisant Decorate-Sort-Undecorate

    * La méthode traditionnelle d'utiliser le paramètre *cmp*

    * Curiosités et conclusion

  * Guide Unicode

    * Introduction à Unicode

      * Histoire des codes de caractères

      * Définitions

      * Encodages

      * Références

    * Prise en charge Unicode de Python

      * Le type *String*

      * Conversion en octets

      * Littéraux Unicode dans le code source Python

      * Propriétés Unicode

      * Expressions régulières Unicode

      * Références

    * Lecture et écriture de données Unicode

      * Noms de fichiers Unicode

      * Conseils pour écrire des programmes compatibles Unicode

        * Conversion entre les encodages de fichiers

        * Fichiers dans un encodage inconnu

      * Références

    * Remerciements

  * HOWTO Fetch Internet Resources Using The urllib Package

    * Introduction

    * Fetching URLs

      * Data

      * Headers

    * Gestion des exceptions

      * URLError

      * HTTPError

        * Error Codes

      * Wrapping it Up

        * Number 1

        * Number 2

    * info and geturl

    * Openers and Handlers

    * Basic Authentication

    * Proxies

    * Sockets and Layers

    * Notes

  * Tutoriel *argparse*

    * Concepts

    * Les bases

    * Introduction aux arguments positionnels

    * Introduction aux arguments optionnels

      * Les paramètres raccourcis

    * Combinaison d'arguments positionnels et optionnels

    * Aller un peu plus loin

      * Paramètres en conflit

    * Conclusion

  * Introduction au module "ipaddress"

    * Créer un objet Adresse/Réseau/Interface

      * Note sur les versions d'IP

      * Adresses IP des hôtes

      * Définir des réseaux

      * Interfaces des hôtes

    * Inspecter les objets Address/Network/Interface

    * Réseaux en tant que listes d'adresses

    * Comparaisons

    * Utiliser des adresse IP avec d'autre modules

    * Obtenir plus de détails lors de l'échec de la création de
      l'instance

  * Argument Clinic How-To

    * Les objectifs d'Argument Clinic

    * Concepts de base et utilisation

    * Convertissez votre première fonction

    * Sujets avancés

      * Valeurs par défaut

      * Renaming the C functions and variables generated by Argument
        Clinic

      * Conversion des fonctions en utilisant *PyArg_UnpackTuple*

      * Groupes optionnels

      * Using real Argument Clinic converters, instead of "legacy
        converters"

      * Py_buffer

      * Advanced converters

      * Parameter default values

      * The "NULL" default value

      * Expressions specified as default values

      * Using a return converter

      * Cloning existing functions

      * Calling Python code

      * Using a "self converter"

      * Writing a custom converter

      * Writing a custom return converter

      * METH_O and METH_NOARGS

      * tp_new and tp_init functions

      * Changing and redirecting Clinic's output

      * The #ifdef trick

      * Using Argument Clinic in Python files

  * Instrumenter CPython avec DTrace et SystemTap

    * Activer les marqueurs statiques

    * Sondes DTrace statiques

    * Marqueurs statiques *SystemTap*

    * Marqueurs statiques disponibles

    * *Tapsets* de *SystemTap*

    * Exemples

* Questions fréquemment posées sur Python

  * FAQ générale sur Python

    * Informations générales

    * Python c'est le monde réel

  * FAQ de programmation

    * Questions générales

    * Fondamentaux

    * Nombres et chaînes de caractères

    * Performances

    * Séquences (n-uplets / listes)

    * Dictionnaires

    * Objets

    * Modules

  * FAQ histoire et design

    * Pourquoi Python utilise-t-il l'indentation pour grouper les
      instructions ?

    * Pourquoi ai-je d'étranges résultats suite à de simples
      opérations arithmétiques ?

    * Pourquoi les calculs à virgules flottantes sont si imprécis ?

    * Pourquoi les chaînes de caractères Python sont-elles immuables ?

    * Pourquoi "self" doit-il être explicitement utilisé dans les
      définitions et les appels de méthode ?

    * Pourquoi ne puis-je pas utiliser d'assignation dans une
      expression ?

    * Pourquoi Python utilise des méthodes pour certaines
      fonctionnalités (ex : "list.index()") mais des fonctions pour
      d'autres (ex : "len(list)") ?

    * Pourquoi "join()" est une méthode de chaîne plutôt qu'une de
      liste ou de tuple ?

    * À quel point les exceptions sont-elles rapides ?

    * Pourquoi n'y a-t-il pas une instruction *switch* ou une
      structure similaire à *switch / case* en Python ?

    * Est-il possible d'émuler des fils d'exécution dans
      l'interpréteur plutôt que se baser sur les implémentations
      spécifique aux OS ?

    * Pourquoi les expressions lambda ne peuvent pas contenir
      d'instructions ?

    * Python peut-il être compilé en code machine, en C ou dans un
      autre langage ?

    * Comment Python gère la mémoire ?

    * Pourquoi CPython n'utilise-il pas un ramasse-miette plus
      traditionnel ?

    * Pourquoi toute la mémoire n'est pas libérée lorsque *CPython*
      s'arrête ?

    * Pourquoi les *tuples* et les *list* sont deux types de données
      séparés ?

    * How are lists implemented in CPython?

    * How are dictionaries implemented in CPython?

    * Pourquoi les clés du dictionnaire sont immuables ?

    * Pourquoi "list.sort()" ne renvoie pas la liste triée ?

    * Comment spécifiez-vous et appliquez-vous une spécification
      d’interface en Python ?

    * Pourquoi n'y a-t-il pas de "goto" en Python ?

    * Pourquoi les chaînes de caractères brutes (r-strings) ne
      peuvent-elles pas se terminer par un *backslash* ?

    * Pourquoi la déclaration "with" pour les assignations d'attributs
      n'existe pas en Python ?

    * Pourquoi les deux-points sont-ils nécessaires pour les
      déclarations "if/while/def/class" ?

    * Pourquoi Python permet-il les virgules à la fin des listes et
      des tuples ?

  * FAQ sur la bibliothèque et les extensions

    * Questions générales sur la bibliothèque

    * Tâches fréquentes

    * Fils d'exécution

    * Les entrées/sorties

    * Programmation réseau et Internet

    * Bases de données

    * Mathématiques et calcul numérique

  * FAQ extension/intégration

    * Puis-je créer mes propres fonctions en C ?

    * Puis-je créer mes propres fonctions en C++ ?

    * Écrire directement en C est difficile ; existe-t-il des
      alternatives ?

    * Comment puis-je exécuter des instructions quelconques Python à
      partir de C ?

    * Comment puis-je évaluer une expression quelconque de Python à
      partir de C ?

    * Comment puis-je extraire des donnés en C d'un objet Python ?

    * Comment utiliser Py_BuildValue() pour créer un tuple de longueur
      définie ?

    * Comment puis-je appeler la méthode d'un objet à partir de C ?

    * Comment puis-je récupérer la sortie de "PyErr_Print()" (ou tout
      ce qui s'affiche sur *stdout*/*stderr*) ?

    * Comment accéder à un module écrit en Python à partir de C ?

    * Comment s'interfacer avec les objets C++ depuis Python ?

    * J'ai ajouté un module en utilisant le fichier *Setup* et la
      compilation échoue ; pourquoi ?

    * Comment déboguer une extension ?

    * Je veux compiler un module Python sur mon système Linux, mais il
      manque certains fichiers. Pourquoi ?

    * Comment distinguer une « entrée incomplète » (*incomplete
      input*) d'une « entrée invalide » (*invalid input*) ?

    * Comment puis-je trouver les symboles g++ indéfinis
      "__builtin_new" ou "__pure_virtual" ?

    * Puis-je créer une classe d'objets avec certaines méthodes
      implémentées en C et d'autres en Python (p. ex. en utilisant
      l'héritage) ?

  * FAQ : Python et Windows

    * Comment exécuter un programme Python sous Windows ?

    * Comment rendre des scripts Python exécutables ?

    * Pourquoi Python met-il du temps à démarrer ?

    * Comment construire un exécutable depuis un script Python ?

    * Est-ce qu'un fichier "*.pyd" est la même chose qu'une DLL ?

    * Comment puis-je intégrer Python dans une application Windows ?

    * Comment empêcher mon éditeur d'utiliser des tabulations dans mes
      fichiers Python ?

    * Comment puis-je vérifier de manière non bloquante qu'une touche
      a été pressée ?

  * FAQ interface graphique

    * Questions générales sur l'interface graphique

    * Quelles bibliothèques d'interfaces graphiques multi-plateformes
      existent en Python ?

    * Quelles boîtes à outils IUG spécifiques à la plate-forme
      existent pour Python ?

    * Questions à propos de *Tkinter*

  * FAQ "Pourquoi Python est installé sur mon ordinateur ?"

    * Qu'est-ce que Python ?

    * Pourquoi Python est installé sur ma machine ?

    * Puis-je supprimer Python ?

* Glossaire

* À propos de ces documents

  * Contributeurs de la documentation Python

* S'attaquer aux bogues

  * Bogues de documentation

  * Utilisation du gestionnaire de tickets Python

  * Commencer à contribuer à Python vous-même

* Copyright

* Histoire et licence

  * Histoire du logiciel

  * Conditions générales pour accéder à, ou utiliser, Python

    * PSF LICENSE AGREEMENT FOR PYTHON 3.6.11

    * LICENCE D'UTILISATION BEOPEN.COM POUR PYTHON 2.0

    * LICENCE D'UTILISATION CNRI POUR PYTHON 1.6.1

    * LICENCE D'UTILISATION CWI POUR PYTHON 0.9.0 à 1.2

  * Licences et remerciements pour les logiciels tiers

    * Mersenne twister

    * Interfaces de connexion (*sockets*)

    * Virgule flottante et contrôle d'exception

    * Interfaces de connexion asynchrones

    * Gestion de témoin (*cookie*)

    * Traçage d'exécution

    * Les fonctions UUencode et UUdecode

    * Appel de procédures distantes en XML (*RPC*, pour *Remote
      Procedure Call*)

    * test_epoll

    * Select kqueue

    * SipHash24

    * *strtod* et *dtoa*

    * OpenSSL

    * expat

    * libffi

    * zlib

    * cfuhash

    * libmpdec
