Python 메타클래스란 무엇입니까? Python 메타클래스 소개

이 기사에서는 Python 메타클래스가 무엇인지 설명합니다. Python 메타클래스에 대한 소개에는 특정 참고 가치가 있습니다. 도움이 필요한 친구들이 참고할 수 있기를 바랍니다.

파이썬의 가장 어려운 지식 포인트를 두 문장으로 마스터하세요 - 메타클래스

소위 "메타클래스는 99%의 파이썬 프로그래머가 사용하지 않을 기능입니다"라는 말에 겁먹지 마세요. 왜냐하면모든 중국인은 메타클래스의 자연스러운 사용자이기 때문입니다

메타클래스를 배우려면 문장 두 개만 알면 됩니다.

• 타오는 하나를 낳고, 하나는 둘을 낳고, 둘은 셋을 낳고, 셋은 낳습니다. to all things

• 나는 누구일까요? 나는 어디서 왔는가? 나는 어디로 가는 걸까? (블로거는 다음과 같아야 한다고 생각합니다: 나는 누구인가? 나는 어디서 왔는가? 나는 무엇을 할 수 있는가?)

파이썬 세계에는 영원한 도가 있는데, 그것은 바로 "유형"입니다. 꼭 지켜주세요. 당신의 마음 속에서 유형은 도(Tao)입니다. 이렇게 방대한 Python 생태계는 모두 유형별로 생성됩니다.

도는 하나를 만들고, 둘을 만들고, 둘은 셋을 만들고, 셋은 만물을 만듭니다.

1. 道는 유형

2. One은 메타클래스(메타클래스 또는 클래스 생성기)

3. Two는 클래스(클래스 또는 인스턴스 생성기)

4. 三 인스턴스( 인스턴스)

5. Everything은 우리가 보통 파이썬을 사용할 때 인스턴스의 다양한 속성과 메소드를 호출합니다.

Tao와 one은 오늘 우리가 논의하는 명제이고, two, three, all things는 우리가 자주 사용하는 클래스, 인스턴스, 속성 및 메서드입니다. hello world를 예로 사용하세요:

# 创建一个Hello类，拥有属性say_hello ----二的起源
class Hello():
    def say_hello(self, name='world'):
        print('Hello, %s.' % name)


# 从Hello类创建一个实例hello ----二生三
hello = Hello()

# 使用hello调用方法say_hello ----三生万物
hello.say_hello()

출력 효과:

Hello, world.

이것은 "둘이 셋을 낳고, 셋이 만물을 낳는다"라는 표준적인 과정입니다. 클래스부터 호출할 수 있는 메서드까지 이 두 단계가 사용됩니다.

그렇다면 우리는 수업이 어디서 오는지 묻지 않을 수 없습니다. 코드의 첫 번째 줄로 돌아갑니다.

class Hello는 실제로 코드를 더 쉽게 이해할 수 있도록 함수의 "의미적 약어"입니다. 이를 작성하는 또 다른 방법은 다음과 같습니다.

def fn(self, name='world'): # 假如我们有一个函数叫fn
    print('Hello, %s.' % name)
    
Hello = type('Hello', (object,), dict(say_hello=fn)) # 通过type创建Hello class ---- 神秘的“道”，可以点化一切，这次我们直接从“道”生出了“二”

이 작성 방법은 이전 Class Hello 작성 방법과 동일한 효과를 갖습니다. 인스턴스를 생성하고

# 从Hello类创建一个实例hello ----二生三，完全一样
hello = Hello()
# 使用hello调用方法say_hello ----三生万物，完全一样
hello.say_hello()

를 호출해 볼 수 있습니다. 출력 효과:

Hello, world. ----调用结果完全一样。

가장 흥미로웠던 부분을 되돌아보겠습니다.

Tao가 직접 두 개를 낳았습니다.:

Hello = type('Hello', (object,), dict(say_hello=fn))

이것이 Python 세계의 기원인 "Tao"입니다. , 당신은 이것을 할 수 있고 놀랍습니다.

세 가지 매개변수에 주목하세요! 이는 인류의 세 가지 영원한 명제, 즉 나는 누구이며, 어디서 왔고, 어디로 가고 싶은가와 일치합니다.

• 첫 번째 매개변수: 나는 누구인가. 여기에는 다른 것과는 다른 이름이 필요합니다. 위의 예에서는 "Hello"

• 두 번째 매개변수: Where do I from from

  를 지정합니다. 여기서는 이것이 내 "부모 클래스"인지 알아야 합니다. 위의 예에서 내 부모 클래스는 "객체"입니다. 이는 Python의 매우 하위 클래스입니다.
  

• 세 번째 매개변수: 어디로 가고 싶어요

  여기에는 사전으로 호출하여 매개변수로 전달해야 하는 메서드와 속성이 포함되어 있습니다. 위의 예에서는 사전에 싸인 say_hello 메소드가 있습니다.
  

세 가지 영원한 명제는 모든 클래스, 모든 인스턴스, 심지어 모든 인스턴스 속성과 메소드에 의해 소유된다는 점에 주목할 가치가 있습니다. "작성자"인 Tao와 Yi, 즉 유형과 메타클래스도 이 세 가지 매개변수를 갖고 있는 것은 당연합니다. 그런데 보통 클래스의 세 가지 영원한 명제는 매개변수로 전달되지 않고 다음과 같은 방식으로 전달됩니다

class Hello(object){
# class 后声明“我是谁”
# 小括号内声明“我来自哪里”
# 中括号内声明“我要到哪里去”
    def say_hello(){
        
    }
}

• Creator가 직접 한 사람을 생성할 수도 있지만 이게 힘든 작업입니다. 창조주는 먼저 "인간"이라는 종을 창조한 다음 일괄적으로 특정 개인을 창조할 것입니다. 그리고 세 가지 영원한 제안을 전달하십시오.

• "타오"는 "2"를 직접 생산할 수 있지만 먼저 "1"을 생산한 다음 "2"를 일괄 생산합니다.

• type은 클래스(클래스)를 직접 생성할 수도 있지만 먼저 메타클래스(메타클래스)를 생성한 다음 메타클래스를 사용하여 클래스(클래스)를 일괄 맞춤화할 수도 있습니다.

메타클래스 - 타오는 하나를 낳고 인생은 둘을 낳는다

일반적으로 메타클래스는 접미사 Metalass를 붙여 명명됩니다. 자동으로 hello라고 말할 수 있는 메타클래스가 필요하다고 상상해 보세요. 때로는 say_Hello가 필요하고, 때로는 say_Hi가 필요하고, 때로는 say_Sayolala가 필요하고, 때로는 say_Nihao가 필요합니다.

내장된 각 say_xxx를 클래스에서 한 번씩 선언해야 한다면 얼마나 힘든 일이겠습니까! 문제를 해결하려면

metaclass를 사용하는 것이 좋습니다.

다음은 "안녕하세요"를 위해 특별히 메타클래스를 생성하는 코드입니다.

class SayMetaClass(type):

    def __new__(cls, name, bases, attrs):
        attrs['say_'+name] = lambda self,value,saying=name: print(saying+','+value+'!')
        return type.__new__(cls, name, bases, attrs)

두 가지 점을 기억하세요.

1. 메타클래스는 "유형"에서 파생되므로 상위 클래스에 유형을 전달해야 합니다. 【
타오는 하나를 만들기 때문에 하나는 도를 담고 있어야 한다】

2、元类的操作都在 __new__中完成，它的第一个参数是将创建的类，之后的参数即是三大永恒命题：我是谁，我从哪里来，我将到哪里去。 它返回的对象也是三大永恒命题，接下来，这三个参数将一直陪伴我们。

在__new__中，我只进行了一个操作，就是

attrs['say_'+name] = lambda self,value,saying=name: print(saying+','+value+'!')

它跟据类的名字，创建了一个类方法。比如我们由元类创建的类叫“Hello”，那创建时就自动有了一个叫“say_Hello”的类方法，然后又将类的名字“Hello”作为默认参数saying，传到了方法里面。然后把hello方法调用时的传参作为value传进去，最终打印出来。

那么，一个元类是怎么从创建到调用的呢？
来！一起根据道生一、一生二、二生三、三生万物的准则，走进元类的生命周期吧！

# 道生一：传入type
class SayMetaClass(type):

    # 传入三大永恒命题：类名称、父类、属性
    def __new__(cls, name, bases, attrs):
        # 创造“天赋”
        attrs['say_'+name] = lambda self,value,saying=name: print(saying+','+value+'!')
        # 传承三大永恒命题：类名称、父类、属性
        return type.__new__(cls, name, bases, attrs)

# 一生二：创建类
class Hello(object, metaclass=SayMetaClass):
    pass

# 二生三：创建实列
hello = Hello()

# 三生万物：调用实例方法
hello.say_Hello('world!')

输出为

Hello, world!

注意：通过元类创建的类，第一个参数是父类，第二个参数是metaclass

普通人出生都不会说话，但有的人出生就会打招呼说“Hello”，“你好”,“sayolala”，这就是天赋的力量。它会给我们面向对象的编程省下无数的麻烦。

现在，保持元类不变，我们还可以继续创建Sayolala， Nihao类，如下：

# 一生二：创建类
class Sayolala(object, metaclass=SayMetaClass):
    pass

# 二生三：创建实列
s = Sayolala()

# 三生万物：调用实例方法
s.say_Sayolala('japan!')

输出

Sayolala, japan!

也可以说中文

# 一生二：创建类
class Nihao(object, metaclass=SayMetaClass):
    pass

# 二生三：创建实列
n = Nihao()

# 三生万物：调用实例方法
n.say_Nihao('中华!')

输出

Nihao, 中华!

再来一个小例子：

# 道生一
class ListMetaclass(type):
    def __new__(cls, name, bases, attrs):
        # 天赋：通过add方法将值绑定
        attrs['add'] = lambda self, value: self.append(value)
        return type.__new__(cls, name, bases, attrs)
        
# 一生二
class MyList(list, metaclass=ListMetaclass):
    pass
    
# 二生三
L = MyList()

# 三生万物
L.add(1)

现在我们打印一下L

print(L)

>>> [1]

而普通的list没有add()方法

L2 = list()
L2.add(1)

>>>AttributeError: 'list' object has no attribute 'add'

太棒了！学到这里，你是不是已经体验到了造物主的乐趣？

年轻的造物主，请随我一起开创新世界。

我们选择两个领域，一个是Django的核心思想，“Object Relational Mapping”，即对象-关系映射，简称ORM。

这是Django的一大难点，但学完了元类，一切变得清晰。你对Django的理解将更上一层楼！

另一个领域是爬虫领域（黑客领域），一个自动搜索网络上的可用代理，然后换着IP去突破别的人反爬虫限制。

这两项技能非常有用，也非常好玩！

挑战一：通过元类创建ORM

准备工作，创建一个Field类

class Field(object):

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

    def __str__(self):
        return &#39;<%s:%s>&#39; % (self.__class__.__name__, self.name)

它的作用是
在Field类实例化时将得到两个参数，name和column_type，它们将被绑定为Field的私有属性，如果要将Field转化为字符串时，将返回“Field:XXX” ， XXX是传入的name名称。

准备工作：创建StringField和IntergerField

class StringField(Field):

    def __init__(self, name):
        super(StringField, self).__init__(name, 'varchar(100)')

class IntegerField(Field):

    def __init__(self, name):
        super(IntegerField, self).__init__(name, 'bigint')

它的作用是
在StringField,IntegerField实例初始化时，时自动调用父类的初始化方式。

道生一

class ModelMetaclass(type):

    def __new__(cls, name, bases, attrs):
        if name=='Model':
            return type.__new__(cls, name, bases, attrs)
        print('Found model: %s' % name)
        mappings = dict()
        for k, v in attrs.items():
            if isinstance(v, Field):
                print('Found mapping: %s ==> %s' % (k, v))
                mappings[k] = v
        for k in mappings.keys():
            attrs.pop(k)
        attrs['__mappings__'] = mappings # 保存属性和列的映射关系
        attrs['__table__'] = name # 假设表名和类名一致
        return type.__new__(cls, name, bases, attrs)

它做了以下几件事

1. 创建一个新的字典mapping

2. 将每一个类的属性，通过.items()遍历其键值对。如果值是Field类，则打印键值，并将这一对键值绑定到mapping字典上。

3. 将刚刚传入值为Field类的属性删除。

4. 创建一个专门的__mappings__属性，保存字典mapping。

5. 创建一个专门的__table__属性，保存传入的类的名称。

一生二

class Model(dict, metaclass=ModelMetaclass):

    def __init__(self, **kwarg):
        super(Model, self).__init__(**kwarg)

    def __getattr__(self, key):
        try:
            return self[key]
        except KeyError:
            raise AttributeError("'Model' object has no attribute '%s'" % key)

    def __setattr__(self, key, value):
        self[key] = value

    # 模拟建表操作
    def save(self):
        fields = []
        args = []
        for k, v in self.__mappings__.items():
            fields.append(v.name)
            args.append(getattr(self, k, None))
        sql = 'insert into %s (%s) values (%s)' % (self.__table__, ','.join(fields), ','.join([str(i) for i in args]))
        print('SQL: %s' % sql)
        print('ARGS: %s' % str(args))

如果从Model创建一个子类User：

class User(Model):
    # 定义类的属性到列的映射：
    id = IntegerField('id')
    name = StringField('username')
    email = StringField('email')
    password = StringField('password')

这时
id= IntegerField('id')就会自动解析为：

Model.__setattr__(self, 'id', IntegerField('id'))

因为IntergerField('id')是Field的子类的实例，自动触发元类的__new__，所以将IntergerField('id')存入__mappings__并删除这个键值对。

二生三、三生万物

当你初始化一个实例的时候并调用save()方法时候

u = User(id=12345, name='Batman', email='batman@nasa.org', password='iamback')
u.save()

这时先完成了二生三的过程：

1. 先调用Model.__setattr__，将键值载入私有对象

2. 然后调用元类的“天赋”，ModelMetaclass.__new__，将Model中的私有对象，只要是Field的实例，都自动存入u.__mappings__。

接下来完成了三生万物的过程：

通过u.save()模拟数据库存入操作。这里我们仅仅做了一下遍历__mappings__操作，虚拟了sql并打印，在现实情况下是通过输入sql语句与数据库来运行。

输出结果为

Found model: User
Found mapping: name ==> <StringField:username>
Found mapping: password ==> <StringField:password>
Found mapping: id ==> <IntegerField:id>
Found mapping: email ==> <StringField:email>
SQL: insert into User (username,password,id,email) values (Batman,iamback,12345,batman@nasa.org)
ARGS: [&#39;Batman&#39;, &#39;iamback&#39;, 12345, &#39;batman@nasa.org&#39;]

• 年轻的造物主，你已经和我一起体验了由“道”演化“万物”的伟大历程，这也是Django中的Model版块核心原理。

• 接下来，请和我一起进行更好玩的爬虫实战（嗯，你现在已经是初级黑客了）：网络代理的爬取吧！

挑战二：网络代理的爬取

准备工作，先爬个页面玩玩

请确保已安装requests和pyquery这两个包。

# 文件：get_page.py
import requests

base_headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.71 Safari/537.36',
    'Accept-Encoding': 'gzip, deflate, sdch',
    'Accept-Language': 'zh-CN,zh;q=0.8'
}


def get_page(url):
    headers = dict(base_headers)
    print('Getting', url)
    try:
        r = requests.get(url, headers=headers)
        print('Getting result', url, r.status_code)
        if r.status_code == 200:
            return r.text
    except ConnectionError:
        print('Crawling Failed', url)
        return None

这里，我们利用request包，把百度的源码爬了出来。

试一试抓百度

把这一段粘在get_page.py后面，试完删除

if(__name__ == '__main__'):
    rs = get_page('https://www.baidu.com')
    print('result:\r\n', rs)

试一试抓代理

把这一段粘在get_page.py后面，试完删除

if(__name__ == '__main__'):
    from pyquery import PyQuery as pq
    start_url = 'http://www.proxy360.cn/Region/China'
    print('Crawling', start_url)
    html = get_page(start_url)
    if html:
        doc = pq(html)
        lines = doc('p[name="list_proxy_ip"]').items()
        for line in lines:
            ip = line.find('.tbBottomLine:nth-child(1)').text()
            port = line.find('.tbBottomLine:nth-child(2)').text()
            print(ip+':'+port)

接下来进入正题：使用元类批量抓取代理

批量处理抓取代理

from getpage import get_page
from pyquery import PyQuery as pq


# 道生一：创建抽取代理的metaclass
class ProxyMetaclass(type):
    """
        元类，在FreeProxyGetter类中加入
        __CrawlFunc__和__CrawlFuncCount__
        两个参数，分别表示爬虫函数，和爬虫函数的数量。
    """
    def __new__(cls, name, bases, attrs):
        count = 0
        attrs['__CrawlFunc__'] = []
        attrs['__CrawlName__'] = []
        for k, v in attrs.items():
            if 'crawl_' in k:
                attrs['__CrawlName__'].append(k)
                attrs['__CrawlFunc__'].append(v)
                count += 1
        for k in attrs['__CrawlName__']:
            attrs.pop(k)
        attrs['__CrawlFuncCount__'] = count
        return type.__new__(cls, name, bases, attrs)


# 一生二：创建代理获取类

class ProxyGetter(object, metaclass=ProxyMetaclass):
    def get_raw_proxies(self, site):
        proxies = []
        print('Site', site)
        for func in self.__CrawlFunc__:
            if func.__name__==site:
                this_page_proxies = func(self)
                for proxy in this_page_proxies:
                    print('Getting', proxy, 'from', site)
                    proxies.append(proxy)
        return proxies


    def crawl_daili66(self, page_count=4):
        start_url = 'http://www.66ip.cn/{}.html'
        urls = [start_url.format(page) for page in range(1, page_count + 1)]
        for url in urls:
            print('Crawling', url)
            html = get_page(url)
            if html:
                doc = pq(html)
                trs = doc('.containerbox table tr:gt(0)').items()
                for tr in trs:
                    ip = tr.find('td:nth-child(1)').text()
                    port = tr.find('td:nth-child(2)').text()
                    yield ':'.join([ip, port])

    def crawl_proxy360(self):
        start_url = 'http://www.proxy360.cn/Region/China'
        print('Crawling', start_url)
        html = get_page(start_url)
        if html:
            doc = pq(html)
            lines = doc('p[name="list_proxy_ip"]').items()
            for line in lines:
                ip = line.find('.tbBottomLine:nth-child(1)').text()
                port = line.find('.tbBottomLine:nth-child(2)').text()
                yield ':'.join([ip, port])

    def crawl_goubanjia(self):
        start_url = 'http://www.goubanjia.com/free/gngn/index.shtml'
        html = get_page(start_url)
        if html:
            doc = pq(html)
            tds = doc('td.ip').items()
            for td in tds:
                td.find('p').remove()
                yield td.text().replace(' ', '')


if __name__ == '__main__':
    # 二生三：实例化ProxyGetter
    crawler = ProxyGetter()
    print(crawler.__CrawlName__)
    # 三生万物
    for site_label in range(crawler.__CrawlFuncCount__):
        site = crawler.__CrawlName__[site_label]
        myProxies = crawler.get_raw_proxies(site)

道生一：元类的__new__中，做了四件事：

1. 将“crawl_”开头的类方法的名称推入ProxyGetter.__CrawlName__

2. 将“crawl_”开头的类方法的本身推入ProxyGetter.__CrawlFunc_

3. 计算符合“crawl_”开头的类方法个数

4. 删除所有符合“crawl_”开头的类方法

怎么样？是不是和之前创建ORM的__mappings__过程极为相似？

一生二：类里面定义了使用pyquery抓取页面元素的方法

分别从三个免费代理网站抓取了页面上显示的全部代理。

如果对yield用法不熟悉，可以查看：
廖雪峰的python教程：生成器

二生三：创建实例对象crawler

三生万物：遍历每一个__CrawlFunc__

1. 在ProxyGetter.__CrawlName__上面，获取可以抓取的的网址名。

2. 触发类方法ProxyGetter.get_raw_proxies(site)

3. 遍历ProxyGetter.__CrawlFunc__,如果方法名和网址名称相同的，则执行这一个方法

4. 把每个网址获取到的代理整合成数组输出。

那么。。。怎么利用批量代理，冲击别人的网站，套取别人的密码，狂发广告水贴，定时骚扰客户？ 呃！想啥呢！这些自己悟！如果悟不到，请听下回分解！

年轻的造物主，创造世界的工具已经在你手上，请你将它的威力发挥到极致！

请记住挥动工具的口诀：

• 道生一，一生二，二生三，三生万物

• 我是谁，我来自哪里，我要到哪里去

相关推荐：

python数据类型元组详细介绍

Python 元类实例解析_python

위 내용은 Python 메타클래스란 무엇입니까? Python 메타클래스 소개의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!