Python中的面向对象编程，类，对象，封装，继承，多态

Jam-Young2024-11-15 10:14

一、面向对象编程

1.面向过程和面向对象

面向过程和面向对象都是一种编程方式，只不过再设计上有区别。

面向过程

C语言

细分成每一个过程

优点：简单直观、性能高效、代码简洁。

缺点：不易维护、不易扩展、代码重用性低。

面向对象

python、java、C++

要使用某个功能，直接找到对应的对象即可

优点：模块化、安全性高、代码重用性高。

缺点：学习难度大、性能开销大、调试困难。

二、类和对象

Python中一切都是对象

目前我们所学的python中的内置类型都是对象------内置对象，内置对象有时候不能满足我们的需求，需要自定义一些对象。

10， 20， 30， -40， a=10, b=20等等等，都是整数，对其进行抽象------int类。

1 类的定义 与 实例化对象

在python中使用class关键字创建一个类。

python 复制代码 
语法格式1：
class ClassA:
    # 公共的属性
    def __init__(self):
        pass
    def fun1(self):
        pass
    def fun2(self):
        pass

语法格式2：
class ClassA(object):
    # 公共的属性
    def __init__(self):
        pass
    def fun1(self):
        pass
    def fun2(self):
        pass
        
 实例化对象的语法：
 1》无参
     对象名 = 类名()
 2》有参
     对象名 = 类名(参数列表)

第一个 init()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会自动调用该方法。不是必须要定义的，可以在需要的时候再定义。

第二个 self是一个参数，表示对象自身【对象的id号】，里面存放着对象自身的地址。如果希望类中的方法可以被对象调用，第一个参数必须是self。作用是将实例对象与类的方法进行绑定，这样实例的每个对象都能调用"属于"自己的方法。传参时可以省略。

2 访问属性/方法

使用 . 进行访问

python 复制代码 
# 访问属性
对象名.属性
# 访问方法
对象名.方法名()

3 对象与类的关系

  1. 对象拥有类的所有属性和方法
  2. 对象的属性和方法可以单独添加、删除、修改
  3. 对象与对象之间的属性和方法不可共享
  4. 对象不能独自创建，必须依托于类，类可以实例化N个对象
python 复制代码 
class Stu(object):
    id = '1001'
    name = '张三'
    def fun1(self):
        pass

# 实例化对象
s1 = Stu()
s2 = Stu()
# 对象的属性可以单独修改、添加、删除
s1.name = '李四'
s1.age = 18
del s1.age
print(s1.name)
# print(s1.age)
print(s2.name)
# print(s2.age)

拓展对象的方法

MethodType

python 复制代码 
from types import MethodType

class Stu(object):
    id = '1001'
    name = '张三'

    def fun1(self):
        print(f"{self.name}会吃饭")

    def fun2(self):
        print(f"{self.name}会学习")

s1 = Stu()
s2 = Stu()
s1.name = '刘德华'
s2.name = '蔡徐坤'

s1.fun1()
s2.fun1()

def sing(self):
    print(f"{self.name}会唱歌")

def dance(self):
    print(f"{self.name}会跳舞")

# 拓展对象的方法
s1.sing = MethodType(sing, s1)
s2.dance = MethodType(dance, s2)

s1.sing()
s2.dance()
  • getattr(obj, name[, default]) : 访问对象的属性。
  • hasattr(obj,name) : 检查是否存在一个属性。
  • setattr(obj,name,value) : 设置一个属性。如果属性不存在，会创建一个新属性。
  • delattr(obj, name) : 删除属性。

4 魔方方法------构造函数 与 析构函数

  1. init 构造函数：完成对象的初始化工作，方便统一管理、调用类创建对象时，自动执行。
  2. del 析构函数：删除对象时执行一些操作，自动执行。
  3. str 打印方法：输出执行信息，自动执行。
python 复制代码 
class Car(object):
    def __init__(self, name, color):
        self.name = name
        self.color = color

    def __str__(self):
        return f"车品牌{self.name} 颜色{self.color}"

    def __del__(self):
        print(f"{self.name}报废了，去车管所吧")


c1 = Car("奥迪", "黑色")
c2 = Car("小米su7", "紫色")

print(c1.name, c2.name)
print(c1)
print(c2)

5 类属性/方法 与 实例对象属性/方法 与 静态方法

类属性，实例属性

python 复制代码 
class Student(object):
    """
    定义了一个学生类
    """
    grade = 'A'       # 类属性

    def __init__(self, name, age):
        self.name = name    # 实例对象属性
        self.age = age      # 实例对象属性

s1 = Student('张三', 18)

# 类属性的访问
print(Student.grade)
print(s1.grade)

# 实例属性的访问
# print(Student.name)    报错！！！
print(s1.name)

类方法、实例方法、静态方法

类方法中只能调用类属性和类方法

在类方法前加上@classmethod

实例方法中能调用类属性、实例属性

静态方法一般实现与类和对象无关联的操作，例如：游戏说明书等

在静态方法前加@staticmethod

python 复制代码 
class Student(object):
    """
    定义了一个学生类
    """
    grade = 'py24101'

    @classmethod
    def cls_fun(cls):
        """类方法中只能调用类属性和类方法"""
        print(f"班级名称是{cls.grade}")

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def fun1(self):
        """实例方法中能调用类属性、实例属性"""
        print(f"实例方法中输出类属性{self.grade}, 输出实例属性{self.name}")

    @staticmethod
    def sta_fun(x):
        print(f"{x}静态方法一般实现与类和对象无关联的操作，例如：游戏说明书等")

s1 = Student('张三', 18)
# 如何调用类方法
Student.cls_fun()
s1.cls_fun()

# 如何调用实例方法
Student.fun1(s1)
s1.fun1()

# 如何调用静态方法
Student.sta_fun(3)
s1.sta_fun(3)

6 Python的内置类属性

  • dict : 类的属性（包含一个字典，由类的数据属性组成）
  • doc :类的文档字符串
  • name: 类名
  • module: 类定义所在的模块（类的全名是'main.className'，如果类位于一个导入模块mymod中，那么className.module 等于 mymod）
  • bases : 类的所有父类构成元素（包含了一个由所有父类组成的元组）
python 复制代码 
class Student(object):
    """
    定义一个学生类
    属性：名字 年龄
    方法：method_1 method_2
    """
    name = '张三'
    age = 18

    def method_1(self):
        pass

    def method_2(self):
        pass

print(Student.__dict__)
print(Student.__doc__)
print(Student.__name__)
print(Student.__module__)
print(int.__module__)
print(Student.__bases__)

三、类的封装

封装是类的三大特性之一。

封装指的是隐藏对象中一些不希望让外部所访问的属性或方法。

python中封装其实是通过设置访问权限来体现的，私有属性和私有方法是控制访问权限的组成部分。

1 私有属性

在类的内部使用，不希望外部直接访问的变量。

在python中，使用双下划线作为前缀来定义私有属性。

私有属性在类外不能访问

python 复制代码 
class Bank(object):
    """
    定义了一个银行卡类
    属性：name     pwd密码【我不希望外部访问】
    """
    def __init__(self, name, pwd):
        self.name = name
        self.__pwd = pwd

    # 为了在某些需要的时候，访问到私有属性，所以需要在类内部设置两个接口
    def get_pwd(self):
        return self.__pwd

    def set_pwd(self, newpwd):
        self.__pwd = newpwd


# print(Bank.__pwd)

b1 = Bank('张三', '123456')
print(b1.name)
# print(b1.__pwd)
print(b1.get_pwd())
b1.set_pwd('666888')
print(b1.get_pwd())

2 私有方法

和私有属性是一样的。

python 复制代码 
class Bank(object):
    """
    定义了一个银行卡类
    属性：name     pwd密码【我不希望外部访问】
    """
    def __init__(self, name, pwd):
        self.name = name
        self.__pwd = pwd

    def __info(self):
        print(f"名字{self.name}, 密码{self.__pwd}")

    def get_info(self):
        self.__info()

# Bank.__info() 报错
b1 = Bank('李四', '123456')
# b1.__info()   报错
b1.get_info()

3 属性装饰器

属性装饰器是实现把方法转为属性的装饰器。

作用：

  1. 把方法转为属性，便于操作属性
  2. 实现对属性的更改（验证）、查看、删除

查看：在查看方法前加@property

更改：在更改方法前加@方法名.setter

删除：在删除方法前加@方法名.deleter

方法名是一样的

python 复制代码 
class Student(object):
    def __init__(self, name):
        self.__name = name

    @property
    def name(self):
        return self.__name

    @name.setter
    def name(self, new_name):
        if not isinstance(new_name, str):
            print('名字必须是一个字符串')
        else:
            self.__name = new_name

    @name.deleter
    def name(self):
        print("已删除名字")
        del self.__name

s1 = Student('张三')
print(s1.name)
s1.name = 111
s1.name = '李四'
print(s1.name)
del s1.name

四、类的继承

面向对象的编程带来的主要好处之一就是代码的重用，实现这种重用的方法之一就是通过继承机制。

通过继承创建的新类称之为【子类】或者【派生类】，被继承的类称之为【父类】、【基类】、【超类】。

1 语法格式

python 复制代码 
class Parent(object):
    """
    定义父类
    """
    par_attr = 100

    def __init__(self):
        print("初始化父类")

    def par_fun1(self):
        print("父类方法1")

    def par_fun2(self):
        print("父类方法2")

class Child(Parent):
    """
    定义子类
    """
    child_attr = 666
    def __init__(self):
        print("初始化子类")

    def child_fun1(self):
        print("子类方法1")

c1 = Child()
print(c1.child_attr)
c1.child_fun1()

print(c1.par_attr)
c1.par_fun1()
c1.par_fun2()

2 多继承语法【明白即可，不建议乱用】

如果在继承的元组（）里面有一个以上的类，就称之为多继承。

python 复制代码 
class A:
    pass

class B:
    pass

class C:
    pass

class D(A, B, C):
    pass

d1 = D()
print(D.mro())
# python中提供了一个函数mro()用于查看继承的顺序。

3 继承重写父类方法

如果你的父类方法不能满足你得要求，你可以在子类中重写父类的方法。

python 复制代码 
class Parent(object):
    def method(self):
        print(f"{self}的方法")

class Child(Parent):
    def method(self):
        print("xxxxxxxxxx")
        print(f"{self}的方法")

c = Child()
c.method()

这里列出了一些通用的功能，可以在自己的类重写：

  1. init ( self [,args...] ) 构造函数 简单的调用方法: obj = className(args)
  2. del( self ) 析构方法, 删除一个对象 简单的调用方法 : del obj
  3. repr( self ) 转化为供解释器读取的形式 简单的调用方法 : repr(obj)
  4. str( self ) 用于将值转化为适于人阅读的形式 简单的调用方法 : str(obj)
  5. cmp ( self, x ) 对象比较 简单的调用方法 : cmp(obj, x)

4 python继承特点

  • 在子类中如果需要父类的构造方法，需要显式调用父类的构造方法，或者不重写父类的构造方法。init()
  • 在子类中调用父类的方法，需要显式调用，且第一个参数self不能省略。
python 复制代码 
class Parent(object):
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def method(self):
        print(f"{self}的方法")

class Child(Parent):
    def __init__(self, x, y, z):
        Parent.__init__(self, x, y)
        self.z = z

    def fun1(self):
        print(self.x , self.y, self.z)

# 重写父类构造方法、里面显式调用父类构造方法
c = Child(1, 2, 33)
c.fun1()

可以用super()

加法也可以重写

python 复制代码 
class Parent(object):
    def __init__(self, x, y):
        self.x = x
        self.y = y

class Child(Parent):
    def __init__(self, x, y, z):
        super().__init__(x, y)
        self.z = z

    def add(self):
        return self.x + self.y + self.z

c = Child(1, 1, 1)
print(c.add())

5 运算符重载

在Python中，并没有像其他语言（如C++）中那样的内置机制来重载运算符。但是，你可以通过定义特定的方法来模拟运算符重载的行为。

以下是一些常见运算符以及它们对应的特殊方法：

加法：+ 对应 add

减法：- 对应 sub

乘法：* 对应 mul

除法：/ 对应 truediv

取模：% 对应 mod

幂运算：** 对应 pow

位运算：

位运算：>> 对应 rshift

位运算：& 对应 and

位运算：| 对应 or

位运算：^ 对应 xor

python 复制代码 
class Operator(object):
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return self.x * other.x + self.y * other.y

o1 = Operator(1, 2)
o2 = Operator(3, 4)
print(o1 + o2)

五、类的多态

python中的多态也可以通过方法重写进行。

同一个方法，不同对象显式的结果不同。

python 复制代码 
lass Animal(object):
    name = '动物'
    age = 0
    def speak(self):
        print("动物的声音")

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

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

a = Animal()
d = Dog()
c = Cat()

a.speak()
d.speak()
c.speak()

六、关于下划线说明

  1. foo: 以双下划线开头双下划线结尾，定义的是特殊方法，一般是系统定义名字 ，类似 init() 之类的，自动。
  2. _foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import ···
  3. __foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。
相关推荐
半盏茶香3 分钟前
在21世纪的我用C语言探寻世界本质 ——编译和链接（编译环境和运行环境）
c语言·开发语言·c++·算法
Evand J1 小时前
LOS/NLOS环境建模与三维TOA定位，MATLAB仿真程序，可自定义锚点数量和轨迹点长度
开发语言·matlab
LucianaiB1 小时前
探索CSDN博客数据：使用Python爬虫技术
开发语言·爬虫·python
Ronin3051 小时前
11.vector的介绍及模拟实现
开发语言·c++
计算机学长大白2 小时前
C中设计不允许继承的类的实现方法是什么？
c语言·开发语言
PieroPc3 小时前
Python 写的 智慧记 进销存 辅助 程序 导入导出 excel 可打印
开发语言·python·excel
2401_857439696 小时前
SSM 架构下 Vue 电脑测评系统：为电脑性能评估赋能
开发语言·php
SoraLuna6 小时前
「Mac畅玩鸿蒙与硬件47」UI互动应用篇24 - 虚拟音乐控制台
开发语言·macos·ui·华为·harmonyos
xlsw_6 小时前
java全栈day20--Web后端实战(Mybatis基础2)
java·开发语言·mybatis
梧桐树04297 小时前
python常用内建模块：collections
python
热门推荐
01〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04DisplayPort AltMode On Type-c协议_Ver2.0(学习笔记)05校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站06Docker 夺命连环 15 问076个主流的工业3D管道设计软件08基于大语言模型（LLM）的合成数据生成、策展和评估的综述09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10树莓派 5 AI 套件（Hailo-8L）使用教程