面向对象

多态

在面向对象中，父类、子类通过继承联系在一起，如果可以通过一套方法，就可以实现不同表现，就是多态。

在Python中，多态是面向对象编程中的一个重要概念，它允许不同类型的对象对相同的方法名做出不同的响应。多态性使得代码更加灵活，可以在不同的情境下使用相同的接口来调用不同的方法。

Python实现多态的方式主要是通过方法的重写（覆盖）。当子类继承自父类并重写了父类的方法时，可以根据对象的类型来调用相应的方法。

下面是一个简单的示例，演示了Python中多态的概念：

## 定义一个父类
class Shape:
    def area(self):
        pass

## 定义一个子类，继承自Shape类
class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height
    
    def area(self):
        return self.width * self.height

## 定义另一个子类，继承自Shape类
class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    
    def area(self):
        import math
        return math.pi * self.radius ** 2

## 使用多态调用方法
shapes = [Rectangle(4, 5), Circle(3)]

for shape in shapes:
    print("Area:", shape.area())

在这个示例中，我们定义了一个名为Shape的父类，它包含一个名为area()的方法。然后，我们定义了两个子类Rectangle和Circle，它们分别重写了父类的area()方法以计算矩形和圆的面积。最后，我们创建了一个包含不同类型对象的列表，并使用多态性调用它们的area()方法。

通过多态，我们可以编写更加通用的代码，不需要关心对象的具体类型，只需要调用统一的接口即可。这样可以提高代码的可读性和可维护性，并且使得程序更加灵活和易于扩展。

示例

class Animal():
    def __init__(self, name):
        self.name = name
    def shout(self):
        print('Animal shouts')

class Cat(Animal):
    def __init__(self, name, age):
        super().__init__(name)
        self.age = age
    def shout(self):
        print('Cat shouts')

class Dog(Animal):
    def shout(self):
        print('Dog shouts')

d = Dog('wangcai')
d.shout() # Dog shouts

c = Cat('hauhua', 3)
c.shout() # Cat shouts

以上代码展示了多态的概念。

封装

封装概述

将数据和操作组织到类中（属性和方法）；
将数据隐藏起来，给使用者提供操作（方法）。使用者通过操作就可以获取或者修改数据（getter和setter）；
通过访问控制，暴露适当的数据和操作给用户，该隐藏的隐藏起来（私有成员或保护成员）。

Python 类定义语法

在Python中，定义一个类的语法非常简洁和直观。下面是一个基本的类定义的语法：

class ClassName:
    def __init__(self, parameter1, parameter2, ...): # 初始化方法（构造函数），用于创建类的实例并初始化属性
        self.parameter1 = parameter1
        self.parameter2 = parameter2
        ...

    def method1(self, arg1, arg2, ...):
        # 类的方法定义
        # 方法体
        ...

    def method2(self, arg1, arg2, ...):
        # 另一个方法定义
        # 方法体
        ...

class关键字用于定义一个类。
ClassName是类的名称，通常采用驼峰命名法（大驼峰，每个单词的首字母大写）。
类的属性和方法定义在类的缩进块中。
__init__()方法是一个特殊的方法，称为构造函数，用于初始化类的对象。这个方法在创建类的实例时自动调用。
self参数：在类的方法中，第一个参数通常被命名为self，它表示类的实例本身，可以用来访问和操作类的属性和方法。
- self是一个指向对象本身的引用，用于访问对象的属性和方法。
- 类的方法定义与普通函数定义类似，但是第一个参数必须是self，用于表示对象本身。
- 在类的方法中，可以通过self来访问对象的属性和调用其他方法。

类的属性和方法

属性类似于对象的变量，它们用于存储对象的状态信息。
方法则类似于函数，它们定义在类中并且可以访问对象的属性，用于实现对象的行为或操作。
属性和方法都可以通过点运算符来访问。属性通常用于描述对象的特征或状态，而方法则用于实现对象的行为或操作。

_init_ 方法

__init__ 方法是Python类中的一个特殊方法，用于初始化新创建的对象。当你实例化一个类时，__init__ 方法会被自动调用，用于执行一些对象的初始化操作。

下面是关于 __init__ 方法的一些详解：

命名和双下划线：__init__ 是一个特殊的方法，其名称前后都有双下划线。这是Python中约定的一种命名方式，表示这是一个特殊用途的方法。
初始化参数：__init__ 方法的第一个参数通常是 self，它代表要初始化的对象自身。除了 self 参数之外，你可以在 __init__ 方法中定义其他参数，这些参数用于传递初始化对象时所需的信息。
对象属性的初始化：__init__ 方法通常用于初始化对象的属性。在方法内部，你可以通过 self 来访问对象的属性，并对其进行赋值。

继承

继承概述

可以通过继承来创建一个新类（子类），该类继承了另一个类（父类）的属性和方法，并可以在其基础上进行扩展或修改。
例如：猫类和狗类可以继承自动物类，动物类是父类，猫类和狗类是子类；
从父类继承，就可以直接拥有父类的属性和方法。这样可以减少代码量，多复用。子类也可以定义自己的属性和方法。
继承通过在类定义时将父类的名称放在子类名称后面的括号中来实现

继承的用途：在子类上实现对基类的增强，实现多态

以下是一个简单的示例，演示了如何在Python中使用继承：

## 定义一个父类
class Animal:
    def __init__(self, name):
        self.name = name
    
    def speak(self):
        print(f"{self.name} makes a sound.")

## 定义一个子类，继承自Animal
class Dog(Animal):
    def speak(self):
        print(f"{self.name} says Woof!")

## 定义另一个子类，也继承自Animal
class Cat(Animal):
    def speak(self):
        print(f"{self.name} says Meow!")

## 创建父类对象
animal = Animal("Generic Animal")
animal.speak()

## 创建子类对象
dog = Dog("Buddy")
dog.speak()

cat = Cat("Whiskers")
cat.speak()

在这个示例中，我们定义了一个名为Animal的父类，它具有一个名为speak()的方法。然后我们定义了两个子类Dog和Cat，它们分别继承了Animal类，并且重写了speak()方法以表达不同的声音。最后，我们创建了父类和子类的对象，并调用它们的speak()方法。

继承使得代码更加模块化、可重用和易于维护，因为它允许您在不重复编写相似代码的情况下创建新的类，并且可以根据需要对继承的行为进行定制化修改。

根基类 object

在 Python3 中，所有的类都是继承自一个名为object的基类。object是Python中所有类的顶级基类，它定义了一些基本的行为和方法，所有其他类都直接或间接地继承了这些特性。尽管在定义类时通常不需要显式地指定继承自object，但如果不继承其他类，Python会默认将其视为继承自object。

object类提供了一些常用的方法和属性，包括：

__init__(self[, ...]): 初始化方法，用于创建对象并设置初始状态。
__new__(cls[, ...]): 用于创建对象的实例，通常情况下不需要重写它。
__del__(self): 对象销毁时调用的方法，在对象被垃圾回收之前执行清理工作。
__repr__(self): 返回对象的“官方”字符串表示，通常用于调试和日志记录。
__str__(self): 返回对象的“非官方”字符串表示，通常用于用户友好的输出。
__eq__(self, other): 定义对象之间的相等性比较。
__hash__(self): 返回对象的哈希值，通常与__eq__一起使用。
__getattr__(self, name): 获取对象的属性，当属性不存在时调用。
__setattr__(self, name, value): 设置对象的属性，当属性被赋值时调用。
__delattr__(self, name): 删除对象的属性，当属性被删除时调用。

除了上述方法之外，object类还定义了一些特殊的方法，用于支持对象的比较、布尔测试、迭代等功能。通过继承自object，所有的Python类都具有这些方法的默认实现。

面向对象练习题

随机数生成类

要求：

可指定生成数字的个数、生成的数值范围；
运行时还可以调整每批生成数字的个数。

方法1

import random

class NumberGenerator:
    def __init__(self, num_count=1, range_min=0, range_max=100):
        self.num_count = num_count
        self.range_min = range_min
        self.range_max = range_max

    def generate_numbers(self):
        return [random.randint(self.range_min, self.range_max) for _ in range(self.num_count)]

    def set_num_count(self, num_count):
        self.num_count = num_count

    def set_range(self, range_min, range_max):
        self.range_min = range_min
        self.range_max = range_max

## 示例用法
## 创建一个生成器对象
generator = NumberGenerator()

## 生成默认数量的数字
print("Generated numbers:", generator.generate_numbers())

## 设置新的数字个数
generator.set_num_count(3)

## 生成新的数字
print("Generated numbers:", generator.generate_numbers())

## 设置新的数字范围
generator.set_range(10, 50)

## 生成新的数字
print("Generated numbers:", generator.generate_numbers())

这个类名为 NumberGenerator，你可以根据需要初始化时指定生成的数字个数和范围，也可以随时调整生成的数字个数。使用 generate_numbers 方法可以生成指定数量的随机整数列表，使用 set_num_count 和 set_range 方法可以在运行时修改生成的数字个数和范围。

方法2（推荐）

普通类实现，这种实现适合用每一个实例来保存各自的数值范围，互不干扰。

import random
class RandomGen:
    def __init__(self, start=1, end=100, count=10):
        self.start = start
        self.end = end
        self.count = count
    def generate(self):
        return [random.randint(self.start, self.end) for _ in range(self.count)]

rg1 = RandomGen()
print(rg1.generate())

rg2 = RandomGen(1, 10000, 3)
print(rg2.generate())

方法3（推荐）

作为工具类来实现，提供类方法。不需要记录用过的值，只需要调用一次给结果就好。

元编程

元编程概述

一般写程序就是直接写代码，能否用代码生成所需的代码？例如，写了一个类 class A，能否用代码生成一个类出来？

用来生成代码的程序称为元程序 metaprogram，编写这种程序就称为元编程 metaprogramming。

python能通过反射实现元编程。在python中：

所有非object类都继承自object类；
- 在 Python 中，所有的类都可以追溯到 object 类，这意味着 object 类是所有类的基类。这种继承关系意味着所有类都继承了 object 类的属性和方法。
所有类的类型包括type类都是type；
- 在 Python 中，类本身也是对象，它们的类型是 type。这包括了普通的类以及 type 类本身。
type类继承自object类，object类的类型也是type类。
- 这意味着 type 类本身也是一个对象，它继承了 object 类的属性和方法。同时，object 类的类型也是 type 类，因为 object 类是一个类，而类的类型是 type。

这些概念在元编程中非常重要，因为它们揭示了类和对象之间的关系，以及如何使用反射和元编程技术来操作类和对象。

—

Python中的元编程是指在运行时创建或修改Python代码的能力。这种技术允许程序在运行时动态地生成类、函数、方法和模块，或者在运行时修改它们的行为。元编程通常用于创建通用框架、装饰器、插件系统等。

Python提供了几种元编程的机制，包括：

元类（Metaclasses）：元类是用于创建类的类。通过定义自己的元类，您可以控制类的创建过程。元类的 __new__ 和 __init__ 方法可以用来拦截类的创建过程，并且允许您在类创建时进行自定义操作。
装饰器（Decorators）：装饰器是用于修改函数、方法或类的行为的函数。它们允许您在不修改原始对象的情况下，动态地添加额外的功能。装饰器是Python元编程中常用的技术之一，用于实现日志记录、性能分析、权限检查等功能。
类装饰器（Class Decorators）：类装饰器是用于修改类行为的装饰器。它们允许您在类定义时对类进行修改或增强。类装饰器可以用于实现单例模式、缓存类实例等功能。
元编程模块（Metaprogramming modules）：Python标准库中的一些模块提供了元编程的支持，如 inspect 模块用于检查对象的属性和源代码，ast 模块用于操作抽象语法树（AST），types 模块用于动态创建新类型等。
动态属性和方法：Python允许在运行时动态地添加、修改或删除对象的属性和方法。这种灵活性使得在运行时根据需要动态地修改对象成为可能，这对于某些特定的应用场景非常有用。

元编程是Python中非常强大且灵活的一部分，但也需要谨慎使用，因为它可以使代码更加复杂和难以理解。优秀的元编程代码应该具有清晰的文档和易于理解的设计。

元编程通常与面向对象编程（Object-Oriented Programming，OOP）概念相关联，因为它涉及到在运行时创建、修改或操作类、对象和其行为。

在面向对象编程中，类是对象的蓝图，它定义了对象的属性和方法。元编程提供了一种在程序运行时动态创建、修改或扩展这些类和对象的能力，从而增强了面向对象编程的灵活性和可扩展性。

通过元编程，您可以在运行时创建新的类，添加新的方法或属性，或者修改现有类的行为，而无需在代码编写阶段静态定义它们。这使得代码可以更具动态性，并且可以根据需要进行自我适应或扩展。因此，尽管元编程是一个独立的概念，但通常与面向对象编程一起使用，以提供更灵活和强大的编程范式。

type 类

type是元类，是构造其他类的类。