Python学习第二十天元类

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Python学习第二十天元类，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含14458字，纯文字阅读大概需要21分钟。

内容图文

https://www.cnblogs.com/linhaifeng/articles/8029564.html

一前言

元类属于python面向对象编程的深层魔法，99%的人都不得要领，一些自以为搞明白元类的人其实也只是自圆其说、点到为止，从对元类的控制上来看就破绽百出、逻辑混乱，今天我就来带大家来深度了解python元类的来龙去脉。

笔者深入浅出的背后是对技术一日复一日的执念，希望可以大家可以尊重原创，为大家能因此文而解开对元类所有的疑惑而感到开心！！！

二什么是元类

一切源自于一句话：python中一切皆为对象。让我们先定义一个类，然后逐步分析

class OldboyTeacher(object):
    school='oldboy'

    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print('%s says welcome to the oldboy to learn Python' %self.name)

所有的对象都是实例化或者说调用类而得到的（调用类的过程称为类的实例化），比如对象t1是调用类OldboyTeacher得到的

t1=OldboyTeacher('egon',18)
print(type(t1)) #查看对象t1的类是<class '__main__.OldboyTeacher'>

如果一切皆为对象，那么类OldboyTeacher本质也是一个对象，既然所有的对象都是调用类得到的，那么OldboyTeacher必然也是调用了一个类得到的，这个类称为元类

于是我们可以推导出===>产生OldboyTeacher的过程一定发生了：OldboyTeacher=元类(...)

print(type(OldboyTeacher)) # 结果为<class 'type'>，证明是调用了type这个元类而产生的OldboyTeacher，即默认的元类为type

Python学习第二十天元类 - 文章图片

三 class关键字创建类的流程分析

上文我们基于python中一切皆为对象的概念分析出：我们用class关键字定义的类本身也是一个对象，负责产生该对象的类称之为元类（元类可以简称为类的类），内置的元类为type

class关键字在帮我们创建类时，必然帮我们调用了元类OldboyTeacher=type(...)，那调用type时传入的参数是什么呢？必然是类的关键组成部分，一个类有三大组成部分，分别是

1、类名class_name='OldboyTeacher'

2、基类们class_bases=(object,)

3、类的名称空间class_dic，类的名称空间是执行类体代码而得到的

调用type时会依次传入以上三个参数

综上，class关键字帮我们创建一个类应该细分为以下四个过程

补充：exec的用法 ?

#exec：三个参数
#参数一：包含一系列python代码的字符串
#参数二：全局作用域（字典形式），如果不指定，默认为globals()
#参数三：局部作用域（字典形式），如果不指定，默认为locals()

#可以把exec命令的执行当成是一个函数的执行，会将执行期间产生的名字存放于局部名称空间中
g={
    'x':1,
    'y':2
}
l={}

exec('''
global x,z
x=100
z=200

m=300
''',g,l)

print(g) #{'x': 100, 'y': 2,'z':200,......}
print(l) #{'m': 300}

五自定义元类控制类OldboyTeacher的创建

一个类没有声明自己的元类，默认他的元类就是type，除了使用内置元类type，我们也可以通过继承type来自定义元类，然后使用metaclass关键字参数为一个类指定元类

class Mymeta(type): #只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类
    pass

class OldboyTeacher(object,metaclass=Mymeta): # OldboyTeacher=Mymeta('OldboyTeacher',(object),{...})
    school='oldboy'

    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print('%s says welcome to the oldboy to learn Python' %self.name)

自定义元类可以控制类的产生过程，类的产生过程其实就是元类的调用过程,即OldboyTeacher=Mymeta('OldboyTeacher',(object),{...})，调用Mymeta会先产生一个空对象OldoyTeacher，然后连同调用Mymeta括号内的参数一同传给Mymeta下的__init__方法，完成初始化，于是我们可以

class Mymeta(type): #只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类
    def __init__(self,class_name,class_bases,class_dic):
        # print(self) #<class '__main__.OldboyTeacher'>
        # print(class_bases) #(<class 'object'>,)
        # print(class_dic) #{'__module__': '__main__', '__qualname__': 'OldboyTeacher', 'school': 'oldboy', '__init__': <function OldboyTeacher.__init__ at 0x102b95ae8>, 'say': <function OldboyTeacher.say at 0x10621c6a8>}
        super(Mymeta, self).__init__(class_name, class_bases, class_dic)  # 重用父类的功能

        if class_name.islower():
            raise TypeError('类名%s请修改为驼峰体' %class_name)

        if '__doc__' not in class_dic or len(class_dic['__doc__'].strip(' \n')) == 0:
            raise TypeError('类中必须有文档注释，并且文档注释不能为空')

class OldboyTeacher(object,metaclass=Mymeta): # OldboyTeacher=Mymeta('OldboyTeacher',(object),{...})
    """
    类OldboyTeacher的文档注释
    """
    school='oldboy'

    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print('%s says welcome to the oldboy to learn Python' %self.name)

六自定义元类控制类OldboyTeacher的调用

储备知识：__call__

class Foo:
    def __call__(self, *args, **kwargs):
        print(self)
        print(args)
        print(kwargs)

obj=Foo()
#1、要想让obj这个对象变成一个可调用的对象，需要在该对象的类中定义一个方法__call__方法，该方法会在调用对象时自动触发
#2、调用obj的返回值就是__call__方法的返回值
res=obj(1,2,3,x=1,y=2)

由上例得知，调用一个对象，就是触发对象所在类中的__call__方法的执行，如果把OldboyTeacher也当做一个对象，那么在OldboyTeacher这个对象的类中也必然存在一个__call__方法

class Mymeta(type): #只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类
    def __call__(self, *args, **kwargs):
        print(self) #<class '__main__.OldboyTeacher'>
        print(args) #('egon', 18)
        print(kwargs) #{}
        return 123

class OldboyTeacher(object,metaclass=Mymeta):
    school='oldboy'

    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print('%s says welcome to the oldboy to learn Python' %self.name)



# 调用OldboyTeacher就是在调用OldboyTeacher类中的__call__方法
# 然后将OldboyTeacher传给self,溢出的位置参数传给*，溢出的关键字参数传给**
# 调用OldboyTeacher的返回值就是调用__call__的返回值
t1=OldboyTeacher('egon',18)
print(t1) #123

默认地，调用t1=OldboyTeacher('egon',18)会做三件事

1、产生一个空对象obj

2、调用__init__方法初始化对象obj

3、返回初始化好的obj

对应着，OldboyTeacher类中的__call__方法也应该做这三件事

class Mymeta(type): #只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类
    def __call__(self, *args, **kwargs): #self=<class '__main__.OldboyTeacher'>
        #1、调用__new__产生一个空对象obj
        obj=self.__new__(self) # 此处的self是类OldoyTeacher，必须传参，代表创建一个OldboyTeacher的对象obj

        #2、调用__init__初始化空对象obj
        self.__init__(obj,*args,**kwargs)

        #3、返回初始化好的对象obj
        return obj

class OldboyTeacher(object,metaclass=Mymeta):
    school='oldboy'

    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print('%s says welcome to the oldboy to learn Python' %self.name)

t1=OldboyTeacher('egon',18)
print(t1.__dict__) #{'name': 'egon', 'age': 18}

上例的__call__相当于一个模板，我们可以在该基础上改写__call__的逻辑从而控制调用OldboyTeacher的过程，比如将OldboyTeacher的对象的所有属性都变成私有的

class Mymeta(type): #只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类
    def __call__(self, *args, **kwargs): #self=<class '__main__.OldboyTeacher'>
        #1、调用__new__产生一个空对象obj
        obj=self.__new__(self) # 此处的self是类OldoyTeacher，必须传参，代表创建一个OldboyTeacher的对象obj

        #2、调用__init__初始化空对象obj
        self.__init__(obj,*args,**kwargs)

        # 在初始化之后，obj.__dict__里就有值了
        obj.__dict__={'_%s__%s' %(self.__name__,k):v for k,v in obj.__dict__.items()}
        #3、返回初始化好的对象obj
        return obj

class OldboyTeacher(object,metaclass=Mymeta):
    school='oldboy'

    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print('%s says welcome to the oldboy to learn Python' %self.name)

t1=OldboyTeacher('egon',18)
print(t1.__dict__) #{'_OldboyTeacher__name': 'egon', '_OldboyTeacher__age': 18}

上例中涉及到查找属性的问题，比如self.__new__，请看下一小节

六再看属性查找

结合python继承的实现原理+元类重新看属性的查找应该是什么样子呢？？？

在学习完元类后，其实我们用class自定义的类也全都是对象（包括object类本身也是元类type的一个实例，可以用type(object)查看），我们学习过继承的实现原理，如果把类当成对象去看，将下述继承应该说成是：对象OldboyTeacher继承对象Foo，对象Foo继承对象Bar，对象Bar继承对象object

class Mymeta(type): #只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类
    n=444

    def __call__(self, *args, **kwargs): #self=<class '__main__.OldboyTeacher'>
        obj=self.__new__(self)
        self.__init__(obj,*args,**kwargs)
        return obj

class Bar(object):
    n=333

class Foo(Bar):
    n=222

class OldboyTeacher(Foo,metaclass=Mymeta):
    n=111

    school='oldboy'

    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print('%s says welcome to the oldboy to learn Python' %self.name)


print(OldboyTeacher.n) #自下而上依次注释各个类中的n=xxx，然后重新运行程序，发现n的查找顺序为OldboyTeacher->Foo->Bar->object->Mymeta->type

于是属性查找应该分成两层，一层是对象层（基于c3算法的MRO）的查找，另外一个层则是类层（即元类层）的查找

Python学习第二十天元类 - 文章图片

#查找顺序：
#1、先对象层：OldoyTeacher->Foo->Bar->object
#2、然后元类层：Mymeta->type

依据上述总结，我们来分析下元类Mymeta中__call__里的self.__new__的查找

class Mymeta(type): 
    n=444

    def __call__(self, *args, **kwargs): #self=<class '__main__.OldboyTeacher'>
        obj=self.__new__(self)
        print(self.__new__ is object.__new__) #True


class Bar(object):
    n=333

    # def __new__(cls, *args, **kwargs):
    #     print('Bar.__new__')

class Foo(Bar):
    n=222

    # def __new__(cls, *args, **kwargs):
    #     print('Foo.__new__')

class OldboyTeacher(Foo,metaclass=Mymeta):
    n=111

    school='oldboy'

    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print('%s says welcome to the oldboy to learn Python' %self.name)


    # def __new__(cls, *args, **kwargs):
    #     print('OldboyTeacher.__new__')


OldboyTeacher('egon',18) #触发OldboyTeacher的类中的__call__方法的执行，进而执行self.__new__开始查找

总结，Mymeta下的__call__里的self.__new__在OldboyTeacher、Foo、Bar里都没有找到__new__的情况下，会去找object里的__new__，而object下默认就有一个__new__，所以即便是之前的类均未实现__new__,也一定会在object中找到一个，根本不会、也根本没必要再去找元类Mymeta->type中查找__new__

我们在元类的__call__中也可以用object.__new__(self)去造对象

Python学习第二十天元类 - 文章图片

但我们还是推荐在__call__中使用self.__new__（self）去创造空对象，因为这种方式会检索三个类OldboyTeacher->Foo->Bar,而object.__new__则是直接跨过了他们三个

最后说明一点

class Mymeta(type): #只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类
    n=444

    def __new__(cls, *args, **kwargs):
        obj=type.__new__(cls,*args,**kwargs) # 必须按照这种传值方式
        print(obj.__dict__)
        # return obj # 只有在返回值是type的对象时，才会触发下面的__init__
        return 123

    def __init__(self,class_name,class_bases,class_dic):
        print('run。。。')


class OldboyTeacher(object,metaclass=Mymeta): #OldboyTeacher=Mymeta('OldboyTeacher',(object),{...})
    n=111

    school='oldboy'

    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print('%s says welcome to the oldboy to learn Python' %self.name)


print(type(Mymeta)) #<class 'type'>
# 产生类OldboyTeacher的过程就是在调用Mymeta，而Mymeta也是type类的一个对象，那么Mymeta之所以可以调用，一定是在元类type中有一个__call__方法
# 该方法中同样需要做至少三件事：
# class type:
#     def __call__(self, *args, **kwargs): #self=<class '__main__.Mymeta'>
#         obj=self.__new__(self,*args,**kwargs) # 产生Mymeta的一个对象
#         self.__init__(obj,*args,**kwargs) 
#         return obj

七练习题

练习一：在元类中控制把自定义类的数据属性都变成大写

class Mymetaclass(type):
    def __new__(cls,name,bases,attrs):
        update_attrs={}
        for k,v in attrs.items():
            if not callable(v) and not k.startswith('__'):
                update_attrs[k.upper()]=v
            else:
                update_attrs[k]=v
        return type.__new__(cls,name,bases,update_attrs)

class Chinese(metaclass=Mymetaclass):
    country='China'
    tag='Legend of the Dragon' #龙的传人
    def walk(self):
        print('%s is walking' %self.name)


print(Chinese.__dict__)
'''
{'__module__': '__main__',
 'COUNTRY': 'China', 
 'TAG': 'Legend of the Dragon',
 'walk': <function Chinese.walk at 0x0000000001E7B950>,
 '__dict__': <attribute '__dict__' of 'Chinese' objects>,                                         
 '__weakref__': <attribute '__weakref__' of 'Chinese' objects>,
 '__doc__': None}
'''

练习二：在元类中控制自定义的类无需__init__方法

　　1.元类帮其完成创建对象，以及初始化操作；

　　2.要求实例化时传参必须为关键字形式，否则抛出异常TypeError: must use keyword argument

　　3.key作为用户自定义类产生对象的属性，且所有属性变成大写

class Mymetaclass(type):
    # def __new__(cls,name,bases,attrs):
    #     update_attrs={}
    #     for k,v in attrs.items():
    #         if not callable(v) and not k.startswith('__'):
    #             update_attrs[k.upper()]=v
    #         else:
    #             update_attrs[k]=v
    #     return type.__new__(cls,name,bases,update_attrs)

    def __call__(self, *args, **kwargs):
        if args:
            raise TypeError('must use keyword argument for key function')
        obj = object.__new__(self) #创建对象，self为类Foo

        for k,v in kwargs.items():
            obj.__dict__[k.upper()]=v
        return obj

class Chinese(metaclass=Mymetaclass):
    country='China'
    tag='Legend of the Dragon' #龙的传人
    def walk(self):
        print('%s is walking' %self.name)


p=Chinese(name='egon',age=18,sex='male')
print(p.__dict__)

练习三：在元类中控制自定义的类产生的对象相关的属性全部为隐藏属性

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):v for k,v in obj.__dict__.items()}

        return obj

class Foo(object,metaclass=Mymeta):  # Foo=Mymeta(...)
    def __init__(self, name, age,sex):
        self.name=name
        self.age=age
        self.sex=sex


obj=Foo('egon',18,'male')
print(obj.__dict__)

练习四：基于元类实现单例模式

#步骤五：基于元类实现单例模式
# 单例：即单个实例，指的是同一个类实例化多次的结果指向同一个对象，用于节省内存空间
# 如果我们从配置文件中读取配置来进行实例化，在配置相同的情况下，就没必要重复产生对象浪费内存了
#settings.py文件内容如下
HOST='1.1.1.1'
PORT=3306

#方式一:定义一个类方法实现单例模式
import settings

class Mysql:
    __instance=None
    def __init__(self,host,port):
        self.host=host
        self.port=port

    @classmethod
    def singleton(cls):
        if not cls.__instance:
            cls.__instance=cls(settings.HOST,settings.PORT)
        return cls.__instance


obj1=Mysql('1.1.1.2',3306)
obj2=Mysql('1.1.1.3',3307)
print(obj1 is obj2) #False

obj3=Mysql.singleton()
obj4=Mysql.singleton()
print(obj3 is obj4) #True



#方式二：定制元类实现单例模式
import settings

class Mymeta(type):
    def __init__(self,name,bases,dic): #定义类Mysql时就触发

        # 事先先从配置文件中取配置来造一个Mysql的实例出来
        self.__instance = object.__new__(self)  # 产生对象
        self.__init__(self.__instance, settings.HOST, settings.PORT)  # 初始化对象
        # 上述两步可以合成下面一步
        # self.__instance=super().__call__(*args,**kwargs)


        super().__init__(name,bases,dic)

    def __call__(self, *args, **kwargs): #Mysql(...)时触发
        if args or kwargs: # args或kwargs内有值
            obj=object.__new__(self)
            self.__init__(obj,*args,**kwargs)
            return obj

        return self.__instance




class Mysql(metaclass=Mymeta):
    def __init__(self,host,port):
        self.host=host
        self.port=port



obj1=Mysql() # 没有传值则默认从配置文件中读配置来实例化，所有的实例应该指向一个内存地址
obj2=Mysql()
obj3=Mysql()

print(obj1 is obj2 is obj3)

obj4=Mysql('1.1.1.4',3307)



#方式三:定义一个装饰器实现单例模式
import settings

def singleton(cls): #cls=Mysql
    _instance=cls(settings.HOST,settings.PORT)

    def wrapper(*args,**kwargs):
        if args or kwargs:
            obj=cls(*args,**kwargs)
            return obj
        return _instance

    return wrapper


@singleton # Mysql=singleton(Mysql)
class Mysql:
    def __init__(self,host,port):
        self.host=host
        self.port=port

obj1=Mysql()
obj2=Mysql()
obj3=Mysql()
print(obj1 is obj2 is obj3) #True

obj4=Mysql('1.1.1.3',3307)
obj5=Mysql('1.1.1.4',3308)
print(obj3 is obj4) #False

内容总结

以上是互联网集市为您收集整理的Python学习第二十天元类全部内容，希望文章能够帮你解决Python学习第二十天元类所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/633058.html

来源：【匿名】

【上一篇】Excel+Python：分组名单【下一篇】浅谈PHP运行Python脚本的方法

更多 ►

【Python学习第二十天元类】教程文章相关的互联网学习教程文章

文件的读写：file.flush() # 强制刷新file.readlines() # 将所有的内容生成一个列表，不适合操作大文件for line in file: # file相当于一个迭代器，内存上只读一行，占用内存少，高端的方法f.tell() # 当前句柄，和指针差不多f.encoing # 返回编码原文：http://www.cnblogs.com/sxhui/p/6204667.html

python学习笔记之-for循环

for循环需要预先设定好循环的次数(n)，然后执行隶属于for的语句n次。基本构造是 for 元素 in 序列: statement 举例来说，我们编辑一个叫forDemo.py的文件 for a in [3,4.4,‘life‘]: print a 这个循环就是每次从表[3,4.4,‘life‘] 中取出一个元素（回忆：表是一种序列），然后将这个元素赋值给a，之后执行隶属于for的操作(print)。介绍一个新的Python函数range()，来帮助你建立表。 idx = range(5) print idx 可以看到...

python学习笔记回忆录【代码】

1、print“ ”，print‘ ’ ：输出内容到屏幕，可以是变量、字符串、数字2、SyntaxError: 语法错误3、编码：python脚本默认使用 ASCII 编码，在代码开头加上 # -*- coding: utf-8 -* / # coding=UTF-8 ，在脚本中使用了 unicode UTF-8 编码4、字符串格式化输出：字符串可以包含格式化字符 %s，只要将格式化的变量放到字符串中。例子：1# coding=UTF-82 name = "lily"3 age = 20 4 hobby = "coding"5print"I am %s，my age is...

Python学习杂记_4_分支和循环【图】

分支和循环分支和循环这俩结构在各语言中都有着很重要的地位，当然我之前都没有学好，这里总结一下在Python学习中对这俩结构的认识。分支结构# 单分支if 条件判断:执行语句… # 双分支if 条件判断: 执行语句…else: 执行语句… #多分支if 条件判断: 执行语句…elif: 执行语句…else: 执行语句… 循环结构1. while循环，需要定义循环变量来控制循环。i = 0初始化一个控制...

python学习_day30_基于tcp协议的粘包现象【代码】

1、基于远程执行命令的程序　　需用到subprocess模块服务端：#1、执行客户端发送的指令import socket import subprocess phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) phone.bind((‘127.0.0.1‘,8090)) phone.listen(5) while True:conn,addr=phone.accept()print(‘IP:%s PORT:%s‘ %(addr[0],addr[1]))while True:try:cmd=conn.recv(1024)ifnot cmd:break#执行命令obj=subprocess.Popen(cmd.decode(‘utf-8‘),shel...

【Python学习之旅】---socket编程（基于TCP/UDP编程）【图】

原文：https://www.cnblogs.com/chenyuxia/p/12271080.html

Python学习---Java和Python的区别小记

Java和Python的区别小记注意这里使用的是 and/or/not 非java中的&&，||,!Java中的true是小写 Python中函数就是对象，函数和我们之前的[1,2,3],‘abc‘,8等一样都是对象 Python既可以函数式编程，也可以用面向对象编程 Python的类可以继承多个类，Java和C#中则只能继承一个类 Python利用and or来进行与或的操作 Python的类如果继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先和广度优先 Python中一切事物都是对象 Py...

Python 学习之二：Python超短教程【代码】

前言本教程综合Stanford CS231N和UC Berkerley CS188的Python教程。教程很短，但适合有一定编程基础，学过其他语言的童鞋。Python启动Python 解释器Python可以有两种使用方式，一种就是使用解释器interpreter，类似Matlab，输入一行代码，运行一行；另一种就是编写一个py后缀的文档，称为脚本，然后python xxx.py运行脚本script。这里我们使用解释器。在已安装Python的情况下，在Terminal输入python，可以启动Python：FloodSur...

Python学习——实现简单的交互raw_input的使用【代码】

row_input的使用：>>> name=raw_input("please input your name:") please input your name:xiaobai >>> name ‘xiaobai‘编写小程序，询问用户姓名，性别，年龄，工作，工资，以格式化的方式输出：Information of company stuff：Name：Age：Sex：Job：代码：[root@nfs-server ~]# vim information_of_stuff.py #!/bin/python name=raw_input("Please input your name:") age=raw_input("Please input your age:") sex=raw_inp...

Python学习笔记__2.4章递归函数

# 这是学习廖雪峰老师python教程的学习笔记在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。使用递归函数写一个阶乘函数：def fact(n): if n==1: return 1 return n * fact(n - 1)计算过程：===> fact(5)===>5 * fact(4)===>5 * (4 * fact(3))===>5 * (4 * (3 * fact(2)))===>5 * (4 * (3 * (2 * fact(1))))===>5 * (4 * (3 * (2 * 1)))===>5 * (4 * (3 * 2))===>5 * (4 * ...

Python学习笔记四：过程控制【代码】

条件语句：#以缩进来区分表示同一范围。 1# coding=utf8 2# 例1：if 基本用法 3 4 flag = False5 name = ‘luren‘ 6if name == ‘python‘: # 判断变量否为‘python‘ 7 flag = True # 条件成立时设置标志为真 8print‘welcome boss‘# 并输出欢迎信息 9else: 10print name # 条件不成立时输出变量名称多重判断： 1# coding=utf8 2# 例2：elif用法 3 4 num = 5 5if num == 3: #...

python学习笔记-第一天（Linux基本操作与Python的基础）【图】

我有两台电脑,一台台式一台笔记本，笔记本是老电脑了。本机就装的kali linux。之前白天学习的时候直接在python的解释器里写的代码。但是如果要写文件的话肯定不行。所以就在台式机上弄个了elementaryos的虚拟机来写。首先说一下我的学习方法吧。那就是不停的敲，文章里面抓住重点的关键词。例如if（判断）之类的.然后不停的敲，我是一开始会记不住那么多，但是你忘记了看一下你忘记的，再敲。记得差不多了之后会报错，因为有些字符...

20200527----python学习第21天【代码】

今日内容　　嵌套　　特殊方法：__init__　　type/isinstance/issubclass/super　　异常处理内容回顾　　#函数执行def login(): passlogin()#执行函数#类创建对象，调用方法class Account: def login(self): passobj = Account()obj.login()#1.谈谈你了解的面向对象？#2.类和对象是什么关系？对象是类创建的一个示例。class Foo: def __init__(self,name): self.name = name def run(self): pass...

Python学习记录——Ubuntu（五）Vim【图】

一.工作模式切换二.Vim命令小抄三.操作命令1.进入vi的命令：（1）vi filename :打开或新建文件，并将光标置于第一行首（2）vi +n filename ：打开文件，并将光标置于第n行首（3）vi + filename ：打开文件，并将光标置于最后一行首（4）vi +/pattern filename：打开文件，并将光标置于第一个与pattern匹配的串处（5）vi -r filename ：在上次正用vi编辑时发生系统崩溃，恢复filename （6）vi filename....filename ：打开多个文...

Python学习————logging模块和re【代码】【图】

logging模块一日志级别CRITICAL = 50 #FATAL = CRITICAL ERROR = 40 WARNING = 30 #WARN = WARNING INFO = 20 DEBUG = 10 NOTSET = 0 #不设置二默认级别为warning，默认打印到终端import logginglogging.debug(‘调试debug‘) logging.info(‘消息info‘) logging.warning(‘警告warn‘) logging.error(‘错误error‘) logging.critical(‘严重critical‘)‘‘‘ WARNING:root:警告warn ERROR:root:错误error CRITICAL:root:严重...

PYTHON - 技术教程分类

Python3 教程 Python3 简介 Python3 环境搭建 Python3 基础语法 Python3 基本数据类型 Python3 解释器 Python3 注释 Python3 运算符 Python3 数字(Number) Python3 字符串 Python3 列表 Python3 元组 Python3 字典 Python3 集合 Python3 编程第一步 Python3 条件控制 Python3 循环语句 Python3 迭代器与生成器 Python3 函数 Python3 数据结构 Python3 模块 Python3 输入和输出 Python3 File Python3 OS Python3 错误和异常 Python3 面向对象 Python3 命名空间/作用域 Python3 标准库概览 Python3 实例 Python3 CGI编程 Python3 MySQL(PyMySQL) Python3 网络编程 Python3 SMTP发送邮件 Python3 多线程 Python3 日期和时间 Python3 内置函数 Python3 MongoDB Python3 urllib python 全部

PYTHON - 最热教程

python如何统计字符串中字母个数？使用Python进行微信公众号开发（三）回...Python+PyQT5的子线程更新UI界面的实例 python时间戳怎么获得？如何获得当前时...vscode调试python时提示无法将“conda”...python接口自动化全局变量access_token...python收取邮件(腾讯企业邮箱)python如何绘制降水图详解python并发获取snmp信息及性能测试...怎么卸载Python3.6？

首页 / PYTHON / Python学习第二十天元类

Python学习第二十天元类

内容导读

内容图文

https://www.cnblogs.com/linhaifeng/articles/8029564.html

一前言

二什么是元类

三 class关键字创建类的流程分析

五自定义元类控制类OldboyTeacher的创建

六自定义元类控制类OldboyTeacher的调用

六再看属性查找

七练习题

内容总结

内容备注

内容手机端

【Python学习第二十天元类】教程文章相关的互联网学习教程文章

python学习

python学习笔记之-for循环

python学习笔记回忆录【代码】

Python学习杂记_4_分支和循环【图】

python学习_day30_基于tcp协议的粘包现象【代码】

【Python学习之旅】---socket编程（基于TCP/UDP编程）【图】

Python学习---Java和Python的区别小记

Python 学习之二：Python超短教程【代码】

Python学习——实现简单的交互raw_input的使用【代码】

Python学习笔记__2.4章递归函数

Python学习笔记四：过程控制【代码】

python学习笔记-第一天（Linux基本操作与Python的基础）【图】

20200527----python学习第21天【代码】

Python学习记录——Ubuntu（五）Vim【图】

Python学习————logging模块和re【代码】【图】

PYTHON - 相关标签

PYTHON - 技术教程分类

PYTHON - 最新教程

PYTHON - 最热教程

首页 / PYTHON / Python学习第二十天 元类

Python学习第二十天 元类

内容导读

内容图文

一 前言

二 什么是元类

三 class关键字创建类的流程分析

五 自定义元类控制类OldboyTeacher的创建

六 自定义元类控制类OldboyTeacher的调用

六 再看属性查找

七 练习题

内容总结

内容备注

内容手机端

【Python学习第二十天 元类】教程文章相关的互联网学习教程文章

PYTHON - 相关标签

PYTHON - 技术教程分类

PYTHON - 最新教程

PYTHON - 最热教程

首页 / PYTHON / Python学习第二十天元类

Python学习第二十天元类

一前言

二什么是元类

五自定义元类控制类OldboyTeacher的创建

六自定义元类控制类OldboyTeacher的调用

六再看属性查找

七练习题

【Python学习第二十天元类】教程文章相关的互联网学习教程文章