python.txt

main:
    if __name__ == "__main__":
        main()
    
__buildin__:    #ref: http://docs.python.org/2/library/functions.html
    help(object)
    type()      #what's it
    str()   
    basestring()    # test whether an object is an instance of str or unicode
    bin(x)          # convert to a binary string
    dir()       #attrs and methods
    callable()  #return True/False
    repr() vs. eval()
    locals()    :dict
    id(obj)
    hasattr(object, name)
    getattr(object, name[, default]) -> value
    setattr(object, name, value):
        setattr(x, 'y', v)  -> x.y = v
    delattr(object, name)
    memoryview(object)
    buffer(object [, offset[, size]])
    sorted()
    reversed(sequence)  -> reverse iterator over values of the sequence
    divmod(a, b)
        same as (a // b, a % b)
    isinstance(object, classinfo)
    issubclass(class, classinfo)
    filter(function or None, sequence)
    map(function, sequence[, sequence, ...]) -> list:
        Return a list of the results of applying the function to the items of
the argument sequence(s). 
        map(lambda x: x*2,[1,2,3]):  -> [2, 4, 6]
    reduce():
        reduce(function, sequence[, initial]) -> value    
    enumerate:    
        [i for i in enumerate(['a','b','c'])]:
         #result:  [(0, 'a'), (1, 'b'), (2, 'c')]
    zip:
        x,y = (1, 2, 3), (4, 5, 6)
        zipped = zip(x, y)
        [x,y] == zip(*zipped)
    divmod():
        divmod(x, y) -> (quotient, remainder)
        e.g.:   divmod(7,3)=(2,1)
    __contains__:
        x.__contains__(y) <==> y in x
    with:   #ver>python2.5
        purpurse:   to simiplify try...except...finally
        inner:
        __file__:   #current filepath
            print os.path.dirname(__file__)
            any class defined __enter__(), and __exit__() can be context manager, like file obj returned by open()
        e.g.: with open('xxx') as file:
                file.read()
                ...
        
import:
    import X
    reload(X)
    from X import *|Y [as Z]
    import sys,os   
    sys.path:
        .append() 
    os.path.expanduser('~/')

print:
    redirect to file:
        fo = open("/tmp/abc.txt", "w+")
        print >> fo, 'ok'

random:
    os.urandom(LEN)     # random string 
    random.random()
    random.randint()     
          
data structure:
-limit:
    sys.maxint:
        2**63(1<<63) in 64bit system
-negetive number：
    use complement code: bitwise not + 1        
-convert:
    hex(255)        # return str
    bin(3)
    int('ab', 16)
    chr(i):         # 0~255 -> ASCII char 
        e.g.:
            for i in range(257):print chr(i),
    unichr()        # unicode method of chr()
    ord('\r')       # <==>char()
-bitwise op:
    <<, >>     #SHIFT
    |, &, ^(XOR), ~(NOT)    
-set:
    op: -, |, &    
- dict:
    d = {"k1":"v1", "k2":"v2"}
    d = dict(mapping):
        e.g.: dict(('key%s' %i, 'value%s' %i) for i in xrange(10))
    d = dict(**kwargs):
        e.g.: dict(one=1, two=2)
    dic=dict(zip(ls1,ls2))
    **dic:  k=v,...
    d["k1"]
    .clear()
    .keys()
    .values()
    .items():
        ["%s=%s" % (k, v) for k, v in params.items()]
    .pop(k[,d]) ->v #If k is not found, d is returned if given
    .iteritems(): an iterator over the (key, value) items of D
    k/v swap: r_dic=dict((v, k) for k,v in dic.iteritems())
- list:
    li = [0]*3
    li = ["a", "b", "mpilgrim", "z", "example"]
    li[0]
    li[1:3]
    li[-1]  #last item
    .append()
    .insert()
    .extend(iterable)
    .remove()
    .reverse() # [::-1] return a reversed list 
    len(list)
    list comprehension:
        [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
        
#const, safe and faster than list
- tuple:  readonly list
    t = ("a", "b", "mpilgrim", "z", "example")
    .append()
    .remove()
    .indiex('abc')
    touple([1,2,3]) # change list to tuple
    
- enum:
    (MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY) = range(7)

- string:
    "%s=%d" %("name",31)
    "price is %.2f" % price
    s=';'.join(words)
    s.split(';'):    
        " ".join(s.split())
    ''.join(sorted('cat'))

---
class:
    def __call__(self):     # call like a function
        ...
    super(type, self) -> bound super object; 
    unbound method: class method
    bound method: object method
    classmethod(function)
        class C:
        @classmethod
        def f(cls, arg1, arg2, ...):
---
object:
    .__getattr__(self, name)
    .__getattribute__(self, name)
        e.g.:   dict().__getattribute__('keys')
    .__setattr__(self, name, value)
    .__delattr__(self, name)
    
---
re
    special characters:
        (?:...):        non-capture, optional,
        (?P<name>...):  grouped expression that is named. ... can be get by m.group('name')
        (?=...):        lookahead assertion. 
            e.g.: Isaac (?=Asimov) will match 'Isaac ' only if it’s followed by 'Asimov'.
        (?!...):        negative lookahead assertion
        (?<=...):       lookbehind assertion.
            e.g.: (?<=abc)def match 'def' lead by 'abc'
        (?<!...):       negative lookbehind assertion    
---
multiprocessing
    .Pool
    .Process    
    .Queue: exchange obj, thread/process safe
        .put(obj),.get(obj)
    .Pipe: two way exchange data
        .send(obj), recv(), close()
        
---
nose: UT
    pip install nose
    它会自动搜索当前目录和名为test的子目录
    func:   setUp(), tearDown()
    run: nosetests:
        -h, -s
    test specific func:
        nosettests XX.py:XXX
    coverage: a plugin
        pip install coverage
        nosetests --with-coverage --cover-html
            default coverage report in ./cover/ folder
---
debug:
    import traceback
    for line in traceback.format_stack():
        print line.strip()
                        
---
performance:
    profile:
        run:
            - python -m profile XXX.py
            - import profile; profile.run('XXX')    
        result:
            ncalls: number calls
            tottime: 函数总计运行时间，除去函数中调用的函数运行时间
            cumtime: 函数运行的总时间
            percall: tottime/ncalls
        help(sys.setprofile)
    timeit:
        python -m timeit -n -r "XXX"
        import timeit
        
---
lambda:   anonymus function
    e.g.:  func=lambda x: x*2 
    e.g.:  triple op: 
        fn=lambda x,a,b:a if x else b  
    limit:  cannot contain statements.
    usage:  with filter(),map(),reduce():
        filter(lambda x: ..., container)
                    
--- 
web server:
    framework: web.py flask pyramid
    WSGI
    nginx+uWsgi
    
---
math:
    import math
        .log()
        .floor()    2.1 => 2
        .ceil()     2.1 => 3
    numpy
    
---
deepcopy:
    ls2=ls1[:]
    if ls1 is has complex level, such as:   
        lst1 = ['a','b',['ab','ba']]
    change ls1[2] will affect ls2[2], because they point to same obj
    solution:
        from copy import deepcopy
        lst2 = deepcopy(lst1)
        
---
sql:
    mysql-python:
        get src; python setup.py install
        import MySQLdb
        
---
ipython:
    start:  ipyhthon -pylab
    virable:    %env %[TAB]
    %autoindent #toggle autoindent, for paste
    help:
        dict?, dict??
    ![Shell]
    %paste
    %history
    e.g.:
        X=frange(0,10,0.1)
        Y=[sin(x) for x in X]
        plot(X,Y)

---
pyrex/Cython
    Pyrex is a Python-like language that is used to create C modules for Python.
    why it:
        fast
        wrap a c lib for python
    .pyx:
    
    build:
        setup.py:
            from setuptools import setup, Extension
        python setup.py build_ext --inplace
        python setup.py build
        python setup.py test
        python setup.py install
        pip uninstall XXX
    use:
        import mymodule
                
---
serialize:
    marshal: faster, inner type only
    cPickle
    method:
        dumps(,protocol=0)
        loads()
---
as config:
    .py: from xxx import *
---
Pythonic:
    Zen of python: import this
---
decorator:
    class decorator:
        class mydec(object):
            def __init__(self,action,msg=None):
                self.action,self.msg=action,msg
            def __call__(self,func):
                def _(ui,req,*args,**kwargs):
                    ...
                    return func(ui,*args,**kwargs)
                return _
                
    func decorator: 3 layers:
        def mydec(pattern, expire=0):   # decrator arg
            def deco(f):                    # func
                ...
                def _(*a, **kw):            # func args
                        r = f(*a, **kw) 
                        ...
                    return r
                return _
            return deco
    
---
itertools:
    count(n) --> n, n+1, n+2 
    cycle(p) --> p0, p1, ... plast, p0, p1, ... 
    repeate(elem[,n]) --> elem, elem, elem, ...
    izip(p,q,...) --> (p[0], q[0]), (p[1], q[1]), ...
    islice(seq,[start,]stop[,step])--> elements from seq[start:stop:step]
    groupby:
     words = ['cat','act','wer','erw']
     [list(v) for k,v in itertools.groupby(words,sorted)]

---
metaclass
    def: 
        defines the behavior of certain classes and their instances
        as a class factory
    class as obj:
        hasattr(object, name) -> bool
    (): return object of a class
    type():
        type(name of the class, 
           tuple of the parent class), 
           dictionary containing attributes names and values)
        e.g.:
            FooChild = type('FooChild', (Foo,), {'echo_bar': echo_bar})
    the __metaclass__ attribute:
    act:
        intercept a class creation
        modify the class
        return the modified class    
    e.g.:
        class myMetaclass(type):
            def __new__(cls, name, bases, attrs):   #attrs is a dict
                attrs.update(...)
                ...
                return type.__new__(cls, name, bases, attrs)
        class myObj:
            __metaclass__=myMetaclass                
---
descriptor:
    intro:
        dotted access(eg, x.y):
            1. lookup obj.y
            2. lookup class.y
            if .y existed: execute it
    def: any class that implements the __get__, __set__, or __delete__ methods.
        def __get__(self, obj, type=None) --> value
        def __set__(self, obj, value) --> None
        def __delete__(self, obj) --> None       

    application:
        @property:
            property(fget=None, fset=None, fdel=None, doc=None) -> property attribute
            e.g.:
                class C(object):
                    def getx(self): return self.__x
                    def setx(self, value): self.__x = value
                    def delx(self): del self.__x
                    x = property(getx, setx, delx, "I'm the 'x' property.")
        bound method:
        __slot__: limit __dict__ attr

---
msg queue: 
    Rabbitmq
    zmq
    
---
unicode:
    s1= u'中国'
    assert s1.encode('utf-8').decode('utf-8') == s1
    urllib.unquote(urlstr).decode('gbk')
    s2=str(s1)
    assert isinstance(s1,basestring)
    
+web+
    URL:         
        scheme://netloc/path;params?query#frag
        data = urlparse.urlparse(urlstr)
            : .scheme .hostname .netloc .path .params .port .username .fragment .password .query 
        urlparse.urlunparse(data) 
    net_loc:     
        user:passwd@host:port
    path:        '/' delimited
    query:       '&'.join('k=v')
        str=urllib.urlencode(dic):
        dic=urlparse.parse_qs(str)
        urlparse.urljoin(baseurl, newurl) # keep net_loc, replace path
    quote:  
        urllib.quote(urldata,safe='/')    # not quote '/'
        urllib.quote_plus()               # besides, ' ' -> '+' 
        urllib.unquote()
        urllib.unquote_plus()    
    execute:
        f = .urlopen(urlstr, POSTdata) 
        .urlretrieve(url)           # download entire HTML 
    urllib2:
        auth, proxy
        urllib2?   
    HTML
        escape:
            import cgi
            res = cgi.escape('<')   #'%3C'
        unescape:
            import HTMLParser
            hp=HTMLParser.HTMLParser() 
            hp.unescape(res) 
    
CGI:
    common gateway interface
    helloworld:
        import CGIHTTPServer
        CGIHTTPServer.test()
    overview:
        client <--> web server <--> CGI app
    enable tracebacks:
        import cgitb
        cgitb.enable()
    problem:
        does not scale, cgi process is created for each request and thrown away 
    solve:
        server API:
            apache,nginx
            precreated working process/thread
        external process:
            fastCGI    
        wsgi:
            e.g.:
                python -m wsgiref.simple_server
base64:
    3*8bit ->4*6bit( 00 before 6 bit), add '=' at end,
    length=4/3 of orginal
    str.encode('base64')
            
---
pip:
    pip install XXX
    pip install  --no-index -f file:/root/pyPkg4NBS/ uwsgi
    
---
pydev:
    Help > Software Updates > Find and Install:
        http://www.fabioz.com/pydev/updates
    Window > Preferences > Pydev > Interpreter:
        New
        /usr/bin/python2
        
+pep8+
    pip install pep8
    pep8 *.py --ignore E501
    
---
limitation:
    GIL: Global Interpreter Lock
        sys.getcheckinterval()
        
---
#use yaml in python
    import yaml

    stream = open("example.yaml", 'r')
    print yaml.load(stream)

---
string format:
    %r :    repr()
    %x/%X:  16bit/16bit upper
    %#x:    0xXXX
    %e:     scientific
    %%:     %
    -:      left align
    %10s:   right align with 10 char space
    +:      '+'num
    m.n:    min m length, n numbers after '.' 
       
---
exception:
    try-except-else-finally
    with:
        from __future__ import with_statement
---
Bigtable, Dynamo

---
paste:
    framework of web frameworks
    subcomponents:
        WebOb:  wsgi env wrapper
        Paste Deploy:   find and config wsgi app
        Paste Script,...