Python_day8_面向对象(多态成员修饰符类中特殊方法对象边缘知识)异常处理之篇
Posted lcj122
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Python_day8_面向对象(多态成员修饰符类中特殊方法对象边缘知识)异常处理之篇相关的知识,希望对你有一定的参考价值。
一、面向对象之多态
1、多态:简而言子就是多种形态或多种类型
python中不支持多态也用不到多态,多态的概念是应用与java/C#中指定传参的数据类型,
java多态传参:必须是传参数的数据类型或传参的子类类型
面向对象总结:
面向对象是一种编程方式,此编程方式的实现是基于类和对象的使用
类:是一个模板,模板中包含了多个函数共使用,即类中可包含多个函数(类中的函数即叫做方法)
一般疑问:
1)什么样的代码才是面向对象?
简单来说,如果程序中的所有功能否是由 “类”和“对象”实现,那么就是面向对象编程
2)函数式编程和面向对象如果选择?分别在什么情况下使用?
C#和java只支持面向对象编程,不支持函数式编程
python和php则支持两种编程方式,且函数式编程能完成的操作,面向对象都可以实现;而对象能实现的操作,函数则不行(函数式编程无法实现面向对象的封装功能)
python编程中,全部使用面向对象或面向对象和函数式混合使用
1、多个函数使用共同的值:类中的函数俗称为一个方法
#!/usr/bin/env python # -*- coding:utf-8 -*- # Author:lcj #Blog address(博客地址):http://i.cnblogs.com/EditPosts.aspx?postid=5500010&update=1 #学号:stu179501 password:055bc2457dfa2e class hh: def __init__(self,host,user,pwd): self.host = host self.user = user self.pwd = pwd #增加 def zengjia(self,sql): print(self.host) print(self.user) print(self.pwd) print(sql) #删除 def shangchu(self,sql): print(sql) #修改 def xiugai(self): print(self.host) print(self.user) print(self.pwd) #查 def cha(self): pass #将动态传输\'localhost\',\'lcj\',123传给__init__方法中host,user,pwd obj1 = hh(\'localhost\',\'lcj\',123) # obj1.zengjia(\'selet * from A\') #有对象调用方法时系统会自动执行__init方法并将动态参数selet * from A传递个sql ##输出 #localhost # lcj # 123 # selet * from A # obj2 = hh(\'localhost\',\'lcj\',123) # obj2.shangchu(\'select * from lcj\') # #修改,host,用户名,密码 obj3 = hh(\'127.0.0.1\',\'xiaoluo\',123) obj3.xiugai() # 127.0.0.1 # xiaoluo # 123
2、需要创建多个事务,每一个事务属性个数相同,但是值得需求如:姓名、年龄、血型都不相同,即属性个数相同,但是值不相同
class dome(): def __init__(self,name,age,xuexing): self.name = name self.age = age self.xuexing = xuexing def tail(self): temp = "My nian%s age%s 血型%s"%(self.name,self.age,self.xuexing) #指定站位符记性传参 print(temp) obj1 = dome(\'lcj\',12,\'O\') obj1.tail() # My nianlcj age12 血型O obj2 = dome(\'xiaoluo\',18,\'O\') obj2.tail() # My nianxiaoluo age18 血型O
二、面向对象中类成员
python类成员包含:字段、方法、属性
1、字段
普通字段:保存在对象中 ,存在于对象中,一般情况下由对象访问普通字段
静态字段:属于类中,保存在内里面,即在类下面,由“类”访问静态字段
注意:一般情况下,自己访问自己,静态字段中(在万不得已情况下可以用对象访问静态字段)
静态字段在代码加载时已经创建,而对象则需要创建并调用才能将数据存放在内存
由图可知:
- 静态字段在内存中只保存一份
- 普通字段在每一个对象中都要保存
应用场景:通过类创建对象时,如果每一个对象中都包含相同的字段,那么就可使用静态字段(静态字段存在于类面)
class Province: #静态字段 Country = \'世界\' def __init__(self,name): #普通字段 self.name = name #一般情况下,自己访问自己 zh = Province(\'中国\') print(zh.name) #对象访问普通字段 #静态字段:只有类才能访问,在万不得已下可以用对象访问静态字段 print(zh.Country) #由类访问静态字段 print(Province.Country)
2、方法
python中什么是方法?
定义:将函数放至类中,且传参中含有“slef”,表示方法
方法:静态方法、普通方法及类方法,三种方法在内存中都归属类,其他语言中只含有两种方法:静态方法和普通普通方法
1)静态方法:
静态方法:调用静态方法时,需再方法前加@staticmethod,参数即可有可无,一般由类执行静态方法(不到万不得已时,可用对象调用静态方法),静态方法中参数可有可无
class Province: #静态字段 Country = \'世界\' def __init__(self,name): #普通字段 self.name = name #普通方法,与对象调用(方法属于类) def show(self): print(self.name) #静态方法:两步,去掉self,二,添加装饰器@staticmethod @staticmethod def f1(arg1,arg2): #静态方法由类调用,(当方法内部不需要对象中封装的值时,可以将方法写成静态方法) print(arg1,arg2) # obj1 = Province(456,234) # obj1.f1() #由对象调用静态方法,则报错 #类调用静态方法 Province.f1(111,122) # 111 122
2)普通方法:
创建普通方法时参数中必须带一个self关键字,当任意对象执行普通方法时,自动将调用该方法的对象赋值给self
3)类方法:
创建规则:创建类方法规则:普通方法前加@classmethod ,参数中必须带一个“cls”关键字,执行类方法时,自动将调用该方法的类赋值给cls关键字
特点:由类调用类方法时,系统自动将当前类名传递给cls参数
class Province: #静态字段 Country = \'世界\' def __init__(self,name): #普通字段 self.name = name #普通方法,与对象调用(方法属于类) def show(self): print(self.name) #静态方法:两步,去掉self,二,添加装饰器@staticmethod @staticmethod def f1(arg1,arg2): #静态方法由类调用, print(arg1,arg2) #类方法:由类调用, @classmethod # 类方法参数中至少有“cls"参数 def f2(cls): #调用类方法时,系统自动将当前类名传递给cls print(cls) #类调用静态方法 Province.f1(111,122) # 111 122 Province.f2() #<class \'__main__.Province\'>
3、属性
定义:不伦不类的东西
规则:在创建属性时,在普通方法基础上添加@property装饰器,属性仅有一个self参数,调用时无需加括号,方法:foo_obj.func(),属属性:foo_obj.prop
按照对象调用方法进行访问形式且执行调用方法时不加“括号”,ret = obj.show 【obj属于对象,show属于对象中存在的方法】
特点:具有方法的写作形式(),又有字段的访问形式(字段是用过对象访问,且访问时不加“括号”进行访问)
Python的构造方法中有四个参数:
第一个参数是方法名,调用 对象.属性 时自动触发执行方法 第二个参数是方法名,调用 对象.属性 = XXX 时自动触发执行方法 第三个参数是方法名,调用 del 对象.属性 时自动触发执行方法 第四个参数是字符串,调用 对象.属性.__doc__ ,此参数是该属性的描述信息
class Foo: def get_bar(self): return \'lcj\' # *必须两个参数 def set_bar(self, value): return \'set value\' + value def del_bar(self): return \'qaz\' BAR = property(get_bar, set_bar, del_bar, \'description...\') obj = Foo() ret = obj.BAR # 自动调用第一个参数中定义的方法:get_bar print(ret) ret= obj.BAR = "xiaoluo" # 自动调用第二个参数中定义的方法:set_bar方法,并将“alex”当作参数传入 print(ret) del Foo.BAR # 自动调用第三个参数中定义的方法:del_bar方法 # obj.BAE.__doc__ # 自动获取第四个参数中设置的值:description...
通过方法完成分页:
#通过方法计算分页 class www: def __init__(self,all_count): self.all_count = all_count def show(self): #divmod:计算分页,a1表示商,a2:表示余数 a1,a2 = divmod(self.all_count,10) if a2 == 0: return a1 else: return a1 + 1 obj = www(101) #创建obj1对象,并把101参数赋值给对象obj ret = obj.show() #由对象调用show方法,并将返回结果值赋值给一个变量 print(ret) # 11
通过添加属性@property,再由对象调用方法执行
class www: def __init__(self,all_count): #字段all_count self.all_count = all_count #属性 @property def show(self): #divmod:计算分页,a1表示商,a2:表示余数 a1,a2 = divmod(self.all_count,10) if a2 == 0: return a1 else: return a1 + 1 obj = www(101) #创建obj1对象,并把101参数赋值给对象obj # ret = obj.all_count #对象调用字段all_count # print(ret) 101 # ret = obj.show() #由对象调用show方法,并将返回结果值赋值给一个变量 # print(ret) # 11 ret3 = obj.show #通过对象调用方法,此时方法已经被属性化,无需加()即可执行show方法 print(ret3) # 11
对属性中的数值进行“修改(添加装饰器@show.setter)、删除(添加装饰器@show.deleter)”操作,show属于方法
class www: def __init__(self,all_count): #字段all_count self.all_count = all_count #属性 @property def show(self): #divmod:计算分页,a1表示商,a2:表示余数 a1,a2 = divmod(self.all_count,10) if a2 == 0: return a1 else: return a1 + 1 #修改属性中的数值 @show.setter def show(self,value): print(value) #对属性中数值进行删除 @show.deleter def show(self): print(\'del show\') obj = www(101) #创建obj1对象,并把101参数赋值给对象obj # ret = obj.all_count #对象调用字段all_count # print(ret) 101 # ret = obj.show() #由对象调用show方法,并将返回结果值赋值给一个变量 # print(ret) # 11 # print(obj.all_count) # obj.all_count = 102 #对字段进行重新赋值 # print(obj.all_count) # del obj.all_count #删除字段中的数字 ret = obj.show print(ret) #修改属性中的数值 obj.show = 123 #删除属性中值 del obj.show
方式二:foo = property(F1,F2,F3)
class lcj: def __init__(self,count): self.count = count pass def F1(self): return 111 def F2(self,value): pass def F3(self): print(\'hahaha\') #当对象调用foo方法时,系统会自动执行指定的方法 foo = property(F1,F2,F3) obj = lcj(124) #打印原属性中的值 ret = obj.foo print(ret) # 返回值:111 #修改属性值 ret = obj.foo = 1000 print(ret) #返回修改属性值为:1000 del obj.foo #返回删除属性中的值:hahaha
三、类成员的修饰符
类成员修饰符可分:公共成功和私有成员
1、什么是公共成员和私有成员?
公共成员:在任何地方都能访问,即可在类外面和对象调用方法进行访问
私有成员:只有在类的内部才能访问
class C: def __init__(self): self.name = \'公有字段\' self.__foo = "私有字段"
创建私有成员规则:即在字段前面添加两个双下划线:__字段,且只能有内部访问(通过对象调用私有字段访问),外部访问不了
2、私有成员:私有成员命名时,前两个字符时下划线,特殊成员除外:如:(__init__、__call__、__dict__等)
即私有字段:只能类自己本身成员内部可以访问,其他成员访问不了
静态字段:公有静态字段和私有静态字段
公有静态字段:类可以访问,类内部可以访问;派生类中也可访问
class foo: name = \'公共静态字段\' def __init__(self,name): self.name = name #公有静态字段 def f1(self): print(self.name) class fol(foo): def f2(self): print(self.name) #类访问公共静态字段 print(foo.name) #公共静态字段 #类内部通过对象访问方法 obj = foo(\'lcj\') obj.f1() #lcj #中派生类中可以访问 obj2 = fol(\'xiaoluo\') obj2.f2() #先去fol类中执行f2方法,如没有则在父类foo中执行f2方法 #xiaoluo
私有静态字段:仅类内部可以访问
class foo: #创建私有静态字段 __age = 18 def __init__(self,name): #创建私有字段:__name self.__name = name def f1(self): print(self.__name) #创建静态方法 @staticmethod def f2(): print(foo.__age) foo.f2() #通过类直接调用静态方法中F2方法
3、公有成员:
【不到万不得已不要在外部强制访问私有成员】
class foo: #创建私有静态字段 __age = 18 def __init__(self,name): #创建私有字段:__name self.__name = name def f1(self): print(self.__name) # 强制访问私有字段,对象+一个下划线+类名+两个下划线+参数 obj = foo(\'xiaoluo\') print(obj._foo__name) # xiaoluo
四、类的特殊成员
常用类成员有:__doc__,__module__和__class__, __init__,__del__,__call__, __dict__,, __str__,__getitem__、__setitem__、__delitem__,__getslice__、__setslice__、__delslice__,__iter__, __new__ 和 __metaclass__,
1、__doc__:表示类的描述
class foo:
#构造方法
def __init__(self,name):
self.name= name
#输出描述信息
obj= foo(\'lcj\')
print(obj.name) #调用对象时,系统自动执行__init__方法,输出:lcj
print(foo.__doc__)#None
2、__module__和__class__
__module__ 表示当前操作的对象在那个模块
__class__ 表示当前操作的对象的类是什么
class lcj: def __init__(self): self.name =\'xiaoluo\'
from lib.s4 import lcj #导入模块 obj =lcj() #创建对象 print(obj.__module__) #输出lib.s4模块 print(obj.__class__) # 输出类<class \'lib.s4.lcj\'>
练习:
class ww: #创建构造方法 def __init__(self,name,age): self.name = name self.age = age #析构方法:当对象结束对方法调用时,系统自动执行析构方法 def __del__(self): pass #call方法: def __call__(self, *args, **kwargs): print("call") #将对象转化至字符串类型,并按照字符串进行输出 def __str__(self): return ("%s ---%d"%(self.name,self.age)) #执行call方法:对象+() obj1 = ww(\'lcj\',18) # obj1() #call ww()() # obj2 = ww(\'lcc\',18) # print(obj1) # print(obj2)
3、 __init__
构造方法:通过类创建对象时,系统触发执行__init__方法
class lcj: #创建构造方法 def __init__(self,name,gender,age,): self.name = name self.gender = gender self.age = age def f1(self): print("i am is %s,性别:%s,年龄:%s"%(self.name,self.gender,self.age)) #创建对象obj,self=obj,并将参数传递给__init__方法 obj = lcj("xiaoluo",18,"男") obj.f1() # i am is xiaoluo,性别:18,年龄:男
4、__del__
析构方法,当对象在内存中释放时,系统自动触发执行(释放内存空间,充当垃圾回收)
注:此方法一般无须定义,因为Python是一门高级语言,程序员在使用时无需关心内存的分配和释放,因为此工作都是交给Python解释器来执行,所以,析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。
class lcj: #创建构造方法 def __init__(self,name,gender,age,): self.name = name self.gender = gender self.age = age def f1(self): print("i am is %s,性别:%s,年龄:%s"%(self.name,self.gender,self.age)) #析构方法, def __del__(self): pass #创建对象obj,self=obj,并将参数传递给__init__方法 obj = lcj("xiaoluo",18,"男") obj.f1() # i am is xiaoluo,性别:18,年龄:男
5、__call__
调用方式:对象+(),即触发执行__call__方法
注:构造方法的执行是由创建对象触发的,即:对象 = 类名() ;而对于 __call__ 方法的执行是由对象后加括号触发的,即:对象() 或者 类()()
class lcj: #创建构造方法 def __init__(self,name,gender,age,): self.name = name self.gender = gender self.age = age def f1(self): print("i am is %s,性别:%s,年龄:%s"%(self.name,self.gender,self.age)) #析构方法, def __del__(self): pass #创建__call__方法 def __call__(self, *args, **kwargs): print(self.name,self.gender,self.age) #创建对象obj,self=obj,并将参数传递给__init__方法 obj = lcj("xiaoluo",18,"男") # obj.f1() #执行__init__方法 obj() #对象+():执行__call__方法 # xiaoluo 18 男
6、__dict__
获取类和对象中所有成员
类的普通字段属于对象,类的静态字段和方法等属于类
class lcj: #创建静态字段 think = "思考中的人" #创建构造方法 def __init__(self,name,age): self.name = name self.age = age def f1(self,*args,**kwargs): pass #获取类中成员,即:静态字段、方法 print(lcj.__dict__) #输出:{\'f1\': <function lcj.f1 at 0x000000000110CEA0>, \'__module__\': \'__main__\', \'__init__\': <function lcj.__init__ at 0x000000000110CE18>, \'__dict__\': <attribute \'__dict__\' of \'lcj\' objects>, \'__weakref__\': <attribute \'__weakref__\' of \'lcj\' objects>, \'think\': \'思考中的人\', \'__doc__\': None} #创建对象 obj = lcj("xiaoluo",18) #获取对象中的各成员 print(obj.__dict__) #输出:{\'name\': \'xiaoluo\', \'age\': 18}
__add__(self, other)方法:
class lcj: def __init__(self,name,age): self.name = name self.age = age def f1(self): print("i am is %s age%s"%(self.name,self.age)) #__add__方法 def __add__(self, other): tem = "%s ---%d"%(self.name,other.age) return tem obj1 = lcj("xiaoluo",19) obj2 = lcj("haha",18) ret = obj1 + obj2 #两对象相加 print(ret) #输出:xiaoluo ---18
7、__str__
如果一个类中定义了__str__方法,那在打印“对象”时,默认输出该方法的返回值
class xiaoluo: #调用对象时,默认输出__str_方法返回值 def __str__(self): return ("haha") obj = xiaoluo() print(obj) #输出:haha
8、__getitem__、__setitem__、__delitem__
用于索引操作又可做切片方式操作,如字典,以上分别获取,设置,删除数据
class lcj: #构造方法 def __init__(self,like,yanse): self.like = like self.yanse = yanse #获取 def __getitem__(self, key): print(self.__getitem__,key) #修改key和value def __setitem__(self, key, value): print(self.__setattr__,key,value) #删除key def __delitem__(self, key): print(self.__delitem__,key) obj = lcj("蓝天","蓝色的天空") obj[\'xiaoluo\'] #系统自动触发__getitem__方法 #输出:<bound method lcj.__getitem__ of <__main__.lcj object at 0x0000000000B4A8D0>> xiaoluo obj[\'k2\'] = \'中国梦\' #输出:<method-wrapper \'__setattr__\' of lcj object at 0x0000000001132438> k2 中国梦 del obj[\'lcj\'] #自动触发:__delitem__方法 #输出:<bound method lcj.__delitem__ of <__main__.lcj object at 0x00000000011724A8>> lcj
切片方式:
class lcj: #构造方法 def __init__(self,like,yanse): self.like = like self.yanse = yanse #获取 def __getitem__(self, key): print(self.__getitem__,key) print(key.start) print(key.stop) print(key.step) #修改key和value def __setitem__(self, key, value): # print(self.__setattr__,key,value) print(key.start) print(key.stop) print(key.step) #删除key def __delitem__(self, key): print(self.__delitem__,key) obj = lcj("蓝天","蓝色的天空") # ret = obj[1:4:2] #切片调用:__getitem__方法,并分别打印出:起始位置:1、终止位置:4及字长:2 obj[1:4] = [1,2,3,45,5] #调用__setitem__方法:并分别打印出:起始位置:1、终止位置:4及字长:None del obj[1:4]
9、__getslice__、__setslice__、__delslice__
该三个方法用于分片操作,如下:
#!/usr/bin/env python # -*- coding:utf-8 -*- class Foo(object): def __getslice__(self, i, j): print \'__getslice__\',i,j def __setslice__(self, i, j, sequence): print \'__setslice__\',i,j def __delslice__(self, i, j): print \'__delslice__\',i,j obj = Foo() obj[-1:1] # 自动触发执行 __getslice__ obj[0:1] = [11,22,33,44] # 自动触发执行 __setslice__ del obj[0:2] # 自动触发执行 __delslice__
10、__iter__
用于迭代器,之所以列表、字典、元组可以进行for循环,是因为类型内部定义了 __iter__
k = iter([11,23,4,5,6,7,8,]) for i in k: #循环打印出k列表中的各值 print(i)
11、__new__ 和 __metaclass__
python中一切都是对象
如果按照一切事物都是对象的理论:obj对象是通过执行Foo类的构造方法创建,那么Foo类对象应该也是通过执行某个类的 构造方法 创建。
所以,kw对象是foo类的一个实例,foo类对象是 type 类的一个实例,即:foo类对象 是通过type类的构造方法创建。
class foo: def __init__(self,name,age): self.name = name self.age = age def lcj(self,): print("--%s----%d"%(self.name,self.age)) kw = foo(\'jack\',18) #kw是通过foo类实例化的对象 kw.lcj() print(type(kw)) #输出:<class \'__main__.foo\'> #表示kw队形是由foo类创建 print(type(foo)) #<class \'type\'> #表示foo类对象是由type类创建
创建类两种方式
a)普通方式:
class foo(object): def lcj(self): print ("nihao,lcj") f1 = foo() f1.lcj()
b)特殊方式(type类构造函数)
def lcj(): print(\'hello xiaoluo\') foo = type(\'foo\',(object,),{\'lcj\':lcj}) #type第一个参数:类名 #type第二个参数:当前类的基类 object #type第三个参数:类的成员 \'lcj\':lcj
=====》类是由type类实例化产生
那么问题来了,类默认是由 type 类实例化产生,type类中如何实现的创建类?类又是如何创建对象?
答:类中有一个属性 __metaclass__,其用来表示该类由 谁 来实例化创建,所以,我们可以为 __metaclass__ 设置一个type类的派生类,从而查看 类 创建的过程。
class MyType(type): def __init__(self, what, bases=None, dict=None): super(MyType, self).__init__(what, bases, dict) def __call__(self, *args, **kwargs): obj = self.__new__(self, *args, **kwargs) self.__init__(obj) class Foo(object): __metaclass__ = MyType def __init__(self, name): self.name = name def __new__(cls, *args, **kwargs): return object.__new__(cls, *args, **kwargs) # 第一阶段:解释器从上到下执行代码创建Foo类 # 第二阶段:通过Foo类创建obj对象 obj = Foo()
五、其他相关
1、isinstance(obj,lcj)
检查obj是否是类lcj对象
class Foo(object): pass obj = Foo() ret = isinstance(obj,Foo) print(ret) #如果obj是Foo类的对象就输出True # 输出:True
2、issubclass(sub, super)
检查sub类是否是super类的派生类(即子类)
class Foo(object): pass class lcj(Foo): #lcj子类继承父类Foo pass ret = issubclass(lcj,Foo) #如果子类lcj是父类Foo派生类,则返回True,否则False print(ret)
3、主动执行父类中的方法,运用super方法
class lcj: #父类
def f1(self):
print(\'clj.f1\')
class xiaoluo(lcj): #子类继承父类lcj
def f2(self):
#主动执行lcj类(父类)中的f1方法
super(xiaoluo,self).f1()
print(\'xiaoluo.f2\')
obj = xiaoluo()
obj.f2()
#输出:clj.f1
# 输出:xiaoluo.f2
方式二:类+方法名+self关键字 ----》执行父类中的指定的方法
class lcj: #父类 def f1(self): print(\'clj.f1\') class xiaoluo(lcj): #子类继承父类lcj def f2(self): #主动执行lcj类(父类)中的f1方法 #方式二:类+方法名+self关键字 lcj.f1(self) obj = xiaoluo() obj.f2() #输出:clj.f1
六、异常处理
以上是关于Python_day8_面向对象(多态成员修饰符类中特殊方法对象边缘知识)异常处理之篇的主要内容,如果未能解决你的问题,请参考以下文章