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

六、异常处理