标签：
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参数，调用时无需加括号
按照对象调用方法进行访问形式且执行调用方法时不加“括号”，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
Python_day8_面向对象（多态、成员修饰符、类中特殊方法、对象边缘知识）、异常处理之篇
标签：
原文地址：http://www.cnblogs.com/lcj0703/p/5617514.html
