| 1 | <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"> |
| 2 | <html> |
| 3 | <head> |
| 4 | <link rel="STYLESHEET" href="tut.css" type='text/css' /> |
| 5 | <link rel="SHORTCUT ICON" href="../icons/pyfav.png" type="image/png" /> |
| 6 | <link rel='start' href='../index.html' title='Python Documentation Index' /> |
| 7 | <link rel="first" href="tut.html" title='Python Tutorial' /> |
| 8 | <link rel='contents' href='node2.html' title="Contents" /> |
| 9 | <link rel='index' href='node19.html' title='Index' /> |
| 10 | <link rel='last' href='about.html' title='About this document...' /> |
| 11 | <link rel='help' href='about.html' title='About this document...' /> |
| 12 | <link rel="next" href="node19.html" /> |
| 13 | <link rel="prev" href="node17.html" /> |
| 14 | <link rel="parent" href="tut.html" /> |
| 15 | <link rel="next" href="node19.html" /> |
| 16 | <meta name='aesop' content='information' /> |
| 17 | <title>D. Glossary</title> |
| 18 | </head> |
| 19 | <body> |
| 20 | <DIV CLASS="navigation"> |
| 21 | <div id='top-navigation-panel' xml:id='top-navigation-panel'> |
| 22 | <table align="center" width="100%" cellpadding="0" cellspacing="2"> |
| 23 | <tr> |
| 24 | <td class='online-navigation'><a rel="prev" title="C. History and License" |
| 25 | href="node17.html"><img src='../icons/previous.png' |
| 26 | border='0' height='32' alt='Previous Page' width='32' /></A></td> |
| 27 | <td class='online-navigation'><a rel="parent" title="Python Tutorial" |
| 28 | href="tut.html"><img src='../icons/up.png' |
| 29 | border='0' height='32' alt='Up One Level' width='32' /></A></td> |
| 30 | <td class='online-navigation'><a rel="next" title="Index" |
| 31 | href="node19.html"><img src='../icons/next.png' |
| 32 | border='0' height='32' alt='Next Page' width='32' /></A></td> |
| 33 | <td align="center" width="100%">Python Tutorial</td> |
| 34 | <td class='online-navigation'><a rel="contents" title="Table of Contents" |
| 35 | href="node2.html"><img src='../icons/contents.png' |
| 36 | border='0' height='32' alt='Contents' width='32' /></A></td> |
| 37 | <td class='online-navigation'><img src='../icons/blank.png' |
| 38 | border='0' height='32' alt='' width='32' /></td> |
| 39 | <td class='online-navigation'><a rel="index" title="Index" |
| 40 | href="node19.html"><img src='../icons/index.png' |
| 41 | border='0' height='32' alt='Index' width='32' /></A></td> |
| 42 | </tr></table> |
| 43 | <div class='online-navigation'> |
| 44 | <b class="navlabel">Previous:</b> |
| 45 | <a class="sectref" rel="prev" href="node17.html">C. History and License</A> |
| 46 | <b class="navlabel">Up:</b> |
| 47 | <a class="sectref" rel="parent" href="tut.html">Python Tutorial</A> |
| 48 | <b class="navlabel">Next:</b> |
| 49 | <a class="sectref" rel="next" href="node19.html">Index</A> |
| 50 | </div> |
| 51 | <hr /></div> |
| 52 | </DIV> |
| 53 | <!--End of Navigation Panel--> |
| 54 | |
| 55 | <H1><A NAME="SECTION0018000000000000000000"></A><A NAME="glossary"></A> |
| 56 | <BR> |
| 57 | D. Glossary |
| 58 | </H1> |
| 59 | |
| 60 | <P> |
| 61 | <DL> |
| 62 | <DD><a id='l2h-37' xml:id='l2h-37'></a> |
| 63 | </DD> |
| 64 | <DT><STRONG><code>><code>></code>></code></STRONG></DT> |
| 65 | <DD>The typical Python prompt of the interactive shell. Often seen for |
| 66 | code examples that can be tried right away in the interpreter. |
| 67 | <P> |
| 68 | <a id='l2h-38' xml:id='l2h-38'></a> |
| 69 | </DD> |
| 70 | <DT><STRONG><code>.<code>.</code>.</code></STRONG></DT> |
| 71 | <DD>The typical Python prompt of the interactive shell when entering code |
| 72 | for an indented code block. |
| 73 | |
| 74 | <P> |
| 75 | <a id='l2h-39' xml:id='l2h-39'></a> |
| 76 | </DD> |
| 77 | <DT><STRONG>BDFL</STRONG></DT> |
| 78 | <DD>Benevolent Dictator For Life, a.k.a. <a class="ulink" href="http://www.python.org/~guido/" |
| 79 | >Guido van |
| 80 | Rossum</a>, Python's creator. |
| 81 | |
| 82 | <P> |
| 83 | <a id='l2h-40' xml:id='l2h-40'></a> |
| 84 | </DD> |
| 85 | <DT><STRONG>byte code</STRONG></DT> |
| 86 | <DD>The internal representation of a Python program in the interpreter. |
| 87 | The byte code is also cached in <code>.pyc</code> and <code>.pyo</code> |
| 88 | files so that executing the same file is faster the second time |
| 89 | (recompilation from source to byte code can be avoided). This |
| 90 | ``intermediate language'' is said to run on a ``virtual |
| 91 | machine'' that calls the subroutines corresponding to each bytecode. |
| 92 | |
| 93 | <P> |
| 94 | <a id='l2h-41' xml:id='l2h-41'></a> |
| 95 | </DD> |
| 96 | <DT><STRONG>classic class</STRONG></DT> |
| 97 | <DD>Any class which does not inherit from <tt class="class">object</tt>. See |
| 98 | <em>new-style class</em>. |
| 99 | |
| 100 | <P> |
| 101 | <a id='l2h-42' xml:id='l2h-42'></a> |
| 102 | </DD> |
| 103 | <DT><STRONG>coercion</STRONG></DT> |
| 104 | <DD>The implicit conversion of an instance of one type to another during an |
| 105 | operation which involves two arguments of the same type. For example, |
| 106 | <code>int(3.15)</code> converts the floating point number to the integer |
| 107 | <code>3</code>, but in <code>3+4.5</code>, each argument is of a different type (one |
| 108 | int, one float), and both must be converted to the same type before they can |
| 109 | be added or it will raise a <code>TypeError</code>. Coercion between two |
| 110 | operands can be performed with the <code>coerce</code> builtin function; thus, |
| 111 | <code>3+4.5</code> is equivalent to calling <code>operator.add(*coerce(3, |
| 112 | 4.5))</code> and results in <code>operator.add(3.0, 4.5)</code>. Without coercion, |
| 113 | all arguments of even compatible types would have to be normalized to the |
| 114 | same value by the programmer, e.g., <code>float(3)+4.5</code> rather than just |
| 115 | <code>3+4.5</code>. |
| 116 | |
| 117 | <P> |
| 118 | <a id='l2h-43' xml:id='l2h-43'></a> |
| 119 | </DD> |
| 120 | <DT><STRONG>complex number</STRONG></DT> |
| 121 | <DD>An extension of the familiar real number system in which all numbers are |
| 122 | expressed as a sum of a real part and an imaginary part. Imaginary numbers |
| 123 | are real multiples of the imaginary unit (the square root of <code>-1</code>), |
| 124 | often written <code>i</code> in mathematics or <code>j</code> in engineering. |
| 125 | Python has builtin support for complex numbers, which are written with this |
| 126 | latter notation; the imaginary part is written with a <code>j</code> suffix, |
| 127 | e.g., <code>3+1j</code>. To get access to complex equivalents of the |
| 128 | <tt class="module">math</tt> module, use <tt class="module">cmath</tt>. Use of complex numbers is a |
| 129 | fairly advanced mathematical feature. If you're not aware of a need for them, |
| 130 | it's almost certain you can safely ignore them. |
| 131 | |
| 132 | <P> |
| 133 | <a id='l2h-44' xml:id='l2h-44'></a> |
| 134 | </DD> |
| 135 | <DT><STRONG>descriptor</STRONG></DT> |
| 136 | <DD>Any <em>new-style</em> object that defines the methods |
| 137 | <tt class="method">__get__()</tt>, <tt class="method">__set__()</tt>, or <tt class="method">__delete__()</tt>. |
| 138 | When a class attribute is a descriptor, its special binding behavior |
| 139 | is triggered upon attribute lookup. Normally, writing <var>a.b</var> looks |
| 140 | up the object <var>b</var> in the class dictionary for <var>a</var>, but if |
| 141 | <var>b</var> is a descriptor, the defined method gets called. |
| 142 | Understanding descriptors is a key to a deep understanding of Python |
| 143 | because they are the basis for many features including functions, |
| 144 | methods, properties, class methods, static methods, and reference to |
| 145 | super classes. |
| 146 | |
| 147 | <P> |
| 148 | <a id='l2h-45' xml:id='l2h-45'></a> |
| 149 | </DD> |
| 150 | <DT><STRONG>dictionary</STRONG></DT> |
| 151 | <DD>An associative array, where arbitrary keys are mapped to values. The |
| 152 | use of <tt class="class">dict</tt> much resembles that for <tt class="class">list</tt>, but the keys |
| 153 | can be any object with a <tt class="method">__hash__()</tt> function, not just |
| 154 | integers starting from zero. Called a hash in Perl. |
| 155 | |
| 156 | <P> |
| 157 | <a id='l2h-46' xml:id='l2h-46'></a> |
| 158 | </DD> |
| 159 | <DT><STRONG>duck-typing</STRONG></DT> |
| 160 | <DD>Pythonic programming style that determines an object's type by inspection |
| 161 | of its method or attribute signature rather than by explicit relationship |
| 162 | to some type object ("If it looks like a duck and quacks like a duck, it |
| 163 | must be a duck.") By emphasizing interfaces rather than specific types, |
| 164 | well-designed code improves its flexibility by allowing polymorphic |
| 165 | substitution. Duck-typing avoids tests using <tt class="function">type()</tt> or |
| 166 | <tt class="function">isinstance()</tt>. Instead, it typically employs |
| 167 | <tt class="function">hasattr()</tt> tests or <em>EAFP</em> programming. |
| 168 | |
| 169 | <P> |
| 170 | <a id='l2h-47' xml:id='l2h-47'></a> |
| 171 | </DD> |
| 172 | <DT><STRONG>EAFP</STRONG></DT> |
| 173 | <DD>Easier to ask for forgiveness than permission. This common Python |
| 174 | coding style assumes the existence of valid keys or attributes and |
| 175 | catches exceptions if the assumption proves false. This clean and |
| 176 | fast style is characterized by the presence of many <tt class="keyword">try</tt> and |
| 177 | <tt class="keyword">except</tt> statements. The technique contrasts with the |
| 178 | <em>LBYL</em> style that is common in many other languages such as C. |
| 179 | |
| 180 | <P> |
| 181 | <a id='l2h-48' xml:id='l2h-48'></a> |
| 182 | </DD> |
| 183 | <DT><STRONG>__future__</STRONG></DT> |
| 184 | <DD>A pseudo module which programmers can use to enable new language |
| 185 | features which are not compatible with the current interpreter. For |
| 186 | example, the expression <code>11/4</code> currently evaluates to <code>2</code>. |
| 187 | If the module in which it is executed had enabled <em>true division</em> |
| 188 | by executing: |
| 189 | |
| 190 | <P> |
| 191 | <div class="verbatim"><pre> |
| 192 | from __future__ import division |
| 193 | </pre></div> |
| 194 | |
| 195 | <P> |
| 196 | the expression <code>11/4</code> would evaluate to <code>2.75</code>. By |
| 197 | importing the <a class="ulink" href="../lib/module-future.html" |
| 198 | ><tt class="module">__future__</tt></a> |
| 199 | module and evaluating its variables, you can see when a new feature |
| 200 | was first added to the language and when it will become the default: |
| 201 | |
| 202 | <P> |
| 203 | <div class="verbatim"><pre> |
| 204 | >>> import __future__ |
| 205 | >>> __future__.division |
| 206 | _Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192) |
| 207 | </pre></div> |
| 208 | |
| 209 | <P> |
| 210 | <a id='l2h-49' xml:id='l2h-49'></a> |
| 211 | </DD> |
| 212 | <DT><STRONG>generator</STRONG></DT> |
| 213 | <DD>A function that returns an iterator. It looks like a normal function except |
| 214 | that values are returned to the caller using a <tt class="keyword">yield</tt> statement |
| 215 | instead of a <tt class="keyword">return</tt> statement. Generator functions often |
| 216 | contain one or more <tt class="keyword">for</tt> or <tt class="keyword">while</tt> loops that |
| 217 | <tt class="keyword">yield</tt> elements back to the caller. The function execution is |
| 218 | stopped at the <tt class="keyword">yield</tt> keyword (returning the result) and is |
| 219 | resumed there when the next element is requested by calling the |
| 220 | <tt class="method">next()</tt> method of the returned iterator. |
| 221 | |
| 222 | <P> |
| 223 | <a id='l2h-50' xml:id='l2h-50'></a> |
| 224 | </DD> |
| 225 | <DT><STRONG>generator expression</STRONG></DT> |
| 226 | <DD>An expression that returns a generator. It looks like a normal expression |
| 227 | followed by a <tt class="keyword">for</tt> expression defining a loop variable, range, and |
| 228 | an optional <tt class="keyword">if</tt> expression. The combined expression generates |
| 229 | values for an enclosing function: |
| 230 | |
| 231 | <P> |
| 232 | <div class="verbatim"><pre> |
| 233 | >>> sum(i*i for i in range(10)) # sum of squares 0, 1, 4, ... 81 |
| 234 | 285 |
| 235 | </pre></div> |
| 236 | |
| 237 | <P> |
| 238 | <a id='l2h-51' xml:id='l2h-51'></a> |
| 239 | </DD> |
| 240 | <DT><STRONG>GIL</STRONG></DT> |
| 241 | <DD>See <em>global interpreter lock</em>. |
| 242 | |
| 243 | <P> |
| 244 | <a id='l2h-52' xml:id='l2h-52'></a> |
| 245 | </DD> |
| 246 | <DT><STRONG>global interpreter lock</STRONG></DT> |
| 247 | <DD>The lock used by Python threads to assure that only one thread can be |
| 248 | run at a time. This simplifies Python by assuring that no two |
| 249 | processes can access the same memory at the same time. Locking the |
| 250 | entire interpreter makes it easier for the interpreter to be |
| 251 | multi-threaded, at the expense of some parallelism on multi-processor |
| 252 | machines. Efforts have been made in the past to create a |
| 253 | ``free-threaded'' interpreter (one which locks shared data at a much |
| 254 | finer granularity), but performance suffered in the common |
| 255 | single-processor case. |
| 256 | |
| 257 | <P> |
| 258 | <a id='l2h-53' xml:id='l2h-53'></a> |
| 259 | </DD> |
| 260 | <DT><STRONG>IDLE</STRONG></DT> |
| 261 | <DD>An Integrated Development Environment for Python. IDLE is a |
| 262 | basic editor and interpreter environment that ships with the standard |
| 263 | distribution of Python. Good for beginners, it also serves as clear |
| 264 | example code for those wanting to implement a moderately |
| 265 | sophisticated, multi-platform GUI application. |
| 266 | |
| 267 | <P> |
| 268 | <a id='l2h-54' xml:id='l2h-54'></a> |
| 269 | </DD> |
| 270 | <DT><STRONG>immutable</STRONG></DT> |
| 271 | <DD>An object with fixed value. Immutable objects are numbers, strings or |
| 272 | tuples (and more). Such an object cannot be altered. A new object |
| 273 | has to be created if a different value has to be stored. They play an |
| 274 | important role in places where a constant hash value is needed, for |
| 275 | example as a key in a dictionary. |
| 276 | |
| 277 | <P> |
| 278 | <a id='l2h-55' xml:id='l2h-55'></a> |
| 279 | </DD> |
| 280 | <DT><STRONG>integer division</STRONG></DT> |
| 281 | <DD>Mathematical division discarding any remainder. For example, the |
| 282 | expression <code>11/4</code> currently evaluates to <code>2</code> in contrast |
| 283 | to the <code>2.75</code> returned by float division. Also called |
| 284 | <em>floor division</em>. When dividing two integers the outcome will |
| 285 | always be another integer (having the floor function applied to it). |
| 286 | However, if one of the operands is another numeric type (such as a |
| 287 | <tt class="class">float</tt>), the result will be coerced (see <em>coercion</em>) to |
| 288 | a common type. For example, an integer divided by a float will result |
| 289 | in a float value, possibly with a decimal fraction. Integer division |
| 290 | can be forced by using the <code>//</code> operator instead of the <code>/</code> |
| 291 | operator. See also <em>__future__</em>. |
| 292 | |
| 293 | <P> |
| 294 | <a id='l2h-56' xml:id='l2h-56'></a> |
| 295 | </DD> |
| 296 | <DT><STRONG>interactive</STRONG></DT> |
| 297 | <DD>Python has an interactive interpreter which means that you can try out |
| 298 | things and immediately see their results. Just launch <code>python</code> with no |
| 299 | arguments (possibly by selecting it from your computer's main menu). |
| 300 | It is a very powerful way to test out new ideas or inspect modules and |
| 301 | packages (remember <code>help(x)</code>). |
| 302 | |
| 303 | <P> |
| 304 | <a id='l2h-57' xml:id='l2h-57'></a> |
| 305 | </DD> |
| 306 | <DT><STRONG>interpreted</STRONG></DT> |
| 307 | <DD>Python is an interpreted language, as opposed to a compiled one. This means |
| 308 | that the source files can be run directly without first creating an |
| 309 | executable which is then run. Interpreted languages typically have a |
| 310 | shorter development/debug cycle than compiled ones, though their programs |
| 311 | generally also run more slowly. See also <em>interactive</em>. |
| 312 | |
| 313 | <P> |
| 314 | <a id='l2h-58' xml:id='l2h-58'></a> |
| 315 | </DD> |
| 316 | <DT><STRONG>iterable</STRONG></DT> |
| 317 | <DD>A container object capable of returning its members one at a time. |
| 318 | Examples of iterables include all sequence types (such as <tt class="class">list</tt>, |
| 319 | <tt class="class">str</tt>, and <tt class="class">tuple</tt>) and some non-sequence types like |
| 320 | <tt class="class">dict</tt> and <tt class="class">file</tt> and objects of any classes you define |
| 321 | with an <tt class="method">__iter__()</tt> or <tt class="method">__getitem__()</tt> method. Iterables |
| 322 | can be used in a <tt class="keyword">for</tt> loop and in many other places where a |
| 323 | sequence is needed (<tt class="function">zip()</tt>, <tt class="function">map()</tt>, ...). When an |
| 324 | iterable object is passed as an argument to the builtin function |
| 325 | <tt class="function">iter()</tt>, it returns an iterator for the object. This |
| 326 | iterator is good for one pass over the set of values. When using |
| 327 | iterables, it is usually not necessary to call <tt class="function">iter()</tt> or |
| 328 | deal with iterator objects yourself. The <code>for</code> statement does |
| 329 | that automatically for you, creating a temporary unnamed variable to |
| 330 | hold the iterator for the duration of the loop. See also |
| 331 | <em>iterator</em>, <em>sequence</em>, and <em>generator</em>. |
| 332 | |
| 333 | <P> |
| 334 | <a id='l2h-59' xml:id='l2h-59'></a> |
| 335 | </DD> |
| 336 | <DT><STRONG>iterator</STRONG></DT> |
| 337 | <DD>An object representing a stream of data. Repeated calls to the |
| 338 | iterator's <tt class="method">next()</tt> method return successive items in the |
| 339 | stream. When no more data is available a <tt class="exception">StopIteration</tt> |
| 340 | exception is raised instead. At this point, the iterator object is |
| 341 | exhausted and any further calls to its <tt class="method">next()</tt> method just |
| 342 | raise <tt class="exception">StopIteration</tt> again. Iterators are required to have |
| 343 | an <tt class="method">__iter__()</tt> method that returns the iterator object |
| 344 | itself so every iterator is also iterable and may be used in most |
| 345 | places where other iterables are accepted. One notable exception is |
| 346 | code that attempts multiple iteration passes. A container object |
| 347 | (such as a <tt class="class">list</tt>) produces a fresh new iterator each time you |
| 348 | pass it to the <tt class="function">iter()</tt> function or use it in a |
| 349 | <tt class="keyword">for</tt> loop. Attempting this with an iterator will just |
| 350 | return the same exhausted iterator object used in the previous iteration |
| 351 | pass, making it appear like an empty container. |
| 352 | |
| 353 | <P> |
| 354 | <a id='l2h-60' xml:id='l2h-60'></a> |
| 355 | </DD> |
| 356 | <DT><STRONG>LBYL</STRONG></DT> |
| 357 | <DD>Look before you leap. This coding style explicitly tests for |
| 358 | pre-conditions before making calls or lookups. This style contrasts |
| 359 | with the <em>EAFP</em> approach and is characterized by the presence of |
| 360 | many <tt class="keyword">if</tt> statements. |
| 361 | |
| 362 | <P> |
| 363 | <a id='l2h-61' xml:id='l2h-61'></a> |
| 364 | </DD> |
| 365 | <DT><STRONG>list comprehension</STRONG></DT> |
| 366 | <DD>A compact way to process all or a subset of elements in a sequence and |
| 367 | return a list with the results. <code>result = ["0x%02x" |
| 368 | % x for x in range(256) if x % 2 == 0]</code> generates a list of strings |
| 369 | containing hex numbers (0x..) that are even and in the range from 0 to 255. |
| 370 | The <tt class="keyword">if</tt> clause is optional. If omitted, all elements in |
| 371 | <code>range(256)</code> are processed. |
| 372 | |
| 373 | <P> |
| 374 | <a id='l2h-62' xml:id='l2h-62'></a> |
| 375 | </DD> |
| 376 | <DT><STRONG>mapping</STRONG></DT> |
| 377 | <DD>A container object (such as <tt class="class">dict</tt>) that supports arbitrary key |
| 378 | lookups using the special method <tt class="method">__getitem__()</tt>. |
| 379 | |
| 380 | <P> |
| 381 | <a id='l2h-63' xml:id='l2h-63'></a> |
| 382 | </DD> |
| 383 | <DT><STRONG>metaclass</STRONG></DT> |
| 384 | <DD>The class of a class. Class definitions create a class name, a class |
| 385 | dictionary, and a list of base classes. The metaclass is responsible |
| 386 | for taking those three arguments and creating the class. Most object |
| 387 | oriented programming languages provide a default implementation. What |
| 388 | makes Python special is that it is possible to create custom |
| 389 | metaclasses. Most users never need this tool, but when the need |
| 390 | arises, metaclasses can provide powerful, elegant solutions. They |
| 391 | have been used for logging attribute access, adding thread-safety, |
| 392 | tracking object creation, implementing singletons, and many other |
| 393 | tasks. |
| 394 | |
| 395 | <P> |
| 396 | <a id='l2h-64' xml:id='l2h-64'></a> |
| 397 | </DD> |
| 398 | <DT><STRONG>mutable</STRONG></DT> |
| 399 | <DD>Mutable objects can change their value but keep their <tt class="function">id()</tt>. |
| 400 | See also <em>immutable</em>. |
| 401 | |
| 402 | <P> |
| 403 | <a id='l2h-65' xml:id='l2h-65'></a> |
| 404 | </DD> |
| 405 | <DT><STRONG>namespace</STRONG></DT> |
| 406 | <DD>The place where a variable is stored. Namespaces are implemented as |
| 407 | dictionaries. There are the local, global and builtin namespaces |
| 408 | as well as nested namespaces in objects (in methods). Namespaces support |
| 409 | modularity by preventing naming conflicts. For instance, the |
| 410 | functions <tt class="function">__builtin__.open()</tt> and <tt class="function">os.open()</tt> are |
| 411 | distinguished by their namespaces. Namespaces also aid readability |
| 412 | and maintainability by making it clear which module implements a |
| 413 | function. For instance, writing <tt class="function">random.seed()</tt> or |
| 414 | <tt class="function">itertools.izip()</tt> makes it clear that those functions are |
| 415 | implemented by the <a class="ulink" href="../lib/module-random.html" |
| 416 | ><tt class="module">random</tt></a> |
| 417 | and <a class="ulink" href="../lib/module-itertools.html" |
| 418 | ><tt class="module">itertools</tt></a> modules |
| 419 | respectively. |
| 420 | |
| 421 | <P> |
| 422 | <a id='l2h-66' xml:id='l2h-66'></a> |
| 423 | </DD> |
| 424 | <DT><STRONG>nested scope</STRONG></DT> |
| 425 | <DD>The ability to refer to a variable in an enclosing definition. For |
| 426 | instance, a function defined inside another function can refer to |
| 427 | variables in the outer function. Note that nested scopes work only |
| 428 | for reference and not for assignment which will always write to the |
| 429 | innermost scope. In contrast, local variables both read and write in |
| 430 | the innermost scope. Likewise, global variables read and write to the |
| 431 | global namespace. |
| 432 | |
| 433 | <P> |
| 434 | <a id='l2h-67' xml:id='l2h-67'></a> |
| 435 | </DD> |
| 436 | <DT><STRONG>new-style class</STRONG></DT> |
| 437 | <DD>Any class that inherits from <tt class="class">object</tt>. This includes all |
| 438 | built-in types like <tt class="class">list</tt> and <tt class="class">dict</tt>. Only new-style |
| 439 | classes can use Python's newer, versatile features like |
| 440 | <tt class="method">__slots__</tt>, descriptors, properties, |
| 441 | <tt class="method">__getattribute__()</tt>, class methods, and static methods. |
| 442 | |
| 443 | <P> |
| 444 | <a id='l2h-68' xml:id='l2h-68'></a> |
| 445 | </DD> |
| 446 | <DT><STRONG>Python3000</STRONG></DT> |
| 447 | <DD>A mythical python release, not required to be backward compatible, with |
| 448 | telepathic interface. |
| 449 | |
| 450 | <P> |
| 451 | <a id='l2h-69' xml:id='l2h-69'></a> |
| 452 | </DD> |
| 453 | <DT><STRONG>__slots__</STRONG></DT> |
| 454 | <DD>A declaration inside a <em>new-style class</em> that saves memory by |
| 455 | pre-declaring space for instance attributes and eliminating instance |
| 456 | dictionaries. Though popular, the technique is somewhat tricky to get |
| 457 | right and is best reserved for rare cases where there are large |
| 458 | numbers of instances in a memory-critical application. |
| 459 | |
| 460 | <P> |
| 461 | <a id='l2h-70' xml:id='l2h-70'></a> |
| 462 | </DD> |
| 463 | <DT><STRONG>sequence</STRONG></DT> |
| 464 | <DD>An <em>iterable</em> which supports efficient element access using |
| 465 | integer indices via the <tt class="method">__getitem__()</tt> and |
| 466 | <tt class="method">__len__()</tt> special methods. Some built-in sequence types |
| 467 | are <tt class="class">list</tt>, <tt class="class">str</tt>, <tt class="class">tuple</tt>, and <tt class="class">unicode</tt>. |
| 468 | Note that <tt class="class">dict</tt> also supports <tt class="method">__getitem__()</tt> and |
| 469 | <tt class="method">__len__()</tt>, but is considered a mapping rather than a |
| 470 | sequence because the lookups use arbitrary <em>immutable</em> keys |
| 471 | rather than integers. |
| 472 | |
| 473 | <P> |
| 474 | <a id='l2h-71' xml:id='l2h-71'></a> |
| 475 | </DD> |
| 476 | <DT><STRONG>Zen of Python</STRONG></DT> |
| 477 | <DD>Listing of Python design principles and philosophies that are helpful |
| 478 | in understanding and using the language. The listing can be found by |
| 479 | typing ``<code>import this</code>'' at the interactive prompt. |
| 480 | |
| 481 | <P> |
| 482 | </DD> |
| 483 | </DL> |
| 484 | |
| 485 | <P> |
| 486 | |
| 487 | <DIV CLASS="navigation"> |
| 488 | <div class='online-navigation'> |
| 489 | <p></p><hr /> |
| 490 | <table align="center" width="100%" cellpadding="0" cellspacing="2"> |
| 491 | <tr> |
| 492 | <td class='online-navigation'><a rel="prev" title="C. History and License" |
| 493 | href="node17.html"><img src='../icons/previous.png' |
| 494 | border='0' height='32' alt='Previous Page' width='32' /></A></td> |
| 495 | <td class='online-navigation'><a rel="parent" title="Python Tutorial" |
| 496 | href="tut.html"><img src='../icons/up.png' |
| 497 | border='0' height='32' alt='Up One Level' width='32' /></A></td> |
| 498 | <td class='online-navigation'><a rel="next" title="Index" |
| 499 | href="node19.html"><img src='../icons/next.png' |
| 500 | border='0' height='32' alt='Next Page' width='32' /></A></td> |
| 501 | <td align="center" width="100%">Python Tutorial</td> |
| 502 | <td class='online-navigation'><a rel="contents" title="Table of Contents" |
| 503 | href="node2.html"><img src='../icons/contents.png' |
| 504 | border='0' height='32' alt='Contents' width='32' /></A></td> |
| 505 | <td class='online-navigation'><img src='../icons/blank.png' |
| 506 | border='0' height='32' alt='' width='32' /></td> |
| 507 | <td class='online-navigation'><a rel="index" title="Index" |
| 508 | href="node19.html"><img src='../icons/index.png' |
| 509 | border='0' height='32' alt='Index' width='32' /></A></td> |
| 510 | </tr></table> |
| 511 | <div class='online-navigation'> |
| 512 | <b class="navlabel">Previous:</b> |
| 513 | <a class="sectref" rel="prev" href="node17.html">C. History and License</A> |
| 514 | <b class="navlabel">Up:</b> |
| 515 | <a class="sectref" rel="parent" href="tut.html">Python Tutorial</A> |
| 516 | <b class="navlabel">Next:</b> |
| 517 | <a class="sectref" rel="next" href="node19.html">Index</A> |
| 518 | </div> |
| 519 | </div> |
| 520 | <hr /> |
| 521 | <span class="release-info">Release 2.4.2, documentation updated on 28 September 2005.</span> |
| 522 | </DIV> |
| 523 | <!--End of Navigation Panel--> |
| 524 | <ADDRESS> |
| 525 | See <i><a href="about.html">About this document...</a></i> for information on suggesting changes. |
| 526 | </ADDRESS> |
| 527 | </BODY> |
| 528 | </HTML> |