mirror of https://github.com/python/cpython
Since we recommend one module per import line, reflect this also in the
documentation.
This commit is contained in:
parent
a630735b31
commit
5149742e8b
|
@ -267,7 +267,8 @@ sequence with comparable semantics, for example, yet many people write their own
|
|||
:func:`max`/:func:`min`. Another highly useful function is :func:`reduce`. A
|
||||
classical use of :func:`reduce` is something like ::
|
||||
|
||||
import sys, operator
|
||||
import operator
|
||||
import sys
|
||||
nums = map(float, sys.argv[1:])
|
||||
print reduce(operator.add, nums)/len(nums)
|
||||
|
||||
|
|
|
@ -99,7 +99,8 @@ simple CGI program::
|
|||
# -*- coding: UTF-8 -*-
|
||||
|
||||
# enable debugging
|
||||
import cgitb; cgitb.enable()
|
||||
import cgitb
|
||||
cgitb.enable()
|
||||
|
||||
print "Content-Type: text/plain;charset=utf-8"
|
||||
print
|
||||
|
@ -279,7 +280,9 @@ following WSGI-application::
|
|||
# -*- coding: UTF-8 -*-
|
||||
|
||||
from cgi import escape
|
||||
import sys, os
|
||||
import os
|
||||
import sys
|
||||
|
||||
from flup.server.fcgi import WSGIServer
|
||||
|
||||
def app(environ, start_response):
|
||||
|
|
|
@ -1,5 +1,6 @@
|
|||
import datetime
|
||||
import sqlite3
|
||||
import datetime, time
|
||||
import time
|
||||
|
||||
def adapt_datetime(ts):
|
||||
return time.mktime(ts.timetuple())
|
||||
|
|
|
@ -246,7 +246,8 @@ asyncore Example basic HTTP client
|
|||
Here is a very basic HTTP client that uses the :class:`dispatcher` class to
|
||||
implement its socket handling::
|
||||
|
||||
import asyncore, socket
|
||||
import asyncore
|
||||
import socket
|
||||
|
||||
class http_client(asyncore.dispatcher):
|
||||
|
||||
|
|
|
@ -67,16 +67,20 @@ Begin by writing ``import cgi``. Do not use ``from cgi import *`` --- the
|
|||
module defines all sorts of names for its own use or for backward compatibility
|
||||
that you don't want in your namespace.
|
||||
|
||||
When you write a new script, consider adding the line::
|
||||
When you write a new script, consider adding the following::
|
||||
|
||||
import cgitb; cgitb.enable()
|
||||
import cgitb
|
||||
|
||||
cgitb.enable()
|
||||
|
||||
This activates a special exception handler that will display detailed reports in
|
||||
the Web browser if any errors occur. If you'd rather not show the guts of your
|
||||
program to users of your script, you can have the reports saved to files
|
||||
instead, with a line like this::
|
||||
instead, with something like this::
|
||||
|
||||
import cgitb; cgitb.enable(display=0, logdir="/tmp")
|
||||
import cgitb
|
||||
|
||||
cgitb.enable(display=0, logdir="/tmp")
|
||||
|
||||
It's very helpful to use this feature during script development. The reports
|
||||
produced by :mod:`cgitb` provide information that can save you a lot of time in
|
||||
|
|
|
@ -231,7 +231,8 @@ RawConfigParser Objects
|
|||
load the required file or files using :meth:`readfp` before calling :meth:`read`
|
||||
for any optional files::
|
||||
|
||||
import ConfigParser, os
|
||||
import ConfigParser
|
||||
import os
|
||||
|
||||
config = ConfigParser.ConfigParser()
|
||||
config.readfp(open('defaults.cfg'))
|
||||
|
|
|
@ -747,7 +747,8 @@ Examples
|
|||
|
||||
The first example shows the most common usage of :mod:`cookielib`::
|
||||
|
||||
import cookielib, urllib2
|
||||
import cookielib
|
||||
import urllib2
|
||||
cj = cookielib.CookieJar()
|
||||
opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cj))
|
||||
r = opener.open("http://example.com/")
|
||||
|
@ -755,7 +756,9 @@ The first example shows the most common usage of :mod:`cookielib`::
|
|||
This example illustrates how to open a URL using your Netscape, Mozilla, or Lynx
|
||||
cookies (assumes Unix/Netscape convention for location of the cookies file)::
|
||||
|
||||
import os, cookielib, urllib2
|
||||
import cookielib
|
||||
import os
|
||||
import urllib2
|
||||
cj = cookielib.MozillaCookieJar()
|
||||
cj.load(os.path.join(os.environ["HOME"], ".netscape/cookies.txt"))
|
||||
opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cj))
|
||||
|
|
|
@ -45,7 +45,9 @@ this module.
|
|||
|
||||
A simple example illustrating typical use::
|
||||
|
||||
import crypt, getpass, pwd
|
||||
import crypt
|
||||
import getpass
|
||||
import pwd
|
||||
|
||||
def login():
|
||||
username = raw_input('Python login:')
|
||||
|
|
|
@ -460,7 +460,8 @@ Registering a new dialect::
|
|||
|
||||
A slightly more advanced use of the reader --- catching and reporting errors::
|
||||
|
||||
import csv, sys
|
||||
import csv
|
||||
import sys
|
||||
filename = "some.csv"
|
||||
reader = csv.reader(open(filename, "rb"))
|
||||
try:
|
||||
|
@ -506,7 +507,9 @@ For all other encodings the following :class:`UnicodeReader` and
|
|||
parameter in their constructor and make sure that the data passes the real
|
||||
reader or writer encoded as UTF-8::
|
||||
|
||||
import csv, codecs, cStringIO
|
||||
import codecs
|
||||
import cStringIO
|
||||
import csv
|
||||
|
||||
class UTF8Recoder:
|
||||
"""
|
||||
|
|
|
@ -708,7 +708,11 @@ It is also contained in the Python source distribution, as
|
|||
|
||||
"""
|
||||
|
||||
import sys, os, time, difflib, optparse
|
||||
import difflib
|
||||
import os
|
||||
import optparse
|
||||
import sys
|
||||
import time
|
||||
|
||||
def main():
|
||||
# Configure the option parser
|
||||
|
|
|
@ -951,9 +951,11 @@ Python 2.4, :mod:`doctest`'s :class:`Tester` class is deprecated, and
|
|||
test suites from modules and text files containing doctests. These test suites
|
||||
can then be run using :mod:`unittest` test runners::
|
||||
|
||||
import unittest
|
||||
import doctest
|
||||
import my_module_with_doctests, and_another
|
||||
import unittest
|
||||
|
||||
import my_module_with_doctests
|
||||
import my_other_module_with_doctests
|
||||
|
||||
suite = unittest.TestSuite()
|
||||
for mod in my_module_with_doctests, and_another:
|
||||
|
|
|
@ -133,7 +133,9 @@ The module defines the following functions:
|
|||
|
||||
Examples (all on a SVR4 compliant system)::
|
||||
|
||||
import struct, fcntl, os
|
||||
import fcntl
|
||||
import os
|
||||
import struct
|
||||
|
||||
f = open(...)
|
||||
rv = fcntl.fcntl(f, fcntl.F_SETFL, os.O_NDELAY)
|
||||
|
|
|
@ -114,7 +114,8 @@ Using long option names is equally easy:
|
|||
|
||||
In a script, typical usage is something like this::
|
||||
|
||||
import getopt, sys
|
||||
import getopt
|
||||
import sys
|
||||
|
||||
def main():
|
||||
try:
|
||||
|
|
|
@ -124,7 +124,9 @@ The following functions are non-standard or have special argument conventions:
|
|||
|
||||
Here is a tiny but complete example GL program in Python::
|
||||
|
||||
import gl, GL, time
|
||||
import gl
|
||||
import GL
|
||||
import time
|
||||
|
||||
def main():
|
||||
gl.foreground()
|
||||
|
|
|
@ -521,7 +521,8 @@ IMAP4 Example
|
|||
Here is a minimal example (without error checking) that opens a mailbox and
|
||||
retrieves and prints all messages::
|
||||
|
||||
import getpass, imaplib
|
||||
import getpass
|
||||
import imaplib
|
||||
|
||||
M = imaplib.IMAP4()
|
||||
M.login(getpass.getuser(), getpass.getpass())
|
||||
|
|
|
@ -112,7 +112,9 @@ This code is intended to be read, not executed. However, it does work
|
|||
|
||||
::
|
||||
|
||||
import sys, imp, __builtin__
|
||||
import __builtin__
|
||||
import imp
|
||||
import sys
|
||||
|
||||
# Replacement for __import__()
|
||||
def import_hook(name, globals=None, locals=None, fromlist=None):
|
||||
|
|
|
@ -1347,7 +1347,8 @@ Let's say you want to send logging events across a network, and handle them at
|
|||
the receiving end. A simple way of doing this is attaching a
|
||||
:class:`SocketHandler` instance to the root logger at the sending end::
|
||||
|
||||
import logging, logging.handlers
|
||||
import logging
|
||||
import logging.handlers
|
||||
|
||||
rootLogger = logging.getLogger('')
|
||||
rootLogger.setLevel(logging.DEBUG)
|
||||
|
@ -2600,7 +2601,9 @@ properly preceded with the binary-encoded length, as the new logging
|
|||
configuration::
|
||||
|
||||
#!/usr/bin/env python
|
||||
import socket, sys, struct
|
||||
import socket
|
||||
import struct
|
||||
import sys
|
||||
|
||||
data_to_send = open(sys.argv[1], "r").read()
|
||||
|
||||
|
|
|
@ -64,7 +64,8 @@ Example usage of :class:`ModuleFinder`
|
|||
|
||||
The script that is going to get analyzed later on (bacon.py)::
|
||||
|
||||
import re, itertools
|
||||
import itertools
|
||||
import re
|
||||
|
||||
try:
|
||||
import baconhameggs
|
||||
|
|
|
@ -708,7 +708,8 @@ The following example reads the resulting pickled data. When reading a
|
|||
pickle-containing file, you should open the file in binary mode because you
|
||||
can't be sure if the ASCII or binary format was used. ::
|
||||
|
||||
import pprint, pickle
|
||||
import pickle
|
||||
import pprint
|
||||
|
||||
pkl_file = open('data.pkl', 'rb')
|
||||
|
||||
|
|
|
@ -182,7 +182,8 @@ POP3 Example
|
|||
Here is a minimal example (without error checking) that opens a mailbox and
|
||||
retrieves and prints all messages::
|
||||
|
||||
import getpass, poplib
|
||||
import getpass
|
||||
import poplib
|
||||
|
||||
M = poplib.POP3('localhost')
|
||||
M.user(getpass.getuser())
|
||||
|
|
|
@ -228,7 +228,8 @@ serial device that may not be turned on, which would normally cause the
|
|||
before opening the file; if the operation takes too long, the alarm signal will
|
||||
be sent, and the handler raises an exception. ::
|
||||
|
||||
import signal, os
|
||||
import os
|
||||
import signal
|
||||
|
||||
def handler(signum, frame):
|
||||
print 'Signal handler called with signal', signum
|
||||
|
|
|
@ -423,7 +423,8 @@ Connection Objects
|
|||
Example::
|
||||
|
||||
# Convert file existing_db.db to SQL dump file dump.sql
|
||||
import sqlite3, os
|
||||
import os
|
||||
import sqlite3
|
||||
|
||||
con = sqlite3.connect('existing_db.db')
|
||||
with open('dump.sql', 'w') as f:
|
||||
|
|
|
@ -481,7 +481,9 @@ Client-side operation
|
|||
This example connects to an SSL server, prints the server's address and certificate,
|
||||
sends some bytes, and reads part of the response::
|
||||
|
||||
import socket, ssl, pprint
|
||||
import pprint
|
||||
import socket
|
||||
import ssl
|
||||
|
||||
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
||||
|
||||
|
@ -535,7 +537,8 @@ For server operation, typically you'd need to have a server certificate, and pri
|
|||
You'd open a socket, bind it to a port, call :meth:`listen` on it, then start waiting for clients
|
||||
to connect::
|
||||
|
||||
import socket, ssl
|
||||
import socket
|
||||
import ssl
|
||||
|
||||
bindsocket = socket.socket()
|
||||
bindsocket.bind(('myaddr.mydomain.com', 10023))
|
||||
|
|
|
@ -139,7 +139,8 @@ on the implementation of the underlying system call.
|
|||
|
||||
Example::
|
||||
|
||||
import os, sys
|
||||
import os
|
||||
import sys
|
||||
from stat import *
|
||||
|
||||
def walktree(top, callback):
|
||||
|
|
|
@ -135,11 +135,13 @@ methods (except ``control`` objects which only provide :meth:`getinfo`,
|
|||
The audio device supports asynchronous notification of various events, through
|
||||
the SIGPOLL signal. Here's an example of how you might enable this in Python::
|
||||
|
||||
import fcntl
|
||||
import signal
|
||||
import STROPTS
|
||||
|
||||
def handle_sigpoll(signum, frame):
|
||||
print 'I got a SIGPOLL update'
|
||||
|
||||
import fcntl, signal, STROPTS
|
||||
|
||||
signal.signal(signal.SIGPOLL, handle_sigpoll)
|
||||
fcntl.ioctl(audio_obj.fileno(), STROPTS.I_SETSIG, STROPTS.S_MSG)
|
||||
|
||||
|
|
|
@ -91,7 +91,8 @@ technique using a separate :func:`tcgetattr` call and a :keyword:`try` ...
|
|||
exactly no matter what happens::
|
||||
|
||||
def getpass(prompt = "Password: "):
|
||||
import termios, sys
|
||||
import sys
|
||||
import termios
|
||||
fd = sys.stdin.fileno()
|
||||
old = termios.tcgetattr(fd)
|
||||
new = termios.tcgetattr(fd)
|
||||
|
|
|
@ -145,7 +145,8 @@ less useful than) the standard Python interactive interpreter loop. For a more
|
|||
complete implementation of the interpreter loop, refer to the :mod:`code`
|
||||
module. ::
|
||||
|
||||
import sys, traceback
|
||||
import sys
|
||||
import traceback
|
||||
|
||||
def run_user_code(envdir):
|
||||
source = raw_input(">>> ")
|
||||
|
@ -165,7 +166,8 @@ module. ::
|
|||
The following example demonstrates the different ways to print and format the
|
||||
exception and traceback::
|
||||
|
||||
import sys, traceback
|
||||
import sys
|
||||
import traceback
|
||||
|
||||
def lumberjack():
|
||||
bright_side_of_death()
|
||||
|
|
|
@ -551,7 +551,8 @@ transport. The following example shows how:
|
|||
|
||||
::
|
||||
|
||||
import xmlrpclib, httplib
|
||||
import httplib
|
||||
import xmlrpclib
|
||||
|
||||
class ProxiedTransport(xmlrpclib.Transport):
|
||||
def set_proxy(self, proxy):
|
||||
|
|
|
@ -99,7 +99,8 @@ Automatic completion of variable and module names is optionally available. To
|
|||
enable it in the interpreter's interactive mode, add the following to your
|
||||
startup file: [#]_ ::
|
||||
|
||||
import rlcompleter, readline
|
||||
import readline
|
||||
import rlcompleter
|
||||
readline.parse_and_bind('tab: complete')
|
||||
|
||||
This binds the :kbd:`Tab` key to the completion function, so hitting the
|
||||
|
|
|
@ -170,7 +170,8 @@ case is running I/O in parallel with computations in another thread.
|
|||
The following code shows how the high level :mod:`threading` module can run
|
||||
tasks in background while the main program continues to run::
|
||||
|
||||
import threading, zipfile
|
||||
import threading
|
||||
import zipfile
|
||||
|
||||
class AsyncZip(threading.Thread):
|
||||
def __init__(self, infile, outfile):
|
||||
|
|
|
@ -473,7 +473,8 @@ statement both starts a database transaction and acquires a thread lock::
|
|||
Finally, the :func:`closing(object)` function returns *object* so that it can be
|
||||
bound to a variable, and calls ``object.close`` at the end of the block. ::
|
||||
|
||||
import urllib, sys
|
||||
import sys
|
||||
import urllib
|
||||
from contextlib import closing
|
||||
|
||||
with closing(urllib.urlopen('http://www.yahoo.com')) as f:
|
||||
|
|
Loading…
Reference in New Issue