目录
简单理解：类属性是整个类共有的属性，对象属性是每个对象实例的属性，类属性的值每个对象都一样，而对象属性的值每个对象各不相同。
面向对象基本概念
在编程领域，面向对象编程（OOP）是一种广泛使用的编程范式，它通过创建对象来模拟现实世界中的实体及其交互。Python作为一种高级编程语言，内置了对面向对象编程的全面支持，使得开发者能够轻松构建复杂且易于维护的应用程序。本文将详细探讨Python中的面向对象编程，包括类、对象、封装、继承和多态等核心概念。
一、类和对象
类（Class）
类是对一群具有相同特征或者行为的事物的一个统称，是抽象的，不能直接使用.
类是创建对象的蓝图或模板，它定义了对象所具有的属性和方法。属性是对象的特征（如颜色、大小），而方法是对象能够执行的操作（如走、跑、叫）。
在程序开发中，要设计一个类，通常需要满足一下三个要素:
- 1.类名：这类事物的名字，按照大驼峰命名法(每个单词的首字母大写)起名。
- 2.属性：这类事物具有什么样的特征。
- 3.方法：这类事物具有什么样的行为。
class Dog:
def __init__(self, name, age):
self.name = name # 实例变量
self.age = age
def bark(self):
print(f"{self.name} is barking.")在这个例子中，Dog是一个类，它有两个实例变量name和age，以及一个方法bark。__init__方法是一个特殊的方法，被称为类的构造函数或初始化方法，当创建类的新实例时自动调用。
self详解：
哪个对象调用了方法，方法里的self 指的就是谁。通过self.属性名可以访问到这个对象的属性;通过self.方法名(）可以调用这个对象的方法。
代码举例：
class Student(object):#这里的object表示Student继承自object类
def __init__(self,x,y):
self.name=x
self.age=y
def say_hello(self):
print('大家好，我是',self.name)
#Student('张三',18)这段代码具体做了什么呢？
#1.调用__new__方法，用来申请内存空间
#2.调用__init__方法传入参数，将self指向创建好的内存空间，填充数据
#3.变量s1也指向创建好的内存空间
s1=Student('张三',18)
s1.say_hello()
s2=Student('李四',18)
s2.say_hello()
结果：
大家好，我是 张三
大家好，我是 李四
对象（Object）
对象是类的实例。通过类可以创建多个具有相同属性和方法的对象，但每个对象的属性值可能不同。
d1 = Dog("Buddy", 3)
d2 = Dog("Max", 5)
d1.bark() # 输出: Buddy is barking.
d2.bark() # 输出: Max is barking.魔法方法：
# 特点:
#1.不需要手动调用，会在合适的时机自动调用#2、这些方法，都是使用开始，使用结束#3.方法名都是系统规定好的，在合适的时机自己调用
__init__和__del__方法：
__init__创建对象时会自动调用
__del__当对象被销毁时，会自动调用这个方法
class Person(object):
def __init__(self,name,age):
#在创建对象时，会自动调用这个方法
print('__init__方法被调用了')
self.name=name
self.age=age
def __del__(self):
#当对象被销毁时会自动调用这个方法
print('__del__方法被调用了')
p=Person('张三',18)
del p
结果：
__init__方法被调用了
__del__方法被调用了
repr__和__str
当打印一个对象时，会调用这个对象的__repr__或__str__方法，如果两个方法都写了则调用__str__方法
调用repr()方法，会调用对象的__repr__方法
class Person(object):
def __init__(self,name,age):
#在创建对象时，会自动调用这个方法
print('__init__方法被调用了')
self.name=name
self.age=age
def __del__(self):
#当对象被销毁时会自动调用这个方法
print('__del__方法被调用了')
def __repr__(self):
return 'repr'+self.name+' '+self.age
def __str__(self):
return 'str'+self.name+' '+self.age
p=Person('张三','18')
print(p)
print(repr(p))
print(p.__repr__)
结果：
__init__方法被调用了
__del__方法被调用了
str张三 18
repr张三 18
<bound method Person.__repr__ of repr张三 18>
运算符的相关魔法方法:
==会调用对象的_eq_方法，获取这个方法的比较结果
__eq___如果不重写，默认比较依然是内存地址
class Person(object):
def __init__(self,name,age):
#在创建对象时，会自动调用这个方法
self.name=name
self.age=age
def __eq__(self,other):
return self.name==other.name and self.age==other.age
p1=Person('张三',18)
p2=Person('张三',18)
# p1和p2是同一个对象吗?
#怎样比较两个对象是否是同一个对象?比较的是内存地址
# is身份运算符可以用来判断两个对象是否是同一个对象
print(p1 is p2)# False
#is 比较两个对象的内存地址
# ==会调用对象的_eq_方法，获取这个方法的比较结果
nums1 = [1,2,3]
nums2 = [1,2,3]
print(nums1 is nums2)# False
print(nums1 == nums2)#True
#p1==p2本质是p1.eq(p2)获取这个方法的返回值
print(p1==p2)#true,因为在Person类中已经写了__eq__方法
结果：
False
False
True
True
__ne__方法
！=本质是调用__ne__方法或者__eq__方法取反__gt__方法
> 本质调用_ne__方法__ge__方法
> =本质调用__ge__方法…
__add__方法
+默认调用此方法__sub__方法
-默认调用此方法…
__str__方法
将对象转换为字符串时会调用此方法
打印对象时也会调用，默认是类型+内存地址
类属性和对象属性
简单理解：类属性是整个类共有的属性，对象属性是每个对象实例的属性，类属性的值每个对象都一样，而对象属性的值每个对象各不相同。
class Person(object):
type='人类'
def __init__(self,name,age):
#在创建对象时，会自动调用这个方法
self.name=name
self.age=age
#每个实例之间的属性没有关联，互不影响
p1=Person('张三',18)
p2=Person('李四',18)
#可以通过实例对象来获取类属性
print(p1.type)
print(p2.type)
p1.type='human'
print(p1.type) #并不会修改类属性，而是给实例对象增加了一个属性
#类属性只能通过类对象来修改，实例对象无法修改类属性
Person.type='monkey'# 修改了类属性
print(p2.type)
print(Person.type)
结果：
人类
人类
human
monkey
monkey
私有属性和方法
不能够通过对象.属性（方法）的形式直接调用，会报错
以两个下划线开始的变量或方法为私有的
- 1.使用 对象._类名__私有变量名获取(也适用于私有方法)
- 2.定义get和set方法来获取
- 3.使用property来获取
私有方法可以在类中的其他方法中调用：
def __demo(self):#__开头的方法为私有方法，在外部不能直接调用
print('我是私有方法')
def test(self):
self.__demo()
静态方法和类方法：
class Person(object):
type='rich'
def __init__(self,name,age):
self.name=name
self.age=age
#如果一个方法里没有用到对象属性和类属性则可定义为静态方法
@staticmethod
def demo():
print('hello')
#类方法有一个参数cls，无需手动传参，指的是类对象，当前类中 cls is Person
@classmethod
def test(cls):#
print(cls.type)
p=Person('张三',18)
#静态方法和类方法均可以通过实例对象和类对象调用
p.demo()
Person.demo()
p.test()
Person.test()
结果：
hello
hello
rich
rich
单例模式
简单理解为一个类从始至终只有一个实例对象
class Singleton:
__instance=None
__is_first=True
@classmethod
def __new__(cls,*args,**kwargs):
if cls.__instance is None:
cls.__instance=object.__new__(cls)
return cls.__instance
def __init__(self,a,b):
if self.__is_first:
self.a=a
self.b=b
self.__is_first=False
s1=Singleton('哈哈','嘿嘿嘿')
s2=Singleton('呵呵','嘻嘻嘻')
print(s1.a)
print(s2.a)
结果：
哈哈
哈哈
二、封装（Encapsulation）
封装是面向对象编程的核心思想之一，它将对象的属性和方法封装成一个整体，隐藏对象的内部实现细节，只提供有限的对外接口。在Python中，虽然可以直接访问对象的属性，但通常建议通过方法（如getter和setter）来访问和修改属性，以维护封装性。
class Dog:
def __init__(self, name, age):
self._name = name # 使用单下划线表示受保护的属性（习惯用法，Python不强制）
self._age = age
def get_name(self):
return self._name
def set_name(self, name):
self._name = name
# ... 其他方法三、继承（Inheritance）
继承允许我们定义一个类（子类）来继承另一个类（父类）的属性和方法。子类可以拥有父类的所有属性和方法，并且还可以定义自己的属性和方法。
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
raise NotImplementedError("Subclass must implement abstract method")
class Dog(Animal):
def __init__(self, name, age):
super().__init__(name) # 调用父类的__init__方法
self.age = age
def speak(self):
return f"{self.name} says Woof!"
# 使用
d = Dog("Rex", 4)
print(d.speak()) # 输出: Rex says Woof!在这个例子中，Dog类继承了Animal类，并实现了speak方法。
多继承举例：
若一个子类继承了多个父类
例：class A(B,C),即A类同时继承了B、C两个父类，则调用子类的某个方法时，先在A类里面找，若A类没有则会去B类方法里面找，若B类里面也没有，继续找B的父类，若B的祖先类里都没有则回去C里面找，C里面没有去C的父类里面找…(广度搜索下深度搜索)
class Animal(object):#Animal继承自object类
def __init__(self,name,age):
self.name=name
def sleep(self):
print(self.name+'正在睡觉')
class Dog(Animal,object):#Dog类继承自Animal类
def bark(self):
print(self.name+'正在叫')
d=Dog('小哈',3)
d.bark()
print(Dog.__mro__)
结果：
小哈正在叫
(<class '__main__.Dog'>, <class '__main__.Animal'>, <class 'object'>)
父类中的私有方法和私有属性
父类中的私有方法和属性不能继承
可以通过对象名._父类名__私有方法（或属性名进行调用）
class Animal(object):#Animal继承自object类
def __init__(self,name,age):
self.name=name
self.__age=age
def __sleep(self):
print(self.name+'正在睡觉')
class Dog(Animal):#Dog类继承自Animal类
def bark(self):
print(self.name+'正在叫')
d=Dog('小哈 ',3)
print(d._Animal__age)
d._Animal__sleep()
结果：
3
小哈 正在睡觉
四、多态（Polymorphism）
多态允许不同类的对象对同一消息作出响应。在Python中，多态是隐式实现的，因为Python是动态类型语言。你可以定义一个接受任意类型对象作为参数的函数，并在这个函数中调用这些对象的方法，而不需要关心它们的具体类型。
def make_it_speak(animal):
return animal.speak()
# 假设还有其他类，如Cat，也实现了speak方法
class Cat(Animal):
def speak(self):
return f"{self.name} says Meow!"
c = Cat("Whiskers")
print(make_it_speak(c)) # 输出: Whiskers says Meow!在这个例子中，make_it_speak函数可以接受任何具有speak方法的对象作为参数，并调用该方法。
五、总结
面向对象编程为Python开发者提供了一种强大而灵活的方式来构建和维护复杂的软件系统。通过类、对象、封装、继承和多态等核心概念，开发者能够创建出高度模块化和可重用的代码，从而提高开发效率和软件质量。希望本文能够帮助到大家更好地理解和应用Python的面向对象编程。
本文灵感来自原文链接：https://blog.csdn.net/m0_46213598/article/details/119256595