面向对象编程：一切皆对象

news/2024/9/24 10:20:29/

面向对象(OOP)是一种编程范式,它使用''对象''来设计软件。对象可以包含数据和代码：数据代表对象的状态，而代码代表操作数据的方式。在面向对象编程中，一切皆对象，这意味着将现实世界事务使用类与实例来模拟，如灯，汽车，导弹，杯子，都可以用类和实例来模拟。

一 、类与实例

类

类是对现实世界描述的一种类型。它定义了一组具有相同属性和方法的对象的结构。类名通常使用大驼峰命名法，例如 ElectricCar。

python">class ElectricCar:pass

类是抽象的，约定了未来实例应该有的内容，是实例的模板。

实例

实例是类的具现化。通过调用类来生成实例：

python">class ElectricCar:pass
my_car = ElectricCar()

实例是具体的，具有具体的数据。实例的内容依赖于类。

二、self

self 是类的一个特殊变量，用于代表未来的实例。在类的内部，self 用于访问类的属性和方法。

初始化函数

__init__ 是一个特殊的方法，称为构造器，用于初始化新创建的对象。

python">class ElectricCar:def __init__(self, make, model):self.make = makeself.model = model

 魔法函数

Python 提供了一系列特殊的方法，称为魔法函数，例如 __str__、__len__ 和比较方法 __eq__ 等。

python"># 内部编写所有魔法方法的使用案例
'''
以双下滑线开头和结尾的为魔法函数
__init__: 用于初始化对象。
__str__: 返回实例用字符串表示，自定义内容
__len__:当使用 len() 函数时调用，返回容器类型的长度。实例与实例之间也可以比较了
__eq__ :==触发
__ne__ :!=触发
__gt__ :>触发
__ge__ :>=触发
__lt__ :< 触发
__le__ :<=触发__add__ :+触发
__sub__ :-触发
__mul__ :*触发
__truediv:/触发
__floordiv__://触发
__mod__:%触发
__divmod__:div(x,y)触发
'''# class Myclass:
#     def __init__(self, name, age):
#         print('初始化函数执行了')
#         self.name = name
#         self.age = age
#
#     def __str__(self):
#         return f'姓名：{self.name},年龄：{self.age}'
#
#     def __len__(self):
#         return len(self.name)
#
#     def __gt__(self, other):
#         '''
#         用>来判断年龄大小
#         :param other:
#         :return:
#         '''
#         return self.age > other.age
#
#     def __lt__(self, other):
#         '''
#         用<来判断 年龄大小
#         :param other:
#         :return:
#         '''
#         return self.age < other.age
#
#     def __ge__(self, other):
#         '''
#         用>=来判断 年龄大小
#         :param other:
#         :return:
#         '''
#         return self.age >= other.age
#
#     def __le__(self, other):
#         '''
#         用<=来判断 年龄大小
#         :param other:
#         :return:
#         '''
#         return self.age <= other.age
#
#     def __eq__(self, other):
#         '''
#         判断两个实例age和name是否完全相等
#         :param other:
#         :return:
#         '''
#         return self.age == other.age and self.name == other.name
#
#     def __ne__(self, other):
#         '''
#         判断两个实例 age 或者 name 是否有一方不相等
#         :param other:
#         :return:
#         '''
#         return self.age != other.age or self.name != other.name
#
#     def __add__(self, other):
#         '''
#         返回两个实例的age相加
#         :param other:
#         :return:
#         '''
#         return self.age + other.age
#
#     def __mul__(self, other):
#         '''
#         返回两个实例的age乘积
#         :param other:
#         :return:
#         '''
#         return self.age * other.age
#
#     def __divmod__(self, other):
#         '''
#         先求除 再求余
#         :param other:
#         :return:
#         '''
#         return divmod(self.age, other.age)
#
#     def __mod__(self, other):
#         '''
#         返回两个实例的
#         :param other:
#         :return:
#         '''
#         return self.age % other.age
#
#
# mc = Myclass('亲亲亲', 18)
# print(mc)
# # __len__
# print(len(mc))
#
# mc2 = Myclass('顺子', 18)
# # __str__
# print(mc2)
# __gt__
# print(mc > mc2)
# # __lt__
# print(mc < mc2)
# # __ge__
# print(mc >= mc2)
# __le__
# print(mc <= mc2)
# __eq__
# print(mc == mc2)
# # __nq__
# print(mc != mc2)
# # __add__
# print(mc + mc2)
# # __mul__
# print(mc * mc2)
# __mod__
# print(mc % mc2)
# __divmod__
# print(divmod(mc, mc2))

构造函数与析构函数

构造函数用于创建实例，返回实例，通过父类来创建实例，super()._new()而析构函数在实例不再使用时执行，用于清理资源。

python">"""
构造函数：创建并且返回实例（self）
初始化函数： self已经创建完成，可以向self中添加数据
析构函数： 销毁实例 清理实例内存  实例不在使用则回收实例内存之前汇执行对应的析构函数
"""# class MyClass:
#     def __new__(cls, *args, **kwargs):
#         # 调用父类的new方法创建一个实例
#         instance = super().__new__(cls)
#         print(f"构造函数执行了", id(instance))
#         # 将创建好的实例返回 返回给初始化函数
#         return instances
#
#     def __init__(self, name):
#         print(f"初始化函数执行了", id(self))
#         self.name = name
#
#     def __del__(self):
#         print(f"析构函数执行了")
#
#
# mc1 = MyClass("阿拉伯")
# print(id(mc1), id(None), mc1 is None)
#
# mc1 = None
# print("程序执行完毕  将要退出")
# #  程序退出执行析构mc1class MyOpen:def __init__(self, filename, mode="r", encoding="utf8"):self.f = open(filename, mode=mode, encoding=encoding)def read_all(self):return self.f.read()def __del__(self):self.f.close()mo = MyOpen("./65.魔法函数.py")
print(mo.read_all())

三、三大特性

封装

封装是将数据（属性）和操作数据的方法组合在一起的过程。封装确保了数据的安全性，只能通过特定的方法来访问和修改。

python"># 装饰器：一个函数，用于增强或修改另一个函数的行为，通常通过返回一个新的函数来实现。
import random
import timedatas = [random.randint(0, 10000) for i in range(10000)]
# 通过浅拷贝 得到一模一样的列表
datas_copy = datas.copy()def time_cost(f):def calc():stat = time.time()f()print(f'{f}花费的时间开销为：{time.time() - stat}')return calc@time_cost
def my_fun1():datas.sort()print(datas)my_fun1()@time_cost
def my_fun2():new_list = sorted(datas_copy)print(new_list)my_fun2()import random
import timedatas = [random.randint(0, 10000) for i in range(10000)]
# 通过浅拷贝 得到一模一样的列表
datas_copy = datas.copy()def time_cost(f):def calc():stat = time.time()f()print(f'{f.__name__}花费的时间开销为：{time.time() - stat}')return calcdef fun1():datas.sort()print(datas)fun1 = time_cost(fun1)
fun1()  # 此时的fun1（）不是fun1（）而是calc（）def fun2():new_list = sorted(datas_copy)print(new_list)fun2 = time_cost(fun2)
fun2()  # 此时的fun2（）不是fun2（）而是calc（）

继承

继承允许新创建的类（子类）继承现有类（父类）的属性和方法。

  • __base__     ：获取父类
  •  __bases__  ：获取父类元组
  •  __class__   ：返回实例对应的类
多继承

继承多个父类-java，c# 只支持单继承，通过接口等来实现多继承的功能，Python直接就可以有多个父类。

python"># 多继承 继承多个父类class SpeakAble:def __init__(self, la):self.la = ladef speak(self):return print(f'I can speak {self.la}')class SpeedAble:def __init__(self, speed):self.speed = speeddef move(self):print(f'Moving at a speed of {self.speed} km/h')class Person(SpeedAble, SpeakAble):def __init__(self, name, la, speed):self.name = nameSpeedAble.__init__(self, speed)SpeakAble.__init__(self, la)def __str__(self):return f'name: {self.name}, language: {self.la}, speed: {self.speed}'class ATM(Person):def __init__(self, name, speed, la, skill):super().__init__(name, la, speed)self.skill = skilldef show(self):return print(f'{self.name},{self.speed},{self.la},{self.skill}')def attack(self):print(f'{self.name} is attacking with a skill: {self.skill}')atmo = ATM('赛罗', 1000, '光环语言', '赛罗光纤')
atmo.show()
atmo.move()
atmo.speak()
atmo.attack()
# 多继承 mro : method(方法) retrieval(检索)  order(顺序)
# Python3 使用广度优先# print(ATM.mro())

多态

多态允许同一个接口接受不同的数据类型。在Python中，多态是隐式实现的，不需要显式定义。

python"># 同名不同参数# def my_fun(a):
#     print(a)
#
#
# def my_fun(a, b):
#     print(a, b)
#
#
# # 后一个的my_fun()覆盖掉了上方的my_fun
# my_fun(10, 2)# 在面向对象编程中，子类可以重写父类的方法，当调用子类实例的方法时，将执行子类中的方法定义。
class Animal:def walk(self, speed):print('walk')class Dog(Animal):def walk(self, speed):print('run')class Cat(Animal):def walk(self, speed):print('sheep')# 类似于多态！结果以元组的形式输出
def my_fun(*args):print(args)my_fun(10)
my_fun(10, 11)
my_fun(10, 11, 22)
my_fun(10, 11, 22, 33)

抽象类

抽象类是一种特殊的类，它不能被实例化，但可以包含抽象方法。子类继承抽象类时，必须实现这些抽象方法。

python">'''
抽象类是一种不能被实例化的类
'''from abc import ABC, abstractmethodclass Animal(ABC):'''通过装饰器abstractmethod把walk变为抽象方法'''@abstractmethoddef walk(self):passdef eat(self):print('可以吃')class Dog(Animal):def walk(self):print('dog can walk')class Cat(Animal):def walk(self):print('cat can walk')dog = Dog()
dog.walk()  # 输出: Woof!cat = Cat()
cat.walk()  # 输出: Meow!

四、类中内容

实例属性

向实例中添加的数据，可以通过类内 self 或类外实例来添加。

实例方法

第一个参数是 self 的方法，可以通过类内或类外实例来调用。

python">class Person:def __init__(self, name, sex):self.name = nameself.sex = sexdef set_name(self, name):self.name = namedef __str__(self):return f'类名：{self.name} 类别：{self.sex}'p = Person('泉', '男')
print(p)

类属性

类属性可以通过类名直接访问和设置。

python">class MyClass:# 类属性class_attribute = 'I am a class attribute'@classmethoddef class_method(cls):print(cls.class_attribute)@classmethoddef update_class_attribute(cls, new_value):cls.class_attribute = new_valueprint(MyClass.class_attribute)  # I am a class attributeMyClass.class_method()          # I am a class attribute

类方法

使用 @classmethod 装饰器的方法，第一个参数通常是 cls，表示类本身。

python">class MyClass:@classmethoddef class_method(cls):# cls 代表 MyClass 类print(f"这是 {cls} 的类方法")# 类方法可以通过类直接调用，也可以通过类的实例调用，但推荐通过类直接调用。MyClass.class_method()  # 推荐方式# 实例也可以调用类方法，但这不是推荐的做法
my_instance = MyClass()
my_instance.class_method()

静态方法

使用 @staticmethod 装饰器的方法，没有特殊的参数，通常用于辅助功能。

python"># 静态方法  不需要 self 或 cls 参数，不能访问类或实例的属性。
class GamePerson:@staticmethoddef play_name():pass@staticmethoddef play_age():pass@staticmethoddef play_sex():pass@staticmethoddef play_address():passGamePerson.play_name()
GamePerson.play_age()
GamePerson.play_address()
GamePerson.play_sex()

五、Python的灵活性

Python 是一种解释性语言，允许动态地向类中添加内容，包括属性、方法等。

数据的访问级别

在面向对象编程中，数据的访问级别（也称为访问修饰符）用于控制类成员（属性和方法）的可见性和可访问性。Python 没有像 Java 或 C++ 那样的严格访问级别，但是它遵循一些约定来模拟访问控制。以下是 Python 中常见的数据访问级别：

公有（Public）
  • 公有属性和方法没有特定的修饰符。它们可以直接从类的实例和类的外部访问。
  • 公有成员通常以小写字母开头，这是 Python 的惯例。
python"># 公有（Public）
class Car:def __init__(self, color):self.color = color  # 公有属性def start(self):    # 公有方法return f'The car starts.'print(car.start())
私有(Private)
  • 私有成员以双下划线 __ 开头。它们通常只在类内部使用，不可从类的外部直接访问。
  • Python 中的私有属性和方法实际上并不是真正的私有，它们可以通过_classname__attributename 的方式访问，但这是一种约定，表明这些成员不应该从外部访问。 
    python"># 私有(Private)
# 私有成员以双下划线 __ 开头。
class Car:def __init__(self):  # 私有属性self.__max_spend = 200def get_max_spend(self):  # 公开私有属性的方法return self.__max_spendcar = Car()
print(car.get_max_spend())
    保护（Protected）
    • 受保护的成员以单个下划线 _ 开头。它们可以在类本身和继承的子类中访问，但不应在类的外部访问。
    • 与私有成员一样，Python 中的受保护成员也不是真正的受保护，但遵循约定不应从外部访问。 
      python"># 私有(Private)
# 私有成员以双下划线 __ 开头。
class Car:def __init__(self):  # 私有属性self.__max_spend = 200def get_max_spend(self):  # 公开私有属性的方法return self.__max_spend

六、属性封装 

使用 @property 装饰器可以创建只读属性，使用 @属性名.setter 可以定义设置属性值的方法。

上方的代码保护（Protected）中_color 属性是一个受保护的成员，这意味着它按照惯例应该只在类内部或子类中访问。然而，由于 Python 的动态特性仍可以通过从类的外部访问和修改它。

为了更好地封装，可以使用属性装饰器 @property 来提供对属性的受控访问：

python"># 保护(Protected)
class Car:def __init__(self):self._color = 'red'  # 受保护的属性@propertydef color(self):# 只读属性，外部不能直接设置_color的值return self._color@color.setterdef color(self, new_color):# 可以在这里添加验证逻辑self._color = new_color# 使用 setter 方法修改颜色
car = Car()
car.color = 'yellow'  # 使用属性的方式调用 setter 方法
print(car.color)  # 使用属性的方式获取颜色，将输出 'yellow'

在这个修改后的版本中，color 是一个属性，提供了对 _color 的受控访问。外部代码应该使用 car.color 来获取和设置颜色值，而不是直接使用 car._color。这样，您可以在 color 的 setter 方法中添加验证逻辑，确保属性值的有效性。

单例类

单例类确保只有一个实例存在。它通过控制构造函数来实现这一点。

python">class Person:pass# 每次调用类都可以生成一个新的实例
p1 = Person()
p2 = Person()
p3 = Person()print(p1 is p2, p2 is p3, p3 is p1)class Manage(object):instance = Nonedef __new__(cls, *args, **kwargs):'''对构造函数进行控制 不是每次都生成新的实例1. 对类属性instance判断 如果为空 就构造一个实例 并且把实例赋予instance2. 对类属性instance判断 如果不为空 则直接把他返回'''if not Manage.instance:Manage.instance = super().__new__(cls)return Manage.instancedef __init__(self):print('初始化函数执行了')m1 = Manage()
m2 = Manage()
print(m1 is m2, m1 is None, m2 is None)

结论

面向对象编程是一种强大的范式，它通过类和实例的概念，提供了一种自然的方式来模拟现实世界中的事务。Python 的灵活性和动态特性使得OOP在Python中得以广泛应用。通过封装、继承和多态，OOP提高了代码的可重用性、灵活性和可维护性。


http://www.ppmy.cn/news/1503948.html

相关文章

视频监控汇聚平台LntonCVS安防管理平台构建互联网视频监控安全管理系统方案

视频监控汇聚平台LntonCVS安防管理平台构建互联网视频监控安全管理系统方案

随着互联网和人工智能技术的发展&#xff0c;我们致力于建设一种云端平台&#xff0c;统一整合各类二三类视频资源&#xff0c;实现对网络工程最后100米、10米甚至1米的全域覆盖。 依托互联网与VPN网络&#xff0c;我们提供了一种视频监控安全管理系统方案&#xff0c;集成了大…
阅读更多...
关于Unity四种合批技术详解

关于Unity四种合批技术详解

文章目录 一.静态合批(StaticBatching)1.启用静态合批2.举例说明3.静态合批的限制4.静态合批的优点缺点5.动态指定物品合批 二.动态合批(Dynamic Batching)1.启用动态合批2.合批规则3.举例说明4.使用限制 三.GPU Instancing1.启用GPU Instancing2.启用限制3.举例说明 四.SRP Ba…
阅读更多...
希尔排序算法思想及代码实现

希尔排序算法思想及代码实现

希尔排序是根据增量序列划分成组后对组内的元素进行直接插入排序。 增量序列的确定 数组长度/2向下取整直到1&#xff0c;如数组 arr{5, 3, 8, 6, 2, 7, 1, 4} 其长度为8&#xff0c;那么增量序列就是[8,4,1]。8/24&#xff0c;4/22&#xff0c;2/21 计算增量序列的Java代…
阅读更多...
Pycharm + Pyside6

Pycharm + Pyside6

1. 使用 Qt designer 创建 UI 文件 2. 使用 UIC 工具生成 ui_.py 文件 3. 自定义类导入ui.py 文件的窗口类 4.自定义窗口继承UI窗体类 5. self.setupUi(self) from PySide6.QtWidgets import QApplication, QWidget, QComboBox, QVBoxLayout from ui_test import Ui_Formc…
阅读更多...
释放自动化测试潜能：性能优化策略与实战技巧！

释放自动化测试潜能：性能优化策略与实战技巧！

引言 在当今追求软件快速迭代的环境下&#xff0c;自动化测试的性能瓶颈正成为制约开发流程加速的主要障碍。本文将深入探讨如何通过策略和实践&#xff0c;优化自动化测试的性能&#xff0c;实现测试执行速度的质的飞跃。 自动化性能瓶颈的识别与突破 首先&#xff0c;识别并…
阅读更多...
好用的 AIGC工具（ 6个 ）

好用的 AIGC工具（ 6个 ）

现在智能化的AI工具&#xff0c;可以实现智能聊天、文本生成、语言翻译等多种功能。 博主归纳总结了6个好用免费的AI工具网站&#xff0c;供大家参考。 ## 1&#xff0c;insCode 网址&#xff1a; https://inscode.csdn.net/ 简介&#xff1a; InsCode 的 Ins 是 Inspiratio…
阅读更多...
【2024蓝桥杯/C++/B组/拔河】

【2024蓝桥杯/C++/B组/拔河】

题目 代码 #include<bits/stdc.h> using namespace std;const int N 1e3100; long long a[N]; long long s[N]; long long sum[N*N]; int main() {int n;cin >> n;for(int i 1; i < n; i){cin >> a[i];s[i] s[i-1] a[i];}int cnt 0;for(int i 1; i…
阅读更多...
系统架构设计师 - 企业信息化战略与实施

系统架构设计师 - 企业信息化战略与实施

企业信息化战略与实施 企业信息化战略与实施信息与信息化的概念信息的定义信息的特点信息化的概念信息化对组织的意义 信息系统生命周期 ★立项阶段开发阶段运维阶段消亡阶段 信息系统战略规划 ★ ★ ★政府信息化与电子政务 ★企业信息化与电子商务 ★ ★ ★企业资源计划企业资…
阅读更多...
最新文章

Copyright @ 2022~2023