Python之路，第二十篇：Python入门与基础20

python3  面向对象4

supper 函数

supper（type， obj） 返回绑定超类的实例（要求obj必须为type类型的实例）

supper（）   返回绑定的超类的实例，等同于（class， 实例方法的第一个参数），此方法必须用在方法内部；

作用：返回绑定超类的实例，用超类的实例来调用其自身的方法；

 class A(object):
     def hello(self):
         print("A类的hello（self）")

 class B(A):
     def hello(self):
         print("B类的hello（self）")
         #self.__class__.__base__.hello(self)  #A类的hello（self）

 b = B()
 b.hello()   #调用B类的方法
 #调用基类的方法
 super(B, b).hello() # A类的hello被调用，等同于B.__base__.hello(b)  #A类的hello（self）

 class A(object):
     def hello(self):
         print("A类的hello（self）")

 class B(A):
     def hello(self):
         print("B类的hello（self）")
         #self.__class__.__base__.hello(self)  #A类的hello（self）

     def super_hello(self): #此方法用来调用基类的hello方法
         #self.hello() #调用B类的hello方法
         super(B, self).hello() #可以简写为super().hello()

 b = B()
 b.hello()   #调用B类的方法
 #调用基类的方法
 #super(B, b).hello() # A类的hello被调用，等同于B.__base__.hello(b)  #A类的hello（self）
 b.super_hello() #A类的hello（self）

用于类的函数：

issubclass(cls,  类  或  类元组)

判断一个类是否是继承自其它的类，如果此类cls是类（class）或类元组中的一个派生子类，则返回True， 否则返回False；

查看帮助：

>>>help（__builtins__）可以查看所有内建类的帮助；

 class A:
     pass

 class B(A):
     pass

 class C(B):
     pass

 class D(C):
     pass

 #判断是否继承其他类
 print(issubclass(C, A))  #True
 print(issubclass(C, B))  #True
 print(issubclass(A, C))  #False
 print(issubclass(C, D))  #False
 print(issubclass(C, (A, B, D)))  #True
 #
 print(issubclass(int, object))   #True
 print(issubclass(int, bool))    #False
 print(issubclass(bool, int))    #True

显示调用基类的构造方法：

def   __init__(self,  ....):

.........

 #如何显示调用构造方法
 #class A(object):
 #    """docstring for A"""
 #    def __init__(self, arg):
 #        super(A, self).__init__()
 #        self.arg = arg

 class Human:
     def __init__(self, name, age):
         self.name = name
         self.age = age

     def infos(self):
         print("姓名：",self.name,"年龄：",self.age)

 class Student(Human):
     def __init__(self, name, age, score):
         #self.name = name
         #self.age = age
         super(Student, self).__init__(name, age)# 可以简写为 super().__init__(name,age)
         self.score = score

     def infos(self):
         print("姓名：",self.name,
               "年龄：",self.age,
               "分数：",self.score)

 h1 = Human("张三", 20)
 h1.infos() #姓名： 张三 年龄： 20

 s1 = Student("李四",21, 100)
 s1.infos() #姓名： 李四 年龄： 21 分数： 100

多态 polymorphic

什么是多态：

字面意思：“多种状态”；

多态是批在有继承/派生关系的类中，调用基类对象方法，实际能调用子类的覆盖方法现象叫多态；

多态调用的方法与对象相关，不与类型相关；

 class Shape: #图形类
     def drw(self):
         self.drawSelf()

 class Point(Shape):
     def drawSelf(self):
         print("正在画一个点.")

 class Circle(Point):
     def drawSelf(self):
         print("正在画一个圆.")

 shape = Point()
 shape.drw() #正在画一个点.

 shape = Circle()
 shape.drw() #正在画一个圆.

面向对象思想的特征：

1， 封装

2， 继承（派生）

3，多态

 class OrderSet(list):
     def add(self, n):
         for i in range(len(self)):
             self[i] += n

 L = OrderSet()
 L.append(10)
 L.append(19)
 print(L) #[10, 19]
 L.add(2)
 print(L) #[12, 21]

封装

作用：封装是指隐藏类的实现细节，让使用者不关心这些细节；

注：python的封装是假的（模拟的）封装；

私有实例变量和方法：

python中，以双下划线开头"__"开头，不以双下划线结尾的标识符，为私有成员；

私有成员分为：私有属性和私有方法

私有成员在子类和类外部无法访问；

 class A:
     def __init__(self, args):
         self.__p = None
         self.__p = args

     def __private_method(self):
         print("你好，我是私有方法.")

     def showA(self):
         print("self.__p",self.__p)
         self.__private_method()

 class B(A):
     def __init__(self):
         super().__init__(0)

     def myfun(self):
         pass
         #print("self.__p", self.__p) #错的，不能使用私有属性
         #self.__private_method()     #错的，不能使用私有方法

 b = B()
 b.myfun() #

 a = A(100)
 a.showA()
 #私有方法不能在类外部调用
 #a.__private_method()
 #私有属性不能在外部使用
 #a.__p -= 2
 #print(a.__p)

多继承 multiple  inheritance

多继承是指一个子类继承自两个或两个以上的基类；

多继承的语法：

class    类名（超类1，超类2，......）:

......

 class Car: #汽车类
     def run(self, speed):
         print("汽车以",speed, "km/h的速度行驶")

 class Plane: #飞机类
     def fly(self, height):
         print("在海拔", height, "米高度飞行.")

 class PlaneCar(Car, Plane):
     """PlaneCar 类 同时继承自汽车和飞机"""

 pl = PlaneCar()
 pl.fly(10000)
 pl.run(250)

多继承的问题（缺陷）： 标识符的冲突问题，要谨慎使用多继承；

 class A:
     def __init__(self):
         self.name = "A"

 class B:
     def __init__(self):
         self.name = "B"

 class AB(A, B):  #感觉A类、B类都可以用
     def infos(self):
         print(self.name) #

 ab = AB()
 ab.infos() #结果是"A" ; 不是"A","B".
 #######################################
 class A:
     def __init__(self):
         self.name = "A"

 class B:
     def __init__(self):
         self.name = "B"

 class AB(B, A):  #感觉A类、B类都可以用
     def infos(self):
         print(self.name) #

 ab = AB()
 ab.infos() #结果是"B" ; 不是"A","B".

PEP8  编码标准：

代码编写：

1，使用4个空格进行退进，不使用TAB，更不允许使用TAB和空格混用；

2，每行最大长度79个字节，超过部分使用反斜杠折行；

3，类和全局函数定义间隔两个空行，类内方法定义间隔一个空行，其他地方不加空行；

文档编排：

1，import部分 按标准，三方和自己编写的顺序依次排序，之间空一行；

2，不要在一名import 中导入多个库模块，如 import  os , sys, time应写成多行；

3， 尽可能用import  XX ，而不用from xx import yy 引用库， 因为可能出现名字冲突；

空格的使用：

1，各种右括号前不用加空格

L = [1,2,3]  # OK

L = { 1,2,3  }  #   } 前不要加空格；

2，逗号，冒号，分号前不要加空格；

3，函数左括号前不要加空格；

4，操作符左右各加一个空格，不要为了对齐增加空格；

5，函数的默认参数使用的赋值符左右省略空格（def  xxx(a=1,b=2):））;

6，不要将多句语句写在同一行，尽量不要加用分号；。

7，if/for/while语句中，即使执行语句只有一句，也必须另起一行；

========

总结：

1，python中闭包必须满足三大特点 ：1.闭包函数必须有内嵌函数   2.内嵌函数需要引用该嵌套函数上一级namespace中的变量  3.闭包函数必须返回内嵌函数；

2，如果你不想在异常发生时结束你的程序，只需在try里捕获它。

3，_foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import *

========