Python面向对象浅析

目录

面向对象基本概念

一、类和对象

类和对象是面向对象骗程的两个核心概念。

在程序开发中，要设计一个类，通常需要满足一下三个要素:

self详解：

对象（Object）

魔法方法：

类里的一些特殊方法

__init__和__del__方法：

repr__和__str

运算符的相关魔法方法:

__eq__方法

类属性和对象属性

简单理解：类属性是整个类共有的属性，对象属性是每个对象实例的属性，类属性的值每个对象都一样，而对象属性的值每个对象各不相同。

私有属性和方法

获取私有属性的方法：

静态方法和类方法：

静态方法和类方法均可通过实例和类调用

单例模式

二、封装（Encapsulation）

三、继承（Inheritance）

父类中的私有方法和私有属性

四、多态（Polymorphism）

五、总结

---

面向对象基本概念

在编程领域，面向对象编程（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=xself.age=ydef 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=nameself.age=agedef __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=nameself.age=agedef __del__(self):#当对象被销毁时会自动调用这个方法print('__del__方法被调用了')def __repr__(self):return 'repr'+self.name+' '+self.agedef __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_方法，获取这个方法的比较结果
__eq___如果不重写，默认比较依然是内存地址

class Person(object):def __init__(self,name,age):#在创建对象时，会自动调用这个方法self.name=nameself.age=agedef __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=nameself.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=nameself.age=age#如果一个方法里没有用到对象属性和类属性则可定义为静态方法@staticmethoddef demo():print('hello')#类方法有一个参数cls，无需手动传参，指的是类对象，当前类中 cls is Person@classmethoddef 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@classmethoddef __new__(cls,*args,**kwargs):if cls.__instance is None:cls.__instance=object.__new__(cls)return cls.__instancedef __init__(self,a,b):if self.__is_first:self.a=aself.b=bself.__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=namedef 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=nameself.__age=agedef __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