标签：接下来 spl inter += 写法 field 参考 japan pytho
学懂元类，首先要知道两句话：
在Python的世界里，拥有一个永恒的道：type，如此广袤无垠的Python生态圈，都是由type产生出来的。
道生一，一生二，二生三，三生万物。
道和一，是我们今天讨论的命题，而二、三、和万物，则是我们常常使用的类、实例、属性和方法，用hello world来举例：
1 # 创建一个Hello类，拥有属性say_hello ----二的起源 2 class Hello(): 3 def say_hello(self, name=‘world‘): 4 print(‘Hello, %s.‘ % name) 5 6 7 # 从Hello类创建一个实例hello ----二生三 8 hello = Hello() 9 10 # 使用hello调用方法say_hello ----三生万物 11 hello.say_hello()
输出效果：
Hello, world.
这就是一个标准的“二生三，三生万物”过程。 从类到我们可以调用的方法，用了这两步。
那我们不由自主要问，类从何而来呢？回到代码的第一行。class Hello其实是一个函数的“语义化简称”，只为了让代码更浅显易懂，它的另一个写法是：
1 def fn(self, name=‘world‘): # 假如我们有一个函数叫fn 2 print(‘Hello, %s.‘ % name) 3 4 Hello = type(‘Hello‘, (object,), dict(say_hello=fn)) # 通过type创建Hello class ---- 神秘的“道”，可以点化一切，这次我们直接从“道”生出了“二”
这样的写法，就和之前的Class Hello写法作用完全相同，你可以试试创建实例并调用：
1 # 从Hello类创建一个实例hello ----二生三，完全一样 2 hello = Hello() 3 4 # 使用hello调用方法say_hello ----三生万物，完全一样 5 hello.say_hello()
输出效果：
Hello, world.
可以看出，输出的结果一致。
我们回头看一眼最精彩的地方，道直接生出了二：
Hello = type(‘Hello’, (object,), dict(say_hello=fn))
这就是“道”，python世界的起源，你可以为此而惊叹。
注意它的三个参数！暗合人类的三大永恒命题：我是谁，我从哪里来，我要到哪里去。
值得注意的是，三大永恒命题，是一切类，一切实例，甚至一切实例属性与方法都具有的。理所应当，它们的“创造者”，道和一，即type和元类，也具有这三个参数。但平常，类的三大永恒命题并不作为参数传入，而是以如下方式传入：
1 class Hello(object){ 2 # class 后声明“我是谁” 3 # 小括号内声明“我来自哪里” 4 # 花括号内声明“我要到哪里去” 5 def say_hello(){ 6 pass 7 } 8 }
一般来说，元类均被命名后缀为Metalass。想象一下，我们需要一个可以自动打招呼的元类，它里面的类方法呢，有时需要say_Hello，有时需要say_Hi，有时又需要say_Sayolala，有时需要say_Nihao。
如果每个内置的say_xxx都需要在类里面声明一次，那将是多么可怕的苦役！ 不如使用元类来解决问题。
以下是创建一个专门“打招呼”用的元类代码：
1 class SayMetaClass(type): 2 3 def __new__(cls, name, bases, attrs): 4 attrs[‘say_‘+name] = lambda self,value,saying=name: print(saying+‘,‘+value+‘!‘) 5 return type.__new__(cls, name, bases, attrs)
记住两点：
在__new__中，我只进行了一个操作，就是：
attrs[‘say_‘+name] = lambda self,value,saying=name: print(saying+‘,‘+value+‘!‘)
它跟据类的名字，创建了一个类方法。比如我们由元类创建的类叫“Hello”，那创建时就自动有了一个叫“say_Hello”的类方法，然后又将类的名字“Hello”作为默认参数saying，传到了方法里面。然后把hello方法调用时的传参作为value传进去，最终打印出来。
那么，一个元类是怎么从创建到调用的呢？
来！一起根据道生一、一生二、二生三、三生万物的准则，走进元类的生命周期吧！
1 # 道生一：传入type 2 class SayMetaClass(type): 3 4 # 传入三大永恒命题：类名称、父类、属性 5 def __new__(cls, name, bases, attrs): 6 # 创造“天赋” 7 attrs[‘say_‘+name] = lambda self,value,saying=name: print(saying+‘,‘+value+‘!‘) 8 # 传承三大永恒命题：类名称、父类、属性 9 return type.__new__(cls, name, bases, attrs) 10 11 # 一生二：创建类 12 class Hello(object, metaclass=SayMetaClass): 13 pass 14 15 # 二生三：创建实列 16 hello = Hello() 17 18 # 三生万物：调用实例方法 19 hello.say_Hello(‘world!‘)
输出为:
Hello, world!
注意：通过元类创建的类，第一个参数是父类，第二个参数是metaclass
普通人出生都不会说话，但有的人出生就会打招呼说“Hello”，“你好”,“sayolala”，这就是天赋的力量。它会给我们面向对象的编程省下无数的麻烦。
现在，保持元类不变，我们还可以继续创建Sayolala， Nihao类，如下：
# 一生二：创建类 class Sayolala(object, metaclass=SayMetaClass): pass class Nihao(object, metaclass=SayMetaClass): pass # 二生三：创建实列 s = Sayolala() n = Nihao() # 三生万物：调用实例方法 s.say_Sayolala(‘japan!‘) n.say_Nihao(‘中华!‘)
输出结果为：
Sayolala, japan!
Nihao, 中华!
再来一个小栗子：
1 # 道生一 2 class ListMetaclass(type): 3 def __new__(cls, name, bases, attrs): 4 # 天赋：通过add方法将值绑定 5 attrs[‘add‘] = lambda self, value: self.append(value) 6 return type.__new__(cls, name, bases, attrs) 7 8 # 一生二 9 class MyList(list, metaclass=ListMetaclass): 10 pass 11 12 # 二生三 13 L = MyList() 14 15 # 三生万物 16 L.add(1)
现在我们打印一下L:
print(L) >>> [1]
而普通的list没有add()方法：
1 L2 = list() 2 L2.add(1) 3 4 >>>AttributeError: ‘list‘ object has no attribute ‘add‘
太棒了！学到这里，你是不是已经体验到了造物主的乐趣？
年轻的造物主，请随我一起开创新世界。
我们选择两个领域，一个是Django的核心思想，“Object Relational Mapping”，即对象-关系映射，简称ORM。这是Django的一大难点，但学完了元类，一切变得清晰。你对Django的理解将更上一层楼！
另一个领域是爬虫领域（黑客领域），一个自动搜索网络上的可用代理，然后换着IP去突破别的人反爬虫限制。
这两项技能非常有用，也非常好玩！
1 class Field(object): 2 3 def __init__(self, name, column_type): 4 self.name = name 5 self.column_type = column_type 6 7 def __str__(self): 8 return ‘<%s:%s>‘ % (self.__class__.__name__, self.name)
它的作用是：
在Field类实例化时将得到两个参数，name和column_type，它们将被绑定为Field的私有属性，如果要将Field转化为字符串时，将返回“Field:XXX” ， XXX是传入的name名称。
1 class StringField(Field): 2 3 def __init__(self, name): 4 super(StringField, self).__init__(name, ‘varchar(100)‘) 5 6 class IntegerField(Field): 7 8 def __init__(self, name): 9 super(IntegerField, self).__init__(name, ‘bigint‘)
它的作用是：在StringField,IntegerField实例初始化时，时自动调用父类的初始化方式。
1 class ModelMetaclass(type): 2 3 def __new__(cls, name, bases, attrs): 4 if name==‘Model‘: 5 return type.__new__(cls, name, bases, attrs) 6 print(‘Found model: %s‘ % name) 7 mappings = dict() 8 for k, v in attrs.items(): 9 if isinstance(v, Field): 10 print(‘Found mapping: %s ==> %s‘ % (k, v)) 11 mappings[k] = v 12 for k in mappings.keys(): 13 attrs.pop(k) 14 attrs[‘__mappings__‘] = mappings # 保存属性和列的映射关系 15 attrs[‘__table__‘] = name # 假设表名和类名一致 16 return type.__new__(cls, name, bases, attrs)
它做了以下几件事
1 class Model(dict, metaclass=ModelMetaclass): 2 3 def __init__(self, **kwarg): 4 super(Model, self).__init__(**kwarg) 5 6 def __getattr__(self, key): 7 try: 8 return self[key] 9 except KeyError: 10 raise AttributeError("‘Model‘ object has no attribute ‘%s‘" % key) 11 12 def __setattr__(self, key, value): 13 self[key] = value 14 15 # 模拟建表操作 16 def save(self): 17 fields = [] 18 args = [] 19 for k, v in self.__mappings__.items(): 20 fields.append(v.name) 21 args.append(getattr(self, k, None)) 22 sql = ‘insert into %s (%s) values (%s)‘ % (self.__table__, ‘,‘.join(fields), ‘,‘.join([str(i) for i in args])) 23 print(‘SQL: %s‘ % sql) 24 print(‘ARGS: %s‘ % str(args))
如果从Model创建一个子类User：
1 class User(Model): 2 # 定义类的属性到列的映射： 3 id = IntegerField(‘id‘) 4 name = StringField(‘username‘) 5 email = StringField(‘email‘) 6 password = StringField(‘password‘)
这时id= IntegerField(‘id’)就会自动解析为：
Model.__setattr__(self, ‘id’, IntegerField(‘id’))
因为IntergerField(‘id’)是Field的子类的实例，自动触发元类的__new__，所以将IntergerField(‘id’)存入__mappings__并删除这个键值对。
当你初始化一个实例的时候并调用save()方法时候
1 u = User(id=12345, name=‘Batman‘, email=‘batman@nasa.org‘, password=‘iamback‘) 2 u.save()
这时先完成了二生三的过程：
接下来完成了三生万物的过程：
通过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: [‘Batman‘, ‘iamback‘, 12345, ‘batman@nasa.org‘]
请确保已安装requests和pyquery这两个包。
1 # 文件：get_page.py 2 import requests 3 4 base_headers = { 5 ‘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‘, 6 ‘Accept-Encoding‘: ‘gzip, deflate, sdch‘, 7 ‘Accept-Language‘: ‘zh-CN,zh;q=0.8‘ 8 } 9 10 11 def get_page(url): 12 headers = dict(base_headers) 13 print(‘Getting‘, url) 14 try: 15 r = requests.get(url, headers=headers) 16 print(‘Getting result‘, url, r.status_code) 17 if r.status_code == 200: 18 return r.text 19 except ConnectionError: 20 print(‘Crawling Failed‘, url) 21 return None
这里，我们利用request包，把百度的源码爬了出来：
1 if(__name__ == ‘__main__‘): 2 rs = get_page(‘https://www.baidu.com‘) 3 print(‘result:\r\n‘, rs)
试一试抓代理：
1 if(__name__ == ‘__main__‘): 2 from pyquery import PyQuery as pq 3 start_url = ‘http://www.proxy360.cn/Region/China‘ 4 print(‘Crawling‘, start_url) 5 html = get_page(start_url) 6 if html: 7 doc = pq(html) 8 lines = doc(‘div[name="list_proxy_ip"]‘).items() 9 for line in lines: 10 ip = line.find(‘.tbBottomLine:nth-child(1)‘).text() 11 port = line.find(‘.tbBottomLine:nth-child(2)‘).text() 12 print(ip+‘:‘+port)
接下来进入正题：使用元类批量抓取代理。
1 from getpage import get_page 2 from pyquery import PyQuery as pq 3 4 5 # 道生一：创建抽取代理的metaclass 6 class ProxyMetaclass(type): 7 """ 8 元类，在FreeProxyGetter类中加入 9 __CrawlFunc__和__CrawlFuncCount__ 10 两个参数，分别表示爬虫函数，和爬虫函数的数量。 11 """ 12 def __new__(cls, name, bases, attrs): 13 count = 0 14 attrs[‘__CrawlFunc__‘] = [] 15 attrs[‘__CrawlName__‘] = [] 16 for k, v in attrs.items(): 17 if ‘crawl_‘ in k: 18 attrs[‘__CrawlName__‘].append(k) 19 attrs[‘__CrawlFunc__‘].append(v) 20 count += 1 21 for k in attrs[‘__CrawlName__‘]: 22 attrs.pop(k) 23 attrs[‘__CrawlFuncCount__‘] = count 24 return type.__new__(cls, name, bases, attrs) 25 26 27 # 一生二：创建代理获取类 28 29 class ProxyGetter(object, metaclass=ProxyMetaclass): 30 def get_raw_proxies(self, site): 31 proxies = [] 32 print(‘Site‘, site) 33 for func in self.__CrawlFunc__: 34 if func.__name__==site: 35 this_page_proxies = func(self) 36 for proxy in this_page_proxies: 37 print(‘Getting‘, proxy, ‘from‘, site) 38 proxies.append(proxy) 39 return proxies 40 41 42 def crawl_daili66(self, page_count=4): 43 start_url = ‘http://www.66ip.cn/{}.html‘ 44 urls = [start_url.format(page) for page in range(1, page_count + 1)] 45 for url in urls: 46 print(‘Crawling‘, url) 47 html = get_page(url) 48 if html: 49 doc = pq(html) 50 trs = doc(‘.containerbox table tr:gt(0)‘).items() 51 for tr in trs: 52 ip = tr.find(‘td:nth-child(1)‘).text() 53 port = tr.find(‘td:nth-child(2)‘).text() 54 yield ‘:‘.join([ip, port]) 55 56 def crawl_proxy360(self): 57 start_url = ‘http://www.proxy360.cn/Region/China‘ 58 print(‘Crawling‘, start_url) 59 html = get_page(start_url) 60 if html: 61 doc = pq(html) 62 lines = doc(‘div[name="list_proxy_ip"]‘).items() 63 for line in lines: 64 ip = line.find(‘.tbBottomLine:nth-child(1)‘).text() 65 port = line.find(‘.tbBottomLine:nth-child(2)‘).text() 66 yield ‘:‘.join([ip, port]) 67 68 def crawl_goubanjia(self): 69 start_url = ‘http://www.goubanjia.com/free/gngn/index.shtml‘ 70 html = get_page(start_url) 71 if html: 72 doc = pq(html) 73 tds = doc(‘td.ip‘).items() 74 for td in tds: 75 td.find(‘p‘).remove() 76 yield td.text().replace(‘ ‘, ‘‘) 77 78 79 if __name__ == ‘__main__‘: 80 # 二生三：实例化ProxyGetter 81 crawler = ProxyGetter() 82 print(crawler.__CrawlName__) 83 # 三生万物 84 for site_label in range(crawler.__CrawlFuncCount__): 85 site = crawler.__CrawlName__[site_label] 86 myProxies = crawler.get_raw_proxies(site)
怎么样？是不是和之前创建ORM的__mappings__过程极为相似？
分别从三个免费代理网站抓取了页面上显示的全部代理。
如果对yield用法不熟悉，可以查看：廖雪峰的python教程：生成器
略
那么。。。怎么利用批量代理，冲击别人的网站，套取别人的密码，狂发广告水贴，定时骚扰客户？ 呃！想啥呢！这些自己悟！如果悟不到，请听下回分解！
请记住挥动工具的口诀：
本文参考资料：http://python.jobbole.com/88795/
标签：接下来 spl inter += 写法 field 参考 japan pytho
原文地址：https://www.cnblogs.com/qianyeliange/p/9286797.html
