ToB企服应用市场:ToB评测及商务社交产业平台

标题: day16-面向对象高级和应用 [打印本页]

---

作者: 怀念夏天    时间: 2024-5-17 22:42
标题: day16-面向对象高级和应用
1. 继承【补充】

对于Python面向对象中的继承，我们已学过：

• 继承存在意义：将公共的方法提取到父类中，有利于增加代码重用性。
  
• 继承的编写方式：
  1. # 继承
  2. class Base(object):
  3.     pass
  5. class Foo(Base):
  6.     pass

  复制代码
  1. # 多继承
  2. class Base(object):
  3.     pass
  5. class Bar(object):
  6.     pass
  8. class Foo(Base,Bar):
  9.     pass

  复制代码
• 调用类中的成员时，遵照：
  
  
  
  • 优先在自己所在类中找，没有的话则去父类中找。
    
  • 如果类存在多继承（多个父类），则先找左边再找右边。
    
  
  

上述的知识点把握之后，其实就可以办理继承相关的大部分问题。
但如果遇到一些特殊情况（不常见），你就可能不知道怎么搞了，例如：

1.1 mro和c3算法

如果类中存在继承关系，在可以通过mro()获取当前类的继承关系（找成员的顺序）。
示例1：

1. mro(A) = [A] + [B,C]
2. mro(A) = [A,B,C]

复制代码

1. mro(A) = [A] + merge( mro(B), mro(C), [B,C] )
2. mro(A) = [A] + merge( [object], [object], [] )
3. mro(A) = [A] + [B,C,object]
4. mro(A) = [A,B,C,object]

复制代码

1. mro(A) = [A] + merge( mro(B), mro(C), [B,C] )
2. mro(A) = [A] + merge( [], [C], [,C] )
3. mro(A) = [A] + [B,C]

复制代码

1. class C(object):
2.     pass
4. class B(object):
5.     pass
7. class A(B, C):
8.     pass
10. print( A.mro() )   # [<class '__main__.A'>, <class '__main__.B'>, <class '__main__.C'>, <class 'object'>]
11. print( A.__mro__ ) # (<class '__main__.A'>, <class '__main__.B'>, <class '__main__.C'>, <class 'object'>)

复制代码

示例2：

1. mro(A) = [A] + merge( mro(B), mro(C), [B,C] )
2. mro(A) = [A] + merge( [], [D], [] )
3. mro(A) = [A] + [B,C,D]
4. mro(A) = [A,B,C,D]

复制代码

1. class D(object):
2.     pass
5. class C(D):
6.     pass
9. class B(object):
10.     pass
13. class A(B, C):
14.     pass
17. print( A.mro() ) # [<class '__main__.A'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.D'>, <class 'object'>]

复制代码

示例3:

1. mro(A) = [A] + merge( mro(B),mro(C),[B,C])
2. mro(A) = [A] + merge( [B,D], [C], [B,C])
3. mro(A) = [A] + merge( [], [C], [C])
4. mro(A) = [A,B,D,C]

复制代码

1. class D(object):
2.     pass
5. class C(object):
6.     pass
9. class B(D):
10.     pass
13. class A(B, C):
14.     pass
17. print(A.mro()) # [<class '__main__.A'>, <class '__main__.B'>, <class '__main__.D'>, <class '__main__.C'>, <class 'object'>]

复制代码

示例4：

1. mro(A) = [A] + merge( mro(B), mro(C), [B,C])
3. mro(A) = [A] + merge( [B,D], [C,D], [B,C])
5. mro(A) = [A] + [B,C,D]
6. mro(A) = [A,B,C,D]

复制代码

1. class D(object):
2.     pass
5. class C(D):
6.     pass
9. class B(D):
10.     pass
13. class A(B, C):
14.     pass
17. print(A.mro()) # [<class '__main__.A'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.D'>, <class 'object'>]

复制代码

示例5：

1. 简写为：A -> B -> D -> G -> H -> K -> C -> E -> F -> M -> N -> P -> object

复制代码

1. mro(A) = [A] + merge( mro(B),          mro(C),      mro(P),      [B,C,P])
2.                   []   [N]     [P]          [P]
4. mro(A) = [A,B,D,G,H,K,C,E,F,M,N,P]
6. -----------------------------------------------------
7. mro(B) = [B] + merge( mro(D), mro(E), [D,E])
9. mro(D) = [D] + merge(mro(G),mro(H), [G,H])
11. mro(G) = [G]
13. mro(H) = [H,K]
15. mro(B) = [B] + merge( [], [E,M], [E])
16. mro(B) = [B,D,G,H,K,E,M]
19. -----------------------------------------------------
20. mro(C) = [C] + merge(mro(E),mro(F),[E,F])
22. mro(E) = [E,M]
24. mro(F) = [F,M,N]
26. mro(C) = [C] + merge([M],[M,N] ,[])
27. mro(C) = [C,E,F,M,N]

复制代码

1. class M:
2.     pass
5. class N:
6.     pass
9. class E(M):
10.     pass
13. class G:
14.     pass
17. class K:
18.     pass
21. class H(K):
22.     pass
25. class D(G, H):
26.     pass
29. class F(M, N):
30.     pass
33. class P:
34.     pass
37. class C(E, F):
38.     pass
41. class B(D, E):
42.     pass
45. class A(B, C, P):
46.     pass
49. print(A.mro()) # 简写为：A -> B -> D -> G -> H -> K -> C -> E -> F -> M -> N -> P -> object

复制代码

特别补充：一句话搞定继承关系
不知道你是否发现，如果用正经的C3算法规则去分析一个类继承关系有点繁琐，尤其是遇到一个复杂的类也要分析很久。
所以，我自己根据经验总结了一句话赠予给大家：从左到右，深度优先，巨细钻石，留住顶端，基于这句话可以更快的找到继承关系。

1. 简写为：A -> B -> D -> G -> H -> K -> C -> E -> F -> M -> N -> P -> object

复制代码

1.2 py2和py3区别（了解）

概述：

• 在python2.2之前，只支持经典类【从左到右，深度优先，巨细钻石，不留顶端】
  
• 后来，Python想让类默认继承object（其他语言的面向对象基本上也都是默认都继承object），此时发现原来的经典类不能直接集成集成这个功能，有Bug。
  
• 所以，Python决定不再原来的经典类上举行修改了，而是再创建一个新式类来支持这个功能。【从左到右，深度优先，巨细钻石，留住顶端。】
  
  
  
  • 经典类，不继承object类型
    1. class Foo:
    2.     pass

    复制代码
  • 新式类，直接或间接继承object
    1. class Base(object):
    2.     pass
    4. class Foo(Base):
    5.     pass

    复制代码
  
  
• 这样，python2.2之后 中就出现了经典类和新式类共存。（正式支持是2.3）
  
• 最终，python3中丢弃经典类，只保存新式类。
  

1. 详细文档：
2.         https://www.python.org/dev/peps/pep-0253/#mro-method-resolution-order-the-lookup-rule
3.         https://www.python.org/download/releases/2.3/mro/
5. In classic Python, the rule is given by the following recursive function, also known as the left-to-right depth-first rule.
7. def classic_lookup(cls, name):
8.     if cls.__dict__.has_key(name):
9.         return cls.__dict__[name]
10.     for base in cls.__bases__:
11.         try:
12.             return classic_lookup(base, name)
13.         except AttributeError:
14.             pass
15.     raise AttributeError, name
16.    
17. The problem with this becomes apparent when we consider a "diamond diagram":
19.       class A:
20.         ^ ^  def save(self): ...
21.        /   \
22.       /     \
23.      /       \
24.     /         \
25. class B     class C:
26.     ^         ^  def save(self): ...
27.      \       /
28.       \     /
29.        \   /
30.         \ /
31.       class D
32.       
34. Arrows point from a subtype to its base type(s). This particular diagram means B and C derive from A, and D derives from B and C (and hence also, indirectly, from A).
36. Assume that C overrides the method save(), which is defined in the base A. (C.save() probably calls A.save() and then saves some of its own state.) B and D don't override save(). When we invoke save() on a D instance, which method is called? According to the classic lookup rule, A.save() is called, ignoring C.save()!
38. This is not good. It probably breaks C (its state doesn't get saved), defeating the whole purpose of inheriting from C in the first place.
40. Why was this not a problem in classic Python? Diamond diagrams are rarely found in classic Python class hierarchies. Most class hierarchies use single inheritance, and multiple inheritance is usually confined to mix-in classes. In fact, the problem shown here is probably the reason why multiple inheritance is unpopular in classic Python.
42. Why will this be a problem in the new system? The 'object' type at the top of the type hierarchy defines a number of methods that can usefully be extended by subtypes, for example __getattr__().
44. (Aside: in classic Python, the __getattr__() method is not really the implementation for the get-attribute operation; it is a hook that only gets invoked when an attribute cannot be found by normal means. This has often been cited as a shortcoming -- some class designs have a legitimate need for a __getattr__() method that gets called for all attribute references. But then of course this method has to be able to invoke the default implementation directly. The most natural way is to make the default implementation available as object.__getattr__(self, name).)
46. Thus, a classic class hierarchy like this:
48. class B     class C:
49.     ^         ^  def __getattr__(self, name): ...
50.      \       /
51.       \     /
52.        \   /
53.         \ /
54.       class D
55.       
57. will change into a diamond diagram under the new system:
59.       object:
60.         ^ ^  __getattr__()
61.        /   \
62.       /     \
63.      /       \
64.     /         \
65. class B     class C:
66.     ^         ^  def __getattr__(self, name): ...
67.      \       /
68.       \     /
69.        \   /
70.         \ /
71.       class D
74. and while in the original diagram C.__getattr__() is invoked, under the new system with the classic lookup rule, object.__getattr__() would be invoked!
76. Fortunately, there's a lookup rule that's better. It's a bit difficult to explain, but it does the right thing in the diamond diagram, and it is the same as the classic lookup rule when there are no diamonds in the inheritance graph (when it is a tree).

复制代码

总结：Python2和Python3在关于面向对象的区别。

• Py2：
  
  
  
  • 经典类，未继承object类型。【从左到右，深度优先，巨细钻石，不留顶端】
    1. class Foo:
    2.     pass

    复制代码
  • 新式类，直接获取间接继承object类型。【从左到右，深度优先，巨细钻石，留住顶端 -- C3算法】
    1. class Foo(object):
    2.     pass

    复制代码
    或
    1. class Base(object):
    2.   pass
    4. class Foo(Base):
    5.   pass

    复制代码
  
  
• Py3
  
  
  
  • 新式类，丢弃了经典类只保存了新式类。【从左到右，深度优先，巨细钻石，留住顶端 -- C3算法】
    1. class Foo:
    2.     passclass Bar(object):    pass

    复制代码
  
  

2. 内置函数补充

本次要给解说的内置函数共8个，他们都跟面向对象的知识相关。

• classmethod、staticmethod、property 。
  
• callable，是否可在后面加括号执行。
  
  
  
  • 函数
    1. def func():
    2.     pass
    4. print( callable(func) ) # True

    复制代码
  • 类
    1. class Foo(object):
    2.     passprint( callable(Foo) ) # True

    复制代码
  • 类中具有__call__方法的对象
    1. class Foo(object):
    2.         pass
    4. obj = Foo()
    5. print( callable(obj) ) # False

    复制代码
    1. class Foo(object):
    3.     def __call__(self, *args, **kwargs):
    4.         pass
    5.    
    6. obj = Foo()
    7. print( callable(obj) ) # True

    复制代码
  所以当你以后在见到下面的情况时，首先就要想到handler可以是：函数、类、具有call方法的对象 这三种，到底详细是什么，需要根据代码的调用关系才华分析出来。
  1. def do_something(handler):
  2.     handler()

  复制代码
• super，按照mro继承关系向上找成员。
  1. class Top(object):
  2.     def message(self, num):
  3.         print("Top.message", num)
  4.         
  5. class Base(Top):
  6.     pass
  8. class Foo(Base):
  10.     def message(self, num):
  11.         print("Foo.message", num)
  12.         super().message(num + 100)
  15. obj = Foo()
  16. obj.message(1)
  18. >>> Foo.message 1
  19. >>> Top.message 101

  复制代码
  1. class Base(object):
  3.     def message(self, num):
  4.         print("Base.message", num)
  5.         super().message(1000)
  8. class Bar(object):
  10.     def message(self, num):
  11.         print("Bar.message", num)
  14. class Foo(Base, Bar):
  15.     pass
  18. obj = Foo()
  19. obj.message(1)
  21. >>> Base.message 1
  22. >>> Bar.message 1000

  复制代码
  应用场景
  假设有一个类，他原来已实现了某些功能，但我们想在他的基础上再扩展点功能，重新写一遍？比较贫苦，此时可以用super。
  1. info = dict() # {}
  2. info['name'] = "武沛齐"
  3. info["age"] = 18
  5. value = info.get("age")
  7. print(value)

  复制代码
  1. class MyDict(dict):
  3.     def get(self, k):
  4.         print("自定义功能")
  5.         return super().get(k)
  8. info = MyDict()
  9. info['name'] = "武沛齐" # __setitem__
  10. info["age"] = 18       # __setitem__
  11. print(info)
  13. value = info.get("age")
  15. print(value)

  复制代码

• type，获取一个对象的类型。
  1. v1 = "武沛齐"
  2. result = type(v1)
  3. print(result) # <class 'str'>

  复制代码
  1. v2 = "武沛齐"
  2. print( type(v2) == str )  # True
  4. v3 = [11, 22, 33] # list(...)
  5. print( type(v3) == list )  # True

  复制代码
  1. class Foo(object):
  2.     passv4 = Foo()print( type(v4) == Foo )  # True

  复制代码
• isinstance，判定对象是否是某个类或其子类的实例。
  1. class Top(object):
  2.     pass
  5. class Base(Top):
  6.     pass
  9. class Foo(Base):
  10.     pass
  13. v1 = Foo()
  15. print( isinstance(v1, Foo) )   # True，对象v1是Foo类的实例
  16. print( isinstance(v1, Base) )  # True，对象v1的Base子类的实例。
  17. print( isinstance(v1, Top) )   # True，对象v1的Top子类的实例。

  复制代码
  1. class Animal(object):
  2.     def run(self):
  3.         pass
  5. class Dog(Animal):
  6.     pass
  8. class Cat(Animal):
  9.     pass
  11. data_list = [
  12.     "alex",
  13.     Dog(),
  14.     Cat(),
  15.     "root"
  16. ]
  18. for item in data_list:
  19.     if type(item) == Cat:
  20.         item.run()
  21.     elif type(item) == Dog:
  22.         item.run()
  23.     else:
  24.         pass
  25.    
  26. for item in data_list:
  27.     if isinstance(item, Animal):
  28.         item.run()
  29.     else:
  30.         pass

  复制代码
• issubclass，判定类是否是某个类的子孙类。
  1. class Top(object):
  2.     pass
  5. class Base(Top):
  6.     pass
  9. class Foo(Base):
  10.     pass
  13. print(issubclass(Foo, Base))  # True
  14. print(issubclass(Foo, Top))   # True

  复制代码

3.异常处理

在步调开辟中如果遇到一些 不可预知的错误 或 你懒得做一些判定 时，可以选择用异常处理来做。

1. import requests
3. while True:
4.     url = input("请输入要下载网页地址：")
5.     res = requests.get(url=url)
6.     with open('content.txt', mode='wb') as f:
7.         f.write(res.content)

复制代码

上述下载视频的代码在正常情况下可以运行，但如果遇到网络出问题，那么此时步调就会报错无法正常执行。

1. try:
2.     res = requests.get(url=url)
3. except Exception as e:
4.     代码块，上述代码出异常待执行。
5. print("结束")

复制代码

1. import requests
3. while True:
4.     url = input("请输入要下载网页地址：")
5.    
6.     try:
7.         res = requests.get(url=url)
8.     except Exception as e:
9.         print("请求失败，原因：{}".format(str(e)))
10.         continue
11.         
12.     with open('content.txt', mode='wb') as f:
13.         f.write(res.content)

复制代码

1. num1 = input("请输入数字：")
2. num2 = input("请输入数字：")
3. try:
4.     num1 = int(num1)
5.     num2 = int(num2)
6.     result = num1 + num2
7.     print(result)
8. except Exception as e:
9.     print("输入错误")

复制代码

以后常见的应用场景：

• 调用微信的API实现微信消息的推送、微信支付等
  
• 支付宝支付、视频播放等
  
• 数据库 或 redis连接和操纵
  
• 调用第三方的视频播放发的功能，由第三方的步调出问题导致的错误。
  

异常处理的基本格式：

1. try:
2.     # 逻辑代码
3. except Exception as e:
4.     # try中的代码如果有异常，则此代码块中的代码会执行。

复制代码

1. try:
2.     # 逻辑代码
3. except Exception as e:
4.     # try中的代码如果有异常，则此代码块中的代码会执行。finally:    # try中的代码无论是否报错，finally中的代码都会执行，一样平常用于开释资源。print("end")"""try:    file_object = open("xxx.log")    # ....except Exception as e:    # 异常处理finally:    file_object.close()  # try中没异常，最后执行finally关闭文件；try有异常，执行except中的逻辑，最后再执行finally关闭文件。"""

复制代码

3.1 异常细分

1. import requests
3. while True:
4.     url = input("请输入要下载网页地址：")
5.    
6.     try:
7.         res = requests.get(url=url)
8.     except Exception as e:
9.         print("请求失败，原因：{}".format(str(e)))
10.         continue
11.         
12.     with open('content.txt', mode='wb') as f:
13.         f.write(res.content)

复制代码

之前只是简单的捕捉了异常，出现异常则同一提示信息即可。如果想要对异常举行更加过细的异常处理，则可以这样来做：

1. import requests
2. from requests import exceptions
4. while True:
5.     url = input("请输入要下载网页地址：")
6.     try:
7.         res = requests.get(url=url)
8.         print(res)   
9.     except exceptions.MissingSchema as e:
10.         print("URL架构不存在")
11.     except exceptions.InvalidSchema as e:
12.         print("URL架构错误")
13.     except exceptions.InvalidURL as e:
14.         print("URL地址格式错误")
15.     except exceptions.ConnectionError as e:
16.         print("网络连接错误")
17.     except Exception as e:
18.         print("代码出现错误", e)
20. # 提示：如果想要写的简单一点，其实只写一个Exception捕获错误就可以了。

复制代码

如果想要对错误举行细分的处理，例如：发生Key错误和发生Value错误分开处理。
基本格式：

1. try:
2.     # 逻辑代码
3.     pass
5. except KeyError as e:
6.     # 小兵，只捕获try代码中发现了键不存在的异常，例如：去字典 info_dict["n1"] 中获取数据时，键不存在。
7.     print("KeyError")
9. except ValueError as e:
10.     # 小兵，只捕获try代码中发现了值相关错误，例如：把字符串转整型 int("无诶器")
11.     print("ValueError")
13. except Exception as e:
14.     # 王者，处理上面except捕获不了的错误（可以捕获所有的错误）。
15.     print("Exception")

复制代码

Python中内置了许多细分的错误，供你选择。

1. 常见异常：
2. """
3. AttributeError 试图访问一个对象没有的属性，比如foo.x，但是foo没有属性x
4. IOError 输入/输出异常；基本上是无法打开文件
5. ImportError 无法引入模块或包；基本上是路径问题或名称错误
6. IndentationError 语法错误（的子类） ；代码没有正确对齐
7. IndexError 下标索引超出序列边界，比如当x只有三个元素，却试图访问n x[5]
8. KeyError 试图访问字典里不存在的键 inf['xx']
9. KeyboardInterrupt Ctrl+C被按下
10. NameError 使用一个还未被赋予对象的变量
11. SyntaxError Python代码非法，代码不能编译(个人认为这是语法错误，写错了）
12. TypeError 传入对象类型与要求的不符合
13. UnboundLocalError 试图访问一个还未被设置的局部变量，基本上是由于另有一个同名的全局变量，导致你以为正在访问它
14. ValueError 传入一个调用者不期望的值，即使值的类型是正确的
15. """
16. 更多异常：
17. """
18. ArithmeticError
19. AssertionError
20. AttributeError
21. BaseException
22. BufferError
23. BytesWarning
24. DeprecationWarning
25. EnvironmentError
26. EOFError
27. Exception
28. FloatingPointError
29. FutureWarning
30. GeneratorExit
31. ImportError
32. ImportWarning
33. IndentationError
34. IndexError
35. IOError
36. KeyboardInterrupt
37. KeyError
38. LookupError
39. MemoryError
40. NameError
41. NotImplementedError
42. OSError
43. OverflowError
44. PendingDeprecationWarning
45. ReferenceError
46. RuntimeError
47. RuntimeWarning
48. StandardError
49. StopIteration
50. SyntaxError
51. SyntaxWarning
52. SystemError
53. SystemExit
54. TabError
55. TypeError
56. UnboundLocalError
57. UnicodeDecodeError
58. UnicodeEncodeError
59. UnicodeError
60. UnicodeTranslateError
61. UnicodeWarning
62. UserWarning
63. ValueError
64. Warning
65. ZeroDivisionError
66. """

复制代码

3.2 自定义异常&抛出异常

上面都是Python内置的异常，只有遇到特定的错误之后才会抛出相应的异常。
其实，在开辟中也可以自定义异常。

1. class MyException(Exception):
2.     pass

复制代码

1. try:
2.     pass
3. except MyException as e:
4.     print("MyException异常被触发了", e)
5. except Exception as e:
6.     print("Exception", e)

复制代码

上述代码在except中定义了捕捉MyException异常，但他永久不会被触发。因为默认的那些异常都有特定的触发条件，例如：索引不存在、键不存在会触发IndexError和KeyError异常。
对于我们自定义的异常，如果想要触发，则需要使用：raise MyException()类实现。

1. class MyException(Exception):
2.     passtry:    # 。。。    raise MyException()    # 。。。except MyException as e:    print("MyException异常被触发了", e)except Exception as e:    print("Exception", e)

复制代码

1. class MyException(Exception):
2.     def __init__(self, msg, *args, **kwargs):
3.         super().__init__(*args, **kwargs)
4.         self.msg = msg
7. try:
8.     raise MyException("xxx失败了")
9. except MyException as e:
10.     print("MyException异常被触发了", e.msg)
11. except Exception as e:
12.     print("Exception", e)

复制代码

1. class MyException(Exception):
2.     title = "请求错误"
5. try:
6.     raise MyException()
7. except MyException as e:
8.     print("MyException异常被触发了", e.title)
9. except Exception as e:
10.     print("Exception", e)

复制代码

案例一：你我互助协同开辟，你调用我写的方法。

• 我定义了一个函数
  1. class EmailValidError(Exception):
  2.     title = "邮箱格式错误"
  4. class ContentRequiredError(Exception):
  5.     title = "文本不能为空错误"
  6.    
  7. def send_email(email,content):
  8.     if not re.match("\w+@live.com",email):
  9.         raise EmailValidError()
  10.     if len(content) == 0 :
  11.         raise ContentRequiredError()
  12.     # 发送邮件代码...
  13.     # ...

  复制代码
• 你调用我写的函数
  1. def execute():
  2.     # 其他代码
  3.     # ...
  4.    
  5.     try:
  6.         send_email(...)
  7.     except EmailValidError as e:
  8.         pass
  9.     except ContentRequiredError as e:
  10.         pass
  11.     except Exception as e:
  12.         print("发送失败")
  14. execute()
  16. # 提示：如果想要写的简单一点，其实只写一个Exception捕获错误就可以了。

  复制代码

案例二：在框架内部已经定义好，遇到什么样的错误都会触发不同的异常。

1. import requests
2. from requests import exceptions
4. while True:
5.     url = input("请输入要下载网页地址：")
6.     try:
7.         res = requests.get(url=url)
8.         print(res)   
9.     except exceptions.MissingSchema as e:
10.         print("URL架构不存在")
11.     except exceptions.InvalidSchema as e:
12.         print("URL架构错误")
13.     except exceptions.InvalidURL as e:
14.         print("URL地址格式错误")
15.     except exceptions.ConnectionError as e:
16.         print("网络连接错误")
17.     except Exception as e:
18.         print("代码出现错误", e)
19.         
20. # 提示：如果想要写的简单一点，其实只写一个Exception捕获错误就可以了。

复制代码

案例三：按照规定去触发指定的异常，每种异常都具备被特殊的寄义。

3.4 特殊的finally

1. try:
2.     # 逻辑代码
3. except Exception as e:
4.     # try中的代码如果有异常，则此代码块中的代码会执行。finally:    # try中的代码无论是否报错，finally中的代码都会执行，一样平常用于开释资源。print("end")

复制代码

当在函数或方法中定义异常处理的代码时，要特别注意finally和return。

1. def func():
2.     try:
3.         return 123
4.     except Exception as e:
5.         pass
6.     finally:
7.         print(666)
9. func()

复制代码

在try或except中即使定义了return，也会执行最后的finally块中的代码。
练习题

• 补充代码实现捕捉步调中的错误。
  1. # 迭代器
  2. class IterRange(object):
  3.     def __init__(self, num):
  4.         self.num = num
  5.         self.counter = -1
  7.     def __iter__(self):
  8.         return self
  10.     def __next__(self):
  11.         self.counter += 1
  12.         if self.counter == self.num:
  13.             raise StopIteration()
  14.         return self.counter
  16.    
  17. obj = IterRange(20)
  19. while True:
  20.     try:
  21.          ele = next(obj)
  22.     except StopIteration as e:
  23.          print("数据获取完毕")
  24.          break
  25.     print(ele)
  26.    

  复制代码
• 补充代码实现捕捉步调中的错误。
  1. class IterRange(object):
  2.     def __init__(self, num):
  3.         self.num = num
  4.         self.counter = -1
  6.     def __iter__(self):
  7.         return self
  9.     def __next__(self):
  10.         self.counter += 1
  11.         if self.counter == self.num:
  12.             raise StopIteration()
  13.         return self.counter
  16. class Xrange(object):
  17.     def __init__(self, max_num):
  18.         self.max_num = max_num
  20.     def __iter__(self):
  21.         return IterRange(self.max_num)
  24. data_object = Xrange(100)
  25. obj_iter = data_object.__iter__()
  27. while True:
  28.     try:
  29.         ele = next(obj_iter)
  30.     except StopIteration as e:
  31.         print("数据获取完毕")
  32.         break
  33.     print(ele)

  复制代码
• 补充代码实现捕捉步调中的错误。
  1. def func():
  2.     yield 1
  3.     yield 2
  4.     yield 3
  5.    
  6. gen = func()
  7. while True:
  8.     try:
  9.         ele = next(gen)
  10.     except StopIteration as e:
  11.         print("数据获取完毕")
  12.         break
  13.     print(ele)

  复制代码
• 补充代码实现捕捉步调中的错误。（注意：本案例用于练习，在真实开辟中对于这种情况建议还是自己做判定处理，不要用异常）
  1. num = int("武沛齐")

  复制代码
  1. try:
  2.     num = int("武沛齐")
  3. except ValueError as e:
  4.     print("转换失败")

  复制代码
• 补充代码实现捕捉步调中的错误。（注意：本案例用于练习，在真实开辟中对于这种情况建议还是自己做判定处理，不要用异常）
  1. data = [11,22,33,44,55]
  2. data[1000]

  复制代码
  1. try:
  2.     data = [11,22,33,44,55]
  3.     data[1000]
  4. except IndexError as e:
  5.     print("转换失败")

  复制代码
• 补充代码实现捕捉步调中的错误。（注意：本案例用于练习，在真实开辟中对于这种情况建议还是自己做判定处理，不要用异常）
  1. data = {"k1":123,"k2":456}
  2. data["xxxx"]

  复制代码
  1. try:
  2.     data = {"k1":123,"k2":456}
  3.     data["xxxx"]
  4. except KeyError as e:
  5.     print("转换失败")

  复制代码
• 分析代码，写结果
  1. class MyDict(dict):
  3.     def __getitem__(self, item):
  4.         try:
  5.             return super().__getitem__(item) # KeyError
  6.         except KeyError as e:
  7.             return None
  10. info = MyDict()
  11. info['name'] = "武沛齐"
  12. info['wx'] = "wupeiq666"
  14. print(info['wx'])     # wupeiq666     info['wx']  -> __getitem__
  15. print(info['email'])  # None      info['email']  -> __getitem__

  复制代码
• 看代码写结果
  1. def run(handler):
  2.     try:
  3.         num = handler()
  4.         print(num)
  5.         return "成功"
  6.     except Exception as e:
  7.         return "错误"
  8.     finally:
  9.         print("END")
  11.     print("结束")
  14. res = run(lambda: 123)
  15. print(res)

  复制代码
  1. >>> 123
  2. >>> END
  3. >>> 成功

  复制代码
  1. def func():
  2.     print(666)
  3.     return "成功"
  5. def run(handler):
  6.     try:
  7.         num = handler()
  8.         print(num)
  9.         return func()
  10.     except Exception as e:
  11.         return "错误"
  12.     finally:
  13.         print("END")
  15.     print("结束")
  18. res = run(lambda: 123)
  19. print(res)

  复制代码
  1. >>> 123
  2. >>> 666
  3. >>> END
  4. >>> 成功

  复制代码

4.反射

反射，提供了一种更加灵活的方式让你可以实现去 对象 中操纵成员（以字符串的情势去 对象 中举行成员的操纵）。

1. class Person(object):
2.    
3.     def __init__(self,name,wx):
4.         self.name = name
5.         self.wx = wx
6.        
7.     def show(self):
8.         message = "姓名{}，微信：{}".format(self.name,self.wx)
9.         
10.         
11. user_object = Person("武沛齐","wupeiqi666")
14. # 对象.成员 的格式去获取数据
15. user_object.name
16. user_object.wx
17. user_object.show()
19. # 对象.成员 的格式去设置数据
20. user_object.name = "吴培期"

复制代码

1. user = Person("武沛齐","wupeiqi666")
3. # getattr 获取成员
4. getattr(user,"name") # user.name
5. getattr(user,"wx")   # user.wx
8. method = getattr(user,"show") # user.show
9. method()
10. # 或
11. getattr(user,"show")()
13. # setattr 设置成员
14. setattr(user, "name", "吴培期") # user.name = "吴培期"

复制代码

Python中提供了4个内置函数来支持反射：

• getattr，去对象中获取成员
  1. v1 = getattr(对象,"成员名称")
  2. v2 = getattr(对象,"成员名称", 不存在时的默认值)

  复制代码
• setattr，去对象中设置成员
  1. setattr(对象,"成员名称",值)

  复制代码
• hasattr，对象中是否包含成员
  1. v1 = hasattr(对象,"成员名称") # True/False

  复制代码
• delattr，删除对象中的成员
  1. delattr(对象,"成员名称")

  复制代码

以后如果再遇到 对象.成员 这种编写方式时，均可以基于反射来实现。
案例：

1. class Account(object):
3.     def login(self):
4.         pass
6.     def register(self):
7.         pass
9.     def index(self):
10.         pass
12.    
13. def run(self):
14.     name = input("请输入要执行的方法名称：") # index register login xx run ..
15.    
16.     account_object = Account()
17.     method = getattr(account_object, name,None) # index = getattr(account_object,"index")
18.    
19.     if not method:
20.         print("输入错误")
21.         return
22.     method()

复制代码

4.1 一切皆对象

在Python中有这么句话：一切皆对象。 每个对象的内部都有自己维护的成员。

• 对象是对象
  1. class Person(object):
  2.    
  3.     def __init__(self,name,wx):
  4.         self.name = name
  5.         self.wx = wx
  6.        
  7.     def show(self):
  8.         message = "姓名{}，微信：{}".format(self.name,self.wx)
  9.         
  10.         
  11. user_object = Person("武沛齐","wupeiqi666")
  12. user_object.name

  复制代码
• 类是对象
  1. class Person(object):
  2.     title = "武沛齐"
  4. Person.title
  5. # Person类也是一个对象（平时不这么称呼）

  复制代码
• 模块是对象
  1. import re
  3. re.match
  4. # re模块也是一个对象（平时不这么称呼）。

  复制代码

由于反射支持以字符串的形式去对象中操作成员【等价于 对象.成员 】，所以，基于反射也可以对类、模块中的成员举行操纵。
简单粗暴：只要看到 xx.oo 都可以用反射实现。

1. class Person(object):
2.     title = "武沛齐"
4. v1 = Person.title
5. print(v1)
6. v2 = getattr(Person,"title")
7. print(v2)

复制代码

1. import re
3. v1 = re.match("\w+","dfjksdufjksd")
4. print(v1)
6. func = getattr(re,"match")
7. v2 = func("\w+","dfjksdufjksd")
8. print(v2)

复制代码

4.2 import_module + 反射

在Python中如果想要导入一个模块，可以通过import语法导入；其实也可以通过字符串的情势导入。
示例一：

1. # 导入模块
2. import random
4. v1 = random.randint(1,100)

复制代码

1. # 导入模块
2. from importlib import import_module
4. m = import_module("random")
6. v1 = m.randint(1,100)

复制代码

示例二：

1. # 导入模块exceptions
2. from requests import exceptions as m

复制代码

1. # 导入模块exceptions
2. from importlib import import_module
3. m = import_module("requests.exceptions")

复制代码

示例三：

1. # 导入模块exceptions，获取exceptions中的InvalidURL类。
2. from requests.exceptions import InvalidURL

复制代码

1. # 错误方式
2. from importlib import import_module
3. m = import_module("requests.exceptions.InvalidURL") # 报错，import_module只能导入到模块级别。

复制代码

1. # 导入模块
2. from importlib import import_module
3. m = import_module("requests.exceptions")
4. # 去模块中获取类
5. cls = m.InvalidURL

复制代码

在许多项目的源码中都会有 import_module 和 getattr 配合实现根据字符串的情势导入模块并获取成员，例如：

1. from importlib import import_module
3. path = "openpyxl.utils.exceptions.InvalidFileException"
5. module_path,class_name = path.rsplit(".",maxsplit=1) # "openpyxl.utils.exceptions"   "InvalidFileException"
7. module_object = import_module(module_path)
9. cls = getattr(module_object,class_name)
11. print(cls)

复制代码

总结

• 了解 mro和c3算法
  
• python2和python3在面向对象中的区别。
  
• 内置函数
  1. staticmethod,classmethod,property,callable,type,isinstance,issubclass,super
  2. getattr,setattr,hasattr,delattr

  复制代码
• 异常处理
  
• 根据字符串的情势导入模块 import_module
  
• 根据字符串的情势操纵成员 反射-getattr,setattr,hasattr,delattr
  

作业

• super的作用？
  

1. 根据类继承关系向上寻找成员

复制代码

• 看图分析类A的继承关系
  
  
  
  

1. 继承关系：A->B->C->M->D->F->J->G->H

复制代码

• 看代码写结果
  1. class Foo(object):
  2.     def __init__(self, name, age):
  3.         self.name = name
  4.         self.age = age
  6.     @property
  7.     def message(self):
  8.         return "{}-{}".format(self.name, self.age)
  11. class Bar(Foo):
  12.     def __init__(self, email, *args, **kwargs):
  13.         super().__init__(*args, **kwargs)
  14.         self.email = email
  16.     def total(self):
  17.         data = "{}-{}-{}".format(self.name, self.age, self.email)
  18.         return data
  21. obj1 = Foo("武沛齐", 20)
  22. print(obj1.message)        # 武沛齐-20
  24. obj2 = Bar("xx@live.com", "root", 100)
  25. print(obj2.message)        # root-100
  26. print(obj2.total())        # root-100-xx@live.com

  复制代码
• 看代码写结果
  1. class Foo(object):
  2.     def __call__(self, *args, **kwargs):
  3.         return 666
  4.    
  5. data_list = [
  6.     "武沛齐",
  7.     dict,
  8.         lambda :123,
  9.     True,
  10.     Foo,
  11.     Foo()
  12. ]
  14. for item in data_list:
  15.     if callable(item):
  16.         val = item()
  17.         print(val)
  18.     else:
  19.         print(item)
  21. >>> 武沛齐
  22. >>> {}
  23. >>> 123
  24. >>> True
  25. >>> <__main__.Foo object at 0x0000022DC5259550>
  26. >>> 666

  复制代码
• 如何自动触发一个异常？
  

1. raise 异常类(...)

复制代码

• 反射的作用？
  

1. 以字符串的形式去对象中操作成员

复制代码

• 看代码写结果
  1. class Person(object):
  2.     title = "北京"
  4.     def __init__(self, name, wx):
  5.         self.name = name
  6.         self.wx = wx
  8.     def show(self):
  9.         message = "姓名{}，微信：{}".format(self.name, self.wx)
  10.         return message
  12.     @property
  13.     def message(self):
  14.         return 666
  16.     @staticmethod
  17.     def something():
  18.         return 999
  21. obj = Person("武沛齐", "wupeiqi666")
  23. print(getattr(obj, 'wx'))   # wupeiqi666
  24. print(getattr(obj, 'message'))  # 666
  25. print(getattr(obj, 'show')())   # 姓名武沛齐，微信：wupeiqi666
  26. print(getattr(obj, 'something')())  # 999

  复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

---

欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/)

Powered by Discuz! X3.4