11-Python继承
2018-11-17 本文已影响21人
墨雨love薏雪
一、封装【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()
