# 动态导入模块，并执行其中函数url = input("url: ")target_host,target_module, target_func = url.split('/')m = __import__('aaa.' + target_module, fromlist=True)inp = url.split("/")[-1]# 分割url,并取出url最后一个字符串if hasattr(m, inp):# 判断在commons模块中是否存在inp这个字符串inp= getattr(m, inp)# 获取inp的引用inp()# 执行else:print("404")

• __getattr__：只有在使用点调用属性且属性不存在的时候才会触发。比较有用
• __delattr__：删除属性的时候会触发
• __setattr__：添加/修改属性会触发它的执行
  当你自己写__getattr__、__delattr__、__setattr__方法，系统会调用你写的方法，如果没写，系统调用默认

class Foo:x = 1def __init__(self, y):self.y = ydef __getattr__(self, item):print('----> from getattr:你找的属性不存在')def __setattr__(self, key, value):print('----> from setattr')# self.key = value# 这就无限递归了,你好好想想# self.__dict__[key] = value# 应该使用它def __delattr__(self, item):print('----> from delattr')# del self.item# 无限递归了self.__dict__.pop(item)f1 = Foo(10)# ----> from setattrprint(f1.__dict__ )# 因为你重写了__setattr__，凡是赋值操作都会触发它的运行，你啥都没写，就是根本没赋值。除非你直接操作属性字典，否则永远无法赋值# {}f1.z = 3# ----> from setattrprint(f1.__dict__)# {}f1.__dict__['a'] = 3# 我们可以直接修改属性字典，来完成添加/修改属性的操作（不会触发__setattr__）del f1.a# ----> from delattr print(f1.__dict__)# {}

class Foo:def __init__(self, x):self.x = xdef __getattribute__(self, item):print('不管是否存在，我都会执行')f1 = Foo(10)f1.x# 不管是否存在，我都会执行f1.xxxxxx# 不管是否存在，我都会执行

class Foo:def __init__(self, x):self.x = xdef __getattr__(self, item):print('执行的是我')# return self.__dict__[item]def __getattribute__(self, item):print('不管是否存在,我都会执行')raise AttributeError('哈哈')f1 = Foo(10)f1.x# 不管是否存在,我都会执行# 执行的是我f1.xxxxxx# 不管是否存在,我都会执行# 执行的是我

• __setitem__:中括号赋值时触发
• __getitem__:中括号取值时触发
• __delitem__：中括号删除时触发
• __delattr__：.删除时触发

class Foo:def __init__(self, name):self.name = namedef __getitem__(self, item):print('getitem执行', self.__dict__[item])def __setitem__(self, key, value):print('setitem执行')self.__dict__[key] = valuedef __delitem__(self, key):print('del obj[key]时，delitem执行')self.__dict__.pop(key)def __delattr__(self, item):print('del obj.key时，delattr执行')self.__dict__.pop(item)f1 = Foo('sb')f1['age'] = 18# setitem执行f1['age1'] = 19# setitem执行f1['age']# getitem执行 18f1['name'] = 'tank'# setitem执行del f1.age1# del obj.key时，delattr执行del f1['age']# del obj[key]时，delitem执行print(f1.__dict__)# {'name': 'tank'}

date_dic = {'ymd': '{0.year}:{0.month}:{0.day}','dmy': '{0.day}/{0.month}/{0.year}','mdy': '{0.month}-{0.day}-{0.year}',}class Date:def __init__(self, year, month, day):self.year = yearself.month = monthself.day = daydef __format__(self, format_spec):# 默认打印ymd的{0.year}:{0.month}:{0.day}格式if not format_spec or format_spec not in date_dic:format_spec = 'ymd'fmt = date_dic[format_spec]return fmt.format(self)d1 = Date(2016, 12, 29)print(format(d1))# 2016:12:29print('{:mdy}'.format(d1))# 12-29-2016

class People:def __init__(self, name, age):self.name = nameself.age = ageself.f = open('test.txt', 'w', encoding='utf-8')def __del__(self):print('run======>')# 做回收系统资源相关的事情self.f.close()obj = People('egon', 18)del obj# del obj会间接删除f的内存占用，但是还需要自定制__del__删除文件的系统占用# run=-====>

class Foo:__slots__ = 'x'f1 = Foo()f1.x = 1f1.y = 2# 报错print(f1.__slots__ )# f1不再有__dict__

class Bar:__slots__ = ['x', 'y']n = Bar()n.x, n.y = 1, 2n.z = 3# 报错

class Foo:'我是描述信息'passprint(Foo.__doc__)# 我是描述信息

class Foo:'我是描述信息'passclass Bar(Foo):passprint(Bar.__doc__)# 该属性无法继承给子类# None

class Foo:def __init__(self):print('__init__触发了')def __call__(self, *args, **kwargs):print('__call__触发了')obj = Foo()# 执行 __init__# __init__触发了obj()# 执行 __call__# __call__

class A:passclass B(A):def __new__(cls):print("__new__方法被执行")return super().__new__(cls)def __init__(self):print("__init__方法被执行")b = B()# __new__方法被执行# __init__方法被执行

# 1、使用init的情况：class CapStr1(str):def __init__(self, string):string = string.upper()a = CapStr1("I love China!")print(a)# I love China!无变化 ！！！！！！！# 2、使用__new__的情况class CapStr2(str):def __new__(cls, string):string = string.upper()return super().__new__(cls, string)a = CapStr2("I love China!")print(a)# I LOVE CHINA!

class Foo:def __init__(self, name, age):"""对象实例化的时候自动触发"""self.name = nameself.age = agedef __str__(self):print('打印的时候自动触发，但是其实不需要print即可打印')return f'{self.name}:{self.age}'# 如果不返回字符串类型，则会报错obj = Foo('nick', 18)print(obj)# obj.__str__() # 打印的时候就是在打印返回值# 打印的时候自动触发，但是其实不需要print即可打印# nick:18

• 如果__str__没有被定义，那么就会使用__repr__来代替输出。
• 注意：这俩方法的返回值必须是字符串，否则抛出异常。

class School:def __init__(self, name, addr, type):self.name = nameself.addr = addrself.type = typedef __repr__(self):return 'School(%s,%s)' % (self.name, self.addr)def __str__(self):return '(%s,%s)' % (self.name, self.addr)s1 = School('oldboy1', '北京', '私立')print('from repr: ', repr(s1))# from repr:School(oldboy1,北京)print('from str: ', str(s1))# from str:(oldboy1,北京)print(s1)# (oldboy1,北京)s1# jupyter属于交互式# School(oldboy1,北京)

• __module__ 表示当前操作的对象在那个模块
• __class__表示当前操作的对象的类是什么

# lib/aa.pyclass C:def __init__(self):self.name = 'SB'# index.pyfrom lib.aa import Cobj = C()print(obj.__module__)# 输出 lib.aa，即：输出模块print(obj.__class__)# 输出 lib.aa.C，即：输出类

• 使用with语句的目的就是把代码块放入with中执行，with结束后，自动完成清理工作，无须手动干预
• 在需要管理一些资源比如文件，网络连接和锁的编程环境中，可以在__exit__中定制自动释放资源的机制，你无须再去关系这个问题，这将大有用处。

class Open:def __init__(self, name):self.name = namedef __enter__(self):print('出现with语句，对象的__enter__被触发，有返回值则赋值给as声明的变量')def __exit__(self, exc_type, exc_val, exc_tb):print('with中代码块执行完毕时执行我啊')print(exc_type)print(exc_val)print(exc_tb)try:with Open('a.txt') as f:print('=====>执行代码块')raise AttributeError('***着火啦，救火啊***')except Exception as e:print(e)# 出现with语句，对象的__enter__被触发，有返回值则赋值给as声明的变量# =====>执行代码块# with中代码块执行完毕时执行我啊# # ***着火啦，救火啊***## ***着火啦，救火啊***

class Open:def __init__(self, name):self.name = namedef __enter__(self):print('出现with语句，对象的__enter__被触发，有返回值则赋值给as声明的变量')def __exit__(self, exc_type, exc_val, exc_tb):print('with中代码块执行完毕时执行我啊')print(exc_type)print(exc_val)print(exc_tb)return Truewith Open('a.txt') as f:print('=====>执行代码块')raise AttributeError('***着火啦，救火啊***')print('0' * 100)# ------------------------------->会执行# 出现with语句，对象的__enter__被触发，有返回值则赋值给as声明的变量# =====>执行代码块# with中代码块执行完毕时执行我啊# # ***着火啦，救火啊***## 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000#

class Open:def __init__(self, filepath, mode='r', encoding='utf-8'):self.filepath = filepathself.mode = modeself.encoding = encodingdef __enter__(self):# print('enter')self.f = open(self.filepath, mode=self.mode, encoding=self.encoding)return self.fdef __exit__(self, exc_type, exc_val, exc_tb):# print('exit')self.f.close()return Truedef __getattr__(self, item):return getattr(self.f, item)with Open('a.txt', 'w') as f:print(f)f.write('aaaaaa')f.wasdf#抛出异常，交给__exit__处理# <_io.TextIOWrapper name='a.txt' mode='w' encoding='utf-8'>

• __get__()：调用一个属性时，触发
• __set__()：为一个属性赋值时，触发
• __delete__()：采用del删除属性时，触发

class Foo:def __get__(self, instance, owner):print('触发get')def __set__(self, instance, value):print('触发set')def __delete__(self, instance):print('触发delete')f1 = Foo()f1.name = 'nick'f1.namedel f1.name#无任何输出结果！！！

class ST:"""描述符Str"""def __get__(self, instance, owner):print('Str调用')def __set__(self, instance, value):print('Str设置...')def __delete__(self, instance):print('Str删除...')class IN:"""描述符Int"""def __get__(self, instance, owner):print('Int调用')def __set__(self, instance, value):print('Int设置...')def __delete__(self, instance):print('Int删除...')class People:name = ST()age = IN()def __init__(self, name, age):# name被ST类代理，age被IN类代理self.name = nameself.age = agep1 = People('alex', 18)# Str设置...# Int设置...p1.name# Str调用p1.name = 'nick'# Str设置...del p1.name# Str删除...p1.age# Int调用p1.age = 18# Int设置...del p1.age# Int删除...print(p1.__dict__)# {}print(People.__dict__)# {'__module__': '__main__', 'name': <__main__.ST object at 0x0000000002167490>, 'age': <__main__.IN object at 0x000000000234A700>, '__init__': , '__dict__': , '__weakref__': , '__doc__': None}print(type(p1) == People)# Trueprint(type(p1).__dict__ == People.__dict__)# True

class Typed:def __init__(self, name, expected_type):self.name = nameself.expected_type = expected_typedef __get__(self, instance, owner):print('get--->', instance, owner)if instance is None:return selfreturn instance.__dict__[self.name]def __set__(self, instance, value):print('set--->', instance, value)if not isinstance(value, self.expected_type):raise TypeError('Expected %s' % str(self.expected_type))instance.__dict__[self.name] = valuedef __delete__(self, instance):print('delete--->', instance)instance.__dict__.pop(self.name)class People:name = Typed('name', str)age = Typed('name', int)salary = Typed('name', float)def __init__(self, name, age, salary):self.name = nameself.age = ageself.salary = salarytry:p1 = People(123, 18, 3333.3)except Exception as e:print(e)# set---> <__main__.People object at 0x1082c7908> 123# Expected try:p1 = People('nick', '18', 3333.3)except Exception as e:print(e)# set---> <__main__.People object at 0x1078dd438> nick# set---> <__main__.People object at 0x1078dd438> 18# Expected p1 = People('nick', 18, 3333.3)# set---> <__main__.People object at 0x1081b3da0> nick# set---> <__main__.People object at 0x1081b3da0> 18# set---> <__main__.People object at 0x1081b3da0> 3333.3

def decorate(cls):print('类的装饰器开始运行啦------>')return cls@decorate# 无参：People = decorate(People)class People:def __init__(self, name, age, salary):self.name = nameself.age = ageself.salary = salaryp1 = People('nick', 18, 3333.3)# 类的装饰器开始运行啦------>

def typeassert(**kwargs):def decorate(cls):print('类的装饰器开始运行啦------>', kwargs)return clsreturn decorate@typeassert( name=str, age=int, salary=float)# 有参：1.运行typeassert(...)返回结果是decorate，此时参数都传给kwargs 2.People=decorate(People)class People:def __init__(self, name, age, salary):self.name = nameself.age = ageself.salary = salaryp1 = People('nick', 18, 3333.3)# 类的装饰器开始运行啦------> {'name': , 'age': , 'salary': }

class Typed:def __init__(self, name, expected_type):self.name = nameself.expected_type = expected_typedef __get__(self, instance, owner):print('get--->', instance, owner)if instance is None:return selfreturn instance.__dict__[self.name]def __set__(self, instance, value):print('set--->', instance, value)if not isinstance(value, self.expected_type):raise TypeError('Expected %s' % str(self.expected_type))instance.__dict__[self.name] = valuedef __delete__(self, instance):print('delete--->', instance)instance.__dict__.pop(self.name)def typeassert(**kwargs):def decorate(cls):print('类的装饰器开始运行啦------>', kwargs)for name, expected_type in kwargs.items():setattr(cls, name, Typed(name, expected_type))return clsreturn decorate@typeassert(name=str, age=int,salary=float)# 有参：1.运行typeassert(...)返回结果是decorate，此时参数都传给kwargs 2.People=decorate(People)class People:def __init__(self, name, age, salary):self.name = nameself.age = ageself.salary = salaryprint(People.__dict__)# 类的装饰器开始运行啦------> {'name': , 'age': , 'salary': }# {'__module__': '__main__', '__init__': , '__dict__': , '__weakref__': , '__doc__': None, 'name': <__main__.Typed object at 0x000000000238F8B0>, 'age': <__main__.Typed object at 0x000000000238FF40>, 'salary': <__main__.Typed object at 0x000000000238FFA0>}p1 = People('nick', 18, 3333.3)# set---> <__main__.People object at 0x0000000001E07490> nick# set---> <__main__.People object at 0x0000000001E07490> 18# set---> <__main__.People object at 0x0000000001E07490> 3333.3

class Lazyproperty:def __init__(self, func):self.func = funcdef __get__(self, instance, owner):print('这是我们自己定制的静态属性，r1.area实际是要执行r1.area()')if instance is None:return selfelse:print('--->')value = https://www.it610.com/article/self.func(instance)setattr(instance, self.func.__name__, value)# 计算一次就缓存到实例的属性字典中return valueclass Room:def __init__(self, name, width, length):self.name = nameself.width = widthself.length = length@Lazyproperty# area=Lazyproperty(area) 相当于'定义了一个类属性,即描述符'def area(self):return self.width * self.lengthr1 = Room('alex', 1, 2)print(r1.area)# 先从自己的属性字典找,没有再去类的中找,然后出发了area的__get__方法# 这是我们自己定制的静态属性，r1.area实际是要执行r1.area()# ---># 2print(r1.area)# 先从自己的属性字典找,找到了,是上次计算的结果,这样就不用每执行一次都去计算# 2

class ClassMethod:def __init__(self, func):self.func = funcdef __get__(self, instance, owner):# 类来调用,instance为None,owner为类本身,实例来调用,instance为实例,owner为类本身,def feedback(*args, **kwargs):print('在这里可以加功能啊...')return self.func(owner, *args, **kwargs)return feedbackclass People:name = 'nick'@ClassMethod# say_hi=ClassMethod(say_hi)def say_hi(cls, msg):print('你好啊,帅哥 %s %s' % (cls.name, msg))People.say_hi('你是那偷心的贼')p1 = People()# 在这里可以加功能啊...# 你好啊,帅哥 nick 你是那偷心的贼p1.say_hi('你是那偷心的贼')# 在这里可以加功能啊...# 你好啊,帅哥 nick 你是那偷心的贼

class StaticMethod:def __init__(self, func):self.func = funcdef __get__(self, instance, owner):# 类来调用，instance为None，owner为类本身，实例来调用，instance为实例，owner为类本身def feedback(*args, **kwargs):print('在这里可以加功能啊...')return self.func(*args, **kwargs)return feedbackclass People:@StaticMethod# say_hi = StaticMethod(say_hi)def say_hi(x, y, z):print('------>', x, y, z)People.say_hi(1, 2, 3)# 在这里可以加功能啊...# ------> 1 2 3p1 = People()p1.say_hi(4, 5, 6)# 在这里可以加功能啊...# ------> 4 5 6

class People:# People=type(...)country = 'China'def __init__(self, name, age):self.name = nameself.age = agedef eat(self):print('%s is eating' % self.name)print(type(People))

• 创建类的3个要素：类名，基类，类的名称空间
• People = type(类名，基类，类的名称空间)

class_name = 'People'# 类名class_bases = (object,)# 基类class_dic = {}# 类的名称空间class_body = """country='China'def __init__(self,name,age):self.name=nameself.age=agedef eat(self):print('%s is eating' %self.name)"""exec(class_body, {}, class_dic, )#执行class_body中的代码，然后把产生的名字丢入class_dic字典中print(class_name)# Peopleprint(class_bases)# (,)print(class_dic)# 类的名称空间# {'country': 'China', '__init__': , 'eat': }People1 = type(class_name, class_bases, class_dic)print(People1)# obj1 = People1(1, 2)obj1.eat()# 1 is eating

• 拿到一个字符串格式的类名class_name='People'
  
• 拿到一个类的基类们class_bases=(obejct,)
  
• 执行类体代码，拿到一个类的名称空间class_dic={...}
  
• 调用People=type(class_name,class_bases,class_dic)
  

class Mymeta(type):# 只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类def __init__(self, class_name, class_bases, class_dic):print('self:', self)# 现在是Peopleprint('class_name:', class_name)print('class_bases:', class_bases)print('class_dic:', class_dic)super(Mymeta, self).__init__(class_name, class_bases, class_dic)# 重用父类type的功能class People(object, metaclass=Mymeta):# People=Mymeta(类名,基类们,类的名称空间)country = 'China'def __init__(self, name, age):self.name = nameself.age = agedef eat(self):print('%s is eating' % self.name)# self: # class_name: People# class_bases: (,)# class_dic: {'__module__': '__main__', '__qualname__': 'People', 'country': 'China', '__init__': , 'eat': }

class Mymeta(type):# 只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类def __init__(self, class_name, class_bases, class_dic):if class_dic.get('__doc__') is None or len(class_dic.get('__doc__').strip()) == 0:raise TypeError('类中必须有文档注释，并且文档注释不能为空')if not class_name.istitle():raise TypeError('类名首字母必须大写')super(Mymeta, self).__init__(class_name, class_bases,class_dic)# 重用父类的功能try:class People(object, metaclass=Mymeta ):# People= Mymeta('People',(object,),{....})#"""这是People类"""country = 'China'def __init__(self, name, age):self.name = nameself.age = agedef eat(self):print('%s is eating' % self.name)except Exception as e:print(e)# 类中必须有文档注释，并且文档注释不能为空

class Mymeta(type):def __call__(self, *args, **kwargs):print(self)# self是Peopleprint(args)# args = ('nick',)print(kwargs)# kwargs = {'age':18}# return 123# 1. 先造出一个People的空对象，申请内存空间# __new__方法接受的参数虽然也是和__init__一样，但__init__是在类实例创建之后调用，而 __new__方法正是创建这个类实例的方法。obj = self.__new__(self)# 虽然和下面同样是People，但是People没有，找到的__new__是父类的# 2. 为该对空对象初始化独有的属性self.__init__(obj, *args, **kwargs)# 3. 返回一个初始化好的对象return objclass People(object, metaclass=Mymeta):# People = Mymeta()，People()则会触发__call__country = 'China'def __init__(self, name, age):self.name = nameself.age = agedef eat(self):print('%s is eating' % self.name)#在调用Mymeta的__call__的时候，首先会找自己（如下函数）的，自己的没有才会找父类的#def __new__(cls, *args, **kwargs):## print(cls)# cls是People## cls.__new__(cls) # 错误，无限死循环，自己找自己的，会无限递归#obj = super(People, cls).__new__(cls)# 使用父类的，则是去父类中找__new__#return objobj = People('nick', age=18)# # ('nick',)# {'age': 18}print(obj.__dict__)# {'name': 'nick', 'age': 18}

class Mymeta(type):def __init__(self, class_name, class_bases, class_dic):# 加上逻辑，控制类Foo的创建super(Mymeta, self).__init__(class_name, class_bases, class_dic)def __call__(self, *args, **kwargs):# 加上逻辑，控制Foo的调用过程，即Foo对象的产生过程obj = self.__new__(self)self.__init__(obj, *args, **kwargs)# 修改属性为隐藏属性obj.__dict__ = {'_%s__%s' % (self.__name__, k): vfor k, v in obj.__dict__.items()}return objclass Foo(object, metaclass=Mymeta):# Foo = Mymeta(...)def __init__(self, name, age, sex):self.name = nameself.age = ageself.sex = sexobj = Foo('nick', 18, 'male')print(obj.age)# 'Foo' object has no attribute 'age'print(obj.__dict__)# {'_Foo__name': 'egon', '_Foo__age': 18, '_Foo__sex': 'male'}

NAME = 'nick'AGE = 18class Mymeta(type):def __init__(self,class_name,class_bases,class_dict):super().__init__(class_name,class_bases,class_dict)self.__instance = self(NAME,AGE)def __call__(self,*args,**kwargs):if len(args) == 0 and len(kwargs) == 0:return self.__instanceobj = object.__new__(self)self.__init__(obj,*args,**kwargs)return objclass People(metaclass=Mymeta):def __init__(self,name,age):self.name = nameself.age = agepeo1 = People()peo2 = People()

推荐阅读

• 

  奥迪a65缸没压力怎么修 奥迪a6一个缸没压力
• 

  今日浙江无缝钢管成品今日价格
• 

  支付宝女神节餐饮享五折如何领取？支付宝女神节餐饮五折领取教程
• 

  鞋子上eur是什么意思
• 

  信用卡欠款9个月还不了会坐牢吗
• 

  奥林匹克是什么意思 奥林匹克的解释
• 

  ALS推荐系统实战
• 

  伸缩晾衣杆好吗 升降晾衣杆有什么优点
• 

  送外卖大概多少钱一单？新手送外卖如何做到月入过万？
• 

  教师的6个主要的事业角色是什么
• 

  d女郎怎么用方法 滨海d女郎
• 

  杨幂如何接吻视频
• 

  部落冲突康庄大道怎么打
• 

  豌豆发芽了还可以吃吗
• 

  高中孩子厌学还有救吗 高中孩子厌学家长应该怎么办
• 

  irfp250n场效应管代换 场效应管代换原则
• 

  微波炉蒸鸡蛋羹几分钟用什么火
• 

  甲状腺肿大不能吃什么 甲状腺肿大不能吃什么?
• 

  plaaf pk是哪里
• 

  python爬虫课程骗局，python爬虫课程多少钱

• Python特效之文字成像方法详解
• 教你python tkinter实现简单计算器功能
• #yyds干货盘点# Python网络爬虫之js逆向之远程调用(rpc)免去抠代码补环境简介
• #yyds干货盘点# python-redis-lock锁
• #yyds干货盘点#Python图像处理，cv2模块，OpenCV实现模板匹配
• Python训练营Python每日一练----第15天:字串排序
• Python和C#之间有什么区别（）
• Python（算法|Python:递归算法(基础)）
• python数据结构|python数据结构——递归recursion
• #指尖人生#面向对象设计常用的设计模式-简单工厂模式