Python之面向对象

最新推荐文章于 2024-05-15 22:31:40 发布

「PlanA」

最新推荐文章于 2024-05-15 22:31:40 发布

阅读量876

点赞数 24

分类专栏： Python 文章标签： python 开发语言

本文链接：https://blog.csdn.net/2301_77599154/article/details/135947093

版权

Python 专栏收录该内容

11 篇文章 4 订阅

订阅专栏

Python从设计之初就已经是一门面向对象的语言，正因为如此，在Python中创建一个类和对象是很容易的。

面向对象技术简介

类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
数据成员：类变量或者实例变量, 用于处理类及其实例对象的相关的数据。
方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
局部变量：定义在方法中的变量，只作用于当前实例的类。
实例变量：在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。
继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
实例化：创建一个类的实例，类的具体对象。
方法：类中定义的函数。
对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

一初始对象

什么是对象？

对象是指在计算机中，具有独特标识的实体，它可以表示一个具体的事物、概念或者抽象概念。对象拥有属性和方法，属性是对象的特征或者状态的描述，而方法则是对象能够执行的操作或者行为。对象可以与其他对象互动，通过调用对象的方法来实现。在面向对象编程中，对象是面向对象程序设计的基本单位。每个对象都是一个独立的实例，它们之间可以有继承、封装、多态等关系。通过实例化对象，我们可以创建新的对象，并对对象进行操作和管理。

使用对象来组织数据

在程序中设计表格，我们称之为：设计类：
class Student:
    name = None    
在程序中打印生产表格，我们称之为：创建对象：
student1 = Student()
student2 = Student()
在程序中填写表格，我们称之为：对象的属性赋值：
student1.name = "PLO"
student2.name = "LKJ"

用法示例

class Student:
    name = None  # 姓名
    gender = None  # 年龄
    nation = None  # 民族

# 创建对象
student1 = Student()
# 为对象的属性赋值
student1.name = "PLO"
student1.gender = "男"
student1.nation = "汉"

print(student1.name)
print(student1.gender)
print(student1.nation)

二类的成员方法

类的定义和使用

使用方法：

class 类名称： ▣class是关键词，表示要定义类

类的属性 ▣类的属性，即定义在类中的变量（成员变量）

类的行为 ▣类的行为，即定义在类中的函数（成员方法）

创建类对象的语法：

对象 = 类名称（）

可以看出，类中：

        不仅可以定义属性用来记录数据

        也可以定义函数用来记录行为

其中：
        类中定义的属性（变量），我们称之为：成员变量

        类中定义的行为（函数），我们称之为：成员方法

成员方法的定义语法

在类中定义定义成员方法和定义函数基本一致，但有细微区别：

def 方法名（self，形参1,......,形参n):

方法体

可以看到，在方法定义参数的列表中，有一个：self关键字

self关键字是成员方法定义的时候必须填写的：

        它用来表示类对象自身的意思

        当我们使用类对象调用方法的时候，self会自动被python传入

        在方法内部，想要访问类的成员变量，必须使用self

三类和对象

现实世界的事物和类

现实世界的事物可以分为：属性和行为两个类。

现实世界的事物也有属性和行为，类也有属性和行为，那么我们使用程序中的类就可以完美的描述现实世界的事物。类只是程序内的“设计图纸”，需要基于图纸生产实体（对象），才能正常工作，这种套路称之为：面向对象编程。

class Clock:
    id = None
    price = None


    def ring(self):
        import winsound
        winsound.Beep(2000,3000)

clock1 = Clock()
clock1.id = "02156"
clock1.price = "19.99"
print(f"闹钟id:{clock1.id},价格:{clock1.price}")
clock1.ring()

四构造方法

构造方法

Python类可以使用__init__（）方法，称之为构造方法。

可以实现：

在创建类对象的时候，会自动执行

在创建类对象的时候，将传入参数自动传递给__init__方法使用。

构造方法注意事项

构造方法名称:_init__init__init_，千万不要忘记init前后都有2个下划线
构造方法也是成员方法，不要忘记在参数列表中提供:self
在构造方法内定义成员变量，需要使用self关键字

五魔术方法

常见的几个魔术方法

str字符串方法

我们使用一下str方法发现它输出的是内存地址，内存地址没有多大作用，我们可以通过__str__方法，控制类转换为字符串的行为。

        方法名：__str__

        返回值：字符串

        内容：自行定义

我们来看一下替换后的效果：

lt小于比较方法

如图我们创建了两个对象进行比较，发现是不可以进行的，这是因为我们没有定义相关的方法，它不知道按照什么进行比较。

        方法名：__lt__

        传入参数：other,另一个对象

        返回值：True或False

        内容：自行定义

le小于等于比较方法

__le__小于等于比较方法和__lt__小于比较方法类似。

        方法名：__le__

        传入参数：other,另一个对象

        返回值：True或False

        内容：自行定义

eq比较运算符

首先我们使用一下==号来看一下效果：

可以发现运行的结果是False,这是因为”==“比较的是内存中的地址，我们创建的两个对象的内存地址肯定不一样，因此结果一定是False，要想比较内容就要用到__eq__方法。

        方法名：__eq__

        传入参数：other,另一个对象

        返回值：True或False

        内容：自行定义

六封装

面向对象的三大特性

面向对象编程，是许多编程语言都支持的一种编程思想。
简单理解是:基于模板（类）去创建实体（对象），使用对象完成功能开发。

▶封装

▶继承

▶多态

封装

封装表示的是，将现实世界的事物的属性，行为。封装到类中，描述为：成员变量，成员方法。从而完成程序对现实世界事物的描述。

对用户隐藏的属性和行为

现实世界中的事物，都有属性和行为，但并不代表这些属性和行为都可以给用户使用，任何事物都有限制，我们不可能了解清楚它的一切。列如手机的一些行为：

私有成员

和现实世界一样我么的程序设计中也提供有私有的变量，控制他人访问。类中提供了私有成员的形式来支持：

私有成员变量

私有成员方法

定义私有成员的方法非常简单，只需要：

私有成员变量：变量名以__开头（2个下划线）

私有成员方法：方法名以__开头（2个下划线）

即可完成私有成员变量的设置

使用私有成员

1.私有方法无法直接被类使用

2.私有变量无法赋值，也无法获取值

私有成员可以被类中其他的对象使用

私有的成员变量只有类的内部可以使用，出了这个类，到外面或者类对象都无法使用私有成员。

综合案例

class Phone:
    _is_5g_enable = False

    def __check_5g(self):
        if self._is_5g_enable:
            print("5G开启")
        else:
            print("5G关闭，使用4g网络")

    def call_by_5g(self):
        self.__check_5g()
        print("正在通话中")

phone = Phone()
phone.call_by_5g()

七继承

继承是面向对象编程中的一个重要概念，它允许一个类继承另一个类的属性和方法。继承可以创建一个类的层次结构，使得子类可以继承父类的属性和方法，并且还可以添加自己的特定属性和方法。

单继承

语法：class 类名（父类名）：

类内容体

多继承

语法：class 类名（父类1，父类2，父类3......父类n）：

类内容体

class MyPhone(Phone,NFCReader,RemoteControl):
    pass    # 用来补全语法
如果是多继承谁先来，谁的优先级最高，优先级从左向右递减。

复写父类方法

子类继承父类的成员属性和成员方法后，如果对其“不满意”，那么可以进行复写。;在子类中重新定义同名的属性或方法即可。

调用父类同名成员

一旦复写父类成员，那么类对象调用成员的时候，就会调用复写后的新成员，如果需要使用被复写的父类成员，需要特殊的调用方式：

方式一：

▶调用父类成员

使用成员变量名：父类名.成员变量

使用成员方法：父类名.成员方法(self)

方式二：

▶使用super()调用父类成员

使用成员变量：super().成员变量

使用成员方法：super().成员方法()

注意：只可以在子类内部调用父类的同名方法，子类的实体类对象调用的默认是子类的复写方法。

八多态

多态，指的是：多种状态，即完成某个行为时，使用不同的对象得到的不同的状态。

同样的行为（函数），传入不同的对象，得到不同的状态。

实现案例

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        print("汪汪汪")

class Cat(Animal):
    def speak(self):
        print("喵喵喵")

def make_noise(animal:Animal):
    animal.speak()


dog = Dog()
make_noise(dog)
cat = Cat()
make_noise(cat)

抽象类

抽象类：含有抽象方法的类称之为抽象类。

抽象方法：方法体是空的（pass)称之为抽象方法。

抽象类就是定义了一个标准，包含了一些抽象的方法，要求子类必须实现

案例演示

class AC:
    def cool_wind(self):  # 制冷
        pass
    def hot_wind(self):  # 制热
        pass
    def swing_wind(self):  # 扫风
        pass

class Midea_AC(AC):
    def cool_wind(self):
        print("美的制冷")
    def hot_wind(self):
        print("美的制热")
    def swing_wind(self):
        print("美的扫风")

class GREE_AC(AC):
    def cool_wind(self):
        print("格力制冷")
    def hot_wind(self):
        print("格力制热")
    def swing_wind(self):
        print("格力扫风")

def make_cool(ac:AC):
    ac.cool_wind()


MEI = Midea_AC()
MEI.cool_wind()
GRee = GREE_AC()
GRee.cool_wind()