Python面向对象-高级用法

智多星星星星相映

1.魔法函数

python中常见的内置类型

什么是魔法函数？
python的魔法函数总被双下划线包围，它们可以给你的类增加特殊的方法。如果你的对象实现了这些方法中的一个，那么这个方法就会在特殊情况下被调用，你可以定义想要
的行为，而这一切都是自动发生的。
魔法函数一览

魔法函数举例
1.1.__getitem__

把对象变成可迭代的对象
例子：

1. class Company(object):
2.     def __init__(self,employee_list):
3.         self.employee = employee_list
4.     #魔法函数，给类加可迭代类型
5.     def __getitem__(self, item):
6.         return self.employee[item]
8. company = Company(['11','22','33'])
10. #加了魔法函数“__getitem__”，类就成了可迭代的了
11. for em in company:
12.     print(em)    #11,22,33

复制代码

如果不用魔法函数循环出每个员工的方法

1. class Company(object):
2.     def __init__(self,employee_list):
3.         self.employee = employee_list
6. company = Company(['11','22','33'])
8. for em in company.employee:
9.     print(em)

复制代码

还可以切片和获取长度

1. class Company(object):
2.     def __init__(self,employee_list):
3.         self.employee = employee_list
4.     #魔法函数
5.     def __getitem__(self, item):
6.         return self.employee[item]
8. company = Company(['11','22','33'])
9. #可以切片
10. company1 = company[:2]
11. #可以判断len长度
12. print(len(company1))   #2
14. for em in company1:
15.     print(em)    #11,22

复制代码

1.2.__len__

1. class Company(object):
2.     def __init__(self, employee_list):
3.         self.employee = employee_list
4.     #
5.     # def __getitem__(self, item):
6.     #     return self.employee[item]
8.     def __len__(self):
9.         return len(self.employee)
11. company = Company(["11", "22", "33"])
13. #如果不加魔法函数，len（company）会报错的
14. print(len(company))     #3

复制代码

1.3. __repr__和__str__

1.安装交互环境（jupyter）

1. pip install -i https://pypi.douban.com/simple ipython
3. pip install -i https://pypi.douban.com/simple notebook
5. #启动
6. ipython notebook

复制代码

2.__repr__和__str__的用法

2.深入类和对象

1.1.鸭子类型和多态

“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。”
我们并不关心对象是什么类型，到底是不是鸭子，只关心行为。
实例一：

1. # 鸭子类型和多态简单实例
3. class Dog(object):
4.     def say(self):
5.         print('a dog')
8. class Cat(object):
9.     def say(self):
10.         print('a cat')
12. class Duck(object):
13.     def say(self):
14.         print('a duck')
16. animal_list = [Dog,Cat,Duck]
18. for animal in animal_list:
19.     animal().say()
22. #运行结果
24. a dog
25. a cat
26. a duck

复制代码

实例二：
类只要实现了__getitem__方法，它就是可迭代的,并不关心对象的本身，只关心行为，然后就可以当做extend的参数。

1. class Company(object):
2.     def __init__(self, employee_list):
3.         self.employee = employee_list
5.     def __getitem__(self, item):
6.         return self.employee[item]
9. company = Company(["11", "22", "33"])
11. a = ['derek1','derek2']
13. name_set = set()
15. name_set.add('tom1')
16. name_set.add(('tom2'))
18. #extend里面的参数介绍
19. #def extend(self, iterable):  # real signature unknown; restored from __doc__
20.     #""" L.extend(iterable) -> None -- extend list by appending elements from the iterable """
23. #extend里面可以添加任何可迭代的参数，给类添加一个魔法函数__getitem__,类就变成可迭代的，所以可以extend进去
24. a.extend(company)
25. print(a)       #['derek1', 'derek2', '11', '22', '33']
27. a.extend(name_set)
28. print(a)       #['derek1', 'derek2', '11', '22', '33', 'tom2', 'tom1']

复制代码

1.2.抽象基类（abc模块）

抽象基类的作用类似于JAVA中的接口。在接口中定义各种方法，然后继承接口的各种类进行具体方法的实现。抽象基类就是定义各种方法而不做具体实现的类，任何继承自抽象基类的类必须实现这些方法，否则无法实例化
（1）判断类时候有某种属性

1. #判断类是否有某种属性
3. class Company(object):
4.     def __init__(self, employee_list):
5.         self.employee = employee_list
7.     def __len__(self):
8.         return len(self.employee)
10. com = Company(["11", "22", "33"])
12. #hasattr判断类有没有某种属性，方法也是类的属性
13. print(hasattr(com,"__len__"))   #True
15. #虽然用hasattr可以判断，但正确的方式是定义一个抽象基类
17. #我们在某些情况下希望判定某个对象的类型，可以用抽象基类
18. from collections.abc import Sized
19. print(isinstance(com,Sized))    #True
20. # print(len(com))

复制代码

1. class Sized(metaclass=ABCMeta):
3.     __slots__ = ()
5.     @abstractmethod
6.     def __len__(self):
7.         return 0
9.     @classmethod
10.     def __subclasshook__(cls, C):
11.         if cls is Sized:
12.             return _check_methods(C, "__len__")
13.         return NotImplemented

复制代码

（2）abc模块

简单抽象基类实例

1. #模拟一个抽象基类
3. #写一个抽象基类，它的子类必须要重写抽象基类里面的方法
4. import abc
5. #定义一个抽象基类
6. class CacheBase(metaclass=abc.ABCMeta):
7.     @abc.abstractclassmethod
8.     def get(self,key):
9.         pass
11.     @abc.abstractclassmethod
12.     def set(self,key,value):
13.         pass
15. #子类,必须有抽象基类里面的方法，get和set
16. #假入不写set方法会报错
18. class RedisCache(CacheBase):
19.     def get(self,key):
20.         pass
21.    
22.     # def set(self,key,value):
23.     #     pass
25. redis_cache = RedisCache()

复制代码

1. #模拟一个抽象基类
3. #写一个抽象基类，它的子类必须要重写抽象基类里面的方法
4. import abc
5. #定义一个抽象基类
6. class CacheBase(metaclass=abc.ABCMeta):
7.     @abc.abstractclassmethod
8.     def get(self,key):
9.         pass
11.     @abc.abstractclassmethod
12.     def set(self,key,value):
13.         pass
15. #子类,必须有抽象基类里面的方法，get和set
16. #假入不写set方法会报错
18. class RedisCache(CacheBase):
19.     def get(self,key):
20.         pass
22.     def set(self,key,value):
23.         pass
25. redis_cache = RedisCache()

复制代码

（3）abc里面所有的抽象基类

1. from collections.abc import *

复制代码

所有的抽象基类

1. # Copyright 2007 Google, Inc. All Rights Reserved.
2. # Licensed to PSF under a Contributor Agreement.
4. """Abstract Base Classes (ABCs) for collections, according to PEP 3119.
6. Unit tests are in test_collections.
7. """
9. from abc import ABCMeta, abstractmethod
10. import sys
12. __all__ = ["Awaitable", "Coroutine",
13.            "AsyncIterable", "AsyncIterator", "AsyncGenerator",
14.            "Hashable", "Iterable", "Iterator", "Generator", "Reversible",
15.            "Sized", "Container", "Callable", "Collection",
16.            "Set", "MutableSet",
17.            "Mapping", "MutableMapping",
18.            "MappingView", "KeysView", "ItemsView", "ValuesView",
19.            "Sequence", "MutableSequence",
20.            "ByteString",
21.            ]
23. # This module has been renamed from collections.abc to _collections_abc to
24. # speed up interpreter startup. Some of the types such as MutableMapping are
25. # required early but collections module imports a lot of other modules.
26. # See issue #19218
27. __name__ = "collections.abc"
29. # Private list of types that we want to register with the various ABCs
30. # so that they will pass tests like:
31. #       it = iter(somebytearray)
32. #       assert isinstance(it, Iterable)
33. # Note:  in other implementations, these types might not be distinct
34. # and they may have their own implementation specific types that
35. # are not included on this list.
36. bytes_iterator = type(iter(b''))
37. bytearray_iterator = type(iter(bytearray()))
38. #callable_iterator = ???
39. dict_keyiterator = type(iter({}.keys()))
40. dict_valueiterator = type(iter({}.values()))
41. dict_itemiterator = type(iter({}.items()))
42. list_iterator = type(iter([]))
43. list_reverseiterator = type(iter(reversed([])))
44. range_iterator = type(iter(range(0)))
45. longrange_iterator = type(iter(range(1 << 1000)))
46. set_iterator = type(iter(set()))
47. str_iterator = type(iter(""))
48. tuple_iterator = type(iter(()))
49. zip_iterator = type(iter(zip()))
50. ## views ##
51. dict_keys = type({}.keys())
52. dict_values = type({}.values())
53. dict_items = type({}.items())
54. ## misc ##
55. mappingproxy = type(type.__dict__)
56. generator = type((lambda: (yield))())
57. ## coroutine ##
58. async def _coro(): pass
59. _coro = _coro()
60. coroutine = type(_coro)
61. _coro.close()  # Prevent ResourceWarning
62. del _coro
63. ## asynchronous generator ##
64. async def _ag(): yield
65. _ag = _ag()
66. async_generator = type(_ag)
67. del _ag
70. ### ONE-TRICK PONIES ###
72. def _check_methods(C, *methods):
73.     mro = C.__mro__
74.     for method in methods:
75.         for B in mro:
76.             if method in B.__dict__:
77.                 if B.__dict__[method] is None:
78.                     return NotImplemented
79.                 break
80.         else:
81.             return NotImplemented
82.     return True
84. class Hashable(metaclass=ABCMeta):
86.     __slots__ = ()
88.     @abstractmethod
89.     def __hash__(self):
90.         return 0
92.     @classmethod
93.     def __subclasshook__(cls, C):
94.         if cls is Hashable:
95.             return _check_methods(C, "__hash__")
96.         return NotImplemented
99. class Awaitable(metaclass=ABCMeta):
101.     __slots__ = ()
103.     @abstractmethod
104.     def __await__(self):
105.         yield
107.     @classmethod
108.     def __subclasshook__(cls, C):
109.         if cls is Awaitable:
110.             return _check_methods(C, "__await__")
111.         return NotImplemented
114. class Coroutine(Awaitable):
116.     __slots__ = ()
118.     @abstractmethod
119.     def send(self, value):
120.         """Send a value into the coroutine.
121.         Return next yielded value or raise StopIteration.
122.         """
123.         raise StopIteration
125.     @abstractmethod
126.     def throw(self, typ, val=None, tb=None):
127.         """Raise an exception in the coroutine.
128.         Return next yielded value or raise StopIteration.
129.         """
130.         if val is None:
131.             if tb is None:
132.                 raise typ
133.             val = typ()
134.         if tb is not None:
135.             val = val.with_traceback(tb)
136.         raise val
138.     def close(self):
139.         """Raise GeneratorExit inside coroutine.
140.         """
141.         try:
142.             self.throw(GeneratorExit)
143.         except (GeneratorExit, StopIteration):
144.             pass
145.         else:
146.             raise RuntimeError("coroutine ignored GeneratorExit")
148.     @classmethod
149.     def __subclasshook__(cls, C):
150.         if cls is Coroutine:
151.             return _check_methods(C, '__await__', 'send', 'throw', 'close')
152.         return NotImplemented
155. Coroutine.register(coroutine)
158. class AsyncIterable(metaclass=ABCMeta):
160.     __slots__ = ()
162.     @abstractmethod
163.     def __aiter__(self):
164.         return AsyncIterator()
166.     @classmethod
167.     def __subclasshook__(cls, C):
168.         if cls is AsyncIterable:
169.             return _check_methods(C, "__aiter__")
170.         return NotImplemented
173. class AsyncIterator(AsyncIterable):
175.     __slots__ = ()
177.     @abstractmethod
178.     async def __anext__(self):
179.         """Return the next item or raise StopAsyncIteration when exhausted."""
180.         raise StopAsyncIteration
182.     def __aiter__(self):
183.         return self
185.     @classmethod
186.     def __subclasshook__(cls, C):
187.         if cls is AsyncIterator:
188.             return _check_methods(C, "__anext__", "__aiter__")
189.         return NotImplemented
192. class AsyncGenerator(AsyncIterator):
194.     __slots__ = ()
196.     async def __anext__(self):
197.         """Return the next item from the asynchronous generator.
198.         When exhausted, raise StopAsyncIteration.
199.         """
200.         return await self.asend(None)
202.     @abstractmethod
203.     async def asend(self, value):
204.         """Send a value into the asynchronous generator.
205.         Return next yielded value or raise StopAsyncIteration.
206.         """
207.         raise StopAsyncIteration
209.     @abstractmethod
210.     async def athrow(self, typ, val=None, tb=None):
211.         """Raise an exception in the asynchronous generator.
212.         Return next yielded value or raise StopAsyncIteration.
213.         """
214.         if val is None:
215.             if tb is None:
216.                 raise typ
217.             val = typ()
218.         if tb is not None:
219.             val = val.with_traceback(tb)
220.         raise val
222.     async def aclose(self):
223.         """Raise GeneratorExit inside coroutine.
224.         """
225.         try:
226.             await self.athrow(GeneratorExit)
227.         except (GeneratorExit, StopAsyncIteration):
228.             pass
229.         else:
230.             raise RuntimeError("asynchronous generator ignored GeneratorExit")
232.     @classmethod
233.     def __subclasshook__(cls, C):
234.         if cls is AsyncGenerator:
235.             return _check_methods(C, '__aiter__', '__anext__',
236.                                   'asend', 'athrow', 'aclose')
237.         return NotImplemented
240. AsyncGenerator.register(async_generator)
243. class Iterable(metaclass=ABCMeta):
245.     __slots__ = ()
247.     @abstractmethod
248.     def __iter__(self):
249.         while False:
250.             yield None
252.     @classmethod
253.     def __subclasshook__(cls, C):
254.         if cls is Iterable:
255.             return _check_methods(C, "__iter__")
256.         return NotImplemented
259. class Iterator(Iterable):
261.     __slots__ = ()
263.     @abstractmethod
264.     def __next__(self):
265.         'Return the next item from the iterator. When exhausted, raise StopIteration'
266.         raise StopIteration
268.     def __iter__(self):
269.         return self
271.     @classmethod
272.     def __subclasshook__(cls, C):
273.         if cls is Iterator:
274.             return _check_methods(C, '__iter__', '__next__')
275.         return NotImplemented
277. Iterator.register(bytes_iterator)
278. Iterator.register(bytearray_iterator)
279. #Iterator.register(callable_iterator)
280. Iterator.register(dict_keyiterator)
281. Iterator.register(dict_valueiterator)
282. Iterator.register(dict_itemiterator)
283. Iterator.register(list_iterator)
284. Iterator.register(list_reverseiterator)
285. Iterator.register(range_iterator)
286. Iterator.register(longrange_iterator)
287. Iterator.register(set_iterator)
288. Iterator.register(str_iterator)
289. Iterator.register(tuple_iterator)
290. Iterator.register(zip_iterator)
293. class Reversible(Iterable):
295.     __slots__ = ()
297.     @abstractmethod
298.     def __reversed__(self):
299.         while False:
300.             yield None
302.     @classmethod
303.     def __subclasshook__(cls, C):
304.         if cls is Reversible:
305.             return _check_methods(C, "__reversed__", "__iter__")
306.         return NotImplemented
309. class Generator(Iterator):
311.     __slots__ = ()
313.     def __next__(self):
314.         """Return the next item from the generator.
315.         When exhausted, raise StopIteration.
316.         """
317.         return self.send(None)
319.     @abstractmethod
320.     def send(self, value):
321.         """Send a value into the generator.
322.         Return next yielded value or raise StopIteration.
323.         """
324.         raise StopIteration
326.     @abstractmethod
327.     def throw(self, typ, val=None, tb=None):
328.         """Raise an exception in the generator.
329.         Return next yielded value or raise StopIteration.
330.         """
331.         if val is None:
332.             if tb is None:
333.                 raise typ
334.             val = typ()
335.         if tb is not None:
336.             val = val.with_traceback(tb)
337.         raise val
339.     def close(self):
340.         """Raise GeneratorExit inside generator.
341.         """
342.         try:
343.             self.throw(GeneratorExit)
344.         except (GeneratorExit, StopIteration):
345.             pass
346.         else:
347.             raise RuntimeError("generator ignored GeneratorExit")
349.     @classmethod
350.     def __subclasshook__(cls, C):
351.         if cls is Generator:
352.             return _check_methods(C, '__iter__', '__next__',
353.                                   'send', 'throw', 'close')
354.         return NotImplemented
356. Generator.register(generator)
359. class Sized(metaclass=ABCMeta):
361.     __slots__ = ()
363.     @abstractmethod
364.     def __len__(self):
365.         return 0
367.     @classmethod
368.     def __subclasshook__(cls, C):
369.         if cls is Sized:
370.             return _check_methods(C, "__len__")
371.         return NotImplemented
374. class Container(metaclass=ABCMeta):
376.     __slots__ = ()
378.     @abstractmethod
379.     def __contains__(self, x):
380.         return False
382.     @classmethod
383.     def __subclasshook__(cls, C):
384.         if cls is Container:
385.             return _check_methods(C, "__contains__")
386.         return NotImplemented
388. class Collection(Sized, Iterable, Container):
390.     __slots__ = ()
392.     @classmethod
393.     def __subclasshook__(cls, C):
394.         if cls is Collection:
395.             return _check_methods(C,  "__len__", "__iter__", "__contains__")
396.         return NotImplemented
398. class Callable(metaclass=ABCMeta):
400.     __slots__ = ()
402.     @abstractmethod
403.     def __call__(self, *args, **kwds):
404.         return False
406.     @classmethod
407.     def __subclasshook__(cls, C):
408.         if cls is Callable:
409.             return _check_methods(C, "__call__")
410.         return NotImplemented
413. ### SETS ###
416. class Set(Collection):
418.     """A set is a finite, iterable container.
420.     This class provides concrete generic implementations of all
421.     methods except for __contains__, __iter__ and __len__.
423.     To override the comparisons (presumably for speed, as the
424.     semantics are fixed), redefine __le__ and __ge__,
425.     then the other operations will automatically follow suit.
426.     """
428.     __slots__ = ()
430.     def __le__(self, other):
431.         if not isinstance(other, Set):
432.             return NotImplemented
433.         if len(self) > len(other):
434.             return False
435.         for elem in self:
436.             if elem not in other:
437.                 return False
438.         return True
440.     def __lt__(self, other):
441.         if not isinstance(other, Set):
442.             return NotImplemented
443.         return len(self) < len(other) and self.__le__(other)
445.     def __gt__(self, other):
446.         if not isinstance(other, Set):
447.             return NotImplemented
448.         return len(self) > len(other) and self.__ge__(other)
450.     def __ge__(self, other):
451.         if not isinstance(other, Set):
452.             return NotImplemented
453.         if len(self) < len(other):
454.             return False
455.         for elem in other:
456.             if elem not in self:
457.                 return False
458.         return True
460.     def __eq__(self, other):
461.         if not isinstance(other, Set):
462.             return NotImplemented
463.         return len(self) == len(other) and self.__le__(other)
465.     @classmethod
466.     def _from_iterable(cls, it):
467.         '''Construct an instance of the class from any iterable input.
469.         Must override this method if the class constructor signature
470.         does not accept an iterable for an input.
471.         '''
472.         return cls(it)
474.     def __and__(self, other):
475.         if not isinstance(other, Iterable):
476.             return NotImplemented
477.         return self._from_iterable(value for value in other if value in self)
479.     __rand__ = __and__
481.     def isdisjoint(self, other):
482.         'Return True if two sets have a null intersection.'
483.         for value in other:
484.             if value in self:
485.                 return False
486.         return True
488.     def __or__(self, other):
489.         if not isinstance(other, Iterable):
490.             return NotImplemented
491.         chain = (e for s in (self, other) for e in s)
492.         return self._from_iterable(chain)
494.     __ror__ = __or__
496.     def __sub__(self, other):
497.         if not isinstance(other, Set):
498.             if not isinstance(other, Iterable):
499.                 return NotImplemented
500.             other = self._from_iterable(other)
501.         return self._from_iterable(value for value in self
502.                                    if value not in other)
504.     def __rsub__(self, other):
505.         if not isinstance(other, Set):
506.             if not isinstance(other, Iterable):
507.                 return NotImplemented
508.             other = self._from_iterable(other)
509.         return self._from_iterable(value for value in other
510.                                    if value not in self)
512.     def __xor__(self, other):
513.         if not isinstance(other, Set):
514.             if not isinstance(other, Iterable):
515.                 return NotImplemented
516.             other = self._from_iterable(other)
517.         return (self - other) | (other - self)
519.     __rxor__ = __xor__
521.     def _hash(self):
522.         """Compute the hash value of a set.
524.         Note that we don't define __hash__: not all sets are hashable.
525.         But if you define a hashable set type, its __hash__ should
526.         call this function.
528.         This must be compatible __eq__.
530.         All sets ought to compare equal if they contain the same
531.         elements, regardless of how they are implemented, and
532.         regardless of the order of the elements; so there's not much
533.         freedom for __eq__ or __hash__.  We match the algorithm used
534.         by the built-in frozenset type.
535.         """
536.         MAX = sys.maxsize
537.         MASK = 2 * MAX + 1
538.         n = len(self)
539.         h = 1927868237 * (n + 1)
540.         h &= MASK
541.         for x in self:
542.             hx = hash(x)
543.             h ^= (hx ^ (hx << 16) ^ 89869747)  * 3644798167
544.             h &= MASK
545.         h = h * 69069 + 907133923
546.         h &= MASK
547.         if h > MAX:
548.             h -= MASK + 1
549.         if h == -1:
550.             h = 590923713
551.         return h
553. Set.register(frozenset)
556. class MutableSet(Set):
557.     """A mutable set is a finite, iterable container.
559.     This class provides concrete generic implementations of all
560.     methods except for __contains__, __iter__, __len__,
561.     add(), and discard().
563.     To override the comparisons (presumably for speed, as the
564.     semantics are fixed), all you have to do is redefine __le__ and
565.     then the other operations will automatically follow suit.
566.     """
568.     __slots__ = ()
570.     @abstractmethod
571.     def add(self, value):
572.         """Add an element."""
573.         raise NotImplementedError
575.     @abstractmethod
576.     def discard(self, value):
577.         """Remove an element.  Do not raise an exception if absent."""
578.         raise NotImplementedError
580.     def remove(self, value):
581.         """Remove an element. If not a member, raise a KeyError."""
582.         if value not in self:
583.             raise KeyError(value)
584.         self.discard(value)
586.     def pop(self):
587.         """Return the popped value.  Raise KeyError if empty."""
588.         it = iter(self)
589.         try:
590.             value = next(it)
591.         except StopIteration:
592.             raise KeyError
593.         self.discard(value)
594.         return value
596.     def clear(self):
597.         """This is slow (creates N new iterators!) but effective."""
598.         try:
599.             while True:
600.                 self.pop()
601.         except KeyError:
602.             pass
604.     def __ior__(self, it):
605.         for value in it:
606.             self.add(value)
607.         return self
609.     def __iand__(self, it):
610.         for value in (self - it):
611.             self.discard(value)
612.         return self
614.     def __ixor__(self, it):
615.         if it is self:
616.             self.clear()
617.         else:
618.             if not isinstance(it, Set):
619.                 it = self._from_iterable(it)
620.             for value in it:
621.                 if value in self:
622.                     self.discard(value)
623.                 else:
624.                     self.add(value)
625.         return self
627.     def __isub__(self, it):
628.         if it is self:
629.             self.clear()
630.         else:
631.             for value in it:
632.                 self.discard(value)
633.         return self
635. MutableSet.register(set)
638. ### MAPPINGS ###
641. class Mapping(Collection):
643.     __slots__ = ()
645.     """A Mapping is a generic container for associating key/value
646.     pairs.
648.     This class provides concrete generic implementations of all
649.     methods except for __getitem__, __iter__, and __len__.
651.     """
653.     @abstractmethod
654.     def __getitem__(self, key):
655.         raise KeyError
657.     def get(self, key, default=None):
658.         'D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.'
659.         try:
660.             return self[key]
661.         except KeyError:
662.             return default
664.     def __contains__(self, key):
665.         try:
666.             self[key]
667.         except KeyError:
668.             return False
669.         else:
670.             return True
672.     def keys(self):
673.         "D.keys() -> a set-like object providing a view on D's keys"
674.         return KeysView(self)
676.     def items(self):
677.         "D.items() -> a set-like object providing a view on D's items"
678.         return ItemsView(self)
680.     def values(self):
681.         "D.values() -> an object providing a view on D's values"
682.         return ValuesView(self)
684.     def __eq__(self, other):
685.         if not isinstance(other, Mapping):
686.             return NotImplemented
687.         return dict(self.items()) == dict(other.items())
689.     __reversed__ = None
691. Mapping.register(mappingproxy)
694. class MappingView(Sized):
696.     __slots__ = '_mapping',
698.     def __init__(self, mapping):
699.         self._mapping = mapping
701.     def __len__(self):
702.         return len(self._mapping)
704.     def __repr__(self):
705.         return '{0.__class__.__name__}({0._mapping!r})'.format(self)
708. class KeysView(MappingView, Set):
710.     __slots__ = ()
712.     @classmethod
713.     def _from_iterable(self, it):
714.         return set(it)
716.     def __contains__(self, key):
717.         return key in self._mapping
719.     def __iter__(self):
720.         yield from self._mapping
722. KeysView.register(dict_keys)
725. class ItemsView(MappingView, Set):
727.     __slots__ = ()
729.     @classmethod
730.     def _from_iterable(self, it):
731.         return set(it)
733.     def __contains__(self, item):
734.         key, value = item
735.         try:
736.             v = self._mapping[key]
737.         except KeyError:
738.             return False
739.         else:
740.             return v is value or v == value
742.     def __iter__(self):
743.         for key in self._mapping:
744.             yield (key, self._mapping[key])
746. ItemsView.register(dict_items)
749. class ValuesView(MappingView):
751.     __slots__ = ()
753.     def __contains__(self, value):
754.         for key in self._mapping:
755.             v = self._mapping[key]
756.             if v is value or v == value:
757.                 return True
758.         return False
760.     def __iter__(self):
761.         for key in self._mapping:
762.             yield self._mapping[key]
764. ValuesView.register(dict_values)
767. class MutableMapping(Mapping):
769.     __slots__ = ()
771.     """A MutableMapping is a generic container for associating
772.     key/value pairs.
774.     This class provides concrete generic implementations of all
775.     methods except for __getitem__, __setitem__, __delitem__,
776.     __iter__, and __len__.
778.     """
780.     @abstractmethod
781.     def __setitem__(self, key, value):
782.         raise KeyError
784.     @abstractmethod
785.     def __delitem__(self, key):
786.         raise KeyError
788.     __marker = object()
790.     def pop(self, key, default=__marker):
791.         '''D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
792.           If key is not found, d is returned if given, otherwise KeyError is raised.
793.         '''
794.         try:
795.             value = self[key]
796.         except KeyError:
797.             if default is self.__marker:
798.                 raise
799.             return default
800.         else:
801.             del self[key]
802.             return value
804.     def popitem(self):
805.         '''D.popitem() -> (k, v), remove and return some (key, value) pair
806.            as a 2-tuple; but raise KeyError if D is empty.
807.         '''
808.         try:
809.             key = next(iter(self))
810.         except StopIteration:
811.             raise KeyError
812.         value = self[key]
813.         del self[key]
814.         return key, value
816.     def clear(self):
817.         'D.clear() -> None.  Remove all items from D.'
818.         try:
819.             while True:
820.                 self.popitem()
821.         except KeyError:
822.             pass
824.     def update(*args, **kwds):
825.         ''' D.update([E, ]**F) -> None.  Update D from mapping/iterable E and F.
826.             If E present and has a .keys() method, does:     for k in E: D[k] = E[k]
827.             If E present and lacks .keys() method, does:     for (k, v) in E: D[k] = v
828.             In either case, this is followed by: for k, v in F.items(): D[k] = v
829.         '''
830.         if not args:
831.             raise TypeError("descriptor 'update' of 'MutableMapping' object "
832.                             "needs an argument")
833.         self, *args = args
834.         if len(args) > 1:
835.             raise TypeError('update expected at most 1 arguments, got %d' %
836.                             len(args))
837.         if args:
838.             other = args[0]
839.             if isinstance(other, Mapping):
840.                 for key in other:
841.                     self[key] = other[key]
842.             elif hasattr(other, "keys"):
843.                 for key in other.keys():
844.                     self[key] = other[key]
845.             else:
846.                 for key, value in other:
847.                     self[key] = value
848.         for key, value in kwds.items():
849.             self[key] = value
851.     def setdefault(self, key, default=None):
852.         'D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D'
853.         try:
854.             return self[key]
855.         except KeyError:
856.             self[key] = default
857.         return default
859. MutableMapping.register(dict)
862. ### SEQUENCES ###
865. class Sequence(Reversible, Collection):
867.     """All the operations on a read-only sequence.
869.     Concrete subclasses must override __new__ or __init__,
870.     __getitem__, and __len__.
871.     """
873.     __slots__ = ()
875.     @abstractmethod
876.     def __getitem__(self, index):
877.         raise IndexError
879.     def __iter__(self):
880.         i = 0
881.         try:
882.             while True:
883.                 v = self[i]
884.                 yield v
885.                 i += 1
886.         except IndexError:
887.             return
889.     def __contains__(self, value):
890.         for v in self:
891.             if v is value or v == value:
892.                 return True
893.         return False
895.     def __reversed__(self):
896.         for i in reversed(range(len(self))):
897.             yield self[i]
899.     def index(self, value, start=0, stop=None):
900.         '''S.index(value, [start, [stop]]) -> integer -- return first index of value.
901.            Raises ValueError if the value is not present.
902.         '''
903.         if start is not None and start < 0:
904.             start = max(len(self) + start, 0)
905.         if stop is not None and stop < 0:
906.             stop += len(self)
908.         i = start
909.         while stop is None or i < stop:
910.             try:
911.                 v = self[i]
912.                 if v is value or v == value:
913.                     return i
914.             except IndexError:
915.                 break
916.             i += 1
917.         raise ValueError
919.     def count(self, value):
920.         'S.count(value) -> integer -- return number of occurrences of value'
921.         return sum(1 for v in self if v is value or v == value)
923. Sequence.register(tuple)
924. Sequence.register(str)
925. Sequence.register(range)
926. Sequence.register(memoryview)
929. class ByteString(Sequence):
931.     """This unifies bytes and bytearray.
933.     XXX Should add all their methods.
934.     """
936.     __slots__ = ()
938. ByteString.register(bytes)
939. ByteString.register(bytearray)
942. class MutableSequence(Sequence):
944.     __slots__ = ()
946.     """All the operations on a read-write sequence.
948.     Concrete subclasses must provide __new__ or __init__,
949.     __getitem__, __setitem__, __delitem__, __len__, and insert().
951.     """
953.     @abstractmethod
954.     def __setitem__(self, index, value):
955.         raise IndexError
957.     @abstractmethod
958.     def __delitem__(self, index):
959.         raise IndexError
961.     @abstractmethod
962.     def insert(self, index, value):
963.         'S.insert(index, value) -- insert value before index'
964.         raise IndexError
966.     def append(self, value):
967.         'S.append(value) -- append value to the end of the sequence'
968.         self.insert(len(self), value)
970.     def clear(self):
971.         'S.clear() -> None -- remove all items from S'
972.         try:
973.             while True:
974.                 self.pop()
975.         except IndexError:
976.             pass
978.     def reverse(self):
979.         'S.reverse() -- reverse *IN PLACE*'
980.         n = len(self)
981.         for i in range(n//2):
982.             self[i], self[n-i-1] = self[n-i-1], self[i]
984.     def extend(self, values):
985.         'S.extend(iterable) -- extend sequence by appending elements from the iterable'
986.         for v in values:
987.             self.append(v)
989.     def pop(self, index=-1):
990.         '''S.pop([index]) -> item -- remove and return item at index (default last).
991.            Raise IndexError if list is empty or index is out of range.
992.         '''
993.         v = self[index]
994.         del self[index]
995.         return v
997.     def remove(self, value):
998.         '''S.remove(value) -- remove first occurrence of value.
999.            Raise ValueError if the value is not present.
1000.         '''
1001.         del self[self.index(value)]
1003.     def __iadd__(self, values):
1004.         self.extend(values)
1005.         return self
1007. MutableSequence.register(list)
1008. MutableSequence.register(bytearray)  # Multiply inheriting, see ByteString

复制代码

1.3.使用isinstance而不是type

（1）语法

1. isinstance(object, classinfo)

复制代码

其中，object 是变量，classinfo 是类型即 (tuple,dict,int,float,list,bool等) 和 class类
若参数 object 是 classinfo 类的实例，或者 object 是 classinfo 类的子类的一个实例， 返回 True。
若 object 不是一个给定类型的的对象， 则返回结果总是False。
若 classinfo 不是一种数据类型或者由数据类型构成的元组，将引发一个 TypeError 异常。
（2）isinstance简单用法

1. >>> isinstance(1,int)
2. True
3. >>>
4. >>> isinstance('1',str)
5. True
6. >>>
7. >>> isinstance(1,list)
8. False

复制代码

（3）type()与isinstance()的区别：

• 共同点：两者都可以判断对象类型
  
• 不同点：对于一个 class 类的子类对象类型判断，type就不行了，而 isinstance 可以。
  

1. class A:
2.     pass
4. class B(A):
5.     pass
7. b = B()
9. #判断b是不是B的类型
10. print(isinstance(b,B))        #True
11. # b是不是A的类型呢，也是的
12. #因为B继承A，isinstance内部会去检查继承链
13. print(isinstance(b,A))        #True
15. print(type(b) is B)           #True
16. #b指向了B()对象，虽然A是B的父类，但是A是另外一个对象，它们的id是不相等的
17. print(type(b) is A)           #False

复制代码

1.4.类变量和实例变量

python的类变量和实例变量，顾名思义，类变量是指跟类的变量，而实例变量，指跟类的具体实例相关联的变量

1. class A:
2.     #类变量
3.     bb = 11
4.     def __init__(self,x,y):
5.         #实例变量
6.         self.x = x
7.         self.y = y
9. a = A(2,3)
10. A.bb = 111111
11. print(a.x,a.y,a.bb)    # 2 3 111111
12. print(A.bb)            # 111111
14. a.bb = 2222     #实际上会在实例对象a里面新建一个属性bb
15. print(a.bb)          # 2222
16. print(A.bb)          # 111111

复制代码

1.5.类和实例属性的查找顺序

1. class D:
2.     pass
4. class C(D):
5.     pass
7. class B(D):
8.     pass
10. class A(B,C):
11.     pass
13. #顺序：A,B,C,D
14. #__mro__,类的属性查找顺序
15. print(A.__mro__)      #(<class '__main__.A'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.D'>, <class 'object'>)

复制代码

1. class D:
2.     pass
4. class E:
5.     pass
7. class C(E):
8.     pass
10. class B(D):
11.     pass
13. class A(B,C):
14.     pass
16. #顺序：A,B,D,C,E
17. #__mro__,类的属性查找顺序
18. print(A.__mro__)      
20. #(<class '__main__.A'>, <class '__main__.B'>, <class '__main__.D'>, <class '__main__.C'>, <class '__main__.E'>, <class 'object'>)

复制代码

1.6.类方法，静态方法，和实例方法

实例：

1. class Date():
2.     #构造函数
3.     def __init__(self,year,month,day):
4.         self.year = year
5.         self.month = month
6.         self.day = day
8.     #实例方法
9.     def tomorrow(self):
10.         self.day += 1
12.     # 静态方法不用写self
13.     @staticmethod
14.     def parse_from_string(date_str):
15.         year, month, day = tuple(date_str.split("-"))
16.         # 静态方法不好的地方是采用硬编码，如果用类方法的话就不会了
17.         return Date(int(year), int(month), int(day))
19.     #类方法
20.     @classmethod
21.     def from_string(cls, date_str):
22.         year, month, day = tuple(date_str.split("-"))
23.         # cls：传进来的类,而不是像静态方法把类写死了
24.         return cls(int(year), int(month), int(day))
26.     def __str__(self):
27.         return '%s/%s/%s'%(self.year,self.month,self.day)
29. if __name__ == "__main__":
30.     new_day = Date(2018,5,9)
31.     #实例方法
32.     new_day.tomorrow()
33.     print(new_day)       #2018/5/10
35.     #静态方法
36.     date_str = '2018-05-09'
37.     new_day = Date.parse_from_string(date_str)
38.     print(new_day)       #2018/5/9
40.     # 类方法
41.     date_str = '2018-05-09'
42.     new_day = Date.from_string(date_str)
43.     print(new_day)  # 2018/5/9

复制代码

1.7.python对象的自省机制

在计算机编程中，自省是指一种能力：检查某些事物以确定它是什么、它知道什么以及它能做什么。自省向程序员提供了极大的灵活性和控制力。

1. class Person:
2.     '''人类'''
3.     name = "user"
6. class Student(Person):
7.     def __init__(self,school_name):
8.         self.school_name = school_name
10. if __name__ == "__main__":
12.     user = Student('仙剑')
13.     #通过 __dict__ 查询有哪些属性
14.     print(user.__dict__)        #{'school_name': '仙剑'}
16.     print(Person.__dict__)      #{'__module__': '__main__', '__doc__': '人类', 'name': 'user', '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>}
18.     print(Person.__doc__)       #人类
20.     #可以添加属性
21.     user.__dict__['school_addr'] = '北京'
22.     print(user.school_addr)     #北京
25.     #dir也可以查看属性，比__dict__功能更强大
26.     print(dir(user))
27. #['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name', 'school_addr', 'school_name']

复制代码

1.8.super函数

super执行的顺序

1. class A:
2.     def __init__(self):
3.         print('A')
5. class B(A):
6.     def __init__(self):
7.         print('B')
8.         super().__init__()
11. class C(A):
12.     def __init__(self):
13.         print('C')
14.         super().__init__()
17. class D(B,C):
18.     def __init__(self):
19.         print('D')
20.         super(D, self).__init__()
22. if __name__ == '__main__':
23.     print(D.__mro__)          #(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)
24.     d = D()
25.    
26.    
27. #执行结果
28. D
29. B
30. C
31. A

复制代码

1.9.with语句（上下文管理器）

1. #上下文管理器
2. class Sample:
3.     def __enter__(self):
4.         print('enter')
5.         #获取资源
6.         return self
8.     def __exit__(self, exc_type, exc_val, exc_tb):
9.         #释放资源
10.         print('exit')
12.     def do_something(self):
13.         print('doing something')
15. #会自动执行enter和exit方法
16. with Sample() as sample:
17.     sample.do_something()
20. # 运行结果
21. enter
22. doing something
23. exit

复制代码

3.python元类编程

1.1.propety动态属性

在面向对象编程中，我们一般把名词性的东西映射成属性，动词性的东西映射成方法。在python中他们对应的分别是属性self.xxx和类方法。但有时我们需要的属性需要根据其他属性动态的计算，此时如果直接使用属性方法处理，会导致数据不同步。下面介绍@property方法来动态创建类属性。

1. from datetime import datetime,date
3. class User:
4.     def __init__(self,name,birthday):
5.         self.name = name
6.         self.birthday = birthday
7.         self._age = 0
9.     @property
10.     def age(self):
11.         return datetime.now().year - self.birthday.year
13.     @age.setter
14.     def age(self,value):
15.         self._age = value
17. if __name__ == '__main__':
18.     user = User("derek",date(year=1994,month=11,day=11))
19.     user.age = 23
20.     print(user._age)   # 23
21.     print(user.age)    # 24 ,动态计算出来的

复制代码

1.2.__getattr__和__getattribute__的区别

object.__getattr__(self, name)
找不到attribute的时候，会调用getattr，返回一个值或AttributeError异常。
object.__getattribute__(self, name)
无条件被调用，通过实例访问属性。如果class中定义了__getattr__()，则__getattr__()不会被调用（除非显示调用或引发AttributeError异常）
（1）调用一个不存在的属性

1. class User:
2.     def __init__(self,info={}):
3.         self.info = info
5.     # def __getattr__(self, item):
6.     #     return self.info[item]
8. if __name__ == '__main__':
9.     user = User(info={"name":"derek","age":24})
10.     print(user.name)

复制代码

会报错

（2）加了__getattr__之后就可以调用了

1. class User:
2.     def __init__(self,info={}):
3.         self.info = info
5.     #__getattr__是在查找不到属性的时候调用
6.     def __getattr__(self, item):
7.         return self.info[item]
9. if __name__ == '__main__':
10.     user = User(info={"name":"derek","age":24})
11.     print(user.name)    #derek

复制代码

（3）__getattribute__

1. class User:
2.     def __init__(self,info={}):
3.         self.info = info
5.     #__getattr__是在查找不到属性的时候调用
6.     def __getattr__(self, item):
7.         return self.info[item]
9.     #__getattribute不管属性存不存在，都访问这个
10.     def __getattribute__(self, item):
11.         return "zhang_derek"
14. if __name__ == '__main__':
15.     user = User(info={"name":"derek","age":24})
16.     #不管属性存不存在，都走__getattribute__
17.     print(user.name)    #zhang_derek     #即使属性存在也走__getattribute__
18.     print(user.test)     #zhang_derek    #不存在的属性也能打印
19.     print(user.company)   #zhang_derek   #不存在的属性也能打印

复制代码

1.3.属性描述符

验证赋值的时候是不是int类型

1. #属性描述符
3. import numbers
5. #只要一个类实现了下面三种魔法函数中的一种，这个类就是属性描述符
6. class IntField:
7.     def __get__(self, instance, owner):
8.         return self.value
9.     def __set__(self, instance, value):
10.         if not isinstance(value,numbers.Integral):
11.             raise ValueError("必须为int")
12.         self.value = value
13.     def __delete__(self, instance):
14.         pass
16. class User:
17.     age = IntField()
19. if __name__ == '__main__':
20.     user = User()
21.     user.age = 24
22.     print(user.age)

复制代码

如果user.age=24，值是int，可以正常打印
如果user.age='test',传一个字符串，则会报错

1.4.__new__和__init__的区别

（1）__new__方法如果不返回对象，不会执行init方法

1. class User:
2.     def __new__(cls, *args, **kwargs):
3.         print("in new")
5.     def __init__(self,name):
6.         print("in init")
7.         self.name = name
9. # new是用用来控制对象的生成过程，在对象生成之前
10. # init是用来完善对象的
11. # 如果new方法不返回对象，则不会调用init函数
12. if __name__ == '__main__':
13.     user = User("derek")

复制代码

运行结果：没有调用init方法

（2）返回对象就会执行init方法

1. class User:
2.     def __new__(cls, *args, **kwargs):
3.         print("in new")         #in new
4.         print(cls)              #cls是当前class对象    <class '__main__.User'>
5.         print(type(cls))        #<class 'type'>
6.         return super().__new__(cls)   #必须返回class对象，才会调用__init__方法
8.     def __init__(self,name):
9.         print("in init")        #in init
10.         print(self)             #self是class的实例对象      <__main__.User object at 0x00000000021B8780>
11.         print(type(self))       #<class '__main__.User'>
12.         self.name = name
14. # new是用用来控制对象的生成过程，在对象生成之前
15. # init是用来完善对象的
16. # 如果new方法不返回对象，则不会调用init函数
17. if __name__ == '__main__':
18.     user = User(name="derek")
20. #总结
21. # __new__ 用来创建实例，在返回的实例上执行__init__，如果不返回实例那么__init__将不会执行
22. # __init__ 用来初始化实例，设置属性什么的

复制代码

1.5.自定义元类

（1）前戏：通过传入不同的字符串动态的创建不同的类

1. def create_class(name):
2.     if name == 'user':
3.         class User:
4.             def __str__(self):
5.                 return "user"
6.         return User
8.     elif name == "company":
9.         class Company:
10.             def __str__(self):
11.                 return "company"
12.         return Company
14. if __name__ == '__main__':
15.     Myclass = create_class("user")
16.     my_obj = Myclass()
17.     print(my_obj)    #user
18.     print(type(my_obj))     #<class '__main__.create_class.<locals>.User'>

复制代码

（2）用type创建
虽然上面的方法能够创建，但很麻烦，下面是type创建类的一个简单实例

1. # 一个简单type创建类的例子
2. #type(object_or_name, bases, dict)
3. #type里面有三个参数，第一个类名，第二个基类名，第三个是属性
4. User = type("User",(),{"name":"derek"})
6. my_obj = User()
7. print(my_obj.name)    #derek

复制代码

（3）不但可以定义属性，还可以定义方法

1. def say(self):     #必须加self
2.     return "i am derek"
4. User = type("User",(),{"name":"derek","say":say})
6. my_obj = User()
7. print(my_obj.name)     #derek
8. print(my_obj.say())    #i am derek

复制代码

（4）让type创建的类继承一个基类

1. def say(self):     #必须加self
2.     return "i am derek"
4. class BaseClass:
5.     def answer(self):
6.         return "i am baseclass"
8. #type里面有三个参数，第一个类名，第二个基类名，第三个是属性
9. User = type("User",(BaseClass,),{"name":"derek","say":say})
11. if __name__ == '__main__':
13.     my_obj = User()
14.     print(my_obj.name)          # derek
15.     print(my_obj.say())         # i am derek
16.     print(my_obj.answer())      # i am baseclass

复制代码

1.6.什么是元类？

元类就是创建类的类，比如上面的type
在实际编码中，我们一般不直接用type去创建类，而是用元类的写法，自定义一个元类metaclass去创建

1. # 把User类创建的过程委托给元类去做，这样代码的分离性比较好
3. class MetaClass(type):
4.     def __new__(cls, *args, **kwargs):
5.         return super().__new__(cls,*args, **kwargs)
7. class User(metaclass=MetaClass):
8.     def __init__(self,name):
9.         self.name = name
11.     def __str__(self):
12.         return "test"
14. if __name__ == '__main__':
15.     #python中类的实例化过程，会首先寻找metaclass，通过metaclass去创建User类
16.     my_obj = User(name="derek")
17.     print(my_obj)    #test

复制代码

4.自定义序列类

1.1.序列类型的分类

1.2.序列的+和+=，extend和append的区别

1. from collections import abc
3. a = [1,2,]
4. c = a + [3,4]
5. print(c)         #[1, 2, 3, 4]
7. #如果 + 元祖则会报错， not tuple
8. # c = a + (3,4)     #TypeError: can only concatenate list (not "tuple") to list
10. # + 是新生产一个list, += 是就地加，不会新生成list
11. #用+= 则可以是元祖，后面只要是可迭代的就行
12. #其原理是python内部抽象基类MutableSequence里面有个魔法函数__iadd__来实现的
13. a += (3,4)       #[1, 2, 3, 4]
14. print(a)
16. a.extend((5,6))
17. print(a)        #[1, 2, 3, 4, 5, 6]
19. a.append((7,8))
20. print(a)        #[1, 2, 3, 4, 5, 6, (7, 8)]
22. #可以看到extend和append结果并不一样，append是把里面当一个值传进去，extend是迭代的传进去

复制代码

1.3.实现可切片的对象

（1）切片的用法

1. #模式[start:end:step]
2. """
3.     其中，第一个数字start表示切片开始位置，默认为0；
4.     第二个数字end表示切片截止（但不包含）位置（默认为列表长度）；
5.     第三个数字step表示切片的步长（默认为1）。
6.     当start为0时可以省略，当end为列表长度时可以省略，
7.     当step为1时可以省略，并且省略步长时可以同时省略最后一个冒号。
8.     另外，当step为负整数时，表示反向切片，这时start应该比end的值要大才行。
9. """
10. aList = [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
11. #切片返回的是一个新元素，不会改变原有的list
13. print (aList[::])  # 返回包含原列表中所有元素的新列表            [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
14. print (aList[::-1])  # 返回包含原列表中所有元素的逆序列表        [17, 15, 13, 11, 9, 7, 6, 5, 4, 3]
15. print (aList[::2])  # 隔一个取一个，获取偶数位置的元素           [3, 5, 7, 11, 15]
16. print (aList[1::2])  # 隔一个取一个，获取奇数位置的元素          [4, 6, 9, 13, 17]
17. print (aList[3:6])  # 指定切片的开始和结束位置                   [6, 7, 9]
18. print(aList[0:100])  # 切片结束位置大于列表长度时，从列表尾部截断      [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
19. print(aList[100:])  # 切片开始位置大于列表长度时，返回空列表           []
21. # aList[len(aList):] = [9]  # 在列表尾部增加元素
22. # aList[:0] = [1, 2]  # 在列表头部插入元素
23. # aList[3:3] = [4]  # 在列表中间位置插入元素
24. # aList[:3] = [1, 2]  # 替换列表元素，等号两边的列表长度相等
25. # aList[3:] = [4, 5, 6]  # 等号两边的列表长度也可以不相等
26. # aList[::2] = [0] * 3  # 隔一个修改一个
27. # print (aList)
28. # aList[::2] = ['a', 'b', 'c']  # 隔一个修改一个
29. # aList[::2] = [1,2]  # 左侧切片不连续，等号两边列表长度必须相等  #会报错
30. # aList[:3] = []  # 删除列表中前3个元素
33. #删除
34. # del aList[:3]  # 切片元素连续
35. # del aList[::2]  # 切片元素不连续，隔一个删一个

复制代码

（2）实现对象支持切片操作

1. from collections import abc
2. #Sequence协议
4. import numbers
5. class Group:
6.     #支持切片操作
7.     def __init__(self, group_name, company_name, staffs):
8.         self.group_name = group_name
9.         self.company_name = company_name
10.         self.staffs = staffs
12.     def __reversed__(self):
13.         self.staffs.reverse()
15.     def __getitem__(self, item):
16.         #当前的类
17.         cls = type(self)
18.         #判断类是不是可切片的对象
19.         if isinstance(item, slice):
20.             return cls(group_name=self.group_name, company_name=self.company_name, staffs=self.staffs[item])
21.         elif isinstance(item, numbers.Integral):
22.             return cls(group_name=self.group_name, company_name=self.company_name, staffs=[self.staffs[item]])
24.     def __len__(self):
25.         return len(self.staffs)
27.     def __iter__(self):
28.         return iter(self.staffs)
30.     def __contains__(self, item):
31.         if item in self.staffs:
32.             return True
33.         else:
34.             return False
36. staffs = ["derek1", "derek2", "derek3", "derek4"]
37. group = Group(company_name="alibaba", group_name="user", staffs=staffs)
39. #现在对象就成可切片的对象了
41. #__getitem__
42. for user in group:
43.     print(user)
45. #运行结果
46. # derek1
47. # derek2
48. # derek3
49. # derek4
51. #__contains__
52. if 'derek1' in group:
53.     print('yes')

复制代码

1.4.列表生成式，字典推导式

1. # odd_list = []
2. # for i in range(21):
3. #     if i%2 == 1:
4. #         odd_list.append(i)
5. # print(odd_list)      #[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
8. #列表生成式
9. #1.取出1-20之间的基数
10. odd_list = [i for i in range(21) if i %2 == 1]
11. print(odd_list)     #[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
13. #2.取出1-20之间的基数的平方
14. def hadle_item(item):
15.     return item * item
17. odd_list = [hadle_item(i) for i in range(21) if i %2 == 1]
18. print(odd_list)     #[1, 9, 25, 49, 81, 121, 169, 225, 289, 361]

复制代码

利用字典推导式把字典的key和value做转换：{key:value}变成{value:key}的形式

1. # 字典推导式的用法
2. my_dict = {'derek1':11,'derek2':22,'derek3':33}
3. reversed_dict = {value:key for key,value in my_dict.items()}
4. print(reversed_dict)    #{11: 'derek1', 22: 'derek2', 33: 'derek3'}

复制代码

https://www.cnblogs.com/derek1184405959/p/8579428.html

来源:https://www.cnblogs.com/geoffreygao/p/17271010.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！