mirror of
https://github.com/python/cpython.git
synced 2025-11-03 19:34:08 +00:00
merge from trunk
This commit is contained in:
Benjamin Peterson
parent
2d8dcdcb06
commit
f10a79aad4
40 changed files with 621 additions and 305 deletions
|
|
@ -111,7 +111,7 @@ dist:
|
|||
|
||||
# archive the HTML
|
||||
make html
|
||||
cp -a build/html dist/python$(DISTVERSION)-docs-html
|
||||
cp -pPR build/html dist/python$(DISTVERSION)-docs-html
|
||||
tar -C dist -cf dist/python$(DISTVERSION)-docs-html.tar python$(DISTVERSION)-docs-html
|
||||
bzip2 -9 -k dist/python$(DISTVERSION)-docs-html.tar
|
||||
(cd dist; zip -q -r -9 python$(DISTVERSION)-docs-html.zip python$(DISTVERSION)-docs-html)
|
||||
|
|
@ -120,7 +120,7 @@ dist:
|
|||
|
||||
# archive the text build
|
||||
make text
|
||||
cp -a build/text dist/python$(DISTVERSION)-docs-text
|
||||
cp -pPR build/text dist/python$(DISTVERSION)-docs-text
|
||||
tar -C dist -cf dist/python$(DISTVERSION)-docs-text.tar python$(DISTVERSION)-docs-text
|
||||
bzip2 -9 -k dist/python$(DISTVERSION)-docs-text.tar
|
||||
(cd dist; zip -q -r -9 python$(DISTVERSION)-docs-text.zip python$(DISTVERSION)-docs-text)
|
||||
|
|
|
|||
|
|
@ -744,11 +744,11 @@ created.
|
|||
:cmacro:`Py_END_ALLOW_THREADS` macros is acceptable.
|
||||
|
||||
The return value is an opaque "handle" to the thread state when
|
||||
:cfunc:`PyGILState_Acquire` was called, and must be passed to
|
||||
:cfunc:`PyGILState_Ensure` was called, and must be passed to
|
||||
:cfunc:`PyGILState_Release` to ensure Python is left in the same state. Even
|
||||
though recursive calls are allowed, these handles *cannot* be shared - each
|
||||
unique call to :cfunc:`PyGILState_Ensure` must save the handle for its call to
|
||||
:cfunc:`PyGILState_Release`.
|
||||
unique call to :cfunc:`PyGILState_Ensure` must save the handle for its call
|
||||
to :cfunc:`PyGILState_Release`.
|
||||
|
||||
When the function returns, the current thread will hold the GIL. Failure is a
|
||||
fatal error.
|
||||
|
|
|
|||
|
|
@ -41,13 +41,6 @@ today_fmt = '%B %d, %Y'
|
|||
|
||||
# List of files that shouldn't be included in the build.
|
||||
unused_docs = [
|
||||
'whatsnew/2.0',
|
||||
'whatsnew/2.1',
|
||||
'whatsnew/2.2',
|
||||
'whatsnew/2.3',
|
||||
'whatsnew/2.4',
|
||||
'whatsnew/2.5',
|
||||
'whatsnew/2.6',
|
||||
'maclib/scrap',
|
||||
'library/xmllib',
|
||||
'library/xml.etree',
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
|
||||
.. toctree::
|
||||
|
||||
whatsnew/3.0.rst
|
||||
whatsnew/index.rst
|
||||
tutorial/index.rst
|
||||
using/index.rst
|
||||
reference/index.rst
|
||||
|
|
|
|||
|
|
@ -299,7 +299,7 @@ followed by ``lines`` for the text version or ``binary`` for the binary version.
|
|||
.. method:: FTP.quit()
|
||||
|
||||
Send a ``QUIT`` command to the server and close the connection. This is the
|
||||
"polite" way to close a connection, but it may raise an exception of the server
|
||||
"polite" way to close a connection, but it may raise an exception if the server
|
||||
responds with an error to the ``QUIT`` command. This implies a call to the
|
||||
:meth:`close` method which renders the :class:`FTP` instance useless for
|
||||
subsequent calls (see below).
|
||||
|
|
|
|||
|
|
@ -22,9 +22,8 @@ are always available. They are listed here in alphabetical order.
|
|||
The function is invoked by the :keyword:`import` statement. It mainly exists
|
||||
so that you can replace it with another function that has a compatible
|
||||
interface, in order to change the semantics of the :keyword:`import`
|
||||
statement. See also the built-in module :mod:`imp`, which
|
||||
defines some useful operations out of which you can build your own
|
||||
:func:`__import__` function.
|
||||
statement. See the built-in module :mod:`imp`, which defines some useful
|
||||
operations out of which you can build your own :func:`__import__` function.
|
||||
|
||||
For example, the statement ``import spam`` results in the following call:
|
||||
``__import__('spam', globals(), locals(), [], -1)``; the statement
|
||||
|
|
@ -1201,6 +1200,18 @@ are always available. They are listed here in alphabetical order.
|
|||
care about trailing, unmatched values from the longer iterables. If those
|
||||
values are important, use :func:`itertools.zip_longest` instead.
|
||||
|
||||
:func:`zip` in conjunction with the ``*`` operator can be used to unzip a
|
||||
list::
|
||||
|
||||
>>> x = [1, 2, 3]
|
||||
>>> y = [4, 5, 6]
|
||||
>>> zipped = zip(x, y)
|
||||
>>> zipped
|
||||
[(1, 4), (2, 5), (3, 6)]
|
||||
>>> x2, y2 = zip(*zipped)
|
||||
>>> x == x2, y == y2
|
||||
True
|
||||
|
||||
|
||||
.. rubric:: Footnotes
|
||||
|
||||
|
|
|
|||
|
|
@ -25,7 +25,7 @@ represents the database. Here the data will be stored in the
|
|||
You can also supply the special name ``:memory:`` to create a database in RAM.
|
||||
|
||||
Once you have a :class:`Connection`, you can create a :class:`Cursor` object
|
||||
and call its :meth:`execute` method to perform SQL commands::
|
||||
and call its :meth:`~Cursor.execute` method to perform SQL commands::
|
||||
|
||||
c = conn.cursor()
|
||||
|
||||
|
|
@ -50,7 +50,7 @@ is insecure; it makes your program vulnerable to an SQL injection attack.
|
|||
|
||||
Instead, use the DB-API's parameter substitution. Put ``?`` as a placeholder
|
||||
wherever you want to use a value, and then provide a tuple of values as the
|
||||
second argument to the cursor's :meth:`execute` method. (Other database modules
|
||||
second argument to the cursor's :meth:`~Cursor.execute` method. (Other database modules
|
||||
may use a different placeholder, such as ``%s`` or ``:1``.) For example::
|
||||
|
||||
# Never do this -- insecure!
|
||||
|
|
@ -69,8 +69,8 @@ may use a different placeholder, such as ``%s`` or ``:1``.) For example::
|
|||
c.execute('insert into stocks values (?,?,?,?,?)', t)
|
||||
|
||||
To retrieve data after executing a SELECT statement, you can either treat the
|
||||
cursor as an :term:`iterator`, call the cursor's :meth:`fetchone` method to
|
||||
retrieve a single matching row, or call :meth:`fetchall` to get a list of the
|
||||
cursor as an :term:`iterator`, call the cursor's :meth:`~Cursor.fetchone` method to
|
||||
retrieve a single matching row, or call :meth:`~Cursor.fetchall` to get a list of the
|
||||
matching rows.
|
||||
|
||||
This example uses the iterator form::
|
||||
|
|
@ -128,7 +128,7 @@ Module functions and constants
|
|||
returns. It will look for a string formed [mytype] in there, and then decide
|
||||
that 'mytype' is the type of the column. It will try to find an entry of
|
||||
'mytype' in the converters dictionary and then use the converter function found
|
||||
there to return the value. The column name found in :attr:`cursor.description`
|
||||
there to return the value. The column name found in :attr:`Cursor.description`
|
||||
is only the first word of the column name, i. e. if you use something like
|
||||
``'as "x [datetime]"'`` in your SQL, then we will parse out everything until the
|
||||
first blank for the column name: the column name would simply be "x".
|
||||
|
|
@ -215,11 +215,13 @@ Module functions and constants
|
|||
Connection Objects
|
||||
------------------
|
||||
|
||||
A :class:`Connection` instance has the following attributes and methods:
|
||||
.. class:: Connection
|
||||
|
||||
A SQLite database connection has the following attributes and methods:
|
||||
|
||||
.. attribute:: Connection.isolation_level
|
||||
|
||||
Get or set the current isolation level. None for autocommit mode or one of
|
||||
Get or set the current isolation level. :const:`None` for autocommit mode or one of
|
||||
"DEFERRED", "IMMEDIATE" or "EXLUSIVE". See section
|
||||
:ref:`sqlite3-controlling-transactions` for a more detailed explanation.
|
||||
|
||||
|
|
@ -234,7 +236,7 @@ A :class:`Connection` instance has the following attributes and methods:
|
|||
.. method:: Connection.commit()
|
||||
|
||||
This method commits the current transaction. If you don't call this method,
|
||||
anything you did since the last call to commit() is not visible from from
|
||||
anything you did since the last call to ``commit()`` is not visible from from
|
||||
other database connections. If you wonder why you don't see the data you've
|
||||
written to the database, please check you didn't forget to call this method.
|
||||
|
||||
|
|
@ -383,9 +385,9 @@ A :class:`Connection` instance has the following attributes and methods:
|
|||
|
||||
.. attribute:: Connection.text_factory
|
||||
|
||||
Using this attribute you can control what objects are returned for the TEXT data
|
||||
type. By default, this attribute is set to :class:`str` and the
|
||||
:mod:`sqlite3` module will return strings for TEXT. If you want to
|
||||
Using this attribute you can control what objects are returned for the ``TEXT``
|
||||
data type. By default, this attribute is set to :class:`str` and the
|
||||
:mod:`sqlite3` module will return Unicode objects for ``TEXT``. If you want to
|
||||
return bytestrings instead, you can set it to :class:`bytes`.
|
||||
|
||||
For efficiency reasons, there's also a way to return :class:`str` objects
|
||||
|
|
@ -430,8 +432,9 @@ A :class:`Connection` instance has the following attributes and methods:
|
|||
Cursor Objects
|
||||
--------------
|
||||
|
||||
A :class:`Cursor` instance has the following attributes and methods:
|
||||
.. class:: Cursor
|
||||
|
||||
A SQLite database cursor has the following attributes and methods:
|
||||
|
||||
.. method:: Cursor.execute(sql, [parameters])
|
||||
|
||||
|
|
@ -470,7 +473,7 @@ A :class:`Cursor` instance has the following attributes and methods:
|
|||
.. method:: Cursor.executescript(sql_script)
|
||||
|
||||
This is a nonstandard convenience method for executing multiple SQL statements
|
||||
at once. It issues a COMMIT statement first, then executes the SQL script it
|
||||
at once. It issues a ``COMMIT`` statement first, then executes the SQL script it
|
||||
gets as a parameter.
|
||||
|
||||
*sql_script* can be an instance of :class:`str` or :class:`bytes`.
|
||||
|
|
@ -483,7 +486,7 @@ A :class:`Cursor` instance has the following attributes and methods:
|
|||
.. method:: Cursor.fetchone()
|
||||
|
||||
Fetches the next row of a query result set, returning a single sequence,
|
||||
or ``None`` when no more data is available.
|
||||
or :const:`None` when no more data is available.
|
||||
|
||||
|
||||
.. method:: Cursor.fetchmany([size=cursor.arraysize])
|
||||
|
|
@ -522,8 +525,8 @@ A :class:`Cursor` instance has the following attributes and methods:
|
|||
into :attr:`rowcount`.
|
||||
|
||||
As required by the Python DB API Spec, the :attr:`rowcount` attribute "is -1 in
|
||||
case no executeXX() has been performed on the cursor or the rowcount of the last
|
||||
operation is not determinable by the interface".
|
||||
case no ``executeXX()`` has been performed on the cursor or the rowcount of the
|
||||
last operation is not determinable by the interface".
|
||||
|
||||
This includes ``SELECT`` statements because we cannot determine the number of
|
||||
rows a query produced until all rows were fetched.
|
||||
|
|
@ -535,6 +538,81 @@ A :class:`Cursor` instance has the following attributes and methods:
|
|||
method. For operations other than ``INSERT`` or when :meth:`executemany` is
|
||||
called, :attr:`lastrowid` is set to :const:`None`.
|
||||
|
||||
.. attribute:: Cursor.description
|
||||
|
||||
This read-only attribute provides the column names of the last query. To
|
||||
remain compatible with the Python DB API, it returns a 7-tuple for each
|
||||
column where the last six items of each tuple are :const:`None`.
|
||||
|
||||
It is set for ``SELECT`` statements without any matching rows as well.
|
||||
|
||||
.. _sqlite3-row-objects:
|
||||
|
||||
Row Objects
|
||||
-----------
|
||||
|
||||
.. class:: Row
|
||||
|
||||
A :class:`Row` instance serves as a highly optimized
|
||||
:attr:`~Connection.row_factory` for :class:`Connection` objects.
|
||||
It tries to mimic a tuple in most of its features.
|
||||
|
||||
It supports mapping access by column name and index, iteration,
|
||||
representation, equality testing and :func:`len`.
|
||||
|
||||
If two :class:`Row` objects have exactly the same columns and their
|
||||
members are equal, they compare equal.
|
||||
|
||||
.. versionchanged:: 2.6
|
||||
Added iteration and equality (hashability).
|
||||
|
||||
.. method:: keys
|
||||
|
||||
This method returns a tuple of column names. Immediately after a query,
|
||||
it is the first member of each tuple in :attr:`Cursor.description`.
|
||||
|
||||
.. versionadded:: 2.6
|
||||
|
||||
Let's assume we initialize a table as in the example given above::
|
||||
|
||||
conn = sqlite3.connect(":memory:")
|
||||
c = conn.cursor()
|
||||
c.execute('''create table stocks
|
||||
(date text, trans text, symbol text,
|
||||
qty real, price real)''')
|
||||
c.execute("""insert into stocks
|
||||
values ('2006-01-05','BUY','RHAT',100,35.14)""")
|
||||
conn.commit()
|
||||
c.close()
|
||||
|
||||
Now we plug :class:`Row` in::
|
||||
|
||||
>>> conn.row_factory = sqlite3.Row
|
||||
>>> c = conn.cursor()
|
||||
>>> c.execute('select * from stocks')
|
||||
<sqlite3.Cursor object at 0x7f4e7dd8fa80>
|
||||
>>> r = c.fetchone()
|
||||
>>> type(r)
|
||||
<type 'sqlite3.Row'>
|
||||
>>> r
|
||||
(u'2006-01-05', u'BUY', u'RHAT', 100.0, 35.140000000000001)
|
||||
>>> len(r)
|
||||
5
|
||||
>>> r[2]
|
||||
u'RHAT'
|
||||
>>> r.keys()
|
||||
['date', 'trans', 'symbol', 'qty', 'price']
|
||||
>>> r['qty']
|
||||
100.0
|
||||
>>> for member in r: print member
|
||||
...
|
||||
2006-01-05
|
||||
BUY
|
||||
RHAT
|
||||
100.0
|
||||
35.14
|
||||
|
||||
|
||||
.. _sqlite3-types:
|
||||
|
||||
SQLite and Python types
|
||||
|
|
@ -544,36 +622,38 @@ SQLite and Python types
|
|||
Introduction
|
||||
^^^^^^^^^^^^
|
||||
|
||||
SQLite natively supports the following types: NULL, INTEGER, REAL, TEXT, BLOB.
|
||||
SQLite natively supports the following types: ``NULL``, ``INTEGER``,
|
||||
``REAL``, ``TEXT``, ``BLOB``.
|
||||
|
||||
The following Python types can thus be sent to SQLite without any problem:
|
||||
|
||||
+-------------------------------+-------------+
|
||||
| Python type | SQLite type |
|
||||
+===============================+=============+
|
||||
| ``None`` | NULL |
|
||||
| :const:`None` | ``NULL`` |
|
||||
+-------------------------------+-------------+
|
||||
| :class:`int` | INTEGER |
|
||||
| :class:`int` | ``INTEGER`` |
|
||||
+-------------------------------+-------------+
|
||||
| :class:`float` | REAL |
|
||||
| :class:`float` | ``REAL`` |
|
||||
+-------------------------------+-------------+
|
||||
| :class:`bytes` (UTF8-encoded) | TEXT |
|
||||
| :class:`bytes` (UTF8-encoded) | ``TEXT`` |
|
||||
+-------------------------------+-------------+
|
||||
| :class:`str` | TEXT |
|
||||
| :class:`str` | ``TEXT`` |
|
||||
+-------------------------------+-------------+
|
||||
| :class:`buffer` | BLOB |
|
||||
| :class:`buffer` | ``BLOB`` |
|
||||
+-------------------------------+-------------+
|
||||
|
||||
|
||||
This is how SQLite types are converted to Python types by default:
|
||||
|
||||
+-------------+---------------------------------------------+
|
||||
| SQLite type | Python type |
|
||||
+=============+=============================================+
|
||||
| ``NULL`` | None |
|
||||
| ``NULL`` | :const:`None` |
|
||||
+-------------+---------------------------------------------+
|
||||
| ``INTEGER`` | int |
|
||||
| ``INTEGER`` | :class`int` |
|
||||
+-------------+---------------------------------------------+
|
||||
| ``REAL`` | float |
|
||||
| ``REAL`` | :class:`float` |
|
||||
+-------------+---------------------------------------------+
|
||||
| ``TEXT`` | depends on text_factory, str by default |
|
||||
+-------------+---------------------------------------------+
|
||||
|
|
@ -701,9 +781,10 @@ Controlling Transactions
|
|||
------------------------
|
||||
|
||||
By default, the :mod:`sqlite3` module opens transactions implicitly before a
|
||||
Data Modification Language (DML) statement (i.e. INSERT/UPDATE/DELETE/REPLACE),
|
||||
and commits transactions implicitly before a non-DML, non-query statement (i. e.
|
||||
anything other than SELECT/INSERT/UPDATE/DELETE/REPLACE).
|
||||
Data Modification Language (DML) statement (i.e.
|
||||
``INSERT``/``UPDATE``/``DELETE``/``REPLACE``), and commits transactions
|
||||
implicitly before a non-DML, non-query statement (i. e.
|
||||
anything other than ``SELECT`` or the aforementioned).
|
||||
|
||||
So if you are within a transaction and issue a command like ``CREATE TABLE
|
||||
...``, ``VACUUM``, ``PRAGMA``, the :mod:`sqlite3` module will commit implicitly
|
||||
|
|
@ -712,7 +793,7 @@ is that some of these commands don't work within transactions. The other reason
|
|||
is that pysqlite needs to keep track of the transaction state (if a transaction
|
||||
is active or not).
|
||||
|
||||
You can control which kind of "BEGIN" statements pysqlite implicitly executes
|
||||
You can control which kind of ``BEGIN`` statements pysqlite implicitly executes
|
||||
(or none at all) via the *isolation_level* parameter to the :func:`connect`
|
||||
call, or via the :attr:`isolation_level` property of connections.
|
||||
|
||||
|
|
@ -736,7 +817,7 @@ Using the nonstandard :meth:`execute`, :meth:`executemany` and
|
|||
be written more concisely because you don't have to create the (often
|
||||
superfluous) :class:`Cursor` objects explicitly. Instead, the :class:`Cursor`
|
||||
objects are created implicitly and these shortcut methods return the cursor
|
||||
objects. This way, you can execute a SELECT statement and iterate over it
|
||||
objects. This way, you can execute a ``SELECT`` statement and iterate over it
|
||||
directly using only a single call on the :class:`Connection` object.
|
||||
|
||||
.. literalinclude:: ../includes/sqlite3/shortcut_methods.py
|
||||
|
|
|
|||
|
|
@ -334,8 +334,8 @@ Replacing /bin/sh shell backquote
|
|||
output = Popen(["mycmd", "myarg"], stdout=PIPE).communicate()[0]
|
||||
|
||||
|
||||
Replacing shell pipe line
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
Replacing shell pipeline
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
::
|
||||
|
||||
|
|
|
|||
|
|
@ -775,9 +775,9 @@ can appear before a future statement are:
|
|||
.. XXX change this if future is cleaned out
|
||||
|
||||
The features recognized by Python 3.0 are ``absolute_import``, ``division``,
|
||||
``generators``, ``nested_scopes`` and ``with_statement``. They are all
|
||||
redundant because they are always enabled, and only kept for backwards
|
||||
compatibility.
|
||||
``generators``, ``unicode_literals``, ``print_function``, ``nested_scopes`` and
|
||||
``with_statement``. They are all redundant because they are always enabled, and
|
||||
only kept for backwards compatibility.
|
||||
|
||||
A future statement is recognized and treated specially at compile time: Changes
|
||||
to the semantics of core constructs are often implemented by generating
|
||||
|
|
|
|||
|
|
@ -31,8 +31,8 @@ in the table are the size of the download files in Kilobytes.</p>
|
|||
<td><a href="{{ dlbase }}/python-docs-html.tar.bz2">Download</a> (ca. 4 MB)</td>
|
||||
</tr>
|
||||
<tr><td>Plain Text</td>
|
||||
<td><a href="{{ dlbase }}/python-docs-pdf-text.zip">Download</a> (ca. 2 MB)</td>
|
||||
<td><a href="{{ dlbase }}/python-docs-pdf-text.tar.bz2">Download</a> (ca. 1.5 MB)</td>
|
||||
<td><a href="{{ dlbase }}/python-docs-text.zip">Download</a> (ca. 2 MB)</td>
|
||||
<td><a href="{{ dlbase }}/python-docs-text.tar.bz2">Download</a> (ca. 1.5 MB)</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
<table class="contentstable" align="center"><tr>
|
||||
<td width="50%">
|
||||
<p class="biglink"><a class="biglink" href="{{ pathto("whatsnew/" + version) }}">What's new in Python {{ version }}?</a><br/>
|
||||
<span class="linkdescr">changes since previous major release</span></p>
|
||||
<span class="linkdescr">or <a href="{{ pathto("whatsnew/index") }}">all "What's new" documents</a> since 2.0</span></span></p>
|
||||
<p class="biglink"><a class="biglink" href="{{ pathto("tutorial/index") }}">Tutorial</a><br/>
|
||||
<span class="linkdescr">start here</span></p>
|
||||
<p class="biglink"><a class="biglink" href="{{ pathto("using/index") }}">Using Python</a><br/>
|
||||
|
|
|
|||
|
|
@ -1,5 +1,4 @@
|
|||
{% extends "!layout.html" %}
|
||||
{% block rootrellink %}
|
||||
<li><img src="{{ pathto('_static/py.png', 1) }}" alt="" style="vertical-align: middle; margin-top: -1px"/></li>
|
||||
{{ super() }}
|
||||
<li><img src="{{ pathto('_static/py.png', 1) }}" alt="" style="vertical-align: middle; margin-top: -1px"/></li><li><a href="{{ pathto('index') }}">{{ shorttitle }}</a>{{ reldelim1 }}</li>
|
||||
{% endblock %}
|
||||
|
|
|
|||
|
|
@ -714,7 +714,7 @@ Python's division operator, ``/``, behaves like C's division operator when
|
|||
presented with two integer arguments: it returns an integer result that's
|
||||
truncated down when there would be a fractional part. For example, ``3/2`` is
|
||||
1, not 1.5, and ``(-1)/2`` is -1, not -0.5. This means that the results of
|
||||
divison can vary unexpectedly depending on the type of the two operands and
|
||||
division can vary unexpectedly depending on the type of the two operands and
|
||||
because Python is dynamically typed, it can be difficult to determine the
|
||||
possible types of the operands.
|
||||
|
||||
|
|
|
|||
|
|
@ -1196,7 +1196,7 @@ Optimizations
|
|||
|
||||
* The ``SET_LINENO`` opcode is now gone. This may provide a small speed
|
||||
increase, depending on your compiler's idiosyncrasies. See section
|
||||
:ref:`section-other` for a longer explanation. (Removed by Michael Hudson.)
|
||||
:ref:`23section-other` for a longer explanation. (Removed by Michael Hudson.)
|
||||
|
||||
* :func:`xrange` objects now have their own iterator, making ``for i in
|
||||
xrange(n)`` slightly faster than ``for i in range(n)``. (Patch by Raymond
|
||||
|
|
@ -1951,7 +1951,7 @@ Other new platforms now supported by Python include AtheOS
|
|||
.. ======================================================================
|
||||
|
||||
|
||||
.. _section-other:
|
||||
.. _23section-other:
|
||||
|
||||
Other Changes and Fixes
|
||||
=======================
|
||||
|
|
@ -2062,7 +2062,7 @@ code:
|
|||
.. ======================================================================
|
||||
|
||||
|
||||
.. _acks:
|
||||
.. _23acks:
|
||||
|
||||
Acknowledgements
|
||||
================
|
||||
|
|
|
|||
|
|
@ -1551,7 +1551,7 @@ code:
|
|||
.. ======================================================================
|
||||
|
||||
|
||||
.. _acks:
|
||||
.. _24acks:
|
||||
|
||||
Acknowledgements
|
||||
================
|
||||
|
|
|
|||
|
|
@ -16,9 +16,9 @@ release schedule.
|
|||
The changes in Python 2.5 are an interesting mix of language and library
|
||||
improvements. The library enhancements will be more important to Python's user
|
||||
community, I think, because several widely-useful packages were added. New
|
||||
modules include ElementTree for XML processing (section :ref:`module-etree`),
|
||||
the SQLite database module (section :ref:`module-sqlite`), and the :mod:`ctypes`
|
||||
module for calling C functions (section :ref:`module-ctypes`).
|
||||
modules include ElementTree for XML processing (:mod:`xml.etree`),
|
||||
the SQLite database module (:mod:`sqlite`), and the :mod:`ctypes`
|
||||
module for calling C functions.
|
||||
|
||||
The language changes are of middling significance. Some pleasant new features
|
||||
were added, but most of them aren't features that you'll use every day.
|
||||
|
|
@ -736,7 +736,7 @@ add a :keyword:`return` statement at the marked location. ::
|
|||
# return False
|
||||
|
||||
|
||||
.. _module-contextlib:
|
||||
.. _contextlibmod:
|
||||
|
||||
The contextlib module
|
||||
---------------------
|
||||
|
|
@ -1109,7 +1109,7 @@ Here are all of the changes that Python 2.5 makes to the core Python language.
|
|||
.. ======================================================================
|
||||
|
||||
|
||||
.. _interactive:
|
||||
.. _25interactive:
|
||||
|
||||
Interactive Interpreter Changes
|
||||
-------------------------------
|
||||
|
|
@ -1211,7 +1211,7 @@ marked in the following list.
|
|||
.. ======================================================================
|
||||
|
||||
|
||||
.. _modules:
|
||||
.. _25modules:
|
||||
|
||||
New, Improved, and Removed Modules
|
||||
==================================
|
||||
|
|
@ -1273,7 +1273,7 @@ complete list of changes, or look through the SVN logs for all the details.
|
|||
(Contributed by Raymond Hettinger.)
|
||||
|
||||
* New module: The :mod:`contextlib` module contains helper functions for use
|
||||
with the new ':keyword:`with`' statement. See section :ref:`module-contextlib`
|
||||
with the new ':keyword:`with`' statement. See section :ref:`contextlibmod`
|
||||
for more about this module.
|
||||
|
||||
* New module: The :mod:`cProfile` module is a C implementation of the existing
|
||||
|
|
@ -2272,8 +2272,6 @@ code:
|
|||
.. ======================================================================
|
||||
|
||||
|
||||
.. _acks:
|
||||
|
||||
Acknowledgements
|
||||
================
|
||||
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
:Release: |release|
|
||||
:Date: |today|
|
||||
|
||||
.. $Id: whatsnew26.tex 55746 2007-06-02 18:33:53Z neal.norwitz $
|
||||
.. $Id$
|
||||
Rules for maintenance:
|
||||
|
||||
* Anyone can add text to this document. Do not spend very much time
|
||||
|
|
@ -49,9 +49,8 @@
|
|||
This saves the maintainer some effort going through the SVN logs
|
||||
when researching a change.
|
||||
|
||||
This article explains the new features in Python 2.6. The release
|
||||
schedule is described in :pep:`361`; currently the final release is
|
||||
scheduled for October 1 2008.
|
||||
This article explains the new features in Python 2.6, released on October 1
|
||||
2008. The release schedule is described in :pep:`361`.
|
||||
|
||||
The major theme of Python 2.6 is preparing the migration path to
|
||||
Python 3.0, a major redesign of the language. Whenever possible,
|
||||
|
|
@ -663,33 +662,33 @@ and :meth:`Semaphore` to create shared locks.)
|
|||
from multiprocessing import Pool, Manager
|
||||
|
||||
def factorial(N, dictionary):
|
||||
"Compute a factorial."
|
||||
# Calculate the result
|
||||
fact = 1L
|
||||
for i in range(1, N+1):
|
||||
fact = fact * i
|
||||
"Compute a factorial."
|
||||
# Calculate the result
|
||||
fact = 1L
|
||||
for i in range(1, N+1):
|
||||
fact = fact * i
|
||||
|
||||
# Store result in dictionary
|
||||
dictionary[N] = fact
|
||||
dictionary[N] = fact
|
||||
|
||||
if __name__ == '__main__':
|
||||
p = Pool(5)
|
||||
mgr = Manager()
|
||||
d = mgr.dict() # Create shared dictionary
|
||||
p = Pool(5)
|
||||
mgr = Manager()
|
||||
d = mgr.dict() # Create shared dictionary
|
||||
|
||||
# Run tasks using the pool
|
||||
for N in range(1, 1000, 10):
|
||||
p.apply_async(factorial, (N, d))
|
||||
# Run tasks using the pool
|
||||
for N in range(1, 1000, 10):
|
||||
p.apply_async(factorial, (N, d))
|
||||
|
||||
# Mark pool as closed -- no more tasks can be added.
|
||||
p.close()
|
||||
# Mark pool as closed -- no more tasks can be added.
|
||||
p.close()
|
||||
|
||||
# Wait for tasks to exit
|
||||
p.join()
|
||||
# Wait for tasks to exit
|
||||
p.join()
|
||||
|
||||
# Output results
|
||||
for k, v in sorted(d.items()):
|
||||
print k, v
|
||||
# Output results
|
||||
for k, v in sorted(d.items()):
|
||||
print k, v
|
||||
|
||||
This will produce the output::
|
||||
|
||||
|
|
@ -724,32 +723,33 @@ In 2.6, both 8-bit and Unicode strings have a `.format()` method that
|
|||
treats the string as a template and takes the arguments to be formatted.
|
||||
The formatting template uses curly brackets (`{`, `}`) as special characters::
|
||||
|
||||
# Substitute positional argument 0 into the string.
|
||||
"User ID: {0}".format("root") -> "User ID: root"
|
||||
|
||||
# Use the named keyword arguments
|
||||
'User ID: {uid} Last seen: {last_login}'.format(
|
||||
uid='root',
|
||||
last_login = '5 Mar 2008 07:20') ->
|
||||
'User ID: root Last seen: 5 Mar 2008 07:20'
|
||||
>>> # Substitute positional argument 0 into the string.
|
||||
>>> "User ID: {0}".format("root")
|
||||
'User ID: root'
|
||||
>>> # Use the named keyword arguments
|
||||
>>> "User ID: {uid} Last seen: {last_login}".format(
|
||||
... uid="root",
|
||||
... last_login = "5 Mar 2008 07:20")
|
||||
'User ID: root Last seen: 5 Mar 2008 07:20'
|
||||
|
||||
Curly brackets can be escaped by doubling them::
|
||||
|
||||
format("Empty dict: {{}}") -> "Empty dict: {}"
|
||||
>>> format("Empty dict: {{}}")
|
||||
"Empty dict: {}"
|
||||
|
||||
Field names can be integers indicating positional arguments, such as
|
||||
``{0}``, ``{1}``, etc. or names of keyword arguments. You can also
|
||||
supply compound field names that read attributes or access dictionary keys::
|
||||
|
||||
import sys
|
||||
'Platform: {0.platform}\nPython version: {0.version}'.format(sys) ->
|
||||
'Platform: darwin\n
|
||||
Python version: 2.6a1+ (trunk:61261M, Mar 5 2008, 20:29:41) \n
|
||||
[GCC 4.0.1 (Apple Computer, Inc. build 5367)]'
|
||||
>>> import sys
|
||||
>>> print 'Platform: {0.platform}\nPython version: {0.version}'.format(sys)
|
||||
Platform: darwin
|
||||
Python version: 2.6a1+ (trunk:61261M, Mar 5 2008, 20:29:41)
|
||||
[GCC 4.0.1 (Apple Computer, Inc. build 5367)]'
|
||||
|
||||
import mimetypes
|
||||
'Content-type: {0[.mp4]}'.format(mimetypes.types_map) ->
|
||||
'Content-type: video/mp4'
|
||||
>>> import mimetypes
|
||||
>>> 'Content-type: {0[.mp4]}'.format(mimetypes.types_map)
|
||||
'Content-type: video/mp4'
|
||||
|
||||
Note that when using dictionary-style notation such as ``[.mp4]``, you
|
||||
don't need to put any quotation marks around the string; it will look
|
||||
|
|
@ -761,30 +761,25 @@ So far we've shown how to specify which field to substitute into the
|
|||
resulting string. The precise formatting used is also controllable by
|
||||
adding a colon followed by a format specifier. For example::
|
||||
|
||||
# Field 0: left justify, pad to 15 characters
|
||||
# Field 1: right justify, pad to 6 characters
|
||||
fmt = '{0:15} ${1:>6}'
|
||||
|
||||
fmt.format('Registration', 35) ->
|
||||
'Registration $ 35'
|
||||
|
||||
fmt.format('Tutorial', 50) ->
|
||||
'Tutorial $ 50'
|
||||
|
||||
fmt.format('Banquet', 125) ->
|
||||
'Banquet $ 125'
|
||||
>>> # Field 0: left justify, pad to 15 characters
|
||||
>>> # Field 1: right justify, pad to 6 characters
|
||||
>>> fmt = '{0:15} ${1:>6}'
|
||||
>>> fmt.format('Registration', 35)
|
||||
'Registration $ 35'
|
||||
>>> fmt.format('Tutorial', 50)
|
||||
'Tutorial $ 50'
|
||||
>>> fmt.format('Banquet', 125)
|
||||
'Banquet $ 125'
|
||||
|
||||
Format specifiers can reference other fields through nesting::
|
||||
|
||||
fmt = '{0:{1}}'
|
||||
|
||||
width = 15
|
||||
fmt.format('Invoice #1234', width) ->
|
||||
'Invoice #1234 '
|
||||
|
||||
width = 35
|
||||
fmt.format('Invoice #1234', width) ->
|
||||
'Invoice #1234 '
|
||||
>>> fmt = '{0:{1}}'
|
||||
>>> width = 15
|
||||
>>> fmt.format('Invoice #1234', width)
|
||||
'Invoice #1234 '
|
||||
>>> width = 35
|
||||
>>> fmt.format('Invoice #1234', width)
|
||||
'Invoice #1234 '
|
||||
|
||||
The alignment of a field within the desired width can be specified:
|
||||
|
||||
|
|
@ -799,7 +794,7 @@ Character Effect
|
|||
|
||||
Format specifiers can also include a presentation type, which
|
||||
controls how the value is formatted. For example, floating-point numbers
|
||||
can be formatted as a general number or in exponential notation:
|
||||
can be formatted as a general number or in exponential notation::
|
||||
|
||||
>>> '{0:g}'.format(3.75)
|
||||
'3.75'
|
||||
|
|
@ -807,25 +802,27 @@ can be formatted as a general number or in exponential notation:
|
|||
'3.750000e+00'
|
||||
|
||||
A variety of presentation types are available. Consult the 2.6
|
||||
documentation for a :ref:`complete list <formatstrings>`; here's a sample::
|
||||
documentation for a :ref:`complete list <formatstrings>`; here's a sample:
|
||||
|
||||
'b' - Binary. Outputs the number in base 2.
|
||||
'c' - Character. Converts the integer to the corresponding
|
||||
Unicode character before printing.
|
||||
'd' - Decimal Integer. Outputs the number in base 10.
|
||||
'o' - Octal format. Outputs the number in base 8.
|
||||
'x' - Hex format. Outputs the number in base 16, using lower-
|
||||
case letters for the digits above 9.
|
||||
'e' - Exponent notation. Prints the number in scientific
|
||||
notation using the letter 'e' to indicate the exponent.
|
||||
'g' - General format. This prints the number as a fixed-point
|
||||
number, unless the number is too large, in which case
|
||||
it switches to 'e' exponent notation.
|
||||
'n' - Number. This is the same as 'g' (for floats) or 'd' (for
|
||||
integers), except that it uses the current locale setting to
|
||||
insert the appropriate number separator characters.
|
||||
'%' - Percentage. Multiplies the number by 100 and displays
|
||||
in fixed ('f') format, followed by a percent sign.
|
||||
===== ========================================================================
|
||||
``b`` Binary. Outputs the number in base 2.
|
||||
``c`` Character. Converts the integer to the corresponding Unicode character
|
||||
before printing.
|
||||
``d`` Decimal Integer. Outputs the number in base 10.
|
||||
``o`` Octal format. Outputs the number in base 8.
|
||||
``x`` Hex format. Outputs the number in base 16, using lower-case letters for
|
||||
the digits above 9.
|
||||
``e`` Exponent notation. Prints the number in scientific notation using the
|
||||
letter 'e' to indicate the exponent.
|
||||
``g`` General format. This prints the number as a fixed-point number, unless
|
||||
the number is too large, in which case it switches to 'e' exponent
|
||||
notation.
|
||||
``n`` Number. This is the same as 'g' (for floats) or 'd' (for integers),
|
||||
except that it uses the current locale setting to insert the appropriate
|
||||
number separator characters.
|
||||
``%`` Percentage. Multiplies the number by 100 and displays in fixed ('f')
|
||||
format, followed by a percent sign.
|
||||
===== ========================================================================
|
||||
|
||||
Classes and types can define a :meth:`__format__` method to control how they're
|
||||
formatted. It receives a single argument, the format specifier::
|
||||
|
|
@ -866,13 +863,14 @@ by doing ``def print(...)`` or importing a new function from somewhere else.
|
|||
Python 2.6 has a ``__future__`` import that removes ``print`` as language
|
||||
syntax, letting you use the functional form instead. For example::
|
||||
|
||||
from __future__ import print_function
|
||||
print('# of entries', len(dictionary), file=sys.stderr)
|
||||
>>> from __future__ import print_function
|
||||
>>> print('# of entries', len(dictionary), file=sys.stderr)
|
||||
|
||||
The signature of the new function is::
|
||||
|
||||
def print(*args, sep=' ', end='\n', file=None)
|
||||
|
||||
|
||||
The parameters are:
|
||||
|
||||
* *args*: positional arguments whose values will be printed out.
|
||||
|
|
@ -950,6 +948,20 @@ or using a :class:`bytes` constructor. For future compatibility,
|
|||
Python 2.6 adds :class:`bytes` as a synonym for the :class:`str` type,
|
||||
and it also supports the ``b''`` notation.
|
||||
|
||||
|
||||
The 2.6 :class:`str` differs from 3.0's :class:`bytes` type in various
|
||||
ways; most notably, the constructor is completely different. In 3.0,
|
||||
``bytes([65, 66, 67])`` is 3 elements long, containing the bytes
|
||||
representing ``ABC``; in 2.6, ``bytes([65, 66, 67])`` returns the
|
||||
12-byte string representing the :func:`str` of the list.
|
||||
|
||||
The primary use of :class:`bytes` in 2.6 will be to write tests of
|
||||
object type such as ``isinstance(x, bytes)``. This will help the 2to3
|
||||
converter, which can't tell whether 2.x code intends strings to
|
||||
contain either characters or 8-bit bytes; you can now
|
||||
use either :class:`bytes` or :class:`str` to represent your intention
|
||||
exactly, and the resulting code will also be correct in Python 3.0.
|
||||
|
||||
There's also a ``__future__`` import that causes all string literals
|
||||
to become Unicode strings. This means that ``\u`` escape sequences
|
||||
can be used to include Unicode characters::
|
||||
|
|
@ -989,6 +1001,8 @@ Byte arrays support most of the methods of string types, such as
|
|||
and some of the methods of lists, such as :meth:`append`,
|
||||
:meth:`pop`, and :meth:`reverse`.
|
||||
|
||||
::
|
||||
|
||||
>>> b = bytearray('ABC')
|
||||
>>> b.append('d')
|
||||
>>> b.append(ord('e'))
|
||||
|
|
@ -1211,8 +1225,8 @@ To check whether an object supports a particular interface, you can
|
|||
now write::
|
||||
|
||||
def func(d):
|
||||
if not isinstance(d, collections.MutableMapping):
|
||||
raise ValueError("Mapping object expected, not %r" % d)
|
||||
if not isinstance(d, collections.MutableMapping):
|
||||
raise ValueError("Mapping object expected, not %r" % d)
|
||||
|
||||
Don't feel that you must now begin writing lots of checks as in the
|
||||
above example. Python has a strong tradition of duck-typing, where
|
||||
|
|
@ -1224,22 +1238,22 @@ do it where it's absolutely necessary.
|
|||
You can write your own ABCs by using ``abc.ABCMeta`` as the
|
||||
metaclass in a class definition::
|
||||
|
||||
from abc import ABCMeta, abstractmethod
|
||||
from abc import ABCMeta, abstractmethod
|
||||
|
||||
class Drawable():
|
||||
__metaclass__ = ABCMeta
|
||||
class Drawable():
|
||||
__metaclass__ = ABCMeta
|
||||
|
||||
@abstractmethod
|
||||
def draw(self, x, y, scale=1.0):
|
||||
pass
|
||||
@abstractmethod
|
||||
def draw(self, x, y, scale=1.0):
|
||||
pass
|
||||
|
||||
def draw_doubled(self, x, y):
|
||||
self.draw(x, y, scale=2.0)
|
||||
def draw_doubled(self, x, y):
|
||||
self.draw(x, y, scale=2.0)
|
||||
|
||||
|
||||
class Square(Drawable):
|
||||
def draw(self, x, y, scale):
|
||||
...
|
||||
class Square(Drawable):
|
||||
def draw(self, x, y, scale):
|
||||
...
|
||||
|
||||
|
||||
In the :class:`Drawable` ABC above, the :meth:`draw_doubled` method
|
||||
|
|
@ -1259,7 +1273,7 @@ try to create an instance of a subclass lacking the method::
|
|||
>>> class Circle(Drawable):
|
||||
... pass
|
||||
...
|
||||
>>> c=Circle()
|
||||
>>> c = Circle()
|
||||
Traceback (most recent call last):
|
||||
File "<stdin>", line 1, in <module>
|
||||
TypeError: Can't instantiate abstract class Circle with abstract methods draw
|
||||
|
|
@ -1318,7 +1332,7 @@ built-in returns the binary representation for a number::
|
|||
The :func:`int` and :func:`long` built-ins will now accept the "0o"
|
||||
and "0b" prefixes when base-8 or base-2 are requested, or when the
|
||||
*base* argument is zero (signalling that the base used should be
|
||||
determined from the string):
|
||||
determined from the string)::
|
||||
|
||||
>>> int ('0o52', 0)
|
||||
42
|
||||
|
|
@ -1491,7 +1505,7 @@ Some smaller changes made to the core Python language are:
|
|||
(Contributed by Alexander Belopolsky; :issue:`1686487`.)
|
||||
|
||||
It's also become legal to provide keyword arguments after a ``*args`` argument
|
||||
to a function call.
|
||||
to a function call. ::
|
||||
|
||||
>>> def f(*args, **kw):
|
||||
... print args, kw
|
||||
|
|
@ -1532,17 +1546,17 @@ Some smaller changes made to the core Python language are:
|
|||
property. You would use them like this::
|
||||
|
||||
class C(object):
|
||||
@property
|
||||
def x(self):
|
||||
return self._x
|
||||
@property
|
||||
def x(self):
|
||||
return self._x
|
||||
|
||||
@x.setter
|
||||
def x(self, value):
|
||||
self._x = value
|
||||
@x.setter
|
||||
def x(self, value):
|
||||
self._x = value
|
||||
|
||||
@x.deleter
|
||||
def x(self):
|
||||
del self._x
|
||||
@x.deleter
|
||||
def x(self):
|
||||
del self._x
|
||||
|
||||
class D(C):
|
||||
@C.x.getter
|
||||
|
|
@ -1865,8 +1879,8 @@ changes, or look through the Subversion logs for all the details.
|
|||
|
||||
>>> var_type = collections.namedtuple('variable',
|
||||
... 'id name type size')
|
||||
# Names are separated by spaces or commas.
|
||||
# 'id, name, type, size' would also work.
|
||||
>>> # Names are separated by spaces or commas.
|
||||
>>> # 'id, name, type, size' would also work.
|
||||
>>> var_type._fields
|
||||
('id', 'name', 'type', 'size')
|
||||
|
||||
|
|
@ -1916,11 +1930,13 @@ changes, or look through the Subversion logs for all the details.
|
|||
|
||||
* A new window method in the :mod:`curses` module,
|
||||
:meth:`chgat`, changes the display attributes for a certain number of
|
||||
characters on a single line. (Contributed by Fabian Kreutz.) ::
|
||||
characters on a single line. (Contributed by Fabian Kreutz.)
|
||||
|
||||
::
|
||||
|
||||
# Boldface text starting at y=0,x=21
|
||||
# and affecting the rest of the line.
|
||||
stdscr.chgat(0,21, curses.A_BOLD)
|
||||
stdscr.chgat(0, 21, curses.A_BOLD)
|
||||
|
||||
The :class:`Textbox` class in the :mod:`curses.textpad` module
|
||||
now supports editing in insert mode as well as overwrite mode.
|
||||
|
|
@ -1986,8 +2002,8 @@ changes, or look through the Subversion logs for all the details.
|
|||
order, and returns a new generator that returns the contents of all
|
||||
the iterators, also in sorted order. For example::
|
||||
|
||||
heapq.merge([1, 3, 5, 9], [2, 8, 16]) ->
|
||||
[1, 2, 3, 5, 8, 9, 16]
|
||||
>>> list(heapq.merge([1, 3, 5, 9], [2, 8, 16]))
|
||||
[1, 2, 3, 5, 8, 9, 16]
|
||||
|
||||
Another new function, ``heappushpop(heap, item)``,
|
||||
pushes *item* onto *heap*, then pops off and returns the smallest item.
|
||||
|
|
@ -2021,57 +2037,55 @@ changes, or look through the Subversion logs for all the details.
|
|||
each of the elements; if some of the iterables are shorter than
|
||||
others, the missing values are set to *fillvalue*. For example::
|
||||
|
||||
itertools.izip_longest([1,2,3], [1,2,3,4,5]) ->
|
||||
(1, 1), (2, 2), (3, 3), (None, 4), (None, 5)
|
||||
>>> tuple(itertools.izip_longest([1,2,3], [1,2,3,4,5]))
|
||||
((1, 1), (2, 2), (3, 3), (None, 4), (None, 5))
|
||||
|
||||
``product(iter1, iter2, ..., [repeat=N])`` returns the Cartesian product
|
||||
of the supplied iterables, a set of tuples containing
|
||||
every possible combination of the elements returned from each iterable. ::
|
||||
|
||||
itertools.product([1,2,3], [4,5,6]) ->
|
||||
(1, 4), (1, 5), (1, 6),
|
||||
(2, 4), (2, 5), (2, 6),
|
||||
(3, 4), (3, 5), (3, 6)
|
||||
>>> list(itertools.product([1,2,3], [4,5,6]))
|
||||
[(1, 4), (1, 5), (1, 6),
|
||||
(2, 4), (2, 5), (2, 6),
|
||||
(3, 4), (3, 5), (3, 6)]
|
||||
|
||||
The optional *repeat* keyword argument is used for taking the
|
||||
product of an iterable or a set of iterables with themselves,
|
||||
repeated *N* times. With a single iterable argument, *N*-tuples
|
||||
are returned::
|
||||
|
||||
itertools.product([1,2], repeat=3) ->
|
||||
(1, 1, 1), (1, 1, 2), (1, 2, 1), (1, 2, 2),
|
||||
(2, 1, 1), (2, 1, 2), (2, 2, 1), (2, 2, 2)
|
||||
>>> list(itertools.product([1,2], repeat=3))
|
||||
[(1, 1, 1), (1, 1, 2), (1, 2, 1), (1, 2, 2),
|
||||
(2, 1, 1), (2, 1, 2), (2, 2, 1), (2, 2, 2)]
|
||||
|
||||
With two iterables, *2N*-tuples are returned. ::
|
||||
|
||||
itertools.product([1,2], [3,4], repeat=2) ->
|
||||
(1, 3, 1, 3), (1, 3, 1, 4), (1, 3, 2, 3), (1, 3, 2, 4),
|
||||
(1, 4, 1, 3), (1, 4, 1, 4), (1, 4, 2, 3), (1, 4, 2, 4),
|
||||
(2, 3, 1, 3), (2, 3, 1, 4), (2, 3, 2, 3), (2, 3, 2, 4),
|
||||
(2, 4, 1, 3), (2, 4, 1, 4), (2, 4, 2, 3), (2, 4, 2, 4)
|
||||
>>> list(itertools.product([1,2], [3,4], repeat=2))
|
||||
[(1, 3, 1, 3), (1, 3, 1, 4), (1, 3, 2, 3), (1, 3, 2, 4),
|
||||
(1, 4, 1, 3), (1, 4, 1, 4), (1, 4, 2, 3), (1, 4, 2, 4),
|
||||
(2, 3, 1, 3), (2, 3, 1, 4), (2, 3, 2, 3), (2, 3, 2, 4),
|
||||
(2, 4, 1, 3), (2, 4, 1, 4), (2, 4, 2, 3), (2, 4, 2, 4)]
|
||||
|
||||
``combinations(iterable, r)`` returns sub-sequences of length *r* from
|
||||
the elements of *iterable*. ::
|
||||
|
||||
itertools.combinations('123', 2) ->
|
||||
('1', '2'), ('1', '3'), ('2', '3')
|
||||
|
||||
itertools.combinations('123', 3) ->
|
||||
('1', '2', '3')
|
||||
|
||||
itertools.combinations('1234', 3) ->
|
||||
('1', '2', '3'), ('1', '2', '4'), ('1', '3', '4'),
|
||||
('2', '3', '4')
|
||||
>>> list(itertools.combinations('123', 2))
|
||||
[('1', '2'), ('1', '3'), ('2', '3')]
|
||||
>>> list(itertools.combinations('123', 3))
|
||||
[('1', '2', '3')]
|
||||
>>> list(itertools.combinations('1234', 3))
|
||||
[('1', '2', '3'), ('1', '2', '4'),
|
||||
('1', '3', '4'), ('2', '3', '4')]
|
||||
|
||||
``permutations(iter[, r])`` returns all the permutations of length *r* of
|
||||
the iterable's elements. If *r* is not specified, it will default to the
|
||||
number of elements produced by the iterable. ::
|
||||
|
||||
itertools.permutations([1,2,3,4], 2) ->
|
||||
(1, 2), (1, 3), (1, 4),
|
||||
(2, 1), (2, 3), (2, 4),
|
||||
(3, 1), (3, 2), (3, 4),
|
||||
(4, 1), (4, 2), (4, 3)
|
||||
>>> list(itertools.permutations([1,2,3,4], 2))
|
||||
[(1, 2), (1, 3), (1, 4),
|
||||
(2, 1), (2, 3), (2, 4),
|
||||
(3, 1), (3, 2), (3, 4),
|
||||
(4, 1), (4, 2), (4, 3)]
|
||||
|
||||
``itertools.chain(*iterables)`` is an existing function in
|
||||
:mod:`itertools` that gained a new constructor in Python 2.6.
|
||||
|
|
@ -2080,8 +2094,8 @@ changes, or look through the Subversion logs for all the details.
|
|||
then return all the elements of the first iterable, then
|
||||
all the elements of the second, and so on. ::
|
||||
|
||||
chain.from_iterable([[1,2,3], [4,5,6]]) ->
|
||||
1, 2, 3, 4, 5, 6
|
||||
>>> list(itertools.chain.from_iterable([[1,2,3], [4,5,6]]))
|
||||
[1, 2, 3, 4, 5, 6]
|
||||
|
||||
(All contributed by Raymond Hettinger.)
|
||||
|
||||
|
|
@ -2252,16 +2266,15 @@ changes, or look through the Subversion logs for all the details.
|
|||
with an installed Python package. For example::
|
||||
|
||||
>>> import pkgutil
|
||||
>>> pkgutil.get_data('test', 'exception_hierarchy.txt')
|
||||
'BaseException
|
||||
>>> print pkgutil.get_data('test', 'exception_hierarchy.txt')
|
||||
BaseException
|
||||
+-- SystemExit
|
||||
+-- KeyboardInterrupt
|
||||
+-- GeneratorExit
|
||||
+-- Exception
|
||||
+-- StopIteration
|
||||
+-- StandardError
|
||||
...'
|
||||
>>>
|
||||
...
|
||||
|
||||
(Contributed by Paul Moore; :issue:`2439`.)
|
||||
|
||||
|
|
@ -2535,9 +2548,9 @@ changes, or look through the Subversion logs for all the details.
|
|||
|
||||
with test_support.check_warnings() as wrec:
|
||||
warnings.simplefilter("always")
|
||||
... code that triggers a warning ...
|
||||
# ... code that triggers a warning ...
|
||||
assert str(wrec.message) == "function is outdated"
|
||||
assert len(wrec.warnings) == 1, "Multiple warnings raised"
|
||||
assert len(wrec.warnings) == 1, "Multiple warnings raised"
|
||||
|
||||
(Contributed by Brett Cannon.)
|
||||
|
||||
|
|
@ -2711,7 +2724,7 @@ for debugging::
|
|||
t = ast.parse("""
|
||||
d = {}
|
||||
for i in 'abcdefghijklm':
|
||||
d[i + i] = ord(i) - ord('a') + 1
|
||||
d[i + i] = ord(i) - ord('a') + 1
|
||||
print d
|
||||
""")
|
||||
print ast.dump(t)
|
||||
|
|
@ -2720,32 +2733,32 @@ This outputs a deeply nested tree::
|
|||
|
||||
Module(body=[
|
||||
Assign(targets=[
|
||||
Name(id='d', ctx=Store())
|
||||
Name(id='d', ctx=Store())
|
||||
], value=Dict(keys=[], values=[]))
|
||||
For(target=Name(id='i', ctx=Store()),
|
||||
iter=Str(s='abcdefghijklm'), body=[
|
||||
Assign(targets=[
|
||||
Subscript(value=
|
||||
Name(id='d', ctx=Load()),
|
||||
slice=
|
||||
Index(value=
|
||||
BinOp(left=Name(id='i', ctx=Load()), op=Add(),
|
||||
right=Name(id='i', ctx=Load()))), ctx=Store())
|
||||
], value=
|
||||
BinOp(left=
|
||||
BinOp(left=
|
||||
Call(func=
|
||||
Name(id='ord', ctx=Load()), args=[
|
||||
Name(id='i', ctx=Load())
|
||||
], keywords=[], starargs=None, kwargs=None),
|
||||
op=Sub(), right=Call(func=
|
||||
Name(id='ord', ctx=Load()), args=[
|
||||
Str(s='a')
|
||||
], keywords=[], starargs=None, kwargs=None)),
|
||||
op=Add(), right=Num(n=1)))
|
||||
], orelse=[])
|
||||
Print(dest=None, values=[
|
||||
Name(id='d', ctx=Load())
|
||||
iter=Str(s='abcdefghijklm'), body=[
|
||||
Assign(targets=[
|
||||
Subscript(value=
|
||||
Name(id='d', ctx=Load()),
|
||||
slice=
|
||||
Index(value=
|
||||
BinOp(left=Name(id='i', ctx=Load()), op=Add(),
|
||||
right=Name(id='i', ctx=Load()))), ctx=Store())
|
||||
], value=
|
||||
BinOp(left=
|
||||
BinOp(left=
|
||||
Call(func=
|
||||
Name(id='ord', ctx=Load()), args=[
|
||||
Name(id='i', ctx=Load())
|
||||
], keywords=[], starargs=None, kwargs=None),
|
||||
op=Sub(), right=Call(func=
|
||||
Name(id='ord', ctx=Load()), args=[
|
||||
Str(s='a')
|
||||
], keywords=[], starargs=None, kwargs=None)),
|
||||
op=Add(), right=Num(n=1)))
|
||||
], orelse=[])
|
||||
Print(dest=None, values=[
|
||||
Name(id='d', ctx=Load())
|
||||
], nl=True)
|
||||
])
|
||||
|
||||
|
|
@ -2754,7 +2767,7 @@ representing a literal expression, parses and evaluates it, and
|
|||
returns the resulting value. A literal expression is a Python
|
||||
expression containing only strings, numbers, dictionaries,
|
||||
etc. but no statements or function calls. If you need to
|
||||
evaluate an expression but accept the security risk of using an
|
||||
evaluate an expression but cannot accept the security risk of using an
|
||||
:func:`eval` call, :func:`literal_eval` will handle it safely::
|
||||
|
||||
>>> literal = '("a", "b", {2:4, 3:8, 1:2})'
|
||||
|
|
@ -2849,8 +2862,8 @@ Using the module is simple::
|
|||
|
||||
# Create data structure
|
||||
data_struct = dict(lastAccessed=datetime.datetime.now(),
|
||||
version=1,
|
||||
categories=('Personal','Shared','Private'))
|
||||
version=1,
|
||||
categories=('Personal','Shared','Private'))
|
||||
|
||||
# Create string containing XML.
|
||||
plist_str = plistlib.writePlistToString(data_struct)
|
||||
|
|
@ -3040,7 +3053,7 @@ Changes to Python's build process and to the C API include:
|
|||
``numfree``, and a macro ``Py<typename>_MAXFREELIST`` is
|
||||
always defined.
|
||||
|
||||
* A new Makefile target, "make check", prepares the Python source tree
|
||||
* A new Makefile target, "make patchcheck", prepares the Python source tree
|
||||
for making a patch: it fixes trailing whitespace in all modified
|
||||
``.py`` files, checks whether the documentation has been changed,
|
||||
and reports whether the :file:`Misc/ACKS` and :file:`Misc/NEWS` files
|
||||
|
|
@ -3261,13 +3274,13 @@ that may require changes to your code:
|
|||
.. ======================================================================
|
||||
|
||||
|
||||
.. _acks:
|
||||
.. _26acks:
|
||||
|
||||
Acknowledgements
|
||||
================
|
||||
|
||||
The author would like to thank the following people for offering
|
||||
suggestions, corrections and assistance with various drafts of this
|
||||
article: Georg Brandl, Steve Brown, Nick Coghlan, Jim Jewett, Kent
|
||||
Johnson, Chris Lambacher, Antoine Pitrou.
|
||||
article: Georg Brandl, Steve Brown, Nick Coghlan, Ralph Corderoy,
|
||||
Jim Jewett, Kent Johnson, Chris Lambacher, Antoine Pitrou, Brian Warner.
|
||||
|
||||
|
|
|
|||
138
Doc/whatsnew/2.7.rst
Normal file
138
Doc/whatsnew/2.7.rst
Normal file
|
|
@ -0,0 +1,138 @@
|
|||
****************************
|
||||
What's New in Python 2.7
|
||||
****************************
|
||||
|
||||
:Author: A.M. Kuchling (amk at amk.ca)
|
||||
:Release: |release|
|
||||
:Date: |today|
|
||||
|
||||
.. $Id$
|
||||
Rules for maintenance:
|
||||
|
||||
* Anyone can add text to this document. Do not spend very much time
|
||||
on the wording of your changes, because your text will probably
|
||||
get rewritten to some degree.
|
||||
|
||||
* The maintainer will go through Misc/NEWS periodically and add
|
||||
changes; it's therefore more important to add your changes to
|
||||
Misc/NEWS than to this file.
|
||||
|
||||
* This is not a complete list of every single change; completeness
|
||||
is the purpose of Misc/NEWS. Some changes I consider too small
|
||||
or esoteric to include. If such a change is added to the text,
|
||||
I'll just remove it. (This is another reason you shouldn't spend
|
||||
too much time on writing your addition.)
|
||||
|
||||
* If you want to draw your new text to the attention of the
|
||||
maintainer, add 'XXX' to the beginning of the paragraph or
|
||||
section.
|
||||
|
||||
* It's OK to just add a fragmentary note about a change. For
|
||||
example: "XXX Describe the transmogrify() function added to the
|
||||
socket module." The maintainer will research the change and
|
||||
write the necessary text.
|
||||
|
||||
* You can comment out your additions if you like, but it's not
|
||||
necessary (especially when a final release is some months away).
|
||||
|
||||
* Credit the author of a patch or bugfix. Just the name is
|
||||
sufficient; the e-mail address isn't necessary.
|
||||
|
||||
* It's helpful to add the bug/patch number in a parenthetical comment.
|
||||
|
||||
XXX Describe the transmogrify() function added to the socket
|
||||
module.
|
||||
(Contributed by P.Y. Developer; :issue:`12345`.)
|
||||
|
||||
This saves the maintainer some effort going through the SVN logs
|
||||
when researching a change.
|
||||
|
||||
This article explains the new features in Python 2.7.
|
||||
No release schedule has been decided yet for 2.7.
|
||||
|
||||
.. Compare with previous release in 2 - 3 sentences here.
|
||||
add hyperlink when the documentation becomes available online.
|
||||
|
||||
.. ========================================================================
|
||||
.. Large, PEP-level features and changes should be described here.
|
||||
.. Should there be a new section here for 3k migration?
|
||||
.. Or perhaps a more general section describing module changes/deprecation?
|
||||
.. ========================================================================
|
||||
|
||||
|
||||
|
||||
Other Language Changes
|
||||
======================
|
||||
|
||||
Some smaller changes made to the core Python language are:
|
||||
|
||||
* List of changes to be written here.
|
||||
|
||||
.. ======================================================================
|
||||
|
||||
|
||||
Optimizations
|
||||
-------------
|
||||
|
||||
To be written.
|
||||
|
||||
.. ======================================================================
|
||||
|
||||
New, Improved, and Deprecated Modules
|
||||
=====================================
|
||||
|
||||
As in every release, Python's standard library received a number of
|
||||
enhancements and bug fixes. Here's a partial list of the most notable
|
||||
changes, sorted alphabetically by module name. Consult the
|
||||
:file:`Misc/NEWS` file in the source tree for a more complete list of
|
||||
changes, or look through the Subversion logs for all the details.
|
||||
|
||||
* To be written.
|
||||
|
||||
.. ======================================================================
|
||||
.. whole new modules get described in subsections here
|
||||
|
||||
.. ======================================================================
|
||||
|
||||
|
||||
Build and C API Changes
|
||||
=======================
|
||||
|
||||
Changes to Python's build process and to the C API include:
|
||||
|
||||
* To be written.
|
||||
|
||||
.. ======================================================================
|
||||
|
||||
Port-Specific Changes: Windows
|
||||
-----------------------------------
|
||||
|
||||
|
||||
.. ======================================================================
|
||||
|
||||
Port-Specific Changes: Mac OS X
|
||||
-----------------------------------
|
||||
|
||||
|
||||
.. ======================================================================
|
||||
|
||||
Porting to Python 2.7
|
||||
=====================
|
||||
|
||||
This section lists previously described changes and other bugfixes
|
||||
that may require changes to your code:
|
||||
|
||||
To be written.
|
||||
|
||||
.. ======================================================================
|
||||
|
||||
|
||||
.. _acks27:
|
||||
|
||||
Acknowledgements
|
||||
================
|
||||
|
||||
The author would like to thank the following people for offering
|
||||
suggestions, corrections and assistance with various drafts of this
|
||||
article: no one yet.
|
||||
|
||||
|
|
@ -440,7 +440,7 @@ Platform-specific changes go here.
|
|||
.. ======================================================================
|
||||
|
||||
|
||||
.. _section-other:
|
||||
.. _30section-other:
|
||||
|
||||
Other Changes and Fixes
|
||||
=======================
|
||||
|
|
|
|||
22
Doc/whatsnew/index.rst
Normal file
22
Doc/whatsnew/index.rst
Normal file
|
|
@ -0,0 +1,22 @@
|
|||
.. _whatsnew-index:
|
||||
|
||||
######################
|
||||
What's New in Python
|
||||
######################
|
||||
|
||||
The "What's New in Python" series of essays takes tours through the most
|
||||
important changes between major Python versions. They are a "must read" for
|
||||
anyone wishing to stay up-to-date after a new release.
|
||||
|
||||
.. toctree::
|
||||
:maxdepth: 1
|
||||
|
||||
3.0.rst
|
||||
2.7.rst
|
||||
2.6.rst
|
||||
2.5.rst
|
||||
2.4.rst
|
||||
2.3.rst
|
||||
2.2.rst
|
||||
2.1.rst
|
||||
2.0.rst
|
||||
Loading…
Add table
Add a link
Reference in a new issue