| | |
- object
-
- basestring
-
- str
- str
- unicode
- buffer
- bytearray
- classmethod
- complex
- dict
- enumerate
- file
- float
- frozenset
- int
-
- bool
- list
- long
- memoryview
- property
- reversed
- set
- slice
- staticmethod
- super
- tuple
- type
- xrange
class bool(int) |
| |
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. |
| |
- Method resolution order:
- bool
- int
- object
Methods defined here:
- __and__(...)
- x.__and__(y) <==> x&y
- __or__(...)
- x.__or__(y) <==> x|y
- __rand__(...)
- x.__rand__(y) <==> y&x
- __repr__(...)
- x.__repr__() <==> repr(x)
- __ror__(...)
- x.__ror__(y) <==> y|x
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __str__(...)
- x.__str__() <==> str(x)
- __xor__(...)
- x.__xor__(y) <==> x^y
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
Methods inherited from int:
- __abs__(...)
- x.__abs__() <==> abs(x)
- __add__(...)
- x.__add__(y) <==> x+y
- __cmp__(...)
- x.__cmp__(y) <==> cmp(x,y)
- __coerce__(...)
- x.__coerce__(y) <==> coerce(x, y)
- __div__(...)
- x.__div__(y) <==> x/y
- __divmod__(...)
- x.__divmod__(y) <==> divmod(x, y)
- __float__(...)
- x.__float__() <==> float(x)
- __floordiv__(...)
- x.__floordiv__(y) <==> x//y
- __format__(...)
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __getnewargs__(...)
- __hash__(...)
- x.__hash__() <==> hash(x)
- __hex__(...)
- x.__hex__() <==> hex(x)
- __index__(...)
- x[y:z] <==> x[y.__index__():z.__index__()]
- __int__(...)
- x.__int__() <==> int(x)
- __invert__(...)
- x.__invert__() <==> ~x
- __long__(...)
- x.__long__() <==> long(x)
- __lshift__(...)
- x.__lshift__(y) <==> x<<y
- __mod__(...)
- x.__mod__(y) <==> x%y
- __mul__(...)
- x.__mul__(y) <==> x*y
- __neg__(...)
- x.__neg__() <==> -x
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rdiv__(...)
- x.__rdiv__(y) <==> y/x
- __rdivmod__(...)
- x.__rdivmod__(y) <==> divmod(y, x)
- __rfloordiv__(...)
- x.__rfloordiv__(y) <==> y//x
- __rlshift__(...)
- x.__rlshift__(y) <==> y<<x
- __rmod__(...)
- x.__rmod__(y) <==> y%x
- __rmul__(...)
- x.__rmul__(y) <==> y*x
- __rpow__(...)
- y.__rpow__(x[, z]) <==> pow(x, y[, z])
- __rrshift__(...)
- x.__rrshift__(y) <==> y>>x
- __rshift__(...)
- x.__rshift__(y) <==> x>>y
- __rsub__(...)
- x.__rsub__(y) <==> y-x
- __rtruediv__(...)
- x.__rtruediv__(y) <==> y/x
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __trunc__(...)
- Truncating an Integral returns itself.
- bit_length(...)
- int.bit_length() -> int
Number of bits necessary to represent self in binary.
>>> bin(37)
'0b100101'
>>> (37).bit_length()
6
- conjugate(...)
- Returns self, the complex conjugate of any int.
Data descriptors inherited from int:
- denominator
- the denominator of a rational number in lowest terms
- imag
- the imaginary part of a complex number
- numerator
- the numerator of a rational number in lowest terms
- real
- the real part of a complex number
|
class buffer(object) |
| |
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). |
| |
Methods defined here:
- __add__(...)
- x.__add__(y) <==> x+y
- __cmp__(...)
- x.__cmp__(y) <==> cmp(x,y)
- __delitem__(...)
- x.__delitem__(y) <==> del x[y]
- __delslice__(...)
- x.__delslice__(i, j) <==> del x[i:j]
Use of negative indices is not supported.
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __getslice__(...)
- x.__getslice__(i, j) <==> x[i:j]
Use of negative indices is not supported.
- __hash__(...)
- x.__hash__() <==> hash(x)
- __len__(...)
- x.__len__() <==> len(x)
- __mul__(...)
- x.__mul__(n) <==> x*n
- __repr__(...)
- x.__repr__() <==> repr(x)
- __rmul__(...)
- x.__rmul__(n) <==> n*x
- __setitem__(...)
- x.__setitem__(i, y) <==> x[i]=y
- __setslice__(...)
- x.__setslice__(i, j, y) <==> x[i:j]=y
Use of negative indices is not supported.
- __str__(...)
- x.__str__() <==> str(x)
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class bytearray(object) |
| |
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. |
| |
Methods defined here:
- __add__(...)
- x.__add__(y) <==> x+y
- __alloc__(...)
- B.__alloc__() -> int
Returns the number of bytes actually allocated.
- __contains__(...)
- x.__contains__(y) <==> y in x
- __delitem__(...)
- x.__delitem__(y) <==> del x[y]
- __eq__(...)
- x.__eq__(y) <==> x==y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __gt__(...)
- x.__gt__(y) <==> x>y
- __iadd__(...)
- x.__iadd__(y) <==> x+=y
- __imul__(...)
- x.__imul__(y) <==> x*=y
- __init__(...)
- x.__init__(...) initializes x; see help(type(x)) for signature
- __iter__(...)
- x.__iter__() <==> iter(x)
- __le__(...)
- x.__le__(y) <==> x<=y
- __len__(...)
- x.__len__() <==> len(x)
- __lt__(...)
- x.__lt__(y) <==> x<y
- __mul__(...)
- x.__mul__(n) <==> x*n
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __reduce__(...)
- Return state information for pickling.
- __repr__(...)
- x.__repr__() <==> repr(x)
- __rmul__(...)
- x.__rmul__(n) <==> n*x
- __setitem__(...)
- x.__setitem__(i, y) <==> x[i]=y
- __sizeof__(...)
- B.__sizeof__() -> int
Returns the size of B in memory, in bytes
- __str__(...)
- x.__str__() <==> str(x)
- append(...)
- B.append(int) -> None
Append a single item to the end of B.
- capitalize(...)
- B.capitalize() -> copy of B
Return a copy of B with only its first character capitalized (ASCII)
and the rest lower-cased.
- center(...)
- 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).
- count(...)
- B.count(sub [,start [,end]]) -> int
Return the number of non-overlapping occurrences of subsection sub in
bytes B[start:end]. Optional arguments start and end are interpreted
as in slice notation.
- decode(...)
- B.decode([encoding[, errors]]) -> unicode object.
Decodes B 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.
- endswith(...)
- 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.
- expandtabs(...)
- 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.
- extend(...)
- B.extend(iterable int) -> None
Append all the elements from the iterator or sequence to the
end of B.
- find(...)
- B.find(sub [,start [,end]]) -> int
Return the lowest index in B where subsection sub is found,
such that sub is contained within B[start,end]. Optional
arguments start and end are interpreted as in slice notation.
Return -1 on failure.
- fromhex(...)
- bytearray.fromhex(string) -> bytearray
Create a bytearray object from a string of hexadecimal numbers.
Spaces between two numbers are accepted.
Example: bytearray.fromhex('B9 01EF') -> bytearray(b'\xb9\x01\xef').
- index(...)
- B.index(sub [,start [,end]]) -> int
Like B.find() but raise ValueError when the subsection is not found.
- insert(...)
- B.insert(index, int) -> None
Insert a single item into the bytearray before the given index.
- isalnum(...)
- B.isalnum() -> bool
Return True if all characters in B are alphanumeric
and there is at least one character in B, False otherwise.
- isalpha(...)
- B.isalpha() -> bool
Return True if all characters in B are alphabetic
and there is at least one character in B, False otherwise.
- isdigit(...)
- B.isdigit() -> bool
Return True if all characters in B are digits
and there is at least one character in B, False otherwise.
- islower(...)
- B.islower() -> bool
Return True if all cased characters in B are lowercase and there is
at least one cased character in B, False otherwise.
- isspace(...)
- B.isspace() -> bool
Return True if all characters in B are whitespace
and there is at least one character in B, False otherwise.
- istitle(...)
- B.istitle() -> bool
Return True if B is a titlecased string and there is at least one
character in B, i.e. uppercase characters may only follow uncased
characters and lowercase characters only cased ones. Return False
otherwise.
- isupper(...)
- B.isupper() -> bool
Return True if all cased characters in B are uppercase and there is
at least one cased character in B, False otherwise.
- join(...)
- B.join(iterable_of_bytes) -> bytes
Concatenates any number of bytearray objects, with B in between each pair.
- ljust(...)
- B.ljust(width[, fillchar]) -> copy of B
Return B left justified in a string of length width. Padding is
done using the specified fill character (default is a space).
- lower(...)
- B.lower() -> copy of B
Return a copy of B with all ASCII characters converted to lowercase.
- lstrip(...)
- B.lstrip([bytes]) -> bytearray
Strip leading bytes contained in the argument.
If the argument is omitted, strip leading ASCII whitespace.
- partition(...)
- B.partition(sep) -> (head, sep, tail)
Searches for the separator sep in B, and returns the part before it,
the separator itself, and the part after it. If the separator is not
found, returns B and two empty bytearray objects.
- pop(...)
- B.pop([index]) -> int
Remove and return a single item from B. If no index
argument is given, will pop the last value.
- remove(...)
- B.remove(int) -> None
Remove the first occurance of a value in B.
- replace(...)
- 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.
- reverse(...)
- B.reverse() -> None
Reverse the order of the values in B in place.
- rfind(...)
- B.rfind(sub [,start [,end]]) -> int
Return the highest index in B where subsection sub is found,
such that sub is contained within B[start,end]. Optional
arguments start and end are interpreted as in slice notation.
Return -1 on failure.
- rindex(...)
- B.rindex(sub [,start [,end]]) -> int
Like B.rfind() but raise ValueError when the subsection is not found.
- rjust(...)
- 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)
- rpartition(...)
- 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.
- rsplit(...)
- B.rsplit(sep[, maxsplit]) -> list of bytearray
Return a list of the sections in B, using sep as the delimiter,
starting at the end of B and working to the front.
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.
- rstrip(...)
- B.rstrip([bytes]) -> bytearray
Strip trailing bytes contained in the argument.
If the argument is omitted, strip trailing ASCII whitespace.
- split(...)
- 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.
- splitlines(...)
- B.splitlines(keepends=False) -> list of lines
Return a list of the lines in B, breaking at line boundaries.
Line breaks are not included in the resulting list unless keepends
is given and true.
- startswith(...)
- B.startswith(prefix [,start [,end]]) -> bool
Return True if B starts with the specified prefix, False otherwise.
With optional start, test B beginning at that position.
With optional end, stop comparing B at that position.
prefix can also be a tuple of strings to try.
- strip(...)
- B.strip([bytes]) -> bytearray
Strip leading and trailing bytes contained in the argument.
If the argument is omitted, strip ASCII whitespace.
- swapcase(...)
- B.swapcase() -> copy of B
Return a copy of B with uppercase ASCII characters converted
to lowercase ASCII and vice versa.
- title(...)
- B.title() -> copy of B
Return a titlecased version of B, i.e. ASCII words start with uppercase
characters, all remaining cased characters have lowercase.
- translate(...)
- 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.
- upper(...)
- B.upper() -> copy of B
Return a copy of B with all ASCII characters converted to uppercase.
- zfill(...)
- 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.
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
bytes = class str(basestring) |
| |
str(object='') -> string
Return a nice string representation of the object.
If the argument is a string, the return value is the same object. |
| |
- Method resolution order:
- str
- basestring
- object
Methods defined here:
- __add__(...)
- x.__add__(y) <==> x+y
- __contains__(...)
- x.__contains__(y) <==> y in x
- __eq__(...)
- x.__eq__(y) <==> x==y
- __format__(...)
- S.__format__(format_spec) -> string
Return a formatted version of S as described by format_spec.
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __getnewargs__(...)
- __getslice__(...)
- x.__getslice__(i, j) <==> x[i:j]
Use of negative indices is not supported.
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hash__(...)
- x.__hash__() <==> hash(x)
- __le__(...)
- x.__le__(y) <==> x<=y
- __len__(...)
- x.__len__() <==> len(x)
- __lt__(...)
- x.__lt__(y) <==> x<y
- __mod__(...)
- x.__mod__(y) <==> x%y
- __mul__(...)
- x.__mul__(n) <==> x*n
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __repr__(...)
- x.__repr__() <==> repr(x)
- __rmod__(...)
- x.__rmod__(y) <==> y%x
- __rmul__(...)
- x.__rmul__(n) <==> n*x
- __sizeof__(...)
- S.__sizeof__() -> size of S in memory, in bytes
- __str__(...)
- x.__str__() <==> str(x)
- capitalize(...)
- S.capitalize() -> string
Return a copy of the string S with only its first character
capitalized.
- center(...)
- S.center(width[, fillchar]) -> string
Return S centered in a string of length width. Padding is
done using the specified fill character (default is a space)
- count(...)
- S.count(sub[, start[, end]]) -> int
Return the number of non-overlapping occurrences of substring sub in
string S[start:end]. Optional arguments start and end are interpreted
as in slice notation.
- decode(...)
- 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.
- encode(...)
- S.encode([encoding[,errors]]) -> object
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 is able to handle UnicodeEncodeErrors.
- endswith(...)
- S.endswith(suffix[, start[, end]]) -> bool
Return True if S ends with the specified suffix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
suffix can also be a tuple of strings to try.
- expandtabs(...)
- S.expandtabs([tabsize]) -> string
Return a copy of S where all tab characters are expanded using spaces.
If tabsize is not given, a tab size of 8 characters is assumed.
- find(...)
- 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.
- format(...)
- S.format(*args, **kwargs) -> string
Return a formatted version of S, using substitutions from args and kwargs.
The substitutions are identified by braces ('{' and '}').
- index(...)
- S.index(sub [,start [,end]]) -> int
Like S.find() but raise ValueError when the substring is not found.
- isalnum(...)
- S.isalnum() -> bool
Return True if all characters in S are alphanumeric
and there is at least one character in S, False otherwise.
- isalpha(...)
- S.isalpha() -> bool
Return True if all characters in S are alphabetic
and there is at least one character in S, False otherwise.
- isdigit(...)
- S.isdigit() -> bool
Return True if all characters in S are digits
and there is at least one character in S, False otherwise.
- islower(...)
- 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.
- isspace(...)
- S.isspace() -> bool
Return True if all characters in S are whitespace
and there is at least one character in S, False otherwise.
- istitle(...)
- 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.
- isupper(...)
- 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.
- join(...)
- S.join(iterable) -> string
Return a string which is the concatenation of the strings in the
iterable. The separator between elements is S.
- ljust(...)
- 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).
- lower(...)
- S.lower() -> string
Return a copy of the string S converted to lowercase.
- lstrip(...)
- 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
- partition(...)
- 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.
- replace(...)
- S.replace(old, new[, count]) -> string
Return a copy of string S with all occurrences of substring
old replaced by new. If the optional argument count is
given, only the first count occurrences are replaced.
- rfind(...)
- S.rfind(sub [,start [,end]]) -> int
Return the highest 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.
- rindex(...)
- S.rindex(sub [,start [,end]]) -> int
Like S.rfind() but raise ValueError when the substring is not found.
- rjust(...)
- S.rjust(width[, fillchar]) -> string
Return S right-justified in a string of length width. Padding is
done using the specified fill character (default is a space)
- rpartition(...)
- S.rpartition(sep) -> (head, sep, tail)
Search for the separator sep in S, starting at the end of S, and return
the part before it, the separator itself, and the part after it. If the
separator is not found, return two empty strings and S.
- rsplit(...)
- 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.
- rstrip(...)
- 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
- split(...)
- S.split([sep [,maxsplit]]) -> list of strings
Return a list of the words in the string S, using sep as the
delimiter string. If maxsplit is given, at most maxsplit
splits are done. If sep is not specified or is None, any
whitespace string is a separator and empty strings are removed
from the result.
- splitlines(...)
- S.splitlines(keepends=False) -> 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.
- startswith(...)
- 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.
- strip(...)
- 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
- swapcase(...)
- S.swapcase() -> string
Return a copy of the string S with uppercase characters
converted to lowercase and vice versa.
- title(...)
- S.title() -> string
Return a titlecased version of S, i.e. words start with uppercase
characters, all remaining cased characters have lowercase.
- translate(...)
- S.translate(table [,deletechars]) -> string
Return a copy of the string S, 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 string of length 256 or None.
If the table argument is None, no translation is applied and
the operation simply removes the characters in deletechars.
- upper(...)
- S.upper() -> string
Return a copy of the string S converted to uppercase.
- zfill(...)
- S.zfill(width) -> string
Pad a numeric string S with zeros on the left, to fill a field
of the specified width. The string S is never truncated.
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class classmethod(object) |
| |
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. |
| |
Methods defined here:
- __get__(...)
- descr.__get__(obj[, type]) -> value
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __init__(...)
- x.__init__(...) initializes x; see help(type(x)) for signature
Data descriptors defined here:
- __func__
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class complex(object) |
| |
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. |
| |
Methods defined here:
- __abs__(...)
- x.__abs__() <==> abs(x)
- __add__(...)
- x.__add__(y) <==> x+y
- __coerce__(...)
- x.__coerce__(y) <==> coerce(x, y)
- __div__(...)
- x.__div__(y) <==> x/y
- __divmod__(...)
- x.__divmod__(y) <==> divmod(x, y)
- __eq__(...)
- x.__eq__(y) <==> x==y
- __float__(...)
- x.__float__() <==> float(x)
- __floordiv__(...)
- x.__floordiv__(y) <==> x//y
- __format__(...)
- complex.__format__() -> str
Converts to a string according to format_spec.
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __getnewargs__(...)
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hash__(...)
- x.__hash__() <==> hash(x)
- __int__(...)
- x.__int__() <==> int(x)
- __le__(...)
- x.__le__(y) <==> x<=y
- __long__(...)
- x.__long__() <==> long(x)
- __lt__(...)
- x.__lt__(y) <==> x<y
- __mod__(...)
- x.__mod__(y) <==> x%y
- __mul__(...)
- x.__mul__(y) <==> x*y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __neg__(...)
- x.__neg__() <==> -x
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rdiv__(...)
- x.__rdiv__(y) <==> y/x
- __rdivmod__(...)
- x.__rdivmod__(y) <==> divmod(y, x)
- __repr__(...)
- x.__repr__() <==> repr(x)
- __rfloordiv__(...)
- x.__rfloordiv__(y) <==> y//x
- __rmod__(...)
- x.__rmod__(y) <==> y%x
- __rmul__(...)
- x.__rmul__(y) <==> y*x
- __rpow__(...)
- y.__rpow__(x[, z]) <==> pow(x, y[, z])
- __rsub__(...)
- x.__rsub__(y) <==> y-x
- __rtruediv__(...)
- x.__rtruediv__(y) <==> y/x
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- conjugate(...)
- complex.conjugate() -> complex
Returns the complex conjugate of its argument. (3-4j).conjugate() == 3+4j.
Data descriptors defined here:
- imag
- the imaginary part of a complex number
- real
- the real part of a complex number
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class dict(object) |
| |
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) |
| |
Methods defined here:
- __cmp__(...)
- x.__cmp__(y) <==> cmp(x,y)
- __contains__(...)
- D.__contains__(k) -> True if D has a key k, else False
- __delitem__(...)
- x.__delitem__(y) <==> del x[y]
- __eq__(...)
- x.__eq__(y) <==> x==y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __gt__(...)
- x.__gt__(y) <==> x>y
- __init__(...)
- x.__init__(...) initializes x; see help(type(x)) for signature
- __iter__(...)
- x.__iter__() <==> iter(x)
- __le__(...)
- x.__le__(y) <==> x<=y
- __len__(...)
- x.__len__() <==> len(x)
- __lt__(...)
- x.__lt__(y) <==> x<y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __repr__(...)
- x.__repr__() <==> repr(x)
- __setitem__(...)
- x.__setitem__(i, y) <==> x[i]=y
- __sizeof__(...)
- D.__sizeof__() -> size of D in memory, in bytes
- clear(...)
- D.clear() -> None. Remove all items from D.
- copy(...)
- D.copy() -> a shallow copy of D
- fromkeys(...)
- dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.
v defaults to None.
- get(...)
- D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None.
- has_key(...)
- D.has_key(k) -> True if D has a key k, else False
- items(...)
- D.items() -> list of D's (key, value) pairs, as 2-tuples
- iteritems(...)
- D.iteritems() -> an iterator over the (key, value) items of D
- iterkeys(...)
- D.iterkeys() -> an iterator over the keys of D
- itervalues(...)
- D.itervalues() -> an iterator over the values of D
- keys(...)
- D.keys() -> list of D's keys
- pop(...)
- D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
If key is not found, d is returned if given, otherwise KeyError is raised
- popitem(...)
- D.popitem() -> (k, v), remove and return some (key, value) pair as a
2-tuple; but raise KeyError if D is empty.
- setdefault(...)
- D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
- update(...)
- D.update([E, ]**F) -> None. Update D from dict/iterable E and F.
If E present and has a .keys() method, does: for k in E: D[k] = E[k]
If E present and 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]
- values(...)
- D.values() -> list of D's values
- viewitems(...)
- D.viewitems() -> a set-like object providing a view on D's items
- viewkeys(...)
- D.viewkeys() -> a set-like object providing a view on D's keys
- viewvalues(...)
- D.viewvalues() -> an object providing a view on D's values
Data and other attributes defined here:
- __hash__ = None
- __new__ = <built-in method __new__ of type object>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class enumerate(object) |
| |
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]), ... |
| |
Methods defined here:
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __iter__(...)
- x.__iter__() <==> iter(x)
- next(...)
- x.next() -> the next value, or raise StopIteration
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class file(object) |
| |
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. |
| |
Methods defined here:
- __delattr__(...)
- x.__delattr__('name') <==> del x.name
- __enter__(...)
- __enter__() -> self.
- __exit__(...)
- __exit__(*excinfo) -> None. Closes the file.
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __init__(...)
- x.__init__(...) initializes x; see help(type(x)) for signature
- __iter__(...)
- x.__iter__() <==> iter(x)
- __repr__(...)
- x.__repr__() <==> repr(x)
- __setattr__(...)
- x.__setattr__('name', value) <==> x.name = value
- close(...)
- 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.
- fileno(...)
- fileno() -> integer "file descriptor".
This is needed for lower-level file interfaces, such os.read().
- flush(...)
- flush() -> None. Flush the internal I/O buffer.
- isatty(...)
- isatty() -> true or false. True if the file is connected to a tty device.
- next(...)
- x.next() -> the next value, or raise StopIteration
- read(...)
- 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.
- readinto(...)
- readinto() -> Undocumented. Don't use this; it may go away.
- readline(...)
- 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.
- readlines(...)
- 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.
- seek(...)
- 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.
- tell(...)
- tell() -> current file position, an integer (may be a long integer).
- truncate(...)
- truncate([size]) -> None. Truncate the file to at most size bytes.
Size defaults to the current file position, as returned by tell().
- write(...)
- 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.
- writelines(...)
- 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.
- xreadlines(...)
- xreadlines() -> returns self.
For backward compatibility. File objects now include the performance
optimizations previously implemented in the xreadlines module.
Data descriptors defined here:
- closed
- True if the file is closed
- encoding
- file encoding
- errors
- Unicode error handler
- mode
- file mode ('r', 'U', 'w', 'a', possibly with 'b' or '+' added)
- name
- file name
- newlines
- end-of-line convention used in this file
- softspace
- flag indicating that a space needs to be printed; used by print
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class float(object) |
| |
float(x) -> floating point number
Convert a string or number to a floating point number, if possible. |
| |
Methods defined here:
- __abs__(...)
- x.__abs__() <==> abs(x)
- __add__(...)
- x.__add__(y) <==> x+y
- __coerce__(...)
- x.__coerce__(y) <==> coerce(x, y)
- __div__(...)
- x.__div__(y) <==> x/y
- __divmod__(...)
- x.__divmod__(y) <==> divmod(x, y)
- __eq__(...)
- x.__eq__(y) <==> x==y
- __float__(...)
- x.__float__() <==> float(x)
- __floordiv__(...)
- x.__floordiv__(y) <==> x//y
- __format__(...)
- float.__format__(format_spec) -> string
Formats the float according to format_spec.
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __getformat__(...)
- float.__getformat__(typestr) -> string
You probably don't want to use this function. It exists mainly to be
used in Python's test suite.
typestr must be 'double' or 'float'. This function returns whichever of
'unknown', 'IEEE, big-endian' or 'IEEE, little-endian' best describes the
format of floating point numbers used by the C type named by typestr.
- __getnewargs__(...)
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hash__(...)
- x.__hash__() <==> hash(x)
- __int__(...)
- x.__int__() <==> int(x)
- __le__(...)
- x.__le__(y) <==> x<=y
- __long__(...)
- x.__long__() <==> long(x)
- __lt__(...)
- x.__lt__(y) <==> x<y
- __mod__(...)
- x.__mod__(y) <==> x%y
- __mul__(...)
- x.__mul__(y) <==> x*y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __neg__(...)
- x.__neg__() <==> -x
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rdiv__(...)
- x.__rdiv__(y) <==> y/x
- __rdivmod__(...)
- x.__rdivmod__(y) <==> divmod(y, x)
- __repr__(...)
- x.__repr__() <==> repr(x)
- __rfloordiv__(...)
- x.__rfloordiv__(y) <==> y//x
- __rmod__(...)
- x.__rmod__(y) <==> y%x
- __rmul__(...)
- x.__rmul__(y) <==> y*x
- __rpow__(...)
- y.__rpow__(x[, z]) <==> pow(x, y[, z])
- __rsub__(...)
- x.__rsub__(y) <==> y-x
- __rtruediv__(...)
- x.__rtruediv__(y) <==> y/x
- __setformat__(...)
- float.__setformat__(typestr, fmt) -> None
You probably don't want to use this function. It exists mainly to be
used in Python's test suite.
typestr must be 'double' or 'float'. fmt must be one of 'unknown',
'IEEE, big-endian' or 'IEEE, little-endian', and in addition can only be
one of the latter two if it appears to match the underlying C reality.
Overrides the automatic determination of C-level floating point type.
This affects how floats are converted to and from binary strings.
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __trunc__(...)
- Returns the Integral closest to x between 0 and x.
- as_integer_ratio(...)
- 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)
- conjugate(...)
- Returns self, the complex conjugate of any float.
- fromhex(...)
- 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
- hex(...)
- float.hex() -> string
Return a hexadecimal representation of a floating-point number.
>>> (-0.1).hex()
'-0x1.999999999999ap-4'
>>> 3.14159.hex()
'0x1.921f9f01b866ep+1'
- is_integer(...)
- Returns True if the float is an integer.
Data descriptors defined here:
- imag
- the imaginary part of a complex number
- real
- the real part of a complex number
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class int(object) |
| |
int(x=0) -> int or long
int(x, base=10) -> int or long
Convert a number or string to an integer, or return 0 if no arguments
are given. If x is floating point, the conversion truncates towards zero.
If x is outside the integer range, the function returns a long instead.
If x is not a number or if base is given, then x must be a string or
Unicode object representing an integer literal in the given base. The
literal can be preceded by '+' or '-' and be surrounded by whitespace.
The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to
interpret the base from the string as an integer literal.
>>> int('0b100', base=0)
4 |
| |
Methods defined here:
- __abs__(...)
- x.__abs__() <==> abs(x)
- __add__(...)
- x.__add__(y) <==> x+y
- __and__(...)
- x.__and__(y) <==> x&y
- __cmp__(...)
- x.__cmp__(y) <==> cmp(x,y)
- __coerce__(...)
- x.__coerce__(y) <==> coerce(x, y)
- __div__(...)
- x.__div__(y) <==> x/y
- __divmod__(...)
- x.__divmod__(y) <==> divmod(x, y)
- __float__(...)
- x.__float__() <==> float(x)
- __floordiv__(...)
- x.__floordiv__(y) <==> x//y
- __format__(...)
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __getnewargs__(...)
- __hash__(...)
- x.__hash__() <==> hash(x)
- __hex__(...)
- x.__hex__() <==> hex(x)
- __index__(...)
- x[y:z] <==> x[y.__index__():z.__index__()]
- __int__(...)
- x.__int__() <==> int(x)
- __invert__(...)
- x.__invert__() <==> ~x
- __long__(...)
- x.__long__() <==> long(x)
- __lshift__(...)
- x.__lshift__(y) <==> x<<y
- __mod__(...)
- x.__mod__(y) <==> x%y
- __mul__(...)
- x.__mul__(y) <==> x*y
- __neg__(...)
- x.__neg__() <==> -x
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(y) <==> y&x
- __rdiv__(...)
- x.__rdiv__(y) <==> y/x
- __rdivmod__(...)
- x.__rdivmod__(y) <==> divmod(y, x)
- __repr__(...)
- x.__repr__() <==> repr(x)
- __rfloordiv__(...)
- x.__rfloordiv__(y) <==> y//x
- __rlshift__(...)
- x.__rlshift__(y) <==> y<<x
- __rmod__(...)
- x.__rmod__(y) <==> y%x
- __rmul__(...)
- x.__rmul__(y) <==> y*x
- __ror__(...)
- x.__ror__(y) <==> y|x
- __rpow__(...)
- y.__rpow__(x[, z]) <==> pow(x, y[, z])
- __rrshift__(...)
- x.__rrshift__(y) <==> y>>x
- __rshift__(...)
- x.__rshift__(y) <==> x>>y
- __rsub__(...)
- x.__rsub__(y) <==> y-x
- __rtruediv__(...)
- x.__rtruediv__(y) <==> y/x
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __trunc__(...)
- Truncating an Integral returns itself.
- __xor__(...)
- x.__xor__(y) <==> x^y
- bit_length(...)
- int.bit_length() -> int
Number of bits necessary to represent self in binary.
>>> bin(37)
'0b100101'
>>> (37).bit_length()
6
- conjugate(...)
- Returns self, the complex conjugate of any int.
Data descriptors defined here:
- denominator
- the denominator of a rational number in lowest terms
- imag
- the imaginary part of a complex number
- numerator
- the numerator of a rational number in lowest terms
- real
- the real part of a complex number
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class list(object) |
| |
list() -> new empty list
list(iterable) -> new list initialized from iterable's items |
| |
Methods defined here:
- __add__(...)
- x.__add__(y) <==> x+y
- __contains__(...)
- x.__contains__(y) <==> y in x
- __delitem__(...)
- x.__delitem__(y) <==> del x[y]
- __delslice__(...)
- x.__delslice__(i, j) <==> del x[i:j]
Use of negative indices is not supported.
- __eq__(...)
- x.__eq__(y) <==> x==y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __getslice__(...)
- x.__getslice__(i, j) <==> x[i:j]
Use of negative indices is not supported.
- __gt__(...)
- x.__gt__(y) <==> x>y
- __iadd__(...)
- x.__iadd__(y) <==> x+=y
- __imul__(...)
- x.__imul__(y) <==> x*=y
- __init__(...)
- x.__init__(...) initializes x; see help(type(x)) for signature
- __iter__(...)
- x.__iter__() <==> iter(x)
- __le__(...)
- x.__le__(y) <==> x<=y
- __len__(...)
- x.__len__() <==> len(x)
- __lt__(...)
- x.__lt__(y) <==> x<y
- __mul__(...)
- x.__mul__(n) <==> x*n
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __repr__(...)
- x.__repr__() <==> repr(x)
- __reversed__(...)
- L.__reversed__() -- return a reverse iterator over the list
- __rmul__(...)
- x.__rmul__(n) <==> n*x
- __setitem__(...)
- x.__setitem__(i, y) <==> x[i]=y
- __setslice__(...)
- x.__setslice__(i, j, y) <==> x[i:j]=y
Use of negative indices is not supported.
- __sizeof__(...)
- L.__sizeof__() -- size of L in memory, in bytes
- append(...)
- L.append(object) -- append object to end
- count(...)
- L.count(value) -> integer -- return number of occurrences of value
- extend(...)
- L.extend(iterable) -- extend list by appending elements from the iterable
- index(...)
- L.index(value, [start, [stop]]) -> integer -- return first index of value.
Raises ValueError if the value is not present.
- insert(...)
- L.insert(index, object) -- insert object before index
- pop(...)
- L.pop([index]) -> item -- remove and return item at index (default last).
Raises IndexError if list is empty or index is out of range.
- remove(...)
- L.remove(value) -- remove first occurrence of value.
Raises ValueError if the value is not present.
- reverse(...)
- L.reverse() -- reverse *IN PLACE*
- sort(...)
- L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
cmp(x, y) -> -1, 0, 1
Data and other attributes defined here:
- __hash__ = None
- __new__ = <built-in method __new__ of type object>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class long(object) |
| |
long(x=0) -> long
long(x, base=10) -> long
Convert a number or string to a long integer, or return 0L if no arguments
are given. If x is floating point, the conversion truncates towards zero.
If x is not a number or if base is given, then x must be a string or
Unicode object representing an integer literal in the given base. The
literal can be preceded by '+' or '-' and be surrounded by whitespace.
The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to
interpret the base from the string as an integer literal.
>>> int('0b100', base=0)
4L |
| |
Methods defined here:
- __abs__(...)
- x.__abs__() <==> abs(x)
- __add__(...)
- x.__add__(y) <==> x+y
- __and__(...)
- x.__and__(y) <==> x&y
- __cmp__(...)
- x.__cmp__(y) <==> cmp(x,y)
- __coerce__(...)
- x.__coerce__(y) <==> coerce(x, y)
- __div__(...)
- x.__div__(y) <==> x/y
- __divmod__(...)
- x.__divmod__(y) <==> divmod(x, y)
- __float__(...)
- x.__float__() <==> float(x)
- __floordiv__(...)
- x.__floordiv__(y) <==> x//y
- __format__(...)
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __getnewargs__(...)
- __hash__(...)
- x.__hash__() <==> hash(x)
- __hex__(...)
- x.__hex__() <==> hex(x)
- __index__(...)
- x[y:z] <==> x[y.__index__():z.__index__()]
- __int__(...)
- x.__int__() <==> int(x)
- __invert__(...)
- x.__invert__() <==> ~x
- __long__(...)
- x.__long__() <==> long(x)
- __lshift__(...)
- x.__lshift__(y) <==> x<<y
- __mod__(...)
- x.__mod__(y) <==> x%y
- __mul__(...)
- x.__mul__(y) <==> x*y
- __neg__(...)
- x.__neg__() <==> -x
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(y) <==> y&x
- __rdiv__(...)
- x.__rdiv__(y) <==> y/x
- __rdivmod__(...)
- x.__rdivmod__(y) <==> divmod(y, x)
- __repr__(...)
- x.__repr__() <==> repr(x)
- __rfloordiv__(...)
- x.__rfloordiv__(y) <==> y//x
- __rlshift__(...)
- x.__rlshift__(y) <==> y<<x
- __rmod__(...)
- x.__rmod__(y) <==> y%x
- __rmul__(...)
- x.__rmul__(y) <==> y*x
- __ror__(...)
- x.__ror__(y) <==> y|x
- __rpow__(...)
- y.__rpow__(x[, z]) <==> pow(x, y[, z])
- __rrshift__(...)
- x.__rrshift__(y) <==> y>>x
- __rshift__(...)
- x.__rshift__(y) <==> x>>y
- __rsub__(...)
- x.__rsub__(y) <==> y-x
- __rtruediv__(...)
- x.__rtruediv__(y) <==> y/x
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __sizeof__(...)
- Returns size in memory, in bytes
- __str__(...)
- x.__str__() <==> str(x)
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __trunc__(...)
- Truncating an Integral returns itself.
- __xor__(...)
- x.__xor__(y) <==> x^y
- bit_length(...)
- long.bit_length() -> int or long
Number of bits necessary to represent self in binary.
>>> bin(37L)
'0b100101'
>>> (37L).bit_length()
6
- conjugate(...)
- Returns self, the complex conjugate of any long.
Data descriptors defined here:
- denominator
- the denominator of a rational number in lowest terms
- imag
- the imaginary part of a complex number
- numerator
- the numerator of a rational number in lowest terms
- real
- the real part of a complex number
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class property(object) |
| |
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 |
| |
Methods defined here:
- __delete__(...)
- descr.__delete__(obj)
- __get__(...)
- descr.__get__(obj[, type]) -> value
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __init__(...)
- x.__init__(...) initializes x; see help(type(x)) for signature
- __set__(...)
- descr.__set__(obj, value)
- deleter(...)
- Descriptor to change the deleter on a property.
- getter(...)
- Descriptor to change the getter on a property.
- setter(...)
- Descriptor to change the setter on a property.
Data descriptors defined here:
- fdel
- fget
- fset
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class staticmethod(object) |
| |
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. |
| |
Methods defined here:
- __get__(...)
- descr.__get__(obj[, type]) -> value
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __init__(...)
- x.__init__(...) initializes x; see help(type(x)) for signature
Data descriptors defined here:
- __func__
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class str(basestring) |
| |
str(object='') -> string
Return a nice string representation of the object.
If the argument is a string, the return value is the same object. |
| |
- Method resolution order:
- str
- basestring
- object
Methods defined here:
- __add__(...)
- x.__add__(y) <==> x+y
- __contains__(...)
- x.__contains__(y) <==> y in x
- __eq__(...)
- x.__eq__(y) <==> x==y
- __format__(...)
- S.__format__(format_spec) -> string
Return a formatted version of S as described by format_spec.
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __getnewargs__(...)
- __getslice__(...)
- x.__getslice__(i, j) <==> x[i:j]
Use of negative indices is not supported.
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hash__(...)
- x.__hash__() <==> hash(x)
- __le__(...)
- x.__le__(y) <==> x<=y
- __len__(...)
- x.__len__() <==> len(x)
- __lt__(...)
- x.__lt__(y) <==> x<y
- __mod__(...)
- x.__mod__(y) <==> x%y
- __mul__(...)
- x.__mul__(n) <==> x*n
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __repr__(...)
- x.__repr__() <==> repr(x)
- __rmod__(...)
- x.__rmod__(y) <==> y%x
- __rmul__(...)
- x.__rmul__(n) <==> n*x
- __sizeof__(...)
- S.__sizeof__() -> size of S in memory, in bytes
- __str__(...)
- x.__str__() <==> str(x)
- capitalize(...)
- S.capitalize() -> string
Return a copy of the string S with only its first character
capitalized.
- center(...)
- S.center(width[, fillchar]) -> string
Return S centered in a string of length width. Padding is
done using the specified fill character (default is a space)
- count(...)
- S.count(sub[, start[, end]]) -> int
Return the number of non-overlapping occurrences of substring sub in
string S[start:end]. Optional arguments start and end are interpreted
as in slice notation.
- decode(...)
- 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.
- encode(...)
- S.encode([encoding[,errors]]) -> object
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 is able to handle UnicodeEncodeErrors.
- endswith(...)
- S.endswith(suffix[, start[, end]]) -> bool
Return True if S ends with the specified suffix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
suffix can also be a tuple of strings to try.
- expandtabs(...)
- S.expandtabs([tabsize]) -> string
Return a copy of S where all tab characters are expanded using spaces.
If tabsize is not given, a tab size of 8 characters is assumed.
- find(...)
- 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.
- format(...)
- S.format(*args, **kwargs) -> string
Return a formatted version of S, using substitutions from args and kwargs.
The substitutions are identified by braces ('{' and '}').
- index(...)
- S.index(sub [,start [,end]]) -> int
Like S.find() but raise ValueError when the substring is not found.
- isalnum(...)
- S.isalnum() -> bool
Return True if all characters in S are alphanumeric
and there is at least one character in S, False otherwise.
- isalpha(...)
- S.isalpha() -> bool
Return True if all characters in S are alphabetic
and there is at least one character in S, False otherwise.
- isdigit(...)
- S.isdigit() -> bool
Return True if all characters in S are digits
and there is at least one character in S, False otherwise.
- islower(...)
- 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.
- isspace(...)
- S.isspace() -> bool
Return True if all characters in S are whitespace
and there is at least one character in S, False otherwise.
- istitle(...)
- 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.
- isupper(...)
- 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.
- join(...)
- S.join(iterable) -> string
Return a string which is the concatenation of the strings in the
iterable. The separator between elements is S.
- ljust(...)
- 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).
- lower(...)
- S.lower() -> string
Return a copy of the string S converted to lowercase.
- lstrip(...)
- 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
- partition(...)
- 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.
- replace(...)
- S.replace(old, new[, count]) -> string
Return a copy of string S with all occurrences of substring
old replaced by new. If the optional argument count is
given, only the first count occurrences are replaced.
- rfind(...)
- S.rfind(sub [,start [,end]]) -> int
Return the highest 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.
- rindex(...)
- S.rindex(sub [,start [,end]]) -> int
Like S.rfind() but raise ValueError when the substring is not found.
- rjust(...)
- S.rjust(width[, fillchar]) -> string
Return S right-justified in a string of length width. Padding is
done using the specified fill character (default is a space)
- rpartition(...)
- S.rpartition(sep) -> (head, sep, tail)
Search for the separator sep in S, starting at the end of S, and return
the part before it, the separator itself, and the part after it. If the
separator is not found, return two empty strings and S.
- rsplit(...)
- 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.
- rstrip(...)
- 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
- split(...)
- S.split([sep [,maxsplit]]) -> list of strings
Return a list of the words in the string S, using sep as the
delimiter string. If maxsplit is given, at most maxsplit
splits are done. If sep is not specified or is None, any
whitespace string is a separator and empty strings are removed
from the result.
- splitlines(...)
- S.splitlines(keepends=False) -> 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.
- startswith(...)
- 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.
- strip(...)
- 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
- swapcase(...)
- S.swapcase() -> string
Return a copy of the string S with uppercase characters
converted to lowercase and vice versa.
- title(...)
- S.title() -> string
Return a titlecased version of S, i.e. words start with uppercase
characters, all remaining cased characters have lowercase.
- translate(...)
- S.translate(table [,deletechars]) -> string
Return a copy of the string S, 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 string of length 256 or None.
If the table argument is None, no translation is applied and
the operation simply removes the characters in deletechars.
- upper(...)
- S.upper() -> string
Return a copy of the string S converted to uppercase.
- zfill(...)
- S.zfill(width) -> string
Pad a numeric string S with zeros on the left, to fill a field
of the specified width. The string S is never truncated.
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class unicode(basestring) |
| |
unicode(object='') -> unicode object
unicode(string[, encoding[, errors]]) -> unicode 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'. |
| |
- Method resolution order:
- unicode
- basestring
- object
Methods defined here:
- __add__(...)
- x.__add__(y) <==> x+y
- __contains__(...)
- x.__contains__(y) <==> y in x
- __eq__(...)
- x.__eq__(y) <==> x==y
- __format__(...)
- S.__format__(format_spec) -> unicode
Return a formatted version of S as described by format_spec.
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __getnewargs__(...)
- __getslice__(...)
- x.__getslice__(i, j) <==> x[i:j]
Use of negative indices is not supported.
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hash__(...)
- x.__hash__() <==> hash(x)
- __le__(...)
- x.__le__(y) <==> x<=y
- __len__(...)
- x.__len__() <==> len(x)
- __lt__(...)
- x.__lt__(y) <==> x<y
- __mod__(...)
- x.__mod__(y) <==> x%y
- __mul__(...)
- x.__mul__(n) <==> x*n
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __repr__(...)
- x.__repr__() <==> repr(x)
- __rmod__(...)
- x.__rmod__(y) <==> y%x
- __rmul__(...)
- x.__rmul__(n) <==> n*x
- __sizeof__(...)
- S.__sizeof__() -> size of S in memory, in bytes
- __str__(...)
- x.__str__() <==> str(x)
- capitalize(...)
- S.capitalize() -> unicode
Return a capitalized version of S, i.e. make the first character
have upper case and the rest lower case.
- center(...)
- S.center(width[, fillchar]) -> unicode
Return S centered in a Unicode string of length width. Padding is
done using the specified fill character (default is a space)
- count(...)
- S.count(sub[, start[, end]]) -> int
Return the number of non-overlapping occurrences of substring sub in
Unicode string S[start:end]. Optional arguments start and end are
interpreted as in slice notation.
- decode(...)
- S.decode([encoding[,errors]]) -> string or unicode
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.
- encode(...)
- 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.
- endswith(...)
- S.endswith(suffix[, start[, end]]) -> bool
Return True if S ends with the specified suffix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
suffix can also be a tuple of strings to try.
- expandtabs(...)
- S.expandtabs([tabsize]) -> unicode
Return a copy of S where all tab characters are expanded using spaces.
If tabsize is not given, a tab size of 8 characters is assumed.
- find(...)
- 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.
- format(...)
- S.format(*args, **kwargs) -> unicode
Return a formatted version of S, using substitutions from args and kwargs.
The substitutions are identified by braces ('{' and '}').
- index(...)
- S.index(sub [,start [,end]]) -> int
Like S.find() but raise ValueError when the substring is not found.
- isalnum(...)
- S.isalnum() -> bool
Return True if all characters in S are alphanumeric
and there is at least one character in S, False otherwise.
- isalpha(...)
- S.isalpha() -> bool
Return True if all characters in S are alphabetic
and there is at least one character in S, False otherwise.
- isdecimal(...)
- S.isdecimal() -> bool
Return True if there are only decimal characters in S,
False otherwise.
- isdigit(...)
- S.isdigit() -> bool
Return True if all characters in S are digits
and there is at least one character in S, False otherwise.
- islower(...)
- 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.
- isnumeric(...)
- S.isnumeric() -> bool
Return True if there are only numeric characters in S,
False otherwise.
- isspace(...)
- S.isspace() -> bool
Return True if all characters in S are whitespace
and there is at least one character in S, False otherwise.
- istitle(...)
- S.istitle() -> bool
Return True if S is a titlecased string and there is at least one
character in S, i.e. upper- and titlecase characters may only
follow uncased characters and lowercase characters only cased ones.
Return False otherwise.
- isupper(...)
- 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.
- join(...)
- S.join(iterable) -> unicode
Return a string which is the concatenation of the strings in the
iterable. The separator between elements is S.
- ljust(...)
- S.ljust(width[, fillchar]) -> int
Return S left-justified in a Unicode string of length width. Padding is
done using the specified fill character (default is a space).
- lower(...)
- S.lower() -> unicode
Return a copy of the string S converted to lowercase.
- lstrip(...)
- S.lstrip([chars]) -> 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 a str, it will be converted to unicode before stripping
- partition(...)
- 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.
- replace(...)
- S.replace(old, new[, count]) -> unicode
Return a copy of S with all occurrences of substring
old replaced by new. If the optional argument count is
given, only the first count occurrences are replaced.
- rfind(...)
- S.rfind(sub [,start [,end]]) -> int
Return the highest 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.
- rindex(...)
- S.rindex(sub [,start [,end]]) -> int
Like S.rfind() but raise ValueError when the substring is not found.
- rjust(...)
- S.rjust(width[, fillchar]) -> unicode
Return S right-justified in a Unicode string of length width. Padding is
done using the specified fill character (default is a space).
- rpartition(...)
- S.rpartition(sep) -> (head, sep, tail)
Search for the separator sep in S, starting at the end of S, and return
the part before it, the separator itself, and the part after it. If the
separator is not found, return two empty strings and S.
- rsplit(...)
- S.rsplit([sep [,maxsplit]]) -> list of strings
Return a list of the words in 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, any whitespace string
is a separator.
- rstrip(...)
- S.rstrip([chars]) -> 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 a str, it will be converted to unicode before stripping
- split(...)
- S.split([sep [,maxsplit]]) -> list of strings
Return a list of the words in S, using sep as the
delimiter string. If maxsplit is given, at most maxsplit
splits are done. If sep is not specified or is None, any
whitespace string is a separator and empty strings are
removed from the result.
- splitlines(...)
- S.splitlines(keepends=False) -> 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.
- startswith(...)
- 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.
- strip(...)
- S.strip([chars]) -> 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 a str, it will be converted to unicode before stripping
- swapcase(...)
- S.swapcase() -> unicode
Return a copy of S with uppercase characters converted to lowercase
and vice versa.
- title(...)
- S.title() -> unicode
Return a titlecased version of S, i.e. words start with title case
characters, all remaining cased characters have lower case.
- translate(...)
- S.translate(table) -> unicode
Return a copy of the string S, where all characters have been mapped
through the given translation table, which must be a mapping of
Unicode ordinals to Unicode ordinals, Unicode strings or None.
Unmapped characters are left untouched. Characters mapped to None
are deleted.
- upper(...)
- S.upper() -> unicode
Return a copy of S converted to uppercase.
- zfill(...)
- S.zfill(width) -> unicode
Pad a numeric string S with zeros on the left, to fill a field
of the specified width. The string S is never truncated.
Data and other attributes defined here:
- __new__ = <built-in method __new__ of type object>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
|


Move mouse to change perspective.
Drag and drop or select a JPG file taken with Android Camera using Lens Blur option.


New User Register
Existing User
A verification code has been sent to your mobile xxxxxxxxxx by SMS. Please enter the verification code.
Resend ?
Verify
Name:
Password:
Submit


Sample Web Application that uses a managed relational database service such as Google CloudSQL or Amazon RDS.
UT UTAlsjkjsljsjlksjlBCD****123456----123456 Greetings stored in database


Kistner's Flowers
About
About Us
Meet The Staff
Visit Our Store
Help
(800) 532-3409
Sororities
Gamma Phi Beta
Alpha Chi Omega
Alpha Delta Pi
Delta, Delta, Delta
Alpha Xi Delta
Chi Omega
Zeta Tau Alpha
Kappa Alpha Theta
Kappa Kappa Gamma
Kappa Delta
Pi Beta Phi
Sigma Kappa
Occasion
New Baby!
Daily Expressions
Garden Paradise
Wedding
Sympathy
Birthday
Shop All Occasions
${generateCardHTML()}
Policy Pool


MIToS defines methods and types useful for any MSA. The Pfam
module uses other MIToS modules in the context of Pfam MSAs, where it’s possible to us determine how structure and sequence information should be mapped. This module defines functions that go from a Pfam MSA to the protein contact prediction performance of pairwise scores estimated from that MSA.
using MIToS.Pfam
# Truncate IJulia outputs at:
ENV["LINES"] = 15
ENV["COLUMNS"] = 60;
The function downloadpfam
takes a Pfam accession and downloads a Pfam MSA in Stockholm format. Use read
function and the Stockholm
Format
to get a AnnotatedMultipleSequenceAlignment
object with the MSA and its Pfam annotations. You must set generatemapping
and useidcoordinates
to true
the first time you read the downloaded MSA. This is necessary to some of the methods in the Pfam
module.
pfamfile = downloadpfam("PF12464")
msa = read(pfamfile, Stockholm, generatemapping=true, useidcoordinates=true)
The function getseq2pdb
parses the MSA annotations to return a Dict
from the sequence identifier in the MSA to PDB and chain codes.
getseq2pdb(msa)
Once you know the association between PDB chains and sequences, you can use that information together with the msacolumn2pdbresidue
function to get the PDB residue number that correspond to each MSA column for given a determined sequence and PDB chain. That function downloads information from SIFTS to generate the mapping.
col2res = msacolumn2pdbresidue(msa, "MAA_ECOLI/7-58", "1OCX", "C")
The returned dictionary can be used to get the PDB residue associated to each column (using the msaresidues
function)...
using MIToS.PDB
pdbfile = downloadpdb("1OCX")
pdb = read(pdbfile, PDBML)
resdict = @residuesdict pdb model "1" chain "C" group "ATOM" residue "*"
msaresidues(msa, resdict, col2res)
...or to delete the columns without PDB residues (using the hasresidues
function):
using MIToS.MSA
filtercolumns!(msa, hasresidues(msa, col2res))
The Dict
between MSA columns and PDB residue number also can be used to generate a protein contact map associated to the MSA.
cmap = msacontacts(msa, resdict, col2res)
That protein contact map can be used to calculate the Area Under the ROC Curve for a given score with the AUC
function.
using MIToS.Information
ZMIp, MIp = buslje09(msa)
AUC(ZMIp, cmap)


405 Error - Method not allowed
A request was made of a resource using a request method not supported by that resource


The Thief of Baghdad (1940)
Grade: 45
"The Thief of Baghdad" was an elaborate technicolor remake of the 1924 silent classic. Producer Alexander Korda struggled mightily to make the film, going through six directors, and he was forced by the war to move the final production from North Africa to the U.S. The expenses associated with the enormous sets and the early color cinematography made "The Thief of Baghdad" one of the most expensive films ever made to that point, costing more than "Gone With the Wind".
The story is greatly changed from the 1924 version. Douglas Fairbanks' character is split into two roles, a love interest (Ahmad, played by John Justin) and an adolescent thief (Abu, played by Sabu). Ahmad is the puppet prince of evil magician Jaffar (Conrad Veidt).  Ahmad soon falls for a foreign princess (June Duprez), who is the daughter of a foolish, toy-obsessed king (Morton Selten, who is also credited as one of the writers). Jaffar also wants the lovely princess, who in turn pines for Ahmad. Ahmad and Abu spend the rest of the film trying to pry the princess from the clutches of evil Jaffar, frequently performing brave and heroic deeds in the process. These deeds are aided by a bombastic genie (Rex Ingram), an all-seeing eye, a magic bow, and a flying carpet. Many of these story elements later found their way into Disney's "Aladdin" (1992) animated feature.
"The Thief of Baghdad" was nominated for four Academy Awards, including Best Color Cinematography (George Perinal), best sets (Vincent Korda, the producer's brother), Best Special Effects (Lawrence Butler), and Best Original Score (Miklos Rozsa).
"The Thief of Baghdad" is highly regarded today. No amount of web-surfing could come up with a negative comment about the film. But my experience with the film was different. I found the soundtrack blaring, the special effects cheezy, and the entire story was implausible (admittedly from an adult's point of view). I am aware that the film is a fantasy, but then there is the instant, mutual love that Ahmad and the princess have. There is also the obsession that Abu has for Ahmad, and that Jaffar has for the princess. I can accept that there is an all-seeing eye, but not that flinging it against rocks will send you to a sky palace where elderly sultans will greet you as a hero.  I can accept that Abu must kill a giant spider to steal the all-seeing eye, but the eye's 'guardians' seem thoroughly confused.
And, personally, if an evil magician made me blind or turned me into a dog, I wouldn't mess with him anymore. Hey, you can have the princess. It's just not worth it.
<EMAIL_ADDRESS>http://members.tripod.com/~Brian_Koller/movies.html
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Does the DAC grant this researcher permission to access the data?
Please review the Application Summary and Data Use Limitations to answer the two questions below. You may review other DAC votes related to this data access request below the questions on this page.
Please review the Application Summary and Data Use Limitations to answer the question below. You may review other DAC votes related to this data access request below the question on this page.


I started iOS development as a .NET developer. My first impression, Storyboard is really really interesting. 80% UI of my apps is built in Storyboard. I can’t imagine how I can develop iOS without Storyboard.
There are many discussions about Auto Layout with Storyboard or Programmatically is better. But no one wins. Everyone has own reason and belief.
This post is my personal opinion. It’s written by a developer can’t live without Storyboard, and now he abandons it.
3 reasons why he changed to Auto Layout by programmatically.
I designed a very good UI, and connected outlet, started logic coding, finished that feature. One day, I had to refactor code and found some improvement. Some UILabel
had gestures, should be changed to UIButton
. No problem, made changes. What did I do?
- Found the
UILabel
need change- Delete one by one.
- Add new
UIButton
- Connect new outlets
- Setup Auto Layout constraints. (This is most painful step, dozens of constraints need setup)
- Find and change many things in code
And when I changed to Auto Layout programmatically:
UILabel
need changeUILabel
to UIButton
Easier a lot, right? Especially, no change in setting up constraints.
My first project had a huge Storyboard, all-in-one. More than 30 Controllers were in 1 Storyboard file. It’s a nightmare. Anytime I opened it, change the UILabel
’s textColor, and committed. 99% had conflicts. Fix conflicts in XML is another nightmare.
Thanks God, some experienced developers tell about split it up. A Storyboard should contain 3 to 5 Controllers, not more. It should be splitted up as features, for instance, Membership
Storyboard contains Landing
, Register
, Login
Controllers, or Password
Controller contains ForgotPassword
, Confirmation
, NewPassword
Controllers. It’s a big improvement and save a lot of iOS developer’s lives.
It’s better but not the best choice. Conflicts usually occur with Storyboard, and can’t avoid. Besides that, constraints list is a mess, really mess and easy to make you mad.
You can debate about select a control, and select the constraint you want instead of find in the list. Believe me, many times you can’t do that, and we soon get mad with it.
What would you do with this control in Storyboard? You can make a custom view with 1 UILabel
for title, 1 UITextField
for text input, and 1 UIView
for underline, 1 UIButton
for right button.
How to use it? Drag a UIView
to Storyboard, choose subclass. Remember, it’s a UIView. You have to access to the view instance, textField and change the properties.
But with Auto Layout programmatically, it’s a UITextField
. You can change textColor, font, backgroundColor easily. Again, It’s a UITextField
.
You can see how I implement this custom UITextField
at knGistTextField
Yes, I have to admit that. There are 600 - 700 lines of code in my file. But it’s easy to solve this problem with Extension.
Why don’t we define and setup constraints in the main file, (LoginController.swift
, for instance), and move all handler, logic into new file, LoginControllerHandler.swift
.
Define a UIButton
with Auto Layout programmatically
let button: UIButton = {
let title = "Sample"
let image = "Sample"
let color = UIColor.black
let button = UIButton()
button.translatesAutoresizingMaskIntoConstraints = false
button.setTitle(title, for: .normal)
button.setTitleColor(color, for: .normal)
button.setImage(UIImage(named: image), for: .normal)
return button
}()
Every time I need a UIButton
, do I have to find and copy this code? No, code snippet can help you.
Find out how it helps here.
I define above button with knButton
key in my XCode. It’s easier that find and drag a UIButton
and then format it in Storyboard, right?
// (1): can't change anything
let underline = UIView()
underline.translatesAutoresizingMaskIntoConstraints = false
addSubview(underline)
// (2): Constraints setup
underline.bottomAnchor.constraint(equalTo: bottomAnchor, constant: -8).isActive = true
underline.rightAnchor.constraint(equalTo: rightAnchor).isActive = true
underline.leftAnchor.constraint(equalTo: leftAnchor).isActive = true
underline.heightAnchor.constraint(equalToConstant: 1).isActive = true
// Format control
underline.backgroundColor = UIColor.lightGray
The (1) is same to all controls in Auto Layout programmatically, you have to keep this format for all controls. You can make it better with this code (if you want)
extension UIView {
func addToView(view: UIView) {
translatesAutoresizingMaskIntoConstraints = false
view.addSubview(self)
}
}
(1) can be changed to
let underline = UIView()
underline.addToView(view)
The (2), they’re default code from Apple, why don’t we make it more readable and beautiful?
underline.bottom(toView: view, space: -8)
underline.horizontal(toView: view)
underline.height(1)
Is it beautiful enough? It comes from my own Auto Layout library. You can find it at https://github.com/nguyentruongky/knConstraints
If you wan to try a life without Storyboard, why don’t you try these following instructions?
Please feel free to touch to me by leaving comments below or Skype: nguyentruongky3390.


Class: Sass::Script::Tree::Variable
- Inherits:
-
Node
- Object
- Node
- Sass::Script::Tree::Variable
- Defined in:
- /usr/local/google-old/home/code/sass-site/.sass/lib/sass/script/tree/variable.rb
Overview
A SassScript parse node representing a variable.
Instance Attribute Summary (collapse)
-
- (String) name
readonly
The name of the variable.
-
- (String) underscored_name
readonly
The underscored name of the variable.
Attributes inherited from Node
#filename, #line, #options, #source_range
Instance Method Summary (collapse)
-
- (Sass::Script::Value) _perform(environment)
protected
Evaluates the variable.
-
- (Array<Node>) children
Returns an empty array.
- - deep_copy
-
- (Variable) initialize(name)
constructor
A new instance of Variable.
-
- (String) inspect(opts = {})
(also: #to_sass)
A string representation of the variable.
Methods inherited from Node
Constructor Details
- (Variable) initialize(name)
Returns a new instance of Variable
15 16 17 18 19 |
# File '/usr/local/google-old/home/code/sass-site/.sass/lib/sass/script/tree/variable.rb', line 15
def initialize(name)
@name = name
@underscored_name = name.gsub(/-/, "_")
super()
end
|
Instance Attribute Details
- (String) name (readonly)
The name of the variable.
7 8 9 |
# File '/usr/local/google-old/home/code/sass-site/.sass/lib/sass/script/tree/variable.rb', line 7
def name
@name
end
|
- (String) underscored_name (readonly)
The underscored name of the variable.
12 13 14 |
# File '/usr/local/google-old/home/code/sass-site/.sass/lib/sass/script/tree/variable.rb', line 12
def underscored_name
@underscored_name
end
|
Instance Method Details
- (Sass::Script::Value) _perform(environment) (protected)
Evaluates the variable.
47 48 49 50 51 52 53 54 55 |
# File '/usr/local/google-old/home/code/sass-site/.sass/lib/sass/script/tree/variable.rb', line 47
def _perform(environment)
val = environment.var(name)
raise Sass::SyntaxError.new("Undefined variable: \"$#{name}\".") unless val
if val.is_a?(Sass::Script::Value::Number) && val.original
val = val.dup
val.original = nil
end
val
end
|
- (Array<Node>) children
Returns an empty array.
31 32 33 |
# File '/usr/local/google-old/home/code/sass-site/.sass/lib/sass/script/tree/variable.rb', line 31
def children
[]
end
|
- deep_copy
36 37 38 |
# File '/usr/local/google-old/home/code/sass-site/.sass/lib/sass/script/tree/variable.rb', line 36
def deep_copy
dup
end
|
- (String) inspect(opts = {}) Also known as: to_sass
Returns A string representation of the variable
22 23 24 |
# File '/usr/local/google-old/home/code/sass-site/.sass/lib/sass/script/tree/variable.rb', line 22
def inspect(opts = {})
"$#{dasherize(name, opts)}"
end
|


Discounts
Address
:
Product SkuID:
Amount :
Loading ...


Initially, JavaScript was a Programming Language for the Web...
...but now, it can arguably do ALL and EVERYTHING you can think of right now..
To understand a programming language, you must be able to think in that language
That simply comes with practice and real-world usage
JavaScript (Front-end) frameworks for developing web apps
const http = require('http');
const hostname = '<IP_ADDRESS>';
const port = 3000;
const server = http.createServer((req, res) => {
res.statusCode = 200;
res.setHeader('Content-Type', 'text/plain');
res.end('Hello World\n');
});
server.listen(port, hostname, () => {
console.log(`Server running at http://${hostname}:${port}/`);
});
Variables - they are containers that you store your value in
//declare a variable
var myVariable;
//assign a value to the variable
myVariable = "meetup";
//push out the result
alert(myVariable);
Conditionals - they allow you check if an expression returns
true or not.
var iceCream = 'chocolate';
if (iceCream == 'chocolate') {
alert('Yay, I love chocolate ice cream!');
} else {
alert('Awwww, but chocolate is my favorite...');
}
Functions - a way of packaging functionality you wish to use.
var myVariable = document.querySelector('h1');
alert("Hello, Wolrd");
//a simple function to multiply two numbers
function multiply(num1, num2) {
var result = num1*num2;
return result;
}
//so if you want to use it, you do something like
multiply(2, 7);
https://developer.mozilla.org/en-US/docs/Learn/Getting_started_with_the_web/JavaScript_basics
http://2ality.com/2013/06/basic-javascript.html
https://www.w3schools.com/js/default.asp
https://guide.freecodecamp.org/javascript/


ProductDetails_1
- MonthlyMaximumCharge : String
The maximum relevant charges that could accrue as defined fully in Part 7 of the CMA order
- Notes : List
Optional additional notes to supplement the Core product details
- Segment : List
Market segmentation is a marketing term referring to the aggregating of prospective buyers into groups, or segments, that have common needs and respond similarly to a marketing action. Market segmentation enables companies to target different categories of consumers who perceive the full value of certain products and services differently from one another. Read more: Market Segmentation http://www.investopedia.com/terms/m/marketsegmentation.asp#ixzz4gfEEalTd With respect to PCA products, they are segmented in relation to different markets that they wish to focus on.
- Enum:


{% for data in data.all %} {{ data.summary }} {% endfor %}
Task 2: Most Popular Start and End Points
Task 3: Average Distance Traveled
Task 4: Popularity of Bike Sharing
Challenge 1: How Does Ridership Change with Season?
Task 4: Popularity of Bike Sharing


Content specific to this page goes here.
Please fill in the fields below to submit your request for support.