Python面向对象进阶教程,Python面向对象进阶知识笔记

亦凉 2024-03-23 23:19 23阅读 0赞

### **类方法、静态方法** ###

#### **1. 类方法** ####

*  **第一个形参是类对象的方法**
 *  需要用装饰器`@classmethod`来标识其为类方法，对于类方法，**第一个参数必须是类对象**，一般以`cls`作为第一个参数。

class Dog(object):

\_\_type = "狗"

\# 类方法，用classmethod来进行修饰

@classmethod

def get\_type(cls):

return cls.\_\_type

print(Dog.get\_type())

使用场景：

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

#### **2. 静态方法** ####

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

class Dog(object):

type = "狗"

def \_\_init\_\_(self):

name = None

\# 静态方法

@staticmethod

def introduce(): \# 静态方法不会自动传递实例对象和类对象

print("犬科哺乳动物,属于食肉目..")

dog1 = Dog()

Dog.introduce() \# 可以用 实例对象 来调用 静态方法

dog1.introduce() \# 可以用 类对象 来调用 静态方法

用场景：

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

#### **注意点：** ####

*  类中定义了同名的方法时，调用方法会执行最后定义的方法

class Dog:

def demo\_method(self):

print("对象方法")

@classmethod

def demo\_method(cls):

print("类方法")

@staticmethod

def demo\_method(): \# 被最后定义

print("静态方法")

dog1 = Dog()

Dog.demo\_method() \# 结果: 静态方法

dog1.demo\_method() \# 结果: 静态方法

### **\_\_new\_\_和\_\_init\_\_方法** ###

class A(object):

def \_\_init\_\_(self):

print("这是 init 方法")

def \_\_new\_\_(cls):

print("这是 new 方法")

return object.\_\_new\_\_(cls)

A()

#### **总结** ####

*  `__new__`至少要有一个参数cls，代表要实例化的类，此参数在实例化时由Python解释器自动提供
 *  `__new__`必须要有返回值，返回实例化出来的实例，这点在自己实现`__new__`时要特别注意，可以return父类`__new__`出来的实例，或者直接是object的`__new__`出来的实例
 *  `__init__`有一个参数self，就是这个`__new__`返回的实例，`__init__`在`__new__`的基础上可以完成一些其它初始化的动作，`__init__`不需要返回值

\# 实例化一个单例

class Singleton(object):

\_\_instance = None

\_\_is\_first = True

def \_\_new\_\_(cls, age, name):

if not cls.\_\_instance:

cls.\_\_instance = object.\_\_new\_\_(cls)

return cls.\_\_instance

def \_\_init\_\_(self, age, name):

if self. \_\_is\_first: \# 不会再创建第二个对象

self.age = age

self.name = name

Singleton. \_\_is\_first = False

a = Singleton(18, "张三")

b = Singleton(28, "张三")

print(id(a))

print(id(b))

print(a.age) \# 18

print(b.age) \# 18

a.age = 19

print(b.age)

### **继承的基本使用** ###

在现实生活中，继承一般指的是子女继承父辈的财产，父辈有的财产，子女能够直接使用。

#### **程序里的继承** ####

继承是面向对象软件设计中的一个概念，与多态、封装共为面向对象的三个基本特征。继承可以使得子类具有父类的属性和方法或者重新定义、追加属性和方法等。

![84610f4d135648229f5e9a11dc17d13e.png][]

*  在程序中，继承描述的是多个类之间的所属关系。
 *  如果一个类A里面的属性和方法可以复用，则可以通过继承的方式，传递到类B里。
 *  那么类A就是基类，也叫做父类；类B就是派生类，也叫做子类。

class Animal:

def \_\_int\_\_(self):

pass

"""动物类"""

def sleep(self):

print('正在睡觉')

class Dog(Animal):

"""Dog类继承自Animal类"""

def \_\_init\_\_(self):

pass

class Cat(Animal): \# 定义类时，在括号后面传入父类的类名，表示子类继承父类

"""Cat类继承自Animal类"""

def \_\_int\_\_(self):

pass

\# Dog 和 Cat 都继承自Animal类，可以直接使用Animal类里的sleep方法

dog = Dog()

dog.sleep()

cat = Cat()

cat.sleep()

在Python中，继承可以分为单继承、多继承和多层继承。

### **单继承：子类只继承一个父类** ###

继承概念：子类用于父类的所有的方法和属性。

![e0186dad514b469e97747c0bc3d5c1bc.png][]

继承语法:

class 类名(父类名):

pass

*  子类继承自父类，可以享受父类中已经封装好的方法，不需要再次定义
 *  子类中应该根据职责，封装子类特有的属性和方法。

#### **继承的传递性** ####

Dog类继承自Animal,XiaoTianQuan又继承自Dog类，那么XiaoTianQuan类就具有了Animal类里的所有属性和方法。

子类拥有父类以及父类的父类中封装的所有属性和方法。

思考:

XiaoTianQuan能否调用Animal的run()方法？ XiaoTianQUan能够调用Cat里的方法？

### **多继承** ###

子类可以拥有多个父类，并且具有所有父类的属性和方法。

![b8dddd41d58e43c298bfa6d52c41480c.png][]

语法格式：

class 子类名(父类名1,父类名2...)

pass

#### **多继承的使用注意事项** ####

思考:

如果不同的父类中存在同名的方法，子类对象在调用方法时，会调用哪个父类的方法？ 说明：开发中，应该尽量避免这种容易产生混淆的情况。如果多个父类之间存在同名的属性后者方法，应该尽量避免使用多继承。

![f5fc8644e741491fa2951d6a62a06aef.png][]

### **Python中的MRO** ###

*  Python中针对类提供了一个内置属性`__mro__`可以用来查看方法的搜索顺序。
 *  MRO 是`method resolution order`的简称，主要用于在多继承时判断方法属性的调用顺序。

print(C.__mro__)

输出结果:

(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)

*  在调用方法时，按照`__mro__`的输出结果从左至右的顺序查找。
 *  如果再当前类中找到方法，就直接执行，不再向下搜索。
 *  如果没有找到，就顺序查找下一个类中是否有对应的方法，如果找到，就直接执行，不再继续向下搜索。
 *  如果找到了最后一个类，依然没有找到方法，程序就会报错。

### **新式类和旧式（经典）类** ###

`object`是Python中所有对象的基类，提供了一些内置的属性和方法，可以时候用`dir`函数查看。

*  新式类：以`object`为基类的类，**推荐使用**
 *  经典类：不以object为基类的类，**不推荐使用**
 *  在 Python3.x 以后定义类时，如果没有指定父类，这个类会默认继承自 object,所以，python3.x版本定义的类都是新式类。
 *  在Python2.x中定义类时，如果没有指定父类，则不会继承自object.

为了保证代码在Python2.x和Python3.x中都能够运行，在定义类时，如果一个类没有父类，建议统一继承自'object'

class 类名(object):

pass

### **对象相关的内置函数** ###

Python中的身份运算符用来判断两个对象是否相等；isinstance用来判断对象和类之间的关系；issublcass用啊里判断类与类之间的关系。

#### **身份运算符** ####

身份运算符用来比较两个对象的内存地址，看这两个对象是否是同一个对象。

class Person(object):

def __init__(self, name, age):

self.name = name

self.age = age

p1 = Person('张三', 18)

p2 = Person('张三', 18)

p3 = p1

print(p1 is p2)  # False

print(p1 is p3)  # True

#### **isinstance** ####

instance内置函数，用来判断一个实例对象是否是由某一个类(或者它的子类)实例化创建出来的。

class Person(object):

def __init__(self, name, age):

self.name = name

self.age = age

class Student(Person):

def __init__(self, name, age, score):

super(Student, self).__init__(name, age)

self.score = score

class Dog(object):

def __init__(self, name, color):

self.name = name

self.color = color

p = Person('tony', 18)

s = Student('jack', 20, 90)

d = Dog('旺财', '白色')

print(isinstance(p, Person))  # True.对象p是由Person类创建出来的

print(isinstance(s, Person))  # True.对象s是有Person类的子类创建出来的

print(isinstance(d, Person))  # False.对象d和Person类没有关系

#### **issubclass** ####

issubclass 用来判断两个类之间的继承关系。

class Person(object):

def __init__(self, name, age):

self.name = name

self.age = age

class Student(Person):

def __init__(self, name, age, score):

super(Student, self).__init__(name, age)

self.score = score

class Dog(object):

def __init__(self, name, color):

self.name = name

self.color = color

print(issubclass(Student, Person))  # True

print(issubclass(Dog, Person))  # False

### **多态** ###

面向对象的三大特性：

*  封装：这是定义类的准则，根据对象的特点，将行为和属性抽象出来，封装到一个类中。
 *  继承：这是设计类的技巧。父类与子类，主要体现在代码的重用，不需要大量的编写重复代码。
 *  多态：不同的子类调用相同的父类方法，产生不同的执行结果，可以增加代码的外部灵活度。多态是以继承和重写父类方法为前提的，它是一种调用方法的技巧，不会影响到类的内部设计。

#### **场景** ####

*  提供三个类：缉毒犬、军犬、人
 *  缉毒犬-->追查毒品，军犬-->攻击假人，人-->让小狗干活
 *  设计类来完成功能。

![371a726bb5414d2a9d3ca5528699988c.png][]

代码实现:

class ArmyDog(object):

def bite_enemy(self):

print('追击敌人')

class DrugDog(object):

def track_drug(self):

print('追查毒品')

class Person(object):

def work_with_army(self, dog):

dog.bite_enemy()

def work_with_drug(self, dog):

dog.track_drug()

ad = ArmyDog()

dd = DrugDog()

p = Person()

p.work_with_army(ad)

p.work_with_drug(dd)

思考：这段代码设是否有问题？

新增需求：此时，又多了一个犬种，就又需要在Person类里新建一个方法，让这个方法操作新的狗。

class XiaoTianDog(object):

def eat_moon(self):

print('哮天犬把月亮吃了')

class Person(object):

def work_with_xiaotian(self, dog):  # 添加方法

dog.eat_moon()

Person 类总是不断的添加新的功能，每次都需要改动Person类的源码，程序的扩展性太差了！

*  最好是提供一个父类 Dog，具备 work 的功能，其他小狗继承它，这样只要是小狗类，则行为被统一起来了，我们人类完全可以保证，只要是小狗的子类，找它干活肯定不会有问题。
 *  这样人只要一个方法就能逗任意种类的狗玩，哪怕是添加新的狗，人的类都不需要修改。
 *  图示如下：

代码实现:

class Dog(object):

def work(self):  # 父类提供统一的方法，哪怕是空方法

pass

class ArmyDog(Dog):   # 继承 Dog

def work(self):  # 子类重写方法，并且处理自己的行为

print('追击敌人')

class DrugDog(Dog):

def work(self):

print('追查毒品')

class Person(object):

def work_with_dog(self, dog):

dog.work()    # 使用小狗可以根据对象的不同而产生不同的运行效果, 保障了代码的稳定性

# 子类对象可以当作父类来使用

dog = Dog()

ad = ArmyDog()

dd = DrugDog()

p = Person()

p.work_with_dog(dog)

p.work_with_dog(ad)  # 同一个方法，只要是 Dog 的子类就可以传递，提供了代码的灵活性

p.work_with_dog(dd)  # 并且传递不同对象，最终 work_with_dog 产生了不同的执行效果

*  最终效果
    
     *  Person 类中只需要调用 Dog 对象 work() 方法，而不关心具体是 什么狗
     *  work() 方法是在 Dog 父类中定义的，子类重写并处理不同方式的实现
     *  在程序执行时，传入不同的 Dog 对象作为实参，就会产生不同的执行效果

#### **多态总结** ####

*  定义：多态是一种使用对象的方式，子类重写父类方法，调用不同子类对象的相同父类方法，可以产生不同的执行结果
 *  好处：调用灵活，有了多态，更容易编写出通用的代码，做出通用的编程，以适应需求的不断变化！
 *  实现步骤：
    
     *  定义父类，并提供公共方法
     *  定义子类，并重写父类方法
     *  传递子类对象给调用者，可以看到不同子类执行效果不同

[84610f4d135648229f5e9a11dc17d13e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/05ed4c5630e74211a8de495923ccc02d.png
[e0186dad514b469e97747c0bc3d5c1bc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/ba2e4b872fb34d2d87cfa6cb0f6abf94.png
[b8dddd41d58e43c298bfa6d52c41480c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/5a9a9826a4134358afd9efcb9351ebcd.png
[f5fc8644e741491fa2951d6a62a06aef.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/1f1d30ceba4b4b7e8ee04703e5950ade.png
[371a726bb5414d2a9d3ca5528699988c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/a8e4bf4a28d44562b6ab697dedc9f453.png