Python高手之路【二】python基本数据类型
一：数字 int
int(整型)：
在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807
long（长整型）：
跟C语言不同，Python的长整数没有指定位宽，即：Python没有限制长整数数值的大小，但实际上由于机器内存有限，我们使用的长整数数值不可能无限大
注意：自从python2.2起，如果整数发生溢出，python会自动将整数数据转换为长整数，所以如今在长整数数据后面不加字母L也不会导致严重后果了
float（浮点型）：
浮点数用来处理实数，即带有小数的数字，类似于C语言中的double类型，占8个字节（64位），其中52位表示底，11位表示指数，剩下一位表示符号
class int(object):<br/>
"""<br/>
int(x=0) -> int or long<br/>
int(x, base=10) -> int or long
Convert a number or string to an integer, or return 0 if no arguments<br/>
are given. If x is floating point, the conversion truncates towards zero.<br/>
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<br/>
Unicode object representing an integer literal in the given base. The<br/>
literal can be preceded by '+' or '-' and be surrounded by whitespace.<br/>
The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to<br/>
interpret the base from the string as an integer literal.<br/>
>>> int('0b100', base=0)<br/>
"""<br/>
def bit_length(self):<br/>
""" 返回表示该数字的时占用的最少位数 """<br/>
"""<br/>
int.bit_length() -> int
Number of bits necessary to represent self in binary.<br/>
>>> bin(37)<br/>
'0b100101'<br/>
>>> (37).bit_length()<br/>
"""<br/>
return 0
def conjugate(self, *args, **kwargs): # real signature unknown<br/>
""" 返回该复数的共轭复数 """<br/>
""" Returns self, the complex conjugate of any int. """<br/>
pass
def __abs__(self):<br/>
""" 返回绝对值 """<br/>
""" x.__abs__() <==> abs(x) """<br/>
pass
def __add__(self, y):<br/>
""" x.__add__(y) <==> x+y """<br/>
pass
def __and__(self, y):<br/>
""" x.__and__(y) <==> x&y """<br/>
pass
def __cmp__(self, y):<br/>
""" 比较两个数大小 """<br/>
""" x.__cmp__(y) <==> cmp(x,y) """<br/>
pass
def __coerce__(self, y):<br/>
""" 强制生成一个元组 """<br/>
""" x.__coerce__(y) <==> coerce(x, y) """<br/>
pass
def __divmod__(self, y):<br/>
""" 相除，得到商和余数组成的元组 """<br/>
""" x.__divmod__(y) <==> divmod(x, y) """<br/>
pass
def __div__(self, y):<br/>
""" x.__div__(y) <==> x/y """<br/>
pass
def __float__(self):<br/>
""" 转换为浮点类型 """<br/>
""" x.__float__() <==> float(x) """<br/>
pass
def __floordiv__(self, y):<br/>
""" x.__floordiv__(y) <==> x//y """<br/>
pass
def __format__(self, *args, **kwargs): # real signature unknown<br/>
pass
def __getattribute__(self, name):<br/>
""" x.__getattribute__('name') <==> x.name """<br/>
pass
def __getnewargs__(self, *args, **kwargs): # real signature unknown<br/>
""" 内部调用 __new__方法或创建对象时传入参数使用 """<br/>
pass
def __hash__(self):<br/>
"""如果对象object为哈希表类型，返回对象object的哈希值。哈希值为整数。在字典查找中，哈希值用于快速比较字典的键。两个数值如果相等，则哈希值也相等。"""<br/>
""" x.__hash__() <==> hash(x) """<br/>
pass
def __hex__(self):<br/>
""" 返回当前数的 十六进制 表示 """<br/>
""" x.__hex__() <==> hex(x) """<br/>
pass
def __index__(self):<br/>
""" 用于切片，数字无意义 """<br/>
""" x[y:z] <==> x[y.__index__():z.__index__()] """<br/>
pass
def __init__(self, x, base=10): # known special case of int.__init__<br/>
""" 构造方法，执行 x = 123 或 x = int(10) 时，自动调用，暂时忽略 """<br/>
"""<br/>
int(x=0) -> int or long<br/>
int(x, base=10) -> int or long
Convert a number or string to an integer, or return 0 if no arguments<br/>
are given. If x is floating point, the conversion truncates towards zero.<br/>
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<br/>
Unicode object representing an integer literal in the given base. The<br/>
literal can be preceded by '+' or '-' and be surrounded by whitespace.<br/>
The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to<br/>
interpret the base from the string as an integer literal.<br/>
>>> int('0b100', base=0)<br/>
# (copied from class doc)<br/>
"""<br/>
pass
def __int__(self):<br/>
""" 转换为整数 """<br/>
""" x.__int__() <==> int(x) """<br/>
pass
def __invert__(self):<br/>
""" x.__invert__() <==> ~x """<br/>
pass
def __long__(self):<br/>
""" 转换为长整数 """<br/>
""" x.__long__() <==> long(x) """<br/>
pass
def __lshift__(self, y):<br/>
""" x.__lshift__(y) <==> x<<y """<br/>
pass
def __mod__(self, y):<br/>
""" x.__mod__(y) <==> x%y """<br/>
pass
def __mul__(self, y):<br/>
""" x.__mul__(y) <==> x*y """<br/>
pass
def __neg__(self):<br/>
""" x.__neg__() <==> -x """<br/>
pass
@staticmethod # known case of __new__<br/>
def __new__(S, *more):<br/>
""" T.__new__(S, ...) -> a new object with type S, a subtype of T """<br/>
pass
def __nonzero__(self):<br/>
""" x.__nonzero__() <==> x != 0 """<br/>
pass
def __oct__(self):<br/>
""" 返回改值的 八进制 表示 """<br/>
""" x.__oct__() <==> oct(x) """<br/>
pass
def __or__(self, y):<br/>
""" x.__or__(y) <==> x|y """<br/>
pass
def __pos__(self):<br/>
""" x.__pos__() <==> +x """<br/>
pass
def __pow__(self, y, z=None):<br/>
""" 幂，次方 """<br/>
""" x.__pow__(y[, z]) <==> pow(x, y[, z]) """<br/>
pass
def __radd__(self, y):<br/>
""" x.__radd__(y) <==> y+x """<br/>
pass
def __rand__(self, y):<br/>
""" x.__rand__(y) <==> y&x """<br/>
pass
def __rdivmod__(self, y):<br/>
""" x.__rdivmod__(y) <==> divmod(y, x) """<br/>
pass
def __rdiv__(self, y):<br/>
""" x.__rdiv__(y) <==> y/x """<br/>
pass
def __repr__(self):<br/>
"""转化为解释器可读取的形式 """<br/>
""" x.__repr__() <==> repr(x) """<br/>
pass
def __str__(self):<br/>
"""转换为人阅读的形式，如果没有适于人阅读的解释形式的话，则返回解释器课阅读的形式"""<br/>
""" x.__str__() <==> str(x) """<br/>
pass
def __rfloordiv__(self, y):<br/>
""" x.__rfloordiv__(y) <==> y//x """<br/>
pass
def __rlshift__(self, y):<br/>
""" x.__rlshift__(y) <==> y<<x """<br/>
pass
def __rmod__(self, y):<br/>
""" x.__rmod__(y) <==> y%x """<br/>
pass
def __rmul__(self, y):<br/>
""" x.__rmul__(y) <==> y*x """<br/>
pass
def __ror__(self, y):<br/>
""" x.__ror__(y) <==> y|x """<br/>
pass
def __rpow__(self, x, z=None):<br/>
""" y.__rpow__(x[, z]) <==> pow(x, y[, z]) """<br/>
pass
def __rrshift__(self, y):<br/>
""" x.__rrshift__(y) <==> y>>x """<br/>
pass
def __rshift__(self, y):<br/>
""" x.__rshift__(y) <==> x>>y """<br/>
pass
def __rsub__(self, y):<br/>
""" x.__rsub__(y) <==> y-x """<br/>
pass
def __rtruediv__(self, y):<br/>
""" x.__rtruediv__(y) <==> y/x """<br/>
pass
def __rxor__(self, y):<br/>
""" x.__rxor__(y) <==> y^x """<br/>
pass
def __sub__(self, y):<br/>
""" x.__sub__(y) <==> x-y """<br/>
pass
def __truediv__(self, y):<br/>
""" x.__truediv__(y) <==> x/y """<br/>
pass
def __trunc__(self, *args, **kwargs):<br/>
""" 返回数值被截取为整形的值，在整形中无意义 """<br/>
pass
def __xor__(self, y):<br/>
""" x.__xor__(y) <==> x^y """<br/>
pass
denominator = property(lambda self: object(), lambda self, v: None, lambda self: None) # default<br/>
""" 分母 = 1 """<br/>
"""the denominator of a rational number in lowest terms"""
imag = property(lambda self: object(), lambda self, v: None, lambda self: None) # default<br/>
""" 虚数，无意义 """<br/>
"""the imaginary part of a complex number"""
numerator = property(lambda self: object(), lambda self, v: None, lambda self: None) # default<br/>
""" 分子 = 数字大小 """<br/>
"""the numerator of a rational number in lowest terms"""
real = property(lambda self: object(), lambda self, v: None, lambda self: None) # default<br/>
""" 实属，无意义 """<br/>
"""the real part of a complex number"""
int
int
二：字符串 str
class str(basestring):<br/>
"""<br/>
str(object='') -> string
Return a nice string representation of the object.<br/>
If the argument is a string, the return value is the same object.<br/>
"""<br/>
def capitalize(self):<br/>
""" 首字母变大写 """<br/>
"""<br/>
S.capitalize() -> string
Return a copy of the string S with only its first character<br/>
capitalized.<br/>
"""<br/>
return ""
def center(self, width, fillchar=None):<br/>
""" 内容居中，width：总长度；fillchar：空白处填充内容，默认无 """<br/>
"""<br/>
S.center(width[, fillchar]) -> string
Return S centered in a string of length width. Padding is<br/>
done using the specified fill character (default is a space)<br/>
"""<br/>
return ""
def count(self, sub, start=None, end=None):<br/>
""" 子序列个数 """<br/>
"""<br/>
S.count(sub[, start[, end]]) -> int
Return the number of non-overlapping occurrences of substring sub in<br/>
string S[start:end]. Optional arguments start and end are interpreted<br/>
as in slice notation.<br/>
"""<br/>
return 0
def decode(self, encoding=None, errors=None):<br/>
""" 解码 """<br/>
"""<br/>
S.decode([encoding[,errors]]) -> object
Decodes S using the codec registered for encoding. encoding defaults<br/>
to the default encoding. errors may be given to set a different error<br/>
handling scheme. Default is 'strict' meaning that encoding errors raise<br/>
a UnicodeDecodeError. Other possible values are 'ignore' and 'replace'<br/>
as well as any other name registered with codecs.register_error that is<br/>
able to handle UnicodeDecodeErrors.<br/>
"""<br/>
return object()
def encode(self, encoding=None, errors=None):<br/>
""" 编码，针对unicode """<br/>
"""<br/>
S.encode([encoding[,errors]]) -> object
Encodes S using the codec registered for encoding. encoding defaults<br/>
to the default encoding. errors may be given to set a different error<br/>
handling scheme. Default is 'strict' meaning that encoding errors raise<br/>
a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and<br/>
'xmlcharrefreplace' as well as any other name registered with<br/>
codecs.register_error that is able to handle UnicodeEncodeErrors.<br/>
"""<br/>
return object()
def endswith(self, suffix, start=None, end=None):<br/>
""" 是否以 xxx 结束 """<br/>
"""<br/>
S.endswith(suffix[, start[, end]]) -> bool
Return True if S ends with the specified suffix, False otherwise.<br/>
With optional start, test S beginning at that position.<br/>
With optional end, stop comparing S at that position.<br/>
suffix can also be a tuple of strings to try.<br/>
"""<br/>
return False
def expandtabs(self, tabsize=None):<br/>
""" 将tab转换成空格，默认一个tab转换成8个空格 """<br/>
"""<br/>
S.expandtabs([tabsize]) -> string
Return a copy of S where all tab characters are expanded using spaces.<br/>
If tabsize is not given, a tab size of 8 characters is assumed.<br/>
"""<br/>
return ""
def find(self, sub, start=None, end=None):<br/>
""" 寻找子序列位置，如果没找到，返回 -1 """<br/>
"""<br/>
S.find(sub [,start [,end]]) -> int
Return the lowest index in S where substring sub is found,<br/>
such that sub is contained within S[start:end]. Optional<br/>
arguments start and end are interpreted as in slice notation.
Return -1 on failure.<br/>
"""<br/>
return 0
def format(*args, **kwargs): # known special case of str.format<br/>
""" 字符串格式化，动态参数，将函数式编程时细说 """<br/>
"""<br/>
S.format(*args, **kwargs) -> string
Return a formatted version of S, using substitutions from args and kwargs.<br/>
The substitutions are identified by braces ('{' and '}').<br/>
"""<br/>
pass
def index(self, sub, start=None, end=None):<br/>
""" 子序列位置，如果没找到，报错 """<br/>
S.index(sub [,start [,end]]) -> int
Like S.find() but raise ValueError when the substring is not found.<br/>
"""<br/>
return 0
def isalnum(self):<br/>
""" 是否是字母和数字 """<br/>
"""<br/>
S.isalnum() -> bool
Return True if all characters in S are alphanumeric<br/>
and there is at least one character in S, False otherwise.<br/>
"""<br/>
return False
def isalpha(self):<br/>
""" 是否是字母 """<br/>
"""<br/>
S.isalpha() -> bool
Return True if all characters in S are alphabetic<br/>
and there is at least one character in S, False otherwise.<br/>
"""<br/>
return False
def isdigit(self):<br/>
""" 是否是数字 """<br/>
"""<br/>
S.isdigit() -> bool
Return True if all characters in S are digits<br/>
and there is at least one character in S, False otherwise.<br/>
"""<br/>
return False
def islower(self):<br/>
""" 是否小写 """<br/>
"""<br/>
S.islower() -> bool
Return True if all cased characters in S are lowercase and there is<br/>
at least one cased character in S, False otherwise.<br/>
"""<br/>
return False
def isspace(self):<br/>
"""<br/>
S.isspace() -> bool
Return True if all characters in S are whitespace<br/>
and there is at least one character in S, False otherwise.<br/>
"""<br/>
return False
def istitle(self):<br/>
"""<br/>
S.istitle() -> bool
Return True if S is a titlecased string and there is at least one<br/>
character in S, i.e. uppercase characters may only follow uncased<br/>
characters and lowercase characters only cased ones. Return False<br/>
otherwise.<br/>
"""<br/>
return False
def isupper(self):<br/>
"""<br/>
S.isupper() -> bool
Return True if all cased characters in S are uppercase and there is<br/>
at least one cased character in S, False otherwise.<br/>
"""<br/>
return False
def join(self, iterable):<br/>
""" 连接 """<br/>
"""<br/>
S.join(iterable) -> string
Return a string which is the concatenation of the strings in the<br/>
iterable. The separator between elements is S.<br/>
"""<br/>
return ""
def ljust(self, width, fillchar=None):<br/>
""" 内容左对齐，右侧填充 """<br/>
"""<br/>
S.ljust(width[, fillchar]) -> string
Return S left-justified in a string of length width. Padding is<br/>
done using the specified fill character (default is a space).<br/>
"""<br/>
return ""
def lower(self):<br/>
""" 变小写 """<br/>
"""<br/>
S.lower() -> string
Return a copy of the string S converted to lowercase.<br/>
"""<br/>
return ""
def lstrip(self, chars=None):<br/>
""" 移除左侧空白 """<br/>
"""<br/>
S.lstrip([chars]) -> string or unicode
Return a copy of the string S with leading whitespace removed.<br/>
If chars is given and not None, remove characters in chars instead.<br/>
If chars is unicode, S will be converted to unicode before stripping<br/>
"""<br/>
return ""
def partition(self, sep):<br/>
""" 分割，前，中，后三部分 """<br/>
"""<br/>
S.partition(sep) -> (head, sep, tail)
Search for the separator sep in S, and return the part before it,<br/>
the separator itself, and the part after it. If the separator is not<br/>
found, return S and two empty strings.<br/>
"""<br/>
pass
def replace(self, old, new, count=None):<br/>
""" 替换 """<br/>
"""<br/>
S.replace(old, new[, count]) -> string
Return a copy of string S with all occurrences of substring<br/>
old replaced by new. If the optional argument count is<br/>
given, only the first count occurrences are replaced.<br/>
"""<br/>
return ""
def rfind(self, sub, start=None, end=None):<br/>
"""<br/>
S.rfind(sub [,start [,end]]) -> int
Return the highest index in S where substring sub is found,<br/>
such that sub is contained within S[start:end]. Optional<br/>
arguments start and end are interpreted as in slice notation.
Return -1 on failure.<br/>
"""<br/>
return 0
def rindex(self, sub, start=None, end=None):<br/>
"""<br/>
S.rindex(sub [,start [,end]]) -> int
Like S.rfind() but raise ValueError when the substring is not found.<br/>
"""<br/>
return 0
def rjust(self, width, fillchar=None):<br/>
"""<br/>
S.rjust(width[, fillchar]) -> string
Return S right-justified in a string of length width. Padding is<br/>
done using the specified fill character (default is a space)<br/>
"""<br/>
return ""
def rpartition(self, sep):<br/>
"""<br/>
S.rpartition(sep) -> (head, sep, tail)
Search for the separator sep in S, starting at the end of S, and return<br/>
the part before it, the separator itself, and the part after it. If the<br/>
separator is not found, return two empty strings and S.<br/>
"""<br/>
pass
def rsplit(self, sep=None, maxsplit=None):<br/>
"""<br/>
S.rsplit([sep [,maxsplit]]) -> list of strings
Return a list of the words in the string S, using sep as the<br/>
delimiter string, starting at the end of the string and working<br/>
to the front. If maxsplit is given, at most maxsplit splits are<br/>
done. If sep is not specified or is None, any whitespace string<br/>
is a separator.<br/>
"""<br/>
return []
def rstrip(self, chars=None):<br/>
"""<br/>
S.rstrip([chars]) -> string or unicode
Return a copy of the string S with trailing whitespace removed.<br/>
If chars is given and not None, remove characters in chars instead.<br/>
If chars is unicode, S will be converted to unicode before stripping<br/>
"""<br/>
return ""
def split(self, sep=None, maxsplit=None):<br/>
""" 分割， maxsplit最多分割几次 """<br/>
"""<br/>
S.split([sep [,maxsplit]]) -> list of strings
Return a list of the words in the string S, using sep as the<br/>
delimiter string. If maxsplit is given, at most maxsplit<br/>
splits are done. If sep is not specified or is None, any<br/>
whitespace string is a separator and empty strings are removed<br/>
from the result.<br/>
"""<br/>
return []
def splitlines(self, keepends=False):<br/>
""" 根据换行分割 """<br/>
"""<br/>
S.splitlines(keepends=False) -> list of strings
Return a list of the lines in S, breaking at line boundaries.<br/>
Line breaks are not included in the resulting list unless keepends<br/>
is given and true.<br/>
"""<br/>
return []
def startswith(self, prefix, start=None, end=None):<br/>
""" 是否起始 """<br/>
"""<br/>
S.startswith(prefix[, start[, end]]) -> bool
Return True if S starts with the specified prefix, False otherwise.<br/>
With optional start, test S beginning at that position.<br/>
With optional end, stop comparing S at that position.<br/>
prefix can also be a tuple of strings to try.<br/>
"""<br/>
return False
def strip(self, chars=None):<br/>
""" 移除两段空白 """<br/>
"""<br/>
S.strip([chars]) -> string or unicode
Return a copy of the string S with leading and trailing<br/>
whitespace removed.<br/>
If chars is given and not None, remove characters in chars instead.<br/>
If chars is unicode, S will be converted to unicode before stripping<br/>
"""<br/>
return ""
def swapcase(self):<br/>
""" 大写变小写，小写变大写 """<br/>
"""<br/>
S.swapcase() -> string
Return a copy of the string S with uppercase characters<br/>
converted to lowercase and vice versa.<br/>
"""<br/>
return ""
def title(self):<br/>
"""<br/>
S.title() -> string
Return a titlecased version of S, i.e. words start with uppercase<br/>
characters, all remaining cased characters have lowercase.<br/>
"""<br/>
return ""
def translate(self, table, deletechars=None):<br/>
"""<br/>
转换，需要先做一个对应表，最后一个表示删除字符集合<br/>
intab = "aeiou"<br/>
outtab = ""<br/>
trantab = maketrans(intab, outtab)<br/>
str = "this is string example....wow!!!"<br/>
print str.translate(trantab, 'xm')<br/>
"""
"""<br/>
S.translate(table [,deletechars]) -> string
Return a copy of the string S, where all characters occurring<br/>
in the optional argument deletechars are removed, and the<br/>
remaining characters have been mapped through the given<br/>
translation table, which must be a string of length 256 or None.<br/>
If the table argument is None, no translation is applied and<br/>
the operation simply removes the characters in deletechars.<br/>
"""<br/>
return ""
def upper(self):<br/>
"""<br/>
S.upper() -> string
Return a copy of the string S converted to uppercase.<br/>
"""<br/>
return ""
def zfill(self, width):<br/>
"""方法返回指定长度的字符串，原字符串右对齐，前面填充0。"""<br/>
"""<br/>
S.zfill(width) -> string
Pad a numeric string S with zeros on the left, to fill a field<br/>
of the specified width. The string S is never truncated.<br/>
"""<br/>
return ""
def _formatter_field_name_split(self, *args, **kwargs): # real signature unknown<br/>
pass
def _formatter_parser(self, *args, **kwargs): # real signature unknown<br/>
pass
def __add__(self, y):<br/>
""" x.__add__(y) <==> x+y """<br/>
pass
def __contains__(self, y):<br/>
""" x.__contains__(y) <==> y in x """<br/>
pass
def __eq__(self, y):<br/>
""" x.__eq__(y) <==> x==y """<br/>
pass
def __format__(self, format_spec):<br/>
"""<br/>
S.__format__(format_spec) -> string
Return a formatted version of S as described by format_spec.<br/>
"""<br/>
return ""
def __getattribute__(self, name):<br/>
""" x.__getattribute__('name') <==> x.name """<br/>
pass
def __getitem__(self, y):<br/>
""" x.__getitem__(y) <==> x[y] """<br/>
pass
def __getnewargs__(self, *args, **kwargs): # real signature unknown<br/>
pass
def __getslice__(self, i, j):<br/>
"""<br/>
x.__getslice__(i, j) <==> x[i:j]
Use of negative indices is not supported.<br/>
"""<br/>
pass
def __ge__(self, y):<br/>
""" x.__ge__(y) <==> x>=y """<br/>
pass
def __gt__(self, y):<br/>
""" x.__gt__(y) <==> x>y """<br/>
pass
def __hash__(self):<br/>
""" x.__hash__() <==> hash(x) """<br/>
pass
def __init__(self, string=''): # known special case of str.__init__<br/>
"""<br/>
str(object='') -> string
Return a nice string representation of the object.<br/>
If the argument is a string, the return value is the same object.<br/>
# (copied from class doc)<br/>
"""<br/>
pass
def __len__(self):<br/>
""" x.__len__() <==> len(x) """<br/>
pass
def __le__(self, y):<br/>
""" x.__le__(y) <==> x<=y """<br/>
pass
def __lt__(self, y):<br/>
""" x.__lt__(y) <==> x<y """<br/>
pass
def __mod__(self, y):<br/>
""" x.__mod__(y) <==> x%y """<br/>
pass
def __mul__(self, n):<br/>
""" x.__mul__(n) <==> x*n """<br/>
pass
@staticmethod # known case of __new__<br/>
def __new__(S, *more):<br/>
""" T.__new__(S, ...) -> a new object with type S, a subtype of T """<br/>
pass
def __ne__(self, y):<br/>
""" x.__ne__(y) <==> x!=y """<br/>
pass
def __repr__(self):<br/>
""" x.__repr__() <==> repr(x) """<br/>
pass
def __rmod__(self, y):<br/>
""" x.__rmod__(y) <==> y%x """<br/>
pass
def __rmul__(self, n):<br/>
""" x.__rmul__(n) <==> n*x """<br/>
pass
def __sizeof__(self):<br/>
""" S.__sizeof__() -> size of S in memory, in bytes """<br/>
pass
def __str__(self):<br/>
""" x.__str__() <==> str(x) """<br/>
pass
str
str
字符串是 Python 中最常用的数据类型。我们可以使用引号，双引号，或三引号来创建字符串。
a = 'poe'<br/> b = "bruce"<br/> c = """Jacky Chen"""
1：字符串连接
方法一：join方法
a = ['a','b','c','d']<br/> content = ''<br/> content = ' '.join(a)<br/> print(content)
方法二：用字符串的替换占位符替换
a = ['a','b','c','d']<br/> content = ''<br/> content = '%s%s%s%s' % tuple(a)<br/> print(content)
方法三：for循环
a = ['a','b','c','d']<br/>
content = ''<br/>
for i in a:<br/>
content += i<br/>
print(content)
注意：方法三效率低，不推荐使用！
原因：在循环连接字符串的时候，他每次连接一次，就要重新开辟空间，然后把字符串连接起来，再放入新的空间，再一次循环，又要开辟新的空间，把字符串连接起来放入新的空间，如此反复，内存操作比较频繁，每次都要计算内存空间，然后开辟内存空间，再释放内存空间，效率非常低，你也许操作比较少的数据的时候看不出来，感觉影响不大，但是你碰到操作数据量比较多的时候，这个方法就要退休了。
2：字符串截取
我们可以通过索引来提取想要获取的字符，可以把python的字符串也做为字符串的列表就更好理解
python的字串列表有2种取值顺序：
1是从左到右索引默认0开始的，最大范围是字符串长度少1
s = 'ilovepython'<br/> s[0]的结果是i
2是从右到左索引默认-1开始的，最大范围是字符串开头
s = 'ilovepython'<br/> s[-1]的结果是n
上面这个是取得一个字符，如果你的实际要取得一段子串的话，可以用到变量[头下标:尾下标]，就可以截取相应的字符串，其中下标是从0开始算起，可以是正数或负数，下标可以为空表示取到头或尾。
比如
s = 'ilovepython'<br/> s[1:5]的结果是love
当使用以冒号分隔的字符串，python返回一个新的对象，结果包含了以这对偏移标识的连续的内容，左边的开始是包含了下边界，比如上面的结果包含了s[1]的值l，而取到的最大范围不包括上边界，就是s[5]的值p
注：s[1:5]形式截头不截尾
3：字符串替换
方法一：使用repalce方法
a = 'hello world'<br/>
b = a.replace('world','python')<br/>
print(b)
方法二：使用正则表达式
import re<br/>
a = 'hello world'<br/>
strinfo = re.compile('world')<br/>
b = strinfo.sub('python',a)<br/>
print(b)
4：字符串比较
cmp方法比较两个对象，并根据结果返回一个整数。cmp(x,y)如果X< Y,返回值是负数 如果X>Y 返回的值为正数。
str1 = 'strch'<br/> str2 = 'strchr'<br/> print(cmp(str1,str2))<br/> ## -1
5：字符串相加
我们通过操作符号+来进行字符串的相加，不过建议还是用其他的方式来进行字符串的拼接，这样效率高点。
原因：在循环连接字符串的时候，他每次连接一次，就要重新开辟空间，然后把字符串连接起来，再放入新的空间，再一次循环，又要开辟新的空间，把字符串连接起来放入新的空间，如此反复，内存操作比较频繁，每次都要计算内存空间，然后开辟内存空间，再释放内存空间，效率非常低。
str1 = 'strch'<br/> str2 = 'strchr'<br/> print(str1+str2)<br/> ## strchstrchr
6：字符串查找
python 字符串查找有4个方法，1 find,2 index方法，3 rfind方法,4 rindex方法。
方法一：find方法
info = 'abca'<br/>
print info.find('a')##从下标0开始，查找在字符串里第一个出现的子串，返回结果：0
info = 'abca'<br/>
print info.find('a',1)##从下标1开始，查找在字符串里第一个出现的子串：返回结果3
info = 'abca'<br/>
print info.find('')##返回-1,查找不到返回-1
方法二：index方法
python 的index方法是在字符串里查找子串第一次出现的位置，类似字符串的find方法，不过比find方法更好的是，如果查找不到子串，会抛出异常，而不是返回-1
info = 'abca'<br/>
print info.index('a')<br/>
print info.index('')
7：字符串分割
字符串分割，可以用split,rsplit方法，通过相应的规则来切割成生成列表对象
info = 'name:haha,age:20$name:python,age:30$name:fef,age:55'<br/>
content = info.split('$')<br/>
print content<br/>
## ['name:haha,age:20', 'name:python,age:30', 'name:fef,age:55']
8：字符串反转
a = 'abcd'<br/> b = a[::-1]##[::-1]通过步进反转<br/> print b
9：字符串编码
10：字符串追加和拼接
通过字符串的占位符来进行字符串的拼接
#1 元组拼接<br/>
m = 'python'<br/>
astr = 'i love %s' % m<br/>
print astr
#2 字符串的format方法<br/>
m = 'python'<br/>
astr = "i love {python}".format(python=m)<br/>
print astr
#3 字典格式化字符串<br/>
m = 'python'<br/>
astr = "i love %(python)s " % {'python':m}<br/>
print astr
11：字符串复制
#通过变量来进行赋值<br/> fstr = 'strcpy'<br/> sstr = fstr<br/> fstr = 'strcpy2'<br/> print sstr
12：字符串长度
#通过内置方法len()来计算字符串的长度，注意这个计算的是字符的长度。<br/> aa = 'afebb'<br/> bb = '你'<br/> print len(aa)<br/> print len(bb)
13：字符串大小写
#通过下面的upper(),lower()等方法来转换大小写<br/> S.upper()#S中的字母大写<br/> S.lower() #S中的字母小写<br/> S.capitalize() #首字母大写<br/> S.istitle() #S是否是首字母大写的<br/> S.isupper() #S中的字母是否便是大写<br/> S.islower() #S中的字母是否全是小写
14：字符串去空格
#通过strip(),lstrip(),rstrip()方法去除字符串的空格<br/>
S.strip() #去掉字符串的左右空格<br/>
S.lstrip() #去掉字符串的左边空格<br/>
S.rstrip() #去掉字符串的右边空格<br/>
#注意：strip()函数不仅可以去空格还可以去除指定的字符，如<br/>
S.strip("\n")
15：字符串其他方法
#字符串相关的其他方法:count(),join()方法等。<br/> S.center(width, [fillchar]) #中间对齐<br/> S.count(substr, [start, [end]]) #计算substr在S中出现的次数<br/> S.expandtabs([tabsize]) #把S中的tab字符替换没空格，每个tab替换为tabsize个空格，默认是8个<br/> S.isalnum() #是否全是字母和数字，并至少有一个字符<br/> S.isalpha() #是否全是字母，并至少有一个字符<br/> S.isspace() #是否全是空白字符，并至少有一个字符<br/> S.join()#S中的join，把列表生成一个字符串对象<br/> S.ljust(width,[fillchar]) #输出width个字符，S左对齐，不足部分用fillchar填充，默认的为空格。<br/> S.rjust(width,[fillchar]) #右对齐<br/> S.splitlines([keepends]) #把S按照行分割符分为一个list，keepends是一个bool值，如果为真每行后而会保留行分割符。<br/> S.swapcase() #大小写互换
三：列表 list
class list(object):<br/>
"""<br/>
list() -> new empty list<br/>
list(iterable) -> new list initialized from iterable's items<br/>
"""<br/>
def append(self, p_object): # real signature unknown; restored from __doc__<br/>
""" L.append(object) -- append object to end """<br/>
pass
def count(self, value): # real signature unknown; restored from __doc__<br/>
""" L.count(value) -> integer -- return number of occurrences of value """<br/>
return 0
def extend(self, iterable): # real signature unknown; restored from __doc__<br/>
""" L.extend(iterable) -- extend list by appending elements from the iterable """<br/>
pass
def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__<br/>
"""<br/>
L.index(value, [start, [stop]]) -> integer -- return first index of value.<br/>
Raises ValueError if the value is not present.<br/>
"""<br/>
return 0
def insert(self, index, p_object): # real signature unknown; restored from __doc__<br/>
""" L.insert(index, object) -- insert object before index """<br/>
pass
def pop(self, index=None): # real signature unknown; restored from __doc__<br/>
"""<br/>
L.pop([index]) -> item -- remove and return item at index (default last).<br/>
Raises IndexError if list is empty or index is out of range.<br/>
"""<br/>
pass
def remove(self, value): # real signature unknown; restored from __doc__<br/>
"""<br/>
L.remove(value) -- remove first occurrence of value.<br/>
Raises ValueError if the value is not present.<br/>
"""<br/>
pass
def reverse(self): # real signature unknown; restored from __doc__<br/>
""" L.reverse() -- reverse *IN PLACE* """<br/>
pass
def sort(self, cmp=None, key=None, reverse=False): # real signature unknown; restored from __doc__<br/>
"""<br/>
L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;<br/>
cmp(x, y) -> -1, 0, 1<br/>
"""<br/>
pass
def __add__(self, y): # real signature unknown; restored from __doc__<br/>
""" x.__add__(y) <==> x+y """<br/>
pass
def __contains__(self, y): # real signature unknown; restored from __doc__<br/>
""" x.__contains__(y) <==> y in x """<br/>
pass
def __delitem__(self, y): # real signature unknown; restored from __doc__<br/>
""" x.__delitem__(y) <==> del x[y] """<br/>
pass
def __delslice__(self, i, j): # real signature unknown; restored from __doc__<br/>
"""<br/>
x.__delslice__(i, j) <==> del x[i:j]
Use of negative indices is not supported.<br/>
"""<br/>
pass
def __eq__(self, y): # real signature unknown; restored from __doc__<br/>
""" x.__eq__(y) <==> x==y """<br/>
pass
def __getattribute__(self, name): # real signature unknown; restored from __doc__<br/>
""" x.__getattribute__('name') <==> x.name """<br/>
pass
def __getitem__(self, y): # real signature unknown; restored from __doc__<br/>
""" x.__getitem__(y) <==> x[y] """<br/>
pass
def __getslice__(self, i, j): # real signature unknown; restored from __doc__<br/>
"""<br/>
x.__getslice__(i, j) <==> x[i:j]
Use of negative indices is not supported.<br/>
"""<br/>
pass
def __ge__(self, y): # real signature unknown; restored from __doc__<br/>
""" x.__ge__(y) <==> x>=y """<br/>
pass
def __gt__(self, y): # real signature unknown; restored from __doc__<br/>
""" x.__gt__(y) <==> x>y """<br/>
pass
def __iadd__(self, y): # real signature unknown; restored from __doc__<br/>
""" x.__iadd__(y) <==> x+=y """<br/>
pass
def __imul__(self, y): # real signature unknown; restored from __doc__<br/>
""" x.__imul__(y) <==> x*=y """<br/>
pass
def __init__(self, seq=()): # known special case of list.__init__<br/>
"""<br/>
list() -> new empty list<br/>
list(iterable) -> new list initialized from iterable's items<br/>
# (copied from class doc)<br/>
"""<br/>
pass
def __iter__(self): # real signature unknown; restored from __doc__<br/>
""" x.__iter__() <==> iter(x) """<br/>
pass
def __len__(self): # real signature unknown; restored from __doc__<br/>
""" x.__len__() <==> len(x) """<br/>
pass
def __le__(self, y): # real signature unknown; restored from __doc__<br/>
""" x.__le__(y) <==> x<=y """<br/>
pass
def __lt__(self, y): # real signature unknown; restored from __doc__<br/>
""" x.__lt__(y) <==> x<y """<br/>
pass
def __mul__(self, n): # real signature unknown; restored from __doc__<br/>
""" x.__mul__(n) <==> x*n """<br/>
pass
@staticmethod # known case of __new__<br/>
def __new__(S, *more): # real signature unknown; restored from __doc__<br/>
""" T.__new__(S, ...) -> a new object with type S, a subtype of T """<br/>
pass
def __ne__(self, y): # real signature unknown; restored from __doc__<br/>
""" x.__ne__(y) <==> x!=y """<br/>
pass
def __repr__(self): # real signature unknown; restored from __doc__<br/>
""" x.__repr__() <==> repr(x) """<br/>
pass
def __reversed__(self): # real signature unknown; restored from __doc__<br/>
""" L.__reversed__() -- return a reverse iterator over the list """<br/>
pass
def __rmul__(self, n): # real signature unknown; restored from __doc__<br/>
""" x.__rmul__(n) <==> n*x """<br/>
pass
def __setitem__(self, i, y): # real signature unknown; restored from __doc__<br/>
""" x.__setitem__(i, y) <==> x[i]=y """<br/>
pass
def __setslice__(self, i, j, y): # real signature unknown; restored from __doc__<br/>
"""<br/>
x.__setslice__(i, j, y) <==> x[i:j]=y
Use of negative indices is not supported.<br/>
"""<br/>
pass
def __sizeof__(self): # real signature unknown; restored from __doc__<br/>
""" L.__sizeof__() -- size of L in memory, in bytes """<br/>
pass
__hash__ = None
list
list
1：创建列表
list1 = ['physics', 'chemistry', 1997, 2000];<br/> list2 = [1, 2, 3, 4, 5 ];<br/> list3 = ["a", "b", "c", "d"];
与字符串的索引一样，列表索引从0开始。列表可以进行截取、组合等
2：访问列表
list1 = ['physics', 'chemistry', 1997, 2000];<br/> list2 = [1, 2, 3, 4, 5, 6, 7 ];<br/> print(list1[0])<br/> print(list2[2:5])#截头不截尾<br/> ## physics<br/> ## [3, 4, 5]
3：append方法：在列表末尾添加新的对象
aList = [123, 'xyz', 'zara', 'abc'];<br/> aList.append( 2009 );<br/> print "Updated List : ", aList;<br/> ## Updated List : [123, 'xyz', 'zara', 'abc', 2009]
4：count方法：统计某个元素在列表中出现的次数
aList = [123, 'xyz', 'zara', 123];<br/> print(aList.count(123))<br/> ## 2
5：extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
aList = [123, 'xyz', 'zara', 'abc', 123];<br/> bList = [2009, 'manni'];<br/> aList.extend(bList) print "Extended List : ", aList ;<br/> ## Extended List : [123, 'xyz', 'zara', 'abc', 123, 2009, 'manni']
6：index() 函数用于从列表中找出某个值第一个匹配项的索引位置
aList = [123, 'xyz', 'zara', 'abc']; print "Index for xyz : ", aList.index( 'xyz' ) ;<br/> print "Index for zara : ", aList.index( 'zara' ) ; ##Index for xyz : 1<br/> ## Index for zara : 2
7：insert() 函数用于将指定对象插入列表的指定位置
aList = [123, 'xyz', 'zara', 'abc'] aList.insert( 3, 2009) print "Final List : ", aList ## Final List : [123, 'xyz', 'zara', 2009, 'abc']
insert()接收两个参数，list.insert(index, obj)，第一个参数index为要插入的索引位置，第二个参数要插入的元素
8：pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
aList = [123, 'xyz', 'zara', 'abc']; print "A List : ", aList.pop();<br/> print "B List : ", aList.pop(); ## A List : abc<br/> ## B List : zara
9：remove() 函数用于移除列表中某个值的第一个匹配项
aList = [123, 'xyz', 'zara', 'abc', 'xyz'];
aList.remove('xyz');<br/>
print "List : ", aList;<br/>
aList.remove('abc');<br/>
print "List : ", aList;
## List : [123, 'zara', 'abc', 'xyz']<br/>
## List : [123, 'zara', 'xyz']
10：列表的四种遍历方法
aList = [123, 'xyz', 'zara', 123];
方法一：只遍历列表中的值
for value in aList :<br/>
print(value)<br/>
####################<br/>
123<br/>
xyz<br/>
zara<br/>
123
方法二：如果需要遍历列表中的索引与值，就需要用到enumerate
for key,value in enumerate(aList) :<br/>
print(key,value)<br/>
######################<br/>
(0, 123)<br/>
(1, 'xyz')<br/>
(2, 'zara')<br/>
(3, 123)
enumrate：为可迭代的对象添加序号，默认从0开始！因为列表的索引也是从0开始，所以我们在enumerate中不指定第二个参数，如有需要，可以指定从几开始，如下：
for key,value in enumerate(aList,1) :<br/>
print(key,value)<br/>
######################################<br/>
(1, 123)<br/>
(2, 'xyz')<br/>
(3, 'zara')<br/>
(4, 123)
方法三：
for i in range(len(aList)) :<br/>
print(i,aList[i])<br/>
##############################<br/>
(0, 123)<br/>
(1, 'xyz')<br/>
(2, 'zara')<br/>
(3, 123)
range和xrange：指定范围，生成指定的数字
方法四：使用iter()
for i in iter(aList) :<br/>
print(i)<br/>
##########################################<br/>
123<br/>
xyz<br/>
zara<br/>
123
四：元组 tuple
lass tuple(object):<br/>
"""<br/>
tuple() -> empty tuple<br/>
tuple(iterable) -> tuple initialized from iterable's items
If the argument is a tuple, the return value is the same object.<br/>
"""<br/>
def count(self, value): # real signature unknown; restored from __doc__<br/>
""" T.count(value) -> integer -- return number of occurrences of value """<br/>
return 0
def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__<br/>
"""<br/>
T.index(value, [start, [stop]]) -> integer -- return first index of value.<br/>
Raises ValueError if the value is not present.<br/>
"""<br/>
return 0
def __add__(self, y): # real signature unknown; restored from __doc__<br/>
""" x.__add__(y) <==> x+y """<br/>
pass
def __contains__(self, y): # real signature unknown; restored from __doc__<br/>
""" x.__contains__(y) <==> y in x """<br/>
pass
def __eq__(self, y): # real signature unknown; restored from __doc__<br/>
""" x.__eq__(y) <==> x==y """<br/>
pass
def __getattribute__(self, name): # real signature unknown; restored from __doc__<br/>
""" x.__getattribute__('name') <==> x.name """<br/>
pass
def __getitem__(self, y): # real signature unknown; restored from __doc__<br/>
""" x.__getitem__(y) <==> x[y] """<br/>
pass
def __getnewargs__(self, *args, **kwargs): # real signature unknown<br/>
pass
def __getslice__(self, i, j): # real signature unknown; restored from __doc__<br/>
"""<br/>
x.__getslice__(i, j) <==> x[i:j]
Use of negative indices is not supported.<br/>
"""<br/>
pass
def __ge__(self, y): # real signature unknown; restored from __doc__<br/>
""" x.__ge__(y) <==> x>=y """<br/>
pass
def __gt__(self, y): # real signature unknown; restored from __doc__<br/>
""" x.__gt__(y) <==> x>y """<br/>
pass
def __hash__(self): # real signature unknown; restored from __doc__<br/>
""" x.__hash__() <==> hash(x) """<br/>
pass
def __init__(self, seq=()): # known special case of tuple.__init__<br/>
"""<br/>
tuple() -> empty tuple<br/>
tuple(iterable) -> tuple initialized from iterable's items
If the argument is a tuple, the return value is the same object.<br/>
# (copied from class doc)<br/>
"""<br/>
pass
def __iter__(self): # real signature unknown; restored from __doc__<br/>
""" x.__iter__() <==> iter(x) """<br/>
pass
def __len__(self): # real signature unknown; restored from __doc__<br/>
""" x.__len__() <==> len(x) """<br/>
pass
def __le__(self, y): # real signature unknown; restored from __doc__<br/>
""" x.__le__(y) <==> x<=y """<br/>
pass
def __lt__(self, y): # real signature unknown; restored from __doc__<br/>
""" x.__lt__(y) <==> x<y """<br/>
pass
def __mul__(self, n): # real signature unknown; restored from __doc__<br/>
""" x.__mul__(n) <==> x*n """<br/>
pass
@staticmethod # known case of __new__<br/>
def __new__(S, *more): # real signature unknown; restored from __doc__<br/>
""" T.__new__(S, ...) -> a new object with type S, a subtype of T """<br/>
pass
def __ne__(self, y): # real signature unknown; restored from __doc__<br/>
""" x.__ne__(y) <==> x!=y """<br/>
pass
def __repr__(self): # real signature unknown; restored from __doc__<br/>
""" x.__repr__() <==> repr(x) """<br/>
pass
def __rmul__(self, n): # real signature unknown; restored from __doc__<br/>
""" x.__rmul__(n) <==> n*x """<br/>
pass
def __sizeof__(self): # real signature unknown; restored from __doc__<br/>
""" T.__sizeof__() -- size of T in memory, in bytes """<br/>
pass
tuple
tuple
Python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可
tuple只有两个可使用的功能：count , index
1：创建元组
tup1 = ();#创建空元组 tup1 = (50,);#元组中只包含一个元素时，需要在元素后面添加逗号
元组与字符串类似，下标索引从0开始，可以进行截取，组合等。元组的访问与列表一样！
2：元组的连接组合
tup1 = (12, 34.56);<br/>
tup2 = ('abc', 'xyz');
# 以下修改元组元素操作是非法的。<br/>
# tup1[0] = 100;
# 创建一个新的元组<br/>
tup3 = tup1 + tup2;<br/>
print tup3;<br/>
##########################################<br/>
(12, 34.56, 'abc', 'xyz')
3：删除元组
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:
tup = ('physics', 'chemistry', 1997, 2000);
print tup;<br/>
del tup;<br/>
print "After deleting tup : "<br/>
print tup;<br/>
##########################################<br/>
以上实例元组被删除后，输出变量会有异常信息，输出如下所示：<br/>
('physics', 'chemistry', 1997, 2000)<br/>
After deleting tup :<br/>
Traceback (most recent call last):<br/>
File "test.py", line 9, in <module><br/>
print tup;<br/>
NameError: name 'tup' is not defined
五：字典 dict
class dict(object):<br/>
"""<br/>
dict() -> new empty dictionary<br/>
dict(mapping) -> new dictionary initialized from a mapping object's<br/>
(key, value) pairs<br/>
dict(iterable) -> new dictionary initialized as if via:<br/>
d = {}<br/>
for k, v in iterable:<br/>
d[k] = v<br/>
dict(**kwargs) -> new dictionary initialized with the name=value pairs<br/>
in the keyword argument list. For example: dict(one=1, two=2)<br/>
"""
def clear(self): # real signature unknown; restored from __doc__<br/>
""" 清除内容 """<br/>
""" D.clear() -> None. Remove all items from D. """<br/>
pass
def copy(self): # real signature unknown; restored from __doc__<br/>
""" 浅拷贝 """<br/>
""" D.copy() -> a shallow copy of D """<br/>
pass
@staticmethod # known case<br/>
def fromkeys(S, v=None): # real signature unknown; restored from __doc__<br/>
"""<br/>
dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.<br/>
v defaults to None.<br/>
"""<br/>
pass
def get(self, k, d=None): # real signature unknown; restored from __doc__<br/>
""" 根据key获取值，d是默认值 """<br/>
""" D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None. """<br/>
pass
def has_key(self, k): # real signature unknown; restored from __doc__<br/>
""" 是否有key """<br/>
""" D.has_key(k) -> True if D has a key k, else False """<br/>
return False
def items(self): # real signature unknown; restored from __doc__<br/>
""" 所有项的列表形式 """<br/>
""" D.items() -> list of D's (key, value) pairs, as 2-tuples """<br/>
return []
def iteritems(self): # real signature unknown; restored from __doc__<br/>
""" 项可迭代 """<br/>
""" D.iteritems() -> an iterator over the (key, value) items of D """<br/>
pass
def iterkeys(self): # real signature unknown; restored from __doc__<br/>
""" key可迭代 """<br/>
""" D.iterkeys() -> an iterator over the keys of D """<br/>
pass
def itervalues(self): # real signature unknown; restored from __doc__<br/>
""" value可迭代 """<br/>
""" D.itervalues() -> an iterator over the values of D """<br/>
pass
def keys(self): # real signature unknown; restored from __doc__<br/>
""" 所有的key列表 """<br/>
""" D.keys() -> list of D's keys """<br/>
return []
def pop(self, k, d=None): # real signature unknown; restored from __doc__<br/>
""" 获取并在字典中移除 """<br/>
"""<br/>
D.pop(k[,d]) -> v, remove specified key and return the corresponding value.<br/>
If key is not found, d is returned if given, otherwise KeyError is raised<br/>
"""<br/>
pass
def popitem(self): # real signature unknown; restored from __doc__<br/>
""" 获取并在字典中移除 """<br/>
"""<br/>
D.popitem() -> (k, v), remove and return some (key, value) pair as a<br/>
2-tuple; but raise KeyError if D is empty.<br/>
"""<br/>
pass
def setdefault(self, k, d=None): # real signature unknown; restored from __doc__<br/>
""" 如果key不存在，则创建，如果存在，则返回已存在的值且不修改 """<br/>
""" D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """<br/>
pass
def update(self, E=None, **F): # known special case of dict.update<br/>
""" 更新<br/>
{'name':'alex', 'age': 18000}<br/>
[('name','sbsbsb'),]<br/>
"""<br/>
"""<br/>
D.update([E, ]**F) -> None. Update D from dict/iterable E and F.<br/>
If E present and has a .keys() method, does: for k in E: D[k] = E[k]<br/>
If E present and lacks .keys() method, does: for (k, v) in E: D[k] = v<br/>
In either case, this is followed by: for k in F: D[k] = F[k]<br/>
"""<br/>
pass
def values(self): # real signature unknown; restored from __doc__<br/>
""" 所有的值 """<br/>
""" D.values() -> list of D's values """<br/>
return []
def viewitems(self): # real signature unknown; restored from __doc__<br/>
""" 所有项，只是将内容保存至view对象中 """<br/>
""" D.viewitems() -> a set-like object providing a view on D's items """<br/>
pass
def viewkeys(self): # real signature unknown; restored from __doc__<br/>
""" D.viewkeys() -> a set-like object providing a view on D's keys """<br/>
pass
def viewvalues(self): # real signature unknown; restored from __doc__<br/>
""" D.viewvalues() -> an object providing a view on D's values """<br/>
pass
def __cmp__(self, y): # real signature unknown; restored from __doc__<br/>
""" x.__cmp__(y) <==> cmp(x,y) """<br/>
pass
def __contains__(self, k): # real signature unknown; restored from __doc__<br/>
""" D.__contains__(k) -> True if D has a key k, else False """<br/>
return False
def __delitem__(self, y): # real signature unknown; restored from __doc__<br/>
""" x.__delitem__(y) <==> del x[y] """<br/>
pass
def __eq__(self, y): # real signature unknown; restored from __doc__<br/>
""" x.__eq__(y) <==> x==y """<br/>
pass
def __getattribute__(self, name): # real signature unknown; restored from __doc__<br/>
""" x.__getattribute__('name') <==> x.name """<br/>
pass
def __getitem__(self, y): # real signature unknown; restored from __doc__<br/>
""" x.__getitem__(y) <==> x[y] """<br/>
pass
def __ge__(self, y): # real signature unknown; restored from __doc__<br/>
""" x.__ge__(y) <==> x>=y """<br/>
pass
def __gt__(self, y): # real signature unknown; restored from __doc__<br/>
""" x.__gt__(y) <==> x>y """<br/>
pass
def __init__(self, seq=None, **kwargs): # known special case of dict.__init__<br/>
"""<br/>
dict() -> new empty dictionary<br/>
dict(mapping) -> new dictionary initialized from a mapping object's<br/>
(key, value) pairs<br/>
dict(iterable) -> new dictionary initialized as if via:<br/>
d = {}<br/>
for k, v in iterable:<br/>
d[k] = v<br/>
dict(**kwargs) -> new dictionary initialized with the name=value pairs<br/>
in the keyword argument list. For example: dict(one=1, two=2)<br/>
# (copied from class doc)<br/>
"""<br/>
pass
def __iter__(self): # real signature unknown; restored from __doc__<br/>
""" x.__iter__() <==> iter(x) """<br/>
pass
def __len__(self): # real signature unknown; restored from __doc__<br/>
""" x.__len__() <==> len(x) """<br/>
pass
def __le__(self, y): # real signature unknown; restored from __doc__<br/>
""" x.__le__(y) <==> x<=y """<br/>
pass
def __lt__(self, y): # real signature unknown; restored from __doc__<br/>
""" x.__lt__(y) <==> x<y """<br/>
pass
@staticmethod # known case of __new__<br/>
def __new__(S, *more): # real signature unknown; restored from __doc__<br/>
""" T.__new__(S, ...) -> a new object with type S, a subtype of T """<br/>
pass
def __ne__(self, y): # real signature unknown; restored from __doc__<br/>
""" x.__ne__(y) <==> x!=y """<br/>
pass
def __repr__(self): # real signature unknown; restored from __doc__<br/>
""" x.__repr__() <==> repr(x) """<br/>
pass
def __setitem__(self, i, y): # real signature unknown; restored from __doc__<br/>
""" x.__setitem__(i, y) <==> x[i]=y """<br/>
pass
def __sizeof__(self): # real signature unknown; restored from __doc__<br/>
""" D.__sizeof__() -> size of D in memory, in bytes """<br/>
pass
__hash__ = None
dict
dict
字典是另一种可变容器模型，且可存储任意类型对象。字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：
d = {key1 : value1, key2 : value2 }
键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
1：访问字典里的值
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
print "dict['Name']: ", dict['Name'];<br/>
print "dict['Age']: ", dict['Age'];<br/>
##########################################<br/>
dict['Name']: Zara<br/>
dict['Age']: 7
2：修改字典里的值
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
dict['Age'] = 8; # update existing entry<br/>
dict['School'] = "DPS School"; # Add new entry
print "dict['Age']: ", dict['Age'];<br/>
print "dict['School']: ", dict['School'];<br/>
##########################################<br/>
dict['Age']: 8<br/>
dict['School']: DPS School
3：删除操作
能删单一的元素也能清空字典，清空只需一项操作。显示删除一个字典用del命令，如下实例：
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
del dict['Name']; # 删除键是'Name'的条目<br/>
dict.clear(); # 清空词典所有条目<br/>
del dict ; # 删除词典
print "dict['Age']: ", dict['Age'];<br/>
print "dict['School']: ", dict['School'];<br/>
##########################################<br/>
dict['Age']:<br/>
Traceback (most recent call last):<br/>
File "test.py", line 8, in <module><br/>
print "dict['Age']: ", dict['Age'];<br/>
TypeError: 'type' object is unsubscriptable
clear() 函数用于删除字典内所有元素：
dict = {'Name': 'Zara', 'Age': 7};
print "Start Len : %d" % len(dict)<br/>
dict.clear()<br/>
print "End Len : %d" % len(dict)
注：clear函数是删除字典里的所有元素，删除后，该字典仍然存在，不过是个空字典而已
4： copy() 函数返回一个字典的浅复制
dict1 = {'Name': 'Zara', 'Age': 7};
dict2 = dict1.copy()<br/>
print "New Dictinary : %s" % str(dict2)<br/>
##########################################<br/>
New Dictinary : {'Age': 7, 'Name': 'Zara'}
有关深浅复制的区别，请点击这里！
5：fromkeys() 函数用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值
seq = ('name','age','sex')<br/>
dic = dict.fromkeys(seq)<br/>
print(dic)<br/>
#########################################<br/>
{'age': None, 'name': None, 'sex': None}
可以指定一个值，如：
seq = ('name','age','sex')<br/>
dic = dict.fromkeys(seq,10)<br/>
print(dic)<br/>
##########################################<br/>
{'age': 10, 'name': 10, 'sex': 10}
6：get() 函数返回指定键的值，如果值不在字典中返回默认值
dic = {'Name': 'Zara', 'Age': 27}<br/>
print(dic.get('Age'))<br/>
print(dic.get('Sex','Never'))#Never为设置的默认值<br/>
##########################################<br/>
27<br/>
Never
7：has_key() 函数用于判断键是否存在于字典中，如果键在字典dict里返回true，否则返回false
dic = {'Name': 'Zara', 'Age': 27}<br/>
print(dic.has_key('Name'))<br/>
print(dic.has_key('Sex'))<br/>
##########################################<br/>
True<br/>
False
8：items() 函数以列表返回可遍历的(键, 值) 元组数组
dic = {'Name': 'Zara', 'Age': 27}<br/>
print(dic.items())<br/>
##########################################<br/>
[('Age', 27), ('Name', 'Zara')]
9：keys() 函数以列表返回一个字典所有的键
dic = {'Name': 'Zara', 'Age': 27}<br/>
print(dic.keys())<br/>
##########################################<br/>
['Age', 'Name']
10：values() 函数以列表返回字典中的所有值
dic = {'Name': 'Zara', 'Age': 27}<br/>
print(dic.values())<br/>
##########################################<br/>
[27, 'Zara']
11：update() 函数把字典dict2的键/值对更新到dict1里
dict1 = {'Name': 'Zara', 'Age': 7}<br/>
dict2 = {'Sex': 'female' }<br/>
dict1.update(dict2)<br/>
print(dict1)<br/>
##########################################<br/>
{'Age': 7, 'Name': 'Zara', 'Sex': 'female'}
12：字典的遍历
方法一：
dict1 = {'Age': 7, 'Name': 'Zara', 'Sex': 'female'}<br/>
for k,v in dict1.items() :<br/>
print(k,v)<br/>
##########################################<br/>
('Age', 7)<br/>
('Name', 'Zara')<br/>
('Sex', 'female')
方法二：
dict1 = {'Age': 7, 'Name': 'Zara', 'Sex': 'female'}<br/>
for (k,v) in dict1.items() :<br/>
print(k,v)<br/>
##########################################<br/>
('Age', 7)<br/>
('Name', 'Zara')<br/>
('Sex', 'female')
