home *** CD-ROM | disk | FTP | other *** search
/ The Datafile PD-CD 5 / DATAFILE_PDCD5.iso / utilities / p / python / !ibrowse / files / pylibi-1 (.txt) < prev    next >
GNU Info File  |  1996-11-14  |  39KB  |  785 lines
  1. This is Info file pylibi, produced by Makeinfo-1.55 from the input file
  2. lib.texi.
  3. This file describes the built-in types, exceptions and functions and the
  4. standard modules that come with the Python system.  It assumes basic
  5. knowledge about the Python language.  For an informal introduction to
  6. the language, see the Python Tutorial.  The Python Reference Manual
  7. gives a more formal definition of the language.  (These manuals are not
  8. yet available in INFO or Texinfo format.)
  9. Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam, The
  10. Netherlands.
  11. All Rights Reserved
  12. Permission to use, copy, modify, and distribute this software and its
  13. documentation for any purpose and without fee is hereby granted,
  14. provided that the above copyright notice appear in all copies and that
  15. both that copyright notice and this permission notice appear in
  16. supporting documentation, and that the names of Stichting Mathematisch
  17. Centrum or CWI or Corporation for National Research Initiatives or CNRI
  18. not be used in advertising or publicity pertaining to distribution of
  19. the software without specific, written prior permission.
  20. While CWI is the initial source for this software, a modified version
  21. is made available by the Corporation for National Research Initiatives
  22. (CNRI) at the Internet address ftp://ftp.python.org.
  23. STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
  24. REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
  25. MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
  26. CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
  27. DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  28. PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
  29. ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
  30. THIS SOFTWARE.
  31. File: pylibi,  Node: Top,  Next: Introduction,  Prev: (dir),  Up: (dir)
  32. The Python library
  33. ******************
  34. This file describes the built-in types, exceptions and functions and the
  35. standard modules that come with the Python system.  It assumes basic
  36. knowledge about the Python language.  For an informal introduction to
  37. the language, see the `Python Tutorial'.  The `Python Reference Manual'
  38. gives a more formal definition of the language.  (These manuals are not
  39. yet available in INFO or Texinfo format.)
  40. This version corresponds to Python version 1.4 (Oct 25 1996).
  41. * Menu:
  42. * Introduction::
  43. * Built-in Objects::
  44. * Python Services::
  45. * String Services::
  46. * Miscellaneous Services::
  47. * Generic Operating System Services::
  48. * Optional Operating System Services::
  49. * The Python Debugger::
  50. * The Python Profiler::
  51. * Internet and WWW::
  52. * Restricted Execution::
  53. * Cryptographic Services::
  54. * RISCOS ONLY::
  55. * Function Index::
  56. * Variable Index::
  57. * Module Index::
  58. * Concept Index::
  59. File: pylibi,  Node: Introduction,  Next: Built-in Objects,  Prev: Top,  Up: Top
  60. Introduction
  61. ************
  62. The "Python library" contains several different kinds of components.
  63. It contains data types that would normally be considered part of the
  64. "core" of a language, such as numbers and lists.  For these types, the
  65. Python language core defines the form of literals and places some
  66. constraints on their semantics, but does not fully define the
  67. semantics.  (On the other hand, the language core does define syntactic
  68. properties like the spelling and priorities of operators.)
  69. The library also contains built-in functions and exceptions -- objects
  70. that can be used by all Python code without the need of an `import'
  71. statement.  Some of these are defined by the core language, but many
  72. are not essential for the core semantics and are only described here.
  73. The bulk of the library, however, consists of a collection of modules.
  74. There are many ways to dissect this collection.  Some modules are
  75. written in C and built in to the Python interpreter; others are written
  76. in Python and imported in source form.  Some modules provide interfaces
  77. that are highly specific to Python, like printing a stack trace; some
  78. provide interfaces that are specific to particular operating systems,
  79. like socket I/O; others provide interfaces that are specific to a
  80. particular application domain, like the World-Wide Web.  Some modules
  81. are avaiable in all versions and ports of Python; others are only
  82. available when the underlying system supports or requires them; yet
  83. others are available only when a particular configuration option was
  84. chosen at the time when Python was compiled and installed.
  85. This manual is organized "from the inside out": it first describes the
  86. built-in data types, then the built-in functions and exceptions, and
  87. finally the modules, grouped in chapters of related modules.  The
  88. ordering of the chapters as well as the ordering of the modules within
  89. each chapter is roughly from most relevant to least important.
  90. This means that if you start reading this manual from the start, and
  91. skip to the next chapter when you get bored, you will get a reasonable
  92. overview of the available modules and application areas that are
  93. supported by the Python library.  Of course, you don't *have* to read
  94. it like a novel -- you can also browse the table of contents (in front
  95. of the manual), or look for a specific function, module or term in the
  96. index (in the back).  And finally, if you enjoy learning about random
  97. subjects, you choose a random page number (see module `rand') and read
  98. a section or two.
  99. Let the show begin!
  100. File: pylibi,  Node: Built-in Objects,  Next: Python Services,  Prev: Introduction,  Up: Top
  101. Built-in Types, Exceptions and Functions
  102. ****************************************
  103. Names for built-in exceptions and functions are found in a separate
  104. symbol table.  This table is searched last when the interpreter looks
  105. up the meaning of a name, so local and global user-defined names can
  106. override built-in names.  Built-in types are described together here
  107. for easy reference.(1)
  108. The tables in this chapter document the priorities of operators by
  109. listing them in order of ascending priority (within a table) and
  110. grouping operators that have the same priority in the same box.  Binary
  111. operators of the same priority group from left to right.  (Unary
  112. operators group from right to left, but there you have no real choice.)
  113. See Chapter 5 of the Python Reference Manual for the complete picture
  114. on operator priorities.
  115. * Menu:
  116. * Types::
  117. * Exceptions::
  118. * Built-in Functions::
  119. ---------- Footnotes ----------
  120. (1)  Most descriptions sorely lack explanations of the exceptions that
  121. may be raised -- this will be fixed in a future version of this manual.
  122. File: pylibi,  Node: Types,  Next: Exceptions,  Prev: Built-in Objects,  Up: Built-in Objects
  123. Built-in Types
  124. ==============
  125. The following sections describe the standard types that are built into
  126. the interpreter.  These are the numeric types, sequence types, and
  127. several others, including types themselves.  There is no explicit
  128. Boolean type; use integers instead.
  129. Some operations are supported by several object types; in particular,
  130. all objects can be compared, tested for truth value, and converted to a
  131. string (with the ``...`' notation).  The latter conversion is
  132. implicitly used when an object is written by the `print' statement.
  133. * Menu:
  134. * Truth Value Testing::
  135. * Boolean Operations::
  136. * Comparisons::
  137. * Numeric Types::
  138. * Sequence Types::
  139. * Mapping Types::
  140. * Other Built-in Types::
  141. * Special Attributes::
  142. File: pylibi,  Node: Truth Value Testing,  Next: Boolean Operations,  Prev: Types,  Up: Types
  143. Truth Value Testing
  144. -------------------
  145. Any object can be tested for truth value, for use in an `if' or `while'
  146. condition or as operand of the Boolean operations below.  The following
  147. values are considered false:
  148.    * `None'
  149.    * zero of any numeric type, e.g., `0', `0L', `0.0'.
  150.    * any empty sequence, e.g., `''', `()', `[]'.
  151.    * any empty mapping, e.g., `{}'.
  152.    * instances of user-defined classes, if the class defines a
  153.      `__nonzero__()' or `__len__()' method, when that method returns
  154.      zero.
  155. All other values are considered true -- so objects of many types are
  156. always true.
  157. Operations and built-in functions that have a Boolean result always
  158. return `0' for false and `1' for true, unless otherwise stated.
  159. (Important exception: the Boolean oper