Python-面向对象

职场小菜鸟.

已于 2023-05-22 14:58:45 修改

阅读量146

点赞数

文章标签： python 开发语言

于 2023-05-19 10:11:36 首次发布

本文链接：https://blog.csdn.net/weixin_44930323/article/details/130684152

版权

定义类：

class 类名:
语句1
语句2
...
语句n

#直接在定义类时指定该类的属性，即类属性。
class Student:
name='Unkonwn'

#对类属性的访问：可以通过类名访问，也可以通过对该类的对象访问。
类名或对象名:属性名

class Student:
    name='Unknown'
if __name__=="__main__":
    print("第1行输出：",Student.name)
    stu1=Student()
    stu2=Student()
    print("第2行输出：stu1 %s,stu1 %s"%(stu1.name,stu2.name))
    
    Student.name="未知"
    print("第3行输出：",Student.name)
    print("第4行输出：stu1 %s,stu1 %s"%(stu1.name,stu2.name))
    
    stu1.name="小红"
    stu2.name="小明"
    print("第5行输出：",Student.name)
    print("第6行输出：stu1 %s,stu1 %s"%(stu1.name,stu2.name))
    
    Student.name="学生"
    print("第7行输出：",Student.name)
    print("第8行输出：stu1 %s,stu1 %s"%(stu1.name,stu2.name))
    #在对象的属性赋过值后，对象的属性独立，不随着类的属性的变化而变化

输出结果：
第1行输出： Unknown
第2行输出：stu1 Unknown,stu1 Unknown
第3行输出： 未知
第4行输出：stu1 未知,stu1 未知
第5行输出： 未知
第6行输出：stu1 小红,stu1 小明
第7行输出： 学生
第8行输出：stu1 小红,stu1 小明

#动态添加对象的属性
class Student:
    name="Unknowm"
if __name__=='__main__':
    stu1=Student()
    stu2=Student()
    stu1.age=19  #动态绑定新的属性age
    print("stu1姓名：%s，年龄：%d"%(stu1.name,stu1.age))
    #print("stu2姓名：%s，年龄：%d"%(stu2.name,stu2.age))
    #print("类名访问年龄属性：%d"%Student.age)
    #上面备注的两条语句会报错，因为没有对应age属性

结果如下：
stu1姓名：Unknowm，年龄：19

定义类的普通方法：要求第一个参数需要对应调用方法时所使用的的实例对象，一般命名为self。调用类的普通方法时，不需要传入self参数的值，self自动对应调用该方法所使用的对象。

当使用一个实例对象调用类的普通方法时，其语法：
实例对象名.方法名(实参列表)

class Student:
    name='Unknown'
    def SetName(self,newname):
        self.name=newname
    def PrintName(self):
        print('姓名：%s'%self.name)
if __name__=='__main__':
    stu1=Student()
    stu2=Student()
    stu1.SetName('小明') #通过stu1对象调用SetName方法
    stu2.SetName('小红')
    stu1.PrintName()
    stu2.PrintName()
    
    #不能通过类名直接调用 Student.SetName() 会报错！

结果如下：
姓名：小明
姓名：小红

私有属性：指类内可以直接访问，而类外无法直接访问的属性。Python中规定，在定义类时，如果一个类属性名是以__(两个下划线)开头，则该类属性为私有属性。在类外访问该类的私有属性时，需要在私有属性前加上“_类名”

class Student:
    name='未知'
    __id='未知'
    def SetInfo(self,newname,newid):
        self.name=newname
        self.__id=newid
    def PrintInfo(self):
        print('姓名：%s，身份证号：%s'%(self.name,self.__id))
if __name__=='__main__':
    stu=Student()
    stu.SetInfo("小明","3303111111111")
    stu.PrintInfo()
    
    print("姓名：%s"%stu.name)
    #print("身份证号：%s"%stu.__id) 报错，__id是私有属性，不能在类外直接调用
    print("身份证号：%s"%stu._Student__id)  
    #在类外访问私有属性时，需在私有属性前加上“_类名”

结果如下：
姓名：小明，身份证号：3303111111111
姓名：小明
身份证号：3303111111111

类的方法本质上就是函数，类的方法可以设置默认参数值

class Student():
    name=''  #定义类属性
    __id=''
    def SetInfo(self,newname,newid='Unkonwn'):  #设置默认参数值
        self.name=newname
        self.__id=newid
    def PrintInfo(self):
        print('姓名：%s，身份证号：%s'%(self.name,self.__id))
if __name__=='__main__':
    stu=Student()
    stu.SetInfo("小明")  #可以不传newid的值，使用默认值
    stu.PrintInfo()        

结果如下：
姓名：小明，身份证号：Unkonwn

构造方法是Python类中的内置方法之一，它的方法名为__init__,在创建一个类对象时，会自动执行，负责完成新创建对象的初始化工作。

class Student:
    def __init__(self):
        print("构造方法被调用！")
        self.name='未知' #将self对应对象的name属性赋值
    def PrintInfo(self):
        print("姓名:%s"%self.name)
if __name__=='__main__':
    stu=Student()  #创建Student类对象stu，自动执行构造方法
    stu.PrintInfo() #通过stu对象调用PrintInfo方法

结果如下：
构造方法被调用！
姓名:未知

class Student:
    def __init__(self,name="未知"):
        print("构造方法被调用！")
        self.name=name #将self对应对象的name属性赋值给形参
    def PrintInfo(self):
        print("姓名:%s"%self.name)
if __name__=='__main__':
    stu1=Student()  #创建Student类对象stu1，自动执行构造方法
    stu2=Student("小明")  #创建Student类对象stu2，自动执行构造方法
    stu1.PrintInfo() #通过stu对象调用PrintInfo方法
    stu2.PrintInfo()

结果如下：
构造方法被调用！
构造方法被调用！
姓名:未知
姓名:小明

析构方法是类的另一个内置方法，他的方法名为__del__,在销毁一个类对象时，会自动执行，负责完成待销毁对象的资源清理工作，如关闭文件等。
1.局部变量的作用域结束。
2.使用del删除对象时，
3.程序结束时，程序中的所有对象都被销毁。

class Student:
    def __init__(self,name):
        self.name=name
        print("姓名为%s的对象被创建！"%self.name)
    def __del__(self):
        print("姓名为%s的对象被销毁！"%self.name)
def func(name):
    stu=Student(name)
if __name__=="__main__":
    stu1=Student("刘晓明")
    stu2=Student("马红")
    stu3=stu2
    del stu2
    func("张刚")
    del stu3
    stu4=Student("刘建")
   
结果如下：
姓名为刘晓明的对象被创建！
姓名为马红的对象被创建！
姓名为张刚的对象被创建！
姓名为张刚的对象被销毁！
姓名为马红的对象被销毁！
姓名为刘建的对象被创建！

__str__
调用str函数对类对象进行处理时或调用Python内置函数format()和print()时自动执行，__str__方法的返回值必须是字符串。

class Complex:
    def __init__(self,real,image):
        self.real=real
        self.image=image
    def __str__(self):
        return str(self.real)+'+'+str(self.image)+'i'
if __name__=='__main__':
    c=Complex(3.2,5.3)
    print(c)

结果如下：
3.2+5.3i

比较运算的内置方法

内置方法·	功能描述
__gt__(self,other)	self>other时自动执行
__lt__(self,other)	self<other时自动执行
__ge__(self,other)	self>=other时自动执行
__le__(self,other)	self<=other时自动执行
__eq__(self,other)	self==other时自动执行
__ne__(self,other)	self!=other时自动执行

class Student:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __le__(self,other):
        return self.age<=other.age
if __name__=='__main__':
    stu1=Student("小明",19)
    stu2=Student("马红",20)
    print("马红的年龄小于等于小明的年龄：",stu2<=stu1)

结果如下：
马红的年龄小于等于小明的年龄： False

定义子类
class 子类名(父类名1,父类名2，,...,父类名M):
语句1
语句2
...
语句n

当m=1时，则为单继承；当m＞1时，则为多重集继承

class Person:
    def SetName(self,name):
        self.name=name
class Student(Person):
    def SetSno(self,sno):
        self.sno=sno
class Teacher(Person):
    def SetTno(self,tno):
        self.tno=tno
class TA(Student,Teacher):
    def SetTeacher(self,teacher):
        self.teacher=teacher
if __name__=='__main__':
    stu=Student()
    stu.SetSno('1810100')
    stu.SetName('李晓明')
    print('学号：%s，姓名：%s'%(stu.sno,stu.name))
    t=Teacher()
    t.SetTno('998012')
    t.SetName('马红')
    print('教工号：%s，姓名：%s'%(t.tno,t.name))

结果如下：
学号：1810100，姓名：李晓明
教工号：998012，姓名：马红

方法重写：指子类可以对从父类中继承过来的方法进行重新定义，
从而使得子类对象可以表现出与父类对象不同的行为。

class Person:
    def __init__(self,name):
        self.name=name
    def PrintInfo(self):
        print("姓名：%s"%self.name)
class Student(Person):
    def __init__(self,sno,name):
        self.sno=sno
        self.name=name
    def PrintInfo(self):
        print("学号：%s，姓名：%s"%(self.sno,self.name))
def PrintPersonInfo(person):
    print('PrintPersonInfo函数中输出的结果',end='#')
    person.PrintInfo()
if __name__=='__main__':
    p=Person('李晓明')
    stu=Student('1810100','李晓明')
    p.PrintInfo()
    stu.PrintInfo()
    PrintPersonInfo(p)
    PrintPersonInfo(stu)

结果如下：
姓名：李晓明
学号：1810100，姓名：李晓明
PrintPersonInfo函数中输出的结果#姓名：李晓明
PrintPersonInfo函数中输出的结果#学号：1810100，姓名：李晓明