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