-
:mod:`binhex` --- Encode and decode binhex4 files
=================================================
supporting a :meth:`write` and :meth:`close` method).
-.. function:: hexbin(input[, output])
+.. function:: hexbin(input, output)
Decode a binhex file *input*. *input* may be a filename or a file-like object
supporting :meth:`read` and :meth:`close` methods. The resulting file is written
- to a file named *output*, unless the argument is omitted in which case the
+ to a file named *output*, unless the argument is ``None`` in which case the
output filename is read from the binhex file.
The following exception is also defined:
-
:mod:`bisect` --- Array bisection algorithm
===========================================
The following functions are provided:
-.. function:: bisect_left(list, item[, lo[, hi]])
-
- Locate the proper insertion point for *item* in *list* to maintain sorted order.
- The parameters *lo* and *hi* may be used to specify a subset of the list which
- should be considered; by default the entire list is used. If *item* is already
- present in *list*, the insertion point will be before (to the left of) any
- existing entries. The return value is suitable for use as the first parameter
- to ``list.insert()``. This assumes that *list* is already sorted.
-
-
-.. function:: bisect_right(list, item[, lo[, hi]])
-
- Similar to :func:`bisect_left`, but returns an insertion point which comes after
- (to the right of) any existing entries of *item* in *list*.
-
-
-.. function:: bisect(...)
+.. function:: bisect_left(a, x, lo=0, hi=len(a))
- Alias for :func:`bisect_right`.
+ Locate the proper insertion point for *x* in *a* to maintain sorted order.
+ The parameters *lo* and *hi* may be used to specify a subset of the list
+ which should be considered; by default the entire list is used. If *x* is
+ already present in *a*, the insertion point will be before (to the left of)
+ any existing entries. The return value is suitable for use as the first
+ parameter to ``list.insert()``. This assumes that *a* is already sorted.
-.. function:: insort_left(list, item[, lo[, hi]])
+.. function:: bisect_right(a, x, lo=0, hi=len(a))
+ bisect(a, x, lo=0, hi=len(a))
- Insert *item* in *list* in sorted order. This is equivalent to
- ``list.insert(bisect.bisect_left(list, item, lo, hi), item)``. This assumes
- that *list* is already sorted.
+ Similar to :func:`bisect_left`, but returns an insertion point which comes
+ after (to the right of) any existing entries of *x* in *a*.
-.. function:: insort_right(list, item[, lo[, hi]])
+.. function:: insort_left(a, x, lo=0, hi=len(a))
- Similar to :func:`insort_left`, but inserting *item* in *list* after any
- existing entries of *item*.
+ Insert *x* in *a* in sorted order. This is equivalent to
+ ``a.insert(bisect.bisect_left(a, x, lo, hi), x)``. This assumes that *a* is
+ already sorted.
-.. function:: insort(...)
+.. function:: insort_right(a, x, lo=0, hi=len(a))
+ insort(a, x, lo=0, hi=len(a))
- Alias for :func:`insort_right`.
+ Similar to :func:`insort_left`, but inserting *x* in *a* after any existing
+ entries of *x*.
Examples
-
:mod:`builtins` --- Built-in objects
====================================
-
:mod:`bz2` --- Compression compatible with :program:`bzip2`
===========================================================
.. module:: bz2
- :synopsis: Interface to compression and decompression routines compatible with bzip2.
+ :synopsis: Interface to compression and decompression routines
+ compatible with bzip2.
.. moduleauthor:: Gustavo Niemeyer <niemeyer@conectiva.com>
.. sectionauthor:: Gustavo Niemeyer <niemeyer@conectiva.com>
Handling of compressed files is offered by the :class:`BZ2File` class.
-.. class:: BZ2File(filename[, mode[, buffering[, compresslevel]]])
+.. class:: BZ2File(filename, mode='r', buffering=0, compresslevel=9)
Open a bz2 file. Mode can be either ``'r'`` or ``'w'``, for reading (default)
or writing. When opened for writing, the file will be created if it doesn't
:class:`BZ2Compressor` and :class:`BZ2Decompressor`.
-.. class:: BZ2Compressor([compresslevel])
+.. class:: BZ2Compressor(compresslevel=9)
Create a new compressor object. This object may be used to compress data
sequentially. If you want to compress data in one shot, use the
:func:`compress` function instead. The *compresslevel* parameter, if given,
must be a number between ``1`` and ``9``; the default is ``9``.
-
.. method:: compress(data)
Provide more data to the compressor object. It will return chunks of
sequentially. If you want to decompress data in one shot, use the
:func:`decompress` function instead.
-
.. method:: decompress(data)
Provide more data to the decompressor object. It will return chunks of
and :func:`decompress` functions.
-.. function:: compress(data[, compresslevel])
+.. function:: compress(data, compresslevel=9)
Compress *data* in one shot. If you want to compress data sequentially, use
an instance of :class:`BZ2Compressor` instead. The *compresslevel* parameter,
-
:mod:`calendar` --- General calendar-related functions
======================================================
.. module:: calendar
- :synopsis: Functions for working with calendars, including some emulation of the Unix cal
- program.
+ :synopsis: Functions for working with calendars, including some emulation
+ of the Unix cal program.
.. sectionauthor:: Drew Csillag <drew_csillag@geocities.com>
it's the base calendar for all computations.
-.. class:: Calendar([firstweekday])
+.. class:: Calendar(firstweekday=0)
Creates a :class:`Calendar` object. *firstweekday* is an integer specifying the
first day of the week. ``0`` is Monday (the default), ``6`` is Sunday.
weeks. Weeks are lists of seven day numbers.
- .. method:: yeardatescalendar(year[, width])
+ .. method:: yeardatescalendar(year, width=3)
Return the data for the specified year ready for formatting. The return
value is a list of month rows. Each month row contains up to *width*
each week contains 1--7 days. Days are :class:`datetime.date` objects.
- .. method:: yeardays2calendar(year[, width])
+ .. method:: yeardays2calendar(year, width=3)
Return the data for the specified year ready for formatting (similar to
:meth:`yeardatescalendar`). Entries in the week lists are tuples of day
numbers and weekday numbers. Day numbers outside this month are zero.
- .. method:: yeardayscalendar(year[, width])
+ .. method:: yeardayscalendar(year, width=3)
Return the data for the specified year ready for formatting (similar to
:meth:`yeardatescalendar`). Entries in the week lists are day numbers. Day
numbers outside this month are zero.
-.. class:: TextCalendar([firstweekday])
+.. class:: TextCalendar(firstweekday=0)
This class can be used to generate plain text calendars.
-
:class:`TextCalendar` instances have the following methods:
- .. method:: formatmonth(theyear, themonth[, w[, l]])
+ .. method:: formatmonth(theyear, themonth, w=0, l=0)
Return a month's calendar in a multi-line string. If *w* is provided, it
specifies the width of the date columns, which are centered. If *l* is
:meth:`setfirstweekday` method.
- .. method:: prmonth(theyear, themonth[, w[, l]])
+ .. method:: prmonth(theyear, themonth, w=0, l=0)
Print a month's calendar as returned by :meth:`formatmonth`.
- .. method:: formatyear(theyear, themonth[, w[, l[, c[, m]]]])
+ .. method:: formatyear(theyear, themonth, w=2, l=1, c=6, m=3)
Return a *m*-column calendar for an entire year as a multi-line string.
Optional parameters *w*, *l*, and *c* are for date column width, lines per
can be generated is platform-dependent.
- .. method:: pryear(theyear[, w[, l[, c[, m]]]])
+ .. method:: pryear(theyear, w=2, l=1, c=6, m=3)
Print the calendar for an entire year as returned by :meth:`formatyear`.
-.. class:: HTMLCalendar([firstweekday])
+.. class:: HTMLCalendar(firstweekday=0)
This class can be used to generate HTML calendars.
:class:`HTMLCalendar` instances have the following methods:
- .. method:: formatmonth(theyear, themonth[, withyear])
+ .. method:: formatmonth(theyear, themonth, withyear=True)
Return a month's calendar as an HTML table. If *withyear* is true the year
will be included in the header, otherwise just the month name will be
used.
- .. method:: formatyear(theyear, themonth[, width])
+ .. method:: formatyear(theyear, themonth, width=3)
Return a year's calendar as an HTML table. *width* (defaulting to 3)
specifies the number of months per row.
- .. method:: formatyearpage(theyear[, width[, css[, encoding]]])
+ .. method:: formatyearpage(theyear, width=3, css='calendar.css', encoding=None)
Return a year's calendar as a complete HTML page. *width* (defaulting to
3) specifies the number of months per row. *css* is the name for the
output (defaulting to the system default encoding).
-.. class:: LocaleTextCalendar([firstweekday[, locale]])
+.. class:: LocaleTextCalendar(firstweekday=0, locale=None)
This subclass of :class:`TextCalendar` can be passed a locale name in the
constructor and will return month and weekday names in the specified
weekday names will be returned as unicode.
-.. class:: LocaleHTMLCalendar([firstweekday[, locale]])
+.. class:: LocaleHTMLCalendar(firstweekday=0, locale=None)
This subclass of :class:`HTMLCalendar` can be passed a locale name in the
constructor and will return month and weekday names in the specified
unless set by :func:`setfirstweekday`.
-.. function:: prmonth(theyear, themonth[, w[, l]])
+.. function:: prmonth(theyear, themonth, w=0, l=0)
Prints a month's calendar as returned by :func:`month`.
-.. function:: month(theyear, themonth[, w[, l]])
+.. function:: month(theyear, themonth, w=0, l=0)
Returns a month's calendar in a multi-line string using the :meth:`formatmonth`
of the :class:`TextCalendar` class.
-.. function:: prcal(year[, w[, l[c]]])
+.. function:: prcal(year, w=0, l=0, c=6, m=3)
Prints the calendar for an entire year as returned by :func:`calendar`.
-.. function:: calendar(year[, w[, l[c]]])
+.. function:: calendar(year, w=2, l=1, c=6, m=3)
- Returns a 3-column calendar for an entire year as a multi-line string using the
- :meth:`formatyear` of the :class:`TextCalendar` class.
+ Returns a 3-column calendar for an entire year as a multi-line string using
+ the :meth:`formatyear` of the :class:`TextCalendar` class.
.. function:: timegm(tuple)
-
-:mod:`cgi` --- Common Gateway Interface support.
-================================================
+:mod:`cgi` --- Common Gateway Interface support
+===============================================
.. module:: cgi
:synopsis: Helpers for running Python scripts via the Common Gateway Interface.
:meth:`getlist` provided by this higher level interface.
-.. method:: FieldStorage.getfirst(name[, default])
+.. method:: FieldStorage.getfirst(name, default=None)
This method always returns only one value associated with form field *name*.
The method returns only the first value in case that more values were posted
algorithms implemented in this module in other circumstances.
-.. function:: parse(fp[, keep_blank_values[, strict_parsing]])
+.. function:: parse(fp=None, environ=os.environ, keep_blank_values=False, strict_parsing=False)
Parse a query in the environment or from a file (the file defaults to
``sys.stdin``). The *keep_blank_values* and *strict_parsing* parameters are
passed to :func:`urllib.parse.parse_qs` unchanged.
-.. function:: parse_qs(qs[, keep_blank_values[, strict_parsing]])
+.. function:: parse_qs(qs, keep_blank_values=False, strict_parsing=False)
This function is deprecated in this module. Use :func:`urllib.parse.parse_qs`
instead. It is maintained here only for backward compatibility.
-.. function:: parse_qsl(qs[, keep_blank_values[, strict_parsing]])
+.. function:: parse_qsl(qs, keep_blank_values=False, strict_parsing=False)
This function is deprecated in this module. Use :func:`urllib.parse.parse_qs`
instead. It is maintained here only for backward compatibility.
Print a list of useful (used by CGI) environment variables in HTML.
-.. function:: escape(s[, quote])
+.. function:: escape(s, quote=False)
Convert the characters ``'&'``, ``'<'`` and ``'>'`` in string *s* to HTML-safe
sequences. Use this if you need to display text that might contain such
-
:mod:`cgitb` --- Traceback manager for CGI scripts
==================================================
analysis.
-.. function:: enable([display[, logdir[, context[, format]]]])
+.. function:: enable(display=1, logdir=None, context=5, format="html")
.. index:: single: excepthook() (in module sys)
value forces plain text output. The default value is ``"html"``.
-.. function:: handler([info])
+.. function:: handler(info=None)
This function handles an exception using the default settings (that is, show a
report in the browser, but don't log to a file). This can be used when you've
-
:mod:`chunk` --- Read IFF chunked data
======================================
instance will fail with a :exc:`EOFError` exception.
-.. class:: Chunk(file[, align, bigendian, inclheader])
+.. class:: Chunk(file, align=True, bigendian=True, inclheader=False)
Class which represents a chunk. The *file* argument is expected to be a
file-like object. An instance of this class is specifically allowed. The
Returns ``False``.
- .. method:: seek(pos[, whence])
+ .. method:: seek(pos, whence=0)
Set the chunk's current position. The *whence* argument is optional and
defaults to ``0`` (absolute file positioning); other values are ``1``
Return the current position into the chunk.
- .. method:: read([size])
+ .. method:: read(size=-1)
Read at most *size* bytes from the chunk (less if the read hits the end of
the chunk before obtaining *size* bytes). If the *size* argument is
-
:mod:`cmath` --- Mathematical functions for complex numbers
===========================================================
-
:mod:`cmd` --- Support for line-oriented command interpreters
=============================================================
interface.
-.. class:: Cmd([completekey[, stdin[, stdout]]])
+.. class:: Cmd(completekey='tab', stdin=None, stdout=None)
A :class:`Cmd` instance or subclass instance is a line-oriented interpreter
framework. There is no good reason to instantiate :class:`Cmd` itself; rather,
A :class:`Cmd` instance has the following methods:
-.. method:: Cmd.cmdloop([intro])
+.. method:: Cmd.cmdloop(intro=None)
Repeatedly issue a prompt, accept input, parse an initial prefix off the
received input, and dispatch to action methods, passing them the remainder of
build applications which provide an interactive interpreter prompt.
-.. class:: InteractiveInterpreter([locals])
+.. class:: InteractiveInterpreter(locals=None)
This class deals with parsing and interpreter state (the user's namespace); it
does not deal with input buffering or prompting or input file naming (the
``'__doc__'`` set to ``None``.
-.. class:: InteractiveConsole([locals[, filename]])
+.. class:: InteractiveConsole(locals=None, filename="<console>")
Closely emulate the behavior of the interactive Python interpreter. This class
builds on :class:`InteractiveInterpreter` and adds prompting using the familiar
``sys.ps1`` and ``sys.ps2``, and input buffering.
-.. function:: interact([banner[, readfunc[, local]]])
+.. function:: interact(banner=None, readfunc=None, local=None)
Convenience function to run a read-eval-print loop. This creates a new instance
of :class:`InteractiveConsole` and sets *readfunc* to be used as the
discarded after use.
-.. function:: compile_command(source[, filename[, symbol]])
+.. function:: compile_command(source, filename="<input>", symbol="single")
This function is useful for programs that want to emulate Python's interpreter
main loop (a.k.a. the read-eval-print loop). The tricky part is to determine
-------------------------------
-.. method:: InteractiveInterpreter.runsource(source[, filename[, symbol]])
+.. method:: InteractiveInterpreter.runsource(source, filename="<input>", symbol="single")
Compile and run some source in the interpreter. Arguments are the same as for
:func:`compile_command`; the default for *filename* is ``'<input>'``, and for
with it.
-.. method:: InteractiveInterpreter.showsyntaxerror([filename])
+.. method:: InteractiveInterpreter.showsyntaxerror(filename=None)
Display the syntax error that just occurred. This does not display a stack
trace because there isn't one for syntax errors. If *filename* is given, it is
interpreter objects as well as the following additions.
-.. method:: InteractiveConsole.interact([banner])
+.. method:: InteractiveConsole.interact(banner=None)
Closely emulate the interactive Python console. The optional banner argument
specify the banner to print before the first interaction; by default it prints a
Remove any unhandled source text from the input buffer.
-.. method:: InteractiveConsole.raw_input([prompt])
+.. method:: InteractiveConsole.raw_input(prompt="")
Write a prompt and read a line. The returned line does not include the trailing
newline. When the user enters the EOF key sequence, :exc:`EOFError` is raised.
-
:mod:`codecs` --- Codec registry and base classes
=================================================
defaults to line buffered.
-.. function:: EncodedFile(file, input[, output[, errors]])
+.. function:: EncodedFile(file, data_encoding, file_encoding=None, errors='strict')
Return a wrapped version of file which provides transparent encoding
translation.
Bytes written to the wrapped file are interpreted according to the given
- *input* encoding and then written to the original file as bytes using the
- *output* encoding.
+ *data_encoding* and then written to the original file as bytes using the
+ *file_encoding*.
- If *output* is not given, it defaults to *input*.
+ If *file_encoding* is not given, it defaults to *data_encoding*.
- *errors* may be given to define the error handling. It defaults to ``'strict'``,
- which causes :exc:`ValueError` to be raised in case an encoding error occurs.
+ *errors* may be given to define the error handling. It defaults to
+ ``'strict'``, which causes :exc:`ValueError` to be raised in case an encoding
+ error occurs.
-.. function:: iterencode(iterable, encoding[, errors])
+.. function:: iterencode(iterator, encoding, errors='strict', **kwargs)
Uses an incremental encoder to iteratively encode the input provided by
- *iterable*. This function is a :term:`generator`. *errors* (as well as any
+ *iterator*. This function is a :term:`generator`. *errors* (as well as any
other keyword argument) is passed through to the incremental encoder.
-.. function:: iterdecode(iterable, encoding[, errors])
+.. function:: iterdecode(iterator, encoding, errors='strict', **kwargs)
Uses an incremental decoder to iteratively decode the input provided by
- *iterable*. This function is a :term:`generator`. *errors* (as well as any
+ *iterator*. This function is a :term:`generator`. *errors* (as well as any
other keyword argument) is passed through to the incremental decoder.
+
The module also provides the following constants which are useful for reading
and writing to platform dependent files:
projects / python / commitdiff