前言

作為一個代碼寫得比較一般的我，想將代碼能力提高一個level?？磿@心法，看大牛寫的項目獲形法。當我搜索，python源碼閱讀推薦，看到基本都有requests這個包，本身也經常用這個包，關鍵是這個包相對來說比較簡單，就愉快的決定從這個輪子開始拆了。大體看完后，(〃′皿`)q膜拜Kenneth Reitz，狂打call，人帥，代碼寫得更帥，還是減肥勵志級別人物。

感覺有趣，值得學習，借鑒的

目錄結構

原先的目錄文件結構并沒有這樣劃分得這么清晰，只有一個core.py文件，里面包含了一切。這樣劃分的好處就是，相同功能的劃分到一個文件里頭，更加的清晰。這里提供了很好的文件命名規(guī)范，具體的如下注釋。哈哈哈，以后自己寫代碼，目錄結構按照這里的來，完美。

├── 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     # 全局各種狀態(tài)碼
│   ├── structures.py       # 自定義的容器類
│   └── utils.py            # 各種工具方法

優(yōu)雅的hook函數(shù)

平時自己寫函數(shù)，有時也會提供回調處理之類的，但是一般屬于寫死型，不夠通用。在v0.6.0版本中看到，以下用法時，Σ（?д?lll）目瞪口呆，臥槽，強，牛逼。核心思路是1. 若有hook函數(shù)就處理，沒有就返回原有數(shù)據，2. 利用**kwargs可以傳入各種不同的參數(shù)（不用args?估計是因為讓參數(shù)意義更明確）。寫一個通用 利用上partial，改造一下，就能變化出各種不同場景的hook處理了。

# v2.9.2 版本的，比起最初版，增加了點判斷，思路是一樣的。

HOOKS = ['response']    # 限定dispatch_hook所能處理的hook函數(shù)

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

# TODO: response is the only one

# 這函數(shù)，若有hook函數(shù)就處理，沒有就返回原有數(shù)據。這個沒有就返回原來的數(shù)據很重要?。?！調用時就可以不用判斷，直接寫寫就行了。
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)

對于狀態(tài)碼是數(shù)字，但又想代碼意義明確的優(yōu)雅處理

以前寫代碼經常會這種反人類的寫法if status == 1: do something。之后將它改進游戲，在文件開頭用大寫的變量定義狀態(tài)，然后引入。但是看到下面的用法時，我看到了更加優(yōu)雅的解決辦法。核心思路：1. 將各種狀態(tài)碼寫入一個文件 2. 用屬性名來代替數(shù)字狀態(tài)碼

_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語言框架調用的，實現(xiàn)了這個就可以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. 字符串，整形等基礎數(shù)據類型的改變。而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的管理是用裝飾器來做的，每個字母我都認識，但我完全看不懂?。。?！但大神就大神，后來改用類來做，代碼優(yōu)雅度，可讀性上升N個臺階。核心思路：創(chuàng)建一個專門用來管理上下文的類，利用對象屬性，在下次操作時，將需要繼續(xù)使用的，傳入函數(shù)中。描述得比較魔幻，需要配合代碼來理解。

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):
      ..... 持續(xù)省略
      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.
      ..... 持續(xù)省略
      return p  
    
    
    # 實現(xiàn)了這兩個方法，就可以with Session() as session：dosomething
    def __enter__(self):
        return self

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

教科書式的類繼承體系

講真，看同事寫的代碼，自己寫的代碼，在類繼體系這一塊，普遍都做得不好，為了方便，經常是亂繼承，導致代碼過度耦合！??！在殿堂級神書《冒號課堂》，有兩句話，值得背下下來。1. 提倡接口繼承，慎用實現(xiàn)繼承。2. 非抽象類不適合作基類。補充一下，mixin類就是帶實現(xiàn)的接口，不應該被實例化使用，算是接口繼承。

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):
    ....繼續(xù)省略
    
    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
    

一個設置參數(shù)默認值的思路

在方法里面設置，而非在參數(shù)里面設置。適合參數(shù)巨多的場景

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 這樣的用法。一般嘛，自定義容器類，需要實現(xiàn)各種各樣的magic方法，對外接口啊。做為一個懶人，每次自定義都有實現(xiàn)實在是麻煩，還可能會漏。官方提供collections模塊來拯救世界，里面有很多已經定義好的抽象基類。只要實現(xiàn)了要求的magic方法（沒有實現(xiàn)還會很貼心的報錯，告訴你沒有實現(xiàn)），那么可以使用相對于的接口。

最后的嘮叨

還有一些有趣的小細節(jié)用法，沒有貼出來，因為我?guī)ё⑨尠娴?，被我亂切分支，不知道去了哪里了，懶得找出來記錄?？丛创a的思路，主要是看用法，具體的和網絡相關詳細而且細節(jié)的知識略過。目的不是為了學習網絡相關的細節(jié)知識，所以略過，就算要學也不應該看代碼來學，太零散沒有價值，應該要去看相關的協(xié)議。這次拆輪子體驗良好，下次沒有意外的話，應該是拆flask框架。最近發(fā)現(xiàn)本好書<<流暢的python>>里面好多進階知識用法，可能會主要先看它，再繼續(xù)拆，下次更新時間不知道啥時候。