进击python第二篇：初识

入门拾遗

模块

 >>> import math >>> math.floor(3.5) 3.0 

 >>> from math import ceil  >>> ceil(3.5) 4.0 

字符串表示：str和repr

 >>> print "hello,lzl"     hello,lzl        #print输出易读 >>> print repr("hello,lzl") 'hello,lzl' >>> repr("hello,lzl") "'hello,lzl'" >>> str("hello,lzl") 'hello,lzl' 

原始字符串和unicode

 >>> path='c:/nowhere' >>> path 'c:/nowhere' >>> print path c: owhere >>> print r'c:/nowhere'    #r开头有表示原始字符串 c:/nowhere 

 >>> a=u'hello,lzl'  #以u开头 >>> type(a) <type 'unicode'> 

作用域

 if 1==1:     name = 'lzl'  print name 

三元运算

格式：result = 值 1 if 条件 else 值 2

如果条件为真：result = 值1如果条件为假：result = 值2

python基础

常见类

• 整数

创建方法： n=10或n=int(10)

如： 18、73、84

每一个整数都具备如下功能：

bit_lenth():返回表示该数字的时占用的最少位数

　_divmod_(): x.__divmod__(y) <==> divmod(x, y)相除，得到商和余数组成的元组，常见应用：分页时求有多少页

__float__()：转换为浮点类型

详细:

  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)     """     def bit_length(self):          """ 返回表示该数字的时占用的最少位数 """         """         int.bit_length() -> int                  Number of bits necessary to represent self in binary.         >>> bin(37)         '0b100101'         >>> (37).bit_length()         """         return 0      def conjugate(self, *args, **kwargs): # real signature unknown         """ 返回该复数的共轭复数 """         """ Returns self, the complex conjugate of any int. """         pass      def __abs__(self):         """ 返回绝对值 """         """ x.__abs__() <==> abs(x) """         pass      def __add__(self, y):         """ x.__add__(y) <==> x+y """         pass      def __and__(self, y):         """ x.__and__(y) <==> x&y """         pass      def __cmp__(self, y):          """ 比较两个数大小 """         """ x.__cmp__(y) <==> cmp(x,y) """         pass      def __coerce__(self, y):         """ 强制生成一个元组 """          """ x.__coerce__(y) <==> coerce(x, y) """         pass      def __divmod__(self, y):          """ 相除，得到商和余数组成的元组 """          """ x.__divmod__(y) <==> divmod(x, y) """         pass      def __div__(self, y):          """ x.__div__(y) <==> x/y """         pass      def __float__(self):          """ 转换为浮点类型 """          """ x.__float__() <==> float(x) """         pass      def __floordiv__(self, y):          """ x.__floordiv__(y) <==> x//y """         pass      def __format__(self, *args, **kwargs): # real signature unknown         pass      def __getattribute__(self, name):          """ x.__getattribute__('name') <==> x.name """         pass      def __getnewargs__(self, *args, **kwargs): # real signature unknown         """ 内部调用 __new__方法或创建对象时传入参数使用 """          pass      def __hash__(self):          """如果对象object为哈希表类型，返回对象object的哈希值。哈希值为整数。在字典查找中，哈希值用于快速比较字典的键。两个数值如果相等，则哈希值也相等。"""         """ x.__hash__() <==> hash(x) """         pass      def __hex__(self):          """ 返回当前数的 十六进制 表示 """          """ x.__hex__() <==> hex(x) """         pass      def __index__(self):          """ 用于切片，数字无意义 """         """ x[y:z] <==> x[y.__index__():z.__index__()] """         pass      def __init__(self, x, base=10): # known special case of int.__init__         """ 构造方法，执行 x = 123 或 x = int(10) 时，自动调用，暂时忽略 """          """         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)         # (copied from class doc)         """         pass      def __int__(self):          """ 转换为整数 """          """ x.__int__() <==> int(x) """         pass      def __invert__(self):          """ x.__invert__() <==> ~x """         pass      def __long__(self):          """ 转换为长整数 """          """ x.__long__() <==> long(x) """         pass      def __lshift__(self, y):          """ x.__lshift__(y) <==> x<<y """         pass      def __mod__(self, y):          """ x.__mod__(y) <==> x%y """         pass      def __mul__(self, y):          """ x.__mul__(y) <==> x*y """         pass      def __neg__(self):          """ x.__neg__() <==> -x """         pass      @staticmethod # known case of __new__     def __new__(S, *more):          """ T.__new__(S, ...) -> a new object with type S, a subtype of T """         pass      def __nonzero__(self):          """ x.__nonzero__() <==> x != 0 """         pass      def __oct__(self):          """ 返回改值的 八进制 表示 """          """ x.__oct__() <==> oct(x) """         pass      def __or__(self, y):          """ x.__or__(y) <==> x|y """         pass      def __pos__(self):          """ x.__pos__() <==> +x """         pass      def __pow__(self, y, z=None):          """ 幂，次方 """          """ x.__pow__(y[, z]) <==> pow(x, y[, z]) """         pass      def __radd__(self, y):          """ x.__radd__(y) <==> y+x """         pass      def __rand__(self, y):          """ x.__rand__(y) <==> y&x """         pass      def __rdivmod__(self, y):          """ x.__rdivmod__(y) <==> divmod(y, x) """         pass      def __rdiv__(self, y):          """ x.__rdiv__(y) <==> y/x """         pass      def __repr__(self):          """转化为解释器可读取的形式 """         """ x.__repr__() <==> repr(x) """         pass      def __str__(self):          """转换为人阅读的形式，如果没有适于人阅读的解释形式的话，则返回解释器课阅读的形式"""         """ x.__str__() <==> str(x) """         pass      def __rfloordiv__(self, y):          """ x.__rfloordiv__(y) <==> y//x """         pass      def __rlshift__(self, y):          """ x.__rlshift__(y) <==> y<<x """         pass      def __rmod__(self, y):          """ x.__rmod__(y) <==> y%x """         pass      def __rmul__(self, y):          """ x.__rmul__(y) <==> y*x """         pass      def __ror__(self, y):          """ x.__ror__(y) <==> y|x """         pass      def __rpow__(self, x, z=None):          """ y.__rpow__(x[, z]) <==> pow(x, y[, z]) """         pass      def __rrshift__(self, y):          """ x.__rrshift__(y) <==> y>>x """         pass      def __rshift__(self, y):          """ x.__rshift__(y) <==> x>>y """         pass      def __rsub__(self, y):          """ x.__rsub__(y) <==> y-x """         pass      def __rtruediv__(self, y):          """ x.__rtruediv__(y) <==> y/x """         pass      def __rxor__(self, y):          """ x.__rxor__(y) <==> y^x """         pass      def __sub__(self, y):          """ x.__sub__(y) <==> x-y """         pass      def __truediv__(self, y):          """ x.__truediv__(y) <==> x/y """         pass      def __trunc__(self, *args, **kwargs):          """ 返回数值被截取为整形的值，在整形中无意义 """         pass      def __xor__(self, y):          """ x.__xor__(y) <==> x^y """         pass      denominator = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default     """ 分母 = 1 """     """the denominator of a rational number in lowest terms"""      imag = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default     """ 虚数，无意义 """     """the imaginary part of a complex number"""      numerator = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default     """ 分子 = 数字大小 """     """the numerator of a rational number in lowest terms"""      real = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default     """ 实属，无意义 """     """the real part of a complex number"""  int

• 长整型

可能如：2147483649、9223372036854775807

每个长整型都具备如下功能：

__floordiv__(self, y): 地板除 x.__floordiv__(y) <==> x//y

__getattribute__(self, name):类中含有该方法后可使用对象.方法（）调用 __getattribute__('name') <==> x.name

__hash__(self):  如果对象object为哈希表类型，返回对象object的哈希值。哈希值为整数。在字典查找中，哈希值用于快速比较字典的键。两个数值如果相等，则哈希值也相等。

详细:

  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     """     def bit_length(self): # real signature unknown; restored from __doc__         """         long.bit_length() -> int or long                  Number of bits necessary to represent self in binary.         >>> bin(37L)         '0b100101'         >>> (37L).bit_length()         """         return 0      def conjugate(self, *args, **kwargs): # real signature unknown         """ Returns self, the complex conjugate of any long. """         pass      def __abs__(self): # real signature unknown; restored from __doc__         """ x.__abs__() <==> abs(x) """         pass      def __add__(self, y): # real signature unknown; restored from __doc__         """ x.__add__(y) <==> x+y """         pass      def __and__(self, y): # real signature unknown; restored from __doc__         """ x.__and__(y) <==> x&y """         pass      def __cmp__(self, y): # real signature unknown; restored from __doc__         """ x.__cmp__(y) <==> cmp(x,y) """         pass      def __coerce__(self, y): # real signature unknown; restored from __doc__         """ x.__coerce__(y) <==> coerce(x, y) """         pass      def __divmod__(self, y): # real signature unknown; restored from __doc__         """ x.__divmod__(y) <==> divmod(x, y) """         pass      def __div__(self, y): # real signature unknown; restored from __doc__         """ x.__div__(y) <==> x/y """         pass      def __float__(self): # real signature unknown; restored from __doc__         """ x.__float__() <==> float(x) """         pass      def __floordiv__(self, y): # real signature unknown; restored from __doc__         """ x.__floordiv__(y) <==> x//y """         pass      def __format__(self, *args, **kwargs): # real signature unknown         pass      def __getattribute__(self, name): # real signature unknown; restored from __doc__         """ x.__getattribute__('name') <==> x.name """         pass      def __getnewargs__(self, *args, **kwargs): # real signature unknown         pass      def __hash__(self): # real signature unknown; restored from __doc__         """ x.__hash__() <==> hash(x) """         pass      def __hex__(self): # real signature unknown; restored from __doc__         """ x.__hex__() <==> hex(x) """         pass      def __index__(self): # real signature unknown; restored from __doc__         """ x[y:z] <==> x[y.__index__():z.__index__()] """         pass      def __init__(self, x=0): # real signature unknown; restored from __doc__         pass      def __int__(self): # real signature unknown; restored from __doc__         """ x.__int__() <==> int(x) """         pass      def __invert__(self): # real signature unknown; restored from __doc__         """ x.__invert__() <==> ~x """         pass      def __long__(self): # real signature unknown; restored from __doc__         """ x.__long__() <==> long(x) """         pass      def __lshift__(self, y): # real signature unknown; restored from __doc__         """ x.__lshift__(y) <==> x<<y """         pass      def __mod__(self, y): # real signature unknown; restored from __doc__         """ x.__mod__(y) <==> x%y """         pass      def __mul__(self, y): # real signature unknown; restored from __doc__         """ x.__mul__(y) <==> x*y """         pass      def __neg__(self): # real signature unknown; restored from __doc__         """ x.__neg__() <==> -x """         pass      @staticmethod # known case of __new__     def __new__(S, *more): # real signature unknown; restored from __doc__         """ T.__new__(S, ...) -> a new object with type S, a subtype of T """         pass      def __nonzero__(self): # real signature unknown; restored from __doc__         """ x.__nonzero__() <==> x != 0 """         pass      def __oct__(self): # real signature unknown; restored from __doc__         """ x.__oct__() <==> oct(x) """         pass      def __or__(self, y): # real signature unknown; restored from __doc__         """ x.__or__(y) <==> x|y """         pass      def __pos__(self): # real signature unknown; restored from __doc__         """ x.__pos__() <==> +x """         pass      def __pow__(self, y, z=None): # real signature unknown; restored from __doc__         """ x.__pow__(y[, z]) <==> pow(x, y[, z]) """         pass      def __radd__(self, y): # real signature unknown; restored from __doc__         """ x.__radd__(y) <==> y+x """         pass      def __rand__(self, y): # real signature unknown; restored from __doc__         """ x.__rand__(y) <==> y&x """         pass      def __rdivmod__(self, y): # real signature unknown; restored from __doc__         """ x.__rdivmod__(y) <==> divmod(y, x) """         pass      def __rdiv__(self, y): # real signature unknown; restored from __doc__         """ x.__rdiv__(y) <==> y/x """         pass      def __repr__(self): # real signature unknown; restored from __doc__         """ x.__repr__() <==> repr(x) """         pass      def __rfloordiv__(self, y): # real signature unknown; restored from __doc__         """ x.__rfloordiv__(y) <==> y//x """         pass      def __rlshift__(self, y): # real signature unknown; restored from __doc__         """ x.__rlshift__(y) <==> y<<x """         pass      def __rmod__(self, y): # real signature unknown; restored from __doc__         """ x.__rmod__(y) <==> y%x """         pass      def __rmul__(self, y): # real signature unknown; restored from __doc__         """ x.__rmul__(y) <==> y*x """         pass      def __ror__(self, y): # real signature unknown; restored from __doc__         """ x.__ror__(y) <==> y|x """         pass      def __rpow__(self, x, z=None): # real signature unknown; restored from __doc__         """ y.__rpow__(x[, z]) <==> pow(x, y[, z]) """         pass      def __rrshift__(self, y): # real signature unknown; restored from __doc__         """ x.__rrshift__(y) <==> y>>x """         pass      def __rshift__(self, y): # real signature unknown; restored from __doc__         """ x.__rshift__(y) <==> x>>y """         pass      def __rsub__(self, y): # real signature unknown; restored from __doc__         """ x.__rsub__(y) <==> y-x """         pass      def __rtruediv__(self, y): # real signature unknown; restored from __doc__         """ x.__rtruediv__(y) <==> y/x """         pass      def __rxor__(self, y): # real signature unknown; restored from __doc__         """ x.__rxor__(y) <==> y^x """         pass      def __sizeof__(self, *args, **kwargs): # real signature unknown         """ Returns size in memory, in bytes """         pass      def __str__(self): # real signature unknown; restored from __doc__         """ x.__str__() <==> str(x) """         pass      def __sub__(self, y): # real signature unknown; restored from __doc__         """ x.__sub__(y) <==> x-y """         pass      def __truediv__(self, y): # real signature unknown; restored from __doc__         """ x.__truediv__(y) <==> x/y """         pass      def __trunc__(self, *args, **kwargs): # real signature unknown         """ Truncating an Integral returns itself. """         pass      def __xor__(self, y): # real signature unknown; restored from __doc__         """ x.__xor__(y) <==> x^y """         pass      denominator = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default     """the denominator of a rational number in lowest terms"""      imag = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default     """the imaginary part of a complex number"""      numerator = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default     """the numerator of a rational number in lowest terms"""      real = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default     """the real part of a complex number"""  long  long

• 浮点型

如：3.14、2.88

每个浮点型都具备如下功能：

  class float(object):     """     float(x) -> floating point number          Convert a string or number to a floating point number, if possible.     """     def as_integer_ratio(self):            """ 获取改值的最简比 """         """         float.as_integer_ratio() -> (int, int)          Return a pair of integers, whose ratio is exactly equal to the original         float and with a positive denominator.         Raise 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)         """         pass      def conjugate(self, *args, **kwargs): # real signature unknown         """ Return self, the complex conjugate of any float. """         pass      def fromhex(self, string):            """ 将十六进制字符串转换成浮点型 """         """         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         """         return 0.0      def hex(self):            """ 返回当前值的 16 进制表示 """         """         float.hex() -> string                  Return a hexadecimal representation of a floating-point number.         >>> (-0.1).hex()         '-0x1.999999999999ap-4'         >>> 3.14159.hex()         '0x1.921f9f01b866ep+1'         """         return ""      def is_integer(self, *args, **kwargs): # real signature unknown         """ Return True if the float is an integer. """         pass      def __abs__(self):            """ x.__abs__() <==> abs(x) """         pass      def __add__(self, y):            """ x.__add__(y) <==> x+y """         pass      def __coerce__(self, y):            """ x.__coerce__(y) <==> coerce(x, y) """         pass      def __divmod__(self, y):            """ x.__divmod__(y) <==> divmod(x, y) """         pass      def __div__(self, y):            """ x.__div__(y) <==> x/y """         pass      def __eq__(self, y):            """ x.__eq__(y) <==> x==y """         pass      def __float__(self):            """ x.__float__() <==> float(x) """         pass      def __floordiv__(self, y):            """ x.__floordiv__(y) <==> x//y """         pass      def __format__(self, format_spec):            """         float.__format__(format_spec) -> string                  Formats the float according to format_spec.         """         return ""      def __getattribute__(self, name):            """ x.__getattribute__('name') <==> x.name """         pass      def __getformat__(self, typestr):            """         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.         """         return ""      def __getnewargs__(self, *args, **kwargs): # real signature unknown         pass      def __ge__(self, y):            """ x.__ge__(y) <==> x>=y """         pass      def __gt__(self, y):            """ x.__gt__(y) <==> x>y """         pass      def __hash__(self):            """ x.__hash__() <==> hash(x) """         pass      def __init__(self, x):            pass      def __int__(self):            """ x.__int__() <==> int(x) """         pass      def __le__(self, y):            """ x.__le__(y) <==> x<=y """         pass      def __long__(self):            """ x.__long__() <==> long(x) """         pass      def __lt__(self, y):            """ x.__lt__(y) <==> x<y """         pass      def __mod__(self, y):            """ x.__mod__(y) <==> x%y """         pass      def __mul__(self, y):            """ x.__mul__(y) <==> x*y """         pass      def __neg__(self):            """ x.__neg__() <==> -x """         pass      @staticmethod # known case of __new__     def __new__(S, *more):            """ T.__new__(S, ...) -> a new object with type S, a subtype of T """         pass      def __ne__(self, y):            """ x.__ne__(y) <==> x!=y """         pass      def __nonzero__(self):            """ x.__nonzero__() <==> x != 0 """         pass      def __pos__(self):            """ x.__pos__() <==> +x """         pass      def __pow__(self, y, z=None):            """ x.__pow__(y[, z]) <==> pow(x, y[, z]) """         pass      def __radd__(self, y):            """ x.__radd__(y) <==> y+x """         pass      def __rdivmod__(self, y):            """ x.__rdivmod__(y) <==> divmod(y, x) """         pass      def __rdiv__(self, y):            """ x.__rdiv__(y) <==> y/x """         pass      def __repr__(self):            """ x.__repr__() <==> repr(x) """         pass      def __rfloordiv__(self, y):            """ x.__rfloordiv__(y) <==> y//x """         pass      def __rmod__(self, y):            """ x.__rmod__(y) <==> y%x """         pass      def __rmul__(self, y):            """ x.__rmul__(y) <==> y*x """         pass      def __rpow__(self, x, z=None):            """ y.__rpow__(x[, z]) <==> pow(x, y[, z]) """         pass      def __rsub__(self, y):            """ x.__rsub__(y) <==> y-x """         pass      def __rtruediv__(self, y):            """ x.__rtruediv__(y) <==> y/x """         pass      def __setformat__(self, typestr, fmt):            """         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.                  Override the automatic determination of C-level floating point type.         This affects how floats are converted to and from binary strings.         """         pass      def __str__(self):            """ x.__str__() <==> str(x) """         pass      def __sub__(self, y):            """ x.__sub__(y) <==> x-y """         pass      def __truediv__(self, y):            """ x.__truediv__(y) <==> x/y """         pass      def __trunc__(self, *args, **kwargs): # real signature unknown         """ Return the Integral closest to x between 0 and x. """         pass      imag = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default     """the imaginary part of a complex number"""      real = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default     """the real part of a complex number"""  float

• 字符串

如：'wupeiqi'、'alex'

每个字符串都具备如下功能：

center():内容居中，width：总长度；fillchar：空白处填充内容，默认无

 >>> name='lzl'  >>> name.center(20,":")  '::::::::lzl:::::::::'  >>> name.center(20,"*")  '********lzl*********' 

ljust(self, width, fillchar=None):内容左对齐，右侧填充 ；相反rjust

count():子序列个数

expendtabs(self, tabsize=None):  将tab转换成空格，默认一个tab转换成8个空格 ,可结合strip()使用

find():寻找第一个子序列位置下标，如果没找到，返回 -1

index():寻找第一个子序列位置下标，如果没找到，报错

endswith(self, suffix, start=None, end=None): 是否以 xxx 结束；相反startswith

isalnum(self):是否是字母和数字

isalpha(self):是否是字母 isdigit(self): 是否是数字

islower(self):  是否小写       isupper(self):是否大写

swapcase(self): 大写变小写，小写变大写

partition(self, sep): 分割，前，中，后三部分

 >>> name='hello lzl'  >>> name.partition('ll')  ('he', 'll', 'o lzl') 

replace(self, old, new, count=None): 替换

translate(self, table, deletechars=None): 转换，需要先做一个对应表，最后一个表示删除字符集合

zfill(self, width):方法返回指定长度的字符串，原字符串右对齐，前面填充0。可以用rjust实现

详细：

  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.     """     def capitalize(self):           """ 首字母变大写 """         """         S.capitalize() -> string                  Return a copy of the string S with only its first character         capitalized.         """         return ""      def center(self, width, fillchar=None):           """ 内容居中，width：总长度；fillchar：空白处填充内容，默认无 """         """         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)         """         return ""      def count(self, sub, start=None, end=None):           """ 子序列个数 """         """         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.         """         return 0      def decode(self, encoding=None, errors=None):           """ 解码 """         """         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.         """         return object()      def encode(self, encoding=None, errors=None):           """ 编码，针对unicode """         """         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.         """         return object()      def endswith(self, suffix, start=None, end=None):           """ 是否以 xxx 结束 """         """         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.         """         return False      def expandtabs(self, tabsize=None):           """ 将tab转换成空格，默认一个tab转换成8个空格 """         """         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.         """         return ""      def find(self, sub, start=None, end=None):           """ 寻找子序列位置，如果没找到，返回 -1 """         """         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.         """         return 0      def format(*args, **kwargs): # known special case of str.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 '}').         """         pass      def index(self, sub, start=None, end=None):           """ 子序列位置，如果没找到，报错 """         S.index(sub [,start [,end]]) -> int                  Like S.find() but raise ValueError when the substring is not found.         """         return 0      def isalnum(self):           """ 是否是字母和数字 """         """         S.isalnum() -> bool                  Return True if all characters in S are alphanumeric         and there is at least one character in S, False otherwise.         """         return False      def isalpha(self):           """ 是否是字母 """         """         S.isalpha() -> bool                  Return True if all characters in S are alphabetic         and there is at least one character in S, False otherwise.         """         return False      def isdigit(self):           """ 是否是数字 """         """         S.isdigit() -> bool                  Return True if all characters in S are digits         and there is at least one character in S, False otherwise.         """         return False      def islower(self):           """ 是否小写 """         """         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.         """         return False      def isspace(self):           """         S.isspace() -> bool                  Return True if all characters in S are whitespace         and there is at least one character in S, False otherwise.         """         return False      def istitle(self):           """         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.         """         return False      def isupper(self):           """         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.         """         return False      def join(self, iterable):           """ 连接 """         """         S.join(iterable) -> string                  Return a string which is the concatenation of the strings in the         iterable.  The separator between elements is S.         """         return ""      def ljust(self, width, fillchar=None):           """ 内容左对齐，右侧填充 """         """         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).         """         return ""      def lower(self):           """ 变小写 """         """         S.lower() -> string                  Return a copy of the string S converted to lowercase.         """         return ""      def lstrip(self, chars=None):           """ 移除左侧空白 """         """         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         """         return ""      def partition(self, sep):           """ 分割，前，中，后三部分 """         """         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.         """         pass      def replace(self, old, new, count=None):           """ 替换 """         """         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.         """         return ""      def rfind(self, sub, start=None, end=None):           """         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.         """         return 0      def rindex(self, sub, start=None, end=None):           """         S.rindex(sub [,start [,end]]) -> int                  Like S.rfind() but raise ValueError when the substring is not found.         """         return 0      def rjust(self, width, fillchar=None):           """         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)         """         return ""      def rpartition(self, sep):           """         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.         """         pass      def rsplit(self, sep=None, maxsplit=None):           """         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.         """         return []      def rstrip(self, chars=None):           """         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         """         return ""      def split(self, sep=None, maxsplit=None):           """ 分割， maxsplit最多分割几次 """         """         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.         """         return []      def splitlines(self, keepends=False):           """ 根据换行分割 """         """         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.         """         return []      def startswith(self, prefix, start=None, end=None):           """ 是否起始 """         """         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.         """         return False      def strip(self, chars=None):           """ 移除两段空白 """         """         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         """         return ""      def swapcase(self):           """ 大写变小写，小写变大写 """         """         S.swapcase() -> string                  Return a copy of the string S with uppercase characters         converted to lowercase and vice versa.         """         return ""      def title(self):           """         S.title() -> string                  Return a titlecased version of S, i.e. words start with uppercase         characters, all remaining cased characters have lowercase.         """         return ""      def translate(self, table, deletechars=None):           """         转换，需要先做一个对应表，最后一个表示删除字符集合         intab = "aeiou"         outtab = "12345"         trantab = maketrans(intab, outtab)         str = "this is string example....wow!!!"         print str.translate(trantab, 'xm')         """          """         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.         """         return ""      def upper(self):           """         S.upper() -> string                  Return a copy of the string S converted to uppercase.         """         return ""      def zfill(self, width):           """方法返回指定长度的字符串，原字符串右对齐，前面填充0。"""         """         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.         """         return ""      def _formatter_field_name_split(self, *args, **kwargs): # real signature unknown         pass      def _formatter_parser(self, *args, **kwargs): # real signature unknown         pass      def __add__(self, y):           """ x.__add__(y) <==> x+y """         pass      def __contains__(self, y):           """ x.__contains__(y) <==> y in x """         pass      def __eq__(self, y):           """ x.__eq__(y) <==> x==y """         pass      def __format__(self, format_spec):           """         S.__format__(format_spec) -> string                  Return a formatted version of S as described by format_spec.         """         return ""      def __getattribute__(self, name):           """ x.__getattribute__('name') <==> x.name """         pass      def __getitem__(self, y):           """ x.__getitem__(y) <==> x[y] """         pass      def __getnewargs__(self, *args, **kwargs): # real signature unknown         pass      def __getslice__(self, i, j):           """         x.__getslice__(i, j) <==> x[i:j]                                        Use of negative indices is not supported.         """         pass      def __ge__(self, y):           """ x.__ge__(y) <==> x>=y """         pass      def __gt__(self, y):           """ x.__gt__(y) <==> x>y """         pass      def __hash__(self):           """ x.__hash__() <==> hash(x) """         pass      def __init__(self, string=''): # known special case of str.__init__         """         str(object='') -> string                  Return a nice string representation of the object.         If the argument is a string, the return value is the same object.         # (copied from class doc)         """         pass      def __len__(self):           """ x.__len__() <==> len(x) """         pass      def __le__(self, y):           """ x.__le__(y) <==> x<=y """         pass      def __lt__(self, y):           """ x.__lt__(y) <==> x<y """         pass      def __mod__(self, y):           """ x.__mod__(y) <==> x%y """         pass      def __mul__(self, n):           """ x.__mul__(n) <==> x*n """         pass      @staticmethod # known case of __new__     def __new__(S, *more):           """ T.__new__(S, ...) -> a new object with type S, a subtype of T """         pass      def __ne__(self, y):           """ x.__ne__(y) <==> x!=y """         pass      def __repr__(self):           """ x.__repr__() <==> repr(x) """         pass      def __rmod__(self, y):           """ x.__rmod__(y) <==> y%x """         pass      def __rmul__(self, n):           """ x.__rmul__(n) <==> n*x """         pass      def __sizeof__(self):           """ S.__sizeof__() -> size of S in memory, in bytes """         pass      def __str__(self):           """ x.__str__() <==> str(x) """         pass  str

• 列表

如：[11,22,33]、['wupeiqi', 'alex']

None、空列表和初始化： None是python内建值，表示什么也没有，创建10个元素空间的列表---sequence=[None]*10

每个列表都具备如下功能：

extend():list1.extend(list2) 扩展list1，list2列表不变

insert(self, index, p_object): 插入元素 -- insert object before index

pop()； 删除并返回 指定下标的值，不指定下标，默认返回最后一个元素

sort(self, cmp=None, key=None, reverse=False):排序，字符按ascci码比较，中文按Unicode比较，

注意：sort对列表排序后改变了原来的列表，返回的是空值None，即要想需要一个排好序的副本，又想保留原有的列表不变，可以：

 >>> x=[5,4,3,6,4,7]  >>> y=x[:] #列表的分片赋值  >>> y.sort()  >>> x  [5, 4, 3, 6, 4, 7]  >>> y  [3, 4, 4, 5, 6, 7]  另一种获取：sorted函数  >>> y=sorted(x)  >>> y  [3, 4, 4, 5, 6, 7] 

扩展：希望元素按照特定方式排序（而不是按照sort默认的升序）

 >>> x=['aa','bbb','a','ab','cccc']  >>> x.sort(key=len) #len为函数，该函数不是直接用来确定对象的大小，而是为每个元素创建一个以元素长度的键值，然后以键排序  >>> x  ['a', 'aa', 'ab', 'bbb', 'cccc'] 

详细:

  class list(object):     """     list() -> new empty list     list(iterable) -> new list initialized from iterable's items     """     def append(self, p_object): # real signature unknown; restored from __doc__         """ L.append(object) -- append object to end """         pass      def count(self, value): # real signature unknown; restored from __doc__         """ L.count(value) -> integer -- return number of occurrences of value """         return 0      def extend(self, iterable): # real signature unknown; restored from __doc__         """ L.extend(iterable) -- extend list by appending elements from the iterable """         pass      def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__         """         L.index(value, [start, [stop]]) -> integer -- return first index of value.         Raises ValueError if the value is not present.         """         return 0      def insert(self, index, p_object): # real signature unknown; restored from __doc__         """ L.insert(index, object) -- insert object before index """         pass      def pop(self, index=None): # real signature unknown; restored from __doc__         """         L.pop([index]) -> item -- remove and return item at index (default last).         Raises IndexError if list is empty or index is out of range.         """         pass      def remove(self, value): # real signature unknown; restored from __doc__         """         L.remove(value) -- remove first occurrence of value.         Raises ValueError if the value is not present.         """         pass      def reverse(self): # real signature unknown; restored from __doc__         """ L.reverse() -- reverse *IN PLACE* """         pass      def sort(self, cmp=None, key=None, reverse=False): # real signature unknown; restored from __doc__         """         L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;         cmp(x, y) -> -1, 0, 1         """         pass      def __add__(self, y): # real signature unknown; restored from __doc__         """ x.__add__(y) <==> x+y """         pass      def __contains__(self, y): # real signature unknown; restored from __doc__         """ x.__contains__(y) <==> y in x """         pass      def __delitem__(self, y): # real signature unknown; restored from __doc__         """ x.__delitem__(y) <==> del x[y] """         pass      def __delslice__(self, i, j): # real signature unknown; restored from __doc__         """         x.__delslice__(i, j) <==> del x[i:j]                                        Use of negative indices is not supported.         """         pass      def __eq__(self, y): # real signature unknown; restored from __doc__         """ x.__eq__(y) <==> x==y """         pass      def __getattribute__(self, name): # real signature unknown; restored from __doc__         """ x.__getattribute__('name') <==> x.name """         pass      def __getitem__(self, y): # real signature unknown; restored from __doc__         """ x.__getitem__(y) <==> x[y] """         pass      def __getslice__(self, i, j): # real signature unknown; restored from __doc__         """         x.__getslice__(i, j) <==> x[i:j]                                        Use of negative indices is not supported.         """         pass      def __ge__(self, y): # real signature unknown; restored from __doc__         """ x.__ge__(y) <==> x>=y """         pass      def __gt__(self, y): # real signature unknown; restored from __doc__         """ x.__gt__(y) <==> x>y """         pass      def __iadd__(self, y): # real signature unknown; restored from __doc__         """ x.__iadd__(y) <==> x+=y """         pass      def __imul__(self, y): # real signature unknown; restored from __doc__         """ x.__imul__(y) <==> x*=y """         pass      def __init__(self, seq=()): # known special case of list.__init__         """         list() -> new empty list         list(iterable) -> new list initialized from iterable's items         # (copied from class doc)         """         pass      def __iter__(self): # real signature unknown; restored from __doc__         """ x.__iter__() <==> iter(x) """         pass      def __len__(self): # real signature unknown; restored from __doc__         """ x.__len__() <==> len(x) """         pass      def __le__(self, y): # real signature unknown; restored from __doc__         """ x.__le__(y) <==> x<=y """         pass      def __lt__(self, y): # real signature unknown; restored from __doc__         """ x.__lt__(y) <==> x<y """         pass      def __mul__(self, n): # real signature unknown; restored from __doc__         """ x.__mul__(n) <==> x*n """         pass      @staticmethod # known case of __new__     def __new__(S, *more): # real signature unknown; restored from __doc__         """ T.__new__(S, ...) -> a new object with type S, a subtype of T """         pass      def __ne__(self, y): # real signature unknown; restored from __doc__         """ x.__ne__(y) <==> x!=y """         pass      def __repr__(self): # real signature unknown; restored from __doc__         """ x.__repr__() <==> repr(x) """         pass      def __reversed__(self): # real signature unknown; restored from __doc__         """ L.__reversed__() -- return a reverse iterator over the list """         pass      def __rmul__(self, n): # real signature unknown; restored from __doc__         """ x.__rmul__(n) <==> n*x """         pass      def __setitem__(self, i, y): # real signature unknown; restored from __doc__         """ x.__setitem__(i, y) <==> x[i]=y """         pass      def __setslice__(self, i, j, y): # real signature unknown; restored from __doc__         """         x.__setslice__(i, j, y) <==> x[i:j]=y                                        Use  of negative indices is not supported.         """         pass      def __sizeof__(self): # real signature unknown; restored from __doc__         """ L.__sizeof__() -- size of L in memory, in bytes """         pass      __hash__ = None  list

• 元组

是一种序列，如果用逗号分隔一些值，即可创建，逗号很重要：（38）和38一样都是int；或用tuple函数以一个序列为参数创建

 >>> a=(38) >>> type(a) <type 'int'> >>> tuple('abc')  ('a', 'b', 'c')       >>> tuple([1,2,3])       (1, 2, 3)    

如：(11,22,33)、('wupeiqi', 'alex')

元组意义：

1. 元组可在映射（和集合的成员）中当键使用
2. 元组作为很多内建函数和方法的返回值存在

每个元组都具备如下功能：

  class tuple(object):     """     tuple() -> empty tuple     tuple(iterable) -> tuple initialized from iterable's items          If the argument is a tuple, the return value is the same object.     """     def count(self, value): # real signature unknown; restored from __doc__         """ T.count(value) -> integer -- return number of occurrences of value """         return 0      def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__         """         T.index(value, [start, [stop]]) -> integer -- return first index of value.         Raises ValueError if the value is not present.         """         return 0      def __add__(self, y): # real signature unknown; restored from __doc__         """ x.__add__(y) <==> x+y """         pass      def __contains__(self, y): # real signature unknown; restored from __doc__         """ x.__contains__(y) <==> y in x """         pass      def __eq__(self, y): # real signature unknown; restored from __doc__         """ x.__eq__(y) <==> x==y """         pass      def __getattribute__(self, name): # real signature unknown; restored from __doc__         """ x.__getattribute__('name') <==> x.name """         pass      def __getitem__(self, y): # real signature unknown; restored from __doc__         """ x.__getitem__(y) <==> x[y] """         pass      def __getnewargs__(self, *args, **kwargs): # real signature unknown         pass      def __getslice__(self, i, j): # real signature unknown; restored from __doc__         """         x.__getslice__(i, j) <==> x[i:j]                                        Use of negative indices is not supported.         """         pass      def __ge__(self, y): # real signature unknown; restored from __doc__         """ x.__ge__(y) <==> x>=y """         pass      def __gt__(self, y): # real signature unknown; restored from __doc__         """ x.__gt__(y) <==> x>y """         pass      def __hash__(self): # real signature unknown; restored from __doc__         """ x.__hash__() <==> hash(x) """         pass      def __init__(self, seq=()): # known special case of tuple.__init__         """         tuple() -> empty tuple         tuple(iterable) -> tuple initialized from iterable's items                  If the argument is a tuple, the return value is the same object.         # (copied from class doc)         """         pass      def __iter__(self): # real signature unknown; restored from __doc__         """ x.__iter__() <==> iter(x) """         pass      def __len__(self): # real signature unknown; restored from __doc__         """ x.__len__() <==> len(x) """         pass      def __le__(self, y): # real signature unknown; restored from __doc__         """ x.__le__(y) <==> x<=y """         pass      def __lt__(self, y): # real signature unknown; restored from __doc__         """ x.__lt__(y) <==> x<y """         pass      def __mul__(self, n): # real signature unknown; restored from __doc__         """ x.__mul__(n) <==> x*n """         pass      @staticmethod # known case of __new__     def __new__(S, *more): # real signature unknown; restored from __doc__         """ T.__new__(S, ...) -> a new object with type S, a subtype of T """         pass      def __ne__(self, y): # real signature unknown; restored from __doc__         """ x.__ne__(y) <==> x!=y """         pass      def __repr__(self): # real signature unknown; restored from __doc__         """ x.__repr__() <==> repr(x) """         pass      def __rmul__(self, n): # real signature unknown; restored from __doc__         """ x.__rmul__(n) <==> n*x """         pass      def __sizeof__(self): # real signature unknown; restored from __doc__         """ T.__sizeof__() -- size of T in memory, in bytes """         pass  tuple

• 字典

如：{'name': 'wupeiqi', 'age': 18} 、{'host': '2.2.2.2', 'port': 80]}

ps：循环时，默认循环key

每个字典都具备如下功能：

clear(self):清除内容

get(self, k, d=None): 根据key获取值，d是默认值，

 >>> dic1={'name':'lzl','age':18}  >>> dic1['name']  'lzl'  >>> dic1['k3'] #找不到键k3，返回KeyError报错  Traceback (most recent call last):  File "<input>", line 1, in <module>  KeyError: 'k3'  >>> dic1.get('name')  'lzl'  >>> print dic1.get('k3')  None  >>> print dic1.get('k3','ok') #如果没有键k3，返回值‘ok’  ok 

fromkeys(S, v=None):

 >>> a={}  >>> a.fromkeys([1,2,3],[])  {1: [], 2: [], 3: []}  >>> a.fromkeys([1,2,3],'password') #执行后字典a不变  {1: 'password', 2: 'password', 3: 'password'}  >>> c=a.fromkeys(range(5),[])  >>> c  {0: [], 1: [], 2: [], 3: [], 4: []}  >>> c[1]  []  >>> c[1].append('lzl') # fromkeys生成的values为列表时，对value修改会修改所有的值  >>> c  {0: ['lzl'], 1: ['lzl'], 2: ['lzl'], 3: ['lzl'], 4: ['lzl']}  >>> c=a.fromkeys(range(5),'lzl')   #生成字典值为字符串  >>> c  {0: 'lzl', 1: 'lzl', 2: 'lzl', 3: 'lzl', 4: 'lzl'}  >>> c[0]='hero'  #  >>> c  {0: 'hero', 1: 'lzl', 2: 'lzl', 3: 'lzl', 4: 'lzl'}  #只修改key 0对应value 

items(self):生成所有（键，值）元组的列表

 >>> b= a.fromkeys([1,2,3],[])  >>> b.items()  [(1, []), (2, []), (3, [])]  >>> for k,v in b.items():print k,v #不推荐此种循环方式，字典较大时会增加内存和生成列表过程  1 []  2 []  3 []  >>> for k in b:print k,b[k]  #另一种循环方式  1 []  2 []  3 [] 

keys(self):所有的key列表  values(self): 所有的值的列表

setdefault(self, k, d=None): 如果key不存在，则创建，如果存在，则返回已存在的值 且不修改

 >>> a={}  >>> for i in range(5):a[i]=[]  >>> a #生成的字典a的值（空列表）占用不同的内存，区别于fromkeys方法  {0: [], 1: [], 2: [], 3: [], 4: []}  >>> a[1].append({'b':1})  >>> a  {0: [], 1: [{'b': 1}], 2: [], 3: [], 4: []}  >>> a[1][0]['b'] #逐层取值  1  >>> b=a #把字典a赋值给b  >>> b  {0: [], 1: [{'b': 1}], 2: [], 3: [], 4: []}  >>> a['key5']='lzl' #修改字典a的值  >>> a  {0: [], 1: [{'b': 1}], 2: [], 3: [], 4: [], 'key5': 'lzl'}  >>> b #注意：b的值跟着变，但对于字符的变量不会变，此时变量是字典，如此减少了内存占用  {0: [], 1: [{'b': 1}], 2: [], 3: [], 4: [], 'key5': 'lzl'} 

由此引出方法copy（），以生成独立的字典变量  #注意：浅copy，只针对一层

 >>> del a[ 'key5']  >>> a  {0: [], 1: [{'b': 1}], 2: [], 3: [], 4: []}  >>> b #同样b跟着改变  {0: [], 1: [{'b': 1}], 2: [], 3: [], 4: []}  >>> b=a.copy() #以copy方式赋值b  >>> a['key5']='lzl'  >>> a  {0: [], 1: [{'b': 1}], 2: [], 3: [], 4: [], 'key5': 'lzl'}  >>> b #b不变  {0: [], 1: [{'b': 1}], 2: [], 3: [], 4: []} 

另一种情况：当字典中的值中再有新字典

 >>> a[1][0]['b']='hehe'  >>> a  {0: [], 1: [{'b': 'hehe'}], 2: [], 3: [], 4: []，'key5': 'lzl'}  >>> b #二层的字典跟着改变  {0: [], 1: [{'b': 'hehe'}], 2: [], 3: [], 4: []} 

由此引出深copy：借助 第三方模块—copy

 >>> import copy  >>> d=copy.deepcopy(a)  >>> d  {0: [], 1: [{'b': 'hehe'}], 2: [], 3: [], 4: [], 'key5': 'lzl'}  >>> a[1][0]['b']='game over!'  >>> a  {0: [], 1: [{'b': 'game over!'}], 2: [], 3: [], 4: [], 'key5': 'lzl'}  >>> d #完全独立  {0: [], 1: [{'b': 'hehe'}], 2: [], 3: [], 4: [], 'key5': 'lzl'} 

  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)     """      def clear(self): # real signature unknown; restored from __doc__         """ 清除内容 """         """ D.clear() -> None.  Remove all items from D. """         pass      def copy(self): # real signature unknown; restored from __doc__         """ 浅拷贝 """         """ D.copy() -> a shallow copy of D """         pass      @staticmethod # known case     def fromkeys(S, v=None): # real signature unknown; restored from __doc__         """         dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.         v defaults to None.         """         pass      def get(self, k, d=None): # real signature unknown; restored from __doc__         """ 根据key获取值，d是默认值 """         """ D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None. """         pass      def has_key(self, k): # real signature unknown; restored from __doc__         """ 是否有key """         """ D.has_key(k) -> True if D has a key k, else False """         return False      def items(self): # real signature unknown; restored from __doc__         """ 所有项的列表形式 """         """ D.items() -> list of D's (key, value) pairs, as 2-tuples """         return []      def iteritems(self): # real signature unknown; restored from __doc__         """ 项可迭代 """         """ D.iteritems() -> an iterator over the (key, value) items of D """         pass      def iterkeys(self): # real signature unknown; restored from __doc__         """ key可迭代 """         """ D.iterkeys() -> an iterator over the keys of D """         pass      def itervalues(self): # real signature unknown; restored from __doc__         """ value可迭代 """         """ D.itervalues() -> an iterator over the values of D """         pass      def keys(self): # real signature unknown; restored from __doc__         """ 所有的key列表 """         """ D.keys() -> list of D's keys """         return []      def pop(self, k, d=None): # real signature unknown; restored from __doc__         """ 获取并在字典中移除 """         """         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         """         pass      def popitem(self): # real signature unknown; restored from __doc__         """ 获取并在字典中移除 """         """         D.popitem() -> (k, v), remove and return some (key, value) pair as a         2-tuple; but raise KeyError if D is empty.         """         pass      def setdefault(self, k, d=None): # real signature unknown; restored from __doc__         """ 如果key不存在，则创建，如果存在，则返回已存在的值且不修改 """         """ D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """         pass      def update(self, E=None, **F): # known special case of dict.update         """ 更新             {'name':'alex', 'age': 18000}             [('name','sbsbsb'),]         """         """         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]         """         pass      def values(self): # real signature unknown; restored from __doc__         """ 所有的值 """         """ D.values() -> list of D's values """         return []      def viewitems(self): # real signature unknown; restored from __doc__         """ 所有项，只是将内容保存至view对象中 """         """ D.viewitems() -> a set-like object providing a view on D's items """         pass      def viewkeys(self): # real signature unknown; restored from __doc__         """ D.viewkeys() -> a set-like object providing a view on D's keys """         pass      def viewvalues(self): # real signature unknown; restored from __doc__         """ D.viewvalues() -> an object providing a view on D's values """         pass      def __cmp__(self, y): # real signature unknown; restored from __doc__         """ x.__cmp__(y) <==> cmp(x,y) """         pass      def __contains__(self, k): # real signature unknown; restored from __doc__         """ D.__contains__(k) -> True if D has a key k, else False """         return False      def __delitem__(self, y): # real signature unknown; restored from __doc__         """ x.__delitem__(y) <==> del x[y] """         pass      def __eq__(self, y): # real signature unknown; restored from __doc__         """ x.__eq__(y) <==> x==y """         pass      def __getattribute__(self, name): # real signature unknown; restored from __doc__         """ x.__getattribute__('name') <==> x.name """         pass      def __getitem__(self, y): # real signature unknown; restored from __doc__         """ x.__getitem__(y) <==> x[y] """         pass      def __ge__(self, y): # real signature unknown; restored from __doc__         """ x.__ge__(y) <==> x>=y """         pass      def __gt__(self, y): # real signature unknown; restored from __doc__         """ x.__gt__(y) <==> x>y """         pass      def __init__(self, seq=None, **kwargs): # known special case of dict.__init__         """         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)         # (copied from class doc)         """         pass      def __iter__(self): # real signature unknown; restored from __doc__         """ x.__iter__() <==> iter(x) """         pass      def __len__(self): # real signature unknown; restored from __doc__         """ x.__len__() <==> len(x) """         pass      def __le__(self, y): # real signature unknown; restored from __doc__         """ x.__le__(y) <==> x<=y """         pass      def __lt__(self, y): # real signature unknown; restored from __doc__         """ x.__lt__(y) <==> x<y """         pass      @staticmethod # known case of __new__     def __new__(S, *more): # real signature unknown; restored from __doc__         """ T.__new__(S, ...) -> a new object with type S, a subtype of T """         pass      def __ne__(self, y): # real signature unknown; restored from __doc__         """ x.__ne__(y) <==> x!=y """         pass      def __repr__(self): # real signature unknown; restored from __doc__         """ x.__repr__() <==> repr(x) """         pass      def __setitem__(self, i, y): # real signature unknown; restored from __doc__         """ x.__setitem__(i, y) <==> x[i]=y """         pass      def __sizeof__(self): # real signature unknown; restored from __doc__         """ D.__sizeof__() -> size of D in memory, in bytes """         pass      __hash__ = None  dict

• set集合

set是一个无序且不重复的元素集合

主要功能去重和比对

 >>> a=[1,2,3,4]  >>> b=[3,4,5,6]  >>> a.append(3)  >>> a  [1, 2, 3, 4, 3]  >>> c=set(a)  >>> c #生成集合，去重  set([1, 2, 3, 4])  >>> d=set(b)  >>> c & d #取交集 相当于c.intersection(d)  set([3, 4])  >>> c | d #取并集 相当于c.union(d)  set([1, 2, 3, 4, 5, 6])  >>> c-d #取集合c中独有的 相当于c.difference(d)  set([1, 2])  >>> d-c #取集合d中独有的  set([5, 6])  >>> e=c&d  >>> e  set([3, 4])  >>> e.issubset(c) #判断e是不是c的子集  True  >>> e.issuperset(c) #判断e是不是c的夫集  False 

discard(self, *args, **kwargs):移除元素

isdisjoint(self, *args, **kwargs):如果没有交集，返回true

详细：

  class set(object):     """     set() -> new empty set object     set(iterable) -> new set object          Build an unordered collection of unique elements.     """     def add(self, *args, **kwargs): # real signature unknown         """ 添加 """         """         Add an element to a set.                  This has no effect if the element is already present.         """         pass      def clear(self, *args, **kwargs): # real signature unknown         """ Remove all elements from this set. """         pass      def copy(self, *args, **kwargs): # real signature unknown         """ Return a shallow copy of a set. """         pass      def difference(self, *args, **kwargs): # real signature unknown         """         Return the difference of two or more sets as a new set.                  (i.e. all elements that are in this set but not the others.)         """         pass      def difference_update(self, *args, **kwargs): # real signature unknown         """ 删除当前set中的所有包含在 new set 里的元素 """         """ Remove all elements of another set from this set. """         pass      def discard(self, *args, **kwargs): # real signature unknown         """ 移除元素 """         """         Remove an element from a set if it is a member.                  If the element is not a member, do nothing.         """         pass      def intersection(self, *args, **kwargs): # real signature unknown         """ 取交集，新创建一个set """         """         Return the intersection of two or more sets as a new set.                  (i.e. elements that are common to all of the sets.)         """         pass      def intersection_update(self, *args, **kwargs): # real signature unknown         """ 取交集，修改原来set """         """ Update a set with the intersection of itself and another. """         pass      def isdisjoint(self, *args, **kwargs): # real signature unknown         """ 如果没有交集，返回true  """         """ Return True if two sets have a null intersection. """         pass      def issubset(self, *args, **kwargs): # real signature unknown         """ 是否是子集 """         """ Report whether another set contains this set. """         pass      def issuperset(self, *args, **kwargs): # real signature unknown         """ 是否是父集 """         """ Report whether this set contains another set. """         pass      def pop(self, *args, **kwargs): # real signature unknown         """ 移除 """         """         Remove and return an arbitrary set element.         Raises KeyError if the set is empty.         """         pass      def remove(self, *args, **kwargs): # real signature unknown         """ 移除 """         """         Remove an element from a set; it must be a member.                  If the element is not a member, raise a KeyError.         """         pass      def symmetric_difference(self, *args, **kwargs): # real signature unknown         """ 差集，创建新对象"""         """         Return the symmetric difference of two sets as a new set.                  (i.e. all elements that are in exactly one of the sets.)         """         pass      def symmetric_difference_update(self, *args, **kwargs): # real signature unknown         """ 差集，改变原来 """         """ Update a set with the symmetric difference of itself and another. """         pass      def union(self, *args, **kwargs): # real signature unknown         """ 并集 """         """         Return the union of sets as a new set.                  (i.e. all elements that are in either set.)         """         pass      def update(self, *args, **kwargs): # real signature unknown         """ 更新 """         """ Update a set with the union of itself and others. """         pass      def __and__(self, y): # real signature unknown; restored from __doc__         """ x.__and__(y) <==> x&y """         pass      def __cmp__(self, y): # real signature unknown; restored from __doc__         """ x.__cmp__(y) <==> cmp(x,y) """         pass      def __contains__(self, y): # real signature unknown; restored from __doc__         """ x.__contains__(y) <==> y in x. """         pass      def __eq__(self, y): # real signature unknown; restored from __doc__         """ x.__eq__(y) <==> x==y """         pass      def __getattribute__(self, name): # real signature unknown; restored from __doc__         """ x.__getattribute__('name') <==> x.name """         pass      def __ge__(self, y): # real signature unknown; restored from __doc__         """ x.__ge__(y) <==> x>=y """         pass      def __gt__(self, y): # real signature unknown; restored from __doc__         """ x.__gt__(y) <==> x>y """         pass      def __iand__(self, y): # real signature unknown; restored from __doc__         """ x.__iand__(y) <==> x&=y """         pass      def __init__(self, seq=()): # known special case of set.__init__         """         set() -> new empty set object         set(iterable) -> new set object                  Build an unordered collection of unique elements.         # (copied from class doc)         """         pass      def __ior__(self, y): # real signature unknown; restored from __doc__         """ x.__ior__(y) <==> x|=y """         pass      def __isub__(self, y): # real signature unknown; restored from __doc__         """ x.__isub__(y) <==> x-=y """         pass      def __iter__(self): # real signature unknown; restored from __doc__         """ x.__iter__() <==> iter(x) """         pass      def __ixor__(self, y): # real signature unknown; restored from __doc__         """ x.__ixor__(y) <==> x^=y """         pass      def __len__(self): # real signature unknown; restored from __doc__         """ x.__len__() <==> len(x) """         pass      def __le__(self, y): # real signature unknown; restored from __doc__         """ x.__le__(y) <==> x<=y """         pass      def __lt__(self, y): # real signature unknown; restored from __doc__         """ x.__lt__(y) <==> x<y """         pass      @staticmethod # known case of __new__     def __new__(S, *more): # real signature unknown; restored from __doc__         """ T.__new__(S, ...) -> a new object with type S, a subtype of T """         pass      def __ne__(self, y): # real signature unknown; restored from __doc__         """ x.__ne__(y) <==> x!=y """         pass      def __or__(self, y): # real signature unknown; restored from __doc__         """ x.__or__(y) <==> x|y """         pass      def __rand__(self, y): # real signature unknown; restored from __doc__         """ x.__rand__(y) <==> y&x """         pass      def __reduce__(self, *args, **kwargs): # real signature unknown         """ Return state information for pickling. """         pass      def __repr__(self): # real signature unknown; restored from __doc__         """ x.__repr__() <==> repr(x) """         pass      def __ror__(self, y): # real signature unknown; restored from __doc__         """ x.__ror__(y) <==> y|x """         pass      def __rsub__(self, y): # real signature unknown; restored from __doc__         """ x.__rsub__(y) <==> y-x """         pass      def __rxor__(self, y): # real signature unknown; restored from __doc__         """ x.__rxor__(y) <==> y^x """         pass      def __sizeof__(self): # real signature unknown; restored from __doc__         """ S.__sizeof__() -> size of S in memory, in bytes """         pass      def __sub__(self, y): # real signature unknown; restored from __doc__         """ x.__sub__(y) <==> x-y """         pass      def __xor__(self, y): # real signature unknown; restored from __doc__         """ x.__xor__(y) <==> x^y """         pass      __hash__ = None  set

深浅拷贝

为什么要拷贝？

数字字符串 和 集合 在修改时的差异？ （深浅拷贝不同的终极原因 ）

• 数字字符串：在内存中新建一份数据
• 集合：修改内存中的同一份数据—>优点？节省内存空间

对于集合，如何保留其修改前和修改后的数据？

对于集合，如何拷贝其n层元素同时拷贝？