python.def

是一个很好的编辑器

[compiler.symbols.Scope |G Module symbol-table generator]
compiler.symbols.Scope(|name, module, klass=None)
;
[compiler.symbols.SymbolVisitor |G {class}]
compiler.symbols.SymbolVisitor(|) 
;
[compiler.symbols.list_eq |G Module symbol-table generator]
compiler.symbols.list_eq(|l1, l2)
;
[compiler.symbols.mangle |G {function}]
compiler.symbols.mangle(|) 
;
[compiler.symbols.sort |G Module symbol-table generator]
compiler.symbols.sort(|l)
;
[compiler.syntax.SyntaxErrorChecker |G  A visitor to find syntax errors in the AST.]
compiler.syntax.SyntaxErrorChecker(|multi=None) 
;
[compiler.syntax.check |G ]
compiler.syntax.check(|tree, multi=None)
;
[compiler.syntax.walk |G {function}]
compiler.syntax.walk(|) 
;
[compiler.transformer.Add |G {class}]
compiler.transformer.Add(|) 
;
[compiler.transformer.And |G {class}]
compiler.transformer.And(|) 
;
[compiler.transformer.AssAttr |G {class}]
compiler.transformer.AssAttr(|) 
;
[compiler.transformer.AssList |G {class}]
compiler.transformer.AssList(|) 
;
[compiler.transformer.AssName |G {class}]
compiler.transformer.AssName(|) 
;
[compiler.transformer.AssTuple |G {class}]
compiler.transformer.AssTuple(|) 
;
[compiler.transformer.Assert |G {class}]
compiler.transformer.Assert(|) 
;
[compiler.transformer.Assign |G {class}]
compiler.transformer.Assign(|) 
;
[compiler.transformer.AugAssign |G {class}]
compiler.transformer.AugAssign(|) 
;
[compiler.transformer.Backquote |G {class}]
compiler.transformer.Backquote(|) 
;
[compiler.transformer.Bitand |G {class}]
compiler.transformer.Bitand(|) 
;
[compiler.transformer.Bitor |G {class}]
compiler.transformer.Bitor(|) 
;
[compiler.transformer.Bitxor |G {class}]
compiler.transformer.Bitxor(|) 
;
[compiler.transformer.Break |G {class}]
compiler.transformer.Break(|) 
;
[compiler.transformer.CallFunc |G {class}]
compiler.transformer.CallFunc(|) 
;
[compiler.transformer.Class |G {class}]
compiler.transformer.Class(|) 
;
[compiler.transformer.Compare |G {class}]
compiler.transformer.Compare(|) 
;
[compiler.transformer.Const |G {class}]
compiler.transformer.Const(|) 
;
[compiler.transformer.Continue |G {class}]
compiler.transformer.Continue(|) 
;
[compiler.transformer.Dict |G {class}]
compiler.transformer.Dict(|) 
;
[compiler.transformer.Discard |G {class}]
compiler.transformer.Discard(|) 
;
[compiler.transformer.Div |G {class}]
compiler.transformer.Div(|) 
;
[compiler.transformer.Ellipsis |G {class}]
compiler.transformer.Ellipsis(|) 
;
[compiler.transformer.EmptyNode |G {class}]
compiler.transformer.EmptyNode(|) 
;
[compiler.transformer.Exec |G {class}]
compiler.transformer.Exec(|) 
;
[compiler.transformer.Expression |G {class}]
compiler.transformer.Expression(|) 
;
[compiler.transformer.FloorDiv |G {class}]
compiler.transformer.FloorDiv(|) 
;
[compiler.transformer.For |G {class}]
compiler.transformer.For(|) 
;
[compiler.transformer.From |G {class}]
compiler.transformer.From(|) 
;
[compiler.transformer.Function |G {class}]
compiler.transformer.Function(|) 
;
[compiler.transformer.Getattr |G {class}]
compiler.transformer.Getattr(|) 
;
[compiler.transformer.Global |G {class}]
compiler.transformer.Global(|) 
;
[compiler.transformer.If |G {class}]
compiler.transformer.If(|) 
;
[compiler.transformer.Import |G {class}]
compiler.transformer.Import(|) 
;
[compiler.transformer.Invert |G {class}]
compiler.transformer.Invert(|) 
;
[compiler.transformer.Keyword |G {class}]
compiler.transformer.Keyword(|) 
;
[compiler.transformer.Lambda |G {class}]
compiler.transformer.Lambda(|) 
;
[compiler.transformer.LeftShift |G {class}]
compiler.transformer.LeftShift(|) 
;
[compiler.transformer.List |G {class}]
compiler.transformer.List(|) 
;
[compiler.transformer.ListComp |G {class}]
compiler.transformer.ListComp(|) 
;
[compiler.transformer.ListCompFor |G {class}]
compiler.transformer.ListCompFor(|) 
;
[compiler.transformer.ListCompIf |G {class}]
compiler.transformer.ListCompIf(|) 
;
[compiler.transformer.Mod |G {class}]
compiler.transformer.Mod(|) 
;
[compiler.transformer.Module |G {class}]
compiler.transformer.Module(|) 
;
[compiler.transformer.Mul |G {class}]
compiler.transformer.Mul(|) 
;
[compiler.transformer.Name |G {class}]
compiler.transformer.Name(|) 
;
[compiler.transformer.Node |G ]
compiler.transformer.Node(|*args)
;
[compiler.transformer.Not |G {class}]
compiler.transformer.Not(|) 
;
[compiler.transformer.Or |G {class}]
compiler.transformer.Or(|) 
;
[compiler.transformer.Pass |G {class}]
compiler.transformer.Pass(|) 
;
[compiler.transformer.Power |G {class}]
compiler.transformer.Power(|) 
;
[compiler.transformer.Print |G {class}]
compiler.transformer.Print(|) 
;
[compiler.transformer.Printnl |G {class}]
compiler.transformer.Printnl(|) 
;
[compiler.transformer.Raise |G {class}]
compiler.transformer.Raise(|) 
;
[compiler.transformer.Return |G {class}]
compiler.transformer.Return(|) 
;
[compiler.transformer.RightShift |G {class}]
compiler.transformer.RightShift(|) 
;
[compiler.transformer.Slice |G {class}]
compiler.transformer.Slice(|) 
;
[compiler.transformer.Sliceobj |G {class}]
compiler.transformer.Sliceobj(|) 
;
[compiler.transformer.Stmt |G {class}]
compiler.transformer.Stmt(|) 
;
[compiler.transformer.Sub |G {class}]
compiler.transformer.Sub(|) 
;
[compiler.transformer.Subscript |G {class}]
compiler.transformer.Subscript(|) 
;
[compiler.transformer.Transformer |G  Utility object for transforming Python parse trees.]
compiler.transformer.Transformer(|) 
;
[compiler.transformer.TryExcept |G {class}]
compiler.transformer.TryExcept(|) 
;
[compiler.transformer.TryFinally |G {class}]
compiler.transformer.TryFinally(|) 
;
[compiler.transformer.Tuple |G {class}]
compiler.transformer.Tuple(|) 
;
[compiler.transformer.UnaryAdd |G {class}]
compiler.transformer.UnaryAdd(|) 
;
[compiler.transformer.UnarySub |G {class}]
compiler.transformer.UnarySub(|) 
;
[compiler.transformer.While |G {class}]
compiler.transformer.While(|) 
;
[compiler.transformer.Yield |G {class}]
compiler.transformer.Yield(|) 
;
[compiler.transformer.asList |G ]
compiler.transformer.asList(|nodes)
;
[compiler.transformer.debug_tree |G ]
compiler.transformer.debug_tree(|tree)
;
[compiler.transformer.flatten |G {function}]
compiler.transformer.flatten(|) 
;
[compiler.transformer.flatten_nodes |G {function}]
compiler.transformer.flatten_nodes(|) 
;
[compiler.transformer.parse |G ]
compiler.transformer.parse(|buf, mode="exec")
;
[compiler.transformer.parseFile |G ]
compiler.transformer.parseFile(|path)
;
[compiler.visitor.ASTVisitor |G  Performs a depth-first walk of the AST]
compiler.visitor.ASTVisitor(|) 
;
[compiler.visitor.ExampleASTVisitor |G  Prints examples of the nodes that aren't visited]
compiler.visitor.ExampleASTVisitor(|) 
;
[compiler.visitor._walker |G  Performs a depth-first walk of the AST]
compiler.visitor._walker(|) 
;
[compiler.visitor.dumpNode |G ]
compiler.visitor.dumpNode(|node)
;
[compiler.visitor.walk |G ]
compiler.visitor.walk(|tree, visitor, walker=None, verbose=None)
;
[compiler.walk |G {function}]
compiler.walk(|) 
;
[complex |G -> complex number]
complex(|real[, imag]) 
;
[copy.Error |G {class}]
copy.Error(|) 
;
[copy._EmptyClass |G {class}]
copy._EmptyClass(|) 
;
[copy._copy_atomic |G ]
copy._copy_atomic(|x)
;
[copy._copy_dict |G ]
copy._copy_dict(|x)
;
[copy._copy_inst |G ]
copy._copy_inst(|x)
;
[copy._copy_list |G ]
copy._copy_list(|x)
;
[copy._copy_tuple |G ]
copy._copy_tuple(|x)
;
[copy._deepcopy_atomic |G ]
copy._deepcopy_atomic(|x, memo)
;
[copy._deepcopy_dict |G ]
copy._deepcopy_dict(|x, memo)
;
[copy._deepcopy_inst |G ]
copy._deepcopy_inst(|x, memo)
;
[copy._deepcopy_list |G ]
copy._deepcopy_list(|x, memo)
;
[copy._deepcopy_tuple |G ]
copy._deepcopy_tuple(|x, memo)
;
[copy._keep_alive |G  Keeps a reference to the object x in the memo.]
copy._keep_alive(|x, memo) 
;
[copy._reconstruct |G ]
copy._reconstruct(|x, info, deep, memo=None)
;
[copy._test |G ]
copy._test(|)
;
[copy.copy |G  Shallow copy operation on arbitrary Python objects.]
copy.copy(|x) 
;
[copy.deepcopy |G  Deep copy operation on arbitrary Python objects.]
copy.deepcopy(|x, memo = None) 
;
[copy.error |G {class}]
copy.error(|) 
;
[copy_reg._reconstructor |G ]
copy_reg._reconstructor(|cls, base, state)
;
[copy_reg._reduce |G ]
copy_reg._reduce(|self)
;
[copy_reg.constructor |G ]
copy_reg.constructor(|object)
;
[copy_reg.pickle |G ]
copy_reg.pickle(|ob_type, pickle_function, constructor_ob=None)
;
[copy_reg.pickle_complex |G ]
copy_reg.pickle_complex(|c)
;
[dbhash.error |G {class}]
dbhash.error(|) 
;
[dbhash.open |G ]
dbhash.open(|file, flag = 'r', mode=0666)
;
[delattr |G ]
delattr(|object, name)
;
[dict |G -> new empty dictionary.]
dict(|) 
;
[difflib.Differ |G  ]
difflib.Differ(|linejunk=None, charjunk=None) 
;
[difflib.IS_CHARACTER_JUNK |G  ]
difflib.IS_CHARACTER_JUNK(|ch, ws=" \t") 
;
[difflib.IS_LINE_JUNK |G  ]
difflib.IS_LINE_JUNK(|line, pat=re.compile(r"\s*#?\s*$").match) 
;
[difflib.SequenceMatcher |G  ]
difflib.SequenceMatcher(|isjunk=None, a='', b='') 
;
[difflib._count_leading |G  ]
difflib._count_leading(|line, ch) 
;
[difflib._test |G ]
difflib._test(|)
;
[difflib.get_close_matches |G  Use SequenceMatcher to return list of the best "good enough" matches.]
difflib.get_close_matches(|word, possibilities, n=3, cutoff=0.6) 
;
[difflib.ndiff |G  ]
difflib.ndiff(|a, b, linejunk=IS_LINE_JUNK, charjunk=IS_CHARACTER_JUNK) 
;
[difflib.restore |G  ]
difflib.restore(|delta, which) 
;
[dir |G -> list of strings]
dir(|[object]) 
;
[dircache.annotate |G  Add '/' suffixes to directories.]
dircache.annotate(|head, list) 
;
[dircache.listdir |G  List directory contents, using cache.]
dircache.listdir(|path) 
;
[dircache.opendir |G  List directory contents, using cache.]
dircache.opendir(|) 
;
[dircache.reset |G  Reset the cache completely.]
dircache.reset(|) 
;
[dis._test |G  Simple test program to disassemble a file.]
dis._test(|) 
;
[dis.def_op |G ]
dis.def_op(|name, op)
;
[dis.dis |G  Disassemble classes, methods, functions, or code.]
dis.dis(|x=None) 
;
[dis.disassemble |G  Disassemble a code object.]
dis.disassemble(|co, lasti=-1) 
;
[dis.disco |G  Disassemble a code object.]
dis.disco(|) 
;
[dis.distb |G  Disassemble a traceback (default: last traceback).]
dis.distb(|tb=None) 
;
[dis.findlabels |G  Detect all offsets in a byte code which are jump targets.]
dis.findlabels(|code) 
;
[dis.jabs_op |G ]
dis.jabs_op(|name, op)
;
[dis.jrel_op |G ]
dis.jrel_op(|name, op)
;
[dis.name_op |G ]
dis.name_op(|name, op)
;
[divmod |G -> (div, mod)]
divmod(|x, y) 
;
[doctest.Tester |G  Class Tester -- runs docstring examples and accumulates stats.]
doctest.Tester(|) 
;
[doctest._SpoofOut |G {class}]
doctest._SpoofOut(|) 
;
[doctest._TestClass |G  ]
doctest._TestClass(|val) 
;
[doctest._classify_class_attrs |G  Return list of attribute-descriptor tuples.]
doctest._classify_class_attrs(|) 
;
[doctest._extract_examples |G ]
doctest._extract_examples(|s)
;
[doctest._extract_future_flags |G ]
doctest._extract_future_flags(|globs)
;
[doctest._from_module |G ]
doctest._from_module(|module, object)
;
[doctest._isclass |G  Return true if the object is a class.]