Python面向对象三大特征(python系列20)

2023-12-14 13:47:01

1.封装

? ? ? ? 定义:

? ? ? ? 数据角度:将基本数据类型复合成一个自定义类型

? ? ? ? ? ? ? ? 作用:可读性更高,将数据与对数据的操作相关联。

? ? ? ? 行为角度:对类外提供必要的功能,隐藏实现的细节

? ? ? ? ? ? ? ? 作用:让调用者不必了解实现代码,也能调用我们写的功能

? ? ? ? ? ? ? ? 让调用者操作变得简单

? ? ? ? 私有化成员:

? ? ? ? ? ? ? ? 定义:变量名双下划线开头

? ? ? ? ? ? ? ? 如 self.__name = name

? ? ? ? ? ? ? ? 本质:障眼法,可以通过对象._类名__成员名调用。

2.继承

? ? ? ? 定义:重用现有类的功能,并在此功能上进行扩展。

? ? ? ? 多个类型有相同的行为,且概念统一,这个时候我们就可以将多个类型统一的行为抽出来做一个类,而这个类就为多个类的父类,当创建子类时继承父类,就可以继承父类中已经有的行为。

通俗一些的讲,就是子类继承父类,就相当于子类复制粘贴了父类代码。

? ? ? ? 继承语法:

class Person:
    pass
class Student(Person):
    Pass

# 代码1-1

? ? ? ?代码1-1中class Person其实就相当于,class Person(object),python代码中,创建一个类时,当不选择父类时,默认继承object,因此:任何类都直接或间接继承object类。

鸭子原则

其实:默认继承object体现了鸭子原则的精神,关心的是对象的行为,而不是对象的类型,只要对象的行为符合我们的期待,我们就可以将其视为所需要的类型。为什么代码1-1Person后面可以不写object来明确认父,这是一种思想,想告诉写python的程序员,我管你什么类型和继承关系,你给我实现功能就好了。

代码案例:

class Duck:  
    def quack(self):  
        print("Quack!")  
  
class Cat:  
    def meow(self):  
        print("Meow!")  
  
def sound(animal):  
    animal.quack()  # 调用Duck类中的quack方法  
  
duck = Duck()  
cat = Cat()  
  
sound(duck)  # 输出 "Quack!"  
sound(cat)   # 抛出 AttributeError,因为Cat类没有定义quack方法

? ?上述代码:

? ? ? ? 因为Cat类没有定义quack方法,因此才抛出异常,若Cat类中有queck方法则正常输出,

? ? ? ? 这里就能感受到,python只关心对象的行为,而不关心对象的类型,运行时才确定对象类型。而python中这种思想体现在动态类型语言检测和灵活的面向对象编程上。

总结:鸭子原则时一种思想,我们只关系对象的行为,而不关心对象的类型,而在python中这种思想体现在动态类型语言检测和灵活的面向对象编程上。在动态类型语言检测上,我们是在运行程序时才确定对象类型,因此当我们将一个对象当作参数传入一个函数中时,该对象可以时任何类型,只要能实现函数中的对象就不会抛出异常,反之不能满足函数中对象的行为则会抛出类型中没有此方法的异常。

在面向对象的继承上:

即使你不继承父类,但是你有和父类一样的行为,那么你就有了这个父类的特性,

从而可以在python中就可以达到你就是继承这个父类的效果。

类型判断:isinstance, type

class Animal:
    @staticmethod
    def eat():
        print("我吃吃吃")


class Dog(Animal):
    @staticmethod
    def run():
        print("我跑跑跑")


class Bird(Animal):
    @staticmethod
    def fly():
        print("我飞飞飞")


if __name__ == '__main__':
    bird = Bird()
    bird.fly()
    bird.eat()
    dog = Dog()
    dog.eat()
    dog.eat()
    animal = Animal()
    print(isinstance(dog, Dog))  # True
    print(isinstance(dog, Animal))  # True
    print(isinstance(animal, Dog))  # False
    print(type(dog) == Dog)  # True
    print(type(dog) == Animal)  # False
    print(type(animal) == Dog)  # False

# 代码1-2 

?通过上述代码:我们可以得出结论,type和isinstance的区别,用法上的不同,type是判断一个对象是不是一个类型,是就返回True,不是返回False。而isinstance是判断一个对象是不是属于一种类型,像代码1-2中,dog对象虽然是Dog类型,但是Dog继承了Animal类型,所以dog对象也属于动物类型,用isinstance判断返回的是True。反之,animal对象不属于Dog类型,怎么理解,只有说儿子属于爸爸,没有说爸爸属于儿子,animal对象是Animal类型是Dog类型的父类。

构造函数的继承

? ? ? ? 若子类没有构造函数,将直接使用父类构造函数。

? ? ? ? 若子类有构造函数,将覆盖父类的构造函数。

? ? ? ? 若子类有构造函数,并且想使用父类的构造函数的成员,可以用super().__init__(参数,参数)

? ? ? ? python可以多继承,但是我们一般都使用单继承,多实现的思想来设计模型。

? ? ? ? 继承父类变量的语法与代码

# 继承父类变量
class Car:
    def __init__(self, brand="", speed=""):
        self.brand = brand
        self.speed = speed


class Electric(Car):
    def __init__(self, brand="", speed="", capacity="", frequency=""):
        super().__init__(brand, speed)
        self.capacity = capacity
        self.frequency = frequency


electric = Electric("1", "1", "1", "1")
print(electric.capacity, electric.frequency, electric.brand, electric.speed)

# 代码1-3

? ? ? ? 父类中是共性,子类中是个性。?

3.多态

? ? ? ? 概念:对于父类的一个方法,在不同子类上有不同的体现。

? ? ? ? 重写:目的是张显个性

? ? ? ? 双下划线开头和双下划线结尾,这些是python的内置函数。

? ? ? ? 重写内置函数:

? ? ? ? 重写之前:

class Animal:
    def __init__(self, name="", color=""):
        self.name = name
        self.color = color


animal = Animal("dog", "white")
print(animal)  # <__main__.Animal object at 0x000001E829958948>

# 代码1-4

? ? ? ? ?重写之后:

class Animal:
    def __init__(self, name="", color=""):
        self.name = name
        self.color = color

    def __str__(self):
        return "name: %s, color: %s" % (self.name, self.color)


animal = Animal("dog", "white")
print(animal)  # name: dog, color: white

? ? ? ? 面向接口编程:

????????先确定用法,后决定做法,这是一种软件架构设计思想,

? ? ? ? 在1991年python祖师爷就确定了print()的用法,就是打印一个对象__str__方法的返回值。

? ? ? ? 这里的重写只是语法上,随便百度就能知道,并不值钱,而这里面牵涉到的软件架构思想才是重中之重,非常重要

? ? ? ? 下列是经常会重写的内置函数:

????????算数运算符:

? ? ? ? 代码案例:

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

    def __str__(self):
        return "name: " + self.name + ", age: " + str(self.age)

    def __add__(self, other):
        if type(other) == int:
            return Animal(self.name, self.age + other)
        else:
            return Animal(self.name, self.age + other.age)


animal = Animal("dog", 2)
print(animal + 1)  # name: dog, age: 3
print(animal + animal)  # name: dog, age: 4

?在python中 animal + 1 相当于? animal.__add__(1)

我们再来看看重写__iadd__

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

    def __str__(self):
        return "name: " + self.name + ", age: " + str(self.age)

    def __iadd__(self, other):
        if type(other) == int:
            self.age += other
            return self
        else:
            self.age += other.age
            return self


animal = Animal("dog", 2)
print(id(animal))  # 140380752334848
animal += 1
print(id(animal))  # 140380752334848
print(animal)  # name: dog, age: 3

而__iadd__则是 +=, 同理加减乘除的累计运算符都是比算数运算符多个i

值得一提的是,当一个对象没有__iadd__时使用 += 对象会调用__add__,但是返回的也是一个新对象。而当一个对象没有__add__时,使用+对象时会抛出异常。

比较运算符对应的内置函数:

这里写两个比较常用的重写的代码案例:

"""
图书列表设计
类:BookModel
数据:书名 - name , 价格 - number
行为1,重写__eq__使其在列表容器中能够实现,remove, in , index等功能。
行为2, 重写__lt__ 或 __gt__ 使其在列表容器中能实现,sort 功能
"""


class BookModel:
    def __init__(self, name, price):
        self.name = name
        self.price = price

    def __str__(self):
        return self.name + " - " + str(self.price)

    def __eq__(self, other):
        return self.name == other.name

    def __lt__(self, other):
        return self.price < other.price


list_book = [
    BookModel("Java", 200),
    BookModel("Python", 100)
]

list_book.sort()
for item in list_book:  # Python - 100 Java - 200
    print(item)
    
list_book.remove(BookModel("Java", 200))
for item in list_book:  # Python - 100
    print(item)

__lt__:

当自定义类型重写了__lt__方法,自定义类型就可以比较大小,并且放入列表中还能使用列表的方法,如sort(),因为sort的实现代码是迭代列表,取列表中元素,让元素与元素之间比较,当列表中的对象类型没有重写__lt__方法时,会抛出异常。

__eq__:?

当自定义类型写__eq__方法,就可以根据自己的业务逻辑来判断自定义对象是否相等,值得一提的是object默认使用对象的内存进行比较,实现这个方法,如果将自定义对象存入列表,将可以使用列表的romove方法,index方法等。

文章来源:https://blog.csdn.net/a12345dfsdf/article/details/134957218
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。