Python面向对象浅析

猛新萌新oo

于 2024-07-30 20:57:29 发布

阅读量901

点赞数 26

分类专栏： python学习文章标签： python 开发语言

本文链接：https://blog.csdn.net/dudnf/article/details/140806061

版权

python学习专栏收录该内容

12 篇文章 0 订阅

订阅专栏

面向对象基本概念

一、类和对象

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

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

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

面向对象基本概念

在编程领域，面向对象编程（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_方法，获取这个方法的比较结果
__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

猛新萌新oo

关注

26
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
Python面向对象浅析

面向对象编程为Python开发者提供了一种强大而灵活的方式来构建和维护复杂的软件系统。通过类、对象、封装、继承和多态等核心概念，开发者能够创建出高度模块化和可重用的代码，从而提高开发效率和软件质量。希望本文能够帮助到大家更好地理解和应用Python的面向对象编程。
复制链接

扫一扫