74084db9a8
git-svn-id: svn://svn.tuxfamily.org/svnroot/notepadplus/repository/trunk@901 f5eea248-9336-0410-98b8-ebc06183d4e3
947 lines
59 KiB
XML
947 lines
59 KiB
XML
<?xml version="1.0" encoding="Windows-1252" ?>
|
|
<!--
|
|
@author Gregori Gerebtzoff
|
|
@version 1.2
|
|
-->
|
|
<NotepadPlus>
|
|
<AutoComplete>
|
|
<Environment ignoreCase="no" startFunc="(" stopFunc=")" paramSeparator="," additionalWordChar = "." />
|
|
<KeyWord name="ArithmeticError" func="yes">
|
|
<Overload retVal="" descr="Base class for arithmetic errors.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="AssertionError" func="yes">
|
|
<Overload retVal="" descr="Assertion failed.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="AttributeError" func="yes">
|
|
<Overload retVal="" descr="Attribute not found.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="BaseException" func="yes">
|
|
<Overload retVal="" descr="Common base class for all exceptions">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="BufferError" func="yes">
|
|
<Overload retVal="" descr="Buffer error.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="BytesWarning" func="yes">
|
|
<Overload retVal="" descr="Base class for warnings about bytes and buffer related problems, mostly
related to conversion from str or comparing to str.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="DeprecationWarning" func="yes">
|
|
<Overload retVal="" descr="Base class for warnings about deprecated features.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="EOFError" func="yes">
|
|
<Overload retVal="" descr="Read beyond end of file.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="EnvironmentError" func="yes">
|
|
<Overload retVal="" descr="Base class for I/O related errors.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="Exception" func="yes">
|
|
<Overload retVal="" descr="Common base class for all non-exit exceptions.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="False" />
|
|
<KeyWord name="FloatingPointError" func="yes">
|
|
<Overload retVal="" descr="Floating point operation failed.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="FutureWarning" func="yes">
|
|
<Overload retVal="" descr="Base class for warnings about constructs that will change semantically
in the future.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="GeneratorExit" func="yes">
|
|
<Overload retVal="" descr="Request that a generator exit.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="IOError" func="yes">
|
|
<Overload retVal="" descr="I/O operation failed.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="ImportError" func="yes">
|
|
<Overload retVal="" descr="Import can't find module, or can't find name in module.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="ImportWarning" func="yes">
|
|
<Overload retVal="" descr="Base class for warnings about probable mistakes in module imports">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="IndentationError" func="yes">
|
|
<Overload retVal="" descr="Improper indentation.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="IndexError" func="yes">
|
|
<Overload retVal="" descr="Sequence index out of range.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="KeyError" func="yes">
|
|
<Overload retVal="" descr="Mapping key not found.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="KeyboardInterrupt" func="yes">
|
|
<Overload retVal="" descr="Program interrupted by user.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="LookupError" func="yes">
|
|
<Overload retVal="" descr="Base class for lookup errors.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="MemoryError" func="yes">
|
|
<Overload retVal="" descr="Out of memory.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="NameError" func="yes">
|
|
<Overload retVal="" descr="Name not found globally.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="None" />
|
|
<KeyWord name="NotImplementedError" func="yes">
|
|
<Overload retVal="" descr="Method or function hasn't been implemented yet.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="OSError" func="yes">
|
|
<Overload retVal="" descr="OS system call failed.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="OverflowError" func="yes">
|
|
<Overload retVal="" descr="Result too large to be represented.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="PendingDeprecationWarning" func="yes">
|
|
<Overload retVal="" descr="Base class for warnings about features which will be deprecated
in the future.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="ReferenceError" func="yes">
|
|
<Overload retVal="" descr="Weak ref proxy used after referent went away.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="RuntimeError" func="yes">
|
|
<Overload retVal="" descr="Unspecified run-time error.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="RuntimeWarning" func="yes">
|
|
<Overload retVal="" descr="Base class for warnings about dubious runtime behavior.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="StandardError" func="yes">
|
|
<Overload retVal="" descr="Base class for all standard Python exceptions that do not represent
interpreter exiting.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="StopIteration" func="yes">
|
|
<Overload retVal="" descr="Signal the end from iterator.next().">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="SyntaxError" func="yes">
|
|
<Overload retVal="" descr="Invalid syntax.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="SyntaxWarning" func="yes">
|
|
<Overload retVal="" descr="Base class for warnings about dubious syntax.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="SystemError" func="yes">
|
|
<Overload retVal="" descr="Internal error in the Python interpreter.

Please report this to the Python maintainer, along with the traceback,
the Python version, and the hardware/OS platform and version.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="SystemExit" func="yes">
|
|
<Overload retVal="" descr="Request to exit from the interpreter.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="TabError" func="yes">
|
|
<Overload retVal="" descr="Improper mixture of spaces and tabs.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="True" />
|
|
<KeyWord name="TypeError" func="yes">
|
|
<Overload retVal="" descr="Inappropriate argument type.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="UnboundLocalError" func="yes">
|
|
<Overload retVal="" descr="Local name referenced but not bound to a value.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="UnicodeDecodeError" func="yes">
|
|
<Overload retVal="" descr="Unicode decoding error.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="UnicodeEncodeError" func="yes">
|
|
<Overload retVal="" descr="Unicode encoding error.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="UnicodeError" func="yes">
|
|
<Overload retVal="" descr="Unicode related error.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="UnicodeTranslateError" func="yes">
|
|
<Overload retVal="" descr="Unicode translation error.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="UnicodeWarning" func="yes">
|
|
<Overload retVal="" descr="Base class for warnings about Unicode related problems, mostly
related to conversion problems.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="UserWarning" func="yes">
|
|
<Overload retVal="" descr="Base class for warnings generated by user code.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="ValueError" func="yes">
|
|
<Overload retVal="" descr="Inappropriate argument value (of correct type).">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="Warning" func="yes">
|
|
<Overload retVal="" descr="Base class for warning categories.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="ZeroDivisionError" func="yes">
|
|
<Overload retVal="" descr="Second argument to a division or modulo operation was zero.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="abs" func="yes">
|
|
<Overload retVal="" descr="abs(number) -> number

Return the absolute value of the argument.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="add" func="yes">
|
|
<Overload retVal="" descr="Add an element to a set.

This has no effect if the element is already present.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="all" func="yes">
|
|
<Overload retVal="" descr="all(iterable) -> bool

Return True if bool(x) is True for all values x in the iterable.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="and" />
|
|
<KeyWord name="any" func="yes">
|
|
<Overload retVal="" descr="any(iterable) -> bool

Return True if bool(x) is True for any x in the iterable.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="append" func="yes">
|
|
<Overload retVal="" descr="B.append(int) -> None

Append a single item to the end of B.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="apply" func="yes">
|
|
<Overload retVal="" descr="apply(object[, args[, kwargs]]) -> value

Call a callable object with positional arguments taken from the tuple args,
and keyword arguments taken from the optional dictionary kwargs.
Note that classes are callable, as are instances with a __call__() method.

Deprecated since release 2.3. Instead, use the extended call syntax:
 function(*args, **keywords).">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="as" />
|
|
<KeyWord name="as_integer_ratio" func="yes">
|
|
<Overload retVal="" descr="float.as_integer_ratio() -> (int, int)

Returns a pair of integers, whose ratio is exactly equal to the original
float and with a positive denominator.
Raises OverflowError on infinities and a ValueError on NaNs.

>>> (10.0).as_integer_ratio()
(10, 1)
>>> (0.0).as_integer_ratio()
(0, 1)
>>> (-.25).as_integer_ratio()
(-1, 4)">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="assert" />
|
|
<KeyWord name="basestring" func="yes">
|
|
<Overload retVal="" descr="Type basestring cannot be instantiated; it is the base for str and unicode.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="bin" func="yes">
|
|
<Overload retVal="" descr="bin(number) -> string

Return the binary representation of an integer or long integer.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="bit_length" func="yes">
|
|
<Overload retVal="" descr="long.bit_length() -> int or long

Number of bits necessary to represent self in binary.
>>> bin(37L)
'0b100101'
>>> (37L).bit_length()
6">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="bool" func="yes">
|
|
<Overload retVal="" descr="bool(x) -> bool

Returns True when the argument x is true, False otherwise.
The builtins True and False are the only two instances of the class bool.
The class bool is a subclass of the class int, and cannot be subclassed.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="break" />
|
|
<KeyWord name="buffer" func="yes">
|
|
<Overload retVal="" descr="buffer(object [, offset[, size]])

Create a new buffer object which references the given object.
The buffer will reference a slice of the target object from the
start of the object (or at the specified offset). The slice will
extend to the end of the target object (or with the specified size).">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="bytearray" func="yes">
|
|
<Overload retVal="" descr="bytearray(iterable_of_ints) -> bytearray.
bytearray(string, encoding[, errors]) -> bytearray.
bytearray(bytes_or_bytearray) -> mutable copy of bytes_or_bytearray.
bytearray(memory_view) -> bytearray.

Construct an mutable bytearray object from:
 - an iterable yielding integers in range(256)
 - a text string encoded using the specified encoding
 - a bytes or a bytearray object
 - any object implementing the buffer API.

bytearray(int) -> bytearray.

Construct a zero-initialized bytearray of the given length.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="bytes" func="yes">
|
|
<Overload retVal="" descr="str(object) -> string

Return a nice string representation of the object.
If the argument is a string, the return value is the same object.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="callable" func="yes">
|
|
<Overload retVal="" descr="callable(object) -> bool

Return whether the object is callable (i.e., some kind of function).
Note that classes are callable, as are instances with a __call__() method.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="capitalize" func="yes">
|
|
<Overload retVal="" descr="S.capitalize() -> string

Return a copy of the string S with only its first character
capitalized.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="center" func="yes">
|
|
<Overload retVal="" descr="B.center(width[, fillchar]) -> copy of B

Return B centered in a string of length width. Padding is
done using the specified fill character (default is a space).">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="chr" func="yes">
|
|
<Overload retVal="" descr="chr(i) -> character

Return a string of one character with ordinal i; 0 <= i < 256.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="class" />
|
|
<KeyWord name="classmethod" func="yes">
|
|
<Overload retVal="" descr="classmethod(function) -> method

Convert a function to be a class method.

A class method receives the class as implicit first argument,
just like an instance method receives the instance.
To declare a class method, use this idiom:

 class C:
 def f(cls, arg1, arg2, ...): ...
 f = classmethod(f)

It can be called either on the class (e.g. C.f()) or on an instance
(e.g. C().f()). The instance is ignored except for its class.
If a class method is called for a derived class, the derived class
object is passed as the implied first argument.

Class methods are different than C++ or Java static methods.
If you want those, see the staticmethod builtin.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="clear" func="yes">
|
|
<Overload retVal="" descr="Remove all elements from this set.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="close" func="yes">
|
|
<Overload retVal="" descr="close() -> None or (perhaps) an integer. Close the file.

Sets data attribute .closed to True. A closed file cannot be used for
further I/O operations. close() may be called more than once without
error. Some kinds of file objects (for example, opened by popen())
may return an exit status upon closing.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="cmp" func="yes">
|
|
<Overload retVal="" descr="cmp(x, y) -> integer

Return negative if x<y, zero if x==y, positive if x>y.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="coerce" func="yes">
|
|
<Overload retVal="" descr="coerce(x, y) -> (x1, y1)

Return a tuple consisting of the two numeric arguments converted to
a common type, using the same rules as used by arithmetic operations.
If coercion is not possible, raise TypeError.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="compile" func="yes">
|
|
<Overload retVal="" descr="compile(source, filename, mode[, flags[, dont_inherit]]) -> code object

Compile the source string (a Python module, statement or expression)
into a code object that can be executed by the exec statement or eval().
The filename will be used for run-time error messages.
The mode must be 'exec' to compile a module, 'single' to compile a
single (interactive) statement, or 'eval' to compile an expression.
The flags argument, if present, controls which future statements influence
the compilation of the code.
The dont_inherit argument, if non-zero, stops the compilation inheriting
the effects of any future statements in effect in the code calling
compile; if absent or zero these statements do influence the compilation,
in addition to any features explicitly specified.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="complex" func="yes">
|
|
<Overload retVal="" descr="complex(real[, imag]) -> complex number

Create a complex number from a real part and an optional imaginary part.
This is equivalent to (real + imag*1j) where imag defaults to 0.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="conjugate" func="yes">
|
|
<Overload retVal="" descr="Returns self, the complex conjugate of any int.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="continue" />
|
|
<KeyWord name="copy" func="yes">
|
|
<Overload retVal="" descr="D.copy() -> a shallow copy of D">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="count" func="yes">
|
|
<Overload retVal="" descr="L.count(value) -> integer -- return number of occurrences of value">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="decode" func="yes">
|
|
<Overload retVal="" descr="S.decode([encoding[,errors]]) -> object

Decodes S using the codec registered for encoding. encoding defaults
to the default encoding. errors may be given to set a different error
handling scheme. Default is 'strict' meaning that encoding errors raise
a UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
as well as any other name registered with codecs.register_error that is
able to handle UnicodeDecodeErrors.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="def" />
|
|
<KeyWord name="del" />
|
|
<KeyWord name="delattr" func="yes">
|
|
<Overload retVal="" descr="delattr(object, name)

Delete a named attribute on an object; delattr(x, 'y') is equivalent to
``del x.y''.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="deleter" func="yes">
|
|
<Overload retVal="" descr="Descriptor to change the deleter on a property.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="dict" func="yes">
|
|
<Overload retVal="" descr="dict() -> new empty dictionary
dict(mapping) -> new dictionary initialized from a mapping object's
 (key, value) pairs
dict(iterable) -> new dictionary initialized as if via:
 d = {}
 for k, v in iterable:
 d[k] = v
dict(**kwargs) -> new dictionary initialized with the name=value pairs
 in the keyword argument list. For example: dict(one=1, two=2)">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="difference" func="yes">
|
|
<Overload retVal="" descr="Return the difference of two or more sets as a new set.

(i.e. all elements that are in this set but not the others.)">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="difference_update" func="yes">
|
|
<Overload retVal="" descr="Remove all elements of another set from this set.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="dir" func="yes">
|
|
<Overload retVal="" descr="dir([object]) -> list of strings

If called without an argument, return the names in the current scope.
Else, return an alphabetized list of names comprising (some of) the attributes
of the given object, and of attributes reachable from it.
If the object supplies a method named __dir__, it will be used; otherwise
the default dir() logic is used and returns:
 for a module object: the module's attributes.
 for a class object: its attributes, and recursively the attributes
 of its bases.
 for any other object: its attributes, its class's attributes, and
 recursively the attributes of its class's base classes.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="discard" func="yes">
|
|
<Overload retVal="" descr="Remove an element from a set if it is a member.

If the element is not a member, do nothing.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="divmod" func="yes">
|
|
<Overload retVal="" descr="divmod(x, y) -> (div, mod)

Return the tuple ((x-x%y)/y, x%y). Invariant: div*y + mod == x.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="elif" />
|
|
<KeyWord name="else" />
|
|
<KeyWord name="encode" func="yes">
|
|
<Overload retVal="" descr="S.encode([encoding[,errors]]) -> string or unicode

Encodes S using the codec registered for encoding. encoding defaults
to the default encoding. errors may be given to set a different error
handling scheme. Default is 'strict' meaning that encoding errors raise
a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
'xmlcharrefreplace' as well as any other name registered with
codecs.register_error that can handle UnicodeEncodeErrors.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="endswith" func="yes">
|
|
<Overload retVal="" descr="B.endswith(suffix [,start [,end]]) -> bool

Return True if B ends with the specified suffix, False otherwise.
With optional start, test B beginning at that position.
With optional end, stop comparing B at that position.
suffix can also be a tuple of strings to try.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="enumerate" func="yes">
|
|
<Overload retVal="" descr="enumerate(iterable[, start]) -> iterator for index, value of iterable

Return an enumerate object. iterable must be another object that supports
iteration. The enumerate object yields pairs containing a count (from
start, which defaults to zero) and a value yielded by the iterable argument.
enumerate is useful for obtaining an indexed list:
 (0, seq[0]), (1, seq[1]), (2, seq[2]), ...">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="eval" func="yes">
|
|
<Overload retVal="" descr="eval(source[, globals[, locals]]) -> value

Evaluate the source in the context of globals and locals.
The source may be a string representing a Python expression
or a code object as returned by compile().
The globals must be a dictionary and locals can be any mapping,
defaulting to the current globals and locals.
If only globals is given, locals defaults to it.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="except" />
|
|
<KeyWord name="exec" />
|
|
<KeyWord name="execfile" func="yes">
|
|
<Overload retVal="" descr="execfile(filename[, globals[, locals]])

Read and execute a Python script from a file.
The globals and locals are dictionaries, defaulting to the current
globals and locals. If only globals is given, locals defaults to it.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="expandtabs" func="yes">
|
|
<Overload retVal="" descr="B.expandtabs([tabsize]) -> copy of B

Return a copy of B where all tab characters are expanded using spaces.
If tabsize is not given, a tab size of 8 characters is assumed.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="extend" func="yes">
|
|
<Overload retVal="" descr="B.extend(iterable int) -> None

Append all the elements from the iterator or sequence to the
end of B.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="file" func="yes">
|
|
<Overload retVal="" descr="file(name[, mode[, buffering]]) -> file object

Open a file. The mode can be 'r', 'w' or 'a' for reading (default),
writing or appending. The file will be created if it doesn't exist
when opened for writing or appending; it will be truncated when
opened for writing. Add a 'b' to the mode for binary files.
Add a '+' to the mode to allow simultaneous reading and writing.
If the buffering argument is given, 0 means unbuffered, 1 means line
buffered, and larger numbers specify the buffer size. The preferred way
to open a file is with the builtin open() function.
Add a 'U' to mode to open the file for input with universal newline
support. Any line ending in the input file will be seen as a '\n'
in Python. Also, a file so opened gains the attribute 'newlines';
the value for this attribute is one of None (no newline read yet),
'\r', '\n', '\r\n' or a tuple containing all the newline types seen.

'U' cannot be combined with 'w' or '+' mode.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="fileno" func="yes">
|
|
<Overload retVal="" descr='fileno() -> integer "file descriptor".

This is needed for lower-level file interfaces, such os.read().'>
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="filter" func="yes">
|
|
<Overload retVal="" descr="filter(function or None, sequence) -> list, tuple, or string

Return those items of sequence for which function(item) is true. If
function is None, return the items that are true. If sequence is a tuple
or string, return the same type, else return a list.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="finally" />
|
|
<KeyWord name="find" func="yes">
|
|
<Overload retVal="" descr="S.find(sub [,start [,end]]) -> int

Return the lowest index in S where substring sub is found,
such that sub is contained within s[start:end]. Optional
arguments start and end are interpreted as in slice notation.

Return -1 on failure.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="float" func="yes">
|
|
<Overload retVal="" descr="float(x) -> floating point number

Convert a string or number to a floating point number, if possible.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="flush" func="yes">
|
|
<Overload retVal="" descr="flush() -> None. Flush the internal I/O buffer.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="for" />
|
|
<KeyWord name="format" func="yes">
|
|
<Overload retVal="" descr="S.format(*args, **kwargs) -> unicode">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="from" />
|
|
<KeyWord name="fromhex" func="yes">
|
|
<Overload retVal="" descr="float.fromhex(string) -> float

Create a floating-point number from a hexadecimal string.
>>> float.fromhex('0x1.ffffp10')
2047.984375
>>> float.fromhex('-0x1p-1074')
-4.9406564584124654e-324">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="fromkeys" func="yes">
|
|
<Overload retVal="" descr="dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.
v defaults to None.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="frozenset" func="yes">
|
|
<Overload retVal="" descr="frozenset() -> empty frozenset object
frozenset(iterable) -> frozenset object

Build an immutable unordered collection of unique elements.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="get" func="yes">
|
|
<Overload retVal="" descr="D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="getattr" func="yes">
|
|
<Overload retVal="" descr="getattr(object, name[, default]) -> value

Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.
When a default argument is given, it is returned when the attribute doesn't
exist; without it, an exception is raised in that case.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="getter" func="yes">
|
|
<Overload retVal="" descr="Descriptor to change the getter on a property.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="global" />
|
|
<KeyWord name="globals" func="yes">
|
|
<Overload retVal="" descr="globals() -> dictionary

Return the dictionary containing the current scope's global variables.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="has_key" func="yes">
|
|
<Overload retVal="" descr="D.has_key(k) -> True if D has a key k, else False">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="hasattr" func="yes">
|
|
<Overload retVal="" descr="hasattr(object, name) -> bool

Return whether the object has an attribute with the given name.
(This is done by calling getattr(object, name) and catching exceptions.)">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="hash" func="yes">
|
|
<Overload retVal="" descr="hash(object) -> integer

Return a hash value for the object. Two objects with the same value have
the same hash value. The reverse is not necessarily true, but likely.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="hex" func="yes">
|
|
<Overload retVal="" descr="float.hex() -> string

Return a hexadecimal representation of a floating-point number.
>>> (-0.1).hex()
'-0x1.999999999999ap-4'
>>> 3.14159.hex()
'0x1.921f9f01b866ep+1'">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="id" func="yes">
|
|
<Overload retVal="" descr="id(object) -> integer

Return the identity of an object. This is guaranteed to be unique among
simultaneously existing objects. (Hint: it's the object's memory address.)">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="if" />
|
|
<KeyWord name="import" />
|
|
<KeyWord name="in" />
|
|
<KeyWord name="index" func="yes">
|
|
<Overload retVal="" descr="S.index(sub [,start [,end]]) -> int

Like S.find() but raise ValueError when the substring is not found.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="indices" func="yes">
|
|
<Overload retVal="" descr="S.indices(len) -> (start, stop, stride)

Assuming a sequence of length len, calculate the start and stop
indices, and the stride length of the extended slice described by
S. Out of bounds indices are clipped in a manner consistent with the
handling of normal slices.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="input" func="yes">
|
|
<Overload retVal="" descr="input([prompt]) -> value

Equivalent to eval(raw_input(prompt)).">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="insert" func="yes">
|
|
<Overload retVal="" descr="B.insert(index, int) -> None

Insert a single item into the bytearray before the given index.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="int" func="yes">
|
|
<Overload retVal="" descr="int(x[, base]) -> integer

Convert a string or number to an integer, if possible. A floating point
argument will be truncated towards zero (this does not include a string
representation of a floating point number!) When converting a string, use
the optional base. It is an error to supply a base when converting a
non-string. If base is zero, the proper base is guessed based on the
string content. If the argument is outside the integer range a
long object will be returned instead.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="intern" func="yes">
|
|
<Overload retVal="" descr="intern(string) -> string

``Intern'' the given string. This enters the string in the (global)
table of interned strings whose purpose is to speed up dictionary lookups.
Return the string itself or the previously interned string object with the
same value.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="intersection" func="yes">
|
|
<Overload retVal="" descr="Return the intersection of two or more sets as a new set.

(i.e. elements that are common to all of the sets.)">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="intersection_update" func="yes">
|
|
<Overload retVal="" descr="Update a set with the intersection of itself and another.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="is" />
|
|
<KeyWord name="is_integer" func="yes">
|
|
<Overload retVal="" descr="Returns True if the float is an integer.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="isalnum" func="yes">
|
|
<Overload retVal="" descr="S.isalnum() -> bool

Return True if all characters in S are alphanumeric
and there is at least one character in S, False otherwise.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="isalpha" func="yes">
|
|
<Overload retVal="" descr="S.isalpha() -> bool

Return True if all characters in S are alphabetic
and there is at least one character in S, False otherwise.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="isatty" func="yes">
|
|
<Overload retVal="" descr="isatty() -> true or false. True if the file is connected to a tty device.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="isdecimal" func="yes">
|
|
<Overload retVal="" descr="S.isdecimal() -> bool

Return True if there are only decimal characters in S,
False otherwise.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="isdigit" func="yes">
|
|
<Overload retVal="" descr="S.isdigit() -> bool

Return True if all characters in S are digits
and there is at least one character in S, False otherwise.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="isdisjoint" func="yes">
|
|
<Overload retVal="" descr="Return True if two sets have a null intersection.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="isinstance" func="yes">
|
|
<Overload retVal="" descr="isinstance(object, class-or-type-or-tuple) -> bool

Return whether an object is an instance of a class or of a subclass thereof.
With a type as second argument, return whether that is the object's type.
The form using a tuple, isinstance(x, (A, B, ...)), is a shortcut for
isinstance(x, A) or isinstance(x, B) or ... (etc.).">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="islower" func="yes">
|
|
<Overload retVal="" descr="S.islower() -> bool

Return True if all cased characters in S are lowercase and there is
at least one cased character in S, False otherwise.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="isnumeric" func="yes">
|
|
<Overload retVal="" descr="S.isnumeric() -> bool

Return True if there are only numeric characters in S,
False otherwise.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="isspace" func="yes">
|
|
<Overload retVal="" descr="S.isspace() -> bool

Return True if all characters in S are whitespace
and there is at least one character in S, False otherwise.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="issubclass" func="yes">
|
|
<Overload retVal="" descr="issubclass(C, B) -> bool

Return whether class C is a subclass (i.e., a derived class) of class B.
When using a tuple as the second argument issubclass(X, (A, B, ...)),
is a shortcut for issubclass(X, A) or issubclass(X, B) or ... (etc.).">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="issubset" func="yes">
|
|
<Overload retVal="" descr="Report whether another set contains this set.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="issuperset" func="yes">
|
|
<Overload retVal="" descr="Report whether this set contains another set.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="istitle" func="yes">
|
|
<Overload retVal="" descr="S.istitle() -> bool

Return True if S is a titlecased string and there is at least one
character in S, i.e. uppercase characters may only follow uncased
characters and lowercase characters only cased ones. Return False
otherwise.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="isupper" func="yes">
|
|
<Overload retVal="" descr="S.isupper() -> bool

Return True if all cased characters in S are uppercase and there is
at least one cased character in S, False otherwise.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="items" func="yes">
|
|
<Overload retVal="" descr="D.items() -> list of D's (key, value) pairs, as 2-tuples">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="iter" func="yes">
|
|
<Overload retVal="" descr="iter(collection) -> iterator
iter(callable, sentinel) -> iterator

Get an iterator from an object. In the first form, the argument must
supply its own iterator, or be a sequence.
In the second form, the callable is called until it returns the sentinel.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="iteritems" func="yes">
|
|
<Overload retVal="" descr="D.iteritems() -> an iterator over the (key, value) items of D">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="iterkeys" func="yes">
|
|
<Overload retVal="" descr="D.iterkeys() -> an iterator over the keys of D">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="itervalues" func="yes">
|
|
<Overload retVal="" descr="D.itervalues() -> an iterator over the values of D">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="join" func="yes">
|
|
<Overload retVal="" descr="S.join(iterable) -> unicode

Return a string which is the concatenation of the strings in the
iterable. The separator between elements is S.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="keys" func="yes">
|
|
<Overload retVal="" descr="D.keys() -> list of D's keys">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="lambda" />
|
|
<KeyWord name="len" func="yes">
|
|
<Overload retVal="" descr="len(object) -> integer

Return the number of items of a sequence or mapping.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="list" func="yes">
|
|
<Overload retVal="" descr="list() -> new empty list
list(iterable) -> new list initialized from iterable's items">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="ljust" func="yes">
|
|
<Overload retVal="" descr="S.ljust(width[, fillchar]) -> string

Return S left-justified in a string of length width. Padding is
done using the specified fill character (default is a space).">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="locals" func="yes">
|
|
<Overload retVal="" descr="locals() -> dictionary

Update and return a dictionary containing the current scope's local variables.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="long" func="yes">
|
|
<Overload retVal="" descr="long(x[, base]) -> integer

Convert a string or number to a long integer, if possible. A floating
point argument will be truncated towards zero (this does not include a
string representation of a floating point number!) When converting a
string, use the optional base. It is an error to supply a base when
converting a non-string.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="lower" func="yes">
|
|
<Overload retVal="" descr="S.lower() -> string

Return a copy of the string S converted to lowercase.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="lstrip" func="yes">
|
|
<Overload retVal="" descr="S.lstrip([chars]) -> string or unicode

Return a copy of the string S with leading whitespace removed.
If chars is given and not None, remove characters in chars instead.
If chars is unicode, S will be converted to unicode before stripping">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="map" func="yes">
|
|
<Overload retVal="" descr="map(function, sequence[, sequence, ...]) -> list

Return a list of the results of applying the function to the items of
the argument sequence(s). If more than one sequence is given, the
function is called with an argument list consisting of the corresponding
item of each sequence, substituting None for missing values when not all
sequences have the same length. If the function is None, return a list of
the items of the sequence (or a list of tuples if more than one sequence).">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="max" func="yes">
|
|
<Overload retVal="" descr="max(iterable[, key=func]) -> value
max(a, b, c, ...[, key=func]) -> value

With a single iterable argument, return its largest item.
With two or more arguments, return the largest argument.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="memoryview" func="yes">
|
|
<Overload retVal="" descr="memoryview(object)

Create a new memoryview object which references the given object.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="min" func="yes">
|
|
<Overload retVal="" descr="min(iterable[, key=func]) -> value
min(a, b, c, ...[, key=func]) -> value

With a single iterable argument, return its smallest item.
With two or more arguments, return the smallest argument.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="mro" func="yes">
|
|
<Overload retVal="" descr="mro() -> list
return a type's method resolution order">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="next" func="yes">
|
|
<Overload retVal="" descr="x.next() -> the next value, or raise StopIteration">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="not" />
|
|
<KeyWord name="object" func="yes">
|
|
<Overload retVal="" descr="The most base type">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="oct" func="yes">
|
|
<Overload retVal="" descr="oct(number) -> string

Return the octal representation of an integer or long integer.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="open" func="yes">
|
|
<Overload retVal="" descr="open(name[, mode[, buffering]]) -> file object

Open a file using the file() type, returns a file object. This is the
preferred way to open a file. See file.__doc__ for further information.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="or" />
|
|
<KeyWord name="ord" func="yes">
|
|
<Overload retVal="" descr="ord(c) -> integer

Return the integer ordinal of a one-character string.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="partition" func="yes">
|
|
<Overload retVal="" descr="S.partition(sep) -> (head, sep, tail)

Search for the separator sep in S, and return the part before it,
the separator itself, and the part after it. If the separator is not
found, return S and two empty strings.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="pass" />
|
|
<KeyWord name="pop" func="yes">
|
|
<Overload retVal="" descr="L.pop([index]) -> item -- remove and return item at index (default last).
Raises IndexError if list is empty or index is out of range.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="popitem" func="yes">
|
|
<Overload retVal="" descr="D.popitem() -> (k, v), remove and return some (key, value) pair as a
2-tuple; but raise KeyError if D is empty.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="pow" func="yes">
|
|
<Overload retVal="" descr="pow(x, y[, z]) -> number

With two arguments, equivalent to x**y. With three arguments,
equivalent to (x**y) % z, but may be more efficient (e.g. for longs).">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="print" />
|
|
<KeyWord name="property" func="yes">
|
|
<Overload retVal="" descr="property(fget=None, fset=None, fdel=None, doc=None) -> property attribute

fget is a function to be used for getting an attribute value, and likewise
fset is a function for setting, and fdel a function for del'ing, an
attribute. Typical use is to define a managed attribute x:
class C(object):
 def getx(self): return self._x
 def setx(self, value): self._x = value
 def delx(self): del self._x
 x = property(getx, setx, delx, "I'm the 'x' property.")

Decorators make defining new properties or modifying existing ones easy:
class C(object):
 @property
 def x(self): return self._x
 @x.setter
 def x(self, value): self._x = value
 @x.deleter
 def x(self): del self._x">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="raise" />
|
|
<KeyWord name="range" func="yes">
|
|
<Overload retVal="" descr="range([start,] stop[, step]) -> list of integers

Return a list containing an arithmetic progression of integers.
range(i, j) returns [i, i+1, i+2, ..., j-1]; start (!) defaults to 0.
When step is given, it specifies the increment (or decrement).
For example, range(4) returns [0, 1, 2, 3]. The end point is omitted!
These are exactly the valid indices for a list of 4 elements.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="raw_input" func="yes">
|
|
<Overload retVal="" descr="raw_input([prompt]) -> string

Read a string from standard input. The trailing newline is stripped.
If the user hits EOF (Unix: Ctl-D, Windows: Ctl-Z+Return), raise EOFError.
On Unix, GNU readline is used if enabled. The prompt string, if given,
is printed without a trailing newline before reading.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="read" func="yes">
|
|
<Overload retVal="" descr="read([size]) -> read at most size bytes, returned as a string.

If the size argument is negative or omitted, read until EOF is reached.
Notice that when in non-blocking mode, less data than what was requested
may be returned, even if no size parameter was given.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="readinto" func="yes">
|
|
<Overload retVal="" descr="readinto() -> Undocumented. Don't use this; it may go away.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="readline" func="yes">
|
|
<Overload retVal="" descr="readline([size]) -> next line from the file, as a string.

Retain newline. A non-negative size argument limits the maximum
number of bytes to return (an incomplete line may be returned then).
Return an empty string at EOF.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="readlines" func="yes">
|
|
<Overload retVal="" descr="readlines([size]) -> list of strings, each a line from the file.

Call readline() repeatedly and return a list of the lines so read.
The optional size argument, if given, is an approximate bound on the
total number of bytes in the lines returned.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="reduce" func="yes">
|
|
<Overload retVal="" descr="reduce(function, sequence[, initial]) -> value

Apply a function of two arguments cumulatively to the items of a sequence,
from left to right, so as to reduce the sequence to a single value.
For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates
((((1+2)+3)+4)+5). If initial is present, it is placed before the items
of the sequence in the calculation, and serves as a default when the
sequence is empty.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="reload" func="yes">
|
|
<Overload retVal="" descr="reload(module) -> module

Reload the module. The module must have been successfully imported before.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="remove" func="yes">
|
|
<Overload retVal="" descr="Remove an element from a set; it must be a member.

If the element is not a member, raise a KeyError.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="replace" func="yes">
|
|
<Overload retVal="" descr="B.replace(old, new[, count]) -> bytes

Return a copy of B with all occurrences of subsection
old replaced by new. If the optional argument count is
given, only the first count occurrences are replaced.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="repr" func="yes">
|
|
<Overload retVal="" descr="repr(object) -> string

Return the canonical string representation of the object.
For most object types, eval(repr(object)) == object.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="return" />
|
|
<KeyWord name="reverse" func="yes">
|
|
<Overload retVal="" descr="L.reverse() -- reverse *IN PLACE*">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="reversed" func="yes">
|
|
<Overload retVal="" descr="reversed(sequence) -> reverse iterator over values of the sequence

Return a reverse iterator">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="rfind" func="yes">
|
|
<Overload retVal="" descr="B.rfind(sub [,start [,end]]) -> int

Return the highest index in B where subsection sub is found,
such that sub is contained within s[start,end]. Optional
arguments start and end are interpreted as in slice notation.

Return -1 on failure.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="rindex" func="yes">
|
|
<Overload retVal="" descr="S.rindex(sub [,start [,end]]) -> int

Like S.rfind() but raise ValueError when the substring is not found.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="rjust" func="yes">
|
|
<Overload retVal="" descr="B.rjust(width[, fillchar]) -> copy of B

Return B right justified in a string of length width. Padding is
done using the specified fill character (default is a space)">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="round" func="yes">
|
|
<Overload retVal="" descr="round(number[, ndigits]) -> floating point number

Round a number to a given precision in decimal digits (default 0 digits).
This always returns a floating point number. Precision may be negative.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="rpartition" func="yes">
|
|
<Overload retVal="" descr="B.rpartition(sep) -> (head, sep, tail)

Searches for the separator sep in B, starting at the end of B,
and returns the part before it, the separator itself, and the
part after it. If the separator is not found, returns two empty
bytearray objects and B.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="rsplit" func="yes">
|
|
<Overload retVal="" descr="S.rsplit([sep [,maxsplit]]) -> list of strings

Return a list of the words in the string S, using sep as the
delimiter string, starting at the end of the string and working
to the front. If maxsplit is given, at most maxsplit splits are
done. If sep is not specified or is None, any whitespace string
is a separator.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="rstrip" func="yes">
|
|
<Overload retVal="" descr="S.rstrip([chars]) -> string or unicode

Return a copy of the string S with trailing whitespace removed.
If chars is given and not None, remove characters in chars instead.
If chars is unicode, S will be converted to unicode before stripping">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="seek" func="yes">
|
|
<Overload retVal="" descr="seek(offset[, whence]) -> None. Move to new file position.

Argument offset is a byte count. Optional argument whence defaults to
0 (offset from start of file, offset should be >= 0); other values are 1
(move relative to current position, positive or negative), and 2 (move
relative to end of file, usually negative, although many platforms allow
seeking beyond the end of a file). If the file is opened in text mode,
only offsets returned by tell() are legal. Use of other offsets causes
undefined behavior.
Note that not all file objects are seekable.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="set" func="yes">
|
|
<Overload retVal="" descr="set() -> new empty set object
set(iterable) -> new set object

Build an unordered collection of unique elements.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="setattr" func="yes">
|
|
<Overload retVal="" descr="setattr(object, name, value)

Set a named attribute on an object; setattr(x, 'y', v) is equivalent to
``x.y = v''.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="setdefault" func="yes">
|
|
<Overload retVal="" descr="D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="setter" func="yes">
|
|
<Overload retVal="" descr="Descriptor to change the setter on a property.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="slice" func="yes">
|
|
<Overload retVal="" descr="slice([start,] stop[, step])

Create a slice object. This is used for extended slicing (e.g. a[0:10:2]).">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="sort" func="yes">
|
|
<Overload retVal="" descr="L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
cmp(x, y) -> -1, 0, 1">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="sorted" func="yes">
|
|
<Overload retVal="" descr="sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="split" func="yes">
|
|
<Overload retVal="" descr="B.split([sep[, maxsplit]]) -> list of bytearray

Return a list of the sections in B, using sep as the delimiter.
If sep is not given, B is split on ASCII whitespace characters
(space, tab, return, newline, formfeed, vertical tab).
If maxsplit is given, at most maxsplit splits are done.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="splitlines" func="yes">
|
|
<Overload retVal="" descr="S.splitlines([keepends]) -> list of strings

Return a list of the lines in S, breaking at line boundaries.
Line breaks are not included in the resulting list unless keepends
is given and true.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="startswith" func="yes">
|
|
<Overload retVal="" descr="S.startswith(prefix[, start[, end]]) -> bool

Return True if S starts with the specified prefix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
prefix can also be a tuple of strings to try.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="staticmethod" func="yes">
|
|
<Overload retVal="" descr="staticmethod(function) -> method

Convert a function to be a static method.

A static method does not receive an implicit first argument.
To declare a static method, use this idiom:

 class C:
 def f(arg1, arg2, ...): ...
 f = staticmethod(f)

It can be called either on the class (e.g. C.f()) or on an instance
(e.g. C().f()). The instance is ignored except for its class.

Static methods in Python are similar to those found in Java or C++.
For a more advanced concept, see the classmethod builtin.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="str" func="yes">
|
|
<Overload retVal="" descr="str(object) -> string

Return a nice string representation of the object.
If the argument is a string, the return value is the same object.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="strip" func="yes">
|
|
<Overload retVal="" descr="S.strip([chars]) -> string or unicode

Return a copy of the string S with leading and trailing
whitespace removed.
If chars is given and not None, remove characters in chars instead.
If chars is unicode, S will be converted to unicode before stripping">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="sum" func="yes">
|
|
<Overload retVal="" descr="sum(sequence[, start]) -> value

Returns the sum of a sequence of numbers (NOT strings) plus the value
of parameter 'start' (which defaults to 0). When the sequence is
empty, returns start.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="super" func="yes">
|
|
<Overload retVal="" descr="super(type) -> unbound super object
super(type, obj) -> bound super object; requires isinstance(obj, type)
super(type, type2) -> bound super object; requires issubclass(type2, type)
Typical use to call a cooperative superclass method:
class C(B):
 def meth(self, arg):
 super(C, self).meth(arg)">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="swapcase" func="yes">
|
|
<Overload retVal="" descr="S.swapcase() -> string

Return a copy of the string S with uppercase characters
converted to lowercase and vice versa.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="symmetric_difference" func="yes">
|
|
<Overload retVal="" descr="Return the symmetric difference of two sets as a new set.

(i.e. all elements that are in exactly one of the sets.)">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="symmetric_difference_update" func="yes">
|
|
<Overload retVal="" descr="Update a set with the symmetric difference of itself and another.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="tell" func="yes">
|
|
<Overload retVal="" descr="tell() -> current file position, an integer (may be a long integer).">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="title" func="yes">
|
|
<Overload retVal="" descr="S.title() -> unicode

Return a titlecased version of S, i.e. words start with title case
characters, all remaining cased characters have lower case.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="tobytes" />
|
|
<KeyWord name="tolist" />
|
|
<KeyWord name="translate" func="yes">
|
|
<Overload retVal="" descr="B.translate(table[, deletechars]) -> bytearray

Return a copy of B, where all characters occurring in the
optional argument deletechars are removed, and the remaining
characters have been mapped through the given translation
table, which must be a bytes object of length 256.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="truncate" func="yes">
|
|
<Overload retVal="" descr="truncate([size]) -> None. Truncate the file to at most size bytes.

Size defaults to the current file position, as returned by tell().">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="try" />
|
|
<KeyWord name="tuple" func="yes">
|
|
<Overload retVal="" descr="tuple() -> empty tuple
tuple(iterable) -> tuple initialized from iterable's items

If the argument is a tuple, the return value is the same object.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="type" func="yes">
|
|
<Overload retVal="" descr="type(object) -> the object's type
type(name, bases, dict) -> a new type">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="unichr" func="yes">
|
|
<Overload retVal="" descr="unichr(i) -> Unicode character

Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="unicode" func="yes">
|
|
<Overload retVal="" descr="unicode(string [, encoding[, errors]]) -> object

Create a new Unicode object from the given encoded string.
encoding defaults to the current default string encoding.
errors can be 'strict', 'replace' or 'ignore' and defaults to 'strict'.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="union" func="yes">
|
|
<Overload retVal="" descr="Return the union of sets as a new set.

(i.e. all elements that are in either set.)">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="update" func="yes">
|
|
<Overload retVal="" descr="D.update(E, **F) -> None. Update D from dict/iterable E and F.
If E has a .keys() method, does: for k in E: D[k] = E[k]
If E lacks .keys() method, does: for (k, v) in E: D[k] = v
In either case, this is followed by: for k in F: D[k] = F[k]">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="upper" func="yes">
|
|
<Overload retVal="" descr="S.upper() -> unicode

Return a copy of S converted to uppercase.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="values" func="yes">
|
|
<Overload retVal="" descr="D.values() -> list of D's values">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="vars" func="yes">
|
|
<Overload retVal="" descr="vars([object]) -> dictionary

Without arguments, equivalent to locals().
With an argument, equivalent to object.__dict__.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="viewitems" func="yes">
|
|
<Overload retVal="" descr="D.viewitems() -> a set-like object providing a view on D's items">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="viewkeys" func="yes">
|
|
<Overload retVal="" descr="D.viewkeys() -> a set-like object providing a view on D's keys">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="viewvalues" func="yes">
|
|
<Overload retVal="" descr="D.viewvalues() -> an object providing a view on D's values">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="while" />
|
|
<KeyWord name="with" />
|
|
<KeyWord name="write" func="yes">
|
|
<Overload retVal="" descr="write(str) -> None. Write string str to file.

Note that due to buffering, flush() or close() may be needed before
the file on disk reflects the data written.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="writelines" func="yes">
|
|
<Overload retVal="" descr="writelines(sequence_of_strings) -> None. Write the strings to the file.

Note that newlines are not added. The sequence can be any iterable object
producing strings. This is equivalent to calling write() for each string.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="xrange" func="yes">
|
|
<Overload retVal="" descr="xrange([start,] stop[, step]) -> xrange object

Like range(), but instead of returning a list, returns an object that
generates the numbers in the range on demand. For looping, this is 
slightly faster than range() and more memory efficient.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="xreadlines" func="yes">
|
|
<Overload retVal="" descr="xreadlines() -> returns self.

For backward compatibility. File objects now include the performance
optimizations previously implemented in the xreadlines module.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="yield" />
|
|
<KeyWord name="zfill" func="yes">
|
|
<Overload retVal="" descr="B.zfill(width) -> copy of B

Pad a numeric string B with zeros on the left, to fill a field
of the specified width. B is never truncated.">
|
|
</Overload>
|
|
</KeyWord>
|
|
<KeyWord name="zip" func="yes">
|
|
<Overload retVal="" descr="zip(seq1 [, seq2 [...]]) -> [(seq1[0], seq2[0] ...), (...)]

Return a list of tuples, where each tuple contains the i-th element
from each of the argument sequences. The returned list is truncated
in length to the length of the shortest argument sequence.">
|
|
</Overload>
|
|
</KeyWord>
|
|
</AutoComplete>
|
|
</NotepadPlus>
|