python之 Nested Function
好文转载 What is a Nested Function?
https://zhuanlan.zhihu.com/p/53116610
【译文稍作修改】
Functions are one of the "first-class citizens" of Python, which means that functions are at the same level as other Python objects like integers, strings, modules, etc. They can be created and destroyed dynamically, passed to other functions, returned as values, etc.
函数是 Python 的“一等公民”之一，这意味着函数与其他 Python 对象（如整数、字符串、模块等）处于同一级别。 它们可以动态地创建和销毁，传递给其他函数，作为值返回，等等。
Python supports the concept of a "nested function" or "inner function", which is simply a function defined inside another function. In the rest of the article, we will use the word "inner function" and "nested function" interchangeably.
Python 支持“嵌套函数（nested function）”或“内部函数（inner function）”的概念，它只是在另一个函数中定义的一个函数。 在本文的其余部分，我们将交替使用"inner function"和"nested function"这两个词。
There are various reasons as to why one would like to create a function inside another function. The inner function is able to access the variables within the enclosing scope. In this article, we will be exploring various aspects of inner functions in Python.
对于为什么要在另一个函数中创建一个函数，有各种各样的原因。 内部函数能够访问封闭范围内的变量。 在本文中，我们将探索 Python 内部函数的各个方面。
Defining an Inner Function
定义内部函数
To define an inner function in Python, we simply create a function inside another function using the Python's def keyword. Here is an example:
为了在 Python 中定义一个内部函数，我们只需使用 Python 的 def 关键字在另一个函数中创建一个函数。 下面是一个例子：
def function1(): # outer function
print ("Hello from outer function")
def function2(): # inner function
print ("Hello from inner function")
function2()
function1()
Output
输出
Hello from outer function
Hello from inner function
In the above example, function2() has been defined inside function1(), making it an inner function. To call function2(), we must first call function1(). The function1() will then go ahead and call function2() as it has been defined inside it.
在上面的示例中，function2()是在 function1()内部定义的，因此它是一个内部函数。 要调用 function2() ，我们必须先调用 function1()。 然后，function1()将继续调用在其中定义的 function2()。
It is important to mention that the outer function has to be called in order for the inner function to execute. If the outer function is not called, the inner function will never execute. To demonstrate this, modify the above code to the following and run it:
必须指出的是，为了执行内部函数，必须调用外部函数。 如果不调用外部函数，内部函数将永远不会执行。 为了演示这一点，将上面的代码修改为下面的代码并运行它：
def function1(): # outer function
print ("Hello from outer function")
def function2(): # inner function
print ("Hello from inner function")
function2()
#function1()
The code will return nothing when executed!
代码在执行时将不返回任何内容！
Here is another example:
下面是另一个例子：
def num1(x):
def num2(y):
return x * y
return num2
res = num1(10)
print(res(5))
Output
输出
The code returns the multiplication of the two numbers, that is, 10 and 5. The example shows that an inner function is able to access variables accessible in the outer function.
该代码返回两个数字的相乘，即10和5。 该示例表明，内部函数能够访问外部函数中可访问的变量。
So far, you have seen that it is possible for us to access the variables of the outer function inside the inner function. What if we attempt to change the variables of the outer function from inside the inner function? Let us see what happens:
到目前为止，您已经看到，我们可以访问内部函数中外部函数的变量。 如果我们尝试从内部函数改变外部函数的变量呢？ 让我们看看会发生什么：
def function1(): # outer function
x = 2 # A variable defined within the outer function
def function2(a): # inner function
# Let's define a new variable within the inner function
# rather than changing the value of x of the outer function
x = 6
print (a+x)
print (x) # to display the value of x of the outer function
function2(3)
function1()
Output
输出
The output shows that it is possible for us to display the value of a variable defined within the outer function from the inner function, but not change it. The statement x = 6 helped us create a new variable x inside the inner function function2() rather than changing the value of variable xdefined in the outer function function1().
输出表明，我们可以从内部函数显示在外部函数中定义的变量的值，但不改变它。 x=6语句帮助我们在内部函数 function2()中创建一个新的变量 x，而不是更改在外部函数 function1()中定义的变量 x 的值。
In the next section, we will be discussing the main reasons as to why we use inner functions in Python.
在下一节中，我们将讨论在 Python 中使用内部函数的主要原因。
Why use Inner Functions?
为什么要使用内部函数？
Encapsulation
封装
A function can be created as an inner function in order to protect it from everything that is happening outside of the function. In that case, the function will be hidden from the global scope. Here is an example:
可以创建一个函数作为内部函数，以保护它不受函数之外发生的任何事情的影响。 在这种情况下，函数将被隐藏在全局作用域（global scope）之外。 下面是一个例子：
def outer_function(x):
# Hidden from the outer code
def inner_increment(x):
return x + 2
y = inner_increment(x)
print(x, y)
inner_increment(5)
#outer_function(5)
Output
输出
Traceback (most recent call last):
File "C:/Users/admin/inner.py", line 7, in <module>
inner_increment(5)
NameError: name 'inner_increment' is not defined
In the above code, we are trying to call the inner_increment() function, but instead we got an error.
在上面的代码中，我们试图调用内部的 increment() 函数，但是得到了一个错误。
Now, comment out the call to inner_increment() and uncomment the call to outer_function()as shown below:
现在，注释掉对 inner increment() 的调用，取消对 outer function() 的调用，如下所示：
def outer_function(x):
# Hidden from the outer code
def inner_increment(x):
return x + 2
y = inner_increment(x)
print(x, y)
#inner_increment(5)
outer_function(5)
Output
输出
The script above shows that the inner function, that is, inner_increment() is protected from what is happening outside it since the variable x inside the inner_increment function is not affected by the value passed to the parameter x of the outer function. In other words, the variables inside the inner function is not accessible outside it. There is a great advantage with such a design pattern. After checking all arguments in the outer function, we can safely skip error checking within the inner function.
上面的脚本显示了内部函数，即 inner_increment() 受到保护，不受外部函数的影响，因为内部增量函数中的变量 x 不受传递给外部函数的参数 x 的值的影响。 换句话说，内部函数中的变量在外部是不可访问的。 这样的设计模式有很大的优势。 在检查了外部函数中的所有参数之后，我们可以安全地跳过内部函数中的错误检查。
Closures and Factory Functions
闭包和工厂功能
All the examples we have seen till now just contain ordinary functions that have been nested inside other functions. It is possible for us to write such functions in another way instead of nesting them inside other functions. We don't have a specific reason as to why we should nest them.
到目前为止，我们看到的所有例子都只包含嵌套在其他函数中的普通函数。 我们可以用另一种方式编写这样的函数，而不是将它们嵌套在其他函数中。 我们没有一个具体的原因，为什么我们应该嵌套他们。
However, for the case of closures, one must use the nested functions.
但是，对于闭包，必须使用嵌套函数。
We can bind/pass data to a function without necessarily passing the data to the function via parameters. This is done using a closure. It is a function object that is able to remember values in the enclosing scopes even when they are not available in the memory. This means that we have a closure when a nested function references a value that is in its enclosing scope.
我们可以将数据绑定 / 传递给函数，而不必通过参数将数据传递给函数。 这是通过闭包完成的。 它是一个函数对象，即使在内存中不可用的情况下，它也能够记住enclosing scopes（外层/封闭作用域）中的值。 这意味着当嵌套函数引用enclosing scopes内的值时，我们有一个闭包（closure）。
The purpose of a closure is to make the inner function remember the state of its environment when it is called, even if it is not in the memory. A closure is caused by an inner function, but it's not the inner function. The closure works by closing the local variable on the stack, which stays around after the creation of the stack has finished executing.
闭包（closure）的目的是使内部函数在被调用时记住其环境的状态，即使它不在内存中。 闭包是由内部函数引起的，但它不是内部函数。 闭包的工作方式是关闭（closing）堆栈上的局部变量，这个局部变量在堆栈创建完成后仍然保留。
The following are the conditions that are required to be met in order to create a closure in Python:
以下是在 Python 中创建闭包所需满足的条件：
- There must be a nested function 。
必须有一个嵌套函数。
- The inner function has to refer to a value that is defined in the enclosing scope。
内部函数必须引用在enclosing scope（外层/封闭作用域）中定义的值。
- The enclosing function has to return the nested function。
enclosing function（外层/封闭函数）必须返回嵌套函数。
Consider the following example:
考虑下面的例子：
def function1(name):
def function2():
print('Hello ' + name)
return function2
func = function1('Nicholas')
func()
Output
输出
Hello Nicholas
The above code demonstrates that with closures, we are able to generate and invoke a function from outside its scope via function passing. The scope of function2() is only inside function1(). However, with the use of closures, it was possible for us to extend this scope and invoke it from outside its scope.
上面的代码演示了使用闭包，我们能够通过函数传递从其作用域之外生成和调用函数。 Function2()的作用域仅在 function1()内。 但是，通过使用闭包，我们可以扩展这个作用域并从其作用域之外调用它。
Inner functions help us in defining factory functions. A factory function is a function that creates another object. For example:
内部函数帮助我们定义工厂函数（actory functions）。 工厂函数是创建另一个对象的函数。 例如：
def power_generator(num):
# Create the inner function
def power_n(power):
return num ** power
return power_n
power_two = power_generator(2)
power_three = power_generator(3)
print(power_two(8))
print(power_three(4))
Output
输出
256
81
In the script above, from the power_n(power) function, we have created two other objects, power_two and power_three. This makes power_n(power) a factory function since it generates the power_two and power_three functions for us using the parameter we pass it.
在上面的脚本中，从 pwoer_n(power) 函数中，我们创建了另外两个对象，power_two 和 power_three。 这使得 power_n(power) 成为一个工厂函数，因为它使用我们传递给它的参数为我们生成 power_two 和 power_three。
Conclusion
总结
An inner function is simply a function that is defined inside another function. The inner function is able to access the variables that have been defined within the scope of the outer function, but it cannot change them. There are a number of reasons as to why we may need to create an inner function. For instance, an inner function is protected from what happens outside it. Inner functions are also a good way of creating closures in Python.
内部函数只是在另一个函数内部定义的函数。 内部函数可以访问在外部函数范围内定义的变量，但不能更改它们。 我们需要创建一个内部函数的原因有很多。 例如，内部函数受到保护，不受外部发生的事情的影响。 内部函数也是在 Python 中创建闭包的好方法。
原文链接：https://zhuanlan.zhihu.com/p/53116610
Python参考手册，官方正式版参考手册，chm版。以下摘取部分内容:Navigation
index modules | next | Python » 3.6.5 Documentation »
Python Documentation contents
What’s New in Python
What’s New In Python 3.6
Summary – Release highlights
New Features
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
asyncio
binascii
cmath
collections
concurrent.futures
contextlib
datetime
decimal
distutils
email
encodings
faulthandler
fileinput
hashlib
http.client
idlelib and IDLE
importlib
inspect
logging
multiprocessing
pathlib
pickle
pickletools
pydoc
random
readline
rlcompleter
shlex
sqlite3
socket
socketserver
statistics
struct
subprocess
telnetlib
timeit
tkinter
traceback
tracemalloc
typing
unicodedata
unittest.mock
urllib.request
urllib.robotparser
warnings
winreg
winsound
xmlrpc.client
zipfile
Optimizations
Build and C API Changes
Other Improvements
Deprecated
New Keywords
Deprecated Python behavior
Deprecated Python modules, functions and methods
asynchat
asyncore
distutils
importlib
tkinter
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.5
What’s New In Python 3.5
Summary – Release highlights
New Features
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: Elimination of PYO files
PEP 489: Multi-phase extension module initialization
Other Language Changes
New Modules
typing
zipapp
Improved Modules
argparse
asyncio
cmath
collections
collections.abc
compileall
concurrent.futures
configparser
contextlib
curses
difflib
distutils
doctest
email
faulthandler
functools
heapq
http.client
idlelib and IDLE
imaplib
imghdr
importlib
inspect
ipaddress
linecache
locale
logging
multiprocessing
operator
pathlib
pickle
poplib
readline
selectors
shutil
signal
smtpd
smtplib
sndhdr
socket
Memory BIO Support
Application-Layer Protocol Negotiation Support
Other Changes
sqlite3
subprocess
sysconfig
tarfile
threading
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
New Keywords
Deprecated Python Behavior
Unsupported Operating Systems
Deprecated Python modules, functions and methods
Removed
API and Feature Removals
Porting to Python 3.5
Changes in Python behavior
Changes in the Python API
Changes in the C API
What’s New In Python 3.4
Summary – Release Highlights
New Features
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
pathlib
selectors
statistics
tracemalloc
Improved Modules
argparse
audioop
base64
collections
colorsys
contextlib
doctest
email
filecmp
functools
hashlib
idlelib and IDLE
importlib
inspect
ipaddress
logging
marshal
multiprocessing
operator
pickle
plistlib
poplib
pprint
pydoc
resource
select
shelve
shutil
smtpd
smtplib
socket
sqlite3
struct
subprocess
sunau
tarfile
textwrap
threading
traceback
types
urllib
unittest
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
Other Improvements
Significant Optimizations
Deprecated
Deprecations in the Python API
Deprecated Features
Removed
Operating Systems No Longer Supported
API and Feature Removals
Code Cleanups
Porting to 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
What’s New In 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
Improved Modules
array
base64
binascii
codecs
collections
contextlib
crypt
curses
datetime
decimal
Features
API changes
email
Policy Framework
Provisional Policy with New Header API
Other API Changes
ftplib
functools
imaplib
inspect
itertools
logging
multiprocessing
nntplib
pickle
pydoc
sched
select
shlex
shutil
signal
smtpd
smtplib
socket
socketserver
sqlite3
struct
subprocess
tarfile
tempfile
textwrap
threading
types
unittest
urllib
webbrowser
xml.etree.ElementTree
Optimizations
Build and C API Changes
Deprecated
Unsupported Operating Systems
Deprecated Python modules, functions and methods
Deprecated functions and types of the C API
Deprecated features
Porting to Python 3.3
Porting Python code
Porting C code
Building C extensions
Command Line Switch Changes
What’s New In 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
reprlib
logging
contextlib
decimal and fractions
popen
select
gzip and zipfile
tarfile
hashlib
shutil
sqlite3
socket
certificates
imaplib
http.client
unittest
random
poplib
asyncore
tempfile
inspect
pydoc
ctypes
sysconfig
configparser
urllib.parse
mailbox
turtledemo
Multi-threading
Optimizations
Unicode
Codecs
Documentation
Code Repository
Build and C API Changes
Porting to Python 3.2
What’s New In Python 3.1
PEP 372: Ordered Dictionaries
PEP 378: Format Specifier for Thousands Separator
Other Language Changes
New, Improved, and Deprecated Modules
Optimizations
Build and C API Changes
Porting to Python 3.1
What’s New In 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
Performance
Porting To Python 3.0
What’s New in 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
Updated module: ElementTree 1.3
Build and C API Changes
Capsules
Port-Specific Changes: Windows
Port-Specific Changes: Mac OS X
Port-Specific Changes: FreeBSD
Other Changes and Fixes
Porting to Python 2.7
New Features Added to Python 2.7 Maintenance Releases
PEP 434: IDLE Enhancement Exception for All Branches
PEP 466: Network Security Enhancements for Python 2.7
Acknowledgements
What’s New in 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
Writing Context Managers
The contextlib module
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
Porting to Python 2.6
Acknowledgements
What’s New in Python 2.5
PEP 308: Conditional Expressions
PEP 309: Partial Function Application
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
Writing Context Managers
The contextlib module
PEP 352: Exceptions as New-Style Classes
PEP 353: Using ssize_t as the index type
PEP 357: The ‘__index__’ method
Other Language Changes
Interactive Interpreter Changes
Optimizations
New, Improved, and Removed Modules
The ctypes package
The ElementTree package
The hashlib package
The sqlite3 package
The wsgiref package
Build and C API Changes
Port-Specific Changes
Porting to Python 2.5
Acknowledgements
What’s New in 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
Porting to Python 2.4
Acknowledgements
What’s New in Python 2.3
PEP 218: A Standard Set Datatype
PEP 255: Simple Generators
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: A Boolean Type
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
Other Changes and Fixes
Porting to Python 2.3
Acknowledgements
What’s New in Python 2.2
Introduction
PEPs 252 and 253: Type and Class Changes
Old and New Classes
Descriptors
Multiple Inheritance: The Diamond Rule
Attribute Access
Related Links
PEP 234: Iterators
PEP 255: Simple Generators
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
Other Changes and Fixes
Acknowledgements
What’s New in Python 2.1
Introduction
PEP 227: Nested Scopes
PEP 236: __future__ Directives
PEP 207: Rich Comparisons
PEP 230: Warning Framework
PEP 229: New Build System
PEP 205: Weak References
PEP 232: Function Attributes
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
Other Changes and Fixes
Acknowledgements
What’s New in Python 2.0
Introduction
What About Python 1.6?
New Development Process
Unicode
List Comprehensions
Augmented Assignment
String Methods
Garbage Collection of Cycles
Other Core Changes
Minor Language Changes
Changes to Built-in Functions
Porting to 2.0
Extending/Embedding Changes
Distutils: Making Modules Easy to Install
XML Modules
SAX2 Support
DOM Support
Relationship to PyXML
Module changes
New modules
IDLE Improvements
Deleted and Deprecated Modules
Acknowledgements
Changelog
Python 3.6.5 final?
Tests
Build
Python 3.6.5 release candidate 1?
Security
Core and Builtins
Library
Documentation
Tests
Build
Windows
macOS
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
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
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
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
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
C API
Tests
Build
Tools/Demos
Windows
Python 3.6.0 alpha 4?
Core and Builtins
Library
Tests
Windows
Build
Python 3.6.0 alpha 3?
Core and Builtins
Library
Security
Library
Security
Library
C API
Build
Tools/Demos
Documentation
Tests
Python 3.6.0 alpha 2?
Core and Builtins
Library
Security
Library
Security
Library
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
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
C API
Documentation
Tests
Tools/Demos
Windows
Build
Python 3.5.2 final?
Core and Builtins
Tests
Python 3.5.2 release candidate 1?
Core and Builtins
Security
Library
Security
Library
Security
Library
Security
Library
Security
Library
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
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
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
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
Build
C API
Documentation
Tests
Tools/Demos
Windows
The Python Tutorial
1. Whetting Your Appetite
2. Using the Python Interpreter
2.1. Invoking the Interpreter
2.1.1. Argument Passing
2.1.2. Interactive Mode
2.2. The Interpreter and Its Environment
2.2.1. Source Code Encoding
3. An Informal Introduction to Python
3.1. Using Python as a Calculator
3.1.1. Numbers
3.1.2. Strings
3.1.3. Lists
3.2. First Steps Towards Programming
4. More Control Flow Tools
4.1. if Statements
4.2. for Statements
4.3. The range() Function
4.4. break and continue Statements, and else Clauses on Loops
4.5. pass Statements
4.6. Defining Functions
4.7. More on Defining Functions
4.7.1. Default Argument Values
4.7.2. Keyword Arguments
4.7.3. Arbitrary Argument Lists
4.7.4. Unpacking Argument Lists
4.7.5. Lambda Expressions
4.7.6. Documentation Strings
4.7.7. Function Annotations
4.8. Intermezzo: Coding Style
5. Data Structures
5.1. More on Lists
5.1.1. Using Lists as Stacks
5.1.2. Using Lists as Queues
5.1.3. List Comprehensions
5.1.4. Nested List Comprehensions
5.2. The del statement
5.3. Tuples and Sequences
5.4. Sets
5.5. Dictionaries
5.6. Looping Techniques
5.7. More on Conditions
5.8. Comparing Sequences and Other Types
6. Modules
6.1. More on Modules
6.1.1. Executing modules as scripts
6.1.2. The Module Search Path
6.1.3. “Compiled” Python files
6.2. Standard Modules
6.3. The dir() Function
6.4. Packages
6.4.1. Importing * From a Package
6.4.2. Intra-package References
6.4.3. Packages in Multiple Directories
7. Input and Output
7.1. Fancier Output Formatting
7.1.1. Old string formatting
7.2. Reading and Writing Files
7.2.1. Methods of File Objects
7.2.2. Saving structured data with json
8. Errors and Exceptions
8.1. Syntax Errors
8.2. Exceptions
8.3. Handling Exceptions
8.4. Raising Exceptions
8.5. User-defined Exceptions
8.6. Defining Clean-up Actions
8.7. Predefined Clean-up Actions
9. Classes
9.1. A Word About Names and Objects
9.2. Python Scopes and Namespaces
9.2.1. Scopes and Namespaces Example
9.3. A First Look at Classes
9.3.1. Class Definition Syntax
9.3.2. Class Objects
9.3.3. Instance Objects
9.3.4. Method Objects
9.3.5. Class and Instance Variables
9.4. Random Remarks
9.5. Inheritance
9.5.1. Multiple Inheritance
9.6. Private Variables
9.7. Odds and Ends
9.8. Iterators
9.9. Generators
9.10. Generator Expressions
10. Brief Tour of the Standard Library
10.1. Operating System Interface
10.2. File Wildcards
10.3. Command Line Arguments
10.4. Error Output Redirection and Program Termination
10.5. String Pattern Matching
10.6. Mathematics
10.7. Internet Access
10.8. Dates and Times
10.9. Data Compression
10.10. Performance Measurement
10.11. Quality Control
10.12. Batteries Included
11. Brief Tour of the Standard Library — Part II
11.1. Output Formatting
11.2. Templating
11.3. Working with Binary Data Record Layouts
11.4. Multi-threading
11.5. Logging
11.6. Weak References
11.7. Tools for Working with Lists
11.8. Decimal Floating Point Arithmetic
12. Virtual Environments and Packages
12.1. Introduction
12.2. Creating Virtual Environments
12.3. Managing Packages with pip
13. What Now?
14. Interactive Input Editing and History Substitution
14.1. Tab Completion and History Editing
14.2. Alternatives to the Interactive Interpreter
15. Floating Point Arithmetic: Issues and Limitations
15.1. Representation Error
16. Appendix
16.1. Interactive Mode
16.1.1. Error Handling
16.1.2. Executable Python Scripts
16.1.3. The Interactive Startup File
16.1.4. The Customization Modules
Python Setup and Usage
1. Command line and environment
1.1. Command line
1.1.1. Interface options
1.1.2. Generic options
1.1.3. Miscellaneous options
1.1.4. Options you shouldn’t use
1.2. Environment variables
1.2.1. Debug-mode variables
2. Using Python on Unix platforms
2.1. Getting and installing the latest version of Python
2.1.1. On Linux
2.1.2. On FreeBSD and OpenBSD
2.1.3. On OpenSolaris
2.2. Building Python
2.3. Python-related paths and files
2.4. Miscellaneous
2.5. Editors and IDEs
3. Using Python on Windows
3.1. Installing Python
3.1.1. Supported Versions
3.1.2. Installation Steps
3.1.3. Removing the MAX_PATH Limitation
3.1.4. Installing Without UI
3.1.5. Installing Without Downloading
3.1.6. Modifying an install
3.1.7. Other Platforms
3.2. Alternative bundles
3.3. Configuring Python
3.3.1. Excursus: Setting environment variables
3.3.2. Finding the Python executable
3.4. Python Launcher for Windows
3.4.1. Getting started
3.4.1.1. From the command-line
3.4.1.2. Virtual environments
3.4.1.3. From a script
3.4.1.4. From file associations
3.4.2. Shebang Lines
3.4.3. Arguments in shebang lines
3.4.4. Customization
3.4.4.1. Customization via INI files
3.4.4.2. Customizing default Python versions
3.4.5. Diagnostics
3.5. Finding modules
3.6. Additional modules
3.6.1. PyWin32
3.6.2. cx_Freeze
3.6.3. WConio
3.7. Compiling Python on Windows
3.8. Embedded Distribution
3.8.1. Python Application
3.8.2. Embedding Python
3.9. Other resources
4. Using Python on a Macintosh
4.1. Getting and Installing MacPython
4.1.1. How to run a Python script
4.1.2. Running scripts with a GUI
4.1.3. Configuration
4.2. The IDE
4.3. Installing Additional Python Packages
4.4. GUI Programming on the Mac
4.5. Distributing Python Applications on the Mac
4.6. Other Resources
The Python Language Reference
1. Introduction
1.1. Alternate Implementations
1.2. Notation
2. Lexical analysis
2.1. Line structure
2.1.1. Logical lines
2.1.2. Physical lines
2.1.3. Comments
2.1.4. Encoding declarations
2.1.5. Explicit line joining
2.1.6. Implicit line joining
2.1.7. Blank lines
2.1.8. Indentation
2.1.9. Whitespace between tokens
2.2. Other tokens
2.3. Identifiers and keywords
2.3.1. Keywords
2.3.2. Reserved classes of identifiers
2.4. Literals
2.4.1. String and Bytes literals
2.4.2. String literal concatenation
2.4.3. Formatted string literals
2.4.4. Numeric literals
2.4.5. Integer literals
2.4.6. Floating point literals
2.4.7. Imaginary literals
2.5. Operators
2.6. Delimiters
3. Data model
3.1. Objects, values and types
3.2. The standard type hierarchy
3.3. Special method names
3.3.1. Basic customization
3.3.2. Customizing attribute access
3.3.2.1. Customizing module attribute access
3.3.2.2. Implementing Descriptors
3.3.2.3. Invoking Descriptors
3.3.2.4. __slots__
3.3.2.4.1. Notes on using __slots__
3.3.3. Customizing class creation
3.3.3.1. Metaclasses
3.3.3.2. Determining the appropriate metaclass
3.3.3.3. Preparing the class namespace
3.3.3.4. Executing the class body
3.3.3.5. Creating the class object
3.3.3.6. Metaclass example
3.3.4. Customizing instance and subclass checks
3.3.5. Emulating callable objects
3.3.6. Emulating container types
3.3.7. Emulating numeric types
3.3.8. With Statement Context Managers
3.3.9. Special method lookup
3.4. Coroutines
3.4.1. Awaitable Objects
3.4.2. Coroutine Objects
3.4.3. Asynchronous Iterators
3.4.4. Asynchronous Context Managers
4. Execution model
4.1. Structure of a program
4.2. Naming and binding
4.2.1. Binding of names
4.2.2. Resolution of names
4.2.3. Builtins and restricted execution
4.2.4. Interaction with dynamic features
4.3. Exceptions
5. The import system
5.1. importlib
5.2. Packages
5.2.1. Regular packages
5.2.2. Namespace packages
5.3. Searching
5.3.1. The module cache
5.3.2. Finders and loaders
5.3.3. Import hooks
5.3.4. The meta path
5.4. Loading
5.4.1. Loaders
5.4.2. Submodules
5.4.3. Module spec
5.4.4. Import-related module attributes
5.4.5. module.__path__
5.4.6. Module reprs
5.5. The Path Based Finder
5.5.1. Path entry finders
5.5.2. Path entry finder protocol
5.6. Replacing the standard import system
5.7. Special considerations for __main__
5.7.1. __main__.__spec__
5.8. Open issues
5.9. References
6. Expressions
6.1. Arithmetic conversions
6.2. Atoms
6.2.1. Identifiers (Names)
6.2.2. Literals
6.2.3. Parenthesized forms
6.2.4. Displays for lists, sets and dictionaries
6.2.5. List displays
6.2.6. Set displays
6.2.7. Dictionary displays
6.2.8. Generator expressions
6.2.9. Yield expressions
6.2.9.1. Generator-iterator methods
6.2.9.2. Examples
6.2.9.3. Asynchronous generator functions
6.2.9.4. Asynchronous generator-iterator methods
6.3. Primaries
6.3.1. Attribute references
6.3.2. Subscriptions
6.3.3. Slicings
6.3.4. Calls
6.4. Await expression
6.5. The power operator
6.6. Unary arithmetic and bitwise operations
6.7. Binary arithmetic operations
6.8. Shifting operations
6.9. Binary bitwise operations
6.10. Comparisons
6.10.1. Value comparisons
6.10.2. Membership test operations
6.10.3. Identity comparisons
6.11. Boolean operations
6.12. Conditional expressions
6.13. Lambdas
6.14. Expression lists
6.15. Evaluation order
6.16. Operator precedence
7. Simple statements
7.1. Expression statements
7.2. Assignment statements
7.2.1. Augmented assignment statements
7.2.2. Annotated assignment statements
7.3. The assert statement
7.4. The pass statement
7.5. The del statement
7.6. The return statement
7.7. The yield statement
7.8. The raise statement
7.9. The break statement
7.10. The continue statement
7.11. The import statement
7.11.1. Future statements
7.12. The global statement
7.13. The nonlocal statement
8. Compound statements
8.1. The if statement
8.2. The while statement
8.3. The for statement
8.4. The try statement
8.5. The with statement
8.6. Function definitions
8.7. Class definitions
8.8. Coroutines
8.8.1. Coroutine function definition
8.8.2. The async for statement
8.8.3. The async with statement
9. Top-level components
9.1. Complete Python programs
9.2. File input
9.3. Interactive input
9.4. Expression input
10. Full Grammar specification
The Python Standard Library
1. Introduction
2. Built-in Functions
3. Built-in Constants
3.1. Constants added by the site module
4. Built-in Types
4.1. Truth Value Testing
4.2. Boolean Operations — and, or, not
4.3. Comparisons
4.4. Numeric Types — int, float, complex
4.4.1. Bitwise Operations on Integer Types
4.4.2. Additional Methods on Integer Types
4.4.3. Additional Methods on Float
4.4.4. Hashing of numeric types
4.5. Iterator Types
4.5.1. Generator Types
4.6. Sequence Types — list, tuple, range
4.6.1. Common Sequence Operations
4.6.2. Immutable Sequence Types
4.6.3. Mutable Sequence Types
4.6.4. Lists
4.6.5. Tuples
4.6.6. Ranges
4.7. Text Sequence Type — str
4.7.1. String Methods
4.7.2. printf-style String Formatting
4.8. Binary Sequence Types — bytes, bytearray, memoryview
4.8.1. Bytes Objects
4.8.2. Bytearray Objects
4.8.3. Bytes and Bytearray Operations
4.8.4. printf-style Bytes Formatting
4.8.5. Memory Views
4.9. Set Types — set, frozenset
4.10. Mapping Types — dict
4.10.1. Dictionary view objects
4.11. Context Manager Types
4.12. Other Built-in Types
4.12.1. Modules
4.12.2. Classes and Class Instances
4.12.3. Functions
4.12.4. Methods
4.12.5. Code Objects
4.12.6. Type Objects
4.12.7. The Null Object
4.12.8. The Ellipsis Object
4.12.9. The NotImplemented Object
4.12.10. Boolean Values
4.12.11. Internal Objects
4.13. Special Attributes
5. Built-in Exceptions
5.1. Base classes
5.2. Concrete exceptions
5.2.1. OS exceptions
5.3. Warnings
5.4. Exception hierarchy
6. Text Processing Services
6.1. string — Common string operations
6.1.1. String constants
6.1.2. Custom String Formatting
6.1.3. Format String Syntax
6.1.3.1. Format Specification Mini-Language
6.1.3.2. Format examples
6.1.4. Template strings
6.1.5. Helper functions
6.2. re — Regular expression operations
6.2.1. Regular Expression Syntax
6.2.2. Module Contents
6.2.3. Regular Expression Objects
6.2.4. Match Objects
6.2.5. Regular Expression Examples
6.2.5.1. Checking for a Pair
6.2.5.2. Simulating scanf()
6.2.5.3. search() vs. match()
6.2.5.4. Making a Phonebook
6.2.5.5. Text Munging
6.2.5.6. Finding all Adverbs
6.2.5.7. Finding all Adverbs and their Positions
6.2.5.8. Raw String Notation
6.2.5.9. Writing a Tokenizer
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 — Text wrapping and filling
6.5. unicodedata — Unicode Database
6.6. stringprep — Internet String Preparation
6.7. readline — GNU readline interface
6.7.1. Init file
6.7.2. Line buffer
6.7.3. History file
6.7.4. History list
6.7.5. Startup hooks
6.7.6. Completion
6.7.7. Example
6.8. rlcompleter — Completion function for GNU readline
6.8.1. Completer Objects
7. Binary Data Services
7.1. struct — Interpret bytes as packed binary data
7.1.1. Functions and Exceptions
7.1.2. Format Strings
7.1.2.1. Byte Order, Size, and Alignment
7.1.2.2. Format Characters
7.1.2.3. Examples
7.1.3. Classes
7.2. codecs — Codec registry and base classes
7.2.1. Codec Base Classes
7.2.1.1. Error Handlers
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. Data Types
8.1. datetime — Basic date and time types
8.1.1. Available Types
8.1.2. timedelta Objects
8.1.3. date Objects
8.1.4. datetime Objects
8.1.5. time Objects
8.1.6. tzinfo Objects
8.1.7. timezone Objects
8.1.8. strftime() and strptime() Behavior
8.2. calendar — General calendar-related functions
8.3. collections — Container datatypes
8.3.1. ChainMap objects
8.3.1.1. ChainMap Examples and Recipes
8.3.2. Counter objects
8.3.3. deque objects
8.3.3.1. deque Recipes
8.3.4. defaultdict objects
8.3.4.1. defaultdict Examples
8.3.5. namedtuple() Factory Function for Tuples with Named Fields
8.3.6. OrderedDict objects
8.3.6.1. OrderedDict Examples and Recipes
8.3.7. UserDict objects
8.3.8. UserList objects
8.3.9. UserString objects
8.4. collections.abc — Abstract Base Classes for Containers
8.4.1. Collections Abstract Base Classes
8.5. heapq — Heap queue algorithm
8.5.1. Basic Examples
8.5.2. Priority Queue Implementation Notes
8.5.3. Theory
8.6. bisect — Array bisection algorithm
8.6.1. Searching Sorted Lists
8.6.2. Other Examples
8.7. array — Efficient arrays of numeric values
8.8. weakref — Weak references
8.8.1. Weak Reference Objects
8.8.2. Example
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 — Shallow and deep copy operations
8.11. pprint — Data pretty printer
8.11.1. PrettyPrinter Objects
8.11.2. Example
8.12. reprlib — Alternate repr() implementation
8.12.1. Repr Objects
8.12.2. Subclassing Repr Objects
8.13. enum — Support for enumerations
8.13.1. Module Contents
8.13.2. Creating an Enum
8.13.3. Programmatic access to enumeration members and their attributes
8.13.4. Duplicating enum members and values
8.13.5. Ensuring unique enumeration values
8.13.6. Using automatic values
8.13.7. Iteration
8.13.8. Comparisons
8.13.9. Allowed members and attributes of enumerations
8.13.10. Restricted subclassing of enumerations
8.13.11. Pickling
8.13.12. Functional API
8.13.13. Derived Enumerations
8.13.13.1. IntEnum
8.13.13.2. IntFlag
8.13.13.3. Flag
8.13.13.4. Others
8.13.14. Interesting examples
8.13.14.1. Omitting values
8.13.14.1.1. Using auto
8.13.14.1.2. Using object
8.13.14.1.3. Using a descriptive string
8.13.14.1.4. Using a custom __new__()
8.13.14.2. OrderedEnum
8.13.14.3. DuplicateFreeEnum
8.13.14.4. Planet
8.13.15. How are Enums different?
8.13.15.1. Enum Classes
8.13.15.2. Enum Members (aka instances)
8.13.15.3. Finer Points
8.13.15.3.1. Supported __dunder__ names
8.13.15.3.2. Supported _sunder_ names
8.13.15.3.3. Enum member type
8.13.15.3.4. Boolean value of Enum classes and members
8.13.15.3.5. Enum classes with methods
8.13.15.3.6. Combining members of Flag
9. Numeric and Mathematical Modules
9.1. numbers — Numeric abstract base classes
9.1.1. The numeric tower
9.1.2. Notes for type implementors
9.1.2.1. Adding More Numeric ABCs
9.1.2.2. Implementing the arithmetic operations
9.2. math — Mathematical functions
9.2.1. Number-theoretic and representation functions
9.2.2. Power and logarithmic functions
9.2.3. Trigonometric functions
9.2.4. Angular conversion
9.2.5. Hyperbolic functions
9.2.6. Special functions
9.2.7. Constants
9.3. cmath — Mathematical functions for complex numbers
9.3.1. Conversions to and from polar coordinates
9.3.2. Power and logarithmic functions
9.3.3. Trigonometric functions
9.3.4. Hyperbolic functions
9.3.5. Classification functions
9.3.6. Constants
9.4. decimal — Decimal fixed point and floating point arithmetic
9.4.1. Quick-start Tutorial
9.4.2. Decimal objects
9.4.2.1. Logical operands
9.4.3. Context objects
9.4.4. Constants
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. Recipes
9.4.10. Decimal FAQ
9.5. fractions — Rational numbers
9.6. random — Generate pseudo-random numbers
9.6.1. Bookkeeping functions
9.6.2. Functions for integers
9.6.3. Functions for sequences
9.6.4. Real-valued distributions
9.6.5. Alternative Generator
9.6.6. Notes on Reproducibility
9.6.7. Examples and Recipes
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. Functional Programming Modules
10.1. itertools — Functions creating iterators for efficient looping
10.1.1. Itertool functions
10.1.2. Itertools Recipes
10.2. functools — Higher-order functions and operations on callable objects
10.2.1. partial Objects
10.3. operator — Standard operators as functions
10.3.1. Mapping Operators to Functions
10.3.2. Inplace Operators
11. File and Directory Access
11.1. pathlib — Object-oriented filesystem paths
11.1.1. Basic use
11.1.2. Pure paths
11.1.2.1. General properties
11.1.2.2. Operators
11.1.2.3. Accessing individual parts
11.1.2.4. Methods and properties
11.1.3. Concrete paths
11.1.3.1. Methods
11.2. os.path — Common pathname manipulations
11.3. fileinput — Iterate over lines from multiple input streams
11.4. stat — Interpreting stat() results
11.5. filecmp — File and Directory Comparisons
11.5.1. The dircmp class
11.6. tempfile — Generate temporary files and directories
11.6.1. Examples
11.6.2. Deprecated functions and variables
11.7. glob — Unix style pathname pattern expansion
11.8. fnmatch — Unix filename pattern matching
11.9. linecache — Random access to text lines
11.10. shutil — High-level file operations
11.10.1. Directory and files operations
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 — Mac OS 9 path manipulation functions
12. Data Persistence
12.1. pickle — Python object serialization
12.1.1. Relationship to other Python modules
12.1.1.1. Comparison with 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. Performance
12.1.8. Examples
12.2. copyreg — Register pickle support functions
12.2.1. Example
12.3. shelve — Python object persistence
12.3.1. Restrictions
12.3.2. Example
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 — DB-API 2.0 interface for SQLite databases
12.6.1. Module functions and constants
12.6.2. Connection Objects
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. Multithreading
13. Data Compression and Archiving
13.1. zlib — Compression compatible with gzip
13.2. gzip — Support for gzip files
13.2.1. Examples of usage
13.3. bz2 — Support for bzip2 compression
13.3.1. (De)compression of files
13.3.2. Incremental (de)compression
13.3.3. One-shot (de)compression
13.4. lzma — Compression using the LZMA algorithm
13.4.1. Reading and writing compressed files
13.4.2. Compressing and decompressing data in memory
13.4.3. Miscellaneous
13.4.4. Specifying custom filter chains
13.4.5. Examples
13.5. zipfile — Work with ZIP archives
13.5.1. ZipFile Objects
13.5.2. PyZipFile Objects
13.5.3. ZipInfo Objects
13.5.4. Command-Line Interface
13.5.4.1. Command-line options
13.6. tarfile — Read and write tar archive files
13.6.1. TarFile Objects
13.6.2. TarInfo Objects
13.6.3. Command-Line Interface
13.6.3.1. Command-line options
13.6.4. Examples
13.6.5. Supported tar formats
13.6.6. Unicode issues
14. File Formats
14.1. csv — CSV File Reading and Writing
14.1.1. Module Contents
14.1.2. Dialects and Formatting Parameters
14.1.3. Reader Objects
14.1.4. Writer Objects
14.1.5. Examples
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 — netrc file processing
14.3.1. netrc Objects
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. Examples
15. Cryptographic Services
15.1. hashlib — Secure hashes and message digests
15.1.1. Hash algorithms
15.1.2. SHAKE variable length digests
15.1.3. Key derivation
15.1.4. BLAKE2
15.1.4.1. Creating hash objects
15.1.4.2. Constants
15.1.4.3. Examples
15.1.4.3.1. Simple hashing
15.1.4.3.2. Using different digest sizes
15.1.4.3.3. Keyed hashing
15.1.4.3.4. Randomized hashing
15.1.4.3.5. Personalization
15.1.4.3.6. Tree mode
15.1.4.4. Credits
15.2. hmac — Keyed-Hashing for Message Authentication
15.3. secrets — Generate secure random numbers for managing secrets
15.3.1. Random numbers
15.3.2. Generating tokens
15.3.2.1. How many bytes should tokens use?
15.3.3. Other functions
15.3.4. Recipes and best practices
16. Generic Operating System Services
16.1. os — Miscellaneous operating system interfaces
16.1.1. File Names, Command Line Arguments, and Environment Variables
16.1.2. Process Parameters
16.1.3. File Object Creation
16.1.4. File Descriptor Operations
16.1.4.1. Querying the size of a terminal
16.1.4.2. Inheritance of File Descriptors
16.1.5. Files and Directories
16.1.5.1. Linux extended attributes
16.1.6. Process Management
16.1.7. Interface to the scheduler
16.1.8. Miscellaneous System Information
16.1.9. Random numbers
16.2. io — Core tools for working with streams
16.2.1. Overview
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. Performance
16.2.4.1. Binary I/O
16.2.4.2. Text I/O
16.2.4.3. Multi-threading
16.2.4.4. Reentrancy
16.3. time — Time access and conversions
16.3.1. Functions
16.3.2. Clock ID Constants
16.3.3. Timezone Constants
16.4. argparse — Parser for command-line options, arguments and sub-commands
16.4.1. Example
16.4.1.1. Creating a parser
16.4.1.2. Adding arguments
16.4.1.3. Parsing arguments
16.4.2. ArgumentParser objects
16.4.2.1. prog
16.4.2.2. usage
16.4.2.3. description
16.4.2.4. epilog
16.4.2.5. parents
16.4.2.6. formatter_class
16.4.2.7. prefix_chars
16.4.2.8. fromfile_prefix_chars
16.4.2.9. argument_default
16.4.2.10. allow_abbrev
16.4.2.11. conflict_handler
16.4.2.12. add_help
16.4.3. The add_argument() method
16.4.3.1. name or flags
16.4.3.2. action
16.4.3.3. nargs
16.4.3.4. const
16.4.3.5. default
16.4.3.6. type
16.4.3.7. choices
16.4.3.8. required
16.4.3.9. help
16.4.3.10. metavar
16.4.3.11. dest
16.4.3.12. Action classes
16.4.4. The parse_args() method
16.4.4.1. Option value syntax
16.4.4.2. Invalid arguments
16.4.4.3. Arguments containing -
16.4.4.4. Argument abbreviations (prefix matching)
16.4.4.5. Beyond sys.argv
16.4.4.6. The Namespace object
16.4.5. Other utilities
16.4.5.1. Sub-commands
16.4.5.2. FileType objects
16.4.5.3. Argument groups
16.4.5.4. Mutual exclusion
16.4.5.5. Parser defaults
16.4.5.6. Printing help
16.4.5.7. Partial parsing
16.4.5.8. Customizing file parsing
16.4.5.9. Exiting methods
16.4.6. Upgrading optparse code
16.5. getopt — C-style parser for command line options
16.6. logging — Logging facility for Python
16.6.1. Logger Objects
16.6.2. Logging Levels
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. Module-Level Functions
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. getpass — Portable password input
16.10. curses — Terminal handling for character-cell displays
16.10.1. Functions
16.10.2. Window Objects
16.10.3. Constants
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. Functions
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 — Standard errno system symbols
16.16. ctypes — A foreign function library for Python
16.16.1. ctypes tutorial
16.16.1.1. Loading dynamic link libraries
16.16.1.2. Accessing functions from loaded dlls
16.16.1.3. Calling functions
16.16.1.4. Fundamental data types
16.16.1.5. Calling functions, continued
16.16.1.6. Calling functions with your own custom data types
16.16.1.7. Specifying the required argument types (function prototypes)
16.16.1.8. Return types
16.16.1.9. Passing pointers (or: passing parameters by reference)
16.16.1.10. Structures and unions
16.16.1.11. Structure/union alignment and byte order
16.16.1.12. Bit fields in structures and unions
16.16.1.13. Arrays
16.16.1.14. Pointers
16.16.1.15. Type conversions
16.16.1.16. Incomplete Types
16.16.1.17. Callback functions
16.16.1.18. Accessing values exported from dlls
16.16.1.19. Surprises
16.16.1.20. Variable-sized data types
16.16.2. ctypes reference
16.16.2.1. Finding shared libraries
16.16.2.2. Loading shared libraries
16.16.2.3. Foreign functions
16.16.2.4. Function prototypes
16.16.2.5. Utility functions
16.16.2.6. Data types
16.16.2.7. Fundamental data types
16.16.2.8. Structured data types
16.16.2.9. Arrays and pointers
17. Concurrent Execution
17.1. threading — Thread-based parallelism
17.1.1. Thread-Local Data
17.1.2. Thread Objects
17.1.3. Lock Objects
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 — Process-based parallelism
17.2.1. Introduction
17.2.1.1. The Process class
17.2.1.2. Contexts and start methods
17.2.1.3. Exchanging objects between processes
17.2.1.4. Synchronization between processes
17.2.1.5. Sharing state between processes
17.2.1.6. Using a pool of workers
17.2.2. Reference
17.2.2.1. Process and exceptions
17.2.2.2. Pipes and Queues
17.2.2.3. Miscellaneous
17.2.2.4. Connection Objects
17.2.2.5. Synchronization primitives
17.2.2.6. Shared ctypes Objects
17.2.2.6.1. The multiprocessing.sharedctypes module
17.2.2.7. Managers
17.2.2.7.1. Customized managers
17.2.2.7.2. Using a remote manager
17.2.2.8. Proxy Objects
17.2.2.8.1. Cleanup
17.2.2.9. Process Pools
17.2.2.10. Listeners and Clients
17.2.2.10.1. Address Formats
17.2.2.11. Authentication keys
17.2.2.12. Logging
17.2.2.13. The multiprocessing.dummy module
17.2.3. Programming guidelines
17.2.3.1. All start methods
17.2.3.2. The spawn and forkserver start methods
17.2.4. Examples
17.3. The concurrent package
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 — Subprocess management
17.5.1. Using the subprocess Module
17.5.1.1. Frequently Used Arguments
17.5.1.2. Popen Constructor
17.5.1.3. Exceptions
17.5.2. Security Considerations
17.5.3. Popen Objects
17.5.4. Windows Popen Helpers
17.5.4.1. Constants
17.5.5. Older high-level API
17.5.6. Replacing Older Functions with the subprocess Module
17.5.6.1. Replacing /bin/sh shell backquote
17.5.6.2. Replacing shell pipeline
17.5.6.3. Replacing os.system()
17.5.6.4. Replacing the os.spawn family
17.5.6.5. Replacing os.popen(), os.popen2(), os.popen3()
17.5.6.6. Replacing functions from the popen2 module
17.5.7. Legacy Shell Invocation Functions
17.5.8. Notes
17.5.8.1. Converting an argument sequence to a string on Windows
17.6. sched — Event scheduler
17.6.1. Scheduler Objects
17.7. queue — A synchronized queue class
17.7.1. Queue Objects
17.8. dummy_threading — Drop-in replacement for the threading module
17.9. _thread — Low-level threading API
17.10. _dummy_thread — Drop-in replacement for the _thread module
18. Interprocess Communication and Networking
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. Constants
18.1.2.3. Functions
18.1.2.3.1. Creating sockets
18.1.2.3.2. Other functions
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. Example
18.2. ssl — TLS/SSL wrapper for socket objects
18.2.1. Functions, Constants, and Exceptions
18.2.1.1. Socket creation
18.2.1.2. Context creation
18.2.1.3. Random generation
18.2.1.4. Certificate handling
18.2.1.5. Constants
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. Examples
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. Examples
18.5. asyncio — Asynchronous I/O, event loop, coroutines and tasks
18.5.1. Base Event Loop
18.5.1.1. Run an event loop
18.5.1.2. Calls
18.5.1.3. Delayed calls
18.5.1.4. Futures
18.5.1.5. Tasks
18.5.1.6. Creating connections
18.5.1.7. Creating listening connections
18.5.1.8. Watch file descriptors
18.5.1.9. Low-level socket operations
18.5.1.10. Resolve host name
18.5.1.11. Connect pipes
18.5.1.12. UNIX signals
18.5.1.13. Executor
18.5.1.14. Error Handling API
18.5.1.15. Debug mode
18.5.1.16. Server
18.5.1.17. Handle
18.5.1.18. Event loop examples
18.5.1.18.1. Hello World with call_soon()
18.5.1.18.2. Display the current date with call_later()
18.5.1.18.3. Watch a file descriptor for read events
18.5.1.18.4. Set signal handlers for SIGINT and SIGTERM
18.5.2. Event loops
18.5.2.1. Event loop functions
18.5.2.2. Available event loops
18.5.2.3. Platform support
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. Tasks and coroutines
18.5.3.1. Coroutines
18.5.3.1.1. Example: Hello World coroutine
18.5.3.1.2. Example: Coroutine displaying the current date
18.5.3.1.3. Example: Chain coroutines
18.5.3.2. InvalidStateError
18.5.3.3. TimeoutError
18.5.3.4. Future
18.5.3.4.1. Example: Future with run_until_complete()
18.5.3.4.2. Example: Future with run_forever()
18.5.3.5. Task
18.5.3.5.1. Example: Parallel execution of tasks
18.5.3.6. Task functions
18.5.4. Transports and protocols (callback based API)
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. Datagram protocols
18.5.4.2.5. Flow control callbacks
18.5.4.2.6. Coroutines and protocols
18.5.4.3. Protocol examples
18.5.4.3.1. TCP echo client protocol
18.5.4.3.2. TCP echo server protocol
18.5.4.3.3. UDP echo client protocol
18.5.4.3.4. UDP echo server protocol
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. Get HTTP headers
18.5.5.7.4. Register an open socket to wait for data using streams
18.5.6. Subprocess
18.5.6.1. Windows event loop
18.5.6.2. Create a subprocess: high-level API using Process
18.5.6.3. Create a subprocess: low-level API using subprocess.Popen
18.5.6.4. Constants
18.5.6.5. Process
18.5.6.6. Subprocess and threads
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. Synchronization primitives
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. Semaphores
18.5.7.2.1. Semaphore
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. Develop with asyncio
18.5.9.1. Debug mode of asyncio
18.5.9.2. Cancellation
18.5.9.3. Concurrency and multithreading
18.5.9.4. Handle blocking functions correctly
18.5.9.5. Logging
18.5.9.6. Detect coroutine objects never scheduled
18.5.9.7. Detect exceptions never consumed
18.5.9.8. Chain coroutines correctly
18.5.9.9. Pending task destroyed
18.5.9.10. Close transports and event loops
18.6. asyncore — Asynchronous socket handler
18.6.1. asyncore Example basic HTTP client
18.6.2. asyncore Example basic echo server
18.7. asynchat — Asynchronous socket command/response handler
18.7.1. asynchat Example
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. Example
18.9. mmap — Memory-mapped file support
19. Internet Data Handling
19.1. email — An email and MIME handling package
19.1.1. email.message: Representing an email message
19.1.2. email.parser: Parsing email messages
19.1.2.1. FeedParser API
19.1.2.2. Parser API
19.1.2.3. Additional notes
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: Examples
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: Encoders
19.1.14. email.utils: Miscellaneous utilities
19.1.15. email.iterators: Iterators
19.2. json — JSON encoder and decoder
19.2.1. Basic Usage
19.2.2. Encoders and Decoders
19.2.3. Exceptions
19.2.4. Standard Compliance and Interoperability
19.2.4.1. Character Encodings
19.2.4.2. Infinite and NaN Number Values
19.2.4.3. Repeated Names Within an Object
19.2.4.4. Top-level Non-Object, Non-Array Values
19.2.4.5. Implementation Limitations
19.2.5. Command Line Interface
19.2.5.1. Command line options
19.3. mailcap — Mailcap file handling
19.4. mailbox — Manipulate mailboxes in various formats
19.4.1. Mailbox objects
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. Examples
19.5. mimetypes — Map filenames to MIME types
19.5.1. MimeTypes Objects
19.6. base64 — Base16, Base32, Base64, Base85 Data Encodings
19.7. binhex — Encode and decode binhex4 files
19.7.1. Notes
19.8. binascii — Convert between binary and ASCII
19.9. quopri — Encode and decode MIME quoted-printable data
19.10. uu — Encode and decode uuencode files
20. Structured Markup Processing Tools
20.1. html — HyperText Markup Language support
20.2. html.parser — Simple HTML and XHTML parser
20.2.1. Example HTML Parser Application
20.2.2. HTMLParser Methods
20.2.3. Examples
20.3. html.entities — Definitions of HTML general entities
20.4. XML Processing Modules
20.4.1. XML vulnerabilities
20.4.2. The defusedxml and defusedexpat Packages
20.5. xml.etree.ElementTree — The ElementTree XML API
20.5.1. Tutorial
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. Example
20.5.2.2. Supported XPath syntax
20.5.3. Reference
20.5.3.1. Functions
20.5.3.2. Element Objects
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 — The Document Object Model API
20.6.1. Module Contents
20.6.2. Objects in the DOM
20.6.2.1. DOMImplementation Objects
20.6.2.2. Node Objects
20.6.2.3. NodeList Objects
20.6.2.4. DocumentType Objects
20.6.2.5. Document Objects
20.6.2.6. Element Objects
20.6.2.7. Attr Objects
20.6.2.8. NamedNodeMap Objects
20.6.2.9. Comment Objects
20.6.2.10. Text and CDATASection Objects
20.6.2.11. ProcessingInstruction Objects
20.6.2.12. Exceptions
20.6.3. Conformance
20.6.3.1. Type Mapping
20.6.3.2. Accessor Methods
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 — Support for SAX2 parsers
20.9.1. SAXException Objects
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 — SAX Utilities
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. Example
20.13.4. Content Model Descriptions
20.13.5. Expat error constants
21. Internet Protocols and Support
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. Functions
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 — Traceback manager for CGI scripts
21.4. wsgiref — WSGI Utilities and Reference Implementation
21.4.1. wsgiref.util – WSGI environment utilities
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. Examples
21.5. urllib — URL handling modules
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. Examples
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 — Exception classes raised by urllib.request
21.10. urllib.robotparser — Parser for robots.txt
21.11. http — HTTP modules
21.11.1. HTTP status codes
21.12. http.client — HTTP protocol client
21.12.1. HTTPConnection Objects
21.12.2. HTTPResponse Objects
21.12.3. Examples
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. Methods
21.16.2. Utility functions
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. Example
21.21. socketserver — A framework for network servers
21.21.1. Server Creation Notes
21.21.2. Server Objects
21.21.3. Request Handler Objects
21.21.4. Examples
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 — HTTP state management
21.23.1. Cookie Objects
21.23.2. Morsel Objects
21.23.3. Example
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. Cookie Objec
1. Whetting Your Appetite 4
2. Using the Python Interpreter 6
2.1. Invoking the Interpreter 7
2.1.1. Argument Passing 8
2.1.2. Interactive Mode 8
2.2. The Interpreter and Its Environment 9
2.2.1. Source Code Encoding 9
3. An Informal Introduction to Python 10
3.1. Using Python as a Calculator 11
3.1.1. Numbers 11
3.1.2. Strings 13
3.1.3. Lists 19
3.2. First Steps Towards Programming 21
4. More Control Flow Tools 24
4.1. if Statements 24
4.2. for Statements 24
4.3. The range() Function 25
4.4. break and continue Statements, and else Clauses on Loops 27
4.5. pass Statements 28
4.6. Defining Functions 29
4.7. More on Defining Functions 31
4.7.1. Default Argument Values 31
4.7.2. Keyword Arguments 33
4.7.3. Arbitrary Argument Lists 35
4.7.4. Unpacking Argument Lists 36
4.7.5. Lambda Expressions 37
4.7.6. Documentation Strings 38
4.7.7. Function Annotations 39
4.8. Intermezzo: Coding Style 39
5. Data Structures 40
5.1. More on Lists 41
5.1.1. Using Lists as Stacks 43
5.1.2. Using Lists as Queues 43
5.1.3. List Comprehensions 44
5.1.4. Nested List Comprehensions 46
5.2. The del statement 47
5.3. Tuples and Sequences 48
5.4. Sets 50
5.5. Dictionaries 51
5.6. Looping Techniques 53
5.7. More on Conditions 55
5.8. Comparing Sequences and Other Types 56
6. Modules 57
6.1. More on Modules 58
6.1.1. Executing modules as scripts 60
6.1.2. The Module Search Path 61
6.1.3. “Compiled” Python files 61
6.2. Standard Modules 62
6.3. The dir() Function 63
6.4. Packages 66
6.4.1. Importing * From a Package 68
6.4.2. Intra-package References 69
6.4.3. Packages in Multiple Directories 70
7. Input and Output 70
7.1. Fancier Output Formatting 70
7.1.1. Old string formatting 75
7.2. Reading and Writing Files 76
7.2.1. Methods of File Objects 77
7.2.2. Saving structured data with json 79
8. Errors and Exceptions 81
8.1. Syntax Errors 81
8.2. Exceptions 81
8.3. Handling Exceptions 82
8.4. Raising Exceptions 86
8.5. User-defined Exceptions 87
8.6. Defining Clean-up Actions 88
8.7. Predefined Clean-up Actions 89
9. Classes 90
9.1. A Word About Names and Objects 91
9.2. Python Scopes and Namespaces 91
9.2.1. Scopes and Namespaces Example 94
9.3. A First Look at Classes 95
9.3.1. Class Definition Syntax 95
9.3.2. Class Objects 96
9.3.3. Instance Objects 97
9.3.4. Method Objects 98
9.3.5. Class and Instance Variables 99
9.4. Random Remarks 100
9.5. Inheritance 102
9.5.1. Multiple Inheritance 104
9.6. Private Variables 105
9.7. Odds and Ends 106
9.8. Iterators 106
9.9. Generators 108
9.10. Generator Expressions 109
10. Brief Tour of the Standard Library 110
10.1. Operating System Interface 110
10.2. File Wildcards 111
10.3. Command Line Arguments 111
10.4. Error Output Redirection and Program Termination 112
10.5. String Pattern Matching 112
10.6. Mathematics 113
10.7. Internet Access 114
10.8. Dates and Times 114
10.9. Data Compression 115
10.10. Performance Measurement 115
10.11. Quality Control 116
10.12. Batteries Included 117
11. Brief Tour of the Standard Library — Part II 117
11.1. Output Formatting 118
11.2. Templating 119
11.3. Working with Binary Data Record Layouts 121
11.4. Multi-threading 121
11.5. Logging 122
11.6. Weak References 123
11.7. Tools for Working with Lists 124
11.8. Decimal Floating Point Arithmetic 126
12. Virtual Environments and Packages 127
12.1. Introduction 127
12.2. Creating Virtual Environments 128
12.3. Managing Packages with pip 129
13. What Now? 131
14. Interactive Input Editing and History Substitution 133
14.1. Tab Completion and History Editing 133
14.2. Alternatives to the Interactive Interpreter 133
15. Floating Point Arithmetic: Issues and Limitations 134
15.1. Representation Error 139
16. Appendix 141
16.1. Interactive Mode 141
16.1.1. Error Handling 141
16.1.2. Executable Python Scripts 142
16.1.3. The Interactive Startup File 142
16.1.4. The Customization Modules 143
1. Python Shortcuts
1.1 Swapping Values Without Using a Temporary Variable
1.2 Constructing a Dictionary Without Excessive Quoting
1.3 Getting a Value from a Dictionary
1.4 Adding an Entry to a Dictionary
1.5 Associating Multiple Values with Each Key in a Dictionary
1.6 Dispatching Using a Dictionary
1.7 Collecting a Bunch of Named Items
1.8 Finding the Intersection of Two Dictionaries
1.9 Assigning and Testing with One Statement
1.10 Using List Comprehensions Instead of map and filter
1.11 Unzipping Simple List-Like Objects
1.12 Flattening a Nested Sequence
1.13 Looping in Parallel over Index and Sequence Items
1.14 Looping Through Multiple Lists
1.15 Spanning a Range Defined by Floats
1.16 Transposing Two-Dimensional Arrays
1.17 Creating Lists of Lists Without Sharing References
2. Searching and Sorting
2.1 Sorting a Dictionary
2.2 Processing Selected Pairs of Structured Data Efficiently
2.3 Sorting While Guaranteeing Sort Stability
2.4 Sorting by One Field, Then by Another
2.5 Looking for Items in a Sorted Sequence Using Binary Search
2.6 Sorting a List of Objects by an Attribute of the Objects
2.7 Sorting by Item or by Attribute
2.8 Selecting Random Elements from a List Without Repetition
2.9 Performing Frequent Membership Tests on a Sequence
2.10 Finding the Deep Index of an Item in an Embedded Sequence
2.11 Showing Off Quicksort in Three Lines
2.12 Sorting Objects Using SQL's ORDER BY Syntax
3. Text
3.1 Processing a String One Character at a Time
3.2 Testing if an Object Is String-Like
3.3 Aligning Strings
3.4 Trimming Space from the Ends of a String
3.5 Combining Strings
3.6 Checking Whe
释义（来自百度百科）
闭包就是能够读取其他函数内部变量的函数。例如在javascript中，只有函数内部的子函数才能读取局部变量，所以闭包可以理解成“定义在一个函数内部的函数“。在本质上，闭包是将函数内部和函数外部连接起来的桥梁。
function makeFunc() {
var name = "...
所谓内嵌函数就是定义于另一个函数内部的函数.(GNU C 不支持内嵌函数) 内嵌函数名在他被定义的块中是局部有效的。例如这里我们定义了一个函数squre并调用了他两次：foo ( double a, double b ){double square (double z) { return z * z; }return square (a) square (b);}包含内嵌函数的函数内的任何变...
周五下午因为嵌套函数的问题反复折腾了几个小时，今天终于搞明白了，python2.6手册里对“nested scope”有一段定义，并结合“OReilly
- Python in a Nutshell”第4.10.6.2节，总结如下：
1 python支持嵌套函数；
2 内层函数可以访问外层函数中定义的变量，但不能重新赋值（rebind）；
3 内层函数的local names
nested loops = The "inner loop" will finish all of it's iterations before finishing one iteration of the "outer loop"
嵌套函数的定义嵌套函数，即nested function，就是嵌套在函数体内部的函数。嵌套函数可以出现在一个函数体内部的任何位置，开始以function声明，结束的时候加上end。需要说明的是包含有嵌套函数的函数，无论它是主函数、子函数、嵌套函数，都应该在末尾的地方加上end。
在Python中，你可以在一个函数内部定义另一个函数，这被称为函数嵌套（nested function）。在一个函数中定义另一个函数可以让你在特定的上下文中创建和使用函数，以及在更高层级的函数中共享和封装代码块。
输出：[1, 2, 3, 4, 5, 6, 7, 8, 9]
法二：sum()函数
sum(a,[])#这种展开方式比较奇怪，在sum()函数文档中也没有找到相关介绍。猜测是某种语法糖。
输出：[1, 2, 3, 4, 5, 6, 7, 8, 9]
法三：迭代赋值
for _ in a:
print(b)
输出：[1, 2, 3, 4,
问题：有一个多变量函数f(abcx),现需要分别在a=a0b=b0c=c0和a=a1b=b1c=c1的条件下对f(abcx)进行某一操作。
此类问题常在数值积分时出现。
解决方案：
1． 使用全局变量
可在主调函数和被调函数中分别将a,b,c声明为全局变量(global a b c)，这时f通过全局变量传递abc, 定义时可以只有一个参数x。
2． 使用anonymous func
[url]http://newsjobs.iteye.com/blog/1002333[/url]
以上的帖子是记录最近开始的一个边学边做的项目的首篇，在那个系列中只会记录项目的进度和基本内容。
涉及到的技术点等会单独开贴来记录
Python整体感觉，语法还是比较复杂的，有其他静态语言经验的想要快速学好Python是件比较难的事，至少对我是。
我基本采用了边做项目边学习的方法来做，遇到...
