全面Python小抄（转）

add by zhj: 有些地方不正确，有时间再改吧

原文：Python Cheat Sheet

Cheat sheet of Python. Some basic concepts for Python programmer need to know.

Python Naming Styles

# see: PEP8
# for public use
var

# for internal use
_var

# convention to avoid conflict keyword
var_

# for private use in class
__var

# for protect use in class
_var_

# "magic" method or attributes
# ex: __init__, __file__, __main__
__var__

# for "internal" use throwaway variable
# usually used in loop
# ex: [_ for _ in range(10)]
# or variable not used
# for _, a in [(1,2),(3,4)]: print a
_

Check object attributes

# example of check list attributes
>>> dir(list)
['__add__', '__class__', ...]

Define a function __doc__

# Define a function document
>>> def Example():
...   """ This is an example function """
...   print "Example function"
...
>>> Example.__doc__
' This is an example function '

# Or using help function
>>> help(Example)

Check instance type

>>> ex = 10
>>> isinstance(ex,int)
True

Check, Get, Set attribute

>>> class example(object):
...   def __init__(self):
...     self.name = "ex"
...   def printex(self):
...     print "This is an example"
... 

# Check object has attributes
# hasattr(obj, 'attr')
>>> ex = example()
>>> hasattr(ex,"name")
True
>>> hasattr(ex,"printex")
True
>>> hasattr(ex,"print")
False

# Get object attribute
# getattr(obj, 'attr')
>>> getattr(ex,'name')
'ex'

# Set object attribute
# setattr(obj, 'attr', value)
>>> setattr(ex,'name','example')
>>> ex.name
'example'

Check inheritance

>>> class example(object):
...   def __init__(self):
...     self.name = "ex"
...   def printex(self):
...     print "This is an example"
...
>>> issubclass(example,object)
True

Check all global variables

# globals() return a dictionary
# {'variable name': variable value}
>>> globals()
{'args': (1, 2, 3, 4, 5), ...}

Check "callable"

>>> a = 10
>>> def fun():
...   print "I am callable"
...
>>> callable(a)
False
>>> callable(fun)
True

Common Use "Magic"

# see python document: data model
# For command class
__main__
__name__
__file__
__module__
__all__
__dict__
__class__
__doc__
__init__(self, [...)
__str__(self)
__repr__(self)
__del__(self)

# For Descriptor
__get__(self, instance, owner)
__set__(self, instance, value)
__delete__(self, instance)

# For Context Manager
__enter__(self)
__exit__(self, exc_ty, exc_val, tb)

# Emulating container types
__len__(self)
__getitem__(self, key)
__setitem__(self, key, value)
__delitem__(self, key)
__iter__(self)
__contains__(self, value)

# Controlling Attribute Access
__getattr__(self, name)
__setattr__(self, name, value)
__delattr__(self, name)
__getattribute__(self, name)

# Callable object
__call__(self, [args...])

# Compare related
__cmp__(self, other)
__eq__(self, other)
__ne__(self, other)
__lt__(self, other)
__gt__(self, other)
__le__(self, other)
__ge__(self, other)

# arithmetical operation related
__add__(self, other)
__sub__(self, other)
__mul__(self, other)
__div__(self, other)
__mod__(self, other)
__and__(self, other)
__or__(self, other)
__xor__(self, other)

Arithmetic operators and Comparison

class example(object):

   def __init__(self,val1,val2):
      self.val1 = val1
      self.val2 = val2
   def __add__(self,other):
      _1 = self.val1 + other.val1
      _2 = self.val2 + other.val2
      return _1 + _2

   def __sub__(self,other):
      _1 = self.val1 - other.val1
      _2 = self.val2 - other.val2
      return _1 - _2

   def __mul__(self,other):
      _1 = self.val1 * other.val1
      _2 = self.val2 * other.val2
      return _1 * _2

   def __div__(self,other):
      _1 = self.val1 / other.val1
      _2 = self.val2 / other.val2
      return _1 / _2

   def __mod__(self,other):
      _1 = self.val1 % other.val1
      _2 = self.val2 % other.val2
      return _1 % _2

   def __eq__(self,other):
      if self.val1 == other.val1 and\
            self.val2 == other.val2:
         return True
      return False

   def __ne__(self,other):
      if self.val1 != other.val1 or\
            self.val2 != other.val2:
         return True
      return False

   def __lt__(self,other):
      if self.val1 < other.val1 or\
            self.val2 < other.val2:
         return True
      return False

   def __gt__(self,other):
      if self.val1 > other.val1 or\
            self.val2 > other.val2:
         return True
      return False

   def __le__(self,other):
      if self.val1 <= other.val1 or\
            self.val2 <= other.val2:
         return True
      return False

   def __ge__(self,other):
      if self.val1 >= other.val1 or\
            self.val2 >= other.val2:
         return True
      return False

# example result:
>>> ex1 = example(1.,2.)
>>> ex2 = example(3.,4.)
>>> ex1+ex2
10.0
>>> ex1-ex2
0.0
>>> ex1*ex2
24.0
>>> ex1/ex2
0.6666666666666666
>>> ex1%ex2
1.0
>>> ex1>ex2
False
>>> ex1<ex2
True
>>> ex1==ex2
False

Representations of your class behave

>>> class example(object):
...    def __str__(self):
...       return "example __str__"
...    def __repr__(self):
...       return "example __repr__"
...
>>> print str(example())
example __str__
>>> example()
example __repr__

Get list item "SMART"

>>> a = [1,2,3,4,5]
>>> a[0]
1
>>>a[-1]
5
>>> a[0:]
[1,2,3,4,5]
>>> a[:-1]
[1,2,3,4]

# a[start:end:step]
>>> a[0:-1:2]
[1,3]

# using slice object
# slice(start,end,step)
>>> s = slice(0,-1,2)
>>> a[s]
[1,3]

# Get index and item in loop
>>> a = range(3)
>>> for idx,item in enumerate(a):
...   print (idx,item),
...
(0, 0) (1, 1) (2, 2)

# with filter
>>> [x for x in range(5) if x>1]
[2, 3, 4]
>>> _ = ['','',3,'Hello',4]
>>> f = lambda x: isinstance(x,int)
>>> filter(f,_)
[3, 4]

Get dictionary item "SMART"

# get dictionary all keys
>>> a={"":1,"":2,"":3}
>>> b={"":2,"":3,"":4}
>>> a.keys()
['', '', '']

# get dictionary key and value as tuple
>>> a.items()
[('', 1), ('', 3), ('', 2)]

# find same key between two dictionary
>>> [_ for _ in a.keys() if _ in b.keys()]
['', '']
# better way
>>> c = set(a).intersection(set(b))
>>> list(c)
['', '']
# or
>>> [_ for _ in a if _ in b]
['', '']

# update dictionary
>>> a.update(b)
>>> a
{'': 1, '': 3, '': 2, '': 4}

Set a list/dict "SMART"

# get a list with init value
>>> ex = [0]*10
>>> ex
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

# using generator
>>> [x for x in range(10)]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> fn = lambda x: x**2
>>> [fn(x) for x in range(5)]
[0, 1, 4, 9, 16]
>>> {'{0}'.format(x): x for x in range(3)}
{'': 1, '': 0, '': 2}

# using builtin function "map"
>>> map(fn,range(5))
[0, 1, 4, 9, 16] 

Delegating Iteration (__iter__)

# __iter__ return an iterator object
# Be careful: list is an "iterable" object not an "iterator"
>>> class example(object):
...    def __init__(self,list_):
...       self._list = list_
...    def __iter__(self):
...    return iter(self._list)
...
>>> ex = example([1,2,3,4,5])
>>> for _ in ex: print _,
...
1 2 3 4 5

Using Generator as Iterator

# see: PEP289
>>> a = (_ for _ in range(10))
>>> for _ in a: print _,
...
0 1 2 3 4 5 6 7 8 9

# equivalent to
>>> def _gen():
...   for _ in range(10):
...     yield _
...
>>> a = _gen()
>>> for _ in a: print _,
...
0 1 2 3 4 5 6 7 8 9 

Emulating a list

>>> class emulist(object):
...   def __init__(self,list_):
...     self._list = list_
...   def __repr__(self):
...     return "emulist: "+str(self._list)
...   def append(self,item):
...     self._list.append(item)
...   def remove(self,item):
...     self._list.remove(item)
...   def __len__(self):
...     return len(self._list)
...   def __getitem__(self,sliced):
...     return self._list[sliced]
...   def __setitem__(self,sliced,val):
...     self._list[sliced] = val
...   def __delitem__(self,sliced):
...     del self._list[sliced]
...   def __contains__(self,item):
...     return item in self._list
...   def __iter__(self):
...     return iter(self._list)
...
>>> emul = emulist(range(5))
>>> emul
emulist: [0, 1, 2, 3, 4]
>>> emul[1:3]
[1, 2]
>>> emul[0:4:2]
[0, 2]
>>> len(emul)
5
>>> emul.append(5)
>>> emul
emulist: [0, 1, 2, 3, 4, 5]
>>> emul.remove(2)
>>> emul
emulist: [0, 1, 3, 4, 5]
>>> emul[3] = 6
>>> emul
emulist: [0, 1, 3, 6, 5]
>>> 0 in emul
True

Emulating a dictionary

>>> class emudict(object):
...   def __init__(self,dict_):
...     self._dict = dict_
...   def __repr__(self):
...     return "emudict: "+str(self._dict)
...   def __getitem__(self,key):
...     return self._dict[key]
...   def __setitem__(self,key,val):
...     self._dict[key] = val
...   def __delitem__(self,key):
...     del self._dict[key]
...   def __contains__(self,key):
...     return key in self._dict
...   def __iter__(self):
...     return iter(self._dict.keys())
...
>>> _ = {"":1,"":2,"":3}
>>> emud = emudict(_)
>>> emud
emudict: {'': 1, '': 3, '': 2}
>>> emud['']
1
>>> emud[''] = 5
>>> emud
emudict: {'': 1, '': 3, '': 2, '': 5}
>>> del emud['']
>>> emud
emudict: {'': 1, '': 3, '': 5}
>>> for _ in emud: print emud[_],
...
1 3 5
>>> '' in emudict
True

Decorator

# see: PEP318
>>> def decor(func):
...   def wrapper(*args,**kwargs):
...     print "wrapper"
...     func()
...     print "-------"
...   return wrapper
...
>>> @decor
... def example():
...   print "Example"
...
>>> example()
wrapper
Example
-------

# equivalent to
>>> def example():
...   print "Example"
...
>>> example = decor(example)
>>> example()
wrapper
Example
-------

Decorator with arguments

>>> def example(val):
...   def decor(func):
...     def wrapper(*args,**kargs):
...       print "Val is {0}".format(val)
...       func()
...     return wrapper
...   return decor
...
>>> @example(10)
... def undecor():
...   print "This is undecor func"
...
>>> undecor()
Val is 10
This is undecor func

# equivalent to
>>> def undecor():
...   print "This is undecor func"
...
>>> d = example(10)
>>> undecor = d(undecor)
>>> undecor()
Val is 10
This is undecor func

for: exp else: exp

# see document: More Control Flow Tools
# forloop’s else clause runs when no break occurs
>>> for _ in range(5):
...   print _,
... else:
...   print "\nno break occur"
...
0 1 2 3 4
no break occur
>>> for _ in range(5):
...   if _ % 2 ==0:
...     print "break occur"
...     break
... else:
...   print "else not occur"
...
break occur
# above statement equivalent to
flag = False
for _ in range(5):
  if _ % 2 == 0:
    flag = True
    print "break occur"
    break
if flag == False:
  print "else not occur"

Lambda function

# lambda [input]: expression
>>> fn = lambda x: x**2
>>> fn(3)
9
>>> (lambda x:x**2)(3)
9
>>> (lambda x: [x*_ for _ in range(5)])(2)
[0, 2, 4, 6, 8]
>>> (lambda x: x if x>3 else 3)(5)
5

# multiline lambda example
>>> (lambda x:
... True
... if x>0
... else
... False)(3)
True

Function with option arguments (*args, **kwargs)

>>> def example(a,b=None,*args,**kwargs):
...   print a, b
...   print args
...   print kwargs
...
>>> example(1,"var",2,3,word="hello")
1 var
(2, 3)
{'word': 'hello'}
>>> _args = (1,2,3,4,5)
>>> _kwargs = {"":1,"":2,"":3}
>>> example(1,"var",*_args,**_kwargs)
1 var
(1, 2, 3, 4, 5)
{'': 1, '': 3, '': 2}

Callable object

>>> class calobj(object):
...   def example(self):
...     print "I am callable!"
...   def __call__(self):
...     self.example()
...
>>> ex = calobj()
>>> ex()
I am callable!

"with" statement (Context Manager)

# replace try: ... finally: ...
# see: PEP343
# common use in open and close
# example:
import socket
class Socket(object):
   def __init__(self,host,port):
      self.host = host
      self.port = port
   def __enter__(self):
      sock = socket.socket(
               socket.AF_INET,
               socket.SOCK_STREAM
            )
      sock.bind((self.host,self.port))
      sock.listen(5)
      self.sock = sock
      return self.sock

   def __exit__(self,*exc_info):
      if exc_ty is not None:
         import traceback
         traceback.print_exception(
            *exc_info
         )
      self.sock.close()

if __name__=="__main__":
   host = 'localhost'
   port 5566
   with Socket(host,port) as s:
      while True:
         conn, addr = s.accept()
         msg = conn.recv(1024)
         print msg
         conn.send(msg)
         conn.close()

Using "contextlib" implement Context Manager

from contextlib import contextmanager
@contextmanager
   def opening(filename):
      f = open(filename)
      try:
          yield f
      finally:
          f.close()

with opening('example.txt','r') as fd:
   fd.read()

Using "with" statement open file

>>> with open("example",'r') as f:
...    content = f.read()

Property - Managed attributes

class example(object):
   def __init__(self,value):
      self.val = value

   @property
   def val(self):
      return self._val

   @val.setter
   def val(self,value):
      if not isintance(value,int):
         raise TypeError("Expect int")
      self._val = value

   @ val.deleter
   def val(self):
      del self._val

# example result:
>>> ex = example(123)
>>> ex.val = "str"
Traceback (most recent call last):
  File "", line 1, in
  File "test.py", line 12, in val
    raise TypeError("Expect int")
TypeError: Expect int

Computed attribures - Using property

# Concept: Attribure's value is not store in memory. Computing the value only when we need.
>>> class example(object):
...   @property
...   def square3(self):
...     return 2**3
...
>>> ex = example()
>>> ex.square3
8

Descriptor - Another choice to manage attributes

# Descriptor
>>> class Integer(object):
...   def __init__(self,name):
...     self._name = name
...   def __get__(self,inst,cls):
...     if inst is None:
...       return self
...     else:
...       return inst.__dict__[self._name]
...   def __set__(self,inst,value):
...     if not isinstance(value,int):
...       raise TypeError("Expected INT")
...     inst.__dict__[self._name] = value
...   def __delete__(self,inst):
...     del inst.__dict__[self._name]
...
>>> class example(object):
...   x = Integer('x')
...   def __init__(self,val):
...     self.x = val
...
>>> ex = example(1)
>>> ex = example("str")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 4, in __init__
  File "<stdin>", line 11, in __set__
TypeError: Expected an int

@staticmethod, @classmethod

# @classmethod: bound to class
# @staticmethod: like python function but in class
>>> class example(object):
...   @classmethod
...   def clsmethod(cls):
...     print "I am classmethod"
...   @staticmethod
...   def stmethod():
...     print "I am staticmethod"
...   def instmethod(self):
...     print "I am instancemethod"
...
>>> ex = example()
>>> ex.clsmethod()
I am classmethod
>>> ex.stmethod()
I am staticmethod
>>> ex.instmethod()
I am instancemethod
>>> example.clsmethod()
I am classmethod
>>> example.stmethod()
I am staticmethod
>>> example.instmethod()
Traceback (most recent call last):
  File "", line 1, in
TypeError: unbound method instmethod() ...

Abstract method - Meta class

# usually using in define methods but not implement
from abc import ABCMeta, abstractmethod

>>> class base(object):
...   __metaclass__ = ABCMeta
...   @abstractmethod
...   def absmethod(self):
...     """ Abstract method """
...
>>> class example(base):
...   def absmethod(self):
...     print "abstract"
...
>>> ex = example()
>>> ex.absmethod()
abstract

# another better way to define a meta class
>>> class base(object):
...   def absmethod(self):
...     raise NotImplementedError
...
>>> class example(base):
...   def absmethod(self):
...     print "abstract"
...
>>> ex = example()
>>> ex.absmethod()
abstract