python.txt

main:
    if __name__ == "__main__":
        main()
    
__buildin__:
    help(object)
    type()      #what's it
    str()   
    dir()       #attrs and methods
    getattr(obj,name,default) -->value
    callable()  #return True/False
    repr() vs. eval()
    locals()    :dict
    setattr(object, name, value):
        setattr(x, 'y', v)  --> x.y = v
    getattr(object, name[, default]) -> value
    sorted()
    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]
    enumerate:    
        [i for i in enumerate(['a','b','c'])]:
         #result:  [(0, 'a'), (1, 'b'), (2, 'c')]
    
import:
    import X
    reload(X)
    from X import *
    import sys,os   
    sys.path:
        - .append() 
        - .insert()
    
data structure:
- dict:
    d = {"k1":"v1", "k2":"v2"}
    d = dict(mapping):
        ex: dict(('key%s' %i, 'value%s' %i) for i in xrange(10))
    d = dict(**kwargs):
        ex: 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 = ["a", "b", "mpilgrim", "z", "example"]
    li[0]
    li[1:3]
    li[-1]  #last item
    .append()
    .insert()
    .extend()
    .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:  
    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:
    super(type, obj) -> bound super object; 
    unbound method: class method
    bound method: object method

---
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
        
---
performance:
    profile:
        run:
            - python -m profile XXX.py
            - import profile; profile.run('XXX')    
        result:
            ncalls: number calls
            cumulative: 函数运行的总时间
        help(sys.setprofile)
    timeit:
        python -m timeit -n -r "XXX"
        import timeit
        
---
lambda:   anonymus function
    ex:  func=lambda x: x*2 
    not allowed: if, for, print:
        use and or to simulate if: （test and x） or y
            
--- 
web server:
    framework: web.py flask pyramid
    WSGI
    nginx+uWsgi
    
---
math:
    numpy

---
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
    ex:
        X=frange(0,10,0.1)
        Y=[sin(x) for x in X]
        plot(X,Y)

---
virtualenv: deploy a clean env
    mkdir ~/my_env && cd ~/my_env/
    virtualenv2 --no-site-packages ~/my_env
    . ~/my_env/bin/activate
    #...
    deactivate
    
---
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)
        ex:
            FooChild = type('FooChild', (Foo,), {'echo_bar': echo_bar})
    the __metaclass__ attribute:
    act:
        intercept a class creation
        modify the class
        return the modified class    
    ex:
        class myMetaclass(type):
            def __new__(cls, name, bases, attrs):
                ...
                return type.__new__(cls, name, bases, up_attrs)
        class myObj:
            __metaclass__=UpperAttrMetaclass                
---
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
        bound method:
        classmethod(function) -> method
            Convert a function to be a class method.
        staticmethod(function) -> method
            Convert a function to be a static method.
        __slot__: limit __dict__ attr

---
mq: 
    Rabbitmq
    
---
encode/decode:
    HTML
        escape:
            import cgi
            res = cgi.escape('<')
        unescape:
            import HTMLParser
            hp=HTMLParser.HTMLParser() 
            hp.unescape(res) 
    base64:
        3*8bit ->4*6bit( 00 before 6 bit), add '=' at end,
        length=4/3 of orginal
        import base64
        base64.encodestring(str)
        base64.decodestring(str)
    urlescape:
        import urllib(2)
        urllib.quote(str)
        urllib.unquote(str)
---
pydev:
    Help > Software Updates > Find and Install:
        http://www.fabioz.com/pydev/updates
    Window > Preferences > Pydev > Interpreter:
        New
        /usr/bin/python2
---
limitation:
    GIL: Global Interpreter Lock
        sys.getcheckinterval()
        
---
#use yaml in python
    import yaml

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

---
Bigtable, Dynamo