python面向对象进阶
2016-07-10 22:27
851 查看
1. 类的成员
python 类的成员有三种:字段、方法、属性字段
字段包括:普通字段和静态字段,他们在定义和使用中有所区别,而最本质的区别是内存中保存的位置不同,普通字段属于对象,只有对象创建之后,才会有普通字段,而且只能通过对象来调用静态字段属于类,解释器在加载代码的时候已经创建,对象和类都可以调用例子:class Province:
country = '中国' #静态字段
def __init__(self,name):
self.name = name #普通字段
#调用字段:
obj = Province('河南') #创建对象
res1 = obj.name #对象调用普通字典
res2 = obj.country #对象调用静态字段
print('对象调用普通字典:',res1)
print('对象调用静态字段:',res2)
res3 = Province.country #类调用静态字段
res4 = Province.name #类调用普通字段,会报错
print('类调用静态字段:',res3)
print('类调用普通字段:',res4) #报错
输出结果:
对象调用普通字典: 河南
对象调用静态字段: 中国
类调用静态字段: 中国
Traceback (most recent call last):
File "D:/study-file/git/gitlab/study/code/day08/成员.py", line 24, in <module>
res4 = Province.name # 类调用普通字段,会报错
AttributeError: type object 'Province' has no attribute 'name'
因为对象没有创建,所以在内存中并没有name这个字段,所以,类直接调用会报错总结:静态字段在内存中只保存一份 普通字段在每个对象中都要保存一份 应用场景: 通过类创建对象时,如果每个对象都具有相同的字段,那么就使用静态字段。普通字段只能用对象访问,静态字段对象和类都可以访问(优先使用类访问)
方法
方法包括:普通方法、静态方法和类方法,三种方法在内存中都归属于类,区别在于调用方式不同普通方法属于类,由对象去调用执行,参数至少有一个self,执行普通方法时,自动将调用该方法的对象赋值给self;静态方法属于类,由类直接调用.当方法内部不需要对象中封装的值时,可以将方法写成静态,并且使用 @staticmethoe装饰,并且参数中不带self,参数可有可无类方法静态方法的特殊形式,至少有一个cls参数 由类执行 @classmethoe装饰,执行类方法时,自动将调用该方法的类复制给cls举例:class Province:
country = '中国' # 静态字段
def __init__(self, name):
self.name = name # 普通字段
def show(self): #普通方法
print(self.country,self.name)
@staticmethod
def f1(arg): #静态方法
print(arg)
@classmethod
def f2(cls): #类方法 cls为类名
print(cls)
# 调用字段:
obj = Province('河南') # 创建对象
obj.show() #类调用普通方法执行
obj.f1('对象调用静态方法执行')
Province.f1('类调用静态方法执行')
Province.f2() #类调用类方法执行,返回类名
执行结果:
中国 河南
对象调用静态方法执行
类调用静态方法执行
<class '__main__.Province'>总结 相同点:对于所有的方法而言,均属于类(非对象)中,所以,在内存中也只保存一份。不同点:方法调用者不同、调用方法时自动传入的参数不同。
属性
属性是普通方法的变种,使用 @property来装饰,所以具有方法的表现形式,使用字段调用的方法来调用方法,所以也具有字段的访问形式。由对象来调用属性的基本使用从执行结果中可以看出,常规类中方法的调用是obj.方法()的形式,但是此时调用属性是obj.方法,不加括号,这种形式和静态字段调用的形式一样,所以说有静态字段的调用方法;而在代码中看,属性的表现形式都是普通方法的形式,即函数,然后使用property来装饰,所以说有普通方法的表现形式class Province:
country = '中国' # 静态字段
def __init__(self, name):
self.name = name # 普通字段
def show(self): #普通方法
print(self.country,self.name)
@staticmethod
def f1(arg): #静态方法
print(arg)
@classmethod
def f2(cls): #类方法 cls为类名
print(cls)
@property
def f3(self): # 属性
print(self.name)
@f3.deleter
def f3(self):
print('del f3')
@f3.setter
def f3(self,arg):
print('set f3',arg)
#调用属性
obj = Province('河南') # 创建对象
obj.f3 #调用属性,自动执行@f3.getter装饰的方法 此形态类似于静态字段的调用
del obj.f3 #自动执行@f3.deleter装饰的方法,类似于静态字段的del
obj.f3 = '123' #自动执行@f3.setter装饰的方法,类似静态字段的set方法
执行结果:
河南
del f3
set f3 123属性的表现形式装饰器:即在一个方法上应用@property装饰器,使方法变为一个属性
```class Foo:@propertydef f1(self):pass@f1.deleterdef f1(self):pass@f1.setterdef f3(self):pass```* 静态字段: 在类中定义値为property对象的静态字段```class Province:country = '中国' # 静态字段def __init__(self, name):self.name = name # 普通字段def show(self): #普通方法print(self.country,self.name)@staticmethoddef f1(arg): #静态方法print(arg)@classmethoddef f2(cls): #类方法 cls为类名print(cls)def f4(self):print(1234)def f5(self,arg):print('执行set')def f6(self):print('执行del')foo = property(fget=f4, fset=f5, fdel=f6) # 属性的静态字段表达方式#调用属性obj = Province('河南') # 创建对象obj.foo #自动执行f4方法del obj.foo #自动执行f6方法obj.foo = '123' #自动执行f5方法输出结果:1234执行del执行set```总结:属性存在意义是:访问属性时可以制造出和访问字段完全相同的假象,按字段的操作来执行对象类中定义的属性中特定的方法,如执行obj.foo会自动执行f4方法,del obj.foo 会自动执行f6方法,此映射关系都使用foo = property(fget=f4, fset=f5, fdel=f6)定义好,属性只是伪造了字段的操作方式而已,不会删除对应的东西,只是根据字段的操作方式来执行对应的方法,而具体执行什么方法,方法有什么功能,这都是自己灵活定义属性由方法变种而来,如果Python中没有属性,方法完全可以代替其功能。
2. 类的成员修饰符
类的成员修饰符使用类的所有成员,包括如下:公有:在任何地方都能访问和调用私有:只能在类内部进行调用“`class Foo:contry = ‘china’ #公有静态字段__contry1 = ‘china’ #私有静态字段def __init__(self,name):self.name = name #公有普通字段self.__name1 = name #私有普通字段def __f1(self): #私有方法print(self.name)def f2(self): #公有方法print(self.__contry)self.__f1()“`特例如果想要强制访问私有字段,可以通过 对象._类名__ 私有成员名访问如:obj._Foo__\f1, obj_Foo__contry1, 不建议强制访问私有成员定义:私有成员命名时,前两个字符是下划线。(特殊成员除外,例如:init、call、dict 等)
3. 类的特殊成员
python的特殊成员是采用__方法名__ 表示含有特殊意义的成员init 构造方法,该方法在对象创建时自动创建class Foo:
def __init__(self,name):
self.name = name #公有普通字段del 析构方法。当对象在内存中被释放时,自动触发执行,此方法一般无须定义,因为Python是一门高级语言,程序员在使用时无需关心内存的分配和释放,因为此工作都是交给Python解释器来执行,所以,析构函数的调用是由解释器在进行垃圾回收时自动触发执行doc 表示类的描述信息
class Foo: """ 描述类信息,牛逼的python """ def func(self): passprint(Foo.__doc__) #输出:类的描述信息输出结果: 描述类信息,牛逼的pythonmodule 和 classmodule 表示当前操作的对象在那个模块class 表示当前操作的对象的类是什么
class Foo:def f1(self): pass
from test import Foo obj = Foo() print(obj.__class__) print(obj.__module__) 输出: <class 'test.Foo'> testcall对象后面加括号,触发执行。注:构造方法的执行是由创建对象触发的,即:对象 = 类名() ;而对于 call 方法的执行是由对象后加括号触发的,即:对象() 或者 类()()
class Foo: def __init__(self): pass def __call__(self, *args, **kwargs): print('__call__') obj = Foo() # 执行 __init__ obj() # 执行 __call__dict 类或对象中的所有成员
class Foo: def __init__(self): self.name = 123def f1(self): passprint(Foo.__dict__) #打印类的所有成员obj = Foo()print(obj.__dict__) #打印对象中的所有成员输出结果:{'__init__': <function Foo.__init__ at 0x01FA1348>, '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__dict__': <attribute '__dict__' of 'Foo' objects>, '__doc__': None, 'f1': <function Foo.f1 at 0x01FA11E0>}{'name': 123}str 指定print对象的时候输出的内容
class Foo: def __init__(self): self.name = 123def f1(self): pass def __str__(self): return "打印对象输出结果" obj = Foo()print(obj) #打印对象输出结果:打印对象输出结果getitem、setitem、delitem用于索引操作,如字典。以上分别表示获取、设置、删除数据
class Foo: def __init__(self): self.name = 123 def __getitem__(self, item): print('__getitem__',item) def __delitem__(self, key): print('__delitem',key) def __setitem__(self, key, value): print('__setitem__',key,value)obj = Foo()result = obj['k1'] # 自动触发执行 __getitem__obj['k2'] = 'hahhahhhha' # 自动触发执行 __setitem__del obj['k1'] ## 自动触发执行 __delitem__输出结果:__getitem__ k1__setitem__ k2 hahhahhhha__delitem k1iter 用于迭代器,之所以列表、字典、元组可以进行for循环,是因为类型内部定义了 iter
class Foo: def __init__(self,num): self.num = num def __iter__(self): i = 1 while True: if i <= self.num: yield i i += 1 else: break obj = Foo(4) for i in obj: print(i) 输出结果: 1 2 3 4以上是常用的特殊成员,还有很多不常用的,不在举例
4. 面向对象其他
isinstance(obj, cls)检查是否obj是否是类 cls 的对象class Foo(object): passobj = Foo()isinstance(obj, Foo)issubclass(sub, super)检查sub类是否是 super 类的派生类
class Foo(object): passclass Bar(Foo): passissubclass(Bar, Foo)执行父类的方法默认情况下当子类和父类的方法一样时,优先执行子类的方法,如下:
class Foo: def f1(self): print('Foo.f1')class Bar(Foo): def f1(self): print('Bar.f1')obj = Bar()obj.f1()输出结果:Bar.f1如果想要强制执行父类的方法呢?可以使用super(子类名,self).父类方法 格式如下:
class Foo:def f1(self): print('Foo.f1')class Bar(Foo):def f1(self): super(Bar,self).f1() #使用super 来强制执行父类的f1方法 print('Bar.f1')obj = Bar()obj.f1()输出结果:Foo.f1 #执行父类f1的结果Bar.f1应用1,扩展原来代码的功能需求:一个开源的web框架,在保证不改变源码的情况下,个性定制自己的环境,适应需求。这就用到了类的继承,我新扩展的功能是在原来功能的基础上进行扩展的,所以,我只需要将新功能类继承源代码的相关功能类,然后使用super强制执行父类的方法,实现基本功能,最后在新类中扩展基本功能即可。此区别于装饰器,使用装饰器需要在原来的类上应用装饰器,那就改变了源码如果我要扩展该功能,需要在每次f1执行前打印一个start,执行结束之后,打印一个end,看下面代码from test import Foo #从源代码中导入Foo类前端调用的时候,我直接调用自己创建的类即可,这就实现了基本的扩展,也不改变源代码字典key 的排序是无序的,如果要实现一个有序字典,可以根据类的继承来自己写一个有序字典类实现思路:1.继承dict类,使新定义的类有dict的所有方法2.定一个列表,用来存放字典中的key,输出的时候循环这个列表,那么这个字典就变成有序输出3.使用__setitem__特殊方法实现可以自定义key value4.使用__str__特殊方法实现print字典代码如下:下面来测试应用2 实现有序字典
obj = Mydict() #创建一个字典
obj['k1'] = 'v1' #字典key value赋值
obj['k2'] = 'v2'
print(obj) #打印字典
print(type(obj)) #打印类型
输出:
{'k1':v1,'k2':v2}
<class '__main__.Mydict'>
class Mydict(dict):
def __init__(self):
self.li = []
super(Mydict,self).__init__()
def __setitem__(self, key, value): #获取obj['k1'] = 'v1'形式的赋值
self.li.append(key) #将key存入列表
super(Mydict, self).__setitem__(key,value) #强制执行父类的__setitem__,实现字典功能
def __str__(self):
temp = []
for key in self.li: #循环列表中的key
value = self.get(key)
temp.append("'%s':%s" % (key,value)) #将key value 组成元组存入一个临时列表
ret = "{" + ','.join(temp) + '}' #join 来替换key value中间的空格为冒号:,并拼接成字典形式
return ret
obj = New()
obj.f1()
输出效果:
===start====
源代码
基本功能执行完毕
===end===
class New(Foo):
def f1(self):
print('===start====')
super(New,self).f1()
print('===end===')
#这是源代码类,实现打印输出
class Foo:
def f1(self):
print('源代码')
print('基本功能执行完毕')
5. 设计模式-单例模式
单例模式指的是是多个对象创建时,如果每次都需要创建一个实例,在通过该实例去执行指定的方法,这样每次频繁的创建实例,对内存的读写消耗很大,如果将他们共同的实例,通过一种判断机制,如果实例不存在,则创建实例,然后调用某个方法;如果实例存在,则直接调用某个方法,那么在内存中就仅仅保留了一份实例,这样岂不更好看下面实例,如果class Mysql 是一个数据库连接池```class Mysql:def __init__(self):self.host = 127.0.0.1self.port = 3306self.dbname = testself.user = jeckself.passwd = 123123def create(self):#执行create语句passdef delete(self):#执行delete语句pass```如果用户需要操作数据库,那么需要进行下面操作user1 = Mysql()user1.create()user2 = Mysql()user2.delete()….发现,每来一个用户,都需要创建一个地址池实例,然后执行某个方法,这样在高并发的网站,直接就崩溃了换种思路,如果,我只创建一个地址池对象,用户请求来之后,先进行判断,没有实例的话,就创建,有的话就直接使用,岂不更高效。“`class Mysql:instance = Falsedef init(self):self.host = ‘127.0.0.1’self.port = 3306self.dbname = ‘test’self.user = ‘jeck’self.passwd = ‘123123’
def create(self):# 执行create语句passdef delete(self):# 执行delete语句pass@classmethoddef get_instance(cls):if cls.instance: #判断instence 是否有値,如果有的话,直接返回return cls.instanceelse:obj = cls() #instence没有値的话,创建对象,并将对象赋给instencecls.instance = objreturn objobj1 = Mysql() #多例模式obj2 = Mysql() #多例模式obj3 = Mysql.get_instance() #单例模式obj4 = Mysql.get_instance() #单例模式#打印内存地址print(‘多例模式:’,obj1)print(‘多例模式:’,obj2)print(‘单例模式:’,obj3)print(‘单例模式:’,obj4)输出结果:多例模式: <main.Mysql object at 0x013AAC70>多例模式: <main.Mysql object at 0x013AACD0>单例模式: <main.Mysql object at 0x013AAD30>单例模式: <main.Mysql object at 0x013AAD30>“`发现使用单例模式后,第二次创建的对象和第一次创建的对象内存地址是一样的,即使再有成千上万后实例,其都是公用的一个连接池总结:单利模式存在的目的是保证当前内存中仅存在单个实例,避免内存浪费!同步更新地址:http://www.cnblogs.com/pycode
相关文章推荐
- Python动态类型的学习---引用的理解
- Python3写爬虫(四)多线程实现数据爬取
- 垃圾邮件过滤器 python简单实现
- 下载并遍历 names.txt 文件,输出长度最长的回文人名。
- install and upgrade scrapy
- Scrapy的架构介绍
- Centos6 编译安装Python
- 使用Python生成Excel格式的图片
- 让Python文件也可以当bat文件运行
- [Python]推算数独
- Python中zip()函数用法举例
- Python中map()函数浅析
- Python将excel导入到mysql中
- Python在CAM软件Genesis2000中的应用
- 使用Shiboken为C++和Qt库创建Python绑定
- FREEBASIC 编译可被python调用的dll函数示例
- Python 七步捉虫法