Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 1 | \chapter{Glossary\label{glossary}} |
| 2 | |
| 3 | %%% keep the entries sorted and include at least one \index{} item for each |
Raymond Hettinger | 5a25aa6 | 2003-09-27 05:42:14 +0000 | [diff] [blame] | 4 | %%% cross-references are marked with \emph{entry} |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 5 | |
| 6 | \begin{description} |
| 7 | |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 8 | |
| 9 | \index{>>>} |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 10 | \item[\code{>\code{>}>}] |
| 11 | The typical Python prompt of the interactive shell. Often seen for |
| 12 | code examples that can be tried right away in the interpreter. |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 13 | |
Raymond Hettinger | 43b5e40 | 2003-09-27 20:19:02 +0000 | [diff] [blame] | 14 | \index{...} |
| 15 | \item[\code{.\code{.}.}] |
| 16 | The typical Python prompt of the interactive shell when entering code |
| 17 | for an indented code block. |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 18 | |
| 19 | \index{BDFL} |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 20 | \item[BDFL] |
| 21 | Benevolent Dictator For Life, a.k.a. \ulink{Guido van |
Raymond Hettinger | 43b5e40 | 2003-09-27 20:19:02 +0000 | [diff] [blame] | 22 | Rossum}{http://www.python.org/\textasciitilde{}guido/}, Python's creator. |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 23 | |
| 24 | \index{byte code} |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 25 | \item[byte code] |
| 26 | The internal representation of a Python program in the interpreter. |
| 27 | The byte code is also cached in the \code{.pyc} and \code{.pyo} |
| 28 | files so that executing the same file is faster the second time |
| 29 | (compilation from source to byte code can be saved). This |
Raymond Hettinger | 43b5e40 | 2003-09-27 20:19:02 +0000 | [diff] [blame] | 30 | ``intermediate language'' is said to run on a ``virtual |
| 31 | machine'' that calls the subroutines corresponding to each bytecode. |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 32 | |
| 33 | \index{classic class} |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 34 | \item[classic class] |
| 35 | Any class which does not inherit from \class{object}. See |
| 36 | \emph{new-style class}. |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 37 | |
| 38 | \index{coercion} |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 39 | \item[coercion] |
Skip Montanaro | dbb4078 | 2004-03-27 18:23:11 +0000 | [diff] [blame] | 40 | |
| 41 | The implicit conversion of an instance of one type to another during an |
| 42 | operation which involves two arguments of the same type. For example, |
| 43 | {}\code{int(3.15)} converts the floating point number to the integer, |
| 44 | {}\code{3}, but in {}\code{3+4.5}, each argument is of a different type (one |
| 45 | int, one float), and both must be converted to the same type before they can |
| 46 | be added or it will raise a {}\code{TypeError}. Coercion between two |
| 47 | operands can be performed with the {}\code{coerce} builtin function; thus, |
| 48 | {}\code{3+4.5} is equivalent to calling {}\code{operator.add(*coerce(3, |
| 49 | 4.5))} and results in {}\code{operator.add(3.0, 4.5)}. Without coercion, |
| 50 | all arguments of even compatible types would have to be normalized to the |
| 51 | same value by the programmer, e.g., {}\code{float(3)+4.5} rather than just |
| 52 | {}\code{3+4.5}. |
| 53 | |
| 54 | \index{complex number} |
| 55 | \item[complex number] |
| 56 | |
| 57 | An extension of the familiar real number system in which all numbers are |
| 58 | expressed as a sum of a real part and an imaginary part. Imaginary numbers |
| 59 | are real multiples of the imaginary unit (the square root of {}\code{-1}), |
| 60 | often written {}\code{i} in mathematics or {}\code{j} in engineering. |
| 61 | Python has builtin support for complex numbers, which are written with this |
| 62 | latter notation; the imaginary part is written with a {}\code{j} suffix, |
| 63 | e.g., {}\code{3+1j}. To get access to complex equivalents of the |
| 64 | {}\module{math} module, use {}\module{cmath}. Use of complex numbers is a |
Andrew M. Kuchling | aeaec8d | 2004-03-29 01:19:54 +0000 | [diff] [blame^] | 65 | fairly advanced mathematical feature. If you're not aware of a need for them, |
Raymond Hettinger | f13c024 | 2004-03-28 22:44:09 +0000 | [diff] [blame] | 66 | it's almost certain you can safely ignore them. |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 67 | |
| 68 | \index{descriptor} |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 69 | \item[descriptor] |
| 70 | Any \emph{new-style} object that defines the methods |
| 71 | {}\method{__get__()}, \method{__set__()}, or \method{__delete__()}. |
| 72 | When a class attribute is a descriptor, its special binding behavior |
| 73 | is triggered upon attribute lookup. Normally, writing \var{a.b} looks |
| 74 | up the object \var{b} in the class dictionary for \var{a}, but if |
| 75 | {}\var{b} is a descriptor, the defined method gets called. |
| 76 | Understanding descriptors is a key to a deep understanding of Python |
| 77 | because they are the basis for many features including functions, |
| 78 | methods, properties, class methods, static methods, and reference to |
| 79 | super classes. |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 80 | |
| 81 | \index{dictionary} |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 82 | \item[dictionary] |
| 83 | An associative array, where arbitrary keys are mapped to values. The |
| 84 | use of \class{dict} much resembles that for \class{list}, but the keys |
| 85 | can be any object with a \method{__hash__()} function, not just |
| 86 | integers starting from zero. Called a hash in Perl. |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 87 | |
| 88 | \index{EAFP} |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 89 | \item[EAFP] |
| 90 | Easier to ask for forgiveness than permission. This common Python |
| 91 | coding style assumes the existence of valid keys or attributes and |
| 92 | catches exceptions if the assumption proves false. This clean and |
| 93 | fast style is characterized by the presence of many \keyword{try} and |
| 94 | {}\keyword{except} statements. The technique contrasts with the |
| 95 | {}\emph{LBYL} style that is common in many other languages such as C. |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 96 | |
| 97 | \index{__future__} |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 98 | \item[__future__] |
| 99 | A pseudo module which programmers can use to enable new language |
| 100 | features which are not compatible with the current interpreter. For |
Raymond Hettinger | 43b5e40 | 2003-09-27 20:19:02 +0000 | [diff] [blame] | 101 | example, the expression \code{11/4} currently evaluates to \code{2}. |
| 102 | If the module in which it is executed had enabled \emph{true division} |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 103 | by executing: |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 104 | |
| 105 | \begin{verbatim} |
| 106 | from __future__ import division |
| 107 | \end{verbatim} |
| 108 | |
Fred Drake | 984920b | 2003-09-28 19:03:36 +0000 | [diff] [blame] | 109 | the expression \code{11/4} would evaluate to \code{2.75}. By actually |
| 110 | importing the \ulink{\module{__future__}}{../lib/module-future.html} |
| 111 | module and evaluating its variables, you can see when a new feature |
| 112 | was first added to the language and when it will become the default: |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 113 | |
| 114 | \begin{verbatim} |
| 115 | >>> import __future__ |
| 116 | >>> __future__.division |
| 117 | _Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192) |
| 118 | \end{verbatim} |
| 119 | |
| 120 | \index{generator} |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 121 | \item[generator] |
Skip Montanaro | dbb4078 | 2004-03-27 18:23:11 +0000 | [diff] [blame] | 122 | A function that returns an iterator. It looks like a normal function except |
| 123 | that values are returned to the caller using a \keyword{yield} statement |
| 124 | instead of a {}\keyword{return} statement. Generator functions often |
| 125 | contain one or more {}\keyword{for} or \keyword{while} loops that |
| 126 | \keyword{yield} elements back to the caller. The function execution is |
| 127 | stopped at the {}\keyword{yield} keyword (returning the result) and is |
| 128 | resumed there when the next element is requested by calling the |
| 129 | \method{next()} method of the returned iterator. |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 130 | |
| 131 | \index{GIL} |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 132 | \item[GIL] |
| 133 | See \emph{global interpreter lock}. |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 134 | |
| 135 | \index{global interpreter lock} |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 136 | \item[global interpreter lock] |
| 137 | The lock used by Python threads to assure that only one thread can be |
| 138 | run at a time. This simplifies Python by assuring that no two |
| 139 | processes can access the same memory at the same time. Locking the |
| 140 | entire interpreter makes it easier for the interpreter to be |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 141 | multi-threaded, at the expense of some parallelism on multi-processor |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 142 | machines. Efforts have been made in the past to create a |
Raymond Hettinger | 43b5e40 | 2003-09-27 20:19:02 +0000 | [diff] [blame] | 143 | ``free-threaded'' interpreter (one which locks shared data at a much |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 144 | finer granularity), but performance suffered in the common |
| 145 | single-processor case. |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 146 | |
| 147 | \index{IDLE} |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 148 | \item[IDLE] |
| 149 | An Integrated Development Environment for Python. IDLE is a |
Raymond Hettinger | 5a25aa6 | 2003-09-27 05:42:14 +0000 | [diff] [blame] | 150 | basic editor and interpreter environment that ships with the standard |
| 151 | distribution of Python. Good for beginners, it also serves as clear |
| 152 | example code for those wanting to implement a moderately |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 153 | sophisticated, multi-platform GUI application. |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 154 | |
| 155 | \index{immutable} |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 156 | \item[immutable] |
Skip Montanaro | dbb4078 | 2004-03-27 18:23:11 +0000 | [diff] [blame] | 157 | An object with fixed value. Immutable objects are numbers, strings or |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 158 | tuples (and more). Such an object cannot be altered. A new object |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 159 | has to be created if a different value has to be stored. They play an |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 160 | important role in places where a constant hash value is needed. For |
| 161 | example as a key in a dictionary. |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 162 | |
| 163 | \index{integer division} |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 164 | \item[integer division] |
| 165 | Mathematical division discarding any remainder. For example, the |
Raymond Hettinger | 43b5e40 | 2003-09-27 20:19:02 +0000 | [diff] [blame] | 166 | expression \code{11/4} currently evaluates to \code{2} in contrast |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 167 | to the \code{2.75} returned by float division. Also called |
| 168 | {}\emph{floor division}. When dividing two integers the outcome will |
| 169 | always be another integer (having the floor function applied to it). |
| 170 | However, if one of the operands is another numeric type (such as a |
| 171 | {}\class{float}), the result will be coerced (see \emph{coercion}) to |
Skip Montanaro | dbb4078 | 2004-03-27 18:23:11 +0000 | [diff] [blame] | 172 | a common type. For example, an integer divided by a float will result |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 173 | in a float value, possibly with a decimal fraction. Integer division |
| 174 | can be forced by using the \code{//} operator instead of the \code{/} |
| 175 | operator. See also \emph{__future__}. |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 176 | |
| 177 | \index{interactive} |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 178 | \item[interactive] |
| 179 | Python has an interactive interpreter which means that you can try out |
| 180 | things and directly see its result. Just launch \code{python} with no |
| 181 | arguments (possibly by selecting it from your computer's main menu). |
| 182 | It is a very powerful way to test out new ideas or inspect modules and |
| 183 | packages (remember \code{help(x)}). |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 184 | |
| 185 | \index{interpreted} |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 186 | \item[interpreted] |
Skip Montanaro | dbb4078 | 2004-03-27 18:23:11 +0000 | [diff] [blame] | 187 | Python is an interpreted language, as opposed to a compiled one. This means |
| 188 | that the source files can be run directly without first creating an |
| 189 | executable which is then run. Interpreted languages typically have a |
| 190 | shorter development/debug cycle than compiled ones, though their programs |
| 191 | generally also run more slowly. See also {}\emph{interactive}. |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 192 | |
| 193 | \index{iterable} |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 194 | \item[iterable] |
| 195 | A container object capable of returning its members one at a time. |
Raymond Hettinger | 43b5e40 | 2003-09-27 20:19:02 +0000 | [diff] [blame] | 196 | Examples of iterables include all sequence types (such as \class{list}, |
Raymond Hettinger | 5a25aa6 | 2003-09-27 05:42:14 +0000 | [diff] [blame] | 197 | {}\class{str}, and \class{tuple}) and some non-sequence types like |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 198 | {}\class{dict} and \class{file} and objects of any classes you define |
| 199 | with an \method{__iter__()} or \method{__getitem__()} method. Iterables |
| 200 | can be used in a \keyword{for} loop and in many other places where a |
| 201 | sequence is needed (\function{zip()}, \function{map()}, ...). When an |
| 202 | iterable object is passed as an argument to the builtin function |
| 203 | {}\function{iter()}, it returns an iterator for the object. This |
| 204 | iterator is good for one pass over the set of values. When using |
| 205 | iterables, it is usually not necessary to call \function{iter()} or |
Raymond Hettinger | 43b5e40 | 2003-09-27 20:19:02 +0000 | [diff] [blame] | 206 | deal with iterator objects yourself. The \code{for} statement does |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 207 | that automatically for you, creating a temporary unnamed variable to |
| 208 | hold the iterator for the duration of the loop. See also |
| 209 | {}\emph{iterator}, \emph{sequence}, and \emph{generator}. |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 210 | |
| 211 | \index{iterator} |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 212 | \item[iterator] |
| 213 | An object representing a stream of data. Repeated calls to the |
| 214 | iterator's \method{next()} method return successive items in the |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 215 | stream. When no more data is available a \exception{StopIteration} |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 216 | exception is raised instead. At this point, the iterator object is |
| 217 | exhausted and any further calls to its \method{next()} method just |
| 218 | raise \exception{StopIteration} again. Iterators are required to have |
| 219 | an \method{__iter__()} method that returns the iterator object |
| 220 | itself so every iterator is also iterable and may be used in most |
| 221 | places where other iterables are accepted. One notable exception is |
| 222 | code that attempts multiple iteration passes. A container object |
| 223 | (such as a \class{list}) produces a fresh new iterator each time you |
| 224 | pass it to the \function{iter()} function or use it in a |
| 225 | {}\keyword{for} loop. Attempting this with an iterator will just |
| 226 | return the same exhausted iterator object from the second iteration |
| 227 | pass, making it appear like an empty container. |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 228 | |
| 229 | \index{list comprehension} |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 230 | \item[list comprehension] |
| 231 | A compact way to process all or a subset of elements in a sequence and |
| 232 | return a list with the results. \code{result = ["0x\%02x" |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 233 | \% x for x in range(256) if x \% 2 == 0]} generates a list of strings |
| 234 | containing hex numbers (0x..) that are even and in the range from 0 to 255. |
| 235 | The \keyword{if} clause is optional. If omitted, all elements in |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 236 | {}\code{range(256)} are processed in that case. |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 237 | |
| 238 | \index{mapping} |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 239 | \item[mapping] |
| 240 | A container object (such as \class{dict}) that supports arbitrary key |
| 241 | lookups using the special method \method{__getitem__()}. |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 242 | |
| 243 | \index{metaclass} |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 244 | \item[metaclass] |
| 245 | The class of a class. Class definitions create a class name, a class |
| 246 | dictionary, and a list of base classes. The metaclass is responsible |
| 247 | for taking those three arguments and creating the class. Most object |
| 248 | oriented programming languages provide a default implementation. What |
| 249 | makes Python special is that it is possible to create custom |
| 250 | metaclasses. Most users never need this tool, but when the need |
| 251 | arises, metaclasses can provide powerful, elegant solutions. They |
| 252 | have been used for logging attribute access, adding thread-safety, |
| 253 | tracking object creation, implementing singletons, and many other |
| 254 | tasks. |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 255 | |
| 256 | \index{LBYL} |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 257 | \item[LBYL] |
| 258 | Look before you leap. This coding style explicitly tests for |
| 259 | pre-conditions before making calls or lookups. This style contrasts |
| 260 | with the \emph{EAFP} approach and is characterized the presence of |
| 261 | many \keyword{if} statements. |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 262 | |
| 263 | \index{mutable} |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 264 | \item[mutable] |
| 265 | Mutable objects can change their value but keep their \function{id()}. |
| 266 | See also \emph{immutable}. |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 267 | |
| 268 | \index{namespace} |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 269 | \item[namespace] |
| 270 | The place where a variable is stored. Namespaces are implemented as |
| 271 | dictionary. There is the local, global and builtins namespace and the |
| 272 | nested namespaces in objects (in methods). Namespaces support |
| 273 | modularity by preventing naming conflicts. For instance, the |
| 274 | functions \function{__builtin__.open()} and \function{os.open()} are |
| 275 | distinguished by their namespaces. Namespaces also aid readability |
| 276 | and maintainability by making it clear which modules implement a |
| 277 | function. For instance, writing \function{random.seed()} or |
| 278 | {}\function{itertools.izip()} makes it clear that those functions are |
Fred Drake | 984920b | 2003-09-28 19:03:36 +0000 | [diff] [blame] | 279 | implemented by the \ulink{\module{random}}{../lib/module-random.html} |
| 280 | and \ulink{\module{itertools}}{../lib/module-itertools.html} modules |
| 281 | respectively. |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 282 | |
| 283 | \index{nested scope} |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 284 | \item[nested scope] |
| 285 | The ability to refer to a variable in an enclosing definition. For |
| 286 | instance, a function defined inside another function can refer to |
| 287 | variables in the outer function. Note that nested scopes work only |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 288 | for reference and not for assignment which will always write to the |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 289 | innermost scope. In contrast, local variables both read and write in |
| 290 | the innermost scope. Likewise, global variables read and write to the |
| 291 | global namespace. |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 292 | |
| 293 | \index{new-style class} |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 294 | \item[new-style class] |
| 295 | Any class that inherits from \class{object}. This includes all |
| 296 | built-in types like \class{list} and \class{dict}. Only new-style |
| 297 | classes can use Python's newer, versatile features like |
Raymond Hettinger | 43b5e40 | 2003-09-27 20:19:02 +0000 | [diff] [blame] | 298 | {}\method{__slots__}, descriptors, properties, |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 299 | \method{__getattribute__()}, class methods, and static methods. |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 300 | |
| 301 | \index{Python3000} |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 302 | \item[Python3000] |
| 303 | A mythical python release, allowed not to be backward compatible, with |
| 304 | telepathic interface. |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 305 | |
Raymond Hettinger | 43b5e40 | 2003-09-27 20:19:02 +0000 | [diff] [blame] | 306 | \index{__slots__} |
| 307 | \item[__slots__] |
| 308 | A declaration inside a \emph{new-style class} that saves memory by |
| 309 | pre-declaring space for instance attributes and eliminating instance |
| 310 | dictionaries. Though popular, the technique is somewhat tricky to get |
| 311 | right and is best reserved for rare cases where there are large |
| 312 | numbers of instances in a memory critical application. |
| 313 | |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 314 | \index{sequence} |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 315 | \item[sequence] |
| 316 | An \emph{iterable} which supports efficient element access using |
| 317 | integer indices via the \method{__getitem__()} and |
| 318 | {}\method{__len__()} special methods. Some built-in sequence types |
| 319 | are \class{list}, \class{str}, \class{tuple}, and \class{unicode}. |
| 320 | Note that \class{dict} also supports \method{__getitem__()} and |
| 321 | {}\method{__len__()}, but is considered a mapping rather than a |
| 322 | sequence because the lookups use arbitrary \emph{immutable} keys |
| 323 | rather than integers. |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 324 | |
| 325 | \index{Zen of Python} |
Fred Drake | d4a1419 | 2003-09-27 18:59:43 +0000 | [diff] [blame] | 326 | \item[Zen of Python] |
| 327 | Listing of Python design principles and philosophies that are helpful |
| 328 | in understanding and using the language. The listing can be found by |
Raymond Hettinger | 43b5e40 | 2003-09-27 20:19:02 +0000 | [diff] [blame] | 329 | typing ``\code{import this}'' at the interactive prompt. |
Skip Montanaro | 757dedc | 2003-09-24 16:51:23 +0000 | [diff] [blame] | 330 | |
| 331 | \end{description} |