面向对象编程python

壹.面向对象编程与面向过程编程进行对比

面向过程编程

面向过程编程一般的思路为

	导入所需要的库
	写所需要的函数
	运行主函数，并且调用上述所需要的函数
	结束运行

可以发现面向过程编程是很符合我们人的思维的，即将一个大的任务拆分为每一个小的函数，通过调用函数，来解决这个大问题。
面向过程编程的优点：易懂，高效，简洁
缺点：不易维护，不易扩展，代码重用性低

面向对象编程

面向对象编程的主要思路为

	导入所需要的库
	设计全局变量
	设计所用到的类
	引用所需要的类解决问题

可以发现面向对象编程将设计的函数封装进了类中（在类中的函数称之为类的方法），通过调用类的方法，来解决问题。
优点：易于理解，简单直接
缺点：编写方式有点与人类理解不同，在一个功能中表现良好，当希望实现其他功能也需要重新编写
并且难于维护

贰.类

类的定义

类是一种抽象的数据类型。它具有特定的属性和方法，面向对象编程就是利用类来进行的。
下面是一个简单的类的例子:

# 定义了一个称之为Myclass的类(类的首字母一般大写)
class MyClass(object):
	# 类的初始化（也是一种方法），将参数传递
    def __init__(self, value):
        self.value = value
	
	# 类的方法（该方法为展现输入的值）
    def display(self):
        print("Value:", self.value)

在这个例子中，MyClass是一个类，它有两个属性：value和display。value是一个实例属性，它被定义在__init__方法中，display是一个实例方法，它被定义在类内部。
self是一个参数，表示对象自身【对象的id号】，里面存放着对象自身的地址。如果希望类中的方法可以被对象调用，第一个参数必须是self。作用是将实例对象与类的方法进行绑定，这样实例的每个对象都能调用“属于”自己的方法。传参时可以省略。

对象与类

通过运行上述代码发现，什么都没有发生。这是因为类需要实例化后才可以使用

# 类的实例化，将10作为value传递进入类（我们也可以通过obj.value来查看）
obj = MyClass(10)
# 运用了类的方法（该方法为输出self.value）
obj.display()  # 输出: Value: 10
print(obj.value)# 输出 10

1.对象拥有类的所有方法，对象的属性，方法可以单独修改
2.对象与对象之间的属性，方法都不共享
3.对象不能直接创建，需要依托与类，类可以实例化多个对象

除了用obj.value外还可以使用以下函数的方式来访问属性：

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

构造函数 与 析构函数

构造函数为__init__ ：完成对象的初始化工作，方便统一管理、调用类创建对象时，自动执行。
析构函数__del__ ：删除对象时执行一些操作，自动执行。

class MyClass:
    def __init__(self, value):
        self.value = value
	def __del__(self):
        print("对象被销毁")

obj = MyClass(10)  # 创建对象时调用__init__方法
obj = MyClass()  # 创建对象
del obj  # 销毁对象时调用__del__方法

类方法和静态方法

例子：

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}")
	# 静态方法无法接受self中的参数，只能接受方法给的
    @staticmethod
    def sta_fun():
        print(f"静态方法一般实现与类和对象无关联的操作，例如：说明书等")

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

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

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

类的继承

类可以通过继承父类，来使用父类的方法
如：

# 建立父类
class ParentClass:
    def __init__(self, value):
        self.value = value

    def display(self):
        print("Value:", self.value)
# 子类调用父类
class ChildClass(ParentClass):
    def __init__(self, value, extra_value):
        #利用super()函数传递参数
        super().__init__(value)
        self.extra_value = extra_value

    def display(self):
        super().display()
        print("Extra Value:", self.extra_value)

obj = ChildClass(10, 20)
obj.display()
# 输出 Value: 10
# Extra Value: 20

类的多态

多态是一种特性，它允许不同类的对象对同一消息做出响应。这意味着你可以使用一个接口来操作不同的对象，而不需要知道这些对象的具体类型。
如：

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

def animal_sound(animal):
    print(animal.speak())

dog = Dog()
cat = Cat()

animal_sound(dog)  # 输出: Woof!
animal_sound(cat)  # 输出: Meow!