一、面向对象

面向对象编程（Object-Oriented Programming，简称OOP）是一种编程范式，它使用“对象”来设计应用程序和计算机程序。它利用了抽象、封装、继承和多态这些概念。

一、面向对象编程的核心概念

封装（Encapsulation）
封装是面向对象编程的一个主要特征，它将对象的数据（属性）和操作这些数据的方法（行为）结合在一起，形成一个独立的对象。这样做的好处是可以隐藏内部的复杂性，只暴露有限的接口给外部使用。在python中，通常通过设置成员变量为私有（双下划线）来实现封装，并提供公共的方法来访问和修改这些变量。
继承（Inheritance）
继承允许新创建的类（子类）继承现有类（父类）的属性和方法。这意味着可以在现有类的基础上构建新的类，从而重用和扩展现有代码。在pthon中，继承是通过类名后的小括号来实现的。
多态（Polymorphism）
多态性是指允许不同类的对象对同一消息作出响应的能力。简单来说，就是允许使用父类类型的引用指向子类的对象。这样，同一个接口可以用来调用不同的实现方法，这些方法可能属于不同的类。

二、面向对象编程的优势

提高代码的重用性：通过继承机制，可以使用现有的代码作为基础，然后通过扩展来实现特定的功能。
提高代码的可维护性：封装使得代码更加容易理解和维护，因为可以独立地修改对象内部的实现，而不影响使用它的代码。
实现代码的可扩展性：面向对象编程提供了框架，使得程序可以在不修改原有代码的基础上增加新的功能。

二、类与对象

1.概念

对象：在我们之前的学习中遇到的一切都是对象，包括不限于字符串，列表，甚至是1，2，3这样的数值，可以说一切的python代码都是有一个个对象构成的。对象就是python的基本单位。

类：类是同种对象的聚合体。类将对象包装起来，每种类都有其自己的独特共性。譬如：1，2，3这样的数值类，他们可进行各种运算。也就是说类也是一种对象

2.类的定义与实例化对象

那么，我们该如何创建属于自己的类呢？

与函数类似，我们用类的关键字声明类，并在后面加上小括号，写入诺干个继承对象。

class my_class(objection):
    pass

这样我们就创建好自己的类了

我们还可以在其中写入种种，来丰富我们的类。

我们创建好类之后该怎样使用吗

还记得我们我们是如何输入值给列表的吗

 ls = [1,2,3]
 ls.append(4)

根据此我们使用我们的类的使用方法也就明晰了

class my_class(object):
    pass

i = my_class()

至此，我们创建类，并完成类的实例化

3.访问属性和方法

类中可以编写许多属性，与方法。如果我们想使用他们时该如何做的。

想想之前的列表是如何添加元素，我们也要进行类似的操作

class my_class(object):
    f_1 = '属性1'
    def fun_1(self):
        return "方法一"

i = my_class()
print(i.f_1)
print(i.fun_1())

类内部与变量类似的部分称之属性，与函数类似的部分称之为方法

4.类与对象关系 

通过上面介绍我们得知了类与对象的关系

1. 对象拥有类的所有属性和方法
2. 对象的属性和方法可以单独添加、删除、修改
3. 对象与对象之间的属性和方法不可共享
4. 对象不能独自创建，必须依托于类，类可以实例化N个对象

 5.魔方方法

与赋值类似，为了方便使用类，我们可以使用一种叫魔方方法的方式来改写我们的类

1. __init__ 构造函数：完成对象的初始化工作，方便统一管理、调用类创建对象时，自动执行。
2. __del__ 析构函数：删除对象时执行一些操作，自动执行。
3. __str__ 打印方法：输出执行信息，自动执行。

   class my_class(object):
       def __init__(self):
           print("类的创建")
       def __str__(self):
           return "我是一返回"
       def __del__(self):
           print("我的出现表明类结束了")
   
   i = my_class()
   print(i)

当然，魔方方法不止这些，他们出现往往伴随着两端的双下划线

6.属性与方法

通过之前的介绍，我们明白了什么是属性什么是方法。我们发现我们平时使用的类中，他们并不是老老实实地呆在一起，那么为什么会这样。我们接下来就要介绍他们的不同

class Student(object):
    school = "10023"
    def __init__(self,n):
        self.id = n

    @classmethod
    def show_info(cls):
        print(f"学校id：{cls.school}")

    def show_id(self):
        print(f"学生id:{self.id}")

    @staticmethod
    def show_none():
        print("我是与世无争的静态方法")

s1 = Student("张三")
s1.show_id()
Student.show_info()
s1.show_none()

 7.函数内置类方法

• __dict__ : 类的属性（包含一个字典，由类的数据属性组成）
• __doc__ :类的文档字符串
• __name__: 类名
• __module__: 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod）
• __bases__ : 类的所有父类构成元素（包含了一个由所有父类组成的元组）

三、封装

接下来，我们开始介绍类的三大特性

封装是类的三大特性之一。
封装指的是隐藏对象中一些不希望让外部所访问的属性或方法。
python中封装其实是通过设置访问权限来体现的，私有属性和私有方法是控制访问权限的组成部分。

 私有属性与私有方法

在类的内部使用，不希望外部直接访问的变量。以此达到保护的目的在python中，使用双下划线作为前缀来定义私有属性。私有属性在类外不能访问

 与私有属性类似，方法也用于同样的是由规则。为了使用它们我们专门设置开口，用来输入输出私有属性与方法

class Car(object):
    def __init__(self,name,color):
        self.__name = name
        self.__color = color

    def __show(self):
        return f"那辆{self.__name}是{self.__color}"

    def show(self):
        return self.__show()

    def color(self):
        return self.__color
i = Car('玛莎拉蒂','红色的')
print(i.color())
print(i.show())

属性装饰器 

 我们在写完发现每次使用类内的属性都需要加上小括号，既然变量能直接赋值，我们能否有方法更直接使用这些属性。这时候就到属性装饰器登场了

属性装饰器是实现把方法转为属性的装饰器。

作用：

1. 把方法转为属性，便于操作属性
2. 实现对属性的更改（验证）、查看、删除

   class 类名(object):
       def __init__(self):
           self.__名字 = xxx
       
       @property
       def 函数名(self):
           return self.__名字
       
       @函数名.setter
       def 函数名(self, m):
           self.__名字 += m

class Car(object):
    def __init__(self,name,color):
        self.__name = name
        self.__color = color

    def __show(self):
        return f"那辆{self.__name}是{self.__color}"

    def show(self):
        return self.__show()

    @property
    def color(self):
        return self.__color

    @color.setter
    def color(self,n):
        self.__color = n
i = Car('玛莎拉蒂','红色的')
print(i.color)
print(i.show())
i.color = '白色的'
print(i.color)

 

四、继承

 面向对象的编程带来的主要好处之一就是代码的重用，实现这种重用的方法之一就是通过继承机制。
通过继承创建的新类称之为【子类】或者【派生类】，被继承的类称之为【父类】、【基类】、【超类】

简单来说，我们可以通过子类来访问父类的属性和方法

class A(object):
    def __init__(self,x,y):
        self.x = x
        self.y = y

    def __str__(self):
        return f"{self.y} and {self.x}"

class B(A):
    pass
b =B(1,2)
print(b)

 我们实际需求中，面对的问题往往仅仅依靠父类是解决不了的，我们还需要一些自己的办法。

此时就需要我们，重写方法

class A(object):
    def __init__(self,x,y):
        self.x = x
        self.y = y

    def my_add(self):
        return self.x+self.y


class B(A):
    def __init__(self,x,y,z):
        super().__init__(x,y)
        self.z = z
    def my_add(self):
        return super().my_add() + self.z
b =B(1,2,3)
print(b.my_add())

五、多态性

就像谚语中说的，老鼠的孩子会打洞，继承的子类多多少少会拥有父类的方法和属性。也会有龙有九子，各不相同。根据实际需求，不同子类继承同个父类的同个方法也会出现不同的结果

class Animals(object):
    def __init__(self,name):
        self.name = name

    def call(self):
        return f"{self.name}在叫"

class Dog(Animals):
    def call(self):
        return super().call()+"汪汪汪"

class Cat(Animals):
    def call(self):
        return super().call() + "喵喵喵"
d = Dog('小狗')
print(d.call())
c = Cat('小猫')
print(c.call())