class HTTPAdapter(BaseAdapter):
    """The built-in HTTP Adapter for urllib3.
    :param max_retries: The maximum number of retries each connection
        should attempt. Note, this applies only to failed DNS lookups, socket
        connections and connection timeouts, never to requests where data has
        made it to the server. By default, Requests does not retry failed
        connections. If you need granular control over the conditions under
        which we retry a request, import urllib3's ``Retry`` class and pass
        that instead.
    Usage::
      >>> import requests
      >>> s = requests.Session()
      >>> a = requests.adapters.HTTPAdapter(max_retries=3)
      >>> s.mount('http://', a)
    """
    __attrs__ = ['max_retries', 'config', '_pool_connections', '_pool_maxsize',
                 '_pool_block']
    def __init__(self, pool_connections=DEFAULT_POOLSIZE,
                 pool_maxsize=DEFAULT_POOLSIZE, max_retries=DEFAULT_RETRIES,
                 pool_block=DEFAULT_POOLBLOCK):
        if max_retries == DEFAULT_RETRIES:
            self.max_retries = Retry(0, read=False)
        else:
            self.max_retries = Retry.from_int(max_retries)

class Retry(object):
    """ Retry configuration.
    Each retry attempt will create a new Retry object with updated values, so
    they can be safely reused.
    Retries can be defined as a default for a pool::
        retries = Retry(connect=5, read=2, redirect=5)
        http = PoolManager(retries=retries)
        response = http.request('GET', 'http://example.com/')
    Or per-request (which overrides the default for the pool)::
        response = http.request('GET', 'http://example.com/', retries=Retry(10))
    Retries can be disabled by passing ``False``::
        response = http.request('GET', 'http://example.com/', retries=False)
    Errors will be wrapped in :class:`~urllib3.exceptions.MaxRetryError` unless
    retries are disabled, in which case the causing exception will be raised.
    :param int total:
        Total number of retries to allow. Takes precedence over other counts.
        Set to ``None`` to remove this constraint and fall back on other
        counts. It's a good idea to set this to some sensibly-high value to
        account for unexpected edge cases and avoid infinite retry loops.
        Set to ``0`` to fail on the first retry.
        Set to ``False`` to disable and imply ``raise_on_redirect=False``.
    ....
    
    :param iterable method_whitelist:
        Set of uppercased HTTP method verbs that we should retry on.
        By default, we only retry on methods which are considered to be
        indempotent (multiple requests with the same parameters end with the
        same state). See :attr:`Retry.DEFAULT_METHOD_WHITELIST`.
    :param iterable status_forcelist:
        A set of HTTP status codes that we should force a retry on.
        By default, this is disabled with ``None``.
    :param float backoff_factor:
        A backoff factor to apply between attempts. urllib3 will sleep for::
            {backoff factor} * (2 ^ ({number of total retries} - 1))
        seconds. If the backoff_factor is 0.1, then :func:`.sleep` will sleep
        for [0.1s, 0.2s, 0.4s, ...] between retries. It will never be longer
        than :attr:`Retry.BACKOFF_MAX`.
        By default, backoff is disabled (set to 0).
        
    """
    DEFAULT_METHOD_WHITELIST = frozenset([
        'HEAD', 'GET', 'PUT', 'DELETE', 'OPTIONS', 'TRACE'])
    #: Maximum backoff time.
    BACKOFF_MAX = 120
    def __init__(self, total=10, connect=None, read=None, redirect=None,
                 method_whitelist=DEFAULT_METHOD_WHITELIST, status_forcelist=None,
                 backoff_factor=0, raise_on_redirect=True, raise_on_status=True,
                 _observed_errors=0):
        self.total = total
        self.connect = connect
        self.read = read
        if redirect is False or total is False:
            redirect = 0
            raise_on_redirect = False
        self.redirect = redirect
        self.status_forcelist = status_forcelist or set()
        self.method_whitelist = method_whitelist
        self.backoff_factor = backoff_factor
        self.raise_on_redirect = raise_on_redirect
        self.raise_on_status = raise_on_status
        self._observed_errors = _observed_errors  # TODO: use .history instead?
    def get_backoff_time(self):
        """ Formula for computing the current backoff
        :rtype: float
        """
        if self._observed_errors <= 1:
            return 0
        # 重试算法， _observed_erros就是第几次重试，每次失败这个值就+1.
        # backoff_factor = 0.1, 重试的间隔为[0.1, 0.2, 0.4, 0.8, ..., BACKOFF_MAX(120)]
        backoff_value = self.backoff_factor * (2 ** (self._observed_errors - 1))
        return min(self.BACKOFF_MAX, backoff_value)
    def sleep(self):
        """ Sleep between retry attempts using an exponential backoff.
        By default, the backoff factor is 0 and this method will return
        immediately.
        """
        backoff = self.get_backoff_time()
        if backoff <= 0:
            return
        time.sleep(backoff)
    def is_forced_retry(self, method, status_code):
        """ Is this method/status code retryable? (Based on method/codes whitelists)
        """
        if self.method_whitelist and method.upper() not in self.method_whitelist:
            return False
        return self.status_forcelist and status_code in self.status_forcelist
# For backwards compatibility (equivalent to pre-v1.9):
Retry.DEFAULT = Retry(3)

resp = requests.get('http://www.baidu.com')
Out[75]
resp.status_code
Out[76]: 200
resp.content[:10]
Out[77]: '<!DOCTYPE '
resp.headers['content-type']
Out[79]: 'text/html; charset=utf-8'
resp.reason
Out[80]: 'OK'

# eventlet/hubs/hub.py
# BaseHub
    def run(self, *a, **kw):
        """Run the runloop until abort is called.
        """
        # accept and discard variable arguments because they will be
        # supplied if other greenlets have run and exited before the
        # hub's greenlet gets a chance to run
        if self.running:
            raise RuntimeError("Already running!")
        try:
            self.running = True
            self.stopping = False
            while not self.stopping:
                # 由于垃圾回收，fd可能重新使用，在重新使用的时候通过`mark_as_reopend` -> `_obsolete`
                # 将原来可能存在的监听事件删除。并且将对应的监听事件回调的tb设置为IOClosed异常。
                while self.closed:
                    # We ditch all of these first.
                    self.close_one()
                # 将timer按照到期时间排序
                self.prepare_timers()
                if self.debug_blocking:
                    self.block_detect_pre()
                # 触发定时的事件
                self.fire_timers(self.clock())
                if self.debug_blocking:
                    self.block_detect_post()
                # 将剩下的没有触发的定时事件排序，主要是为了后面找到sleep的时长
                self.prepare_timers()
                # wait的时间，取最快到期的定时事件的时间戳
                wakeup_when = self.sleep_until()
                if wakeup_when is None:
                    sleep_time = self.default_sleep()
                else:
                    sleep_time = wakeup_when - self.clock()
                if sleep_time > 0:
                    # 由具体的平台决定实现(epoll）
                    self.wait(sleep_time)
                else:
                    self.wait(0)
            else:
                self.timers_canceled = 0
                del self.timers[:]
                del self.next_timers[:]
        finally:
            self.running = False
            self.stopping = False

# eventlet/hubs/hub.py
class BaseHub(object):
    def add_timer(self, timer):
        scheduled_time = self.clock() + timer.seconds
        self.next_timers.append((scheduled_time, timer))
        return scheduled_time
        
# eventlet/hubs/timer.py
class Timer(object):
    def __init__(self, seconds, cb, *args, **kw):
        """Create a timer.
            seconds: The minimum number of seconds to wait before calling
            cb: The callback to call when the timer has expired
            *args: The arguments to pass to cb
            **kw: The keyword arguments to pass to cb
        This timer will not be run unless it is scheduled in a runloop by
        calling timer.schedule() or runloop.add_timer(timer).
        """
        self.seconds = seconds
        self.tpl = cb, args, kw
        self.called = False
        if _g_debug:
            self.traceback = six.StringIO()
            traceback.print_stack(file=self.traceback)
     # 按照id的大小进行排序
     def __lt__(self, other):
        return id(self) < id(other)

# eventlet/hubs/poll.py
  def wait(self, seconds=None):
        readers = self.listeners[READ]
        writers = self.listeners[WRITE]
        
        # 如果没有监听的事件，就休眠到第一个定时事件到期
        if not readers and not writers:
            if seconds:
                sleep(seconds)
            return
        try:
            # 进行poll， 对应python的epoll.poll和C语言的epoll_wait
            presult = self.do_poll(seconds)
        except (IOError, select.error) as e:
            if get_errno(e) == errno.EINTR:
                return
            raise
        SYSTEM_EXCEPTIONS = self.SYSTEM_EXCEPTIONS
        if self.debug_blocking:
            self.block_detect_pre()
        # Accumulate the listeners to call back to prior to
        # triggering any of them. This is to keep the set
        # of callbacks in sync with the events we've just
        # polled for. It prevents one handler from invalidating
        # another.
        # 处理满足监听条件的事件，执行对应的回调函数。
        # 如果不满足条件(例如，监听socket读事件但是当前socket不可读)，则对应的fileno，event不会在presult中
        callbacks = set()
        for fileno, event in presult:
            if event & READ_MASK:
                callbacks.add((readers.get(fileno, noop), fileno))
            if event & WRITE_MASK:
                callbacks.add((writers.get(fileno, noop), fileno))
            if event & select.POLLNVAL:
                self.remove_descriptor(fileno)
                continue
            if event & EXC_MASK:
                callbacks.add((readers.get(fileno, noop), fileno))
                callbacks.add((writers.get(fileno, noop), fileno))
        # 依次执行回调。因为epoll会按照fileno的大小排序返回，因此执行回调也是按照从小到大的顺序
        for listener, fileno in callbacks:
            try:
                listener.cb(fileno)
            except SYSTEM_EXCEPTIONS:
                raise
            except:
                self.squelch_exception(fileno, sys.exc_info())
                clear_sys_exc_info()
        if self.debug_blocking:
            self.block_detect_post()

# eventlet/hubs/epoll.py
class Hub(poll.Hub):
    def __init__(self, clock=time.time):
        BaseHub.__init__(self, clock)
        self.poll = epoll()
        try:
            # modify is required by select.epoll
            self.modify = self.poll.modify
        except AttributeError:
            self.modify = self.poll.register
    def add(self, evtype, fileno, cb, tb, mac):
        oldlisteners = bool(self.listeners[READ].get(fileno) or
                            self.listeners[WRITE].get(fileno))
                            
        # 添加监听事件到listeners或者writers中
        # 注意这里调用的是BaseHub.add, 直接绕过了poll.py中的Hub.add
        listener = BaseHub.add(self, evtype, fileno, cb, tb, mac)
        try:
            if not oldlisteners:
                # Means we've added a new listener
                self.register(fileno, new=True)
            else:
                # 注册监听的事件到 epoll上，相当于epoll_register
                self.register(fileno, new=False)
        except IOError as ex:    # ignore EEXIST, #80
            if get_errno(ex) != errno.EEXIST:
                raise
        return listener
        
        
# eventlet/hubs/hub.py
class BaseHub(object):
        
    def add(self, evtype, fileno, cb, tb, mark_as_closed):
        """ Signals an intent to or write a particular file descriptor.
        The *evtype* argument is either the constant READ or WRITE.
        The *fileno* argument is the file number of the file of interest.
        The *cb* argument is the callback which will be called when the file
        is ready for reading/writing.
        The *tb* argument is the throwback used to signal (into the greenlet)
        that the file was closed.
        The *mark_as_closed* is used in the context of the event hub to
        prepare a Python object as being closed, pre-empting further
        close operations from accidentally shutting down the wrong OS thread.
        """
        # 初始化一个listener实例，这个实例保存监听的事件类型evtype、监听fd、回调函数cb，异常tb等
        # 最后将这 listener 按照类型放到 self.listeners中
        # self.listeners = {'READ': {1:listener1, 2:listener2}, 'WRITE': {3: listener3, ..}}
        listener = self.lclass(evtype, fileno, cb, tb, mark_as_closed)
        bucket = self.listeners[evtype]
        if fileno in bucket:
            if g_prevent_multiple_readers:
                raise RuntimeError(
                    "Second simultaneous %s on fileno %s "
                    "detected.  Unless you really know what you're doing, "
                    "make sure that only one greenthread can %s any "
                    "particular socket.  Consider using a pools.Pool. "
                    "If you do know what you're doing and want to disable "
                    "this error, call "
                    "eventlet.debug.hub_prevent_multiple_readers(False) - MY THREAD=%s; "
                    "THAT THREAD=%s" % (
                        evtype, fileno, evtype, cb, bucket[fileno]))
            # store off the second listener in another structure
            self.secondaries[evtype].setdefault(fileno, []).append(listener)
        else:
            bucket[fileno] = listener
        return listener

# eventlet/greenthread.py
class GreenThread(greenlet.greenlet):
    """The GreenThread class is a type of Greenlet which has the additional
    property of being able to retrieve the return value of the main function.
    Do not construct GreenThread objects directly; call :func:`spawn` to get one.
    """
    def __init__(self, parent):
        greenlet.greenlet.__init__(self, self.main, parent)
        self._exit_event = event.Event()
        self._resolving_links = False
    def wait(self):
        """ Returns the result of the main function of this GreenThread.  If the
        result is a normal return value, :meth:`wait` returns it.  If it raised
        an exception, :meth:`wait` will raise the same exception (though the
        stack trace will unavoidably contain some frames from within the
        greenthread module)."""
        return self._exit_event.wait()
    def link(self, func, *curried_args, **curried_kwargs):
        """ Set up a function to be called with the results of the GreenThread.
        The function must have the following signature::
            def func(gt, [curried args/kwargs]):
        When the GreenThread finishes its run, it calls *func* with itself
        and with the `curried arguments <http://en.wikipedia.org/wiki/Currying>`_ supplied
        at link-time.  If the function wants to retrieve the result of the GreenThread,
        it should call wait() on its first argument.
        Note that *func* is called within execution context of
        the GreenThread, so it is possible to interfere with other linked
        functions by doing things like switching explicitly to another
        greenthread.
        """
        self._exit_funcs = getattr(self, '_exit_funcs', deque())
        self._exit_funcs.append((func, curried_args, curried_kwargs))
        if self._exit_event.ready():
            self._resolve_links()
    def unlink(self, func, *curried_args, **curried_kwargs):
        """ remove linked function set by :meth:`link`
        Remove successfully return True, otherwise False
        """
        if not getattr(self, '_exit_funcs', None):
            return False
        try:
            self._exit_funcs.remove((func, curried_args, curried_kwargs))
            return True
        except ValueError:
            return False
    def main(self, function, args, kwargs):
        try:
            result = function(*args, **kwargs)
        except:
            self._exit_event.send_exception(*sys.exc_info())
            self._resolve_links()
            raise
        else:
            self._exit_event.send(result)
            self._resolve_links()
    def _resolve_links(self):
        # ca and ckw are the curried function arguments
        if self._resolving_links:
            return
        self._resolving_links = True
        try:
            exit_funcs = getattr(self, '_exit_funcs', deque())
            while exit_funcs:
                f, ca, ckw = exit_funcs.popleft()
                f(self, *ca, **ckw)
        finally:
            self._resolving_links = False
    def kill(self, *throw_args):
        """Kills the greenthread using :func:`kill`.  After being killed
        all calls to :meth:`wait` will raise *throw_args* (which default
        to :class:`greenlet.GreenletExit`)."""
        return kill(self, *throw_args)
    def cancel(self, *throw_args):
        """Kills the greenthread using :func:`kill`, but only if it hasn't
        already started running.  After being canceled,
        all calls to :meth:`wait` will raise *throw_args* (which default
        to :class:`greenlet.GreenletExit`)."""
        return cancel(self, *throw_args)

# eventlet/greenthread.py
def spawn(func, *args, **kwargs):
    """Create a greenthread to run ``func(*args, **kwargs)``.  Returns a
    :class:`GreenThread` object which you can use to get the results of the
    call.
    Execution control returns immediately to the caller; the created greenthread
    is merely scheduled to be run at the next available opportunity.
    Use :func:`spawn_after` to  arrange for greenthreads to be spawned
    after a finite delay.
    """
    hub = hubs.get_hub()
    g = GreenThread(hub.greenlet)
    hub.schedule_call_global(0, g.switch, func, args, kwargs)
    return g
def spawn_n(func, *args, **kwargs):
    """Same as :func:`spawn`, but returns a ``greenlet`` object from
    which it is not possible to retrieve either a return value or
    whether it raised any exceptions.  This is faster than
    :func:`spawn`; it is fastest if there are no keyword arguments.
    If an exception is raised in the function, spawn_n prints a stack
    trace; the print can be disabled by calling
    :func:`eventlet.debug.hub_exceptions` with False.
    """
    return _spawn_n(0, func, args, kwargs)[1]
    
def _spawn_n(seconds, func, args, kwargs):
    hub = hubs.get_hub()
    g = greenlet.greenlet(func, parent=hub.greenlet)
    t = hub.schedule_call_global(seconds, g.switch, *args, **kwargs)
    return t, g

# eventlet/hubs/poll.py
# BaseHub
    def schedule_call_global(self, seconds, cb, *args, **kw):
        """Schedule a callable to be called after 'seconds' seconds have
        elapsed. The timer will NOT be canceled if the current greenlet has
        exited before the timer fires.
            seconds: The number of seconds to wait.
            cb: The callable to call after the given time.
            *args: Arguments to pass to the callable when called.
            **kw: Keyword arguments to pass to the callable when called.
        """
        t = timer.Timer(seconds, cb, *args, **kw)
        self.add_timer(t)
        return t

# eventlet/greenio/base.py
class GreenSocket(object):
    """
    Green version of socket.socket class, that is intended to be 100%
    API-compatible.
    It also recognizes the keyword parameter, 'set_nonblocking=True'.
    Pass False to indicate that socket is already in non-blocking mode
    to save syscalls.
    """
    # This placeholder is to prevent __getattr__ from creating an infinite call loop
    fd = None
    def __init__(self, family_or_realsock=socket.AF_INET, *args, **kwargs):
        should_set_nonblocking = kwargs.pop('set_nonblocking', True)
        if isinstance(family_or_realsock, six.integer_types):
            # 创建原生的socket 或者包装已有的socket
            fd = _original_socket(family_or_realsock, *args, **kwargs)
            # Notify the hub that this is a newly-opened socket.
            # 这是个新打开的fd，如果之前有监听的事件删除之
            notify_opened(fd.fileno())
        else:
            fd = family_or_realsock
        # import timeout from other socket, if it was there
        try:
            self._timeout = fd.gettimeout() or socket.getdefaulttimeout()
        except AttributeError:
            self._timeout = socket.getdefaulttimeout()
        # 设置为非堵塞模式，需要注意set_nonblocking这个参数的意思是 传入的socket已经是非堵塞的了，不需要额外的设置。
        if should_set_nonblocking:
            set_nonblocking(fd)
        self.fd = fd
        # when client calls setblocking(0) or settimeout(0) the socket must
        # act non-blocking
        self.act_non_blocking = False
        # Copy some attributes from underlying real socket.
        # This is the easiest way that i found to fix
        # https://bitbucket.org/eventlet/eventlet/issue/136
        # Only `getsockopt` is required to fix that issue, others
        # are just premature optimization to save __getattr__ call.
        self.bind = fd.bind
        self.close = fd.close
        self.fileno = fd.fileno
        self.getsockname = fd.getsockname
        self.getsockopt = fd.getsockopt
        self.listen = fd.listen
        self.setsockopt = fd.setsockopt
        self.shutdown = fd.shutdown
        self._closed = False
        
        
    def _trampoline(self, fd, read=False, write=False, timeout=None, timeout_exc=None):
        """ We need to trampoline via the event hub.
            We catch any signal back from the hub indicating that the operation we
            were waiting on was associated with a filehandle that's since been
            invalidated.
        """
        # 处理已经closed的情况
        if self._closed:
            # If we did any logging, alerting to a second trampoline attempt on a closed
            # socket here would be useful.
            raise IOClosed()
        try:
            return trampoline(fd, read=read, write=write, timeout=timeout,
                              timeout_exc=timeout_exc,
                              mark_as_closed=self._mark_as_closed)
        except IOClosed:
            # This socket's been obsoleted. De-fang it.
            self._mark_as_closed()
            raise
    def accept(self):
        if self.act_non_blocking:
            return self.fd.accept()
        fd = self.fd
        while True:
            # 非堵塞的读取，如果返回errno.EWOULDBLOCK异常，返回None
            res = socket_accept(fd)
             
            # 返回正常可读，设置client为非堵塞，然后绿化之
            if res is not None:
                client, addr = res
                set_nonblocking(client)
                return type(self)(client), addr
            # 对方可能堵塞了，先垫一下(trampoline弹簧垫的意思）
            self._trampoline(fd, read=True, timeout=self.gettimeout(),
                             timeout_exc=socket.timeout("timed out"))
                             
def socket_accept(descriptor):
    """
    Attempts to accept() on the descriptor, returns a client,address tuple
    if it succeeds; returns None if it needs to trampoline, and raises
    any exceptions.
    """
    try:
        return descriptor.accept()
    except socket.error as e:
        if get_errno(e) == errno.EWOULDBLOCK:
            return None
        raise
        
def trampoline(fd, read=None, write=None, timeout=None,
               timeout_exc=timeout.Timeout,
               mark_as_closed=None):
    """Suspend the current coroutine until the given socket object or file
    descriptor is ready to *read*, ready to *write*, or the specified
    *timeout* elapses, depending on arguments specified.
    To wait for *fd* to be ready to read, pass *read* ``=True``; ready to
    write, pass *write* ``=True``. To specify a timeout, pass the *timeout*
    argument in seconds.
    If the specified *timeout* elapses before the socket is ready to read or
    write, *timeout_exc* will be raised instead of ``trampoline()``
    returning normally.
    .. note :: |internal|
    """
    t = None
    hub = get_hub()
    current = greenlet.getcurrent()
    assert hub.greenlet is not current, 'do not call blocking functions from the mainloop'
    assert not (
        read and write), 'not allowed to trampoline for reading and writing'
    try:
        fileno = fd.fileno()
    except AttributeError:
        fileno = fd
        
    # 如果设置了超时时间，定义一个超时的定时事件，从而greenlet.throw产生超时异常
    if timeout is not None:
        def _timeout(exc):
            # This is only useful to insert debugging
            current.throw(exc)
        t = hub.schedule_call_global(timeout, _timeout, timeout_exc)
    # 根据读写任务类型，添加到Hub中进行监听。回调函数是current.switch。即如果某个绿色线程监听的事件满足条件
    # 就在每个Hub循环中通过current.switch切回本绿色线程继续处理，直到处理完毕或者绿色线程主动让出处理
    try:
        if read:
            listener = hub.add(hub.READ, fileno, current.switch, current.throw, mark_as_closed)
        elif write:
            listener = hub.add(hub.WRITE, fileno, current.switch, current.throw, mark_as_closed)
        try:
            # 已经注册了监听事件，切回Hub中的绿色线程处理
            return hub.switch()
        finally:
            # finally能够运行，说明监听条件满足了，从监听中移除该事件。
            hub.remove(listener)
    finally:
        if t is not None:
            t.cancel()

import time
import greenlet
all_g = {}
def format_print(*args):    # 打印当前协程、父协程、输出
	global all_g
	current = greenlet.getcurrent()
	print 'greenlet(%s), parent(%s): %s' % (
              all_g[id(current)], 
              all_g[id(current.parent)],
              ' '.join(map(str, args)))
def run1(start):
	format_print('g1 begin, start', start)
	for i in range(2):  # 注意这里是循环2次
		time.sleep(1)
		start += 1
		start = g2.switch(start)
		format_print('start', start)
	format_print('g1 end, start', start)
def run2(start):
	format_print('g2 begin, start', start)
	for i in range(3):  # 注意这里循环3次
		time.sleep(1)
		start += 1
		start = g1.switch(start)
		format_print('start', start)
	format_print('g2 end, start', start)
def run3(num):
	format_print('g3 begin, num', num)
	for i in range(num):
		format_print('i', i)
		time.sleep(1)
	end = g2.switch(num+100)
	format_print('g3 end', end)
g1 = greenlet.greenlet(run=run1, parent=greenlet.getcurrent())
g2 = greenlet.greenlet(run=run2, parent=greenlet.getcurrent())
g3 = greenlet.greenlet(run=run3, parent=g2)
all_g[id(None)] = 'main'
all_g[id(greenlet.getcurrent())] = 'main'
all_g[id(g1)] = 'g1'
all_g[id(g2)] = 'g2'
all_g[id(g3)] = 'g3'
g1.switch(0)
format_print('back main after g1.switch')
g3.switch(3)
format_print('back main after g3.switch')
format_print(g1.switch('back g1 from main'))
format_print(g3.switch('back g3 from main'))

greenlet.greenlet(run=None, parent=None) => greenlet object
run: 传入需要运行的函数，与`Thread`中的`target`相同
parent: 转入协程的父协程，默认为当前协程

def run(*args, **kwargs):
    print args, kwargs
    print 'run over'
parent = greenlet.greenlet(run=run)
child = greenlet.greenlet(run=run, parent=parent)
child.switch()
>>
(), {}
run over
(None,), {}
run over

def run_child(*args):
    print args
    print 'child over'
    
def run_parent(*args):
    print args
    rv = child.switch('hi, child')
    print 'Parent continue with:', rv
    
parent = greenlet.greenlet(run=run_parent)
child = greenlet.greenlet(run=run_child, parent=parent)
parent.switch()
>>>
()
('hi, child',)
child over
Parent continue with: None

def run_g1():
    print 1, 2
    g2.switch()
    print 5, 6
    
def run_g2():
    print 3, 4
    g1.switch()
    print 7, 8
g1 = greenlet.greenlet(run=run_g1)
g2 = greenlet.greenlet(run=run_g2)
g1.switch()
>>>
1, 2
3, 4
5, 6    # 结束

greenlet.switch(*args, **kargs)
args: 不定参数
kwargs: 位置参数

def run():
    print 'over'
g = greenlet.greenlet(run=run)
print g.dead
print g.switch()
print g.dead
print g.switch(1, 2)
print g.switch()
>>>
False
over
True
(1, 2)
()

greenlet.throw([type, [val, [tb]]])
type: 异常类型，例如TypeError 之类
val: 传递给type的参数，例如‘type is not correct’
tb: 传递给type的参数，异常的栈。

def raiser():
    raise typ, val, tb
g_raiser = greenlet(raiser, parent=g)
g_raiser.switch()

def run():
    try:
        greenlet.getcurrent().parent.switch()
    except greenlet.GreenletExit:
        print 'exit'
        raise       # raise IOError 加入抛出其他异常，对比抛出GreenletExit
g = greenlet.greenlet(run=run)
g.switch()
ge = g.throw()  #
print type(ge)
>>>
exit
greenlet.GreenletExit

greenlet(g1), parent(main): g1 begin, start 0
greenlet(g2), parent(main): g2 begin, start 1
greenlet(g1), parent(main): start 2
greenlet(g2), parent(main): start 3
greenlet(g1), parent(main): start 4
greenlet(g1), parent(main): g1 end, start 4     # g1运行结束，转到父协程(main）中运行
greenlet(main), parent(main): back main after g1.switch
greenlet(g3), parent(g2): g3 begin, num 3   
greenlet(g3), parent(g2): i 0
greenlet(g3), parent(g2): i 1
greenlet(g3), parent(g2): i 2   
greenlet(g2), parent(main): start 103   # g3循环3次转到g2运行
greenlet(main), parent(main): back main after g3.switch
greenlet(main), parent(main): back g1 from main # g1运行已经结束，因此g1.switch()直接返回传递的参数
greenlet(g3), parent(g2): g3 end back g3 from main
greenlet(g2), parent(main): start None  # g3运行结束，转回到父协程g2，因此获取的值为None
greenlet(g2), parent(main): g2 end, start None
greenlet(main), parent(main): None  # g2运行结束，因此获取的参数是None

import threading
import greenlet
import time
def run():
    print 'run in thread'
    
g = greenlet.greenlet(run=run)
th = threaing.Thread(target=g.switch)
th.start()
>>>
Traceback ...
...
error: cannot switch to a different thread

class Spam(object):
	def __init__(self, a, b):
		self.a, self.b = a, b
	
class SpamFactory(self):
    def __init__(self):
		self.__instances = {}
  
    def get_instance(self, a, b):
        key = (a, b)
        if key not in self.__instances:
            self.__instance[key] = Spam(a, b)
        return self.__instance[key]
class Egg(self):
	def __init__(self, x, y):
 		self.x, self.y = x, y
    
class EggFactory(object):
	def __init__(self):
		self.__instances = {}
    
    def get_instance(self, x, y):
		key = (x, y)
		if key not in self.__instances:
			self.__instances[key] = Egg(x, y)
        return self.__instances[key]
#----------------------------
spam_factory = SpamFactory()
egg_factory = EggFactory()
assert spam_factory.get_instance(1, 2) is spam_factory.get_instance(1, 2)
assert egg_factory.get_instance('a', 'b') is egg_factory.get_instance('a', 'b')
assert spam_factory.get_instance(1, 2) is not egg_factory.get_instance(1, 2)

class FlyweightFactory(object):
	def __init__(self, cls):
		self._cls = cls
 		self.__instances = {}
	def get_instance(self, *args, **kwargs):
		key = (args, tuple(kwargs.items()))
		return self.__instances.setdefault(key, self._cls(*args, **kwargs))
#--------------------------------------
class Spam(object):
	def __init__(self, a, b):
		self.a, self.b = a, b
class Egg(object):
	def __init__(self, x, y):
 		self.x, self.y = x, y
class SubSpam(Spam):
	pass
SpamFactory = FlyweightFactory(Spam)
EggFactory = FlyweightFactory(Egg)
SubSpamFactory = FlyweightFactory(SubSpam)
assert SpamFactory.get_instance(1, 2) is SpamFactory.get_instance(1, 2)
assert EggFactory.get_instance('a', 'b') is EggFactory.get_instance('a', 'b')
assert SubSpamFactory.get_instance(1, 2) is not SpamFactory.get_instance(1, 2)

class Flyweight(object):
	def __init__(self, cls):
		self._cls = cls
		self.__instances = {}
	def __call__(self, *args, **kwargs):
		key = (args, tuple(kwargs.items()))
		return self.__instances.setdefault(key, self._cls(*args, **kwargs))
@Flyweight
class Spam(object):
	def __init__(self, a, b):
		self.a, self.b = a, b
@Flyweight
class Egg(object):
	def __init__(self, x, y):
 		self.x, self.y = x, y
assert Spam(1, 2) is Spam(1, 2)
assert Egg('a', 'b') is Egg('a', 'b')
@Flyweight
class SubSpam(Spam._cls):	# 不能使用Spam
	pass
assert SubSpam(1, 2) is SubSpam(1, 2)
assert SubSpam(1, 2) is not Spam(1, 2)

def flyweight(cls):
	instances = {}
	return lambda *args, **kwargs: instances.setdefault(
		(args, tuple(kwarges.items())), 
        cls(*args, **kwargs))
# 或者不使用lambda
def flyweight(cls):
	instances = {}
	def _wrap(*args, **kwargs):
		key = (args, tuple(kwargs.items()))
		return instances.setdefault(key, cls(*args, **kwargs))
	return _wrap

class FlyweightMixin(object):
	_instances = {}
	@classmeothd
	def get_instance(cls, *args, **kwargs):
		return cls._instance.setdefault(
			(args, tuple(kwargs.items())),
			cls(*args, **kwargs))
class Spam(FLyweightMixin):
	def __init__(self, a, b):
		self.a, self.b = a, b
class Egg(FLyweightMixin):
	def __init__(self, x, y):
		self.x, self.y = x, y
assert Spam.get_instance(1, 2) is Spam.get_instance(1, 2)
assert Egg.get_instance('a', 'b') is Egg.get_instance('a', 'b')
class SubSpam(Spam):
	pass
assert SubSpam.get('x', 'y') is SubSpam.get_instance('x', 'y')
assert SubSpam.get('a', 'b') is not Spam.get_instance('a', 'b')

# 所有实例都缓存在FlyweightMixin中
class FlyweightMixin(object):
	_instances = {}
	def __init__(self):
		raise NotImplementedException
	def __new__(cls, *args, **kwargs):
		return cls._instances.setdefault(
				# 需要cls作为键值的一部分
				(cls, args, tuple(kwargs.items())),
				# 通过super和type调用享元类进行实例化
				super(type(cls), cls).__new__(cls, *args, **kwargs))
class Spam(FlyweightMixin):
    def __init__(self, a, b):
        self.a = a
        self.b = b
class Egg(FlyweightMixin):
    def __init__(self, x, y):
        self.x = x
        self.y = y
assert Spam(1, 2) is Spam(1, 2)
assert Egg('a', 'b') is Egg('a', 'b')
assert Spam(1, 2) is not Egg(1, 2)
# Subclassing a flyweight class
class SubSpam(Spam):
    pass
assert SubSpam(1,2) is SubSpam(1,2)
assert Spam(1,2) is not SubSpam(1,2)

@classmethod
def get_instance(cls, *args, **kwargs):
	return cls._instances.setdefault(
			(cls, args, tuple(kwargs.items())),
			super(type(cls), cls).__new__(*args, **kwargs)
def flyweight(decoree):
	decoree._instances = {}
	# 将get_instance 修改为 享元类进行实例化时调用的函数__new__
	# python中 __new__是真正的构建函数，决定实例的模板和内存结构
	# 而 __init__更像初始化函数，用来给实例变量赋予初值
	decoree.__new__ = get_instance
	return decoree
#---------------------------
@flyweight
class Spam(object):
    def __init__(self, a, b):
        self.a = a
        self.b = b
@flyweight
class Egg(object):
    def __init__(self, x, y):
        self.x = x
        self.y = y
assert Spam(1, 2) is Spam(1, 2)
assert Egg('a', 'b') is Egg('a', 'b')
assert Spam(1, 2) is not Egg(1, 2)
# Subclassing a flyweight class
class SubSpam(Spam):
    pass
assert SubSpam(1,2) is SubSpam(1,2)
assert Spam(1,2) is not SubSpam(1,2)

class MetaFlyweight(type):
	def __new__(cls, *args, **kwargs):
		# 初始化类本身，类作为超类的实例进行初始化，可以忽略
		type.__init__(cls, *args, **kwargs)
		cls._instances = {}
		# 修改类的构建函数
		cls.__new__ = cls._get_instance
	def _get_instance(cls, *args, **kwargs):
		return cls._instances.setdefault(
			(args, tuple(kwargs.items())),
			# 调用 享元类 本身去实例化
			super(cls, cls).__new__(*args, **kwargs))
class Spam(object):
    __metaclass__ = MetaFlyweight
    def __init__(self, a, b):
        self.a = a
        self.b = b
class Egg(object):
    __metaclass__ = MetaFlyweight
    def __init__(self, x, y):
        self.x = x
        self.y = y
assert Spam(1, 2) is Spam(1, 2)
assert Egg('a', 'b') is Egg('a', 'b')
assert Spam(1, 2) is not Egg(1, 2)
# Subclassing a flyweight class
class SubSpam(Spam):
    pass
assert SubSpam(1,2) is SubSpam(1,2)
assert Spam(1,2) is not SubSpam(1,2)

@classmethod
def _get_instance(cls, *args, **kwargs):
	return cls.__instances.setdefault(
		(args, tuple(kwargs.items())),
		super(type(cls), cls).__new__(*args, **kwargs))
def metaflyweight(name, parents, attrs):
	# 通过实例化type，动态构建享元类本身
	cls = type(name, parents, attrs)
	# 设置类属性
	cls.__instances = {}
	# 修改享元类实例化时的逻辑
	cls.__new__ = _get_instance
	return cls
#----------------------------------------------------------
class Spam(object):
    __metaclass__ = metaflyweight
    def __init__(self, a, b):
        self.a = a
        self.b = b
class Egg(object):
    __metaclass__ = metaflyweight
    def __init__(self, x, y):
        self.x = x
        self.y = y
assert Spam(1, 2) is Spam(1, 2)
assert Egg('a', 'b') is Egg('a', 'b')
assert Spam(1, 2) is not Egg(1, 2)
# Subclassing a flyweight class
class SubSpam(Spam):
    pass
assert SubSpam(1,2) is SubSpam(1,2)
assert Spam(1,2) is not SubSpam(1,2)

metaflyweight = lambda name, parents, attrs: type(
	name,
    parents,
	#  直接通过__new__, __instances加入attrs
    dict(attrs.items() + [
		('__instances', {}),
		('__new__', classmethod(
			lambda cls, *args, **kwargs: cls.__instances.setdefault(
				(args, tuple(kwargs.items())),
				super(type(cls), cls).__new__(*args, **kwargs))
			)
		)
	])
)
#----------------------------------------------------------
class Spam(object):
    __metaclass__ = metaflyweight
    def __init__(self, a, b):
        self.a = a
        self.b = b
class Egg(object):
    __metaclass__ = metaflyweight
    def __init__(self, x, y):
        self.x = x
        self.y = y
assert Spam(1, 2) is Spam(1, 2)
assert Egg('a', 'b') is Egg('a', 'b')
assert Spam(1, 2) is not Egg(1, 2)
# Subclassing a flyweight class
class SubSpam(Spam):
    pass
assert SubSpam(1,2) is SubSpam(1,2)
assert Spam(1,2) is not SubSpam(1,2)

class ObjectDict(dict):
    """Makes a dictionary behave like an object, with attribute-style access.
    """
    def __getattr__(self, name):
        try:
            return self[name]
        except KeyError:
            raise AttributeError(name)
    def __setattr__(self, name, value):
        self[name] = value
od = ObjectDict()
od.a = 1
od['a']		# 1
od.a		# 1

def import_object(name):
    """Imports an object by name.
    import_object('x') is equivalent to 'import x'.
    import_object('x.y.z') is equivalent to 'from x.y import z'.
    >>> import tornado.escape
    >>> import_object('tornado.escape') is tornado.escape
    True
    >>> import_object('tornado.escape.utf8') is tornado.escape.utf8
    True
    >>> import_object('tornado') is tornado
    True
    >>> import_object('tornado.missing_module')
    Traceback (most recent call last):
        ...
    ImportError: No module named missing_module
    """
    if name.count('.') == 0:
        return __import__(name, None, None)
    parts = name.split('.')
    obj = __import__('.'.join(parts[:-1]), None, None, [parts[-1]], 0)
    try:
        return getattr(obj, parts[-1])
    except AttributeError:
        raise ImportError("No module named %s" % parts[-1])

import_object('os')
os	#NameError
path_exists = import_object('os.path.exists')
# from  os.path import exists as path_exists
####################
mypath = importlib.import_module('.path', 'os')
# from os import path as mypath

import tornado.ioloop
import tornado.web
class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write("Hello, world")
application = tornado.web.Application([
    (r"/", MainHandler),
])
if __name__ == "__main__":
    application.listen(8888)
    tornado.ioloop.IOLoop.instance().start()

from tornado.httpclient import AsyncHTTPClient
def asynchronous_fetch(url, callback):
    http_client = AsyncHTTPClient()
    def handle_response(response):
        callback(response.body)
    http_client.fetch(url, callback=handle_response)

from tornado.concurrent import Future
def async_fetch_future(url):
    http_client = AsyncHTTPClient()
    my_future = Future()
    fetch_future = http_client.fetch(url)
    fetch_future.add_done_callback(
        lambda f: my_future.set_result(f.result()))
    return my_future

from tornado import gen
@gen.coroutine
def fetch_coroutine(url):
    http_client = AsyncHTTPClient()		# 堵塞前操作
    response = yield http_client.fetch(url)	# 堵塞操作
    return response.body	# 堵塞后操作

# Simplified inner loop of tornado.gen.Runner
def run(self):
    # send(x) makes the current yield return x.
    # It returns when the next yield is reached
    future = self.gen.send(self.next) 
	# 通过send 通知 协程进行 堵塞后操作
	# future衔接 堵塞前和堵塞后的逻辑
    def callback(f):
        self.next = f.result()
        self.run()
    future.add_done_callback(callback)
	# 向future中注册辅助函数，进行回调后的通知

import threading
class Singleton(object):
	_singleton_lock = threading.Lock()
	@classmethod
	def instance(cls):
		if not hasattr(cls, '_instance'):
			with cls._singleton_lock:
				if not hasattr(cls, '_instance'):
					cls._instance = cls()
		return cls._instance
	def test(self):
		print('ok')
assert Singleton.instance() is Singleton.instance()		#True

def myfunc(x):
	do_something_with(x)
tpid = thread.start_new_thread(myfunc, (1,))

from django import forms
class MyTestForm(forms.Form):
    my_test_field = forms.CharField(max_length=20, min_length=0)

# <1>
# django/forms/forms.py
# 为了使用python的元编程，Form就是一个简单的继承类，作为`MyTestForm`等自定义类的语法支持，所有的自定义类必须继承于Form
# Form的基类就是six.with_metaclass的返回值，实际上是一个临时的中介类，它的具体作用稍后分析
class Form(six.with_metaclass(DeclarativeFieldsMetaclass, BaseForm)):
    "A collection of Fields, plus their associated data."
    # This is a separate class from BaseForm in order to abstract the way
    # self.fields is specified. This class (Form) is the one that does the
    # fancy metaclass stuff purely for the semantic sugar -- it allows one
    # to define a form using declarative syntax.
    # BaseForm itself has no way of designating self.fields.
# <2>
# django/utils/six.py
# 临时的中介类由此函数生成，即 type.__new__(cls, name, (), d)
# 这个临时的中介类作为Form的基类，以便于在生成真实类时调用meta这个超类
# 到这里就有了两层的中介：第一层forms.Form作为用户自定义类的基类（类似于接口的作用）
# 第二层，临时的中介类作为forms.Form的基类，以便于调用形成最后真实类的超类meta
# MyTestClass -> Form -> 临时中介类 -> 超类meta -> 真实类
def with_metaclass(meta, *bases):
    """Create a base class with a metaclass."""
    # This requires a bit of explanation: the basic idea is to make a
    # dummy metaclass for one level of class instantiation that replaces
    # itself with the actual metaclass.  Because of internal type checks
    # we also need to make sure that we downgrade the custom metaclass
    # for one level to something closer to type (that's why __call__ and
    # __init__ comes back from type etc.).
    class metaclass(meta):
        __call__ = type.__call__
        __init__ = type.__init__
        def __new__(cls, name, this_bases, d):
            if this_bases is None:
                return type.__new__(cls, name, (), d)
            return meta(name, bases, d)
    return metaclass('temporary_class', None, {})
# 上面的__new__方法会调用2次：第一次在six.with_metaclass被调用时调用，返回一个临时的中介类作为forms.Form的继承基类；
# 第二次在定义(程序运行编译时)`MyTestForm`时调用，返回meta(name, bases, d)生成最后的真实类，
# 这个类就是`MyTestForm`实例化时真正其作用的类
# 所以，表面看上`MyTestForm`是自定义类，实例由该类实例化；
# 单由于超类的存在，`MyTestForm`这个名字实际上指向的是由DeclarativeFieldsMetaclass动态生成的类
#（meta(name, bases, d)），它的基类是BaseForm
# <3>
# django/forms/forms.py
# DeclarativeFieldsMetaclass是生成最后真实类的超类， meta(name, bases, attrs)中的meta
# 将定义的各个Field实例，收集到真实类的base_fields中
# 这个超类的以小写class结尾，与其它超累的大写Class不一致:)
class DeclarativeFieldsMetaclass(MediaDefiningClass):
    """
    Metaclass that collects Fields declared on the base classes.
    """
    # 这个attrs包含了MyTestClass等用户自定义类中的类属性，例如my_test_field等
    # 还包含了BaseForm的各个属性和方法
    def __new__(mcs, name, bases, attrs):
        # Collect fields from current class.
        current_fields = []
        for key, value in list(attrs.items()):
            if isinstance(value, Field):
                current_fields.append((key, value))
                attrs.pop(key)
        current_fields.sort(key=lambda x: x[1].creation_counter)
        attrs['declared_fields'] = OrderedDict(current_fields)
        new_class = (super(DeclarativeFieldsMetaclass, mcs)
            .__new__(mcs, name, bases, attrs))
        # Walk through the MRO.
        declared_fields = OrderedDict()
        for base in reversed(new_class.__mro__):
            # Collect fields from base class.
            if hasattr(base, 'declared_fields'):
                declared_fields.update(base.declared_fields)
            # Field shadowing.
            for attr, value in base.__dict__.items():
                if value is None and attr in declared_fields:
                    declared_fields.pop(attr)
        new_class.base_fields = declared_fields
        new_class.declared_fields = declared_fields
        return new_class
# <4>
# django/forms/forms.py
# BaseForm是`MyTestForm`等用户自定义类的基类
# 会作为 meta(name, bases, attrs)中的bases
@python_2_unicode_compatible
class BaseForm(object):
    # This is the main implementation of all the Form logic. Note that this
    # class is different than Form. See the comments by the Form class for more
    # information. Any improvements to the form API should be made to *this*
    # class, not to the Form class.
    def __init__(self, data=None, files=None, auto_id='id_%s', prefix=None,
                 initial=None, error_class=ErrorList, label_suffix=None,
                 empty_permitted=False):
        # 如果实例化时传入了数据，则认为该Form是绑定的。
        # 例如用户提交表单在view中有form = MyTestForm(**request.cleaned_data)
        self.is_bound = data is not None or files is not None
        self.data = data or {}
        self.files = files or {}
        self.auto_id = auto_id
        self.prefix = prefix
        self.initial = initial or {}
        self.error_class = error_class
        # Translators: This is the default suffix added to form field labels
        self.label_suffix = label_suffix if label_suffix is not None else _(':')
        self.empty_permitted = empty_permitted
        self._errors = None  # Stores the errors after clean() has been called.
        self._changed_data = None
        # The base_fields class attribute is the *class-wide* definition of
        # fields. Because a particular *instance* of the class might want to
        # alter self.fields, we create self.fields here by copying base_fields.
        # Instances should always modify self.fields; they should not modify
        # self.base_fields.
        # 将属于类的base_fields复制到属于实例的fields中，防止后续操作污染类属性base_fields
        # base_fields是由
        self.fields = copy.deepcopy(self.base_fields)

# 1.7.1版本django中的six.with_metaclass
def with_metaclass(meta, *bases):
    """Create a base class with a metaclass."""
    # This requires a bit of explanation: the basic idea is to make a
    # dummy metaclass for one level of class instantiation that replaces
    # itself with the actual metaclass.  Because of internal type checks
    # we also need to make sure that we downgrade the custom metaclass
    # for one level to something closer to type (that's why __call__ and
    # __init__ comes back from type etc.).
    class metaclass(meta):
        __call__ = type.__call__
        __init__ = type.__init__
        def __new__(cls, name, this_bases, d):
            if this_bases is None:
                return type.__new__(cls, name, (), d)
            return meta(name, bases, d)
    return metaclass('temporary_class', None, {})
# 1.5.11版本的six.with_metaclass
def with_metaclass(meta, *bases):
    """Create a base class with a metaclass."""
    return meta("NewBase", bases, {})
# 这个meta中的__new__会调用两次：第一次是调用with_metaclass生成中介类，作为Form的基类；
# 第二次实现`MyTestForm`等用户自定义类生成真实类

# 1.7.1
In[13]: from django import forms
In[15]: type(forms.Form)
Out[15]: django.forms.forms.DeclarativeFieldsMetaclass
In[16]: forms.Form.mro()
Out[16]: [django.forms.forms.Form,  # 不存在tempary_class的中介类
          django.forms.forms.BaseForm, 
          object]
# 1.5.1
In [1]: from django import forms
In [2]: type(forms.Form)
Out[2]: django.forms.forms.DeclarativeFieldsMetaclass
In [3]: forms.Form.mro  
Out[3]: <function mro>
In [4]: forms.Form.mro()
Out[4]: 
[django.forms.forms.Form,
 django.forms.forms.NewBase,  # 1.7.1中的继承中少了这个中介类NewBase(tempary_class) 
 django.forms.forms.BaseForm,
 object]

# django.forms.BoundField
def __str__(self):
    """Renders this field as an HTML widget."""
    if self.field.show_hidden_initial:
        return self.as_widget() + self.as_hidden(only_initial=True)
    return self.as_widget()
def as_widget(self, widget=None, attrs=None, only_initial=False):
    """
    Renders the field by rendering the passed widget, adding any HTML
    attributes passed as attrs.  If no widget is specified, then the
    field's default widget will be used.
    """
    if not widget:
        widget = self.field.widget
    if self.field.localize:
        widget.is_localized = True
    attrs = attrs or {}
    auto_id = self.auto_id
    if auto_id and 'id' not in attrs and 'id' not in widget.attrs:
        if not only_initial:
            attrs['id'] = auto_id
        else:
            attrs['id'] = self.html_initial_id
    if not only_initial:
        name = self.html_name
    else:
        name = self.html_initial_name
    # 通过field.render函数获取field的html
    return force_text(widget.render(name, self.value(), attrs=attrs))

# Input.render
# render会被BoundField调用，输出input标签的html语句
def render(self, name, value, attrs=None):
    if value is None:
        value = ''
    # self.input_type由每个继承input的重载，实现input标签中的type="textarea"属性
    final_attrs = self.build_attrs(attrs, type=self.input_type, name=name)
    if value != '':
        # Only add the 'value' attribute if a value is non-empty.
        final_attrs['value'] = force_text(self._format_value(value))
    # flatatt会将attrs转换为key=value形式，例如 class="css_class" name="for_id"
    return format_html('<input{0} />', flatatt(final_attrs))

a = [1, 2, 3, 4]
c = 'abcdef'
print a[::-1]
print c[::-1]
print list(reversed(a))
print list(reversed(c))
==>
c[::-1]
>>> 'fedcba'
list(reversed(c))
>>> ['f', 'e', 'd', 'c', 'b', 'a']

print 'Hello %s!' % ('Tom', )
==>
print 'Hello %s!' % 'Tom'

print '{greet} from {language}.'.format(greet = 'Hello World', language = 'Python')
==>
print '{greet} from {language}.'.format(greet='Hello,world', language='Python')

%timeit '{greet} from {language}.'.format(greet = 'Hello World', language = 'Python')
1000000 loops, best of 3: 780 ns per loop
%timeit '%s from %s.' % ('Hello World', 'Python')
1000000 loops, best of 3: 202 ns per loop

# 实例一
def funA(list, num):
	for element in list:
		if num==element:
			return True
		else:	# pass这边根本没用， 没找到应该返回Fase
			pass
# 实例二
def find_num(searchList, num):
	for listValue in searchList:
		if num==listValue:
			return True
		else:
			pass
==>
def has_find(alist, num):
	return num in alist

import random
guesses_made = 0	# 变量初始化与使用的地方太远，移动到while之前比较好
name = raw_input('Hello! What is your name?\n')
number = random.randint(1, 20)
print 'Well, {0}, I am thinking of a number between 1 and 20.'.format(name)
while guesses_made < 6:
	guess = int(raw_input('Take a guess: ')) 	# 没有处理异常，输入字符等情况
	guesses_made += 1
	if guess < number:	# 分支是互斥的，用 if .. elif .. else 比较好
		print 'Your guess is too low.'
	if guess > number:
		print 'Your guess is too high.'
	if guess == number:	
		Break	# 没有Break，是 break
if guess == number:
	print 'Good job, ..'
else:
	print 'Nope. ..'