Python学习笔记——基础篇2【第三周】——计数器、有序字典、元组、单(双)向队列、深浅拷贝、函数、装饰器

目录

1、Python计数器Counter

2、Python有序字典OrderredDict

3、Python默认字典default

4、python可命名元组namedtuple

5、Python双向队列deque

6、Python单向队列deque

7、Python深浅拷贝原理

8、Python深浅拷贝应用

9、python函数的基本定义（open、lambda、递归、装饰器）

collections系列

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMwAAABmCAIAAAAIx+ktAAALqElEQVR4nO2d62/b1hnG+XesQ7EPS6NkW40hu1RYthVYhjpYsCSImiVaO2xuISBpO6zA4BndGjVdmiumbLmp3nyRaDmyLVuWZJGyfLfl3GzLkU3ZsmRLUWyjbbC2Kxosy6WO94ESRVIkJYvXQ58XzweLos57bP7ynsMjPjnI+vqqLpWy7UAQBDFaU+srqndmkwtRvQdQuheEDEp2QcigZBeEDEp2QcigZBeEDEp2KQTZ3Wl3ZqKFpWz06tpXd58+hUsMOpdCkI02Hh28UsPS0JWaGHZa9T8BlNxSE7LBKzWj9a9Hfe/zfUqqIodbCquy9J8lbxyKUypDNnilZtj+2oTjyISTrSF7jVTZ5YQsYjNCyEpICLJwGPP7fX5/N5d8fX14+WkEIOPTaONRqX5JSSFDLQhiwSFSG5AQZF9+udjFH/fvL5WfhoRsuN6SmXRlJlsE5Rqut0DI9KQSw2VPj9/r9bLw8nq9GBbYUBoSsjK5KXUyakHyQcclZTUihaBzIAQZ/VNs+NiJcl+6U8dskRINMroRsRkRxILSGjHjhXSFXPojuARka2urPp+PBVl3d/fa2vKG0kgGGW6mri55RW3kJcHNjMuTshppp/FChpsRZIcttVKAgPEWV6KiSlbUIF83IjYjQmsTtSAIYkGpnwu9telthld64j8+PkAvZl6v99q1wY2mkQiyXDEoOs64SKRSth1UqeCBLGIzMstGymrMMceXaFUQMuFusG8RCm+lrEY9FjBKpSF79ChLL2OdnZ1PnmysjK1LBRnfxeA8TqtS3JAxxzXGACd01fkhK9ENNrhs/vT79FtZSxhLS1GymHm93qWlaAVpNAsZN0lKQ1ZIqkvUyoJsbW2ZgqyyNBINlxzjEd/xMoZLvtYEEq2KHS4FICPFmtXpQuUuxt69GwuFQsvLM5Wl2RBkY41v8J1M3poVrgFuJn8uPk5/yTfxZ38qZTXmIeBLVEySUIOMbvBDlrJaqAYZ9yI60QZW/GdmrlWchoRsyF4zWbSyz9Kk88iQXXAxFjfTJlAo93HmdRJYwmCsSrDGqVKJuJcweLshVMlwC+dHdCL1v1ZSYMUfSl0pBFl22l1qoZ+t7LRb9b8OlCSCDy1CyS4IGZTsgpBByS4IGZTsQuIwYMgcEDIYsgeQkIVCoQb+aG1tvX37ttp9hFEIHULW1NTU3NwMOdNOAAyZ0+kMM6O3t7epqQnDsPb2dqfTGY1G1e4pjHgcaMjcbnfxWw6HA8fxWCzmcrkcDsfs7Kzy3YPBCr1B1tDQ0N7e7vF4GhoaUBSdmZkRn85uQpCqWowgJDltE4auICNoF9jlcqEoGovFROYiCKy2qjQ9ZZ62OUNXkNGjNxRqa2tTa7gkCLsJQUx2CFw8rhvIQqMT+99vP3iqc+/pnr1ngntOdB/7p29woF+S4bKCgJDRQyeQvW0Pvlkf7r8efeVS+JXLfb++FN53FrsRGZGkklGTrdyYaLJjtVX5ZwxN9vz4SJ1GexdBEKSqFhObmt6iyc5KV9xPMb+sHKETyC55R/7wr/Dv60Ovfxg+dLH3VxdCB/4enp64JUk6NmR5bshyxXnVpapkdlOeU7JZMr/JHo/HiXw+8kwt107gIbM2Bg990Pba+e437PibH4ZevRDcfx7bb8N+aQvPT2EfD2xbwp6fn+oUk44NGa1a5CobQcRlhKxQLOkZyc5QZTKfEEImUVCQBcemdh1r2/2Bd/fJnH5xyrfnjH/PGf/uM/hCNLDYsy2DG5L+HWLSFQ+X1FtKQMYcAekFLEdZEXBaC7AhC4xOvXSiq/qkt/qkt/qUb/fZ4EunSWFHrwwmx/68FNyaxg2Jrm+LSadZyAiKsvwPItPJFGBD5h+Z/Nl7HbuOe3Yd9/zmvP9qoMPTfb6j29btO5foNWWx59KYIY1vm+vYLiadypAxB0FmlhxcFGwi08kUYEPmG5746V/cL77bVv1eW2Ls+ErouSy2hVQG25rGDCRkxNWtYtJVDFkF4xfHzQTtZf5NZmGrMpmqNDrlJwNsyIKjkzvrXD95x/3WBV960JSjKrg1gxWUxbfGO41i0lUAWTwPxEaXMFgpyDbtjBUMgnk+mUajU34yAIYMRdHBoaHfnW7bWddWe7Er2bsvjRkWA1sSXYZE2LTQa0qE9s4Hfp4IvRwnQH3sp+TSVzH3GgyAIXM4HIFAYGxkaOJ6ZGri1nxoXxozpIOGlH/7nNe44P8+0fljtXsqNkpDpu0pPxlAQtbX19fc3NzY2BgKhfr7+yORyM2bNxPhgxnckMYMiY5vEB0/WLh2dsb5bHx2Su3OioqSkJH3F0p2qYIAEjLOmIsNzndWEejXZ53P3G742gz6zbmBt+MEx9dKBDVdosfzpurig1LcsolJJwBZ4csHDc/GyNAPZDA0GxAyGLIHNPdCyS4IGZTsAhKyaHRYwBLn8bgfPEir3kkoSjqErKmpCUUdkDPtCGDInE5nLDY2PT1K00hzc9PNmwM9PV2trS337y+q3lWodaAhc7s5/ivGlhbnxMTQw4d3PB53S4vzyZO7qvcWSm+QsXyXjx5lVe/t+qbfE1NXkNE3YSV9lw8f3lG9t3BPTF1BRtfU5FAg0AmHSy1IJ5AlV+ZfPukxn+uifJfn3FiciDx+rInhcpNLJ5Adc4X/6BzI3Eu9ermP8l2uZiclqWS4hblPJXvvS/rWNfmtuJjHWVvT8e96WWn3jNYUfT+y/JYUxXNBVWaHOoGs8/qtd1oH61r6jjT2U77LLz6dlyQduV1Ibqsb6lrStqpECpvlmDl3z2RDxr3rpajuFdAhe0i2yd5ER51th4GH7KJ/4Ld/87xV31OL9v2ppb/GjlO+ywefjn48sC0TqvrfZ71iryLtXz9u4atSzA/iZq4dxPh3vRTTPWYLrF3DjIyNm8QWzgoENmQLHyUFfJeP/zO8FNyewQ1p7Hti0pHDJeMlixI2guwRs3i4pFqTBjKOXaFyBYzWPSZwCgpsyOZWk3y+yzrX2OeJv5K+y5TvO2LSlQ0ZuY94nhiBSqYgZIXtiAv7Eit9vcCGLL6yQPkuLfbg4K2egZHL/SOXRscuLEcOUb7Lha5viUlXLmTMCRDPhpvyQMZsgdnDXAFjVVwlBTZkxHKC9F3uOdHxefIsn+9yvt0gJt1GIMtPq3P3BzJBxrhdyA3QVJvF27LiZsRothhV26sVbMiSHyVJ3+W7KH7v1iE+3+Viz04x6cqfkzGWOWQcLhmNkI3jtI07i2BijuOKC2DIUBRNLNw4+o/OnXVtJ1t6VsZMpO8y2b1t5drh1fHDy2MH7vRXr0QOr32VUb3P8qmMpS822QoLYMgcDkck0ruYvPHJ6vRn/567M3KA9F0uBrYvBn+Uxn+4GHxR9a4qoNKQqTflJwUkZDMzERR1NDc3TU0NE8R4Njt97158edxM+S6Tvhe+SF+cRZ9de6L/R8pKQsYa7pUXkJBx6vF/J1O+75K+y1jjM4Rryye369afLnOdjDIWs8h4wXyw+KByt2OVd0kAstwcUe0HQPQDGZRmBSGDkl0QMijZBSGDkl1AQgZ9l2BJh5BB36XWBDBk0HcJigCGDPouQZHeIBPvu9zkHkk5pCvIJPFdQsgkl64go6ti3yWETHLpBDIJfZcQMsmlE8gq8l0KeiS5bIx50b7M5sJR+0ZIhaUTyCrwXQp5JOn0pKxGhOUqo71MWW1FzzRr3wipsICHTBrfJetRaUEbY8lns7RvhFRYYEMm0ndZyiOZP5MqPymrsYzCo30jpMICGzIRvstyPJL5kyWFTAtGSIUFNmSV+y6FPZK8NkbUgpSuPdo3QiossCGr3Hcp7JFEeG2M5APNhWKGmy34CnBGSIUFNmRifJfCHkkhGyNuLkzkciQBZoRUWABDplnfpfaNkAoLYMg067vUvhFSYQEJmcZ9l9o3QiosICHj1EZ8l/JK+0ZIhaUfyKA0KwgZlOyCkEHJLggZlOyCkEHJrv8DMSNdhcLoj3oAAAAASUVORK5CYII=" alt="" />

1、Python计数器Counter

1、计数器（counter）

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

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

1 2 3

c = Counter('abcdeabcdabcaba') print c 输出：Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})

 ########################################################################
 ###  Counter
 ########################################################################

 class Counter(dict):
     '''Dict subclass for counting hashable items.  Sometimes called a bag
     or multiset.  Elements are stored as dictionary keys and their counts
     are stored as dictionary values.

     >>> c = Counter('abcdeabcdabcaba')  # count elements from a string

     >>> c.most_common()                # three most common elements
     [('a', ), ('b', ), ('c', )]
     >>> sorted(c)                       # list all unique elements
     ['a', 'b', 'c', 'd', 'e']
     >>> ''.join(sorted(c.elements()))   # list elements with repetitions
     'aaaaabbbbcccdde'
     >>> sum(c.values())                 # total of all counts

     >>> c['a']                          # count of letter 'a'
     >>> for elem in 'shazam':           # update counts from an iterable
     ...     c[elem] +=                 # by adding  to each element's count
     >>> c['a']                          # now there are seven 'a'
     >>> del c['b']                      # remove all 'b'
     >>> c['b']                          # now there are zero 'b'

     >>> d = Counter('simsalabim')       # make another counter
     >>> c.update(d)                     # add in the second counter
     >>> c['a']                          # now there are nine 'a'

     >>> c.clear()                       # empty the counter
     >>> c
     Counter()

     Note:  If a count is set to zero or reduced to zero, it will remain
     in the counter until the entry is deleted or the counter is cleared:

     >>> c = Counter('aaabbc')
     >>> c['b'] -=                      # reduce the count of 'b' by two
     >>> c.most_common()                 # 'b' is still in, but its count is zero
     [('a', ), ('c', ), ('b', )]

     '''
     # References:
     #   http://en.wikipedia.org/wiki/Multiset
     #   http://www.gnu.org/software/smalltalk/manual-base/html_node/Bag.html
     #   http://www.demo2s.com/Tutorial/Cpp/0380__set-multiset/Catalog0380__set-multiset.htm
     #   http://code.activestate.com/recipes/259174/
     #   Knuth, TAOCP Vol. II section 4.6.

     def __init__(self, iterable=None, **kwds):
         '''Create a new, empty Counter object.  And if given, count elements
         from an input iterable.  Or, initialize the count from another mapping
         of elements to their counts.

         >>> c = Counter()                           # a new, empty counter
         >>> c = Counter('gallahad')                 # a new counter from an iterable
         >>> c = Counter({'a': , 'b': })           # a new counter from a mapping
         >>> c = Counter(a=, b=)                   # a new counter from keyword args

         '''
         super(Counter, self).__init__()
         self.update(iterable, **kwds)

     def __missing__(self, key):
         """ 对于不存在的元素，返回计数器为0 """
         'The count of elements not in the Counter is zero.'
         # Needed so that self[missing_item] does not raise KeyError
         return 

     def most_common(self, n=None):
         """ 数量大于等n的所有元素和计数器 """
         '''List the n most common elements and their counts from the most
         common to the least.  If n is None, then list all element counts.

         >>> Counter('abcdeabcdabcaba').most_common()
         [('a', ), ('b', ), ('c', )]

         '''
         # Emulate Bag.sortedByCount from Smalltalk
         if n is None:
             return sorted(self.iteritems(), key=_itemgetter(), reverse=True)
         return _heapq.nlargest(n, self.iteritems(), key=_itemgetter())

     def elements(self):
         """ 计数器中的所有元素，注：此处非所有元素集合，而是包含所有元素集合的迭代器 """
         '''Iterator over elements repeating each as many times as its count.

         >>> c = Counter('ABCABC')
         >>> sorted(c.elements())
         ['A', 'A', 'B', 'B', 'C', 'C']

         # Knuth's example for prime factors of 1836:  2**2 * 3**3 * 17**1
         >>> prime_factors = Counter({: , : , : })
         >>> product =
         >>> for factor in prime_factors.elements():     # loop over factors
         ...     product *= factor                       # and multiply them
         >>> product

         Note, if an element's count has been set to zero or is a negative
         number, elements() will ignore it.

         '''
         # Emulate Bag.do from Smalltalk and Multiset.begin from C++.
         return _chain.from_iterable(_starmap(_repeat, self.iteritems()))

     # Override dict methods where necessary

     @classmethod
     def fromkeys(cls, iterable, v=None):
         # There is no equivalent method for counters because setting v=
         # means that no element can have a count greater than one.
         raise NotImplementedError(
             'Counter.fromkeys() is undefined.  Use Counter(iterable) instead.')

     def update(self, iterable=None, **kwds):
         """ 更新计数器，其实就是增加；如果原来没有，则新建，如果有则加一 """
         '''Like dict.update() but add counts instead of replacing them.

         Source can be an iterable, a dictionary, or another Counter instance.

         >>> c = Counter('which')
         >>> c.update('witch')           # add elements from another iterable
         >>> d = Counter('watch')
         >>> c.update(d)                 # add elements from another counter
         >>> c['h']                      # four 'h' in which, witch, and watch

         '''
         # The regular dict.update() operation makes no sense here because the
         # replace behavior results in the some of original untouched counts
         # being mixed-in with all of the other counts for a mismash that
         # doesn't have a straight-forward interpretation in most counting
         # contexts.  Instead, we implement straight-addition.  Both the inputs
         # and outputs are allowed to contain zero and negative counts.

         if iterable is not None:
             if isinstance(iterable, Mapping):
                 if self:
                     self_get = self.get
                     for elem, count in iterable.iteritems():
                         self[elem] = self_get(elem, ) + count
                 else:
                     super(Counter, self).update(iterable) # fast path when counter is empty
             else:
                 self_get = self.get
                 for elem in iterable:
                     self[elem] = self_get(elem, ) +
         if kwds:
             self.update(kwds)

     def subtract(self, iterable=None, **kwds):
         """ 相减，原来的计数器中的每一个元素的数量减去后添加的元素的数量 """
         '''Like dict.update() but subtracts counts instead of replacing them.
         Counts can be reduced below zero.  Both the inputs and outputs are
         allowed to contain zero and negative counts.

         Source can be an iterable, a dictionary, or another Counter instance.

         >>> c = Counter('which')
         >>> c.subtract('witch')             # subtract elements from another iterable
         >>> c.subtract(Counter('watch'))    # subtract elements from another counter
         >>> c['h']                          #  in which, minus  in witch, minus  in watch
         >>> c['w']                          #  in which, minus  in witch, minus  in watch
         -

         '''
         if iterable is not None:
             self_get = self.get
             if isinstance(iterable, Mapping):
                 for elem, count in iterable.items():
                     self[elem] = self_get(elem, ) - count
             else:
                 for elem in iterable:
                     self[elem] = self_get(elem, ) -
         if kwds:
             self.subtract(kwds)

     def copy(self):
         """ 拷贝 """
         'Return a shallow copy.'
         return self.__class__(self)

     def __reduce__(self):
         """ 返回一个元组（类型，元组） """
         return self.__class__, (dict(self),)

     def __delitem__(self, elem):
         """ 删除元素 """
         'Like dict.__delitem__() but does not raise KeyError for missing values.'
         if elem in self:
             super(Counter, self).__delitem__(elem)

     def __repr__(self):
         if not self:
             return '%s()' % self.__class__.__name__
         items = ', '.join(map('%r: %r'.__mod__, self.most_common()))
         return '%s({%s})' % (self.__class__.__name__, items)

     # Multiset-style mathematical operations discussed in:
     #       Knuth TAOCP Volume II section 4.6. exercise
     #       and at http://en.wikipedia.org/wiki/Multiset
     #
     # Outputs guaranteed to only include positive counts.
     #
     # To strip negative and zero counts, add-in an empty counter:
     #       c += Counter()

     def __add__(self, other):
         '''Add counts from two counters.

         >>> Counter('abbb') + Counter('bcc')
         Counter({'b': , 'c': , 'a': })

         '''
         if not isinstance(other, Counter):
             return NotImplemented
         result = Counter()
         for elem, count in self.items():
             newcount = count + other[elem]
             if newcount > :
                 result[elem] = newcount
         for elem, count in other.items():
             if elem not in self and count > :
                 result[elem] = count
         return result

     def __sub__(self, other):
         ''' Subtract count, but keep only results with positive counts.

         >>> Counter('abbbc') - Counter('bccd')
         Counter({'b': , 'a': })

         '''
         if not isinstance(other, Counter):
             return NotImplemented
         result = Counter()
         for elem, count in self.items():
             newcount = count - other[elem]
             if newcount > :
                 result[elem] = newcount
         for elem, count in other.items():
             if elem not in self and count < :
                 result[elem] =  - count
         return result

     def __or__(self, other):
         '''Union is the maximum of value in either of the input counters.

         >>> Counter('abbb') | Counter('bcc')
         Counter({'b': , 'c': , 'a': })

         '''
         if not isinstance(other, Counter):
             return NotImplemented
         result = Counter()
         for elem, count in self.items():
             other_count = other[elem]
             newcount = other_count if count < other_count else count
             if newcount > :
                 result[elem] = newcount
         for elem, count in other.items():
             if elem not in self and count > :
                 result[elem] = count
         return result

     def __and__(self, other):
         ''' Intersection is the minimum of corresponding counts.

         >>> Counter('abbb') & Counter('bcc')
         Counter({'b': })

         '''
         if not isinstance(other, Counter):
             return NotImplemented
         result = Counter()
         for elem, count in self.items():
             other_count = other[elem]
             newcount = count if count < other_count else other_count
             if newcount > :
                 result[elem] = newcount
         return result

 Counter

Counter

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAigAAAE4CAIAAAD+UZ/UAAAgAElEQVR4nO2dy47syLWe+Th+AoGPoNewgM3H2JmAR3vgGDRUNdTEAnpQBQsCNgUL0qDy+Na+y91Gwrvp42P7aGCnYMNooBsonwE94C3uDEYygmTV92GhkMVLxAqSuX6uiEiy+L8Df/rTn1oAAIDEFAgPAADkBOEBAICsIDwAAJAVhAcAALKC8AAAQFYU4fm7ssQwDIuwrUMZHAmEB8OwFWzrUAZHAuHBMGwF2zqUwZGwC8/WXgHAMSBoQAQIDwDEQ9CACBAeAIiHoAERIDwAEA9BAyJAeAAgHoIGRIDwAEA8BA2IIFx4bqI8FcW5KC9Nbic3oK6qesnyNWhEWRSleA+HF94MCA9EgPBo1FXRoQmMa/mKIDxwPBAeiOCQXW2NeCyK52QC0LZtXdkFxrV8MY0QKf0HyMRRggbsiiMKz7UqTgcXntUEDGBbDhI0YF8ECs/Qz1actYjfiMdh+bkozkX1XBWnojh/+NzJw7koH8ui31eLtfK+pbjpFVXXaYO+f092w+KMk7GfTO0pa0Tp6D9bJjzOciz1TtuqO4zLQ8rvyq1qqYKpi06rgb47SAnCAxEsynisqUa38FE02ofnz/2qXlQ6FRkERvlXWzWUeZZLq2fccNKIUo3v/edGlGNMlj+3bbtIeFzluOpdqfxRe8bKus91pUgNqRWkBeGBCNYSnufa+PBZ2765lMVJzV3Goq7VtGosU8+QvG64MDRlWq4qgbJVuDC4ynHVu1b52pbjv40oSXIgHwgPRJBReJR/PatcFfndcBEY4v3/epZLvWlKd5g/1VhUvtUxn8PuLkSAlUF4III9ZzwBwlNf5m7ujcyjaYaMJEXGM1vvneXPZjxGeaQ/kBKEByLIIDzd4E0/L0Aa9Hic/q2fbWM8LuHpinoUTVtXp9nfFU3DH60SxpWIrulO7BiMXJCrXm2nWswInsNPdyYkt0RxAmB9EB6IIGJWmzzNrK0rbZqZZB9+P8wROA8zBZRC5X0ts9o889bqZ1eZVqauJ0NejC4pretsXOFarpbvWm6mHUN59tluM34OC6bxpH71Z31OG7IDaUF4IIKkv+PROtAA4K2B8EAE6YTnKqU7SX/sCQCbgfBABEd8cgEA7AWCBkSA8ABAPAQNiADhAYB4CBoQQZDwfP/996+vr23bvr6+fvvtt/v8DAD5QXgggiDheX19/fLlyw8//LDbv5scOwBAeCCC0K62PeQ0ns9ZjhUA6CA8EAFjPLA7fvrLH7FNLOJkETQgAoQHdsfm8ffdWsTJImhABAgP7I7N4++7tYiTRdCACBAe2B2bx993axEni6ABESA8sB/6R2v/ePv6F6dTcT4XX/3qu9sfNg/Hb8w8h9f9mg8nBA2IAOGBnTCFvJ/+8scfv/llcT4Xp1/+Jpnw/Pjlty5V86zKqhBRboTs5Tq8bdua7wjxQ9CACO4Wnrr23h81orS9FGAj6sp+N+davgZbHQHl/Qi7OQNO5Dvt6a7811+niunf/NKVTnlWZVWdKDcC93Id3v4ELJEehAciuEd4urfC+EP2ToRnfKON68XVb0x49LfQ7f21PGoHz4+333766pQo3fF0NO2ki8/lRp+mnM/F+fyLb3T3wvfyHN7xFIRLD8IDEdyZ8bje1LlPFrxXNI5GiD0cDVNp1PecrljROu3VBhbSR/bffvrqZFUXz6q82qO70evK6dOnL90Hi2zE7WUVnnDlQXgggp0Ij/Z+z0QpSGrh2YkMZ8tw1mqv+vZwhMcnIT7liNvLLjz6OXGC8EAEC4RnGjRQXhRd1cMK40KdXsmcJAxKaiVXYPNT8tZekGW5sxxLvdoLp5VeLtcRMMofuy6nCqZDqtXgCwozeuCuV25e9dnnj6u91vKVg9CXpfivOzwTlKW+o+L06dMXe7eStuqnv/zxu999mtaqXVLmqm//19BzZdoQx5W9fv31FPqHJdMGQ10/fvnVz7RivW58d/vD1IdmOHDPXjPCE3xXgfBABKHCI98ASZ/rqijLD1M0ssXDJHlAI0o1vk9Bzuan3xPLclc5rnpXKl/VgCl1qSslVPsPqW+tu15rQ1z+LG1Xv7Hoj5eruh5vKjDdwndB/Ge/++3sqjE6d4McfaQeIr5r1Xe/+9SX9s0vOxmTh+67Lbsq5M8/ycMtah+X1PH1BzMd8XjoyV3i9kJ4YFsChceIsH1EUQOiXXlCruClXW2ujgCXn35PzOWucvwdEPeX74rIjSjDJyh4DvjSev0KEd6ubmNXE2K62sbcQlYX1yptOL0Px31m4F7V5U+//rr/8NWvfvO7T0pmY9tLFh5tCsDomG1qgK9Al4TE7RUkPHS1QUoChScuMHkW3klgiA9xz7rcJYRxqYa1/MXH092FqOGJGUvrXXo8PTcQvkOnrZuRnLE/7atPWlrjWqXFX1V4Alb1v3r59Pf/0adhYpitI04rxBHuld62YUKzxw2v8MTsFSQ8wd9ahAciuD/jkZbHZzxLMWpqmiEjSZHxzNZ7Z/mzmYdRnvdu1DwPw6y2zBmP5rT7MlD3m090uo6v29e/UNRldtWyjOenv/zxN78+Fefzz74aBlGmXjLfhO/AcD8mUrNu5M94mE4NSVkwxiNPKZDHJMYr1BEPk43x2IZaHH76PZkZq5ALctWr7aROX7aX7zieDgGQWzI54fqRkOK+XKjnPKoTJUKEx9Je13GbvQzkTb3CMw2TOMZ4LKt+ihrjmbTh9OnTN7/6mRrT5XEdbTqZK9zrPXJd6rPDMZ4lz81BeCCCBbPapm4UKXQJ0YxdQI57pFSTjKeuJ0NeTD/VLiBtBtfc7CzXcrPBQ3lqEC+s2xt+Dgum8aR+9Wd9Fplavv24B0zK0zRl8rL75+c/d/hTG3tpcqRW4JsCpzrcr/IHx2kS1+nTz746mRJiXTWmL2NHnNw55lo1/sLf+lN/ZTpZv700q82YS2ZZq473uNyYltvmp8Xt5RYeHpkDyUn0rLZJbBYNi8P7pg95IffmWArjIaGQh1QPCbX9FAUgiM3j77u1iJOF8EAEPJ0adsfm8ffdWsTJImhABAgP7I7N4++7tYiTRdCACBAe2B2bx993axEni6ABESA8sDs8kfF//8/fd39//5/+MZ/jPiM8sDkID+wOT2T8q//8mz//+Z/w956/CA9sDsIDu8Of8ewkbzjuZ4QHNgfhAYB4CBoQAcIDAPEQNCAChAcA4iFoQAQIDwDEQ9CACI4lPMseXxjA4idTAYDM7oMG7JEDCU8ikVhdzADeEfsOGrBT0gnPTZSnorysFdNDZaeu596ZbTy3FOkBiAXhgQgOIjxBstM9Edu/nf0FNkgPQBwID0Swr662RlysshHcyxb70jmUByCKzYMGHJFdCc+1Kp5tsqG+T9lHrPCE1wAAElsHDTgkQcJTFaeieK6bS1mciuI8hPabKE9FcS6K57pt6+pUFOehb01ZNXDty+k/nIviXIqbWtTZ2Kt1yYnt3c51VVT1sMKQEtvLm71VAIAfhAciCMx4rlUxDdjU1WkQjG7VsxCPVd0aKYuZwYza07Zt2zaXcmb7tq/QUAU5RZE+11VRlh/6fxxpjFVjEB6AGBAeiCBceCRJaC7lNGvgWhWyDrn3siyZFaq+PkNBtEGfcYimruQ8x648No2hqw0gCoQHIogSHuVfl1pYV8UJj6kV2oLxX9dyb2GuDQFgDoQHIlgl40kuPMa0Nk/GIy0PzniY1AYQB8IDESwZ46mubdt2EwGkyL2i8NxE+dgLiNB/AKRpg6I807q6kuYUqP1uUkma8PDcHIBYEB6IYEnGUz93s86MWW3mVDR1VZ8eDZPZPDPf9CpkdH3ofi+qzWoTohnnrjmyGKM7jmwHIBaEByKIG+PZimiRmMSmEaWkSCQ7AHeB8EAE4b/jMX9ecySm9Ij8BmA9EB6IYFdPLgCAg0HQgAgQHgCIh6ABESA8ABAPQQMiQHgAIB6CBkSA8ABAPAQNiADhAYB4CBoQAcIDAPEQNCAChAcA4iFoQAQIDwDEQ9CACBAeAIiHoAERIDwQzuyz8rZ79t3t8nh6vsbseX0+nU6nx4v1XYbt9Vkt1VXP9fnx8fF0Pp9Pp+fr7fLYl3l9PnULHx9t+12fT9PS68Xhw64haEAECA8EEigqGz3t+/rsko627eTidLZxmpMrRWmuz47Nb5fHsf7RldvlUdrT9E8XMWfpe4agARG8OeGpa29wbETJc0Jj8MhOVbTa62HXPMC3y+Wqfmjb6/NJUo7Hy62L4ZfLo6IuTinyR3i3SvU1Pj52G0hpkqQrk9xYF3q8sG20e95C0IDsvCXh6Z5A7b8rR3iicMtOI9pCE55Vped2eRrShyeHjnQdW4+Xi6erqu/yOp/Ppj6dz+dlmcbtZsldhhKm3Mef8HTb+VIxXwq3Hw4eNGAb0gpPI0TeHn/La633QPbjsDJO3WnasrAIz4rKMw58OEZAuu6qLsaHZQz+TrlpozGtMUZnlJEZvczpozfhMcs4KAgPRJBUeMJlYHpdjvlW0TQ15mSfXoXTiNKuI6JsRWN0tfn2WIDcn9Zh66zqYvsY48clIzc5v3m+TqmPiVS+IhpjztUpkKki0pJpR1/Cc32eqrtdr5rDlyMJEsIDEQQJz/Au6aoeJUIKK+OrpqXoOi27Q0VmsNVbV0VVDyuM0NfIDZkruRLd1lWtdeHZ6jVa3NcddRwkFbbXMCx1+bnQ/3G96215duFsRFuKtjXHeNy7LMY2wNP/b3SXdd1TT0+Pnq6qoGynVfr1zCEbsxBZbZ7M1EeXquvz81XOkZRc7nZ5PFQuhPBABOEZT10Vlei7XJQ3SY9ByrjNTXin76i3roqy/ND/47jtDvGqrvrgW1d9fO738tQrVaVVseA4dJohaYT/ONv9/BzjvyZo8/5X1fAhmfA4JhaMM5XN+DyMsFyvZui+XR5NobLOcu4ykmEDbcjGl/DYxUae8taavYKKkB1uggHCAxEsEh5rDqFGKGWLdF1trnpVAbArT6DwdNsoHz47621E6ZmyEH4cXF1UnvZa/Vzqv18pLV7V1SQ2ibra7LozDuwr0XzEmdLcLo+ThiiLrbrjmaPmTHjUsqY+PVnchoxILsQ6FfswIDwQwbKMx3Zj6xGMdBmPK1CGpBr3CI+vfHsXXGiN/i1n2xsoPJHHzXSrKtpCs8q7w1KGnMM58czYoJ8IYP9156mbQWbZ3hLop3688ITHroPDesuUtqkQab3+c9UDgPBABHcKj/9HhemEJ+zOPV/GY+wdmfkZHjfNkFFtmPHMnGcz41lnUpt3QltwwjNOH7PtEZ7wjHtbEx6rfkke6JXovWvD1IgDPrsA4YEI7hQeLVJqAWdaWYuVfzqjRMKpWqU/UI//49baQLtPnPQPznrlQvQxkgXHQdlVqszd3gXC4/N/LlP0aIkuPCs9N2e8+7emAeact65TS589pjx1wJgm92zr2bKOvwyaYE14TE/UYSTdf71TbtC2Q01n60F4IIJFs9rsHUnSzC0j3gxdcSkSn6mbTwqlQjSjP45IOS88fcnjPC/5g71ebfaarbMt+DhMZRlTNbTSnX7+vUX+Dwv0mXiasxY9qaupq62b4bZWtuOZ0NYvtCc87p4q2x72Jxj0YnO9XG7yCI9jspynj81ZiXUk54jpTovwQBRv6ckFHpRpeDy5IJbtHxLqTy+mVMY9UU3NRXwJz+3yeHInUL5lWnFm39zp+Wobo5J8O8xYz9sNGpCQdyI80m3+9qpjzshIlxZCT3jCs4krx+UNBw1Ix3sRHgBIAUEDIkB4ACAeggZEgPAAQDwEDYgA4YHd8f3337++vrZt+/r6+u23377bzzmPeTQEDYgA4YHd8fr6+uXLlx9++OGd/936PARB0IAIEB7YIzvJOTb/vH8IGhABwgMA8RA0IAKEBwDiIWhABAgPAMRD0IAIEB4AiIegAREcS3jWegDlSPJniwG8bXYfNGCPHEh4EonE6mIG8I7Yd9CAnZJOeG6iPBXlZa2YnjA3QXoAYkF4IIKDCE/iLjGkByAOhAci2FdXWyMuVnlZS3caIezFoDwAUWweNOCI7Ep4rlXxbBMG9f3a8djf3r1mDQDvjK2DBhySIOGpilNRPNfNpSxORXEegvdNlKeiOBfFc922dXUqivPQt6asGrj25fQfzkVxLsVNLeps7NUagqG8m7l/q5okG9Oro52vpjblx61JAOAG4YEIAjOea1VMAzZ1dRoEo1v1LMRjVbdGymJmMKP2tG3bts2lnNm+7St0SIXou+CUN1uPGmSkMR51QXgAYkB4IIJw4ZEkobmU06yBa1XIOuTey7JkVqj6+mwdYXVleY21NhikDd3Q1QawMggPRBAlPMq/LrWwrooTHqtiuNIgDVWHXMJDwgMQBcIDEayS8SQXHtu0NqtW+Ke/OeWFSW0AcSA8EMGSMZ7q2rZtNxFAit8rCs9NlI+dANRC/wGQoQ12FVH7zLSdppW1kJbz3ByAWBAeiGBJxlM/d7POjFlt5lQ0dVWfHg2T2Twz3/QqZEZ9mJmiJq229c/pK8h2AOJBeCCCuDGereAhoQD7AuGBCMJ/x2P+vAYA3jsID0SwqycXAMDBIGhABAgPAMRD0IAIEB4AiIegAREgPAAQD0EDIkB4ACAeggZEgPAAQDwEDYigaP/f33amCM+wEMMwzGMEDSzCEB4Mw+KNoIFFGMKDYVi8ETSwCEN4MAyLN4IGFmEID4Zh8UbQwCIM4cEwLN4IGliE2YUHwzBskW0ey7ADGcKDYdgKtnksww5kCA+GYSvY5rEMO5ApwrO5NxiGYdibN4QHwzAMy2oID4ZhGJbVEB4MwzAsqyE8GIZhWFZDeDAMw7CshvBgGIZhWQ3hwTAMw7IawoNhGIZlNYQHwzAMy2oID4ZhGJbVEB4MwzAsqyE8GIZhWFZDeDAMw7CshvBgGIZhWQ3hwTAMw7Ja8Td//j8YhmEYls2Kf/3d32IYhmFYNkN4MAzDsKyG8GAYhmFZDeHBMAzDshrCg2EYhmW14l99+z8wDMMwLJshPBiGYVhWK775j/8dwzAMw7IZwoNhGIZlteJf/um/YRiGYVg2Kzb3AMMwDHtXVvyL//A3GIZhGJbNEB4MwzAsqyE8GIZhWFZDeDAMw7CsVvzzf/9fMQzDMCybITwYhmFYViv+2b/7awzDMAzLZggPhmEYltWKf/pv/wuGYRiGZTOEB8MwDMtqxV/9mwbDMAzDshnCg2EYhmU1hAfDMAzLaggPhmEYltUQHgzDMCyrFR//gcAwDMOwbFa0AAAAGUF4AAAgKwgPAABkBeEBAICsZBCemygfRJO+nlC28mdvx2Epe/N/b/6sxVHadRQ/l/JW27UPmpeyfGlihecmyo9FceqsFLeZusSDsc1QQvnStG3bXquiK/CpjnJoETZ/BgfKl6Zt62pNZxrxUjvrlR2453IfD+BJOqor4ztu6U9cXelVeP1JeyiSkrpd4wV5J0fxs21eytEryZ/ha6676v2eruHOWu3ajGXxX6auPpbi1ra3COG5ifJjNRy5RjwU1XVmj0HlVK6VEq20f1Ni9ad5KSUHzDAXRfc9HIqyH4ex9o/3Xe7SAVTbshpB53F13NoW4k/9NH997o2E7VIvyDs5hp838WFyUo5XtXB/GVPdr6x6/LdhefyfmG6vFwuPWZPz/MnbVJOvkhMbCY/dH3nhra7XuuVR2mWtt+2P6lN11+WuVBR+17bo/ivgPCbCXsverqu1WLFdxvld84AcwU+XPzchnBHT9T2NIOnxz09c/B82ne5CFguPLHc2bqL8aMmvLTc+mwYI643YuLC51qvd8ATdANbVg2ju7FxWKwq9a1t42OfPYyIcteztulqL1dplbrbqATmKn3Kx/ffCJzzrJcrZ2pWHW2T8N/ZdLDxzR81V8ewJ0HqK7CMWjXjoF/aXxdjb+FSPnbbj9u5yHKe/D/1NfVX8r5/GQsaUyFev5GcpXgK+h/2XQUpThpR8aMJQr2u593ha/G+1jtpCU0fL9i7/fV8k43x5q1hWb5A/ww1a6PlS/NSun+Lps78cm/+NeCiKJ9GVX127Xfq1y65Pa7vGfsgH0cgFyq5q57crZxqMkTNj4ziMXUP27Y/jZ4d8b3cV4jYO8wTkbZ7v4+bt0rFdz0MJ1XW4UNXTZP2e6syqplt41Fvh1YXHiZG9ugKlNsw+bSZ3H6ldSdeqeBLioaqDynH4Mxb7IlxfLX3sxFqv7mcxW2/z8qHbXjk316qYTuEwKOdf7jqenrEfb+CwjRXNnUepWY7zpR6Tmyjj/PT4I33hlS9S0PkaPktBKui8u/y/Vv3o3bUqPo67fF58fTrb1fSe9FV/mBcGddxx5jg4tz+Un91a7YBPnkvfI2+7LN+7jY+/iTtOjpe0Pu7l2N4kPl3TSs4nPEbnj7vvtbQOs48RathejdHWiXO+g7h4qLy7hdGvZlu93hTHrFe6U5a+G66us7DlloaY/i9tr9V/Vwmu8zXbo7jQz1B/2tDzNR1Pj/B4Li3Nf1OZOuFZen162zUFRO3Yhvc0eI7Dout5r372+zqOufmt9LdLu0fcuF1aG11xsr+ShXiSnPRurxMtPNptVswYT/Q4hBZxfAfUlyo6s1cL3hTSGgFtRfXC8CCakIsgRACUeuUZdOqdzlwG41kufzGc/i9tr9V/18EP9D+wXr9AhvjjWuU+X1JXWFCSZ/ffLjzjTW7w9en7zjdj+jU/AnffdTV/Pe/Wz6XLl8Wrrdslb+CKk72rRjeAb3uV2HFoY8xsRnj+riwxDMMwLNAsumOMLyA8GIZh2GqmTy6wDWogPBiGYdhqpgmPdcJCqPD4N1vA3n5JvpU/8/Uu7aTOy9s/j8qsp5S/ZvcS2i5lntIGHMXPpUzt8n/vjtauBDjEQpu80JNdeIzpDVuzlT/+escRP+tczEwPtfPyDs6j8jubrRo72y5zovAmHMXPpVyr4uEffu/53h20XeuzSCzyCw8AALw1EB4AAMgKwgMAAFlBeAAAICsIDwAAZAXhAQCArCA8AACQFYQHAACygvAAAEBWEB4AAMgKwmOlrkrbUy0aURZFUVSf27oqisK6javAZdunBv+3Bf+3Bf/XdsZeeiNK89XNbYvw2HAdrEaUxbSirorCfkztLN0+Nfi/Lfi/Lfi/uj92YbPfxGcQnj5N6NjRTYMDp0a3daWcuboKOI+NEMNGQdsvQfNn+e7L9l7Lf/l6wP9026cuDv+zVn93Aan9d4cjm/SkFh4lS1BThl3ilh31yPq2k7YfY1PI9stoRHlH4Fvqz2r+yxdhI8rYO5E5f7pjPx2go/l/7/b+ou5XTfy/p+o36b/vPtiUnrTCYypNLZKkPFJicWc5nvMTkWHcmZS4GUab9i3jJtr5T3R8xrR/9fLz+J+B43regf/bYvrvbZGhPGmFJ1eGs9ZZbETpuYNNJzyNKBf1QnZ+7ufaDfff6K5M0ve69Mjszf+lLL1+2p0FPvzfllX897bIiKxphcd/cKfO8n4ruW9q+vfztHzoQJmOkjKApGUARvlKktiXpRyOZcdutl2lECmEZ3AkzbU7HePw0iMu3L6uteO25P2CFuzE/2Hq0ZjOhua1ewp82jcyyKud+D8bH7w7bu+/7M2iL/Aq/i+7a99MeGQ3pc/GHWX/r6pJehee5Sw6yu83Fn2Xmqs6k9AYo9WboDdsHNVLce1KZaYekVt/2Gsky+1kAv+nIsfLLVVOlbqTM2ktyUt2xIeVa0lRsjvurYvNf9/Eub0Ij/atlb5nTuHxKIRVfl1dInXlVHfvmQoKxEa9a19e0mSSpOG1u21KVn7K70QO4Unk/+D4OG0hWV9eokN0x3yLZSSVhAxNSHf883QFW7vavMEzZ1eb+9u5VGCWCo/W5aL14AVNXFu2MtSxOzHbtbY6TF0MKXtj0n6zEwtPQv87zzvVL0Wz+hR8raIkLO/qieB4uUiWWjxxb/WKlk0u0FYmn9WmfUOHWUGZMx7FhZmBnDhVsu+f9CJO1M09nrFk3w3pmlhrOqJeRdLDntL/uiqqqup1P2HozhJevTfBdxeN8Jgk7L9WWSY8uadTa9Lj/CHM5JfcTSj39viVZqplnO6qj+vYvbDgzk6DrhW5XcGhI25wW/ZnGJdeVoK1zHK8NUgxOK/ewzfiw3jDsWIHR7pZben9Hy+aBWNscYPD2mDMStePXEhoE/bjfxslCTvy3x33/Dvd6X/rO242Ncz65AJnd5imKdOEmO6fn/9cmSFj+wVTXZklSfNrusW+KXCqw9ZVvrEza7uqWpun52LxiZcz6ilXXOMeSpqSVwd7tWg6srsHdA3/1QpWD9zJ/Vey/9DyFl0/6rdAzm9X8F/7igWWuBP/A+ODY8ft/TcrSHHjstT/zR6Zc0Qcdwp92MmTzC4l3XhAHvB/W/B/W47rvycsOrv+EJ63Qba+3UTg/7bg/7Yc3f/FIDwAAJAVhAcAALKC8AAAQFYQHgAAyArCAwAAWUF4AAAgKwgPAABkBeEBAICsIDwAAJAVhAcAALKSR3ik58rZH0UnvxZh0eMy132qsUmiR1nQ3uAdae+a+B6A6/2GAqxJLuH54Lma1S/D0qe0rvdUV2cFK38VaS/t9bmzaXv9X1WAddheeIx7sKCntEov4Fr9qa7GiyVWDU1x7b1je48jjifA0977qtlHe93F+dqL8EAOthYe/Wsa0vUhv+Rm/a4S6wvQVgtNMe317R+N3KJGlFoHy2bt1d+r9NbbO7f/fa44X8ribi/CAznYWHhiv2fJXk/bf1sX3SQuK34fTz8f39Ta/5soyVvY3vG1hquf3322NwOOI+lsL8IDOdhWeNT3tC4g3RvLu9eeGoVHe5qglDUwXiWu+bVNe9O97n6f7c2A45A6PUV4IAfbCs+yQCO9lVmkiFDDl9Hq1SoxcUkh0jyj5DfRlvvfzO3VXimduMUbt3eYusYaE80AAAXsSURBVDam1648ewVcLrmWIzyQg8MIj3yLZh2GuZtxFHYPwiNt2YgyaSC2dw9lF9rVKp1jB+2dXJDmXafJlRAe2CNH6WrTosX6EUqa/LOrrrbuZjhZOHZ59Na62gZ20t6hoeM0h1S6Q1cb7JKNJxcERxqjj37twWe1q8fo71mpwgXF9B45xpxWwRMn87d3xVpd7Ki93YbdXUUpmtV/EjDnkdNRhAdysLfp1C6SZzwSlsKTTbf1bDfWmKixSpuk30UZ6+5h2TSvxKd1T+2tq6Kqqv6+ImFKaz+kTKeGbdlaeIK/8/I3OuCres+jR4zvqiWaxJcf1t5xYnHggNZif9R7bPUEbdDesZYlkxEO3d7xIg4aw4v2Z7qQJnzqiPBADrYXnvC7xLE7rKrl35B6tl58Hyn3uA3fV0ckiX+0SVB7pSl8tSgDgs4yf4yuxWnXbdqrOhRQ0cHbq8wrCJ0Kt/S3qFJ7pzbyyBzYnr09JHRFVuk39wSRe8qnvfdDeyPgIaGwC97qaxFS/4R8bz9Rp73HKn8pe/MH4C7eqvAAAMBOQXgAACArCA8AAGQF4QEAgKwgPAAAkBWEBwAAsoLwAABAVhAeAADICsIDAABZSSI8GIZhGDZrCA+GYRiW1RAeDMMwLKutIDwAAADrgvAAAEBWEB4AAMgKwgMAAFlBeAAAICsIDwAAZAXhAQCArCA8AACQFYQHAACygvAAAEBWEB4AAMgKwgMAAFlBeAAAICsIDwAAZAXhAQCArCA8AACQFYQHAACygvAAAEBWEB4AAMgKwgMAAFlBeAAAICsIDwAAZAXhAQCArCA8AACQFYQHAACyslh4quJjUZwmK1+aFH5tw02UH5e0aNn2jXipYz27b/esfq7uTyLuamb91F3/VeIjBfAmich4rlXxNH3d6qeiuq7oUD4ssSOd8Fyr4mMhH7dl3Ll7Nj9X9ycR9zWzeSn7fW+ifBBv6M4LIA93C4/+71G4VkUXMrL5f2dFqfw0bvw3PqHp862O+GbW1cdS3IZ/DnvjBbAd71l4Mru9T+Exi932hO7/PkDNcpqXcus+Q4DDca/wNOKhqK5950lx6rov6uqjNvzTiId+TEi7PRz6u7Tucvv2zUspjzCN5buWO/2Xh6nGtihNUDd+qqW9hrtd6/Yef7rjZpbjOz7j8lK8eAPltSo+FuVL01f9VA8fPjv9HJdrx8Hnpwub/0MJ1XU4y2P31CJ/vCy6ftzH03l9WngbN14AWxInPFKAUL6o16p4EuKhqlv5C9mIhzF4aZ/VuO/ffuwcm+qqfctnW2HdzJoBSOMBU/++Z3uXn/ZyPMfHcawsNP1hb9v6qd9r/LBme+1VW32WkoOb+KDdDYT746t3yfXjPJ5u/60gPAD3cn9Xm7bqo/G9nSJCv02fAbgGZj3bm4V7lse1YrbraTbuuPxx7ehp75IANww2NOKhy7HqKkSPl7bXxOV/27a9bgnxZJzo+4Un4vpZdPxdIDwA97K68JirXF9UT+hRZ2wHdIks6Srxt+J+4XH54zkO1vYuDXDdBl2H1YNorpWRjKYRHt/5aqfO2Nl6A6tbWoLreps9/i4Y4wG4lwzCE5zxNDfbnamD+sk+luNaHuSqdXmM8Nj8Ccx4RhZmPG1bVx+r6qkoX5r6yfiJSbaMR6V5+SBuUzdgjD+eekOun6UZzzzMagO4kwzC0ypxRxp4UO6Fm5dy+Kz2s4+Bw9KHU/uWx7XifuFx++nY0dFe5bjVVcDvTka9sRwEV3un8F0Lv0A6cfkvDe2YwT3cH1+9ruvHdb1Zj6fbf1fF8jnldzwAi4l+coFlYMPTWdHPc/N0kanf9mm5ZdaZNovJtdzJ5Iyn/ClNkWfoTTOyPtu3d/njLGeMfdZDN7pa1deA3zxKIj0dZ5efYx1P4X66sPnfFfUgmnHtmGGE+zOD6/pxXW+u4+k6/k54cgHAHfCsNgAAyArCAwAAWUF4AAAgKwgPAABkBeEBAICsIDwAAJAVhAcAALKC8AAAQFYQHgAAyMr/B6qVDPcw5CtnAAAAAElFTkSuQmCC" alt="" />

import collections
# obj = collections.Counter('aaddwersdfdf')
# print(obj)
# ret = obj.most_common(4)  #查看前四位
# print(ret)
# for item in obj.elements():
#    print(item)
# for k in obj.elements():
#     print(k)
# for k,v in obj.items():
#     print(k,v)

obj = collections.Counter(['11','22','22','33'])
print(obj)
obj.update(['eric','11','11'])
print(obj)
obj.subtract(['eric','11','11'])
print(obj)

aaarticlea/png;base64,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" alt="" />

 

2、Python有序字典OrderredDict

2、有序字典(orderedDict )

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

 class OrderedDict(dict):
     'Dictionary that remembers insertion order'
     # An inherited dict maps keys to values.
     # The inherited dict provides __getitem__, __len__, __contains__, and get.
     # The remaining methods are order-aware.
     # Big-O running times for all methods are the same as regular dictionaries.

     # The internal self.__map dict maps keys to links in a doubly linked list.
     # The circular doubly linked list starts and ends with a sentinel element.
     # The sentinel element never gets deleted (this simplifies the algorithm).
     # Each link is stored as a list of length three:  [PREV, NEXT, KEY].

     def __init__(self, *args, **kwds):
         '''Initialize an ordered dictionary.  The signature is the same as
         regular dictionaries, but keyword arguments are not recommended because
         their insertion order is arbitrary.

         '''
         if len(args) > 1:
             raise TypeError('expected at most 1 arguments, got %d' % len(args))
         try:
             self.__root
         except AttributeError:
             self.__root = root = []                     # sentinel node
             root[:] = [root, root, None]
             self.__map = {}
         self.__update(*args, **kwds)

     def __setitem__(self, key, value, dict_setitem=dict.__setitem__):
         'od.__setitem__(i, y) <==> od[i]=y'
         # Setting a new item creates a new link at the end of the linked list,
         # and the inherited dictionary is updated with the new key/value pair.
         if key not in self:
             root = self.__root
             last = root[0]
             last[1] = root[0] = self.__map[key] = [last, root, key]
         return dict_setitem(self, key, value)

     def __delitem__(self, key, dict_delitem=dict.__delitem__):
         'od.__delitem__(y) <==> del od[y]'
         # Deleting an existing item uses self.__map to find the link which gets
         # removed by updating the links in the predecessor and successor nodes.
         dict_delitem(self, key)
         link_prev, link_next, _ = self.__map.pop(key)
         link_prev[1] = link_next                        # update link_prev[NEXT]
         link_next[0] = link_prev                        # update link_next[PREV]

     def __iter__(self):
         'od.__iter__() <==> iter(od)'
         # Traverse the linked list in order.
         root = self.__root
         curr = root[1]                                  # start at the first node
         while curr is not root:
             yield curr[2]                               # yield the curr[KEY]
             curr = curr[1]                              # move to next node

     def __reversed__(self):
         'od.__reversed__() <==> reversed(od)'
         # Traverse the linked list in reverse order.
         root = self.__root
         curr = root[0]                                  # start at the last node
         while curr is not root:
             yield curr[2]                               # yield the curr[KEY]
             curr = curr[0]                              # move to previous node

     def clear(self):
         'od.clear() -> None.  Remove all items from od.'
         root = self.__root
         root[:] = [root, root, None]
         self.__map.clear()
         dict.clear(self)

     # -- the following methods do not depend on the internal structure --

     def keys(self):
         'od.keys() -> list of keys in od'
         return list(self)

     def values(self):
         'od.values() -> list of values in od'
         return [self[key] for key in self]

     def items(self):
         'od.items() -> list of (key, value) pairs in od'
         return [(key, self[key]) for key in self]

     def iterkeys(self):
         'od.iterkeys() -> an iterator over the keys in od'
         return iter(self)

     def itervalues(self):
         'od.itervalues -> an iterator over the values in od'
         for k in self:
             yield self[k]

     def iteritems(self):
         'od.iteritems -> an iterator over the (key, value) pairs in od'
         for k in self:
             yield (k, self[k])

     update = MutableMapping.update

     __update = update # let subclasses override update without breaking __init__

     __marker = object()

     def pop(self, key, default=__marker):
         '''od.pop(k[,d]) -> v, remove specified key and return the corresponding
         value.  If key is not found, d is returned if given, otherwise KeyError
         is raised.

         '''
         if key in self:
             result = self[key]
             del self[key]
             return result
         if default is self.__marker:
             raise KeyError(key)
         return default

     def setdefault(self, key, default=None):
         'od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od'
         if key in self:
             return self[key]
         self[key] = default
         return default

     def popitem(self, last=True):
         '''od.popitem() -> (k, v), return and remove a (key, value) pair.
         Pairs are returned in LIFO order if last is true or FIFO order if false.

         '''
         if not self:
             raise KeyError('dictionary is empty')
         key = next(reversed(self) if last else iter(self))
         value = self.pop(key)
         return key, value

     def __repr__(self, _repr_running={}):
         'od.__repr__() <==> repr(od)'
         call_key = id(self), _get_ident()
         if call_key in _repr_running:
             return '...'
         _repr_running[call_key] = 1
         try:
             if not self:
                 return '%s()' % (self.__class__.__name__,)
             return '%s(%r)' % (self.__class__.__name__, self.items())
         finally:
             del _repr_running[call_key]

     def __reduce__(self):
         'Return state information for pickling'
         items = [[k, self[k]] for k in self]
         inst_dict = vars(self).copy()
         for k in vars(OrderedDict()):
             inst_dict.pop(k, None)
         if inst_dict:
             return (self.__class__, (items,), inst_dict)
         return self.__class__, (items,)

     def copy(self):
         'od.copy() -> a shallow copy of od'
         return self.__class__(self)

     @classmethod
     def fromkeys(cls, iterable, value=None):
         '''OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S.
         If not specified, the value defaults to None.

         '''
         self = cls()
         for key in iterable:
             self[key] = value
         return self

     def __eq__(self, other):
         '''od.__eq__(y) <==> od==y.  Comparison to another OD is order-sensitive
         while comparison to a regular mapping is order-insensitive.

         '''
         if isinstance(other, OrderedDict):
             return dict.__eq__(self, other) and all(_imap(_eq, self, other))
         return dict.__eq__(self, other)

     def __ne__(self, other):
         'od.__ne__(y) <==> od!=y'
         return not self == other

     # -- the following methods support python 3.x style dictionary views --

     def viewkeys(self):
         "od.viewkeys() -> a set-like object providing a view on od's keys"
         return KeysView(self)

     def viewvalues(self):
         "od.viewvalues() -> an object providing a view on od's values"
         return ValuesView(self)

     def viewitems(self):
         "od.viewitems() -> a set-like object providing a view on od's items"
         return ItemsView(self)

orderdDict

用for循环做一个有序字典

aaarticlea/png;base64,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" alt="" />

dic = collections.OrderedDict()
# dic = dict()
dic['k1']='v1'
dic['k2']='v2'
dic['k3']='v3'
dic['k2']='v2'
# dic['k4']=None
# dic.setdefault('k4','66') #与上一步等同
print(dic)

#将k1移到结尾
# dic.move_to_end('k1')
# print(dic)

# dic.popitem()
# print(dic)

# dic.popitem()
# print(dic)

# ret = dic.pop('k2')
# print(dic)
# print(ret)

dic.update({'k1':'v111','k10':'v10'})
print(dic)

3、Python默认字典default

3、默认字典(defaultdict)

学前需求：

1 2	有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。 即： {'k1': 大于66 , 'k2': 小于66}

 values = [11, 22, 33,44,55,66,77,88,99,90]

 my_dict = {}

 for value in  values:
     if value>66:
         if my_dict.has_key('k1'):
             my_dict['k1'].append(value)
         else:
             my_dict['k1'] = [value]
     else:
         if my_dict.has_key('k2'):
             my_dict['k2'].append(value)
         else:
             my_dict['k2'] = [value]

 原生字典解决方法

原生字典解决方法

 from collections import defaultdict

 values = [11, 22, 33,44,55,66,77,88,99,90]

 my_dict = defaultdict(list)

 for value in  values:
     if value>66:
         my_dict['k1'].append(value)
     else:
         my_dict['k2'].append(value)

defaultdict字典解决方法

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

 class defaultdict(dict):
     """
     defaultdict(default_factory[, ...]) --> dict with default factory

     The default factory is called without arguments to produce
     a new value when a key is not present, in __getitem__ only.
     A defaultdict compares equal to a dict with the same items.
     All remaining arguments are treated the same as if they were
     passed to the dict constructor, including keyword arguments.
     """
     def copy(self): # real signature unknown; restored from __doc__
         """ D.copy() -> a shallow copy of D. """
         pass

     def __copy__(self, *args, **kwargs): # real signature unknown
         """ D.copy() -> a shallow copy of D. """
         pass

     def __getattribute__(self, name): # real signature unknown; restored from __doc__
         """ x.__getattribute__('name') <==> x.name """
         pass

     def __init__(self, default_factory=None, **kwargs): # known case of _collections.defaultdict.__init__
         """
         defaultdict(default_factory[, ...]) --> dict with default factory

         The default factory is called without arguments to produce
         a new value when a key is not present, in __getitem__ only.
         A defaultdict compares equal to a dict with the same items.
         All remaining arguments are treated the same as if they were
         passed to the dict constructor, including keyword arguments.

         # (copied from class doc)
         """
         pass

     def __missing__(self, key): # real signature unknown; restored from __doc__
         """
         __missing__(key) # Called by __getitem__ for missing key; pseudo-code:
           if self.default_factory is None: raise KeyError((key,))
           self[key] = value = self.default_factory()
           return value
         """
         pass

     def __reduce__(self, *args, **kwargs): # real signature unknown
         """ Return state information for pickling. """
         pass

     def __repr__(self): # real signature unknown; restored from __doc__
         """ x.__repr__() <==> repr(x) """
         pass

     default_factory = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
     """Factory for default value called by __missing__()."""

defaultdict

# dic = {'k1':[]}
# dic['k1'].append('alex')
# print(dic)

dic=collections.defaultdict(list)
dic['k1'].append('alex')
print(dic)

4、python可命名元组namedtuple

4、可命名元组(namedtuple)

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

1 2 3

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

 class Mytuple(__builtin__.tuple)
  |  Mytuple(x, y)
  |
  |  Method resolution order:
  |      Mytuple
  |      __builtin__.tuple
  |      __builtin__.object
  |
  |  Methods defined here:
  |
  |  __getnewargs__(self)
  |      Return self as a plain tuple.  Used by copy and pickle.
  |
  |  __getstate__(self)
  |      Exclude the OrderedDict from pickling
  |
  |  __repr__(self)
  |      Return a nicely formatted representation string
  |
  |  _asdict(self)
  |      Return a new OrderedDict which maps field names to their values
  |
  |  _replace(_self, **kwds)
  |      Return a new Mytuple object replacing specified fields with new values
  |
  |  ----------------------------------------------------------------------
  |  Class methods defined here:
  |
  |  _make(cls, iterable, new=<built-in method __new__ of type object>, len=<built-in function len>) from __builtin__.type
  |      Make a new Mytuple object from a sequence or iterable
  |
  |  ----------------------------------------------------------------------
  |  Static methods defined here:
  |
  |  __new__(_cls, x, y)
  |      Create new instance of Mytuple(x, y)
  |
  |  ----------------------------------------------------------------------
  |  Data descriptors defined here:
  |
  |  __dict__
  |      Return a new OrderedDict which maps field names to their values
  |
  |  x
  |      Alias for field number 0
  |
  |  y
  |      Alias for field number 1
  |
  |  ----------------------------------------------------------------------
  |  Data and other attributes defined here:
  |
  |  _fields = ('x', 'y')
  |
  |  ----------------------------------------------------------------------
  |  Methods inherited from __builtin__.tuple:
  |
  |  __add__(...)
  |      x.__add__(y) <==> x+y
  |
  |  __contains__(...)
  |      x.__contains__(y) <==> y in x
  |
  |  __eq__(...)
  |      x.__eq__(y) <==> x==y
  |
  |  __ge__(...)
  |      x.__ge__(y) <==> x>=y
  |
  |  __getattribute__(...)
  |      x.__getattribute__('name') <==> x.name
  |
  |  __getitem__(...)
  |      x.__getitem__(y) <==> x[y]
  |
  |  __getslice__(...)
  |      x.__getslice__(i, j) <==> x[i:j]
  |
  |      Use of negative indices is not supported.
  |
  |  __gt__(...)
  |      x.__gt__(y) <==> x>y
  |
  |  __hash__(...)
  |      x.__hash__() <==> hash(x)
  |
  |  __iter__(...)
  |      x.__iter__() <==> iter(x)
  |
  |  __le__(...)
  |      x.__le__(y) <==> x<=y
  |
  |  __len__(...)
  |      x.__len__() <==> len(x)
  |
  |  __lt__(...)
  |      x.__lt__(y) <==> x<y
  |
  |  __mul__(...)
  |      x.__mul__(n) <==> x*n
  |
  |  __ne__(...)
  |      x.__ne__(y) <==> x!=y
  |
  |  __rmul__(...)
  |      x.__rmul__(n) <==> n*x
  |
  |  __sizeof__(...)
  |      T.__sizeof__() -- size of T in memory, in bytes
  |
  |  count(...)
  |      T.count(value) -> integer -- return number of occurrences of value
  |
  |  index(...)
  |      T.index(value, [start, [stop]]) -> integer -- return first index of value.
  |      Raises ValueError if the value is not present.

 Mytuple

Mytuple

# t = (11,22,33,44)
#     #name age gender address
# print(t[0])
# print(t[2])
# t.name
# t.age

import collections
#创建类，等同于defaultdict
MytupleClass = collections.namedtuple('MytupleClass',['x', 'y', 'z'])
print(help(MytupleClass))
obj = MytupleClass(11,22,33)
print(obj.x)
print(obj.y)
print(obj.z)

5、Python双向队列deque

5、双向队列(deque)

一个线程安全的双向队列

 class deque(object):
     """
     deque([iterable[, maxlen]]) --> deque object

     Build an ordered collection with optimized access from its endpoints.
     """
     def append(self, *args, **kwargs): # real signature unknown
         """ Add an element to the right side of the deque. """
         pass

     def appendleft(self, *args, **kwargs): # real signature unknown
         """ Add an element to the left side of the deque. """
         pass

     def clear(self, *args, **kwargs): # real signature unknown
         """ Remove all elements from the deque. """
         pass

     def count(self, value): # real signature unknown; restored from __doc__
         """ D.count(value) -> integer -- return number of occurrences of value """
         return 0

     def extend(self, *args, **kwargs): # real signature unknown
         """ Extend the right side of the deque with elements from the iterable """
         pass

     def extendleft(self, *args, **kwargs): # real signature unknown
         """ Extend the left side of the deque with elements from the iterable """
         pass

     def pop(self, *args, **kwargs): # real signature unknown
         """ Remove and return the rightmost element. """
         pass

     def popleft(self, *args, **kwargs): # real signature unknown
         """ Remove and return the leftmost element. """
         pass

     def remove(self, value): # real signature unknown; restored from __doc__
         """ D.remove(value) -- remove first occurrence of value. """
         pass

     def reverse(self): # real signature unknown; restored from __doc__
         """ D.reverse() -- reverse *IN PLACE* """
         pass

     def rotate(self, *args, **kwargs): # real signature unknown
         """ Rotate the deque n steps to the right (default n=1).  If n is negative, rotates left. """
         pass

     def __copy__(self, *args, **kwargs): # real signature unknown
         """ Return a shallow copy of a deque. """
         pass

     def __delitem__(self, y): # real signature unknown; restored from __doc__
         """ x.__delitem__(y) <==> del x[y] """
         pass

     def __eq__(self, y): # real signature unknown; restored from __doc__
         """ x.__eq__(y) <==> x==y """
         pass

     def __getattribute__(self, name): # real signature unknown; restored from __doc__
         """ x.__getattribute__('name') <==> x.name """
         pass

     def __getitem__(self, y): # real signature unknown; restored from __doc__
         """ x.__getitem__(y) <==> x[y] """
         pass

     def __ge__(self, y): # real signature unknown; restored from __doc__
         """ x.__ge__(y) <==> x>=y """
         pass

     def __gt__(self, y): # real signature unknown; restored from __doc__
         """ x.__gt__(y) <==> x>y """
         pass

     def __iadd__(self, y): # real signature unknown; restored from __doc__
         """ x.__iadd__(y) <==> x+=y """
         pass

     def __init__(self, iterable=(), maxlen=None): # known case of _collections.deque.__init__
         """
         deque([iterable[, maxlen]]) --> deque object

         Build an ordered collection with optimized access from its endpoints.
         # (copied from class doc)
         """
         pass

     def __iter__(self): # real signature unknown; restored from __doc__
         """ x.__iter__() <==> iter(x) """
         pass

     def __len__(self): # real signature unknown; restored from __doc__
         """ x.__len__() <==> len(x) """
         pass

     def __le__(self, y): # real signature unknown; restored from __doc__
         """ x.__le__(y) <==> x<=y """
         pass

     def __lt__(self, y): # real signature unknown; restored from __doc__
         """ x.__lt__(y) <==> x<y """
         pass

     @staticmethod # known case of __new__
     def __new__(S, *more): # real signature unknown; restored from __doc__
         """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
         pass

     def __ne__(self, y): # real signature unknown; restored from __doc__
         """ x.__ne__(y) <==> x!=y """
         pass

     def __reduce__(self, *args, **kwargs): # real signature unknown
         """ Return state information for pickling. """
         pass

     def __repr__(self): # real signature unknown; restored from __doc__
         """ x.__repr__() <==> repr(x) """
         pass

     def __reversed__(self): # real signature unknown; restored from __doc__
         """ D.__reversed__() -- return a reverse iterator over the deque """
         pass

     def __setitem__(self, i, y): # real signature unknown; restored from __doc__
         """ x.__setitem__(i, y) <==> x[i]=y """
         pass

     def __sizeof__(self): # real signature unknown; restored from __doc__
         """ D.__sizeof__() -- size of D in memory, in bytes """
         pass

     maxlen = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
     """maximum size of a deque or None if unbounded"""

     __hash__ = None

 deque

deque

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

 class Queue:
     """Create a queue object with a given maximum size.

     If maxsize is <= 0, the queue size is infinite.
     """
     def __init__(self, maxsize=0):
         self.maxsize = maxsize
         self._init(maxsize)
         # mutex must be held whenever the queue is mutating.  All methods
         # that acquire mutex must release it before returning.  mutex
         # is shared between the three conditions, so acquiring and
         # releasing the conditions also acquires and releases mutex.
         self.mutex = _threading.Lock()
         # Notify not_empty whenever an item is added to the queue; a
         # thread waiting to get is notified then.
         self.not_empty = _threading.Condition(self.mutex)
         # Notify not_full whenever an item is removed from the queue;
         # a thread waiting to put is notified then.
         self.not_full = _threading.Condition(self.mutex)
         # Notify all_tasks_done whenever the number of unfinished tasks
         # drops to zero; thread waiting to join() is notified to resume
         self.all_tasks_done = _threading.Condition(self.mutex)
         self.unfinished_tasks = 0

     def task_done(self):
         """Indicate that a formerly enqueued task is complete.

         Used by Queue consumer threads.  For each get() used to fetch a task,
         a subsequent call to task_done() tells the queue that the processing
         on the task is complete.

         If a join() is currently blocking, it will resume when all items
         have been processed (meaning that a task_done() call was received
         for every item that had been put() into the queue).

         Raises a ValueError if called more times than there were items
         placed in the queue.
         """
         self.all_tasks_done.acquire()
         try:
             unfinished = self.unfinished_tasks - 1
             if unfinished <= 0:
                 if unfinished < 0:
                     raise ValueError('task_done() called too many times')
                 self.all_tasks_done.notify_all()
             self.unfinished_tasks = unfinished
         finally:
             self.all_tasks_done.release()

     def join(self):
         """Blocks until all items in the Queue have been gotten and processed.

         The count of unfinished tasks goes up whenever an item is added to the
         queue. The count goes down whenever a consumer thread calls task_done()
         to indicate the item was retrieved and all work on it is complete.

         When the count of unfinished tasks drops to zero, join() unblocks.
         """
         self.all_tasks_done.acquire()
         try:
             while self.unfinished_tasks:
                 self.all_tasks_done.wait()
         finally:
             self.all_tasks_done.release()

     def qsize(self):
         """Return the approximate size of the queue (not reliable!)."""
         self.mutex.acquire()
         n = self._qsize()
         self.mutex.release()
         return n

     def empty(self):
         """Return True if the queue is empty, False otherwise (not reliable!)."""
         self.mutex.acquire()
         n = not self._qsize()
         self.mutex.release()
         return n

     def full(self):
         """Return True if the queue is full, False otherwise (not reliable!)."""
         self.mutex.acquire()
         n = 0 < self.maxsize == self._qsize()
         self.mutex.release()
         return n

     def put(self, item, block=True, timeout=None):
         """Put an item into the queue.

         If optional args 'block' is true and 'timeout' is None (the default),
         block if necessary until a free slot is available. If 'timeout' is
         a non-negative number, it blocks at most 'timeout' seconds and raises
         the Full exception if no free slot was available within that time.
         Otherwise ('block' is false), put an item on the queue if a free slot
         is immediately available, else raise the Full exception ('timeout'
         is ignored in that case).
         """
         self.not_full.acquire()
         try:
             if self.maxsize > 0:
                 if not block:
                     if self._qsize() == self.maxsize:
                         raise Full
                 elif timeout is None:
                     while self._qsize() == self.maxsize:
                         self.not_full.wait()
                 elif timeout < 0:
                     raise ValueError("'timeout' must be a non-negative number")
                 else:
                     endtime = _time() + timeout
                     while self._qsize() == self.maxsize:
                         remaining = endtime - _time()
                         if remaining <= 0.0:
                             raise Full
                         self.not_full.wait(remaining)
             self._put(item)
             self.unfinished_tasks += 1
             self.not_empty.notify()
         finally:
             self.not_full.release()

     def put_nowait(self, item):
         """Put an item into the queue without blocking.

         Only enqueue the item if a free slot is immediately available.
         Otherwise raise the Full exception.
         """
         return self.put(item, False)

     def get(self, block=True, timeout=None):
         """Remove and return an item from the queue.

         If optional args 'block' is true and 'timeout' is None (the default),
         block if necessary until an item is available. If 'timeout' is
         a non-negative number, it blocks at most 'timeout' seconds and raises
         the Empty exception if no item was available within that time.
         Otherwise ('block' is false), return an item if one is immediately
         available, else raise the Empty exception ('timeout' is ignored
         in that case).
         """
         self.not_empty.acquire()
         try:
             if not block:
                 if not self._qsize():
                     raise Empty
             elif timeout is None:
                 while not self._qsize():
                     self.not_empty.wait()
             elif timeout < 0:
                 raise ValueError("'timeout' must be a non-negative number")
             else:
                 endtime = _time() + timeout
                 while not self._qsize():
                     remaining = endtime - _time()
                     if remaining <= 0.0:
                         raise Empty
                     self.not_empty.wait(remaining)
             item = self._get()
             self.not_full.notify()
             return item
         finally:
             self.not_empty.release()

     def get_nowait(self):
         """Remove and return an item from the queue without blocking.

         Only get an item if one is immediately available. Otherwise
         raise the Empty exception.
         """
         return self.get(False)

     # Override these methods to implement other queue organizations
     # (e.g. stack or priority queue).
     # These will only be called with appropriate locks held

     # Initialize the queue representation
     def _init(self, maxsize):
         self.queue = deque()

     def _qsize(self, len=len):
         return len(self.queue)

     # Put a new item in the queue
     def _put(self, item):
         self.queue.append(item)

     # Get an item from the queue
     def _get(self):
         return self.queue.popleft()

Queue.Queue

aaarticlea/png;base64,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" alt="" />

#双向队列
d = collections.deque()
d.append('1')
d.appendleft('10')
d.appendleft('1')
print(d)
r = d.count('1')
print(r)
d.extend(['yy','uu','ii'])
d.extendleft(['y1y','u1u','i1i'])
print(d)
d.rotate(5)
print(d)

6、Python单向队列deque

#单向队列
import queue
#d = collections.deque()
q = queue.Queue()
q.put('123')
q.put('789')
print(q.qsize())  #个数
print(q.get())   #拿数据

7、Python深浅拷贝原理

为什么要拷贝？

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

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

1 2 3

在修改数据时：     数字字符串：在内存中新建一份数据          集合：修改内存中的同一份数据

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

1

在内存中拷贝一份

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

1

深拷贝

深浅拷贝

对于 数字 和 字符串 而言，赋值、浅拷贝和深拷贝无意义，因为其永远指向同一个内存地址。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

import copy # ######### 数字、字符串 ######### n1 = 123 # n1 = "i am alex age 10" print(id(n1)) # ## 赋值 ## n2 = n1 print(id(n2)) # ## 浅拷贝 ## n2 = copy.copy(n1) print(id(n2)) # ## 深拷贝 ## n3 = copy.deepcopy(n1) print(id(n3))

对于字典、元祖、列表 而言，进行赋值、浅拷贝和深拷贝时，其内存地址的变化是不同的。

赋值，只是创建一个变量，该变量指向原来内存地址，如：

1 2 3

n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]} n2 = n1

浅拷贝，在内存中只额外创建第一层数据

1 2 3 4 5

import copy n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]} n3 = copy.copy(n1)

深拷贝，在内存中将所有的数据重新创建一份（排除最后一层，即：python内部对字符串和数字的优化）

1 2 3 4 5

import copy n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]} n4 = copy.deepcopy(n1)

8、Python深浅拷贝应用

aaarticlea/png;base64,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*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*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" alt="" />

import copy
# # #浅拷贝
# copy.copy()
# #深拷贝
# copy.deepcopy()
#  #赋值
#  # =

#字符串，数字
# a1 = "asdasda"
# #a2 = 123123
# a2 = a1
# print(id(a1))
# print(id(a2))
# a3 = copy.copy(a1)
# print(id(a1))
# print(id(a3))
#
# a3 = copy.deepcopy(a1)
# print(id(a1))
# print(id(a3))
# #字符串和数字读取的是内存的地址

#其他，元祖，列表，字典
# n1 = {"k1":"wu","k2":123,"k3":["alex",456]}
# n2=n1
# print(id(n1))
# print(id(n2))
# n3 = copy.copy(n1)
# n3 = copy.deepcopy(n1)
# print(id(n1))
# print(id(n3))
#
# print(id(n1['k3']))
# print(id(n3['k3']))

#实例应用：
dic = {
    "CPU":[80,],
    "mem0":[80,],
    "disk":[80,]
}
print('brefore',dic)
new_dic = copy.deepcopy(dic)
new_dic['CPU'][0] = 50
print(dic)
print(new_dic)

9、python函数的基本定义

一、背景

在学习函数之前，一直遵循：面向过程编程，即：根据业务逻辑从上到下实现功能，其往往用一长段代码来实现指定功能，开发过程中最常见的操作就是粘贴复制，也就是将之前实现的代码块复制到现需功能处，如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

while True：     if cpu利用率 > 90%:         #发送邮件提醒         连接邮箱服务器         发送邮件         关闭连接         if 硬盘使用空间 > 90%:         #发送邮件提醒         连接邮箱服务器         发送邮件         关闭连接         if 内存占用 > 80%:         #发送邮件提醒         连接邮箱服务器         发送邮件         关闭连接

腚眼一看上述代码，if条件语句下的内容可以被提取出来公用，如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

def 发送邮件(内容)     #发送邮件提醒     连接邮箱服务器     发送邮件     关闭连接     while True：         if cpu利用率 > 90%:         发送邮件('CPU报警')         if 硬盘使用空间 > 90%:         发送邮件('硬盘报警')         if 内存占用 > 80%:

对于上述的两种实现方式，第二次必然比第一次的重用性和可读性要好，其实这就是函数式编程和面向过程编程的区别：

• 函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
• 面向对象：对函数进行分类和封装，让开发“更快更好更强...”

函数式编程最重要的是增强代码的重用性和可读性

二、定义和使用

1 2 3 4 5

def 函数名(参数):            ...     函数体     ...

函数的定义主要有如下要点：

• def：表示函数的关键字
• 函数名：函数的名称，日后根据函数名调用函数
• 函数体：函数中进行一系列的逻辑计算，如：发送邮件、计算出 [11,22,38,888,2]中的最大数等...
• 参数：为函数体提供数据
• 返回值：当函数执行完毕后，可以给调用者返回数据。

以上要点中，比较重要有参数和返回值：

1、返回值

函数是一个功能块，该功能到底执行成功与否，需要通过返回值来告知调用者。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

def 发送短信():            发送短信的代码...        if 发送成功:         return True     else:         return False       while True:            # 每次执行发送短信函数，都会将返回值自动赋值给result     # 之后，可以根据result来写日志，或重发等操作        result = 发送短信()     if result == False:         记录日志，短信发送失败...

2、参数

为什么要有参数？

 def CPU报警邮件()
     #发送邮件提醒
     连接邮箱服务器
     发送邮件
     关闭连接

 def 硬盘报警邮件()
     #发送邮件提醒
     连接邮箱服务器
     发送邮件
     关闭连接

 def 内存报警邮件()
     #发送邮件提醒
     连接邮箱服务器
     发送邮件
     关闭连接

 while True：

     if cpu利用率 > 90%:
         CPU报警邮件（）

     if 硬盘使用空间 > 90%:
         硬盘报警邮件（）

     if 内存占用 > 80%:
         内存报警邮件（）

无参数实现

 def 发送邮件(邮件内容)

     #发送邮件提醒
     连接邮箱服务器
     发送邮件
     关闭连接

 while True：

     if cpu利用率 > 90%:
         发送邮件("CPU报警了。")

     if 硬盘使用空间 > 90%:
         发送邮件("硬盘报警了。")

     if 内存占用 > 80%:
         发送邮件("内存报警了。")

有参数实现

函数的有三中不同的参数：

• 普通参数
• 默认参数
• 动态参数

 # ######### 定义函数 ######### 

 # name 叫做函数func的形式参数，简称：形参
 def func(name):
     print name

 # ######### 执行函数 #########
 #  'wupeiqi' 叫做函数func的实际参数，简称：实参
 func('wupeiqi')

普通参数

 def func(name, age = 18):

     print "%s:%s" %(name,age)

 # 指定参数
 func('wupeiqi', 19)
 # 使用默认参数
 func('alex')

 注：默认参数需要放在参数列表最后

默认参数

 def func(*args):

     print args

 # 执行方式一
 func(11,33,4,4454,5)

 # 执行方式二
 li = [11,2,2,3,3,4,54]
 func(*li)

动态参数-序列

 def func(**kwargs):

     print args

 # 执行方式一
 func(name＝'wupeiqi',age=18)

 # 执行方式二
 li = {'name':'wupeiqi', age:18, 'gender':'male'}
 func(**li)

动态参数-字典

 def func(*args, **kwargs):

     print args
     print kwargs

动态参数-序列和字典

扩展：发送邮件实例

import smtplib
from email.mime.text import MIMEText
from email.utils import formataddr

msg = MIMEText('邮件内容', 'plain', 'utf-8')
msg['From'] = formataddr(["武沛齐",'[e-mail]'])
msg['To'] = formataddr(["走人",'[e-mail]'])
msg['Subject'] = "主题"

server = smtplib.SMTP("smtp.126.com", 25)
server.login("[e-mail]", "邮箱密码")
server.sendmail('[e-mail]', ['[e-mail]',], msg.as_string())
server.quit()

内置函数

注：查看详细猛击这里

open函数，该函数用于文件处理

操作文件时，一般需要经历如下步骤：

• 打开文件
• 操作文件

一、打开文件

1	文件句柄 = open('文件路径', '模式')

打开文件时，需要指定文件路径和以何等方式打开文件，打开后，即可获取该文件句柄，日后通过此文件句柄对该文件操作。

打开文件的模式有：

• r，只读模式（默认）。
• w，只写模式。【不可读；不存在则创建；存在则删除内容；】
• a，追加模式。【可读；   不存在则创建；存在则只追加内容；】

"+" 表示可以同时读写某个文件

• r+，可读写文件。【可读；可写；可追加】
• w+，写读
• a+，同a

"U"表示在读取时，可以将 \r \n \r\n自动转换成 \n （与 r 或 r+ 模式同使用）

• rU
• r+U

"b"表示处理二进制文件（如：FTP发送上传ISO镜像文件，linux可忽略，windows处理二进制文件时需标注）

• rb
• wb
• ab

   class file(object)
       def close(self): # real signature unknown; restored from __doc__
           关闭文件
           """
           close() -> None or (perhaps) an integer.  Close the file.
  
           Sets data attribute .closed to True.  A closed file cannot be used for
           further I/O operations.  close() may be called more than once without
           error.  Some kinds of file objects (for example, opened by popen())
           may return an exit status upon closing.
           """
  
       def fileno(self): # real signature unknown; restored from __doc__
           文件描述符
            """
           fileno() -> integer "file descriptor".
  
           This is needed for lower-level file interfaces, such os.read().
           """
           return 0    
  
       def flush(self): # real signature unknown; restored from __doc__
           刷新文件内部缓冲区
           """ flush() -> None.  Flush the internal I/O buffer. """
           pass
  
       def isatty(self): # real signature unknown; restored from __doc__
           判断文件是否是同意tty设备
           """ isatty() -> true or false.  True if the file is connected to a tty device. """
           return False
  
       def next(self): # real signature unknown; restored from __doc__
           获取下一行数据，不存在，则报错
           """ x.next() -> the next value, or raise StopIteration """
           pass
  
       def read(self, size=None): # real signature unknown; restored from __doc__
           读取指定字节数据
           """
           read([size]) -> read at most size bytes, returned as a string.
  
           If the size argument is negative or omitted, read until EOF is reached.
           Notice that when in non-blocking mode, less data than what was requested
           may be returned, even if no size parameter was given.
           """
           pass
  
       def readinto(self): # real signature unknown; restored from __doc__
           读取到缓冲区，不要用，将被遗弃
           """ readinto() -> Undocumented.  Don't use this; it may go away. """
           pass
  
       def readline(self, size=None): # real signature unknown; restored from __doc__
           仅读取一行数据
           """
           readline([size]) -> next line from the file, as a string.
  
           Retain newline.  A non-negative size argument limits the maximum
           number of bytes to return (an incomplete line may be returned then).
           Return an empty string at EOF.
           """
           pass
  
       def readlines(self, size=None): # real signature unknown; restored from __doc__
           读取所有数据，并根据换行保存值列表
           """
           readlines([size]) -> list of strings, each a line from the file.
  
           Call readline() repeatedly and return a list of the lines so read.
           The optional size argument, if given, is an approximate bound on the
           total number of bytes in the lines returned.
           """
           return []
  
       def seek(self, offset, whence=None): # real signature unknown; restored from __doc__
           指定文件中指针位置
           """
           seek(offset[, whence]) -> None.  Move to new file position.
  
           Argument offset is a byte count.  Optional argument whence defaults to
   (offset from start of file, offset should be >= 0); other values are 1
           (move relative to current position, positive or negative), and 2 (move
           relative to end of file, usually negative, although many platforms allow
           seeking beyond the end of a file).  If the file is opened in text mode,
           only offsets returned by tell() are legal.  Use of other offsets causes
           undefined behavior.
           Note that not all file objects are seekable.
           """
           pass
  
       def tell(self): # real signature unknown; restored from __doc__
           获取当前指针位置
           """ tell() -> current file position, an integer (may be a long integer). """
           pass
  
       def truncate(self, size=None): # real signature unknown; restored from __doc__
           截断数据，仅保留指定之前数据
           """
           truncate([size]) -> None.  Truncate the file to at most size bytes.
  
           Size defaults to the current file position, as returned by tell().
           """
           pass
  
       def write(self, p_str): # real signature unknown; restored from __doc__
           写内容
           """
           write(str) -> None.  Write string str to file.
  
           Note that due to buffering, flush() or close() may be needed before
           the file on disk reflects the data written.
           """
           pass
  
       def writelines(self, sequence_of_strings): # real signature unknown; restored from __doc__
           将一个字符串列表写入文件
           """
           writelines(sequence_of_strings) -> None.  Write the strings to the file.
  
           Note that newlines are not added.  The sequence can be any iterable object
           producing strings. This is equivalent to calling write() for each string.
           """
           pass
  
       def xreadlines(self): # real signature unknown; restored from __doc__
           可用于逐行读取文件，非全部
           """
           xreadlines() -> returns self.
  
           For backward compatibility. File objects now include the performance
           optimizations previously implemented in the xreadlines module.
           """
           pass

   class file(object)
       def close(self): # real signature unknown; restored from __doc__
           关闭文件
           """
           close() -> None or (perhaps) an integer.  Close the file.
  
           Sets data attribute .closed to True.  A closed file cannot be used for
           further I/O operations.  close() may be called more than once without
           error.  Some kinds of file objects (for example, opened by popen())
           may return an exit status upon closing.
           """
  
       def fileno(self): # real signature unknown; restored from __doc__
           文件描述符
            """
           fileno() -> integer "file descriptor".
  
           This is needed for lower-level file interfaces, such os.read().
           """
           return 0    
  
       def flush(self): # real signature unknown; restored from __doc__
           刷新文件内部缓冲区
           """ flush() -> None.  Flush the internal I/O buffer. """
           pass
  
       def isatty(self): # real signature unknown; restored from __doc__
           判断文件是否是同意tty设备
           """ isatty() -> true or false.  True if the file is connected to a tty device. """
           return False
  
       def next(self): # real signature unknown; restored from __doc__
           获取下一行数据，不存在，则报错
           """ x.next() -> the next value, or raise StopIteration """
           pass
  
       def read(self, size=None): # real signature unknown; restored from __doc__
           读取指定字节数据
           """
           read([size]) -> read at most size bytes, returned as a string.
  
           If the size argument is negative or omitted, read until EOF is reached.
           Notice that when in non-blocking mode, less data than what was requested
           may be returned, even if no size parameter was given.
           """
           pass
  
       def readinto(self): # real signature unknown; restored from __doc__
           读取到缓冲区，不要用，将被遗弃
           """ readinto() -> Undocumented.  Don't use this; it may go away. """
           pass
  
       def readline(self, size=None): # real signature unknown; restored from __doc__
           仅读取一行数据
           """
           readline([size]) -> next line from the file, as a string.
  
           Retain newline.  A non-negative size argument limits the maximum
           number of bytes to return (an incomplete line may be returned then).
           Return an empty string at EOF.
           """
           pass
  
       def readlines(self, size=None): # real signature unknown; restored from __doc__
           读取所有数据，并根据换行保存值列表
           """
           readlines([size]) -> list of strings, each a line from the file.
  
           Call readline() repeatedly and return a list of the lines so read.
           The optional size argument, if given, is an approximate bound on the
           total number of bytes in the lines returned.
           """
           return []
  
       def seek(self, offset, whence=None): # real signature unknown; restored from __doc__
           指定文件中指针位置
           """
           seek(offset[, whence]) -> None.  Move to new file position.
  
           Argument offset is a byte count.  Optional argument whence defaults to
   (offset from start of file, offset should be >= 0); other values are 1
           (move relative to current position, positive or negative), and 2 (move
           relative to end of file, usually negative, although many platforms allow
           seeking beyond the end of a file).  If the file is opened in text mode,
           only offsets returned by tell() are legal.  Use of other offsets causes
           undefined behavior.
           Note that not all file objects are seekable.
           """
           pass
  
       def tell(self): # real signature unknown; restored from __doc__
           获取当前指针位置
           """ tell() -> current file position, an integer (may be a long integer). """
           pass
  
       def truncate(self, size=None): # real signature unknown; restored from __doc__
           截断数据，仅保留指定之前数据
           """
           truncate([size]) -> None.  Truncate the file to at most size bytes.
  
           Size defaults to the current file position, as returned by tell().
           """
           pass
  
       def write(self, p_str): # real signature unknown; restored from __doc__
           写内容
           """
           write(str) -> None.  Write string str to file.
  
           Note that due to buffering, flush() or close() may be needed before
           the file on disk reflects the data written.
           """
           pass
  
       def writelines(self, sequence_of_strings): # real signature unknown; restored from __doc__
           将一个字符串列表写入文件
           """
           writelines(sequence_of_strings) -> None.  Write the strings to the file.
  
           Note that newlines are not added.  The sequence can be any iterable object
           producing strings. This is equivalent to calling write() for each string.
           """
           pass
  
       def xreadlines(self): # real signature unknown; restored from __doc__
           可用于逐行读取文件，非全部
           """
           xreadlines() -> returns self.
  
           For backward compatibility. File objects now include the performance
           optimizations previously implemented in the xreadlines module.
           """
           

二、操作

 class file(object)
     def close(self): # real signature unknown; restored from __doc__
         关闭文件
         """
         close() -> None or (perhaps) an integer.  Close the file.

         Sets data attribute .closed to True.  A closed file cannot be used for
         further I/O operations.  close() may be called more than once without
         error.  Some kinds of file objects (for example, opened by popen())
         may return an exit status upon closing.
         """

     def fileno(self): # real signature unknown; restored from __doc__
         文件描述符
          """
         fileno() -> integer "file descriptor".

         This is needed for lower-level file interfaces, such os.read().
         """
         return 0    

     def flush(self): # real signature unknown; restored from __doc__
         刷新文件内部缓冲区
         """ flush() -> None.  Flush the internal I/O buffer. """
         pass

     def isatty(self): # real signature unknown; restored from __doc__
         判断文件是否是同意tty设备
         """ isatty() -> true or false.  True if the file is connected to a tty device. """
         return False

     def next(self): # real signature unknown; restored from __doc__
         获取下一行数据，不存在，则报错
         """ x.next() -> the next value, or raise StopIteration """
         pass

     def read(self, size=None): # real signature unknown; restored from __doc__
         读取指定字节数据
         """
         read([size]) -> read at most size bytes, returned as a string.

         If the size argument is negative or omitted, read until EOF is reached.
         Notice that when in non-blocking mode, less data than what was requested
         may be returned, even if no size parameter was given.
         """
         pass

     def readinto(self): # real signature unknown; restored from __doc__
         读取到缓冲区，不要用，将被遗弃
         """ readinto() -> Undocumented.  Don't use this; it may go away. """
         pass

     def readline(self, size=None): # real signature unknown; restored from __doc__
         仅读取一行数据
         """
         readline([size]) -> next line from the file, as a string.

         Retain newline.  A non-negative size argument limits the maximum
         number of bytes to return (an incomplete line may be returned then).
         Return an empty string at EOF.
         """
         pass

     def readlines(self, size=None): # real signature unknown; restored from __doc__
         读取所有数据，并根据换行保存值列表
         """
         readlines([size]) -> list of strings, each a line from the file.

         Call readline() repeatedly and return a list of the lines so read.
         The optional size argument, if given, is an approximate bound on the
         total number of bytes in the lines returned.
         """
         return []

     def seek(self, offset, whence=None): # real signature unknown; restored from __doc__
         指定文件中指针位置
         """
         seek(offset[, whence]) -> None.  Move to new file position.

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

     def tell(self): # real signature unknown; restored from __doc__
         获取当前指针位置
         """ tell() -> current file position, an integer (may be a long integer). """
         pass

     def truncate(self, size=None): # real signature unknown; restored from __doc__
         截断数据，仅保留指定之前数据
         """
         truncate([size]) -> None.  Truncate the file to at most size bytes.

         Size defaults to the current file position, as returned by tell().
         """
         pass

     def write(self, p_str): # real signature unknown; restored from __doc__
         写内容
         """
         write(str) -> None.  Write string str to file.

         Note that due to buffering, flush() or close() may be needed before
         the file on disk reflects the data written.
         """
         pass

     def writelines(self, sequence_of_strings): # real signature unknown; restored from __doc__
         将一个字符串列表写入文件
         """
         writelines(sequence_of_strings) -> None.  Write the strings to the file.

         Note that newlines are not added.  The sequence can be any iterable object
         producing strings. This is equivalent to calling write() for each string.
         """
         pass

     def xreadlines(self): # real signature unknown; restored from __doc__
         可用于逐行读取文件，非全部
         """
         xreadlines() -> returns self.

         For backward compatibility. File objects now include the performance
         optimizations previously implemented in the xreadlines module.
         """
         pass

Python 2.x

 class TextIOWrapper(_TextIOBase):
     """
     Character and line based layer over a BufferedIOBase object, buffer.

     encoding gives the name of the encoding that the stream will be
     decoded or encoded with. It defaults to locale.getpreferredencoding(False).

     errors determines the strictness of encoding and decoding (see
     help(codecs.Codec) or the documentation for codecs.register) and
     defaults to "strict".

     newline controls how line endings are handled. It can be None, '',
     '\n', '\r', and '\r\n'.  It works as follows:

     * On input, if newline is None, universal newlines mode is
       enabled. Lines in the input can end in '\n', '\r', or '\r\n', and
       these are translated into '\n' before being returned to the
       caller. If it is '', universal newline mode is enabled, but line
       endings are returned to the caller untranslated. If it has any of
       the other legal values, input lines are only terminated by the given
       string, and the line ending is returned to the caller untranslated.

     * On output, if newline is None, any '\n' characters written are
       translated to the system default line separator, os.linesep. If
       newline is '' or '\n', no translation takes place. If newline is any
       of the other legal values, any '\n' characters written are translated
       to the given string.

     If line_buffering is True, a call to flush is implied when a call to
     write contains a newline character.
     """
     def close(self, *args, **kwargs): # real signature unknown
         关闭文件
         pass

     def fileno(self, *args, **kwargs): # real signature unknown
         文件描述符
         pass

     def flush(self, *args, **kwargs): # real signature unknown
         刷新文件内部缓冲区
         pass

     def isatty(self, *args, **kwargs): # real signature unknown
         判断文件是否是同意tty设备
         pass

     def read(self, *args, **kwargs): # real signature unknown
         读取指定字节数据
         pass

     def readable(self, *args, **kwargs): # real signature unknown
         是否可读
         pass

     def readline(self, *args, **kwargs): # real signature unknown
         仅读取一行数据
         pass

     def seek(self, *args, **kwargs): # real signature unknown
         指定文件中指针位置
         pass

     def seekable(self, *args, **kwargs): # real signature unknown
         指针是否可操作
         pass

     def tell(self, *args, **kwargs): # real signature unknown
         获取指针位置
         pass

     def truncate(self, *args, **kwargs): # real signature unknown
         截断数据，仅保留指定之前数据
         pass

     def writable(self, *args, **kwargs): # real signature unknown
         是否可写
         pass

     def write(self, *args, **kwargs): # real signature unknown
         写内容
         pass

     def __getstate__(self, *args, **kwargs): # real signature unknown
         pass

     def __init__(self, *args, **kwargs): # real signature unknown
         pass

     @staticmethod # known case of __new__
     def __new__(*args, **kwargs): # real signature unknown
         """ Create and return a new object.  See help(type) for accurate signature. """
         pass

     def __next__(self, *args, **kwargs): # real signature unknown
         """ Implement next(self). """
         pass

     def __repr__(self, *args, **kwargs): # real signature unknown
         """ Return repr(self). """
         pass

     buffer = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

     closed = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

     encoding = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

     errors = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

     line_buffering = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

     name = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

     newlines = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

     _CHUNK_SIZE = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

     _finalizing = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

Python 3.x

三、管理上下文

为了避免打开文件后忘记关闭，可以通过管理上下文，即：

1 2 3

with open('log','r') as f:             ...

如此方式，当with代码块执行完毕时，内部会自动关闭并释放文件资源。

在Python 2.7 后，with又支持同时对多个文件的上下文进行管理，即：

1 2	with open('log1') as obj1, open('log2') as obj2:     pass

lambda表达式

学习条件运算时，对于简单的 if else 语句，可以使用三元运算来表示，即：

1 2 3 4 5 6 7 8

# 普通条件语句 if 1 == 1:     name = 'wupeiqi' else:     name = 'alex'     # 三元运算 name = 'wupeiqi' if 1 == 1 else 'alex'

对于简单的函数，也存在一种简便的表示方式，即：lambda表达式

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

# ###################### 普通函数 ###################### # 定义函数（普通方式） def func(arg):     return arg + 1     # 执行函数 result = func(123)     # ###################### lambda ######################     # 定义函数（lambda表达式） my_lambda = lambda arg : arg + 1     # 执行函数 result = my_lambda(123)

lambda存在意义就是对简单函数的简洁表示

递归

利用函数编写如下数列：

斐波那契数列指的是这样一个数列 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，10946，17711，28657，46368...

1 2 3 4 5 6 7 8

def func(arg1,arg2):     if arg1 == 0:         print arg1, arg2     arg3 = arg1 + arg2     print arg3     func(arg2, arg3) func(0,1)

装饰器

装饰器是函数，只不过该函数可以具有特殊的含义，装饰器用来装饰函数或类，使用装饰器可以在函数执行前和执行后添加相应操作。

1 2 3 4 5 6 7 8 9 10

def wrapper(func):     def result():         print 'before'         func()         print 'after'     return result    @wrapper def foo():     print 'foo'

 import functools

 def wrapper(func):
     @functools.wraps(func)
     def wrapper():
         print 'before'
         func()
         print 'after'
     return wrapper

 @wrapper
 def foo():
     print 'foo'

详细猛击这里