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
六、异常处理
