11-Python继承

一、封装【private】

1.概念

广义的封装：函数和类的定义本身，就是封装的体现

狭义的封装：一个类的某些属性，在使用的过程 中，不希望被外界直接访问，而是把这个属性给作为私有的【只有当前类持有】，然后暴露给外界一个访问的方法即可【间接访问属性】

封装的本质：就是属性私有化的过程

封装的好处：提高了数据的安全性，提高了数据的复用性

说明：举例：插排，不需要关心属性在类的内部做了什么样的操作，只需要关心将值传进去，或者将结果获取出来

2.属性私有化

如果想让成员变量不被外界直接访问，则可以在属性名称的前面添加两个下划线__,成员变量则被称为私有成员变量

私有属性的特点：只能在类的内部直接被访问，在外界不能直接访问

代码演示：

#1.属性不私有化的时候
class Person():
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def myPrint(self):
        print(self.name,self.age)

#通过构造函数给属性赋值
per = Person("张三",10)
per.myPrint()   #张三 10
#通过对象直接访问属性，并且给属性赋值
per.name = "李四"
per.age = 22
per.myPrint()   #李四 22

#2.属性私有化
#写法：在属性的前面添加两个下划线
#用法：只能在类的内部被访问，外界不能直接访问
class Person1():
    def __init__(self,name,age):
        self.name = name
        self.__age = age

    def myPrint(self):
        print(self.name,self.__age)

p1 = Person1("abc",10)
p1.myPrint()   #abc 10
p1.name = "hello"
#其实动态绑定属性，age和__age其实是两个不同的变量
p1.age = 222
p1.myPrint()
print(p1.age)

#AttributeError: 'Person1' object has no attribute '__age',私有化了，在外界不能直接访问
#print(p1.__age)

3.get函数和set函数

get函数和set函数并不是系统的函数，而是自定义的，为了和封装的概念相吻合，起名为getXxx和setXxx

get函数：获取值

set函数：赋值【传值】

代码演示：

#3.get函数和set函数
class Person2():
    def __init__(self,name,age):
        self.name = name
        self.__age = age
        #特殊情况一
        self.__weight__ = 20.0
        #特殊情况二
        self._height = 155.0

    def myPrint(self):
        print(self.name,self.__age)

    # 书写私有属性age的get函数和set函数【通过自定义的函数进行私有属性的赋值和获取值，暴露给外界】
    """
    get函数和set函数并不是系统的函数，而是自定义的，为了和封装的概念相吻合，起名为getXxx和setXxx
    get函数：获取值
    set函数：赋值【传值】
    """
    #set函数:给成员变量赋值
    #命名方式：setXxx
    #特点：需要设置参数，参数和私有成员变量有关
    def setAge(self,age):
        #数据的过滤
        if age < 0:
            age = 0
        self.__age = age
    #get函数：获取成员变量的值
    #命名方式：getXxx
    #特点：需要设置返回值，将成员变量的值返回
    def getAge(self):
        return self.__age

    #注意：有几个私有属性，则书写几对get函数和set函数

p2 = Person2("abc",10)
p2.myPrint()   #abc 10
#print(p2.__age)
#间接的访问了私有的成员变量
print(p2.getAge())
p2.setAge(22)
print(p2.getAge())

p2.setAge(-20)
print(p2.getAge())

#总结：通过将属性私有化之后，然后提供get函数和set函数，外部代码就不能随意更改成员变量的值，这样在一定程度上保证了数据的安全性

#4.工作原理【了解】
#当编译器加载了程序之后，不能直接访问p2.__age,Python解释器把__age解释成_Person2__age
#p2.__age = 100
p2._Person2__age = 100
print(p2.getAge())

#5.特殊情况：尽量不要直接访问
#a.在一个变量的前后各加两个下划线，在Python中被认为特殊成员变量，将不再属于私有变量
#print(p2.__weight__)
#b.特殊变量
#print(p2._height)

#面试题：下面变量的含义
"""
xxx:普通的变量
_xxx:受保护的变量，不建议使用这种形式
__xxx:表示私有的，外界无法直接访问，只能通过暴露给外界的函数访问
__xxxx__：一般是系统的内置变量，比如：__name__,__solts__,自定义标识符的时候尽量不要使用这种形式
"""

4.@property装饰器

装饰器的作用：可以给函数动态添加功能，对于类的成员方法，装饰器一样起作用

Python内置的@property装饰器的作用:将一个函数变成属性使用

@property装饰器：简化get函数和set函数

使用：@property装饰器作用相当于get函数，同时，会生成一个新的装饰器@属性名.settter,相当于set函数的作用

作用：使用在类中的成员函数中，可以简化代码，同时可以保证对参数做校验

代码演示：

class Person1():
    def __init__(self,name,age):
        self.__name = name
        self.__age = age

    def myPrint(self):
        print(self.__name,self.__age)

    """
   def setAge(self,age):
        #数据的过滤
        if age < 0:
            age = 0
        self.__age = age

    def getAge(self):
        return self.__age
    """

    #注意：函数的命名方式：变量的名称
    #作用：相当于get函数，设置返回值，将成员变量的值返回
    @property
    def age(self):
        return  self.__age

    #注意：函数的命名方式：需要和@property中函数的命名保持一致
    #作用：相当于set函数,设置参数，给成员变量赋值
    @age.setter
    def age(self,age):
        if age < 0:
            age = 0
        self.__age = age

    @property
    def name(self):
        return  self.__name

    @name.setter
    def name(self,name):
        self.__name = name


p1 = Person1("abc",10)
p1.myPrint()   #abc 10
#p1.setAge(20)
#print(p1.getAge())

print(p1.age)  #10
p1.age = 18   #相当于调用了set函数，将18传值，实质调用的是@age.setter修饰的函数
print(p1.age) #相当于调用了get函数，将成员变量的值获取出来，实质调用的是@peoperty修饰的函数

p1.name = "zhangsan"
print(p1.name)

5.私有方法

如果类中的一个函数名前面添加__,则认为这个成员函数时私有化的

特点：也不能在外界直接调用，只能在类的内类调用

代码演示：

class Site():
    def __init__(self,name):
        self.name = name

    def who(self):
        print(self.name)
        self.__foo()

    #私有成员方法，只能在当前类的内部内调用
    def __foo(self):    #私有函数
        print("foo")

    def foo(self):    #公开函数
        print("foo~~~~")

    #注意：以上两个函数是两个不同的函数，不存在覆盖的问题

s = Site("千锋")
s.who()
#s.__foo()  #AttributeError: 'Site' object has no attribute 'foo'
s.foo()

二、继承【extends】

1.概念

如果两个或者两个以上的类具有相同的属性或者成员方法，我们可以抽取一个类出来，在抽取的类中声明公共的部分

被抽取出来的类：父类，基类，超类，根类

两个或者两个以上的类：子类，派生类

他们之间的关系：子类  继承自  父类

注意：

a.object是所有类的父类，如果一个类没有显式指明它的父类，则默认为object

b.简化代码，提高代码的复用性

2.单继承

2.1使用

简单来说，一个子类只能有一个父类，被称为单继承

语法：

父类：

class 父类类名(object):

类体【所有子类公共的部分】

子类：

class 子类类名（父类类名）:

类体【子类特有的属性和成员方法】

说明：一般情况下，如果一个类没有显式的指明父类，则统统书写为object

代码演示：

person.py文件【父类】

#1.定义父类
class Person(object):
    #构造函数【成员变量】
    def __init__(self,name,age):
        self.name = name
        self.age = age


    #成员方法
    def show(self):
        print("show")

    def __fun(self):
        print("fun")

worker.py文件【子类1】

from  extends01.person import Person

#2.定义子类
class Worker(Person):
    #构造函数【成员变量】
    def __init__(self,name,age,job):
        """
        self.name = name
        self.age = age
        """
        self.job = job

        #6.在子类的构造函数中调用父类的构造函数【从父类中继承父类中的成员变量】
        #方式一：super(当前子类，self).__init__(属性列表)
        #super(Worker, self).__init__(name,age)
        #方式二：父类名.__init__(self,属性列表)
        Person.__init__(self,name,age)
        #方式三：super().__init__(属性列表)
        #super().__init__(name,age)


    #成员方法
    def work(self):
        print("work")

student.py文件【子类2】

from extends01.person import  Person

class Student(Person):
    # 构造函数【成员变量】
    def __init__(self, name, age, score):

        Person.__init__(self,name,age)
        self.score = score

    # 成员方法
    def study(self):
        print("study")

extendsDemo01.py文件【测试模块】

#测试模块
from extends01.person import Person
from extends01.worker import Worker
from extends01.student import Student

#3.创建父类的对象
p = Person("zhangsan",10)
p.show()
#p.__fun()

#4.创建子类的对象
w = Worker("aaa",20,"工人")
w.work()

#5.子类对象访问父类中的内容
#结论一：子类对象可以调用父类中的公开的成员方法【因为继承，私有方法除外】
w.show()
#w.__fun()
#结论二：通过在子类的构造函数中调用父类的构造函数，子类对象可以直接访问父类中的成员变量【私有变量除外】
print(w.name,w.age,w.job)

s = Student("小明",9,90)
s.study()
s.show()

2.2特殊用法

代码演示：

#6.子类中出现一个和父类同名的成员函数,则优先调用子类中的成员函数
#子类的成员函数覆盖了父类中的同名的成员函数
s = Student("小明",9,90)
s.study()
s.show()

#7.父类对象能不能访问子类中特有的成员函数和成员变量？----->不能
per = Person("gs",10)
#per.work()

#8.slots属性能否应用在子类中
#结论三：在父类中定义slots属性限制属性的定义，子类中是无法使用，除非在子类中添加自己的限制
#父类
class Student(object):
    __slots__ = ("name","age")

#子类
class SeniorStudent(Student):
    pass


s  = Student()
s.name = "zhangsan"
s.age = 10
#s.score = 90

ss = SeniorStudent()
ss.name = "lisi"
ss.age = 20
ss.score = 60

总结：

继承的特点：

a.子类对象可以直接访问父类中非私有化的属性

b.子类对象可以调用父类中非私有化的成员方法

c.父类对象不能访问或者调用子类 中任意的内容

继承的优缺点：

优点：

a.简化代码，减少代码的冗余

b.提高代码的复用性

c.提高了代码的可维护性

d.继承是多态的前提

缺点：

通常使用耦合性来描述类与类之间的关系，耦合性越低，则说明代码的质量越高

但是，在继承关系中，耦合性相对较高【如果修改父类，则子类也会随着发生改变】

3.多继承

一个子类可以有多个父类

语法：

class 子类类名(父类1，父类2，父类3.。。。)：

类体

代码演示：

father.py文件【父类1】

class Father(object):
    def __init__(self,money):
        self.money = money

    def play(self):
        print("playing")

    def fun(self):
        print("father中的fun")

mother.py文件【父类2】

class Mother(object):
    def __init__(self,faceValue):
        self.faceValue = faceValue

    def eat(self):
        print("eating")

    def fun(self):
        print("mother中的fun")

child.py文件【子类】

from extends02.father import Father
from extends02.mother import Mother

#定义子类，有多个父类
class Child(Mother,Father):
    def __init__(self,money,faceValue,hobby):
        #调用父类中的构造函数
        Father.__init__(self,money)
        Mother.__init__(self,faceValue)
        self.hobby = hobby

    def study(self):
        print("study")

extendsDemo03.py文件【测试模块】

from extends02.father import Father
from extends02.mother import Mother
from extends02.child import Child


f = Father(100000)
m = Mother(3.0)

#创建子类对象
c = Child(1000,3.0,"打游戏")
#子类对象调用父类中的成员方法
c.play()
c.eat()

#结论;如果多个父类中有相同的函数，通过子类的对象调用，调用的是哪个父类中的函数取决于在父类列表中出现的先后顺序
c.fun()

4.函数重写【override】

在子类中出现和父类同名的函数，则认为该函数是对父类中函数的重写

4.1系统函数重写

__str__   
__repr__

代码演示：

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

    #重写__str__函数,重写之后一般return一个字符串，有关于成员变量
    def __str__(self):
        return "name=%s age=%d"%(self.name,self.age)

    #重写__repr__,作用和str是相同的，优先使用str
    def __repr__(self):
        return "name=%s age=%d"%(self.name,self.age)

a = Animal("大黄",10)
print(a)   #<__main__.Animal object at 0x00000226A87AC240>
print(a.__str__())

#当一个类继承自object的时候，打印对象获取的是对象的地址，等同于通过子类对象调用父类中__str__
#当打印对象的时候，默认调用了__str__函数
#重写__str__的作用：为了调试程序

"""
总结：【面试题】
a.__str__和__repr__都未被重写的时候，使用对象调用的是__str__,此时__str__返回的是对象的地址
b.__str__和__repr__都被重写之后，使用对象调用的是__str__，此时__str__返回的是自定义的字符串
c.重写了__str__，但是没有重写__repr__，则使用对象调用的是__str__，此时__str__返回的是自定义的字符串
d.未重写__str__，但是重写了__repr__，则使用对象调用的是__repr__,此时，__repr__返回的是自定义的字符串
"""

#使用时机：当一个对象的属性有很多的时候，并且都需要打印，则可以重写__str__，可以简化代码，调试程序

4.2自定义函数重写

代码演示：

#函数重写的时机：在继承关系中，如果父类中函数的功能满足不了子类的需求，则在子类中需要重写
#父类
class People(object):
    def __init__(self,name):
        self.name = name

    def fun(self):
        print("fun")

#子类
class Student(People):
    def __init__(self,name,score):
        self.score = score
        super(Student,self).__init__(name)

    #重写;将函数的声明和实现重新写一遍
    def fun(self):
        #在子类函数中调用父类中的函数【1.想使用父类中的功能，2.需要添加新的功能】
        #根据具体的需求决定需不需要调用父类中的函数
        super(Student,self).fun()
        print("fajfhak")


s = Student("fhafh",10)
s.fun()