python面向对象编程(下)
Posted
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了python面向对象编程(下)相关的知识,希望对你有一定的参考价值。
本篇将详细介绍Python 类的成员、成员修饰符、类的特殊成员。还有两个类的综合运用实例。
环境为:python3.5.1
类的成员
类的成员包括三大类:字段、方法和属性
最重要的是:所有成员中,只有普通字段的内容保存在对象中,即:根据此类创建了多少对象,在内存中就有多少个普通字段。而其他的成员,则都是保存在类中,即:无论对象的多少,在内存中只创建一份。
一、字段
字段包括:普通字段和静态字段,他们在定义和使用中有所区别,而最本质的区别是内存中保存的位置不同。
- 普通字段属于对象。不实例化对象就不会创建字段。每个对象都有一份自己的普通字段。使用对象名.字段名的方式进行访问。
- 静态字段属于类。所有对象共享一份,在代码加载时就创建了,使用类名.字段名的方式访问。(也可以用对象名.类字段访问,但不建议这么用。)
字段有点像类和对象包含的变量,要理解字段的含义:可以参考函数式编程中的局部变量和全部变量,但切切不可混为一谈。
字段的创建和调用方式:
class Province: # 静态字段 country = ‘中国‘ def __init__(self, name): # 普通字段 self.name = name # 直接访问普通字段 obj = Province(‘河北省‘) print obj.name # 直接访问静态字段 Province.country
【普通字段需要通过对象来访问】,【静态字段通过类访问】,在使用上也可以看出普通字段和静态字段的归属是不同的。其在内容的存储方式类似如下图:
反复强调的是:
- 静态字段在内存中只保存一份
- 普通字段在每个对象中都要保存一份
那么什么时候使用静态字段呢?类似全局变量的应用方式: 通过类创建对象时,如果每个对象都具有相同的字段,那么就使用静态字段。
二、方法
方法包括:普通方法、静态方法和类方法,三种方法无论是在代码中还是内存中都归属于类,区别在于传入的参数和调用方式不同。
- 普通方法:由对象调用;至少一个self参数;执行普通方法时,自动将调用该方法的对象赋值给self;
- 类方法: 由类调用,采用@classmethod装饰,至少闯入一个cls(代指类本身,类似self)参数;执行类方法时,自动将调用该方法的类赋值给cls;与对象无关。类方法是python语言独有的方法类型,建议只使用类名.类方法的调用方式。(虽然也可以使用对象名.类方法的方式调用)
- 静态方法:由类调用;无默认参数。将普通方法参数中的self去掉,然后在方法定义上方加上@staticmethod,就成为静态方法。它属于类,和对象无关。建议只使用类名.静态方法的调用方式。(虽然也可以使用对象名.静态方法的方式调用)
下面是三种方法的定义和调用方式
class Foo: def __init__(self, name): self.name = name def ord_func(self): """ 定义普通方法,至少有一个self参数 """ print(‘普通方法‘) @classmethod def class_func(cls): """ 定义类方法,至少有一个cls参数 """ print(‘类方法‘) @staticmethod def static_func(): """ 定义静态方法 ,无默认参数""" print(‘静态方法‘) # 调用普通方法 f = Foo() f.ord_func() # 调用类方法 Foo.class_func() # 调用静态方法 Foo.static_func()
三、属性
Python中的属性其实是普通方法的变种。
对于属性,有两个知识点:
- 属性的基本使用
- 属性的两种定义方式
1、属性的基本使用
# ############### 定义 ############### class Foo: def func(self): pass # 定义属性 @property def prop(self): pass # ############### 调用 ############### foo_obj = Foo() foo_obj.func() foo_obj.prop #调用属性
从本质上而言,属性其实就是假装成字段的普通方法!
由属性的定义和调用可以发现属性的几个特点:
- 定义时,在普通方法的基础上添加 @property 装饰器;
- 定义时,属性仅有一个self参数
- 调用时,无需括号(也就是类似字段的调用方式)
方法:foo_obj.func()
属性:foo_obj.prop
字段:foo_obj.name
属性存在意义是:访问属性时可以制造出和访问字段完全相同的假象.至于有什么用,需要实践中去发现。属性由普通方法变种而来,如果Python中没有属性,方法完全可以代替其功能。
2、属性的两种定义方式
属性的定义有两种方式:
- 装饰器 即:在方法上应用装饰器
- 静态字段 即:在类中定义值为property对象的静态字段
装饰器方式:在类的普通方法上应用@property装饰器
# ############### 定义 ############### class Goods(object): @property def price(self): print ‘@property‘ @price.setter def price(self, value): print ‘@price.setter‘ @price.deleter def price(self): print ‘@price.deleter‘ # ############### 调用 ############### obj = Goods() obj.price # 自动执行 @property 修饰的 price 方法,并获取方法的返回值 obj.price = 123 # 自动执行 @price.setter 修饰的 price 方法,并将 123 赋值给方法的参数 del obj.price # 自动执行 @price.deleter 修饰的 price 方法
仔细分析上面的代码,你会发现关键是这么三个东西@property、@方法名.setter、@方法名.deleter修饰。他们其实共同定义了一个属性,只不过是针对该属性的三种不同操作。
最基本的@property下面定义的代码块,决定了类似“result = obj.price"执行什么代码;
@方法名.setter下面定义的代码块,决定了类似“obj.price = xxx"这样的赋值语句执行什么代码;
@方法名.deleter下面定义的代码块,决定了类似“del obj.price "这样的语句具体执行什么代码;(注意,这里的del并非必须是删除某个东西的功能,仅仅是调用方式)
他们分别将三个方法定义为对同一个属性:获取、修改和删除。其实就是price这个属性的一体三面!
class Goods(object): def __init__(self): # 原价 self.original_price = 100 # 折扣 self.discount = 0.8 @property def price(self): # 实际价格 = 原价 * 折扣 new_price = self.original_price * self.discount return new_price @price.setter def price(self, value): self.original_price = value @price.deltter def price(self, value): del self.original_price obj = Goods() obj.price # 获取商品价格 obj.price = 200 # 修改商品原价 del obj.price # 删除商品原价
感觉似乎在哪见过这种类似的东西?setattr()、getattr()、delattr()?还有__setitem__、__getitem__、__delitem__?你是不是发现在python的哲学里处处都有这种东西?我们再来看一下属性的静态字段方式,你的感觉就会更加强烈了!
静态字段方式,创建值为property对象的静态字段
class Foo: def get_bar(self): return ‘wupeiqi‘ BAR = property(get_bar) obj = Foo() reuslt = obj.BAR # 自动调用get_bar方法,并获取方法的返回值 print(reuslt)
property类的构造方法中有个四个参数
- 第一个参数是方法名,调用
对象.属性
时自动触发执行方法 - 第二个参数是方法名,调用
对象.属性 = XXX
时自动触发执行方法 - 第三个参数是方法名,调用
del 对象.属性
时自动触发执行方法 - 第四个参数是字符串,调用
对象.属性.__doc__
,此参数是该属性的描述信息
class Foo: def get_bar(self): return ‘jack‘ # *必须两个参数 def set_bar(self, value): return return ‘set value‘ + value def del_bar(self): return ‘jack‘ BAR = property(get_bar, set_bar, del_bar, ‘description...‘) obj = Foo() obj.BAR # 自动调用第一个参数中定义的方法:get_bar obj.BAR = "andy" # 自动调用第二个参数中定义的方法:set_bar方法,并将“andy”当作参数传入 del Foo.BAR # 自动调用第三个参数中定义的方法:del_bar方法 obj.BAE.__doc__ # 自动获取第四个参数中设置的值:description...
class Goods(object): def __init__(self): # 原价 self.original_price = 100 # 折扣 self.discount = 0.8 def get_price(self): # 实际价格 = 原价 * 折扣 new_price = self.original_price * self.discount return new_price def set_price(self, value): self.original_price = value def del_price(self, value): del self.original_price PRICE = property(get_price, set_price, del_price, ‘价格属性描述...‘) obj = Goods() obj.PRICE # 获取商品价格 obj.PRICE = 200 # 修改商品原价 del obj.PRICE # 删除商品原价
让我们看一下property构造方法的源代码:
def __init__(self, fget=None, fset=None, fdel=None, doc=None): # known special case of property.__init__ """ property(fget=None, fset=None, fdel=None, doc=None) -> property attribute fget is a function to be used for getting an attribute value, and likewise fset is a function for setting, and fdel a function for del‘ing, an attribute. Typical use is to define a managed attribute x: class C(object): def getx(self): return self._x def setx(self, value): self._x = value def delx(self): del self._x x = property(getx, setx, delx, "I‘m the ‘x‘ property.") Decorators make defining new properties or modifying existing ones easy: class C(object): @property def x(self): "I am the ‘x‘ property." return self._x @x.setter def x(self, value): self._x = value @x.deleter def x(self): del self._x # (copied from class doc) """ pass
看见fget=None, fset=None, fdel=None这三个默认参数么?其实就是@property、@方法名.setter、@方法名.deleter。
无论是装饰函数还是静态字段,都只是定义属性的两种方式而已。在实际的项目中,Python WEB框架 Django 的视图中 request.POST 就是使用的静态字段的方式创建的属性。
class WSGIRequest(http.HttpRequest): def __init__(self, environ): script_name = get_script_name(environ) path_info = get_path_info(environ) if not path_info: # Sometimes PATH_INFO exists, but is empty (e.g. accessing # the SCRIPT_NAME URL without a trailing slash). We really need to # operate as if they‘d requested ‘/‘. Not amazingly nice to force # the path like this, but should be harmless. path_info = ‘/‘ self.environ = environ self.path_info = path_info self.path = ‘%s/%s‘ % (script_name.rstrip(‘/‘), path_info.lstrip(‘/‘)) self.META = environ self.META[‘PATH_INFO‘] = path_info self.META[‘SCRIPT_NAME‘] = script_name self.method = environ[‘REQUEST_METHOD‘].upper() _, content_params = cgi.parse_header(environ.get(‘CONTENT_TYPE‘, ‘‘)) if ‘charset‘ in content_params: try: codecs.lookup(content_params[‘charset‘]) except LookupError: pass else: self.encoding = content_params[‘charset‘] self._post_parse_error = False try: content_length = int(environ.get(‘CONTENT_LENGTH‘)) except (ValueError, TypeError): content_length = 0 self._stream = LimitedStream(self.environ[‘wsgi.input‘], content_length) self._read_started = False self.resolver_match = None def _get_scheme(self): return self.environ.get(‘wsgi.url_scheme‘) def _get_request(self): warnings.warn(‘`request.REQUEST` is deprecated, use `request.GET` or ‘ ‘`request.POST` instead.‘, RemovedInDjango19Warning, 2) if not hasattr(self, ‘_request‘): self._request = datastructures.MergeDict(self.POST, self.GET) return self._request @cached_property def GET(self): # The WSGI spec says ‘QUERY_STRING‘ may be absent. raw_query_string = get_bytes_from_wsgi(self.environ, ‘QUERY_STRING‘, ‘‘) return http.QueryDict(raw_query_string, encoding=self._encoding) # ############### 看这里看这里 ############### def _get_post(self): if not hasattr(self, ‘_post‘): self._load_post_and_files() return self._post # ############### 看这里看这里 ############### def _set_post(self, post): self._post = post @cached_property def COOKIES(self): raw_cookie = get_str_from_wsgi(self.environ, ‘HTTP_COOKIE‘, ‘‘) return http.parse_cookie(raw_cookie) def _get_files(self): if not hasattr(self, ‘_files‘): self._load_post_and_files() return self._files # ############### 看这里看这里 ############### POST = property(_get_post, _set_post) FILES = property(_get_files) REQUEST = property(_get_request)
类成员的修饰符
对于每一个类的成员而言都有两种形式:
- 公有成员,在任何地方都能访问
- 私有成员,只有在类的内部才能方法
私有成员和公有成员的定义不同:私有成员命名时,前两个字符是下划线。(特殊成员除外,例如:__init__、__call__、__dict__等)
class C: def __init__(self): self.name = ‘公有字段‘ self.__foo = "私有字段"
私有成员和公有成员的访问限制不同:
静态字段
- 公有静态字段:类可以访问;类内部可以访问;派生类中可以访问
- 私有静态字段:仅类内部可以访问;
class C: name = "公有静态字段" def func(self): print C.name class D(C): def show(self): print C.name C.name # 类访问 obj = C() obj.func() # 类内部可以访问 obj_son = D() obj_son.show() # 派生类中可以访问
class C: __name = "公有静态字段" def func(self): print C.__name class D(C): def show(self): print C.__name C.__name # 类访问 ==> 错误 obj = C() obj.func() # 类内部可以访问 ==> 正确 obj_son = D() obj_son.show() # 派生类中可以访问 ==> 错误
普通字段
- 公有普通字段:对象可以访问;类内部可以访问;派生类中可以访问
- 私有普通字段:仅类内部可以访问;
ps:如果想要强制访问私有字段,可以通过 【对象._类名__私有字段明 】访问(如:obj._C__foo),不建议强制访问私有成员。
class C: def __init__(self): self.foo = "公有字段" def func(self): print self.foo # 类内部访问 class D(C): def show(self): print self.foo # 派生类中访问 obj = C() obj.foo # 通过对象访问 obj.func() # 类内部访问 obj_son = D(); obj_son.show() # 派生类中访问
class C: def __init__(self): self.__foo = "私有字段" def func(self): print self.foo # 类内部访问 class D(C): def show(self): print self.foo # 派生类中访问 obj = C() obj.__foo # 通过对象访问 ==> 错误 obj.func() # 类内部访问 ==> 正确 obj_son = D(); obj_son.show() # 派生类中访问 ==> 错误
方法、属性的访问于上述方式相似,即:私有成员只能在类内部使用
ps:非要访问私有属性的话,可以通过 对象._类__属性名
类的特殊成员
上面介绍了Python的类成员以及成员修饰符,从而了解到类中有字段、方法和属性三大类成员,并且成员名前如果有两个下划线,则表示该成员是私有成员,私有成员只能由类内部调用。无论人或事物往往都有不按套路出牌的情况,Python的类成员也是如此,存在着一些具有特殊含义的成员,详情如下:
1. __doc__
表示类的描述信息。python自建,无需自定义。
class Foo: """ 描述类信息,可被自动收集 """ def func(self): pass print(Foo.__doc__) #输出:类的描述信息
2. __module__ 和 __class__
__module__ 表示当前操作的对象在那个模块
__class__ 表示当前操作的对象的类是什么
python自建,无需自定义。
#!/usr/bin/env python # -*- coding:utf-8 -*- from f1 import Foo obj = Foo() print(obj.__module__) 运行结果: f1
from lib.aa import C obj = C() print(obj.__module__) # 输出 lib.aa,即:输出模块 print(obj.__class__) # 输出 lib.aa.C,即:输出类
3. __init__
构造方法,通过类创建对象时,自动触发执行。
class Foo: def __init__(self, name): self.name = name self.age = 18 obj = Foo(jack‘) # 自动执行类中的 __init__ 方法
4. __del__
析构方法,当对象在内存中被释放时,自动触发执行。
注:此方法一般无须定义,因为Python是一门高级语言,程序员在使用时无需关心内存的分配和释放,因为此工作都是交给Python解释器来执行,所以,析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。
class Foo: def __del__(self): print("我被回收了!")
5. __call__
对象后面加括号,触发执行。前提是用户在类中定义了该方法。
注:构造方法的执行是由创建对象触发的,即:对象 = 类名() ;而对于 __call__ 方法的执行是由对象后加括号触发的,即:对象() 或者 类()()
class Foo: def __init__(self): pass def __call__(self, *args, **kwargs): print(‘__call__‘) obj = Foo() # 执行 __init__ obj() # 执行 __call__
6. __dict__
列出类或对象中的所有成员!非常重要和有用的一个方法,python自建,无需用户自己定义。
上文中我们知道:类的普通字段属于对象;类中的静态字段和方法等属于类,即:
class Province: country = ‘China‘ def __init__(self, name, count): self.name = name self.count = count def func(self, *args, **kwargs): print(‘func‘) # 获取类的成员,即:静态字段、方法、 print(Province.__dict__) # 输出:{‘country‘: ‘China‘, ‘__module__‘: ‘__main__‘, ‘func‘: <function func at 0x10be30f50>, ‘__init__‘: <function __init__ at 0x10be30ed8>, ‘__doc__‘: None} obj1 = Province(‘HeBei‘,10000) print(obj1.__dict__) # 获取 对象obj1 的成员 # 输出:{‘count‘: 10000, ‘name‘: ‘HeBei‘} obj2 = Province(‘HeNan‘, 3888) print(obj2.__dict__) # 获取 对象obj1 的成员 # 输出:{‘count‘: 3888, ‘name‘: ‘HeNan‘}
7. __str__
如果一个类中定义了__str__方法,那么在打印对象时,默认输出该方法的返回值。
这也是一个非常重要的方法,需要用户自己定义。
class Foo: def __str__(self): return ‘jack‘ obj = Foo() print(obj) # 输出:wupeiqi
8、__getitem__、__setitem__、__delitem__
用于索引操作,如字典。以上分别表示获取、设置、删除数据。
这也是非常重要的方法,需要用户自己定义。
我们知道,变量名后面加圆括号,通常代表执行或调用的意思;而在变量名后面加中括号[],通常代表取值的意思。python设计了这三个特殊成员,用于执行与中括号有关的动作。
类似上面属性的定义方法,也分获取、设置和删除三种操作。
a = 变量名[] : 执行__getitem__方法
变量名[] = a : 执行__setitem__方法
del 变量名[] : 执行__delitem__方法
#!/usr/bin/env python # -*- coding:utf-8 -*- class Foo(object): def __getitem__(self, key): print(‘__getitem__‘,key) def __setitem__(self, key, value): print(‘__setitem__‘,key,value) def __delitem__(self, key): print(‘__delitem__‘,key) obj = Foo() result = obj[‘k1‘] # 自动触发执行 __getitem__ obj[‘k2‘] = ‘jack‘ # 自动触发执行 __setitem__ del obj[‘k1‘] # 自动触发执行 __delitem__
9、__getslice__、__setslice__、__delslice__
这三个方法用于分片操作,也就是类似list[1:7:2]。但是在python3中已经被__getitem__、__setitem__、__delitem__所替代。
那么__getitem__、__setitem__、__delitem__是如何区分你是要取值呢?还是要分片呢?通过传入参数的类型!
class Foo: def __init__(self): pass def __getitem__(self, item): print(type(item)) def __setitem__(self, key, value): pass def __delitem__(self, key): pass obj = Foo() result = obj[1] result = obj["key"] result = obj[1:8] 运行结果: <class ‘int‘> <class ‘str‘> <class ‘slice‘>
看到没有?类似obj[1:8]方式调用的时候,传入的参数是个slice类型!
当__getitem__方法接收到一个slice类型的时候就知道要进行切片的相关处理,于是它提供了start、stop和step三个变量,分别表示起始、终止和步长。
class Foo: def __init__(self): pass def __getitem__(self, item): print(type(item)) print("start= ", item.start) print("stop= ", item.stop) print("step= ", item.step) def __setitem__(self, key, value): pass def __delitem__(self, key): pass obj = Foo() result = obj[1:8:2] 运行结果: <class ‘slice‘> start= 1 stop= 8 step= 2
__setitem__和__delitem__方法对切面的处理方式类似。
10. __iter__
迭代器方法!之所以列表、字典、元组可以进行for循环,是因为类型内部定义了 __iter__这个方法。如果用户想让它自定义的类的对象可以被迭代,那么就需要在类中定义这个方法,并且让该方法返回值是一个可迭代的对象。当在代码中利用for循环对对象进行遍历时,就会调用类的这个__iter__方法。看起来很绕,下面的三步能让你感觉清晰。
第一步:
class Foo(object): pass obj = Foo() for i in obj: print(i) # 报错:TypeError: ‘Foo‘ object is not iterable
# 原因是Foo对象不可迭代
第二步:
class Foo(object): def __iter__(self): pass obj = Foo() for i in obj: print(i) # 报错:TypeError: iter() returned non-iterator of type ‘NoneType‘ #原因是 __iter__方法没有返回一个可迭代的对象
第三步:
class Foo(object): def __init__(self, sq): self.sq = sq def __iter__(self): return iter(self.sq) obj = Foo([11,22,33,44]) for i in obj: print(i) # 这下没问题了!
以上步骤可以看出,for循环迭代的其实是 iter([11,22,33,44]) ,所以执行流程可以变更为:
#!/usr/bin/env python # -*- coding:utf-8 -*- obj = iter([11,22,33,44]) for i in obj: print(i)
其实For循环语法内部也就是:
#!/usr/bin/env python # -*- coding:utf-8 -*- obj = iter([11,22,33,44]) while True: val = obj.next() print(val)
python有个yield的强大语法,可以将函数变成生成器,生成的就是个迭代器。
class Foo: def __init__(self): pass def __iter__(self): yield 1 yield 2 yield 3 obj = Foo() for i in obj: print(i) 运行结果: 1 2 3
11. __new__ 和 __metaclass__
阅读以下代码:
class Foo(object): def __init__(self): pass obj = Foo() # obj是通过Foo类实例化的对象 print(type(obj)) # 输出:<class ‘__main__.Foo‘> 表示,obj 对象由Foo类创建 print(type(Foo)) # 输出:<type ‘type‘> 表示,Foo类对象由 type 类创建
有一个概念必须牢记,那就是在Python中一切事物都是对象!。上述代码显示,obj 是通过 Foo 类实例化的对象,Foo类本身也是一个type类创建的对象。obj对象是通过执行Foo类的构造方法创建的,Foo类对象也是通过type类的构造方法创建得。所以,obj对象是Foo类的一个实例,Foo类对象是 type 类的一个实例。
按照上面的理论,那么,创建类就可以有两种方式:
a). 普通方式
class Foo: def __init__(self): pass
b).特殊方式(type类的构造函数)
def func(self): print("i am jack") Foo = type(‘Foo‘, (object,), {‘func‘: func}) #type第一个参数:类名 #type第二个参数:当前类的基类 #type第三个参数:类的成员
那么问题来了,类默认是由 type 类实例化产生,type类中如何实现的创建类?类又是如何创建对象?
答:类中有一个属性 __metaclass__,用来表示该类由谁来实例化创建,所以,我们可以为 __metaclass__ 设置一个type类的派生类,从而查看类创建的过程。
而对于__new__:
在python2.X中
继承自object的新式类才有__new__
__new__至少要有一个参数cls,代表要实例化的类,此参数在实例化时由Python解释器自动提供
__new__必须要有返回值,返回实例化出来的实例,这点在自己实现__new__时要特别注意,可以return父类__new__出来的实例,或者直接是object的__new__出来的实例
__init__有一个参数self,就是这个__new__返回的实例,__init__在__new__的基础上可以完成一些其它初始化的动作,__init__不需要返回值
若__new__没有正确返回当前类cls的实例,那__init__是不会被调用的,即使是父类的实例也不行
由于博主使用的是python3.5,因此上面的代码需要微小的调整一下,主要是object类不接收参数。
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) Foo_obj = Foo("jack") print(Foo_obj.name)
要理解上这一切,核心要点是:类也是由type这个”老祖宗”实例化的对象!
上面的代码执行可以分为两个阶段:
第一阶段:Foo类的实例化过程,它处于obj = Foo("jack")这句代码之前。
1. 在python从上往下顺序执行的过程中发现了__metaclass__ = MyType这么个东西,于是明白了,Foo类需要由MyType这么一个自定义的继承了type类的类来实例化。
2. 自动调用MyType类中的__init__(self, what, bases=None, dict=None)方法创建了类Foo这么个实例化对象。(Foo在MyType眼中就是个对象)
第二阶段:程序执行到obj = Foo("jack")这句的时候
1. 发现这是个对象+括号的语法,还记得前面的__call__么,对了,它就会自动去调用MyType的__call__方法;
2.来到obj = self.__new__(self, *args, **kwargs)这句,右边的self.__new__指向的是谁呢?self就是Foo这个对象,当然是Foo.__new__了。于是程序又返回了。
3.程序发现Foo.__new__()里只有这么一句return object.__new__(cls),这是利用顶级父类object创建一个对象,并将它作为返回值。好吧,我们接着回到MyType;
4.这时候obj = object.__new__(cls)了,开始执行下一句self.__init__(obj)。这是让程序执行Foo的构造方法,传入的参数就是我们刚才获得的返回值obj;
5. 最后self.name = name这一句接收了“jack”参数,于是最终外围的Foo_obj对象被创建了!
很复杂吧?!
一些与类相关的知识点
一、isinstance(obj, cls)
检查是否obj是否是类 cls 或者cls的父类的对象。是则返回True,否则返回False。
class Foo(object): pass obj = Foo() isinstance(obj, Foo)
二、issubclass(sub, super)
检查sub类是否是 super 类的派生类。返回True或False。
class Foo(object): pass class Bar(Foo): pass issubclass(Bar, Foo)
三、父类的调用方式
先看代码:
class A: def __init__(self, name): self.name = name def show(self): print(self.name) return 123 class B(A): def __init__(self, name, age): super(B, self).__init__(name=name) self.age = age def show(self): ret = super(B, self).show() print(self.age) return ret obj = B("jack", 18) ret = obj.show() print(ret) 运行结果: jack 18 123
我们都知道,在子类中如果有与父类同名的成员,那就会覆盖掉父类里的成员。那如果你想强制调用父类的成员呢?使用super函数!这是一个非常强大的函数!
super的语法是类似这样的:super(B, self).show(),需要传入的是子类名和self,调用的是父类里的方法(在这里是show),按父类的方法传入参数。
类综合运用实例一:扩展源代码
我们在实际运用中,往往会碰到需要对源代码进行功能扩展的情况。通常我们不希望修改源代码,因此装饰器的做法就无法利用。一般我们会使用继承父类,并使用super调用父类的方法来实现需求。
有如下模块结构:
其中,backend包下的commons模块是我们的源代码,或者说是很NB,功能很强大的某个现成的框架,假设它的代码如下:
commons.py:
#!/usr/bin/env python # -*- coding:utf-8 -*- class Foo: def f1(self): print("Foo.f1")
有一个Foo类,类里有一个f1函数,它输出一条信息。
settings模块是配置文件,里面有一个ClassName变量,值是个字符串,指向commons里的类名Foo
settings.py:
#!/usr/bin/env python # -*- coding:utf-8 -*- ClassName = "Foo"
而最关键的index模块是我们的程序入口。
index.py:
#!/usr/bin/env python # -*- coding:utf-8 -*- from settings import ClassName from backend import commons def execute(): cls = getattr(commons, ClassName) obj = cls() obj.f1() if __name__ == ‘__main__‘: execute()
通过getattr的反射功能,我们很容易的动态获取到commons模块里的Foo类,并实例化了一个obj对象,然后调用f1函数。这是我们正常情况下利用源代码或类似django这种框架的方法。
那么现在,我要扩展上面的源代码也就是commons里的功能,希望在f1函数执行前后分别进行一定的操作。要怎么办呢?不能用装饰器,它会修改commons模块。解决思路就是利用上面的继承和super方法。
首先我们创建个新的模块lib.py:
#!/usr/bin/env python # -*- coding:utf-8 -*- from backend.commons import Foo class MyFoo(Foo): def f1(self): print("before do something!") super(MyFoo, self).f1() print("after do something!")
它导入了源码的Foo类,并创建了一个MyFoo类继承Foo,同样也定义了一个f1方法,但是在里面使用super调用了原来Foo类中的f1。两条print语句模拟了前后的操作。
其次我们分别修改了另外两个文件:
setting.py:
#!/usr/bin/env python # -*- coding:utf-8 -*- Path = "lib" ClassName = "MyFoo"
配置文件增加了path,指向lib模块,classname也不再指向commons里的Foo,而是lib里的MyFoo。
index.py:
from settings import ClassName from settings import Path def execute(): module = __import__(Path, fromlist=True) cls = getattr(module, ClassName) obj = cls() obj.f1() if __name__ == ‘__main__‘: execute()
利用__import__(Path, fromlist=True)的反射方法,我们动态的加载了lib模块,然后获得了lib里的MyFoo类,再用MyFoo类实例化了一个对象,再用对象调用MyFoo类的f1方法。最后结果是:
before do something!
Foo.f1
after do something!
我们成功的在不修改源代码的情况下,扩展了f1的功能。梳理一下核心:MyFoo的继承,使我们可以不修改源码的同时扩展源码,settings配置文件让我们可以方便的切换模块和类,index里的动态加载使我们不必局限在某一个类或模块里。
类综合运用实例二:自定义有序字典
我们都知道,在python里字典类型是无序的,那么有没有办法实现一个有序字典呢?其实很简单。(这里介绍的是手工编写,不是使用collection模块里的orderedDict)
代码如下:
#!/usr/bin/env python # -*- coding:utf-8 -*- class MyDict(dict): # MyDict类继承python内置的dict类 def __init__(self): self.li = [] # 构造方法中实例对象的时候,添加一个列表,用于保存有序的key super(MyDict, self).__init__() # 调用父类的构造方法 def __setitem__(self, key, value): self.li.append(key) # 每执行一次obj[key] = value的时候就将key添加到列表里 super(MyDict, self).__setitem__(key, value) # 调用父类的__setitem__方法 def __str__(self): # 当执行print(类的对象)语句时,会自动执行该方法。 temp_list = [] # 下面是一个粗糙的格式化输出的控制代码 for key in self.li: value = self.get(key) temp_list.append("‘%s‘:%s" % (key, value)) temp_str = "{" + ",".join(temp_list) + "}" return temp_str if __name__ == ‘__main__‘: # 以下是调用过程 obj = MyDict() obj["k1"] = 123 obj["k2"] = 456 obj["k3"] = "jack" obj["k4"] = "andy" obj["k5"] = [1, 2, 3] print(obj) 运行结果: {‘k1‘:123,‘k2‘:456,‘k3‘:jack,‘k4‘:andy,‘k5‘:[1, 2, 3]}
实际测试中,你会发现,不管你指定多少次,它都是按这个顺序输出字典的内容。
这段代码本身有很多问题,一是只实现了print输出的有序,而没有实现其他情况下的有序,这是偷懒行为。二是只实现了__setitem__,也就是obj[key] = value的执行方式,对于__getitem__
和__delitem__没有实现。三是__str__方法中的代码写得很烂......
其实,以上都不重要。重点是要明白通过保存一个key的有序列表,实现了dict的有序;通过__setitem__的方法,既执行了列表的append操作,又执行了super的__setitem__方法,其中的编程思想闪耀着光辉。
鸣谢:武sir,您的水平之高,让我敬仰万分!
完!不对之处敬请指出,谢谢!
以上是关于python面向对象编程(下)的主要内容,如果未能解决你的问题,请参考以下文章