python.def

是一个很好的编辑器

;
[codeop.compile_command |G  Compile a command and determine whether it is incomplete.]
codeop.compile_command(|source, filename="<input>", symbol="single") 
;
[coerce |G -> None or (x1, y1)]
coerce(|x, y) 
;
[colorsys._v |G ]
colorsys._v(|m1, m2, hue)
;
[colorsys.hls_to_rgb |G ]
colorsys.hls_to_rgb(|h, l, s)
;
[colorsys.hsv_to_rgb |G ]
colorsys.hsv_to_rgb(|h, s, v)
;
[colorsys.rgb_to_hls |G ]
colorsys.rgb_to_hls(|r, g, b)
;
[colorsys.rgb_to_hsv |G ]
colorsys.rgb_to_hsv(|r, g, b)
;
[colorsys.rgb_to_yiq |G ]
colorsys.rgb_to_yiq(|r, g, b)
;
[colorsys.yiq_to_rgb |G ]
colorsys.yiq_to_rgb(|y, i, q)
;
[commands.getoutput |G  Return output (stdout or stderr) of executing cmd in a shell.]
commands.getoutput(|cmd) 
;
[commands.getstatus |G  Return output of "ls -ld <file>" in a string.]
commands.getstatus(|file) 
;
[commands.getstatusoutput |G  Return (status, output) of executing cmd in a shell.]
commands.getstatusoutput(|cmd) 
;
[commands.mk2arg |G ]
commands.mk2arg(|head, x)
;
[commands.mkarg |G ]
commands.mkarg(|x)
;
[compile |G -> code object]
compile(|source, filename, mode[, flags[, dont_inherit]]) 
;
[compileall.compile_dir |G  Byte-compile all modules in the given directory tree.]
compileall.compile_dir(|dir, maxlevels=10, ddir=None, force=0, rx=None) 
;
[compileall.compile_path |G  Byte-compile all module on sys.path.]
compileall.compile_path(|skip_curdir=1, maxlevels=0, force=0) 
;
[compileall.main |G  Script main program.]
compileall.main(|) 
;
[compiler.ast.Add |G ]
compiler.ast.Add(|(left, right))
;
[compiler.ast.And |G ]
compiler.ast.And(|nodes)
;
[compiler.ast.AssAttr |G ]
compiler.ast.AssAttr(|expr, attrname, flags)
;
[compiler.ast.AssList |G ]
compiler.ast.AssList(|nodes)
;
[compiler.ast.AssName |G ]
compiler.ast.AssName(|name, flags)
;
[compiler.ast.AssTuple |G ]
compiler.ast.AssTuple(|nodes)
;
[compiler.ast.Assert |G ]
compiler.ast.Assert(|test, fail)
;
[compiler.ast.Assign |G ]
compiler.ast.Assign(|nodes, expr)
;
[compiler.ast.AugAssign |G ]
compiler.ast.AugAssign(|node, op, expr)
;
[compiler.ast.Backquote |G ]
compiler.ast.Backquote(|expr)
;
[compiler.ast.Bitand |G ]
compiler.ast.Bitand(|nodes)
;
[compiler.ast.Bitor |G ]
compiler.ast.Bitor(|nodes)
;
[compiler.ast.Bitxor |G ]
compiler.ast.Bitxor(|nodes)
;
[compiler.ast.Break |G ]
compiler.ast.Break(|)
;
[compiler.ast.CallFunc |G ]
compiler.ast.CallFunc(|node, args, star_args = None, dstar_args = None)
;
[compiler.ast.Class |G ]
compiler.ast.Class(|name, bases, doc, code)
;
[compiler.ast.Compare |G ]
compiler.ast.Compare(|expr, ops)
;
[compiler.ast.Const |G ]
compiler.ast.Const(|value)
;
[compiler.ast.Continue |G ]
compiler.ast.Continue(|)
;
[compiler.ast.Dict |G ]
compiler.ast.Dict(|items)
;
[compiler.ast.Discard |G ]
compiler.ast.Discard(|expr)
;
[compiler.ast.Div |G ]
compiler.ast.Div(|(left, right))
;
[compiler.ast.Ellipsis |G ]
compiler.ast.Ellipsis(|)
;
[compiler.ast.EmptyNode |G {class}]
compiler.ast.EmptyNode(|) 
;
[compiler.ast.Exec |G ]
compiler.ast.Exec(|expr, locals, globals)
;
[compiler.ast.Expression |G ]
compiler.ast.Expression(|node)
;
[compiler.ast.FloorDiv |G ]
compiler.ast.FloorDiv(|(left, right))
;
[compiler.ast.For |G ]
compiler.ast.For(|assign, list, body, else_)
;
[compiler.ast.From |G ]
compiler.ast.From(|modname, names)
;
[compiler.ast.Function |G ]
compiler.ast.Function(|name, argnames, defaults, flags, doc, code)
;
[compiler.ast.Getattr |G ]
compiler.ast.Getattr(|expr, attrname)
;
[compiler.ast.Global |G ]
compiler.ast.Global(|names)
;
[compiler.ast.If |G ]
compiler.ast.If(|tests, else_)
;
[compiler.ast.Import |G ]
compiler.ast.Import(|names)
;
[compiler.ast.Invert |G ]
compiler.ast.Invert(|expr)
;
[compiler.ast.Keyword |G ]
compiler.ast.Keyword(|name, expr)
;
[compiler.ast.Lambda |G ]
compiler.ast.Lambda(|argnames, defaults, flags, code)
;
[compiler.ast.LeftShift |G ]
compiler.ast.LeftShift(|(left, right))
;
[compiler.ast.List |G ]
compiler.ast.List(|nodes)
;
[compiler.ast.ListComp |G ]
compiler.ast.ListComp(|expr, quals)
;
[compiler.ast.ListCompFor |G ]
compiler.ast.ListCompFor(|assign, list, ifs)
;
[compiler.ast.ListCompIf |G ]
compiler.ast.ListCompIf(|test)
;
[compiler.ast.Mod |G ]
compiler.ast.Mod(|(left, right))
;
[compiler.ast.Module |G ]
compiler.ast.Module(|doc, node)
;
[compiler.ast.Mul |G ]
compiler.ast.Mul(|(left, right))
;
[compiler.ast.Name |G ]
compiler.ast.Name(|name)
;
[compiler.ast.Node |G {class}]
compiler.ast.Node(|) 
;
[compiler.ast.Not |G ]
compiler.ast.Not(|expr)
;
[compiler.ast.Or |G ]
compiler.ast.Or(|nodes)
;
[compiler.ast.Pass |G ]
compiler.ast.Pass(|)
;
[compiler.ast.Power |G ]
compiler.ast.Power(|(left, right))
;
[compiler.ast.Print |G ]
compiler.ast.Print(|nodes, dest)
;
[compiler.ast.Printnl |G ]
compiler.ast.Printnl(|nodes, dest)
;
[compiler.ast.Raise |G ]
compiler.ast.Raise(|expr1, expr2, expr3)
;
[compiler.ast.Return |G ]
compiler.ast.Return(|value)
;
[compiler.ast.RightShift |G ]
compiler.ast.RightShift(|(left, right))
;
[compiler.ast.Slice |G ]
compiler.ast.Slice(|expr, flags, lower, upper)
;
[compiler.ast.Sliceobj |G ]
compiler.ast.Sliceobj(|nodes)
;
[compiler.ast.Stmt |G ]
compiler.ast.Stmt(|nodes)
;
[compiler.ast.Sub |G ]
compiler.ast.Sub(|(left, right))
;
[compiler.ast.Subscript |G ]
compiler.ast.Subscript(|expr, flags, subs)
;
[compiler.ast.TryExcept |G ]
compiler.ast.TryExcept(|body, handlers, else_)
;
[compiler.ast.TryFinally |G ]
compiler.ast.TryFinally(|body, final)
;
[compiler.ast.Tuple |G ]
compiler.ast.Tuple(|nodes)
;
[compiler.ast.UnaryAdd |G ]
compiler.ast.UnaryAdd(|expr)
;
[compiler.ast.UnarySub |G ]
compiler.ast.UnarySub(|expr)
;
[compiler.ast.While |G ]
compiler.ast.While(|test, body, else_)
;
[compiler.ast.Yield |G ]
compiler.ast.Yield(|value)
;
[compiler.ast.asList |G ]
compiler.ast.asList(|nodes)
;
[compiler.ast.flatten |G ]
compiler.ast.flatten(|list)
;
[compiler.ast.flatten_nodes |G ]
compiler.ast.flatten_nodes(|list)
;
[compiler.compile |G  Replacement for builtin compile() function]
compiler.compile(|) 
;
[compiler.compileFile |G {function}]
compiler.compileFile(|) 
;
[compiler.future.BadFutureParser |G  Check for invalid future statements]
compiler.future.BadFutureParser(|) 
;
[compiler.future.FutureParser |G {class}]
compiler.future.FutureParser(|) 
;
[compiler.future.find_futures |G ]
compiler.future.find_futures(|node)
;
[compiler.future.is_future |G  Return true if statement is a well-formed future statement]
compiler.future.is_future(|stmt) 
;
[compiler.future.walk |G {function}]
compiler.future.walk(|) 
;
[compiler.misc.Set |G {class}]
compiler.misc.Set(|) 
;
[compiler.misc.Stack |G {class}]
compiler.misc.Stack(|) 
;
[compiler.misc.flatten |G ]
compiler.misc.flatten(|tup)
;
[compiler.misc.mangle |G ]
compiler.misc.mangle(|name, klass)
;
[compiler.misc.set_filename |G  Set the filename attribute to filename on every node in tree]
compiler.misc.set_filename(|filename, tree) 
;
[compiler.parse |G {function}]
compiler.parse(|) 
;
[compiler.parseFile |G {function}]
compiler.parseFile(|) 
;
[compiler.pyassem.Block |G A flow graph representation for Python bytecode]
compiler.pyassem.Block(|label='')
;
[compiler.pyassem.FlowGraph |G {class}]
compiler.pyassem.FlowGraph(|) 
;
[compiler.pyassem.LineAddrTable |G  lnotab]
compiler.pyassem.LineAddrTable(|) 
;
[compiler.pyassem.PyFlowGraph |G A flow graph representation for Python bytecode]
compiler.pyassem.PyFlowGraph(|name, filename, args=(), optimized=0, klass=None)
;
[compiler.pyassem.StackDepthTracker |G {class}]
compiler.pyassem.StackDepthTracker(|) 
;
[compiler.pyassem.TupleArg |G  Helper for marking func defs with nested tuples in arglist]
compiler.pyassem.TupleArg(|count, names) 
;
[compiler.pyassem.dfs_postorder |G  Depth-first search of tree rooted at b, return in postorder]
compiler.pyassem.dfs_postorder(|b, seen) 
;
[compiler.pyassem.getArgCount |G A flow graph representation for Python bytecode]
compiler.pyassem.getArgCount(|args)
;
[compiler.pyassem.isJump |G A flow graph representation for Python bytecode]
compiler.pyassem.isJump(|opname)
;
[compiler.pyassem.twobyte |G  Convert an int argument into high and low bytes]
compiler.pyassem.twobyte(|val) 
;
[compiler.pyassem.xxx_sort |G A flow graph representation for Python bytecode]
compiler.pyassem.xxx_sort(|l)
;
[compiler.pycodegen.AbstractClassCode |G ]
compiler.pycodegen.AbstractClassCode(|klass, scopes, module)
;
[compiler.pycodegen.AbstractCompileMode |G ]
compiler.pycodegen.AbstractCompileMode(|source, filename)
;
[compiler.pycodegen.AbstractFunctionCode |G ]
compiler.pycodegen.AbstractFunctionCode(|func, scopes, isLambda, class_name, mod)
;
[compiler.pycodegen.AugGetattr |G {class}]
compiler.pycodegen.AugGetattr(|) 
;
[compiler.pycodegen.AugName |G {class}]
compiler.pycodegen.AugName(|) 
;
[compiler.pycodegen.AugSlice |G {class}]
compiler.pycodegen.AugSlice(|) 
;
[compiler.pycodegen.AugSubscript |G {class}]
compiler.pycodegen.AugSubscript(|) 
;
[compiler.pycodegen.BlockStack |G {class}]
compiler.pycodegen.BlockStack(|) 
;
[compiler.pycodegen.ClassCodeGenerator |G ]
compiler.pycodegen.ClassCodeGenerator(|klass, scopes, module)
;
[compiler.pycodegen.CodeGenerator |G  Defines basic code generator for Python bytecode]
compiler.pycodegen.CodeGenerator(|) 
;
[compiler.pycodegen.Delegator |G  Base class to support delegation for augmented assignment nodes]
compiler.pycodegen.Delegator(|obj) 
;
[compiler.pycodegen.Expression |G {class}]
compiler.pycodegen.Expression(|) 
;
[compiler.pycodegen.ExpressionCodeGenerator |G ]
compiler.pycodegen.ExpressionCodeGenerator(|tree)
;
[compiler.pycodegen.FunctionCodeGenerator |G ]
compiler.pycodegen.FunctionCodeGenerator(|func, scopes, isLambda, class_name, mod)
;
[compiler.pycodegen.Interactive |G {class}]
compiler.pycodegen.Interactive(|) 
;
[compiler.pycodegen.InteractiveCodeGenerator |G ]
compiler.pycodegen.InteractiveCodeGenerator(|tree)
;
[compiler.pycodegen.LocalNameFinder |G  Find local names in scope]
compiler.pycodegen.LocalNameFinder(|names=()) 
;
[compiler.pycodegen.Module |G {class}]
compiler.pycodegen.Module(|) 
;
[compiler.pycodegen.ModuleCodeGenerator |G ]
compiler.pycodegen.ModuleCodeGenerator(|tree)
;
[compiler.pycodegen.NestedScopeMixin |G  Defines initClass() for nested scoping (Python 2.2-compatible)]
compiler.pycodegen.NestedScopeMixin(|) 
;
[compiler.pycodegen.OpFinder |G {class}]
compiler.pycodegen.OpFinder(|) 
;
[compiler.pycodegen.StringIO |G -- Return a StringIO-like stream for reading or writing]
compiler.pycodegen.StringIO(|[s]) 
;
[compiler.pycodegen.TupleArg |G  Helper for marking func defs with nested tuples in arglist]
compiler.pycodegen.TupleArg(|) 
;
[compiler.pycodegen.compile |G  Replacement for builtin compile() function]
compiler.pycodegen.compile(|source, filename, mode, flags=None, dont_inherit=None) 
;
[compiler.pycodegen.compileFile |G ]
compiler.pycodegen.compileFile(|filename, display=0)
;
[compiler.pycodegen.findOp |G  Find the op (DELETE, LOAD, STORE) in an AssTuple tree]
compiler.pycodegen.findOp(|node) 
;
[compiler.pycodegen.generateArgList |G  Generate an arg list marking TupleArgs]
compiler.pycodegen.generateArgList(|arglist) 
;
[compiler.pycodegen.is_constant_false |G ]
compiler.pycodegen.is_constant_false(|node)
;
[compiler.pycodegen.parse |G {function}]
compiler.pycodegen.parse(|) 
;
[compiler.pycodegen.walk |G {function}]
compiler.pycodegen.walk(|) 
;
[compiler.pycodegen.wrap_aug |G ]
compiler.pycodegen.wrap_aug(|node)
;
[compiler.symbols.ClassScope |G Module symbol-table generator]
compiler.symbols.ClassScope(|name, module)
;
[compiler.symbols.FunctionScope |G {class}]
compiler.symbols.FunctionScope(|) 
;
[compiler.symbols.LambdaScope |G Module symbol-table generator]
compiler.symbols.LambdaScope(|module, klass=None)
;
[compiler.symbols.ModuleScope |G {class}]
compiler.symbols.ModuleScope(|) 
;