Python基础复习09_面向对象特性

面向对象特性

1. 继承

Outline
·继承概念
·单继承/多继承
·子类重写/调用父类的同名属性和方法
·多层继承
·super()
·私有属性和私有方法

1.1 继承的概念

继承指的是多个类之间的所属关系，即子类默认继承父类的所有属性和方法
·拓展：经典类（旧式类）与新式类

·不由任意内置类型派生出的类称为经典类
·也即：继承了object类的是新式类，没有继承object类的是经典类
·注意：在python3中所有自定义类的基类都会默认继承object类，也即py3中所有类都是新式类

# 经典类
class ClassName:............# 新式类
class ClassName(object):............

·在python3中，所有类默认继承object类，object类是顶级类或基类；其他自类叫做派生类

1.2 单继承/多继承

·注意：需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索即方法在子类中未找到时，从左到右查找父类中是否包含方法。

# 单继承 && 多继承
class Python:code_language = ''def __init__(self):self.code_language = 'Python'def code(self):print(f"I'm coding in {self.code_language}")class Java:code_language = ""def __init__(self):self.code_language = 'Java'def code(self):print(f"I'm coding in {self.code_language}")# 单继承
class subLang(Python):pass# 多继承
class sub2Lang(Java,Python):passlang1 = subLang()
lang1.code()
lang2 = sub2Lang()
lang2.code()

I'm coding in Python
I'm coding in Java

1.3 子类重写/调用父类同名方法和属性

·子类和父类具有同名属性和方法时，默认使用子类的

# 重写父类方法
class sub3Lang(Java,Python):def __init__(self):self.code_language = 'Scala'def code(self):print("code by %s" % self.code_language)lang3 = sub3Lang()
lang3.code()
print("--"*5)# 调用父类方法
class sub4Lang(Java,Python):def __init__(self):self.code_language = 'scala'def code(self):#如果先调用了父类属性和方法，父类属性会覆盖子类属性，所以在调用属性前，先调用子类的初始化self.__init__()print("code by %s" % self.code_language)# 调用父类方法，为了保证调用到的是父类属性，在调用方法前先调用父类的初始化def codeByPython(self):Python.__init__(self)Python.code(self)def codeByJava(self):Java.__init__(self)Java.code(self)lang4 = sub4Lang()
lang4.code()
lang4.codeByPython()
lang4.codeByJava()
lang4.code()

code by Scala
----------
code by scala
I'm coding in Python
I'm coding in Java
code by scala

1.4 多层继承

# 多层继承
class sub5Lang(sub4Lang):passlang5 = sub5Lang()
lang5.code()
lang5.codeByPython()
lang5.codeByJava()

code by scala
I'm coding in Python
I'm coding in Java

1.5 super()

1.5.1 mro

·查看一个类的父类及层级关系（继承层级顺序）

# __mro__
print(sub5Lang.__mro__)
print(sub4Lang.__mro__)
print(subLang.__mro__)

(<class '__main__.sub5Lang'>, <class '__main__.sub4Lang'>, <class '__main__.Java'>, <class '__main__.Python'>, <class 'object'>)
(<class '__main__.sub4Lang'>, <class '__main__.Java'>, <class '__main__.Python'>, <class 'object'>)
(<class '__main__.subLang'>, <class '__main__.Python'>, <class 'object'>)

1.5.2 super()方法

作用：调用父类方法
语法：

# 带参形式
super(当前类名,self).funName()# python3中可以使用简化写法
super().funName()

·注意：super可以自动查找父类，调用顺序遵循__mro__的顺序，适合单继承使用。

1.6 私有权限

1.6.1 定义私有属性和方法

·在python中，可以为实例属性和方法设置私有权限，即设置某个实例属性或方法不继承给子类
·方法：在属性名/方法名前面加两个下划线
·注意：私有属性和私有方法只能在类中访问和修改

# 定义私有属性和方法
class Father():def __init__(self):self.house = 'BJ2huan'self.__money = "9999999$"def __giveMoney(self):print(f"give u {self.__money}")man = Father()
man.__giveMoney()

---------------------------------------------------------------------------AttributeError                            Traceback (most recent call last)<ipython-input-15-7260ef001b55> in <module>8 9 man = Father()
---> 10 man.__giveMoney()AttributeError: 'Father' object has no attribute '__giveMoney'

print(man.__money)

---------------------------------------------------------------------------AttributeError                            Traceback (most recent call last)<ipython-input-16-0f10097db91d> in <module>
----> 1 print(man.__money)AttributeError: 'Father' object has no attribute '__money'

1.6.2 获取和修改私有属性值

一般定义get_xx来获取私有属性，定义set_xx来修改私有属性

class dad():def __init__(self):self.__money = '$9999999999'def get_money(self):return self.__moneydef set_money(self,money):self.__money = moneyman = dad()
print(man.get_money())
man.set_money('￥999999')
print(man.get_money())

$9999999999
￥999999

2. 多态

·定义：多态是一种使用对象的方式；子类重写父类方法，调用不同子类对象的相同父类方法，可以产生不同的执行效果
·好处：调用灵活，让代码可重用性提高
·实现步骤：

1.定义父类，提供公共方法
2.定义子类，重写父类方法
3.将子类对象传给调用者，可以看到不同子类执行效果不同

class Dog:def work(self):passclass PoliceDog(Dog):def work(self):print("Follow and find the animy")class DrugDog(Dog):def work(self):print("Find the drugs")class Policeman:def workWithDog(self,dog):dog.work()police_dog = PoliceDog()
drug_dog = DrugDog()police = Policeman()
police.workWithDog(police_dog)
police.workWithDog(drug_dog)

Follow and find the animy
Find the drugs

3. 类属性和实例属性

3.1 类属性

3.1.1 设置&访问类属性

·类属性就是类对象所拥有的属性，它被该类的所有实例对象共有
·类属性可以使用类对象或实例对象访问

class Cat:brother = 'tiger'daJu = Cat()
xiaoHua = Cat()print(f"cat's bro : {Cat.brother} \n\
daju's bro:{daJu.brother} \n\xiaohua's bro: {xiaoHua.brother}")

cat's bro : tiger
daju's bro:tiger
xiaohua's bro: tiger

·类属性的优点

记录的某项数据始终保持一致时，则定义类属性。
实例属性 要求 每个对象 为其 单独开辟一份内存空间 来记录数据，而 类属性 为全类所共有，仅占用一份内存，更加节省内存空间。

3.1.2 修改类属性

·类属性只能通过类对象来修改，而不能通过实例对象来修改，如果通过实例对象来修改类属性，实际上表示创建了一个实例属性。

# 修改类属性
Cat.brother = 'xiba'
print(f"cat's bro : {Cat.brother} \n\
daju's bro:{daJu.brother} \n\
xiaohua's bro: {xiaoHua.brother}")
print("---"*10)
# 不能通过实例对象修改类属性
daJu.brother = 'cat'
print(f"cat's bro : {Cat.brother} \n\
daju's bro:{daJu.brother} \n\
xiaohua's bro: {xiaoHua.brother}")

cat's bro : xiba
daju's bro:cat
xiaohua's bro: xiba
------------------------------
cat's bro : xiba
daju's bro:cat
xiaohua's bro: xiba

3.2 实例属性

class Cat:def __init__(self):self.age = 5def print_info(self):print(self.age)shabi = Cat()
print(shabi.age)
shabi.print_info()
print(Cat.age) # 报错：实例属性不可以通过类对象访问

5
5---------------------------------------------------------------------------AttributeError                            Traceback (most recent call last)<ipython-input-29-f947428b7ef1> in <module>8 print(shabi.age)9 shabi.print_info()
---> 10 print(Cat.age) # 报错：实例属性不可以通过类对象访问AttributeError: type object 'Cat' has no attribute 'age'

4. 类方法和静态方法

4.1 类方法

4.1.1 类方法的特点

·需要使用装饰器@classmethod来标识其为类方法，对于类方法，第一个参数必须是类对象，一般以cls为第一个参数

4.1.2 类方法的使用场景

·当方法中需要使用类对象（如访问私有类属性等）时，定义类方法
·类方法一般需要和类属性配合使用

class Doggie:__master = 'jcl'@classmethoddef get_mastername(cls):return cls.__masterwangcai = Doggie()
print(wangcai.get_mastername())

jcl

4.2 静态方法

4.2.1 静态方法特点

需要使用装饰器@staticmethod来修饰，静态方法既不需要传递类对象也不需要传递实例对象（形参没有self/cls)
静态方法也能通过实例对象和类对象去访问。

4.2.2 静态方法使用场景

当方法中既不需要使用实例对象（如实例对象或属性），也不需要使用类对象（类对象/属性/创建实例等）时，定义静态方法
取消不需要的参数传递，有利于减少不必要地内存占用和性能消耗

class Doggg:@staticmethoddef print_info():print("This is a dog class,try to create a dog object")wangcai = Doggg()wangcai.print_info()
Doggg.print_info()

This is a dog class,try to create a dog object
This is a dog class,try to create a dog object

Summary

面向对象三大特性：

封装
- 将属性和方法书写到类的里面的操作即为封装
- 封装可以为属性和方法添加私有权限
继承
- 子类默认继承父类的所有属性和方法
- 子类可以重写父类属性和方法
多态
- 传入不同的对象，产生不同的结果