python面向对象大全解

Python面向对象编程（OOP）是一种编程范式，它基于“对象”概念来组织软件设计。在Python中，面向对象编程提供了丰富的特性和工具，以支持复杂系统的构建和维护。

一、面向对象的基本概念

1. 对象（Object）：

   • 对象是现实世界中某个具体的物理实体或概念的逻辑表示。在Python中，对象具有状态（属性）和行为（方法）。
   • 例如，一个“狗”对象可能具有“名字”、“年龄”等属性，以及“叫”、“跑”等方法。

2. 类（Class）：

   • 类是创建对象的模板或蓝图，它定义了对象的状态（属性）和行为（方法）。
   • 类是一种抽象数据类型，用于表示具有相同属性和方法的对象的集合。

3. 属性（Attribute）：

   • 属性是类或对象所拥有的数据。在Python中，属性可以是类变量或实例变量。
   • 类变量是定义在类中的所有对象共享的变量；实例变量则是每个对象独有的变量。

4. 方法（Method）：

   • 方法是定义在类中的函数，用于执行与对象相关的操作。
   • 方法可以访问和修改对象的属性。

二、面向对象的三大特性

1. 封装（Encapsulation）：

   • 封装是将对象的属性和方法结合成一个独立的单元，并尽可能隐藏对象的内部细节和复杂性。
   • 封装提高了代码的安全性和可维护性。

2. 继承（Inheritance）：

   • 继承允许我们定义一个类（子类）来继承另一个类（父类）的属性和方法。
   • 继承是实现代码复用的重要手段，它支持类的层次结构和多态性。

3. 多态（Polymorphism）：

   • 多态性指的是同一操作作用于不同的对象时，可以有不同的行为。
   • 多态性提高了程序的灵活性和可扩展性。

三、抽象类

• 一个特殊的类

  • 内部可以编写抽象方法

  • 抽象类不能直接实例化

  • 也可以编写普通实例方法

• 子类继承抽象类

  • 必须实现抽象类的抽象方法

# 抽象类：不直接实例化， 通过子类来产生实例
from abc import ABC, abstractmethod

class MyClass(ABC):
    # 抽象类: 拥有抽象方法，不能直接实例化
    # 通过装饰器abstractmethod变为抽象方法
    @abstractmethod
    def get_name(self,name):
        self.name = name

    def get_age(self,age):
        self.age = age


#无法实例化，会报错，无法执行
# mc = MyClass()
# print(mc)


class MyFun(MyClass):
    def get_age(self,age):
        self.age = age

    #必须实现父类的所有抽象方法才可以实例化
    def get_name(self,name):
        self.name = name

my = MyFun()
print(my)

四、类中内容

• 实例属性

• 实例方法

• 类属性

• 类方法

• 静态方法

class MyClass:
    #类属性instance
    instance = 100
    def __init__(self,name):
        #实例属性，向实例中添加的属性
        self.name = name

    #实例方法
    def get_name(self):
        # 第一个形参是self 则他是实例方法
        return self.name

    def set_name(self, name):
        # 第一个形参是self 则他是实例方法
        self.name = name

    #类方法
    @classmethod
    def info(cls):
        # 使用装饰器classmethod 将方法变为类方法
        print(cls.__name__, cls.__bases__, cls.__doc__)


    #静态方法
    @staticmethod
    def status():
        return "静态方法"

mc = MyClass("可莉")
print(mc.info)#输出<bound method MyClass.info of <class '__main__.MyClass'>>

print(mc.status())#输出静态方法

print(mc.instance)#输出100

print(mc.name)#输出可莉
mc.set_name("纳西妲")
print(mc.get_name())#输出纳西妲

五、数据的访问类型

• 公有类型

#共有数据访问
class MyClass:
    def __init__(self,name):
        self.name = name
    #类内调用
    def get_name(self):
        return self.name

    def set_name(self,name):
        self.name = name

mc = MyClass("可莉")
#类外调用
print(mc.name)#输出可莉
mc.set_name("夜兰")
print(mc.name)#输出夜兰


#子类调用
class Myfun(MyClass):
    def __init__(self,name):
        super().__init__(name)
    def __str__(self):
        return self.name


my = Myfun("刘备")
print(my.name)#输出刘备

• 私有类型

# 私有数据访问
class MyClass:
    def __init__(self,name):
        self.__name = name
    #类内调用
    def get_name(self):
        return self.__name

    def set_name(self,name):
        self.__name = name


# mc = MyClass("可莉")
# print(mc.__name)#报错，所以类外不可调用

#子类调用
class Myfun(MyClass):
    def __init__(self,name):
        super().__init__(name)
    def __str__(self):
        return self.__name


# my = Myfun("刘备")
# print(my.name)#错误，所以子类不可调用

• 保护类型

# 保护数据类型访问
class MyClass:
    def __init__(self, name):
        self._name = name

    # 类内调用
    def get_name(self):
        return self._name

    def set_name(self, name):
        self._name = name


mc = MyClass("可莉")
print(mc._name)#输出可莉


# 类外调用
# print(mc.name)#类外不可访问

# 子类调用
class Myfun(MyClass):
    def __init__(self, name):
        super().__init__(name)

    def __str__(self):
        return self._name


my = Myfun("刘备")
print(my)#输出刘备
print(my._name)#子类可调用，#输出刘备

六、属性封装

class MyClass:
    def __init__(self, name):
        self.__name = name

    @property
    def name(self):
        return self.__name

    @name.setter
    def name(self, name):
        self.__name = name


mc = MyClass("小名")

print(mc.name)#输出小名
mc.name = "小花"
print(mc.name)#输出小花

七、单例类

class MyClass:
    instance = None

    def __new__(cls, *args, **kwargs):
        if not MyClass.instance:  # 真,MyClass.instance为空
            MyClass.instance = super().__new__(cls)

        return MyClass.instance

    def __init__(self):
        print("初始化")


mc1 = MyClass()#输出初始化
mc2 = MyClass()#输出初始化
print(mc1)
print(mc2)
print(mc1 is mc2, mc1 is None, mc2 is None)#输出True False False


class MyFun:
    def __new__(cls, *args, **kwargs):
        if not hasattr(MyFun, "instance"):#"instance"不存在
            obj = super().__new__(cls)
            setattr(MyFun, "instance", obj)#建立"instance"，并赋值obj

        return getattr(MyFun, "instance")#返回"instance"的obj


mf1 = MyFun()
mf2 = MyFun()
print(mf1)
print(mf2)
print(mf1 is mf2, mf1 is None, mf2 is None)#输出True False False