python.def

是一个很好的编辑器

base64.test1(|)
;
[bdb.Bdb |G  Generic Python debugger base class.]
bdb.Bdb(|) 
;
[bdb.Breakpoint |G  Breakpoint class]
bdb.Breakpoint(|file, line, temporary=0, cond = None) 
;
[bdb.Tdb |G {class}]
bdb.Tdb(|) 
;
[bdb.bar |G ]
bdb.bar(|a)
;
[bdb.effective |G  Determine which breakpoint for this file:line is to be acted upon.]
bdb.effective(|file, line, frame) 
;
[bdb.foo |G ]
bdb.foo(|n)
;
[bdb.set_trace |G ]
bdb.set_trace(|)
;
[bdb.test |G ]
bdb.test(|)
;
[binascii.Error |G {class}]
binascii.Error(|) 
;
[binascii.Incomplete |G {class}]
binascii.Incomplete(|) 
;
[binascii.a2b_hex |G -> s; Binary data of hexadecimal representation.]
binascii.a2b_hex(|hexstr) 
;
[binascii.b2a_hex |G -> s; Hexadecimal representation of binary data.]
binascii.b2a_hex(|data) 
;
[binascii.b2a_qp |G -> s;]
binascii.b2a_qp(|data, quotetabs=0, istext=1, header=0) 
;
[binhex.BinHex |G ]
binhex.BinHex(|(name, finfo, dlen, rlen), ofp)
;
[binhex.Error |G {class}]
binhex.Error(|) 
;
[binhex.FInfo |G {class}]
binhex.FInfo(|) 
;
[binhex.HexBin |G ]
binhex.HexBin(|ifp)
;
[binhex._Hqxcoderengine |G  Write data to the coder in 3-byte chunks]
binhex._Hqxcoderengine(|ofp) 
;
[binhex._Hqxdecoderengine |G  Read data via the decoder in 4-byte chunks]
binhex._Hqxdecoderengine(|ifp) 
;
[binhex._Rlecoderengine |G  Write data to the RLE-coder in suitably large chunks]
binhex._Rlecoderengine(|ofp) 
;
[binhex._Rledecoderengine |G  Read data via the RLE-coder]
binhex._Rledecoderengine(|ifp) 
;
[binhex._test |G ]
binhex._test(|)
;
[binhex.binhex |G  (infilename, outfilename) - Create binhex-encoded copy of a file]
binhex.binhex(|inp, out) 
;
[binhex.getfileinfo |G {function}]
binhex.getfileinfo(|) 
;
[binhex.hexbin |G  (infilename, outfilename) - Decode binhexed file]
binhex.hexbin(|inp, out) 
;
[binhex.openrsrc |G {class}]
binhex.openrsrc(|) 
;
[bisect.bisect |G  Return the index where to insert item x in list a, assuming a is sorted.]
bisect.bisect(|) 
;
[bisect.bisect_left |G  Return the index where to insert item x in list a, assuming a is sorted.]
bisect.bisect_left(|a, x, lo=0, hi=None) 
;
[bisect.bisect_right |G  Return the index where to insert item x in list a, assuming a is sorted.]
bisect.bisect_right(|a, x, lo=0, hi=None) 
;
[bisect.insort |G  Insert item x in list a, and keep it sorted assuming a is sorted.]
bisect.insort(|) 
;
[bisect.insort_left |G  Insert item x in list a, and keep it sorted assuming a is sorted.]
bisect.insort_left(|a, x, lo=0, hi=None) 
;
[bisect.insort_right |G  Insert item x in list a, and keep it sorted assuming a is sorted.]
bisect.insort_right(|a, x, lo=0, hi=None) 
;
[bool |G -> integer]
bool(|x) 
;
[bsddb.error |G {class}]
bsddb.error(|) 
;
[buffer |G -> object]
buffer(|object [, offset[, size]]) 
;
[cPickle.PickleError |G {class}]
cPickle.PickleError(|) 
;
[cPickle.Pickler |G -- Create a pickler]
cPickle.Pickler(|file, [binary]) 
;
[cPickle.PicklingError |G {class}]
cPickle.PicklingError(|) 
;
[cPickle.UnpickleableError |G {class}]
cPickle.UnpickleableError(|) 
;
[cPickle.Unpickler |G -- Create an unpickler]
cPickle.Unpickler(|file) 
;
[cPickle.UnpicklingError |G {class}]
cPickle.UnpicklingError(|) 
;
[cPickle.dump |G --Write an object in pickle format to the given file]
cPickle.dump(|object, file, [binary]) 
;
[cPickle.dumps |G --Return a string containing an object in pickle format]
cPickle.dumps(|object, [binary]) 
;
[cPickle.load |G -- Load a pickle from the given file]
cPickle.load(|file) 
;
[cPickle.loads |G -- Load a pickle from the given string]
cPickle.loads(|string) 
;
[cStringIO.StringIO |G -- Return a StringIO-like stream for reading or writing]
cStringIO.StringIO(|[s]) 
;
[calendar._center |G  Center a string in a field.]
calendar._center(|str, width) 
;
[calendar._indexer |G {class}]
calendar._indexer(|) 
;
[calendar._localized_day |G ]
calendar._localized_day(|format)
;
[calendar._localized_month |G ]
calendar._localized_month(|format)
;
[calendar.calendar |G  Returns a year's calendar as a multi-line string.]
calendar.calendar(|year, w=0, l=0, c=_spacing) 
;
[calendar.error |G  Inappropriate argument value (of correct type).]
calendar.error(|) 
;
[calendar.firstweekday |G ]
calendar.firstweekday(|)
;
[calendar.format3c |G  Prints 3-column formatting for year calendars]
calendar.format3c(|a, b, c, colwidth=_colwidth, spacing=_spacing) 
;
[calendar.format3cstring |G  Returns a string formatted from 3 strings, centered within 3 columns.]
calendar.format3cstring(|a, b, c, colwidth=_colwidth, spacing=_spacing) 
;
[calendar.isleap |G  Return 1 for leap years, 0 for non-leap years.]
calendar.isleap(|year) 
;
[calendar.leapdays |G  Return number of leap years in range {y1, y2).]
calendar.leapdays(|y1, y2) 
;
[calendar.localtime |G -> (tm_year,tm_mon,tm_day,tm_hour,tm_min,tm_sec,tm_wday,tm_yday,tm_isdst)]
calendar.localtime(|[seconds]) 
;
[calendar.mktime |G -> floating point number]
calendar.mktime(|tuple) 
;
[calendar.month |G  Return a month's calendar string (multi-line).]
calendar.month(|theyear, themonth, w=0, l=0) 
;
[calendar.monthcalendar |G  Return a matrix representing a month's calendar.]
calendar.monthcalendar(|year, month) 
;
[calendar.monthrange |G  Return weekday (0-6 ~ Mon-Sun) and number of days (28-31) for]
calendar.monthrange(|year, month) 
;
[calendar.prcal |G  Print a year's calendar.]
calendar.prcal(|year, w=0, l=0, c=_spacing) 
;
[calendar.prmonth |G  Print a month's calendar.]
calendar.prmonth(|theyear, themonth, w=0, l=0) 
;
[calendar.prweek |G  Print a single week (no newline).]
calendar.prweek(|theweek, width) 
;
[calendar.setfirstweekday |G  Set weekday (Monday=0, Sunday=6) to start each week.]
calendar.setfirstweekday(|weekday) 
;
[calendar.strftime |G -> string]
calendar.strftime(|format[, tuple]) 
;
[calendar.timegm |G  Unrelated but handy function to calculate Unix timestamp from GMT.]
calendar.timegm(|tuple) 
;
[calendar.week |G  Returns a single week in a string (no newline).]
calendar.week(|theweek, width) 
;
[calendar.weekday |G  Return weekday (0-6 ~ Mon-Sun) for year (1970-...), month (1-12),]
calendar.weekday(|year, month, day) 
;
[calendar.weekheader |G  Return a header for a week.]
calendar.weekheader(|width) 
;
[callable |G -> Boolean]
callable(|object) 
;
[cgi.FieldStorage |G  Store a sequence of fields, reading multipart/form-data.]
cgi.FieldStorage(|) 
;
[cgi.FormContent |G  This class is present for backwards compatibility only.]
cgi.FormContent(|) 
;
[cgi.FormContentDict |G  Form content as dictionary with a list of values per field.]
cgi.FormContentDict(|environ=os.environ) 
;
[cgi.InterpFormContentDict |G  This class is present for backwards compatibility only.]
cgi.InterpFormContentDict(|) 
;
[cgi.MiniFieldStorage |G  Like FieldStorage, for use when no file uploads are possible.]
cgi.MiniFieldStorage(|name, value) 
;
[cgi.StringIO |G  class StringIO({buffer})]
cgi.StringIO(|) 
;
[cgi.SvFormContentDict |G  Form content as dictionary expecting a single value per field.]
cgi.SvFormContentDict(|) 
;
[cgi.dolog |G  Write a log message to the log file.  See initlog() for docs.]
cgi.dolog(|fmt, *args) 
;
[cgi.escape |G  Replace special characters '&', '<' and '>' by SGML entities.]
cgi.escape(|s, quote=None) 
;
[cgi.initlog |G  Write a log message, if there is a log file.]
cgi.initlog(|*allargs) 
;
[cgi.log |G  Write a log message, if there is a log file.]
cgi.log(|) 
;
[cgi.nolog |G  Dummy function, assigned to log when logging is disabled.]
cgi.nolog(|*allargs) 
;
[cgi.parse |G  Parse a query in the environment or from a file (default stdin)]
cgi.parse(|fp=None, environ=os.environ, keep_blank_values=0, strict_parsing=0) 
;
[cgi.parse_header |G  Parse a Content-type like header.]
cgi.parse_header(|line) 
;
[cgi.parse_multipart |G  Parse multipart input.]
cgi.parse_multipart(|fp, pdict) 
;
[cgi.parse_qs |G  Parse a query given as a string argument.]
cgi.parse_qs(|qs, keep_blank_values=0, strict_parsing=0) 
;
[cgi.parse_qsl |G  Parse a query given as a string argument.]
cgi.parse_qsl(|qs, keep_blank_values=0, strict_parsing=0) 
;
[cgi.print_arguments |G ]
cgi.print_arguments(|)
;
[cgi.print_directory |G  Dump the current directory as HTML.]
cgi.print_directory(|) 
;
[cgi.print_environ |G  Dump the shell environment as HTML.]
cgi.print_environ(|environ=os.environ) 
;
[cgi.print_environ_usage |G  Dump a list of environment variables used by CGI as HTML.]
cgi.print_environ_usage(|) 
;
[cgi.print_exception |G ]
cgi.print_exception(|type=None, value=None, tb=None, limit=None)
;
[cgi.print_form |G  Dump the contents of a form as HTML.]
cgi.print_form(|form) 
;
[cgi.test |G  Robust test CGI script, usable as main program.]
cgi.test(|environ=os.environ) 
;
[cgi.valid_boundary |G ]
cgi.valid_boundary(|s, _vb_pattern="^[ -~]{0,200}[!-~]$")
;
[cgitb.Hook |G  A hook to replace sys.excepthook that shows tracebacks in HTML.]
cgitb.Hook(|display=1, logdir=None, context=5, file=None) 
;
[cgitb.enable |G  Install an exception handler that formats tracebacks as HTML.]
cgitb.enable(|display=1, logdir=None, context=5) 
;
[cgitb.grey |G ]
cgitb.grey(|text)
;
[cgitb.html |G  Return a nice HTML document describing a given traceback.]
cgitb.html(|(etype, evalue, etb), context=5) 
;
[cgitb.lookup |G  Find the value for a given name in the given environment.]
cgitb.lookup(|name, frame, locals) 
;
[cgitb.reset |G  Return a string that resets the CGI and browser to a known state.]
cgitb.reset(|) 
;
[cgitb.scanvars |G  Scan one logical line of Python and look up values of variables used.]
cgitb.scanvars(|reader, frame, locals) 
;
[cgitb.small |G ]
cgitb.small(|text)
;
[cgitb.strong |G ]
cgitb.strong(|text)
;
[chr |G -> character]
chr(|i) 
;
[chunk.Chunk |G ]
chunk.Chunk(|file, align = 1, bigendian = 1, inclheader = 0)
;
[classmethod |G -> method]
classmethod(|function) 
;
[cmath.acos |G Return the arc cosine of x.]
cmath.acos(|x)
;
[cmath.acosh |G Return the hyperbolic arccosine of x.]
cmath.acosh(|x)
;
[cmath.asin |G Return the arc sine of x.]
cmath.asin(|x)
;
[cmath.asinh |G Return the hyperbolic arc sine of x.]
cmath.asinh(|x)
;
[cmath.atan |G Return the arc tangent of x.]
cmath.atan(|x)
;
[cmath.atanh |G Return the hyperbolic arc tangent of x.]
cmath.atanh(|x)
;
[cmath.cos |G nReturn the cosine of x.]
cmath.cos(|x)
;
[cmath.cosh |G nReturn the hyperbolic cosine of x.]
cmath.cosh(|x)
;
[cmath.exp |G Return the exponential value e**x.]
cmath.exp(|x)
;
[cmath.log |G Return the natural logarithm of x.]
cmath.log(|x)
;
[cmath.log10 |G Return the base-10 logarithm of x.]
cmath.log10(|x)
;
[cmath.sin |G Return the sine of x.]
cmath.sin(|x)
;
[cmath.sinh |G Return the hyperbolic sine of x.]
cmath.sinh(|x)
;
[cmath.sqrt |G Return the square root of x.]
cmath.sqrt(|x)
;
[cmath.tan |G Return the tangent of x.]
cmath.tan(|x)
;
[cmath.tanh |G Return the hyperbolic tangent of x.]
cmath.tanh(|x)
;
[cmd.Cmd |G  A simple framework for writing line-oriented command interpreters.]
cmd.Cmd(|completekey='tab') 
;
[cmp |G -> integer]
cmp(|x, y) 
;
[code.CommandCompiler |G  Instances of this class have __call__ methods identical in]
code.CommandCompiler(|) 
;
[code.InteractiveConsole |G  Closely emulate the behavior of the interactive Python interpreter.]
code.InteractiveConsole(|locals=None, filename="<console>") 
;
[code.InteractiveInterpreter |G  Base class for InteractiveConsole.]
code.InteractiveInterpreter(|locals=None) 
;
[code.compile_command |G  Compile a command and determine whether it is incomplete.]
code.compile_command(|) 
;
[code.interact |G  Closely emulate the interactive Python interpreter.]
code.interact(|banner=None, readfunc=None, local=None) 
;
[code.softspace |G ]
code.softspace(|file, newvalue)
;
[codecs.Codec |G  Defines the interface for stateless encoders/decoders.]
codecs.Codec(|) 
;
[codecs.EncodedFile |G  Return a wrapped version of file which provides transparent]
codecs.EncodedFile(|file, data_encoding, file_encoding=None, errors='strict') 
;
[codecs.StreamReader |G ]
codecs.StreamReader(|stream, errors='strict')
;
[codecs.StreamReaderWriter |G  StreamReaderWriter instances allow wrapping streams which]
codecs.StreamReaderWriter(|stream, Reader, Writer, errors='strict') 
;
[codecs.StreamRecoder |G  StreamRecoder instances provide a frontend - backend]
codecs.StreamRecoder(|) 
;
[codecs.StreamWriter |G ]
codecs.StreamWriter(|stream, errors='strict')
;
[codecs.getdecoder |G  Lookup up the codec for the given encoding and return]
codecs.getdecoder(|encoding) 
;
[codecs.getencoder |G  Lookup up the codec for the given encoding and return]
codecs.getencoder(|encoding) 
;
[codecs.getreader |G  Lookup up the codec for the given encoding and return]
codecs.getreader(|encoding) 
;
[codecs.getwriter |G  Lookup up the codec for the given encoding and return]
codecs.getwriter(|encoding) 
;
[codecs.make_encoding_map |G  Creates an encoding map from a decoding map.]
codecs.make_encoding_map(|decoding_map) 
;
[codecs.make_identity_dict |G -> dict]
codecs.make_identity_dict(|rng) 
;
[codecs.open |G  Open an encoded file using the given mode and return]
codecs.open(|filename, mode='rb', encoding=None, errors='strict', buffering=1) 
;
[codeop.CommandCompiler |G  Instances of this class have __call__ methods identical in]
codeop.CommandCompiler(|) 
;
[codeop.Compile |G  Instances of this class behave much like the built-in compile]
codeop.Compile(|) 
;
[codeop._maybe_compile |G ]
codeop._maybe_compile(|compiler, source, filename, symbol)