一、作用域

对于变量的作用域，执行声明并在内存中存在，该变量就可以在下面的代码中使用。

  1. if 1==1:
  2.     name = 'wupeiqi'
  3. print  name

二、三元运算

result = 值1 if 条件 else 值2   如#果条件成立，值1付给result否则值2付给result

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

name =  'sb'  if 1==1 else '2b'

  1. input = raw_input()
  2.  
  3. result = '2b'  if input =='alex' else 'haoren'

python基础

python里面切皆为对象，对象都是类创建的

例如：li = [11,22,33]  ===类

li.append

1  类创建列表

2  类表还能返回这个类

所以说，对象所拥有的方法不是他自己所拥有的，而是从类里面找到的方法而执行的。

可以用type(li)查看对象的类型

1   <type 'list'> 这个list就是创建li的类

2  然后用dir(list) 能看到所有list下的方法---预览

3  help(list) 看详细的python的源码了---都有什么功能

4  help(list.append)---就只看append的方法

5  在pycham上按住ctrl键点在你要看的类上，就可以看了。

类中的方法可分为 1 内置方法(__add__)两头带__,他的执行方式可能有一种，也可能有多种。

2 不是内置方法,只能有一种执行方法，也就是list.append()

一、整数

如： 18、73、84

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

例如：n1 = -9

n1.__abs__()

9

或者直接abs(-9)

  1. 创建方法：前面两点相同
  1. i = 10
  1. i = int(10)
  1. i = int(“10”,base=2) 创建2进制的字符是10的，
  1.  
  1. class int(object):
  2.     """
  3.     int(x=0) -> int or long
  4.     int(x, base=10) -> int or long
  5.  
  6.     Convert a number or string to an integer, or return 0 if no arguments
  7.     are given.  If x is floating point, the conversion truncates towards zero.
  8.     If x is outside the integer range, the function returns a long instead.
  9.  
  10.     If x is not a number or if base is given, then x must be a string or
  11.     Unicode object representing an integer literal in the given base.  The
  12.     literal can be preceded by '+' or '-' and be surrounded by whitespace.
  13.     The base defaults to 10.  Valid bases are 0 and 2-36.  Base 0 means to
  14.     interpret the base from the string as an integer literal.
  15.     >>> int('0b100', base=0)
  16.     4
  17.     """
  18.     def bit_length(self):
  19.         """ 返回表示该数字的时占用的最少位数 """
  20.         """
  21.         int.bit_length() -> int
  22.  
  23.         Number of bits necessary to represent self in binary.
  24.         >>> bin(37)
  25.         '0b100101'
  26.         >>> (37).bit_length()
  27.         6
  28.         """
  29.         return 0
  30.  
  31.     def conjugate(self, *args, **kwargs): # real signature unknown
  32.         """ 返回该复数的共轭复数 """
  33.         """ Returns self, the complex conjugate of any int. """
  34.         pass
  35.  
  36.     def __abs__(self):
  37.         """ 返回绝对值 """
  38.         """ x.__abs__() <==> abs(x) """
  39.         pass
  40.  
  41.     def __add__(self, y):
  42.         """ x.__add__(y) <==> x+y """
  43.         pass
  44.           #age = 18
  1.           #age.__add__(199)==18+199
  1.     def __and__(self, y):
  2.         """ x.__and__(y) <==> x&y """
  3.         pass
  4.  
  5.     def __cmp__(self, y):
  6.         """ 比较两个数大小 """
  7.         """ x.__cmp__(y) <==> cmp(x,y) """  大于为1 等于为0 小于为-1
  8.         pass
  9.  
  10.      def __coerce__(self, y):
  11.         """ 强制生成一个元组 """
  12.         """ x.__coerce__(y) <==> coerce(x, y) """
  13.         pass

def __divmod__(self, y): """ 相除，得到商和余数组成的元组 """网页上分页用 """ x.__divmod__(y) <==> divmod(x, y) """ pass

  1.     def __div__(self, y):
  2.         """ x.__div__(y) <==> x/y """
  3.         pass
  4.  
  5.     def __float__(self):
  6.         """ 转换为浮点类型 """
  7.         """ x.__float__() <==> float(x) """
  8.         pass
  9.  
  10.     def __floordiv__(self, y):
  11.         """ x.__floordiv__(y) <==> x//y """ 底板除
  12.         pass
  13.  
  14.     def __format__(self, *args, **kwargs): # real signature unknown
  15.         pass
  16.  
  17.     def __getattribute__(self, name):
  18.         """ x.__getattribute__('name') <==> x.name """
  19.         pass
  20.  
  21.     def __getnewargs__(self, *args, **kwargs): # real signature unknown
  22.         """ 内部调用 __new__方法或创建对象时传入参数使用 """
  23.         pass
  24.  
  25.     def __hash__(self):
  26.         """如果对象object为哈希表类型，返回对象object的哈希值。哈希值为整数。在字典查找中，哈希值用于快速比较字典的键。两个数值如果相等，则哈希值也相等。"""
  27.         """ x.__hash__() <==> hash(x) """
  28.         pass
  29.  
  30.     def __hex__(self):
  31.         """ 返回当前数的 十六进制 表示 """
  32.         """ x.__hex__() <==> hex(x) """
  33.         pass
  34.  
  35.     def __index__(self):
  36.         """ 用于切片，数字无意义 """
  37.         """ x[y:z] <==> x[y.__index__():z.__index__()] """
  38.         pass
  39.  
  40.     def __init__(self, x, base=10): # known special case of int.__init__
  41.         """ 构造方法，执行 x = 123 或 x = int(10) 时，自动调用，暂时忽略 """
  42.         """
  43.         int(x=0) -> int or long
  44.         int(x, base=10) -> int or long
  45.  
  46.         Convert a number or string to an integer, or return 0 if no arguments
  47.         are given.  If x is floating point, the conversion truncates towards zero.
  48.         If x is outside the integer range, the function returns a long instead.
  49.  
  50.         If x is not a number or if base is given, then x must be a string or
  51.         Unicode object representing an integer literal in the given base.  The
  52.         literal can be preceded by '+' or '-' and be surrounded by whitespace.
  53.         The base defaults to 10.  Valid bases are 0 and 2-36.  Base 0 means to
  54.         interpret the base from the string as an integer literal.
  55.         >>> int('0b100', base=0)
  56.         4
  57.         # (copied from class doc)
  58.         """
  59.         pass
  60.  
  61.     def __int__(self):
  62.         """ 转换为整数 """
  63.         """ x.__int__() <==> int(x) """
  64.         pass
  65.  
  66.     def __invert__(self):
  67.         """ x.__invert__() <==> ~x """
  68.         pass
  69.  
  70.     def __long__(self):
  71.         """ 转换为长整数 """
  72.         """ x.__long__() <==> long(x) """
  73.         pass
  74.  
  75.     def __lshift__(self, y):
  76.         """ x.__lshift__(y) <==> x<<y """
  77.         pass
  78.  
  79.     def __mod__(self, y):
  80.         """ x.__mod__(y) <==> x%y """
  81.         pass
  82.  
  83.     def __mul__(self, y):
  84.         """ x.__mul__(y) <==> x*y """
  85.         pass
  86.  
  87.     def __neg__(self):
  88.         """ x.__neg__() <==> -x """
  89.         pass
  90.  
  91.     @staticmethod # known case of __new__
  92.     def __new__(S, *more):
  93.         """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
  94.         pass
  95.  
  96.     def __nonzero__(self):
  97.         """ x.__nonzero__() <==> x != 0 """
  98.         pass
  99.  
  100.     def __oct__(self):
  101.         """ 返回改值的 八进制 表示 """
  102.         """ x.__oct__() <==> oct(x) """
  103.         pass
  104.  
  105.     def __or__(self, y):
  106.         """ x.__or__(y) <==> x|y """
  107.         pass
  108.  
  109.     def __pos__(self):
  110.         """ x.__pos__() <==> +x """
  111.         pass
  112.  
  113.     def __pow__(self, y, z=None):
  114.         """ 幂，次方 """2**8
  115.         """ x.__pow__(y[, z]) <==> pow(x, y[, z]) """
  116.         pass
  117.  
  118.     def __radd__(self, y):
  119.         """ x.__radd__(y) <==> y+x """
  120.         pass
  121.  
  122.     def __rand__(self, y):
  123.         """ x.__rand__(y) <==> y&x """
  124.         pass
  125.  
  126.     def __rdivmod__(self, y):
  127.         """ x.__rdivmod__(y) <==> divmod(y, x) """
  128.         pass
  129.  
  130.     def __rdiv__(self, y):
  131.         """ x.__rdiv__(y) <==> y/x """
  132.         pass
  133.  
  134.     def __repr__(self):
  135.         """转化为解释器可读取的形式 """
  136.         """ x.__repr__() <==> repr(x) """
  137.         pass
  138.  
  139.     def __str__(self):
  140.         """转换为人阅读的形式，如果没有适于人阅读的解释形式的话，则返回解释器课阅读的形式"""
  141.         """ x.__str__() <==> str(x) """
  142.         pass
  143.  
  144.     def __rfloordiv__(self, y):
  145.         """ x.__rfloordiv__(y) <==> y//x """
  146.         pass
  147.  
  148.     def __rlshift__(self, y):
  149.         """ x.__rlshift__(y) <==> y<<x """
  150.         pass
  151.  
  152.     def __rmod__(self, y):
  153.         """ x.__rmod__(y) <==> y%x """
  154.         pass
  155.  
  156.     def __rmul__(self, y):
  157.         """ x.__rmul__(y) <==> y*x """
  158.         pass
  159.  
  160.     def __ror__(self, y):
  161.         """ x.__ror__(y) <==> y|x """
  162.         pass
  163.  
  164.     def __rpow__(self, x, z=None):
  165.         """ y.__rpow__(x[, z]) <==> pow(x, y[, z]) """
  166.         pass
  167.  
  168.     def __rrshift__(self, y):
  169.         """ x.__rrshift__(y) <==> y>>x """
  170.         pass
  171.  
  172.     def __rshift__(self, y):
  173.         """ x.__rshift__(y) <==> x>>y """
  174.         pass
  175.  
  176.     def __rsub__(self, y):
  177.         """ x.__rsub__(y) <==> y-x """
  178.         pass
  179.  
  180.     def __rtruediv__(self, y):
  181.         """ x.__rtruediv__(y) <==> y/x """
  182.         pass
  183.  
  184.     def __rxor__(self, y):
  185.         """ x.__rxor__(y) <==> y^x """
  186.         pass
  187.  
  188.     def __sub__(self, y):
  189.         """ x.__sub__(y) <==> x-y """
  190.         pass
  191.  
  192.     def __truediv__(self, y):
  193.         """ x.__truediv__(y) <==> x/y """
  194.         pass
  195.  
  196.     def __trunc__(self, *args, **kwargs):
  197.         """ 返回数值被截取为整形的值，在整形中无意义 """
  198.         pass
  199.  
  200.     def __xor__(self, y):
  201.         """ x.__xor__(y) <==> x^y """
  202.         pass
  203.  
  204.     denominator = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
  205.     """ 分母 = 1 """
  206.     """the denominator of a rational number in lowest terms"""
  207.  
  208.     imag = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
  209.     """ 虚数，无意义 """
  210.     """the imaginary part of a complex number"""
  211.  
  212.     numerator = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
  213.     """ 分子 = 数字大小 """
  214.     """the numerator of a rational number in lowest terms"""
  215.  
  216.     real = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
  217.     """ 实属，无意义 """
  218.     """the real part of a complex number"""

int

二、长整型

可能如：2147483649、9223372036854775807

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

  1. class long(object):
  2.     """
  3.     long(x=0) -> long
  4.     long(x, base=10) -> long
  5.  
  6.     Convert a number or string to a long integer, or return 0L if no arguments
  7.     are given.  If x is floating point, the conversion truncates towards zero.
  8.  
  9.     If x is not a number or if base is given, then x must be a string or
  10.     Unicode object representing an integer literal in the given base.  The
  11.     literal can be preceded by '+' or '-' and be surrounded by whitespace.
  12.     The base defaults to 10.  Valid bases are 0 and 2-36.  Base 0 means to
  13.     interpret the base from the string as an integer literal.
  14.     >>> int('0b100', base=0)
  15.     4L
  16.     """
  17.     def bit_length(self): # real signature unknown; restored from __doc__
  18.         """
  19.         long.bit_length() -> int or long
  20.  
  21.         Number of bits necessary to represent self in binary.
  22.         >>> bin(37L)
  23.         '0b100101'
  24.         >>> (37L).bit_length()
  25.         6
  26.         """
  27.         return 0
  28.  
  29.     def conjugate(self, *args, **kwargs): # real signature unknown
  30.         """ Returns self, the complex conjugate of any long. """
  31.         pass
  32.  
  33.     def __abs__(self): # real signature unknown; restored from __doc__
  34.         """ x.__abs__() <==> abs(x) """
  35.         pass
  36.  
  37.     def __add__(self, y): # real signature unknown; restored from __doc__
  38.         """ x.__add__(y) <==> x+y """
  39.         pass
  40.  
  41.     def __and__(self, y): # real signature unknown; restored from __doc__
  42.         """ x.__and__(y) <==> x&y """
  43.         pass
  44.  
  45.     def __cmp__(self, y): # real signature unknown; restored from __doc__
  46.         """ x.__cmp__(y) <==> cmp(x,y) """
  47.         pass
  48.  
  49.     def __coerce__(self, y): # real signature unknown; restored from __doc__
  50.         """ x.__coerce__(y) <==> coerce(x, y) """
  51.         pass
  52.  
  53.     def __divmod__(self, y): # real signature unknown; restored from __doc__
  54.         """ x.__divmod__(y) <==> divmod(x, y) """
  55.         pass
  56.  
  57.     def __div__(self, y): # real signature unknown; restored from __doc__
  58.         """ x.__div__(y) <==> x/y """
  59.         pass
  60.  
  61.     def __float__(self): # real signature unknown; restored from __doc__
  62.         """ x.__float__() <==> float(x) """
  63.         pass
  64.  
  65.     def __floordiv__(self, y): # real signature unknown; restored from __doc__
  66.         """ x.__floordiv__(y) <==> x//y """
  67.         pass
  68.  
  69.     def __format__(self, *args, **kwargs): # real signature unknown
  70.         pass
  71.  
  72.     def __getattribute__(self, name): # real signature unknown; restored from __doc__
  73.         """ x.__getattribute__('name') <==> x.name """
  74.         pass
  75.  
  76.     def __getnewargs__(self, *args, **kwargs): # real signature unknown
  77.         pass
  78.  
  79.     def __hash__(self): # real signature unknown; restored from __doc__
  80.         """ x.__hash__() <==> hash(x) """
  81.         pass
  82.  
  83.     def __hex__(self): # real signature unknown; restored from __doc__
  84.         """ x.__hex__() <==> hex(x) """
  85.         pass
  86.  
  87.     def __index__(self): # real signature unknown; restored from __doc__
  88.         """ x[y:z] <==> x[y.__index__():z.__index__()] """
  89.         pass
  90.  
  91.     def __init__(self, x=0): # real signature unknown; restored from __doc__
  92.         pass
  93.  
  94.     def __int__(self): # real signature unknown; restored from __doc__
  95.         """ x.__int__() <==> int(x) """
  96.         pass
  97.  
  98.     def __invert__(self): # real signature unknown; restored from __doc__
  99.         """ x.__invert__() <==> ~x """
  100.         pass
  101.  
  102.     def __long__(self): # real signature unknown; restored from __doc__
  103.         """ x.__long__() <==> long(x) """
  104.         pass
  105.  
  106.     def __lshift__(self, y): # real signature unknown; restored from __doc__
  107.         """ x.__lshift__(y) <==> x<<y """
  108.         pass
  109.  
  110.     def __mod__(self, y): # real signature unknown; restored from __doc__
  111.         """ x.__mod__(y) <==> x%y """
  112.         pass
  113.  
  114.     def __mul__(self, y): # real signature unknown; restored from __doc__
  115.         """ x.__mul__(y) <==> x*y """
  116.         pass
  117.  
  118.     def __neg__(self): # real signature unknown; restored from __doc__
  119.         """ x.__neg__() <==> -x """
  120.         pass
  121.  
  122.     @staticmethod # known case of __new__
  123.     def __new__(S, *more): # real signature unknown; restored from __doc__
  124.         """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
  125.         pass
  126.  
  127.     def __nonzero__(self): # real signature unknown; restored from __doc__
  128.         """ x.__nonzero__() <==> x != 0 """
  129.         pass
  130.  
  131.     def __oct__(self): # real signature unknown; restored from __doc__
  132.         """ x.__oct__() <==> oct(x) """
  133.         pass
  134.  
  135.     def __or__(self, y): # real signature unknown; restored from __doc__
  136.         """ x.__or__(y) <==> x|y """
  137.         pass
  138.  
  139.     def __pos__(self): # real signature unknown; restored from __doc__
  140.         """ x.__pos__() <==> +x """
  141.         pass
  142.  
  143.     def __pow__(self, y, z=None): # real signature unknown; restored from __doc__
  144.         """ x.__pow__(y[, z]) <==> pow(x, y[, z]) """
  145.         pass
  146.  
  147.     def __radd__(self, y): # real signature unknown; restored from __doc__
  148.         """ x.__radd__(y) <==> y+x """
  149.         pass
  150.  
  151.     def __rand__(self, y): # real signature unknown; restored from __doc__
  152.         """ x.__rand__(y) <==> y&x """
  153.         pass
  154.  
  155.     def __rdivmod__(self, y): # real signature unknown; restored from __doc__
  156.         """ x.__rdivmod__(y) <==> divmod(y, x) """
  157.         pass
  158.  
  159.     def __rdiv__(self, y): # real signature unknown; restored from __doc__
  160.         """ x.__rdiv__(y) <==> y/x """
  161.         pass
  162.  
  163.     def __repr__(self): # real signature unknown; restored from __doc__
  164.         """ x.__repr__() <==> repr(x) """
  165.         pass
  166.  
  167.     def __rfloordiv__(self, y): # real signature unknown; restored from __doc__
  168.         """ x.__rfloordiv__(y) <==> y//x """
  169.         pass
  170.  
  171.     def __rlshift__(self, y): # real signature unknown; restored from __doc__
  172.         """ x.__rlshift__(y) <==> y<<x """
  173.         pass
  174.  
  175.     def __rmod__(self, y): # real signature unknown; restored from __doc__
  176.         """ x.__rmod__(y) <==> y%x """
  177.         pass
  178.  
  179.     def __rmul__(self, y): # real signature unknown; restored from __doc__
  180.         """ x.__rmul__(y) <==> y*x """
  181.         pass
  182.  
  183.     def __ror__(self, y): # real signature unknown; restored from __doc__
  184.         """ x.__ror__(y) <==> y|x """
  185.         pass
  186.  
  187.     def __rpow__(self, x, z=None): # real signature unknown; restored from __doc__
  188.         """ y.__rpow__(x[, z]) <==> pow(x, y[, z]) """
  189.         pass
  190.  
  191.     def __rrshift__(self, y): # real signature unknown; restored from __doc__
  192.         """ x.__rrshift__(y) <==> y>>x """
  193.         pass
  194.  
  195.     def __rshift__(self, y): # real signature unknown; restored from __doc__
  196.         """ x.__rshift__(y) <==> x>>y """
  197.         pass
  198.  
  199.     def __rsub__(self, y): # real signature unknown; restored from __doc__
  200.         """ x.__rsub__(y) <==> y-x """
  201.         pass
  202.  
  203.     def __rtruediv__(self, y): # real signature unknown; restored from __doc__
  204.         """ x.__rtruediv__(y) <==> y/x """
  205.         pass
  206.  
  207.     def __rxor__(self, y): # real signature unknown; restored from __doc__
  208.         """ x.__rxor__(y) <==> y^x """
  209.         pass
  210.  
  211.     def __sizeof__(self, *args, **kwargs): # real signature unknown
  212.         """ Returns size in memory, in bytes """
  213.         pass
  214.  
  215.     def __str__(self): # real signature unknown; restored from __doc__
  216.         """ x.__str__() <==> str(x) """
  217.         pass
  218.  
  219.     def __sub__(self, y): # real signature unknown; restored from __doc__
  220.         """ x.__sub__(y) <==> x-y """
  221.         pass
  222.  
  223.     def __truediv__(self, y): # real signature unknown; restored from __doc__
  224.         """ x.__truediv__(y) <==> x/y """
  225.         pass
  226.  
  227.     def __trunc__(self, *args, **kwargs): # real signature unknown
  228.         """ Truncating an Integral returns itself. """
  229.         pass
  230.  
  231.     def __xor__(self, y): # real signature unknown; restored from __doc__
  232.         """ x.__xor__(y) <==> x^y """
  233.         pass
  234.  
  235.     denominator = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
  236.     """the denominator of a rational number in lowest terms"""
  237.  
  238.     imag = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
  239.     """the imaginary part of a complex number"""
  240.  
  241.     numerator = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
  242.     """the numerator of a rational number in lowest terms"""
  243.  
  244.     real = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
  245.     """the real part of a complex number"""
  246. 复制代码

long

三、浮点型

如：3.14、2.88

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

  1. class float(object):
  2.     """
  3.     float(x) -> floating point number
  4.  
  5.     Convert a string or number to a floating point number, if possible.
  6.     """
  7.     def as_integer_ratio(self):
  8.         """ 获取改值的最简比 """
  9.         """
  10.         float.as_integer_ratio() -> (int, int)
  11.  
  12.         Return a pair of integers, whose ratio is exactly equal to the original
  13.         float and with a positive denominator.
  14.         Raise OverflowError on infinities and a ValueError on NaNs.
  15.  
  16.         >>> (10.0).as_integer_ratio()
  17.         (10, 1)
  18.         >>> (0.0).as_integer_ratio()
  19.         (0, 1)
  20.         >>> (-.25).as_integer_ratio()
  21.         (-1, 4)
  22.         """
  23.         pass
  24.  
  25.     def conjugate(self, *args, **kwargs): # real signature unknown
  26.         """ Return self, the complex conjugate of any float. """
  27.         pass
  28.  
  29.     def fromhex(self, string):
  30.         """ 将十六进制字符串转换成浮点型 """
  31.         """
  32.         float.fromhex(string) -> float
  33.  
  34.         Create a floating-point number from a hexadecimal string.
  35.         >>> float.fromhex('0x1.ffffp10')
  36.         2047.984375
  37.         >>> float.fromhex('-0x1p-1074')
  38.         -4.9406564584124654e-324
  39.         """
  40.         return 0.0
  41.  
  42.     def hex(self):
  43.         """ 返回当前值的 16 进制表示 """
  44.         """
  45.         float.hex() -> string
  46.  
  47.         Return a hexadecimal representation of a floating-point number.
  48.         >>> (-0.1).hex()
  49.         '-0x1.999999999999ap-4'
  50.         >>> 3.14159.hex()
  51.         '0x1.921f9f01b866ep+1'
  52.         """
  53.         return ""
  54.  
  55.     def is_integer(self, *args, **kwargs): # real signature unknown
  56.         """ Return True if the float is an integer. """
  57.         pass
  58.  
  59.     def __abs__(self):
  60.         """ x.__abs__() <==> abs(x) """
  61.         pass
  62.  
  63.     def __add__(self, y):
  64.         """ x.__add__(y) <==> x+y """
  65.         pass
  66.  
  67.     def __coerce__(self, y):
  68.         """ x.__coerce__(y) <==> coerce(x, y) """
  69.         pass
  70.  
  71.     def __divmod__(self, y):
  72.         """ x.__divmod__(y) <==> divmod(x, y) """
  73.         pass
  74.  
  75.     def __div__(self, y):
  76.         """ x.__div__(y) <==> x/y """
  77.         pass
  78.  
  79.     def __eq__(self, y):
  80.         """ x.__eq__(y) <==> x==y """
  81.         pass
  82.  
  83.     def __float__(self):
  84.         """ x.__float__() <==> float(x) """
  85.         pass
  86.  
  87.     def __floordiv__(self, y):
  88.         """ x.__floordiv__(y) <==> x//y """
  89.         pass
  90.  
  91.     def __format__(self, format_spec):
  92.         """
  93.         float.__format__(format_spec) -> string
  94.  
  95.         Formats the float according to format_spec.
  96.         """
  97.         return ""
  98.  
  99.     def __getattribute__(self, name):
  100.         """ x.__getattribute__('name') <==> x.name """
  101.         pass
  102.  
  103.     def __getformat__(self, typestr):
  104.         """
  105.         float.__getformat__(typestr) -> string
  106.  
  107.         You probably don't want to use this function.  It exists mainly to be
  108.         used in Python's test suite.
  109.  
  110.         typestr must be 'double' or 'float'.  This function returns whichever of
  111.         'unknown', 'IEEE, big-endian' or 'IEEE, little-endian' best describes the
  112.         format of floating point numbers used by the C type named by typestr.
  113.         """
  114.         return ""
  115.  
  116.     def __getnewargs__(self, *args, **kwargs): # real signature unknown
  117.         pass
  118.  
  119.     def __ge__(self, y):
  120.         """ x.__ge__(y) <==> x>=y """
  121.         pass
  122.  
  123.     def __gt__(self, y):
  124.         """ x.__gt__(y) <==> x>y """
  125.         pass
  126.  
  127.     def __hash__(self):
  128.         """ x.__hash__() <==> hash(x) """
  129.         pass
  130.  
  131.     def __init__(self, x):
  132.         pass
  133.  
  134.     def __int__(self):
  135.         """ x.__int__() <==> int(x) """
  136.         pass
  137.  
  138.     def __le__(self, y):
  139.         """ x.__le__(y) <==> x<=y """
  140.         pass
  141.  
  142.     def __long__(self):
  143.         """ x.__long__() <==> long(x) """
  144.         pass
  145.  
  146.     def __lt__(self, y):
  147.         """ x.__lt__(y) <==> x<y """
  148.         pass
  149.  
  150.     def __mod__(self, y):
  151.         """ x.__mod__(y) <==> x%y """
  152.         pass
  153.  
  154.     def __mul__(self, y):
  155.         """ x.__mul__(y) <==> x*y """
  156.         pass
  157.  
  158.     def __neg__(self):
  159.         """ x.__neg__() <==> -x """
  160.         pass
  161.  
  162.     @staticmethod # known case of __new__
  163.     def __new__(S, *more):
  164.         """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
  165.         pass
  166.  
  167.     def __ne__(self, y):
  168.         """ x.__ne__(y) <==> x!=y """
  169.         pass
  170.  
  171.     def __nonzero__(self):
  172.         """ x.__nonzero__() <==> x != 0 """
  173.         pass
  174.  
  175.     def __pos__(self):
  176.         """ x.__pos__() <==> +x """
  177.         pass
  178.  
  179.     def __pow__(self, y, z=None):
  180.         """ x.__pow__(y[, z]) <==> pow(x, y[, z]) """
  181.         pass
  182.  
  183.     def __radd__(self, y):
  184.         """ x.__radd__(y) <==> y+x """
  185.         pass
  186.  
  187.     def __rdivmod__(self, y):
  188.         """ x.__rdivmod__(y) <==> divmod(y, x) """
  189.         pass
  190.  
  191.     def __rdiv__(self, y):
  192.         """ x.__rdiv__(y) <==> y/x """
  193.         pass
  194.  
  195.     def __repr__(self):
  196.         """ x.__repr__() <==> repr(x) """
  197.         pass
  198.  
  199.     def __rfloordiv__(self, y):
  200.         """ x.__rfloordiv__(y) <==> y//x """
  201.         pass
  202.  
  203.     def __rmod__(self, y):
  204.         """ x.__rmod__(y) <==> y%x """
  205.         pass
  206.  
  207.     def __rmul__(self, y):
  208.         """ x.__rmul__(y) <==> y*x """
  209.         pass
  210.  
  211.     def __rpow__(self, x, z=None):
  212.         """ y.__rpow__(x[, z]) <==> pow(x, y[, z]) """
  213.         pass
  214.  
  215.     def __rsub__(self, y):
  216.         """ x.__rsub__(y) <==> y-x """
  217.         pass
  218.  
  219.     def __rtruediv__(self, y):
  220.         """ x.__rtruediv__(y) <==> y/x """
  221.         pass
  222.  
  223.     def __setformat__(self, typestr, fmt):
  224.         """
  225.         float.__setformat__(typestr, fmt) -> None
  226.  
  227.         You probably don't want to use this function.  It exists mainly to be
  228.         used in Python's test suite.
  229.  
  230.         typestr must be 'double' or 'float'.  fmt must be one of 'unknown',
  231.         'IEEE, big-endian' or 'IEEE, little-endian', and in addition can only be
  232.         one of the latter two if it appears to match the underlying C reality.
  233.  
  234.         Override the automatic determination of C-level floating point type.
  235.         This affects how floats are converted to and from binary strings.
  236.         """
  237.         pass
  238.  
  239.     def __str__(self):
  240.         """ x.__str__() <==> str(x) """
  241.         pass
  242.  
  243.     def __sub__(self, y):
  244.         """ x.__sub__(y) <==> x-y """
  245.         pass
  246.  
  247.     def __truediv__(self, y):
  248.         """ x.__truediv__(y) <==> x/y """
  249.         pass
  250.  
  251.     def __trunc__(self, *args, **kwargs): # real signature unknown
  252.         """ Return the Integral closest to x between 0 and x. """
  253.         pass
  254.  
  255.     imag = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
  256.     """the imaginary part of a complex number"""
  257.  
  258.     real = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
  259.     """the real part of a complex number"""

float

四、字符串

如：'wupeiqi'、'alex'

怎样创建字符串：

1  str1 = “Alex”

2 str1 = str（“Alex”）  用str类创建了str1

解码与编码

gbk ---->utf-8

str1,decode(‘gbk’).encode(‘utf-8’) (先解码成unicode在编码成utf-8)

字符串的格式化方法：

1

2

3

可以传递一个类表或者数组进去，例如：

name = ”i am {0},age {1}”

li = [11,22]

name.format(*li)  在列表前一定要加一个*，就是这个规定的。

4

可以传递一个字典进去，例如

name = “i an {ss},age {dd}”

dic = {‘ss’:123,’dd’:456}

name.format(**dic)  传递字典要在前面加**。

  1. print('{}{}'.format('name','age'))
    print ('{name}'.format(name='sun'))
    print('{0}{1}{0}'.format('sun','bo'))
    5 字符串切片,记住顾头不顾尾原则.
    msg= 12345
    print msg[0:4]
    1234

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

  1. class str(basestring):
  2.     """
  3.     str(object='') -> string
  4.  
  5.     Return a nice string representation of the object.
  6.     If the argument is a string, the return value is the same object.
  7.     """
  8.     def capitalize(self):
  9.         """ 首字母变大写 """
  10.         """
  11.         S.capitalize() -> string
  12.  
  13.         Return a copy of the string S with only its first character
  14.         capitalized.
  15.         """
  16.         return ""
  17.  
  18.     def center(self, width, fillchar=None):
  19.         """ 内容居中，width：总长度；fillchar：空白处填充内容，默认无 """
  20.         """
  21.         S.center(width[, fillchar]) -> string
  22.  
  23.         Return S centered in a string of length width. Padding is
  24.         done using the specified fill character (default is a space)
  25.         """
  26.         return ""
  27.  
  28.     def count(self, sub, start=None, end=None):
  29.         """ 子序列个数 start其实就是下标的意思 """
  30.         """
  31.         S.count(sub[, start[, end]]) -> int
  32.  
  33.         Return the number of non-overlapping occurrences of substring sub in
  34.         string S[start:end].  Optional arguments start and end are interpreted
  35.         as in slice notation.
  36.         """
  37.         return 0
  38.  
  39.     def decode(self, encoding=None, errors=None):
  40.         """ 解码 """
  41.         """
  42.         S.decode([encoding[,errors]]) -> object
  43.  
  44.         Decodes S using the codec registered for encoding. encoding defaults
  45.         to the default encoding. errors may be given to set a different error
  46.         handling scheme. Default is 'strict' meaning that encoding errors raise
  47.         a UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
  48.         as well as any other name registered with codecs.register_error that is
  49.         able to handle UnicodeDecodeErrors.
  50.         """
  51.         return object()
  52.  
  53.     def encode(self, encoding=None, errors=None):
  54.         """ 编码，针对unicode """
  55.         """
  56.         S.encode([encoding[,errors]]) -> object
  57.  
  58.         Encodes S using the codec registered for encoding. encoding defaults
  59.         to the default encoding. errors may be given to set a different error
  60.         handling scheme. Default is 'strict' meaning that encoding errors raise
  61.         a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
  62.         'xmlcharrefreplace' as well as any other name registered with
  63.         codecs.register_error that is able to handle UnicodeEncodeErrors.
  64.         """
  65.         return object()
  66.  
  67.     def endswith(self, suffix, start=None, end=None):
  68.         """ 是否以 xxx 结束 """
  69.         """
  70.         S.endswith(suffix[, start[, end]]) -> bool
  71.  
  72.         Return True if S ends with the specified suffix, False otherwise.
  73.         With optional start, test S beginning at that position.
  74.         With optional end, stop comparing S at that position.
  75.         suffix can also be a tuple of strings to try.
  76.         """
  77.         return False
  78.  
  79.     def expandtabs(self, tabsize=None):
  80.         """ 将tab转换成空格，默认一个tab转换成8个空格 """
  81.         """
  82.         S.expandtabs([tabsize]) -> string
  83.  
  84.         Return a copy of S where all tab characters are expanded using spaces.
  85.         If tabsize is not given, a tab size of 8 characters is assumed.
  86.         """
  87.         return ""
  88.  
  89.     def find(self, sub, start=None, end=None):
  90.         """ 寻找子序列位置，如果没找到，返回 -1 """
  91.          如果找的是两个字母，则找到的结果以第一个字母为准        """
  92.         S.find(sub [,start [,end]]) -> int
  93.  
  94.         Return the lowest index in S where substring sub is found,
  95.         such that sub is contained within S[start:end].  Optional
  96.         arguments start and end are interpreted as in slice notation.
  97.  
  98.         Return -1 on failure.
  99.         """
  100.         return 0
  101.  
  102.     def format(*args, **kwargs): # known special case of str.format
  103.         """ 字符串格式化，动态参数，将函数式编程时细说 """
  104.         """
  105.         S.format(*args, **kwargs) -> string
  106.  
  107.         Return a formatted version of S, using substitutions from args and kwargs.
  108.         The substitutions are identified by braces ('{' and '}').
  109.         """
  110.         pass
  111.  
  112.     def index(self, sub, start=None, end=None):
  113.         """ 子序列位置，如果没找到，报错 """
  114.         S.index(sub [,start [,end]]) -> int
  115.  
  116.         Like S.find() but raise ValueError when the substring is not found.
  117.         """
  118.         return 0
  119.  
  120.     def isalnum(self):
  121.         """ 是否是字母和数字 """
  122.         """
  123.         S.isalnum() -> bool
  124.  
  125.         Return True if all characters in S are alphanumeric
  126.         and there is at least one character in S, False otherwise.
  127.         """
  128.         return False
  129.  
  130.     def isalpha(self):
  131.         """ 是否是字母 """
  132.         """
  133.         S.isalpha() -> bool
  134.  
  135.         Return True if all characters in S are alphabetic
  136.         and there is at least one character in S, False otherwise.
  137.         """
  138.         return False
  139.  
  140.     def isdigit(self):
  141.         """ 是否是数字 """
  142.         """
  143.         S.isdigit() -> bool
  144.  
  145.         Return True if all characters in S are digits
  146.         and there is at least one character in S, False otherwise.
  147.         """
  148.         return False
  149.  
  150.     def islower(self):
  151.         """ 是否小写 """
  152.         """
  153.         S.islower() -> bool
  154.  
  155.         Return True if all cased characters in S are lowercase and there is
  156.         at least one cased character in S, False otherwise.
  157.         """
  158.         return False
  159.  
  160.     def isspace(self):
  161.         """
  162.         S.isspace() -> bool
  163.            是否是空格
  164.         Return True if all characters in S are whitespace
  165.         and there is at least one character in S, False otherwise.
  166.         """
  167.         return False
  168.  
  169.     def istitle(self):
  170.         """   是否是标题
  171.         S.istitle() -> bool
  172.  
  173.         Return True if S is a titlecased string and there is at least one
  174.         character in S, i.e. uppercase characters may only follow uncased
  175.         characters and lowercase characters only cased ones. Return False
  176.         otherwise.
  177.         """
  178.         return False
  179.  
  180.     def isupper(self):
  181.         """
  182.             是不是全是大写
  1.            S.isupper() -> bool
  2.  
  3.         Return True if all cased characters in S are uppercase and there is
  4.         at least one cased character in S, False otherwise.
  5.         """
  6.         return False
  7.  
  8.     def join(self, iterable):
  9.         """ 连接 """
  10.         """
  11.          S.join(iterable) -> string
  12.           li = [‘s1’,’s2’]
  1.            ‘_’.join(li)
  1.              ‘s1_s2’
  2.         Return a string which is the concatenation of the strings in the
  3.         iterable.  The separator between elements is S.
  4.         """
  5.         return ""
  6.  
  7.     def ljust(self, width, fillchar=None):
  8.         """ 内容左对齐，右侧填充 """
  9.         """
  10.         S.ljust(width[, fillchar]) -> string
  11.  
  12.         Return S left-justified in a string of length width. Padding is
  13.         done using the specified fill character (default is a space).
  14.         """
  15.         return ""
  16.  
  17.     def lower(self):
  18.

""" 变小写 """

  1.         """
  2.         S.lower() -> string
  3.  
  4.         Return a copy of the string S converted to lowercase.
  5.         """
  6.         return ""
  7.  
  8.     def lstrip(self, chars=None):
  9.         """ 移除左侧空白 """
  10.         """
  11.         S.lstrip([chars]) -> string or unicode
  12.  
  13.         Return a copy of the string S with leading whitespace removed.
  14.         If chars is given and not None, remove characters in chars instead.
  15.         If chars is unicode, S will be converted to unicode before stripping
  16.         """
  17.         return ""
  18.  
  19.     def partition(self, sep):
  20.         """ 分割，前，中，后三部分 """
  21.         """
  22.         S.partition(sep) -> (head, sep, tail)
  23.  
  24.         Search for the separator sep in S, and return the part before it,
  25.         the separator itself, and the part after it.  If the separator is not
  26.         found, return S and two empty strings.
  27.         """
  28.         pass
  29.  
  30.     def replace(self, old, new, count=None):
  31.         """ 替换 """
  32.         """
  33.         S.replace(old, new[, count]) -> string
  34.  
  35.         Return a copy of string S with all occurrences of substring
  36.         old replaced by new.  If the optional argument count is
  37.         given, only the first count occurrences are replaced.
  38.         """
  39.         return ""
  40.  
  41.     def rfind(self, sub, start=None, end=None):
  42.         """
  43.         S.rfind(sub [,start [,end]]) -> int
  44.  
  45.         Return the highest index in S where substring sub is found,
  46.         such that sub is contained within S[start:end].  Optional
  47.         arguments start and end are interpreted as in slice notation.
  48.  
  49.         Return -1 on failure.
  50.         """
  51.         return 0
  52.  
  53.     def rindex(self, sub, start=None, end=None):
  54.         """
  55.         S.rindex(sub [,start [,end]]) -> int
  56.  
  57.         Like S.rfind() but raise ValueError when the substring is not found.
  58.         """
  59.         return 0
  60.  
  61.     def rjust(self, width, fillchar=None):
  62.         """
  63.         S.rjust(width[, fillchar]) -> string
  64.  
  65.         Return S right-justified in a string of length width. Padding is
  66.         done using the specified fill character (default is a space)
  67.         """
  68.         return ""
  69.  
  70.     def rpartition(self, sep):
  71.         """
  72.         S.rpartition(sep) -> (head, sep, tail)
  73.  
  74.         Search for the separator sep in S, starting at the end of S, and return
  75.         the part before it, the separator itself, and the part after it.  If the
  76.         separator is not found, return two empty strings and S.
  77.         """
  78.         pass
  79.  
  80.     def rsplit(self, sep=None, maxsplit=None):
  81.         """
  82.         S.rsplit([sep [,maxsplit]]) -> list of strings
  83.  
  84.         Return a list of the words in the string S, using sep as the
  85.         delimiter string, starting at the end of the string and working
  86.         to the front.  If maxsplit is given, at most maxsplit splits are
  87.         done. If sep is not specified or is None, any whitespace string
  88.         is a separator.
  89.         """
  90.         return []
  91.  
  92.     def rstrip(self, chars=None):
  93.         """
  94.         S.rstrip([chars]) -> string or unicode
  95.  
  96.         Return a copy of the string S with trailing whitespace removed.
  97.         If chars is given and not None, remove characters in chars instead.
  98.         If chars is unicode, S will be converted to unicode before stripping
  99.         """
  100.         return ""
  101.  
  102.     def split(self, sep=None, maxsplit=None):
  103.         """ 分割， maxsplit最多分割几次 """
  104.         """
  105.         S.split([sep [,maxsplit]]) -> list of strings
  106.  
  107.         Return a list of the words in the string S, using sep as the
  108.         delimiter string.  If maxsplit is given, at most maxsplit
  109.         splits are done. If sep is not specified or is None, any
  110.         whitespace string is a separator and empty strings are removed
  111.         from the result.
  112.         """
  113.         return []
  114.  
  115.     def splitlines(self, keepends=False):
  116.         """ 根据换行分割 """
  117.         """
  118.         S.splitlines(keepends=False) -> list of strings
  119.  
  120.         Return a list of the lines in S, breaking at line boundaries.
  121.         Line breaks are not included in the resulting list unless keepends
  122.         is given and true.
  123.         """
  124.         return []
  125.  
  126.     def startswith(self, prefix, start=None, end=None):
  127.         """ 是否起始 """
  128.         """
  129.         S.startswith(prefix[, start[, end]]) -> bool
  130.  
  131.         Return True if S starts with the specified prefix, False otherwise.
  132.         With optional start, test S beginning at that position.
  133.         With optional end, stop comparing S at that position.
  134.         prefix can also be a tuple of strings to try.
  135.         """
  136.         return False
  137.  
  138.     def strip(self, chars=None):
  139.         """ 移除两段空白 """
  140.         """
  141.         S.strip([chars]) -> string or unicode
  142.  
  143.         Return a copy of the string S with leading and trailing
  144.         whitespace removed.
  145.         If chars is given and not None, remove characters in chars instead.
  146.         If chars is unicode, S will be converted to unicode before stripping
  147.         """
  148.         return ""
  149.  
  150.     def swapcase(self):
  151.         """ 大写变小写，小写变大写 """
  152.         """
  153.         S.swapcase() -> string
  154.  
  155.         Return a copy of the string S with uppercase characters
  156.         converted to lowercase and vice versa.
  157.         """
  158.         return ""
  159.  
  160.     def title(self):
  161.         """
  162.         S.title() -> string
  163.            变成标题格式
  164.         Return a titlecased version of S, i.e. words start with uppercase
  165.         characters, all remaining cased characters have lowercase.
  166.         """
  167.         return ""
  168.  
  169.     def translate(self, table, deletechars=None):
  170.         """
  171.         转换，需要先做一个对应表，最后一个表示删除字符集合
  172.           import string
  1.         intab = "aeiou"
  2.         outtab = ""
  3.         trantab = string.maketrans(intab, outtab)
  4.         str = "this is string example....wow!!!"
  5.         print str.translate(trantab, 'xm')
  6.         """
  7.               先删在转换
  8.         """
  9.         S.translate(table [,deletechars]) -> string
  10.  
  11.         Return a copy of the string S, where all characters occurring
  12.         in the optional argument deletechars are removed, and the
  13.         remaining characters have been mapped through the given
  14.         translation table, which must be a string of length 256 or None.
  15.         If the table argument is None, no translation is applied and
  16.         the operation simply removes the characters in deletechars.
  17.         """
  18.         return ""
  19.  
  20.     def upper(self):
  21.         """
  22.         S.upper() -> string
  23.  
  24.         Return a copy of the string S converted to uppercase.
  25.         """
  26.         return ""
  27.  
  28.     def zfill(self, width):
  29.         """方法返回指定长度的字符串，原字符串右对齐，前面填充0。"""
  30.         """
  31.         S.zfill(width) -> string
  32.  
  33.         Pad a numeric string S with zeros on the left, to fill a field
  34.         of the specified width.  The string S is never truncated.
  35.         """
  36.         return ""
  37.  
  38.     def _formatter_field_name_split(self, *args, **kwargs): # real signature unknown
  39.         pass
  40.  
  41.     def _formatter_parser(self, *args, **kwargs): # real signature unknown
  42.         pass
  43.  
  44.     def __add__(self, y):
  45.         """ x.__add__(y) <==> x+y """
  46.         pass
  47.  
  48.     def __contains__(self, y):
  49.         """ x.__contains__(y) <==> y in x """
  50.         pass
  51.  
  52.     def __eq__(self, y):
  53.         """ x.__eq__(y) <==> x==y """
  54.         pass
  55.  
  56.     def __format__(self, format_spec):
  57.         """
  58.         S.__format__(format_spec) -> string
  59.  
  60.         Return a formatted version of S as described by format_spec.
  61.         """
  62.         return ""
  63.  
  64.     def __getattribute__(self, name):
  65.         """ x.__getattribute__('name') <==> x.name """
  66.         pass
  67.  
  68.     def __getitem__(self, y):
  69.         """ x.__getitem__(y) <==> x[y] """
  70.         pass
  71.  
  72.     def __getnewargs__(self, *args, **kwargs): # real signature unknown
  73.         pass
  74.  
  75.     def __getslice__(self, i, j):
  76.         """
  77.         x.__getslice__(i, j) <==> x[i:j]
  78.  
  79.                    Use of negative indices is not supported.
  80.         """
  81.         pass
  82.  
  83.     def __ge__(self, y):
  84.         """ x.__ge__(y) <==> x>=y """
  85.         pass
  86.  
  87.     def __gt__(self, y):
  88.         """ x.__gt__(y) <==> x>y """
  89.         pass
  90.  
  91.     def __hash__(self):
  92.         """ x.__hash__() <==> hash(x) """
  93.         pass
  94.  
  95.     def __init__(self, string=''): # known special case of str.__init__
  96.         """
  97.         str(object='') -> string
  98.  
  99.         Return a nice string representation of the object.
  100.         If the argument is a string, the return value is the same object.
  101.         # (copied from class doc)
  102.         """
  103.         pass
  104.  
  105.     def __len__(self):
  106.         """ x.__len__() <==> len(x) """
  107.         pass
  108.  
  109.     def __le__(self, y):
  110.         """ x.__le__(y) <==> x<=y """
  111.         pass
  112.  
  113.     def __lt__(self, y):
  114.         """ x.__lt__(y) <==> x<y """
  115.         pass
  116.  
  117.     def __mod__(self, y):
  118.         """ x.__mod__(y) <==> x%y """
  119.         pass
  120.  
  121.     def __mul__(self, n):
  122.         """ x.__mul__(n) <==> x*n """
  123.         pass
  124.  
  125.     @staticmethod # known case of __new__
  126.     def __new__(S, *more):
  127.         """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
  128.         pass
  129.  
  130.     def __ne__(self, y):
  131.         """ x.__ne__(y) <==> x!=y """
  132.         pass
  133.  
  134.     def __repr__(self):
  135.         """ x.__repr__() <==> repr(x) """
  136.         pass
  137.  
  138.     def __rmod__(self, y):
  139.         """ x.__rmod__(y) <==> y%x """
  140.         pass
  141.  
  142.     def __rmul__(self, n):
  143.         """ x.__rmul__(n) <==> n*x """
  144.         pass
  145.  
  146.     def __sizeof__(self):
  147.         """ S.__sizeof__() -> size of S in memory, in bytes """
  148.         pass
  149.  
  150.     def __str__(self):
  151.         """ x.__str__() <==> str(x) """
  152.         pass
  153.  
  154. str

str

注：编码；字符串的乘法；字符串和格式化

作业：

多级字典：

  1. # -*- coding: utf-8 -*-
  2. menu = {
  3.     '北京':{
  4.         '海淀':{
  5.             '五道口':{
  6.                 'soho':{},
  7.                 '网易':{},
  8.                 'google':{}
  9.             },
  10.             '中关村':{
  11.                 '爱奇艺':{},
  12.                 '汽车之家':{},
  13.                 'youku':{},
  14.             },
  15.             '上地':{
  16.                 '百度':{},
  17.             },
  18.         },
  19.         '昌平':{
  20.             '沙河':{
  21.                 '老男孩':{},
  22.                 '北航':{},
  23.             },
  24.             '天通苑':{},
  25.             '回龙观':{},
  26.         },
  27.         '朝阳':{},
  28.         '东城':{},
  29.     },
  30.     '上海':{
  31.         '闵行':{
  32.             "人民广场":{
  33.                 '炸鸡店':{}
  34.             }
  35.         },
  36.         '闸北':{
  37.             '火车战':{
  38.                 '携程':{}
  39.             }
  40.         },
  41.         '浦东':{},
  42.     },
  43.     '山东':{},
  44. }
  45. current_level=menu###当前层
  46. last_level=[] ##父亲层
  47. while True:
  48.     for key in current_level:
  49.         print(key)
  50.     choice=input(">>>:").strip()
  51.     if len(choice)==0:continue
  52.     if choice=="quit":
  53.             #if not last_level:break ###和一下行是一个意思
  54.             if len(last_level)==0:break##最后一层，就退出程序
  55.             current_level=last_level[-1]##把当前层改成父亲层，下一次循环就回到上一次层
  56.             last_level.pop()
  57.     if choice not in current_level:continue###如果输入的不在里边，从新输入
  58.     last_level.append(current_level)###记住当前层，
  59.     current_level=current_level[choice]##进入下一层

代码

运算符

算数运算

比较运算

赋值运算

逻辑运算

成员运算

身份运算

位运算

运算符的优先级

布尔值:

非零数字自带的布尔值都是true

非空字符串自带的布尔值都是true

五、列表

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

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

  1. class list(object):
  2.     """
  3.     list() -> new empty list
  4.     list(iterable) -> new list initialized from iterable's items
  5.     """
  6.     def append(self, p_object): # real signature unknown; restored from __doc__
  7.         """ L.append(object) -- append object to end   把值添加到列表的后面"""
  8.         pass
  9.  
  10.     def count(self, value): # real signature unknown; restored from __doc__
  11.         """ L.count(value) -> integer -- return number of occurrences of value 出现的值的次数 """
  12.         return 0
  13.  
  14.     def extend(self, iterable): # real signature unknown; restored from __doc__
  15.         """ L.extend(iterable) -- extend list by appending elements from the iterable 扩展类表，在原列表中可以扩展 li.extend([‘rice’])   id 不变 """
  16.         pass
  17.  
  18.     def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
  19.         """
  20.         L.index(value, [start, [stop]]) -> integer -- return first index of value.
  21.         Raises ValueError if the value is not present.
  22.         """
  23.         return 0
  24.  
  25.     def insert(self, index, p_object): # real signature unknown; restored from __doc__
  26.         """ L.insert(index, object) -- insert object before index  在列表指定位置插入"""
  27.         pass
  28.  
  29.     def pop(self, index=None): # real signature unknown; restored from __doc__
  30.         """
  31.         L.pop([index]) -> item -- remove and return item at index (default last).
  32.         Raises IndexError if list is empty or index is out of range.
  33.         """
  1.          删除并返回指定下标的值，如果没有指定，默认是最后一个值
  1.      li = [111,222,333]
  1.        name = li.pop()
  1.               name
  1.               333
  2.         pass
  3.  
  4.     def remove(self, value): # real signature unknown; restored from __doc__
  5.         """
  6.         L.remove(value) -- remove first occurrence of value.
  7.         Raises ValueError if the value is not present.
  8.         """  移除类表的中元素，这是指定值的,只移除第一个  li.remove(222)
  9.         pass
  10.  
  11.     def reverse(self): # real signature unknown; restored from __doc__
  12.         """ L.reverse() -- reverse *IN PLACE*   翻转 ，也就是顺序颠倒一下"""
  13.         pass
  14.  
  15.     def sort(self, cmp=None, key=None, reverse=False): # real signature unknown; restored from __doc__
  16.         """
  17.         L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
  18.         cmp(x, y) -> -1, 0, 1
  19.         """  数字--大小比较  字符----ak吗  中文—ncode
  20.         pass
  21.  
  22.     def __add__(self, y): # real signature unknown; restored from __doc__
  23.         """ x.__add__(y) <==> x+y """
  24.         pass
  25.  
  26.     def __contains__(self, y): # real signature unknown; restored from __doc__
  27.         """ x.__contains__(y) <==> y in x """
  28.         pass
  29.  
  30.     def __delitem__(self, y): # real signature unknown; restored from __doc__
  31.         """ x.__delitem__(y) <==> del x[y] """
  32.         pass      del li[1]默认就会调用这个delitem这个方法
  33.  
  34.     def __delslice__(self, i, j): # real signature unknown; restored from __doc__
  35.         """
  36.         x.__delslice__(i, j) <==> del x[i:j]
  37.  
  38.                    Use of negative indices is not supported.
  39.         """
  40.         pass
  41.  
  42.     def __eq__(self, y): # real signature unknown; restored from __doc__
  43.         """ x.__eq__(y) <==> x==y """
  44.         pass
  45.  
  46.     def __getattribute__(self, name): # real signature unknown; restored from __doc__
  47.         """ x.__getattribute__('name') <==> x.name """
  48.         pass
  49.  
  50.     def __getitem__(self, y): # real signature unknown; restored from __doc__
  51.         """ x.__getitem__(y) <==> x[y] """
  52.         pass
  53.  
  54.     def __getslice__(self, i, j): # real signature unknown; restored from __doc__
  55.         """
  56.         x.__getslice__(i, j) <==> x[i:j]
  57.  
  58.                    Use of negative indices is not supported.
  59.         """
  60.         pass
  61.  
  62.     def __ge__(self, y): # real signature unknown; restored from __doc__
  63.         """ x.__ge__(y) <==> x>=y """
  64.         pass
  65.  
  66.     def __gt__(self, y): # real signature unknown; restored from __doc__
  67.         """ x.__gt__(y) <==> x>y """
  68.         pass
  69.  
  70.     def __iadd__(self, y): # real signature unknown; restored from __doc__
  71.         """ x.__iadd__(y) <==> x+=y """
  72.         pass
  73.  
  74.     def __imul__(self, y): # real signature unknown; restored from __doc__
  75.         """ x.__imul__(y) <==> x*=y """
  76.         pass
  77.  
  78.     def __init__(self, seq=()): # known special case of list.__init__
  79.         """
  80.         list() -> new empty list
  81.         list(iterable) -> new list initialized from iterable's items
  82.         # (copied from class doc)
  83.         """
  84.         pass
  85.  
  86.     def __iter__(self): # real signature unknown; restored from __doc__
  87.         """ x.__iter__() <==> iter(x) """
  88.         pass
  89.  
  90.     def __len__(self): # real signature unknown; restored from __doc__
  91.         """ x.__len__() <==> len(x) """
  92.         pass
  93.  
  94.     def __le__(self, y): # real signature unknown; restored from __doc__
  95.         """ x.__le__(y) <==> x<=y """
  96.         pass
  97.  
  98.     def __lt__(self, y): # real signature unknown; restored from __doc__
  99.         """ x.__lt__(y) <==> x<y """
  100.         pass
  101.  
  102.     def __mul__(self, n): # real signature unknown; restored from __doc__
  103.         """ x.__mul__(n) <==> x*n """
  104.         pass
  105.  
  106.     @staticmethod # known case of __new__
  107.     def __new__(S, *more): # real signature unknown; restored from __doc__
  108.         """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
  109.         pass
  110.  
  111.     def __ne__(self, y): # real signature unknown; restored from __doc__
  112.         """ x.__ne__(y) <==> x!=y """
  113.         pass
  114.  
  115.     def __repr__(self): # real signature unknown; restored from __doc__
  116.         """ x.__repr__() <==> repr(x) """
  117.         pass
  118.  
  119.     def __reversed__(self): # real signature unknown; restored from __doc__
  120.         """ L.__reversed__() -- return a reverse iterator over the list """
  121.         pass
  122.  
  123.     def __rmul__(self, n): # real signature unknown; restored from __doc__
  124.         """ x.__rmul__(n) <==> n*x """
  125.         pass
  126.  
  127.     def __setitem__(self, i, y): # real signature unknown; restored from __doc__
  128.         """ x.__setitem__(i, y) <==> x[i]=y """
  129.         pass
  130.  
  131.     def __setslice__(self, i, j, y): # real signature unknown; restored from __doc__
  132.         """
  133.         x.__setslice__(i, j, y) <==> x[i:j]=y
  134.  
  135.                    Use  of negative indices is not supported.
  136.         """
  137.         pass
  138.  
  139.     def __sizeof__(self): # real signature unknown; restored from __doc__
  140.         """ L.__sizeof__() -- size of L in memory, in bytes """
  141.         pass
  142.  
  143.     __hash__ = None

list

  1. 列表的循环
  1. name = [["gaolong",29],["wangyuangeng",26],["sunlixue",21],["sunbo",30],["tiansuli",23]]
    for i,ele in enumerate(name):
        print (i,".",ele[0],ele[1])

0 . gaolong
1 . wangyuangeng
2 . sunlixue
3 . sunbo
4 . tiansuli

注：排序；

六、元组

如：(11,22,33)、('wupeiqi', 'alex')  不可修改----元组的元素不能被修改，元组的元素的元素是可以被修改的

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

  1. class tuple(object):
  2.     """
  3.     tuple() -> empty tuple
  4.     tuple(iterable) -> tuple initialized from iterable's items
  5.  
  6.     If the argument is a tuple, the return value is the same object.
  7.     """
  8.     def count(self, value): # real signature unknown; restored from __doc__
  9.         """ T.count(value) -> integer -- return number of occurrences of value """
  10.         return 0
  11.  
  12.     def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
  13.         """
  14.         T.index(value, [start, [stop]]) -> integer -- return first index of value.
  15.         Raises ValueError if the value is not present.
  16.         """
  17.         return 0
  18.  
  19.     def __add__(self, y): # real signature unknown; restored from __doc__
  20.         """ x.__add__(y) <==> x+y """
  21.         pass
  22.  
  23.     def __contains__(self, y): # real signature unknown; restored from __doc__
  24.         """ x.__contains__(y) <==> y in x """
  25.         pass
  26.  
  27.     def __eq__(self, y): # real signature unknown; restored from __doc__
  28.         """ x.__eq__(y) <==> x==y """
  29.         pass
  30.  
  31.     def __getattribute__(self, name): # real signature unknown; restored from __doc__
  32.         """ x.__getattribute__('name') <==> x.name """
  33.         pass
  34.  
  35.     def __getitem__(self, y): # real signature unknown; restored from __doc__
  36.         """ x.__getitem__(y) <==> x[y] """
  37.         pass
  38.  
  39.     def __getnewargs__(self, *args, **kwargs): # real signature unknown
  40.         pass
  41.  
  42.     def __getslice__(self, i, j): # real signature unknown; restored from __doc__
  43.         """
  44.         x.__getslice__(i, j) <==> x[i:j]
  45.  
  46.                    Use of negative indices is not supported.
  47.         """
  48.         pass
  49.  
  50.     def __ge__(self, y): # real signature unknown; restored from __doc__
  51.         """ x.__ge__(y) <==> x>=y """
  52.         pass
  53.  
  54.     def __gt__(self, y): # real signature unknown; restored from __doc__
  55.         """ x.__gt__(y) <==> x>y """
  56.         pass
  57.  
  58.     def __hash__(self): # real signature unknown; restored from __doc__
  59.         """ x.__hash__() <==> hash(x) """
  60.         pass
  61.  
  62.     def __init__(self, seq=()): # known special case of tuple.__init__
  63.         """
  64.         tuple() -> empty tuple
  65.         tuple(iterable) -> tuple initialized from iterable's items
  66.  
  67.         If the argument is a tuple, the return value is the same object.
  68.         # (copied from class doc)
  69.         """
  70.         pass
  71.  
  72.     def __iter__(self): # real signature unknown; restored from __doc__
  73.         """ x.__iter__() <==> iter(x) """
  74.         pass
  75.  
  76.     def __len__(self): # real signature unknown; restored from __doc__
  77.         """ x.__len__() <==> len(x) """
  78.         pass
  79.  
  80.     def __le__(self, y): # real signature unknown; restored from __doc__
  81.         """ x.__le__(y) <==> x<=y """
  82.         pass
  83.  
  84.     def __lt__(self, y): # real signature unknown; restored from __doc__
  85.         """ x.__lt__(y) <==> x<y """
  86.         pass
  87.  
  88.     def __mul__(self, n): # real signature unknown; restored from __doc__
  89.         """ x.__mul__(n) <==> x*n """
  90.         pass
  91.  
  92.     @staticmethod # known case of __new__
  93.     def __new__(S, *more): # real signature unknown; restored from __doc__
  94.         """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
  95.         pass
  96.  
  97.     def __ne__(self, y): # real signature unknown; restored from __doc__
  98.         """ x.__ne__(y) <==> x!=y """
  99.         pass
  100.  
  101.     def __repr__(self): # real signature unknown; restored from __doc__
  102.         """ x.__repr__() <==> repr(x) """
  103.         pass
  104.  
  105.     def __rmul__(self, n): # real signature unknown; restored from __doc__
  106.         """ x.__rmul__(n) <==> n*x """
  107.         pass
  108.  
  109.     def __sizeof__(self): # real signature unknown; restored from __doc__
  110.         """ T.__sizeof__() -- size of T in memory, in bytes """
  111.         pass

tuple

七、字典

  1. name={
        395159623:{'age':29,'shengao':185,'sex':"man"},
        917643002:{'age':30,'shengao':160,'sex':"woman"}
    }
    print (name.get(395159623).get('age'))

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

ps：循环时，默认循环key

每个字典都具备如下功能：字典的key是不可以重复的，他是无位置的，无序的。

什么可以当做字典的key呢？

数字，字符串，类的实例 不可以变的，时间也行

ipmort datatime

a = datatime.datatime.now()

如何判断是不是一个字典？   type(name_dic) is dict

大的数据循环字典，应该这样：

for k in b:

print k,b[k]

这样比较好，因为正常的循环字典会一次性的把字典中的所有值都提出来，放到内存中，比较耗内存。

copy: 浅copy

D.copy()                  #拷贝字典  ，他是一个浅的拷贝，在副本中替换值的时候，原始字段不受影响，但是修改了某个值时（原地修改，不是替换）原始字典也会改变（我理解的还是第一层的对象是不会发生变化的，而里边的其他层就会随之变化），对应的还有深拷贝，我们得借助模块了。data4 = copy.deepcopy(data)，就是把所有层级都copy了, 也就是完全独立了。
x = {'username':'admin','machines':['foo','bar','baz']}
y = x.copy()
y['username']='mih'
y['machines'].remove('bar')

print x
print y

{'username': 'admin', 'machines': ['foo', 'baz']}
{'username': 'mih', 'machines': ['foo', 'baz']

这个例子是这样解释的，y copy了x ,其实是在内存中第一层数据是独立，尔第二层数据其实用的是一份，其实就指针指向了同一块内存地址，这样我改第一层数据的时候，x y是不会同时变化的，而我改第二层数据的时候，他们其实用的是同一块地址，那么数据就会一同改变。而deepcopy是产生了一份完完全全独立的数据。

  1. class dict(object):
  2.     """
  3.     dict() -> new empty dictionary
  4.     dict(mapping) -> new dictionary initialized from a mapping object's
  5.         (key, value) pairs
  6.     dict(iterable) -> new dictionary initialized as if via:
  7.         d = {}
  8.         for k, v in iterable:
  9.             d[k] = v
  10.     dict(**kwargs) -> new dictionary initialized with the name=value pairs
  11.         in the keyword argument list.  For example:  dict(one=1, two=2)
  12.     """
  13.  
  14.     def clear(self): # real signature unknown; restored from __doc__
  15.         """ 清除内容 """
  16.         """ D.clear() -> None.  Remove all items from D. """
  17.         pass
  18.  
  19.     def copy(self): # real signature unknown; restored from __doc__
  20.         """ 浅拷贝 """
  21.         """ D.copy() -> a shallow copy of D """
  22.         pass
  23.  
  24.     @staticmethod # known case
  25.     def fromkeys(S, v=None): # real signature unknown; restored from __doc__
  26.         """
  27.         dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.
  28.         v defaults to None.
  29.         """
  30.         pass
  31.               a.formkeys([1,2,3],’t’)
  1.                 {1:’t’,2:’t’,3:’t’}
  2.     def get(self, k, d=None): # real signature unknown; restored from __doc__
  3.         """ 根据key获取值，d是默认值 """
  4.         """ D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None. """
  5.         pass
  6.             dic = {‘k1’:1234}
  1.             disc[‘k1’]
  1.               dic.get(‘k2’)这样也可以获取元素，没有这个值，也不会报错。
  1.               dic.get(‘k2’,’ok’)
  1.                ok
  2.     def has_key(self, k): # real signature unknown; restored from __doc__
  3.         """ 是否有key """
  4.         """ D.has_key(k) -> True if D has a key k, else False """
  5.         return False
  6.  
  7.     def items(self): # real signature unknown; restored from __doc__
  8.         """ 所有项的列表形式 """
  9.         """ D.items() -> list of D's (key, value) pairs, as 2-tuples """
  10.         return []
  11.  
  12.     def iteritems(self): # real signature unknown; restored from __doc__
  13.         """ 项可迭代 """
  14.         """ D.iteritems() -> an iterator over the (key, value) items of D """
  15.         pass
  16.  
  17.     def iterkeys(self): # real signature unknown; restored from __doc__
  18.         """ key可迭代 """
  19.         """ D.iterkeys() -> an iterator over the keys of D """
  20.         pass
  21.  
  22.     def itervalues(self): # real signature unknown; restored from __doc__
  23.         """ value可迭代 """
  24.         """ D.itervalues() -> an iterator over the values of D """
  25.         pass
  26.  
  27.     def keys(self): # real signature unknown; restored from __doc__
  28.         """ 所有的key列表 """
  29.         """ D.keys() -> list of D's keys """
  30.         return []
  31.  
  32.     def pop(self, k, d=None): # real signature unknown; restored from __doc__
  33.         """ 获取并在字典中移除 ，指定key"""还可以这样  del b[1]
  34.         """
  35.         D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
  36.         If key is not found, d is returned if given, otherwise KeyError is raised
  37.         """
  38.         pass
  39.  
  40.     def popitem(self): # real signature unknown; restored from __doc__
  41.         """ 获取并在字典中移除 """---删掉内存中的数据因为字典是无序，所以不好控制。
  42.         """
  43.         D.popitem() -> (k, v), remove and return some (key, value) pair as a
  44.         2-tuple; but raise KeyError if D is empty.
  45.         """
  46.         pass
  47.  
  48.     def setdefault(self, k, d=None): # real signature unknown; restored from __doc__
  49.         """ 如果key不存在，则创建，如果存在，则返回已存在的值且不修改 """
  50.         """ D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """
  51.         pass
  52.  
  53.     def update(self, E=None, **F): # known special case of dict.update
  54.         """ 更新
  55.             {'name':'alex', 'age': 18000}
  56.             [('name','sbsbsb'),]
  57.         """
  58.         """ 把两个字典中的元素整合到一个字典中，c.update(d) 循环d，把d中的付给c
  59.         D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
  60.         If E present and has a .keys() method, does:     for k in E: D[k] = E[k]
  61.         If E present and lacks .keys() method, does:     for (k, v) in E: D[k] = v
  62.         In either case, this is followed by: for k in F: D[k] = F[k]
  63.         """
  64.         pass
  65.  
  66.     def values(self): # real signature unknown; restored from __doc__
  67.         """ 所有的值 """
  68.         """ D.values() -> list of D's values """
  69.         return []
  70.  
  71.     def viewitems(self): # real signature unknown; restored from __doc__
  72.         """ 所有项，只是将内容保存至view对象中 """
  73.         """ D.viewitems() -> a set-like object providing a view on D's items """
  74.         pass
  75.  
  76.     def viewkeys(self): # real signature unknown; restored from __doc__
  77.         """ D.viewkeys() -> a set-like object providing a view on D's keys """
  78.         pass
  79.  
  80.     def viewvalues(self): # real signature unknown; restored from __doc__
  81.         """ D.viewvalues() -> an object providing a view on D's values """
  82.         pass
  83.  
  84.     def __cmp__(self, y): # real signature unknown; restored from __doc__
  85.         """ x.__cmp__(y) <==> cmp(x,y) """
  86.         pass
  87.  
  88.     def __contains__(self, k): # real signature unknown; restored from __doc__
  89.         """ D.__contains__(k) -> True if D has a key k, else False """
  90.         return False
  91.  
  92.     def __delitem__(self, y): # real signature unknown; restored from __doc__
  93.         """ x.__delitem__(y) <==> del x[y] """
  94.         pass
  95.  
  96.     def __eq__(self, y): # real signature unknown; restored from __doc__
  97.         """ x.__eq__(y) <==> x==y """
  98.         pass
  99.  
  100.     def __getattribute__(self, name): # real signature unknown; restored from __doc__
  101.         """ x.__getattribute__('name') <==> x.name """
  102.         pass
  103.  
  104.     def __getitem__(self, y): # real signature unknown; restored from __doc__
  105.         """ x.__getitem__(y) <==> x[y] """
  106.         pass
  107.  
  108.     def __ge__(self, y): # real signature unknown; restored from __doc__
  109.         """ x.__ge__(y) <==> x>=y """
  110.         pass
  111.  
  112.     def __gt__(self, y): # real signature unknown; restored from __doc__
  113.         """ x.__gt__(y) <==> x>y """
  114.         pass
  115.  
  116.     def __init__(self, seq=None, **kwargs): # known special case of dict.__init__
  117.         """
  118.         dict() -> new empty dictionary
  119.         dict(mapping) -> new dictionary initialized from a mapping object's
  120.             (key, value) pairs
  121.         dict(iterable) -> new dictionary initialized as if via:
  122.             d = {}
  123.             for k, v in iterable:
  124.                 d[k] = v
  125.         dict(**kwargs) -> new dictionary initialized with the name=value pairs
  126.             in the keyword argument list.  For example:  dict(one=1, two=2)
  127.         # (copied from class doc)
  128.         """
  129.         pass
  130.  
  131.     def __iter__(self): # real signature unknown; restored from __doc__
  132.         """ x.__iter__() <==> iter(x) """
  133.         pass
  134.  
  135.     def __len__(self): # real signature unknown; restored from __doc__
  136.         """ x.__len__() <==> len(x) """
  137.         pass
  138.  
  139.     def __le__(self, y): # real signature unknown; restored from __doc__
  140.         """ x.__le__(y) <==> x<=y """
  141.         pass
  142.  
  143.     def __lt__(self, y): # real signature unknown; restored from __doc__
  144.         """ x.__lt__(y) <==> x<y """
  145.         pass
  146.  
  147.     @staticmethod # known case of __new__
  148.     def __new__(S, *more): # real signature unknown; restored from __doc__
  149.         """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
  150.         pass
  151.  
  152.     def __ne__(self, y): # real signature unknown; restored from __doc__
  153.         """ x.__ne__(y) <==> x!=y """
  154.         pass
  155.  
  156.     def __repr__(self): # real signature unknown; restored from __doc__
  157.         """ x.__repr__() <==> repr(x) """
  158.         pass
  159.  
  160.     def __setitem__(self, i, y): # real signature unknown; restored from __doc__
  161.         """ x.__setitem__(i, y) <==> x[i]=y """
  162.         pass
  163.  
  164.     def __sizeof__(self): # real signature unknown; restored from __doc__
  165.         """ D.__sizeof__() -> size of D in memory, in bytes """
  166.         pass
  167.  
  168.     __hash__ = None

dict

1
2
3
练习：元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。
即： {'k1': 大于66 , 'k2': 小于66}
 
  1. 方法1
  2.  
  3. li = [11,22,33,44,55,66,77,88,99,90]
  4.  
  5. dic = {'k1':[],'k2':[]}
  6.  
  7. for item in li:
  8.  
  9.    if item>66:
  10.  
  11.        dic['k2'].append(item)
  12.  
  13.    else:
  14.  
  15.         dic['k1'].append(item)
  16.  
  17. 方法2：
  18.  
  19. li = [11,22,33,44,55,66,77,88,99,90]
  20.  
  21. dic = {}
  22.  
  23. for item in li:
  24.  
  25.    if item > 66:
  26.  
  27.       if 'k2' in dic.keys():
  28.  
  29.           dic['k2'].append(item)
  30.  
  31.       else:
  32.  
  33.          #创建只有一项元素的列表
  34.  
  35.           dic['k2'] = [item,]
  36.  
  37.    else:
  38.  
  39.        if item > 66:
  40.  
  41.       if 'k2' in dic.keys():
  42.  
  43.           dic['k2'].append(item)
  44.  
  45.       else:
  46.  
  47.           dic['k2'] = [item,]

方法

  1. alex|123|1
  2. sun|123|1
  3. bo|123|1
  4. 变成这样的字典
  5. dic = {
  6.     'alex':[123,1],
  7.     'bo':[123,1],
  8.      'sun':[123,1],
  9. }
  10.  
  11. dic = {}
  12. #打开文件，读取文件
  13.    obj = file('log','r')
  14.    line_list = obj.readlines()
  15.    obj.close()
  16.    for line in line_list:
  17.          line = line.strip()   #去掉换行和空格
  18.          ele_list = line.split('|')  #分割['alex','123','1']
  19.          dic[ele_list[0]] = ele_list[1:]

文件格式化

字典的操作

##key定义规则,1,不可变:数字,字符串,元组 (可以用作key)

2 可变的:列表,字典

##value定义规则:任意类型

增(字典是无序的)

  1. dic = {'name':'sun','age':29}
    print (dic)
    dic['sex']='man'
    print(dic)

删

  1. del dic['name']
    print(dic)

改(只能改vlaue,key不能改)

  1. dic = {'name':'sun','age':29}
    print (dic)
    dic['name']='zhaoyue'
    print(dic)

查

  1. name={
        395159623:{'age':29,'shengao':185,'sex':"man"},
        917643002:{'age':30,'shengao':160,'sex':"woman"}
    }
    print (name.get(395159623).get('age'))
    字典的循环方式
  1. dis={'name':'sunbo','age':18}###多用这种方式
    for key in dis:
        print(key,dis[key])
  2.  
  3. for k,v in dis.items():###items得先把字典转化成列表,效率不高.
        print(k,v)

八、set集合

重要功能：去重 比较

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

a = range(5,10)

b = range(7,12)

c = set(a)

d = set(b)

c & d 交集

c|d  并集

c ^d 取反

c – d c里面有d里面没有的

===========================

a & b  #求交集 a.intersection(b)
a | b  #求并集 a.union(b)
a – b  # 求差集 a.difference(b)
a ^ b #求对称差集 a.symmetric_difference(b)
a.issubset(b)  #a 是b 的子集
a.issuperset(b) # a 是否包含b

============================

  1. class set(object):
  2.     """
  3.     set() -> new empty set object
  4.     set(iterable) -> new set object
  5.  
  6.     Build an unordered collection of unique elements.
  7.     """
  8.     def add(self, *args, **kwargs): # real signature unknown
  9.         """ 添加 """
  10.         """
  11.         Add an element to a set.
  12.  
  13.         This has no effect if the element is already present.
  14.         """
  15.         pass
  16.  
  17.     def clear(self, *args, **kwargs): # real signature unknown
  18.         """ Remove all elements from this set. """
  19.         pass
  20.  
  21.     def copy(self, *args, **kwargs): # real signature unknown
  22.         """ Return a shallow copy of a set. """
  23.         pass
  24.  
  25.     def difference(self, *args, **kwargs): # real signature unknown
  26.         """
  27.         Return the difference of two or more sets as a new set.
  28.  
  29.         (i.e. all elements that are in this set but not the others.)
  30.         """
  31.         pass
  32.  
  33.     def difference_update(self, *args, **kwargs): # real signature unknown
  34.         """ 删除当前set中的所有包含在 new set 里的元素 """
  35.         """ Remove all elements of another set from this set. """
  36.         pass
  37.  
  38.     def discard(self, *args, **kwargs): # real signature unknown
  39.         """ 移除元素 """
  40.         """
  41.         Remove an element from a set if it is a member.
  42.  
  43.         If the element is not a member, do nothing.
  44.         """
  45.         pass
  46.  
  47.     def intersection(self, *args, **kwargs): # real signature unknown
  48.         """ 取交集，新创建一个set """
  49.         """
  50.         Return the intersection of two or more sets as a new set.
  51.  
  52.         (i.e. elements that are common to all of the sets.)
  53.         """
  54.         pass
  55.  
  56.     def intersection_update(self, *args, **kwargs): # real signature unknown
  57.         """ 取交集，修改原来set """
  58.         """ Update a set with the intersection of itself and another. """
  59.         pass
  60.  
  61.     def isdisjoint(self, *args, **kwargs): # real signature unknown
  62.         """ 如果没有交集，返回true  """
  63.         """ Return True if two sets have a null intersection. """
  64.         pass
  65.  
  66.     def issubset(self, *args, **kwargs): # real signature unknown
  67.         """ 是否是子集 """
  68.         """ Report whether another set contains this set. """
  69.         pass
  70.  
  71.     def issuperset(self, *args, **kwargs): # real signature unknown
  72.         """ 是否是父集 """
  73.         """ Report whether this set contains another set. """
  74.         pass
  75.  
  76.     def pop(self, *args, **kwargs): # real signature unknown
  77.         """ 移除 """
  78.         """
  79.         Remove and return an arbitrary set element.
  80.         Raises KeyError if the set is empty.
  81.         """
  82.         pass
  83.  
  84.     def remove(self, *args, **kwargs): # real signature unknown
  85.         """ 移除 """
  86.         """
  87.         Remove an element from a set; it must be a member.
  88.  
  89.         If the element is not a member, raise a KeyError.
  90.         """
  91.         pass
  92.  
  93.     def symmetric_difference(self, *args, **kwargs): # real signature unknown
  94.         """ 差集，创建新对象"""
  95.         """
  96.         Return the symmetric difference of two sets as a new set.
  97.  
  98.         (i.e. all elements that are in exactly one of the sets.)
  99.         """
  100.         pass
  101.  
  102.     def symmetric_difference_update(self, *args, **kwargs): # real signature unknown
  103.         """ 差集，改变原来 """
  104.         """ Update a set with the symmetric difference of itself and another. """
  105.         pass
  106.  
  107.     def union(self, *args, **kwargs): # real signature unknown
  108.         """ 并集 """
  109.         """
  110.         Return the union of sets as a new set.
  111.  
  112.         (i.e. all elements that are in either set.)
  113.         """
  114.         pass
  115.  
  116.     def update(self, *args, **kwargs): # real signature unknown
  117.         """ 更新 """
  118.         """ Update a set with the union of itself and others. """
  119.         pass
  120.  
  121.     def __and__(self, y): # real signature unknown; restored from __doc__
  122.         """ x.__and__(y) <==> x&y """
  123.         pass
  124.  
  125.     def __cmp__(self, y): # real signature unknown; restored from __doc__
  126.         """ x.__cmp__(y) <==> cmp(x,y) """
  127.         pass
  128.  
  129.     def __contains__(self, y): # real signature unknown; restored from __doc__
  130.         """ x.__contains__(y) <==> y in x. """
  131.         pass
  132.  
  133.     def __eq__(self, y): # real signature unknown; restored from __doc__
  134.         """ x.__eq__(y) <==> x==y """
  135.         pass
  136.  
  137.     def __getattribute__(self, name): # real signature unknown; restored from __doc__
  138.         """ x.__getattribute__('name') <==> x.name """
  139.         pass
  140.  
  141.     def __ge__(self, y): # real signature unknown; restored from __doc__
  142.         """ x.__ge__(y) <==> x>=y """
  143.         pass
  144.  
  145.     def __gt__(self, y): # real signature unknown; restored from __doc__
  146.         """ x.__gt__(y) <==> x>y """
  147.         pass
  148.  
  149.     def __iand__(self, y): # real signature unknown; restored from __doc__
  150.         """ x.__iand__(y) <==> x&=y """
  151.         pass
  152.  
  153.     def __init__(self, seq=()): # known special case of set.__init__
  154.         """
  155.         set() -> new empty set object
  156.         set(iterable) -> new set object
  157.  
  158.         Build an unordered collection of unique elements.
  159.         # (copied from class doc)
  160.         """
  161.         pass
  162.  
  163.     def __ior__(self, y): # real signature unknown; restored from __doc__
  164.         """ x.__ior__(y) <==> x|=y """
  165.         pass
  166.  
  167.     def __isub__(self, y): # real signature unknown; restored from __doc__
  168.         """ x.__isub__(y) <==> x-=y """
  169.         pass
  170.  
  171.     def __iter__(self): # real signature unknown; restored from __doc__
  172.         """ x.__iter__() <==> iter(x) """
  173.         pass
  174.  
  175.     def __ixor__(self, y): # real signature unknown; restored from __doc__
  176.         """ x.__ixor__(y) <==> x^=y """
  177.         pass
  178.  
  179.     def __len__(self): # real signature unknown; restored from __doc__
  180.         """ x.__len__() <==> len(x) """
  181.         pass
  182.  
  183.     def __le__(self, y): # real signature unknown; restored from __doc__
  184.         """ x.__le__(y) <==> x<=y """
  185.         pass
  186.  
  187.     def __lt__(self, y): # real signature unknown; restored from __doc__
  188.         """ x.__lt__(y) <==> x<y """
  189.         pass
  190.  
  191.     @staticmethod # known case of __new__
  192.     def __new__(S, *more): # real signature unknown; restored from __doc__
  193.         """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
  194.         pass
  195.  
  196.     def __ne__(self, y): # real signature unknown; restored from __doc__
  197.         """ x.__ne__(y) <==> x!=y """
  198.         pass
  199.  
  200.     def __or__(self, y): # real signature unknown; restored from __doc__
  201.         """ x.__or__(y) <==> x|y """
  202.         pass
  203.  
  204.     def __rand__(self, y): # real signature unknown; restored from __doc__
  205.         """ x.__rand__(y) <==> y&x """
  206.         pass
  207.  
  208.     def __reduce__(self, *args, **kwargs): # real signature unknown
  209.         """ Return state information for pickling. """
  210.         pass
  211.  
  212.     def __repr__(self): # real signature unknown; restored from __doc__
  213.         """ x.__repr__() <==> repr(x) """
  214.         pass
  215.  
  216.     def __ror__(self, y): # real signature unknown; restored from __doc__
  217.         """ x.__ror__(y) <==> y|x """
  218.         pass
  219.  
  220.     def __rsub__(self, y): # real signature unknown; restored from __doc__
  221.         """ x.__rsub__(y) <==> y-x """
  222.         pass
  223.  
  224.     def __rxor__(self, y): # real signature unknown; restored from __doc__
  225.         """ x.__rxor__(y) <==> y^x """
  226.         pass
  227.  
  228.     def __sizeof__(self): # real signature unknown; restored from __doc__
  229.         """ S.__sizeof__() -> size of S in memory, in bytes """
  230.         pass
  231.  
  232.     def __sub__(self, y): # real signature unknown; restored from __doc__
  233.         """ x.__sub__(y) <==> x-y """
  234.         pass
  235.  
  236.     def __xor__(self, y): # real signature unknown; restored from __doc__
  237.         """ x.__xor__(y) <==> x^y """
  238.         pass
  239.  
  240.     __hash__ = None

set

练习：寻找差异

# 数据库中原有
old_dict = {
    "#1":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 },
    "#2":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 }
    "#3":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 }
}
 
# cmdb 新汇报的数据
new_dict = {
    "#1":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 800 },
    "#3":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 }
    "#4":{ 'hostname':c2, 'cpu_count': 2, 'mem_capicity': 80 }
}
 
需要删除：？
需要新建：？
需要更新：？ 注意：无需考虑内部元素是否改变，只要原来存在，新汇报也存在，就是需要更新
  1. old_set = set(old_dict.keys())
  2. update_list = list(old_set.intersection(new_dict.keys()))
  3.  
  4. new_list = []
  5. del_list = []
  6.  
  7. for i in new_dict.keys():
  8.     if i not in update_list:
  9.         new_list.append(i)
  10.  
  11. for i in old_dict.keys():
  12.     if i not in update_list:
  13.         del_list.append(i)
  14.  
  15. print update_list,new_list,del_list

九、collection系列

1、计数器（counter）

Counter是对字典类型的补充，用于追踪值的出现次数。

ps：具备字典的所有功能 + 自己的功能

引入collections模块

  1. import collections
  2. collections.Counter('aaabbcc')
  3. c1 = collections.Counter('aabb')
  4. c2 = collections.Counter('aacc')
  5. c1.update(c2)
  1. c = Counter('abcdeabcdabcaba')
  2. print c
  3. 输出：Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1}
  1. ########################################################################
  2. ###  Counter
  3. ########################################################################
  4.  
  5. class Counter(dict): #当前扩展的字典
  6.     '''Dict subclass for counting hashable items.  Sometimes called a bag
  7.     or multiset.  Elements are stored as dictionary keys and their counts
  8.     are stored as dictionary values.
  9.  
  10.     >>> c = Counter('abcdeabcdabcaba')  # count elements from a string
  11.  
  12.     >>> c.most_common(3)                # three most common elements后面的参数的意思是至少出现3次
  13.     [('a', 5), ('b', 4), ('c', 3)]
  14.     >>> sorted(c)                       # list all unique elements
  15.     ['a', 'b', 'c', 'd', 'e']
  16.     >>> ''.join(sorted(c.elements()))   # list elements with repetitions
  17.     'aaaaabbbbcccdde'
  18.     >>> sum(c.values())                 # total of all counts
  19.  
  20.     >>> c['a']                          # count of letter 'a'
  21.     >>> for elem in 'shazam':           # update counts from an iterable
  22.     ...     c[elem] += 1                # by adding 1 to each element's count
  23.     >>> c['a']                          # now there are seven 'a'
  24.     >>> del c['b']                      # remove all 'b'
  25.     >>> c['b']                          # now there are zero 'b'
  26.  
  27.     >>> d = Counter('simsalabim')       # make another counter
  28.     >>> c.update(d)                     # add in the second counter把d加入到c中。
  29.     >>> c['a']                          # now there are nine 'a'
  30.  
  31.     >>> c.clear()                       # empty the counter
  32.     >>> c
  33.     Counter()
  34.  
  35.     Note:  If a count is set to zero or reduced to zero, it will remain
  36.     in the counter until the entry is deleted or the counter is cleared:
  37.  
  38.     >>> c = Counter('aaabbc')
  39.     >>> c['b'] -= 2                     # reduce the count of 'b' by two
  40.     >>> c.most_common()                 # 'b' is still in, but its count is zero
  41.     [('a', 3), ('c', 1), ('b', 0)]
  42.  
  43.     '''
  44.     # References:
  45.     #   http://en.wikipedia.org/wiki/Multiset
  46.     #   http://www.gnu.org/software/smalltalk/manual-base/html_node/Bag.html
  47.     #   http://www.demo2s.com/Tutorial/Cpp/0380__set-multiset/Catalog0380__set-multiset.htm
  48.     #   http://code.activestate.com/recipes/259174/
  49.     #   Knuth, TAOCP Vol. II section 4.6.3
  50.  
  51.     def __init__(self, iterable=None, **kwds):
  52.         '''Create a new, empty Counter object.  And if given, count elements
  53.         from an input iterable.  Or, initialize the count from another mapping
  54.         of elements to their counts.
  55.  
  56.         >>> c = Counter()                           # a new, empty counter
  57.         >>> c = Counter('gallahad')                 # a new counter from an iterable
  58.         >>> c = Counter({'a': 4, 'b': 2})           # a new counter from a mapping
  59.         >>> c = Counter(a=4, b=2)                   # a new counter from keyword args
  60.  
  61.         '''
  62.         super(Counter, self).__init__()
  63.         self.update(iterable, **kwds)
  64.  
  65.     def __missing__(self, key):
  66.         """ 对于不存在的元素，返回计数器为0 """
  67.         'The count of elements not in the Counter is zero.'
  68.         # Needed so that self[missing_item] does not raise KeyError
  69.         return 0
  70.  
  71.     def most_common(self, n=None):
  72.         """ 列出前几位的元素"""
  73.         '''List the n most common elements and their counts from the most
  74.         common to the least.  If n is None, then list all element counts.
  75.  
  76.         >>> Counter('abcdeabcdabcaba').most_common(3)
  77.         [('a', 5), ('b', 4), ('c', 3)]
  78.  
  79.         '''
  80.         # Emulate Bag.sortedByCount from Smalltalk
  81.         if n is None:
  82.             return sorted(self.iteritems(), key=_itemgetter(1), reverse=True)
  83.         return _heapq.nlargest(n, self.iteritems(), key=_itemgetter(1))
  84.  
  85.     def elements(self):
  86.         """ 计数器中的所有元素，注：此处非所有元素集合，而是包含所有元素集合的迭代器 """
  87.         '''Iterator over elements repeating each as many times as its count.
  88.  
  89.         >>> c = Counter('ABCABC')
  90.         >>> sorted(c.elements())
  91.         ['A', 'A', 'B', 'B', 'C', 'C']
  92.  
  93.         # Knuth's example for prime factors of 1836:  2**2 * 3**3 * 17**1
  94.         >>> prime_factors = Counter({2: 2, 3: 3, 17: 1})
  95.         >>> product = 1
  96.         >>> for factor in prime_factors.elements():     # loop over factors
  97.         ...     product *= factor                       # and multiply them
  98.         >>> product
  99.  
  100.         Note, if an element's count has been set to zero or is a negative
  101.         number, elements() will ignore it.
  102.  
  103.         '''
  104.         # Emulate Bag.do from Smalltalk and Multiset.begin from C++.
  105.         return _chain.from_iterable(_starmap(_repeat, self.iteritems()))
  106.  
  107.     # Override dict methods where necessary
  108.  
  109.     @classmethod
  110.     def fromkeys(cls, iterable, v=None):
  111.         # There is no equivalent method for counters because setting v=1
  112.         # means that no element can have a count greater than one.
  113.         raise NotImplementedError(
  114.             'Counter.fromkeys() is undefined.  Use Counter(iterable) instead.')
  115.  
  116.     def update(self, iterable=None, **kwds):
  117.         """ 更新计数器，其实就是增加；如果原来没有，则新建，如果有则加一 """
  118.         '''Like dict.update() but add counts instead of replacing them.
  119.  
  120.         Source can be an iterable, a dictionary, or another Counter instance.
  121.  
  122.         >>> c = Counter('which')
  123.         >>> c.update('witch')           # add elements from another iterable
  124.         >>> d = Counter('watch')
  125.         >>> c.update(d)                 # add elements from another counter
  126.         >>> c['h']                      # four 'h' in which, witch, and watch
  127.  
  128.         '''
  129.         # The regular dict.update() operation makes no sense here because the
  130.         # replace behavior results in the some of original untouched counts
  131.         # being mixed-in with all of the other counts for a mismash that
  132.         # doesn't have a straight-forward interpretation in most counting
  133.         # contexts.  Instead, we implement straight-addition.  Both the inputs
  134.         # and outputs are allowed to contain zero and negative counts.
  135.  
  136.         if iterable is not None:
  137.             if isinstance(iterable, Mapping):
  138.                 if self:
  139.                     self_get = self.get
  140.                     for elem, count in iterable.iteritems():
  141.                         self[elem] = self_get(elem, 0) + count
  142.                 else:
  143.                     super(Counter, self).update(iterable) # fast path when counter is empty
  144.             else:
  145.                 self_get = self.get
  146.                 for elem in iterable:
  147.                     self[elem] = self_get(elem, 0) + 1
  148.         if kwds:
  149.             self.update(kwds)
  150.  
  151.     def subtract(self, iterable=None, **kwds):
  152.         """ 相减，原来的计数器中的每一个元素的数量减去后添加的元素的数量 """
  153.         '''Like dict.update() but subtracts counts instead of replacing them.
  154.         Counts can be reduced below zero.  Both the inputs and outputs are
  155.         allowed to contain zero and negative counts.
  156.  
  157.         Source can be an iterable, a dictionary, or another Counter instance.
  158.  
  159.         >>> c = Counter('which')
  160.         >>> c.subtract('witch')             # subtract elements from another iterable
  161.         >>> c.subtract(Counter('watch'))    # subtract elements from another counter
  162.         >>> c['h']                          # 2 in which, minus 1 in witch, minus 1 in watch
  163.         >>> c['w']                          # 1 in which, minus 1 in witch, minus 1 in watch
  164.         -1
  165.  
  166.         '''
  167.         if iterable is not None:
  168.             self_get = self.get
  169.             if isinstance(iterable, Mapping):
  170.                 for elem, count in iterable.items():
  171.                     self[elem] = self_get(elem, 0) - count
  172.             else:
  173.                 for elem in iterable:
  174.                     self[elem] = self_get(elem, 0) - 1
  175.         if kwds:
  176.             self.subtract(kwds)
  177.  
  178.     def copy(self):
  179.         """ 拷贝 """
  180.         'Return a shallow copy.'
  181.         return self.__class__(self)
  182.  
  183.     def __reduce__(self):
  184.         """ 返回一个元组（类型，元组） """
  185.         return self.__class__, (dict(self),)
  186.  
  187.     def __delitem__(self, elem):
  188.         """ 删除元素 """
  189.         'Like dict.__delitem__() but does not raise KeyError for missing values.'
  190.         if elem in self:
  191.             super(Counter, self).__delitem__(elem)
  192.  
  193.     def __repr__(self):
  194.         if not self:
  195.             return '%s()' % self.__class__.__name__
  196.         items = ', '.join(map('%r: %r'.__mod__, self.most_common()))
  197.         return '%s({%s})' % (self.__class__.__name__, items)
  198.  
  199.     # Multiset-style mathematical operations discussed in:
  200.     #       Knuth TAOCP Volume II section 4.6.3 exercise 19
  201.     #       and at http://en.wikipedia.org/wiki/Multiset
  202.     #
  203.     # Outputs guaranteed to only include positive counts.
  204.     #
  205.     # To strip negative and zero counts, add-in an empty counter:
  206.     #       c += Counter()
  207.  
  208.     def __add__(self, other):
  209.         '''Add counts from two counters.
  210.  
  211.         >>> Counter('abbb') + Counter('bcc')
  212.         Counter({'b': 4, 'c': 2, 'a': 1})
  213.  
  214.         '''
  215.         if not isinstance(other, Counter):
  216.             return NotImplemented
  217.         result = Counter()
  218.         for elem, count in self.items():
  219.             newcount = count + other[elem]
  220.             if newcount > 0:
  221.                 result[elem] = newcount
  222.         for elem, count in other.items():
  223.             if elem not in self and count > 0:
  224.                 result[elem] = count
  225.         return result
  226.  
  227.     def __sub__(self, other):
  228.         ''' Subtract count, but keep only results with positive counts.
  229.  
  230.         >>> Counter('abbbc') - Counter('bccd')
  231.         Counter({'b': 2, 'a': 1})
  232.  
  233.         '''
  234.         if not isinstance(other, Counter):
  235.             return NotImplemented
  236.         result = Counter()
  237.         for elem, count in self.items():
  238.             newcount = count - other[elem]
  239.             if newcount > 0:
  240.                 result[elem] = newcount
  241.         for elem, count in other.items():
  242.             if elem not in self and count < 0:
  243.                 result[elem] = 0 - count
  244.         return result
  245.  
  246.     def __or__(self, other):
  247.         '''Union is the maximum of value in either of the input counters.
  248.  
  249.         >>> Counter('abbb') | Counter('bcc')
  250.         Counter({'b': 3, 'c': 2, 'a': 1})
  251.  
  252.         '''
  253.         if not isinstance(other, Counter):
  254.             return NotImplemented
  255.         result = Counter()
  256.         for elem, count in self.items():
  257.             other_count = other[elem]
  258.             newcount = other_count if count < other_count else count
  259.             if newcount > 0:
  260.                 result[elem] = newcount
  261.         for elem, count in other.items():
  262.             if elem not in self and count > 0:
  263.                 result[elem] = count
  264.         return result
  265.  
  266.     def __and__(self, other):
  267.         ''' Intersection is the minimum of corresponding counts.
  268.  
  269.         >>> Counter('abbb') & Counter('bcc')
  270.         Counter({'b': 1})
  271.  
  272.         '''
  273.         if not isinstance(other, Counter):
  274.             return NotImplemented
  275.         result = Counter()
  276.         for elem, count in self.items():
  277.             other_count = other[elem]
  278.             newcount = count if count < other_count else other_count
  279.             if newcount > 0:
  280.                 result[elem] = newcount
  281.         return result
  282.  
  283. Counter

Counter

2、有序字典(orderedDict )

orderdDict是对字典类型的补充，他记住了字典元素添加的顺序

  1. o1 = collections.OrderedDict()
  2. o1['k1'] = 1
  3. o1['k2'] = 2
  4. o1['k3'] = 3

有序字典其实内部有一个列表，等以后去数据的时候，就会根据类表的顺序去取得。

  1. class OrderedDict(dict):
  2.     'Dictionary that remembers insertion order'
  3.     # An inherited dict maps keys to values.
  4.     # The inherited dict provides __getitem__, __len__, __contains__, and get.
  5.     # The remaining methods are order-aware.
  6.     # Big-O running times for all methods are the same as regular dictionaries.
  7.  
  8.     # The internal self.__map dict maps keys to links in a doubly linked list.
  9.     # The circular doubly linked list starts and ends with a sentinel element.
  10.     # The sentinel element never gets deleted (this simplifies the algorithm).
  11.     # Each link is stored as a list of length three:  [PREV, NEXT, KEY].
  12.  
  13.     def __init__(self, *args, **kwds):
  14.         '''Initialize an ordered dictionary.  The signature is the same as
  15.         regular dictionaries, but keyword arguments are not recommended because
  16.         their insertion order is arbitrary.
  17.  
  18.         '''
  19.         if len(args) > 1:
  20.             raise TypeError('expected at most 1 arguments, got %d' % len(args))
  21.         try:
  22.             self.__root
  23.         except AttributeError:
  24.             self.__root = root = []                     # sentinel node
  25.             root[:] = [root, root, None]
  26.             self.__map = {}
  27.         self.__update(*args, **kwds)
  28.  
  29.     def __setitem__(self, key, value, dict_setitem=dict.__setitem__):
  30.         'od.__setitem__(i, y) <==> od[i]=y'
  31.         # Setting a new item creates a new link at the end of the linked list,
  32.         # and the inherited dictionary is updated with the new key/value pair.
  33.         if key not in self:
  34.             root = self.__root
  35.             last = root[0]
  36.             last[1] = root[0] = self.__map[key] = [last, root, key]
  37.         return dict_setitem(self, key, value)
  38.  
  39.     def __delitem__(self, key, dict_delitem=dict.__delitem__):
  40.         'od.__delitem__(y) <==> del od[y]'
  41.         # Deleting an existing item uses self.__map to find the link which gets
  42.         # removed by updating the links in the predecessor and successor nodes.
  43.         dict_delitem(self, key)
  44.         link_prev, link_next, _ = self.__map.pop(key)
  45.         link_prev[1] = link_next                        # update link_prev[NEXT]
  46.         link_next[0] = link_prev                        # update link_next[PREV]
  47.  
  48.     def __iter__(self):
  49.         'od.__iter__() <==> iter(od)'
  50.         # Traverse the linked list in order.
  51.         root = self.__root
  52.         curr = root[1]                                  # start at the first node
  53.         while curr is not root:
  54.             yield curr[2]                               # yield the curr[KEY]
  55.             curr = curr[1]                              # move to next node
  56.  
  57.     def __reversed__(self):
  58.         'od.__reversed__() <==> reversed(od)'
  59.         # Traverse the linked list in reverse order.
  60.         root = self.__root
  61.         curr = root[0]                                  # start at the last node
  62.         while curr is not root:
  63.             yield curr[2]                               # yield the curr[KEY]
  64.             curr = curr[0]                              # move to previous node
  65.  
  66.     def clear(self):
  67.         'od.clear() -> None.  Remove all items from od.'
  68.         root = self.__root
  69.         root[:] = [root, root, None]
  70.         self.__map.clear()
  71.         dict.clear(self)
  72.  
  73.     # -- the following methods do not depend on the internal structure --
  74.  
  75.     def keys(self):
  76.         'od.keys() -> list of keys in od'
  77.         return list(self)
  78.  
  79.     def values(self):
  80.         'od.values() -> list of values in od'
  81.         return [self[key] for key in self]
  82.  
  83.     def items(self):
  84.         'od.items() -> list of (key, value) pairs in od'
  85.         return [(key, self[key]) for key in self]
  86.  
  87.     def iterkeys(self):
  88.         'od.iterkeys() -> an iterator over the keys in od'
  89.         return iter(self)
  90.  
  91.     def itervalues(self):
  92.         'od.itervalues -> an iterator over the values in od'
  93.         for k in self:
  94.             yield self[k]
  95.  
  96.     def iteritems(self):
  97.         'od.iteritems -> an iterator over the (key, value) pairs in od'
  98.         for k in self:
  99.             yield (k, self[k])
  100.  
  101.     update = MutableMapping.update
  102.  
  103.     __update = update # let subclasses override update without breaking __init__
  104.  
  105.     __marker = object()
  106.  
  107.     def pop(self, key, default=__marker):
  108.         '''od.pop(k[,d]) -> v, remove specified key and return the corresponding
  109.         value.  If key is not found, d is returned if given, otherwise KeyError
  110.         is raised.
  111.  
  112.         '''
  113.         if key in self:
  114.             result = self[key]
  115.             del self[key]
  116.             return result
  117.         if default is self.__marker:
  118.             raise KeyError(key)
  119.         return default
  120.  
  121.     def setdefault(self, key, default=None):
  122.         'od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od'
  123.         if key in self:
  124.             return self[key]
  125.         self[key] = default
  126.         return default
  127.  
  128.     def popitem(self, last=True):
  129.         '''od.popitem() -> (k, v), return and remove a (key, value) pair.
  130.         Pairs are returned in LIFO order if last is true or FIFO order if false.
  131.  
  132.         '''
  133.         if not self:
  134.             raise KeyError('dictionary is empty')
  135.         key = next(reversed(self) if last else iter(self))
  136.         value = self.pop(key)
  137.         return key, value
  138.  
  139.     def __repr__(self, _repr_running={}):
  140.         'od.__repr__() <==> repr(od)'
  141.         call_key = id(self), _get_ident()
  142.         if call_key in _repr_running:
  143.             return '...'
  144.         _repr_running[call_key] = 1
  145.         try:
  146.             if not self:
  147.                 return '%s()' % (self.__class__.__name__,)
  148.             return '%s(%r)' % (self.__class__.__name__, self.items())
  149.         finally:
  150.             del _repr_running[call_key]
  151.  
  152.     def __reduce__(self):
  153.         'Return state information for pickling'
  154.         items = [[k, self[k]] for k in self]
  155.         inst_dict = vars(self).copy()
  156.         for k in vars(OrderedDict()):
  157.             inst_dict.pop(k, None)
  158.         if inst_dict:
  159.             return (self.__class__, (items,), inst_dict)
  160.         return self.__class__, (items,)
  161.  
  162.     def copy(self):
  163.         'od.copy() -> a shallow copy of od'
  164.         return self.__class__(self)
  165.  
  166.     @classmethod
  167.     def fromkeys(cls, iterable, value=None):
  168.         '''OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S.
  169.         If not specified, the value defaults to None.
  170.  
  171.         '''
  172.         self = cls()
  173.         for key in iterable:
  174.             self[key] = value
  175.         return self
  176.  
  177.     def __eq__(self, other):
  178.         '''od.__eq__(y) <==> od==y.  Comparison to another OD is order-sensitive
  179.         while comparison to a regular mapping is order-insensitive.
  180.  
  181.         '''
  182.         if isinstance(other, OrderedDict):
  183.             return dict.__eq__(self, other) and all(_imap(_eq, self, other))
  184.         return dict.__eq__(self, other)
  185.  
  186.     def __ne__(self, other):
  187.         'od.__ne__(y) <==> od!=y'
  188.         return not self == other
  189.  
  190.     # -- the following methods support python 3.x style dictionary views --
  191.  
  192.     def viewkeys(self):
  193.         "od.viewkeys() -> a set-like object providing a view on od's keys"
  194.         return KeysView(self)
  195.  
  196.     def viewvalues(self):
  197.         "od.viewvalues() -> an object providing a view on od's values"
  198.         return ValuesView(self)
  199.  
  200.     def viewitems(self):
  201.         "od.viewitems() -> a set-like object providing a view on od's items"
  202.         return ItemsView(self)

OrderedDict

3、默认字典(defaultdict) ---默认所有的字典的value都为空的列表

也就是为你字典的值设置一个默认类型

my_dict = defaultdict(dict)----也可以自己设置字典里的values时字典

学前需求：

  1. 有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。
  2. 即： {'k1': 大于66 , 'k2': 小于66}
  1. values = [11, 22, 33,44,55,66,77,88,99,90]
  2.  
  3. my_dict = {}
  4.  
  5. for value in  values:
  6.     if value>66:
  7.         if my_dict.has_key('k1'):
  8.             my_dict['k1'].append(value)
  9.         else:
  10.             my_dict['k1'] = [value]
  11.     else:
  12.         if my_dict.has_key('k2'):
  13.             my_dict['k2'].append(value)
  14.         else:
  15.             my_dict['k2'] = [value]

原生字典解决方法

  1. from collections import defaultdict
  2.  
  3. values = [11, 22, 33,44,55,66,77,88,99,90]
  4.  
  5. my_dict = defaultdict(list)
  6.  
  7. for value in  values:
  8.     if value>66:
  9.         my_dict['k1'].append(value)
  10.     else:
  11.         my_dict['k2'].append(value)

defaultdict字典解决方法

defaultdict是对字典的类型的补充，他默认给字典的值设置了一个类型。

  1. class defaultdict(dict):
  2.     """
  3.     defaultdict(default_factory[, ...]) --> dict with default factory
  4.  
  5.     The default factory is called without arguments to produce
  6.     a new value when a key is not present, in __getitem__ only.
  7.     A defaultdict compares equal to a dict with the same items.
  8.     All remaining arguments are treated the same as if they were
  9.     passed to the dict constructor, including keyword arguments.
  10.     """
  11.     def copy(self): # real signature unknown; restored from __doc__
  12.         """ D.copy() -> a shallow copy of D. """
  13.         pass
  14.  
  15.     def __copy__(self, *args, **kwargs): # real signature unknown
  16.         """ D.copy() -> a shallow copy of D. """
  17.         pass
  18.  
  19.     def __getattribute__(self, name): # real signature unknown; restored from __doc__
  20.         """ x.__getattribute__('name') <==> x.name """
  21.         pass
  22.  
  23.     def __init__(self, default_factory=None, **kwargs): # known case of _collections.defaultdict.__init__
  24.         """
  25.         defaultdict(default_factory[, ...]) --> dict with default factory
  26.  
  27.         The default factory is called without arguments to produce
  28.         a new value when a key is not present, in __getitem__ only.
  29.         A defaultdict compares equal to a dict with the same items.
  30.         All remaining arguments are treated the same as if they were
  31.         passed to the dict constructor, including keyword arguments.
  32.  
  33.         # (copied from class doc)
  34.         """
  35.         pass
  36.  
  37.     def __missing__(self, key): # real signature unknown; restored from __doc__
  38.         """
  39.         __missing__(key) # Called by __getitem__ for missing key; pseudo-code:
  40.           if self.default_factory is None: raise KeyError((key,))
  41.           self[key] = value = self.default_factory()
  42.           return value
  43.         """
  44.         pass
  45.  
  46.     def __reduce__(self, *args, **kwargs): # real signature unknown
  47.         """ Return state information for pickling. """
  48.         pass
  49.  
  50.     def __repr__(self): # real signature unknown; restored from __doc__
  51.         """ x.__repr__() <==> repr(x) """
  52.         pass
  53.  
  54.     default_factory = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
  55.     """Factory for default value called by __missing__()."""

defaultdict

4、可命名元组(namedtuple)

根据nametuple可以创建一个包含tuple所有功能以及其他功能的类型。

  1. import collections
  2. Mytuple = collections.namedtuple('Mytuple',['x', 'y', 'z'])

如何使用：

1 首先要创建类：创建我自己的类，这个类是对我原生tuple

  1. Mytuple = collections.namedtuple('Mytuple',['x', 'y', 'z'])

2 根据类创建对象 new = Mytuple(1,2)

3 使用对象   new =====Mytuple(x=1,y=2)       n.x   n.y

  1. class Mytuple(__builtin__.tuple)---对tuple进行扩展，也叫作基础
  2.  |  Mytuple(x, y)
  3.  |
  4.  |  Method resolution order:
  5.  |      Mytuple
  6.  |      __builtin__.tuple
  7.  |      __builtin__.object
  8.  |
  9.  |  Methods defined here:
  10.  |
  11.  |  __getnewargs__(self)
  12.  |      Return self as a plain tuple.  Used by copy and pickle.
  13.  |
  14.  |  __getstate__(self)
  15.  |      Exclude the OrderedDict from pickling
  16.  |
  17.  |  __repr__(self)
  18.  |      Return a nicely formatted representation string
  19.  |
  20.  |  _asdict(self)
  21.  |      Return a new OrderedDict which maps field names to their values
  22.  |
  23.  |  _replace(_self, **kwds)
  24.  |      Return a new Mytuple object replacing specified fields with new values
  25.  |
  26.  |  ----------------------------------------------------------------------
  27.  |  Class methods defined here:
  28.  |
  29.  |  _make(cls, iterable, new=<built-in method __new__ of type object>, len=<built-in function len>) from __builtin__.type
  30.  |      Make a new Mytuple object from a sequence or iterable
  31.  |
  32.  |  ----------------------------------------------------------------------
  33.  |  Static methods defined here:
  34.  |
  35.  |  __new__(_cls, x, y)
  36.  |      Create new instance of Mytuple(x, y)
  37.  |
  38.  |  ----------------------------------------------------------------------
  39.  |  Data descriptors defined here:
  40.  |
  41.  |  __dict__
  42.  |      Return a new OrderedDict which maps field names to their values
  43.  |
  44.  |  x
  45.  |      Alias for field number 0
  46.  |
  47.  |  y
  48.  |      Alias for field number 1
  49.  |
  50.  |  ----------------------------------------------------------------------
  51.  |  Data and other attributes defined here:
  52.  |
  53.  |  _fields = ('x', 'y')
  54.  |
  55.  |  ----------------------------------------------------------------------
  56.  |  Methods inherited from __builtin__.tuple:
  57.  |
  58.  |  __add__(...)
  59.  |      x.__add__(y) <==> x+y
  60.  |
  61.  |  __contains__(...)
  62.  |      x.__contains__(y) <==> y in x
  63.  |
  64.  |  __eq__(...)
  65.  |      x.__eq__(y) <==> x==y
  66.  |
  67.  |  __ge__(...)
  68.  |      x.__ge__(y) <==> x>=y
  69.  |
  70.  |  __getattribute__(...)
  71.  |      x.__getattribute__('name') <==> x.name
  72.  |
  73.  |  __getitem__(...)
  74.  |      x.__getitem__(y) <==> x[y]
  75.  |
  76.  |  __getslice__(...)
  77.  |      x.__getslice__(i, j) <==> x[i:j]
  78.  |
  79.  |      Use of negative indices is not supported.
  80.  |
  81.  |  __gt__(...)
  82.  |      x.__gt__(y) <==> x>y
  83.  |
  84.  |  __hash__(...)
  85.  |      x.__hash__() <==> hash(x)
  86.  |
  87.  |  __iter__(...)
  88.  |      x.__iter__() <==> iter(x)
  89.  |
  90.  |  __le__(...)
  91.  |      x.__le__(y) <==> x<=y
  92.  |
  93.  |  __len__(...)
  94.  |      x.__len__() <==> len(x)
  95.  |
  96.  |  __lt__(...)
  97.  |      x.__lt__(y) <==> x<y
  98.  |
  99.  |  __mul__(...)
  100.  |      x.__mul__(n) <==> x*n
  101.  |
  102.  |  __ne__(...)
  103.  |      x.__ne__(y) <==> x!=y
  104.  |
  105.  |  __rmul__(...)
  106.  |      x.__rmul__(n) <==> n*x
  107.  |
  108.  |  __sizeof__(...)
  109.  |      T.__sizeof__() -- size of T in memory, in bytes
  110.  |
  111.  |  count(...)
  112.  |      T.count(value) -> integer -- return number of occurrences of value
  113.  |
  114.  |  index(...)
  115.  |      T.index(value, [start, [stop]]) -> integer -- return first index of value.
  116.  |      Raises ValueError if the value is not present.
  117.  
  118. Mytuple

Mytuple

5、双向队列(deque)---任意从两边插入和取走元素

一个线程安全的双向队列：类似于加一个锁，防止冲突。

  1. class deque(object):
  2.     """
  3.     deque([iterable[, maxlen]]) --> deque object
  4.  
  5.     Build an ordered collection with optimized access from its endpoints.
  6.     """
  7.     def append(self, *args, **kwargs): # real signature unknown
  8.         """ Add an element to the right side of the deque. """
  9.         pass
  10.  
  11.     def appendleft(self, *args, **kwargs): # real signature unknown
  12.         """ Add an element to the left side of the deque. """
  13.         pass
  14.  
  15.     def clear(self, *args, **kwargs): # real signature unknown
  16.         """ Remove all elements from the deque. """
  17.         pass
  18.  
  19.     def count(self, value): # real signature unknown; restored from __doc__
  20.         """ D.count(value) -> integer -- return number of occurrences of value """
  21.         return 0
  22.  
  23.     def extend(self, *args, **kwargs): # real signature unknown
  24.         """ Extend the right side of the deque with elements from the iterable """
  25.         pass
  26.  
  27.     def extendleft(self, *args, **kwargs): # real signature unknown
  28.         """ Extend the left side of the deque with elements from the iterable """
  29.         pass
  30.  
  31.     def pop(self, *args, **kwargs): # real signature unknown
  32.         """ Remove and return the rightmost element. """
  33.         pass   ###在队列中取最右边的值，并在队列中删除这个值
  34.  
  35.     def popleft(self, *args, **kwargs): # real signature unknown
  36.         """ Remove and return the leftmost element. """
  37.         pass
  38.  
  39.     def remove(self, value): # real signature unknown; restored from __doc__
  40.         """ D.remove(value) -- remove first occurrence of value. """
  41.         pass
  42.  
  43.     def reverse(self): # real signature unknown; restored from __doc__
  44.         """ D.reverse() -- reverse *IN PLACE* """
  45.         pass
  46.  
  47.     def rotate(self, *args, **kwargs): # real signature unknown
  48.         """ Rotate the deque n steps to the right (default n=1).  If n is negative, rotates left. """
  49.         pass
  50.  
  51.     def __copy__(self, *args, **kwargs): # real signature unknown
  52.         """ Return a shallow copy of a deque. """
  53.         pass
  54.  
  55.     def __delitem__(self, y): # real signature unknown; restored from __doc__
  56.         """ x.__delitem__(y) <==> del x[y] """
  57.         pass
  58.  
  59.     def __eq__(self, y): # real signature unknown; restored from __doc__
  60.         """ x.__eq__(y) <==> x==y """
  61.         pass
  62.  
  63.     def __getattribute__(self, name): # real signature unknown; restored from __doc__
  64.         """ x.__getattribute__('name') <==> x.name """
  65.         pass
  66.  
  67.     def __getitem__(self, y): # real signature unknown; restored from __doc__
  68.         """ x.__getitem__(y) <==> x[y] """
  69.         pass
  70.  
  71.     def __ge__(self, y): # real signature unknown; restored from __doc__
  72.         """ x.__ge__(y) <==> x>=y """
  73.         pass
  74.  
  75.     def __gt__(self, y): # real signature unknown; restored from __doc__
  76.         """ x.__gt__(y) <==> x>y """
  77.         pass
  78.  
  79.     def __iadd__(self, y): # real signature unknown; restored from __doc__
  80.         """ x.__iadd__(y) <==> x+=y """
  81.         pass
  82.  
  83.     def __init__(self, iterable=(), maxlen=None): # known case of _collections.deque.__init__
  84.         """
  85.         deque([iterable[, maxlen]]) --> deque object
  86.  
  87.         Build an ordered collection with optimized access from its endpoints.
  88.         # (copied from class doc)
  89.         """
  90.         pass
  91.  
  92.     def __iter__(self): # real signature unknown; restored from __doc__
  93.         """ x.__iter__() <==> iter(x) """
  94.         pass
  95.  
  96.     def __len__(self): # real signature unknown; restored from __doc__
  97.         """ x.__len__() <==> len(x) """
  98.         pass
  99.  
  100.     def __le__(self, y): # real signature unknown; restored from __doc__
  101.         """ x.__le__(y) <==> x<=y """
  102.         pass
  103.  
  104.     def __lt__(self, y): # real signature unknown; restored from __doc__
  105.         """ x.__lt__(y) <==> x<y """
  106.         pass
  107.  
  108.     @staticmethod # known case of __new__
  109.     def __new__(S, *more): # real signature unknown; restored from __doc__
  110.         """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
  111.         pass
  112.  
  113.     def __ne__(self, y): # real signature unknown; restored from __doc__
  114.         """ x.__ne__(y) <==> x!=y """
  115.         pass
  116.  
  117.     def __reduce__(self, *args, **kwargs): # real signature unknown
  118.         """ Return state information for pickling. """
  119.         pass
  120.  
  121.     def __repr__(self): # real signature unknown; restored from __doc__
  122.         """ x.__repr__() <==> repr(x) """
  123.         pass
  124.  
  125.     def __reversed__(self): # real signature unknown; restored from __doc__
  126.         """ D.__reversed__() -- return a reverse iterator over the deque """
  127.         pass
  128.  
  129.     def __setitem__(self, i, y): # real signature unknown; restored from __doc__
  130.         """ x.__setitem__(i, y) <==> x[i]=y """
  131.         pass
  132.  
  133.     def __sizeof__(self): # real signature unknown; restored from __doc__
  134.         """ D.__sizeof__() -- size of D in memory, in bytes """
  135.         pass
  136.  
  137.     maxlen = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
  138.     """maximum size of a deque or None if unbounded"""
  139.  
  140.     __hash__ = None

deque

注：既然有双向队列，也有单项队列（先进先出 FIFO ）

单项队列，在queue这个类中

引用： import queue

创建 q = Queue.Queue(10)   #队列长度10

存入： q.put(1)

提取：q.get()

  1. class Queue:
  2.     """Create a queue object with a given maximum size.
  3.  
  4.     If maxsize is <= 0, the queue size is infinite.
  5.     """
  6.     def __init__(self, maxsize=0):
  7.         self.maxsize = maxsize
  8.         self._init(maxsize)
  9.         # mutex must be held whenever the queue is mutating.  All methods
  10.         # that acquire mutex must release it before returning.  mutex
  11.         # is shared between the three conditions, so acquiring and
  12.         # releasing the conditions also acquires and releases mutex.
  13.         self.mutex = _threading.Lock()
  14.         # Notify not_empty whenever an item is added to the queue; a
  15.         # thread waiting to get is notified then.
  16.         self.not_empty = _threading.Condition(self.mutex)
  17.         # Notify not_full whenever an item is removed from the queue;
  18.         # a thread waiting to put is notified then.
  19.         self.not_full = _threading.Condition(self.mutex)
  20.         # Notify all_tasks_done whenever the number of unfinished tasks
  21.         # drops to zero; thread waiting to join() is notified to resume
  22.         self.all_tasks_done = _threading.Condition(self.mutex)
  23.         self.unfinished_tasks = 0
  24.  
  25.     def task_done(self):
  26.         """Indicate that a formerly enqueued task is complete.
  27.  
  28.         Used by Queue consumer threads.  For each get() used to fetch a task,
  29.         a subsequent call to task_done() tells the queue that the processing
  30.         on the task is complete.
  31.  
  32.         If a join() is currently blocking, it will resume when all items
  33.         have been processed (meaning that a task_done() call was received
  34.         for every item that had been put() into the queue).
  35.  
  36.         Raises a ValueError if called more times than there were items
  37.         placed in the queue.
  38.         """
  39.         self.all_tasks_done.acquire()
  40.         try:
  41.             unfinished = self.unfinished_tasks - 1
  42.             if unfinished <= 0:
  43.                 if unfinished < 0:
  44.                     raise ValueError('task_done() called too many times')
  45.                 self.all_tasks_done.notify_all()
  46.             self.unfinished_tasks = unfinished
  47.         finally:
  48.             self.all_tasks_done.release()
  49.  
  50.     def join(self):
  51.         """Blocks until all items in the Queue have been gotten and processed.
  52.  
  53.         The count of unfinished tasks goes up whenever an item is added to the
  54.         queue. The count goes down whenever a consumer thread calls task_done()
  55.         to indicate the item was retrieved and all work on it is complete.
  56.  
  57.         When the count of unfinished tasks drops to zero, join() unblocks.
  58.         """
  59.         self.all_tasks_done.acquire()
  60.         try:
  61.             while self.unfinished_tasks:
  62.                 self.all_tasks_done.wait()
  63.         finally:
  64.             self.all_tasks_done.release()
  65.  
  66.     def qsize(self):
  67.         """Return the approximate size of the queue (not reliable!)."""
  68.         self.mutex.acquire()
  69.         n = self._qsize()
  70.         self.mutex.release()
  71.         return n
  72.  
  73.     def empty(self):
  74.         """Return True if the queue is empty, False otherwise (not reliable!)."""
  75.         self.mutex.acquire()
  76.         n = not self._qsize()
  77.         self.mutex.release()
  78.         return n
  79.  
  80.     def full(self):
  81.         """Return True if the queue is full, False otherwise (not reliable!)."""
  82.         self.mutex.acquire()
  83.         n = 0 < self.maxsize == self._qsize()
  84.         self.mutex.release()
  85.         return n
  86.  
  87.     def put(self, item, block=True, timeout=None):
  88.         """Put an item into the queue.
  89.  
  90.         If optional args 'block' is true and 'timeout' is None (the default),
  91.         block if necessary until a free slot is available. If 'timeout' is
  92.         a non-negative number, it blocks at most 'timeout' seconds and raises
  93.         the Full exception if no free slot was available within that time.
  94.         Otherwise ('block' is false), put an item on the queue if a free slot
  95.         is immediately available, else raise the Full exception ('timeout'
  96.         is ignored in that case).
  97.         """
  98.         self.not_full.acquire()
  99.         try:
  100.             if self.maxsize > 0:
  101.                 if not block:
  102.                     if self._qsize() == self.maxsize:
  103.                         raise Full
  104.                 elif timeout is None:
  105.                     while self._qsize() == self.maxsize:
  106.                         self.not_full.wait()
  107.                 elif timeout < 0:
  108.                     raise ValueError("'timeout' must be a non-negative number")
  109.                 else:
  110.                     endtime = _time() + timeout
  111.                     while self._qsize() == self.maxsize:
  112.                         remaining = endtime - _time()
  113.                         if remaining <= 0.0:
  114.                             raise Full
  115.                         self.not_full.wait(remaining)
  116.             self._put(item)
  117.             self.unfinished_tasks += 1
  118.             self.not_empty.notify()
  119.         finally:
  120.             self.not_full.release()
  121.  
  122.     def put_nowait(self, item):
  123.         """Put an item into the queue without blocking.
  124.  
  125.         Only enqueue the item if a free slot is immediately available.
  126.         Otherwise raise the Full exception.
  127.         """
  128.         return self.put(item, False)
  129.  
  130.     def get(self, block=True, timeout=None):
  131.         """Remove and return an item from the queue.
  132.  
  133.         If optional args 'block' is true and 'timeout' is None (the default),
  134.         block if necessary until an item is available. If 'timeout' is
  135.         a non-negative number, it blocks at most 'timeout' seconds and raises
  136.         the Empty exception if no item was available within that time.
  137.         Otherwise ('block' is false), return an item if one is immediately
  138.         available, else raise the Empty exception ('timeout' is ignored
  139.         in that case).
  140.         """
  141.         self.not_empty.acquire()
  142.         try:
  143.             if not block:
  144.                 if not self._qsize():
  145.                     raise Empty
  146.             elif timeout is None:
  147.                 while not self._qsize():
  148.                     self.not_empty.wait()
  149.             elif timeout < 0:
  150.                 raise ValueError("'timeout' must be a non-negative number")
  151.             else:
  152.                 endtime = _time() + timeout
  153.                 while not self._qsize():
  154.                     remaining = endtime - _time()
  155.                     if remaining <= 0.0:
  156.                         raise Empty
  157.                     self.not_empty.wait(remaining)
  158.             item = self._get()
  159.             self.not_full.notify()
  160.             return item
  161.         finally:
  162.             self.not_empty.release()
  163.  
  164.     def get_nowait(self):
  165.         """Remove and return an item from the queue without blocking.
  166.  
  167.         Only get an item if one is immediately available. Otherwise
  168.         raise the Empty exception.
  169.         """
  170.         return self.get(False)
  171.  
  172.     # Override these methods to implement other queue organizations
  173.     # (e.g. stack or priority queue).
  174.     # These will only be called with appropriate locks held
  175.  
  176.     # Initialize the queue representation
  177.     def _init(self, maxsize):
  178.         self.queue = deque()
  179.  
  180.     def _qsize(self, len=len):
  181.         return len(self.queue)
  182.  
  183.     # Put a new item in the queue
  184.     def _put(self, item):
  185.         self.queue.append(item)
  186.  
  187.     # Get an item from the queue
  188.     def _get(self):
  189.         return self.queue.popleft()

Queue.Queue

队列：先进先出（fifo）

栈：像弹夹一样，子弹先进去后出来。

四.标准数据类型特性总结

按存值个数区分

标量／原子类型 数字，字符串
容器类型 列表，元组，字典

按可变不可变区分

可变 列表，字典
不可变 数字，字符串，元组

按访问顺序区分

直接访问 数字
顺序访问（序列类型） 字符串，列表，元组
key值访问（映射类型）

字典

迭代器和生成器

一、迭代器

对于Python 列表的 for 循环，他的内部原理：查看下一个元素是否存在，如果存在，则取出，如果不存在，则报异常 StopIteration。（python内部对异常已处理）

  1. class listiterator(object)
  2.  |  Methods defined here:
  3.  |
  4.  |  __getattribute__(...)
  5.  |      x.__getattribute__('name') <==> x.name
  6.  |
  7.  |  __iter__(...)
  8.  |      x.__iter__() <==> iter(x)
  9.  |
  10.  |  __length_hint__(...)
  11.  |      Private method returning an estimate of len(list(it)).
  12.  |
  13.  |  next(...)####必须要有这个方法，才能循环取值
  14.  |      x.next() -> the next value, or raise StopIteration

二、生成器

类似于数据库中的线程池一样，我先不提供链接，等有访问过来，我在生产连接，也就是什么时候用我就什么时候产生。

生成器内部基于yield创建，即：对于生成器只有使用时才创建，从而不避免内存浪费

range不是生成器 和 xrange 是生成器

readlines不是生成器 和 xreadlines 是生成器

  1. >>> print range(10)
  2. [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  3. >>> print xrange(10)
  4. xrange(10)

通过range循环一个列表---下标式循环

  1. li = [11,22,33,44,55,66]
  2. for i in range(6):
  3.      print li[i]
  4. ........
  5. ......
  6. 11
  7. 22
  8. 33
  9. 44
  10. 55
  11. 66

下标循环 len(li)

  1. 练习：<br>有如下列表：
  2.     [13, 22, 6, 99, 11]
  3. 请按照一下规则计算：
  4. 13 和 22 比较，将大的值放在右侧，即：[13, 22, 6, 99, 11]
  5. 22 和 6 比较，将大的值放在右侧，即：[13, 6, 22, 99, 11]
  6. 22 和 99 比较，将大的值放在右侧，即：[13, 6, 22, 99, 11]
  7. 99 和 42 比较，将大的值放在右侧，即：[13, 6, 22, 11, 99,]
  8. 13 和 6 比较，将大的值放在右侧，即：[6, 13, 22, 11, 99,]
  1. 这其实就是一个冒泡算法
    li = [13, 22, 6, 99, 11]
  2. for m in range(len(li)-1):
  3.     for n in range(m+1, len(li)):
  4.         if li[m]> li[n]:
  5.             temp = li[n]
  6.             li[n] = li[m]
  7.             li[m] = temp
  8. print li

深浅拷贝

为什么要拷贝？

当进行修改时，想要保留原来的数据和修改后的数据

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

 在修改数据时：

    数字字符串：在内存中新建一份数据
         集合：修改内存中的同一份数据
对于集合，如何保留其修改前和修改后的数据？
在内存中拷贝一份
对于集合，如何拷贝其n层元素同时拷贝？
深拷贝

python第二天基础1-1的更多相关文章

  1. selenium webdriver (python) 第二版

    前言 对于大多软件测试人员来讲缺乏编程经验(指项目开发经验,大学的C 语言算很基础的编程知识)一直是难以逾越的鸿沟,并不是说测试比开发人员智商低,是国内的大多测试岗位是功能测试为主,在工作时间中,我们 ...

  2. Python学习笔记基础篇——总览

    Python初识与简介[开篇] Python学习笔记——基础篇[第一周]——变量与赋值.用户交互.条件判断.循环控制.数据类型.文本操作 Python学习笔记——基础篇[第二周]——解释器.字符串.列 ...

  3. Day1 Python 介绍及基础

    ******************本文目录******************一.Pyhon基本介绍 1.Why Python? 2. Python 是一门什么样的语言? 3.Python的优缺点: ...

  4. python网络编程基础(线程与进程、并行与并发、同步与异步、阻塞与非阻塞、CPU密集型与IO密集型)

    python网络编程基础(线程与进程.并行与并发.同步与异步.阻塞与非阻塞.CPU密集型与IO密集型) 目录 线程与进程 并行与并发 同步与异步 阻塞与非阻塞 CPU密集型与IO密集型 线程与进程 进 ...

  5. 知了课堂 Python Flask零基础 笔记整理

    目录 起步 安装Python2.7: Python虚拟环境介绍与安装: pip安装flask: 认识url: URL详解 web服务器和应用服务器以及web应用框架: Flask 第一个flask程序 ...

  6. 孤荷凌寒自学python第二十九天python的datetime.time模块

     孤荷凌寒自学python第二十九天python的datetime.time模块 (完整学习过程屏幕记录视频地址在文末,手写笔记在文末) datetime.time模块是专门用来表示纯时间部分的类. ...

  7. 孤荷凌寒自学python第二十八天python的datetime.date模块

     孤荷凌寒自学python第二十八天python的datetime.date模块 (完整学习过程屏幕记录视频地址在文末,手写笔记在文末) 一.toordinal() 此方法将访问从公元1年1月1日至当 ...

  8. 孤荷凌寒自学python第二十七天python的datetime模块及初识datetime.date模块

    孤荷凌寒自学python第二十七天python的datetime模块及初识datetime.date模块 (完整学习过程屏幕记录视频地址在文末,手写笔记在文末) 一.datetime模块 dateti ...

  9. 孤荷凌寒自学python第二十六天python的time模块的相关方法

    孤荷凌寒自学python第二十六天python的time模块的相关方法 (完整学习过程屏幕记录视频地址在文末,手写笔记在文末) 要使用time模块的相关方法,必须在文件顶端引用: import tim ...

随机推荐

  1. splinter(python操作浏览器魔魁啊)

    from splinter import Browser def main(): browser = Browser() browser.visit('http://google.com') brow ...

  2. 在线api地址

    J2SE1.7英文api地址: http://download.oracle.com/javase/7/docs/api/J2SE1.6英文api地址:  http://download.oracle ...

  3. Makefile <网络转载>

    陈皓 (CSDN)概述——什 么是makefile?或许很多Winodws的程序员都不知道这个东西,因为那些Windows的IDE都为你做了这个工作,但我觉得要作一个好的和 professional的 ...

  4. 打造一个有感觉的vim(四)

    今天要介绍的VIM插件的名字叫做surround,这个插件的主要作用是将一个VIM的tex-objects(文本对象)添加或者取消包裹(单引号,双引号,XML标签等等)下载地址如下:https://g ...

  5. IOS学习之路--OC的基础知识

    1.项目经验 2.基础问题 3.指南认识 4.解决思路 ios开发三大块: 1.Oc基础 2.CocoaTouch框架 3.Xcode使用 -------------------- CocoaTouc ...

  6. c++多态

    #include <cstdio> using namespace std; class Base { public: virtual void A() { puts("Base ...

  7. 更新lispbox中的ccl和slime版本

    首先C-x C-f然后输入~,找到.emacs文件,根据slime官方文档说明的添加如下代码到文件末尾,重启一下emacs,slime就编译好了,然后这段代码就可以删除.否则每次启动emacs就算不用 ...

  8. java规范（二）

    常量命名 不允许使用任何魔法值(未定义的常量)直接出现在代码中 反例: String key="Id#taobao_"+tradeId: cache.put(key, value) ...

  9. List<Object> to JSONArray一

    package com.beijxing.TestMain; import java.util.ArrayList; import java.util.List; import com.beijxin ...

  10. 关于$.fn.*的使用

    这个案例是我封装了一个树形插件,也是别人写好的,但是对于我来说调用起来不是很方便,就对他的初始化方法又进行了一次封装,总的来说显得比较麻烦,不过我是新手嘛 DEMO 封装一个jcTree的方法$.fn ...