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_面向对象(多态成员修饰符类中特殊方法对象边缘知识)异常处理之篇的主要内容,如果未能解决你的问题,请参考以下文章

Python_Day7_面向对象学习

python_day8 面向对象常用 补充

Python_Day8_面向对象编程进阶

Java_面向对象三大特征:封装继承多态

Python面向对象成员修饰符

06 面向对象:多态&抽象类&接口&权限修饰符&内部类