python类class

最新推荐文章于 2025-07-05 11:09:34 发布

「已注销」

最新推荐文章于 2025-07-05 11:09:34 发布

阅读量1.2k

点赞数

CC 4.0 BY-SA版权

分类专栏： Python 文章标签： python-class

本文链接：https://blog.youkuaiyun.com/linuxZhuxiaodi/article/details/90544565

Python 专栏收录该内容

25 篇文章

订阅专栏

本文介绍了Python中的类(class)，包括类的创建、实例化、属性继承、运算符重载等核心概念。类作为程序的组成单元，提供了数据封装和逻辑封装的功能。通过实例化，每个对象可以继承类的属性，并拥有自己的命名空间。类还可以通过运算符重载实现与内置类型的交互。文中还展示了多个实例来说明类的使用和子类定制。

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

class，用于创建和管理新对象，python程序的组成单元，逻辑和数据封装的另一种形式，类似与函数和模块。
类特性：多重实例、通过继承定制、运算符重载。

类对象的特性：
1.class语句创造类并将它赋值给变量名。
2.class语句内的赋值语句创造类的属性，class语句的作用域变成类属性的命名空间，类似与模块的全局作用域。
3.类提供了对象的行为，类属性的行为可被实例对象共享，包括def创造的方法。

实例对象的特性:
1.像调用函数那样调用类对象创造新的实例对象。
2.每个实例对象继承类对象的属性并获得自己的命名空间。
3.对方法内self属性做赋值运算会产生实例自己的属性，赋值运算会修改或者创造实例的数据，不会修改类的数据。

属性继承：【object.attribute】从下至上，从左往右。继承是简单的"树"搜索。
属性继承特性：
1.超类列在类开头的括号中。
2.类从它的超类中继承属性。
3.实例会继承所有可读取类的属性。
4.每个object.attribute都会进行全新的搜索。
5.逻辑的修改是通过创建子类而不是修改超类【定制】。

运算符重载：用类写成的对象，截获并响应应用在内置类型上的运算
1.以双下划线命名的方法（_x_）是特殊钩子，提供特定命名的方法去拦截运算。
2.当实例出现在内置运算时，这种方法会自动调用【如实例继承了_add_方法，对象出现在+表达式内时】。
3.类可覆盖多数内置运算。
4.运算符覆盖的方法没有默认值，而且也不需要【类没有定义或继承运算重载方法，那么相应的运算在类实例中并不支持】。
5.运算符可让类与python类型对象相集成。

编写类树：每个class语句生成新的类对象，实例自动连接创造它的类【从下至上，从左往右】。
属性是在class语句中通过赋值语句添加到类中，不是潜入在函数的def语句内。
属性通常在类内，对传给的函数的特殊参数，做赋值运算添加在实例中。
类对象提供行为，是实例对象的工厂；实例对象是程序实际处理的对象；类对象来自语句，实例对象来自调用。
类也可是模块的属性：导入模块中的类【from module import class 、import module ,class a (module.class)【引用】】
实例：构造函数、方法、运算符重载、子类定制、内省函数

实例1：

#通过class语句创造三个类对象，两次类调用创造了test和test1两个实例对象，实例记着它的类c，c3也记着它的超类a和b
#类中函数return可有可无，继承时直接调用方法和属性
class a:
    def func(self,list):#def出现在类内成为方法，自动接收第一个参数self【实例名】
        self.L=[x*2 for x in list]#赋值操作，参与实例运算
        return  self.L
    print("class1")
class b:
    print("class2")
class c(a,b):#超类a、b 子类c
    N=5#类的属性
    def getvalue(self,str):#def出现在类内成为方法，自动接收第一个参数self【实例名】
        self.value=str#赋值操作，参与实例运算
        self.value1=c.N#类属性参与赋值操作
        return self.value
class d:pass #空类
test=c()#类对象调用创建实例
test1=c()#类对象调用创建实例
test.getvalue("test")#调用函数【方法】【类属性】、继承
test1.func([1,2,3])#L1=test1.func([1,2,3]);print(L1)==print(test1.L)
print(test.value,test.value1,test1.L,c.N,test.N,test1.N)#test [2, 4, 6] 5 5 5
test.value="change"
test.value1=20
test.N=10#在外部修改实例的属性【也可在内部】，并不影响类对象的属性
test.new="new"#添加实例新属性
print(test.value,test.value1,test.new,test.N,c.N)#change,20,new,10,5

D:\py\venv\Scripts\python.exe D:/py/classtest.py
class1
class2
test 5 [2, 4, 6] 5 5 5
change 20 new 10 5

Process finished with exit code 0

实例2：

#init方法创建实例时就会传入 __init__的self参数，相当于创建实例时初始化了实例，不需要额外的调用
#由于init运算时机，它也被称作为构造函数-----运算符重载方法
class a:
    print("class1")
class b:
    print("class2")
class c(a,b):
    def __init__(self,str):
        self.value=str
test=c("test2")#创建实例并初始化
print(test.value)

D:\py\venv\Scripts\python.exe D:/py/classtest.py
class1
class2
test2

Process finished with exit code 0

实例3：

#运算符重载
class a:
    print("class1")
class b:
    print("class2")
class c(a,b):
    def __init__(self,str):
        self.value=str
    def __add__(self, other):#内置运算符自动继承并参与实例对象运算
        return c(self.value+other)
test=c("reload")#创建实例并初始化
test1=test+"-ing"#继承_add_方法，返回新对象test1并传递初始化参数为reloading  ===  【test1=c("reloading")】
print(test.value,test1.value)

D:\py\venv\Scripts\python.exe D:/py/classtest.py
class1
class2
reload reload-ing

Process finished with exit code 0

实例4：

#例子：类与字典

#字典
A={"name":"张三","age":25,"job":"hr"}
B={"name":"李四","age":49,"job":"boss"}
C={"name":"王五","age":39,"job":"develpoer"}
print(A["name"],A["age"],A["job"],B["name"],B["age"],B["job"],C["name"],C["age"],C["job"])

#空类，添加属性
class info:pass
A=info()#创造对象A保存A的信息
A.name="张三"
A.age=25
A.job="hr"
B=info()#创造对象B保存B的信息
B.name="李四"
B.age=49
B.job="boss"
C=info()#创造对象C保存C的信息
C.name="王五"
C.age=39
C.job="develpoer"
print(A.name,A.age,A.job,B.name,B.age,B.job,C.name,C.age,C.job)

#带有逻辑实类
class INFO:
    def __init__(self,name,age,job,pay=0):#类方法及属性【构造函数】 【位置参数及默认参数】
        self.name=name
        self.age=age
        self.job=job
        self.pay=pay

    def showinfo(self):#类方法:个人信息
        return self.name,self.age,self.job,self.pay

    def getname(self):#类方法：名 【列表的切割】
        if len(self.name.split())==2:
            return self.name.split()[-1]
        else:
            list = self.name.split()[1:]
            while True:
                if len(list) > 1:
                    Name = list[0] + " "
                else:
                    Name = Name + list[0]
                    break
                list = list[1:]
            return  Name

    def getraise(self,percent=0):#类方法：薪资调整 【数值运算】
        return int (self.pay *(1+percent) )


print(__name__)#作为主程序为__main__,作为模块被导入为模块名classtest
if __name__== "__main__":#作为主程序时才执行下边的实例对象创建及执行
    A = INFO("zhang san feng", 25, "hr",8000)#创建实例并初始化
    B = INFO("li da zhao", 49, "boss",1000000)#创建实例并初始化
    C = INFO("wang wu", 39, "develpoer")#创建实例并初始化
    C.pay=18000#修改实例属性
    B.lover="liu xin"#添加实例属性
    print( "","个人信息：",A.showinfo(), "\n","名：",A.getname(), "\n","调整后薪资为：",A.getraise(0.2))# 属性继承之方法调用
    print("","个人信息：",B.showinfo(), "\n","名：",B.getname(), "\n","调整后薪资为：", B.getraise(0.0),"\n",
          "配偶为：",B.lover)# 属性继承之方法调用
    print("","个人信息：",C.showinfo(), "\n","名：", C.getname(), "\n","调整后薪资为：", C.getraise(0.2))# 属性继承之方法调用
    print("",A.pay,B.pay,C.pay)

D:\py\venv\Scripts\python.exe D:/py/classtest.py
张三 25 hr 李四 49 boss 王五 39 develpoer
张三 25 hr 李四 49 boss 王五 39 develpoer
__main__
 个人信息： ('zhang san feng', 25, 'hr', 8000) 
 名： san feng 
 调整后薪资为： 9600
 个人信息： ('li da zhao', 49, 'boss', 1000000) 
 名： da zhao 
 调整后薪资为： 1000000 
 配偶为： liu xin
 个人信息： ('wang wu', 39, 'develpoer', 18000) 
 名： wu 
 调整后薪资为： 21600
 8000 1000000 18000

Process finished with exit code 0

实例五：

#用str方法整体取实例对象的属性 工资单个调正
#from classtools import AttrDispaly 替代__str__方法？
class A:pass#空类
class INFO:
    def __init__(self,name,age,job,pay=0):#类方法及属性【构造函数】 【位置参数及默认参数】
        self.name=name
        self.age=age
        self.job=job
        self.pay=pay

    def showinfo(self):#类方法:个人信息
        return self.name,self.age,self.job,self.pay

    def getname(self):#类方法：名 【列表的切割】
        if len(self.name.split())==2:
            return self.name.split()[-1]
        else:
            list = self.name.split()[1:]
            while True:
                if len(list) > 1:
                    Name = list[0] + " "
                else:
                    Name = Name + list[0]
                    break
                list = list[1:]
            return  Name

    def getraise(self,percent=0.0):#类方法：薪资调整 【数值运算】
        self.afterpay= int (self.pay *(1+percent)) #创建新属性保存调整后的薪资
        #return self.afterpay

    def __str__(self):#str打印整个对象而不是单个属性 【格式化打印】【截获并响应应用在内置类型上的运算 运算符重载】
        return '[【信息】：名字：%-15s 名：%-10s 年龄：%d 职位：%-10s 待遇：%-7d 调整后待遇：%-7d]' %(self.name,self.getname(),self.age,self.job,self.pay,self.afterpay)

class manager(INFO,A):#【定制构造函数】【继承】【通过子类定制行为】【拓展】
    def __init__(self,name,age,pay=0):#【定制构造函数】---此类为管理者默认为job为manger
        INFO.__init__(self,name,age,"manger",pay)
    def getraise(self,percent=0.0,bonus=0.1):#【继承】【通过子类定制行为】方法名字可以与超类中的方法相同
        INFO.getraise(self,percent+bonus)
    def others(self):#【拓展方法】
        return "最佳员工：%s"%(self.name)

if __name__== "__main__":#作为主程序时才执行下边的实例对象创建及执行
    A = INFO("zhang san feng", 25, "hr",8000)#创建实例并初始化
    B = INFO("li da zhao", 49, "boss",1000000)#创建实例并初始化
    C = INFO("wang wu", 39, "develpoer")#创建实例并初始化
    D = manager("liu shi wen", 35, 8000)  # 创建实例并初始化
    C.pay=18000#修改实例属性
    B.lover="liu xin"#添加实例属性
    """
    A.getraise(0.2)
    B.getraise(0.0)
    C.getraise(0.2)
    D.getraise(0.1)#D私人定制实际涨薪20%  D.getraise(0.1,0.3)涨薪40%
    print("", A, "\n", B, "\n", C,"\n",D)
    """
    
    for person in (A,B,C,D):#python所谓的多态 【A,B,C---常规涨薪、D---私人定制涨薪，不通的对象调用不同的getraise】
        if person == B:#老板的话，则控制不涨工资
            person.getraise(0.0)
            print("", person)
            continue
        person.getraise(0.2)
        print("",person)
    print("",D.others())

D:\py\venv\Scripts\python.exe D:/py/classtest.py
 [【信息】：名字：zhang san feng  名：san feng   年龄：25 职位：hr         待遇：8000    调整后待遇：9600   ]
 [【信息】：名字：li da zhao      名：da zhao    年龄：49 职位：boss       待遇：1000000 调整后待遇：1000000]
 [【信息】：名字：wang wu         名：wu         年龄：39 职位：develpoer  待遇：18000   调整后待遇：21600  ]
 [【信息】：名字：liu shi wen     名：shi wen    年龄：35 职位：manger     待遇：8000    调整后待遇：10400  ]
 最佳员工：liu shi wen

Process finished with exit code 0

实例六：

"""
模块导入类
内置的instance.__class__提供了实例到创建它的类的链接，object【类信息】=D【实例名】.__class
object.__name__【类名】、
object.__bases__【其超类信息--元组】
object.__dict__【字典---存储实例对象的属性信息】
"""

from classtest import INFO,manager#导入类

if __name__ == "__main__":
    A = INFO("zhang san feng", 25, "hr", 8000)
    D = manager("liu shi wen", 35, 8000)
    A.getraise(0.2)
    D.getraise(0.2)
    print(A)
    print(D)
    print(D.__class__)#类信息
    print(D.__class__.__name__,D.__class__.__bases__)#类名，及其超类信息【元组】
    print(D.__dict__)
    for key in D.__dict__.keys():
        print(key,"--->",D.__dict__[key])#print(key, "--->", getattr(D,key))
    for name in D.__class__.__bases__:#类的超类信息名遍历
        print(name.__name__,end=" ")

D:\py\venv\Scripts\python.exe D:/py/class_module.py
[【信息】：名字：zhang san feng  名：san feng   年龄：25 职位：hr         待遇：8000    调整后待遇：9600   ]
[【信息】：名字：liu shi wen     名：shi wen    年龄：35 职位：manger     待遇：8000    调整后待遇：10400  ]
<class 'classtest.manager'>
manager (<class 'classtest.INFO'>, <class 'classtest.A'>)
{'name': 'liu shi wen', 'age': 35, 'job': 'manger', 'pay': 8000, 'afterpay': 10400}
name ---> liu shi wen
age ---> 35
job ---> manger
pay ---> 8000
afterpay ---> 10400
INFO A 
Process finished with exit code 0