在这里插入图片描述

🚀 Python 🚀

🌲 算法刷题专栏 | 面试必备算法 | 面试高频算法 🍀
🌲 越难的东西,越要努力坚持，因为它具有很高的价值，算法就是这样✨
🌲 作者简介：硕风和炜，CSDN-Java领域优质创作者🏆，保研|国家奖学金|高中学习JAVA|大学完善JAVA开发技术栈|面试刷题|面经八股文|经验分享|好用的网站工具分享💎💎💎
🌲 恭喜你发现一枚宝藏博主,赶快收入囊中吧🌻
🌲 人生如棋，我愿为卒，行动虽慢，可谁曾见我后退一步？🎯🎯

🚀 Python 🚀

在这里插入图片描述

🍔 目录

🎍 Python面向对象编程
- 🎋 面向对象编程的基本概念
- 🎋 类和对象的创建
- 🎋 self关键字
- 🎋 属性和方法的定义
- 🎋 封装、继承和多态的概念
- 🎋 特殊方法和属性的使用
- 🎋 使用面向对象编程解决实际问题
- 🎋 面向对象设计原则
- 🎄 Python面向对象编程简单总结
- 💬 共勉

🎍 Python面向对象编程

本文将介绍Python中的面向对象编程，包括面向对象编程的基本概念、类和对象的创建、属性和方法的定义、封装、继承和多态的概念、特殊方法和属性的使用、使用面向对象编程解决实际问题和面向对象设计原则，并提供详细的案例代码。

🎋 面向对象编程的基本概念

面向对象编程是一种编程范式，它将数据和相关的处理方法组合在一起形成对象，并通过封装、继承和多态等机制来实现软件开发的目的。面向对象编程的基本概念包括类、对象、属性、方法、封装、继承和多态等。

🎋 类和对象的创建

在Python中，使用class关键字来定义类，类是一种数据类型，用于定义对象的属性和方法。创建对象时，我们需要实例化类，并将实例化后的对象赋值给变量，这样我们就可以使用对象对属性和方法进行操作。

以下是一个演示如何创建类和对象的示例：

class Car:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year

my_car = Car('Toyota', 'Camry', 2020)
print(my_car.make, my_car.model, my_car.year)

在这个示例中，我们定义了一个名为Car的类，然后使用__init__()方法初始化类的属性。然后，我们实例化了一个名为my_car的对象，并将’Toyota’、'Camry’和2020作为参数传递给__init__()方法。

🎋 self关键字

在 Python 类中，self 是一个关键字，可以用来指代对象本身。每个类中的方法都至少有一个参数，通常被命名为 “self”，这个参数指向调用该方法的对象本身。在方法内部，我们可以使用 self 来访问该对象的属性，甚至可以调用其他方法。
self 是自动传递的，我们无需手动指定，Python 会自动为我们传递当前实例的引用。
通过 self.属性名的方式访问实例的属性。
在方法内调用其他的方法时，需要使用 self.方法名的方式。
在方法内部通过 self.class() 的方式创建一个新的实例。
self 和其他语言中的 this 关键字的区别:在其他一些面向对象的编程语言中，比如 Java 或 C++，使用的关键字是 this，而不是 self。它们的用法基本相似，都是用来指代对象本身。但是，与 self 不同的是，this 是一个指向对象地址的指针，并且必须通过指针间接访问对象的成员。而在 Python 中，self 不是指针，而是一个特殊的变量名，它在方法调用时会自动绑定到当前实例对象，并且可以直接访问该实例的属性和方法。
self 是 Python 中用来指代对象本身的关键字，用于访问对象的属性和方法，以及创建新的实例。与其他面向对象编程语言中的 this 关键字不同，self 是一个变量名，而不是指针。在方法调用时，Python 会自动将 self 绑定到当前实例对象。

🎋 属性和方法的定义

Python中的类可以定义属性和方法，属性是类的特性，方法是定义在类中的函数，用于操作这些属性。

以下是一个演示如何定义属性和方法的示例：

class Car:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
        self.resale_value = 0
        
    def set_resale_value(self, value):
        self.resale_value = value
        
    def get_resale_value(self):
        return self.resale_value

my_car = Car('Toyota', 'Camry', 2020)
my_car.set_resale_value(18000)
print(my_car.get_resale_value())

在这个示例中，我们定义了一个名为resale_value的属性，并使用set_resale_value()和get_resale_value()方法来设置和获取它的值。

🎋 封装、继承和多态的概念

封装、继承和多态是面向对象编程的核心概念之一。

封装：指的是将数据和方法组合在一起形成类的过程。这种方法可以保护数据和方法不被其他程序员直接访问。
继承：指的是创建一个新类，从一个现有类中继承属性和方法的过程。新类通常称为子类，现有类称为父类。
多态：指的是相同的操作或方法作用于不同的对象上可以产生不同的结果的能力。

以下是一个演示封装、继承和多态概念的示例：

class Animal:
    def __init__(self, name):
        self.name = name
        
    def speak(self):
        pass

class Dog(Animal):
    def __init__(self, name):
        super().__init__(name)
        
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def __init__(self, name):
        super().__init__(name)
        
    def speak(self):
        return "Meow!"

dog = Dog("Fido")
cat = Cat("Fluffy")

print(dog.name, dog.speak())
print(cat.name, cat.speak())

在这个示例中，Animal是一个基类，它定义了一个名为speak()的抽象方法。Dog和Cat是Animal的子类，它们重写了speak()方法。当我们调用speak()方法时，它执行的实际上是子类中定义的方法。

🎋 特殊方法和属性的使用

在Python中，特殊方法和属性是与面向对象编程相关的重要概念。包括__init__()、str()、repr()、eq()等特殊方法和__doc__、name、module、__class__等特殊属性。

以下是一个演示使用特殊方法和属性的示例：

class Book:
    def __init__(self, title, author, pages):
        self.title = title
        self.author = author
        self.pages = pages
        
    def __str__(self):
        return f'{self.title} by {self.author}'

    def __repr__(self):
        return f"{self.__class__.__name__}('{self.title}', '{self.author}', {self.pages})"
       
    def __eq__(self, other):
        if isinstance(other, Book):
            return self.pages == other.pages
        return False

book1 = Book('The Great Gatsby', 'F. Scott Fitzgerald', 218)
book2 = Book('To Kill a Mockingbird', 'Harper Lee', 281)

print(book1)
print(repr(book1))
print(book1 == book2)

在这个示例中，我们定义了一个Book类，并使用__str__()方法定义类的字符串表示形式。还使用__repr__()方法返回一个描述对象的字符串，它可以用来创建一个新的对象。最后，我们使用__eq__()方法来判断两个书籍是否相等，然后输出结果。

🎋 使用面向对象编程解决实际问题

面向对象编程可用于解决各种实际问题，如图形界面应用程序、游戏和网站开发等。下面是一个演示如何使用面向对象编程解决实际问题的示例：

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height
        
    def area(self):
        return self.width * self.height

class Square(Rectangle):
    def __init__(self, side):
        super().__init__(side, side)

class GUI:
    def __init__(self, width, height):
        self.rectangles = []
        self.mouse_x = 0
        self.mouse_y = 0
        self.width = width
        self.height = height
        
    def draw_rectangle(self):
        for rectangle in self.rectangles:
            print(f"Drawing rectangle ({rectangle.width} x {rectangle.height}) at ({self.mouse_x}, {self.mouse_y})")
            
    def add_rectangle(self, rectangle):
        self.rectangles.append(rectangle)
        
    def set_mouse_position(self, x, y):
        self.mouse_x = x
        self.mouse_y = y

gui = GUI(600, 400)

rect1 = Rectangle(100, 50)
rect2 = Square(75)

gui.add_rectangle(rect1)
gui.add_rectangle(rect2)

gui.set_mouse_position(200, 150)

gui.draw_rectangle()

在这个示例中，我们使用Rectangle和Square类表示矩形和正方形，并使用GUI类表示图形用户界面。在GUI类中，我们可以添加多个矩形，并在给定位置绘制它们。

🎋 面向对象设计原则

面向对象编程有许多设计原则，其中最常用的是SOLID原则。SOLID原则由Robert Martin提出，包括单一职责原则、开闭原则、里氏替换原则、接口隔离原则和依赖倒置原则等。

以下是一个演示SOLID原则的示例：

class Plane:
    def fly(self):
        pass
        
class Jet(Plane):
    def fly(self):
        print("Jet flying")

class UFO(Plane):
    def fly(self):
        print("UFO flying")

class AirControl:
    def __init__(self):
        self.planes = []
        
    def add_plane(self, plane):
        self.planes.append(plane)
        
    def control_tower(self):
        for plane in self.planes:
            plane.fly()

air_control = AirControl()

jet = Jet()
ufo = UFO()

air_control.add_plane(jet)
air_control.add_plane(ufo)

air_control.control_tower()

在这个示例中，我们定义了五个类，Plane、Jet、UFO、AirControl和一个主函数。Jet和UFO类继承自Plane类，并实现了Plane类的fly()抽象方法。AirControl类是负责掌控所有飞机对象，并实现了一个control_tower()方法，用于控制所有飞机的飞行行为。主函数实例化了Jet和UFO类对象，并将它们添加到AirControl对象中。

这个示例遵循了SOLID原则中的单一职责原则，每个类都只负责一个特定的功能，且它们的职责清晰明了，隔离性强。此外，使用继承和多态实现了开闭原则和里氏替换原则，即可以扩展代码而不用修改原有代码，还可以在任何需要Plane类型的地方使用Jet和UFO对象。接口隔离原则也得到了遵循，每个类只暴露必要的接口，而不是暴露多余的接口。最后，依赖倒置原则有助于系统设计更加灵活和可扩展。

总之，以上示例展示了如何使用Python进行面向对象编程以及应用常见的面向对象设计原则，使得代码具有更好的可读性、可扩展性和易于维护性。