python类class

本文介绍了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

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值