django源代码非常多，框架比较大，以我水平要分析一下还是比较吃力得，能看懂就不错了，要讲出来并且讲得比较清楚就更难了。所以先从小处入手，一点点看django得细节。
1. 信用卡验证算法-luhn算法。
in django/utils/checksums.py
代码比较简单
LUHN_ODD_LOOKUP = (0, 2, 4, 6, 8, 1, 3, 5, 7, 9) # sum_of_digits(index * 2)
def luhn(candidate):
"""
Checks a candidate number for validity according to the Luhn
algorithm (used in validation of, for example, credit cards).
Both numeric and string candidates are accepted.
"""
if not isinstance(candidate, basestring):
candidate = str(candidate)
try:
evens = sum([int(c) for c in candidate[-1::-2]])
odds = sum([LUHN_ODD_LOOKUP[int(c)] for c in candidate[-2::-2]])
return ((evens + odds) % 10 == 0)
except ValueError: # Raised if an int conversion fails
return False
原理是：
1、从卡号最后一位数字开始，逆向将奇数位(1、3、5等等)相加。
2、将偶数位数字相加，但是这里有个麻烦。必须先将数字乘以2，如果结果是两位数，将两个位上数字相加。然后将这些结果加入总和中。
3、将奇数位总和加上偶数位总和，如果信用卡号码是合法的，结果应该可以被10整除。
2. smart_unicode, smart_str
基本上就是unicode和str，不过更安全一点，对于非字符串对象更好支持, 对于字符串使用decode和encode，支持更多字符集
smart_unicode(s, encoding='utf-8', strings_only=False, errors='strict')
smart_str(s, encoding='utf-8', strings_only=False, errors='strict')
3. memoize
in django/utils/functional.py
def memoize(func, cache, num_args):
"""
Wrap a function so that results for any argument tuple are stored in
'cache'. Note that the args to the function must be usable as dictionary
keys.
Only the first num_args are considered when creating the key.
"""
@wraps(func)
def wrapper(*args):
mem_args = args[:num_args]
if mem_args in cache:
return cache[mem_args]
result = func(*args)
cache[mem_args] = result
return result
return wrapper
看懂这个函数之前要先了解functools.wraps 和functools.update_wrap
其实update_wrap主要是将wrapped对象拷贝一些属性到wrapper对象中去， wraps则是update_wrap的partial
明白了wraps，则上面mimoize也就没什么难的了
4. curry
in django/utils/functional.py
功能和functools.partial一样，只不过parital返回partial对象，而curry返回函数
5.lazy
in django/utils/functional.py
先看在其他地方看到的一个lazy init class的例子：
class LazyProxy(object):
def __init__(self, cls, *params, **kwargs):
self.__dict__["_cls"]=cls
self.__dict__["_params"]=params
self.__dict__["_kwargs"]=kwargs
self.__dict__["_obj"]=None
def __getattr__(self, name):
if self.__dict__["_obj"] is None:
self.__init_obj()
return getattr(self.__dict__["_obj"], name)
def __setattr__(self, name, value):
if self.__dict__["_obj"] is None:
self.__init_obj()
setattr(self.__dict__["_obj"], name, value)
def __init_obj(self):
self.__dict__["_obj"]=object.__new__(self.__dict__["_cls"], *self.__dict__["_params"], **self.__dict__["_kwargs"])
self.__dict__["_obj"].__init__(*self.__dict__["_params"], **self.__dict__["_kwargs"])
class LazyInit(object):
def __new__(cls, *params, **kwargs):
return LazyProxy(cls, *params, **kwargs)
class A(LazyInit): # classes meant to be lazy loaded are derived from LazyInit
def __init__(self, x):
print("Init A")
self.x=14+x
a=A(1)
print("Go")
print("15=", a.x)
通过阻断某些操作（new）来达到lazy的效果，django中的lazy实质也是一样， lazy对原来函数包装一下，包装后的函数执行时如果不是需要显示，保存等时，不会执行被包装的函数。
def lazy(func, *resultclasses):
class __proxy__(Promise):
__dispatch = None
def __init__(self, args, kw):
self.__args = args
self.__kw = kw
if self.__dispatch is None:
self.__prepare_class__()
def __prepare_class__(cls):
cls.__dispatch = {}
for resultclass in resultclasses:
cls.__dispatch[resultclass] = {}
for type_ in reversed(resultclass.mro()):
for (k, v) in type_.__dict__.items():
# All __promise__ return the same wrapper method, but they
# also do setup, inserting the method into the dispatch
# dict.
meth = cls.__promise__(resultclass, k, v)
if hasattr(cls, k):
continue
setattr(cls, k, meth)
cls._delegate_str = str in resultclasses
cls._delegate_unicode = unicode in resultclasses
assert not (cls._delegate_str and cls._delegate_unicode), "Cannot call lazy() with both str and unicode return types."
if cls._delegate_unicode:
cls.__unicode__ = cls.__unicode_cast
elif cls._delegate_str:
cls.__str__ = cls.__str_cast
__prepare_class__ = classmethod(__prepare_class__)
def __promise__(cls, klass, funcname, method):
# Builds a wrapper around some magic method and registers that magic
# method for the given type and method name.
def __wrapper__(self, *args, **kw):
# Automatically triggers the evaluation of a lazy value and
# applies the given magic method of the result type.
res = func(*self.__args, **self.__kw)
for t in type(res).mro():
if t in self.__dispatch:
return self.__dispatch[t][funcname](res, *args, **kw)
raise TypeError("Lazy object returned unexpected type.")
if klass not in cls.__dispatch:
cls.__dispatch[klass] = {}
cls.__dispatch[klass][funcname] = method
return __wrapper__
__promise__ = classmethod(__promise__)
@wraps(func)
def __wrapper__(*args, **kw):
# Creates the proxy object, instead of the actual value.
return __proxy__(args, kw)
return __wrapper__
上面代码看起来有点复杂，其实本质是用到了__setattr__, __getattr__, __str__, __unicode__做的一些奇怪事情，下面的代码也实现了lazy，比较简单易懂，跟踪一下就知道怎么回事了， 来自：http://blitiri.com.ar/p/python/
""" lazy - Decorators and utilities for lazy evaluation in Python Alberto Bertogli (albertito@blitiri.com.ar) """ class _LazyWrapper: """Lazy wrapper class for the decorator defined below. It's closely related so don't use it. We don't use a new-style class, otherwise we would have to implement stub methods for __getattribute__, __hash__ and lots of others that are inherited from object by default. This works too and is simple. I'll deal with them when they become mandatory. """ def __init__(self, f, args, kwargs): self._override = True self._isset = False self._value = None self._func = f self._args = args self._kwargs = kwargs self._override = False def _checkset(self): print '111111111111', self._isset, self._value if not self._isset: self._override = True self._value = self._func(*self._args, **self._kwargs) self._isset = True self._checkset = lambda: True self._override = False def __getattr__(self, name): print '----------getattr----', name if self.__dict__['_override']: return self.__dict__[name] self._checkset() print '@@@@@@@@@', self._value, type(self._value), name, self._value.__getattribute__(name) return self._value.__getattribute__(name) def __setattr__(self, name, val): print '----------setattr----', name, val if name == '_override' or self._override: self.__dict__[name] = val return self._checkset() print '222222222222222' setattr(self._value, name, val) return def lazy(f): "Lazy evaluation decorator" def newf(*args, **kwargs): return _LazyWrapper(f, args, kwargs) return newf @lazy def quick_exe(): print '---------quick exe-----------' return 'quickquick' import pdb #pdb.set_trace() quick_exe() print '#####################' print quick_exe()