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 *

========