特殊成员

标签：

class Class1:

def __getitem__(self, item):

print(‘getitem , get:{}, type:{}‘.format(item, type(item)))

def __setitem__(self, key, value):

print(‘setitem , key:{}  value:{},  type:{},type:{}‘.format(key, value, type(key), type(value)))

def __delitem__(self, key):

print(‘delitem,  key:{}, type:{}‘.format(key, type(key)))

# 实例化并调用

obj = Class1()

obj[‘test1‘]                 #“对象索引”，自动触发执行__getitem__()方法

obj[‘test2‘] = ‘value2‘ #“对象索引”赋值，自动触发执行__setitem(key,value) 方法，并将索引的key和值value传给形参

del obj[‘test3‘]           #    删除“对象索引”，自动触发执行 __delitem__(self,key) 方法，并自动将索引的key传递给形参

class Class1:

def __getitem__(self, item):

print(item, type(item))

print(‘item start:{}‘.format(item.start))

print(‘item stop:{}‘.format(item.stop))

print(‘item step:{}‘.format(item.step))

def __setitem__(self, key, value):

print(key, type(key), value, type(value))

print(‘key start:{}‘.format(key.start))

print(‘key stop:{}‘.format(key.stop))

print(‘key step:{}‘.format(key.step))

print(‘value:{}‘.format(value))

def __delitem__(self, key):

print(key, type(key))

print(‘key start:{}‘.format(key.start))

print(‘key stop:{}‘.format(key.stop))

print(‘key step:{}‘.format(key.step))

# 实例化并执行

obj = Class1()

obj[1:2:3]  # 对象切片，会自动执行__getitem__(self, item) 函数，并将[start:stop,step] 传递给 slice 对象

obj[1:2:3] = [1, 2, 3, 4, 5] # 切片赋值，会自动执行__setitem__(slef,key,value) 函数，并将 [start:stop,step] 传递给 slice 对象 key; 值赋给 value

del obj[1:2:3]  # 切片删除，会自动执行__delitem__(self, key) 函数，并将[start:stop,step] 传递给 slice 对象

class Class1:

def __init__(self, ):

self.number = 0

def __iter__(self):

return self    # 拥有__iter__方法的对象，就为迭代器，所以自定义迭代器通常返回对象实例自己

def __next__(self):

if self.number >= 10:

raise StopIteration

else:

self.number += 2

return self.number

# 实例化并执行

obj = Class1()

for x in obj:   

print(x)

#　经常用于执行父类中与子类同名的方法：

class C1:

def f1(self):

print(‘c1.f1‘)

class C2(C1):

def f1(self):

# 表示主动执行父类中的f1方法

super(C2,self).f1()  # 第一中方法

print(‘c2.f1‘)

obj = C2()

--------------------------------公司代码场景

# 老员工NB代码核心逻辑   

   

vim backend/commons

......nb的代码,其中有个Foo类

# 程序配置文件

vim settings.py

Path = ‘bakend.commons‘　// 模块所在路径

ClassName = ‘Foo‘  　　      //所需要的目标类

# 老员工NB代码入口

vim index.py       

from settings import Path        　  类所在模块的路径

from settings import ClassName    所需要调用的类名

def excute():

module = __import(Path,fromlist=True)   ＃　从路径中找到目标模块

cls = getattr(commons, ClassName) 　　＃ 　从目标模块中找到目标类

obj = cls()

obj.func1()   　　　　　　　　　　　　　＃　领导要求对该功能进行封装　，该功能存在于核心逻辑中，核心逻辑文件不能修改，该入口文件也不能改，总之什么都不能改

if __nam__ == ‘__main__‘:

excute()

# 封装功能的文件

vim  lib.py       

from backend.commons import Foo  # 导入要被封装的类

class my_class(Foo):         # 新建一个类，并继承老员工的类

def func1(self):

print(‘before‘)

super(my_class, self).func1()     //执行老员工Foo类中的原本的功能

print(‘after‘)  // 新增功能

# 修改配置文件

vim setting.py

Path = ‘lib‘

ClassName = ‘my_class‘

特殊成员

标签：

原文地址：http://www.cnblogs.com/qiaogy/p/5818668.html