继承
例子:
"""继承"""
class Animal():
def eat(self):
print('--吃--')
def drink(self):
print('--喝--')
def sleep(self):
print('--睡--')
def run(self):
print('--跑')
class Dog(Animal):
"""添加了Dog类,继承了Aniaml类"""
def bark(self):
print('--汪汪--')
class Cat(Animal):
"""添加了Cat类,继承了Aniaml类"""
def catch(self):
print('--抓老鼠--')
a=Animal()
a.drink()
wangcai=Dog()
wangcai.sleep()
tom=Cat()
tom.eat()
D:\Anaconda\python.exe E:/pythonwork/黑马/面向对象.py
--喝--
--睡--
--吃--
Process finished with exit code 0
子类继承父类、父类的父类
"""继承"""
class Animal():
def eat(self):
print('--吃--')
def drink(self):
print('--喝--')
def sleep(self):
print('--睡--')
def run(self):
print('--跑')
class Dog(Animal):
def bark(self):
print('--汪汪--')
class xiaotian(Dog):
"""添加一个类,继承了Dog类,也继承了Animal类"""
def fly(self):
print('--飞---')
# class Cat(Animal):
# def catch(self):
# print('--抓老鼠--')
# a=Animal()
# a.drink()
wangcai=Dog()
wangcai.sleep()
# tom=Cat()
# tom.eat()
xiaotianquan=xiaotian()
xiaotianquan.fly()#调用自己的方法
xiaotianquan.bark()#调用父类Dog的方法
xiaotianquan.eat()#调用父类的父类Animal的方法
D:\Anaconda\python.exe E:/pythonwork/黑马/面向对象.py
--睡--
--飞---
--汪汪--
--吃--
Process finished with exit code 0
在子类中重写父类的方法
"""继承"""
class Animal():
def eat(self):
print('--吃--')
def drink(self):
print('--喝--')
def sleep(self):
print('--睡--')
def run(self):
print('--跑')
class Dog(Animal):
def bark(self):
print('--汪汪--')
class xiaotian(Dog):
"""添加一个类,继承了Dog类,也继承了Animal类"""
def fly(self):
print('--飞---')
def bark(self):#自身定义了一个父类的方法,在子类中对父类的方法进行重写
print('--狂叫--')
# class Cat(Animal):
# def catch(self):
# print('--抓老鼠--')
# a=Animal()
# a.drink()
wangcai=Dog()
wangcai.sleep()
# tom=Cat()
# tom.eat()
xiaotianquan=xiaotian()
xiaotianquan.fly()#调用自己的方法
xiaotianquan.bark()#如果自身有这个方法,就调用自身的方法。如果自身没有就调用父类Dog的方法
xiaotianquan.eat()#调用父类的父类Animal的方法
在子类中调用被重写的父类的方法(两种方法)
第一种方法: 类名.方法名(self) 【类名:可父类可子类,再找相对应的方法调用】
如果自身有这个方法,先调自身的,打印出来,再执行 类名.方法名(self) 调(父类)的方法打印出来。
注意:在子类中调用被重写的父类的方法时,需要传递代表自身的self,否则会报错的
"""继承"""
class Animal():
def eat(self):
print('--吃--')
def drink(self):
print('--喝--')
def sleep(self):
print('--睡--')
def run(self):
print('--跑')
class Dog(Animal):
def bark(self):
print('--汪汪--')
class xiaotian(Dog):
"""添加一个类,继承了Dog类,也继承了Animal类"""
def fly(self):
print('--飞---')
def bark(self):#自身定义了一个父类的方法,在子类中对父类的方法进行重写
print('--狂叫--')
"""第一种在子类中调用父类的方法"""
Dog.bark(self)
wangcai=Dog()
xiaotianquan=xiaotian()
xiaotianquan.fly()#调用自己的方法
xiaotianquan.bark()#如果自身有这个方法,就调用自身的方法,再执行Dog.bark(self)调用父类的Dog方法
D:\Anaconda\python.exe E:/pythonwork/黑马/面向对象.py
--飞---
--狂叫--
--汪汪--
--吃--
Process finished with exit code 0
第二种方法:super().bark()
"""继承"""
class Animal():
def eat(self):
print('--吃--')
def drink(self):
print('--喝--')
def sleep(self):
print('--睡--')
def run(self):
print('--跑')
class Dog(Animal):
def bark(self):
print('--汪汪--')
class xiaotian(Dog):
"""添加一个类,继承了Dog类,也继承了Animal类"""
def fly(self):
print('--飞---')
def bark(self):#自身定义了一个父类的方法,在子类中对父类的方法进行重写
print('--狂叫--')
# """第一种在子类中调用父类的方法"""
# Dog.bark(self)
"""第二种在子类中调用父类的方法"""
super().bark()
wangcai=Dog()
xiaotianquan=xiaotian()
xiaotianquan.fly()#调用自己的方法
xiaotianquan.bark()#如果自身有这个方法,就调用自身的方法,再执行Dog.bark(self)调用父类的Dog方法
D:\Anaconda\python.exe E:/pythonwork/黑马/面向对象.py
--飞---
--狂叫--
--汪汪--
Process finished with exit code 0
私有方法、私有属性在继承中的表现
1、私有的属性和方法并不会被继承,只要是私有的东西就不会被继承的,也就是不能在子类中使用父类中的私有方法和私有属性。
2、私有的属性和方法只能在定义它们的类中公开一个方法里面调用,不能在子类中使用父类中的私有方法和私有属性。
多继承
所谓多继承,即子类有多个父类,并且具有它们的特征。python是可以多继承的,父类中的方法、属性,子类会继承。object类是所有类的基类,下面的object写与不写是一样的。
"""多继承"""
class Base():
def test(self):
print('--base')
class A(Base):
def test(self):
print('--A')
class B(Base):
def test(self):
print('--B')
class C(B,A):
def test(self):
print('--C')
c=C()
#c.test() #如果方法名一样,优先调用自身的方法
c.test() #如果子类没有方法,而继承的多个父类中有相同的方法名时,继承时 谁在前,就调用谁的方法
print(C.__mro__) #C3算法,查看搜索顺序
结果:
D:\Anaconda\python.exe E:/pythonwork/黑马/面向对象.py
--C
(<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class '__main__.Base'>, <class 'object'>)
Process finished with exit code 0
多态
多态的概念是应用于Java和C#这一类强类型语言中,而Python崇尚“鸭子类型”。
所谓多态:定义时的类型和运行时的类型不一样,此时就成为多态。
- Python伪代码实现Java或C#的多态
class F1(object):
def show(self):
print 'F1.show'
class S1(F1):
def show(self):
print 'S1.show'
class S2(F1):
def show(self):
print 'S2.show'
# 由于在Java或C#中定义函数参数时,必须指定参数的类型
# 为了让Func函数既可以执行S1对象的show方法,又可以执行S2对象的show方法,所以,定义了一个S1和S2类的父类
# 而实际传入的参数是:S1对象和S2对象
def Func(F1 obj):
"""Func函数需要接收一个F1类型或者F1子类的类型"""
print obj.show()
s1_obj = S1()
Func(s1_obj) # 在Func函数中传入S1类的对象 s1_obj,执行 S1 的show方法,结果:S1.show
s2_obj = S2()
Func(s2_obj) # 在Func函数中传入Ss类的对象 ss_obj,执行 Ss 的show方法,结果:S2.show
- Python “鸭子类型”
class F1(object):
def show(self):
print 'F1.show'
class S1(F1):
def show(self):
print 'S1.show'
class S2(F1):
def show(self):
print 'S2.show'
def Func(obj):
print obj.show()
s1_obj = S1()
Func(s1_obj)
s2_obj = S2()
Func(s2_obj)
类属性、实例属性
在了解了类基本的东西之后,下面看一下python中这几个概念的区别
先来谈一下类属性
和实例属性
在前面的例子中我们接触到的就是实例属性(对象属性),顾名思义,类属性就是类对象
所拥有的属性,它被所有类对象
的实例对象
所共有,在内存中只存在一个副本,这个和C++中类的静态成员变量有点类似。对于公有的类属性,在类外可以通过类对象
和实例对象
访问
类属性
class People(object):
name = 'Tom' #公有的类属性
__age = 12 #私有的类属性
p = People()
print(p.name) #正确
print(People.name) #正确
print(p.__age) #错误,不能在类外通过实例对象访问私有的类属性
print(People.__age) #错误,不能在类外通过类对象访问私有的类属性
实例属性(对象属性)
class People(object):
address = '山东' #类属性
def __init__(self):
self.name = 'xiaowang' #实例属性
self.age = 20 #实例属性
p = People()
p.age =12 #实例属性
print(p.address) #正确
print(p.name) #正确
print(p.age) #正确
print(People.address) #正确
print(People.name) #错误
print(People.age) #错误
通过实例(对象)去修改类属性
class People(object):
country = 'china' #类属性
print(People.country)
p = People()
print(p.country)
p.country = 'japan'
print(p.country) #实例属性会屏蔽掉同名的类属性
print(People.country)
del p.country #删除实例属性
print(p.country)
总结
- 如果需要在类外修改
类属性
,必须通过类对象
去引用然后进行修改。如果通过实例对象去引用,会产生一个同名的实例属性
,这种方式修改的是实例属性
,不会影响到类属性
,并且之后如果通过实例对象去引用该名称的属性,实例属性会强制屏蔽掉类属性,即引用的是实例属性
,除非删除了该实例属性
。 -
class Tool(object): #类属性 num = 0 #方法 def __init__(self, new_name): #实例属性 self.name = new_name #对类属性+=1 Tool.num += 1 tool1 = Tool("铁锹") tool2 = Tool("工兵铲") tool3 = Tool("水桶") print(Tool.num)
D:\Anaconda\python.exe "D:/黑马/python就业班上(剩余部分加微信VR365666)/01基础/第2节 python语法基础/08.面对对象-2/源码/14-类属性-实例属性.py" 3 Process finished with exit code 0
静态方法和类方法
1. 类方法
是类对象所拥有的方法,需要用修饰器@classmethod
来标识其为类方法,对于类方法,第一个参数必须是类对象,一般以cls
作为第一个参数(当然可以用其他名称的变量作为其第一个参数,但是大部分人都习惯以'cls'作为第一个参数的名字,就最好用'cls'了),能够通过实例对象和类对象去访问。
class People(object):
country = 'china'
#类方法,用classmethod来进行修饰
@classmethod
def getCountry(cls):
return cls.country
p = People()
print p.getCountry() #可以用过实例对象引用
print People.getCountry() #可以通过类对象引用
类方法还有一个用途就是可以对类属性进行修改:
class People(object):
country = 'china'
#类方法,用classmethod来进行修饰
@classmethod
def getCountry(cls):
return cls.country
@classmethod
def setCountry(cls,country):
cls.country = country
p = People()
print p.getCountry() #可以用过实例对象引用
print People.getCountry() #可以通过类对象引用
p.setCountry('japan')
print p.getCountry()
print People.getCountry()
结果显示在用类方法对类属性修改之后,通过类对象和实例对象访问都发生了改变
2. 静态方法
需要通过修饰器@staticmethod
来进行修饰,静态方法不需要多定义参数
class People(object):
country = 'china'
@staticmethod
#静态方法
def getCountry():
return People.country
print(People.getCountry())
总结
从类方法和实例方法以及静态方法的定义形式就可以看出来,类方法的第一个参数是类对象cls,那么通过cls引用的必定是类对象的属性和方法;而实例方法的第一个参数是实例对象self,那么通过self引用的可能是类属性、也有可能是实例属性(这个需要具体分析),不过在存在相同名称的类属性和实例属性的情况下,实例属性优先级更高。静态方法中不需要额外定义参数,因此在静态方法中引用类属性的话,必须通过类对象来引用
class Game(object):
#类属性
num = 0
#实例方法
def __init__(self):
#实例属性
self.name = "laowang"
#类方法
@classmethod
def add_num(cls):
cls.num = 100
#静态方法
@staticmethod
def print_menu():
print("----------------------")
print(" 穿越火线V11.1")
print(" 1. 开始游戏")
print(" 2. 结束游戏")
print("----------------------")
game = Game()
#Game.add_num()#可以通过类的名字调用类方法
game.add_num()#还可以通过这个类创建出来的对象 去调用这个类方法
print(Game.num)
#Game.print_menu()#通过类 去调用静态方法
game.print_menu()#通过实例对象 去调用静态方法
D:\Anaconda\python.exe "D:/黑马/python就业班上(剩余部分加微信VR365666)/01基础/第2节 python语法基础/08.面对对象-2/源码/15-实例方法-类方法-静态方法.py"
100
----------------------
穿越火线V11.1
1. 开始游戏
2. 结束游戏
----------------------
Process finished with exit code 0