This is /home/pdm/install/Python-2.1/Doc/ref/python-ref.info, produced by makeinfo version 4.0 from ref.texi. April 15, 2001 2.1  File: python-ref.info, Node: Miscellaneous Index, Prev: Function-Method-Variable Index, Up: Top Miscellaneous Index ******************* * Menu: * __add__(): Emulating sequence and mapping types. * __bases__: standard type hierarchy. * __builtins__: exec statement. * __call__(): Calls. * __class__: standard type hierarchy. * __cmp__(): Basic customization. * __coerce__(): Emulating sequence and mapping types. * __debug__: Assert statements. * __dict__ <1>: Customizing attribute access. * __dict__: standard type hierarchy. * __doc__: standard type hierarchy. * __file__: standard type hierarchy. * __future__: __future__. * __getitem__(): Special method names. * __iadd__(): Emulating sequence and mapping types. * __imul__(): Emulating sequence and mapping types. * __init__(): standard type hierarchy. * __init__.py: import statement. * __len__(): Basic customization. * __members__: standard type hierarchy. * __methods__: standard type hierarchy. * __module__: standard type hierarchy. * __mul__(): Emulating sequence and mapping types. * __name__: standard type hierarchy. * __nonzero__(): Emulating sequence and mapping types. * __radd__(): Emulating sequence and mapping types. * __rmul__(): Emulating sequence and mapping types. * __setattr__(): Customizing attribute access. * addition: Binary arithmetic operations. * and: Boolean operations. * anonmymous function: Boolean operations. * append(): Emulating sequence and mapping types. * arithmetic conversion: Arithmetic conversions. * ASCII@ASCII <1>: standard type hierarchy. * ASCII@ASCII <2>: Delimiters. * ASCII@ASCII <3>: String literals. * ASCII@ASCII: Notation. * assert: Assert statements. * assignment statement <1>: Assignment statements. * assignment statement: standard type hierarchy. * atom: Atoms. * attribute: standard type hierarchy. * attribute assignment: Assignment statements. * attribute deletion: del statement. * attribute reference: Attribute references. * augmented assignment: Augmented Assignment statements. * back-quotes <1>: String conversions. * back-quotes: Basic customization. * backslash character: Explicit line joining. * backward quotes <1>: String conversions. * backward quotes: Basic customization. * binary arithmetic operation: Binary arithmetic operations. * binary bit-wise operation: Binary bit-wise operations. * binding name <1>: Assignment statements. * binding name: Code blocks. * bit-wise and: Binary bit-wise operations. * bit-wise or: Binary bit-wise operations. * bit-wise xor: Binary bit-wise operations. * blank line: Blank lines blank line. * BNF <1>: Expressions. * BNF: Notation. * Boolean operation: Boolean operations. * break <1>: try statement. * break <2>: for statement. * break <3>: while statement. * break: break statement. * built-in function call: Calls. * built-in method: standard type hierarchy. * built-in method call: Calls. * built-in module: import statement. * built-in name: Identifiers Names. * byte: standard type hierarchy. * bytecode: standard type hierarchy. * C: String literals. * C language <1>: Comparisons. * C language: standard type hierarchy. * call: Calls. * call instance: Emulating callable objects. * chaining comparisons: Comparisons. * character <1>: Subscriptions. * character: standard type hierarchy. * character set: standard type hierarchy. * class attribute: standard type hierarchy. * class attribute assignment: standard type hierarchy. * class constructor: Basic customization. * class definition <1>: Class definitions. * class definition: return statement. * class instance: standard type hierarchy. * class instance attribute: standard type hierarchy. * class instance attribute assignment: standard type hierarchy. * class instance call: Calls. * class name: Class definitions. * class object call <1>: Calls. * class object call: standard type hierarchy. * clause: Compound statements. * clear(): Emulating sequence and mapping types. * co_argcount: standard type hierarchy. * co_cellvars: standard type hierarchy. * co_code: standard type hierarchy. * co_consts: standard type hierarchy. * co_filename: standard type hierarchy. * co_firstlineno: standard type hierarchy. * co_flags: standard type hierarchy. * co_freevars: standard type hierarchy. * co_lnotab: standard type hierarchy. * co_name: standard type hierarchy. * co_names: standard type hierarchy. * co_nlocals: standard type hierarchy. * co_stacksize: standard type hierarchy. * co_varnames: standard type hierarchy. * code block <1>: import statement. * code block <2>: Identifiers Names. * code block: Code blocks. * comma: Parenthesized forms. * command line: Complete Python programs. * comment: Comments. * comparison: Comparisons. * comparisons: Basic customization. * complex literal: Numeric literals. * complex number: standard type hierarchy. * compound statement: Compound statements. * constant: Literals. * container <1>: standard type hierarchy. * container: Objects. * continue <1>: try statement. * continue <2>: for statement. * continue <3>: while statement. * continue: continue statement. * copy(): Emulating sequence and mapping types. * count(): Emulating sequence and mapping types. * dangling else: Compound statements. * data: Objects. * data type: standard type hierarchy. * datum: Dictionary displays. * debugging assertions: Assert statements. * decimal literal: Numeric literals. * DEDENT token <1>: Compound statements. * DEDENT token: Indentation. * default parameter value: Function definitions. * del <1>: del statement. * del <2>: Basic customization. * del: standard type hierarchy. * delete: standard type hierarchy. * deletion target: del statement. * deletion target list: del statement. * delimiters: Delimiters. * destructor <1>: Assignment statements. * destructor: Basic customization. * dictionary display: Dictionary displays. * division: Binary arithmetic operations. * documentation string: standard type hierarchy. * EBCDIC: standard type hierarchy. * elif: if statement. * Ellipsis: standard type hierarchy. * else <1>: try statement. * else <2>: for statement. * else <3>: while statement. * else <4>: if statement. * else: break statement. * empty list: List displays. * empty tuple <1>: Parenthesized forms. * empty tuple: standard type hierarchy. * error handling: Exceptions. * errors: Exceptions. * escape sequence: String literals. * exc_info: standard type hierarchy. * exc_traceback <1>: try statement. * exc_traceback: standard type hierarchy. * exc_type: try statement. * exc_value: try statement. * except: try statement. * exception <1>: raise statement. * exception: Exceptions. * exception handler <1>: Exceptions. * exception handler: standard type hierarchy. * exclusive or: Binary bit-wise operations. * exec <1>: exec statement. * exec <2>: global statement. * exec: Code blocks. * execution frame <1>: Class definitions. * execution frame: Code blocks. * execution model: Execution model. * execution stack: standard type hierarchy. * expression: Expressions. * expression list <1>: Assignment statements. * expression list <2>: Expression statements. * expression list: Expression lists. * expression statement: Expression statements. * extended print statement: print statement. * extended slicing: Slicings. * extension module: standard type hierarchy. * f_back: standard type hierarchy. * f_builtins: standard type hierarchy. * f_code: standard type hierarchy. * f_exc_traceback: standard type hierarchy. * f_exc_type: standard type hierarchy. * f_exc_value: standard type hierarchy. * f_globals: standard type hierarchy. * f_lasti: standard type hierarchy. * f_lineno: standard type hierarchy. * f_locals: standard type hierarchy. * f_restricted: standard type hierarchy. * f_trace: standard type hierarchy. * filename extension: import statement. * finally <1>: try statement. * finally <2>: continue statement. * finally <3>: break statement. * finally: return statement. * floating point literal: Numeric literals. * floating point number: standard type hierarchy. * for <1>: for statement. * for <2>: continue statement. * for: break statement. * from <1>: import statement. * from: Code blocks. * func_code: standard type hierarchy. * func_defaults: standard type hierarchy. * func_dict: standard type hierarchy. * func_doc: standard type hierarchy. * func_globals: standard type hierarchy. * function argument: standard type hierarchy. * function call <1>: Calls. * function call: standard type hierarchy. * function definition <1>: Function definitions. * function definition: return statement. * function name: Function definitions. * future statement: Future statements. * garbage collection: Objects. * generic special attribute: standard type hierarchy. * get(): Emulating sequence and mapping types. * global <1>: global statement. * global <2>: import statement. * global <3>: del statement. * global <4>: Assignment statements. * global <5>: Identifiers Names. * global: Code blocks. * global name: Identifiers Names. * global name binding: global statement. * global namespace <1>: Code blocks. * global namespace: standard type hierarchy. * grammar: Notation. * grouping: Indentation. * handle an exception: Exceptions. * has_key(): Emulating sequence and mapping types. * hash character: Comments. * hexadecimal literal: Numeric literals. * hierarchical module names: import statement. * identifier <1>: Identifiers Names. * identifier: Identifiers and keywords. * identity of an object: Objects. * identity test: Comparisons. * if: if statement. * im_class: standard type hierarchy. * im_func: standard type hierarchy. * im_self: standard type hierarchy. * imaginary literal: Numeric literals. * immutable data type: Literals 2. * immutable object <1>: Dictionary displays. * immutable object <2>: Literals 2. * immutable object: Objects. * import <1>: import statement. * import: standard type hierarchy. * importing module: import statement. * in <1>: for statement. * in: Comparisons. * inclusive or: Binary bit-wise operations. * INDENT token: Indentation. * indentation: Indentation. * index operation: standard type hierarchy. * index(): Emulating sequence and mapping types. * inheritance: Class definitions. * input: Expression input. * input!raw: Expression input. * insert(): Emulating sequence and mapping types. * instance call: Calls. * integer: standard type hierarchy. * integer literal: Numeric literals. * integer representation: standard type hierarchy. * interactive mode: Complete Python programs. * internal type: standard type hierarchy. * interpreter: Top-level components. * inversion: Unary arithmetic operations. * invocation: standard type hierarchy. * is: Comparisons. * is not: Comparisons. * item selection: standard type hierarchy. * items(): Emulating sequence and mapping types. * key: Dictionary displays. * key/datum pair: Dictionary displays. * keys(): Emulating sequence and mapping types. * keyword: Keywords. * lambda expression: Boolean operations. * lambda form <1>: Function definitions. * lambda form: Boolean operations. * last_traceback: standard type hierarchy. * leading whitespace: Indentation. * lexical analysis: Lexical analysis. * lexical definitions: Notation. * line continuation: Explicit line joining. * line joining <1>: Explicit line joining. * line joining: Logical lines. * line structure: Line structure. * list comprehensions: List displays. * list display: List displays. * literal <1>: Literals 2. * literal: Literals. * local namespace: Code blocks. * logical line: Logical lines. * long integer literal: Numeric literals. * loop control target: break statement. * loop statement <1>: for statement. * loop statement <2>: while statement. * loop statement <3>: continue statement. * loop statement: break statement. * loop!over mutable sequence: for statement. * makefile(): standard type hierarchy. * membership test: Comparisons. * method call: Calls. * minus: Unary arithmetic operations. * module initialization: import statement. * module name: import statement. * module namespace: standard type hierarchy. * module search path: import statement. * modules: import statement. * modulo: Binary arithmetic operations. * multiplication: Binary arithmetic operations. * mutable object: Objects. * mutable sequence!loop over: for statement. * name <1>: Identifiers Names. * name: Identifiers and keywords. * name binding <1>: Class definitions. * name binding <2>: Function definitions. * name binding <3>: import statement. * name binding: Identifiers Names. * name mangling: Identifiers Names. * NameError: Code blocks. * namespace: Code blocks. * negation: Unary arithmetic operations. * nested scopes: Nested scopes. * newline suppression: print statement. * NEWLINE token <1>: Compound statements. * NEWLINE token: Logical lines. * None <1>: Expression statements. * None: standard type hierarchy. * not: Boolean operations. * not in: Comparisons. * notation: Notation. * NotImplemented: standard type hierarchy. * null operation: pass statement. * number: Numeric literals. * numeric literal: Numeric literals. * object: Objects. * octal literal: Numeric literals. * operator precedence: Summary. * operators: Operators. * or: Boolean operations. * output <1>: print statement. * output: Expression statements. * OverflowError: standard type hierarchy. * packages: import statement. * parenthesized form: Parenthesized forms. * parser: Lexical analysis. * Pascal language: for statement. * pass: pass statement. * physical line <1>: String literals. * physical line <2>: Explicit line joining. * physical line: Logical lines. * plain integer literal: Numeric literals. * plus: Unary arithmetic operations. * pop(): Emulating sequence and mapping types. * popen(): standard type hierarchy. * primary: Primaries. * print <1>: print statement. * print: Basic customization. * private names: Identifiers Names. * procedure call: Expression statements. * program: Complete Python programs. * raise: raise statement. * raise an exception: Exceptions. * raising exception: raise statement. * raw input: Expression input. * raw string: String literals. * readline(): Expression input. * rebinding name <1>: Assignment statements. * rebinding name: Code blocks. * reference counting: Objects. * remove(): Emulating sequence and mapping types. * reserved word: Keywords. * restricted execution: Code blocks. * return <1>: try statement. * return: return statement. * reverse quotes <1>: String conversions. * reverse quotes: Basic customization. * reverse(): Emulating sequence and mapping types. * sequence item: Subscriptions. * shifting operation: Shifting operations. * simple statement: Simple statements. * singleton tuple: standard type hierarchy. * slice: Slicings. * slicing <1>: Slicings. * slicing: standard type hierarchy. * slicing assignment: Assignment statements. * sort(): Emulating sequence and mapping types. * space: Indentation. * special attribute: standard type hierarchy. * stack trace: standard type hierarchy. * Standard C: String literals. * standard input: Complete Python programs. * standard output <1>: print statement. * standard output: Expression statements. * start <1>: Slicings. * start: standard type hierarchy. * statement grouping: Indentation. * statement!assignment, augmented: Augmented Assignment statements. * stderr: standard type hierarchy. * stdin: standard type hierarchy. * stdio: standard type hierarchy. * stdout <1>: print statement. * stdout: standard type hierarchy. * step <1>: Slicings. * step: standard type hierarchy. * stop <1>: Slicings. * stop: standard type hierarchy. * string comparison: standard type hierarchy. * string conversion <1>: Expression statements. * string conversion <2>: String conversions. * string conversion: Basic customization. * string item: Subscriptions. * string literal: String literals. * string!Unicode: String literals. * subscription <1>: Subscriptions. * subscription: standard type hierarchy. * subscription assignment: Assignment statements. * subtraction: Binary arithmetic operations. * suite: Compound statements. * syntax <1>: Expressions. * syntax: Notation. * sys.exc_info: standard type hierarchy. * sys.exc_traceback: standard type hierarchy. * sys.last_traceback: standard type hierarchy. * sys.modules: import statement. * sys.stderr: standard type hierarchy. * sys.stdin: standard type hierarchy. * sys.stdout: standard type hierarchy. * SystemExit: Exceptions. * tab: Indentation. * target: Assignment statements. * target list <1>: for statement. * target list: Assignment statements. * target list assignment: Assignment statements. * tb_frame: standard type hierarchy. * tb_lasti: standard type hierarchy. * tb_lineno: standard type hierarchy. * tb_next: standard type hierarchy. * termination model: Exceptions. * token: Lexical analysis. * trailing comma <1>: print statement. * trailing comma: Expression lists. * triple-quoted string: String literals. * try <1>: try statement. * try: standard type hierarchy. * tuple display: Parenthesized forms. * type: standard type hierarchy. * type hierarchy: standard type hierarchy. * type of an object: Objects. * types, internal: standard type hierarchy. * unary arithmetic operation: Unary arithmetic operations. * unary bit-wise operation: Unary arithmetic operations. * unbinding name <1>: del statement. * unbinding name: Code blocks. * Unicode: standard type hierarchy. * Unicode Consortium: String literals. * UNIX: Complete Python programs. * unreachable object: Objects. * unrecognized escape sequence: String literals. * update(): Emulating sequence and mapping types. * user-defined function: standard type hierarchy. * user-defined function call: Calls. * user-defined method: standard type hierarchy. * user-defined module: import statement. * value of an object: Objects. * values(): Emulating sequence and mapping types. * while <1>: while statement. * while <2>: continue statement. * while: break statement. * whitespace: Indentation. * writing values <1>: print statement. * writing values: Expression statements.