面向对象 元类 gil log 协程 垃圾回收 描述符 property

面向对象 元类 gil log 协程 垃圾回收 描述符 property"/>

面向对象 元类 gil log 协程 垃圾回收 描述符 property

 封装、继承、多态

当谈到封装、继承和多态时，通常是在面向对象编程 (OOP) 的上下文中讨论的。

封装 (Encapsulation) 示例：

class Person:   def __init__(self, name, age):       self.__name = name  # 使用双下划线前缀将属性变为私有       self.__age = age
​   def get_name(self):       return self.__name
​   def set_name(self, new_name):       if len(new_name) > 0:           self.__name = new_name
​   def get_age(self):       return self.__age
​   def set_age(self, new_age):       if new_age >= 0:           self.__age = new_age
​
# 创建一个Person对象并访问属性
person = Person("Alice", 30)
print(person.get_name())  # 输出：Alice
person.set_age(32)  # 设置年龄
print(person.get_age())  # 输出：32

在这个示例中，我们通过将属性标记为私有（使用双下划线前缀）来封装数据，并提供公共方法（get_name、set_name、get_age、set_age）来访问和修改这些属性。这样，我们可以控制属性的访问和修改，以确保数据的安全性。

使用面向对象来开发，示例代码如下：

• 类：理解为模板
• 对象：理解为实物

1. 在使用面向过程编程时，当需要对数据处理时，需要考虑用哪个模板中哪个函数来进行操作，但是当用面向对象编程时，因为已经将数据存储到了这个独立的空间中，这个独立的空间（即对象）中通过一个特殊的变量（__class__）能够获取到类（模板），而且这个类中的方法是有一定数量的，与此类无关的将不会出现在本类中，因此需要对数据处理时，可以很快速的定位到需要的方法是谁 这样更方便
2. 全局变量是只能有1份的，多个函数需要多个备份时，往往需要利用其它的变量来进行储存；而通过封装 会将用来存储数据的这个变量 变为了对象中的一个“全局”变量，只要对象不一样那么这个变量就可以再有1份，所以这样更方便
3. 代码划分更清晰

继承 (Inheritance) 示例：

class Animal:   def __init__(self, name):       self.name = name
​   def speak(self):       pass
​
class Dog(Animal):   def speak(self):       return f"{self.name} 说：汪汪汪！"
​
class Cat(Animal):   def speak(self):       return f"{self.name} 说：喵喵喵！"
​
# 创建一个Dog对象和一个Cat对象，并调用speak方法
dog = Dog("旺财")
cat = Cat("小花")
print(dog.speak())  # 输出：旺财 说：汪汪汪！
print(cat.speak())  # 输出：小花 说：喵喵喵！

在这个示例中，我们定义了一个基类 Animal，然后创建了两个派生类 Dog 和 Cat，它们继承了 Animal 的属性和方法。每个派生类都可以覆盖基类的方法（例如 speak），以实现自己的行为。

1. 能够提升代码的重用率，即开发一个类，可以在多个子功能中直接使用
2. 继承能够有效的进行代码的管理，当某个类有问题只要修改这个类就行，而其继承这个类的子类往往不需要就修改

多态 (Polymorphism) 示例：

class Shape:   def area(self):       pass
​
class Circle(Shape):   def __init__(self, radius):       self.radius = radius
​   def area(self):       return 3.14 * self.radius * self.radius
​
class Rectangle(Shape):   def __init__(self, length, width):       self.length = length       self.width = width
​   def area(self):       return self.length * self.width
​
# 创建一个Shape的列表，包含不同类型的图形对象
shapes = [Circle(5), Rectangle(4, 6), Circle(3)]
​
# 计算并输出每个图形的面积
for shape in shapes:   print(f"面积：{shape.area()}")

在这个示例中，我们定义了一个基类 Shape，以及两个派生类 Circle 和 Rectangle，它们都具有一个名为 area 的方法。通过多态，我们可以在一个列表中存储不同类型的图形对象，然后通过统一的方法调用来计算它们的面积。这就是多态的核心思想，不同的对象可以对相同的方法做出不同的响应。

class MiniOS(object):"""MiniOS 操作系统类 """def __init__(self, name):self.name = nameself.apps = []  # 安装的应用程序名称列表def __str__(self):return "%s 安装的软件列表为 %s" % (self.name, str(self.apps))def install_app(self, app):# 判断是否已经安装了软件if app.name in self.apps:print("已经安装了 %s，无需再次安装" % app.name)else:app.install()self.apps.append(app.name)class App(object):def __init__(self, name, version, desc):self.name = nameself.version = versionself.desc = descdef __str__(self):return "%s 的当前版本是 %s - %s" % (self.name, self.version, self.desc)def install(self):print("将 %s [%s] 的执行程序复制到程序目录..." % (self.name, self.version))class PyCharm(App):passclass Chrome(App):def install(self):print("正在解压缩安装程序...")super().install()linux = MiniOS("Linux")
print(linux)pycharm = PyCharm("PyCharm", "1.0", "python 开发的 IDE 环境")
chrome = Chrome("Chrome", "2.0", "谷歌浏览器")
chrome2 = Chrome("Chrome2", "3.0", "古哥浏览器")linux.install_app(pycharm)
linux.install_app(chrome)
linux.install_app(chrome)
linux.install_app(chrome2)print(linux)Linux 安装的软件列表为 []
将 PyCharm [1.0] 的执行程序复制到程序目录...
正在解压缩安装程序...
将 Chrome [2.0] 的执行程序复制到程序目录...
已经安装了 Chrome，无需再次安装
正在解压缩安装程序...
将 Chrome2 [3.0] 的执行程序复制到程序目录...
Linux 安装的软件列表为 ['PyCharm', 'Chrome', 'Chrome2']

多态需要用到继承，重写，调用某个方法时，要看是父类创建的实例，还是子类创建的实例，实例不同调用的方法不同

关键点:

1. 定义了一个基类App,它具有name、version、desc属性,以及一个install方法用于安装。
2. 定义了两个子类PyCharm和Chrome,继承自App。
3. Chrome类对install方法进行了重写,添加了自定义的安装逻辑。
4. 在MainOS类中,通过install_app方法安装不同的App实例对象,调用其install方法。
5. 对于同一个install_app方法,传入不同的类的实例,会调用各自类中不同的install实现。这就是多态。
6. 多态允许我们基于同一接口编写可扩展和可维护的代码。子类可以改变父类的行为,同时保持接口一致。

所以多态的关键是:

• 有继承关系
• 子类覆盖父类方法
• 对不同子类实例调用相同的方法

这使得调用者可以一致地调用方法,而具体执行代码依赖于运行时对象的类型。这就是多态

• 面向过程开发，简单、开发前期快速，越往后越复杂，适合小工程

• 面向对象开发，复杂、开发前期较慢，越往后开发越方便，适合大工程

  没有最好的开发模式，只有经过多多练习，见的多了，感受多了，自然也就能够在不同的任务、不同的工程，使用合适的方式进行开发

静态方法和类方法

类属性、实例属性

它们在定义和使用中有所区别，而最本质的区别是内存中保存的位置不同，

• 实例属性属于对象

• 类属性属于类

class Province(object):# 类属性country = 'china'def __init__(self, name):# 实例属性self.name = name# 创建一个实例对象
obj = Province('shangdong')
# 直接访问实例属性
print(obj.name)
# 直接访问类属性
Province.country

由上述代码可以看出【实例属性需要通过对象来访问】【类属性通过类访问】，在使用上可以看出实例属性和类属性的归属是不同的。

其在内容的存储方式类似如下图：

由上图看出：

• 类属性在内存中只保存一份

• 实例属性在每个对象中都要保存一份

• 通过类创建实例对象时，如果每个对象需要具有相同名字的属性，那么就使用类属性，用一份既可

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

方法包括：实例方法、静态方法和类方法，三种方法在内存中都归属于类，区别在于调用方式不同。

• 实例方法：由对象调用；至少一个self参数；执行实例方法时，自动将调用该方法的对象赋值给self；

• 类方法：由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类赋值给cls；

• 静态方法：由类调用；无默认参数；

class Foo(object):def __init__(self, name):self.name = namedef ord_func(self):""" 定义实例方法，至少有一个self参数 """# print(self.name)print('实例方法')@classmethoddef class_func(cls):""" 定义类方法，至少有一个cls参数 """print('类方法')@staticmethoddef static_func():""" 定义静态方法 ，无默认参数"""print('静态方法')f = Foo("china")
# 调用实例方法
f.ord_func()
# 调用类方法
Foo.class_func()
# 调用静态方法
Foo.static_func()
实例方法
类方法
静态方法

• 相同点：对于所有的方法而言，均属于类，所以 在内存中也只保存一份
• 不同点：方法调用者不同、调用方法时自动传入的参数不同。

# 实例方法
# self参数表示当前对象的实例
class Person:def __init__(self, name):self.name = namedef say_hello(self):print(f'Hello, my name is {self.name}')p = Person('John')
p.say_hello() # 调用实例方法,自动传递当前实例p作为self参数# 静态方法
# 使用@staticmethod装饰器声明,不需要默认的self参数
class Person:def __init__(self, name):self.name = name@staticmethoddef hello():print('Hello!')Person.hello() # 直接使用类名调用静态方法,不需要实例化# 类方法
# 使用@classmethod装饰器声明,默认参数cls代表当前类本身
class Person:count = 0 # 类属性def __init__(self, name):self.name = namePerson.count += 1@classmethoddef print_count(cls):print(f'Number of people: {cls.count}')Person.print_count() # 使用类名调用,将类本身作为参数传递
person=Person('')
person.print_count()Hello, my name is John
Hello!
Number of