前言

作为一个代码写得比较一般的我，想将代码能力提高一个level。看书获心法，看大牛写的项目获形法。当我搜索，python源码阅读推荐，看到基本都有requests这个包，本身也经常用这个包，关键是这个包相对来说比较简单，就愉快的决定从这个轮子开始拆了。大体看完后，(〃´皿`)q膜拜Kenneth Reitz，狂打call，人帅，代码写得更帅，还是减肥励志级别人物。

感觉有趣，值得学习，借鉴的

目录结构

原先的目录文件结构并没有这样划分得这么清晰，只有一个core.py文件，里面包含了一切。这样划分的好处就是，相同功能的划分到一个文件里头，更加的清晰。这里提供了很好的文件命名规范，具体的如下注释。哈哈哈，以后自己写代码，目录结构按照这里的来，完美。

├── requests
│   ├── __init__.py
│   ├── adapters.py
│   ├── api.py              # 提供对外的api调用 
│   ├── auth.py         
│   ├── cacert.pem
│   ├── certs.py
│   ├── compat.py           # python2和python3兼容
│   ├── cookies.py
│   ├── exceptions.py       # 各种异常
│   ├── hooks.py        
│   ├── models.py           # 代码中会用到的自定义类
│   ├── packages            # 存放第三方模块
│   │   ├── README.rst
│   │   ├── __init__.py
│   │   ├── chardet
│   │   └── urllib3
│   ├── sessions.py     
│   ├── status_codes.py     # 全局各种状态码
│   ├── structures.py       # 自定义的容器类
│   └── utils.py            # 各种工具方法

优雅的hook函数

平时自己写函数，有时也会提供回调处理之类的，但是一般属于写死型，不够通用。在v0.6.0版本中看到，以下用法时，Σ（ﾟдﾟlll）目瞪口呆，卧槽，强，牛逼。核心思路是1. 若有hook函数就处理，没有就返回原有数据，2. 利用**kwargs可以传入各种不同的参数（不用args�估计是因为让参数意义更明确）。写一个通用 利用上partial，改造一下，就能变化出各种不同场景的hook处理了。

# v2.9.2 版本的，比起最初版，增加了点判断，思路是一样的。

HOOKS = ['response']    # 限定dispatch_hook所能处理的hook函数

def default_hooks():
    return dict((event, []) for event in HOOKS)

# TODO: response is the only one

# 这函数，若有hook函数就处理，没有就返回原有数据。这个没有就返回原来的数据很重要！！！调用时就可以不用判断，直接写写就行了。
def dispatch_hook(key, hooks, hook_data, **kwargs):
    """Dispatches a hook dictionary on a given piece of data."""
    hooks = hooks or dict()
    hooks = hooks.get(key)
    if hooks:
        if hasattr(hooks, '__call__'):  
            hooks = [hooks]
        for hook in hooks:
            _hook_data = hook(hook_data, **kwargs)
            if _hook_data is not None:
                hook_data = _hook_data
    return hook_data



# v0.6.0用法, 最初版的更能体会到dispatch_hook的强大。
args = dispatch_hook('args', hooks, args)

r = Request(**args)

# Pre-request hook.
r = dispatch_hook('pre_request', hooks, r)

# Send the HTTP Request.
r.send()

# Post-request hook.
r = dispatch_hook('post_request', hooks, r)

对于状态码是数字，但又想代码意义明确的优雅处理

以前写代码经常会这种反人类的写法if status == 1: do something。之后将它改进游戏，在文件开头用大写的变量定义状态，然后引入。但是看到下面的用法时，我看到了更加优雅的解决办法。核心思路：1. 将各种状态码写入一个文件 2. 用属性名来代替数字状态码

_codes = {

    # Informational.
    100: ('continue',),
    101: ('switching_protocols',),
    102: ('processing',),
    103: ('checkpoint',),
    122: ('uri_too_long', 'request_uri_too_long'),
    200: ('ok', 'okay', 'all_ok', 'all_okay', 'all_good', '\\o/', '✓'),  # 支持多种映射66666
    201: ('created',),
    202: ('accepted',),
    203: ('non_authoritative_info', 'non_authoritative_information'),
    204: ('no_content',),
    205: ('reset_content', 'reset'),
    206: ('partial_content', 'partial'),
    207: ('multi_status', 'multiple_status', 'multi_stati', 'multiple_stati'),
    208: ('already_reported',),
    226: ('im_used',),
    
    # 后面还有n多，果断省略

}

# 自定义的dict类似的容器类
class LookupDict(dict):
    """Dictionary lookup object."""

    def __init__(self, name=None):
        self.name = name
        super(LookupDict, self).__init__()

    def __repr__(self):
        return '<lookup \'%s\'>' % (self.name)
    
    # python语言框架调用的，实现了这个就可以obj["item"]这样调用。典型的面向接口编程哲学思想
    def __getitem__(self, key):
        # We allow fall-through here, so values default to None

        return self.__dict__.get(key, None)

    def get(self, key, default=None):
        return self.__dict__.get(key, default)


codes = LookupDict(name='status_codes')

for code, titles in _codes.items():
    for title in titles:
        setattr(codes, title, code)
        if not title.startswith('\\'):
            setattr(codes, title.upper(), code)
            
# 然后就可以这样用了
 if response.status_code == codes.see_other and method != 'HEAD'
    pass
    
 if response.status_code == codes['see_other'] and method != 'HEAD'
    pass
            

一个兼容python2与python3的思路

一个名为compat.py的文件吸引了我的眼球，兼容总给我一种这是高大上的用法的感觉。里面给出了一个兼容2和3的思路。python2与3大体上的不同点1. 部分包名路径设置名字变了 2. 字符串，整形等基础数据类型的改变。而compat.py的核心思路是：将不同的弄成一样，然后其他文件，从该文件import。

if is_py2:
    from urllib import quote, unquote, quote_plus, unquote_plus, urlencode, getproxies, proxy_bypass
    from urlparse import urlparse, urlunparse, urljoin, urlsplit, urldefrag
    from urllib2 import parse_http_list
    import cookielib
    from Cookie import Morsel
    from StringIO import StringIO
    from .packages.urllib3.packages.ordered_dict import OrderedDict

    builtin_str = str
    bytes = str
    str = unicode
    basestring = basestring
    numeric_types = (int, long, float)

elif is_py3:
    from urllib.parse import urlparse, urlunparse, urljoin, urlsplit, urlencode, quote, unquote, quote_plus, unquote_plus, urldefrag
    from urllib.request import parse_http_list, getproxies, proxy_bypass
    from http import cookiejar as cookielib
    from http.cookies import Morsel
    from io import StringIO
    from collections import OrderedDict

    builtin_str = str
    str = str
    bytes = bytes
    basestring = (str, bytes)
    numeric_types = (int, float)

利用类来做上下文管理

上下文管理又是一个高级用法。最初的session的管理是用装饰器来做的，每个字母我都认识，但我完全看不懂！！！！但大神就大神，后来改用类来做，代码优雅度，可读性上升N个台阶。核心思路：创建一个专门用来管理上下文的类，利用对象属性，在下次操作时，将需要继续使用的，传入函数中。描述得比较魔幻，需要配合代码来理解。

class Session(SessionRedirectMixin)
    def __init__():
        # 注释全部去掉了，
        self.headers = default_headers()
        self.auth = None
        self.proxies = {}
        self.hooks = default_hooks()
        self.params = {}
        self.stream = False
        self.verify = True
        self.cert = None
        self.max_redirects = DEFAULT_REDIRECT_LIMIT
        self.trust_env = True
        self.cookies = cookiejar_from_dict({})  # 主要观察点cookies, 下次请求带上上次的
        self.adapters = OrderedDict()
        self.mount('https://', HTTPAdapter())
        self.mount('http://', HTTPAdapter())
        self.redirect_cache = RecentlyUsedContainer(REDIRECT_CACHE_SIZE)
    
    def prepare_request(self, request):
      ..... 持续省略
      cookies = request.cookies or {}

      # Bootstrap CookieJar.
      if not isinstance(cookies, cookielib.CookieJar):
          cookies = cookiejar_from_dict(cookies)

      # 上次请求的cookies会被保存到self.cookies这个属性里面，然后下次请求时带上。
      merged_cookies = merge_cookies(
          merge_cookies(RequestsCookieJar(), self.cookies), cookies)

    
      # Set environment's basic authentication if not explicitly set.
      ..... 持续省略
      return p  
    
    
    # 实现了这两个方法，就可以with Session() as session：dosomething
    def __enter__(self):
        return self

    def __exit__(self, *args):
        self.close()

教科书式的类继承体系

讲真，看同事写的代码，自己写的代码，在类继体系这一块，普遍都做得不好，为了方便，经常是乱继承，导致代码过度耦合！！！在殿堂级神书《冒号课堂》，有两句话，值得背下下来。1. 提倡接口继承，慎用实现继承。2. 非抽象类不适合作基类。补充一下，mixin类就是带实现的接口，不应该被实例化使用，算是接口继承。

auth.py

# 专门设计出来，用于抽象的基类
class AuthBase(object):
    """Base class that all auth implementations derive from"""

    def __call__(self, r):
        raise NotImplementedError('Auth hooks must be callable.')
        
        
class HTTPBasicAuth(AuthBase):
    ....省略

    def __call__(self, r):
        r.headers['Authorization'] = _basic_auth_str(self.username, self.password)
        return r


class HTTPProxyAuth(HTTPBasicAuth):
    def __call__(self, r):
        r.headers['Proxy-Authorization'] = _basic_auth_str(self.username, self.password)
        return r


class HTTPDigestAuth(AuthBase):
    ....继续省略
    
    def __call__(self, r):
        # Initialize per-thread state, if needed
        self.init_per_thread_state()
        # If we have a saved nonce, skip the 401
        if self._thread_local.last_nonce:
            r.headers['Authorization'] = self.build_digest_header(r.method, r.url)
        try:
            self._thread_local.pos = r.body.tell()
        except AttributeError:
            # In the case of HTTPDigestAuth being reused and the body of
            # the previous request was a file-like object, pos has the
            # file position of the previous body. Ensure it's set to
            # None.
            self._thread_local.pos = None
        r.register_hook('response', self.handle_401)
        r.register_hook('response', self.handle_redirect)
        self._thread_local.num_401_calls = 1


models.py
# 将一些子类会公用到的，做成mixin类。多重继承也非魔鬼啊。另外的，标准库也有很多mixin类，有兴趣，可以再去看看collections模块里面的用法

class RequestEncodingMixin(object)
    pass

class RequestHooksMixin(object):
    pass
  
class PreparedRequest(RequestEncodingMixin, RequestHooksMixin)
    pass

class Request(RequestHooksMixin)
    pass
    

一个设置参数默认值的思路

在方法里面设置，而非在参数里面设置。适合参数巨多的场景

def send(self, request, **kwargs):
  # 
  kwargs.setdefault('stream', self.stream)
  kwargs.setdefault('verify', self.verify)
  kwargs.setdefault('cert', self.cert)
  kwargs.setdefault('proxies', self.proxies)

更快速自定义容器类

在models.py中看到了一个class CaseInsensitiveDict(collections.MutableMapping): pass 这样的用法。一般嘛，自定义容器类，需要实现各种各样的magic方法，对外接口啊。做为一个懒人，每次自定义都有实现实在是麻烦，还可能会漏。官方提供collections模块来拯救世界，里面有很多已经定义好的抽象基类。只要实现了要求的magic方法（没有实现还会很贴心的报错，告诉你没有实现），那么可以使用相对于的接口。

最后的唠叨

还有一些有趣的小细节用法，没有贴出来，因为我带注释版的，被我乱切分支，不知道去了哪里了，懒得找出来记录。看源码的思路，主要是看用法，具体的和网络相关详细而且细节的知识略过。目的不是为了学习网络相关的细节知识，所以略过，就算要学也不应该看代码来学，太零散没有价值，应该要去看相关的协议。这次拆轮子体验良好，下次没有意外的话，应该是拆flask框架。最近发现本好书<<流畅的python>>里面好多进阶知识用法，可能会主要先看它，再继续拆，下次更新时间不知道啥时候。