[Python进阶]Python builtin 函数及重要知识点学习笔记（一）

时间：2020-05-03 17:57:56 阅读：64 评论：0 收藏：0 [点我收藏+]

《Python进阶》学习笔记

1. *args 和 **kwargs

*args 是用来发送一定长度的键值对, 作为参数传递给一个函数。

2. 调试 Debugging

命令行使用Python debugger运行一个脚本： $ python -m pdb my_script.py

pdb模块（断点调试）用法：

　　import pdb

　　功能：断点设置，单步执行，查看代码，查看函数，追踪变量等

　　pdb.set_trace()

　　功能：设置初始断点，开始进入pdb调试模式

调试中的命令

　　break ， b 设置断点

　　continue ，c 继续执行

w ，显示当前正在执行的代码行的上下文信息

　　list ， l 查看当前代码段

　　next， n 单步执行

　　step， s 进入函数单步执行

　　pp 打印变量值

　　help 帮助

　　q 退出调试

　　exit 退出pdb调试

3. set 数据结构

交集：你可以对比两个集合的交集（两个集合中都有的数据）

set_a.intersection(set_b) : set_a和set_b共同拥有的元素，以set形式返回；

差集：你可以用差集(difference)找出无效的数据，相当于用一个集合减去另一个集合的数据

set_a.difference(set_b) : set_a减去set_b，相当于set_a单独拥有的元素，以set形式返回；

也可以用{}符号来创建集合，如：

a_set = {‘red‘, ‘blue‘, ‘green‘}
print(type(a_set))
### 输出: <type ‘set‘>

4. slots魔法方法

__slots__来告诉Python，当一个类需要创建大量实例时，可以通过__slots__声明实例所需要的属性，不要使用字典，而且只给一个固定集合的属性分配空间。

这样做带来以下优点：

更快的属性访问速度
减少内存消耗
利用这种特性来限制实例的属性。

默认情况下，访问一个实例的属性是通过访问该实例的__dict__来实现的。如访问a.x就相当于访问a.__dict__[‘x‘]。为了便于理解，我粗略地将它拆分为四步：

a.x 2. a.__dict__ 3. a.__dict__[‘x‘] 4. 结果

从__slots__的实现可以得知，定义了__slots__的类会为每个属性创建一个描述器。访问属性时就直接调用这个描述器。在这里我将它拆分为三步：

b.x 2. member decriptor 3. 结果

我在上文提到，访问__dict__和描述器的速度是相近的，而通过__dict__访问属性多了a.__dict__[‘x‘]字典访值一步（一个哈希函数的消耗）。由此可以推断出，使用了__slots__的类的属性访问速度比没有使用的要快。

[参考文章：Python__slots__详解 - rainfd - 博客园 https://www.cnblogs.com/rainfd/p/slots.html]

5. 容器数据类型 Collections

重点：

5.1 defaultdict ：字典的子类，提供了一个工厂函数，为字典查询提供一个默认值；

文档：

  1 Help on class defaultdict in module collections:
  2 
  3 class defaultdict(builtins.dict)
  4 
  5  |  defaultdict(default_factory[, ...]) --> dict with default factory .The default factory is called without arguments to produce
  6 
  7  |  a new value when a key is not present, in __getitem__ only. A defaultdict compares equal to a dict with the same items.
  8 
  9  |  All remaining arguments are treated the same as if they were passed to the dict constructor, including keyword arguments.
 10 
 11  |  Method resolution order:
 12 
 13  |      defaultdict
 14 
 15  |      builtins.dict
 16 
 17  |      builtins.object
 18 
 19  |  Methods defined here:
 20 
 21  |  __copy__(...)
 22 
 23  |      D.copy() -> a shallow copy of D.
 24 
 25  |  __getattribute__(self, name, /)
 26 
 27  |      Return getattr(self, name).
 28 
 29  |  __init__(self, /, *args, **kwargs)
 30 
 31  |      Initialize self.  See help(type(self)) for accurate signature.
 32 
 33  |  __missing__(...)
 34 
 35  |      __missing__(key) # Called by __getitem__ for missing key; pseudo-code:
 36 
 37  |      if self.default_factory is None: raise KeyError((key,))
 38 
 39  |      self[key] = value = self.default_factory()
 40 
 41  |      return value
 42 
 43  |  __reduce__(...)
 44 
 45  |      Return state information for pickling.
 46 
 47  |  __repr__(self, /)
 48 
 49  |      Return repr(self).
 50 
 51  |  copy(...)
 52 
 53  |      D.copy() -> a shallow copy of D.
 54 
 55  |  ----------------------------------------------------------------------
 56 
 57  |  Data descriptors defined here:
 58 
 59  |  default_factory
 60 
 61  |      Factory for default value called by __missing__().
 62 
 63  |  ----------------------------------------------------------------------
 64 
 65  |  Methods inherited from builtins.dict:
 66 
 67  |  __contains__(self, key, /)
 68 
 69  |      True if the dictionary has the specified key, else False.
 70 
 71  |  __delitem__(self, key, /)
 72 
 73  |      Delete self[key].
 74 
 75  |  __eq__(self, value, /)
 76 
 77  |      Return self==value.
 78 
 79  |  __ge__(self, value, /)
 80 
 81  |      Return self>=value.
 82 
 83  |  __getitem__(...)
 84 
 85  |      x.__getitem__(y) <==> x[y]
 86 
 87  |  __gt__(self, value, /)
 88 
 89  |      Return self>value.
 90 
 91  |  __iter__(self, /)
 92 
 93  |      Implement iter(self).
 94 
 95  |  __le__(self, value, /)
 96 
 97  |      Return self<=value.
 98 
 99  |  __len__(self, /)
100 
101  |      Return len(self).
102 
103  |  __lt__(self, value, /)
104 
105  |      Return self<value.
106 
107  |  __ne__(self, value, /)
108 
109  |      Return self!=value.
110 
111  |  __setitem__(self, key, value, /)
112 
113  |      Set self[key] to value.
114 
115  |  __sizeof__(...)
116 
117  |      D.__sizeof__() -> size of D in memory, in bytes
118 
119  |  clear(...)
120 
121  |      D.clear() -> None.  Remove all items from D.
122 
123  |  get(self, key, default=None, /)
124 
125  |      Return the value for key if key is in the dictionary, else default.
126 
127  |  items(...)
128 
129  |      D.items() -> a set-like object providing a view on D‘s items
130 
131  |  keys(...)
132 
133  |      D.keys() -> a set-like object providing a view on D‘s keys
134 
135  |  pop(...)
136 
137  |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
138 
139  |      If key is not found, d is returned if given, otherwise KeyError is raised
140 
141  |  popitem(...)
142 
143  |      D.popitem() -> (k, v), remove and return some (key, value) pair as a
144 
145  |      2-tuple; but raise KeyError if D is empty.
146 
147  |  setdefault(self, key, default=None, /)
148 
149  |      Insert key with a value of default if key is not in the dictionary.
150 
151  |      Return the value for key if key is in the dictionary, else default.
152 
153  |  update(...)
154 
155  |      D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
156 
157  |      If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
158 
159  |      If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
160 
161  |      In either case, this is followed by: for k in F:  D[k] = F[k]
162 
163  |  values(...)
164 
165  |      D.values() -> an object providing a view on D‘s values
166 
167  |  ----------------------------------------------------------------------
168 
169  |  Class methods inherited from builtins.dict:
170 
171  |  fromkeys(iterable, value=None, /) from builtins.type
172 
173  |      Create a new dictionary with keys from iterable and values set to value.
174 
175  |  ----------------------------------------------------------------------
176 
177  |  Static methods inherited from builtins.dict:
178 
179  |  __new__(*args, **kwargs) from builtins.type
180 
181  |      Create and return a new object.  See help(type) for accurate signature.
182 
183  |  ----------------------------------------------------------------------
184 
185  |  Data and other attributes inherited from builtins.dict:
186 
187  |  __hash__ = None

View Code

与一般dict区别：标准字典包括setdefault方法()获取一个值，如果值不存在，建立一个默认；

相比之下,defaultdict允许调用者在初始化时预先设置默认值。

>>> from collections import defaultdict
>>> dd = defaultdict(lambda: ‘N/A‘)
>>> dd[‘key1‘] = ‘abc‘ 
>>> dd[‘key1‘] # key1存在
‘abc‘
>>> dd[‘key2‘] # key2不存在，返回默认值
‘N/A‘

使用dict时，如果引用的Key不存在，就会抛出KeyError。如果希望key不存在时，返回一个默认值，就可以用defaultdict

注意：默认值是调用函数返回的，而函数在创建defaultdict对象时传入。

5.2 Counter：字典的子类，提供了可哈希对象的计数功能

文档：

  1 class Counter(builtins.dict)
  2 
  3  |  Counter(*args, **kwds)
  4 
  5  |  Dict subclass for counting hashable items.  Sometimes called a bag
  6 
  7  |  or multiset.  Elements are stored as dictionary keys and their counts
  8 
  9  |  are stored as dictionary values.
 10 
 11  |  >>> c = Counter(‘abcdeabcdabcaba‘)  # count elements from a string
 12 
 13  |  >>> c.most_common(3)                # three most common elements
 14 
 15  |  [(‘a‘, 5), (‘b‘, 4), (‘c‘, 3)]
 16 
 17  |  >>> sorted(c)                       # list all unique elements
 18 
 19  |  [‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘]
 20 
 21  |  >>> ‘‘.join(sorted(c.elements()))   # list elements with repetitions
 22 
 23  |  ‘aaaaabbbbcccdde‘
 24 
 25  |  >>> sum(c.values())                 # total of all counts
 26 
 27  |  15
 28 
 29  |  >>> c[‘a‘]                          # count of letter ‘a‘
 30 
 31  |  5
 32 
 33  |  >>> for elem in ‘shazam‘:           # update counts from an iterable
 34 
 35  |  ...     c[elem] += 1                # by adding 1 to each element‘s count
 36 
 37  |  >>> c[‘a‘]                          # now there are seven ‘a‘
 38 
 39  |  7
 40 
 41  |  >>> del c[‘b‘]                      # remove all ‘b‘
 42 
 43  |  >>> c[‘b‘]                          # now there are zero ‘b‘
 44 
 45  |  0
 46 
 47  |  >>> d = Counter(‘simsalabim‘)       # make another counter
 48 
 49  |  >>> c.update(d)                     # add in the second counter
 50 
 51  |  >>> c[‘a‘]                          # now there are nine ‘a‘
 52 
 53  |  9
 54 
 55  |  >>> c.clear()                       # empty the counter
 56 
 57  |  >>> c
 58 
 59  |  Counter()
 60 
 61  |  Note:  If a count is set to zero or reduced to zero, it will remain
 62 
 63  |  in the counter until the entry is deleted or the counter is cleared:
 64 
 65  |  >>> c = Counter(‘aaabbc‘)
 66 
 67  |  >>> c[‘b‘] -= 2                     # reduce the count of ‘b‘ by two
 68 
 69  |  >>> c.most_common()                 # ‘b‘ is still in, but its count is zero
 70 
 71  |  [(‘a‘, 3), (‘c‘, 1), (‘b‘, 0)]
 72 
 73  |  Method resolution order:
 74 
 75  |      Counter
 76 
 77  |      builtins.dict
 78 
 79  |      builtins.object
 80 
 81  |  Methods defined here:
 82 
 83  |  __add__(self, other)
 84 
 85  |      Add counts from two counters.
 86 
 87  |      >>> Counter(‘abbb‘) + Counter(‘bcc‘)
 88 
 89  |      Counter({‘b‘: 4, ‘c‘: 2, ‘a‘: 1})
 90 
 91  |  __and__(self, other)
 92 
 93  |      Intersection is the minimum of corresponding counts.
 94 
 95  |      >>> Counter(‘abbb‘) & Counter(‘bcc‘)
 96 
 97  |      Counter({‘b‘: 1})
 98 
 99  |  __delitem__(self, elem)
100 
101  |      Like dict.__delitem__() but does not raise KeyError for missing values.
102 
103  |  __iadd__(self, other)
104 
105  |      Inplace add from another counter, keeping only positive counts.
106 
107  |      >>> c = Counter(‘abbb‘)
108 
109  |      >>> c += Counter(‘bcc‘)
110 
111  |      >>> c
112 
113  |      Counter({‘b‘: 4, ‘c‘: 2, ‘a‘: 1})
114 
115  |  __iand__(self, other)
116 
117  |      Inplace intersection is the minimum of corresponding counts.
118 
119  |      >>> c = Counter(‘abbb‘)
120 
121  |      >>> c &= Counter(‘bcc‘)
122 
123  |      >>> c
124 
125  |      Counter({‘b‘: 1})
126 
127  |  __init__(*args, **kwds)
128 
129  |      Create a new, empty Counter object.  And if given, count elements
130 
131  |      from an input iterable.  Or, initialize the count from another mapping
132 
133  |      of elements to their counts.
134 
135  |      >>> c = Counter()                           # a new, empty counter
136 
137  |      >>> c = Counter(‘gallahad‘)                 # a new counter from an iterable
138 
139  |      >>> c = Counter({‘a‘: 4, ‘b‘: 2})           # a new counter from a mapping
140 
141  |      >>> c = Counter(a=4, b=2)                   # a new counter from keyword args
142 
143  |  __ior__(self, other)
144 
145  |      Inplace union is the maximum of value from either counter.
146 
147  |      >>> c = Counter(‘abbb‘)
148 
149  |      >>> c |= Counter(‘bcc‘)
150 
151  |      >>> c
152 
153  |      Counter({‘b‘: 3, ‘c‘: 2, ‘a‘: 1})
154 
155  |  __isub__(self, other)
156 
157  |      Inplace subtract counter, but keep only results with positive counts.
158 
159  |      >>> c = Counter(‘abbbc‘)
160 
161  |      >>> c -= Counter(‘bccd‘)
162 
163  |      >>> c
164 
165  |      Counter({‘b‘: 2, ‘a‘: 1})
166 
167  |  __missing__(self, key)
168 
169  |      The count of elements not in the Counter is zero.
170 
171  |  __neg__(self)
172 
173  |      Subtracts from an empty counter.  Strips positive and zero counts,
174 
175  |      and flips the sign on negative counts.
176 
177  |  __or__(self, other)
178 
179  |      Union is the maximum of value in either of the input counters.
180 
181  |      >>> Counter(‘abbb‘) | Counter(‘bcc‘)
182 
183  |      Counter({‘b‘: 3, ‘c‘: 2, ‘a‘: 1})
184 
185  |  __pos__(self)
186 
187  |      Adds an empty counter, effectively stripping negative and zero counts
188 
189  |  __reduce__(self)
190 
191  |      Helper for pickle.
192 
193  |  __repr__(self)
194 
195  |      Return repr(self).
196 
197  |  __sub__(self, other)
198 
199  |      Subtract count, but keep only results with positive counts.
200 
201  |      >>> Counter(‘abbbc‘) - Counter(‘bccd‘)
202 
203  |      Counter({‘b‘: 2, ‘a‘: 1})
204 
205  |  copy(self)
206 
207  |      Return a shallow copy.
208 
209  |  elements(self)
210 
211  |      Iterator over elements repeating each as many times as its count.
212 
213  |      >>> c = Counter(‘ABCABC‘)
214 
215  |      >>> sorted(c.elements())
216 
217  |      [‘A‘, ‘A‘, ‘B‘, ‘B‘, ‘C‘, ‘C‘]
218 
219  |      # Knuth‘s example for prime factors of 1836:  2**2 * 3**3 * 17**1
220 
221  |      >>> prime_factors = Counter({2: 2, 3: 3, 17: 1})
222 
223  |      >>> product = 1
224 
225  |      >>> for factor in prime_factors.elements():     # loop over factors
226 
227  |      ...     product *= factor                       # and multiply them
228 
229  |      >>> product
230 
231  |      1836
232 
233  |      Note, if an element‘s count has been set to zero or is a negative
234 
235  |      number, elements() will ignore it.
236 
237  |  most_common(self, n=None)
238 
239  |      List the n most common elements and their counts from the most
240 
241  |      common to the least.  If n is None, then list all element counts.
242 
243  |      >>> Counter(‘abcdeabcdabcaba‘).most_common(3)
244 
245  |      [(‘a‘, 5), (‘b‘, 4), (‘c‘, 3)]
246 
247  |  subtract(*args, **kwds)
248 
249  |      Like dict.update() but subtracts counts instead of replacing them.
250 
251  |      Counts can be reduced below zero.  Both the inputs and outputs are
252 
253  |      allowed to contain zero and negative counts.
254 
255  |      Source can be an iterable, a dictionary, or another Counter instance.
256 
257  |      >>> c = Counter(‘which‘)
258 
259  |      >>> c.subtract(‘witch‘)             # subtract elements from another iterable
260 
261  |      >>> c.subtract(Counter(‘watch‘))    # subtract elements from another counter
262 
263  |      >>> c[‘h‘]                          # 2 in which, minus 1 in witch, minus 1 in watch
264 
265  |      0
266 
267  |      >>> c[‘w‘]                          # 1 in which, minus 1 in witch, minus 1 in watch
268 
269  |      -1
270 
271  |  update(*args, **kwds)
272 
273  |      Like dict.update() but add counts instead of replacing them.
274 
275  |      Source can be an iterable, a dictionary, or another Counter instance.
276 
277  |      >>> c = Counter(‘which‘)
278 
279  |      >>> c.update(‘witch‘)           # add elements from another iterable
280 
281  |      >>> d = Counter(‘watch‘)
282 
283  |      >>> c.update(d)                 # add elements from another counter
284 
285  |      >>> c[‘h‘]                      # four ‘h‘ in which, witch, and watch
286 
287  |      4
288 
289  |  ----------------------------------------------------------------------
290 
291  |  Class methods defined here:
292 
293  |  fromkeys(iterable, v=None) from builtins.type
294 
295  |      Create a new dictionary with keys from iterable and values set to value.
296 
297  |  ----------------------------------------------------------------------
298 
299  |  Data descriptors defined here:
300 
301  |  __dict__
302 
303  |      dictionary for instance variables (if defined)
304 
305  |  __weakref__
306 
307  |      list of weak references to the object (if defined)
308 
309  |  ----------------------------------------------------------------------
310 
311  |  Methods inherited from builtins.dict:
312 
313  |  __contains__(self, key, /)
314 
315  |      True if the dictionary has the specified key, else False.
316 
317  |  __eq__(self, value, /)
318 
319  |      Return self==value.
320 
321  |  __ge__(self, value, /)
322 
323  |      Return self>=value.
324 
325  |  __getattribute__(self, name, /)
326 
327  |      Return getattr(self, name).
328 
329  |  __getitem__(...)
330 
331  |      x.__getitem__(y) <==> x[y]
332 
333  |  __gt__(self, value, /)
334 
335  |      Return self>value.
336 
337  |  __iter__(self, /)
338 
339  |      Implement iter(self).
340 
341  |  __le__(self, value, /)
342 
343  |      Return self<=value.
344 
345  |  __len__(self, /)
346 
347  |      Return len(self).
348 
349  |  __lt__(self, value, /)
350 
351  |      Return self<value.
352 
353  |  __ne__(self, value, /)
354 
355  |      Return self!=value.
356 
357  |  __setitem__(self, key, value, /)
358 
359  |      Set self[key] to value.
360 
361  |  __sizeof__(...)
362 
363  |      D.__sizeof__() -> size of D in memory, in bytes
364 
365  |  clear(...)
366 
367  |      D.clear() -> None.  Remove all items from D.
368 
369  |  get(self, key, default=None, /)
370 
371  |      Return the value for key if key is in the dictionary, else default.
372 
373  |  items(...)
374 
375  |      D.items() -> a set-like object providing a view on D‘s items
376 
377  |  keys(...)
378 
379  |      D.keys() -> a set-like object providing a view on D‘s keys
380 
381  |
382 
383  |  pop(...)
384 
385  |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
386 
387  |      If key is not found, d is returned if given, otherwise KeyError is raised
388 
389  |  popitem(...)
390 
391  |      D.popitem() -> (k, v), remove and return some (key, value) pair as a
392 
393  |      2-tuple; but raise KeyError if D is empty.
394 
395  |  setdefault(self, key, default=None, /)
396 
397  |      Insert key with a value of default if key is not in the dictionary.
398 
399  |      Return the value for key if key is in the dictionary, else default.
400 
401  |  values(...)
402 
403  |      D.values() -> an object providing a view on D‘s values
404 
405  |  ----------------------------------------------------------------------
406 
407  |  Static methods inherited from builtins.dict:
408 
409  |  __new__(*args, **kwargs) from builtins.type
410 
411  |      Create and return a new object.  See help(type) for accurate signature.
412 
413  |  ----------------------------------------------------------------------
414 
415  |  Data and other attributes inherited from builtins.dict:
416 
417  |  __hash__ = None

View Code

from collections import Counter

Counter是一个简单的计数器，例如，统计字符出现的个数，空的Counter容器可以无参数构造，并采用update()方法进行更新；

most_common()返回前n个最多的数据,counter.most_common(x)返回前x个最多的数据；

Counter实例支持聚合结果的算术和集合操作；

elements()方法可以返回一个包含所有Counter数据的迭代器，counter.elements()。

5.3 deque 双端队列：

文档：

  1 class deque(builtins.object)
  2 
  3  |  deque([iterable[, maxlen]]) --> deque object
  4 
  5  |  A list-like sequence optimized for data accesses near its endpoints.
  6 
  7  |  Methods defined here:
  8 
  9  |  __add__(self, value, /)
 10 
 11  |      Return self+value.
 12 
 13  |  __bool__(self, /)
 14 
 15  |      self != 0
 16 
 17  |  __contains__(self, key, /)
 18 
 19  |      Return key in self.
 20 
 21  |  __copy__(...)
 22 
 23  |      Return a shallow copy of a deque.
 24 
 25  |  __delitem__(self, key, /)
 26 
 27  |      Delete self[key].
 28 
 29  |  __eq__(self, value, /)
 30 
 31  |      Return self==value.
 32 
 33  |  __ge__(self, value, /)
 34 
 35  |      Return self>=value.
 36 
 37  |  __getattribute__(self, name, /)
 38 
 39  |      Return getattr(self, name).
 40 
 41  |  __getitem__(self, key, /)
 42 
 43  |      Return self[key].
 44 
 45  |  __gt__(self, value, /)
 46 
 47  |      Return self>value.
 48 
 49  |  __iadd__(self, value, /)
 50 
 51  |      Implement self+=value.
 52 
 53  |  __imul__(self, value, /)
 54 
 55  |      Implement self*=value.
 56 
 57  |  __init__(self, /, *args, **kwargs)
 58 
 59  |      Initialize self.  See help(type(self)) for accurate signature.
 60 
 61  |  __iter__(self, /)
 62 
 63  |      Implement iter(self).
 64 
 65  |  __le__(self, value, /)
 66 
 67  |      Return self<=value.
 68 
 69  |  __len__(self, /)
 70 
 71  |      Return len(self).
 72 
 73  |  __lt__(self, value, /)
 74 
 75  |      Return self<value.
 76 
 77  |  __mul__(self, value, /)
 78 
 79  |      Return self*value.
 80 
 81  |  __ne__(self, value, /)
 82 
 83  |      Return self!=value.
 84 
 85  |  __reduce__(...)
 86 
 87  |      Return state information for pickling.
 88 
 89  |  __repr__(self, /)
 90 
 91  |      Return repr(self).
 92 
 93  |  __reversed__(...)
 94 
 95  |      D.__reversed__() -- return a reverse iterator over the deque
 96 
 97  |  __rmul__(self, value, /)
 98 
 99  |      Return value*self.
100 
101  |  __setitem__(self, key, value, /)
102 
103  |      Set self[key] to value.
104 
105  |  __sizeof__(...)
106 
107  |      D.__sizeof__() -- size of D in memory, in bytes
108 
109  |  append(...)
110 
111  |      Add an element to the right side of the deque.
112 
113  |  appendleft(...)
114 
115  |      Add an element to the left side of the deque.
116 
117  |  clear(...)
118 
119  |      Remove all elements from the deque.
120 
121  |  copy(...)
122 
123  |      Return a shallow copy of a deque.
124 
125  |  count(...)
126 
127  |      D.count(value) -> integer -- return number of occurrences of value
128 
129  |
130 
131  |  extend(...)
132 
133  |      Extend the right side of the deque with elements from the iterable
134 
135  |  extendleft(...)
136 
137  |      Extend the left side of the deque with elements from the iterable
138 
139  |  index(...)
140 
141  |      D.index(value, [start, [stop]]) -> integer -- return first index of value.
142 
143  |      Raises ValueError if the value is not present.
144 
145  |  insert(...)
146 
147  |      D.insert(index, object) -- insert object before index
148 
149  |  pop(...)
150 
151  |      Remove and return the rightmost element.
152 
153  |  popleft(...)
154 
155  |      Remove and return the leftmost element.
156 
157  |  remove(...)
158 
159  |      D.remove(value) -- remove first occurrence of value.
160 
161  |  reverse(...)
162 
163  |      D.reverse() -- reverse *IN PLACE*
164 
165  |  rotate(...)
166 
167  |      Rotate the deque n steps to the right (default n=1).  If n is negative, rotates left.
168 
169  |  ----------------------------------------------------------------------
170 
171  |  Static methods defined here:
172 
173  |  __new__(*args, **kwargs) from builtins.type
174 
175  |      Create and return a new object.  See help(type) for accurate signature.
176 
177  |  ----------------------------------------------------------------------
178 
179  |  Data descriptors defined here:
180 
181  |  maxlen
182 
183  |      maximum size of a deque or None if unbounded
184 
185  |  ----------------------------------------------------------------------
186 
187  |  Data and other attributes defined here:
188 
189  |  __hash__ = None

View Code

类似列表(list)的容器，实现了在两端快速添加(append)和弹出(pop)，deque是为了高效实现插入和删除操作的双向列表，适合用于

队列和栈， deque除了实现list的append()和pop()外，还支持左端插入appendleft()和左端删除popleft()，这样就可以非常高效地往头部添加或删除元素。

由于双端队列是线程安全的，在单独的线程中内容甚至可以从两端同时消费。

5.4 namedtuple 命名元组：创建命名元组子类的工厂函数

文档：
 1 Help on function namedtuple in module collections:
 2 
 3 namedtuple(typename, field_names, *, rename=False, defaults=None, module=None)
 4 
 5     Returns a new subclass of tuple with named fields.
 6 
 7     >>> Point = namedtuple(‘Point‘, [‘x‘, ‘y‘])
 8 
 9     >>> Point.__doc__                   # docstring for the new class
10 
11     ‘Point(x, y)‘
12 
13     >>> p = Point(11, y=22)             # instantiate with positional args or keywords    >>> p[0] + p[1]                     # indexable 
14 
15 like a plain tuple
16 
17     33
18 
19     >>> x, y = p                        # unpack like a regular tuple
20 
21     >>> x, y
22 
23     (11, 22)
24 
25     >>> p.x + p.y                       # fields also accessible by name
26 
27     33
28 
29     >>> d = p._asdict()                 # convert to a dictionary
30 
31     >>> d[‘x‘]
32 
33     11
34 
35     >>> Point(**d)                      # convert from a dictionary
36 
37     Point(x=11, y=22)
38 
39     >>> p._replace(x=100)               # _replace() is like str.replace() but targets named fields
40 
41     Point(x=100, y=22)

from collections import namedtuple

用法： namedtuple(‘名称‘, [属性list]):

Circle = namedtuple(‘Circle‘, [‘x‘, ‘y‘, ‘r‘])

命名元组(namedtuple)有两个必需的参数。它们是元组名称和字段名称。 namedtuple的每个实例没有对象字典，所以它们很轻量，与普通的元组相比，并不需要更多的内存。这使得它们比字典更快。属性值在namedtuple中是不可变的，

namedtuple向后兼容于普通的元组，可以既使用整数索引，也可以使用名称来访问namedtuple

._asdict()方法将一个命名元组转换为字典，用法：namedtuple._asdict()

5.5 OrderedDict ：字典的子类，保存了他们被添加的顺序

文档：

  1 Help on class OrderedDict in module collections:
  2 
  3 class OrderedDict(builtins.dict)
  4 
  5  |  Dictionary that remembers insertion order
  6 
  7  |
  8 
  9  |  Method resolution order:
 10 
 11  |      OrderedDict
 12 
 13  |      builtins.dict
 14 
 15  |      builtins.object
 16 
 17  |
 18 
 19  |  Methods defined here:
 20 
 21  |
 22 
 23  |  __delitem__(self, key, /)
 24 
 25  |      Delete self[key].
 26 
 27  |
 28 
 29  |  __eq__(self, value, /)
 30 
 31  |      Return self==value.
 32 
 33  |
 34 
 35  |  __ge__(self, value, /)
 36 
 37  |      Return self>=value.
 38 
 39  |
 40 
 41  |  __gt__(self, value, /)
 42 
 43  |      Return self>value.
 44 
 45  |
 46 
 47  |  __init__(self, /, *args, **kwargs)
 48 
 49  |      Initialize self.  See help(type(self)) for accurate signature.
 50 
 51  |
 52 
 53  |  __iter__(self, /)
 54 
 55  |      Implement iter(self).
 56 
 57  |
 58 
 59  |  __le__(self, value, /)
 60 
 61  |      Return self<=value.
 62 
 63  |
 64 
 65  |  __lt__(self, value, /)
 66 
 67  |      Return self<value.
 68 
 69  |
 70 
 71  |  __ne__(self, value, /)
 72 
 73  |      Return self!=value.
 74 
 75  |
 76 
 77  |  __reduce__(...)
 78 
 79  |      Return state information for pickling
 80 
 81  |
 82 
 83  |  __repr__(self, /)
 84 
 85  |      Return repr(self).
 86 
 87  |
 88 
 89  |  __reversed__(...)
 90 
 91  |      od.__reversed__() <==> reversed(od)
 92 
 93  |
 94 
 95  |  __setitem__(self, key, value, /)
 96 
 97  |      Set self[key] to value.
 98 
 99  |
100 
101  |  __sizeof__(...)
102 
103  |      D.__sizeof__() -> size of D in memory, in bytes
104 
105  |
106 
107  |  clear(...)
108 
109  |      od.clear() -> None.  Remove all items from od.
110 
111  |
112 
113  |  copy(...)
114 
115  |      od.copy() -> a shallow copy of od
116 
117  |
118 
119  |  items(...)
120 
121  |      D.items() -> a set-like object providing a view on D‘s items
122 
123  |
124 
125  |  keys(...)
126 
127  |      D.keys() -> a set-like object providing a view on D‘s keys
128 
129  |
130 
131  |  move_to_end(self, /, key, last=True)
132 
133  |      Move an existing element to the end (or beginning if last is false).
134 
135  |
136 
137  |      Raise KeyError if the element does not exist.
138 
139  |
140 
141  |  pop(...)
142 
143  |      od.pop(k[,d]) -> v, remove specified key and return the corresponding
144 
145  |      value.  If key is not found, d is returned if given, otherwise KeyError
146 
147  |      is raised.
148 
149  |
150 
151  |  popitem(self, /, last=True)
152 
153  |      Remove and return a (key, value) pair from the dictionary.
154 
155  |
156 
157  |      Pairs are returned in LIFO order if last is true or FIFO order if false.
158 
159  |
160 
161  |  setdefault(self, /, key, default=None)
162 
163  |      Insert key with a value of default if key is not in the dictionary.
164 
165  |
166 
167  |      Return the value for key if key is in the dictionary, else default.
168 
169  |
170 
171  |  update(...)
172 
173  |      D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
174 
175  |      If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
176 
177  |      If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
178 
179  |      In either case, this is followed by: for k in F:  D[k] = F[k]
180 
181  |
182 
183  |  values(...)
184 
185  |      D.values() -> an object providing a view on D‘s values
186 
187  |
188 
189  |  ----------------------------------------------------------------------
190 
191  |  Class methods defined here:
192 
193  |
194 
195  |  fromkeys(iterable, value=None) from builtins.type
196 
197  |      Create a new ordered dictionary with keys from iterable and values set to value.
198 
199  |
200 
201  |  ----------------------------------------------------------------------
202 
203  |  Data descriptors defined here:
204 
205  |
206 
207  |  __dict__
208 
209  |
210 
211  |  ----------------------------------------------------------------------
212 
213  |  Data and other attributes defined here:
214 
215  |
216 
217  |  __hash__ = None
218 
219  |
220 
221  |  ----------------------------------------------------------------------
222 
223  |  Methods inherited from builtins.dict:
224 
225  |
226 
227  |  __contains__(self, key, /)
228 
229  |      True if the dictionary has the specified key, else False.
230 
231  |
232 
233  |  __getattribute__(self, name, /)
234 
235  |      Return getattr(self, name).
236 
237  |
238 
239  |  __getitem__(...)
240 
241  |      x.__getitem__(y) <==> x[y]
242 
243  |
244 
245  |  __len__(self, /)
246 
247  |      Return len(self).
248 
249  |
250 
251  |  get(self, key, default=None, /)
252 
253  |      Return the value for key if key is in the dictionary, else default.
254 
255  |
256 
257  |  ----------------------------------------------------------------------
258 
259  |  Static methods inherited from builtins.dict:
260 
261  |
262 
263  |  __new__(*args, **kwargs) from builtins.type
264 
265  |      Create and return a new object.  See help(type) for accurate signature.

View Code

使用dict时，Key是无序的。在对dict做迭代时，我们无法确定Key的顺序。

如果要保持Key的顺序，可以用OrderedDict：

from collections import OrderedDict

OrderedDict 内部维护着一个根据键插入顺序排序的双向链表。每次当一个新的元素插入进来的时候，它会被放到链表的尾部。对于一个已经存在的键的重复赋值不会改变键的顺序。

OrderedDict的Key会按照插入的顺序排列，不是Key本身排序，即OrderedDict可以实现一个FIFO（先进先出）的dict，当容量超出限制时，先删除最早添加的Key。

需要注意的是，一个 OrderedDict 的大小是一个普通字典的两倍，因为它内部维护着另外一个链表。所以如果你要构建一个需要大量OrderedDict实例的数据结构的时候（比如读取 100,000 行 CSV 数据到一个 OrderedDict 列表中去），那么你就得仔细权衡一下是否使用 OrderedDict 带来的好处要大过额外内存消耗的影响。

【参考：1.7 字典排序 — python3-cookbook 3.0.0 文档 https://python3-cookbook.readthedocs.io

python标准库之collections介绍 - luminousjj - 博客园 https://www.cnblogs.com/luminousjj/p/9342161.html】

6. Python itertools库：Python的内建模块itertools提供了非常有用的用于操作迭代对象的函数。

[参考文章：Python标准库之itertools库的使用方法_python_脚本之家 https://www.jb51.net/article/123094.htm]

itertools中的函数大多是返回各种迭代器对象，其中很多函数的作用我们平时要写很多代码才能达到，而在运行效率上反而更低，毕竟人家是系统库。

itertools.accumulate

简单来说就是累加。

>>> import itertools
>>> x = itertools.accumulate(range(10))
>>> print(list(x))
[0, 1, 3, 6, 10, 15, 21, 28, 36, 45]

itertools.chain

连接多个列表或者迭代器。

>>> x = itertools.chain(range(3), range(4), [3,2,1])
>>> print(list(x))
[0, 1, 2, 0, 1, 2, 3, 3, 2, 1]

itertools.combinations

求列表或生成器中指定数目的元素不重复的所有组合

>>> x = itertools.combinations(range(4), 3)
>>> print(list(x))
[(0, 1, 2), (0, 1, 3), (0, 2, 3), (1, 2, 3)]

itertools.combinations_with_replacement

允许重复元素的组合

>>> x = itertools.combinations_with_replacement(‘ABC‘, 2)
>>> print(list(x))
[(‘A‘, ‘A‘), (‘A‘, ‘B‘), (‘A‘, ‘C‘), (‘B‘, ‘B‘), (‘B‘, ‘C‘), (‘C‘, ‘C‘)]

itertools.compress

按照真值表筛选元素

>>> x = itertools.compress(range(5), (True, False, True, True, False))
>>> print(list(x))
[0, 2, 3]

itertools.count

就是一个计数器,可以指定起始位置和步长

>>> x = itertools.count(start=20, step=-1)
>>> print(list(itertools.islice(x, 0, 10, 1)))
[20, 19, 18, 17, 16, 15, 14, 13, 12, 11]

itertools.cycle

循环指定的列表和迭代器

>>> x = itertools.cycle(‘ABC‘)
>>> print(list(itertools.islice(x, 0, 10, 1)))
[‘A‘, ‘B‘, ‘C‘, ‘A‘, ‘B‘, ‘C‘, ‘A‘, ‘B‘, ‘C‘, ‘A‘]

itertools.dropwhile

按照真值函数丢弃掉列表和迭代器前面的元素

>>> x = itertools.dropwhile(lambda e: e < 5, range(10))
>>> print(list(x))
[5, 6, 7, 8, 9]

itertools.filterfalse

保留对应真值为False的元素

>>> x = itertools.filterfalse(lambda e: e < 5, (1, 5, 3, 6, 9, 4))
>>> print(list(x))
[5, 6, 9]

itertools.groupby

按照分组函数的值对元素进行分组

>>> x = itertools.groupby(range(10), lambda x: x < 5 or x > 8)             
>>> for condition, numbers in x:       
... print(condition, list(numbers))             
True [0, 1, 2, 3, 4]        
False [5, 6, 7, 8]        
True [9]

itertools.islice(下面有详细介绍)

上文使用过的函数，对迭代器进行切片

>>> x = itertools.islice(range(10), 0, 9, 2)
>>> print(list(x))
[0, 2, 4, 6, 8]

itertools.permutations

产生指定数目的元素的所有排列(顺序有关)

>>> x = itertools.permutations(range(4), 3)
>>> print(list(x))
[(0, 1, 2), (0, 1, 3), (0, 2, 1), (0, 2, 3), (0, 3, 1), (0, 3, 2), (1, 0, 2), (1, 0, 3), (1, 2, 0), (1, 2, 3), (1, 3, 0), (1, 3, 2), (2, 0, 1), (2, 0, 3), (2, 1, 0), (2, 1, 3), (2, 3, 0), (2, 3, 1), (3, 0, 1), (3, 0, 2), (3, 1, 0), (3, 1, 2), (3, 2, 0), (3, 2, 1)]

itertools.product

产生多个列表和迭代器的(积)

>>> x = itertools.product(‘ABC‘, range(3))
>>>
>>> print(list(x))
[(‘A‘, 0), (‘A‘, 1), (‘A‘, 2), (‘B‘, 0), (‘B‘, 1), (‘B‘, 2), (‘C‘, 0), (‘C‘, 1), (‘C‘, 2)]

itertools.repeat

简单的生成一个拥有指定数目元素的迭代器

>>> x = itertools.repeat(0, 5)
>>> print(list(x))
[0, 0, 0, 0, 0]

itertools.starmap

类似map

>>> x = itertools.starmap(str.islower, ‘aBCDefGhI‘)
>>> print(list(x))
[True, False, False, False, True, True, False, True, False]

itertools.takewhile

与dropwhile相反，保留元素直至真值函数值为假。

>>> x = itertools.takewhile(lambda e: e < 5, range(10))
>>> print(list(x))
[0, 1, 2, 3, 4]

itertools.tee

这个函数我也不是很懂，似乎是生成指定数目的迭代器

>>> x = itertools.tee(range(10), 2)
>>> for letters in x:
... print(list(letters))
...
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

itertools.zip_longest

类似于zip，不过已较长的列表和迭代器的长度为准

>>> x = itertools.zip_longest(range(3), range(5))
>>> y = zip(range(3), range(5))
>>> print(list(x))
[(0, 0), (1, 1), (2, 2), (None, 3), (None, 4)]
>>> print(list(y))
[(0, 0), (1, 1), (2, 2)]

7. 推导式 Comprehension ，可迭代对象 Iterable，迭代器 Iterator 及生成器 Generators

7.1 推导式

推导式一般用的最多的是列表推导式（list comprehensions）

example：a = [i*i for i in range(10)]

官方解释：列表解析式是Python内置的非常简单却强大的可以用来创建list的生成式，在一个中括号里包含一个表达式，然后是一个for语句，然后是0个或多个for或者if语句。那个表达式可以是任意的，意思是你可以在列表中放任意类型的对象。返回结果将是一个新的列表，在这个以if和for语句为上下文的表达式运行完成之后产生。

可以看到，使用列表解析式的写法更加简短，除此之外，因为是Python内置的用法，底层使用c语言实现，相较于编写Python代码而言，运行速度更快。

====总结====：如果要对现有可迭代对象做一下处理，然后生成新的列表，使用列表推导式将是最便捷的方法。

7.2 可迭代对象 Iterable

最简单的解释：可以使用for...in...语句进行循环的对象，就是可迭代对象（Iterable），可以使用isinstance()方法进行判断。list、dict、str是Iterable（可迭代对象），但不是Iterator（迭代器），可以使用iter()函数把list、dict、str等Iterable变成Iterator。

temp=iter([1, 2, 3])
print type(temp)  # list_iterator
print next(temp)  # 1

7.3 迭代器 Iterator

任意对象，只要定义了next (Python2) 或者__next__方法并实现了iter方法，它就是一个迭代器。

迭代器的优势：在构建迭代器时，不是将所有元素一次性的加载，而是等调用next方法时返回元素，大量节省内存。

迭代器应用场景：数列的数据规模巨大且数列有规律，但是不能使用列表推导式描述的时候，如大数据量的数列的创建，大文件的读取等。

7.4 生成器 Generators

生成器是一个特殊的函数，可以被用作控制循环的迭代行为，python中生成器是一种高级迭代器，使用yield代替return返回，每次调用yield会暂停，而可以使用next()函数和send()函数恢复生成器。

生成器类似于返回值为一个数组的一个函数，这个函数可以接收参数，可以被调用,但是不同于一般的函数会一次性返回包括了所有数值的数组，生成器一次只能产生一个值，这样消耗的内存数量将大大减小，生成器可以被看作是一个函数，但是它本质上也算是一个迭代器。

生成器函数：为什么叫生成器函数？因为它随着时间的推移生成了一个数值队列。一般的函数在执行完毕之后会返回一个值然后退出，但是生成器函数会自动挂起，然后重新拾起急需执行，利用yield关键字关起函数，给调用者返回一个值，同时保留了当前的足够多的状态，可以使函数继续执行。当需要一个将返回一个序列或在循环中执行的函数时，就可以使用生成器，因为当这些元素被传递到另一个函数中进行后续处理时，一次返回一个元素可以有效的提升整体性能。常见的应用场景是使用生成器生成数据流缓冲区。

生成器表达式：生成式表达式是一种实现生成器的便捷方式，将列表推导式的中括号替换为圆括号。返回一个对象，这个对象只有在需要的时候才产生结果。

生成器表达式的一个例子： g = (x*x for x in range（10）)

[参考文章]：

python 生成器和迭代器有这篇就够了 - 战争热诚 - 博客园 https://www.cnblogs.com/wj-1314/p/8490822.html

迭代器生成器, 可迭代对象以及应用场景 - 若无过客丶何来人生 - 博客园 https://www.cnblogs.com/liurenli/p/10127818.html

8. 命名切片

slice() 函数描述：slice() 函数用实现切片对象，主要在切片操作函数里的参数传递。

slice 语法：

class slice(stop)

class slice(start, stop[, step])

如果你有一个切片对象 a，你可以分别调用它的 a.start , a.stop , a.step 属性来获取更多的信息。

另外，你还能通过调用切片的 indices(size) 方法将它映射到一个确定大小的序列上，这个方法返回一个三元组 (start, stop, step) ，所有值都会被合适的缩小以满足边界限制，从而使用的时候避免出现 IndexError 异常。

文档的说明：

 1 class slice(object)
 2 
 3  |  slice(stop)
 4 
 5  |  slice(start, stop[, step])
 6 
 7  |  Create a slice object.  This is used for extended slicing (e.g. a[0:10:2]).
 8 
 9  |  Methods defined here:
10 
11  |  __eq__(self, value, /)
12 
13  |      Return self==value.
14 
15  |  __ge__(self, value, /)
16 
17  |      Return self>=value.
18 
19  |
20 
21  |  __getattribute__(self, name, /)
22 
23  |      Return getattr(self, name).
24 
25  |  __gt__(self, value, /)
26 
27  |      Return self>value.
28 
29  |  __le__(self, value, /)
30 
31  |      Return self<=value.
32 
33  |  __lt__(self, value, /)
34 
35  |      Return self<value.
36 
37  |  __ne__(self, value, /)
38 
39  |      Return self!=value.
40 
41  |  __reduce__(...)
42 
43  |      Return state information for pickling.
44 
45  |  __repr__(self, /)
46 
47  |      Return repr(self).
48 
49  |  indices(...)
50 
51  |      S.indices(len) -> (start, stop, stride)
52 
53  |      Assuming a sequence of length len, calculate the start and stop
54 
55  |      indices, and the stride length of the extended slice described by
56 
57  |      S. Out of bounds indices are clipped in a manner consistent with the
58 
59  |      handling of normal slices.
60 
61  |  ----------------------------------------------------------------------
62 
63  |  Static methods defined here:
64 
65  |  __new__(*args, **kwargs) from builtins.type
66 
67  |      Create and return a new object.  See help(type) for accurate signature.-- More  -- |
68 
69  |  ----------------------------------------------------------------------
70 
71  |  Data descriptors defined here:
72 
73  |  start
74 
75  |  step
76 
77  |  stop
78 
79  |  ----------------------------------------------------------------------
80 
81  |  Data and other attributes defined here:
82 
83  |  __hash__ = None

View Code

9. 上下文管理器：

常见用法：
with open(‘test.txt‘) as f:
    print f.readlines()

几个概念

上下文表达式：with open(‘test.txt‘) as f:
上下文管理器：open(‘test.txt‘)
f 不是上下文管理器，应该是资源对象。

为什么要使用上下文管理器？

可以以一种更加优雅的方式，操作（创建/获取/释放）资源，如文件操作、数据库连接；

可以以一种更加优雅的方式，处理异常；

简单点说，就是在一个类里，实现了__enter__和__exit__的方法，这个类的实例就是一个上下文管理器。

一个基管于类实现的上下文理器：

class File(object):

def __init__(self, file_name, method):

self.file_obj = open(file_name, method)

def __enter__(self):

return self.file_obj

def __exit__(self, exc_type, exc_value, exc_traceback):

self.file_obj.close()

注：exc_type：异常类型， exc_value：异常值， exc_traceback：异常的错误栈信息

执行过程：

with语句先暂存了File类的__exit__方法；

然后它调用File类的__enter__方法；

__enter__方法打开文件并返回给with语句；

打开的文件句柄被传递给opened_file参数；

我们使用.write()来写文件；

with语句调用之前暂存的__exit__方法；

__exit__方法关闭了文件。

[关于上下文管理器的更多详细可以参考文章]：

浅淡python中with的用法，上下文管理器 - 听风。 - 博客园 https://www.cnblogs.com/huchong/p/8268765.html

深入理解 Python 中的上下文管理器 - 王一白 - 博客园 https://www.cnblogs.com/wongbingming/p/10519553.html

统一声明：关于原创博客内容，可能会有部分内容参考自互联网，如有原创链接会声明引用；如找不到原创链接，在此声明如有侵权请联系删除哈。关于转载博客，如有原创链接会声明；如找不到原创链接，如果有哪些问题、有些谬误、有哪些不妥或者侵犯到您的权益的地方，可以联系我，我马上修改。

[Python进阶]Python builtin 函数及重要知识点学习笔记（一）

原文：https://www.cnblogs.com/vanjoe/p/12822280.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)