python-面向对象

Conan-Doyle

已于 2022-11-23 17:20:46 修改

阅读量379

点赞数

文章标签： python 开发语言

于 2022-11-22 18:08:22 首次发布

本文链接：https://blog.csdn.net/2201_75373590/article/details/127986813

版权

本文详细介绍了Python的面向对象编程，包括类和对象的概念、类的内置成员、装饰器函数、类相关函数、继承（单继承和多继承）、多态以及类方法与静态方法。通过实例解析了如何创建类、使用魔术方法、实现继承与多态，帮助读者深入理解Python的面向对象特性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

面向对象：

面向对象是相对于面向过程而言的、它是一种理解。面向过程编程主要是分析实现需求需要的步骤。面向对象编程则是分析需求，对这些需求的特征、功能、进行描述。将存在共性的事务或关系编写成类，最后通过对象的组合和调用完成需求。

类和对象：

对象是指存在的各种事务，列如汽车、动物、人类等。对象通常包含两部分信息：属性与行为。一般使用变量来描述属性，用函数方法来表示对象的行为

一、class内置成员

1、__str__ :打印对象的时候，自动触发的函数返回值只能是字符串

2、__init__：类初始化方法

3、__del__ 方法：程序执行完毕触发

# del 函数在类销毁的时候调用
class Test():
    def __init__(self):
        print("初始化")
    def __del__(self):
        print("结束后执行！！")


stu = Test()
print(stu)

触发机制：析构方法会在对象被毀时自动触发
作用：关闭一些开发的资源

注意：是对象被销毀时触发了析构方法，而不是触发析构方法销毀了对象

对象会在哪些情况下被毀：

1.当程序执行完华，内存中所有的资源都会被毀释放
2使用del删除时
3.对象没有被引用时，会自动被撤销毀

4、classname.__doc__ ：获取类中注释内容返回类型str

# del 函数在类销毁的时候调用
class Test():
    """
    asasdasdasd
    """
    def __init__(self):
        print("初始化")
    def __del__(self):
        print("结束后执行！！")


stu = Test()
print(type(Test.__doc__))

5、classname.__name__:获取类名

class Test():
    """
    asasdasdasd
    """
    def __init__(self):
        print("初始化")
    def __del__(self):
        print("结束后执行！！")


stu = Test()
print(type(Test.__doc__))
print(Test.__name__)

二、class内置装饰器函数（property，setter，deleter）

1、@property(用于场景方法不要传递参数且有return可以使用就是普通函数)

"""
函数的作用是在新式类中返回属性值。  把方法伪装成属性了
"""
from  math import pi
# property() 函数的作用是在新式类中返回属性值。  把方法伪装成属性了
class Circle:
    def __init__(self, r):
        self.r = r

    @property                           # @property 把方法伪装成属性了
    def per(self):  # 周长               使用  @property  伪装成属性 不能单参数
        return 2 * pi * self.r

    @property
    def aer(self):  # 面积
        return self.r ** 2 * pi
aa = Circle(3)
print(aa.per)              # @property 把方法伪装成属性了  调用了  但是不能 传递任何参数
print(aa.aer)

2、@setter 设置属性

class Pers(object):
    def __init__(self,name):
         self.__name=name
    @property                      #  有了@property  里面的方法名可以一样
    def aa(self):
        return  self.__name+'----啊哈哈哈哈哈'

    @aa.setter             #       @aa.setter  修改
    def aa(self,new_name):
           self.__name = new_name
f=Pers("王五")

print(f.aa)     #  使用@property  修改里面的方
f.aa='王六'
print(f.aa)
----------------------result-------------------------------
王五----啊哈哈哈哈哈
王六----啊哈哈哈哈哈

3、@deleter 删除属性

class A(object):  # 要求继承object
    def __init__(self):
        self.__name = None

    # 下面开始定义属性，3个函数的名字要一样！
    @property  # 读
    def name(self):
        return self.__name

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

    @name.deleter  # 删除
    def name(self):
        del self.__name


a = A()
print(a.name)  # 读
a.name = 'python'  # 写
print(a.name)  # 读
del a.name  # 删除
# print a.name # a.name已经没有这个name属性了
print(a.name)

三、类相关函数

1、关键字【is】：判断两个对象知否指向同一块内存地

class a():
    pass

a_1=a()
a_2=a()
print(a_1 is a_2)


--------------------result------------------------
false

2、isinstance(obj,类)：判断obj是不是类的对象，或者判断obj是不是该类子类的对象返回bool类型值

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age


class Student(Person):
    def __init__(self, name, age, score):
        super(Student, self).__init__(name, age)
        self.score = score


class Dog:
    def __init__(self, name, color):
        self.name = name
        self.color = color


p = Person('tony', 18)
s = Student('jack', 20, 90)
d = Dog('旺财', '白色')

print(isinstance(p, Person))  # >> True    对象p是由Person类创建出来的
print(isinstance(s, Person))  # >> True    对象s是有Person类的子类创建出来的
print(isinstance(d, Person))  # >> False   对象d和Person类没有关系

3、issubclass(a,b)：判断是否是某个类的子孙类

class Top(object):
    pass
 
 
class Base(Top):
    pass
 
 
class Foo(Base):
    pass
 
 
print(issubclass(Foo, Base))  # True
print(issubclass(Foo, Top))   # True

四、python的继承

python支持单继承和多继承，这种继承机制极大的提高了代码的复用性，使得子类可以继承父类和祖类的方法以及属性，这就是继承，同时，子类也可以重写父类和祖类的某个方法或者属性，从而使得子类可以获得与父类和祖类不一样的行为，这就是多态。

继承的意义:

提高代的重用性，建立新的类与类的关系，方便其它辑的操作

继承语法：

class 父类():
    pass
class 子类(父类):
    pass

继承的特征：
        在不指定承的父类时，所有类都承自objects 类（系统提供）了解
        子类继承了父类后，就拥有了父类中的所有成员包括魔术方法（除了私有成员）
        子类继承父类后，并不会把父类的成员复制给子类，而去引用
        子类继承父类后可以重写父中的方法，叫做重写
        子类重写父类的方法，依然可以使用super().父类方法名()的方式调用父类的方法
        子类中如果定义了父类不存在的方法，称对父类的扩展

1、单继承（子类只继承一个父类）

阿凯老师傅在忍者界摸爬滚打几十年，拥有一身精湛的武功，

并总结了一套"武功绝学"。可是老师傅年迈已久，

在嗝屁之前希望把自己的技能传承下去，于是老师傅把技能传给他的徒弟小李...

class TeacherKai():
    """
    创建阿凯类并创建方法 ko 进行开启毕生绝学奇门遁甲

    """
    def __init__(self):
       self.skill="奇门遁甲"
    def ko(self):
       print(f"使用毕生绝学{self.skill}！")

class StudentLi(TeacherKai):
    """
    StudentLi 继承 TeacherKai  
    所有可以使用 TeacherKai的属性与方法
    """
    pass



if __name__ == '__main__':
     阿凯=TeacherKai()
     print(阿凯.skill)
     阿凯.ko()
     print("*"*30)
     小李=StudentLi()
     print(小李.skill)
     小李.ko()

小李继承阿凯的绝学后

奇门遁甲
使用毕生绝学奇门遁甲！
******************************
奇门遁甲
使用毕生绝学奇门遁甲！

2、多继承

小李掌握了凯老师的配方，可以使用奇门遁甲，

但是小李是个爱学习的好孩子，他希望学到更多技能，

于是通过百度搜索，找到了一家新西方培训学校。

class TeacherKai():
    """
    创建阿凯类并创建方法 ko 进行开启毕生绝学奇门遁甲

    """
    def __init__(self):
       self.skill="奇门遁甲"
    def kaiko(self):
       print(f"使用毕生绝学{self.skill}！")


class NinjaSchool():
    def __init__(self):
        self.skill="螺旋丸"


    def schoolko(self):
        print(f"使用学院绝学{self.skill}")

class StudentLi(NinjaSchool,TeacherKai):
    """
    StudentLi 继承 TeacherKai
    所有可以使用 TeacherKai的属性与方法
    """
    pass



if __name__ == '__main__':

     小李=StudentLi()
     print(小李.skill)
     小李.kaiko()
     小李.schoolko()

五、多态

1、普通多态

#定义电脑类
class computer():
    #定义接口方法
    def usb(self,obj):
        obj.start()
#定义鼠标类
class mouse():
    def start(self):
        print("鼠标启动")
#定义键盘类
class keyboard():
    def start(self):
        print("键盘启动")
#定义U盘类
class udisk():
    def start(self):
        print("U盘启动")
#实例化对象
c = computer()
m = mouse()
k = keyboard()
u = udisk()
#把不同的设备连接到电脑的usb接口
c.usb(m)
c.usb(k)
c.usb(u)

2、多态继承

class usb():
    '''
    当前定义一个接口规范类,需要子类继承并实现start方法
    start方法不做任何具体功能的实现
    '''
    def start(self):
        pass
#定义鼠标类
class mouse(usb):
    def start(self):
        print("鼠标启动")
#定义键盘类
class keyboard(usb):
    def start(self):
        print("键盘启动")
#定义U盘类
class udisk(usb):
    def start(self):
        print("U盘启动")
#实例化对象
m = mouse()
k = keyboard()
u = udisk()
#把不同的设备连接到电脑的usb接口
m.start()
k.start()
u.start()

六：类方法与静态方法

1、类方法(classmethod)

类方法是从属于“类对象”的方法。类方法通过装饰器@classmethod来定义，格式如下:

@classmethod
def  类方法名(cls  [，形参列表]) ：
    方法体

注意：

@classmethod必须位于方法上面一行
第一个cls必须有；cls指的就是“类对象”本身
调用类方法格式：类名.类方法名(参数列表)。参数列表中，不需要也不能给cls传值
类方法中访问实例属性和实例方法会导致错误
子类继承父类方法时，传入cls是子类对象，而非父类对象

示例：

class Student:
    company = "111"     #类属性
    
    @classmethod
    def printCompany(cls):
        print(cls.company)   # 打印类属性
    
8Student.printCompany()   # 调用类方法

2、静态方法(staticmethod)
Python中允许定义与“类对象”无关的方法，称为“静态方法”。

“静态方法”和在模块中定义普通函数没有区别，只不过“静态方法”放到了“类的名字空间里面”，需要通过“类调用”。

静态方法通过装饰器@staticmethod来定义，格式如下：

@staticmethod
def  静态方法名([形参列表]) ：
    方法体

注意：

@staticmethod必须位于方法上面一行
调用静态方法格式：类名.静态方法名(参数列表)
静态方法中访问实例属性和实例方法会导致错误

class Student:
    company = "111"  # 类属性

    @staticmethod
    def add(a, b):  # 静态方法
        print("{0}+{1}={2}".format(a,b,(a+b)))
        return a+b

Student.add(20,30)