Eric Zhong

if __name__ == "__main__":
    # execute only if run as a script or "python -m", but not when it is imported
    main()

>>> a=1
>>> b=a             # 传递的是引用，而非数值
>>> a is b
True
>>> id(a); id(b)    # 引用相同的整数对象
140702335940872
140702335940872

>>> a=256
>>> b=256
>>> a is b
True
>>> c=257
>>> d=257
>>> c is d
False
>>> id(c); id(d)
140297333980944
140297333980824

>>> e=257; f=257       # 这条语句被解释器优化了，引用了同一个对象
>>> e is f
True

>>> a=(1,2); b=(1,2)
>>> a is b
False
>>> a[0] is b[0]
True
>>> a[1] is b[1]
True

>>> a,b = b,a

>>> a = 1,2
>>> a
(1, 2)

>>> a,b = (1,2)
>>> print a,b
1 2

[x for x in range(0,5)]         # 列表推导式
[x for x in range(0,5) if x%2]  # [1,3] （可加条件判断）
{k:v for (k,v) in iterable}     # 字典推导式

(x for x in range(0,5))         # 返回 generator !!!

>>> int('101', base=2)
5

>>> import functools
>>> b2i = functools.partial(int, base=2)
>>> b2i('101')
5

>>> def btoi(x, base=2):
...     return int(x, base)
... 
>>> btoi('101')
5

>>> f = lambda x,y: pow(x,y)
>>> f
<function <lambda> at 0x10397c578>
>>> f(2,10)
1024

>>> filter(lambda x: x>2, range(0,5))
[3, 4]

>>> map(lambda x: x>2, range(0,5))
[False, False, False, True, True]
>>> map(lambda x: x*2, range(0,5))
[0, 2, 4, 6, 8]

>>> reduce(lambda x,y: x+y, range(0,5))     # 0+1+2+3+4=10
10

class Test(object):
    @staticmethod
    def foo1():
        pass
    # 或者： foo1 = staticmethod(foo1)
    
    @classmethod
    def foo2(cls):
        pass
    # 或者：foo2 = classmethod(foo2)
    
    def foo3(self):
        pass

class Test(object):
    __a = "class variable"
    __b = None
    def foo(self):
        Test.__a = "changed variable"
        print Test.__a                       # changed variable
        del Test.__a
        print hasattr(Test, "_Test__a")      # Flase
        print hasattr(Test, "_Test__b")      # True

t = Test()
t.foo()

class RoundFloat(float):
    def __new__(cls, val):
        print "Create an object."
        return float.__new__(cls, round(val, 2))
    
    def __init__(self, val):
        super(RoundFloat, self).__init__(val)      # 在子类中调用，该语句应放在第一行
        print "Do something here."
-----------------------
>>> RoundFloat(1.234567)
Create an object.
Do something here.
1.23

dir(), vars()
getattr(), hasattr(), setattr(), delattr()
type(), isinstance(), issubclass()
super()          # 必须是新式类
------------
dir(obj)  # 显示实例变量和继承过来的所有方法和属性
dir(cls)  # 显示类和基类的 __dict__ 内容
dir(mod)  # 显示模块的 __dict__ 内容
dir()     # 显示调用者的局部变量
vars(arg) # 返回参数对象中的 __dict__ 内容，如果没有该属性，就会引发 TypeError 异常
vars()    # 返回本地名字空间中的属性和值，等于调用 locals()

__foo__      # 内部定义。
__foo        # 解析成 _ClassName__foo，防止与父类名字空间冲突。
_foo         # 私有，import * 无法导入。

"%s+%s=%s" % (1,1,2)
"{0}+{1}={2}".format(1,1,2)
"{a}+{b}={sum}".format(a=1,b=1,sum=2)

from string import Template; 
s = Template('There are {howmany} {what}!'); 
print s.substitute(what='people', howmany=3);

def intGen():
    for n in range(0,2):
        yield n
---------------
>>> g = intGen()    # 返回生成器
>>> g.next()
0
>>> g.next()
1
>>> g.next()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

def log(func):
    def log_func():
        print "write func %s to log" % func.__name__
        return func()
    return log_func

@log
def foo():
    pass
--------------
>>> foo()
write func foo to log

# 旧式类
type(obj)     # <type 'instance'>
type(0)       # <type 'int'>
type(Cls)     # <type 'class'>
type(int)     # <type 'builtin_function_or_method'>

# 新式类
type(obj)     # <class '__main__.MyClass'>
type(0)       # <type 'int'>
type(Cls)     # <type 'type'>
type(int)     # <type 'type'>

class Singleton(object):
    __instance = None
    def __new__(cls,*args,**kwargs):
        if Singleton.__instance is None:
            Singleton.__instance=object.__new__(cls,*args,**kwargs)
        return Singleton.__instance

a = Singleton()
b = Singleton()

print a is b      # True

def singleton(cls, *args, **kw):  
    instances = {}  
    def _singleton():  
        if cls not in instances:  
            instances[cls] = cls(*args, **kw)  
        return instances[cls]  
    return _singleton

@singleton  
class Test(object):
    pass

>>> import copy
>>> a = [1,2,3,[4,5]]
>>> b = copy.copy(a)         # 浅拷贝
>>> c = copy.deepcopy(a)     # 深拷贝
>>> id(a[3])
4315649880
>>> id(b[3])                 # b[3] 的只是引用了 [4,5]
4315649880
>>> id(c[3])                 # c[3] 复制了一份新的
4315651176

# 接着上面的例子
>>> a[3] is b[3]
True
>>> a[3] is c[3]
False
>>> a[3] == b[3]
True
>>> a[3] == c[3]
True

str = fd.read([size])       # 返回所有或指定字节，返回空串则表示到文件结尾了
str = fd.readline([size])   # 从文件读取一行，也可以指定大小，-1 表示读到行尾，会包含换行符
lst = fd.readlines()        # 返回列表，包含所有行
fd.write(str)               # 把字符串写入文件
fd.writelines(list)         # 将字符串列表写入文件，要自己给每行加换行符

for eachLine in f:
    # ...

with open("/etc/passwd", 'r') as f:
    # ...

pass    # 无操作，用来占位

import pickle
val = pickle.load(tmpfile)
pickle.dump(val, tmpfile)

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.")

print type(C.x)      # <type 'property'>

class C(object):
    def __init__(self):
        self._x = None

    @property
    def x(self):
        """I'm the 'x' property."""
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

    @x.deleter
    def x(self):
        del self._x

__all__ = ['mod1', 'mod2', 'mod3']

import mod1
import mod2
import mod3

>>> zip('123', 'abc')
[('1', 'a'), ('2', 'b'), ('3', 'c')]
>>> zip(*zip('123', 'abc'))             # 参数解包
[('1', '2', '3'), ('a', 'b', 'c')]

from decimal import Decimal
print Decimal('.1') + Decimal('1.0')   # 1.1

coerce(1,134L)    # 转为相同类型：(1L, 134L)
pow(2,5)          # 32
abs(-1)           # 1
divmod(10,3)      # (3,1)
round(-3.4)       # 四舍五入：-3.0

for i,c in enumerate('str'): pass            # 遍历字符串

dict([['x',1],['y',2]])       # 从列表创建字典：{‘y’:2, 'x':1}
{}.fromkeys(('x','y'), None)  # 创建默认字典：{'y': None, 'x': None}

dict.keys(); dict.values(); dict.items();
dict.iterkeys(); dict.itervalues(); dict.iteritems();   # 返回迭代器

del dict         # 删除
del dict[key]; dict.pop(key)    # 删除元素
dict.clear();    # 清空
dict1.update(dict2)   # 合并两个字典

key [not] in dict

dict.setdefault(key,default=None)    # 如果 key 不存在就新建
dict.get(key,default=None)
dict.pop(key[,default])

set('123')            # set(['1', '3', '2'])
frozenset('123')

set.add(t)    # 添加元素
set.remove(t)   # 删除元素 (元素不存在时会报错)
set.update(t)   # 
set.discard(t)  # 删除元素 (不会报错)
set.pop()     # 删除并返回任意一个元素
set.clear()   # 清空
set.issubset(t); set.issuperset(t)    # 子集、超集

set.union(t)                     # 并集
set.intersection(t)              # 交集
set.difference(t)                # 差集
set.symmetric_difference(t)      # 两个集合的不相交部分

a = [1,2,3,4,5]
a*2        # [1, 2, 3, 4, 5, 1, 2, 3, 4, 5] (重复)
a[1:3]     # [2, 3] （切片slice，只取到停止位的前一个）
a[::-1]    # [5, 4, 3, 2, 1] (翻转)
a[::-2]    # [5, 3, 1] (翻转，2-step)
a[-2::-2]  # [4, 2]
a[3::-2]   # [4, 2]
[i for i in reversed(a)]     # [5, 4, 3, 2, 1] (翻转，reversed()返回迭代器)
sum(a)     # 15 (求和)

sorted(list)      # 返回列表
reversed(list)    # 返回迭代器
list.sort()       # 原地排序
list.reverse()    # 原地翻转
sum(list)         # 返回求和值
cmp(list1,list2)  # 0相等，-1小于，1大于
list1.extend(list2)     # 等于 list1 + list2
list1 + list2     # 拼接
list.insert(0,e)
list.append(e)
del list
del list[1]
list.remove(123)
list.pop(123)

from a import b
from .a import b
from ..a import b
from a.zip import b
import a.b
import *

os.path.expanduser('~/Documents')

__name__   # 对象名称
__doc__    # 对象的文档字符串
__bases__  # 包含所有父类的元组
__dict__   # 对象的属性
__module__ # 对象定义所在的模块
__class__  # 实例对应的类
__mro__    # 新式类才有，查看MRO
__slots__  # 是个元组，可替代 __dict__，更省空间
__self__   # 方法绑定的对象

__new__()     # 构造器，必须返回要创建的对象
__init__()    # 创建对象后第一个执行的函数，可用来初始化
__del__()     # 当对象的引用计数为0时，在销毁对象前调用一次
__getattribute__()   # 所有的属性访问都会调用该方法
__getattr__()        # 当 __getattribute__() 找不到属性时就会调用它
__call__()           # 实现该方法后类的实例可以像函数一样调用。foo(args) => foo.__call__(foo, args)

func_code       # 代码对象
func_defaults   # 默认参数元组
func_globals    # 全局名称空间字典，和在内部调用 globals() 一样
func_dict       # 属性字典
func_closure    # 闭包引用的自由变量元组

im_class    # 方法定义的类
im_func     # 方法的函数对象
im_self     # 绑定的实例，非绑定方法为 None

compile(代码字符串、保存文件名或''、代码对象类型)

eval('1+1')    # 2 （对表达式字符串求值或者执行 compile() 返回的代码对象，并返回结果）
exec obj       # 只执行代码对象，无返回值。也可以是包含 Python 代码的文件对象。
input()        # 等价于 eval(raw_input())，对用户输入求值
execfile(filename) # 与 exec f 相同，不用打开文件

callable(obj)

import re
m = re.match('bat|bet|bit', 'He bit me!')
if m is not None: 
    m.group()
----------------
m.group()     # 返回匹配到的字符串
m.groups()    # 返回元组，包含所有所有匹配的子组
re.findall()  # 返回列表，包含所有匹配的字符串
re.match()    # 返回匹配对象 (MatchObject) 或 None
re.search()   # 返回首次匹配的位置
re.sub()      # 查找并替换，返回替换后的字符串
re.subn()     # 查找并替换，返回元组：('替换后的字符串'，替换次数)
re.split()    # 分割字符串

re.match(r'\bblow', 'blow')