{"title": "Extending and Embedding the Python Interpreter", "text": "---\nnode1.html node1.html\n---\n# Extending and Embedding the Python Interpreter\nGuido van Rossum\nDept. AA, CWI, P.O. Box 94079\n1090 GB Amsterdam, The Netherlands\nE-mail: guido@cwi.nl\n10 April 1995\nRelease 1.2\nCopyright © 1991-1995 by Stichting Mathematisch Centrum,\nAmsterdam, The Netherlands.\nAll Rights Reserved\nPermission to use, copy, modify, and distribute this software and its\ndocumentation for any purpose and without fee is hereby granted,\nprovided that the above copyright notice appear in all copies and that\nboth that copyright notice and this permission notice appear in\nsupporting documentation, and that the names of Stichting Mathematisch\nCentrum or CWI not be used in advertising or publicity pertaining to\ndistribution of the software without specific, written prior permission.\nSTICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO\nTHIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND\nFITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE\nFOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES\nWHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN\nACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT\nOF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\n### Abstract:\nPython is an interpreted, object-oriented programming language. This\ndocument describes how to write modules in C or C++ to extend the\nPython interpreter with new modules. Those modules can define new\nfunctions but also new object types and their methods. The document\nalso describes how to embed the Python interpreter in another\napplication, for use as an extension language. Finally, it shows how\nto compile and link extension modules so that they can be loaded\ndynamically (at run time) into the interpreter, if the underlying\noperating system supports this feature.\nThis document assumes basic knowledge about Python. For an informal\nintroduction to the language, see the Python Tutorial. The Python\nReference Manual gives a more formal definition of the language. The\nPython Library Reference documents the existing object types,\nfunctions and modules (both built-in and written in Python) that give\nthe language its wide application range.\n---\n- Contents (node1.html#SECTION00100000000000000000)\nExtending Python with C or C++ code (node2.html#SECTION00200000000000000000)\n- Introduction (node3.html#SECTION00210000000000000000)\nA Simple Example (node4.html#SECTION00220000000000000000)\nIntermezzo: Errors and Exceptions (node5.html#SECTION00230000000000000000)\nBack to the Example (node6.html#SECTION00240000000000000000)\nThe Module's Method Table and Initialization Function (node7.html#SECTION00250000000000000000)\nCompilation and Linkage (node8.html#SECTION00260000000000000000)\nCalling Python Functions From C (node9.html#SECTION00270000000000000000)\nFormat Strings for PyArg_ParseTuple() (node10.html#SECTION00280000000000000000)\nThe Py_BuildValue() Function (node11.html#SECTION00290000000000000000)\nReference Counts (node12.html#SECTION002100000000000000000)\n- Introduction (node13.html#SECTION002101000000000000000)\nReference Counting in Python (node14.html#SECTION002102000000000000000)\nOwnership Rules (node15.html#SECTION002103000000000000000)\nThin Ice (node16.html#SECTION002104000000000000000)\nNULL Pointers (node17.html#SECTION002105000000000000000)\nWriting Extensions in C++ (node18.html#SECTION002110000000000000000)\nEmbedding Python in another application (node19.html#SECTION00300000000000000000)\n- Embedding Python in C++ (node20.html#SECTION00310000000000000000)\nDynamic Loading (node21.html#SECTION00400000000000000000)\n- Configuring and Building the Interpreter for Dynamic Loading (node22.html#SECTION00410000000000000000)\n- Shared Libraries (node23.html#SECTION00411000000000000000)\nSGI IRIX 4 Dynamic Loading (node24.html#SECTION00412000000000000000)\nGNU Dynamic Loading (node25.html#SECTION00413000000000000000)\nBuilding a Dynamically Loadable Module (node26.html#SECTION00420000000000000000)\n- Shared Libraries (node27.html#SECTION00421000000000000000)\nSGI IRIX 4 Dynamic Loading (node28.html#SECTION00422000000000000000)\nGNU Dynamic Loading (node29.html#SECTION00423000000000000000)\nAbout this document ... (node30.html#SECTION00500000000000000000)\n---\nnode1.html node1.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 4322, "url": "https://docs.python.org/{python_version}/python-ext/ext.html"}
{"title": "Footnotes", "text": "guido@cwi.nl", "python_version": "1.2", "length": 12, "url": "https://docs.python.org/{python_version}/python-ext/footnode.html"}
{"title": "Contents", "text": "---\nnode2.html ext.html ext.html\n---\n## Contents\n- Extending Python with C or C++ code (node2.html#SECTION00200000000000000000)\n- Introduction (node3.html#SECTION00210000000000000000)\nA Simple Example (node4.html#SECTION00220000000000000000)\nIntermezzo: Errors and Exceptions (node5.html#SECTION00230000000000000000)\nBack to the Example (node6.html#SECTION00240000000000000000)\nThe Module's Method Table and Initialization Function (node7.html#SECTION00250000000000000000)\nCompilation and Linkage (node8.html#SECTION00260000000000000000)\nCalling Python Functions From C (node9.html#SECTION00270000000000000000)\nFormat Strings for PyArg_ParseTuple() (node10.html#SECTION00280000000000000000)\nThe Py_BuildValue() Function (node11.html#SECTION00290000000000000000)\nReference Counts (node12.html#SECTION002100000000000000000)\n- Introduction (node13.html#SECTION002101000000000000000)\nReference Counting in Python (node14.html#SECTION002102000000000000000)\nOwnership Rules (node15.html#SECTION002103000000000000000)\nThin Ice (node16.html#SECTION002104000000000000000)\nNULL Pointers (node17.html#SECTION002105000000000000000)\nWriting Extensions in C++ (node18.html#SECTION002110000000000000000)\nEmbedding Python in another application (node19.html#SECTION00300000000000000000)\n- Embedding Python in C++ (node20.html#SECTION00310000000000000000)\nDynamic Loading (node21.html#SECTION00400000000000000000)\n- Configuring and Building the Interpreter for Dynamic Loading (node22.html#SECTION00410000000000000000)\n- Shared Libraries (node23.html#SECTION00411000000000000000)\nSGI IRIX 4 Dynamic Loading (node24.html#SECTION00412000000000000000)\nGNU Dynamic Loading (node25.html#SECTION00413000000000000000)\nBuilding a Dynamically Loadable Module (node26.html#SECTION00420000000000000000)\n- Shared Libraries (node27.html#SECTION00421000000000000000)\nSGI IRIX 4 Dynamic Loading (node28.html#SECTION00422000000000000000)\nGNU Dynamic Loading (node29.html#SECTION00423000000000000000)\nAbout this document ... (node30.html#SECTION00500000000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 2049, "url": "https://docs.python.org/{python_version}/python-ext/node1.html"}
{"title": "Format Strings for PyArg_ParseTuple()", "text": "---\nnode11.html node2.html node9.html node1.html\n---\n# Format Strings for PyArg_ParseTuple()\nThe `PyArg_ParseTuple()` function is declared as follows:\n```text\nint PyArg_ParseTuple(PyObject *arg, char *format, ...);\n```\nThe arg argument must be a tuple object containing an argument\nlist passed from Python to a C function. The format argument\nmust be a format string, whose syntax is explained below. The\nremaining arguments must be addresses of variables whose type is\ndetermined by the format string. For the conversion to succeed, the\narg object must match the format and the format must be\nexhausted.\nNote that while `PyArg_ParseTuple()` checks that the Python\narguments have the required types, it cannot check the validity of the\naddresses of C variables passed to the call: if you make mistakes\nthere, your code will probably crash or at least overwrite random bits\nin memory. So be careful!\nA format string consists of zero or more ``format units''. A format\nunit describes one Python object; it is usually a single character or\na parenthesized sequence of format units. With a few exceptions, a\nformat unit that is not a parenthesized sequence normally corresponds\nto a single address argument to `PyArg_ParseTuple()`. In the\nfollowing description, the quoted form is the format unit; the entry\nin (round) parentheses is the Python object type that matches the\nformat unit; and the entry in [square] brackets is the type of the C\nvariable(s) whose address should be passed. (Use the `&'\noperator to pass a variable's address.)\nIt is possible to pass Python long integers where integers are\nrequested; however no proper range checking is done -- the most\nsignificant bits are silently truncated when the receiving field is\ntoo small to receive the value (actually, the semantics are inherited\nfrom downcasts in C --- your milage may vary).\nA few other characters have a meaning in a format string. These may\nnot occur inside nested parentheses. They are:\nSome example calls:\n```text\nint ok;\nint i, j;\nlong k, l;\nchar *s;\nint size;\n\nok = PyArg_ParseTuple(args, \"\"); /* No arguments */\n/* Python call: f() */\n\nok = PyArg_ParseTuple(args, \"s\", &s); /* A string */\n/* Possible Python call: f('whoops!') */\n\nok = PyArg_ParseTuple(args, \"lls\", &k, &l, &s); /* Two longs and a string */\n/* Possible Python call: f(1, 2, 'three') */\n\nok = PyArg_ParseTuple(args, \"(ii)s#\", &i, &j, &s, &size);\n/* A pair of ints and a string, whose size is also returned */\n/* Possible Python call: f(1, 2, 'three') */\n\n{\nchar *file;\nchar *mode = \"r\";\nint bufsize = 0;\nok = PyArg_ParseTuple(args, \"s|si\", &file, &mode, &bufsize);\n/* A string, and optionally another string and an integer */\n/* Possible Python calls:\nf('spam')\nf('spam', 'w')\nf('spam', 'wb', 100000) */\n}\n\n{\nint left, top, right, bottom, h, v;\nok = PyArg_ParseTuple(args, \"((ii)(ii))(ii)\",\n&left, &top, &right, &bottom, &h, &v);\n/* A rectangle and a point */\n/* Possible Python call:\nf(((0, 0), (400, 300)), (10, 10)) */\n}\n```\n---\nnode11.html node2.html node9.html node1.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 3043, "url": "https://docs.python.org/{python_version}/python-ext/node10.html"}
{"title": "The Py_BuildValue() Function", "text": "---\nnode12.html node2.html node10.html node1.html\n---\n# The Py_BuildValue() Function\nThis function is the counterpart to `PyArg_ParseTuple()`. It is\ndeclared as follows:\n```text\nPyObject *Py_BuildValue(char *format, ...);\n```\nIt recognizes a set of format units similar to the ones recognized by\n`PyArg_ParseTuple()`, but the arguments (which are input to the\nfunction, not output) must not be pointers, just values. It returns a\nnew Python object, suitable for returning from a C function called\nfrom Python.\nOne difference with `PyArg_ParseTuple()`: while the latter\nrequires its first argument to be a tuple (since Python argument lists\nare always represented as tuples internally), `BuildValue()` does\nnot always build a tuple. It builds a tuple only if its format string\ncontains two or more format units. If the format string is empty, it\nreturns `None`; if it contains exactly one format unit, it\nreturns whatever object is described by that format unit. To force it\nto return a tuple of size 0 or one, parenthesize the format string.\nIn the following description, the quoted form is the format unit; the\nentry in (round) parentheses is the Python object type that the format\nunit will return; and the entry in [square] brackets is the type of\nthe C value(s) to be passed.\nThe characters space, tab, colon and comma are ignored in format\nstrings (but not within format units such as `s#'). This can be\nused to make long format strings a tad more readable.\nIf there is an error in the format string, the\n`PyExc_SystemError` exception is raised and `NULL` returned.\nExamples (to the left the call, to the right the resulting Python value):\n```text\nPy_BuildValue(\"\") None\nPy_BuildValue(\"i\", 123) 123\nPy_BuildValue(\"iii\", 123, 456, 789) (123, 456, 789)\nPy_BuildValue(\"s\", \"hello\") 'hello'\nPy_BuildValue(\"ss\", \"hello\", \"world\") ('hello', 'world')\nPy_BuildValue(\"s#\", \"hello\", 4) 'hell'\nPy_BuildValue(\"()\") ()\nPy_BuildValue(\"(i)\", 123) (123,)\nPy_BuildValue(\"(ii)\", 123, 456) (123, 456)\nPy_BuildValue(\"(i,i)\", 123, 456) (123, 456)\nPy_BuildValue(\"[i,i]\", 123, 456) [123, 456]\nPy_BuildValue(\"{s:i,s:i}\",\n\"abc\", 123, \"def\", 456) {'abc': 123, 'def': 456}\nPy_BuildValue(\"((ii)(ii)) (ii)\",\n1, 2, 3, 4, 5, 6) (((1, 2), (3, 4)), (5, 6))\n```\n---\nnode12.html node2.html node10.html node1.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 2303, "url": "https://docs.python.org/{python_version}/python-ext/node11.html"}
{"title": "Reference Counts", "text": "---\nnode13.html node2.html node11.html node1.html\n---\n# Reference Counts\n---\n- Introduction (node13.html#SECTION002101000000000000000)\nReference Counting in Python (node14.html#SECTION002102000000000000000)\nOwnership Rules (node15.html#SECTION002103000000000000000)\nThin Ice (node16.html#SECTION002104000000000000000)\nNULL Pointers (node17.html#SECTION002105000000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 391, "url": "https://docs.python.org/{python_version}/python-ext/node12.html"}
{"title": "Introduction", "text": "---\nnode14.html node12.html node12.html node1.html\n---\n## Introduction\nIn languages like C or C++, the programmer is responsible for\ndynamic allocation and deallocation of memory on the heap. In C, this\nis done using the functions `malloc()` and `free()`. In\nC++, the operators `new` and `delete` are used with\nessentially the same meaning; they are actually implemented using\n`malloc()` and `free()`, so we'll restrict the following\ndiscussion to the latter.\nEvery block of memory allocated with `malloc()` should eventually\nbe returned to the pool of available memory by exactly one call to\n`free()`. It is important to call `free()` at the right\ntime. If a block's address is forgotten but `free()` is not\ncalled for it, the memory it occupies cannot be reused until the\nprogram terminates. This is called a memory leak. On the other\nhand, if a program calls `free()` for a block and then continues\nto use the block, it creates a conflict with re-use of the block\nthrough another `malloc()` call. This is called using freed\nmemory has the same bad consequences as referencing uninitialized\ndata --- core dumps, wrong results, mysterious crashes.\nCommon causes of memory leaks are unusual paths through the code. For\ninstance, a function may allocate a block of memory, do some\ncalculation, and then free the block again. Now a change in the\nrequirements for the function may add a test to the calculation that\ndetects an error condition and can return prematurely from the\nfunction. It's easy to forget to free the allocated memory block when\ntaking this premature exit, especially when it is added later to the\ncode. Such leaks, once introduced, often go undetected for a long\ntime: the error exit is taken only in a small fraction of all calls,\nand most modern machines have plenty of virtual memory, so the leak\nonly becomes apparent in a long-running process that uses the leaking\nfunction frequently. Therefore, it's important to prevent leaks from\nhappening by having a coding convention or strategy that minimizes\nthis kind of errors.\nSince Python makes heavy use of malloc() and `free()`, it\nneeds a strategy to avoid memory leaks as well as the use of freed\nmemory. The chosen method is called `reference counting`. The\nprinciple is simple: every object contains a counter, which is\nincremented when a reference to the object is stored somewhere, and\nwhich is decremented when a reference to it is deleted. When the\ncounter reaches zero, the last reference to the object has been\ndeleted and the object is freed.\nAn alternative strategy is called automatic garbage collection.\n(Sometimes, reference counting is also referred to as a garbage\ncollection strategy, hence my use of ``automatic'' to distinguish the\ntwo.) The big advantage of automatic garbage collection is that the\nuser doesn't need to call free() explicitly. (Another claimed\nadvantage is an improvement in speed or memory usage --- this is no\nhard fact however.) The disadvantage is that for C, there is no\ntruly portable automatic garbage collector, while reference counting\ncan be implemented portably (as long as the functions `malloc()`\nand `free()` are available --- which the C Standard guarantees).\nMaybe some day a sufficiently portable automatic garbage collector\nwill be available for C. Until then, we'll have to live with\nreference counts.\n---\nnode14.html node12.html node12.html node1.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 3401, "url": "https://docs.python.org/{python_version}/python-ext/node13.html"}
{"title": "Reference Counting in Python", "text": "---\nnode15.html node12.html node13.html node1.html\n---\n## Reference Counting in Python\nThere are two macros, `Py_INCREF(x)` and `Py_DECREF(x)`,\nwhich handle the incrementing and decrementing of the reference count.\n`Py_DECREF()` also frees the object when the count reaches zero.\nFor flexibility, it doesn't call `free()` directly --- rather, it\nmakes a call through a function pointer in the object's type\nobject. For this purpose (and others), every object also contains a\npointer to its type object.\nThe big question now remains: when to use Py_INCREF(x) and\n`Py_DECREF(x)`? Let's first introduce some terms. Nobody\n``owns'' an object; however, you can `own a reference` to an\nobject. An object's reference count is now defined as the number of\nowned references to it. The owner of a reference is responsible for\ncalling Py_DECREF() when the reference is no longer needed.\nOwnership of a reference can be transferred. There are three ways to\ndispose of an owned reference: pass it on, store it, or call\n`Py_DECREF()`. Forgetting to dispose of an owned reference creates\na memory leak.\nIt is also possible to `borrow`footnode.html#371 a reference to an object. The borrower\nof a reference should not call Py_DECREF(). The borrower must\nnot hold on to the object longer than the owner from which it was\nborrowed. Using a borrowed reference after the owner has disposed of\nit risks using freed memory and should be avoided\ncompletely.footnode.html#538\nThe advantage of borrowing over owning a reference is that you don't\nneed to take care of disposing of the reference on all possible paths\nthrough the code --- in other words, with a borrowed reference you\ndon't run the risk of leaking when a premature exit is taken. The\ndisadvantage of borrowing over leaking is that there are some subtle\nsituations where in seemingly correct code a borrowed reference can be\nused after the owner from which it was borrowed has in fact disposed\nof it.\nA borrowed reference can be changed into an owned reference by calling\n`Py_INCREF()`. This does not affect the status of the owner from\nwhich the reference was borrowed --- it creates a new owned reference,\nand gives full owner responsibilities (i.e., the new owner must\ndispose of the reference properly, as well as the previous owner).\n---\nnode15.html node12.html node13.html node1.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 2349, "url": "https://docs.python.org/{python_version}/python-ext/node14.html"}
{"title": "Ownership Rules", "text": "---\nnode16.html node12.html node14.html node1.html\n---\n## Ownership Rules\nWhenever an object reference is passed into or out of a function, it\nis part of the function's interface specification whether ownership is\ntransferred with the reference or not.\nMost functions that return a reference to an object pass on ownership\nwith the reference. In particular, all functions whose function it is\nto create a new object, e.g. `PyInt_FromLong()` and\n`Py_BuildValue()`, pass ownership to the receiver. Even if in\nfact, in some cases, you don't receive a reference to a brand new\nobject, you still receive ownership of the reference. For instance,\n`PyInt_FromLong()` maintains a cache of popular values and can\nreturn a reference to a cached item.\nMany functions that extract objects from other objects also transfer\nownership with the reference, for instance\n`PyObject_GetAttrString()`. The picture is less clear, here,\nhowever, since a few common routines are exceptions:\n`PyTuple_GetItem()`, `PyList_GetItem()` and\n`PyDict_GetItem()` (and `PyDict_GetItemString()`) all return\nreferences that you borrow from the tuple, list or dictionary.\nThe function `PyImport_AddModule()` also returns a borrowed\nreference, even though it may actually create the object it returns:\nthis is possible because an owned reference to the object is stored in\n`sys.modules`.\nWhen you pass an object reference into another function, in general,\nthe function borrows the reference from you --- if it needs to store\nit, it will use `Py_INCREF()` to become an independent owner.\nThere are exactly two important exceptions to this rule:\n`PyTuple_SetItem()` and `PyList_SetItem()`. These functions\ntake over ownership of the item passed to them --- even if they fail!\n(Note that `PyDict_SetItem()` and friends don't take over\nownership --- they are ``normal''.)\nWhen a C function is called from Python, it borrows references to its\narguments from the caller. The caller owns a reference to the object,\nso the borrowed reference's lifetime is guaranteed until the function\nreturns. Only when such a borrowed reference must be stored or passed\non, it must be turned into an owned reference by calling\n`Py_INCREF()`.\nThe object reference returned from a C function that is called from\nPython must be an owned reference --- ownership is tranferred from the\nfunction to its caller.\n---\nnode16.html node12.html node14.html node1.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 2417, "url": "https://docs.python.org/{python_version}/python-ext/node15.html"}
{"title": "Thin Ice", "text": "---\nnode17.html node12.html node15.html node1.html\n---\n## Thin Ice\nThere are a few situations where seemingly harmless use of a borrowed\nreference can lead to problems. These all have to do with implicit\ninvocations of the interpreter, which can cause the owner of a\nreference to dispose of it.\nThe first and most important case to know about is using\n`Py_DECREF()` on an unrelated object while borrowing a reference\nto a list item. For instance:\n```text\nbug(PyObject *list) {\nPyObject *item = PyList_GetItem(list, 0);\nPyList_SetItem(list, 1, PyInt_FromLong(0L));\nPyObject_Print(item, stdout, 0); /* BUG! */\n}\n```\nThis function first borrows a reference to `list[0]`, then\nreplaces `list[1]` with the value `0`, and finally prints\nthe borrowed reference. Looks harmless, right? But it's not!\nLet's follow the control flow into `PyList_SetItem()`. The list\nowns references to all its items, so when item 1 is replaced, it has\nto dispose of the original item 1. Now let's suppose the original\nitem 1 was an instance of a user-defined class, and let's further\nsuppose that the class defined a `__del__()` method. If this\nclass instance has a reference count of 1, disposing of it will call\nits `__del__()` method.\nSince it is written in Python, the `__del__()` method can execute\narbitrary Python code. Could it perhaps do something to invalidate\nthe reference to `item` in `bug()`? You bet! Assuming that\nthe list passed into `bug()` is accessible to the\n`__del__()` method, it could execute a statement to the effect of\n`del list[0]`, and assuming this was the last reference to that\nobject, it would free the memory associated with it, thereby\ninvalidating `item`.\nThe solution, once you know the source of the problem, is easy:\ntemporarily increment the reference count. The correct version of the\nfunction reads:\n```text\nno_bug(PyObject *list) {\nPyObject *item = PyList_GetItem(list, 0);\nPy_INCREF(item);\nPyList_SetItem(list, 1, PyInt_FromLong(0L));\nPyObject_Print(item, stdout, 0);\nPy_DECREF(item);\n}\n```\nThis is a true story. An older version of Python contained variants\nof this bug and someone spent a considerable amount of time in a C\ndebugger to figure out why his `__del__()` methods would fail...\nThe second case of problems with a borrowed reference is a variant\ninvolving threads. Normally, multiple threads in the Python\ninterpreter can't get in each other's way, because there is a global\nlock protecting Python's entire object space. However, it is possible\nto temporarily release this lock using the macro\n`Py_BEGIN_ALLOW_THREADS`, and to re-acquire it using\n`Py_END_ALLOW_THREADS`. This is common around blocking I/O\ncalls, to let other threads use the CPU while waiting for the I/O to\ncomplete. Obviously, the following function has the same problem as\nthe previous one:\n```text\nbug(PyObject *list) {\nPyObject *item = PyList_GetItem(list, 0);\nPy_BEGIN_ALLOW_THREADS\n...some blocking I/O call...\nPy_END_ALLOW_THREADS\nPyObject_Print(item, stdout, 0); /* BUG! */\n}\n```\n---\nnode17.html node12.html node15.html node1.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 3056, "url": "https://docs.python.org/{python_version}/python-ext/node16.html"}
{"title": "NULL Pointers", "text": "---\nnode18.html node12.html node16.html node1.html\n---\n## NULL Pointers\nIn general, functions that take object references as arguments don't\nexpect you to pass them `NULL` pointers, and will dump core (or\ncause later core dumps) if you do so. Functions that return object\nreferences generally return `NULL` only to indicate that an\nexception occurred. The reason for not testing for `NULL`\narguments is that functions often pass the objects they receive on to\nother function --- if each function were to test for `NULL`,\nthere would be a lot of redundant tests and the code would run slower.\nIt is better to test for `NULL` only at the ``source'', i.e.\\\nwhen a pointer that may be `NULL` is received, e.g. from\n`malloc()` or from a function that may raise an exception.\nThe macros `Py_INCREF()` and `Py_DECREF()`\ndon't check for `NULL` pointers --- however, their variants\n`Py_XINCREF()` and `Py_XDECREF()` do.\nThe macros for checking for a particular object type\n(`Py type _Check()`) don't check for `NULL` pointers ---\nagain, there is much code that calls several of these in a row to test\nan object against various different expected types, and this would\ngenerate redundant tests. There are no variants with `NULL`\nchecking.\nThe C function calling mechanism guarantees that the argument list\npassed to C functions (`args` in the examples) is never\n`NULL` --- in fact it guarantees that it is always a tuple.\nfootnode.html#427\nIt is a severe error to ever let a `NULL` pointer ``escape'' to\nthe Python user.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1527, "url": "https://docs.python.org/{python_version}/python-ext/node17.html"}
{"title": "Writing Extensions in C++", "text": "---\nnode19.html node2.html node17.html node1.html\n---\n# Writing Extensions in C++\nIt is possible to write extension modules in C++. Some restrictions\napply: since the main program (the Python interpreter) is compiled and\nlinked by the C compiler, global or static objects with constructors\ncannot be used. All functions that will be called directly or\nindirectly (i.e. via function pointers) by the Python interpreter will\nhave to be declared using `extern \"C\"`; this applies to all\n``methods'' as well as to the module's initialization function.\nIt is unnecessary to enclose the Python header files in\n`extern \"C\" {...}` --- they use this form already if the symbol\n`__cplusplus' is defined (all recent C++ compilers define this\nsymbol).\n---\nguido@cwi.nl", "python_version": "1.2", "length": 755, "url": "https://docs.python.org/{python_version}/python-ext/node18.html"}
{"title": "Embedding Python in another application", "text": "---\nnode20.html ext.html node18.html node1.html\n---\n# Embedding Python in another application\nEmbedding Python is similar to extending it, but not quite. The\ndifference is that when you extend Python, the main program of the\napplication is still the Python interpreter, while if you embed\nPython, the main program may have nothing to do with Python ---\ninstead, some parts of the application occasionally call the Python\ninterpreter to run some Python code.\nSo if you are embedding Python, you are providing your own main\nprogram. One of the things this main program has to do is initialize\nthe Python interpreter. At the very least, you have to call the\nfunction `Py_Initialize()`. There are optional calls to pass command\nline arguments to Python. Then later you can call the interpreter\nfrom any part of the application.\nThere are several different ways to call the interpreter: you can pass\na string containing Python statements to `PyRun_SimpleString()`,\nor you can pass a stdio file pointer and a file name (for\nidentification in error messages only) to `PyRun_SimpleFile()`. You\ncan also call the lower-level operations described in the previous\nchapters to construct and use Python objects.\nA simple demo of embedding Python can be found in the directory\n``Demo/embed`'.\n---\n- Embedding Python in C++ (node20.html#SECTION00310000000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1367, "url": "https://docs.python.org/{python_version}/python-ext/node19.html"}
{"title": "Extending Python with C or C++ code", "text": "---\nnode3.html ext.html node1.html node1.html\n---\n# Extending Python with C or C++ code\n---\n- Introduction (node3.html#SECTION00210000000000000000)\nA Simple Example (node4.html#SECTION00220000000000000000)\nIntermezzo: Errors and Exceptions (node5.html#SECTION00230000000000000000)\nBack to the Example (node6.html#SECTION00240000000000000000)\nThe Module's Method Table and Initialization Function (node7.html#SECTION00250000000000000000)\nCompilation and Linkage (node8.html#SECTION00260000000000000000)\nCalling Python Functions From C (node9.html#SECTION00270000000000000000)\nFormat Strings for PyArg_ParseTuple() (node10.html#SECTION00280000000000000000)\nThe Py_BuildValue() Function (node11.html#SECTION00290000000000000000)\nReference Counts (node12.html#SECTION002100000000000000000)\n- Introduction (node13.html#SECTION002101000000000000000)\nReference Counting in Python (node14.html#SECTION002102000000000000000)\nOwnership Rules (node15.html#SECTION002103000000000000000)\nThin Ice (node16.html#SECTION002104000000000000000)\nNULL Pointers (node17.html#SECTION002105000000000000000)\nWriting Extensions in C++ (node18.html#SECTION002110000000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1169, "url": "https://docs.python.org/{python_version}/python-ext/node2.html"}
{"title": "Embedding Python in C++", "text": "---\nnode21.html node19.html node19.html node1.html\n---\n# Embedding Python in C++\nIt is also possible to embed Python in a C++ program; precisely how this\nis done will depend on the details of the C++ system used; in general you\nwill need to write the main program in C++, and use the C++ compiler\nto compile and link your program. There is no need to recompile Python\nitself using C++.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 402, "url": "https://docs.python.org/{python_version}/python-ext/node20.html"}
{"title": "Dynamic Loading", "text": "---\nnode22.html ext.html node20.html node1.html\n---\n# Dynamic Loading\nOn most modern systems it is possible to configure Python to support\ndynamic loading of extension modules implemented in C. When shared\nlibraries are used dynamic loading is configured automatically;\notherwise you have to select it as a build option (see below). Once\nconfigured, dynamic loading is trivial to use: when a Python program\nexecutes `import spam`, the search for modules tries to find a\nfile ``spammodule.o`' (``spammodule.so`' when using shared\nlibraries) in the module search path, and if one is found, it is\nloaded into the executing binary and executed. Once loaded, the\nmodule acts just like a built-in extension module.\nThe advantages of dynamic loading are twofold: the ``core'' Python\nbinary gets smaller, and users can extend Python with their own\nmodules implemented in C without having to build and maintain their\nown copy of the Python interpreter. There are also disadvantages:\ndynamic loading isn't available on all systems (this just means that\non some systems you have to use static loading), and dynamically\nloading a module that was compiled for a different version of Python\n(e.g. with a different representation of objects) may dump core.\n---\n- Configuring and Building the Interpreter for Dynamic Loading (node22.html#SECTION00410000000000000000)\n- Shared Libraries (node23.html#SECTION00411000000000000000)\nSGI IRIX 4 Dynamic Loading (node24.html#SECTION00412000000000000000)\nGNU Dynamic Loading (node25.html#SECTION00413000000000000000)\nBuilding a Dynamically Loadable Module (node26.html#SECTION00420000000000000000)\n- Shared Libraries (node27.html#SECTION00421000000000000000)\nSGI IRIX 4 Dynamic Loading (node28.html#SECTION00422000000000000000)\nGNU Dynamic Loading (node29.html#SECTION00423000000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1832, "url": "https://docs.python.org/{python_version}/python-ext/node21.html"}
{"title": "Configuring and Building the Interpreter for Dynamic Loading", "text": "---\nnode23.html node21.html node21.html node1.html\n---\n# Configuring and Building the Interpreter for Dynamic Loading\nThere are three styles of dynamic loading: one using shared libraries,\none using SGI IRIX 4 dynamic loading, and one using GNU dynamic\nloading.\n---\n- Shared Libraries (node23.html#SECTION00411000000000000000)\nSGI IRIX 4 Dynamic Loading (node24.html#SECTION00412000000000000000)\nGNU Dynamic Loading (node25.html#SECTION00413000000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 474, "url": "https://docs.python.org/{python_version}/python-ext/node22.html"}
{"title": "Shared Libraries", "text": "---\nnode24.html node22.html node22.html node1.html\n---\n## Shared Libraries\nThe following systems support dynamic loading using shared libraries:\nSunOS 4; Solaris 2; SGI IRIX 5 (but not SGI IRIX 4!); and probably all\nsystems derived from SVR4, or at least those SVR4 derivatives that\nsupport shared libraries (are there any that don't?).\nYou don't need to do anything to configure dynamic loading on these\nsystems --- the ``configure`' detects the presence of the\n``<dlfcn.h>`' header file and automatically configures dynamic\nloading.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 551, "url": "https://docs.python.org/{python_version}/python-ext/node23.html"}
{"title": "SGI IRIX 4 Dynamic Loading", "text": "---\nnode25.html node22.html node23.html node1.html\n---\n## SGI IRIX 4 Dynamic Loading\nOnly SGI IRIX 4 supports dynamic loading of modules using SGI dynamic\nloading. (SGI IRIX 5 might also support it but it is inferior to\nusing shared libraries so there is no reason to; a small test didn't\nwork right away so I gave up trying to support it.)\nBefore you build Python, you first need to fetch and build the `dl`\npackage written by Jack Jansen. This is available by anonymous ftp\nfrom host ``ftp.cwi.nl`', directory ``pub/dynload`', file\n``dl-1.6.tar.Z`'. (The version number may change.) Follow the\ninstructions in the package's ``README`' file to build it.\nOnce you have built `dl`, you can configure Python to use it. To\nthis end, you run the ``configure`' script with the option\n`--with-dl= directory` where directory is the absolute\npathname of the `dl` directory.\nNow build and install Python as you normally would (see the\n``README`' file in the toplevel Python directory.)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 993, "url": "https://docs.python.org/{python_version}/python-ext/node24.html"}
{"title": "GNU Dynamic Loading", "text": "---\nnode26.html node22.html node24.html node1.html\n---\n## GNU Dynamic Loading\nGNU dynamic loading supports (according to its ``README`' file) the\nfollowing hardware and software combinations: VAX (Ultrix), Sun 3\n(SunOS 3.4 and 4.0), Sparc (SunOS 4.0), Sequent Symmetry (Dynix), and\nAtari ST. There is no reason to use it on a Sparc; I haven't seen a\nSun 3 for years so I don't know if these have shared libraries or not.\nYou need to fetch and build two packages. One is GNU DLD 3.2.3,\navailable by anonymous ftp from host ``ftp.cwi.nl`', directory\n``pub/dynload`', file ``dld-3.2.3.tar.Z`'. (As far as I know,\nno further development on GNU DLD is being done.) The other is an\nemulation of Jack Jansen's `dl` package that I wrote on top of\nGNU DLD 3.2.3. This is available from the same host and directory,\nfile dl-dld-1.1.tar.Z. (The version number may change --- but I doubt\nit will.) Follow the instructions in each package's ``README`'\nfile to configure build them.\nNow configure Python. Run the ``configure`' script with the option\n`--with-dl-dld= dl-directory , dld-directory` where\ndl-directory is the absolute pathname of the directory where you\nhave built the ``dl-dld`' package, and dld-directory is that\nof the GNU DLD package. The Python interpreter you build hereafter\nwill support GNU dynamic loading.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1331, "url": "https://docs.python.org/{python_version}/python-ext/node25.html"}
{"title": "Building a Dynamically Loadable Module", "text": "---\nnode27.html node21.html node25.html node1.html\n---\n# Building a Dynamically Loadable Module\nSince there are three styles of dynamic loading, there are also three\ngroups of instructions for building a dynamically loadable module.\nInstructions common for all three styles are given first. Assuming\nyour module is called `spam`, the source filename must be\n``spammodule.c`', so the object name is ``spammodule.o`'. The\nmodule must be written as a normal Python extension module (as\ndescribed earlier).\nNote that in all cases you will have to create your own Makefile that\ncompiles your module file(s). This Makefile will have to pass two\n`-I' arguments to the C compiler which will make it find the\nPython header files. If the Make variable PYTHONTOP points to\nthe toplevel Python directory, your CFLAGS Make variable should\ncontain the options `-I$(PYTHONTOP) -I$(PYTHONTOP)/Include'.\n(Most header files are in the ``Include`' subdirectory, but the\n``config.h`' header lives in the toplevel directory.) You must\nalso add `-DHAVE_CONFIG_H' to the definition of CFLAGS to\ndirect the Python headers to include ``config.h`'.\n---\n- Shared Libraries (node27.html#SECTION00421000000000000000)\nSGI IRIX 4 Dynamic Loading (node28.html#SECTION00422000000000000000)\nGNU Dynamic Loading (node29.html#SECTION00423000000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1335, "url": "https://docs.python.org/{python_version}/python-ext/node26.html"}
{"title": "Shared Libraries", "text": "---\nnode28.html node26.html node26.html node1.html\n---\n## Shared Libraries\nYou must link the `.o' file to produce a shared library. This is\ndone using a special invocation of the Unix loader/linker,\nld(1). Unfortunately the invocation differs slightly per system.\nOn SunOS 4, use\n```text\nld spammodule.o -o spammodule.so\n```\nOn Solaris 2, use\n```text\nld -G spammodule.o -o spammodule.so\n```\nOn SGI IRIX 5, use\n```text\nld -shared spammodule.o -o spammodule.so\n```\nOn other systems, consult the manual page for `ld`(1) to find what\nflags, if any, must be used.\nIf your extension module uses system libraries that haven't already\nbeen linked with Python (e.g. a windowing system), these must be\npassed to the `ld` command as `-l' options after the\n`.o' file.\nThe resulting file ``spammodule.so`' must be copied into a directory\nalong the Python module search path.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 878, "url": "https://docs.python.org/{python_version}/python-ext/node27.html"}
{"title": "SGI IRIX 4 Dynamic Loading", "text": "---\nnode29.html node26.html node27.html node1.html\n---\n## SGI IRIX 4 Dynamic Loading\nIMPORTANT: You must compile your extension module with the\nadditional C flag `-G0' (or `-G 0'). This instruct the\nassembler to generate position-independent code.\nYou don't need to link the resulting ``spammodule.o`' file; just\ncopy it into a directory along the Python module search path.\nThe first time your extension is loaded, it takes some extra time and\na few messages may be printed. This creates a file\n``spammodule.ld`' which is an image that can be loaded quickly into\nthe Python interpreter process. When a new Python interpreter is\ninstalled, the `dl` package detects this and rebuilds\n``spammodule.ld`'. The file ``spammodule.ld`' is placed in the\ndirectory where ``spammodule.o`' was found, unless this directory is\nunwritable; in that case it is placed in a temporary\ndirectory.footnode.html#544\nIf your extension modules uses additional system libraries, you must\ncreate a file ``spammodule.libs`' in the same directory as the\n``spammodule.o`'. This file should contain one or more lines with\nwhitespace-separated options that will be passed to the linker ---\nnormally only `-l' options or absolute pathnames of libraries\n(`.a' files) should be used.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1268, "url": "https://docs.python.org/{python_version}/python-ext/node28.html"}
{"title": "GNU Dynamic Loading", "text": "---\nnode30.html node26.html node28.html node1.html\n---\n## GNU Dynamic Loading\nJust copy ``spammodule.o`' into a directory along the Python module\nsearch path.\nIf your extension modules uses additional system libraries, you must\ncreate a file ``spammodule.libs`' in the same directory as the\n``spammodule.o`'. This file should contain one or more lines with\nwhitespace-separated absolute pathnames of libraries (`.a'\nfiles). No `-l' options can be used.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 469, "url": "https://docs.python.org/{python_version}/python-ext/node29.html"}
{"title": "Introduction", "text": "---\nnode4.html node2.html node2.html node1.html\n---\n# Introduction\nIt is quite easy to add new built-in modules to Python, if you know\nhow to program in C. Such extension modules can do two things\nthat can't be done directly in Python: they can implement new built-in\nobject types, and they can call C library functions and system calls.\nTo support extensions, the Python API (Application Programmers\nInterface) defines a set of functions, macros and variables that\nprovide access to most aspects of the Python run-time system. The\nPython API is incorporated in a C source file by including the header\n`\"Python.h\"`.\nThe compilation of an extension module depends on its intended use as\nwell as on your system setup; details are given in a later section.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 770, "url": "https://docs.python.org/{python_version}/python-ext/node3.html"}
{"title": "About this document ...", "text": "---\next.html node29.html node1.html\n---\n# About this document ...\nExtending and Embedding the Python Interpreter\nThis document was generated using the LaTeX2HTML (http://cbl.leeds.ac.uk/nikos/tex2html/doc/latex2html/latex2html.html) translator Version 95.1 (Fri Jan 20 1995) Copyright © 1993, 1994, Nikos Drakos (http://cbl.leeds.ac.uk/nikos/personal.html), Computer Based Learning Unit, University of Leeds.\nThe command line arguments were:\nlatex2html -address guido@cwi.nl -dont_include myformat ext.tex.\nThe translation was initiated by Guido van Rossum on Tue Apr 11 00:22:00 MDT 1995\n---\nguido@cwi.nl", "python_version": "1.2", "length": 605, "url": "https://docs.python.org/{python_version}/python-ext/node30.html"}
{"title": "A Simple Example", "text": "---\nnode5.html node2.html node3.html node1.html\n---\n# A Simple Example\nLet's create an extension module called `spam' (the favorite food\nof Monty Python fans...) and let's say we want to create a Python\ninterface to the C library function `system()`.footnode.html#522\nThis function takes a null-terminated character string as argument and\nreturns an integer. We want this function to be callable from Python\nas follows:\n```text\n>>> import spam\n>>> status = spam.system(\"ls -l\")\n```\nBegin by creating a file `spammodule.c'. (In general, if a\nmodule is called `spam', the C file containing its implementation\nis called ``spammodule.c`'; if the module name is very long, like\n`spammify', the module name can be just ``spammify.c`'.)\nThe first line of our file can be:\n```text\n#include \"Python.h\"\n```\nwhich pulls in the Python API (you can add a comment describing the\npurpose of the module and a copyright notice if you like).\nAll user-visible symbols defined by `\"Python.h\"` have a prefix of\n`Py' or `PY', except those defined in standard header files.\nFor convenience, and since they are used extensively by the Python\ninterpreter, `\"Python.h\"` includes a few standard header files:\n`<stdio.h>`, `<string.h>`, `<errno.h>`, and\n`<stdlib.h>`. If the latter header file does not exist on your\nsystem, it declares the functions `malloc()`, `free()` and\n`realloc()` directly.\nThe next thing we add to our module file is the C function that will\nbe called when the Python expression `spam.system(string)'\nis evaluated (we'll see shortly how it ends up being called):\n```text\nstatic PyObject *\nspam_system(self, args)\nPyObject *self;\nPyObject *args;\n{\nchar *command;\nint sts;\nif (!PyArg_ParseTuple(args, \"s\", &command))\nreturn NULL;\nsts = system(command);\nreturn Py_BuildValue(\"i\", sts);\n}\n```\nThere is a straightforward translation from the argument list in\nPython (e.g. the single expression `\"ls -l\"`) to the arguments\npassed to the C function. The C function always has two arguments,\nconventionally named self and args.\nThe self argument is only used when the C function implements a\nbuiltin method. This will be discussed later. In the example,\nself will always be a `NULL` pointer, since we are defining\na function, not a method. (This is done so that the interpreter\ndoesn't have to understand two different types of C functions.)\nThe args argument will be a pointer to a Python tuple object\ncontaining the arguments. Each item of the tuple corresponds to an\nargument in the call's argument list. The arguments are Python\nobjects -- in order to do anything with them in our C function we have\nto convert them to C values. The function `PyArg_ParseTuple()`\nin the Python API checks the argument types and converts them to C\nvalues. It uses a template string to determine the required types of\nthe arguments as well as the types of the C variables into which to\nstore the converted values. More about this later.\n`PyArg_ParseTuple()` returns true (nonzero) if all arguments have\nthe right type and its components have been stored in the variables\nwhose addresses are passed. It returns false (zero) if an invalid\nargument list was passed. In the latter case it also raises an\nappropriate exception by so the calling function can return\n`NULL` immediately (as we saw in the example).\n---\nnode5.html node2.html node3.html node1.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 3349, "url": "https://docs.python.org/{python_version}/python-ext/node4.html"}
{"title": "Intermezzo: Errors and Exceptions", "text": "---\nnode6.html node2.html node4.html node1.html\n---\n# Intermezzo: Errors and Exceptions\nAn important convention throughout the Python interpreter is the\nfollowing: when a function fails, it should set an exception condition\nand return an error value (usually a `NULL` pointer). Exceptions\nare stored in a static global variable inside the interpreter; if this\nvariable is `NULL` no exception has occurred. A second global\nvariable stores the ``associated value'' of the exception (the second\nargument to `raise`). A third variable contains the stack\ntraceback in case the error originated in Python code. These three\nvariables are the C equivalents of the Python variables\n`sys.exc_type`, `sys.exc_value` and `sys.exc_traceback`\n(see the section on module `sys` in the Library Reference\nManual). It is important to know about them to understand how errors\nare passed around.\nThe Python API defines a number of functions to set various types of\nexceptions.\nThe most common one is `PyErr_SetString()`. Its arguments are an\nexception object and a C string. The exception object is usually a\npredefined object like `PyExc_ZeroDivisionError`. The C string\nindicates the cause of the error and is converted to a Python string\nobject and stored as the ``associated value'' of the exception.\nAnother useful function is `PyErr_SetFromErrno()`, which only\ntakes an exception argument and constructs the associated value by\ninspection of the (Unix) global variable `errno`. The most\ngeneral function is `PyErr_SetObject()`, which takes two object\narguments, the exception and its associated value. You don't need to\n`Py_INCREF()` the objects passed to any of these functions.\nYou can test non-destructively whether an exception has been set with\n`PyErr_Occurred()`. This returns the current exception object,\nor `NULL` if no exception has occurred. You normally don't need\nto call `PyErr_Occurred()` to see whether an error occurred in a\nfunction call, since you should be able to tell from the return value.\nWhen a function f that calls another function varg detects\nthat the latter fails, f should itself return an error value\n(e.g. `NULL` or `-1`). It should not call one of the\n`PyErr_*()` functions --- one has already been called by g.\nf's caller is then supposed to also return an error indication\nto its caller, again without calling `PyErr_*()`,\nand so on --- the most detailed cause of the error was already\nreported by the function that first detected it. Once the error\nreaches the Python interpreter's main loop, this aborts the currently\nexecuting Python code and tries to find an exception handler specified\nby the Python programmer.\n(There are situations where a module can actually give a more detailed\nerror message by calling another `PyErr_*()` function, and in\nsuch cases it is fine to do so. As a general rule, however, this is\nnot necessary, and can cause information about the cause of the error\nto be lost: most operations can fail for a variety of reasons.)\nTo ignore an exception set by a function call that failed, the exception\ncondition must be cleared explicitly by calling `PyErr_Clear()`.\nThe only time C code should call `PyErr_Clear()` is if it doesn't\nwant to pass the error on to the interpreter but wants to handle it\ncompletely by itself (e.g. by trying something else or pretending\nnothing happened).\nNote that a failing `malloc()` call must be turned into an\nexception --- the direct caller of `malloc()` (or\n`realloc()`) must call `PyErr_NoMemory()` and return a\nfailure indicator itself. All the object-creating functions\n(`PyInt_FromLong()` etc.) already do this, so only if you call\n`malloc()` directly this note is of importance.\nAlso note that, with the important exception of\n`PyArg_ParseTuple()` and friends, functions that return an\ninteger status usually return a positive value or zero for success and\n`-1` for failure, like Unix system calls.\nFinally, be careful to clean up garbage (by making `Py_XDECREF()`\nor `Py_DECREF()` calls for objects you have already created) when\nyou return an error indicator!\nThe choice of which exception to raise is entirely yours. There are\npredeclared C objects corresponding to all built-in Python exceptions,\ne.g. `PyExc_ZeroDevisionError` which you can use directly. Of\ncourse, you should choose exceptions wisely --- don't use\n`PyExc_TypeError` to mean that a file couldn't be opened (that\nshould probably be `PyExc_IOError`). If something's wrong with\nthe argument list, the `PyArg_ParseTuple()` function usually\nraises `PyExc_TypeError`. If you have an argument whose value\nwhich must be in a particular range or must satisfy other conditions,\n`PyExc_ValueError` is appropriate.\nYou can also define a new exception that is unique to your module.\nFor this, you usually declare a static object variable at the\nbeginning of your file, e.g.\n```text\nstatic PyObject *SpamError;\n```\nand initialize it in your module's initialization function\n(`initspam()`) with a string object, e.g. (leaving out the error\nchecking for now):\n```text\nvoid\ninitspam()\n{\nPyObject *m, *d;\nm = Py_InitModule(\"spam\", SpamMethods);\nd = PyModule_GetDict(m);\nSpamError = PyString_FromString(\"spam.error\");\nPyDict_SetItemString(d, \"error\", SpamError);\n}\n```\nNote that the Python name for the exception object is\n`spam.error`. It is conventional for module and exception names\nto be spelled in lower case. It is also conventional that the\nvalue of the exception object is the same as its name, e.g.\\\nthe string `\"spam.error\"`.\n---\nnode6.html node2.html node4.html node1.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 5544, "url": "https://docs.python.org/{python_version}/python-ext/node5.html"}
{"title": "Back to the Example", "text": "---\nnode7.html node2.html node5.html node1.html\n---\n# Back to the Example\nGoing back to our example function, you should now be able to\nunderstand this statement:\n```text\nif (!PyArg_ParseTuple(args, \"s\", &command))\nreturn NULL;\n```\nIt returns `NULL` (the error indicator for functions returning\nobject pointers) if an error is detected in the argument list, relying\non the exception set by `PyArg_ParseTuple()`. Otherwise the\nstring value of the argument has been copied to the local variable\n`command`. This is a pointer assignment and you are not supposed\nto modify the string to which it points (so in Standard C, the variable\n`command` should properly be declared as const char\n*command).\nThe next statement is a call to the ' function `system()`,\npassing it the string we just got from `PyArg_ParseTuple()`:\n```text\nsts = system(command);\n```\nOur `spam.system()` function must return the value of `sys`\nas a Python object. This is done using the function\n`Py_BuildValue()`, which is something like the inverse of\n`PyArg_ParseTuple()`: it takes a format string and an arbitrary\nnumber of C values, and returns a new Python object. More info on\n`Py_BuildValue()` is given later.\n```text\nreturn Py_BuildValue(\"i\", sts);\n```\nIn this case, it will return an integer object. (Yes, even integers\nare objects on the heap in Python!)\nIf you have a C function that returns no useful argument (a function\nreturning `void`), the corresponding Python function must return\n`None`. You need this idiom to do so:\n```text\nPy_INCREF(Py_None);\nreturn Py_None;\n```\n`Py_None` is the C name for the special Python object\n`None`. It is a genuine Python object (not a `NULL`\npointer, which means ``error'' in most contexts, as we have seen).\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1739, "url": "https://docs.python.org/{python_version}/python-ext/node6.html"}
{"title": "The Module's Method Table and Initialization Function", "text": "---\nnode8.html node2.html node6.html node1.html\n---\n# The Module's Method Table and Initialization Function\nI promised to show how `spam_system()` is called from Python\nprograms. First, we need to list its name and address in a ``method\ntable'':\n```text\nstatic PyMethodDef SpamMethods[] = {\n...\n{\"system\", spam_system, 1},\n...\n{NULL, NULL} /* Sentinel */\n};\n```\nNote the third entry (`1'). This is a flag telling the\ninterpreter the calling convention to be used for the C function. It\nshould normally always be `1'; a value of `0' means that an\nobsolete variant of `PyArg_ParseTuple()` is used.\nThe method table must be passed to the interpreter in the module's\ninitialization function (which should be the only non-`static`\nitem defined in the module file):\n```text\nvoid\ninitspam()\n{\n(void) Py_InitModule(\"spam\", SpamMethods);\n}\n```\nWhen the Python program imports module `spam` for the first time,\n`initspam()` is called. It calls `Py_InitModule()`, which\ncreates a ``module object'' (which is inserted in the dictionary\n`sys.modules` under the key `\"spam\"`), and inserts built-in\nfunction objects into the newly created module based upon the table\n(an array of `PyMethodDef` structures) that was passed as its\nsecond argument. `Py_InitModule()` returns a pointer to the\nmodule object that it creates (which is unused here). It aborts with\na fatal error if the module could not be initialized satisfactorily,\nso the caller doesn't need to check for errors.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1476, "url": "https://docs.python.org/{python_version}/python-ext/node7.html"}
{"title": "Compilation and Linkage", "text": "---\nnode9.html node2.html node7.html node1.html\n---\n# Compilation and Linkage\nThere are two more things to do before you can use your new extension:\ncompiling and linking it with the Python system. If you use dynamic\nloading, the details depend on the style of dynamic loading your\nsystem uses; see the chapter on Dynamic Loading for more info about\nthis.\nIf you can't use dynamic loading, or if you want to make your module a\npermanent part of the Python interpreter, you will have to change the\nconfiguration setup and rebuild the interpreter. Luckily, this is\nvery simple: just place your file (``spammodule.c`' for example) in\nthe ``Modules`' directory, add a line to the file\n``Modules/Setup`' describing your file:\n```text\nspam spammodule.o\n```\nand rebuild the interpreter by running `make` in the toplevel\ndirectory. You can also run `make` in the ``Modules`'\nsubdirectory, but then you must first rebuilt the ``Makefile`'\nthere by running `make Makefile`. (This is necessary each time\nyou change the ``Setup`' file.)\nIf your module requires additional libraries to link with, these can\nbe listed on the line in the ``Setup`' file as well, for instance:\n```text\nspam spammodule.o -lX11\n```\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1213, "url": "https://docs.python.org/{python_version}/python-ext/node8.html"}
{"title": "Calling Python Functions From C", "text": "---\nnode10.html node2.html node8.html node1.html\n---\n# Calling Python Functions From C\nSo far we have concentrated on making C functions callable from\nPython. The reverse is also useful: calling Python functions from C.\nThis is especially the case for libraries that support so-called\n``callback'' functions. If a C interface makes use of callbacks, the\nequivalent Python often needs to provide a callback mechanism to the\nPython programmer; the implementation will require calling the Python\ncallback functions from a C callback. Other uses are also imaginable.\nFortunately, the Python interpreter is easily called recursively, and\nthere is a standard interface to call a Python function. (I won't\ndwell on how to call the Python parser with a particular string as\ninput --- if you're interested, have a look at the implementation of\nthe `-c' command line option in ``Python/pythonmain.c`'.)\nCalling a Python function is easy. First, the Python program must\nsomehow pass you the Python function object. You should provide a\nfunction (or some other interface) to do this. When this function is\ncalled, save a pointer to the Python function object (be careful to\n`Py_INCREF()` it!) in a global variable --- or whereever you see fit.\nFor example, the following function might be part of a module\ndefinition:\n```text\nstatic PyObject *my_callback = NULL;\n\nstatic PyObject *\nmy_set_callback(dummy, arg)\nPyObject *dummy, *arg;\n{\nPy_XDECREF(my_callback); /* Dispose of previous callback */\nPy_XINCREF(arg); /* Add a reference to new callback */\nmy_callback = arg; /* Remember new callback */\n/* Boilerplate to return \"None\" */\nPy_INCREF(Py_None);\nreturn Py_None;\n}\n```\nThe macros `Py_XINCREF()` and `Py_XDECREF()` increment/decrement\nthe reference count of an object and are safe in the presence of\n`NULL` pointers. More info on them in the section on Reference\nCounts below.\nLater, when it is time to call the function, you call the C function\n`PyEval_CallObject()`. This function has two arguments, both\npointers to arbitrary Python objects: the Python function, and the\nargument list. The argument list must always be a tuple object, whose\nlength is the number of arguments. To call the Python function with\nno arguments, pass an empty tuple; to call it with one argument, pass\na singleton tuple. `Py_BuildValue()` returns a tuple when its\nformat string consists of zero or more format codes between\nparentheses. For example:\n```text\nint arg;\nPyObject *arglist;\nPyObject *result;\n...\narg = 123;\n...\n/* Time to call the callback */\narglist = Py_BuildValue(\"(i)\", arg);\nresult = PyEval_CallObject(my_callback, arglist);\nPy_DECREF(arglist);\n```\n`PyEval_CallObject()` returns a Python object pointer: this is\nthe return value of the Python function. `PyEval_CallObject()` is\n``reference-count-neutral'' with respect to its arguments. In the\nexample a new tuple was created to serve as the argument list, which\nis `Py_DECREF()`-ed immediately after the call.\nThe return value of `PyEval_CallObject()` is ``new'': either it\nis a brand new object, or it is an existing object whose reference\ncount has been incremented. So, unless you want to save it in a\nglobal variable, you should somehow `Py_DECREF()` the result,\neven (especially!) if you are not interested in its value.\nBefore you do this, however, it is important to check that the return\nvalue isn't `NULL`. If it is, the Python function terminated by raising\nan exception. If the C code that called `PyEval_CallObject()` is\ncalled from Python, it should now return an error indication to its\nPython caller, so the interpreter can print a stack trace, or the\ncalling Python code can handle the exception. If this is not possible\nor desirable, the exception should be cleared by calling\n`PyErr_Clear()`. For example:\n```text\nif (result == NULL)\nreturn NULL; /* Pass error back */\n...use result...\nPy_DECREF(result);\n```\nDepending on the desired interface to the Python callback function,\nyou may also have to provide an argument list to `PyEval_CallObject()`.\nIn some cases the argument list is also provided by the Python\nprogram, through the same interface that specified the callback\nfunction. It can then be saved and used in the same manner as the\nfunction object. In other cases, you may have to construct a new\ntuple to pass as the argument list. The simplest way to do this is to\ncall `Py_BuildValue()`. For example, if you want to pass an integral\nevent code, you might use the following code:\n```text\nPyObject *arglist;\n...\narglist = Py_BuildValue(\"(l)\", eventcode);\nresult = PyEval_CallObject(my_callback, arglist);\nPy_DECREF(arglist);\nif (result == NULL)\nreturn NULL; /* Pass error back */\n/* Here maybe use the result */\nPy_DECREF(result);\n```\nNote the placement of `Py_DECREF(argument)` immediately after the call,\nbefore the error check! Also note that strictly spoken this code is\nnot complete: `Py_BuildValue()` may run out of memory, and this should\nbe checked.\n---\nnode10.html node2.html node8.html node1.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 4996, "url": "https://docs.python.org/{python_version}/python-ext/node9.html"}
{"title": "__builtin__ -- Python library reference", "text": "__builtin__ -- Python library reference\nPrev: imp (imp.html)\nTop: Top (top.html)\n# 3.9. Built-in Module `__builtin__`\nThis module provides direct access to all `built-in' identifiers of\nPython; e.g. `__builtin__.open` is the full name for the built-in\nfunction `open`.  See the section on Built-in Functions in the\nprevious chapter.", "python_version": "1.2", "length": 332, "url": "https://docs.python.org/{python_version}/python-lib/__builtin__.html"}
{"title": "__main__ -- Python library reference", "text": "__main__ -- Python library reference\nPrev: __builtin__ (__builtin__.html)\nTop: Top (top.html)\n# 3.10. Built-in Module `__main__`\nThis module represents the (otherwise anonymous) scope in which the\ninterpreter's main program executes --- commands read either from\nstandard input or from a script file.", "python_version": "1.2", "length": 300, "url": "https://docs.python.org/{python_version}/python-lib/__main__.html"}
{"title": "aifc -- Python library reference", "text": "aifc -- Python library reference\nPrev: imageop (imageop.html)\nTop: Top (top.html)\n# 12.3. Standard Module `aifc`\nThis module provides support for reading and writing AIFF and AIFF-C\nfiles.  AIFF is Audio Interchange File Format, a format for storing\ndigital audio samples in a file.  AIFF-C is a newer version of the\nformat that includes the ability to compress the audio data.\nAudio files have a number of parameters that describe the audio data.\nThe sampling rate or frame rate is the number of times per second the\nsound is sampled. The number of channels indicate if the audio is\nmono, stereo, or quadro. Each frame consists of one sample per\nchannel. The sample size is the size in bytes of each sample. Thus a\nframe consists of nchannels*samplesize bytes, and a\nsecond's worth of audio consists of\nnchannels*samplesize*framerate bytes.\nFor example, CD quality audio has a sample size of two bytes (16\nbits), uses two channels (stereo) and has a frame rate of 44,100\nframes/second. This gives a frame size of 4 bytes (2*2), and a\nsecond's worth occupies 2*2*44100 bytes, i.e. 176,400 bytes.\nModule `aifc` defines the following function:\nObjects returned by `aifc.open()` when a file is opened for\nreading have the following methods:\nObjects returned by `aifc.open()` when a file is opened for\nwriting have all the above methods, except for `readframes` and\n`setpos`. In addition the following methods exist. The\n`get` methods can only be called after the corresponding\n`set` methods have been called. Before the first\n`writeframes` or `writeframesraw`, all parameters except for\nthe number of frames must be filled in.", "python_version": "1.2", "length": 1623, "url": "https://docs.python.org/{python_version}/python-lib/aifc.html"}
{"title": "al -- Python library reference", "text": "al -- Python library reference\nPrev: SGI IRIX Specific Services (sgi_irix_specific_services.html)\nTop: Top (top.html)\n# 16.1. Built-in Module `al`\nThis module provides access to the audio facilities of the SGI Indy\nand Indigo workstations.  See section 3A of the IRIX man pages for\ndetails.  You'll need to read those man pages to understand what these\nfunctions do!  Some of the functions are not available in IRIX\nreleases before 4.0.5.  Again, see the manual to check whether a\nspecific function is available on your platform.\nAll functions and methods defined in this module are equivalent to\nthe C functions with `AL' prefixed to their name.\nSymbolic constants from the C header file <audio.h> are defined\nin the standard module `AL`, see below.\nWarning: the current version of the audio library may dump core\nwhen bad argument values are passed rather than returning an error\nstatus. Unfortunately, since the precise circumstances under which\nthis may happen are undocumented and hard to check, the Python\ninterface can provide no protection against this kind of problems.\n(One example is specifying an excessive queue size --- there is no\ndocumented upper limit.)\nThe module defines the following functions:\n## Menu", "python_version": "1.2", "length": 1222, "url": "https://docs.python.org/{python_version}/python-lib/al.html"}
{"title": "AL (uppercase) -- Python library reference", "text": "AL (uppercase) -- Python library reference\nPrev: al (al.html)\nTop: Top (top.html)\n# 16.2. Standard Module `AL`\nThis module defines symbolic constants needed to use the built-in\nmodule `al` (see above); they are equivalent to those defined in\nthe C header file <audio.h> except that the name prefix\n`AL_' is omitted.  Read the module source for a complete list of\nthe defined names.  Suggested use:", "python_version": "1.2", "length": 397, "url": "https://docs.python.org/{python_version}/python-lib/al__uppercase_.html"}
{"title": "alias objects -- Python library reference", "text": "alias objects -- Python library reference\nPrev: FSSpec objects (fsspec_objects.html)\nTop: Top (top.html)\n## 14.6.2. alias objects\nNote that it is currently not possible to directly manipulate a resource\nas an alias object. Hence, after calling Update or after\nResolve indicates that the alias has changed the Python program\nis responsible for getting the data from the alias object and\nmodifying the resource.", "python_version": "1.2", "length": 409, "url": "https://docs.python.org/{python_version}/python-lib/alias_objects.html"}
{"title": "array -- Python library reference", "text": "array -- Python library reference\nPrev: whrandom (whrandom.html)\nTop: Top (top.html)\n# 5.4. Built-in Module `array`\nThis module defines a new object type which can efficiently represent\nan array of basic values: characters, integers, floating point\nnumbers.  Arrays are sequence types and behave very much like lists,\nexcept that the type of objects stored in them is constrained.  The\ntype is specified at object creation time by using a type code,\nwhich is a single character.  The following type codes are defined:\nThe actual representation of values is determined by the machine\narchitecture (strictly speaking, by the C implementation). The actual\nsize can be accessed through the itemsize attribute.\nSee also built-in module `struct`.\nThe module defines the following function:\nArray objects support the following data items and methods:\nWhen an array object is printed or converted to a string, it is\nrepresented as `array( typecode , initializer )`. The\ninitializer is omitted if the array is empty, otherwise it is a\nstring if the typecode is `'c'`, otherwise it is a list of\nnumbers. The string is guaranteed to be able to be converted back to\nan array with the same type and value using reverse quotes\n(````). Examples:", "python_version": "1.2", "length": 1230, "url": "https://docs.python.org/{python_version}/python-lib/array.html"}
{"title": "Audio Device Objects -- Python library reference", "text": "Audio Device Objects -- Python library reference\nPrev: sunaudiodev (sunaudiodev.html)\nTop: Top (top.html)\n## 17.1.1. Audio Device Objects\nThe audio device objects are returned by `open` define the\nfollowing methods (except `control` objects which only provide\ngetinfo, setinfo and drain):\nThere is a companion module, `SUNAUDIODEV`, which defines useful\nsymbolic constants like `MIN_GAIN`, `MAX_GAIN`,\n`SPEAKER`, etc. The names of\nthe constants are the same names as used in the C include file\n<sun/audioio.h>, with the leading string `AUDIO_' stripped.\nUseability of the control device is limited at the moment, since there\nis no way to use the ``wait for something to happen'' feature the\ndevice provides.", "python_version": "1.2", "length": 707, "url": "https://docs.python.org/{python_version}/python-lib/audio_device_objects.html"}
{"title": "audioop -- Python library reference", "text": "audioop -- Python library reference\nPrev: Multimedia Services (multimedia_services.html)\nTop: Top (top.html)\n# 12.1. Built-in Module `audioop`\nThe `audioop` module contains some useful operations on sound fragments.\nIt operates on sound fragments consisting of signed integer samples\n8, 16 or 32 bits wide, stored in Python strings.  This is the same\nformat as used by the `al` and `sunaudiodev` modules.  All\nscalar items are integers, unless specified otherwise.\nA few of the more complicated operations only take 16-bit samples,\notherwise the sample size (in bytes) is always a parameter of the operation.\nThe module defines the following variables and functions:\nNote that operations such as `mul` or `max` make no\ndistinction between mono and stereo fragments, i.e. all samples are\ntreated equal. If this is a problem the stereo fragment should be split\ninto two mono fragments first and recombined later. Here is an example\nof how to do that:\nIf you use the ADPCM coder to build network packets and you want your\nprotocol to be stateless (i.e. to be able to tolerate packet loss)\nyou should not only transmit the data but also the state. Note that\nyou should send the initial state (the one you passed to\n`lin2adpcm`) along to the decoder, not the final state (as returned by\nthe coder). If you want to use `struct` to store the state in\nbinary you can code the first element (the predicted value) in 16 bits\nand the second (the delta index) in 8.\nThe ADPCM coders have never been tried against other ADPCM coders,\nonly against themselves. It could well be that I misinterpreted the\nstandards in which case they will not be interoperable with the\nrespective standards.\nThe `find...` routines might look a bit funny at first sight.\nThey are primarily meant to do echo cancellation. A reasonably\nfast way to do this is to pick the most energetic piece of the output\nsample, locate that in the input sample and subtract the whole output\nsample from the input sample:", "python_version": "1.2", "length": 1969, "url": "https://docs.python.org/{python_version}/python-lib/audioop.html"}
{"title": "Bit-string Operations -- Python library reference", "text": "Bit-string Operations -- Python library reference\nPrev: Numeric Types (numeric_types.html)\nTop: Top (top.html)\n### 2.1.4.1. Bit-string Operations on Integer Types\nPlain and long integer types support additional operations that make\nsense only for bit-strings.  Negative numbers are treated as their 2's\ncomplement value (for long integers, this assumes a sufficiently large\nnumber of bits that no overflow occurs during the operation).\nThe priorities of the binary bit-wise operations are all lower than\nthe numeric operations and higher than the comparisons; the unary\noperation `~' has the same priority as the other unary numeric\noperations (`+' and `-').\nThis table lists the bit-string operations sorted in ascending\npriority (operations in the same box have the same priority):\nNotes:", "python_version": "1.2", "length": 790, "url": "https://docs.python.org/{python_version}/python-lib/bit-string_operations.html"}
{"title": "Bitmap Objects -- Python library reference", "text": "Bitmap Objects -- Python library reference\nPrev: Menu Objects (menu_objects.html)\nTop: Top (top.html)\n## 15.1.5. Bitmap Objects\nA bitmap represents a rectangular array of bits.\nThe top left bit has coordinate (0, 0).\nA bitmap can be drawn with the `bitmap` method of a drawing object.\nBitmaps are currently not available on the Macintosh.\nThe following methods are defined:", "python_version": "1.2", "length": 373, "url": "https://docs.python.org/{python_version}/python-lib/bitmap_objects.html"}
{"title": "Boolean Operations -- Python library reference", "text": "Boolean Operations -- Python library reference\nPrev: Truth Value Testing (truth_value_testing.html)\nTop: Top (top.html)\n## 2.1.2. Boolean Operations\nThese are the Boolean operations, ordered by ascending priority:\n Notes:", "python_version": "1.2", "length": 221, "url": "https://docs.python.org/{python_version}/python-lib/boolean_operations.html"}
{"title": "Built-in Functions -- Python library reference", "text": "Built-in Functions -- Python library reference\nPrev: Exceptions (exceptions.html)\nTop: Top (top.html)\n# 2.3. Built-in Functions\nThe Python interpreter has a number of functions built into it that\nare always available.  They are listed here in alphabetical order.\n## ---------- Footnotes ----------\n(1) (#footnoteref1)\nIt is used relatively rarely\nso does not warrant being made into a statement.\n(2) (#footnoteref2)\nThis is ugly --- the\nlanguage definition should require truncation towards zero.\n(3) (#footnoteref3)\nSpecifying a buffer size currently has no effect on systems\nthat don't have `setvbuf()`. The interface to specify the buffer\nsize is not done using a method that calls `setvbuf()`, because\nthat may dump core when called after any I/O has been performed, and\nthere's no reliable way to determine whether this is the case.\n(4) (#footnoteref4)\nIn the current implementation, local variable bindings\ncannot normally be affected this way, but variables retrieved from\nother scopes (e.g. modules) can be. This may change.", "python_version": "1.2", "length": 1032, "url": "https://docs.python.org/{python_version}/python-lib/built-in_functions.html"}
{"title": "Built-in Objects -- Python library reference", "text": "Built-in Objects -- Python library reference\nPrev: Introduction (introduction.html)\nTop: Top (top.html)\n# 2. Built-in Types, Exceptions and Functions\nNames for built-in exceptions and functions are found in a separate\nsymbol table.  This table is searched last when the interpreter looks\nup the meaning of a name, so local and global\nuser-defined names can override built-in names.  Built-in types are\ndescribed together here for easy reference.(1) (#footnotetext1)\nThe tables in this chapter document the priorities of operators by\nlisting them in order of ascending priority (within a table) and\ngrouping operators that have the same priority in the same box.\nBinary operators of the same priority group from left to right.\n(Unary operators group from right to left, but there you have no real\nchoice.)  See Chapter 5 of the Python Reference Manual for the\ncomplete picture on operator priorities.\n## Menu\n## ---------- Footnotes ----------\n(1) (#footnoteref1)\nMost descriptions sorely lack explanations of the exceptions\nthat may be raised --- this will be fixed in a future version of\nthis manual.", "python_version": "1.2", "length": 1101, "url": "https://docs.python.org/{python_version}/python-lib/built-in_objects.html"}
{"title": "Calibration -- Python library reference", "text": "Calibration -- Python library reference\nPrev: Limitations (limitations.html)\nTop: Top (top.html)\n# 10.7. Calibration\nThe profiler class has a hard coded constant that is added to each\nevent handling time to compensate for the overhead of calling the time\nfunction, and socking away the results.  The following procedure can\nbe used to obtain this constant for a given platform (see discussion\nin section Limitations above).\nThe argument to calibrate() is the number of times to try to do the\nsample calls to get the CPU times. If your computer is very\nfast, you might have to do:\nor even:\nThe object of this exercise is to get a fairly consistent result.\nWhen you have a consistent answer, you are ready to use that number in\nthe source code. For a Sun Sparcstation 1000 running Solaris 2.3, the\nmagical number is about .00053. If you have a choice, you are better\noff with a smaller constant, and your results will ``less often'' show\nup as negative in profile statistics.\nThe following shows how the trace_dispatch() method in the Profile\nclass should be modified to install the calibration constant on a Sun\nSparcstation 1000:\nNote that if there is no calibration constant, then the line\ncontaining the callibration constant should simply say:\nYou can also achieve the same results using a derived class (and the\nprofiler will actually run equally fast!!), but the above method is\nthe simplest to use. I could have made the profiler ``self\ncalibrating'', but it would have made the initialization of the\nprofiler class slower, and would have required some very fancy\ncoding, or else the use of a variable where the constant `.00053'\nwas placed in the code shown. This is a VERY critical\nperformance section, and there is no reason to use a variable lookup\nat this point, when a constant can be used.", "python_version": "1.2", "length": 1802, "url": "https://docs.python.org/{python_version}/python-lib/calibration.html"}
{"title": "cd -- Python library reference", "text": "cd -- Python library reference\nPrev: AL (uppercase) (al__uppercase_.html)\nTop: Top (top.html)\n# 16.3. Built-in Module `cd`\nThis module provides an interface to the Silicon Graphics CD library.\nIt is available only on Silicon Graphics systems.\nThe way the library works is as follows. A program opens the CD-ROM\ndevice with `cd.open()` and creates a parser to parse the data\nfrom the CD with `cd.createparser()`. The object returned by\n`cd.open()` can be used to read data from the CD, but also to get\nstatus information for the CD-ROM device, and to get information about\nthe CD, such as the table of contents. Data from the CD is passed to\nthe parser, which parses the frames, and calls any callback\nfunctions that have previously been added.\nAn audio CD is divided into tracks or programs (the terms\nare used interchangeably). Tracks can be subdivided into\nindices. An audio CD contains a table of contents which\ngives the starts of the tracks on the CD. Index 0 is usually the\npause before the start of a track. The start of the track as given by\nthe table of contents is normally the start of index 1.\nPositions on a CD can be represented in two ways. Either a frame\nnumber or a tuple of three values, minutes, seconds and frames. Most\nfunctions use the latter representation. Positions can be both\nrelative to the beginning of the CD, and to the beginning of the\ntrack.\nModule `cd` defines the following functions and constants:\nThe module defines the following variables:\nThe following variables are states as returned by `getstatus`:\nPlayer objects (returned by `cd.open()`) have the following\nmethods:\nParser objects (returned by `cd.createparser()`) have the\nfollowing methods:", "python_version": "1.2", "length": 1686, "url": "https://docs.python.org/{python_version}/python-lib/cd.html"}
{"title": "cgi -- Python library reference", "text": "cgi -- Python library reference\nPrev: Internet and WWW (internet_and_www.html)\nTop: Top (top.html)\n# 11.1. Standard Module `cgi`\nThis module makes it easy to write Python scripts that run in a WWW\nserver using the Common Gateway Interface.  It was written by Michael\nMcLay and subsequently modified by Steve Majewski and Guido van\nRossum.\nWhen a WWW server finds that a URL contains a reference to a file in a\nparticular subdirectory (usually `/cgibin`), it runs the file as\na subprocess. Information about the request such as the full URL, the\noriginating host etc., is passed to the subprocess in the shell\nenvironment; additional input from the client may be read from\nstandard input. Standard output from the subprocess is sent back\nacross the network to the client as the response from the request.\nThe CGI protocol describes what the environment variables passed to\nthe subprocess mean and how the output should be formatted. The\nofficial reference documentation for the CGI protocol can be found on\nthe World-Wide Web at\n`<URL:http://hoohoo.ncsa.uiuc.edu/cgi/overview.html>`. The\n`cgi` module was based on version 1.1 of the protocol and should\nalso work with version 1.0.\nThe `cgi` module defines several classes that make it easy to\naccess the information passed to the subprocess from a Python script;\nin particular, it knows how to parse the input sent by an HTML\n``form'' using either a POST or a GET request (these are alternatives\nfor submitting forms in the HTTP protocol).\nThe formatting of the output is so trivial that no additional support\nis needed. All you need to do is print a minimal set of MIME headers\ndescribing the output format, followed by a blank line and your actual\noutput. E.g. if you want to generate HTML, your script could start as\nfollows:\nThe server will add some header lines of its own, but it won't touch\nthe output following the header.\nThe `cgi` module defines the following functions:\nThe module defines the following classes. Since the base class\ninitializes itself by calling `parse()`, at most one instance of\nat most one of these classes should be created per script invocation:\n(It currently defines some more classes, but these are experimental\nand/or obsolescent, and are thus not documented --- see the source for\nmore informations.)\nThe module defines the following variable:\n## Menu", "python_version": "1.2", "length": 2337, "url": "https://docs.python.org/{python_version}/python-lib/cgi.html"}
{"title": "CGI Example -- Python library reference", "text": "CGI Example -- Python library reference\nPrev: cgi (cgi.html)\nTop: Top (top.html)\n## 11.1.1. Example\nThis example assumes that you have a WWW server up and running,\ne.g. NCSA's `httpd`.\nPlace the following file in a convenient spot in the WWW server's\ndirectory tree. E.g., if you place it in the subdirectory test\nof the root directory and call it test.html, its URL will be\nhttp://yourservername/test/test.html.\nSelecting this file's URL from a forms-capable browser such as Mosaic\nor Netscape will bring up a simple form with two text input fields and\na ``submit'' button.\nBut wait. Before pressing ``submit'', a script that responds to the\nform must also be installed. The test file as shown assumes that the\nscript is called test.py and lives in the server's\n`cgi-bin` directory. Here's the test script:\nThe script should be made executable (`chmod +x script').\nIf the Python interpreter is not located at\n/usr/local/bin/python but somewhere else, the first line of the\nscript should be modified accordingly.\nNow that everything is installed correctly, we can try out the form.\nBring up the test form in your WWW browser, fill in a name and address\nin the form, and press the ``submit'' button. The script should now\nrun and its output is sent back to your browser. This should roughly\nlook as follows:\nTest Form Output\n- • Name: the name you entered\n• Address: the address you entered\nIf you didn't enter a name or address, the corresponding line will be\nmissing (since the browser doesn't send empty form fields to the\nserver).", "python_version": "1.2", "length": 1533, "url": "https://docs.python.org/{python_version}/python-lib/cgi_example.html"}
{"title": "Classes and Instances -- Python library reference", "text": "Classes and Instances -- Python library reference\nPrev: Modules (modules.html)\nTop: Top (top.html)\n### 2.1.7.2. Classes and Class Instances\n(See Chapters 3 and 7 of the Python Reference Manual for these.)", "python_version": "1.2", "length": 204, "url": "https://docs.python.org/{python_version}/python-lib/classes_and_instances.html"}
{"title": "Code Objects -- Python library reference", "text": "Code Objects -- Python library reference\nPrev: Methods (methods.html)\nTop: Top (top.html)\n### 2.1.7.5. Code Objects\nCode objects are used by the implementation to represent\n``pseudo-compiled'' executable Python code such as a function body.\nThey differ from function objects because they don't contain a\nreference to their global execution environment.  Code objects are\nreturned by the built-in `compile()` function and can be\nextracted from function objects through their `func_code`\nattribute.\nA code object can be executed or evaluated by passing it (instead of a\nsource string) to the `exec` statement or the built-in\n`eval()` function.\n(See the Python Reference Manual for more info.)", "python_version": "1.2", "length": 690, "url": "https://docs.python.org/{python_version}/python-lib/code_objects.html"}
{"title": "Comparisons -- Python library reference", "text": "Comparisons -- Python library reference\nPrev: Boolean Operations (boolean_operations.html)\nTop: Top (top.html)\n## 2.1.3. Comparisons\nComparison operations are supported by all objects.  They all have the\nsame priority (which is higher than that of the Boolean operations).\nComparisons can be chained arbitrarily, e.g. `x < y <= z` is\nequivalent to `x < y and y <= z`, except that `y` is\nevaluated only once (but in both cases `z` is not evaluated at\nall when `x < y` is found to be false).\nThis table summarizes the comparison operations:\nNotes:\nObjects of different types, except different numeric types, never\ncompare equal; such objects are ordered consistently but arbitrarily\n(so that sorting a heterogeneous array yields a consistent result).\nFurthermore, some types (e.g., windows) support only a degenerate\nnotion of comparison where any two objects of that type are unequal.\nAgain, such objects are ordered arbitrarily but consistently.\n(Implementation note: objects of different types except numbers are\nordered by their type names; objects of the same types that don't\nsupport proper comparison are ordered by their address.)\nTwo more operations with the same syntactic priority, `in` and\n`not in`, are supported only by sequence types (below).", "python_version": "1.2", "length": 1255, "url": "https://docs.python.org/{python_version}/python-lib/comparisons.html"}
{"title": "Concept Index -- Python library reference", "text": "Concept Index -- Python library reference\nPrev: Module Index (module_index.html)\nTop: Top (top.html)\n# Concept Index", "python_version": "1.2", "length": 116, "url": "https://docs.python.org/{python_version}/python-lib/concept_index.html"}
{"title": "Configuration Objects -- Python library reference", "text": "Configuration Objects -- Python library reference\nPrev: al (al.html)\nTop: Top (top.html)\n## 16.1.1. Configuration Objects\nConfiguration objects (returned by `al.newconfig()` have the\nfollowing methods:", "python_version": "1.2", "length": 201, "url": "https://docs.python.org/{python_version}/python-lib/configuration_objects.html"}
{"title": "connection object -- Python library reference", "text": "connection object -- Python library reference\nPrev: ctb (ctb.html)\nTop: Top (top.html)\n## 14.3.1. connection object\nFor all connection methods that take a timeout argument, a value\nof `-1` is indefinite, meaning that the command runs to completion.", "python_version": "1.2", "length": 248, "url": "https://docs.python.org/{python_version}/python-lib/connection_object.html"}
{"title": "console window object -- Python library reference", "text": "console window object -- Python library reference\nPrev: macconsole options object (macconsole_options_object.html)\nTop: Top (top.html)\n## 14.4.2. console window object", "python_version": "1.2", "length": 167, "url": "https://docs.python.org/{python_version}/python-lib/console_window_object.html"}
{"title": "copy -- Python library reference", "text": "copy -- Python library reference\nPrev: shelve (shelve.html)\nTop: Top (top.html)\n# 3.6. Standard Module `copy`\nThis module provides generic (shallow and deep) copying operations.\nInterface summary:\nFor module specific errors, `copy.error` is raised.\nThe difference between shallow and deep copying is only relevant for\ncompound objects (objects that contain other objects, like lists or\nclass instances):\n- • A shallow copy constructs a new compound object and then (to the\nextent possible) inserts references into it to the objects found\nin the original.\n• A deep copy constructs a new compound object and then,\nrecursively, inserts copies into it of the objects found in the\noriginal.\nTwo problems often exist with deep copy operations that don't exist\nwith shallow copy operations:\n- • Recursive objects (compound objects that, directly or indirectly,\ncontain a reference to themselves) may cause a recursive loop.\n• Because deep copy copies everything it may copy too much, e.g.\nadministrative data structures that should be shared even between\ncopies.\nPython's `deepcopy()` operation avoids these problems by:\n- • keeping a table of objects already copied during the current\ncopying pass; and\n• letting user-defined classes override the copying operation or the\nset of components copied.\nThis version does not copy types like module, class, function, method,\nnor stack trace, stack frame, nor file, socket, window, nor array, nor\nany similar types.\nClasses can use the same interfaces to control copying that they use\nto control pickling: they can define methods called\n`__getinitargs__()`, `__getstate__()` and\n`__setstate__()`. See the description of module `pickle`\nfor information on these methods.", "python_version": "1.2", "length": 1706, "url": "https://docs.python.org/{python_version}/python-lib/copy.html"}
{"title": "Cryptographic Services -- Python library reference", "text": "Cryptographic Services -- Python library reference\nPrev: Multimedia Services (multimedia_services.html)\nTop: Top (top.html)\n# 13. Cryptographic Services\nThe modules described in this chapter implement various algorithms of\na cryptographic nature.  They are available at the discretion of the\ninstallation.  Here's an overview:\nHardcore cypherpunks will probably find the Python Cryptography Kit of\nfurther interest; the package adds built-in modules for DES and IDEA\nencryption, and provides a Python module for reading and decrypting\nPGP files. The Python Cryptography Kit is not distributed with Python\nbut available separately. See the URL\nhttp://www.cs.mcgill.ca/%7Efnord/crypt.html for more information.\n## Menu", "python_version": "1.2", "length": 716, "url": "https://docs.python.org/{python_version}/python-lib/cryptographic_services.html"}
{"title": "ctb -- Python library reference", "text": "ctb -- Python library reference\nPrev: macpath (macpath.html)\nTop: Top (top.html)\n# 14.3. Built-in Module `ctb`\nThis module provides a partial interface to the Macintosh\nCommunications Toolbox. Currently, only Connection Manager tools are\nsupported.  It may not be available in all Mac Python versions.\n## Menu", "python_version": "1.2", "length": 309, "url": "https://docs.python.org/{python_version}/python-lib/ctb.html"}
{"title": "dbm -- Python library reference", "text": "dbm -- Python library reference\nPrev: grp (grp.html)\nTop: Top (top.html)\n# 8.5. Built-in Module `dbm`\nDbm provides python programs with an interface to the unix `ndbm`\ndatabase library.  Dbm objects are of the mapping type, so they can be\nhandled just like objects of the built-in dictionary type,\nexcept that keys and values are always strings, and printing a dbm\nobject doesn't print the keys and values.\nThe module defines the following constant and functions:", "python_version": "1.2", "length": 463, "url": "https://docs.python.org/{python_version}/python-lib/dbm.html"}
{"title": "Debugger Commands -- Python library reference", "text": "Debugger Commands -- Python library reference\nPrev: The Python Debugger (the_python_debugger.html)\nTop: Top (top.html)\n# 9.1. Debugger Commands\nThe debugger recognizes the following commands.  Most commands can be\nabbreviated to one or two letters; e.g. ```h(elp)`'' means that\neither ```h`'' or ```help`'' can be used to enter the help\ncommand (but not ```he`'' or ```hel`'', nor ```H`'' or\n```Help` or ```HELP`'').  Arguments to commands must be\nseparated by whitespace (spaces or tabs).  Optional arguments are\nenclosed in square brackets (```[]`'') in the command syntax; the\nsquare brackets must not be typed.  Alternatives in the command syntax\nare separated by a vertical bar (```|`'').\n\nEntering a blank line repeats the last command entered. Exception: if\nthe last command was a ```list`'' command, the next 11 lines are\nlisted.\n\nCommands that the debugger doesn't recognize are assumed to be Python\nstatements and are executed in the context of the program being\ndebugged. Python statements can also be prefixed with an exclamation\npoint (```!`''). This is a powerful way to inspect the program\nbeing debugged; it is even possible to change a variable or call a\nfunction. When an\nexception occurs in such a statement, the exception name is printed\nbut the debugger's state is not changed.", "python_version": "1.2", "length": 1298, "url": "https://docs.python.org/{python_version}/python-lib/debugger_commands.html"}
{"title": "Deterministic Profiling -- Python library reference", "text": "Deterministic Profiling -- Python library reference\nPrev: Instant Users Manual (instant_users_manual.html)\nTop: Top (top.html)\n# 10.4. What Is Deterministic Profiling?\nDeterministic profiling is meant to reflect the fact that all\nfunction call, function return, and exception events\nare monitored, and precise timings are made for the intervals between\nthese events (during which time the user's code is executing).  In\ncontrast, statistical profiling (which is not done by this\nmodule) randomly samples the effective instruction pointer, and\ndeduces where time is being spent.  The latter technique traditionally\ninvolves less overhead (as the code does not need to be instrumented),\nbut provides only relative indications of where time is being spent.\nIn Python, since there is an interpreter active during execution, the\npresence of instrumented code is not required to do deterministic\nprofiling. Python automatically provides a hook (optional\ncallback) for each event. In addition, the interpreted nature of\nPython tends to add so much overhead to execution, that deterministic\nprofiling tends to only add small processing overhead in typical\napplications. The result is that deterministic profiling is not that\nexpensive, yet provides extensive run time statistics about the\nexecution of a Python program.\nCall count statistics can be used to identify bugs in code (surprising\ncounts), and to identify possible inline-expansion points (high call\ncounts). Internal time statistics can be used to identify ``hot\nloops'' that should be carefully optimized. Cumulative time\nstatistics should be used to identify high level errors in the\nselection of algorithms. Note that the unusual handling of cumulative\ntimes in this profiler allows statistics for recursive implementations\nof algorithms to be directly compared to iterative implementations.", "python_version": "1.2", "length": 1847, "url": "https://docs.python.org/{python_version}/python-lib/deterministic_profiling.html"}
{"title": "dnr result object -- Python library reference", "text": "dnr result object -- Python library reference\nPrev: macdnr (macdnr.html)\nTop: Top (top.html)\n## 14.5.1. dnr result object\nSince the DNR calls all execute asynchronously you do not get the\nresults back immediately.  Instead, you get a dnr result object.  You\ncan check this object to see whether the query is complete, and access\nits attributes to obtain the information when it is.\nAlternatively, you can also reference the result attributes directly,\nthis will result in an implicit wait for the query to complete.\nThe rtnCode and cname attributes are always available, the\nothers depend on the type of query (address, hinfo or mx).\nThe simplest way to use the module to convert names to dotted-decimal\nstrings, without worrying about idle time, etc:", "python_version": "1.2", "length": 751, "url": "https://docs.python.org/{python_version}/python-lib/dnr_result_object.html"}
{"title": "Drawing Objects -- Python library reference", "text": "Drawing Objects -- Python library reference\nPrev: Window Objects (window_objects.html)\nTop: Top (top.html)\n## 15.1.3. Drawing Objects\nDrawing objects are created exclusively by the window method\n`begindrawing()`.\nOnly one drawing object can exist at any given time; the drawing object\nmust be deleted to finish drawing.\nNo drawing object may exist when\n`stdwin.getevent()`\nis called.\nDrawing objects have the following methods:", "python_version": "1.2", "length": 427, "url": "https://docs.python.org/{python_version}/python-lib/drawing_objects.html"}
{"title": "Examples -- Python library reference", "text": "Examples -- Python library reference\nPrev: imp (imp.html)\nTop: Top (top.html)\n## 3.8.1. Examples\nThe following function emulates the default import statement:", "python_version": "1.2", "length": 158, "url": "https://docs.python.org/{python_version}/python-lib/examples.html"}
{"title": "Exceptions -- Python library reference", "text": "Exceptions -- Python library reference\nPrev: Types (types.html)\nTop: Top (top.html)\n# 2.2. Built-in Exceptions\nExceptions are string objects.  Two distinct string objects with the\nsame value are different exceptions.  This is done to force programmers\nto use exception names rather than their string value when specifying\nexception handlers.  The string value of all built-in exceptions is\ntheir name, but this is not a requirement for user-defined exceptions\nor exceptions defined by library modules.\nThe following exceptions can be generated by the interpreter or\nbuilt-in functions. Except where mentioned, they have an `associated\nvalue' indicating the detailed cause of the error. This may be a\nstring or a tuple containing several items of information (e.g., an\nerror code and a string explaining the code).\nUser code can raise built-in exceptions. This can be used to test an\nexception handler or to report an error condition `just like' the\nsituation in which the interpreter raises the same exception; but\nbeware that there is nothing to prevent user code from raising an\ninappropriate error.", "python_version": "1.2", "length": 1101, "url": "https://docs.python.org/{python_version}/python-lib/exceptions.html"}
{"title": "fcntl -- Python library reference", "text": "fcntl -- Python library reference\nPrev: TERMIOS (termios.html)\nTop: Top (top.html)\n# 8.9. Built-in Module `fcntl`\nThis module performs file control and I/O control on file descriptors.\nIt is an interface to the fcntl() and ioctl() UNIX routines.\nFile descriptors can be obtained with the fileno() method of a\nfile or socket object.\nThe module defines the following functions:\nIf the library modules `FCNTL` or `IOCTL` are missing, you\ncan find the opcodes in the C include files `sys/fcntl` and\n`sys/ioctl`. You can create the modules yourself with the h2py\nscript, found in the `Demo/scripts` directory.\nExamples (all on a SVR4 compliant system):\nNote that in the first example the return value variable `rv` will\nhold an integer value; in the second example it will hold a string\nvalue.", "python_version": "1.2", "length": 788, "url": "https://docs.python.org/{python_version}/python-lib/fcntl.html"}
{"title": "File Objects -- Python library reference", "text": "File Objects -- Python library reference\nPrev: The Null Object (the_null_object.html)\nTop: Top (top.html)\n### 2.1.7.8. File Objects\nFile objects are implemented using C's `stdio` package and can be\ncreated with the built-in function `open()` described under\nBuilt-in Functions below.  They are also returned by some other\nbuilt-in functions and methods, e.g. `posix.popen()` and\n`posix.fdopen()` and the `makefile()` method of socket\nobjects.\nWhen a file operation fails for an I/O-related reason, the exception\n`IOError` is raised.  This includes situations where the\noperation is not defined for some reason, like `seek()` on a tty\ndevice or writing a file opened for reading.\nFiles have the following methods:\n## ---------- Footnotes ----------\n(1) (#footnoteref1)\nThe advantage of leaving the newline on is that an empty string\ncan be returned to mean EOF without being ambiguous. Another\nadvantage is that (in cases where it might matter, e.g. if you\nwant to make an exact copy of a file while scanning its lines)\nyou can tell whether the last line of a file ended in a newline\nor not (yes this happens!).", "python_version": "1.2", "length": 1110, "url": "https://docs.python.org/{python_version}/python-lib/file_objects.html"}
{"title": "fl -- Python library reference", "text": "fl -- Python library reference\nPrev: cd (cd.html)\nTop: Top (top.html)\n# 16.4. Built-in Module `fl`\nThis module provides an interface to the FORMS Library by Mark\nOvermars.  The source for the library can be retrieved by anonymous\nftp from host `ftp.cs.ruu.nl', directory SGI/FORMS.  It\nwas last tested with version 2.0b.\nMost functions are literal translations of their C equivalents,\ndropping the initial `fl_' from their name. Constants used by\nthe library are defined in module `FL` described below.\nThe creation of objects is a little different in Python than in C:\ninstead of the `current form' maintained by the library to which new\nFORMS objects are added, all functions that add a FORMS object to a\nform are methods of the Python object representing the form.\nConsequently, there are no Python equivalents for the C functions\n`fl_addto_form` and `fl_end_form`, and the equivalent of\n`fl_bgn_form` is called `fl.make_form`.\nWatch out for the somewhat confusing terminology: FORMS uses the word\nobject for the buttons, sliders etc. that you can place in a form.\nIn Python, `object' means any value. The Python interface to FORMS\nintroduces two new Python object types: form objects (representing an\nentire form) and FORMS objects (representing one button, slider etc.).\nHopefully this isn't too confusing...\nThere are no `free objects' in the Python interface to FORMS, nor is\nthere an easy way to add object classes written in Python. The FORMS\ninterface to GL event handling is available, though, so you can mix\nFORMS with pure GL windows.\nPlease note: importing `fl` implies a call to the GL function\n`foreground()` and to the FORMS routine `fl_init()`.\n## Menu", "python_version": "1.2", "length": 1670, "url": "https://docs.python.org/{python_version}/python-lib/fl.html"}
{"title": "FL (uppercase) -- Python library reference", "text": "FL (uppercase) -- Python library reference\nPrev: fl (fl.html)\nTop: Top (top.html)\n# 16.5. Standard Module `FL`\nThis module defines symbolic constants needed to use the built-in\nmodule `fl` (see above); they are equivalent to those defined in\nthe C header file <forms.h> except that the name prefix\n`FL_' is omitted.  Read the module source for a complete list of\nthe defined names.  Suggested use:", "python_version": "1.2", "length": 397, "url": "https://docs.python.org/{python_version}/python-lib/fl__uppercase_.html"}
{"title": "FL Functions -- Python library reference", "text": "FL Functions -- Python library reference\nPrev: fl (fl.html)\nTop: Top (top.html)\n## 16.4.1. Functions Defined in Module `fl`\nModule `fl` defines the following functions.  For more information\nabout what they do, see the description of the equivalent C function\nin the FORMS documentation:", "python_version": "1.2", "length": 287, "url": "https://docs.python.org/{python_version}/python-lib/fl_functions.html"}
{"title": "flp -- Python library reference", "text": "flp -- Python library reference\nPrev: FL (uppercase) (fl__uppercase_.html)\nTop: Top (top.html)\n# 16.6. Standard Module `flp`\nThis module defines functions that can read form definitions created\nby the `form designer' (`fdesign`) program that comes with the\nFORMS library (see module `fl` above).\nFor now, see the file flp.doc in the Python library source\ndirectory for a description.\nXXX A complete description should be inserted here!", "python_version": "1.2", "length": 435, "url": "https://docs.python.org/{python_version}/python-lib/flp.html"}
{"title": "fm -- Python library reference", "text": "fm -- Python library reference\nPrev: flp (flp.html)\nTop: Top (top.html)\n# 16.7. Built-in Module `fm`\nThis module provides access to the IRIS Font Manager library.\nIt is available only on Silicon Graphics machines.\nSee also: 4Sight User's Guide, Section 1, Chapter 5: Using the IRIS\nFont Manager.\nThis is not yet a full interface to the IRIS Font Manager.\nAmong the unsupported features are: matrix operations; cache\noperations; character operations (use string operations instead); some\ndetails of font info; individual glyph metrics; and printer matching.\nIt supports the following operations:\nFont handle objects support the following operations:", "python_version": "1.2", "length": 648, "url": "https://docs.python.org/{python_version}/python-lib/fm.html"}
{"title": "Form Objects -- Python library reference", "text": "Form Objects -- Python library reference\nPrev: FL Functions (fl_functions.html)\nTop: Top (top.html)\n## 16.4.2. Form Objects\nForm objects (returned by `fl.make_form()` above) have the\nfollowing methods.  Each method corresponds to a C function whose name\nis prefixed with `fl_'; and whose first argument is a form\npointer; please refer to the official FORMS documentation for\ndescriptions.\nAll the `add_...' functions return a Python object representing\nthe FORMS object. Methods of FORMS objects are described below. Most\nkinds of FORMS object also have some methods specific to that kind;\nthese methods are listed here.\nForm objects have the following data attributes; see the FORMS\ndocumentation:", "python_version": "1.2", "length": 698, "url": "https://docs.python.org/{python_version}/python-lib/form_objects.html"}
{"title": "FORMS Objects -- Python library reference", "text": "FORMS Objects -- Python library reference\nPrev: Form Objects (form_objects.html)\nTop: Top (top.html)\n## 16.4.3. FORMS Objects\nBesides methods specific to particular kinds of FORMS objects, all\nFORMS objects also have the following methods:\nFORMS objects have these data attributes; see the FORMS documentation:", "python_version": "1.2", "length": 310, "url": "https://docs.python.org/{python_version}/python-lib/forms_objects.html"}
{"title": "FSSpec objects -- Python library reference", "text": "FSSpec objects -- Python library reference\nPrev: macfs (macfs.html)\nTop: Top (top.html)\n## 14.6.1. FSSpec objects", "python_version": "1.2", "length": 113, "url": "https://docs.python.org/{python_version}/python-lib/fsspec_objects.html"}
{"title": "FTP Objects -- Python library reference", "text": "FTP Objects -- Python library reference\nPrev: ftplib (ftplib.html)\nTop: Top (top.html)\n## 11.4.1. FTP Objects\nFTP instances have the following methods:", "python_version": "1.2", "length": 151, "url": "https://docs.python.org/{python_version}/python-lib/ftp_objects.html"}
{"title": "ftplib -- Python library reference", "text": "ftplib -- Python library reference\nPrev: httplib (httplib.html)\nTop: Top (top.html)\n# 11.4. Standard Module `ftplib`\nThis module defines the class `FTP` and a few related items.  The\n`FTP` class implements the client side of the FTP protocol.  You\ncan use this to write Python programs that perform a variety of\nautomated FTP jobs, such as mirroring other ftp servers.  It is also\nused bu the module `urllib` to handle URLs that use FTP.  For\nmore information on FTP (File Transfer Protocol), see Internet RFC\n959.\nHere's a sample session using the `ftplib` module:\nThe module defines the following items:\n## Menu", "python_version": "1.2", "length": 613, "url": "https://docs.python.org/{python_version}/python-lib/ftplib.html"}
{"title": "Functions -- Python library reference", "text": "Functions -- Python library reference\nPrev: Classes and Instances (classes_and_instances.html)\nTop: Top (top.html)\n### 2.1.7.3. Functions\nFunction objects are created by function definitions.  The only\noperation on a function object is to call it:\n`func ( argument-list )`.\nThere are really two flavors of function objects: built-in functions\nand user-defined functions. Both support the same operation (to call\nthe function), but the implementation is different, hence the\ndifferent object types.\nThe implementation adds two special read-only attributes:\n`f .func_code` is a function's code object (see below) and\n`f .func_globals` is the dictionary used as the function's\nglobal name space (this is the same as `m .__dict__` where\nm is the module in which the function f was defined).", "python_version": "1.2", "length": 786, "url": "https://docs.python.org/{python_version}/python-lib/functions.html"}
{"title": "gdbm -- Python library reference", "text": "gdbm -- Python library reference\nPrev: dbm (dbm.html)\nTop: Top (top.html)\n# 8.6. Built-in Module `gdbm`\nGdbm provides python programs with an interface to the GNU `gdbm`\ndatabase library.  Gdbm objects are of the mapping type, so they can be\nhandled just like objects of the built-in dictionary type,\nexcept that keys and values are always strings, and printing a gdbm\nobject doesn't print the keys and values.\nThe module is based on the Dbm module, modified to use GDBM instead.\nThe module defines the following constant and functions:", "python_version": "1.2", "length": 536, "url": "https://docs.python.org/{python_version}/python-lib/gdbm.html"}
{"title": "Generic Operating System Services -- Python library reference", "text": "Generic Operating System Services -- Python library reference\nPrev: Miscellaneous Services (miscellaneous_services.html)\nTop: Top (top.html)\n# 6. Generic Operating System Services\nThe modules described in this chapter provide interfaces to operating\nsystem features that are available on (almost) all operating systems,\nsuch as files and a clock.  The interfaces are generally modelled\nafter the UNIX or C interfaces but they are available on most other\nsystems as well.  Here's an overview:\n## Menu", "python_version": "1.2", "length": 499, "url": "https://docs.python.org/{python_version}/python-lib/generic_operating_system_services.html"}
{"title": "getopt -- Python library reference", "text": "getopt -- Python library reference\nPrev: time (time.html)\nTop: Top (top.html)\n# 6.3. Standard Module `getopt`\nThis module helps scripts to parse the command line arguments in\n`sys.argv`.\nIt uses the same conventions as the UNIX\n`getopt()`\nfunction (including the special meanings of arguments of the form\n`-' and `--').\nIt defines the function\n`getopt.getopt(args, options)`\nand the exception\n`getopt.error`.\nThe first argument to\n`getopt()`\nis the argument list passed to the script with its first element\nchopped off (i.e.,\n`sys.argv[1:]`).\nThe second argument is the string of option letters that the\nscript wants to recognize, with options that require an argument\nfollowed by a colon (i.e., the same format that UNIX\n`getopt()`\nuses).\nThe return value consists of two elements: the first is a list of\noption-and-value pairs; the second is the list of program arguments\nleft after the option list was stripped (this is a trailing slice of the\nfirst argument).\nEach option-and-value pair returned has the option as its first element,\nprefixed with a hyphen (e.g.,\n`'-x'`),\nand the option argument as its second element, or an empty string if the\noption has no argument.\nThe options occur in the list in the same order in which they were\nfound, thus allowing multiple occurrences.\nExample:\nThe exception\n`getopt.error = 'getopt error'`\nis raised when an unrecognized option is found in the argument list or\nwhen an option requiring an argument is given none.\nThe argument to the exception is a string indicating the cause of the\nerror.", "python_version": "1.2", "length": 1537, "url": "https://docs.python.org/{python_version}/python-lib/getopt.html"}
{"title": "gl -- Python library reference", "text": "gl -- Python library reference\nPrev: fm (fm.html)\nTop: Top (top.html)\n# 16.8. Built-in Module `gl`\nThis module provides access to the Silicon Graphics\nGraphics Library.\nIt is available only on Silicon Graphics machines.\nWarning:\nSome illegal calls to the GL library cause the Python interpreter to dump\ncore.\nIn particular, the use of most GL calls is unsafe before the first\nwindow is opened.\nThe module is too large to document here in its entirety, but the\nfollowing should help you to get started.\nThe parameter conventions for the C functions are translated to Python as\nfollows:\n- • All (short, long, unsigned) int values are represented by Python\nintegers.\n• All float and double values are represented by Python floating point\nnumbers.\nIn most cases, Python integers are also allowed.\n• All arrays are represented by one-dimensional Python lists.\nIn most cases, tuples are also allowed.\n• All string and character arguments are represented by Python strings,\nfor instance,\n`winopen('Hi There!')`\nand\n`rotate(900, 'z')`.\n• All (short, long, unsigned) integer arguments or return values that are\nonly used to specify the length of an array argument are omitted.\nFor example, the C call\nis translated to Python as\n• Output arguments are omitted from the argument list; they are\ntransmitted as function return values instead.\nIf more than one value must be returned, the return value is a tuple.\nIf the C function has both a regular return value (that is not omitted\nbecause of the previous rule) and an output argument, the return value\ncomes first in the tuple.\nExamples: the C call\nis translated to Python as\nThe following functions are non-standard or have special argument\nconventions:\nHere is a tiny but complete example GL program in Python:", "python_version": "1.2", "length": 1752, "url": "https://docs.python.org/{python_version}/python-lib/gl.html"}
{"title": "GL and DEVICE -- Python library reference", "text": "GL and DEVICE -- Python library reference\nPrev: gl (gl.html)\nTop: Top (top.html)\n# 16.9. Standard Modules `GL` and `DEVICE`\nThese modules define the constants used by the Silicon Graphics\nGraphics Library\nthat C programmers find in the header files\n<gl/gl.h>\nand\n<gl/device.h>.\nRead the module source files for details.", "python_version": "1.2", "length": 319, "url": "https://docs.python.org/{python_version}/python-lib/gl_and_device.html"}
{"title": "gopherlib -- Python library reference", "text": "gopherlib -- Python library reference\nPrev: ftplib (ftplib.html)\nTop: Top (top.html)\n# 11.5. Standard Module `gopherlib`\nThis module provides a minimal implementation of client side of the\nthe Gopher protocol.  It is used by the module `urllib` to handle\nURLs that use the Gopher protocol.\nThe module defines the following functions:\nNote that the data returned by the Gopher server can be of any type,\ndepending on the first character of the selector string. If the data\nis text (first character of the selector is `0'), lines are\nterminated by CRLF, and the data is terminated by a line consisting of\na single `.', and a leading `.' should be stripped from\nlines that begin with `..'. Directory listings (first charactger\nof the selector is `1') are transferred using the same protocol.", "python_version": "1.2", "length": 788, "url": "https://docs.python.org/{python_version}/python-lib/gopherlib.html"}
{"title": "grp -- Python library reference", "text": "grp -- Python library reference\nPrev: pwd (pwd.html)\nTop: Top (top.html)\n# 8.4. Built-in Module `grp`\nThis module provides access to the UNIX group database.\nIt is available on all UNIX versions.\nGroup database entries are reported as 4-tuples containing the\nfollowing items from the group database (see <grp.h>), in order:\n`gr_name`,\n`gr_passwd`,\n`gr_gid`,\n`gr_mem`.\nThe gid is an integer, name and password are strings, and the member\nlist is a list of strings.\n(Note that most users are not explicitly listed as members of the\ngroup they are in according to the password database.)\nAn exception is raised if the entry asked for cannot be found.\nIt defines the following items:", "python_version": "1.2", "length": 679, "url": "https://docs.python.org/{python_version}/python-lib/grp.html"}
{"title": "HotProfile Class -- Python library reference", "text": "HotProfile Class -- Python library reference\nPrev: OldProfile Class (oldprofile_class.html)\nTop: Top (top.html)\n## 10.8.2. HotProfile Class\nThis profiler is the fastest derived profile example.  It does not\ncalculate caller-callee relationships, and does not calculate\ncumulative time under a function.  It only calculates time spent in a\nfunction, so it runs very quickly (re: very low overhead).  In truth,\nthe basic profiler is so fast, that is probably not worth the savings\nto give up the data, but this class still provides a nice example.", "python_version": "1.2", "length": 545, "url": "https://docs.python.org/{python_version}/python-lib/hotprofile_class.html"}
{"title": "How It Works -- Python library reference", "text": "How It Works -- Python library reference\nPrev: Debugger Commands (debugger_commands.html)\nTop: Top (top.html)\n# 9.2. How It Works\nSome changes were made to the interpreter:\n- • sys.settrace(func) sets the global trace function\n• there can also a local trace function (see later)\nTrace functions have three arguments: (frame, event, arg)\nA trace function should return a new trace function or None.\nClass methods are accepted (and most useful!) as trace methods.\nThe events have the following meaning:\nNote that as an exception is propagated down the chain of callers, an\n`'exception'` event is generated at each level.\nStack frame objects have the following read-only attributes:\nCode objects have the following read-only attributes:", "python_version": "1.2", "length": 733, "url": "https://docs.python.org/{python_version}/python-lib/how_it_works.html"}
{"title": "htmllib -- Python library reference", "text": "htmllib -- Python library reference\nPrev: urlparse (urlparse.html)\nTop: Top (top.html)\n# 11.8. Standard Module `htmllib`\nThis module defines a number of classes which can serve as a basis for\nparsing text files formatted in HTML (HyperText Mark-up Language).\nThe classes are not directly concerned with I/O --- the have to be fed\ntheir input in string form, and will make calls to methods of a\n``formatter'' object in order to produce output.  The classes are\ndesigned to be used as base classes for other classes in order to add\nfunctionality, and allow most of their methods to be extended or\noverridden.  In turn, the classes are derived from and extend the\nclass `SGMLParser` defined in module `sgmllib`.\nThe following is a summary of the interface defined by\n`sgmllib.SGMLParser`:\n- • The interface to feed data to an instance is through the `feed()`\nmethod, which takes a string argument. This can be called with as\nlittle or as much text at a time as desired;\n`p.feed(a); p.feed(b)` has the same effect as `p.feed(a+b)`.\nWhen the data contains complete\nHTML elements, these are processed immediately; incomplete elements\nare saved in a buffer. To force processing of all unprocessed data,\ncall the `close()` method.\nExample: to parse the entire contents of a file, do*\n`parser.feed(open(file).read()); parser.close()`.\n• The interface to define semantics for HTML tags is very simple: derive\na class and define methods called `start_ tag ()`,\n`end_ tag ()`, or `do_ tag ()`. The parser will\ncall these at appropriate moments: `start_ tag` or\n`do_ tag` is called when an opening tag of the form\n`< tag ...>` is encountered; `end_ tag` is called\nwhen a closing tag of the form `< tag >` is encountered. If\nan opening tag requires a corresponding closing tag, like `<H1>`\n... `</H1>`, the class should define the `start_ tag`\nmethod; if a tag requires no closing tag, like `<P>`, the class\nshould define the `do_ tag` method.\nThe module defines the following classes:\nInstances of `CollectingParser` (and thus also instances of\n`FormattingParser` and `AnchoringParser`) have the following\ninstance variables:\nThe `anchors`, `anchornames` and `anchortypes` lists\nare ``parallel arrays'': items in these lists with the same index\npertain to the same anchor. Missing attributes default to the empty\nstring. Anchors with neither a `HREF` nor a `NAME`\nattribute are not entered in these lists at all.\nThe module also defines a number of style sheet classes. These should\nnever be instantiated --- their class variables are the only behavior\nrequired. Note that style sheets are specifically designed for a\nparticular formatter implementation. The currently defined style\nsheets are:\nStyle sheets have the following class variables:\nAlthough no documented implementation of a formatter exists, the\n`FormattingParser` class assumes that formatters have a\ncertain interface. This interface requires the following methods:\nA sample formatter implementation can be found in the module\n`fmt`, which in turn uses the module `Para`. These modules are\nnot intended as standard library modules; they are available as an\nexample of how to write a formatter.", "python_version": "1.2", "length": 3145, "url": "https://docs.python.org/{python_version}/python-lib/htmllib.html"}
{"title": "HTTP Example -- Python library reference", "text": "HTTP Example -- Python library reference\nPrev: HTTP Objects (http_objects.html)\nTop: Top (top.html)\n## 11.3.2. Example\nHere is an example session:", "python_version": "1.2", "length": 146, "url": "https://docs.python.org/{python_version}/python-lib/http_example.html"}
{"title": "HTTP Objects -- Python library reference", "text": "HTTP Objects -- Python library reference\nPrev: httplib (httplib.html)\nTop: Top (top.html)\n## 11.3.1. HTTP Objects\n`HTTP` instances have the following methods:", "python_version": "1.2", "length": 158, "url": "https://docs.python.org/{python_version}/python-lib/http_objects.html"}
{"title": "httplib -- Python library reference", "text": "httplib -- Python library reference\nPrev: urllib (urllib.html)\nTop: Top (top.html)\n# 11.3. Standard Module `httplib`\nThis module defines a class which implements the client side of the\nHTTP protocol.  It is normally not used directly --- the module\n`urllib` uses it to handle URLs that use HTTP.\nThe module defines one class, `HTTP`.  An `HTTP` instance\nrepresents one transaction with an HTTP server.  It should be\ninstantiated passing it a host and optional port number.  If no port\nnumber is passed, the port is extracted from the host string if it has\nthe form `host:port`, else the default HTTP port (80) is used.\nIf no host is passed, no connection is made, and the `connect`\nmethod should be used to connect to a server.  For example, the\nfollowing calls all create instances that connect to the server at the\nsame host and port:\nOnce an `HTTP` instance has been connected to an HTTP server, it\nshould be used as follows:\n- 1. 1. Make exactly one call to the `putrequest()` method.\n2. 2. Make zero or more calls to the `putheader()` method.\n3. 3. Call the `endheaders()` method (this can be omitted if\nstep 4 makes no calls).\n4. 4. Optional calls to the `send()` method.\n5. 5. Call the `getreply()` method.\n6. 6. Call the `getfile()` method and read the data off the\nfile object that it returns.\n## Menu", "python_version": "1.2", "length": 1310, "url": "https://docs.python.org/{python_version}/python-lib/httplib.html"}
{"title": "imageop -- Python library reference", "text": "imageop -- Python library reference\nPrev: audioop (audioop.html)\nTop: Top (top.html)\n# 12.2. Built-in Module `imageop`\nThe `imageop` module contains some useful operations on images.\nIt operates on images consisting of 8 or 32 bit pixels\nstored in Python strings.  This is the same format as used\nby `gl.lrectwrite` and the `imgfile` module.\nThe module defines the following variables and functions:", "python_version": "1.2", "length": 399, "url": "https://docs.python.org/{python_version}/python-lib/imageop.html"}
{"title": "imgfile -- Python library reference", "text": "imgfile -- Python library reference\nPrev: GL and DEVICE (gl_and_device.html)\nTop: Top (top.html)\n# 16.10. Built-in Module `imgfile`\nThe imgfile module allows python programs to access SGI imglib image\nfiles (also known as .rgb files).  The module is far from\ncomplete, but is provided anyway since the functionality that there is\nis enough in some cases.  Currently, colormap files are not supported.\nThe module defines the following variables and functions:", "python_version": "1.2", "length": 458, "url": "https://docs.python.org/{python_version}/python-lib/imgfile.html"}
{"title": "imp -- Python library reference", "text": "imp -- Python library reference\nPrev: marshal (marshal.html)\nTop: Top (top.html)\n# 3.8. Built-in Module `imp`\nThis module provides an interface to the mechanisms used to implement\nthe `import` statement.  It defines the following constants and\nfunctions:\nThe following constants with integer values, defined in the module,\nare used to indicate the search result of `imp.find_module`.\n## Menu", "python_version": "1.2", "length": 391, "url": "https://docs.python.org/{python_version}/python-lib/imp.html"}
{"title": "Instant Users Manual -- Python library reference", "text": "Instant Users Manual -- Python library reference\nPrev: Profiler Changes (profiler_changes.html)\nTop: Top (top.html)\n# 10.3. Instant Users Manual\nThis section is provided for users that ``don't want to read the\nmanual.'' It provides a very brief overview, and allows a user to\nrapidly perform profiling on an existing application.\nTo profile an application with a main entry point of `foo()', you\nwould add the following to your module:\nThe above action would cause `foo()' to be run, and a series of\ninformative lines (the profile) to be printed. The above approach is\nmost useful when working with the interpreter. If you would like to\nsave the results of a profile into a file for later examination, you\ncan supply a file name as the second argument to the `run()`\nfunction:\nWhen you wish to review the profile, you should use the methods in the\n`pstats` module. Typically you would load the statistics data as\nfollows:\nThe class `Stats` (the above code just created an instance of\nthis class) has a variety of methods for manipulating and printing the\ndata that was just read into `p'. When you ran\n`profile.run()` above, what was printed was the result of three\nmethod calls:\nThe first method removed the extraneous path from all the module\nnames. The second method sorted all the entries according to the\nstandard module/line/name string that is printed (this is to comply\nwith the semantics of the old profiler). The third method printed out\nall the statistics. You might try the following sort calls:\nThe first call will actually sort the list by function name, and the\nsecond call will print out the statistics. The following are some\ninteresting calls to experiment with:\nThis sorts the profile by cumulative time in a function, and then only\nprints the ten most significant lines. If you want to understand what\nalgorithms are taking time, the above line is what you would use.\nIf you were looking to see what functions were looping a lot, and\ntaking a lot of time, you would do:\nto sort according to time spent within each function, and then print\nthe statistics for the top ten functions.\nYou might also try:\nThis will sort all the statistics by file name, and then print out\nstatistics for only the class init methods ('cause they are spelled\nwith `__init__` in them). As one final example, you could try:\nThis line sorts statistics with a primary key of time, and a secondary\nkey of cumulative time, and then prints out some of the statistics.\nTo be specific, the list is first culled down to 50% (re: `.5')\nof its original size, then only lines containing `init` are\nmaintained, and that sub-sub-list is printed.\nIf you wondered what functions called the above functions, you could\nnow (`p' is still sorted according to the last criteria) do:\nand you would get a list of callers for each of the listed functions.\nIf you want more functionality, you're going to have to read the\nmanual, or guess what the following functions do:", "python_version": "1.2", "length": 2942, "url": "https://docs.python.org/{python_version}/python-lib/instant_users_manual.html"}
{"title": "Internal Objects -- Python library reference", "text": "Internal Objects -- Python library reference\nPrev: File Objects (file_objects.html)\nTop: Top (top.html)\n### 2.1.7.9. Internal Objects\n(See the Python Reference Manual for these.)", "python_version": "1.2", "length": 178, "url": "https://docs.python.org/{python_version}/python-lib/internal_objects.html"}
{"title": "Internet and WWW -- Python library reference", "text": "Internet and WWW -- Python library reference\nPrev: The Python Profiler (the_python_profiler.html)\nTop: Top (top.html)\n# 11. Internet and WWW Services\nThe modules described in this chapter provide various services to\nWorld-Wide Web (WWW) clients and/or services, and a few modules\nrelated to news and email.  They are all implemented in Python.  Some\nof these modules require the presence of the system-dependent module\n`sockets`, which is currently only fully supported on Unix and\nWindows NT.  Here is an overview:\n## Menu", "python_version": "1.2", "length": 523, "url": "https://docs.python.org/{python_version}/python-lib/internet_and_www.html"}
{"title": "Introduction -- Python library reference", "text": "Introduction -- Python library reference\nPrev: Top (top.html)\nTop: Top (top.html)\n# 1. Introduction\nThe ``Python library'' contains several different kinds of components.\nIt contains data types that would normally be considered part of the\n``core'' of a language, such as numbers and lists. For these types,\nthe Python language core defines the form of literals and places some\nconstraints on their semantics, but does not fully define the\nsemantics. (On the other hand, the language core does define\nsyntactic properties like the spelling and priorities of operators.)\nThe library also contains built-in functions and exceptions ---\nobjects that can be used by all Python code without the need of an\n`import` statement. Some of these are defined by the core\nlanguage, but many are not essential for the core semantics and are\nonly described here.\nThe bulk of the library, however, consists of a collection of modules.\nThere are many ways to dissect this collection. Some modules are\nwritten in C and built in to the Python interpreter; others are\nwritten in Python and imported in source form. Some modules provide\ninterfaces that are highly specific to Python, like printing a stack\ntrace; some provide interfaces that are specific to particular\noperating systems, like socket I/O; others provide interfaces that are\nspecific to a particular application domain, like the World-Wide Web.\nSome modules are avaiable in all versions and ports of Python; others\nare only available when the underlying system supports or requires\nthem; yet others are available only when a particular configuration\noption was chosen at the time when Python was compiled and installed.\nThis manual is organized ``from the inside out'': it first describes\nthe built-in data types, then the built-in functions and exceptions,\nand finally the modules, grouped in chapters of related modules. The\nordering of the chapters as well as the ordering of the modules within\neach chapter is roughly from most relevant to least important.\nThis means that if you start reading this manual from the start, and\nskip to the next chapter when you get bored, you will get a reasonable\noverview of the available modules and application areas that are\nsupported by the Python library. Of course, you don't have to\nread it like a novel --- you can also browse the table of contents (in\nfront of the manual), or look for a specific function, module or term\nin the index (in the back). And finally, if you enjoy learning about\nrandom subjects, you choose a random page number (see module\n`rand`) and read a section or two.\nLet the show begin!", "python_version": "1.2", "length": 2597, "url": "https://docs.python.org/{python_version}/python-lib/introduction.html"}
{"title": "jpeg -- Python library reference", "text": "jpeg -- Python library reference\nPrev: aifc (aifc.html)\nTop: Top (top.html)\n# 12.4. Built-in Module `jpeg`\nThe module `jpeg` provides access to the jpeg compressor and\ndecompressor written by the Independent JPEG Group. JPEG is a (draft?)\nstandard for compressing pictures.  For details on jpeg or the\nIndependent JPEG Group software refer to the JPEG standard or the\ndocumentation provided with the software.\nThe `jpeg` module defines these functions:\nCompress and uncompress raise the error `jpeg.error` in case of errors.", "python_version": "1.2", "length": 524, "url": "https://docs.python.org/{python_version}/python-lib/jpeg.html"}
{"title": "Limitations -- Python library reference", "text": "Limitations -- Python library reference\nPrev: Reference Manual (reference_manual.html)\nTop: Top (top.html)\n# 10.6. Limitations\nThere are two fundamental limitations on this profiler.  The first is\nthat it relies on the Python interpreter to dispatch call,\nreturn, and exception events.  Compiled C code does not\nget interpreted, and hence is ``invisible'' to the profiler.  All time\nspent in C code (including builtin functions) will be charged to the\nPython function that invoked the C code.  If the C code calls out\nto some native Python code, then those calls will be profiled\nproperly.\nThe second limitation has to do with accuracy of timing information.\nThere is a fundamental problem with deterministic profilers involving\naccuracy. The most obvious restriction is that the underlying ``clock''\nis only ticking at a rate (typically) of about .001 seconds. Hence no\nmeasurements will be more accurate that that underlying clock. If\nenough measurements are taken, then the ``error'' will tend to average\nout. Unfortunately, removing this first error induces a second source\nof error...\nThe second problem is that it ``takes a while'' from when an event is\ndispatched until the profiler's call to get the time actually\ngets the state of the clock. Similarly, there is a certain lag\nwhen exiting the profiler event handler from the time that the clock's\nvalue was obtained (and then squirreled away), until the user's code\nis once again executing. As a result, functions that are called many\ntimes, or call many functions, will typically accumulate this error.\nThe error that accumulates in this fashion is typically less than the\naccuracy of the clock (i.e., less than one clock tick), but it\ncan accumulate and become very significant. This profiler\nprovides a means of calibrating itself for a given platform so that\nthis error can be probabilistically (i.e., on the average) removed.\nAfter the profiler is calibrated, it will be more accurate (in a least\nsquare sense), but it will sometimes produce negative numbers (when\ncall counts are exceptionally low, and the gods of probability work\nagainst you :-). ) Do NOT be alarmed by negative numbers in\nthe profile. They should only appear if you have calibrated\nyour profiler, and the results are actually better than without\ncalibration.", "python_version": "1.2", "length": 2293, "url": "https://docs.python.org/{python_version}/python-lib/limitations.html"}
{"title": "mac -- Python library reference", "text": "mac -- Python library reference\nPrev: Macintosh Specific Services (macintosh_specific_services.html)\nTop: Top (top.html)\n# 14.1. Built-in Module `mac`\nThis module provides a subset of the operating system dependent\nfunctionality provided by the optional built-in module `posix`.\nIt is best accessed through the more portable standard module\n`os`.\nThe following functions are available in this module:\n`chdir`,\n`getcwd`,\n`listdir`,\n`mkdir`,\n`rename`,\n`rmdir`,\n`stat`,\n`sync`,\n`unlink`,\nas well as the exception `error`.", "python_version": "1.2", "length": 518, "url": "https://docs.python.org/{python_version}/python-lib/mac.html"}
{"title": "macconsole -- Python library reference", "text": "macconsole -- Python library reference\nPrev: ctb (ctb.html)\nTop: Top (top.html)\n# 14.4. Built-in Module `macconsole`\nThis module is available on the Macintosh, provided Python has been\nbuilt using the Think C compiler. It provides an interface to the\nThink console package, with which basic text windows can be created.\n## Menu", "python_version": "1.2", "length": 327, "url": "https://docs.python.org/{python_version}/python-lib/macconsole.html"}
{"title": "macconsole options object -- Python library reference", "text": "macconsole options object -- Python library reference\nPrev: macconsole (macconsole.html)\nTop: Top (top.html)\n## 14.4.1. macconsole options object\nThese options are examined when a window is created:", "python_version": "1.2", "length": 198, "url": "https://docs.python.org/{python_version}/python-lib/macconsole_options_object.html"}
{"title": "macdnr -- Python library reference", "text": "macdnr -- Python library reference\nPrev: macconsole (macconsole.html)\nTop: Top (top.html)\n# 14.5. Built-in Module `macdnr`\nThis module provides an interface to the Macintosh Domain Name\nResolver.  It is usually used in conjunction with the mactcp\nmodule, to map hostnames to IP-addresses.  It may not be available in\nall Mac Python versions.\nThe `macdnr` module defines the following functions:\n## Menu", "python_version": "1.2", "length": 402, "url": "https://docs.python.org/{python_version}/python-lib/macdnr.html"}
{"title": "macfs -- Python library reference", "text": "macfs -- Python library reference\nPrev: macdnr (macdnr.html)\nTop: Top (top.html)\n# 14.6. Built-in Module `macfs`\nThis module provides access to macintosh FSSpec handling, the Alias\nManager, finder aliases and the Standard File package.\nWhenever a function or method expects a file argument, this\nargument can be one of three things: (1) a full or partial Macintosh\npathname, (2) an FSSpec object or (3) a 3-tuple `(wdRefNum,\nparID, name)` as described in Inside Mac VI.\nand the standard file package can also be found there.\n## Menu", "python_version": "1.2", "length": 532, "url": "https://docs.python.org/{python_version}/python-lib/macfs.html"}
{"title": "Macintosh Specific Services -- Python library reference", "text": "Macintosh Specific Services -- Python library reference\nPrev: Cryptographic Services (cryptographic_services.html)\nTop: Top (top.html)\n# 14. Macintosh Specific Services\nThe modules in this chapter are available on the Apple Macintosh only.\n## Menu", "python_version": "1.2", "length": 247, "url": "https://docs.python.org/{python_version}/python-lib/macintosh_specific_services.html"}
{"title": "macpath -- Python library reference", "text": "macpath -- Python library reference\nPrev: mac (mac.html)\nTop: Top (top.html)\n# 14.2. Standard Module `macpath`\nThis module provides a subset of the pathname manipulation functions\navailable from the optional standard module `posixpath`.  It is\nbest accessed through the more portable standard module `os`, as\n`os.path`.\nThe following functions are available in this module:\n`normcase`,\n`isabs`,\n`join`,\n`split`,\n`isdir`,\n`isfile`,\n`exists`.", "python_version": "1.2", "length": 440, "url": "https://docs.python.org/{python_version}/python-lib/macpath.html"}
{"title": "macspeech -- Python library reference", "text": "macspeech -- Python library reference\nPrev: mactcp (mactcp.html)\nTop: Top (top.html)\n# 14.8. Built-in Module `macspeech`\nThis module provides an interface to the Macintosh Speech Manager,\nallowing you to let the Macintosh utter phrases. You need a version of\nthe speech manager extension (version 1 and 2 have been tested) in\nyour `Extensions` folder for this to work. The module does not\nprovide full access to all features of the Speech Manager yet.  It may\nnot be available in all Mac Python versions.\n## Menu", "python_version": "1.2", "length": 512, "url": "https://docs.python.org/{python_version}/python-lib/macspeech.html"}
{"title": "mactcp -- Python library reference", "text": "mactcp -- Python library reference\nPrev: macfs (macfs.html)\nTop: Top (top.html)\n# 14.7. Built-in Module `mactcp`\nThis module provides an interface to the Macintosh TCP/IP driver\nMacTCP.`macdnr` which provides an\ninterface to the name-server (allowing you to translate hostnames to\nip-addresses), a module `MACTCP` which has symbolic names for\nconstants constants used by MacTCP and a wrapper module `socket`\nwhich mimics the UNIX socket interface (as far as possible).  It may\nnot be available in all Mac Python versions.\nA complete description of the MacTCP interface can be found in the\nApple MacTCP API documentation.\n## Menu", "python_version": "1.2", "length": 628, "url": "https://docs.python.org/{python_version}/python-lib/mactcp.html"}
{"title": "Mapping Types -- Python library reference", "text": "Mapping Types -- Python library reference\nPrev: Sequence Types (sequence_types.html)\nTop: Top (top.html)\n## 2.1.6. Mapping Types\nA mapping object maps values of one type (the key type) to\narbitrary objects.  Mappings are mutable objects.  There is currently\nonly one standard mapping type, the dictionary.  A dictionary's keys are\nalmost arbitrary values.  The only types of values not acceptable as\nkeys are values containing lists or dictionaries or other mutable\ntypes that are compared by value rather than by object identity.\nNumeric types used for keys obey the normal rules for numeric\ncomparison: if two numbers compare equal (e.g. 1 and 1.0) then they\ncan be used interchangeably to index the same dictionary entry.\nDictionaries are created by placing a comma-separated list of\n`key :,varvalue` pairs within braces, for example:\n`{'jack':,4098, 'sjoerd':,4127}` or\n`{4098:,'jack', 4127:,'sjoerd'}`.\nThe following operations are defined on mappings (where a is a\nmapping, k is a key and x is an arbitrary object):\nNotes:", "python_version": "1.2", "length": 1028, "url": "https://docs.python.org/{python_version}/python-lib/mapping_types.html"}
{"title": "marshal -- Python library reference", "text": "marshal -- Python library reference\nPrev: copy (copy.html)\nTop: Top (top.html)\n# 3.7. Built-in Module `marshal`\nThis module contains functions that can read and write Python\nvalues in a binary format.  The format is specific to Python, but\nindependent of machine architecture issues (e.g., you can write a\nPython value to a file on a PC, transport the file to a Sun, and read\nit back there).  Details of the format are undocumented on purpose;\nit may change between Python versions (although it rarely does).(1) (#footnotetext1)\nThis is not a general ``persistency'' module. For general persistency\nand transfer of Python objects through RPC calls, see the modules\n`pickle` and `shelve`. The `marshal` module exists\nmainly to support reading and writing the ``pseudo-compiled'' code for\nPython modules of `.pyc' files.\nNot all Python object types are supported; in general, only objects\nwhose value is independent from a particular invocation of Python can\nbe written and read by this module. The following types are supported:\n`None`, integers, long integers, floating point numbers,\nstrings, tuples, lists, dictionaries, and code objects, where it\nshould be understood that tuples, lists and dictionaries are only\nsupported as long as the values contained therein are themselves\nsupported; and recursive lists and dictionaries should not be written\n(they will cause infinite loops).\nCaveat: On machines where C's `long int` type has more than\n32 bits (such as the DEC Alpha or the HP Precision Architecture), it\nis possible to create plain Python integers that are longer than 32\nbits. Since the current `marshal` module uses 32 bits to\ntransfer plain Python integers, such values are silently truncated.\nThis particularly affects the use of very long integer literals in\nPython modules --- these will be accepted by the parser on such\nmachines, but will be silently be truncated when the module is read\nfrom the `.pyc` instead.(2) (#footnotetext2)\nThere are functions that read/write files as well as functions\noperating on strings.\nThe module defines these functions:\n## ---------- Footnotes ----------\n(1) (#footnoteref1)\nThe name of this module stems from a bit of terminology used\nby the designers of Modula-3 (amongst others), who use the term\n``marshalling'' for shipping of data around in a self-contained form.\nStrictly speaking, ``to marshal'' means to convert some data from\ninternal to external form (in an RPC buffer for instance) and\n``unmarshalling'' for the reverse process.\n(2) (#footnoteref2)\nA solution would be to refuse such literals in the parser,\nsince they are inherently non-portable. Another solution would be to\nlet the `marshal` module raise an exception when an integer value\nwould be truncated. At least one of these solutions will be\nimplemented in a future version.", "python_version": "1.2", "length": 2799, "url": "https://docs.python.org/{python_version}/python-lib/marshal.html"}
{"title": "math -- Python library reference", "text": "math -- Python library reference\nPrev: Miscellaneous Services (miscellaneous_services.html)\nTop: Top (top.html)\n# 5.1. Built-in Module `math`\nThis module is always available.\nIt provides access to the mathematical functions defined by the C\nstandard.\nThey are:\nNote that `frexp` and `modf` have a different call/return\npattern than their C equivalents: they take a single argument and\nreturn a pair of values, rather than returning their second return\nvalue through an `output parameter' (there is no such thing in Python).\nThe `hypot` function, which is not standard C, is not available\non all platforms.\nThe module also defines two mathematical constants:", "python_version": "1.2", "length": 657, "url": "https://docs.python.org/{python_version}/python-lib/math.html"}
{"title": "md5 -- Python library reference", "text": "md5 -- Python library reference\nPrev: Cryptographic Services (cryptographic_services.html)\nTop: Top (top.html)\n# 13.1. Built-in Module `md5`\nThis module implements the interface to RSA's MD5 message digest\nalgorithm (see also Internet RFC 1321).  Its use is quite\nstraightforward: use the `md5.new()` to create an md5 object.\nYou can now feed this object with arbitrary strings using the\n`update()` method, and at any point you can ask it for the\ndigest (a strong kind of 128-bit checksum,\na.k.a. ``fingerprint'') of the contatenation of the strings fed to it\nso far using the `digest()` method.\nFor example, to obtain the digest of the string `\"Nobody inspects\nthe spammish repetition\"`:\nMore condensed:\nAn md5 object has the following methods:", "python_version": "1.2", "length": 745, "url": "https://docs.python.org/{python_version}/python-lib/md5.html"}
{"title": "Menu Objects -- Python library reference", "text": "Menu Objects -- Python library reference\nPrev: Drawing Objects (drawing_objects.html)\nTop: Top (top.html)\n## 15.1.4. Menu Objects\nA menu object represents a menu.\nThe menu is destroyed when the menu object is deleted.\nThe following methods are defined:", "python_version": "1.2", "length": 252, "url": "https://docs.python.org/{python_version}/python-lib/menu_objects.html"}
{"title": "Message Objects -- Python library reference", "text": "Message Objects -- Python library reference\nPrev: rfc822 (rfc822.html)\nTop: Top (top.html)\n## 11.10.1. Message Objects\nA `Message` instance has the following methods:\n`Message` instances also support a read-only mapping interface.\nIn particular: `m[name]` is the same as `m.getheader(name)`;\nand `len(m)`, `m.has_key(name)`, `m.keys()`,\n`m.values()` and `m.items()` act as expected (and\nconsistently).\nFinally, `Message` instances have two public instance variables:", "python_version": "1.2", "length": 466, "url": "https://docs.python.org/{python_version}/python-lib/message_objects.html"}
{"title": "Methods -- Python library reference", "text": "Methods -- Python library reference\nPrev: Functions (functions.html)\nTop: Top (top.html)\n### 2.1.7.4. Methods\nMethods are functions that are called using the attribute notation.\nThere are two flavors: built-in methods (such as `append()` on\nlists) and class instance methods.  Built-in methods are described\nwith the types that support them.\nThe implementation adds two special read-only attributes to class\ninstance methods: `m .im_self` is the object whose method this\nis, and `m .im_func` is the function implementing the method.\nCalling `m ( arg-1 , arg-2 , ... , arg-n )` is completely equivalent to calling\n`m .im_func( m .im_self, arg-1 , arg-2 , ... , arg-n )`.\n(See the Python Reference Manual for more info.)", "python_version": "1.2", "length": 718, "url": "https://docs.python.org/{python_version}/python-lib/methods.html"}
{"title": "mimetools -- Python library reference", "text": "mimetools -- Python library reference\nPrev: rfc822 (rfc822.html)\nTop: Top (top.html)\n# 11.11. Standard Module `mimetools`\nThis module defines a subclass of the class `rfc822.Message` and\na number of utility functions that are useful for the manipulation for\nMIME style multipart or encoded message.\nIt defines the following items:\n## Menu", "python_version": "1.2", "length": 338, "url": "https://docs.python.org/{python_version}/python-lib/mimetools.html"}
{"title": "mimetools.Message Methods -- Python library reference", "text": "mimetools.Message Methods -- Python library reference\nPrev: mimetools (mimetools.html)\nTop: Top (top.html)\n## 11.11.1. Additional Methods of Message objects\nThe `mimetools.Message` class defines the following methods in\naddition to the `rfc822.Message` class:", "python_version": "1.2", "length": 259, "url": "https://docs.python.org/{python_version}/python-lib/mimetools.message_methods.html"}
{"title": "Miscellaneous Services -- Python library reference", "text": "Miscellaneous Services -- Python library reference\nPrev: String Services (string_services.html)\nTop: Top (top.html)\n# 5. Miscellaneous Services\nThe modules described in this chapter provide miscellaneous services\nthat are available in all Python versions.  Here's an overview:\n## Menu", "python_version": "1.2", "length": 284, "url": "https://docs.python.org/{python_version}/python-lib/miscellaneous_services.html"}
{"title": "Module Index -- Python library reference", "text": "Module Index -- Python library reference\nPrev: Variable Index (variable_index.html)\nTop: Top (top.html)\n# Module Index", "python_version": "1.2", "length": 118, "url": "https://docs.python.org/{python_version}/python-lib/module_index.html"}
{"title": "Modules -- Python library reference", "text": "Modules -- Python library reference\nPrev: Other Built-in Types (other_built-in_types.html)\nTop: Top (top.html)\n### 2.1.7.1. Modules\nThe only special operation on a module is attribute access:\n`m . name`, where m is a module and name accesses\na name defined in m's symbol table.  Module attributes can be\nassigned to.  (Note that the `import` statement is not, strictly\nspoken, an operation on a module object; `import foo` does not\nrequire a module object named foo to exist, rather it requires\nan (external) definition for a module named foo\nsomewhere.)\nA special member of every module is `__dict__`.\nThis is the dictionary containing the module's symbol table.\nModifying this dictionary will actually change the module's symbol\ntable, but direct assignment to the `__dict__` attribute is not\npossible (i.e., you can write `m .__dict__['a'] = 1`, which\ndefines `m .a` to be `1`, but you can't write `m .__dict__ = {}`.\nModules are written like this: `<module 'sys'>`.", "python_version": "1.2", "length": 969, "url": "https://docs.python.org/{python_version}/python-lib/modules.html"}
{"title": "More String Operations -- Python library reference", "text": "More String Operations -- Python library reference\nPrev: Sequence Types (sequence_types.html)\nTop: Top (top.html)\n### 2.1.5.1. More String Operations\nString objects have one unique built-in operation: the `%`\noperator (modulo) with a string left argument interprets this string\nas a C sprintf format string to be applied to the right argument, and\nreturns the string resulting from this formatting operation.\nThe right argument should be a tuple with one item for each argument\nrequired by the format string; if the string requires a single\nargument, the right argument may also be a single non-tuple object.(1) (#footnotetext1)\nThe following format characters are understood:\n%, c, s, i, d, u, o, x, X, e, E, f, g, G.\nWidth and precision may be a * to specify that an integer argument\nspecifies the actual width or precision. The flag characters -, +,\nblank, # and 0 are understood. The size specifiers h, l or L may be\npresent but are ignored. The `%s` conversion takes any Python\nobject and converts it to a string using `str()` before\nformatting it. The ANSI features `%p` and `%n`\nare not supported. Since Python strings have an explicit length,\n`%s` conversions don't assume that `'\\0'` is the end of\nthe string.\nFor safety reasons, floating point precisions are clipped to 50;\n`%f` conversions for numbers whose absolute value is over 1e25\nare replaced by `%g` conversions.(2) (#footnotetext2)\nAll other errors raise exceptions.\nIf the right argument is a dictionary (or any kind of mapping), then\nthe formats in the string must have a parenthesized key into that\ndictionary inserted immediately after the `%` character, and\neach format formats the corresponding entry from the mapping. E.g.\nIn this case no * specifiers may occur in a format (since they a\nrequire sequential parameter list).\nAdditional string operations are defined in standard module\n`string` and in built-in module `regex`.\n## ---------- Footnotes ----------\n(1) (#footnoteref1)\nA tuple object in this case should be a singleton.\n(2) (#footnoteref2)\nThese numbers are fairly arbitrary. They are intended to\navoid printing endless strings of meaningless digits without hampering\ncorrect use and without having to know the exact precision of floating\npoint values on a particular machine.", "python_version": "1.2", "length": 2263, "url": "https://docs.python.org/{python_version}/python-lib/more_string_operations.html"}
{"title": "mpz -- Python library reference", "text": "mpz -- Python library reference\nPrev: md5 (md5.html)\nTop: Top (top.html)\n# 13.2. Built-in Module `mpz`\nThis module implements the interface to part of the GNU MP library.\nThis library contains arbitrary precision integer and rational number\narithmetic routines. Only the interfaces to the integer\n(`mpz_...') routines are provided. If not stated\notherwise, the description in the GNU MP documentation can be applied.\nIn general, mpz-numbers can be used just like other standard\nPython numbers, e.g. you can use the built-in operators like `+`,\n`*`, etc., as well as the standard built-in functions like\n`abs`, `int`, ..., `divmod`, `pow`.\nPlease note: the bitwise-xor operation has been implemented as\na bunch of ands, inverts and ors, because the library\nlacks an `mpz_xor` function, and I didn't need one.\nYou create an mpz-number by calling the function called `mpz` (see\nbelow for an exact description). An mpz-number is printed like this:\n`mpz( value )`.\nA number of extra functions are defined in this module. Non\nmpz-arguments are converted to mpz-values first, and the functions\nreturn mpz-numbers.\nAn mpz-number has one method:", "python_version": "1.2", "length": 1136, "url": "https://docs.python.org/{python_version}/python-lib/mpz.html"}
{"title": "Multimedia Services -- Python library reference", "text": "Multimedia Services -- Python library reference\nPrev: Internet and WWW (internet_and_www.html)\nTop: Top (top.html)\n# 12. Multimedia Services\nThe modules described in this chapter implement various algorithms or\ninterfaces that are mainly useful for multimedia applications.  They\nare available at the discretion of the installation.  Here's an overview:\n## Menu", "python_version": "1.2", "length": 361, "url": "https://docs.python.org/{python_version}/python-lib/multimedia_services.html"}
{"title": "Mutable Sequence Types -- Python library reference", "text": "Mutable Sequence Types -- Python library reference\nPrev: More String Operations (more_string_operations.html)\nTop: Top (top.html)\n### 2.1.5.2. Mutable Sequence Types\nList objects support additional operations that allow in-place\nmodification of the object.\nThese operations would be supported by other mutable sequence types\n(when added to the language) as well.\nStrings and tuples are immutable sequence types and such objects cannot\nbe modified once created.\nThe following operations are defined on mutable sequence types (where\nx is an arbitrary object):\n Notes:", "python_version": "1.2", "length": 565, "url": "https://docs.python.org/{python_version}/python-lib/mutable_sequence_types.html"}
{"title": "NNTP Objects -- Python library reference", "text": "NNTP Objects -- Python library reference\nPrev: nntplib (nntplib.html)\nTop: Top (top.html)\n## 11.6.1. NNTP Objects\nNNTP instances have the following methods.  The response that is\nreturned as the first item in the return tuple of almost all methods\nis the server's response: a string beginning with a three-digit code.\nIf the server's response indicates an error, the method raises one of\nthe above exceptions.", "python_version": "1.2", "length": 409, "url": "https://docs.python.org/{python_version}/python-lib/nntp_objects.html"}
{"title": "nntplib -- Python library reference", "text": "nntplib -- Python library reference\nPrev: gopherlib (gopherlib.html)\nTop: Top (top.html)\n# 11.6. Standard Module `nntplib`\nThis module defines the class `NNTP` which implements the client\nside of the NNTP protocol.  It can be used to implement a news reader\nor poster, or automated news processors.  For more information on NNTP\n(Network News Transfer Protocol), see Internet RFC 977.\nHere are two small examples of how it can be used. To list some\nstatistics about a newsgroup and print the subjects of the last 10\narticles:\n@small{\n}\nTo post an article from a file (this assumes that the article has\nvalid headers):\nThe module itself defines the following items:\n## Menu", "python_version": "1.2", "length": 672, "url": "https://docs.python.org/{python_version}/python-lib/nntplib.html"}
{"title": "Numeric Types -- Python library reference", "text": "Numeric Types -- Python library reference\nPrev: Comparisons (comparisons.html)\nTop: Top (top.html)\n## 2.1.4. Numeric Types\nThere are three numeric types: plain integers, long integers, and\nfloating point numbers.  Plain integers (also just called integers)\nare implemented using `long` in C, which gives them at least 32\nbits of precision.  Long integers have unlimited precision.  Floating\npoint numbers are implemented using `double` in C.  All bets on\ntheir precision are off unless you happen to know the machine you are\nworking with.\nNumbers are created by numeric literals or as the result of built-in\nfunctions and operators.  Unadorned integer literals (including hex\nand octal numbers) yield plain integers.  Integer literals with an `L'\nor `l' suffix yield long integers\n(`L' is preferred because `1l` looks too much like eleven!).\nNumeric literals containing a decimal point or an exponent sign yield\nfloating point numbers.\nPython fully supports mixed arithmetic: when a binary arithmetic\noperator has operands of different numeric types, the operand with the\n``smaller'' type is converted to that of the other, where plain\ninteger is smaller than long integer is smaller than floating point.\nComparisons between numbers of mixed type use the same rule.(1) (#footnotetext1)\nThe functions `int()`, `long()` and `float()` can be used\nto coerce numbers to a specific type.\nAll numeric types support the following operations, sorted by\nascending priority (operations in the same box have the same\npriority; all numeric operations have a higher priority than\ncomparison operations):\nNotes:\n## Menu\n## ---------- Footnotes ----------\n(1) (#footnoteref1)\nAs a consequence, the list `[1, 2]` is considered equal\nto `[1.0, 2.0]`, and similar for tuples.", "python_version": "1.2", "length": 1756, "url": "https://docs.python.org/{python_version}/python-lib/numeric_types.html"}
{"title": "OldProfile Class -- Python library reference", "text": "OldProfile Class -- Python library reference\nPrev: Profiler Extensions (profiler_extensions.html)\nTop: Top (top.html)\n## 10.8.1. OldProfile Class\nThe following derived profiler simulates the old style profiler,\nproviding errant results on recursive functions. The reason for the\nusefulness of this profiler is that it runs faster (i.e., less\noverhead) than the old profiler.  It still creates all the caller\nstats, and is quite useful when there is no recursion in the\nuser's code.  It is also a lot more accurate than the old profiler, as\nit does not charge all its overhead time to the user's code.", "python_version": "1.2", "length": 600, "url": "https://docs.python.org/{python_version}/python-lib/oldprofile_class.html"}
{"title": "Optional Operating System Services -- Python library reference", "text": "Optional Operating System Services -- Python library reference\nPrev: Generic Operating System Services (generic_operating_system_services.html)\nTop: Top (top.html)\n# 7. Optional Operating System Services\nThe modules described in this chapter provide interfaces to operating\nsystem features that are available on selected operating systems only.\nThe interfaces are generally modelled after the UNIX or C\ninterfaces but they are available on some other systems as well\n(e.g. Windows or NT).  Here's an overview:\n## Menu", "python_version": "1.2", "length": 517, "url": "https://docs.python.org/{python_version}/python-lib/optional_operating_system_services.html"}
{"title": "os -- Python library reference", "text": "os -- Python library reference\nPrev: Generic Operating System Services (generic_operating_system_services.html)\nTop: Top (top.html)\n# 6.1. Standard Module `os`\nThis module provides a more portable way of using operating system\n(OS) dependent functionality than importing an OS dependent built-in\nmodule like `posix`.\nWhen the optional built-in module `posix` is available, this\nmodule exports the same functions and data as `posix`; otherwise,\nit searches for an OS dependent built-in module like `mac` and\nexports the same functions and data as found there. The design of all\nPython's built-in OS dependent modules is such that as long as the same\nfunctionality is available, it uses the same interface; e.g., the\nfunction `os.stat( file )` returns stat info about a file in a\nformat compatible with the POSIX interface.\nExtensions peculiar to a particular OS are also available through the\n`os` module, but using them is of course a threat to portability!\nNote that after the first time `os` is imported, there is no\nperformance penalty in using functions from `os` instead of\ndirectly from the OS dependent built-in module, so there should be\nno reason not to use `os`!\nIn addition to whatever the correct OS dependent module exports, the\nfollowing variables and functions are always exported by `os`:\n(The functions `os.execv()` and `execve()` are not\ndocumented here, since they are implemented by the OS dependent\nmodule. If the OS dependent module doesn't define either of these,\nthe functions that rely on it will raise an exception. They are\ndocumented in the section on module `posix`, together with all\nother functions that `os` imports from the OS dependent module.)", "python_version": "1.2", "length": 1678, "url": "https://docs.python.org/{python_version}/python-lib/os.html"}
{"title": "Other Built-in Types -- Python library reference", "text": "Other Built-in Types -- Python library reference\nPrev: Mapping Types (mapping_types.html)\nTop: Top (top.html)\n## 2.1.7. Other Built-in Types\nThe interpreter supports several other kinds of objects.\nMost of these support only one or two operations.\n## Menu", "python_version": "1.2", "length": 255, "url": "https://docs.python.org/{python_version}/python-lib/other_built-in_types.html"}
{"title": "pickle -- Python library reference", "text": "pickle -- Python library reference\nPrev: traceback (traceback.html)\nTop: Top (top.html)\n# 3.4. Standard Module `pickle`\nThe `pickle` module implements a basic but powerful algorithm for\n``pickling'' (a.k.a. serializing, marshalling or flattening) nearly\narbitrary Python objects.  This is the act of converting objects to a\nstream of bytes (and back: ``unpickling'').\nThis is a more primitive notion than\npersistency --- although `pickle` reads and writes file objects,\nit does not handle the issue of naming persistent objects, nor the\n(even more complicated) area of concurrent access to persistent\nobjects.  The `pickle` module can transform a complex object into\na byte stream and it can transform the byte stream into an object with\nthe same internal structure.  The most obvious thing to do with these\nbyte streams is to write them onto a file, but it is also conceivable\nto send them across a network or store them in a database.  The module\n`shelve` provides a simple interface to pickle and unpickle\nobjects on ``dbm''-style database files.\nUnlike the built-in module `marshal`, `pickle` handles the\nfollowing correctly:\n- • recursive objects (objects containing references to themselves)\n  • object sharing (references to the same object in different places)\n  • user-defined classes and their instances\nThe data format used by `pickle` is Python-specific.  This has\nthe advantage that there are no restrictions imposed by external\nstandards such as CORBA (which probably can't represent pointer\nsharing or recursive objects); however it means that non-Python\nprograms may not be able to reconstruct pickled Python objects.\nThe `pickle` data format uses a printable ASCII representation.\nThis is slightly more voluminous than a binary representation.\nHowever, small integers actually take less space when\nrepresented as minimal-size decimal strings than when represented as\n32-bit binary numbers, and strings are only much longer if they\ncontain many control characters or 8-bit characters. The big\nadvantage of using printable ASCII (and of some other characteristics\nof `pickle`'s representation) is that for debugging or recovery\npurposes it is possible for a human to read the pickled file with a\nstandard text editor. (I could have gone a step further and used a\nnotation like S-expressions, but the parser\n(currently written in Python) would have been\nconsiderably more complicated and slower, and the files would probably\nhave become much larger.)\nThe `pickle` module doesn't handle code objects, which the\n`marshal` module does. I suppose `pickle` could, and maybe\nit should, but there's probably no great need for it right now (as\nlong as `marshal` continues to be used for reading and writing\ncode objects), and at least this avoids the possibility of smuggling\nTrojan horses into a program.\nFor the benefit of persistency modules written using `pickle`, it\nsupports the notion of a reference to an object outside the pickled\ndata stream. Such objects are referenced by a name, which is an\narbitrary string of printable ASCII characters. The resolution of\nsuch names is not defined by the `pickle` module --- the\npersistent object module will have to implement a method\n`persistent_load`. To write references to persistent objects,\nthe persistent module must define a method `persistent_id` which\nreturns either `None` or the persistent ID of the object.\nThere are some restrictions on the pickling of class instances.\nFirst of all, the class must be defined at the top level in a module.\nNext, it must normally be possible to create class instances by\ncalling the class without arguments. If this is undesirable, the\nclass can define a method `__getinitargs__()`, which should\nreturn a tuple containing the arguments to be passed to the\nclass constructor (`__init__()`).\nClasses can further influence how their instances are pickled --- if the class\ndefines the method `__getstate__()`, it is called and the return\nstate is pickled as the contents for the instance, and if the class\ndefines the method `__setstate__()`, it is called with the\nunpickled state. (Note that these methods can also be used to\nimplement copying class instances.) If there is no\n`__getstate__()` method, the instance's `__dict__` is\npickled. If there is no `__setstate__()` method, the pickled\nobject must be a dictionary and its items are assigned to the new\ninstance's dictionary. (If a class defines both `__getstate__()`\nand `__setstate__()`, the state object needn't be a dictionary\n--- these methods can do what they want.) This protocol is also used\nby the shallow and deep copying operations defined in the `copy`\nmodule.\nNote that when class instances are pickled, their class's code and\ndata are not pickled along with them. Only the instance data are\npickled. This is done on purpose, so you can fix bugs in a class or\nadd methods and still load objects that were created with an earlier\nversion of the class. If you plan to have long-lived objects that\nwill see many versions of a class, it may be worthwhile to put a version\nnumber in the objects so that suitable conversions can be made by the\nclass's `__setstate__()` method.\nWhen a class itself is pickled, only its name is pickled --- the class\ndefinition is not pickled, but re-imported by the unpickling process.\nTherefore, the restriction that the class must be defined at the top\nlevel in a module applies to pickled classes as well.\nThe interface can be summarized as follows.\nTo pickle an object `x` onto a file `f`, open for writing:\nA shorthand for this is:\nTo unpickle an object `x` from a file `f`, open for reading:\nA shorthand is:\nThe `Pickler` class only calls the method `f.write` with a\nstring argument. The `Unpickler` calls the methods `f.read`\n(with an integer argument) and `f.readline` (without argument),\nboth returning a string. It is explicitly allowed to pass non-file\nobjects here, as long as they have the right methods.\nThe following types can be pickled:\n- • `None`\n• integers, long integers, floating point numbers\n• strings\n• tuples, lists and dictionaries containing only picklable objects\n• classes that are defined at the top level in a module\n• instances of such classes whose `__dict__` or\n`__setstate__()` is picklable\nAttempts to pickle unpicklable objects will raise the\n`PicklingError` exception; when this happens, an unspecified\nnumber of bytes may have been written to the file.\nIt is possible to make multiple calls to the `dump()` method of\nthe same `Pickler` instance. These must then be matched to the\nsame number of calls to the `load()` instance of the\ncorresponding `Unpickler` instance. If the same object is\npickled by multiple `dump()` calls, the `load()` will all\nyield references to the same object. Warning: this is intended\nfor pickling multiple objects without intervening modifications to the\nobjects or their parts. If you modify an object and then pickle it\nagain using the same `Pickler` instance, the object is not\npickled again --- a reference to it is pickled and the\n`Unpickler` will return the old value, not the modified one.\n(There are two problems here: (a) detecting changes, and (b)\nmarshalling a minimal set of changes. I have no answers. Garbage\nCollection may also become a problem here.)\nApart from the `Pickler` and `Unpickler` classes, the\nmodule defines the following functions, and an exception:", "python_version": "1.2", "length": 7338, "url": "https://docs.python.org/{python_version}/python-lib/pickle.html"}
{"title": "Port Objects -- Python library reference", "text": "Port Objects -- Python library reference\nPrev: Configuration Objects (configuration_objects.html)\nTop: Top (top.html)\n## 16.1.2. Port Objects\nPort objects (returned by `al.openport()` have the following\nmethods:", "python_version": "1.2", "length": 211, "url": "https://docs.python.org/{python_version}/python-lib/port_objects.html"}
{"title": "posix -- Python library reference", "text": "posix -- Python library reference\nPrev: UNIX Specific Services (unix_specific_services.html)\nTop: Top (top.html)\n# 8.1. Built-in Module `posix`\nThis module provides access to operating system functionality that is\nstandardized by the C Standard and the POSIX standard (a thinly disguised\nUNIX interface).\nDo not import this module directly. Instead, import the\nmodule `os`, which provides a portable version of this\ninterface. On UNIX, the `os` module provides a superset of\nthe `posix` interface. On non-UNIX operating systems the\n`posix` module is not available, but a subset is always available\nthrough the `os` interface. Once `os` is imported, there is\nno performance penalty in using it instead of\n`posix`.\nThe descriptions below are very terse; refer to the\ncorresponding UNIX manual entry for more information. Arguments\ncalled path refer to a pathname given as a string.\nErrors are reported as exceptions; the usual exceptions are given\nfor type errors, while errors reported by the system calls raise\n`posix.error`, described below.\nModule `posix` defines the following data items:\nIt defines the following functions and constants:\n## ---------- Footnotes ----------\n(1) (#footnoteref1)\nThe problem with automatically passing on `environ` is\nthat there is no portable way of changing the environment.", "python_version": "1.2", "length": 1310, "url": "https://docs.python.org/{python_version}/python-lib/posix.html"}
{"title": "posixfile -- Python library reference", "text": "posixfile -- Python library reference\nPrev: fcntl (fcntl.html)\nTop: Top (top.html)\n# 8.10. Standard Module `posixfile`\nThis module implements some additional functionality over the built-in\nfile objects.  In particular, it implements file locking, control over\nthe file flags, and an easy interface to duplicate the file object.\nThe module defines a new file object, the posixfile object.  It\nhas all the standard file object methods and adds the methods\ndescribed below.  This module only works for certain flavors of\nUNIX, since it uses `fcntl()` for file locking.\nTo instantiate a posixfile object, use the `open()` function in\nthe posixfile module. The resulting object looks and feels roughly\nthe same as a standard file object.\nThe posixfile module defines the following constants:\nThe posixfile module defines the following functions:\nThe posixfile object defines the following additional methods:\nAll methods return `IOError` when the request fails.\nFormat characters for the `lock()` method have the following meaning:\nIn addition the following modifiers can be added to the format:\nNote:\n(1) The lock returned is in the format `(mode, len, start,\nwhence, pid)` where mode is a character representing the type of lock\n('r' or 'w'). This modifier prevents a request from being granted; it\nis for query purposes only.\nFormat character for the `flags()` method have the following meaning:\nIn addition the following modifiers can be added to the format:\nNote:\n(1) The `!` and `=` modifiers are mutually exclusive.\n(2) This string represents the flags after they may have been altered\nby the same call.\nExamples:", "python_version": "1.2", "length": 1616, "url": "https://docs.python.org/{python_version}/python-lib/posixfile.html"}
{"title": "posixpath -- Python library reference", "text": "posixpath -- Python library reference\nPrev: posix (posix.html)\nTop: Top (top.html)\n# 8.2. Standard Module `posixpath`\nThis module implements some useful functions on POSIX pathnames.\nDo not import this module directly. Instead, import the\nmodule `os` and use `os.path`.", "python_version": "1.2", "length": 269, "url": "https://docs.python.org/{python_version}/python-lib/posixpath.html"}
{"title": "Profiler Changes -- Python library reference", "text": "Profiler Changes -- Python library reference\nPrev: Profiler Introduction (profiler_introduction.html)\nTop: Top (top.html)\n# 10.2. How Is This Profiler Different From The Old Profiler?\nThe big changes from old profiling module are that you get more\ninformation, and you pay less CPU time.  It's not a trade-off, it's a\ntrade-up.\nTo be specific:", "python_version": "1.2", "length": 343, "url": "https://docs.python.org/{python_version}/python-lib/profiler_changes.html"}
{"title": "Profiler Extensions -- Python library reference", "text": "Profiler Extensions -- Python library reference\nPrev: Calibration (calibration.html)\nTop: Top (top.html)\n# 10.8. Extensions --- Deriving Better Profilers\nThe `Profile` class of module `profile` was written so that\nderived classes could be developed to extend the profiler.  Rather\nthan describing all the details of such an effort, I'll just present\nthe following two examples of derived classes that can be used to do\nprofiling.  If the reader is an avid Python programmer, then it should\nbe possible to use these as a model and create similar (and perchance\nbetter) profile classes.\nIf all you want to do is change how the timer is called, or which\ntimer function is used, then the basic class has an option for that in\nthe constructor for the class. Consider passing the name of a\nfunction to call into the constructor:\nThe resulting profiler will call `your_time_func()` instead of\n`os.times()`. The function should return either a single number\nor a list of numbers (like what `os.times()` returns). If the\nfunction returns a single time number, or the list of returned numbers\nhas length 2, then you will get an especially fast version of the\ndispatch routine.\nBe warned that you should calibrate the profiler class for the\ntimer function that you choose. For most machines, a timer that\nreturns a lone integer value will provide the best results in terms of\nlow overhead during profiling. (os.times is pretty bad, 'cause\nit returns a tuple of floating point values, so all arithmetic is\nfloating point in the profiler!). If you want to substitute a\nbetter timer in the cleanest fashion, you should derive a class, and\nsimply put in the replacement dispatch method that better handles your\ntimer call, along with the appropriate calibration constant :-).\n## Menu", "python_version": "1.2", "length": 1768, "url": "https://docs.python.org/{python_version}/python-lib/profiler_extensions.html"}
{"title": "Profiler Introduction -- Python library reference", "text": "Profiler Introduction -- Python library reference\nPrev: The Python Profiler (the_python_profiler.html)\nTop: Top (top.html)\n# 10.1. Introduction to the profiler\nA profiler is a program that describes the run time performance\nof a program, providing a variety of statistics.  This documentation\ndescribes the profiler functionality provided in the modules\n`profile` and `pstats.`  This profiler provides\ndeterministic profiling of any Python programs.  It also\nprovides a series of report generation tools to allow users to rapidly\nexamine the results of a profile operation.", "python_version": "1.2", "length": 573, "url": "https://docs.python.org/{python_version}/python-lib/profiler_introduction.html"}
{"title": "pwd -- Python library reference", "text": "pwd -- Python library reference\nPrev: posixpath (posixpath.html)\nTop: Top (top.html)\n# 8.3. Built-in Module `pwd`\nThis module provides access to the UNIX password database.\nIt is available on all UNIX versions.\nPassword database entries are reported as 7-tuples containing the\nfollowing items from the password database (see <pwd.h>), in order:\n`pw_name`,\n`pw_passwd`,\n`pw_uid`,\n`pw_gid`,\n`pw_gecos`,\n`pw_dir`,\n`pw_shell`.\nThe uid and gid items are integers, all others are strings.\nAn exception is raised if the entry asked for cannot be found.\nIt defines the following items:", "python_version": "1.2", "length": 577, "url": "https://docs.python.org/{python_version}/python-lib/pwd.html"}
{"title": "Python Services -- Python library reference", "text": "Python Services -- Python library reference\nPrev: Built-in Objects (built-in_objects.html)\nTop: Top (top.html)\n# 3. Python Services\nThe modules described in this chapter provide a wide range of services\nrelated to the Python interpreter and its interaction with its\nenvironment.  Here's an overview:\n## Menu", "python_version": "1.2", "length": 307, "url": "https://docs.python.org/{python_version}/python-lib/python_services.html"}
{"title": "rand -- Python library reference", "text": "rand -- Python library reference\nPrev: math (math.html)\nTop: Top (top.html)\n# 5.2. Standard Module `rand`\n This module implements a pseudo-random number\ngenerator with an interface similar to `rand()` in C.\nthe following functions:", "python_version": "1.2", "length": 231, "url": "https://docs.python.org/{python_version}/python-lib/rand.html"}
{"title": "rect -- Python library reference", "text": "rect -- Python library reference\nPrev: stdwinevents (stdwinevents.html)\nTop: Top (top.html)\n# 15.3. Standard Module `rect`\nThis module contains useful operations on rectangles.\nA rectangle is defined as in module\n`stdwin`:\na pair of points, where a point is a pair of integers.\nFor example, the rectangle\nis a rectangle whose left, top, right and bottom edges are 10, 20, 90\nand 80, respectively.\nNote that the positive vertical axis points down (as in\n`stdwin`).\nThe module defines the following objects:", "python_version": "1.2", "length": 505, "url": "https://docs.python.org/{python_version}/python-lib/rect.html"}
{"title": "Reference Manual -- Python library reference", "text": "Reference Manual -- Python library reference\nPrev: Deterministic Profiling (deterministic_profiling.html)\nTop: Top (top.html)\n# 10.5. Reference Manual\nThe primary entry point for the profiler is the global function\n`profile.run()`.  It is typically used to create any profile\ninformation.  The reports are formatted and printed using methods of\nthe class `pstats.Stats`.  The following is a description of all\nof these standard entry points and functions.  For a more in-depth\nview of some of the code, consider reading the later section on\nProfiler Extensions, which includes discussion of how to derive\n``better'' profilers from the classes presented, or reading the source\ncode for these modules.\n## Menu", "python_version": "1.2", "length": 707, "url": "https://docs.python.org/{python_version}/python-lib/reference_manual.html"}
{"title": "regex -- Python library reference", "text": "regex -- Python library reference\nPrev: string (string.html)\nTop: Top (top.html)\n# 4.2. Built-in Module `regex`\nThis module provides regular expression matching operations similar to\nthose found in Emacs.  It is always available.\nBy default the patterns are Emacs-style regular expressions; there is\na way to change the syntax to match that of several well-known\nUNIX utilities.\nThis module is 8-bit clean: both patterns and strings may contain null\nbytes and characters whose high bit is set.\nPlease note: There is a little-known fact about Python string\nliterals which means that you don't usually have to worry about\ndoubling backslashes, even though they are used to escape special\ncharacters in string literals as well as in regular expressions. This\nis because Python doesn't remove backslashes from string literals if\nthey are followed by an unrecognized escape character.\nHowever, if you want to include a literal backslash in a\nregular expression represented as a string literal, you have to\nquadruple it. E.g. to extract LaTeX `\\section{...}' headers from a document, you can use this pattern:\n`'\\\\\\\\section{\\(.*\\)}'`.\nThe module defines these functions, and an exception:\nCompiled regular expression objects support these methods:\nCompiled regular expressions support these data attributes:", "python_version": "1.2", "length": 1301, "url": "https://docs.python.org/{python_version}/python-lib/regex.html"}
{"title": "regsub -- Python library reference", "text": "regsub -- Python library reference\nPrev: regex (regex.html)\nTop: Top (top.html)\n# 4.3. Standard Module `regsub`\nThis module defines a number of functions useful for working with\nregular expressions (see built-in module `regex`).", "python_version": "1.2", "length": 228, "url": "https://docs.python.org/{python_version}/python-lib/regsub.html"}
{"title": "rfc822 -- Python library reference", "text": "rfc822 -- Python library reference\nPrev: sgmllib (sgmllib.html)\nTop: Top (top.html)\n# 11.10. Standard Module `rfc822`\nThis module defines a class, `Message`, which represents a\ncollection of ``email headers'' as defined by the Internet standard\nRFC 822.  It is used in various contexts, usually to read such headers\nfrom a file.\nA `Message` instance is instantiated with an open file object as\nparameter. Instantiation reads headers from the file up to a blank\nline and stores them in the instance; after instantiation, the file is\npositioned directly after the blank line that terminates the headers.\nInput lines as read from the file may either be terminated by CR-LF or\nby a single linefeed; a terminating CR-LF is replaced by a single\nlinefeed before the line is stored.\nAll header matching is done independent of upper or lower case;\ne.g. `m['From']`, `m['from']` and `m['FROM']` all yield\nthe same result.\n## Menu", "python_version": "1.2", "length": 919, "url": "https://docs.python.org/{python_version}/python-lib/rfc822.html"}
{"title": "rgbimg -- Python library reference", "text": "rgbimg -- Python library reference\nPrev: jpeg (jpeg.html)\nTop: Top (top.html)\n# 12.5. Built-in Module `rgbimg`\nThe rgbimg module allows python programs to access SGI imglib image\nfiles (also known as .rgb files).  The module is far from\ncomplete, but is provided anyway since the functionality that there is\nis enough in some cases.  Currently, colormap files are not supported.\nThe module defines the following variables and functions:", "python_version": "1.2", "length": 436, "url": "https://docs.python.org/{python_version}/python-lib/rgbimg.html"}
{"title": "rotor -- Python library reference", "text": "rotor -- Python library reference\nPrev: mpz (mpz.html)\nTop: Top (top.html)\n# 13.3. Built-in Module `rotor`\nThis module implements a rotor-based encryption algorithm, contributed by\nLance Ellinghouse.  The design is derived from the Enigma device, a machine\nused during World War II to encipher messages.  A rotor is simply a\npermutation.  For example, if the character `A' is the origin of the rotor,\nthen a given rotor might map `A' to `L', `B' to `Z', `C' to `G', and so on.\nTo encrypt, we choose several different rotors, and set the origins of the\nrotors to known positions; their initial position is the ciphering key.  To\nencipher a character, we permute the original character by the first rotor,\nand then apply the second rotor's permutation to the result. We continue\nuntil we've applied all the rotors; the resulting character is our\nciphertext.  We then change the origin of the final rotor by one position,\nfrom `A' to `B'; if the final rotor has made a complete revolution, then we\nrotate the next-to-last rotor by one position, and apply the same procedure\nrecursively.  In other words, after enciphering one character, we advance\nthe rotors in the same fashion as a car's odometer. Decoding works in the\nsame way, except we reverse the permutations and apply them in the opposite\norder.\nThe available functions in this module are:\nRotor objects have the following methods:\nAn example usage:\nThe module's code is not an exact simulation of the original Enigma device;\nit implements the rotor encryption scheme differently from the original. The\nmost important difference is that in the original Enigma, there were only 5\nor 6 different rotors in existence, and they were applied twice to each\ncharacter; the cipher key was the order in which they were placed in the\nmachine. The Python rotor module uses the supplied key to initialize a\nrandom number generator; the rotor permutations and their initial positions\nare then randomly generated. The original device only enciphered the\nletters of the alphabet, while this module can handle any 8-bit binary data;\nit also produces binary output. This module can also operate with an\narbitrary number of rotors.\nThe original Enigma cipher was broken in 1944.\nThe version implemented here is probably a good deal more difficult to crack\n(especially if you use many rotors), but it won't be impossible for\na truly skilful and determined attacker to break the cipher. So if you want\nto keep the NSA out of your files, this rotor cipher may well be unsafe, but\nfor discouraging casual snooping through your files, it will probably be\njust fine, and may be somewhat safer than using the Unix crypt\ncommand.", "python_version": "1.2", "length": 2659, "url": "https://docs.python.org/{python_version}/python-lib/rotor.html"}
{"title": "select -- Python library reference", "text": "select -- Python library reference\nPrev: socket (socket.html)\nTop: Top (top.html)\n# 7.3. Built-in Module `select`\nThis module provides access to the function `select` available in\nmost UNIX versions.  It defines the following:", "python_version": "1.2", "length": 226, "url": "https://docs.python.org/{python_version}/python-lib/select.html"}
{"title": "Sequence Types -- Python library reference", "text": "Sequence Types -- Python library reference\nPrev: Numeric Types (numeric_types.html)\nTop: Top (top.html)\n## 2.1.5. Sequence Types\nThere are three sequence types: strings, lists and tuples.\nStrings literals are written in single or double quotes:\n`'xyzzy'`, `\"frobozz\"`. See Chapter 2 of the Python\nReference Manual for more about string literals. Lists are\nconstructed with square brackets, separating items with commas:\n`[a, b, c]`. Tuples are constructed by the comma operator (not\nwithin square brackets), with or without enclosing parentheses, but an\nempty tuple must have the enclosing parentheses, e.g.,\n`a, b, c` or `()`. A single item tuple must have a trailing\ncomma, e.g., `(d,)`.\nSequence types support the following operations. The `in' and\n`not,in' operations have the same priorities as the comparison\noperations. The `+' and `*' operations have the same\npriority as the corresponding numeric operations.(1) (#footnotetext1)\nThis table lists the sequence operations sorted in ascending priority\n(operations in the same box have the same priority). In the table,\ns and t are sequences of the same type; n, i\nand j are integers:\nNotes:\n## Menu\n## ---------- Footnotes ----------\n(1) (#footnoteref1)\nThey must\nhave since the parser can't tell the type of the operands.", "python_version": "1.2", "length": 1278, "url": "https://docs.python.org/{python_version}/python-lib/sequence_types.html"}
{"title": "SGI IRIX Specific Services -- Python library reference", "text": "SGI IRIX Specific Services -- Python library reference\nPrev: Standard Windowing Interface (standard_windowing_interface.html)\nTop: Top (top.html)\n# 16. SGI IRIX Specific Services\nThe modules described in this chapter provide interfaces to features\nthat are unique to SGI's IRIX operating system (versions 4 and 5).\n## Menu", "python_version": "1.2", "length": 322, "url": "https://docs.python.org/{python_version}/python-lib/sgi_irix_specific_services.html"}
{"title": "sgmllib -- Python library reference", "text": "sgmllib -- Python library reference\nPrev: htmllib (htmllib.html)\nTop: Top (top.html)\n# 11.9. Standard Module `sgmllib`\nThis module defines a class `SGMLParser` which serves as the\nbasis for parsing text files formatted in SGML (Standard Generalized\nMark-up Language).  In fact, it does not provide a full SGML parser\n--- it only parses SGML insofar as it is used by HTML, and the module only\nexists as a basis for the `htmllib` module.\nIn particular, the parser is hardcoded to recognize the following\nelements:\n- • Opening and closing tags of the form\n```< tag attr =\" value \" ...>`'' and\n```</ tag >`'', respectively.\n• Character references of the form ```&# name ;`''.\n• Entity references of the form ```& name ;`''.\n• SGML comments of the form ```<!-- text >`''.\nThe `SGMLParser` class must be instantiated without arguments.\nIt has the following interface methods:\nApart from overriding or extending the methods listed above, derived\nclasses may also define methods of the following form to define\nprocessing of specific tags. Tag names in the input stream are case\nindependent; the tag occurring in method names must be in lower\ncase:\nNote that the parser maintains a stack of opening tags for which no\nmatching closing tag has been found yet. Only tags processed by\n`start_ tag ()` are pushed on this stack. Definition of a\n`end_ tag ()` method is optional for these tags. For tags\nprocessed by `do_ tag ()` or by `unknown_tag()`, no\n`end_ tag ()` method must be defined.", "python_version": "1.2", "length": 1478, "url": "https://docs.python.org/{python_version}/python-lib/sgmllib.html"}
{"title": "shelve -- Python library reference", "text": "shelve -- Python library reference\nPrev: pickle (pickle.html)\nTop: Top (top.html)\n# 3.5. Standard Module `shelve`\nA ``shelf'' is a persistent, dictionary-like object.  The difference\nwith ``dbm'' databases is that the values (not the keys!) in a shelf\ncan be essentially arbitrary Python objects --- anything that the\n`pickle` module can handle.  This includes most class instances,\nrecursive data types, and objects containing lots of shared\nsub-objects.  The keys are ordinary strings.\nTo summarize the interface (`key` is a string, `data` is an\narbitrary object):\nRestrictions:\n- • The choice of which database package will be used (e.g. dbm or gdbm)\ndepends on which interface is available. Therefore it isn't safe to\nopen the database directly using dbm. The database is also\n(unfortunately) subject to the limitations of dbm, if it is used ---\nthis means that (the pickled representation of) the objects stored in\nthe database should be fairly small, and in rare cases key collisions\nmay cause the database to refuse updates.\n• Dependent on the implementation, closing a persistent dictionary may\nor may not be necessary to flush changes to disk.\n• The `shelve` module does not support concurrent read/write\naccess to shelved objects. (Multiple simultaneous read accesses are\nsafe.) When a program has a shelf open for writing, no other program\nshould have it open for reading or writing. UNIX file locking can\nbe used to solve this, but this differs across UNIX versions and\nrequires knowledge about the database implementation used.", "python_version": "1.2", "length": 1540, "url": "https://docs.python.org/{python_version}/python-lib/shelve.html"}
{"title": "signal -- Python library reference", "text": "signal -- Python library reference\nPrev: Optional Operating System Services (optional_operating_system_services.html)\nTop: Top (top.html)\n# 7.1. Built-in Module `signal`\nThis module provides mechanisms to use signal handlers in Python.\nSome general rules for working with signals handlers:\n- • A handler for a particular signal, once set, remains installed until\nit is explicitly reset (i.e. Python uses the BSD style interface).\n• There is no way to ``block'' signals temporarily from critical\nsections (since this is not supported by all UNIX flavors).\n• Although Python signal handlers are called asynchronously as far as\nthe Python user is concerned, they can only occur between the\n``atomic'' instructions of the Python interpreter. This means that\nsignals arriving during long calculations implemented purely in C\n(e.g. regular expression matches on large bodies of text) may be\ndelayed for an arbitrary amount of time.\n• When a signal arrives during an I/O operation, it is possible that the\nI/O operation raises an exception after the signal handler returns.\nThis is dependent on the underlying UNIX system's semantics regarding\ninterrupted system calls.\n• Because the C signal handler always returns, it makes little sense to\ncatch synchronous errors like `SIGFPE` or `SIGSEGV`.\n• Python installs a small number of signal handlers by default:\n`SIGPIPE` is ignored (so write errors on pipes and sockets can be\nreported as ordinary Python exceptions), `SIGINT` is translated\ninto a `KeyboardInterrupt` exception, and `SIGTERM` is\ncaught so that necessary cleanup (especially `sys.exitfunc`) can\nbe performed before actually terminating. All of these can be\noverridden.\n• Some care must be taken if both signals and threads are used in the\nsame program. The fundamental thing to remember in using signals and\nthreads simultaneously is: always perform `signal()` operations\nin the main thread of execution. Any thread can perform an\n`alarm()`, `getsignal()`, or `pause()`; only the main\nthread can set a new signal handler, and the main thread will be the\nonly one to receive signals (this is enforced by the Python signal\nmodule, even if the underlying thread implementation supports sending\nsignals to individual threads). This means that signals can't be used\nas a means of interthread communication. Use locks instead.\nThe variables defined in the signal module are:\nThe signal module defines the following functions:", "python_version": "1.2", "length": 2426, "url": "https://docs.python.org/{python_version}/python-lib/signal.html"}
{"title": "socket -- Python library reference", "text": "socket -- Python library reference\nPrev: signal (signal.html)\nTop: Top (top.html)\n# 7.2. Built-in Module `socket`\nThis module provides access to the BSD socket interface.\nIt is available on UNIX systems that support this interface.\nFor an introduction to socket programming (in C), see the following\npapers: An Introductory 4.3BSD Interprocess Communication\nTutorial, by Stuart Sechrest and An Advanced 4.3BSD Interprocess\nCommunication Tutorial, by Samuel J. Leffler et al, both in the\nUNIX Programmer's Manual, Supplementary Documents 1 (sections PS1:7\nand PS1:8). The UNIX manual pages for the various socket-related\nsystem calls are also a valuable source of information on the details of\nsocket semantics.\nThe Python interface is a straightforward transliteration of the\nUNIX system call and library interface for sockets to Python's\nobject-oriented style: the `socket()` function returns a\nsocket object whose methods implement the various socket system\ncalls. Parameter types are somewhat higer-level than in the C\ninterface: as with `read()` and `write()` operations on Python\nfiles, buffer allocation on receive operations is automatic, and\nbuffer length is implicit on send operations.\nSocket addresses are represented as a single string for the\n`AF_UNIX` address family and as a pair\n`( host , port )` for the `AF_INET` address family,\nwhere host is a string representing\neither a hostname in Internet domain notation like\n`'daring.cwi.nl'` or an IP address like `'100.50.200.5'`,\nand port is an integral port number. Other address families are\ncurrently not supported. The address format required by a particular\nsocket object is automatically selected based on the address family\nspecified when the socket object was created.\nAll errors raise exceptions. The normal exceptions for invalid\nargument types and out-of-memory conditions can be raised; errors\nrelated to socket or address semantics raise the error `socket.error`.\nNon-blocking mode is supported through the `setblocking()`\nmethod.\nThe module `socket` exports the following constants and functions:\n## Menu", "python_version": "1.2", "length": 2080, "url": "https://docs.python.org/{python_version}/python-lib/socket.html"}
{"title": "Socket Example -- Python library reference", "text": "Socket Example -- Python library reference\nPrev: Socket Objects (socket_objects.html)\nTop: Top (top.html)\n## 7.2.2. Example\nHere are two minimal example programs using the TCP/IP protocol: a\nserver that echoes all data that it receives back (servicing only one\nclient), and a client using it.  Note that a server must perform the\nsequence `socket`, `bind`, `listen`, `accept`\n(possibly repeating the `accept` to service more than one client),\nwhile a client only needs the sequence `socket`, `connect`.\nAlso note that the server does not `send`/`receive` on the\nsocket it is listening on but on the new socket returned by\n`accept`.", "python_version": "1.2", "length": 631, "url": "https://docs.python.org/{python_version}/python-lib/socket_example.html"}
{"title": "Socket Objects -- Python library reference", "text": "Socket Objects -- Python library reference\nPrev: socket (socket.html)\nTop: Top (top.html)\n## 7.2.1. Socket Objects\n Socket objects have the following methods.  Except for\n`makefile()` these correspond to UNIX system calls applicable to\nsockets.\nNote that there are no methods `read()` or `write()`; use\n`recv()` and `send()` without flags argument instead.", "python_version": "1.2", "length": 356, "url": "https://docs.python.org/{python_version}/python-lib/socket_objects.html"}
{"title": "Special Attributes -- Python library reference", "text": "Special Attributes -- Python library reference\nPrev: Other Built-in Types (other_built-in_types.html)\nTop: Top (top.html)\n## 2.1.8. Special Attributes\nThe implementation adds a few special read-only attributes to several\nobject types, where they are relevant:\n- • `x .__dict__` is a dictionary of some sort used to store an\nobject's (writable) attributes;\n• `x .__methods__` lists the methods of many built-in object types,\ne.g., `[].__methods__` yields\n`['append', 'count', 'index', 'insert', 'remove', 'reverse', 'sort']`;\n• `x .__members__` lists data attributes;\n• `x .__class__` is the class to which a class instance belongs;\n• `x .__bases__` is the tuple of base classes of a class object.", "python_version": "1.2", "length": 696, "url": "https://docs.python.org/{python_version}/python-lib/special_attributes.html"}
{"title": "speech channel objects -- Python library reference", "text": "speech channel objects -- Python library reference\nPrev: voice objects (voice_objects.html)\nTop: Top (top.html)\n## 14.8.2. speech channel objects\nA speech channel object allows you to speak strings with slightly more\ncontrol than `SpeakString()`, and allows you to use multiple\nspeakers at the same time. Please note that channel pitch and rate are\ninterrelated in some way, so that to make your Macintosh sing you will\nhave to adjust both.", "python_version": "1.2", "length": 440, "url": "https://docs.python.org/{python_version}/python-lib/speech_channel_objects.html"}
{"title": "Standard Windowing Interface -- Python library reference", "text": "Standard Windowing Interface -- Python library reference\nPrev: Macintosh Specific Services (macintosh_specific_services.html)\nTop: Top (top.html)\n# 15. Standard Windowing Interface\nThe modules in this chapter are available only on those systems where\nthe STDWIN library is available.  STDWIN runs on UNIX under X11 and\non the Macintosh.  See CWI report CS-R8817.\nWarning: Using STDWIN is not recommended for new\napplications. It has never been ported to Microsoft Windows or\nWindows NT, and for X11 or the Macintosh it lacks important\nfunctionality --- in particular, it has no tools for the construction\nof dialogs. For most platforms, alternative, native solutions exist\n(though none are currently documented in this manual): Tkinter for\nUNIX under X11, native Xt with Motif or Athena widgets for UNIX\nunder X11, Win32 for Windows and Windows NT, and a collection of\nnative toolkit interfaces for the Macintosh.\n## Menu", "python_version": "1.2", "length": 921, "url": "https://docs.python.org/{python_version}/python-lib/standard_windowing_interface.html"}
{"title": "stdwin -- Python library reference", "text": "stdwin -- Python library reference\nPrev: Standard Windowing Interface (standard_windowing_interface.html)\nTop: Top (top.html)\n# 15.1. Built-in Module `stdwin`\nThis module defines several new object types and functions that\nprovide access to the functionality of STDWIN.\nOn Unix running X11, it can only be used if the `DISPLAY`\nenvironment variable is set or an explicit `-display\ndisplayname' argument is passed to the Python interpreter.\nFunctions have names that usually resemble their C STDWIN counterparts\nwith the initial `w' dropped.\nPoints are represented by pairs of integers; rectangles\nby pairs of points.\nFor a complete description of STDWIN please refer to the documentation\nof STDWIN for C programmers (aforementioned CWI report).\n## Menu", "python_version": "1.2", "length": 752, "url": "https://docs.python.org/{python_version}/python-lib/stdwin.html"}
{"title": "STDWIN Example -- Python library reference", "text": "STDWIN Example -- Python library reference\nPrev: Text-edit Objects (text-edit_objects.html)\nTop: Top (top.html)\n## 15.1.7. Example\nHere is a minimal example of using STDWIN in Python.\nIt creates a window and draws the string ``Hello world'' in the top\nleft corner of the window.\nThe window will be correctly redrawn when covered and re-exposed.\nThe program quits when the close icon or menu item is requested.", "python_version": "1.2", "length": 409, "url": "https://docs.python.org/{python_version}/python-lib/stdwin_example.html"}
{"title": "STDWIN Functions -- Python library reference", "text": "STDWIN Functions -- Python library reference\nPrev: stdwin (stdwin.html)\nTop: Top (top.html)\n## 15.1.1. Functions Defined in Module `stdwin`\nThe following functions are defined in the `stdwin` module:\n## ---------- Footnotes ----------\n(1) (#footnoteref1)\nThe Python version of STDWIN does not support draw procedures; all\ndrawing requests are reported as draw events.", "python_version": "1.2", "length": 367, "url": "https://docs.python.org/{python_version}/python-lib/stdwin_functions.html"}
{"title": "stdwinevents -- Python library reference", "text": "stdwinevents -- Python library reference\nPrev: stdwin (stdwin.html)\nTop: Top (top.html)\n# 15.2. Standard Module `stdwinevents`\nThis module defines constants used by STDWIN for event types\n(`WE_ACTIVATE` etc.), command codes (`WC_LEFT` etc.)\nand selection types (`WS_PRIMARY` etc.).\nRead the file for details.\nSuggested usage is", "python_version": "1.2", "length": 327, "url": "https://docs.python.org/{python_version}/python-lib/stdwinevents.html"}
{"title": "string -- Python library reference", "text": "string -- Python library reference\nPrev: String Services (string_services.html)\nTop: Top (top.html)\n# 4.1. Standard Module `string`\nThis module defines some constants useful for checking character\nclasses and some useful string functions.  See the modules\n`regex` and `regsub` for string functions based on regular\nexpressions.\nThe constants defined in this module are are:\nThe functions defined in this module are:\nThis module is implemented in Python. Much of its functionality has\nbeen reimplemented in the built-in module `strop`. However, you\nshould never import the latter module directly. When\n`string` discovers that `strop` exists, it transparently\nreplaces parts of itself with the implementation from `strop`.\nAfter initialization, there is no overhead in using\n`string` instead of `strop`.", "python_version": "1.2", "length": 801, "url": "https://docs.python.org/{python_version}/python-lib/string.html"}
{"title": "String Services -- Python library reference", "text": "String Services -- Python library reference\nPrev: Python Services (python_services.html)\nTop: Top (top.html)\n# 4. String Services\nThe modules described in this chapter provide a wide range of string\nmanipulation operations.  Here's an overview:\n## Menu", "python_version": "1.2", "length": 252, "url": "https://docs.python.org/{python_version}/python-lib/string_services.html"}
{"title": "struct -- Python library reference", "text": "struct -- Python library reference\nPrev: regsub (regsub.html)\nTop: Top (top.html)\n# 4.4. Built-in Module `struct`\nThis module performs conversions between Python values and C\nstructs represented as Python strings.  It uses format strings\n(explained below) as compact descriptions of the lay-out of the C\nstructs and the intended conversion to/from Python values.\nSee also built-in module `array`.\nThe module defines the following exception and functions:\nFormat characters have the following meaning; the conversion between C\nand Python values should be obvious given their types:\nA format character may be preceded by an integral repeat count; e.g.\nthe format string `'4h'` means exactly the same as `'hhhh'`.\nC numbers are represented in the machine's native format and byte\norder, and properly aligned by skipping pad bytes if necessary\n(according to the rules used by the C compiler).\nExamples (all on a big-endian machine):\nHint: to align the end of a structure to the alignment requirement of\na particular type, end the format with the code for that type with a\nrepeat count of zero, e.g. the format `'llh0l'` specifies two\npad bytes at the end, assuming longs are aligned on 4-byte boundaries.\n(More format characters are planned, e.g. `'s'` for character\narrays, upper case for unsigned variants, and a way to specify the\nbyte order, which is useful for [de]constructing network packets and\nreading/writing portable binary file formats like TIFF and AIFF.)", "python_version": "1.2", "length": 1464, "url": "https://docs.python.org/{python_version}/python-lib/struct.html"}
{"title": "sunaudiodev -- Python library reference", "text": "sunaudiodev -- Python library reference\nPrev: SunOS Specific Services (sunos_specific_services.html)\nTop: Top (top.html)\n# 17.1. Built-in Module `sunaudiodev`\nThis module allows you to access the sun audio interface. The sun\naudio hardware is capable of recording and playing back audio data\nin U-LAW format with a sample rate of 8K per second. A full\ndescription can be gotten with `man audio'.\nThe module defines the following variables and functions:\n## Menu", "python_version": "1.2", "length": 461, "url": "https://docs.python.org/{python_version}/python-lib/sunaudiodev.html"}
{"title": "SunOS Specific Services -- Python library reference", "text": "SunOS Specific Services -- Python library reference\nPrev: SGI IRIX Specific Services (sgi_irix_specific_services.html)\nTop: Top (top.html)\n# 17. SunOS Specific Services\nThe modules described in this chapter provide interfaces to features\nthat are unique to the SunOS operating system (versions 4 and 5; the\nlatter is also known as Solaris version 2).\n## Menu", "python_version": "1.2", "length": 358, "url": "https://docs.python.org/{python_version}/python-lib/sunos_specific_services.html"}
{"title": "sys -- Python library reference", "text": "sys -- Python library reference\nPrev: Python Services (python_services.html)\nTop: Top (top.html)\n# 3.1. Built-in Module `sys`\nThis module provides access to some variables used or maintained by the\ninterpreter and to functions that interact strongly with the interpreter.\nIt is always available.", "python_version": "1.2", "length": 295, "url": "https://docs.python.org/{python_version}/python-lib/sys.html"}
{"title": "TCP Status Objects -- Python library reference", "text": "TCP Status Objects -- Python library reference\nPrev: TCP Stream Objects (tcp_stream_objects.html)\nTop: Top (top.html)\n## 14.7.2. TCP Status Objects\nThis object has no methods, only some members holding information on\nthe connection. A complete description of all fields in this objects\ncan be found in the Apple documentation. The most interesting ones are:", "python_version": "1.2", "length": 357, "url": "https://docs.python.org/{python_version}/python-lib/tcp_status_objects.html"}
{"title": "TCP Stream Objects -- Python library reference", "text": "TCP Stream Objects -- Python library reference\nPrev: mactcp (mactcp.html)\nTop: Top (top.html)\n## 14.7.1. TCP Stream Objects", "python_version": "1.2", "length": 123, "url": "https://docs.python.org/{python_version}/python-lib/tcp_stream_objects.html"}
{"title": "tempfile -- Python library reference", "text": "tempfile -- Python library reference\nPrev: getopt (getopt.html)\nTop: Top (top.html)\n# 6.4. Standard Module `tempfile`\nThis module generates temporary file names.  It is not UNIX specific,\nbut it may require some help on non-UNIX systems.\nNote: the modules does not create temporary files, nor does it\nautomatically remove them when the current process exits or dies.\nThe module defines a single user-callable function:\nThe module uses two global variables that tell it how to construct a\ntemporary name. The caller may assign values to them; by default they\nare initialized at the first call to `mktemp()`.\nWarning: if a UNIX process uses `mktemp()`, then calls\n`fork()` and both parent and child continue to use\n`mktemp()`, the processes will generate conflicting temporary\nnames. To resolve this, the child process should assign `None`\nto `template`, to force recomputing the default on the next call\nto `mktemp()`.", "python_version": "1.2", "length": 917, "url": "https://docs.python.org/{python_version}/python-lib/tempfile.html"}
{"title": "TERMIOS -- Python library reference", "text": "TERMIOS -- Python library reference\nPrev: termios (termios.html)\nTop: Top (top.html)\n# 8.8. Standard Module `TERMIOS`\nThis module defines the symbolic constants required to use the\n`termios` module (see the previous section).  See the Posix or\nUNIX manual pages (or the source) for a list of those constants.\nNote: this module resides in a system-dependent subdirectory of the\nPython library directory. You may have to generate it for your\nparticular system using the script Tools/scripts/h2py.py.", "python_version": "1.2", "length": 497, "url": "https://docs.python.org/{python_version}/python-lib/termios.html"}
{"title": "termios Example -- Python library reference", "text": "termios Example -- Python library reference\nPrev: termios (termios.html)\nTop: Top (top.html)\n## 8.7.1. Example\nHere's a function that prompts for a password with echoing turned off.\nNote the technique using a separate `termios.tcgetattr()` call\nand a `try ... finally` statement to ensure that the old tty\nattributes are restored exactly no matter what happens:", "python_version": "1.2", "length": 361, "url": "https://docs.python.org/{python_version}/python-lib/termios_example.html"}
{"title": "Text-edit Objects -- Python library reference", "text": "Text-edit Objects -- Python library reference\nPrev: Bitmap Objects (bitmap_objects.html)\nTop: Top (top.html)\n## 15.1.6. Text-edit Objects\nA text-edit object represents a text-edit block.\nFor semantics, see the STDWIN documentation for C programmers.\nThe following methods exist:", "python_version": "1.2", "length": 278, "url": "https://docs.python.org/{python_version}/python-lib/text-edit_objects.html"}
{"title": "The Null Object -- Python library reference", "text": "The Null Object -- Python library reference\nPrev: Type Objects (type_objects.html)\nTop: Top (top.html)\n### 2.1.7.7. The Null Object\nThis object is returned by functions that don't explicitly return a\nvalue.  It supports no special operations.  There is exactly one null\nobject, named `None` (a built-in name).\nIt is written as `None`.", "python_version": "1.2", "length": 334, "url": "https://docs.python.org/{python_version}/python-lib/the_null_object.html"}
{"title": "The Python Debugger -- Python library reference", "text": "The Python Debugger -- Python library reference\nPrev: UNIX Specific Services (unix_specific_services.html)\nTop: Top (top.html)\n# 9. The Python Debugger\nThe module `pdb` defines an interactive source code debugger for\nPython programs.  It supports setting breakpoints and single stepping\nat the source line level, inspection of stack frames, source code\nlisting, and evaluation of arbitrary Python code in the context of any\nstack frame.  It also supports post-mortem debugging and can be called\nunder program control.\nThe debugger is extensible --- it is actually defined as a class\n`Pdb`. This is currently undocumented but easily understood by\nreading the source. The extension interface uses the (also\nundocumented) modules `bdb` and `cmd`.\nA primitive windowing version of the debugger also exists --- this is\nmodule `wdb`, which requires STDWIN (see the chapter on STDWIN\nspecific modules).\nThe debugger's prompt is ```(Pdb)`''.\nTypical usage to run a program under control of the debugger is:\nTypical usage to inspect a crashed program is:\nThe module defines the following functions; each enters the debugger\nin a slightly different way:\n## Menu", "python_version": "1.2", "length": 1151, "url": "https://docs.python.org/{python_version}/python-lib/the_python_debugger.html"}
{"title": "The Python Profiler -- Python library reference", "text": "The Python Profiler -- Python library reference\nPrev: The Python Debugger (the_python_debugger.html)\nTop: Top (top.html)\n# 10. The Python Profiler\nCopyright @copyright 1994, by InfoSeek Corporation, all rights reserved.\nWritten by James Roskind(1) (#footnotetext1)\nPermission to use, copy, modify, and distribute this Python software\nand its associated documentation for any purpose (subject to the\nrestriction in the following sentence) without fee is hereby granted,\nprovided that the above copyright notice appears in all copies, and\nthat both that copyright notice and this permission notice appear in\nsupporting documentation, and that the name of InfoSeek not be used in\nadvertising or publicity pertaining to distribution of the software\nwithout specific, written prior permission. This permission is\nexplicitly restricted to the copying and modification of the software\nto remain in Python, compiled Python, or other languages (such as C)\nwherein the modified or derived code is exclusively imported into a\nPython module.\nINFOSEEK CORPORATION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS\nSOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND\nFITNESS. IN NO EVENT SHALL INFOSEEK CORPORATION BE LIABLE FOR ANY\nSPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER\nRESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF\nCONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN\nCONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\nThe profiler was written after only programming in Python for 3 weeks.\nAs a result, it is probably clumsy code, but I don't know for sure yet\n'cause I'm a beginner :-). I did work hard to make the code run fast,\nso that profiling would be a reasonable thing to do. I tried not to\nrepeat code fragments, but I'm sure I did some stuff in really awkward\nways at times. Please send suggestions for improvements to:\n`jar@infoseek.com`. I won't promise any support. ...but\nI'd appreciate the feedback.\n## Menu\n## ---------- Footnotes ----------\n(1) (#footnoteref1)\nUpdated and converted to LaTeX by Guido van Rossum. The references to\nthe old profiler are left in the text, although it no longer exists.", "python_version": "1.2", "length": 2188, "url": "https://docs.python.org/{python_version}/python-lib/the_python_profiler.html"}
{"title": "The Stats Class -- Python library reference", "text": "The Stats Class -- Python library reference\nPrev: Reference Manual (reference_manual.html)\nTop: Top (top.html)\n## 10.5.1. The `Stats` Class\n## ---------- Footnotes ----------\n(1) (#footnoteref1)\nThis was once necessary, when Python would print any unused expression\nresult that was not `None`.  The method is still defined for\nbackward compatibility.", "python_version": "1.2", "length": 350, "url": "https://docs.python.org/{python_version}/python-lib/the_stats_class.html"}
{"title": "thread -- Python library reference", "text": "thread -- Python library reference\nPrev: select (select.html)\nTop: Top (top.html)\n# 7.4. Built-in Module `thread`\nThis module provides low-level primitives for working with multiple\nthreads (a.k.a. light-weight processes or tasks) --- multiple\nthreads of control sharing their global data space.  For\nsynchronization, simple locks (a.k.a. mutexes or binary\nsemaphores) are provided.\nThe module is optional and supported on SGI IRIX 4.x and 5.x and Sun\nSolaris 2.x systems, as well as on systems that have a PTHREAD\nimplementation (e.g. KSR).\nIt defines the following constant and functions:\nLock objects have the following methods:\nCaveats:\n- • Threads interact strangely with interrupts: the\n`KeyboardInterrupt` exception will be received by an arbitrary\nthread. (When the `signal` module is available, interrupts\nalways go to the main thread.)\n• Calling `sys.exit()` or raising the `SystemExit` is\nequivalent to calling `thread.exit_thread()`.\n• Not all built-in functions that may block waiting for I/O allow other\nthreads to run. (The most popular ones (`sleep`, `read`,\n`select`) work as expected.)", "python_version": "1.2", "length": 1103, "url": "https://docs.python.org/{python_version}/python-lib/thread.html"}
{"title": "time -- Python library reference", "text": "time -- Python library reference\nPrev: os (os.html)\nTop: Top (top.html)\n# 6.2. Built-in Module `time`\nThis module provides various time-related functions.\nIt is always available.\nAn explanation of some terminology and conventions is in order.\n- • The ``epoch'' is the point where the time starts. On January 1st of that\nyear, at 0 hours, the ``time since the epoch'' is zero. For UNIX, the\nepoch is 1970. To find out what the epoch is, look at `gmtime(0)`.\n• UTC is Coordinated Universal Time (formerly known as Greenwich Mean\nTime). The acronym UTC is not a mistake but a compromise between\nEnglish and French.\n• DST is Daylight Saving Time, an adjustment of the timezone by\n(usually) one hour during part of the year. DST rules are magic\n(determined by local law) and can change from year to year. The C\nlibrary has a table containing the local rules (often it is read from\na system file for flexibility) and is the only source of True Wisdom\nin this respect.\n• The precision of the various real-time functions may be less than\nsuggested by the units in which their value or argument is expressed.\nE.g. on most UNIX systems, the clock ``ticks'' only 50 or 100 times a\nsecond, and on the Mac, times are only accurate to whole seconds.\nThe module defines the following functions and data items:", "python_version": "1.2", "length": 1294, "url": "https://docs.python.org/{python_version}/python-lib/time.html"}
{"title": "Top -- Python library reference", "text": "Top -- Python library reference\nPrev: (dir) (../dir.html)\n# The Python library\nThis file describes the built-in types, exceptions and functions and the\nstandard modules that come with the Python system.  It assumes basic\nknowledge about the Python language.  For an informal introduction to\nthe language, see the Python Tutorial.  The Python\nReference Manual gives a more formal definition of the language.\n(These manuals are not yet available in INFO or Texinfo format.)\nThis version corresponds to Python version 1.2 (4 April 1995).\n## Menu", "python_version": "1.2", "length": 542, "url": "https://docs.python.org/{python_version}/python-lib/top.html"}
{"title": "traceback -- Python library reference", "text": "traceback -- Python library reference\nPrev: types (types.html)\nTop: Top (top.html)\n# 3.3. Standard Module `traceback`\nThis module provides a standard interface to format and print stack\ntraces of Python programs.  It exactly mimics the behavior of the\nPython interpreter when it prints a stack trace.  This is useful when\nyou want to print stack traces under program control, e.g. in a\n``wrapper'' around the interpreter.\nThe module uses traceback objects --- this is the object type\nthat is stored in the variables `sys.exc_traceback` and\n`sys.last_traceback`.\nThe module defines the following functions:", "python_version": "1.2", "length": 605, "url": "https://docs.python.org/{python_version}/python-lib/traceback.html"}
{"title": "Truth Value Testing -- Python library reference", "text": "Truth Value Testing -- Python library reference\nPrev: Types (types.html)\nTop: Top (top.html)\n## 2.1.1. Truth Value Testing\nAny object can be tested for truth value, for use in an `if` or\n`while` condition or as operand of the Boolean operations below.\nThe following values are considered false:\n- • `None`\n  • zero of any numeric type, e.g., `0`, `0L`, `0.0`.\n  • any empty sequence, e.g., `''`, `()`, `[]`.\n  • any empty mapping, e.g., `{}`.\n  • instances of user-defined classes, if the class defines a\n  `__nonzero__()` or `__len__()` method, when that\n  method returns zero.\nAll other values are considered true --- so objects of many types are\nalways true.\nOperations and built-in functions that have a Boolean result always\nreturn `0` for false and `1` for true, unless otherwise\nstated.  (Important exception: the Boolean operations `or' and\n`and' always return one of their operands.)", "python_version": "1.2", "length": 892, "url": "https://docs.python.org/{python_version}/python-lib/truth_value_testing.html"}
{"title": "Type Objects -- Python library reference", "text": "Type Objects -- Python library reference\nPrev: Code Objects (code_objects.html)\nTop: Top (top.html)\n### 2.1.7.6. Type Objects\nType objects represent the various object types.  An object's type is\naccessed by the built-in function `type()`.  There are no special\noperations on types.  The standard module `types` defines names\nfor all standard built-in types.\nTypes are written like this: `<type 'int'>`.", "python_version": "1.2", "length": 403, "url": "https://docs.python.org/{python_version}/python-lib/type_objects.html"}
{"title": "types -- Python library reference", "text": "types -- Python library reference\nPrev: sys (sys.html)\nTop: Top (top.html)\n# 3.2. Standard Module `types`\nThis module defines names for all object types that are used by the\nstandard Python interpreter (but not for the types defined by various\nextension modules).  It is safe to use ```from types import *`'' ---\nthe module does not export any other names besides the ones listed\nhere.  New names exported by future versions of this module will\nall end in `Type`.\nTypical use is for functions that do different things depending on\ntheir argument types, like the following:\nThe module defines the following names:", "python_version": "1.2", "length": 612, "url": "https://docs.python.org/{python_version}/python-lib/types.html"}
{"title": "UDP Stream Objects -- Python library reference", "text": "UDP Stream Objects -- Python library reference\nPrev: TCP Status Objects (tcp_status_objects.html)\nTop: Top (top.html)\n## 14.7.3. UDP Stream Objects\nNote that, unlike the name suggests, there is nothing stream-like\nabout UDP.", "python_version": "1.2", "length": 224, "url": "https://docs.python.org/{python_version}/python-lib/udp_stream_objects.html"}
{"title": "UNIX Specific Services -- Python library reference", "text": "UNIX Specific Services -- Python library reference\nPrev: Optional Operating System Services (optional_operating_system_services.html)\nTop: Top (top.html)\n# 8. UNIX Specific Services\nThe modules described in this chapter provide interfaces to features\nthat are unique to the UNIX operating system, or in some cases to\nsome or many variants of it.  Here's an overview:\n## Menu", "python_version": "1.2", "length": 374, "url": "https://docs.python.org/{python_version}/python-lib/unix_specific_services.html"}
{"title": "urllib -- Python library reference", "text": "urllib -- Python library reference\nPrev: cgi (cgi.html)\nTop: Top (top.html)\n# 11.2. Standard Module `urllib`\nThis module provides a high-level interface for fetching data across\nthe World-Wide Web.  In particular, the `urlopen` function is\nsimilar to the built-in function `open`, but accepts URLs\n(Universal Resource Locators) instead of filenames.  Some restrictions\napply --- it can only open URLs for reading, and no seek operations\nare available.\nit defines the following public functions:\nRestrictions:\n- • Currently, only the following protocols are supported: HTTP, (versions\n0.9 and 1.0), Gopher (but not Gopher-+), FTP, and local files.\n• The caching feature of `urlretrieve()` has been disabled until I\nfind the time to hack proper processing of Expiration time headers.\n• There should be a function to query whether a particular URL is in\nthe cache.\n• For backward compatibility, if a URL appears to point to a local file\nbut the file can't be opened, the URL is re-interpreted using the FTP\nprotocol. This can sometimes cause confusing error messages.\n• The `urlopen()` and `urlretrieve()` functions can cause\narbitrarily long delays while waiting for a network connection to be\nset up. This means that it is difficult to build an interactive\nweb client using these functions without using threads.\n• The data returned by `urlopen()` or `urlretrieve()` is the\nraw data returned by the server. This may be binary data (e.g. an\nimage), plain text or (for example) HTML. The HTTP protocol provides\ntype information in the reply header, which can be inspected by\nlooking at the `Content-type` header. For the Gopher protocol,\ntype information is encoded in the URL; there is currently no easy way\nto extract it. If the returned data is HTML, you can use the module\n`htmllib` to parse it.\n• Although the `urllib` module contains (undocumented) routines to\nparse and unparse URL strings, the recommended interface for URL\nmanipulation is in module `urlparse`.", "python_version": "1.2", "length": 1966, "url": "https://docs.python.org/{python_version}/python-lib/urllib.html"}
{"title": "urlparse -- Python library reference", "text": "urlparse -- Python library reference\nPrev: nntplib (nntplib.html)\nTop: Top (top.html)\n# 11.7. Standard Module `urlparse`\nThis module defines a standard interface to break URL strings up in\ncomponents (addessing scheme, network location, path etc.), to combine\nthe components back into a URL string, and to convert a ``relative\nURL'' to an absolute URL given a ``base URL''.\nThe module has been designed to match the current Internet draft on\nRelative Uniform Resource Locators (and discovered a bug in an earlier\ndraft!).\nIt defines the following functions:", "python_version": "1.2", "length": 557, "url": "https://docs.python.org/{python_version}/python-lib/urlparse.html"}
{"title": "Variable Index -- Python library reference", "text": "Variable Index -- Python library reference\nPrev: Function Index (function_index.html)\nTop: Top (top.html)\n# Variable Index", "python_version": "1.2", "length": 122, "url": "https://docs.python.org/{python_version}/python-lib/variable_index.html"}
{"title": "voice objects -- Python library reference", "text": "voice objects -- Python library reference\nPrev: macspeech (macspeech.html)\nTop: Top (top.html)\n## 14.8.1. voice objects\nVoice objects contain the description of a voice. It is currently not\nyet possible to access the parameters of a voice.", "python_version": "1.2", "length": 239, "url": "https://docs.python.org/{python_version}/python-lib/voice_objects.html"}
{"title": "whrandom -- Python library reference", "text": "whrandom -- Python library reference\nPrev: rand (rand.html)\nTop: Top (top.html)\n# 5.3. Standard Module `whrandom`\nThis module implements a Wichmann-Hill pseudo-random number generator.\nIt defines the following functions:", "python_version": "1.2", "length": 220, "url": "https://docs.python.org/{python_version}/python-lib/whrandom.html"}
{"title": "Window Objects -- Python library reference", "text": "Window Objects -- Python library reference\nPrev: STDWIN Functions (stdwin_functions.html)\nTop: Top (top.html)\n## 15.1.2. Window Objects\nWindow objects are created by `stdwin.open()`.  They are closed\nby their `close()` method or when they are garbage-collected.\nWindow objects have the following methods:", "python_version": "1.2", "length": 304, "url": "https://docs.python.org/{python_version}/python-lib/window_objects.html"}
{"title": "Footnotes", "text": "guido@cwi.nl", "python_version": "1.2", "length": 12, "url": "https://docs.python.org/{python_version}/python-ref/footnode.html"}
{"title": "Contents", "text": "---\nnode2.html ref.html ref.html node79.html\n---\n## Contents\n- Introduction (node2.html#SECTION00200000000000000000)\n- Notation (node3.html#SECTION00210000000000000000)\nLexical analysis (node4.html#SECTION00300000000000000000)\n- Line structure (node5.html#SECTION00310000000000000000)\n- Comments (node6.html#SECTION00311000000000000000)\nExplicit line joining (node7.html#SECTION00312000000000000000)\nImplicit line joining (node8.html#SECTION00313000000000000000)\nBlank lines (node9.html#SECTION00314000000000000000)\nIndentation (node10.html#SECTION00315000000000000000)\nOther tokens (node11.html#SECTION00320000000000000000)\nIdentifiers (node12.html#SECTION00330000000000000000)\n- Keywords (node13.html#SECTION00331000000000000000)\nLiterals (node14.html#SECTION00340000000000000000)\n- String literals (node15.html#SECTION00341000000000000000)\nNumeric literals (node16.html#SECTION00342000000000000000)\nOperators (node17.html#SECTION00350000000000000000)\nDelimiters (node18.html#SECTION00360000000000000000)\nData model (node19.html#SECTION00400000000000000000)\n- Objects, values and types (node20.html#SECTION00410000000000000000)\nThe standard type hierarchy (node21.html#SECTION00420000000000000000)\nSpecial method names (node22.html#SECTION00430000000000000000)\n- Special methods for any type (node23.html#SECTION00431000000000000000)\nSpecial methods for attribute access (node24.html#SECTION00432000000000000000)\nSpecial methods for sequence and mapping types (node25.html#SECTION00433000000000000000)\nSpecial methods for sequence types (node26.html#SECTION00434000000000000000)\nSpecial methods for numeric types (node27.html#SECTION00435000000000000000)\nExecution model (node28.html#SECTION00500000000000000000)\n- Code blocks, execution frames, and name spaces (node29.html#SECTION00510000000000000000)\nExceptions (node30.html#SECTION00520000000000000000)\nExpressions and conditions (node31.html#SECTION00600000000000000000)\n- Arithmetic conversions (node32.html#SECTION00610000000000000000)\nAtoms (node33.html#SECTION00620000000000000000)\n- Identifiers (Names) (node34.html#SECTION00621000000000000000)\nLiterals (node35.html#SECTION00622000000000000000)\nParenthesized forms (node36.html#SECTION00623000000000000000)\nList displays (node37.html#SECTION00624000000000000000)\nDictionary displays (node38.html#SECTION00625000000000000000)\nString conversions (node39.html#SECTION00626000000000000000)\nPrimaries (node40.html#SECTION00630000000000000000)\n- Attribute references (node41.html#SECTION00631000000000000000)\nSubscriptions (node42.html#SECTION00632000000000000000)\nSlicings (node43.html#SECTION00633000000000000000)\nCalls (node44.html#SECTION00634000000000000000)\nUnary arithmetic operations (node45.html#SECTION00640000000000000000)\nBinary arithmetic operations (node46.html#SECTION00650000000000000000)\nShifting operations (node47.html#SECTION00660000000000000000)\nBinary bit-wise operations (node48.html#SECTION00670000000000000000)\nComparisons (node49.html#SECTION00680000000000000000)\nBoolean operations (node50.html#SECTION00690000000000000000)\nExpression lists and condition lists (node51.html#SECTION006100000000000000000)\nSummary (node52.html#SECTION006110000000000000000)\nSimple statements (node53.html#SECTION00700000000000000000)\n- Expression statements (node54.html#SECTION00710000000000000000)\nAssignment statements (node55.html#SECTION00720000000000000000)\nThe pass statement (node56.html#SECTION00730000000000000000)\nThe del statement (node57.html#SECTION00740000000000000000)\nThe print statement (node58.html#SECTION00750000000000000000)\nThe return statement (node59.html#SECTION00760000000000000000)\nThe raise statement (node60.html#SECTION00770000000000000000)\nThe break statement (node61.html#SECTION00780000000000000000)\nThe continue statement (node62.html#SECTION00790000000000000000)\nThe import statement (node63.html#SECTION007100000000000000000)\nThe global statement (node64.html#SECTION007110000000000000000)\nThe access statement (node65.html#SECTION007120000000000000000)\nThe exec statement (node66.html#SECTION007130000000000000000)\nCompound statements (node67.html#SECTION00800000000000000000)\n- The if statement (node68.html#SECTION00810000000000000000)\nThe while statement (node69.html#SECTION00820000000000000000)\nThe for statement (node70.html#SECTION00830000000000000000)\nThe try statement (node71.html#SECTION00840000000000000000)\nFunction definitions (node72.html#SECTION00850000000000000000)\nClass definitions (node73.html#SECTION00860000000000000000)\nTop-level components (node74.html#SECTION00900000000000000000)\n- Complete Python programs (node75.html#SECTION00910000000000000000)\nFile input (node76.html#SECTION00920000000000000000)\nInteractive input (node77.html#SECTION00930000000000000000)\nExpression input (node78.html#SECTION00940000000000000000)\nIndex (node79.html#SECTION001000000000000000000)\nAbout this document ... (node80.html#SECTION001100000000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 4932, "url": "https://docs.python.org/{python_version}/python-ref/node1.html"}
{"title": "Indentation", "text": "---\nnode11.html node5.html node9.html node1.html node79.html\n---\n## Indentation\nLeading whitespace (spaces and tabs) at the beginning of a logical\nline is used to compute the indentation level of the line, which in\nturn is used to determine the grouping of statements.\nFirst, tabs are replaced (from left to right) by one to eight spaces\nsuch that the total number of characters up to there is a multiple of\neight (this is intended to be the same rule as used by Unix). The\ntotal number of spaces preceding the first non-blank character then\ndetermines the line's indentation. Indentation cannot be split over\nmultiple physical lines using backslashes.\nThe indentation levels of consecutive lines are used to generate\nINDENT and DEDENT tokens, using a stack, as follows.\nBefore the first line of the file is read, a single zero is pushed on\nthe stack; this will never be popped off again. The numbers pushed on\nthe stack will always be strictly increasing from bottom to top. At\nthe beginning of each logical line, the line's indentation level is\ncompared to the top of the stack. If it is equal, nothing happens.\nIf it is larger, it is pushed on the stack, and one INDENT token is\ngenerated. If it is smaller, it must be one of the numbers\noccurring on the stack; all numbers on the stack that are larger are\npopped off, and for each number popped off a DEDENT token is\ngenerated. At the end of the file, a DEDENT token is generated for\neach number remaining on the stack that is larger than zero.\nHere is an example of a correctly (though confusingly) indented piece\nof Python code:\n```text\ndef perm(l):\n# Compute the list of all permutations of l\n\nif len(l) <= 1:\nreturn [l]\nr = []\nfor i in range(len(l)):\ns = l[:i] + l[i+1:]\np = perm(s)\nfor x in p:\nr.append(l[i:i+1] + x)\nreturn r\n```\nThe following example shows various indentation errors:\n```text\ndef perm(l): # error: first line indented\nfor i in range(len(l)): # error: not indented\ns = l[:i] + l[i+1:]\np = perm(l[:i] + l[i+1:]) # error: unexpected indent\nfor x in p:\nr.append(l[i:i+1] + x)\nreturn r # error: inconsistent dedent\n```\n(Actually, the first three errors are detected by the parser; only the\nlast error is found by the lexical analyzer --- the indentation of\n`return r` does not match a level popped off the stack.)\n---\nnode11.html node5.html node9.html node1.html node79.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 2367, "url": "https://docs.python.org/{python_version}/python-ref/node10.html"}
{"title": "Other tokens", "text": "---\nnode12.html node4.html node10.html node1.html node79.html\n---\n# Other tokens\nBesides NEWLINE, INDENT and DEDENT, the following categories of tokens\nexist: identifiers, keywords, literals, operators, and delimiters.\nSpaces and tabs are not tokens, but serve to delimit tokens. Where\nambiguity exists, a token comprises the longest possible string that\nforms a legal token, when read from left to right.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 422, "url": "https://docs.python.org/{python_version}/python-ref/node11.html"}
{"title": "Identifiers", "text": "---\nnode13.html node4.html node11.html node1.html node79.html\n---\n# Identifiers\nIdentifiers (also referred to as names) are described by the following\nlexical definitions:\n```text\nidentifier: (letter|\"_\") (letter|digit|\"_\")*\nletter: lowercase | uppercase\nlowercase: \"a\"...\"z\"\nuppercase: \"A\"...\"Z\"\ndigit: \"0\"...\"9\"\n```\nIdentifiers are unlimited in length. Case is significant.\n---\n- Keywords (node13.html#SECTION00331000000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 449, "url": "https://docs.python.org/{python_version}/python-ref/node12.html"}
{"title": "Keywords", "text": "---\nnode14.html node12.html node12.html node1.html node79.html\n---\n## Keywords\nThe following identifiers are used as reserved words, or\nkeywords of the language, and cannot be used as ordinary\nidentifiers. They must be spelled exactly as written here:\n```text\naccess del from lambda return\nand elif global not try\nbreak else if or while\nclass except import pass\ncontinue finally in print\ndef for is raise\n```\n---\nguido@cwi.nl", "python_version": "1.2", "length": 425, "url": "https://docs.python.org/{python_version}/python-ref/node13.html"}
{"title": "Literals", "text": "---\nnode15.html node4.html node13.html node1.html node79.html\n---\n# Literals\nLiterals are notations for constant values of some built-in types.\n---\n- String literals (node15.html#SECTION00341000000000000000)\nNumeric literals (node16.html#SECTION00342000000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 283, "url": "https://docs.python.org/{python_version}/python-ref/node14.html"}
{"title": "String literals", "text": "---\nnode16.html node14.html node14.html node1.html node79.html\n---\n## String literals\nString literals are described by the following lexical definitions:\n```text\nstringliteral: shortstring | longstring\nshortstring: \"'\" shortstringitem* \"'\" | '\"' shortstringitem* '\"'\nlongstring: \"'''\" longstringitem* \"'''\" | '\"\"\"' longstringitem* '\"\"\"'\nshortstringitem: shortstringchar | escapeseq\nshortstringchar: <any ASCII character except \"\\\" or newline or the quote>\nlongstringchar: <any ASCII character except \"\\\">\nescapeseq: \"\\\" <any ASCII character>\n```\nIn ``long strings'' (strings surrounded by sets of three quotes),\nunescaped newlines and quotes are allowed (and are retained), except\nthat three unescaped quotes in a row terminate the string. (A\n``quote'' is the character used to open the string, i.e. either\n`'` or `\"`.)\nEscape sequences in strings are interpreted according to rules similar\nto those used by Standard C. The recognized escape sequences are:\nIn strict compatibility with Standard C, up to three octal digits are\naccepted, but an unlimited number of hex digits is taken to be part of\nthe hex escape (and then the lower 8 bits of the resulting hex number\nare used in all current implementations...).\nAll unrecognized escape sequences are left in the string unchanged,\ni.e., the backslash is left in the string. (This behavior is\nuseful when debugging: if an escape sequence is mistyped, the\nresulting output is more easily recognized as broken. It also helps a\ngreat deal for string literals used as regular expressions or\notherwise passed to other modules that do their own escape handling.)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1622, "url": "https://docs.python.org/{python_version}/python-ref/node15.html"}
{"title": "Numeric literals", "text": "---\nnode17.html node14.html node15.html node1.html node79.html\n---\n## Numeric literals\nThere are three types of numeric literals: plain integers, long\nintegers, and floating point numbers.\nInteger and long integer literals are described by the following\nlexical definitions:\n```text\nlonginteger: integer (\"l\"|\"L\")\ninteger: decimalinteger | octinteger | hexinteger\ndecimalinteger: nonzerodigit digit* | \"0\"\noctinteger: \"0\" octdigit+\nhexinteger: \"0\" (\"x\"|\"X\") hexdigit+\n\nnonzerodigit: \"1\"...\"9\"\noctdigit: \"0\"...\"7\"\nhexdigit: digit|\"a\"...\"f\"|\"A\"...\"F\"\n```\nAlthough both lower case `l' and upper case `L' are allowed as suffix\nfor long integers, it is strongly recommended to always use `L', since\nthe letter `l' looks too much like the digit `1'.\nPlain integer decimal literals must be at most 2147483647 (i.e., the\nlargest positive integer, using 32-bit arithmetic). Plain octal and\nhexadecimal literals may be as large as 4294967295, but values larger\nthan 2147483647 are converted to a negative value by subtracting\n4294967296. There is no limit for long integer literals apart from\nwhat can be stored in available memory.\nSome examples of plain and long integer literals:\n```text\n7 2147483647 0177 0x80000000\n3L 79228162514264337593543950336L 0377L 0x100000000L\n```\nFloating point literals are described by the following lexical\ndefinitions:\n```text\nfloatnumber: pointfloat | exponentfloat\npointfloat: [intpart] fraction | intpart \".\"\nexponentfloat: (intpart | pointfloat) exponent\nintpart: digit+\nfraction: \".\" digit+\nexponent: (\"e\"|\"E\") [\"+\"|\"-\"] digit+\n```\nThe allowed range of floating point literals is\nimplementation-dependent.\nSome examples of floating point literals:\n```text\n3.14 10. .001 1e100 3.14e-10\n```\nNote that numeric literals do not include a sign; a phrase like\n`-1` is actually an expression composed of the operator\n`-` and the literal `1`.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1879, "url": "https://docs.python.org/{python_version}/python-ref/node16.html"}
{"title": "Operators", "text": "---\nnode18.html node4.html node16.html node1.html node79.html\n---\n# Operators\nThe following tokens are operators:\n```text\n+ - * / %\n<< >> & | ^ ~\n< == > <= <> != >=\n```\nThe comparison operators `<>` and `!=` are alternate\nspellings of the same operator.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 270, "url": "https://docs.python.org/{python_version}/python-ref/node17.html"}
{"title": "Delimiters", "text": "---\nnode19.html node4.html node17.html node1.html node79.html\n---\n# Delimiters\nThe following tokens serve as delimiters or otherwise have a special\nmeaning:\n```text\n( ) [ ] { }\n, : . \" ` '\n= ;\n```\nThe following printing ASCII characters are not used in Python. Their\noccurrence outside string literals and comments is an unconditional\nerror:\n```text\n@ $ ?\n```\nThey may be used by future versions of the language though!\n---\nguido@cwi.nl", "python_version": "1.2", "length": 436, "url": "https://docs.python.org/{python_version}/python-ref/node18.html"}
{"title": "Data model", "text": "---\nnode20.html ref.html node18.html node1.html node79.html\n---\n# Data model\n---\n- Objects, values and types (node20.html#SECTION00410000000000000000)\nThe standard type hierarchy (node21.html#SECTION00420000000000000000)\nSpecial method names (node22.html#SECTION00430000000000000000)\n- Special methods for any type (node23.html#SECTION00431000000000000000)\nSpecial methods for attribute access (node24.html#SECTION00432000000000000000)\nSpecial methods for sequence and mapping types (node25.html#SECTION00433000000000000000)\nSpecial methods for sequence types (node26.html#SECTION00434000000000000000)\nSpecial methods for numeric types (node27.html#SECTION00435000000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 694, "url": "https://docs.python.org/{python_version}/python-ref/node19.html"}
{"title": "Introduction", "text": "---\nnode3.html ref.html node1.html node1.html node79.html\n---\n# Introduction\nThis reference manual describes the Python programming language.\nIt is not intended as a tutorial.\nWhile I am trying to be as precise as possible, I chose to use English\nrather than formal specifications for everything except syntax and\nlexical analysis. This should make the document more understandable\nto the average reader, but will leave room for ambiguities.\nConsequently, if you were coming from Mars and tried to re-implement\nPython from this document alone, you might have to guess things and in\nfact you would probably end up implementing quite a different language.\nOn the other hand, if you are using\nPython and wonder what the precise rules about a particular area of\nthe language are, you should definitely be able to find them here.\nIt is dangerous to add too many implementation details to a language\nreference document --- the implementation may change, and other\nimplementations of the same language may work differently. On the\nother hand, there is currently only one Python implementation, and\nits particular quirks are sometimes worth being mentioned, especially\nwhere the implementation imposes additional limitations. Therefore,\nyou'll find short ``implementation notes'' sprinkled throughout the\ntext.\nEvery Python implementation comes with a number of built-in and\nstandard modules. These are not documented here, but in the separate\nPython Library Reference document. A few built-in modules are\nmentioned when they interact in a significant way with the language\ndefinition.\n---\n- Notation (node3.html#SECTION00210000000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1650, "url": "https://docs.python.org/{python_version}/python-ref/node2.html"}
{"title": "Objects, values and types", "text": "---\nnode21.html node19.html node19.html node1.html node79.html\n---\n# Objects, values and types\nObjects are Python's abstraction for data. All data in a Python\nprogram is represented by objects or by relations between objects.\n(In a sense, and in conformance to Von Neumann's model of a\n``stored program computer'', code is also represented by objects.)\nEvery object has an identity, a type and a value. An object's\nidentity never changes once it has been created; you may think of it\nas the object's address in memory. An object's type is also\nunchangeable. It determines the operations that an object supports\n(e.g. ``does it have a length?'') and also defines the possible\nvalues for objects of that type. The value of some objects can\nchange. Objects whose value can change are said to be mutable;\nobjects whose value is unchangeable once they are created are called\nimmutable. The type determines an object's (im)mutability.\nObjects are never explicitly destroyed; however, when they become\nunreachable they may be garbage-collected. An implementation is\nallowed to delay garbage collection or omit it altogether --- it is a\nmatter of implementation quality how garbage collection is\nimplemented, as long as no objects are collected that are still\nreachable. (Implementation note: the current implementation uses a\nreference-counting scheme which collects most objects as soon as they\nbecome unreachable, but never collects garbage containing circular\nreferences.)\nNote that the use of the implementation's tracing or debugging\nfacilities may keep objects alive that would normally be collectable.\nSome objects contain references to ``external'' resources such as open\nfiles or windows. It is understood that these resources are freed\nwhen the object is garbage-collected, but since garbage collection is\nnot guaranteed to happen, such objects also provide an explicit way to\nrelease the external resource, usually a `close` method.\nPrograms are strongly recommended to always explicitly close such\nobjects.\nSome objects contain references to other objects; these are called\ncontainers. Examples of containers are tuples, lists and\ndictionaries. The references are part of a container's value. In\nmost cases, when we talk about the value of a container, we imply the\nvalues, not the identities of the contained objects; however, when we\ntalk about the (im)mutability of a container, only the identities of\nthe immediately contained objects are implied. (So, if an immutable\ncontainer contains a reference to a mutable object, its value changes\nif that mutable object is changed.)\nTypes affect almost all aspects of objects' lives. Even the meaning\nof object identity is affected in some sense: for immutable types,\noperations that compute new values may actually return a reference to\nany existing object with the same type and value, while for mutable\nobjects this is not allowed. E.g. after\n```text\na = 1; b = 1; c = []; d = []\n```\n`a` and `b` may or may not refer to the same object with the\nvalue one, depending on the implementation, but `c` and `d`\nare guaranteed to refer to two different, unique, newly created empty\nlists.\n---\nnode21.html node19.html node19.html node1.html node79.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 3219, "url": "https://docs.python.org/{python_version}/python-ref/node20.html"}
{"title": "The standard type hierarchy", "text": "---\nnode22.html node19.html node20.html node1.html node79.html\n---\n# The standard type hierarchy\nBelow is a list of the types that are built into Python. Extension\nmodules written in C can define additional types. Future versions of\nPython may add types to the type hierarchy (e.g. rational or complex\nnumbers, efficiently stored arrays of integers, etc.).\nSome of the type descriptions below contain a paragraph listing\n`special attributes'. These are attributes that provide access to the\nimplementation and are not intended for general use. Their definition\nmay change in the future. There are also some `generic' special\nattributes, not listed with the individual objects: `__methods__`\nis a list of the method names of a built-in object, if it has any;\n`__members__` is a list of the data attribute names of a built-in\nobject, if it has any.\n---\nnode22.html node19.html node20.html node1.html node79.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 930, "url": "https://docs.python.org/{python_version}/python-ref/node21.html"}
{"title": "Special method names", "text": "---\nnode23.html node19.html node21.html node1.html node79.html\n---\n# Special method names\nA class can implement certain operations that are invoked by special\nsyntax (such as subscription or arithmetic operations) by defining\nmethods with special names. For instance, if a class defines a\nmethod named `__getitem__`, and `x` is an instance of this\nclass, then `x[i]` is equivalent to `x.__getitem__(i)`.\n(The reverse is not true --- if `x` is a list object,\n`x.__getitem__(i)` is not equivalent to `x[i]`.)\nExcept for `__repr__`, `__str__` and `__cmp__`,\nattempts to execute an\noperation raise an exception when no appropriate method is defined.\nFor `__repr__`, the default is to return a string describing the\nobject's class and address.\nFor `__cmp__`, the default is to compare instances based on their\naddress.\nFor `__str__`, the default is to use `__repr__`.\n---\n- Special methods for any type (node23.html#SECTION00431000000000000000)\nSpecial methods for attribute access (node24.html#SECTION00432000000000000000)\nSpecial methods for sequence and mapping types (node25.html#SECTION00433000000000000000)\nSpecial methods for sequence types (node26.html#SECTION00434000000000000000)\nSpecial methods for numeric types (node27.html#SECTION00435000000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1277, "url": "https://docs.python.org/{python_version}/python-ref/node22.html"}
{"title": "Special methods for any type", "text": "---\nnode24.html node22.html node22.html node1.html node79.html\n---\n## Special methods for any type\n---\nnode24.html node22.html node22.html node1.html node79.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 182, "url": "https://docs.python.org/{python_version}/python-ref/node23.html"}
{"title": "Special methods for attribute access", "text": "---\nnode25.html node22.html node23.html node1.html node79.html\n---\n## Special methods for attribute access\nThe following methods can be used to change the meaning of attribute\naccess for class instances.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 220, "url": "https://docs.python.org/{python_version}/python-ref/node24.html"}
{"title": "Special methods for sequence and mapping types", "text": "---\nnode26.html node22.html node24.html node1.html node79.html\n---\n## Special methods for sequence and mapping types\n---\nguido@cwi.nl", "python_version": "1.2", "length": 133, "url": "https://docs.python.org/{python_version}/python-ref/node25.html"}
{"title": "Special methods for sequence types", "text": "---\nnode27.html node22.html node25.html node1.html node79.html\n---\n## Special methods for sequence types\n---\nguido@cwi.nl", "python_version": "1.2", "length": 121, "url": "https://docs.python.org/{python_version}/python-ref/node26.html"}
{"title": "Special methods for numeric types", "text": "---\nnode28.html node22.html node26.html node1.html node79.html\n---\n## Special methods for numeric types\n---\nnode28.html node22.html node26.html node1.html node79.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 187, "url": "https://docs.python.org/{python_version}/python-ref/node27.html"}
{"title": "Execution model", "text": "---\nnode29.html ref.html node27.html node1.html node79.html\n---\n# Execution model\n---\n- Code blocks, execution frames, and name spaces (node29.html#SECTION00510000000000000000)\nExceptions (node30.html#SECTION00520000000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 246, "url": "https://docs.python.org/{python_version}/python-ref/node28.html"}
{"title": "Code blocks, execution frames, and name spaces", "text": "---\nnode30.html node28.html node28.html node1.html node79.html\n---\n# Code blocks, execution frames, and name spaces\nA code block is a piece of Python program text that can be\nexecuted as a unit, such as a module, a class definition or a function\nbody. Some code blocks (like modules) are executed only once, others\n(like function bodies) may be executed many times. Code blocks may\ntextually contain other code blocks. Code blocks may invoke other\ncode blocks (that may or may not be textually contained in them) as\npart of their execution, e.g. by invoking (calling) a function.\nThe following are code blocks: A module is a code block. A function\nbody is a code block. A class definition is a code block. Each\ncommand typed interactively is a separate code block; a script file is\na code block. The string argument passed to the built-in function\n`eval` and to the `exec` statement are code blocks.\nAnd finally, the\nexpression read and evaluated by the built-in function `input` is\na code block.\nA code block is executed in an execution frame. An execution\nframe contains some administrative information (used for debugging),\ndetermines where and how execution continues after the code block's\nexecution has completed, and (perhaps most importantly) defines two\nname spaces, the local and the global name space, that affect\nexecution of the code block.\nA name space is a mapping from names (identifiers) to objects.\nA particular name space may be referenced by more than one execution\nframe, and from other places as well. Adding a name to a name space\nis called binding a name (to an object); changing the mapping of\na name is called rebinding; removing a name is unbinding.\nName spaces are functionally equivalent to dictionaries.\nThe local name space of an execution frame determines the default\nplace where names are defined and searched. The global name\nspace determines the place where names listed in `global`\nstatements are defined and searched, and where names that are not\nexplicitly bound in the current code block are searched.\nWhether a name is local or global in a code block is determined by\nstatic inspection of the source text for the code block: in the\nabsence of `global` statements, a name that is bound anywhere in\nthe code block is local in the entire code block; all other names are\nconsidered global. The `global` statement forces global\ninterpretation of selected names throughout the code block. The\nfollowing constructs bind names: formal parameters, `import`\nstatements, class and function definitions (these bind the class or\nfunction name), and targets that are identifiers if occurring in an\nassignment, `for` loop header, or `except` clause header.\nA target occurring in a `del` statement is also considered bound\nfor this purpose (though the actual semantics are to ``unbind'' the\nname).\nWhen a global name is not found in the global name space, it is\nsearched in the list of ``built-in'' names (which is actually the\nglobal name space of the module `__builtin__`). When a name is not\nfound at all, the `NameError` exception is raised.\nfootnode.html#585\nThe following table lists the meaning of the local and global name\nspace for various types of code blocks. The name space for a\nparticular module is automatically created when the module is first\nreferenced. Note that in almost all cases, the global name space is\nthe name space of the containing module --- scopes in Python do not\nnest!\nNotes:\nThe built-in function `vars()` returns a dictionary representing\nthe current local name space. The effect of modifications to this\ndictionary on the name space are undefined.\nfootnode.html#586\n---\nnode30.html node28.html node28.html node1.html node79.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 3709, "url": "https://docs.python.org/{python_version}/python-ref/node29.html"}
{"title": "Notation", "text": "---\nnode4.html node2.html node2.html node1.html node79.html\n---\n# Notation\nThe descriptions of lexical analysis and syntax use a modified BNF\ngrammar notation. This uses the following style of definition:\n```text\nname: lc_letter (lc_letter | \"_\")*\nlc_letter: \"a\"...\"z\"\n```\nThe first line says that a `name` is an `lc_letter` followed by\na sequence of zero or more `lc_letter`s and underscores. An\n`lc_letter` in turn is any of the single characters `a' through `z'.\n(This rule is actually adhered to for the names defined in lexical and\ngrammar rules in this document.)\nEach rule begins with a name (which is the name defined by the rule)\nand a colon. A vertical bar (`|`) is used to separate\nalternatives; it is the least binding operator in this notation. A\nstar (`*`) means zero or more repetitions of the preceding item;\nlikewise, a plus (`+`) means one or more repetitions, and a\nphrase enclosed in square brackets (`[ ]`) means zero or one\noccurrences (in other words, the enclosed phrase is optional). The\n`*` and `+` operators bind as tightly as possible;\nparentheses are used for grouping. Literal strings are enclosed in\nquotes. White space is only meaningful to separate tokens.\nRules are normally contained on a single line; rules with many\nalternatives may be formatted alternatively with each line after the\nfirst beginning with a vertical bar.\nIn lexical definitions (as the example above), two more conventions\nare used: Two literal characters separated by three dots mean a choice\nof any single character in the given (inclusive) range of ASCII\ncharacters. A phrase between angular brackets (`<...>`) gives an\ninformal description of the symbol defined; e.g. this could be used\nto describe the notion of `control character' if needed.\nEven though the notation used is almost the same, there is a big\ndifference between the meaning of lexical and syntactic definitions:\na lexical definition operates on the individual characters of the\ninput source, while a syntax definition operates on the stream of\ntokens generated by the lexical analysis. All uses of BNF in the next\nchapter (``Lexical Analysis'') are lexical definitions; uses in\nsubsequent chapters are syntactic definitions.\n---\nnode4.html node2.html node2.html node1.html node79.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 2279, "url": "https://docs.python.org/{python_version}/python-ref/node3.html"}
{"title": "Exceptions", "text": "---\nnode31.html node28.html node29.html node1.html node79.html\n---\n# Exceptions\nExceptions are a means of breaking out of the normal flow of control\nof a code block in order to handle errors or other exceptional\nconditions. An exception is raised at the point where the error\nis detected; it may be handled by the surrounding code block or\nby any code block that directly or indirectly invoked the code block\nwhere the error occurred.\nThe Python interpreter raises an exception when it detects an run-time\nerror (such as division by zero). A Python program can also\nexplicitly raise an exception with the `raise` statement.\nException handlers are specified with the `try...except`\nstatement.\nPython uses the ``termination'' model of error handling: an exception\nhandler can find out what happened and continue execution at an outer\nlevel, but it cannot repair the cause of the error and retry the\nfailing operation (except by re-entering the the offending piece of\ncode from the top).\nWhen an exception is not handled at all, the interpreter terminates\nexecution of the program, or returns to its interactive main loop.\nExceptions are identified by string objects. Two different string\nobjects with the same value identify different exceptions.\nWhen an exception is raised, an object (maybe `None`) is passed\nas the exception's ``parameter''; this object does not affect the\nselection of an exception handler, but is passed to the selected\nexception handler as additional information.\nSee also the description of the `try` and `raise`\nstatements.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1563, "url": "https://docs.python.org/{python_version}/python-ref/node30.html"}
{"title": "Expressions and conditions", "text": "---\nnode32.html ref.html node30.html node1.html node79.html\n---\n# Expressions and conditions\nNote: In this and the following chapters, extended BNF notation\nwill be used to describe syntax, not lexical analysis.\nThis chapter explains the meaning of the elements of expressions and\nconditions. Conditions are a superset of expressions, and a condition\nmay be used wherever an expression is required by enclosing it in\nparentheses. The only places where expressions are used in the syntax\ninstead of conditions is in expression statements and on the\nright-hand side of assignment statements; this catches some nasty bugs\nlike accidentally writing `x == 1` instead of `x = 1`.\nThe comma plays several roles in Python's syntax. It is usually an\noperator with a lower precedence than all others, but occasionally\nserves other purposes as well; e.g. it separates function arguments,\nis used in list and dictionary constructors, and has special semantics\nin `print` statements.\nWhen (one alternative of) a syntax rule has the form\n```text\nname: othername\n```\nand no semantics are given, the semantics of this form of `name`\nare the same as for `othername`.\n---\n- Arithmetic conversions (node32.html#SECTION00610000000000000000)\nAtoms (node33.html#SECTION00620000000000000000)\n- Identifiers (Names) (node34.html#SECTION00621000000000000000)\nLiterals (node35.html#SECTION00622000000000000000)\nParenthesized forms (node36.html#SECTION00623000000000000000)\nList displays (node37.html#SECTION00624000000000000000)\nDictionary displays (node38.html#SECTION00625000000000000000)\nString conversions (node39.html#SECTION00626000000000000000)\nPrimaries (node40.html#SECTION00630000000000000000)\n- Attribute references (node41.html#SECTION00631000000000000000)\nSubscriptions (node42.html#SECTION00632000000000000000)\nSlicings (node43.html#SECTION00633000000000000000)\nCalls (node44.html#SECTION00634000000000000000)\nUnary arithmetic operations (node45.html#SECTION00640000000000000000)\nBinary arithmetic operations (node46.html#SECTION00650000000000000000)\nShifting operations (node47.html#SECTION00660000000000000000)\nBinary bit-wise operations (node48.html#SECTION00670000000000000000)\nComparisons (node49.html#SECTION00680000000000000000)\nBoolean operations (node50.html#SECTION00690000000000000000)\nExpression lists and condition lists (node51.html#SECTION006100000000000000000)\nSummary (node52.html#SECTION006110000000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 2431, "url": "https://docs.python.org/{python_version}/python-ref/node31.html"}
{"title": "Arithmetic conversions", "text": "---\nnode33.html node31.html node31.html node1.html node79.html\n---\n# Arithmetic conversions\nWhen a description of an arithmetic operator below uses the phrase\n``the numeric arguments are converted to a common type'',\nthis both means that if either argument is not a number, a\n`TypeError` exception is raised, and that otherwise\nthe following conversions are applied:\n- first, if either argument is a floating point number,\nthe other is converted to floating point;\nelse, if either argument is a long integer,\nthe other is converted to long integer;\notherwise, both must be plain integers and no conversion\nis necessary.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 636, "url": "https://docs.python.org/{python_version}/python-ref/node32.html"}
{"title": "Atoms", "text": "---\nnode34.html node31.html node32.html node1.html node79.html\n---\n# Atoms\nAtoms are the most basic elements of expressions. Forms enclosed in\nreverse quotes or in parentheses, brackets or braces are also\ncategorized syntactically as atoms. The syntax for atoms is:\n```text\natom: identifier | literal | enclosure\nenclosure: parenth_form | list_display | dict_display | string_conversion\n```\n---\n- Identifiers (Names) (node34.html#SECTION00621000000000000000)\nLiterals (node35.html#SECTION00622000000000000000)\nParenthesized forms (node36.html#SECTION00623000000000000000)\nList displays (node37.html#SECTION00624000000000000000)\nDictionary displays (node38.html#SECTION00625000000000000000)\nString conversions (node39.html#SECTION00626000000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 767, "url": "https://docs.python.org/{python_version}/python-ref/node33.html"}
{"title": "Identifiers (Names)", "text": "---\nnode35.html node33.html node33.html node1.html node79.html\n---\n## Identifiers (Names)\nAn identifier occurring as an atom is a reference to a local, global\nor built-in name binding. If a name is assigned to anywhere in a code\nblock (even in unreachable code), and is not mentioned in a\n`global` statement in that code block, then it refers to a local\nname throughout that code block. When it is not assigned to anywhere\nin the block, or when it is assigned to but also explicitly listed in\na `global` statement, it refers to a global name if one exists,\nelse to a built-in name (and this binding may dynamically change).\nWhen the name is bound to an object, evaluation of the atom yields\nthat object. When a name is not bound, an attempt to evaluate it\nraises a `NameError` exception.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 804, "url": "https://docs.python.org/{python_version}/python-ref/node34.html"}
{"title": "Literals", "text": "---\nnode36.html node33.html node34.html node1.html node79.html\n---\n## Literals\nPython knows string and numeric literals:\n```text\nliteral: stringliteral | integer | longinteger | floatnumber\n```\nEvaluation of a literal yields an object of the given type (string,\ninteger, long integer, floating point number) with the given value.\nThe value may be approximated in the case of floating point literals.\nSee section node14.html#literals for details.\nAll literals correspond to immutable data types, and hence the\nobject's identity is less important than its value. Multiple\nevaluations of literals with the same value (either the same\noccurrence in the program text or a different occurrence) may obtain\nthe same object or a different object with the same value.\n(In the original implementation, all literals in the same code block\nwith the same type and value yield the same object.)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 897, "url": "https://docs.python.org/{python_version}/python-ref/node35.html"}
{"title": "Parenthesized forms", "text": "---\nnode37.html node33.html node35.html node1.html node79.html\n---\n## Parenthesized forms\nA parenthesized form is an optional condition list enclosed in\nparentheses:\n```text\nparenth_form: \"(\" [condition_list] \")\"\n```\nA parenthesized condition list yields whatever that condition list\nyields.\nAn empty pair of parentheses yields an empty tuple object. Since\ntuples are immutable, the rules for literals apply here.\n(Note that tuples are not formed by the parentheses, but rather by use\nof the comma operator. The exception is the empty tuple, for which\nparentheses are required --- allowing unparenthesized ``nothing''\nin expressions would cause ambiguities and allow common typos to\npass uncaught.)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 715, "url": "https://docs.python.org/{python_version}/python-ref/node36.html"}
{"title": "List displays", "text": "---\nnode38.html node33.html node36.html node1.html node79.html\n---\n## List displays\nA list display is a possibly empty series of conditions enclosed in\nsquare brackets:\n```text\nlist_display: \"[\" [condition_list] \"]\"\n```\nA list display yields a new list object.\nIf it has no condition list, the list object has no items. Otherwise,\nthe elements of the condition list are evaluated from left to right\nand inserted in the list object in that order.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 462, "url": "https://docs.python.org/{python_version}/python-ref/node37.html"}
{"title": "Dictionary displays", "text": "---\nnode39.html node33.html node37.html node1.html node79.html\n---\n## Dictionary displays\nA dictionary display is a possibly empty series of key/datum pairs\nenclosed in curly braces:\n```text\ndict_display: \"{\" [key_datum_list] \"}\"\nkey_datum_list: key_datum (\",\" key_datum)* [\",\"]\nkey_datum: condition \":\" condition\n```\nA dictionary display yields a new dictionary object.\nThe key/datum pairs are evaluated from left to right to define the\nentries of the dictionary: each key object is used as a key into the\ndictionary to store the corresponding datum.\nRestrictions on the types of the key values are listed earlier in\nsection node21.html#types.\nClashes between duplicate keys are not detected; the last\ndatum (textually rightmost in the display) stored for a given key\nvalue prevails.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 801, "url": "https://docs.python.org/{python_version}/python-ref/node38.html"}
{"title": "String conversions", "text": "---\nnode40.html node33.html node38.html node1.html node79.html\n---\n## String conversions\nA string conversion is a condition list enclosed in reverse (or\nbackward) quotes:\n```text\nstring_conversion: \"`\" condition_list \"`\"\n```\nA string conversion evaluates the contained condition list and\nconverts the resulting object into a string according to rules\nspecific to its type.\nIf the object is a string, a number, `None`, or a tuple, list or\ndictionary containing only objects whose type is one of these, the\nresulting string is a valid Python expression which can be passed to\nthe built-in function `eval()` to yield an expression with the\nsame value (or an approximation, if floating point numbers are\ninvolved).\n(In particular, converting a string adds quotes around it and converts\n``funny'' characters to escape sequences that are safe to print.)\nIt is illegal to attempt to convert recursive objects (e.g. lists or\ndictionaries that contain a reference to themselves, directly or\nindirectly.)\nThe built-in function `repr()` performs exactly the same\nconversion in its argument as enclosing it it reverse quotes does.\nThe built-in function `str()` performs a similar but more\nuser-friendly conversion.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1219, "url": "https://docs.python.org/{python_version}/python-ref/node39.html"}
{"title": "Lexical analysis", "text": "---\nnode5.html ref.html node3.html node1.html node79.html\n---\n# Lexical analysis\nA Python program is read by a parser. Input to the parser is a\nstream of tokens, generated by the lexical analyzer. This\nchapter describes how the lexical analyzer breaks a file into tokens.\n---\n- Line structure (node5.html#SECTION00310000000000000000)\n- Comments (node6.html#SECTION00311000000000000000)\nExplicit line joining (node7.html#SECTION00312000000000000000)\nImplicit line joining (node8.html#SECTION00313000000000000000)\nBlank lines (node9.html#SECTION00314000000000000000)\nIndentation (node10.html#SECTION00315000000000000000)\nOther tokens (node11.html#SECTION00320000000000000000)\nIdentifiers (node12.html#SECTION00330000000000000000)\n- Keywords (node13.html#SECTION00331000000000000000)\nLiterals (node14.html#SECTION00340000000000000000)\n- String literals (node15.html#SECTION00341000000000000000)\nNumeric literals (node16.html#SECTION00342000000000000000)\nOperators (node17.html#SECTION00350000000000000000)\nDelimiters (node18.html#SECTION00360000000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1072, "url": "https://docs.python.org/{python_version}/python-ref/node4.html"}
{"title": "Primaries", "text": "---\nnode41.html node31.html node39.html node1.html node79.html\n---\n# Primaries\nPrimaries represent the most tightly bound operations of the language.\nTheir syntax is:\n```text\nprimary: atom | attributeref | subscription | slicing | call\n```\n---\n- Attribute references (node41.html#SECTION00631000000000000000)\nSubscriptions (node42.html#SECTION00632000000000000000)\nSlicings (node43.html#SECTION00633000000000000000)\nCalls (node44.html#SECTION00634000000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 480, "url": "https://docs.python.org/{python_version}/python-ref/node40.html"}
{"title": "Attribute references", "text": "---\nnode42.html node40.html node40.html node1.html node79.html\n---\n## Attribute references\nAn attribute reference is a primary followed by a period and a name:\n```text\nattributeref: primary \".\" identifier\n```\nThe primary must evaluate to an object of a type that supports\nattribute references, e.g. a module or a list. This object is then\nasked to produce the attribute whose name is the identifier. If this\nattribute is not available, the exception `AttributeError` is\nraised. Otherwise, the type and value of the object produced is\ndetermined by the object. Multiple evaluations of the same attribute\nreference may yield different objects.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 658, "url": "https://docs.python.org/{python_version}/python-ref/node41.html"}
{"title": "Subscriptions", "text": "---\nnode43.html node40.html node41.html node1.html node79.html\n---\n## Subscriptions\nA subscription selects an item of a sequence (string, tuple or list)\nor mapping (dictionary) object:\n```text\nsubscription: primary \"[\" condition \"]\"\n```\nThe primary must evaluate to an object of a sequence or mapping type.\nIf it is a mapping, the condition must evaluate to an object whose\nvalue is one of the keys of the mapping, and the subscription selects\nthe value in the mapping that corresponds to that key.\nIf it is a sequence, the condition must evaluate to a plain integer.\nIf this value is negative, the length of the sequence is added to it\n(so that, e.g. `x[-1]` selects the last item of `x`.)\nThe resulting value must be a nonnegative integer smaller than the\nnumber of items in the sequence, and the subscription selects the item\nwhose index is that value (counting from zero).\nA string's items are characters. A character is not a separate data\ntype but a string of exactly one character.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1005, "url": "https://docs.python.org/{python_version}/python-ref/node42.html"}
{"title": "Slicings", "text": "---\nnode44.html node40.html node42.html node1.html node79.html\n---\n## Slicings\nA slicing (or slice) selects a range of items in a sequence (string,\ntuple or list) object:\n```text\nslicing: primary \"[\" [condition] \":\" [condition] \"]\"\n```\nThe primary must evaluate to a sequence object. The lower and upper\nbound expressions, if present, must evaluate to plain integers;\ndefaults are zero and the sequence's length, respectively. If either\nbound is negative, the sequence's length is added to it. The slicing\nnow selects all items with index k such that\n`i <= k < j` where i\nand j are the specified lower and upper bounds. This may be an\nempty sequence. It is not an error if i or j lie outside the\nrange of valid indexes (such items don't exist so they aren't\nselected).\n---\nguido@cwi.nl", "python_version": "1.2", "length": 785, "url": "https://docs.python.org/{python_version}/python-ref/node43.html"}
{"title": "Calls", "text": "---\nnode45.html node40.html node43.html node1.html node79.html\n---\n## Calls\nA call calls a callable object (e.g. a function) with a possibly empty\nseries of arguments:\n```text\ncall: primary \"(\" [condition_list] \")\"\n```\nThe primary must evaluate to a callable object (user-defined\nfunctions, built-in functions, methods of built-in objects, class\nobjects, and methods of class instances are callable). If it is a\nclass, the argument list must be empty; otherwise, the arguments are\nevaluated.\nA call always returns some value, possibly `None`, unless it\nraises an exception. How this value is computed depends on the type\nof the callable object. If it is:\n---\nguido@cwi.nl", "python_version": "1.2", "length": 671, "url": "https://docs.python.org/{python_version}/python-ref/node44.html"}
{"title": "Unary arithmetic operations", "text": "---\nnode46.html node31.html node44.html node1.html node79.html\n---\n# Unary arithmetic operations\nAll unary arithmetic (and bit-wise) operations have the same priority:\n```text\nu_expr: primary | \"-\" u_expr | \"+\" u_expr | \"~\" u_expr\n```\nThe unary `\"-\"` (minus) operator yields the negation of its\nnumeric argument.\nThe unary `\"+\"` (plus) operator yields its numeric argument\nunchanged.\nThe unary `\"~\"` (invert) operator yields the bit-wise inversion\nof its plain or long integer argument. The bit-wise inversion of\n`x` is defined as `-(x+1)`.\nIn all three cases, if the argument does not have the proper type,\na `TypeError` exception is raised.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 659, "url": "https://docs.python.org/{python_version}/python-ref/node45.html"}
{"title": "Binary arithmetic operations", "text": "---\nnode47.html node31.html node45.html node1.html node79.html\n---\n# Binary arithmetic operations\nThe binary arithmetic operations have the conventional priority\nlevels. Note that some of these operations also apply to certain\nnon-numeric types. There is no ``power'' operator, so there are only\ntwo levels, one for multiplicative operators and one for additive\noperators:\n```text\nm_expr: u_expr | m_expr \"*\" u_expr\n| m_expr \"/\" u_expr | m_expr \"%\" u_expr\na_expr: m_expr | aexpr \"+\" m_expr | aexpr \"-\" m_expr\n```\nThe `\"*\"` (multiplication) operator yields the product of its\narguments. The arguments must either both be numbers, or one argument\nmust be a plain integer and the other must be a sequence. In the\nformer case, the numbers are converted to a common type and then\nmultiplied together. In the latter case, sequence repetition is\nperformed; a negative repetition factor yields an empty sequence.\nThe `\"/\"` (division) operator yields the quotient of its\narguments. The numeric arguments are first converted to a common\ntype. Plain or long integer division yields an integer of the same\ntype; the result is that of mathematical division with the `floor'\nfunction applied to the result. Division by zero raises the\n`ZeroDivisionError` exception.\nThe `\"%\"` (modulo) operator yields the remainder from the\ndivision of the first argument by the second. The numeric arguments\nare first converted to a common type. A zero right argument raises\nthe `ZeroDivisionError` exception. The arguments may be floating\npoint numbers, e.g. `3.14 % 0.7` equals `0.34`. The modulo\noperator always yields a result with the same sign as its second\noperand (or zero); the absolute value of the result is strictly\nsmaller than the second operand.\nThe integer division and modulo operators are connected by the\nfollowing identity: `x == (x/y)*y + (x%y)`. Integer division and\nmodulo are also connected with the built-in function `divmod()`:\n`divmod(x, y) == (x/y, x%y)`. These identities don't hold for\nfloating point numbers; there a similar identity holds where\n`x/y` is replaced by `floor(x/y)`).\nThe `\"+\"` (addition) operator yields the sum of its arguments.\nThe arguments must either both be numbers, or both sequences of the\nsame type. In the former case, the numbers are converted to a common\ntype and then added together. In the latter case, the sequences are\nconcatenated.\nThe `\"-\"` (subtraction) operator yields the difference of its\narguments. The numeric arguments are first converted to a common\ntype.\n---\nnode47.html node31.html node45.html node1.html node79.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 2581, "url": "https://docs.python.org/{python_version}/python-ref/node46.html"}
{"title": "Shifting operations", "text": "---\nnode48.html node31.html node46.html node1.html node79.html\n---\n# Shifting operations\nThe shifting operations have lower priority than the arithmetic\noperations:\n```text\nshift_expr: a_expr | shift_expr ( \"<<\" | \">>\" ) a_expr\n```\nThese operators accept plain or long integers as arguments. The\narguments are converted to a common type. They shift the first\nargument to the left or right by the number of bits given by the\nsecond argument.\nA right shift by n bits is defined as division by\n`pow(2, n )`. A left shift by n bits is defined as\nmultiplication with `pow(2, n )`; for plain integers there is\nno overflow check so this drops bits and flips the sign if the result\nis not less than `pow(2,31)` in absolute value.\nNegative shift counts raise a `ValueError` exception.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 792, "url": "https://docs.python.org/{python_version}/python-ref/node47.html"}
{"title": "Binary bit-wise operations", "text": "---\nnode49.html node31.html node47.html node1.html node79.html\n---\n# Binary bit-wise operations\nEach of the three bitwise operations has a different priority level:\n```text\nand_expr: shift_expr | and_expr \"&\" shift_expr\nxor_expr: and_expr | xor_expr \"^\" and_expr\nor_expr: xor_expr | or_expr \"|\" xor_expr\n```\nThe `\"&\"` operator yields the bitwise AND of its arguments, which\nmust be plain or long integers. The arguments are converted to a\ncommon type.\nThe `\"^\"` operator yields the bitwise XOR (exclusive OR) of its\narguments, which must be plain or long integers. The arguments are\nconverted to a common type.\nThe `\"|\"` operator yields the bitwise (inclusive) OR of its\narguments, which must be plain or long integers. The arguments are\nconverted to a common type.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 782, "url": "https://docs.python.org/{python_version}/python-ref/node48.html"}
{"title": "Comparisons", "text": "---\nnode50.html node31.html node48.html node1.html node79.html\n---\n# Comparisons\nContrary to C, all comparison operations in Python have the same\npriority, which is lower than that of any arithmetic, shifting or\nbitwise operation. Also contrary to C, expressions like\n`a < b < c` have the interpretation that is conventional in\nmathematics:\n```text\ncomparison: or_expr (comp_operator or_expr)*\ncomp_operator: \"<\"|\">\"|\"==\"|\">=\"|\"<=\"|\"<>\"|\"!=\"|\"is\" [\"not\"]|[\"not\"] \"in\"\n```\nComparisons yield integer values: 1 for true, 0 for false.\nComparisons can be chained arbitrarily, e.g. `x < y <= z` is\nequivalent to `x < y and y <= z`, except that `y` is\nevaluated only once (but in both cases `z` is not evaluated at all\nwhen `x < y` is found to be false).\nFormally, if a, b, c, ..., y, z are\nexpressions and opa, opb, ..., opy are comparison\noperators, then a opa b opb c ...y opy z is equivalent\nto a opa b `and` b opb c `and` ...`and`\ny opy z, except that each expression is evaluated at most once.\nNote that a opa b opb c doesn't imply any kind of comparison\nbetween a and c, so that e.g. `x < y > z` is\nperfectly legal (though perhaps not pretty).\nThe forms `<>` and `!=` are equivalent; for consistency with\nC, `!=` is preferred; where `!=` is mentioned below\n`<>` is also implied.\nThe operators \"<\", \">\", \"==\", \">=\", \"<=\", and \"!=\" compare\nthe values of two objects. The objects needn't have the same type.\nIf both are numbers, they are coverted to a common type. Otherwise,\nobjects of different types always compare unequal, and are\nordered consistently but arbitrarily.\n(This unusual definition of comparison is done to simplify the\ndefinition of operations like sorting and the `in` and\n`not` `in` operators.)\nComparison of objects of the same type depends on the type:\n- Numbers are compared arithmetically.\nStrings are compared lexicographically using the numeric equivalents\n(the result of the built-in function `ord`) of their characters.\nTuples and lists are compared lexicographically using comparison of\ncorresponding items.\nMappings (dictionaries) are compared through lexicographic\ncomparison of their sorted (key, value) lists.\nfootnode.html#937\nMost other types compare unequal unless they are the same object;\nthe choice whether one object is considered smaller or larger than\nanother one is made arbitrarily but consistently within one\nexecution of a program.\nThe operators `in` and `not in` test for sequence\nmembership: if y is a sequence, `x in y` is\ntrue if and only if there exists an index i such that\n`x = y [ i ]`.\n`x not in y` yields the inverse truth value. The\nexception `TypeError` is raised when y is not a sequence,\nor when y is a string and x is not a string of length one.\nfootnode.html#827\nThe operators `is` and `is not` test for object identity:\nx `is` y is true if and only if x and y\nare the same object. x `is not` y yields the inverse\ntruth value.\n---\nnode50.html node31.html node48.html node1.html node79.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 2968, "url": "https://docs.python.org/{python_version}/python-ref/node49.html"}
{"title": "Line structure", "text": "---\nnode6.html node4.html node4.html node1.html node79.html\n---\n# Line structure\nA Python program is divided in a number of logical lines. The end of\na logical line is represented by the token NEWLINE. Statements cannot\ncross logical line boundaries except where NEWLINE is allowed by the\nsyntax (e.g. between statements in compound statements).\n---\n- Comments (node6.html#SECTION00311000000000000000)\nExplicit line joining (node7.html#SECTION00312000000000000000)\nImplicit line joining (node8.html#SECTION00313000000000000000)\nBlank lines (node9.html#SECTION00314000000000000000)\nIndentation (node10.html#SECTION00315000000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 651, "url": "https://docs.python.org/{python_version}/python-ref/node5.html"}
{"title": "Boolean operations", "text": "---\nnode51.html node31.html node49.html node1.html node79.html\n---\n# Boolean operations\nBoolean operations have the lowest priority of all Python operations:\n```text\ncondition: or_test | lambda_form\nor_test: and_test | or_test \"or\" and_test\nand_test: not_test | and_test \"and\" not_test\nnot_test: comparison | \"not\" not_test\nlambda_form: \"lambda\" [parameter_list]: condition\n```\nIn the context of Boolean operations, and also when conditions are\nused by control flow statements, the following values are interpreted\nas false: `None`, numeric zero of all types, empty sequences\n(strings, tuples and lists), and empty mappings (dictionaries). All\nother values are interpreted as true.\nThe operator `not` yields 1 if its argument is false, 0 otherwise.\nThe condition x `and` y first evaluates x; if\nx is false, its value is returned; otherwise, y is\nevaluated and the resulting value is returned.\nThe condition x `or` y first evaluates x; if\nx is true, its value is returned; otherwise, y is\nevaluated and the resulting value is returned.\n(Note that `and` and `or` do not restrict the value and type\nthey return to 0 and 1, but rather return the last evaluated argument.\nThis is sometimes useful, e.g. if `s` is a string that should be\nreplaced by a default value if it is empty, the expression\n`s or 'foo'` yields the desired value. Because `not` has to\ninvent a value anyway, it does not bother to return a value of the\nsame type as its argument, so e.g. `not 'foo'` yields `0`,\nnot `''`.)\nLambda forms (lambda expressions) have the same syntactic position as\nconditions. They are a shorthand to create anonymous functions; the\nexpression lambda arguments: condition\nyields a function object that behaves virtually identical to one\ndefined with\ndef name (arguments): return condition.\nSee section node72.html#function for the syntax of\nparameter lists. Note that functions created with lambda forms cannot\ncontain statements.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1940, "url": "https://docs.python.org/{python_version}/python-ref/node50.html"}
{"title": "Expression lists and condition lists", "text": "---\nnode52.html node31.html node50.html node1.html node79.html\n---\n# Expression lists and condition lists\n```text\nexpr_list: or_expr (\",\" or_expr)* [\",\"]\ncond_list: condition (\",\" condition)* [\",\"]\n```\nThe only difference between expression lists and condition lists is\nthe lowest priority of operators that can be used in them without\nbeing enclosed in parentheses; condition lists allow all operators,\nwhile expression lists don't allow comparisons and Boolean operators\n(they do allow bitwise and shift operators though).\nExpression lists are used in expression statements and assignments;\ncondition lists are used everywhere else where a list of\ncomma-separated values is required.\nAn expression (condition) list containing at least one comma yields a\ntuple. The length of the tuple is the number of expressions\n(conditions) in the list. The expressions (conditions) are evaluated\nfrom left to right. (Condition lists are used syntactically is a few\nplaces where no tuple is constructed but a list of values is needed\nnevertheless.)\nThe trailing comma is required only to create a single tuple (a.k.a. a\nsingleton); it is optional in all other cases. A single\nexpression (condition) without a trailing comma doesn't create a\ntuple, but rather yields the value of that expression (condition).\n(To create an empty tuple, use an empty pair of parentheses:\n`()`.)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1380, "url": "https://docs.python.org/{python_version}/python-ref/node51.html"}
{"title": "Summary", "text": "---\nnode53.html node31.html node51.html node1.html node79.html\n---\n# Summary\nThe following table summarizes the operator precedences in Python,\nfrom lowest precedence (least binding) to highest precedence (most\nbinding). Operators in the same box have the same precedence. Unless\nthe syntax is explicitly given, operators are binary. Operators in\nthe same box group left to right (except for comparisons, which\nchain from left to right --- see above).\n---\nguido@cwi.nl", "python_version": "1.2", "length": 468, "url": "https://docs.python.org/{python_version}/python-ref/node52.html"}
{"title": "Simple statements", "text": "---\nnode54.html ref.html node52.html node1.html node79.html\n---\n# Simple statements\nSimple statements are comprised within a single logical line.\nSeveral simple statements may occur on a single line separated\nby semicolons. The syntax for simple statements is:\n```text\nsimple_stmt: expression_stmt\n| assignment_stmt\n| pass_stmt\n| del_stmt\n| print_stmt\n| return_stmt\n| raise_stmt\n| break_stmt\n| continue_stmt\n| import_stmt\n| global_stmt\n| access_stmt\n| exec_stmt\n```\n---\n- Expression statements (node54.html#SECTION00710000000000000000)\nAssignment statements (node55.html#SECTION00720000000000000000)\nThe pass statement (node56.html#SECTION00730000000000000000)\nThe del statement (node57.html#SECTION00740000000000000000)\nThe print statement (node58.html#SECTION00750000000000000000)\nThe return statement (node59.html#SECTION00760000000000000000)\nThe raise statement (node60.html#SECTION00770000000000000000)\nThe break statement (node61.html#SECTION00780000000000000000)\nThe continue statement (node62.html#SECTION00790000000000000000)\nThe import statement (node63.html#SECTION007100000000000000000)\nThe global statement (node64.html#SECTION007110000000000000000)\nThe access statement (node65.html#SECTION007120000000000000000)\nThe exec statement (node66.html#SECTION007130000000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1305, "url": "https://docs.python.org/{python_version}/python-ref/node53.html"}
{"title": "Expression statements", "text": "---\nnode55.html node53.html node53.html node1.html node79.html\n---\n# Expression statements\nExpression statements are used (mostly interactively) to compute and\nwrite a value, or (usually) to call a procedure (a function that\nreturns no meaningful result; in Python, procedures return the value\n`None`):\n```text\nexpression_stmt: expression_list\n```\nAn expression statement evaluates the expression list (which may be a\nsingle expression). If the value is not `None`, it is converted\nto a string using the rules for string conversions (expressions in\nreverse quotes), and the resulting string is written to standard\noutput (see section node58.html#print) on a line by itself.\n(The exception for `None` is made so that procedure calls, which\nare syntactically equivalent to expressions, do not cause any output.\nA tuple with only `None` items is written normally.)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 878, "url": "https://docs.python.org/{python_version}/python-ref/node54.html"}
{"title": "Assignment statements", "text": "---\nnode56.html node53.html node54.html node1.html node79.html\n---\n# Assignment statements\nAssignment statements are used to (re)bind names to values and to\nmodify attributes or items of mutable objects:\n```text\nassignment_stmt: (target_list \"=\")+ expression_list\ntarget_list: target (\",\" target)* [\",\"]\ntarget: identifier | \"(\" target_list \")\" | \"[\" target_list \"]\"\n| attributeref | subscription | slicing\n```\n(See section node40.html#primaries for the syntax definitions for the last\nthree symbols.)\nAn assignment statement evaluates the expression list (remember that\nthis can be a single expression or a comma-separated list, the latter\nyielding a tuple) and assigns the single resulting object to each of\nthe target lists, from left to right.\nAssignment is defined recursively depending on the form of the target\n(list). When a target is part of a mutable object (an attribute\nreference, subscription or slicing), the mutable object must\nultimately perform the assignment and decide about its validity, and\nmay raise an exception if the assignment is unacceptable. The rules\nobserved by various types and the exceptions raised are given with the\ndefinition of the object types (see section node21.html#types).\nAssignment of an object to a target list is recursively defined as\nfollows.\n- If the target list is a single target: the object is assigned to that\ntarget.\nIf the target list is a comma-separated list of targets: the object\nmust be a tuple with the same number of items as the list contains\ntargets, and the items are assigned, from left to right, to the\ncorresponding targets.\nAssignment of an object to a single target is recursively defined as\nfollows.\n(In the current implementation, the syntax for targets is taken\nto be the same as for expressions, and invalid syntax is rejected\nduring the code generation phase, causing less detailed error\nmessages.)\nWARNING: Although the definition of assignment implies that overlaps\nbetween the left-hand side and the right-hand side are `safe' (e.g.\n`a, b = b, a` swaps two variables), overlaps within the\ncollection of assigned-to variables are not safe! For instance, the\nfollowing program prints [0, 2]@:\n```text\nx = [0, 1]\ni = 0\ni, x[i] = 1, 2\nprint x\n```\n---\nnode56.html node53.html node54.html node1.html node79.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 2304, "url": "https://docs.python.org/{python_version}/python-ref/node55.html"}
{"title": "The pass statement", "text": "---\nnode57.html node53.html node55.html node1.html node79.html\n---\n# The pass statement\n```text\npass_stmt: \"pass\"\n```\n`pass` is a null operation --- when it is executed, nothing\nhappens. It is useful as a placeholder when a statement is\nrequired syntactically, but no code needs to be executed, for example:\n```text\ndef f(arg): pass # a function that does nothing (yet)\n\nclass C: pass # an class with no methods (yet)\n```\n---\nguido@cwi.nl", "python_version": "1.2", "length": 438, "url": "https://docs.python.org/{python_version}/python-ref/node56.html"}
{"title": "The del statement", "text": "---\nnode58.html node53.html node56.html node1.html node79.html\n---\n# The del statement\n```text\ndel_stmt: \"del\" target_list\n```\nDeletion is recursively defined very similar to the way assignment is\ndefined. Rather that spelling it out in full details, here are some\nhints.\nDeletion of a target list recursively deletes each target, from left\nto right.\nDeletion of a name removes the binding of that name (which must exist)\nfrom the local or global name space, depending on whether the name\noccurs in a `global` statement in the same code block.\nDeletion of attribute references, subscriptions and slicings\nis passed to the primary object involved; deletion of a slicing\nis in general equivalent to assignment of an empty slice of the\nright type (but even this is determined by the sliced object).\n---\nguido@cwi.nl", "python_version": "1.2", "length": 812, "url": "https://docs.python.org/{python_version}/python-ref/node57.html"}
{"title": "The print statement", "text": "---\nnode59.html node53.html node57.html node1.html node79.html\n---\n# The print statement\n```text\nprint_stmt: \"print\" [ condition (\",\" condition)* [\",\"] ]\n```\n`print` evaluates each condition in turn and writes the resulting\nobject to standard output (see below). If an object is not a string,\nit is first converted to a string using the rules for string\nconversions. The (resulting or original) string is then written. A\nspace is written before each object is (converted and) written, unless\nthe output system believes it is positioned at the beginning of a\nline. This is the case: (1) when no characters have yet been written\nto standard output; or (2) when the last character written to standard\noutput is `\\n`; or (3) when the last write operation on standard\noutput was not a `print` statement. (In some cases it may be\nfunctional to write an empty string to standard output for this\nreason.)\nA `\"\\n\"` character is written at the end, unless the `print`\nstatement ends with a comma. This is the only action if the statement\ncontains just the keyword `print`.\nStandard output is defined as the file object named `stdout`\nin the built-in module `sys`. If no such object exists,\nor if it is not a writable file, a `RuntimeError` exception is raised.\n(The original implementation attempts to write to the system's original\nstandard output instead, but this is not safe, and should be fixed.)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1408, "url": "https://docs.python.org/{python_version}/python-ref/node58.html"}
{"title": "The return statement", "text": "---\nnode60.html node53.html node58.html node1.html node79.html\n---\n# The return statement\n```text\nreturn_stmt: \"return\" [condition_list]\n```\n`return` may only occur syntactically nested in a function\ndefinition, not within a nested class definition.\nIf a condition list is present, it is evaluated, else `None`\nis substituted.\n`return` leaves the current function call with the condition\nlist (or `None`) as return value.\nWhen `return` passes control out of a `try` statement\nwith a `finally` clause, that finally clause is executed\nbefore really leaving the function.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 585, "url": "https://docs.python.org/{python_version}/python-ref/node59.html"}
{"title": "Comments", "text": "---\nnode7.html node5.html node5.html node1.html node79.html\n---\n## Comments\nA comment starts with a hash character (`#`) that is not part of\na string literal, and ends at the end of the physical line. A comment\nalways signifies the end of the logical line. Comments are ignored by\nthe syntax.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 309, "url": "https://docs.python.org/{python_version}/python-ref/node6.html"}
{"title": "The raise statement", "text": "---\nnode61.html node53.html node59.html node1.html node79.html\n---\n# The raise statement\n```text\nraise_stmt: \"raise\" condition [\",\" condition]\n```\n`raise` evaluates its first condition, which must yield\na string, class, or instance object. If there is a second condition,\nthis is evaluated, else `None` is substituted. If the first\ncondition is a class object, then the second condition must be an\ninstance of that class or one of its derivatives. If the first\ncondition is an instance object, the second condition must be\n`None`.\nIf the first object is a class or string, it then raises the exception\nidentified by the first object, with the second one (or `None`)\nas its parameter. If the first object is an instance, it raises the\nexception identified by the class of the object, with the instance as\nits parameter.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 835, "url": "https://docs.python.org/{python_version}/python-ref/node60.html"}
{"title": "The break statement", "text": "---\nnode62.html node53.html node60.html node1.html node79.html\n---\n# The break statement\n```text\nbreak_stmt: \"break\"\n```\n`break` may only occur syntactically nested in a `for`\nor `while` loop, but not nested in a function or class definition\nwithin that loop.\nIt terminates the nearest enclosing loop, skipping the optional\n`else` clause if the loop has one.\nIf a `for` loop is terminated by `break`, the loop control\ntarget keeps its current value.\nWhen `break` passes control out of a `try` statement\nwith a `finally` clause, that finally clause is executed\nbefore really leaving the loop.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 608, "url": "https://docs.python.org/{python_version}/python-ref/node61.html"}
{"title": "The continue statement", "text": "---\nnode63.html node53.html node61.html node1.html node79.html\n---\n# The continue statement\n```text\ncontinue_stmt: \"continue\"\n```\n`continue` may only occur syntactically nested in a `for` or\n`while` loop, but not nested in a function or class definition or\n`try` statement within that loop.footnode.html#1125\nIt continues with the next cycle of the nearest enclosing loop.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 389, "url": "https://docs.python.org/{python_version}/python-ref/node62.html"}
{"title": "The import statement", "text": "---\nnode64.html node53.html node62.html node1.html node79.html\n---\n# The import statement\n```text\nimport_stmt: \"import\" identifier (\",\" identifier)*\n| \"from\" identifier \"import\" identifier (\",\" identifier)*\n| \"from\" identifier \"import\" \"*\"\n```\nImport statements are executed in two steps: (1) find a module, and\ninitialize it if necessary; (2) define a name or names in the local\nname space (of the scope where the `import` statement occurs).\nThe first form (without `from`) repeats these steps for each\nidentifier in the list, the `from` form performs them once, with\nthe first identifier specifying the module name.\nThe system maintains a table of modules that have been initialized,\nindexed by module name. (The current implementation makes this table\naccessible as `sys.modules`.) When a module name is found in\nthis table, step (1) is finished. If not, a search for a module\ndefinition is started. This first looks for a built-in module\ndefinition, and if no built-in module if the given name is found, it\nsearches a user-specified list of directories for a file whose name is\nthe module name with extension `\".py\"`. (The current\nimplementation uses the list of strings `sys.path` as the search\npath; it is initialized from the shell environment variable\n`$PYTHONPATH`, with an installation-dependent default.)\nIf a built-in module is found, its built-in initialization code is\nexecuted and step (1) is finished. If no matching file is found,\n`ImportError` is raised. If a file is found, it is parsed,\nyielding an executable code block. If a syntax error occurs,\n`SyntaxError` is raised. Otherwise, an empty module of the given\nname is created and inserted in the module table, and then the code\nblock is executed in the context of this module. Exceptions during\nthis execution terminate step (1).\nWhen step (1) finishes without raising an exception, step (2) can\nbegin.\nThe first form of `import` statement binds the module name in the\nlocal name space to the module object, and then goes on to import the\nnext identifier, if any. The `from` from does not bind the\nmodule name: it goes through the list of identifiers, looks each one\nof them up in the module found in step (1), and binds the name in the\nlocal name space to the object thus found. If a name is not found,\n`ImportError` is raised. If the list of identifiers is replaced\nby a star (`*`), all names defined in the module are bound,\nexcept those beginning with an underscore(`_`).\nNames bound by import statements may not occur in `global`\nstatements in the same scope.\nThe `from` form with `*` may only occur in a module scope.\n(The current implementation does not enforce the latter two\nrestrictions, but programs should not abuse this freedom, as future\nimplementations may enforce them or silently change the meaning of the\nprogram.)\n---\nnode64.html node53.html node62.html node1.html node79.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 2889, "url": "https://docs.python.org/{python_version}/python-ref/node63.html"}
{"title": "The global statement", "text": "---\nnode65.html node53.html node63.html node1.html node79.html\n---\n# The global statement\n```text\nglobal_stmt: \"global\" identifier (\",\" identifier)*\n```\nThe `global` statement is a declaration which holds for the\nentire current scope. It means that the listed identifiers are to be\ninterpreted as globals. While using global names is automatic\nif they are not defined in the local scope, assigning to global\nnames would be impossible without `global`.\nNames listed in a `global` statement must not be used in the same\nscope before that `global` statement is executed.\nNames listed in a `global` statement must not be defined as formal\nparameters or in a `for` loop control target, `class`\ndefinition, function definition, or `import` statement.\n(The current implementation does not enforce the latter two\nrestrictions, but programs should not abuse this freedom, as future\nimplementations may enforce them or silently change the meaning of the\nprogram.)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 970, "url": "https://docs.python.org/{python_version}/python-ref/node64.html"}
{"title": "The access statement", "text": "---\nnode66.html node53.html node64.html node1.html node79.html\n---\n# The access statement\n```text\naccess_stmt: \"access\" ...\n```\nThis statement will be used in the future to control access to\ninstance and class variables. Currently its syntax and effects are\nundefined; however the keyword `access` is a reserved word for\nthe parser.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 349, "url": "https://docs.python.org/{python_version}/python-ref/node65.html"}
{"title": "The exec statement", "text": "---\nnode67.html node53.html node65.html node1.html node79.html\n---\n# The exec statement\n```text\nexec_stmt: \"exec\" expression [\"in\" expression [\",\" expression]]\n```\nThis statement supports dynamic execution of Python code. The first\nexpression should evaluate to either a string, an open file object, or\na code object. If it is a string, the string is parsed as a suite of\nPython statements which is then executed (unless a syntax error\noccurs). If it is an open file, the file is parsed until EOF and\nexecuted. If it is a code object, it is simply executed.\nIn all cases, if the optional parts are omitted, the code is executed\nin the current scope. If only the first expression after `in` is\nspecified, it should be a dictionary, which will be used for both the\nglobal and the local variables. If two expressions are given, both\nmust be dictionaries and they are used for the global and local\nvariables, respectively.\nHints: dynamic evaluation of expressions is supported by the built-in\nfunction `eval()`. The built-in function `vars()` returns\nthe current local dictionary, which may be useful to pass around for\nuse by `exec`.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1147, "url": "https://docs.python.org/{python_version}/python-ref/node66.html"}
{"title": "Compound statements", "text": "---\nnode68.html ref.html node66.html node1.html node79.html\n---\n# Compound statements\nCompound statements contain (groups of) other statements; they affect\nor control the execution of those other statements in some way. In\ngeneral, compound statements span multiple lines, although in simple\nincarnations a whole compound statement may be contained in one line.\nThe `if`, `while` and `for` statements implement\ntraditional control flow constructs. `try` specifies exception\nhandlers and/or cleanup code for a group of statements. Function and\nclass definitions are also syntactically compound statements.\nCompound statements consist of one or more `clauses'. A clause\nconsists of a header and a `suite'. The clause headers of a\nparticular compound statement are all at the same indentation level.\nEach clause header begins with a uniquely identifying keyword and ends\nwith a colon. A suite is a group of statements controlled by a\nclause. A suite can be one or more semicolon-separated simple\nstatements on the same line as the header, following the header's\ncolon, or it can be one or more indented statements on subsequent\nlines. Only the latter form of suite can contain nested compound\nstatements; the following is illegal, mostly because it wouldn't be\nclear to which `if` clause a following `else` clause would\nbelong:\n```text\nif test1: if test2: print x\n```\nAlso note that the semicolon binds tighter than the colon in this\ncontext, so that in the following example, either all or none of the\n`print` statements are executed:\n```text\nif x < y < z: print x; print y; print z\n```\nSummarizing:\n```text\ncompound_stmt: if_stmt | while_stmt | for_stmt\n| try_stmt | funcdef | classdef\nsuite: stmt_list NEWLINE | NEWLINE INDENT statement+ DEDENT\nstatement: stmt_list NEWLINE | compound_stmt\nstmt_list: simple_stmt (\";\" simple_stmt)* [\";\"]\n```\nNote that statements always end in a `NEWLINE` possibly followed\nby a `DEDENT`.\nAlso note that optional continuation clauses always begin with a\nkeyword that cannot start a statement, thus there are no ambiguities\n(the `dangling `else`' problem is solved in Python by requiring\nnested `if` statements to be indented).\nThe formatting of the grammar rules in the following sections places\neach clause on a separate line for clarity.\n---\n- The if statement (node68.html#SECTION00810000000000000000)\nThe while statement (node69.html#SECTION00820000000000000000)\nThe for statement (node70.html#SECTION00830000000000000000)\nThe try statement (node71.html#SECTION00840000000000000000)\nFunction definitions (node72.html#SECTION00850000000000000000)\nClass definitions (node73.html#SECTION00860000000000000000)\n---\nnode68.html ref.html node66.html node1.html node79.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 2723, "url": "https://docs.python.org/{python_version}/python-ref/node67.html"}
{"title": "The if statement", "text": "---\nnode69.html node67.html node67.html node1.html node79.html\n---\n# The if statement\nThe `if` statement is used for conditional execution:\n```text\nif_stmt: \"if\" condition \":\" suite\n(\"elif\" condition \":\" suite)*\n[\"else\" \":\" suite]\n```\nIt selects exactly one of the suites by evaluating the conditions one\nby one until one is found to be true (see section node50.html#Booleans for\nthe definition of true and false); then that suite is executed (and no\nother part of the `if` statement is executed or evaluated). If\nall conditions are false, the suite of the `else` clause, if\npresent, is executed.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 613, "url": "https://docs.python.org/{python_version}/python-ref/node68.html"}
{"title": "The while statement", "text": "---\nnode70.html node67.html node68.html node1.html node79.html\n---\n# The while statement\nThe `while` statement is used for repeated execution as long as a\ncondition is true:\n```text\nwhile_stmt: \"while\" condition \":\" suite\n[\"else\" \":\" suite]\n```\nThis repeatedly tests the condition and, if it is true, executes the\nfirst suite; if the condition is false (which may be the first time it\nis tested) the suite of the `else` clause, if present, is\nexecuted and the loop terminates.\nA `break` statement executed in the first suite terminates the\nloop without executing the `else` clause's suite. A\n`continue` statement executed in the first suite skips the rest\nof the suite and goes back to testing the condition.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 725, "url": "https://docs.python.org/{python_version}/python-ref/node69.html"}
{"title": "Explicit line joining", "text": "---\nnode8.html node5.html node6.html node1.html node79.html\n---\n## Explicit line joining\nTwo or more physical lines may be joined into logical lines using\nbackslash characters (`\\`), as follows: when a physical line ends\nin a backslash that is not part of a string literal or comment, it is\njoined with the following forming a single logical line, deleting the\nbackslash and the following end-of-line character. For example:\n```text\nif 1900 < year < 2100 and 1 <= month <= 12 \\\nand 1 <= day <= 31 and 0 <= hour < 24 \\\nand 0 <= minute < 60 and 0 <= second < 60: # Looks like a valid date\nreturn 1\n```\nA line ending in a backslash cannot carry a comment; a backslash does\nnot continue a comment (but it does continue a string literal, see\nbelow).\n---\nguido@cwi.nl", "python_version": "1.2", "length": 761, "url": "https://docs.python.org/{python_version}/python-ref/node7.html"}
{"title": "The for statement", "text": "---\nnode71.html node67.html node69.html node1.html node79.html\n---\n# The for statement\nThe `for` statement is used to iterate over the elements of a\nsequence (string, tuple or list):\n```text\nfor_stmt: \"for\" target_list \"in\" condition_list \":\" suite\n[\"else\" \":\" suite]\n```\nThe condition list is evaluated once; it should yield a sequence. The\nsuite is then executed once for each item in the sequence, in the\norder of ascending indices. Each item in turn is assigned to the\ntarget list using the standard rules for assignments, and then the\nsuite is executed. When the items are exhausted (which is immediately\nwhen the sequence is empty), the suite in the `else` clause, if\npresent, is executed, and the loop terminates.\nA `break` statement executed in the first suite terminates the\nloop without executing the `else` clause's suite. A\n`continue` statement executed in the first suite skips the rest\nof the suite and continues with the next item, or with the `else`\nclause if there was no next item.\nThe suite may assign to the variable(s) in the target list; this does\nnot affect the next item assigned to it.\nThe target list is not deleted when the loop is finished, but if the\nsequence is empty, it will not have been assigned to at all by the\nloop.\nHint: the built-in function `range()` returns a sequence of\nintegers suitable to emulate the effect of Pascal's\n`for i := a to b do`;\ne.g. `range(3)` returns the list `[0, 1, 2]`.\nWarning: There is a subtlety when the sequence is being modified\nby the loop (this can only occur for mutable sequences, i.e. lists).\nAn internal counter is used to keep track of which item is used next,\nand this is incremented on each iteration. When this counter has\nreached the length of the sequence the loop terminates. This means that\nif the suite deletes the current (or a previous) item from the\nsequence, the next item will be skipped (since it gets the index of\nthe current item which has already been treated). Likewise, if the\nsuite inserts an item in the sequence before the current item, the\ncurrent item will be treated again the next time through the loop.\nThis can lead to nasty bugs that can be avoided by making a temporary\ncopy using a slice of the whole sequence, e.g.\n```text\nfor x in a[:]:\nif x < 0: a.remove(x)\n```\n---\nnode71.html node67.html node69.html node1.html node79.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 2355, "url": "https://docs.python.org/{python_version}/python-ref/node70.html"}
{"title": "The try statement", "text": "---\nnode72.html node67.html node70.html node1.html node79.html\n---\n# The try statement\nThe `try` statement specifies exception handlers and/or cleanup\ncode for a group of statements:\n```text\ntry_stmt: try_exc_stmt | try_fin_stmt\ntry_exc_stmt: \"try\" \":\" suite\n(\"except\" [condition [\",\" target]] \":\" suite)+\n[\"else\" \":\" suite]\ntry_fin_stmt: \"try\" \":\" suite\n\"finally\" \":\" suite\n```\nThere are two forms of `try` statement: `try...except` and\n`try...finally`. These forms cannot be mixed.\nThe `try...except` form specifies one or more exception handlers\n(the `except` clauses). When no exception occurs in the\n`try` clause, no exception handler is executed. When an\nexception occurs in the `try` suite, a search for an exception\nhandler is started. This inspects the except clauses in turn until\none is found that matches the exception. A condition-less except\nclause, if present, must be last; it matches any exception. For an\nexcept clause with a condition, that condition is evaluated, and the\nclause matches the exception if the resulting object is ``compatible''\nwith the exception. An object is compatible with an exception if it\nis either the object that identifies the exception, or (for exceptions\nthat are classes) it is a base class of the exception, or it is a\ntuple containing an item that is compatible with the exception. Note\nthat the object identities must match, i.e. it must be the same\nobject, not just an object with the same value.\nIf no except clause matches the exception, the search for an exception\nhandler continues in the surrounding code and on the invocation stack.\nIf the evaluation of a condition in the header of an except clause\nraises an exception, the original search for a handler is cancelled\nand a search starts for the new exception in the surrounding code and\non the call stack (it is treated as if the entire `try` statement\nraised the exception).\nWhen a matching except clause is found, the exception's parameter is\nassigned to the target specified in that except clause, if present,\nand the except clause's suite is executed. When the end of this suite\nis reached, execution continues normally after the entire try\nstatement. (This means that if two nested handlers exist for the same\nexception, and the exception occurs in the try clause of the inner\nhandler, the outer handler will not handle the exception.)\nBefore an except clause's suite is executed, details about the\nexception are assigned to three variables in the `sys` module:\n`sys.exc_type` receives the object identifying the exception;\n`sys.exc_value` receives the exception's parameter;\n`sys.exc_traceback` receives a traceback object (see section\nnode21.html#traceback) identifying the point in the program where the\nexception occurred.\nThe optional `else` clause is executed when no exception occurs\nin the `try` clause. Exceptions in the `else` clause are\nnot handled by the preceding `except` clauses.\nThe `try...finally` form specifies a `cleanup' handler. The\n`try` clause is executed. When no exception occurs, the\n`finally` clause is executed. When an exception occurs in the\n`try` clause, the exception is temporarily saved, the\n`finally` clause is executed, and then the saved exception is\nre-raised. If the `finally` clause raises another exception or\nexecutes a `return`, `break` or `continue` statement,\nthe saved exception is lost.\nWhen a `return` or `break` statement is executed in the\n`try` suite of a `try...finally` statement, the\n`finally` clause is also executed `on the way out'. A\n`continue` statement is illegal in the `try` clause. (The\nreason is a problem with the current implementation --- this\nrestriction may be lifted in the future).\n---\nnode72.html node67.html node70.html node1.html node79.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 3751, "url": "https://docs.python.org/{python_version}/python-ref/node71.html"}
{"title": "Function definitions", "text": "---\nnode73.html node67.html node71.html node1.html node79.html\n---\n# Function definitions\nA function definition defines a user-defined function object (see\nsection node21.html#types):\n```text\nfuncdef: \"def\" funcname \"(\" [parameter_list] \")\" \":\" suite\nparameter_list: (defparameter \",\")* (\"*\" identifier | defparameter [\",\"])\ndefparameter: parameter [\"=\" condition]\nsublist: parameter (\",\" parameter)* [\",\"]\nparameter: identifier | \"(\" sublist \")\"\nfuncname: identifier\n```\nA function definition is an executable statement. Its execution binds\nthe function name in the current local name space to a function object\n(a wrapper around the executable code for the function). This\nfunction object contains a reference to the current global name space\nas the global name space to be used when the function is called.\nThe function definition does not execute the function body; this gets\nexecuted only when the function is called.\nWhen one or more top-level parameters have the form parameter =\ncondition, the function is said to have ``default parameter values''.\nDefault parameter values are evaluated when the function definition is\nexecuted. For a parameter with a default value, the correponding\nargument may be omitted from a call, in which case the parameter's\ndefault value is substituted. If a parameter has a default value, all\nfollowing parameters must also have a default value --- this is a\nsyntactic restriction that is not expressed by the grammar.\nfootnode.html#1238\nFunction call semantics are described in section node44.html#calls. When a\nuser-defined function is called, first missing arguments for which a\ndefault value exists are supplied; then the arguments (a.k.a. actual\nparameters) are bound to the (formal) parameters, as follows:\n- If there are no formal parameters, there must be no arguments.\nIf the formal parameter list does not end in a star followed by an\nidentifier, there must be exactly as many arguments as there are\nparameters in the formal parameter list (at the top level); the\narguments are assigned to the formal parameters one by one. Note that\nthe presence or absence of a trailing comma at the top level in either\nthe formal or the actual parameter list makes no difference. The\nassignment to a formal parameter is performed as if the parameter\noccurs on the left hand side of an assignment statement whose right\nhand side's value is that of the argument.\nIf the formal parameter list ends in a star followed by an identifier,\npreceded by zero or more comma-followed parameters, there must be at\nleast as many arguments as there are parameters preceding the star.\nCall this number N. The first N arguments are assigned to\nthe corresponding formal parameters in the way descibed above. A\ntuple containing the remaining arguments, if any, is then assigned to\nthe identifier following the star. This variable will always be a\ntuple: if there are no extra arguments, its value is `()`, if\nthere is just one extra argument, it is a singleton tuple.\nNote that the `variable length parameter list' feature only works at\nthe top level of the parameter list; individual parameters use a model\ncorresponding more closely to that of ordinary assignment. While the\nlatter model is generally preferable, because of the greater type\nsafety it offers (wrong-sized tuples aren't silently mistreated),\nvariable length parameter lists are a sufficiently accepted practice\nin most programming languages that a compromise has been worked out.\n(And anyway, assignment has no equivalent for empty argument lists.)\nIt is also possible to create anonymous functions (functions not bound\nto a name), for immediate use in expressions. This uses lambda forms,\ndescribed in section node50.html#lambda.\n---\nnode73.html node67.html node71.html node1.html node79.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 3795, "url": "https://docs.python.org/{python_version}/python-ref/node72.html"}
{"title": "Class definitions", "text": "---\nnode74.html node67.html node72.html node1.html node79.html\n---\n# Class definitions\nA class definition defines a class object (see section node21.html#types):\n```text\nclassdef: \"class\" classname [inheritance] \":\" suite\ninheritance: \"(\" [condition_list] \")\"\nclassname: identifier\n```\nA class definition is an executable statement. It first evaluates the\ninheritance list, if present. Each item in the inheritance list\nshould evaluate to a class object. The class's suite is then executed\nin a new execution frame (see section node29.html#execframes), using a newly\ncreated local name space and the original global name space.\n(Usually, the suite contains only function definitions.) When the\nclass's suite finishes execution, its execution frame is discarded but\nits local name space is saved. A class object is then created using\nthe inheritance list for the base classes and the saved local name\nspace for the attribute dictionary. The class name is bound to this\nclass object in the original local name space.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1031, "url": "https://docs.python.org/{python_version}/python-ref/node73.html"}
{"title": "Top-level components", "text": "---\nnode75.html ref.html node73.html node1.html node79.html\n---\n# Top-level components\nThe Python interpreter can get its input from a number of sources:\nfrom a script passed to it as standard input or as program argument,\ntyped in interactively, from a module source file, etc. This chapter\ngives the syntax used in these cases.\n---\n- Complete Python programs (node75.html#SECTION00910000000000000000)\nFile input (node76.html#SECTION00920000000000000000)\nInteractive input (node77.html#SECTION00930000000000000000)\nExpression input (node78.html#SECTION00940000000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 591, "url": "https://docs.python.org/{python_version}/python-ref/node74.html"}
{"title": "Complete Python programs", "text": "---\nnode76.html node74.html node74.html node1.html node79.html\n---\n# Complete Python programs\nWhile a language specification need not prescribe how the language\ninterpreter is invoked, it is useful to have a notion of a complete\nPython program. A complete Python program is executed in a minimally\ninitialized environment: all built-in and standard modules are\navailable, but none have been initialized, except for `sys`\n(various system services), `__builtin__` (built-in functions,\nexceptions and `None`) and `__main__`. The latter is used\nto provide the local and global name space for execution of the\ncomplete program.\nThe syntax for a complete Python program is that for file input,\ndescribed in the next section.\nThe interpreter may also be invoked in interactive mode; in this case,\nit does not read and execute a complete program but reads and executes\none statement (possibly compound) at a time. The initial environment\nis identical to that of a complete program; each statement is executed\nin the name space of `__main__`.\nUnder Unix, a complete program can be passed to the interpreter in\nthree forms: with the -c string command line option, as a\nfile passed as the first command line argument, or as standard input.\nIf the file or standard input is a tty device, the interpreter enters\ninteractive mode; otherwise, it executes the file as a complete\nprogram.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1388, "url": "https://docs.python.org/{python_version}/python-ref/node75.html"}
{"title": "File input", "text": "---\nnode77.html node74.html node75.html node1.html node79.html\n---\n# File input\nAll input read from non-interactive files has the same form:\n```text\nfile_input: (NEWLINE | statement)*\n```\nThis syntax is used in the following situations:\n- when parsing a complete Python program (from a file or from a string);\nwhen parsing a module;\nwhen parsing a string passed to the `exec` statement;\n---\nguido@cwi.nl", "python_version": "1.2", "length": 403, "url": "https://docs.python.org/{python_version}/python-ref/node76.html"}
{"title": "Interactive input", "text": "---\nnode78.html node74.html node76.html node1.html node79.html\n---\n# Interactive input\nInput in interactive mode is parsed using the following grammar:\n```text\ninteractive_input: [stmt_list] NEWLINE | compound_stmt NEWLINE\n```\nNote that a (top-level) compound statement must be followed by a blank\nline in interactive mode; this is needed to help the parser detect the\nend of the input.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 403, "url": "https://docs.python.org/{python_version}/python-ref/node77.html"}
{"title": "Expression input", "text": "---\nnode79.html node74.html node77.html node1.html node79.html\n---\n# Expression input\nThere are two forms of expression input. Both ignore leading\nwhitespace.\nThe string argument to `eval()` must have the following form:\n```text\neval_input: condition_list NEWLINE*\n```\nThe input line read by `input()` must have the following form:\n```text\ninput_input: condition_list NEWLINE\n```\nNote: to read `raw' input line without interpretation, you can use the\nbuilt-in function `raw_input()` or the `readline()` method\nof file objects.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 543, "url": "https://docs.python.org/{python_version}/python-ref/node78.html"}
{"title": "Index", "text": "---\nnode80.html ref.html node78.html node1.html\n---\n## Index\n---\nguido@cwi.nl", "python_version": "1.2", "length": 77, "url": "https://docs.python.org/{python_version}/python-ref/node79.html"}
{"title": "Implicit line joining", "text": "---\nnode9.html node5.html node7.html node1.html node79.html\n---\n## Implicit line joining\nExpressions in parentheses, square brackets or curly braces can be\nsplit over more than one physical line without using backslashes.\nFor example:\n```text\nmonth_names = ['Januari', 'Februari', 'Maart', # These are the\n'April', 'Mei', 'Juni', # Dutch names\n'Juli', 'Augustus', 'September', # for the months\n'Oktober', 'November', 'December'] # of the year\n```\nImplicitly continued lines can carry comments. The indentation of the\ncontinuation lines is not important. Blank continuation lines are\nallowed.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 608, "url": "https://docs.python.org/{python_version}/python-ref/node8.html"}
{"title": "About this document ...", "text": "---\nref.html node79.html node1.html node79.html\n---\n# About this document ...\nPython Reference Manual\nThis document was generated using the LaTeX2HTML (http://cbl.leeds.ac.uk/nikos/tex2html/doc/latex2html/latex2html.html) translator Version 95.1 (Fri Jan 20 1995) Copyright © 1993, 1994, Nikos Drakos (http://cbl.leeds.ac.uk/nikos/personal.html), Computer Based Learning Unit, University of Leeds.\nThe command line arguments were:\nlatex2html -address guido@cwi.nl -dont_include myformat ref.tex.\nThe translation was initiated by Guido van Rossum on Tue Apr 11 00:19:37 MDT 1995\n---\nguido@cwi.nl", "python_version": "1.2", "length": 594, "url": "https://docs.python.org/{python_version}/python-ref/node80.html"}
{"title": "Blank lines", "text": "---\nnode10.html node5.html node8.html node1.html node79.html\n---\n## Blank lines\nA logical line that contains only spaces, tabs, and possibly a\ncomment, is ignored (i.e., no NEWLINE token is generated), except that\nduring interactive input of statements, an entirely blank logical line\nterminates a multi-line statement.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 336, "url": "https://docs.python.org/{python_version}/python-ref/node9.html"}
{"title": "Python Reference Manual", "text": "---\nnode1.html node1.html node79.html\n---\n# Python Reference Manual\nGuido van Rossum\nDept. AA, CWI, P.O. Box 94079\n1090 GB Amsterdam, The Netherlands\nE-mail: guido@cwi.nl\n10 April 1995\nRelease 1.2\nCopyright © 1991-1995 by Stichting Mathematisch Centrum,\nAmsterdam, The Netherlands.\nAll Rights Reserved\nPermission to use, copy, modify, and distribute this software and its\ndocumentation for any purpose and without fee is hereby granted,\nprovided that the above copyright notice appear in all copies and that\nboth that copyright notice and this permission notice appear in\nsupporting documentation, and that the names of Stichting Mathematisch\nCentrum or CWI not be used in advertising or publicity pertaining to\ndistribution of the software without specific, written prior permission.\nSTICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO\nTHIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND\nFITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE\nFOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES\nWHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN\nACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT\nOF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\n### Abstract:\nPython is a simple, yet powerful, interpreted programming language\nthat bridges the gap between C and shell programming, and is thus\nideally suited for ``throw-away programming'' and rapid prototyping.\nIts syntax is put together from constructs borrowed from a variety of\nother languages; most prominent are influences from ABC, C, Modula-3\nand Icon.\nThe Python interpreter is easily extended with new functions and data\ntypes implemented in C. Python is also suitable as an extension\nlanguage for highly customizable C applications such as editors or\nwindow managers.\nPython is available for various operating systems, amongst which\nseveral flavors of Unix (including Linux), the Apple Macintosh O.S.,\nMS-DOS, MS-Windows 3.1, Windows NT, and OS/2.\nThis reference manual describes the syntax and ``core semantics'' of\nthe language. It is terse, but attempts to be exact and complete.\nThe semantics of non-essential built-in object types and of the\nbuilt-in functions and modules are described in the Python\nLibrary Reference. For an informal introduction to the language, see\nthe Python Tutorial.\n---\n- Contents (node1.html#SECTION00100000000000000000)\nIntroduction (node2.html#SECTION00200000000000000000)\n- Notation (node3.html#SECTION00210000000000000000)\nLexical analysis (node4.html#SECTION00300000000000000000)\n- Line structure (node5.html#SECTION00310000000000000000)\n- Comments (node6.html#SECTION00311000000000000000)\nExplicit line joining (node7.html#SECTION00312000000000000000)\nImplicit line joining (node8.html#SECTION00313000000000000000)\nBlank lines (node9.html#SECTION00314000000000000000)\nIndentation (node10.html#SECTION00315000000000000000)\nOther tokens (node11.html#SECTION00320000000000000000)\nIdentifiers (node12.html#SECTION00330000000000000000)\n- Keywords (node13.html#SECTION00331000000000000000)\nLiterals (node14.html#SECTION00340000000000000000)\n- String literals (node15.html#SECTION00341000000000000000)\nNumeric literals (node16.html#SECTION00342000000000000000)\nOperators (node17.html#SECTION00350000000000000000)\nDelimiters (node18.html#SECTION00360000000000000000)\nData model (node19.html#SECTION00400000000000000000)\n- Objects, values and types (node20.html#SECTION00410000000000000000)\nThe standard type hierarchy (node21.html#SECTION00420000000000000000)\nSpecial method names (node22.html#SECTION00430000000000000000)\n- Special methods for any type (node23.html#SECTION00431000000000000000)\nSpecial methods for attribute access (node24.html#SECTION00432000000000000000)\nSpecial methods for sequence and mapping types (node25.html#SECTION00433000000000000000)\nSpecial methods for sequence types (node26.html#SECTION00434000000000000000)\nSpecial methods for numeric types (node27.html#SECTION00435000000000000000)\nExecution model (node28.html#SECTION00500000000000000000)\n- Code blocks, execution frames, and name spaces (node29.html#SECTION00510000000000000000)\nExceptions (node30.html#SECTION00520000000000000000)\nExpressions and conditions (node31.html#SECTION00600000000000000000)\n- Arithmetic conversions (node32.html#SECTION00610000000000000000)\nAtoms (node33.html#SECTION00620000000000000000)\n- Identifiers (Names) (node34.html#SECTION00621000000000000000)\nLiterals (node35.html#SECTION00622000000000000000)\nParenthesized forms (node36.html#SECTION00623000000000000000)\nList displays (node37.html#SECTION00624000000000000000)\nDictionary displays (node38.html#SECTION00625000000000000000)\nString conversions (node39.html#SECTION00626000000000000000)\nPrimaries (node40.html#SECTION00630000000000000000)\n- Attribute references (node41.html#SECTION00631000000000000000)\nSubscriptions (node42.html#SECTION00632000000000000000)\nSlicings (node43.html#SECTION00633000000000000000)\nCalls (node44.html#SECTION00634000000000000000)\nUnary arithmetic operations (node45.html#SECTION00640000000000000000)\nBinary arithmetic operations (node46.html#SECTION00650000000000000000)\nShifting operations (node47.html#SECTION00660000000000000000)\nBinary bit-wise operations (node48.html#SECTION00670000000000000000)\nComparisons (node49.html#SECTION00680000000000000000)\nBoolean operations (node50.html#SECTION00690000000000000000)\nExpression lists and condition lists (node51.html#SECTION006100000000000000000)\nSummary (node52.html#SECTION006110000000000000000)\nSimple statements (node53.html#SECTION00700000000000000000)\n- Expression statements (node54.html#SECTION00710000000000000000)\nAssignment statements (node55.html#SECTION00720000000000000000)\nThe pass statement (node56.html#SECTION00730000000000000000)\nThe del statement (node57.html#SECTION00740000000000000000)\nThe print statement (node58.html#SECTION00750000000000000000)\nThe return statement (node59.html#SECTION00760000000000000000)\nThe raise statement (node60.html#SECTION00770000000000000000)\nThe break statement (node61.html#SECTION00780000000000000000)\nThe continue statement (node62.html#SECTION00790000000000000000)\nThe import statement (node63.html#SECTION007100000000000000000)\nThe global statement (node64.html#SECTION007110000000000000000)\nThe access statement (node65.html#SECTION007120000000000000000)\nThe exec statement (node66.html#SECTION007130000000000000000)\nCompound statements (node67.html#SECTION00800000000000000000)\n- The if statement (node68.html#SECTION00810000000000000000)\nThe while statement (node69.html#SECTION00820000000000000000)\nThe for statement (node70.html#SECTION00830000000000000000)\nThe try statement (node71.html#SECTION00840000000000000000)\nFunction definitions (node72.html#SECTION00850000000000000000)\nClass definitions (node73.html#SECTION00860000000000000000)\nTop-level components (node74.html#SECTION00900000000000000000)\n- Complete Python programs (node75.html#SECTION00910000000000000000)\nFile input (node76.html#SECTION00920000000000000000)\nInteractive input (node77.html#SECTION00930000000000000000)\nExpression input (node78.html#SECTION00940000000000000000)\nIndex (node79.html#SECTION001000000000000000000)\nAbout this document ... (node80.html#SECTION001100000000000000000)\n---\nnode1.html node1.html node79.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 7344, "url": "https://docs.python.org/{python_version}/python-ref/ref.html"}
{"title": "Footnotes", "text": "guido@cwi.nl", "python_version": "1.2", "length": 12, "url": "https://docs.python.org/{python_version}/python-tut/footnode.html"}
{"title": "Contents", "text": "---\nnode2.html tut.html tut.html\n---\n## Contents\n- Whetting Your Appetite (node2.html#SECTION00200000000000000000)\n- Where From Here (node3.html#SECTION00210000000000000000)\nUsing the Python Interpreter (node4.html#SECTION00300000000000000000)\n- Invoking the Interpreter (node5.html#SECTION00310000000000000000)\n- Argument Passing (node6.html#SECTION00311000000000000000)\nInteractive Mode (node7.html#SECTION00312000000000000000)\nThe Interpreter and its Environment (node8.html#SECTION00320000000000000000)\n- Error Handling (node9.html#SECTION00321000000000000000)\nThe Module Search Path (node10.html#SECTION00322000000000000000)\n``Compiled'' Python files (node11.html#SECTION00323000000000000000)\nExecutable Python scripts (node12.html#SECTION00324000000000000000)\nThe Interactive Startup File (node13.html#SECTION00325000000000000000)\nInteractive Input Editing and History Substitution (node14.html#SECTION00330000000000000000)\n- Line Editing (node15.html#SECTION00331000000000000000)\nHistory Substitution (node16.html#SECTION00332000000000000000)\nKey Bindings (node17.html#SECTION00333000000000000000)\nCommentary (node18.html#SECTION00334000000000000000)\nAn Informal Introduction to Python (node19.html#SECTION00400000000000000000)\n- Using Python as a Calculator (node20.html#SECTION00410000000000000000)\n- Numbers (node21.html#SECTION00411000000000000000)\nStrings (node22.html#SECTION00412000000000000000)\nLists (node23.html#SECTION00413000000000000000)\nFirst Steps Towards Programming (node24.html#SECTION00420000000000000000)\nMore Control Flow Tools (node25.html#SECTION00500000000000000000)\n- If Statements (node26.html#SECTION00510000000000000000)\nFor Statements (node27.html#SECTION00520000000000000000)\nThe range() Function (node28.html#SECTION00530000000000000000)\nBreak and Continue Statements, and Else Clauses on Loops (node29.html#SECTION00540000000000000000)\nPass Statements (node30.html#SECTION00550000000000000000)\nDefining Functions (node31.html#SECTION00560000000000000000)\nOdds and Ends (node32.html#SECTION00600000000000000000)\n- More on Lists (node33.html#SECTION00610000000000000000)\nThe del statement (node34.html#SECTION00620000000000000000)\nTuples and Sequences (node35.html#SECTION00630000000000000000)\nDictionaries (node36.html#SECTION00640000000000000000)\nMore on Conditions (node37.html#SECTION00650000000000000000)\nComparing Sequences and Other Types (node38.html#SECTION00660000000000000000)\nModules (node39.html#SECTION00700000000000000000)\n- More on Modules (node40.html#SECTION00710000000000000000)\nStandard Modules (node41.html#SECTION00720000000000000000)\nThe dir() function (node42.html#SECTION00730000000000000000)\nOutput Formatting (node43.html#SECTION00800000000000000000)\nErrors and Exceptions (node44.html#SECTION00900000000000000000)\n- Syntax Errors (node45.html#SECTION00910000000000000000)\nExceptions (node46.html#SECTION00920000000000000000)\nHandling Exceptions (node47.html#SECTION00930000000000000000)\nRaising Exceptions (node48.html#SECTION00940000000000000000)\nUser-defined Exceptions (node49.html#SECTION00950000000000000000)\nDefining Clean-up Actions (node50.html#SECTION00960000000000000000)\nClasses (node51.html#SECTION001000000000000000000)\n- A word about terminology (node52.html#SECTION001010000000000000000)\nPython scopes and name spaces (node53.html#SECTION001020000000000000000)\nA first look at classes (node54.html#SECTION001030000000000000000)\n- Class definition syntax (node55.html#SECTION001031000000000000000)\nClass objects (node56.html#SECTION001032000000000000000)\nInstance objects (node57.html#SECTION001033000000000000000)\nMethod objects (node58.html#SECTION001034000000000000000)\nRandom remarks (node59.html#SECTION001040000000000000000)\nInheritance (node60.html#SECTION001050000000000000000)\n- Multiple inheritance (node61.html#SECTION001051000000000000000)\nOdds and ends (node62.html#SECTION001060000000000000000)\nRecent Additions (node63.html#SECTION001100000000000000000)\n- The Last Printed Expression (node64.html#SECTION001110000000000000000)\nString Literals (node65.html#SECTION001120000000000000000)\n- Double Quotes (node66.html#SECTION001121000000000000000)\nContinuation Of String Literals (node67.html#SECTION001122000000000000000)\nTriple-quoted strings (node68.html#SECTION001123000000000000000)\nString Literal Juxtaposition (node69.html#SECTION001124000000000000000)\nThe Formatting Operator (node70.html#SECTION001130000000000000000)\n- Basic Usage (node71.html#SECTION001131000000000000000)\nReferencing Variables By Name (node72.html#SECTION001132000000000000000)\nOptional Function Arguments (node73.html#SECTION001140000000000000000)\n- Default Argument Values (node74.html#SECTION001141000000000000000)\nArbitrary Argument Lists (node75.html#SECTION001142000000000000000)\nLambda And Functional Programming Tools (node76.html#SECTION001150000000000000000)\n- Lambda Forms (node77.html#SECTION001151000000000000000)\nMap, Reduce and Filter (node78.html#SECTION001152000000000000000)\n- Map. (node79.html#SECTION001152100000000000000)\nFilter. (node80.html#SECTION001152200000000000000)\nReduce. (node81.html#SECTION001152300000000000000)\nContinuation Lines Without Backslashes (node82.html#SECTION001160000000000000000)\nRegular Expressions (node83.html#SECTION001170000000000000000)\nGeneralized Dictionaries (node84.html#SECTION001180000000000000000)\nMiscellaneous New Built-in Functions (node85.html#SECTION001190000000000000000)\nElse Clause For Try Statement (node86.html#SECTION0011100000000000000000)\nNew Class Features in Release 1.1 (node87.html#SECTION0011110000000000000000)\n- New Operator Overloading (node88.html#SECTION0011111000000000000000)\nTrapping Attribute Access (node89.html#SECTION0011112000000000000000)\nCalling a Class Instance (node90.html#SECTION0011113000000000000000)\nNew in Release 1.2 (node91.html#SECTION001200000000000000000)\n- New Class Features (node92.html#SECTION001210000000000000000)\nUnix Signal Handling (node93.html#SECTION001220000000000000000)\nExceptions Can Be Classes (node94.html#SECTION001230000000000000000)\nObject Persistency and Object Copying (node95.html#SECTION001240000000000000000)\n- Persistent Objects (node96.html#SECTION001241000000000000000)\nCopying Objects (node97.html#SECTION001242000000000000000)\nDocumentation Strings (node98.html#SECTION001250000000000000000)\nCustomizing Import and Built-Ins (node99.html#SECTION001260000000000000000)\nPython and the World-Wide Web (node100.html#SECTION001270000000000000000)\nMiscellaneous (node101.html#SECTION001280000000000000000)\nAbout this document ... (node102.html#SECTION001300000000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 6590, "url": "https://docs.python.org/{python_version}/python-tut/node1.html"}
{"title": "The Module Search Path", "text": "---\nnode11.html node8.html node9.html node1.html\n---\n## The Module Search Path\nWhen a module named spam is imported, the interpreter searches\nfor a file named spam.py in the list of directories specified by\nthe environment variable PYTHONPATH. It has the same syntax as\nthe Unix shell variable PATH, i.e., a list of colon-separated\ndirectory names. When PYTHONPATH is not set, or when the file\nis not found there, the search continues in an installation-dependent\ndefault path, usually .:/usr/local/lib/python.\nActually, modules are searched in the list of directories given by the\nvariable sys.path which is initialized from PYTHONPATH and\nthe installation-dependent default. This allows Python programs that\nknow what they're doing to modify or replace the module search path.\nSee the section on Standard Modules later.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 838, "url": "https://docs.python.org/{python_version}/python-tut/node10.html"}
{"title": "Python and the World-Wide Web", "text": "---\nnode101.html node91.html node99.html node1.html\n---\n# Python and the World-Wide Web\nThere is a growing number of modules available for writing WWW tools.\nThe previous release already sported modules `gopherlib`,\n`ftplib`, `httplib` and `urllib` (which unifies the\nother three) for accessing data through the commonest WWW protocols.\nThis release also provides `cgi`, to ease the writing of\nserver-side scripts that use the Common Gateway Interface protocol,\nsupported by most WWW servers. The module `urlparse` provides\nprecise parsing of a URL string into its components (address scheme,\nnetwork location, path, parameters, query, and fragment identifier).\nA rudimentary, parser for HTML files is available in the module\n`htmllib`. It currently supports a subset of HTML 1.0 (if you\nbring it up to date, I'd love to receive your fixes!). Unfortunately\nPython seems to be too slow for real-time parsing and formatting of\nHTML such as required by interactive WWW browsers --- but it's good\nenough to write a ``robot'' (an automated WWW browser that searches\nthe web for information).\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1103, "url": "https://docs.python.org/{python_version}/python-tut/node100.html"}
{"title": "Miscellaneous", "text": "---\nnode102.html node91.html node100.html node1.html\n---\n# Miscellaneous\n- The `socket` module now exports all the needed constants used for\nsocket operations, such as `SO_BROADCAST`.\nThe functions `popen()` and `fdopen()` in the `os`\nmodule now follow the pattern of the built-in function `open()`:\nthe default mode argument is `'r'` and the optional third\nargument specifies the buffer size, where `0` means unbuffered,\n`1` means line-buffered, and any larger number means the size of\nthe buffer in bytes.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 524, "url": "https://docs.python.org/{python_version}/python-tut/node101.html"}
{"title": "About this document ...", "text": "---\ntut.html node101.html node1.html\n---\n# About this document ...\nPython Tutorial\nThis document was generated using the LaTeX2HTML (http://cbl.leeds.ac.uk/nikos/tex2html/doc/latex2html/latex2html.html) translator Version 95.1 (Fri Jan 20 1995) Copyright © 1993, 1994, Nikos Drakos (http://cbl.leeds.ac.uk/nikos/personal.html), Computer Based Learning Unit, University of Leeds.\nThe command line arguments were:\nlatex2html -address guido@cwi.nl -dont_include myformat tut.tex.\nThe translation was initiated by Guido van Rossum on Tue Apr 11 00:17:44 MDT 1995\n---\nguido@cwi.nl", "python_version": "1.2", "length": 575, "url": "https://docs.python.org/{python_version}/python-tut/node102.html"}
{"title": "``Compiled'' Python files", "text": "---\nnode12.html node8.html node10.html node1.html\n---\n## ``Compiled'' Python files\nAs an important speed-up of the start-up time for short programs that\nuse a lot of standard modules, if a file called spam.pyc exists\nin the directory where spam.py is found, this is assumed to\ncontain an already-``compiled'' version of the module spam. The\nmodification time of the version of spam.py used to create\nspam.pyc is recorded in spam.pyc, and the file is ignored if\nthese don't match.\nWhenever spam.py is successfully compiled, an attempt is made to\nwrite the compiled version to spam.pyc. It is not an error if\nthis attempt fails; if for any reason the file is not written\ncompletely, the resulting spam.pyc file will be recognized as\ninvalid and thus ignored later.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 779, "url": "https://docs.python.org/{python_version}/python-tut/node11.html"}
{"title": "Executable Python scripts", "text": "---\nnode13.html node8.html node11.html node1.html\n---\n## Executable Python scripts\nOn BSD'ish Unix systems, Python scripts can be made directly\nexecutable, like shell scripts, by putting the line\n```text\n#! /usr/local/bin/python\n```\n(assuming that's the name of the interpreter) at the beginning of the\nscript and giving the file an executable mode. The #! must be\nthe first two characters of the file.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 419, "url": "https://docs.python.org/{python_version}/python-tut/node12.html"}
{"title": "The Interactive Startup File", "text": "---\nnode14.html node8.html node12.html node1.html\n---\n## The Interactive Startup File\nWhen you use Python interactively, it is frequently handy to have some\nstandard commands executed every time the interpreter is started. You\ncan do this by setting an environment variable named\nPYTHONSTARTUP to the name of a file containing your start-up\ncommands. This is similar to the .profile feature of the UNIX\nshells.\nThis file is only read in interactive sessions, not when Python reads\ncommands from a script, and not when /dev/tty is given as the\nexplicit source of commands (which otherwise behaves like an\ninteractive session). It is executed in the same name space where\ninteractive commands are executed, so that objects that it defines or\nimports can be used without qualification in the interactive session.\nYou can also change the prompts sys.ps1 and sys.ps2 in\nthis file.\nIf you want to read an additional start-up file from the current\ndirectory, you can program this in the global start-up file, e.g.\n`execfile('.pythonrc')`. If you want to use the startup file\nin a script, you must write this explicitly in the script, e.g.\n`import os;` `execfile(os.environ['PYTHONSTARTUP'])`.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1202, "url": "https://docs.python.org/{python_version}/python-tut/node13.html"}
{"title": "Interactive Input Editing and History Substitution", "text": "---\nnode15.html node4.html node13.html node1.html\n---\n# Interactive Input Editing and History Substitution\nSome versions of the Python interpreter support editing of the current\ninput line and history substitution, similar to facilities found in\nthe Korn shell and the GNU Bash shell. This is implemented using the\nGNU Readline library, which supports Emacs-style and vi-style\nediting. This library has its own documentation which I won't\nduplicate here; however, the basics are easily explained.\nPerhaps the quickest check to see whether command line editing is\nsupported is typing Control-P to the first Python prompt you get. If\nit beeps, you have command line editing. If nothing appears to\nhappen, or if `^P` is echoed, you can skip the rest of this\nsection.\n---\n- Line Editing (node15.html#SECTION00331000000000000000)\nHistory Substitution (node16.html#SECTION00332000000000000000)\nKey Bindings (node17.html#SECTION00333000000000000000)\nCommentary (node18.html#SECTION00334000000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1012, "url": "https://docs.python.org/{python_version}/python-tut/node14.html"}
{"title": "Line Editing", "text": "---\nnode16.html node14.html node14.html node1.html\n---\n## Line Editing\nIf supported, input line editing is active whenever the interpreter\nprints a primary or secondary prompt. The current line can be edited\nusing the conventional Emacs control characters. The most important\nof these are: C-A (Control-A) moves the cursor to the beginning of the\nline, C-E to the end, C-B moves it one position to the left, C-F to\nthe right. Backspace erases the character to the left of the cursor,\nC-D the character to its right. C-K kills (erases) the rest of the\nline to the right of the cursor, C-Y yanks back the last killed\nstring. C-underscore undoes the last change you made; it can be\nrepeated for cumulative effect.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 727, "url": "https://docs.python.org/{python_version}/python-tut/node15.html"}
{"title": "History Substitution", "text": "---\nnode17.html node14.html node15.html node1.html\n---\n## History Substitution\nHistory substitution works as follows. All non-empty input lines\nissued are saved in a history buffer, and when a new prompt is given\nyou are positioned on a new line at the bottom of this buffer. C-P\nmoves one line up (back) in the history buffer, C-N moves one down.\nAny line in the history buffer can be edited; an asterisk appears in\nfront of the prompt to mark a line as modified. Pressing the Return\nkey passes the current line to the interpreter. C-R starts an\nincremental reverse search; C-S starts a forward search.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 620, "url": "https://docs.python.org/{python_version}/python-tut/node16.html"}
{"title": "Key Bindings", "text": "---\nnode18.html node14.html node16.html node1.html\n---\n## Key Bindings\nThe key bindings and some other parameters of the Readline library can\nbe customized by placing commands in an initialization file called\n$HOME/.inputrc. Key bindings have the form\n```text\nkey-name: function-name\n```\nor\n```text\n\"string\": function-name\n```\nand options can be set with\n```text\nset option-name value\n```\nFor example:\n```text\n# I prefer vi-style editing:\nset editing-mode vi\n# Edit using a single line:\nset horizontal-scroll-mode On\n# Rebind some keys:\nMeta-h: backward-kill-word\n\"\\C-u\": universal-argument\n\"\\C-x\\C-r\": re-read-init-file\n```\nNote that the default binding for TAB in Python is to insert a TAB\ninstead of Readline's default filename completion function. If you\ninsist, you can override this by putting\n```text\nTAB: complete\n```\nin your $HOME/.inputrc. (Of course, this makes it hard to type\nindented continuation lines...)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 937, "url": "https://docs.python.org/{python_version}/python-tut/node17.html"}
{"title": "Commentary", "text": "---\nnode19.html node14.html node17.html node1.html\n---\n## Commentary\nThis facility is an enormous step forward compared to previous\nversions of the interpreter; however, some wishes are left: It would\nbe nice if the proper indentation were suggested on continuation lines\n(the parser knows if an indent token is required next). The\ncompletion mechanism might use the interpreter's symbol table. A\ncommand to check (or even suggest) matching parentheses, quotes etc.\nwould also be useful.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 504, "url": "https://docs.python.org/{python_version}/python-tut/node18.html"}
{"title": "An Informal Introduction to Python", "text": "---\nnode20.html tut.html node18.html node1.html\n---\n# An Informal Introduction to Python\nIn the following examples, input and output are distinguished by the\npresence or absence of prompts (>>> and ...): to repeat\nthe example, you must type everything after the prompt, when the\nprompt appears; lines that do not begin with a prompt are output from\nthe interpreter.\nfootnode.html#108\nNote that a secondary prompt on a line by itself in an example means\nyou must type a blank line; this is used to end a multi-line command.\n---\n- Using Python as a Calculator (node20.html#SECTION00410000000000000000)\n- Numbers (node21.html#SECTION00411000000000000000)\nStrings (node22.html#SECTION00412000000000000000)\nLists (node23.html#SECTION00413000000000000000)\nFirst Steps Towards Programming (node24.html#SECTION00420000000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 840, "url": "https://docs.python.org/{python_version}/python-tut/node19.html"}
{"title": "Whetting Your Appetite", "text": "---\nnode3.html tut.html node1.html node1.html\n---\n# Whetting Your Appetite\nIf you ever wrote a large shell script, you probably know this\nfeeling: you'd love to add yet another feature, but it's already so\nslow, and so big, and so complicated; or the feature involves a system\ncall or other function that is only accessible from C ...Usually\nthe problem at hand isn't serious enough to warrant rewriting the\nscript in C; perhaps because the problem requires variable-length\nstrings or other data types (like sorted lists of file names) that are\neasy in the shell but lots of work to implement in C; or perhaps just\nbecause you're not sufficiently familiar with C.\nIn such cases, Python may be just the language for you. Python is\nsimple to use, but it is a real programming language, offering much\nmore structure and support for large programs than the shell has. On\nthe other hand, it also offers much more error checking than C, and,\nbeing a very-high-level language, it has high-level data types\nbuilt in, such as flexible arrays and dictionaries that would cost you\ndays to implement efficiently in C. Because of its more general data\ntypes Python is applicable to a much larger problem domain than\nAwk or even Perl, yet many things are at least as easy in\nPython as in those languages.\nPython allows you to split up your program in modules that can be\nreused in other Python programs. It comes with a large collection of\nstandard modules that you can use as the basis of your programs --- or\nas examples to start learning to program in Python. There are also\nbuilt-in modules that provide things like file I/O, system calls,\nsockets, and even a generic interface to window systems (STDWIN).\nPython is an interpreted language, which can save you considerable time\nduring program development because no compilation and linking is\nnecessary. The interpreter can be used interactively, which makes it\neasy to experiment with features of the language, to write throw-away\nprograms, or to test functions during bottom-up program development.\nIt is also a handy desk calculator.\nPython allows writing very compact and readable programs. Programs\nwritten in Python are typically much shorter than equivalent C\nprograms, for several reasons:\n- the high-level data types allow you to express complex operations in a\nsingle statement;\nstatement grouping is done by indentation instead of begin/end\nbrackets;\nno variable or argument declarations are necessary.\nPython is extensible: if you know how to program in C it is easy\nto add a new built-in\nfunction or\nmodule to the interpreter, either to\nperform critical operations at maximum speed, or to link Python\nprograms to libraries that may only be available in binary form (such\nas a vendor-specific graphics library). Once you are really hooked,\nyou can link the Python interpreter into an application written in C\nand use it as an extension or command language for that application.\nBy the way, the language is named after the BBC show ``Monty\nPython's Flying Circus'' and has nothing to do with nasty reptiles...\n---\n- Where From Here (node3.html#SECTION00210000000000000000)\n---\nnode3.html tut.html node1.html node1.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 3190, "url": "https://docs.python.org/{python_version}/python-tut/node2.html"}
{"title": "Using Python as a Calculator", "text": "---\nnode21.html node19.html node19.html node1.html\n---\n# Using Python as a Calculator\nLet's try some simple Python commands. Start the interpreter and wait\nfor the primary prompt, >>>. (It shouldn't take long.)\n---\n- Numbers (node21.html#SECTION00411000000000000000)\nStrings (node22.html#SECTION00412000000000000000)\nLists (node23.html#SECTION00413000000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 381, "url": "https://docs.python.org/{python_version}/python-tut/node20.html"}
{"title": "Numbers", "text": "---\nnode22.html node20.html node20.html node1.html\n---\n## Numbers\nThe interpreter acts as a simple calculator: you can type an\nexpression at it and it will write the value. Expression syntax is\nstraightforward: the operators +, -, * and /\nwork just like in most other languages (e.g., Pascal or C); parentheses\ncan be used for grouping. For example:\n```text\n>>> 2+2\n4\n>>> # This is a comment\n... 2+2\n4\n>>> 2+2 # and a comment on the same line as code\n4\n>>> (50-5*6)/4\n5\n>>> # Integer division returns the floor:\n... 7/3\n2\n>>> 7/-3\n-3\n>>>\n```\nLike in C, the equal sign (=) is used to assign a value to a\nvariable. The value of an assignment is not written:\n```text\n>>> width = 20\n>>> height = 5*9\n>>> width * height\n900\n>>>\n```\nA value can be assigned to several variables simultaneously:\n```text\n>>> x = y = z = 0 # Zero x, y and z\n>>> x\n0\n>>> y\n0\n>>> z\n0\n>>>\n```\nThere is full support for floating point; operators with mixed type\noperands convert the integer operand to floating point:\n```text\n>>> 4 * 2.5 / 3.3\n3.0303030303\n>>> 7.0 / 2\n3.5\n>>>\n```\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1067, "url": "https://docs.python.org/{python_version}/python-tut/node21.html"}
{"title": "Strings", "text": "---\nnode23.html node20.html node21.html node1.html\n---\n## Strings\nBesides numbers, Python can also manipulate strings, enclosed in\nsingle quotes or double quotes:\n```text\n>>> 'spam eggs'\n'spam eggs'\n>>> 'doesn\\'t'\n\"doesn't\"\n>>> \"doesn't\"\n\"doesn't\"\n>>> '\"Yes,\" he said.'\n'\"Yes,\" he said.'\n>>> \"\\\"Yes,\\\" he said.\"\n'\"Yes,\" he said.'\n>>> '\"Isn\\'t,\" she said.'\n'\"Isn\\'t,\" she said.'\n>>>\n```\nStrings are written the same way as they are typed for input: inside\nquotes and with quotes and other funny characters escaped by backslashes,\nto show the precise value. The string is enclosed in double quotes if\nthe string contains a single quote and no double quotes, else it's\nenclosed in single quotes. (The print statement, described later,\ncan be used to write strings without quotes or escapes.)\nStrings can be concatenated (glued together) with the +\noperator, and repeated with *:\n```text\n>>> word = 'Help' + 'A'\n>>> word\n'HelpA'\n>>> '<' + word*5 + '>'\n'<HelpAHelpAHelpAHelpAHelpA>'\n>>>\n```\nStrings can be subscripted (indexed); like in C, the first character of\na string has subscript (index) 0.\nThere is no separate character type; a character is simply a string of\nsize one. Like in Icon, substrings can be specified with the\nslice notation: two indices separated by a colon.\n```text\n>>> word[4]\n'A'\n>>> word[0:2]\n'He'\n>>> word[2:4]\n'lp'\n>>>\n```\nSlice indices have useful defaults; an omitted first index defaults to\nzero, an omitted second index defaults to the size of the string being\nsliced.\n```text\n>>> word[:2] # The first two characters\n'He'\n>>> word[2:] # All but the first two characters\n'lpA'\n>>>\n```\nHere's a useful invariant of slice operations: `s[:i] + s[i:]`\nequals `s`.\n```text\n>>> word[:2] + word[2:]\n'HelpA'\n>>> word[:3] + word[3:]\n'HelpA'\n>>>\n```\nDegenerate slice indices are handled gracefully: an index that is too\nlarge is replaced by the string size, an upper bound smaller than the\nlower bound returns an empty string.\n```text\n>>> word[1:100]\n'elpA'\n>>> word[10:]\n''\n>>> word[2:1]\n''\n>>>\n```\nIndices may be negative numbers, to start counting from the right.\nFor example:\n```text\n>>> word[-1] # The last character\n'A'\n>>> word[-2] # The last-but-one character\n'p'\n>>> word[-2:] # The last two characters\n'pA'\n>>> word[:-2] # All but the last two characters\n'Hel'\n>>>\n```\nBut note that -0 is really the same as 0, so it does not count from\nthe right!\n```text\n>>> word[-0] # (since -0 equals 0)\n'H'\n>>>\n```\nOut-of-range negative slice indices are truncated, but don't try this\nfor single-element (non-slice) indices:\n```text\n>>> word[-100:]\n'HelpA'\n>>> word[-10] # error\nTraceback (innermost last):\nFile \"<stdin>\", line 1\nIndexError: string index out of range\n>>>\n```\nThe best way to remember how slices work is to think of the indices as\npointing between characters, with the left edge of the first\ncharacter numbered 0. Then the right edge of the last character of a\nstring of n characters has index n, for example:\n```text\n+---+---+---+---+---+\n| H | e | l | p | A |\n+---+---+---+---+---+\n0 1 2 3 4 5\n-5 -4 -3 -2 -1\n```\nThe first row of numbers gives the position of the indices 0...5 in\nthe string; the second row gives the corresponding negative indices.\nThe slice from `i` to `j` consists of all characters between\nthe edges labeled `i` and `j`, respectively.\nFor nonnegative indices, the length of a slice is the difference of\nthe indices, if both are within bounds, e.g., the length of\n`word[1:3]` is 2.\nThe built-in function len() returns the length of a string:\n```text\n>>> s = 'supercalifragilisticexpialidocious'\n>>> len(s)\n34\n>>>\n```\n---\nnode23.html node20.html node21.html node1.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 3638, "url": "https://docs.python.org/{python_version}/python-tut/node22.html"}
{"title": "Lists", "text": "---\nnode24.html node20.html node22.html node1.html\n---\n## Lists\nPython knows a number of compound data types, used to group\ntogether other values. The most versatile is the list, which\ncan be written as a list of comma-separated values (items) between\nsquare brackets. List items need not all have the same type.\n```text\n>>> a = ['spam', 'eggs', 100, 1234]\n>>> a\n['spam', 'eggs', 100, 1234]\n>>>\n```\nLike string indices, list indices start at 0, and lists can be sliced,\nconcatenated and so on:\n```text\n>>> a[0]\n'spam'\n>>> a[3]\n1234\n>>> a[-2]\n100\n>>> a[1:-1]\n['eggs', 100]\n>>> a[:2] + ['bacon', 2*2]\n['spam', 'eggs', 'bacon', 4]\n>>> 3*a[:3] + ['Boe!']\n['spam', 'eggs', 100, 'spam', 'eggs', 100, 'spam', 'eggs', 100, 'Boe!']\n>>>\n```\nUnlike strings, which are immutable, it is possible to change\nindividual elements of a list:\n```text\n>>> a\n['spam', 'eggs', 100, 1234]\n>>> a[2] = a[2] + 23\n>>> a\n['spam', 'eggs', 123, 1234]\n>>>\n```\nAssignment to slices is also possible, and this can even change the size\nof the list:\n```text\n>>> # Replace some items:\n... a[0:2] = [1, 12]\n>>> a\n[1, 12, 123, 1234]\n>>> # Remove some:\n... a[0:2] = []\n>>> a\n[123, 1234]\n>>> # Insert some:\n... a[1:1] = ['bletch', 'xyzzy']\n>>> a\n[123, 'bletch', 'xyzzy', 1234]\n>>> a[:0] = a # Insert (a copy of) itself at the beginning\n>>> a\n[123, 'bletch', 'xyzzy', 1234, 123, 'bletch', 'xyzzy', 1234]\n>>>\n```\nThe built-in function len() also applies to lists:\n```text\n>>> len(a)\n8\n>>>\n```\nIt is possible to nest lists (create lists containing other lists),\nfor example:\n```text\n>>> q = [2, 3]\n>>> p = [1, q, 4]\n>>> len(p)\n3\n>>> p[1]\n[2, 3]\n>>> p[1][0]\n2\n>>> p[1].append('xtra') # See section 5.1\n>>> p\n[1, [2, 3, 'xtra'], 4]\n>>> q\n[2, 3, 'xtra']\n>>>\n```\nNote that in the last example, p[1] and q really refer to\nthe same object! We'll come back to object semantics later.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1850, "url": "https://docs.python.org/{python_version}/python-tut/node23.html"}
{"title": "First Steps Towards Programming", "text": "---\nnode25.html node19.html node23.html node1.html\n---\n# First Steps Towards Programming\nOf course, we can use Python for more complicated tasks than adding\ntwo and two together. For instance, we can write an initial\nsubsequence of the Fibonacci series as follows:\n```text\n>>> # Fibonacci series:\n... # the sum of two elements defines the next\n... a, b = 0, 1\n>>> while b < 10:\n... print b\n... a, b = b, a+b\n...\n1\n1\n2\n3\n5\n8\n>>>\n```\nThis example introduces several new features.\n- The first line contains a multiple assignment: the variables\na and b simultaneously get the new values 0 and 1. On the\nlast line this is used again, demonstrating that the expressions on\nthe right-hand side are all evaluated first before any of the\nassignments take place.\nThe while loop executes as long as the condition (here: b <\n10) remains true. In Python, like in C, any non-zero integer value is\ntrue; zero is false. The condition may also be a string or list value,\nin fact any sequence; anything with a non-zero length is true, empty\nsequences are false. The test used in the example is a simple\ncomparison. The standard comparison operators are written the same as\nin C: <, >, ==, <=, >= and !=.\nThe body of the loop is indented: indentation is Python's\nway of grouping statements. Python does not (yet!) provide an\nintelligent input line editing facility, so you have to type a tab or\nspace(s) for each indented line. In practice you will prepare more\ncomplicated input for Python with a text editor; most text editors have\nan auto-indent facility. When a compound statement is entered\ninteractively, it must be followed by a blank line to indicate\ncompletion (since the parser cannot guess when you have typed the last\nline).\nThe print statement writes the value of the expression(s) it is\ngiven. It differs from just writing the expression you want to write\n(as we did earlier in the calculator examples) in the way it handles\nmultiple expressions and strings. Strings are printed without quotes,\nand a space is inserted between items, so you can format things nicely,\nlike this:\n```text\n>>> i = 256*256\n>>> print 'The value of i is', i\nThe value of i is 65536\n>>>\n```\nA trailing comma avoids the newline after the output:\n```text\n>>> a, b = 0, 1\n>>> while b < 1000:\n... print b,\n... a, b = b, a+b\n...\n1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987\n>>>\n```\nNote that the interpreter inserts a newline before it prints the next\nprompt if the last line was not completed.\n---\nnode25.html node19.html node23.html node1.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 2534, "url": "https://docs.python.org/{python_version}/python-tut/node24.html"}
{"title": "More Control Flow Tools", "text": "---\nnode26.html tut.html node24.html node1.html\n---\n# More Control Flow Tools\nBesides the while statement just introduced, Python knows the\nusual control flow statements known from other languages, with some\ntwists.\n---\n- If Statements (node26.html#SECTION00510000000000000000)\nFor Statements (node27.html#SECTION00520000000000000000)\nThe range() Function (node28.html#SECTION00530000000000000000)\nBreak and Continue Statements, and Else Clauses on Loops (node29.html#SECTION00540000000000000000)\nPass Statements (node30.html#SECTION00550000000000000000)\nDefining Functions (node31.html#SECTION00560000000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 632, "url": "https://docs.python.org/{python_version}/python-tut/node25.html"}
{"title": "If Statements", "text": "---\nnode27.html node25.html node25.html node1.html\n---\n# If Statements\nPerhaps the most well-known statement type is the if statement.\nFor example:\n```text\n>>> if x < 0:\n... x = 0\n... print 'Negative changed to zero'\n... elif x == 0:\n... print 'Zero'\n... elif x == 1:\n... print 'Single'\n... else:\n... print 'More'\n...\n```\nThere can be zero or more elif parts, and the else part is\noptional. The keyword `elif' is short for `else if', and is\nuseful to avoid excessive indentation. An if...elif...elif...\nsequence is a substitute for the switch or case statements\nfound in other languages.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 604, "url": "https://docs.python.org/{python_version}/python-tut/node26.html"}
{"title": "For Statements", "text": "---\nnode28.html node25.html node26.html node1.html\n---\n# For Statements\nThe for statement in Python differs a bit from what you may be\nused to in C or Pascal. Rather than always iterating over an\narithmetic progression of numbers (like in Pascal), or leaving the user\ncompletely free in the iteration test and step (as C), Python's\nfor statement iterates over the items of any sequence (e.g., a list\nor a string), in the order that they appear in the sequence. For\nexample (no pun intended):\n```text\n>>> # Measure some strings:\n... a = ['cat', 'window', 'defenestrate']\n>>> for x in a:\n... print x, len(x)\n...\ncat 3\nwindow 6\ndefenestrate 12\n>>>\n```\nIt is not safe to modify the sequence being iterated over in the loop\n(this can only happen for mutable sequence types, i.e., lists). If\nyou need to modify the list you are iterating over, e.g., duplicate\nselected items, you must iterate over a copy. The slice notation\nmakes this particularly convenient:\n```text\n>>> for x in a[:]: # make a slice copy of the entire list\n... if len(x) > 6: a.insert(0, x)\n...\n>>> a\n['defenestrate', 'cat', 'window', 'defenestrate']\n>>>\n```\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1139, "url": "https://docs.python.org/{python_version}/python-tut/node27.html"}
{"title": "The range() Function", "text": "---\nnode29.html node25.html node27.html node1.html\n---\n# The range() Function\nIf you do need to iterate over a sequence of numbers, the built-in\nfunction range() comes in handy. It generates lists containing\narithmetic progressions, e.g.:\n```text\n>>> range(10)\n[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n>>>\n```\nThe given end point is never part of the generated list; range(10)\ngenerates a list of 10 values, exactly the legal indices for items of a\nsequence of length 10. It is possible to let the range start at another\nnumber, or to specify a different increment (even negative):\n```text\n>>> range(5, 10)\n[5, 6, 7, 8, 9]\n>>> range(0, 10, 3)\n[0, 3, 6, 9]\n>>> range(-10, -100, -30)\n[-10, -40, -70]\n>>>\n```\nTo iterate over the indices of a sequence, combine range() and\nlen() as follows:\n```text\n>>> a = ['Mary', 'had', 'a', 'little', 'lamb']\n>>> for i in range(len(a)):\n... print i, a[i]\n...\n0 Mary\n1 had\n2 a\n3 little\n4 lamb\n>>>\n```\n---\nguido@cwi.nl", "python_version": "1.2", "length": 939, "url": "https://docs.python.org/{python_version}/python-tut/node28.html"}
{"title": "Break and Continue Statements, and Else Clauses on Loops", "text": "---\nnode30.html node25.html node28.html node1.html\n---\n# Break and Continue Statements, and Else Clauses on Loops\nThe break statement, like in C, breaks out of the smallest\nenclosing for or while loop.\nThe continue statement, also borrowed from C, continues with the\nnext iteration of the loop.\nLoop statements may have an else clause; it is executed when the\nloop terminates through exhaustion of the list (with for) or when\nthe condition becomes false (with while), but not when the loop is\nterminated by a break statement. This is exemplified by the\nfollowing loop, which searches for prime numbers:\n```text\n>>> for n in range(2, 10):\n... for x in range(2, n):\n... if n % x == 0:\n... print n, 'equals', x, '*', n/x\n... break\n... else:\n... print n, 'is a prime number'\n...\n2 is a prime number\n3 is a prime number\n4 equals 2 * 2\n5 is a prime number\n6 equals 2 * 3\n7 is a prime number\n8 equals 2 * 4\n9 equals 3 * 3\n>>>\n```\n---\nguido@cwi.nl", "python_version": "1.2", "length": 939, "url": "https://docs.python.org/{python_version}/python-tut/node29.html"}
{"title": "Where From Here", "text": "---\nnode4.html node2.html node2.html node1.html\n---\n# Where From Here\nNow that you are all excited about Python, you'll want to examine it\nin some more detail. Since the best way to learn a language is\nusing it, you are invited here to do so.\nIn the next chapter, the mechanics of using the interpreter are\nexplained. This is rather mundane information, but essential for\ntrying out the examples shown later.\nThe rest of the tutorial introduces various features of the Python\nlanguage and system though examples, beginning with simple\nexpressions, statements and data types, through functions and modules,\nand finally touching upon advanced concepts like exceptions\nand user-defined classes.\nWhen you're through with the tutorial (or just getting bored), you\nshould read the Library Reference, which gives complete (though terse)\nreference material about built-in and standard types, functions and\nmodules that can save you a lot of time when writing Python programs.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 984, "url": "https://docs.python.org/{python_version}/python-tut/node3.html"}
{"title": "Pass Statements", "text": "---\nnode31.html node25.html node29.html node1.html\n---\n# Pass Statements\nThe pass statement does nothing.\nIt can be used when a statement is required syntactically but the\nprogram requires no action.\nFor example:\n```text\n>>> while 1:\n... pass # Busy-wait for keyboard interrupt\n...\n```\n---\nguido@cwi.nl", "python_version": "1.2", "length": 302, "url": "https://docs.python.org/{python_version}/python-tut/node30.html"}
{"title": "Defining Functions", "text": "---\nnode32.html node25.html node30.html node1.html\n---\n# Defining Functions\nWe can create a function that writes the Fibonacci series to an\narbitrary boundary:\n```text\n>>> def fib(n): # write Fibonacci series up to n\n... a, b = 0, 1\n... while b < n:\n... print b,\n... a, b = b, a+b\n...\n>>> # Now call the function we just defined:\n... fib(2000)\n1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597\n>>>\n```\nThe keyword def introduces a function definition. It must\nbe followed by the function name and the parenthesized list of formal\nparameters. The statements that form the body of the function starts at\nthe next line, indented by a tab stop.\nThe execution of a function introduces a new symbol table used\nfor the local variables of the function. More precisely, all variable\nassignments in a function store the value in the local symbol table;\nwhereas\nvariable references first look in the local symbol table, then\nin the global symbol table, and then in the table of built-in names.\nThus,\nglobal variables cannot be directly assigned a value within a\nfunction (unless named in a global statement), although\nthey may be referenced.\nThe actual parameters (arguments) to a function call are introduced in\nthe local symbol table of the called function when it is called; thus,\narguments are passed using call by value.\nfootnode.html#550\nWhen a function calls another function, a new local symbol table is\ncreated for that call.\nA function definition introduces the function name in the\ncurrent\nsymbol table. The value\nof the function name\nhas a type that is recognized by the interpreter as a user-defined\nfunction. This value can be assigned to another name which can then\nalso be used as a function. This serves as a general renaming\nmechanism:\n```text\n>>> fib\n<function object at 10042ed0>\n>>> f = fib\n>>> f(100)\n1 1 2 3 5 8 13 21 34 55 89\n>>>\n```\nYou might object that fib is not a function but a procedure. In\nPython, like in C, procedures are just functions that don't return a\nvalue. In fact, technically speaking, procedures do return a value,\nalbeit a rather boring one. This value is called None (it's a\nbuilt-in name). Writing the value None is normally suppressed by\nthe interpreter if it would be the only value written. You can see it\nif you really want to:\n```text\n>>> print fib(0)\nNone\n>>>\n```\nIt is simple to write a function that returns a list of the numbers of\nthe Fibonacci series, instead of printing it:\n```text\n>>> def fib2(n): # return Fibonacci series up to n\n... result = []\n... a, b = 0, 1\n... while b < n:\n... result.append(b) # see below\n... a, b = b, a+b\n... return result\n...\n>>> f100 = fib2(100) # call it\n>>> f100 # write the result\n[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]\n>>>\n```\nThis example, as usual, demonstrates some new Python features:\n- The return statement returns with a value from a function.\nreturn without an expression argument is used to return from the middle\nof a procedure (falling off the end also returns from a procedure), in\nwhich case the None value is returned.\nThe statement result.append(b) calls a method of the list\nobject result. A method is a function that `belongs' to an\nobject and is named obj.methodname, where obj is some\nobject (this may be an expression), and methodname is the name\nof a method that is defined by the object's type. Different types\ndefine different methods. Methods of different types may have the\nsame name without causing ambiguity. (It is possible to define your\nown object types and methods, using classes, as discussed later\nin this tutorial.)\nThe method append shown in the example, is defined for\nlist objects; it adds a new element at the end of the list. In this\nexample\nit is equivalent to result = result + [b], but more efficient.\n---\nnode32.html node25.html node30.html node1.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 3800, "url": "https://docs.python.org/{python_version}/python-tut/node31.html"}
{"title": "Odds and Ends", "text": "---\nnode33.html tut.html node31.html node1.html\n---\n# Odds and Ends\nThis chapter describes some things you've learned about already in\nmore detail, and adds some new things as well.\n---\n- More on Lists (node33.html#SECTION00610000000000000000)\nThe del statement (node34.html#SECTION00620000000000000000)\nTuples and Sequences (node35.html#SECTION00630000000000000000)\nDictionaries (node36.html#SECTION00640000000000000000)\nMore on Conditions (node37.html#SECTION00650000000000000000)\nComparing Sequences and Other Types (node38.html#SECTION00660000000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 577, "url": "https://docs.python.org/{python_version}/python-tut/node32.html"}
{"title": "More on Lists", "text": "---\nnode34.html node32.html node32.html node1.html\n---\n# More on Lists\nThe list data type has some more methods. Here are all of the methods\nof lists objects:\nAn example that uses all list methods:\n```text\n>>> a = [66.6, 333, 333, 1, 1234.5]\n>>> print a.count(333), a.count(66.6), a.count('x')\n2 1 0\n>>> a.insert(2, -1)\n>>> a.append(333)\n>>> a\n[66.6, 333, -1, 333, 1, 1234.5, 333]\n>>> a.index(333)\n1\n>>> a.remove(333)\n>>> a\n[66.6, -1, 333, 1, 1234.5, 333]\n>>> a.reverse()\n>>> a\n[333, 1234.5, 1, 333, -1, 66.6]\n>>> a.sort()\n>>> a\n[-1, 1, 66.6, 333, 333, 1234.5]\n>>>\n```\n---\nguido@cwi.nl", "python_version": "1.2", "length": 585, "url": "https://docs.python.org/{python_version}/python-tut/node33.html"}
{"title": "The del statement", "text": "---\nnode35.html node32.html node33.html node1.html\n---\n# The del statement\nThere is a way to remove an item from a list given its index instead\nof its value: the del statement. This can also be used to\nremove slices from a list (which we did earlier by assignment of an\nempty list to the slice). For example:\n```text\n>>> a\n[-1, 1, 66.6, 333, 333, 1234.5]\n>>> del a[0]\n>>> a\n[1, 66.6, 333, 333, 1234.5]\n>>> del a[2:4]\n>>> a\n[1, 66.6, 1234.5]\n>>>\n```\ndel can also be used to delete entire variables:\n```text\n>>> del a\n>>>\n```\nReferencing the name a hereafter is an error (at least until\nanother value is assigned to it). We'll find other uses for del\nlater.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 672, "url": "https://docs.python.org/{python_version}/python-tut/node34.html"}
{"title": "Tuples and Sequences", "text": "---\nnode36.html node32.html node34.html node1.html\n---\n# Tuples and Sequences\nWe saw that lists and strings have many common properties, e.g.,\nindexing and slicing operations. They are two examples of\nsequence data types. Since Python is an evolving language, other\nsequence data types may be added. There is also another standard\nsequence data type: the tuple.\nA tuple consists of a number of values separated by commas, for\ninstance:\n```text\n>>> t = 12345, 54321, 'hello!'\n>>> t[0]\n12345\n>>> t\n(12345, 54321, 'hello!')\n>>> # Tuples may be nested:\n... u = t, (1, 2, 3, 4, 5)\n>>> u\n((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))\n>>>\n```\nAs you see, on output tuples are alway enclosed in parentheses, so\nthat nested tuples are interpreted correctly; they may be input with\nor without surrounding parentheses, although often parentheses are\nnecessary anyway (if the tuple is part of a larger expression).\nTuples have many uses, e.g., (x, y) coordinate pairs, employee records\nfrom a database, etc. Tuples, like strings, are immutable: it is not\npossible to assign to the individual items of a tuple (you can\nsimulate much of the same effect with slicing and concatenation,\nthough).\nA special problem is the construction of tuples containing 0 or 1\nitems: the syntax has some extra quirks to accommodate these. Empty\ntuples are constructed by an empty pair of parentheses; a tuple with\none item is constructed by following a value with a comma\n(it is not sufficient to enclose a single value in parentheses).\nUgly, but effective. For example:\n```text\n>>> empty = ()\n>>> singleton = 'hello', # <-- note trailing comma\n>>> len(empty)\n0\n>>> len(singleton)\n1\n>>> singleton\n('hello',)\n>>>\n```\nThe statement t = 12345, 54321, 'hello!' is an example of\ntuple packing: the values 12345, 54321 and 'hello!'\nare packed together in a tuple. The reverse operation is also\npossible, e.g.:\n```text\n>>> x, y, z = t\n>>>\n```\nThis is called, appropriately enough, tuple unpacking. Tuple\nunpacking requires that the list of variables on the left has the same\nnumber of elements as the length of the tuple. Note that multiple\nassignment is really just a combination of tuple packing and tuple\nunpacking!\nOccasionally, the corresponding operation on lists is useful: list\nunpacking. This is supported by enclosing the list of variables in\nsquare brackets:\n```text\n>>> a = ['spam', 'eggs', 100, 1234]\n>>> [a1, a2, a3, a4] = a\n>>>\n```\n---\nnode36.html node32.html node34.html node1.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 2478, "url": "https://docs.python.org/{python_version}/python-tut/node35.html"}
{"title": "Dictionaries", "text": "---\nnode37.html node32.html node35.html node1.html\n---\n# Dictionaries\nAnother useful data type built into Python is the dictionary.\nDictionaries are sometimes found in other languages as ``associative\nmemories'' or ``associative arrays''. Unlike sequences, which are\nindexed by a range of numbers, dictionaries are indexed by keys,\nwhich are strings (the use of non-string values as keys\nis supported, but beyond the scope of this tutorial).\nIt is best to think of a dictionary as an unordered set of\nkey:value pairs, with the requirement that the keys are unique\n(within one dictionary).\nA pair of braces creates an empty dictionary: `{}`.\nPlacing a comma-separated list of key:value pairs within the\nbraces adds initial key:value pairs to the dictionary; this is also the\nway dictionaries are written on output.\nThe main operations on a dictionary are storing a value with some key\nand extracting the value given the key. It is also possible to delete\na key:value pair\nwith del.\nIf you store using a key that is already in use, the old value\nassociated with that key is forgotten. It is an error to extract a\nvalue using a non-existent key.\nThe keys() method of a dictionary object returns a list of all the\nkeys used in the dictionary, in random order (if you want it sorted,\njust apply the sort() method to the list of keys). To check\nwhether a single key is in the dictionary, use the `has_key()`\nmethod of the dictionary.\nHere is a small example using a dictionary:\n```text\n>>> tel = {'jack': 4098, 'sape': 4139}\n>>> tel['guido'] = 4127\n>>> tel\n{'sape': 4139, 'guido': 4127, 'jack': 4098}\n>>> tel['jack']\n4098\n>>> del tel['sape']\n>>> tel['irv'] = 4127\n>>> tel\n{'guido': 4127, 'irv': 4127, 'jack': 4098}\n>>> tel.keys()\n['guido', 'irv', 'jack']\n>>> tel.has_key('guido')\n1\n>>>\n```\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1800, "url": "https://docs.python.org/{python_version}/python-tut/node36.html"}
{"title": "More on Conditions", "text": "---\nnode38.html node32.html node36.html node1.html\n---\n# More on Conditions\nThe conditions used in while and if statements above can\ncontain other operators besides comparisons.\nThe comparison operators in and not in check whether a value\noccurs (does not occur) in a sequence. The operators is and\nis not compare whether two objects are really the same object; this\nonly matters for mutable objects like lists. All comparison operators\nhave the same priority, which is lower than that of all numerical\noperators.\nComparisons can be chained: e.g., a < b == c tests whether a\nis less than b and moreover b equals c.\nComparisons may be combined by the Boolean operators and and\nor, and the outcome of a comparison (or of any other Boolean\nexpression) may be negated with not. These all have lower\npriorities than comparison operators again; between them, not has\nthe highest priority, and or the lowest, so that\nA and not B or C is equivalent to (A and (not B)) or C. Of\ncourse, parentheses can be used to express the desired composition.\nThe Boolean operators and and or are so-called\nshortcut operators: their arguments are evaluated from left to right,\nand evaluation stops as soon as the outcome is determined. E.g., if\nA and C are true but B is false, A and B and C\ndoes not evaluate the expression C. In general, the return value of a\nshortcut operator, when used as a general value and not as a Boolean, is\nthe last evaluated argument.\nIt is possible to assign the result of a comparison or other Boolean\nexpression to a variable. For example,\n```text\n>>> string1, string2, string3 = '', 'Trondheim', 'Hammer Dance'\n>>> non_null = string1 or string2 or string3\n>>> non_null\n'Trondheim'\n>>>\n```\nNote that in Python, unlike C, assignment cannot occur inside expressions.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1790, "url": "https://docs.python.org/{python_version}/python-tut/node37.html"}
{"title": "Comparing Sequences and Other Types", "text": "---\nnode39.html node32.html node37.html node1.html\n---\n# Comparing Sequences and Other Types\nSequence objects may be compared to other objects with the same\nsequence type. The comparison uses lexicographical ordering:\nfirst the first two items are compared, and if they differ this\ndetermines the outcome of the comparison; if they are equal, the next\ntwo items are compared, and so on, until either sequence is exhausted.\nIf two items to be compared are themselves sequences of the same type,\nthe lexicographical comparison is carried out recursively. If all\nitems of two sequences compare equal, the sequences are considered\nequal. If one sequence is an initial subsequence of the other, the\nshorted sequence is the smaller one. Lexicographical ordering for\nstrings uses the ASCII ordering for individual characters. Some\nexamples of comparisons between sequences with the same types:\n```text\n(1, 2, 3) < (1, 2, 4)\n[1, 2, 3] < [1, 2, 4]\n'ABC' < 'C' < 'Pascal' < 'Python'\n(1, 2, 3, 4) < (1, 2, 4)\n(1, 2) < (1, 2, -1)\n(1, 2, 3) = (1.0, 2.0, 3.0)\n(1, 2, ('aa', 'ab')) < (1, 2, ('abc', 'a'), 4)\n```\nNote that comparing objects of different types is legal. The outcome\nis deterministic but arbitrary: the types are ordered by their name.\nThus, a list is always smaller than a string, a string is always\nsmaller than a tuple, etc. Mixed numeric types are compared according\nto their numeric value, so 0 equals 0.0, etc.\nfootnode.html#275\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1450, "url": "https://docs.python.org/{python_version}/python-tut/node38.html"}
{"title": "Modules", "text": "---\nnode40.html tut.html node38.html node1.html\n---\n# Modules\nIf you quit from the Python interpreter and enter it again, the\ndefinitions you have made (functions and variables) are lost.\nTherefore, if you want to write a somewhat longer program, you are\nbetter off using a text editor to prepare the input for the interpreter\nand running it with that file as input instead. This is known as creating a\nscript. As your program gets longer, you may want to split it\ninto several files for easier maintenance. You may also want to use a\nhandy function that you've written in several programs without copying\nits definition into each program.\nTo support this, Python has a way to put definitions in a file and use\nthem in a script or in an interactive instance of the interpreter.\nSuch a file is called a module; definitions from a module can be\nimported into other modules or into the main module (the\ncollection of variables that you have access to in a script\nexecuted at the top level\nand in calculator mode).\nA module is a file containing Python definitions and statements. The\nfile name is the module name with the suffix .py appended. Within\na module, the module's name (as a string) is available as the value of\nthe global variable __name__. For instance, use your favorite text\neditor to create a file called fibo.py in the current directory\nwith the following contents:\n```text\n# Fibonacci numbers module\n\ndef fib(n): # write Fibonacci series up to n\na, b = 0, 1\nwhile b < n:\nprint b,\na, b = b, a+b\n\ndef fib2(n): # return Fibonacci series up to n\nresult = []\na, b = 0, 1\nwhile b < n:\nresult.append(b)\na, b = b, a+b\nreturn result\n```\nNow enter the Python interpreter and import this module with the\nfollowing command:\n```text\n>>> import fibo\n>>>\n```\nThis does not enter the names of the functions defined in\nfibo\ndirectly in the current symbol table; it only enters the module name\nfibo\nthere.\nUsing the module name you can access the functions:\n```text\n>>> fibo.fib(1000)\n1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987\n>>> fibo.fib2(100)\n[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]\n>>> fibo.__name__\n'fibo'\n>>>\n```\nIf you intend to use a function often you can assign it to a local name:\n```text\n>>> fib = fibo.fib\n>>> fib(500)\n1 1 2 3 5 8 13 21 34 55 89 144 233 377\n>>>\n```\n---\n- More on Modules (node40.html#SECTION00710000000000000000)\nStandard Modules (node41.html#SECTION00720000000000000000)\nThe dir() function (node42.html#SECTION00730000000000000000)\n---\nnode40.html tut.html node38.html node1.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 2529, "url": "https://docs.python.org/{python_version}/python-tut/node39.html"}
{"title": "Using the Python Interpreter", "text": "---\nnode5.html tut.html node3.html node1.html\n---\n# Using the Python Interpreter\n---\n- Invoking the Interpreter (node5.html#SECTION00310000000000000000)\n- Argument Passing (node6.html#SECTION00311000000000000000)\nInteractive Mode (node7.html#SECTION00312000000000000000)\nThe Interpreter and its Environment (node8.html#SECTION00320000000000000000)\n- Error Handling (node9.html#SECTION00321000000000000000)\nThe Module Search Path (node10.html#SECTION00322000000000000000)\n``Compiled'' Python files (node11.html#SECTION00323000000000000000)\nExecutable Python scripts (node12.html#SECTION00324000000000000000)\nThe Interactive Startup File (node13.html#SECTION00325000000000000000)\nInteractive Input Editing and History Substitution (node14.html#SECTION00330000000000000000)\n- Line Editing (node15.html#SECTION00331000000000000000)\nHistory Substitution (node16.html#SECTION00332000000000000000)\nKey Bindings (node17.html#SECTION00333000000000000000)\nCommentary (node18.html#SECTION00334000000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1015, "url": "https://docs.python.org/{python_version}/python-tut/node4.html"}
{"title": "More on Modules", "text": "---\nnode41.html node39.html node39.html node1.html\n---\n# More on Modules\nA module can contain executable statements as well as function\ndefinitions.\nThese statements are intended to initialize the module.\nThey are executed only the\nfirst\ntime the module is imported somewhere.\nfootnode.html#288\nEach module has its own private symbol table, which is used as the\nglobal symbol table by all functions defined in the module.\nThus, the author of a module can use global variables in the module\nwithout worrying about accidental clashes with a user's global\nvariables.\nOn the other hand, if you know what you are doing you can touch a\nmodule's global variables with the same notation used to refer to its\nfunctions,\nmodname.itemname.\nModules can import other modules.\nIt is customary but not required to place all\nimport\nstatements at the beginning of a module (or script, for that matter).\nThe imported module names are placed in the importing module's global\nsymbol table.\nThere is a variant of the\nimport\nstatement that imports names from a module directly into the importing\nmodule's symbol table.\nFor example:\n```text\n>>> from fibo import fib, fib2\n>>> fib(500)\n1 1 2 3 5 8 13 21 34 55 89 144 233 377\n>>>\n```\nThis does not introduce the module name from which the imports are taken\nin the local symbol table (so in the example, fibo is not\ndefined).\nThere is even a variant to import all names that a module defines:\n```text\n>>> from fibo import *\n>>> fib(500)\n1 1 2 3 5 8 13 21 34 55 89 144 233 377\n>>>\n```\nThis imports all names except those beginning with an underscore\n(_).\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1594, "url": "https://docs.python.org/{python_version}/python-tut/node40.html"}
{"title": "Standard Modules", "text": "---\nnode42.html node39.html node40.html node1.html\n---\n# Standard Modules\nPython comes with a library of standard modules, described in a separate\ndocument (Python Library Reference). Some modules are built into the\ninterpreter; these provide access to operations that are not part of the\ncore of the language but are nevertheless built in, either for\nefficiency or to provide access to operating system primitives such as\nsystem calls. The set of such modules is a configuration option; e.g.,\nthe amoeba module is only provided on systems that somehow support\nAmoeba primitives. One particular module deserves some attention:\nsys, which is built into every Python interpreter. The variables\nsys.ps1 and sys.ps2 define the strings used as primary and\nsecondary prompts:\n```text\n>>> import sys\n>>> sys.ps1\n'>>> '\n>>> sys.ps2\n'... '\n>>> sys.ps1 = 'C> '\nC> print 'Yuck!'\nYuck!\nC>\n```\nThese two variables are only defined if the interpreter is in\ninteractive mode.\nThe variable\nsys.path\nis a list of strings that determine the interpreter's search path for\nmodules.\nIt is initialized to a default path taken from the environment variable\nPYTHONPATH,\nor from a built-in default if\nPYTHONPATH\nis not set.\nYou can modify it using standard list operations, e.g.:\n```text\n>>> import sys\n>>> sys.path.append('/ufs/guido/lib/python')\n>>>\n```\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1347, "url": "https://docs.python.org/{python_version}/python-tut/node41.html"}
{"title": "The dir() function", "text": "---\nnode43.html node39.html node41.html node1.html\n---\n# The dir() function\nThe built-in function dir is used to find out which names a module\ndefines. It returns a sorted list of strings:\n```text\n>>> import fibo, sys\n>>> dir(fibo)\n['__name__', 'fib', 'fib2']\n>>> dir(sys)\n['__name__', 'argv', 'builtin_module_names', 'copyright', 'exit',\n'maxint', 'modules', 'path', 'ps1', 'ps2', 'setprofile', 'settrace',\n'stderr', 'stdin', 'stdout', 'version']\n>>>\n```\nWithout arguments, dir() lists the names you have defined currently:\n```text\n>>> a = [1, 2, 3, 4, 5]\n>>> import fibo, sys\n>>> fib = fibo.fib\n>>> dir()\n['__name__', 'a', 'fib', 'fibo', 'sys']\n>>>\n```\nNote that it lists all types of names: variables, modules, functions, etc.\ndir() does not list the names of built-in functions and variables.\nIf you want a list of those, they are defined in the standard module\n__builtin__:\n```text\n>>> import __builtin__\n>>> dir(__builtin__)\n['AccessError', 'AttributeError', 'ConflictError', 'EOFError', 'IOError',\n'ImportError', 'IndexError', 'KeyError', 'KeyboardInterrupt',\n'MemoryError', 'NameError', 'None', 'OverflowError', 'RuntimeError',\n'SyntaxError', 'SystemError', 'SystemExit', 'TypeError', 'ValueError',\n'ZeroDivisionError', '__name__', 'abs', 'apply', 'chr', 'cmp', 'coerce',\n'compile', 'dir', 'divmod', 'eval', 'execfile', 'filter', 'float',\n'getattr', 'hasattr', 'hash', 'hex', 'id', 'input', 'int', 'len', 'long',\n'map', 'max', 'min', 'oct', 'open', 'ord', 'pow', 'range', 'raw_input',\n'reduce', 'reload', 'repr', 'round', 'setattr', 'str', 'type', 'xrange']\n>>>\n```\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1590, "url": "https://docs.python.org/{python_version}/python-tut/node42.html"}
{"title": "Output Formatting", "text": "---\nnode44.html tut.html node42.html node1.html\n---\n# Output Formatting\nSo far we've encountered two ways of writing values: expression\nstatements and the print statement. (A third way is using the\nwrite method of file objects; the standard output file can be\nreferenced as sys.stdout. See the Library Reference for more\ninformation on this.)\nOften you'll want more control over the formatting of your output than\nsimply printing space-separated values. The key to nice formatting in\nPython is to do all the string handling yourself; using string slicing\nand concatenation operations you can create any lay-out you can imagine.\nThe standard module string contains some useful operations for\npadding strings to a given column width; these will be discussed shortly.\nFinally, the `%` operator (modulo) with a string left argument\ninterprets this string as a C sprintf format string to be applied to the\nright argument, and returns the string resulting from this formatting\noperation.\nOne question remains, of course: how do you convert values to strings?\nLuckily, Python has a way to convert any value to a string: just write\nthe value between reverse quotes (````). Some examples:\n```text\n>>> x = 10 * 3.14\n>>> y = 200*200\n>>> s = 'The value of x is ' + `x` + ', and y is ' + `y` + '...'\n>>> print s\nThe value of x is 31.4, and y is 40000...\n>>> # Reverse quotes work on other types besides numbers:\n... p = [x, y]\n>>> ps = `p`\n>>> ps\n'[31.4, 40000]'\n>>> # Converting a string adds string quotes and backslashes:\n... hello = 'hello, world\\n'\n>>> hellos = `hello`\n>>> print hellos\n'hello, world\\012'\n>>> # The argument of reverse quotes may be a tuple:\n... `x, y, ('spam', 'eggs')`\n\"(31.4, 40000, ('spam', 'eggs'))\"\n>>>\n```\nHere are two ways to write a table of squares and cubes:\n```text\n>>> import string\n>>> for x in range(1, 11):\n... print string.rjust(`x`, 2), string.rjust(`x*x`, 3),\n... # Note trailing comma on previous line\n... print string.rjust(`x*x*x`, 4)\n...\n1 1 1\n2 4 8\n3 9 27\n4 16 64\n5 25 125\n6 36 216\n7 49 343\n8 64 512\n9 81 729\n10 100 1000\n>>> for x in range(1,11):\n... print '%2d %3d %4d' % (x, x*x, x*x*x)\n...\n1 1 1\n2 4 8\n3 9 27\n4 16 64\n5 25 125\n6 36 216\n7 49 343\n8 64 512\n9 81 729\n10 100 1000\n>>>\n```\n(Note that one space between each column was added by the way print\nworks: it always adds spaces between its arguments.)\nThis example demonstrates the function string.rjust(), which\nright-justifies a string in a field of a given width by padding it with\nspaces on the left. There are similar functions string.ljust()\nand string.center(). These functions do not write anything, they\njust return a new string. If the input string is too long, they don't\ntruncate it, but return it unchanged; this will mess up your column\nlay-out but that's usually better than the alternative, which would be\nlying about a value. (If you really want truncation you can always add\na slice operation, as in string.ljust(x, n)[0:n].)\nThere is another function, string.zfill, which pads a numeric\nstring on the left with zeros. It understands about plus and minus\nsigns:\n```text\n>>> string.zfill('12', 5)\n'00012'\n>>> string.zfill('-3.14', 7)\n'-003.14'\n>>> string.zfill('3.14159265359', 5)\n'3.14159265359'\n>>>\n```\n---\nnode44.html tut.html node42.html node1.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 3277, "url": "https://docs.python.org/{python_version}/python-tut/node43.html"}
{"title": "Errors and Exceptions", "text": "---\nnode45.html tut.html node43.html node1.html\n---\n# Errors and Exceptions\nUntil now error messages haven't been more than mentioned, but if you\nhave tried out the examples you have probably seen some. There are\n(at least) two distinguishable kinds of errors: syntax errors\nand exceptions.\n---\n- Syntax Errors (node45.html#SECTION00910000000000000000)\nExceptions (node46.html#SECTION00920000000000000000)\nHandling Exceptions (node47.html#SECTION00930000000000000000)\nRaising Exceptions (node48.html#SECTION00940000000000000000)\nUser-defined Exceptions (node49.html#SECTION00950000000000000000)\nDefining Clean-up Actions (node50.html#SECTION00960000000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 679, "url": "https://docs.python.org/{python_version}/python-tut/node44.html"}
{"title": "Syntax Errors", "text": "---\nnode46.html node44.html node44.html node1.html\n---\n# Syntax Errors\nSyntax errors, also known as parsing errors, are perhaps the most common\nkind of complaint you get while you are still learning Python:\n```text\n>>> while 1 print 'Hello world'\nFile \"<stdin>\", line 1\nwhile 1 print 'Hello world'\n^\nSyntaxError: invalid syntax\n>>>\n```\nThe parser repeats the offending line and displays a little `arrow'\npointing at the earliest point in the line where the error was detected.\nThe error is caused by (or at least detected at) the token\npreceding\nthe arrow: in the example, the error is detected at the keyword\nprint, since a colon (:) is missing before it.\nFile name and line number are printed so you know where to look in case\nthe input came from a script.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 775, "url": "https://docs.python.org/{python_version}/python-tut/node45.html"}
{"title": "Exceptions", "text": "---\nnode47.html node44.html node45.html node1.html\n---\n# Exceptions\nEven if a statement or expression is syntactically correct, it may\ncause an error when an attempt is made to execute it.\nErrors detected during execution are called exceptions and are\nnot unconditionally fatal: you will soon learn how to handle them in\nPython programs. Most exceptions are not handled by programs,\nhowever, and result in error messages as shown here:\n```text\n>>> 10 * (1/0)\nTraceback (innermost last):\nFile \"<stdin>\", line 1\nZeroDivisionError: integer division or modulo\n>>> 4 + spam*3\nTraceback (innermost last):\nFile \"<stdin>\", line 1\nNameError: spam\n>>> '2' + 2\nTraceback (innermost last):\nFile \"<stdin>\", line 1\nTypeError: illegal argument type for built-in operation\n>>>\n```\nThe last line of the error message indicates what happened.\nExceptions come in different types, and the type is printed as part of\nthe message: the types in the example are\nZeroDivisionError,\nNameError\nand\nTypeError.\nThe string printed as the exception type is the name of the built-in\nname for the exception that occurred. This is true for all built-in\nexceptions, but need not be true for user-defined exceptions (although\nit is a useful convention).\nStandard exception names are built-in identifiers (not reserved\nkeywords).\nThe rest of the line is a detail whose interpretation depends on the\nexception type; its meaning is dependent on the exception type.\nThe preceding part of the error message shows the context where the\nexception happened, in the form of a stack backtrace.\nIn general it contains a stack backtrace listing source lines; however,\nit will not display lines read from standard input.\nThe Python library reference manual lists the built-in exceptions and\ntheir meanings.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1774, "url": "https://docs.python.org/{python_version}/python-tut/node46.html"}
{"title": "Handling Exceptions", "text": "---\nnode48.html node44.html node46.html node1.html\n---\n# Handling Exceptions\nIt is possible to write programs that handle selected exceptions.\nLook at the following example, which prints a table of inverses of\nsome floating point numbers:\n```text\n>>> numbers = [0.3333, 2.5, 0, 10]\n>>> for x in numbers:\n... print x,\n... try:\n... print 1.0 / x\n... except ZeroDivisionError:\n... print '*** has no inverse ***'\n...\n0.3333 3.00030003\n2.5 0.4\n0 *** has no inverse ***\n10 0.1\n>>>\n```\nThe try statement works as follows.\n- First, the\ntry clause\n(the statement(s) between the try and except keywords) is\nexecuted.\nIf no exception occurs, the\nexcept clause\nis skipped and execution of the try statement is finished.\nIf an exception occurs during execution of the try clause,\nthe rest of the clause is skipped. Then if\nits type matches the exception named after the except keyword,\nthe rest of the try clause is skipped, the except clause is executed,\nand then execution continues after the try statement.\nIf an exception occurs which does not match the exception named in the\nexcept clause, it is passed on to outer try statements; if no handler is\nfound, it is an\nunhandled exception\nand execution stops with a message as shown above.\nA try statement may have more than one except clause, to specify\nhandlers for different exceptions.\nAt most one handler will be executed.\nHandlers only handle exceptions that occur in the corresponding try\nclause, not in other handlers of the same try statement.\nAn except clause may name multiple exceptions as a parenthesized list,\ne.g.:\n```text\n... except (RuntimeError, TypeError, NameError):\n... pass\n```\nThe last except clause may omit the exception name(s), to serve as a\nwildcard.\nUse this with extreme caution, since it is easy to mask a real\nprogramming error in this way!\nWhen an exception occurs, it may have an associated value, also known as\nthe exceptions's\nargument.\nThe presence and type of the argument depend on the exception type.\nFor exception types which have an argument, the except clause may\nspecify a variable after the exception name (or list) to receive the\nargument's value, as follows:\n```text\n>>> try:\n... spam()\n... except NameError, x:\n... print 'name', x, 'undefined'\n...\nname spam undefined\n>>>\n```\nIf an exception has an argument, it is printed as the last part\n(`detail') of the message for unhandled exceptions.\nException handlers don't just handle exceptions if they occur\nimmediately in the try clause, but also if they occur inside functions\nthat are called (even indirectly) in the try clause.\nFor example:\n```text\n>>> def this_fails():\n... x = 1/0\n...\n>>> try:\n... this_fails()\n... except ZeroDivisionError, detail:\n... print 'Handling run-time error:', detail\n...\nHandling run-time error: integer division or modulo\n>>>\n```\n---\nnode48.html node44.html node46.html node1.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 2867, "url": "https://docs.python.org/{python_version}/python-tut/node47.html"}
{"title": "Raising Exceptions", "text": "---\nnode49.html node44.html node47.html node1.html\n---\n# Raising Exceptions\nThe raise statement allows the programmer to force a specified\nexception to occur.\nFor example:\n```text\n>>> raise NameError, 'HiThere'\nTraceback (innermost last):\nFile \"<stdin>\", line 1\nNameError: HiThere\n>>>\n```\nThe first argument to raise names the exception to be raised.\nThe optional second argument specifies the exception's argument.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 432, "url": "https://docs.python.org/{python_version}/python-tut/node48.html"}
{"title": "User-defined Exceptions", "text": "---\nnode50.html node44.html node48.html node1.html\n---\n# User-defined Exceptions\nPrograms may name their own exceptions by assigning a string to a\nvariable.\nFor example:\n```text\n>>> my_exc = 'my_exc'\n>>> try:\n... raise my_exc, 2*2\n... except my_exc, val:\n... print 'My exception occurred, value:', val\n...\nMy exception occurred, value: 4\n>>> raise my_exc, 1\nTraceback (innermost last):\nFile \"<stdin>\", line 1\nmy_exc: 1\n>>>\n```\nMany standard modules use this to report errors that may occur in\nfunctions they define.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 532, "url": "https://docs.python.org/{python_version}/python-tut/node49.html"}
{"title": "Invoking the Interpreter", "text": "---\nnode6.html node4.html node4.html node1.html\n---\n# Invoking the Interpreter\nThe Python interpreter is usually installed as /usr/local/bin/python\non those machines where it is available; putting /usr/local/bin in\nyour Unix shell's search path makes it possible to start it by\ntyping the command\n```text\npython\n```\nto the shell. Since the choice of the directory where the interpreter\nlives is an installation option, other places are possible; check with\nyour local Python guru or system administrator. (E.g.,\n/usr/local/python is a popular alternative location.)\nThe interpreter operates somewhat like the Unix shell: when called\nwith standard input connected to a tty device, it reads and executes\ncommands interactively; when called with a file name argument or with\na file as standard input, it reads and executes a script from\nthat file.\nA third way of starting the interpreter is\n``python -c command [arg] ...'', which\nexecutes the statement(s) in command, analogous to the shell's\n-c option. Since Python statements often contain spaces or other\ncharacters that are special to the shell, it is best to quote\ncommand in its entirety with double quotes.\nNote that there is a difference between ``python file'' and\n``python <file''. In the latter case, input requests from the\nprogram, such as calls to input() and raw_input(), are\nsatisfied from file. Since this file has already been read\nuntil the end by the parser before the program starts executing, the\nprogram will encounter EOF immediately. In the former case (which is\nusually what you want) they are satisfied from whatever file or device\nis connected to standard input of the Python interpreter.\nWhen a script file is used, it is sometimes useful to be able to run\nthe script and enter interactive mode afterwards. This can be done by\npassing -i before the script. (This does not work if the script\nis read from standard input, for the same reason as explained in the\nprevious paragraph.)\n---\n- Argument Passing (node6.html#SECTION00311000000000000000)\nInteractive Mode (node7.html#SECTION00312000000000000000)\n---\nnode6.html node4.html node4.html node1.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 2147, "url": "https://docs.python.org/{python_version}/python-tut/node5.html"}
{"title": "Defining Clean-up Actions", "text": "---\nnode51.html node44.html node49.html node1.html\n---\n# Defining Clean-up Actions\nThe try statement has another optional clause which is intended to\ndefine clean-up actions that must be executed under all circumstances.\nFor example:\n```text\n>>> try:\n... raise KeyboardInterrupt\n... finally:\n... print 'Goodbye, world!'\n...\nGoodbye, world!\nTraceback (innermost last):\nFile \"<stdin>\", line 2\nKeyboardInterrupt\n>>>\n```\nA finally clause is executed whether or not an exception has\noccurred in the try clause. When an exception has occurred, it\nis re-raised after the finally clause is executed. The\nfinally clause is also executed ``on the way out'' when the\ntry statement is left via a break or return\nstatement.\nA try statement must either have one or more except\nclauses or one finally clause, but not both.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 824, "url": "https://docs.python.org/{python_version}/python-tut/node50.html"}
{"title": "Classes", "text": "---\nnode52.html tut.html node50.html node1.html\n---\n# Classes\nPython's class mechanism adds classes to the language with a minimum\nof new syntax and semantics. It is a mixture of the class mechanisms\nfound in C++ and Modula-3. As is true for modules, classes in Python\ndo not put an absolute barrier between definition and user, but rather\nrely on the politeness of the user not to ``break into the\ndefinition.'' The most important features of classes are retained\nwith full power, however: the class inheritance mechanism allows\nmultiple base classes, a derived class can override any methods of its\nbase class(es), a method can call the method of a base class with the\nsame name. Objects can contain an arbitrary amount of private data.\nIn C++ terminology, all class members (including the data members) are\npublic, and all member functions are virtual. There are\nno special constructors or destructors. As in Modula-3, there are no\nshorthands for referencing the object's members from its methods: the\nmethod function is declared with an explicit first argument\nrepresenting the object, which is provided implicitly by the call. As\nin Smalltalk, classes themselves are objects, albeit in the wider\nsense of the word: in Python, all data types are objects. This\nprovides semantics for importing and renaming. But, just like in C++\nor Modula-3, built-in types cannot be used as base classes for\nextension by the user. Also, like in C++ but unlike in Modula-3, most\nbuilt-in operators with special syntax (arithmetic operators,\nsubscripting etc.) can be redefined for class members.\n---\n- A word about terminology (node52.html#SECTION001010000000000000000)\nPython scopes and name spaces (node53.html#SECTION001020000000000000000)\nA first look at classes (node54.html#SECTION001030000000000000000)\n- Class definition syntax (node55.html#SECTION001031000000000000000)\nClass objects (node56.html#SECTION001032000000000000000)\nInstance objects (node57.html#SECTION001033000000000000000)\nMethod objects (node58.html#SECTION001034000000000000000)\nRandom remarks (node59.html#SECTION001040000000000000000)\nInheritance (node60.html#SECTION001050000000000000000)\n- Multiple inheritance (node61.html#SECTION001051000000000000000)\nOdds and ends (node62.html#SECTION001060000000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 2293, "url": "https://docs.python.org/{python_version}/python-tut/node51.html"}
{"title": "A word about terminology", "text": "---\nnode53.html node51.html node51.html node1.html\n---\n# A word about terminology\nLacking universally accepted terminology to talk about classes, I'll\nmake occasional use of Smalltalk and C++ terms. (I'd use Modula-3\nterms, since its object-oriented semantics are closer to those of\nPython than C++, but I expect that few readers have heard of it...)\nI also have to warn you that there's a terminological pitfall for\nobject-oriented readers: the word ``object'' in Python does not\nnecessarily mean a class instance. Like C++ and Modula-3, and unlike\nSmalltalk, not all types in Python are classes: the basic built-in\ntypes like integers and lists aren't, and even somewhat more exotic\ntypes like files aren't. However, all Python types share a little\nbit of common semantics that is best described by using the word\nobject.\nObjects have individuality, and multiple names (in multiple scopes)\ncan be bound to the same object. This is known as aliasing in other\nlanguages. This is usually not appreciated on a first glance at\nPython, and can be safely ignored when dealing with immutable basic\ntypes (numbers, strings, tuples). However, aliasing has an\n(intended!) effect on the semantics of Python code involving mutable\nobjects such as lists, dictionaries, and most types representing\nentities outside the program (files, windows, etc.). This is usually\nused to the benefit of the program, since aliases behave like pointers\nin some respects. For example, passing an object is cheap since only\na pointer is passed by the implementation; and if a function modifies\nan object passed as an argument, the caller will see the change --- this\nobviates the need for two different argument passing mechanisms as in\nPascal.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1731, "url": "https://docs.python.org/{python_version}/python-tut/node52.html"}
{"title": "Python scopes and name spaces", "text": "---\nnode54.html node51.html node52.html node1.html\n---\n# Python scopes and name spaces\nBefore introducing classes, I first have to tell you something about\nPython's scope rules. Class definitions play some neat tricks with\nname spaces, and you need to know how scopes and name spaces work to\nfully understand what's going on. Incidentally, knowledge about this\nsubject is useful for any advanced Python programmer.\nLet's begin with some definitions.\nA name space is a mapping from names to objects. Most name\nspaces are currently implemented as Python dictionaries, but that's\nnormally not noticeable in any way (except for performance), and it\nmay change in the future. Examples of name spaces are: the set of\nbuilt-in names (functions such as `abs()`, and built-in exception\nnames); the global names in a module; and the local names in a\nfunction invocation. In a sense the set of attributes of an object\nalso form a name space. The important thing to know about name\nspaces is that there is absolutely no relation between names in\ndifferent name spaces; for instance, two different modules may both\ndefine a function ``maximize'' without confusion --- users of the\nmodules must prefix it with the module name.\nBy the way, I use the word attribute for any name following a\ndot --- for example, in the expression `z.real`, `real` is\nan attribute of the object `z`. Strictly speaking, references to\nnames in modules are attribute references: in the expression\n`modname.funcname`, `modname` is a module object and\n`funcname` is an attribute of it. In this case there happens to\nbe a straightforward mapping between the module's attributes and the\nglobal names defined in the module: they share the same name space!\nfootnode.html#553\nAttributes may be read-only or writable. In the latter case,\nassignment to attributes is possible. Module attributes are writable:\nyou can write `modname.the_answer = 42`. Writable attributes may\nalso be deleted with the del statement, e.g.\n`del modname.the_answer`.\nName spaces are created at different moments and have different\nlifetimes. The name space containing the built-in names is created\nwhen the Python interpreter starts up, and is never deleted. The\nglobal name space for a module is created when the module definition\nis read in; normally, module name spaces also last until the\ninterpreter quits. The statements executed by the top-level\ninvocation of the interpreter, either read from a script file or\ninteractively, are considered part of a module called `__main__`,\nso they have their own global name space. (The built-in names\nactually also live in a module; this is called `__builtin__`.)\nThe local name space for a function is created when the function is\ncalled, and deleted when the function returns or raises an exception\nthat is not handled within the function. (Actually, forgetting would\nbe a better way to describe what actually happens.) Of course,\nrecursive invocations each have their own local name space.\nA scope is a textual region of a Python program where a name space\nis directly accessible. ``Directly accessible'' here means that an\nunqualified reference to a name attempts to find the name in the name\nspace.\nAlthough scopes are determined statically, they are used dynamically.\nAt any time during execution, exactly three nested scopes are in use\n(i.e., exactly three name spaces are directly accessible): the\ninnermost scope, which is searched first, contains the local names,\nthe middle scope, searched next, contains the current module's global\nnames, and the outermost scope (searched last) is the name space\ncontaining built-in names.\nUsually, the local scope references the local names of the (textually)\ncurrent function. Outside of functions, the local scope references\nthe same name space as the global scope: the module's name space.\nClass definitions place yet another name space in the local scope.\nIt is important to realize that scopes are determined textually: the\nglobal scope of a function defined in a module is that module's name\nspace, no matter from where or by what alias the function is called.\nOn the other hand, the actual search for names is done dynamically, at\nrun time --- however, the language definition is evolving towards\nstatic name resolution, at ``compile'' time, so don't rely on dynamic\nname resolution! (In fact, local variables are already determined\nstatically.)\nA special quirk of Python is that assignments always go into the\ninnermost scope. Assignments do not copy data --- they just\nbind names to objects. The same is true for deletions: the statement\n`del x` removes the binding of x from the name space referenced by the\nlocal scope. In fact, all operations that introduce new names use the\nlocal scope: in particular, import statements and function definitions\nbind the module or function name in the local scope. (The\n`global` statement can be used to indicate that particular\nvariables live in the global scope.)\n---\nnode54.html node51.html node52.html node1.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 5008, "url": "https://docs.python.org/{python_version}/python-tut/node53.html"}
{"title": "A first look at classes", "text": "---\nnode55.html node51.html node53.html node1.html\n---\n# A first look at classes\nClasses introduce a little bit of new syntax, three new object types,\nand some new semantics.\n---\n- Class definition syntax (node55.html#SECTION001031000000000000000)\nClass objects (node56.html#SECTION001032000000000000000)\nInstance objects (node57.html#SECTION001033000000000000000)\nMethod objects (node58.html#SECTION001034000000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 439, "url": "https://docs.python.org/{python_version}/python-tut/node54.html"}
{"title": "Class definition syntax", "text": "---\nnode56.html node54.html node54.html node1.html\n---\n## Class definition syntax\nThe simplest form of class definition looks like this:\n```text\nclass ClassName:\n<statement-1>\n.\n.\n.\n<statement-N>\n```\nClass definitions, like function definitions (`def` statements)\nmust be executed before they have any effect. (You could conceivably\nplace a class definition in a branch of an `if` statement, or\ninside a function.)\nIn practice, the statements inside a class definition will usually be\nfunction definitions, but other statements are allowed, and sometimes\nuseful --- we'll come back to this later. The function definitions\ninside a class normally have a peculiar form of argument list,\ndictated by the calling conventions for methods --- again, this is\nexplained later.\nWhen a class definition is entered, a new name space is created, and\nused as the local scope --- thus, all assignments to local variables\ngo into this new name space. In particular, function definitions bind\nthe name of the new function here.\nWhen a class definition is left normally (via the end), a class\nobject is created. This is basically a wrapper around the contents\nof the name space created by the class definition; we'll learn more\nabout class objects in the next section. The original local scope\n(the one in effect just before the class definitions was entered) is\nreinstated, and the class object is bound here to class name given in\nthe class definition header (ClassName in the example).\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1488, "url": "https://docs.python.org/{python_version}/python-tut/node55.html"}
{"title": "Class objects", "text": "---\nnode57.html node54.html node55.html node1.html\n---\n## Class objects\nClass objects support two kinds of operations: attribute references\nand instantiation.\nAttribute references use the standard syntax used for all\nattribute references in Python: `obj.name`. Valid attribute\nnames are all the names that were in the class's name space when the\nclass object was created. So, if the class definition looked like\nthis:\n```text\nclass MyClass:\ni = 12345\ndef f(x):\nreturn 'hello world'\n```\nthen `MyClass.i` and `MyClass.f` are valid attribute\nreferences, returning an integer and a function object, respectively.\nClass attributes can also be assigned to, so you can change the\nvalue of `MyClass.i` by assignment.\nClass instantiation uses function notation. Just pretend that\nthe class object is a parameterless function that returns a new\ninstance of the class. For example, (assuming the above class):\n```text\nx = MyClass()\n```\ncreates a new instance of the class and assigns this object to\nthe local variable `x`.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1028, "url": "https://docs.python.org/{python_version}/python-tut/node56.html"}
{"title": "Instance objects", "text": "---\nnode58.html node54.html node56.html node1.html\n---\n## Instance objects\nNow what can we do with instance objects? The only operations\nunderstood by instance objects are attribute references. There are\ntwo kinds of valid attribute names.\nThe first I'll call data attributes. These correspond to\n``instance variables'' in Smalltalk, and to ``data members'' in C++.\nData attributes need not be declared; like local variables, they\nspring into existence when they are first assigned to. For example,\nif `x` in the instance of `MyClass` created above, the\nfollowing piece of code will print the value 16, without leaving a\ntrace:\n```text\nx.counter = 1\nwhile x.counter < 10:\nx.counter = x.counter * 2\nprint x.counter\ndel x.counter\n```\nThe second kind of attribute references understood by instance objects\nare methods. A method is a function that ``belongs to'' an\nobject. (In Python, the term method is not unique to class instances:\nother object types can have methods as well, e.g., list objects have\nmethods called append, insert, remove, sort, and so on. However,\nbelow, we'll use the term method exclusively to mean methods of class\ninstance objects, unless explicitly stated otherwise.)\nValid method names of an instance object depend on its class. By\ndefinition, all attributes of a class that are (user-defined) function\nobjects define corresponding methods of its instances. So in our\nexample, `x.f` is a valid method reference, since\n`MyClass.f` is a function, but `x.i` is not, since\n`MyClass.i` is not. But `x.f` is not the\nsame thing as `MyClass.f` --- it is a method object, not a\nfunction object.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1626, "url": "https://docs.python.org/{python_version}/python-tut/node57.html"}
{"title": "Method objects", "text": "---\nnode59.html node54.html node57.html node1.html\n---\n## Method objects\nUsually, a method is called immediately, e.g.:\n```text\nx.f()\n```\nIn our example, this will return the string `'hello world'`.\nHowever, it is not necessary to call a method right away: `x.f`\nis a method object, and can be stored away and called at a later\nmoment, for example:\n```text\nxf = x.f\nwhile 1:\nprint xf()\n```\nwill continue to print `hello world` until the end of time.\nWhat exactly happens when a method is called? You may have noticed\nthat `x.f()` was called without an argument above, even though\nthe function definition for `f` specified an argument. What\nhappened to the argument? Surely Python raises an exception when a\nfunction that requires an argument is called without any --- even if\nthe argument isn't actually used...\nActually, you may have guessed the answer: the special thing about\nmethods is that the object is passed as the first argument of the\nfunction. In our example, the call `x.f()` is exactly equivalent\nto `MyClass.f(x)`. In general, calling a method with a list of\nn arguments is equivalent to calling the corresponding function\nwith an argument list that is created by inserting the method's object\nbefore the first argument.\nIf you still don't understand how methods work, a look at the\nimplementation can perhaps clarify matters. When an instance\nattribute is referenced that isn't a data attribute, its class is\nsearched. If the name denotes a valid class attribute that is a\nfunction object, a method object is created by packing (pointers to)\nthe instance object and the function object just found together in an\nabstract object: this is the method object. When the method object is\ncalled with an argument list, it is unpacked again, a new argument\nlist is constructed from the instance object and the original argument\nlist, and the function object is called with this new argument list.\n---\nnode59.html node54.html node57.html node1.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1975, "url": "https://docs.python.org/{python_version}/python-tut/node58.html"}
{"title": "Random remarks", "text": "---\nnode60.html node51.html node58.html node1.html\n---\n# Random remarks\n[These should perhaps be placed more carefully...]\nData attributes override method attributes with the same name; to\navoid accidental name conflicts, which may cause hard-to-find bugs in\nlarge programs, it is wise to use some kind of convention that\nminimizes the chance of conflicts, e.g., capitalize method names,\nprefix data attribute names with a small unique string (perhaps just\nan underscore), or use verbs for methods and nouns for data attributes.\nData attributes may be referenced by methods as well as by ordinary\nusers (``clients'') of an object. In other words, classes are not\nusable to implement pure abstract data types. In fact, nothing in\nPython makes it possible to enforce data hiding --- it is all based\nupon convention. (On the other hand, the Python implementation,\nwritten in C, can completely hide implementation details and control\naccess to an object if necessary; this can be used by extensions to\nPython written in C.)\nClients should use data attributes with care --- clients may mess up\ninvariants maintained by the methods by stamping on their data\nattributes. Note that clients may add data attributes of their own to\nan instance object without affecting the validity of the methods, as\nlong as name conflicts are avoided --- again, a naming convention can\nsave a lot of headaches here.\nThere is no shorthand for referencing data attributes (or other\nmethods!) from within methods. I find that this actually increases\nthe readability of methods: there is no chance of confusing local\nvariables and instance variables when glancing through a method.\nConventionally, the first argument of methods is often called\n`self`. This is nothing more than a convention: the name\n`self` has absolutely no special meaning to Python. (Note,\nhowever, that by not following the convention your code may be less\nreadable by other Python programmers, and it is also conceivable that\na class browser program be written which relies upon such a\nconvention.)\nAny function object that is a class attribute defines a method for\ninstances of that class. It is not necessary that the function\ndefinition is textually enclosed in the class definition: assigning a\nfunction object to a local variable in the class is also ok. For\nexample:\n```text\n# Function defined outside the class\ndef f1(self, x, y):\nreturn min(x, x+y)\n\nclass C:\nf = f1\ndef g(self):\nreturn 'hello world'\nh = g\n```\nNow `f`, `g` and `h` are all attributes of class\n`C` that refer to function objects, and consequently they are all\nmethods of instances of `C` --- `h` being exactly equivalent\nto `g`. Note that this practice usually only serves to confuse\nthe reader of a program.\nMethods may call other methods by using method attributes of the\n`self` argument, e.g.:\n```text\nclass Bag:\ndef empty(self):\nself.data = []\ndef add(self, x):\nself.data.append(x)\ndef addtwice(self, x):\nself.add(x)\nself.add(x)\n```\nThe instantiation operation (``calling'' a class object) creates an\nempty object. Many classes like to create objects in a known initial\nstate. Therefore a class may define a special method named\n`__init__`, like this:\n```text\ndef __init__(self):\nself.empty()\n```\nWhen a class defines an `__init__` method, class instantiation\nautomatically invokes `__init__` for the newly-created class\ninstance. So in the `Bag` example, a new and initialized instance\ncan be obtained by:\n```text\nx = Bag()\n```\nOf course, the `__init__` method may have arguments for greater\nflexibility. In that case, arguments given to the class instantiation\noperator are passed on to `__init__`. For example,\n```text\n>>> class Complex:\n... def __init__(self, realpart, imagpart):\n... self.r = realpart\n... self.i = imagpart\n...\n>>> x = Complex(3.0,-4.5)\n>>> x.r, x.i\n(3.0, -4.5)\n>>>\n```\nMethods may reference global names in the same way as ordinary\nfunctions. The global scope associated with a method is the module\ncontaining the class definition. (The class itself is never used as a\nglobal scope!) While one rarely encounters a good reason for using\nglobal data in a method, there are many legitimate uses of the global\nscope: for one thing, functions and modules imported into the global\nscope can be used by methods, as well as functions and classes defined\nin it. Usually, the class containing the method is itself defined in\nthis global scope, and in the next section we'll find some good\nreasons why a method would want to reference its own class!\n---\nnode60.html node51.html node58.html node1.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 4553, "url": "https://docs.python.org/{python_version}/python-tut/node59.html"}
{"title": "Argument Passing", "text": "---\nnode7.html node5.html node5.html node1.html\n---\n## Argument Passing\nWhen known to the interpreter, the script name and additional\narguments thereafter are passed to the script in the variable\nsys.argv, which is a list of strings. Its length is at least one;\nwhen no script and no arguments are given, sys.argv[0] is an\nempty string. When the script name is given as '-' (meaning\nstandard input), sys.argv[0] is set to '-'. When -c\ncommand is used, sys.argv[0] is set to '-c'. Options\nfound after -c command are not consumed by the Python\ninterpreter's option processing but left in sys.argv for the\ncommand to handle.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 638, "url": "https://docs.python.org/{python_version}/python-tut/node6.html"}
{"title": "Inheritance", "text": "---\nnode61.html node51.html node59.html node1.html\n---\n# Inheritance\nOf course, a language feature would not be worthy of the name ``class''\nwithout supporting inheritance. The syntax for a derived class\ndefinition looks as follows:\n```text\nclass DerivedClassName(BaseClassName):\n<statement-1>\n.\n.\n.\n<statement-N>\n```\nThe name `BaseClassName` must be defined in a scope containing\nthe derived class definition. Instead of a base class name, an\nexpression is also allowed. This is useful when the base class is\ndefined in another module, e.g.,\n```text\nclass DerivedClassName(modname.BaseClassName):\n```\nExecution of a derived class definition proceeds the same as for a\nbase class. When the class object is constructed, the base class is\nremembered. This is used for resolving attribute references: if a\nrequested attribute is not found in the class, it is searched in the\nbase class. This rule is applied recursively if the base class itself\nis derived from some other class.\nThere's nothing special about instantiation of derived classes:\n`DerivedClassName()` creates a new instance of the class. Method\nreferences are resolved as follows: the corresponding class attribute\nis searched, descending down the chain of base classes if necessary,\nand the method reference is valid if this yields a function object.\nDerived classes may override methods of their base classes. Because\nmethods have no special privileges when calling other methods of the\nsame object, a method of a base class that calls another method\ndefined in the same base class, may in fact end up calling a method of\na derived class that overrides it. (For C++ programmers: all methods\nin Python are ``virtual functions''.)\nAn overriding method in a derived class may in fact want to extend\nrather than simply replace the base class method of the same name.\nThere is a simple way to call the base class method directly: just\ncall `BaseClassName.methodname(self, arguments)`. This is\noccasionally useful to clients as well. (Note that this only works if\nthe base class is defined or imported directly in the global scope.)\n---\n- Multiple inheritance (node61.html#SECTION001051000000000000000)\n---\nnode61.html node51.html node59.html node1.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 2230, "url": "https://docs.python.org/{python_version}/python-tut/node60.html"}
{"title": "Multiple inheritance", "text": "---\nnode62.html node60.html node60.html node1.html\n---\n## Multiple inheritance\nPython supports a limited form of multiple inheritance as well. A\nclass definition with multiple base classes looks as follows:\n```text\nclass DerivedClassName(Base1, Base2, Base3):\n<statement-1>\n.\n.\n.\n<statement-N>\n```\nThe only rule necessary to explain the semantics is the resolution\nrule used for class attribute references. This is depth-first,\nleft-to-right. Thus, if an attribute is not found in\n`DerivedClassName`, it is searched in `Base1`, then\n(recursively) in the base classes of `Base1`, and only if it is\nnot found there, it is searched in `Base2`, and so on.\n(To some people breadth first---searching `Base2` and\n`Base3` before the base classes of `Base1`---looks more\nnatural. However, this would require you to know whether a particular\nattribute of `Base1` is actually defined in `Base1` or in\none of its base classes before you can figure out the consequences of\na name conflict with an attribute of `Base2`. The depth-first\nrule makes no differences between direct and inherited attributes of\n`Base1`.)\nIt is clear that indiscriminate use of multiple inheritance is a\nmaintenance nightmare, given the reliance in Python on conventions to\navoid accidental name conflicts. A well-known problem with multiple\ninheritance is a class derived from two classes that happen to have a\ncommon base class. While it is easy enough to figure out what happens\nin this case (the instance will have a single copy of ``instance\nvariables'' or data attributes used by the common base class), it is\nnot clear that these semantics are in any way useful.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1648, "url": "https://docs.python.org/{python_version}/python-tut/node61.html"}
{"title": "Odds and ends", "text": "---\nnode63.html node51.html node61.html node1.html\n---\n# Odds and ends\nSometimes it is useful to have a data type similar to the Pascal\n``record'' or C ``struct'', bundling together a couple of named data\nitems. An empty class definition will do nicely, e.g.:\n```text\nclass Employee:\npass\n\njohn = Employee() # Create an empty employee record\n\n# Fill the fields of the record\njohn.name = 'John Doe'\njohn.dept = 'computer lab'\njohn.salary = 1000\n```\nA piece of Python code that expects a particular abstract data type\ncan often be passed a class that emulates the methods of that data\ntype instead. For instance, if you have a function that formats some\ndata from a file object, you can define a class with methods\n`read()` and `readline()` that gets the data from a string\nbuffer instead, and pass it as an argument. (Unfortunately, this\ntechnique has its limitations: a class can't define operations that\nare accessed by special syntax such as sequence subscripting or\narithmetic operators, and assigning such a ``pseudo-file'' to\n`sys.stdin` will not cause the interpreter to read further input\nfrom it.)\nInstance method objects have attributes, too: `m.im_self` is the\nobject of which the method is an instance, and `m.im_func` is the\nfunction object corresponding to the method.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1298, "url": "https://docs.python.org/{python_version}/python-tut/node62.html"}
{"title": "Recent Additions", "text": "---\nnode64.html tut.html node62.html node1.html\n---\n# Recent Additions\nPython is an evolving language. Since this tutorial was last\nthoroughly revised, several new features have been added to the\nlanguage. While ideally I should revise the tutorial to incorporate\nthem in the mainline of the text, lack of time currently requires me\nto take a more modest approach. In this chapter I will briefly list the\nmost important improvements to the language and how you can use them\nto your benefit.\n---\n- The Last Printed Expression (node64.html#SECTION001110000000000000000)\nString Literals (node65.html#SECTION001120000000000000000)\n- Double Quotes (node66.html#SECTION001121000000000000000)\nContinuation Of String Literals (node67.html#SECTION001122000000000000000)\nTriple-quoted strings (node68.html#SECTION001123000000000000000)\nString Literal Juxtaposition (node69.html#SECTION001124000000000000000)\nThe Formatting Operator (node70.html#SECTION001130000000000000000)\n- Basic Usage (node71.html#SECTION001131000000000000000)\nReferencing Variables By Name (node72.html#SECTION001132000000000000000)\nOptional Function Arguments (node73.html#SECTION001140000000000000000)\n- Default Argument Values (node74.html#SECTION001141000000000000000)\nArbitrary Argument Lists (node75.html#SECTION001142000000000000000)\nLambda And Functional Programming Tools (node76.html#SECTION001150000000000000000)\n- Lambda Forms (node77.html#SECTION001151000000000000000)\nMap, Reduce and Filter (node78.html#SECTION001152000000000000000)\n- Map. (node79.html#SECTION001152100000000000000)\nFilter. (node80.html#SECTION001152200000000000000)\nReduce. (node81.html#SECTION001152300000000000000)\nContinuation Lines Without Backslashes (node82.html#SECTION001160000000000000000)\nRegular Expressions (node83.html#SECTION001170000000000000000)\nGeneralized Dictionaries (node84.html#SECTION001180000000000000000)\nMiscellaneous New Built-in Functions (node85.html#SECTION001190000000000000000)\nElse Clause For Try Statement (node86.html#SECTION0011100000000000000000)\nNew Class Features in Release 1.1 (node87.html#SECTION0011110000000000000000)\n- New Operator Overloading (node88.html#SECTION0011111000000000000000)\nTrapping Attribute Access (node89.html#SECTION0011112000000000000000)\nCalling a Class Instance (node90.html#SECTION0011113000000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 2333, "url": "https://docs.python.org/{python_version}/python-tut/node63.html"}
{"title": "The Last Printed Expression", "text": "---\nnode65.html node63.html node63.html node1.html\n---\n# The Last Printed Expression\nIn interactive mode, the last printed expression is assigned to the\nvariable `_`. This means that when you are using Python as a\ndesk calculator, it is somewhat easier to continue calculations, for\nexample:\n```text\n>>> tax = 17.5 / 100\n>>> price = 3.50\n>>> price * tax\n0.6125\n>>> price + _\n4.1125\n>>> round(_, 2)\n4.11\n>>>\n```\nFor reasons too embarrassing to explain, this variable is implemented\nas a built-in (living in the module `__builtin__`), so it should\nbe treated as read-only by the user. I.e. don't explicitly assign a\nvalue to it --- you would create an independent local variable with\nthe same name masking the built-in variable with its magic behavior.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 767, "url": "https://docs.python.org/{python_version}/python-tut/node64.html"}
{"title": "String Literals", "text": "---\nnode66.html node63.html node64.html node1.html\n---\n# String Literals\n---\n- Double Quotes (node66.html#SECTION001121000000000000000)\nContinuation Of String Literals (node67.html#SECTION001122000000000000000)\nTriple-quoted strings (node68.html#SECTION001123000000000000000)\nString Literal Juxtaposition (node69.html#SECTION001124000000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 364, "url": "https://docs.python.org/{python_version}/python-tut/node65.html"}
{"title": "Double Quotes", "text": "---\nnode67.html node65.html node65.html node1.html\n---\n## Double Quotes\nPython can now also use double quotes to surround string literals,\ne.g. `\"this doesn't hurt a bit\"`. There is no semantic\ndifference between strings surrounded by single or double quotes.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 276, "url": "https://docs.python.org/{python_version}/python-tut/node66.html"}
{"title": "Continuation Of String Literals", "text": "---\nnode68.html node65.html node66.html node1.html\n---\n## Continuation Of String Literals\nString literals can span multiple lines by escaping newlines with\nbackslashes, e.g.\n```text\nhello = \"This is a rather long string containing\\n\\\nseveral lines of text just as you would do in C.\\n\\\nNote that whitespace at the beginning of the line is\\\nsignificant.\\n\"\nprint hello\n```\nwhich would print the following:\n```text\nThis is a rather long string containing\nseveral lines of text just as you would do in C.\nNote that whitespace at the beginning of the line is significant.\n```\n---\nguido@cwi.nl", "python_version": "1.2", "length": 588, "url": "https://docs.python.org/{python_version}/python-tut/node67.html"}
{"title": "Triple-quoted strings", "text": "---\nnode69.html node65.html node67.html node1.html\n---\n## Triple-quoted strings\nIn some cases, when you need to include really long strings (e.g.\ncontaining several paragraphs of informational text), it is annoying\nthat you have to terminate each line with `\\n\\`, especially if\nyou would like to reformat the text occasionally with a powerful text\neditor like Emacs. For such situations, ``triple-quoted'' strings can\nbe used, e.g.\n```text\nhello = \"\"\"\n\nThis string is bounded by triple double quotes (3 times \").\nUnescaped newlines in the string are retained, though \\\nit is still possible\\nto use all normal escape sequences.\n\nWhitespace at the beginning of a line is\nsignificant. If you need to include three opening quotes\nyou have to escape at least one of them, e.g. \\\"\"\".\n\nThis string ends in a newline.\n\"\"\"\n```\nTriple-quoted strings can be surrounded by three single quotes as\nwell, again without semantic difference.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 941, "url": "https://docs.python.org/{python_version}/python-tut/node68.html"}
{"title": "String Literal Juxtaposition", "text": "---\nnode70.html node65.html node68.html node1.html\n---\n## String Literal Juxtaposition\nOne final twist: you can juxtapose multiple string literals. Two or\nmore adjacent string literals (but not arbitrary expressions!)\nseparated only by whitespace will be concatenated (without intervening\nwhitespace) into a single string object at compile time. This makes\nit possible to continue a long string on the next line without\nsacrificing indentation or performance, unlike the use of the string\nconcatenation operator `+` or the continuation of the literal\nitself on the next line (since leading whitespace is significant\ninside all types of string literals). Note that this feature, like\nall string features except triple-quoted strings, is borrowed from\nStandard C.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 778, "url": "https://docs.python.org/{python_version}/python-tut/node69.html"}
{"title": "Interactive Mode", "text": "---\nnode8.html node5.html node6.html node1.html\n---\n## Interactive Mode\nWhen commands are read from a tty, the interpreter is said to be in\ninteractive mode. In this mode it prompts for the next command\nwith the primary prompt, usually three greater-than signs (\n>>>); for continuation lines it prompts with the secondary\\\nprompt, by default three dots (...). Typing an EOF (Control-D)\nat the primary prompt causes the interpreter to exit with a zero exit\nstatus.\nThe interpreter prints a welcome message stating its version number\nand a copyright notice before printing the first prompt, e.g.:\n```text\npython\nPython 1.2 (Mar 14 1995)\nCopyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam\n>>>\n```\n---\nguido@cwi.nl", "python_version": "1.2", "length": 721, "url": "https://docs.python.org/{python_version}/python-tut/node7.html"}
{"title": "The Formatting Operator", "text": "---\nnode71.html node63.html node69.html node1.html\n---\n# The Formatting Operator\n---\n- Basic Usage (node71.html#SECTION001131000000000000000)\nReferencing Variables By Name (node72.html#SECTION001132000000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 231, "url": "https://docs.python.org/{python_version}/python-tut/node70.html"}
{"title": "Basic Usage", "text": "---\nnode72.html node70.html node70.html node1.html\n---\n## Basic Usage\nThe chapter on output formatting is really out of date: there is now\nan almost complete interface to C-style printf formats. This is done\nby overloading the modulo operator (`%`) for a left operand\nwhich is a string, e.g.\n```text\n>>> import math\n>>> print 'The value of PI is approximately %5.3f.' % math.pi\nThe value of PI is approximately 3.142.\n>>>\n```\nIf there is more than one format in the string you pass a tuple as\nright operand, e.g.\n```text\n>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}\n>>> for name, phone in table.items():\n... print '%-10s ==> %10d' % (name, phone)\n...\nJack ==> 4098\nDcab ==> 8637678\nSjoerd ==> 4127\n>>>\n```\nMost formats work exactly as in C and require that you pass the proper\ntype (however, if you don't you get an exception, not a core dump).\nThe `%s` format is more relaxed: if the corresponding argument is\nnot a string object, it is converted to string using the `str()`\nbuilt-in function. Using `*` to pass the width or precision in\nas a separate (integer) argument is supported. The C formats\n`%n` and `%p` are not supported.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1164, "url": "https://docs.python.org/{python_version}/python-tut/node71.html"}
{"title": "Referencing Variables By Name", "text": "---\nnode73.html node70.html node71.html node1.html\n---\n## Referencing Variables By Name\nIf you have a really long format string that you don't want to split\nup, it would be nice if you could reference the variables to be\nformatted by name instead of by position. This can be done by using\nan extension of C formats using the form `%(name)format`, e.g.\n```text\n>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}\n>>> print 'Jack: %(Jack)d; Sjoerd: %(Sjoerd)d; Dcab: %(Dcab)d' % table\nJack: 4098; Sjoerd: 4127; Dcab: 8637678\n>>>\n```\nThis is particularly useful in combination with the new built-in\n`vars()` function, which returns a dictionary containing all\nlocal variables.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 698, "url": "https://docs.python.org/{python_version}/python-tut/node72.html"}
{"title": "Optional Function Arguments", "text": "---\nnode74.html node63.html node72.html node1.html\n---\n# Optional Function Arguments\nIt is now possible to define functions with a variable number of\narguments. There are two forms, which can be combined.\n---\n- Default Argument Values (node74.html#SECTION001141000000000000000)\nArbitrary Argument Lists (node75.html#SECTION001142000000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 362, "url": "https://docs.python.org/{python_version}/python-tut/node73.html"}
{"title": "Default Argument Values", "text": "---\nnode75.html node73.html node73.html node1.html\n---\n## Default Argument Values\nThe most useful form is to specify a default value for one or more\narguments. This creates a function that can be called with fewer\narguments than it is defined, e.g.\n```text\ndef ask_ok(prompt, retries = 4, complaint = 'Yes or no, please!'):\nwhile 1:\nok = raw_input(prompt)\nif ok in ('y', 'ye', 'yes'): return 1\nif ok in ('n', 'no', 'nop', 'nope'): return 0\nretries = retries - 1\nif retries < 0: raise IOError, 'refusenik user'\nprint complaint\n```\nThis function can be called either like this:\n`ask_ok('Do you really want to quit?')` or like this:\n`ask_ok('OK to overwrite the file?', 2)`.\nThe default values are evaluated at the point of function definition\nin the defining scope, so that e.g.\n```text\ni = 5\ndef f(arg = i): print arg\ni = 6\nf()\n```\nwill print `5`.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 863, "url": "https://docs.python.org/{python_version}/python-tut/node74.html"}
{"title": "Arbitrary Argument Lists", "text": "---\nnode76.html node73.html node74.html node1.html\n---\n## Arbitrary Argument Lists\nIt is also possible to specify that a function can be called with an\narbitrary number of arguments. These arguments will be wrapped up in\na tuple. Before the variable number of arguments, zero or more normal\narguments may occur, e.g.\n```text\ndef fprintf(file, format, *args):\nfile.write(format % args)\n```\nThis feature may be combined with the previous, e.g.\n```text\ndef but_is_it_useful(required, optional = None, *remains):\nprint \"I don't know\"\n```\n---\nguido@cwi.nl", "python_version": "1.2", "length": 550, "url": "https://docs.python.org/{python_version}/python-tut/node75.html"}
{"title": "Lambda And Functional Programming Tools", "text": "---\nnode77.html node63.html node75.html node1.html\n---\n# Lambda And Functional Programming Tools\n---\n- Lambda Forms (node77.html#SECTION001151000000000000000)\nMap, Reduce and Filter (node78.html#SECTION001152000000000000000)\n- Map. (node79.html#SECTION001152100000000000000)\nFilter. (node80.html#SECTION001152200000000000000)\nReduce. (node81.html#SECTION001152300000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 393, "url": "https://docs.python.org/{python_version}/python-tut/node76.html"}
{"title": "Lambda Forms", "text": "---\nnode78.html node76.html node76.html node1.html\n---\n## Lambda Forms\nBy popular demand, a few features commonly found in functional\nprogramming languages and Lisp have been added to Python. With the\n`lambda` keyword, small anonymous functions can be created.\nHere's a function that returns the sum of its two arguments:\n`lambda a, b: a+b`. Lambda forms can be used wherever function\nobjects are required. They are syntactically restricted to a single\nexpression. Semantically, they are just syntactic sugar for a normal\nfunction definition. Like nested function definitions, lambda forms\ncannot reference variables from the containing scope, but this can be\novercome through the judicious use of default argument values, e.g.\n```text\ndef make_incrementor(n):\nreturn lambda x, incr=n: x+incr\n```\n---\nguido@cwi.nl", "python_version": "1.2", "length": 813, "url": "https://docs.python.org/{python_version}/python-tut/node77.html"}
{"title": "Map, Reduce and Filter", "text": "---\nnode79.html node76.html node77.html node1.html\n---\n## Map, Reduce and Filter\nThree new built-in functions on sequences are good candidate to pass\nlambda forms.\n---\n- Map. (node79.html#SECTION001152100000000000000)\nFilter. (node80.html#SECTION001152200000000000000)\nReduce. (node81.html#SECTION001152300000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 336, "url": "https://docs.python.org/{python_version}/python-tut/node78.html"}
{"title": "Map.", "text": "---\nnode80.html node78.html node78.html node1.html\n---\n### Map.\n`map(function, sequence)` calls `function(item)` for each of\nthe sequence's items and returns a list of the return values. For\nexample, to compute some cubes:\n```text\n>>> map(lambda x: x*x*x, range(1, 11))\n[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]\n>>>\n```\nMore than one sequence may be passed; the function must then have as\nmany arguments as there are sequences and is called with the\ncorresponding item from each sequence (or `None` if some sequence\nis shorter than another). If `None` is passed for the function,\na function returning its argument(s) is substituted.\nCombining these two special cases, we see that\n`map(None, list1, list2)` is a convenient way of turning a pair\nof lists into a list of pairs. For example:\n```text\n>>> seq = range(8)\n>>> map(None, seq, map(lambda x: x*x, seq))\n[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25), (6, 36), (7, 49)]\n>>>\n```\n---\nguido@cwi.nl", "python_version": "1.2", "length": 956, "url": "https://docs.python.org/{python_version}/python-tut/node79.html"}
{"title": "The Interpreter and its Environment", "text": "---\nnode9.html node4.html node7.html node1.html\n---\n# The Interpreter and its Environment\n---\n- Error Handling (node9.html#SECTION00321000000000000000)\nThe Module Search Path (node10.html#SECTION00322000000000000000)\n``Compiled'' Python files (node11.html#SECTION00323000000000000000)\nExecutable Python scripts (node12.html#SECTION00324000000000000000)\nThe Interactive Startup File (node13.html#SECTION00325000000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 440, "url": "https://docs.python.org/{python_version}/python-tut/node8.html"}
{"title": "Filter.", "text": "---\nnode81.html node78.html node79.html node1.html\n---\n### Filter.\n`filter(function, sequence)` returns a sequence (of the same\ntype, if possible) consisting of those items from the sequence for\nwhich `function(item)` is true. For example, to compute some\nprimes:\n```text\n>>> filter(lambda x: x%2 != 0 and x%3 != 0, range(2, 25))\n[5, 7, 11, 13, 17, 19, 23]\n>>>\n```\n---\nguido@cwi.nl", "python_version": "1.2", "length": 381, "url": "https://docs.python.org/{python_version}/python-tut/node80.html"}
{"title": "Reduce.", "text": "---\nnode82.html node78.html node80.html node1.html\n---\n### Reduce.\n`reduce(function, sequence)` returns a single value constructed\nby calling the (binary) function on the first two items of the\nsequence, then on the result and the next item, and so on. For\nexample, to compute the sum of the numbers 1 through 10:\n```text\n>>> reduce(lambda x, y: x+y, range(1, 11))\n55\n>>>\n```\nIf there's only one item in the sequence, its value is returned; if\nthe sequence is empty, an exception is raised.\nA third argument can be passed to indicate the starting value. In this\ncase the starting value is returned for an empty sequence, and the\nfunction is first applied to the starting value and the first sequence\nitem, then to the result and the next item, and so on. For example,\n```text\n>>> def sum(seq):\n... return reduce(lambda x, y: x+y, seq, 0)\n...\n>>> sum(range(1, 11))\n55\n>>> sum([])\n0\n>>>\n```\n---\nguido@cwi.nl", "python_version": "1.2", "length": 905, "url": "https://docs.python.org/{python_version}/python-tut/node81.html"}
{"title": "Continuation Lines Without Backslashes", "text": "---\nnode83.html node63.html node81.html node1.html\n---\n# Continuation Lines Without Backslashes\nWhile the general mechanism for continuation of a source line on the\nnext physical line remains to place a backslash on the end of the\nline, expressions inside matched parentheses (or square brackets, or\ncurly braces) can now also be continued without using a backslash.\nThis is particularly useful for calls to functions with many\narguments, and for initializations of large tables.\nFor example:\n```text\nmonth_names = ['Januari', 'Februari', 'Maart',\n'April', 'Mei', 'Juni',\n'Juli', 'Augustus', 'September',\n'Oktober', 'November', 'December']\n```\nand\n```text\nCopyInternalHyperLinks(self.context.hyperlinks,\ncopy.context.hyperlinks,\nuidremap)\n```\n---\nguido@cwi.nl", "python_version": "1.2", "length": 759, "url": "https://docs.python.org/{python_version}/python-tut/node82.html"}
{"title": "Regular Expressions", "text": "---\nnode84.html node63.html node82.html node1.html\n---\n# Regular Expressions\nWhile C's printf-style output formats, transformed into Python, are\nadequate for most output formatting jobs, C's scanf-style input\nformats are not very powerful. Instead of scanf-style input, Python\noffers Emacs-style regular expressions as a powerful input and\nscanning mechanism. Read the corresponding section in the Library\nReference for a full description.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 456, "url": "https://docs.python.org/{python_version}/python-tut/node83.html"}
{"title": "Generalized Dictionaries", "text": "---\nnode85.html node63.html node83.html node1.html\n---\n# Generalized Dictionaries\nThe keys of dictionaries are no longer restricted to strings --- they\ncan be any immutable basic type including strings, numbers, tuples, or\n(certain) class instances. (Lists and dictionaries are not acceptable\nas dictionary keys, in order to avoid problems when the object used as\na key is modified.)\nDictionaries have two new methods: `d.values()` returns a list of\nthe dictionary's values, and `d.items()` returns a list of the\ndictionary's (key, value) pairs. Like `d.keys()`, these\noperations are slow for large dictionaries. Examples:\n```text\n>>> d = {100: 'honderd', 1000: 'duizend', 10: 'tien'}\n>>> d.keys()\n[100, 10, 1000]\n>>> d.values()\n['honderd', 'tien', 'duizend']\n>>> d.items()\n[(100, 'honderd'), (10, 'tien'), (1000, 'duizend')]\n>>>\n```\n---\nguido@cwi.nl", "python_version": "1.2", "length": 850, "url": "https://docs.python.org/{python_version}/python-tut/node84.html"}
{"title": "Miscellaneous New Built-in Functions", "text": "---\nnode86.html node63.html node84.html node1.html\n---\n# Miscellaneous New Built-in Functions\nThe function `vars()` returns a dictionary containing the current\nlocal variables. With a module argument, it returns that module's\nglobal variables. The old function `dir(x)` returns\n`vars(x).keys()`.\nThe function `round(x)` returns a floating point number rounded\nto the nearest integer (but still expressed as a floating point\nnumber). E.g. `round(3.4) == 3.0` and `round(3.5) == 4.0`.\nWith a second argument it rounds to the specified number of digits,\ne.g. `round(math.pi, 4) == 3.1416` or even\n`round(123.4, -2) == 100.0`.\nThe function `hash(x)` returns a hash value for an object.\nAll object types acceptable as dictionary keys have a hash value (and\nit is this hash value that the dictionary implementation uses).\nThe function `id(x)` return a unique identifier for an object.\nFor two objects x and y, `id(x) == id(y)` if and only if\n`x is y`. (In fact the object's address is used.)\nThe function `hasattr(x, name)` returns whether an object has an\nattribute with the given name (a string value). The function\n`getattr(x, name)` returns the object's attribute with the given\nname. The function `setattr(x, name, value)` assigns a value to\nan object's attribute with the given name. These three functions are\nuseful if the attribute names are not known beforehand. Note that\n`getattr(x, 'spam')` is equivalent to `x.spam`, and\n`setattr(x, 'spam', y)` is equivalent to `x.spam = y`. By\ndefinition, `hasattr(x, name)` returns true if and only if\n`getattr(x, name)` returns without raising an exception.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1618, "url": "https://docs.python.org/{python_version}/python-tut/node85.html"}
{"title": "Else Clause For Try Statement", "text": "---\nnode87.html node63.html node85.html node1.html\n---\n# Else Clause For Try Statement\nThe `try...except` statement now has an optional `else`\nclause, which must follow all `except` clauses. It is useful to\nplace code that must be executed if the `try` clause does not\nraise an exception. For example:\n```text\nfor arg in sys.argv:\ntry:\nf = open(arg, 'r')\nexcept IOError:\nprint 'cannot open', arg\nelse:\nprint arg, 'has', len(f.readlines()), 'lines'\nf.close()\n```\n---\nguido@cwi.nl", "python_version": "1.2", "length": 478, "url": "https://docs.python.org/{python_version}/python-tut/node86.html"}
{"title": "New Class Features in Release 1.1", "text": "---\nnode88.html node63.html node86.html node1.html\n---\n# New Class Features in Release 1.1\nSome changes have been made to classes: the operator overloading\nmechanism is more flexible, providing more support for non-numeric use\nof operators (including calling an object as if it were a function),\nand it is possible to trap attribute accesses.\n---\n- New Operator Overloading (node88.html#SECTION0011111000000000000000)\nTrapping Attribute Access (node89.html#SECTION0011112000000000000000)\nCalling a Class Instance (node90.html#SECTION0011113000000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 573, "url": "https://docs.python.org/{python_version}/python-tut/node87.html"}
{"title": "New Operator Overloading", "text": "---\nnode89.html node87.html node87.html node1.html\n---\n## New Operator Overloading\nIt is no longer necessary to coerce both sides of an operator to the\nsame class or type. A class may still provide a `__coerce__`\nmethod, but this method may return objects of different types or\nclasses if it feels like it. If no `__coerce__` is defined, any\nargument type or class is acceptable.\nIn order to make it possible to implement binary operators where the\nright-hand side is a class instance but the left-hand side is not,\nwithout using coercions, right-hand versions of all binary operators\nmay be defined. These have an `r' prepended to their name,\ne.g. `__radd__`.\nFor example, here's a very simple class for representing times. Times\nare initialized from a number of seconds (like time.time()). Times\nare printed like this: `Wed Mar 15 12:28:48 1995`. Subtracting\ntwo Times gives their difference in seconds. Adding or subtracting a\nTime and a number gives a new Time. You can't add two times, nor can\nyou subtract a Time from a number.\n```text\nimport time\n\nclass Time:\ndef __init__(self, seconds):\nself.seconds = seconds\ndef __repr__(self):\nreturn time.ctime(self.seconds)\ndef __add__(self, x):\nreturn Time(self.seconds + x)\n__radd__ = __add__ # support for x+t\ndef __sub__(self, x):\nif hasattr(x, 'seconds'): # test if x could be a Time\nreturn self.seconds - x.seconds\nelse:\nreturn self.seconds - x\n\nnow = Time(time.time())\ntomorrow = 24*3600 + now\nyesterday = now - today\nprint tomorrow - yesterday # prints 172800\n```\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1535, "url": "https://docs.python.org/{python_version}/python-tut/node88.html"}
{"title": "Trapping Attribute Access", "text": "---\nnode90.html node87.html node88.html node1.html\n---\n## Trapping Attribute Access\nYou can define three new ``magic'' methods in a class now:\n`__getattr__(self, name)`, `__setattr__(self, name, value)`\nand `__delattr__(self, name)`.\nThe `__getattr__` method is called when an attribute access fails,\ni.e. when an attribute access would otherwise raise AttributeError ---\nthis is after the instance's dictionary and its class hierarchy\nhave been searched for the named attribute. Note that if this method\nattempts to access any undefined instance attribute it will be called\nrecursively!\nThe `__setattr__` and `__delattr__` methods are called when\nassignment to, respectively deletion of an attribute are attempted.\nThey are called instead of the normal action (which is to insert\nor delete the attribute in the instance dictionary). If either of\nthese methods most set or delete any attribute, they can only do so by\nusing the instance dictionary directly --- `self.__dict__` --- else\nthey would be called recursively.\nFor example, here's a near-universal ``Wrapper'' class that passes all\nits attribute accesses to another object. Note how the\n`__init__` method inserts the wrapped object in\n`self.__dict__` in order to avoid endless recursion\n(`__setattr__` would call `__getattr__` which would call\nitself recursively).\n```text\nclass Wrapper:\ndef __init__(self, wrapped):\nself.__dict__['wrapped'] = wrapped\ndef __getattr__(self, name):\nreturn getattr(self.wrapped, name)\ndef __setattr__(self, name, value):\nsetattr(self.wrapped, name, value)\ndef __delattr__(self, name):\ndelattr(self.wrapped, name)\n\nimport sys\nf = Wrapper(sys.stdout)\nf.write('hello world\\n') # prints 'hello world'\n```\nA simpler example of `__getattr__` is an attribute that is\ncomputed each time (or the first time) it it accessed. For instance:\n```text\nfrom math import pi\n\nclass Circle:\ndef __init__(self, radius):\nself.radius = radius\ndef __getattr__(self, name):\nif name == 'circumference':\nreturn 2 * pi * self.radius\nif name == 'diameter':\nreturn 2 * self.radius\nif name == 'area':\nreturn pi * pow(self.radius, 2)\nraise AttributeError, name\n```\n---\nguido@cwi.nl", "python_version": "1.2", "length": 2140, "url": "https://docs.python.org/{python_version}/python-tut/node89.html"}
{"title": "Error Handling", "text": "---\nnode10.html node8.html node8.html node1.html\n---\n## Error Handling\nWhen an error occurs, the interpreter prints an error\nmessage and a stack trace. In interactive mode, it then returns to\nthe primary prompt; when input came from a file, it exits with a\nnonzero exit status after printing\nthe stack trace. (Exceptions handled by an except clause in a\ntry statement are not errors in this context.) Some errors are\nunconditionally fatal and cause an exit with a nonzero exit; this\napplies to internal inconsistencies and some cases of running out of\nmemory. All error messages are written to the standard error stream;\nnormal output from the executed commands is written to standard\noutput.\nTyping the interrupt character (usually Control-C or DEL) to the\nprimary or secondary prompt cancels the input and returns to the\nprimary prompt.\nfootnode.html#65\nTyping an interrupt while a command is executing raises the\nKeyboardInterrupt exception, which may be handled by a try\nstatement.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1002, "url": "https://docs.python.org/{python_version}/python-tut/node9.html"}
{"title": "Calling a Class Instance", "text": "---\nnode91.html node87.html node89.html node1.html\n---\n## Calling a Class Instance\nIf a class defines a method `__call__` it is possible to call its\ninstances as if they were functions. For example:\n```text\nclass PresetSomeArguments:\ndef __init__(self, func, *args):\nself.func, self.args = func, args\ndef __call__(self, *args):\nreturn apply(self.func, self.args + args)\n\nf = PresetSomeArguments(pow, 2) # f(i) computes powers of 2\nfor i in range(10): print f(i), # prints 1 2 4 8 16 32 64 128 256 512\nprint # append newline\n```\n---\nguido@cwi.nl", "python_version": "1.2", "length": 544, "url": "https://docs.python.org/{python_version}/python-tut/node90.html"}
{"title": "New in Release 1.2", "text": "---\nnode92.html tut.html node90.html node1.html\n---\n# New in Release 1.2\nThis chapter describes even more recent additions to the Python\nlanguage and library.\n---\n- New Class Features (node92.html#SECTION001210000000000000000)\nUnix Signal Handling (node93.html#SECTION001220000000000000000)\nExceptions Can Be Classes (node94.html#SECTION001230000000000000000)\nObject Persistency and Object Copying (node95.html#SECTION001240000000000000000)\n- Persistent Objects (node96.html#SECTION001241000000000000000)\nCopying Objects (node97.html#SECTION001242000000000000000)\nDocumentation Strings (node98.html#SECTION001250000000000000000)\nCustomizing Import and Built-Ins (node99.html#SECTION001260000000000000000)\nPython and the World-Wide Web (node100.html#SECTION001270000000000000000)\nMiscellaneous (node101.html#SECTION001280000000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 853, "url": "https://docs.python.org/{python_version}/python-tut/node91.html"}
{"title": "New Class Features", "text": "---\nnode93.html node91.html node91.html node1.html\n---\n# New Class Features\nThe semantics of `__coerce__` have been changed to be more\nreasonable. As an example, the new standard module `Complex`\nimplements fairly complete complex numbers using this. Additional\nexamples of classes with and without `__coerce__` methods can be\nfound in the `Demo/classes` subdirectory, modules `Rat` and\n`Dates`.\nIf a class defines no `__coerce__` method, this is equivalent to\nthe following definition:\n```text\ndef __coerce__(self, other): return self, other\n```\nIf `__coerce__` coerces itself to an object of a different type,\nthe operation is carried out using that type --- in release 1.1, this\nwould cause an error.\nComparisons involving class instances now invoke `__coerce__`\nexactly as if `cmp(x, y)` were a binary operator like `+`\n(except if `x` and `y` are the same object).\n---\nguido@cwi.nl", "python_version": "1.2", "length": 885, "url": "https://docs.python.org/{python_version}/python-tut/node92.html"}
{"title": "Unix Signal Handling", "text": "---\nnode94.html node91.html node92.html node1.html\n---\n# Unix Signal Handling\nOn Unix, Python now supports signal handling. The module\n`signal` exports functions `signal`, `pause` and\n`alarm`, which act similar to their Unix counterparts. The\nmodule also exports the conventional names for the various signal\nclasses (also usable with `os.kill()`) and `SIG_IGN` and\n`SIG_DFL`. See the section on `signal` in the Library\nReference Manual for more information.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 475, "url": "https://docs.python.org/{python_version}/python-tut/node93.html"}
{"title": "Exceptions Can Be Classes", "text": "---\nnode95.html node91.html node93.html node1.html\n---\n# Exceptions Can Be Classes\nUser-defined exceptions are no longer limited to being string objects\n--- they can be identified by classes as well. Using this mechanism it\nis possible to create extensible hierarchies of exceptions.\nThere are two new valid (semantic) forms for the raise statement:\n```text\nraise Class, instance\n\nraise instance\n```\nIn the first form, `instance` must be an instance of `Class`\nor of a class derived from it. The second form is a shorthand for\n```text\nraise instance.__class__, instance\n```\nAn except clause may list classes as well as string objects. A class\nin an except clause is compatible with an exception if it is the same\nclass or a base class thereof (but not the other way around --- an\nexcept clause listing a derived class is not compatible with a base\nclass). For example, the following code will print B, C, D in that\norder:\n```text\nclass B:\npass\nclass C(B):\npass\nclass D(C):\npass\n\nfor c in [B, C, D]:\ntry:\nraise c()\nexcept D:\nprint \"D\"\nexcept C:\nprint \"C\"\nexcept B:\nprint \"B\"\n```\nNote that if the except clauses were reversed (with ```except B`''\nfirst), it would have printed B, B, B --- the first matching except\nclause is triggered.\nWhen an error message is printed for an unhandled exception which is a\nclass, the class name is printed, then a colon and a space, and\nfinally the instance converted to a string using the built-in function\n`str()`.\nIn this release, the built-in exceptions are still strings.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1525, "url": "https://docs.python.org/{python_version}/python-tut/node94.html"}
{"title": "Object Persistency and Object Copying", "text": "---\nnode96.html node91.html node94.html node1.html\n---\n# Object Persistency and Object Copying\nTwo new modules, `pickle` and `shelve`, support storage and\nretrieval of (almost) arbitrary Python objects on disk, using the\n`dbm` package. A third module, `copy`, provides flexible\nobject copying operations. More information on these modules is\nprovided in the Library Reference Manual.\n---\n- Persistent Objects (node96.html#SECTION001241000000000000000)\nCopying Objects (node97.html#SECTION001242000000000000000)\n---\nguido@cwi.nl", "python_version": "1.2", "length": 527, "url": "https://docs.python.org/{python_version}/python-tut/node95.html"}
{"title": "Persistent Objects", "text": "---\nnode97.html node95.html node95.html node1.html\n---\n## Persistent Objects\nThe module `pickle` provides a general framework for objects to\ndisassemble themselves into a stream of bytes and to reassemble such a\nstream back into an object. It copes with reference sharing,\nrecursive objects and instances of user-defined classes, but not\n(directly) with objects that have ``magical'' links into the operating\nsystem such as open files, sockets or windows.\nThe `pickle` module defines a simple protocol whereby\nuser-defined classes can control how they are disassembled and\nassembled. The method `__getinitargs__()`, if defined, returns\nthe argument list for the constructor to be used at assembly time (by\ndefault the constructor is called without arguments). The methods\n`__getstate__()` and `__setstate__()` are used to pass\nadditional state from disassembly to assembly; by default the\ninstance's `__dict__` is passed and restored.\nNote that `pickle` does not open or close any files --- it can be\nused equally well for moving objects around on a network or store them\nin a database. For ease of debugging, and the inevitable occasional\nmanual patch-up, the constructed byte streams consist of printable\nASCII characters only (though it's not designed to be pretty).\nThe module `shelve` provides a simple model for storing objects\non files. The operation `shelve.open(filename)` returns a\n``shelf'', which is a simple persistent database with a\ndictionary-like interface. Database keys are strings, objects stored\nin the database can be anything that `pickle` will handle.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1592, "url": "https://docs.python.org/{python_version}/python-tut/node96.html"}
{"title": "Copying Objects", "text": "---\nnode98.html node95.html node96.html node1.html\n---\n## Copying Objects\nThe module `copy` exports two functions: `copy()` and\n`deepcopy()`. The `copy()` function returns a ``shallow''\ncopy of an object; `deepcopy()` returns a ``deep'' copy. The\ndifference between shallow and deep copying is only relevant for\ncompound objects (objects that contain other objects, like lists or\nclass instances):\n- A shallow copy constructs a new compound object and then (to the\nextent possible) inserts the same objects into in that the\noriginal contains.\nA deep copy constructs a new compound object and then, recursively,\ninserts copies into it of the objects found in the original.\nBoth functions have the same restrictions and use the same protocols\nas `pickle` --- user-defined classes can control how they are\ncopied by providing methods named `__getinitargs__()`,\n`__getstate__()` and `__setstate__()`.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 913, "url": "https://docs.python.org/{python_version}/python-tut/node97.html"}
{"title": "Documentation Strings", "text": "---\nnode99.html node91.html node97.html node1.html\n---\n# Documentation Strings\nA variety of objects now have a new attribute, `__doc__`, which\nis supposed to contain a documentation string (if no documentation is\npresent, the attribute is `None`). New syntax, compatible with\nthe old interpreter, allows for convenient initialization of the\n`__doc__` attribute of modules, classes and functions by placing\na string literal by itself as the first statement in the suite. It\nmust be a literal --- an expression yielding a string object is not\naccepted as a documentation string, since future tools may need to\nderive documentation from source by parsing.\nHere is a hypothetical, amply documented module called `Spam`:\n```text\n\"\"\"Spam operations.\n\nThis module exports two classes, a function and an exception:\n\nclass Spam: full Spam functionality --- three can sizes\nclass SpamLight: limited Spam functionality --- only one can size\n\ndef open(filename): open a file and return a corresponding Spam or\nSpamLight object\n\nGoneOff: exception raised for errors; should never happen\n\nNote that it is always possible to convert a SpamLight object to a\nSpam object by a simple method call, but that the reverse operation is\ngenerally costly and may fail for a number of reasons.\n\"\"\"\n\nclass SpamLight:\n\"\"\"Limited spam functionality.\n\nSupports a single can size, no flavor, and only hard disks.\n\"\"\"\n\ndef __init__(self, size=12):\n\"\"\"Construct a new SpamLight instance.\n\nArgument is the can size.\n\"\"\"\n# etc.\n\n# etc.\n\nclass Spam(SpamLight):\n\"\"\"Full spam functionality.\n\nSupports three can sizes, two flavor varieties, and all floppy\ndisk formats still supported by current hardware.\n\"\"\"\n\ndef __init__(self, size1=8, size2=12, size3=20):\n\"\"\"Construct a new Spam instance.\n\nArguments are up to three can sizes.\n\"\"\"\n# etc.\n\n# etc.\n\ndef open(filename = \"/dev/null\"):\n\"\"\"Open a can of Spam.\n\nArgument must be an existing file.\n\"\"\"\n# etc.\n\nclass GoneOff:\n\"\"\"Class used for Spam exceptions.\n\nThere shouldn't be any.\n\"\"\"\npass\n```\nAfter executing ```import Spam`'', the following expressions\nreturn the various documentation strings from the module:\n```text\nSpam.__doc__\nSpam.SpamLight.__doc__\nSpam.SpamLight.__init__.__doc__\nSpam.Spam.__doc__\nSpam.Spam.__init__.__doc__\nSpam.open.__doc__\nSpam.GoneOff.__doc__\n```\nThere are emerging conventions about the content and formatting of\ndocumentation strings.\nThe first line should always be a short, concise summary of the\nobject's purpose. For brevity, it should not explicitly state the\nobject's name or type, since these are available by other means\n(except if the name happens to be a verb describing a function's\noperation). This line should begin with a capital letter and end with\na period.\nIf there are more lines in the documentation string, the second line\nshould be blank, visually separating the summary from the rest of the\ndescription. The following lines should be one of more of paragraphs\ndescribing the objects calling conventions, its side effects, etc.\nSome people like to copy the Emacs convention of using UPPER CASE for\nfunction parameters --- this often saves a few words or lines.\nThe Python parser does not strip indentation from multi-line string\nliterals in Python, so tools that process documentation have to strip\nindentation. This is done using the following convention. The first\nnon-blank line after the first line of the string determines the\namount of indentation for the entire documentation string. (We can't\nuse the first line since it is generally adjacent to the string's\nopening quotes so its indentation is not apparent in the string\nliteral.) Whitespace ``equivalent'' to this indentation is then\nstripped from the start of all lines of the string. Lines that are\nindented less should not occur, but if they occur all their leading\nwhitespace should be stripped. Equivalence of whitespace should be\ntested after expansion of tabs (to 8 spaces, normally).\nIn this release, few of the built-in or standard functions and modules\nhave documentation strings.\n---\nnode99.html node91.html node97.html node1.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 4088, "url": "https://docs.python.org/{python_version}/python-tut/node98.html"}
{"title": "Customizing Import and Built-Ins", "text": "---\nnode100.html node91.html node98.html node1.html\n---\n# Customizing Import and Built-Ins\nIn preparation for a ``restricted execution mode'' which will be\nusable to run code received from an untrusted source (such as a WWW\nserver or client), the mechanism by which modules are imported has\nbeen redesigned. It is now possible to provide your own function\n`__import__` which is called whenever an `import` statement\nis executed. There's a built-in function `__import__` which\nprovides the default implementation, but more interesting, the various\nsteps it takes are available separately from the new built-in module\n`imp`. (See the section on `imp` in the Library Reference\nManual for more information on this module.)\nWhen you do `dir()` in a fresh interactive interpreter you will\nsee another ``secret'' object that's present in every module:\n`__builtins__`. This is either a dictionary or a module\ncontaining the set of built-in objects used by functions defined in\ncurrent module. Although normally all modules are initialized with a\nreference to the same dictionary, it is now possible to use a\ndifferent set of built-ins on a per-module basis. Together with the\nfact that the `import` statement uses the `__import__`\nfunction it finds in the importing modules' dictionary of built-ins,\nthis forms the basis for a future restricted execution mode.\n---\nguido@cwi.nl", "python_version": "1.2", "length": 1369, "url": "https://docs.python.org/{python_version}/python-tut/node99.html"}
{"title": "Python Tutorial", "text": "---\nnode1.html node1.html\n---\n# Python Tutorial\nGuido van Rossum\nDept. AA, CWI, P.O. Box 94079\n1090 GB Amsterdam, The Netherlands\nE-mail: guido@cwi.nl\n10 April 1995\nRelease 1.2\nCopyright © 1991-1995 by Stichting Mathematisch Centrum,\nAmsterdam, The Netherlands.\nAll Rights Reserved\nPermission to use, copy, modify, and distribute this software and its\ndocumentation for any purpose and without fee is hereby granted,\nprovided that the above copyright notice appear in all copies and that\nboth that copyright notice and this permission notice appear in\nsupporting documentation, and that the names of Stichting Mathematisch\nCentrum or CWI not be used in advertising or publicity pertaining to\ndistribution of the software without specific, written prior permission.\nSTICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO\nTHIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND\nFITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE\nFOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES\nWHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN\nACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT\nOF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\n### Abstract:\nPython is a simple, yet powerful programming language that bridges the\ngap between C and shell programming, and is thus ideally suited for\n``throw-away programming''\nand rapid prototyping. Its syntax is put\ntogether from constructs borrowed from a variety of other languages;\nmost prominent are influences from ABC, C, Modula-3 and Icon.\nThe Python interpreter is easily extended with new functions and data\ntypes implemented in C. Python is also suitable as an extension\nlanguage for highly customizable C applications such as editors or\nwindow managers.\nPython is available for various operating systems, amongst which\nseveral flavors of Unix, Amoeba, the Apple Macintosh O.S.,\nand MS-DOS.\nThis tutorial introduces the reader informally to the basic concepts\nand features of the Python language and system. It helps to have a\nPython interpreter handy for hands-on experience, but as the examples\nare self-contained, the tutorial can be read off-line as well.\nFor a description of standard objects and modules, see the Python\nLibrary Reference document. The Python Reference Manual gives\na more formal definition of the language.\n---\n- Contents (node1.html#SECTION00100000000000000000)\nWhetting Your Appetite (node2.html#SECTION00200000000000000000)\n- Where From Here (node3.html#SECTION00210000000000000000)\nUsing the Python Interpreter (node4.html#SECTION00300000000000000000)\n- Invoking the Interpreter (node5.html#SECTION00310000000000000000)\n- Argument Passing (node6.html#SECTION00311000000000000000)\nInteractive Mode (node7.html#SECTION00312000000000000000)\nThe Interpreter and its Environment (node8.html#SECTION00320000000000000000)\n- Error Handling (node9.html#SECTION00321000000000000000)\nThe Module Search Path (node10.html#SECTION00322000000000000000)\n``Compiled'' Python files (node11.html#SECTION00323000000000000000)\nExecutable Python scripts (node12.html#SECTION00324000000000000000)\nThe Interactive Startup File (node13.html#SECTION00325000000000000000)\nInteractive Input Editing and History Substitution (node14.html#SECTION00330000000000000000)\n- Line Editing (node15.html#SECTION00331000000000000000)\nHistory Substitution (node16.html#SECTION00332000000000000000)\nKey Bindings (node17.html#SECTION00333000000000000000)\nCommentary (node18.html#SECTION00334000000000000000)\nAn Informal Introduction to Python (node19.html#SECTION00400000000000000000)\n- Using Python as a Calculator (node20.html#SECTION00410000000000000000)\n- Numbers (node21.html#SECTION00411000000000000000)\nStrings (node22.html#SECTION00412000000000000000)\nLists (node23.html#SECTION00413000000000000000)\nFirst Steps Towards Programming (node24.html#SECTION00420000000000000000)\nMore Control Flow Tools (node25.html#SECTION00500000000000000000)\n- If Statements (node26.html#SECTION00510000000000000000)\nFor Statements (node27.html#SECTION00520000000000000000)\nThe range() Function (node28.html#SECTION00530000000000000000)\nBreak and Continue Statements, and Else Clauses on Loops (node29.html#SECTION00540000000000000000)\nPass Statements (node30.html#SECTION00550000000000000000)\nDefining Functions (node31.html#SECTION00560000000000000000)\nOdds and Ends (node32.html#SECTION00600000000000000000)\n- More on Lists (node33.html#SECTION00610000000000000000)\nThe del statement (node34.html#SECTION00620000000000000000)\nTuples and Sequences (node35.html#SECTION00630000000000000000)\nDictionaries (node36.html#SECTION00640000000000000000)\nMore on Conditions (node37.html#SECTION00650000000000000000)\nComparing Sequences and Other Types (node38.html#SECTION00660000000000000000)\nModules (node39.html#SECTION00700000000000000000)\n- More on Modules (node40.html#SECTION00710000000000000000)\nStandard Modules (node41.html#SECTION00720000000000000000)\nThe dir() function (node42.html#SECTION00730000000000000000)\nOutput Formatting (node43.html#SECTION00800000000000000000)\nErrors and Exceptions (node44.html#SECTION00900000000000000000)\n- Syntax Errors (node45.html#SECTION00910000000000000000)\nExceptions (node46.html#SECTION00920000000000000000)\nHandling Exceptions (node47.html#SECTION00930000000000000000)\nRaising Exceptions (node48.html#SECTION00940000000000000000)\nUser-defined Exceptions (node49.html#SECTION00950000000000000000)\nDefining Clean-up Actions (node50.html#SECTION00960000000000000000)\nClasses (node51.html#SECTION001000000000000000000)\n- A word about terminology (node52.html#SECTION001010000000000000000)\nPython scopes and name spaces (node53.html#SECTION001020000000000000000)\nA first look at classes (node54.html#SECTION001030000000000000000)\n- Class definition syntax (node55.html#SECTION001031000000000000000)\nClass objects (node56.html#SECTION001032000000000000000)\nInstance objects (node57.html#SECTION001033000000000000000)\nMethod objects (node58.html#SECTION001034000000000000000)\nRandom remarks (node59.html#SECTION001040000000000000000)\nInheritance (node60.html#SECTION001050000000000000000)\n- Multiple inheritance (node61.html#SECTION001051000000000000000)\nOdds and ends (node62.html#SECTION001060000000000000000)\nRecent Additions (node63.html#SECTION001100000000000000000)\n- The Last Printed Expression (node64.html#SECTION001110000000000000000)\nString Literals (node65.html#SECTION001120000000000000000)\n- Double Quotes (node66.html#SECTION001121000000000000000)\nContinuation Of String Literals (node67.html#SECTION001122000000000000000)\nTriple-quoted strings (node68.html#SECTION001123000000000000000)\nString Literal Juxtaposition (node69.html#SECTION001124000000000000000)\nThe Formatting Operator (node70.html#SECTION001130000000000000000)\n- Basic Usage (node71.html#SECTION001131000000000000000)\nReferencing Variables By Name (node72.html#SECTION001132000000000000000)\nOptional Function Arguments (node73.html#SECTION001140000000000000000)\n- Default Argument Values (node74.html#SECTION001141000000000000000)\nArbitrary Argument Lists (node75.html#SECTION001142000000000000000)\nLambda And Functional Programming Tools (node76.html#SECTION001150000000000000000)\n- Lambda Forms (node77.html#SECTION001151000000000000000)\nMap, Reduce and Filter (node78.html#SECTION001152000000000000000)\n- Map. (node79.html#SECTION001152100000000000000)\nFilter. (node80.html#SECTION001152200000000000000)\nReduce. (node81.html#SECTION001152300000000000000)\nContinuation Lines Without Backslashes (node82.html#SECTION001160000000000000000)\nRegular Expressions (node83.html#SECTION001170000000000000000)\nGeneralized Dictionaries (node84.html#SECTION001180000000000000000)\nMiscellaneous New Built-in Functions (node85.html#SECTION001190000000000000000)\nElse Clause For Try Statement (node86.html#SECTION0011100000000000000000)\nNew Class Features in Release 1.1 (node87.html#SECTION0011110000000000000000)\n- New Operator Overloading (node88.html#SECTION0011111000000000000000)\nTrapping Attribute Access (node89.html#SECTION0011112000000000000000)\nCalling a Class Instance (node90.html#SECTION0011113000000000000000)\nNew in Release 1.2 (node91.html#SECTION001200000000000000000)\n- New Class Features (node92.html#SECTION001210000000000000000)\nUnix Signal Handling (node93.html#SECTION001220000000000000000)\nExceptions Can Be Classes (node94.html#SECTION001230000000000000000)\nObject Persistency and Object Copying (node95.html#SECTION001240000000000000000)\n- Persistent Objects (node96.html#SECTION001241000000000000000)\nCopying Objects (node97.html#SECTION001242000000000000000)\nDocumentation Strings (node98.html#SECTION001250000000000000000)\nCustomizing Import and Built-Ins (node99.html#SECTION001260000000000000000)\nPython and the World-Wide Web (node100.html#SECTION001270000000000000000)\nMiscellaneous (node101.html#SECTION001280000000000000000)\nAbout this document ... (node102.html#SECTION001300000000000000000)\n---\nnode1.html node1.html\n---\n---\nguido@cwi.nl", "python_version": "1.2", "length": 9016, "url": "https://docs.python.org/{python_version}/python-tut/tut.html"}