empty = object()
def new_method_proxy(func):
    def inner(self, *args):
        if self._wrapped is empty:
            self._setup()
        return func(self._wrapped, *args)
    return inner
class LazyObject(object):
    """
    A wrapper for another class that can be used to delay instantiation of the
    wrapped class.
	# 一个封装类，被封装的对象能够延迟实例化的时间
    By subclassing, you have the opportunity to intercept and alter the
    instantiation. If you don't need to do that, use SimpleLazyObject.
	# 通过继承此类，可以介入和改变被封装的实例。如果不需要这样做，可以使用SimpleLazyObject
    """
    def __init__(self):
        self._wrapped = empty
    __getattr__ = new_method_proxy(getattr)
    def __setattr__(self, name, value):
        if name == "_wrapped":
            # Assign to __dict__ to avoid infinite __setattr__ loops.
			# self._wrapped = value 的写法会导致无限循环调用 __setattr__
            self.__dict__["_wrapped"] = value
        else:
			# 进行赋值时，再通过 _setup 进行实例化
            if self._wrapped is empty:
                self._setup()
            setattr(self._wrapped, name, value)
    def __delattr__(self, name):
		# 进行取值时， 再通过 _setup 进行实例化
        if name == "_wrapped":
            raise TypeError("can't delete _wrapped.")
        if self._wrapped is empty:
            self._setup()
        delattr(self._wrapped, name)
    def _setup(self):
        """
        Must be implemented by subclasses to initialise the wrapped object.
        """
        raise NotImplementedError
    # introspection support:
    __dir__ = new_method_proxy(dir)

class SimpleLazyObject(LazyObject):
	def __init__(self, func):
		self.__dict__['_setupfunc'] = func
	
	def _setup(self):
		self._wrapped = self._setupfunc()

class LazySettings(LazyObject):
    """
    A lazy proxy for either global Django settings or a custom settings object.
    The user can manually configure settings prior to using them. Otherwise,
    Django uses the settings module pointed to by DJANGO_SETTINGS_MODULE.
    """
    def _setup(self, name=None):
        """
        Load the settings module pointed to by the environment variable. This
        is used the first time we need any settings at all, if the user has not
        previously configured the settings manually.
        """
        try:
            settings_module = os.environ[ENVIRONMENT_VARIABLE]
            if not settings_module: # If it's set but is an empty string.
                raise KeyError
        except KeyError:
            desc = ("setting %s" % name) if name else "settings"
            raise ImproperlyConfigured(
                "Requested %s, but settings are not configured. "
                "You must either define the environment variable %s "
                "or call settings.configure() before accessing settings."
                % (desc, ENVIRONMENT_VARIABLE))
        self._wrapped = Settings(settings_module)
        self._configure_logging()
    def __getattr__(self, name):
        if self._wrapped is empty:
            self._setup(name)
        return getattr(self._wrapped, name)
    def _configure_logging(self):
        """
        Setup logging from LOGGING_CONFIG and LOGGING settings.
        """
        if not sys.warnoptions:
            try:
                # Route warnings through python logging
                logging.captureWarnings(True)
                # Allow DeprecationWarnings through the warnings filters
                warnings.simplefilter("default", DeprecationWarning)
            except AttributeError:
                # No captureWarnings on Python 2.6, DeprecationWarnings are on anyway
                pass
        if self.LOGGING_CONFIG:
            from django.utils.log import DEFAULT_LOGGING
            # First find the logging configuration function ...
            logging_config_path, logging_config_func_name = self.LOGGING_CONFIG.rsplit('.', 1)
            logging_config_module = importlib.import_module(logging_config_path)
            logging_config_func = getattr(logging_config_module, logging_config_func_name)
            logging_config_func(DEFAULT_LOGGING)
            if self.LOGGING:
                # Backwards-compatibility shim for #16288 fix
                compat_patch_logging_config(self.LOGGING)
                # ... then invoke it with the logging settings
                logging_config_func(self.LOGGING)
    def configure(self, default_settings=global_settings, **options):
        """
        Called to manually configure the settings. The 'default_settings'
        parameter sets where to retrieve any unspecified values from (its
        argument must support attribute access (__getattr__)).
        """
        if self._wrapped is not empty:
            raise RuntimeError('Settings already configured.')
        holder = UserSettingsHolder(default_settings)
        for name, value in options.items():
            setattr(holder, name, value)
        self._wrapped = holder
        self._configure_logging()
    @property
    def configured(self):
        """
        Returns True if the settings have already been configured.
        """
        return self._wrapped is not empty

Any data with state (attributes or value) and defined behavior (methods). 
Also the ultimate base class of any new-style class.

class MyClass(object):
	def __init__(self, *args, **kwargs):
		print 'new self id:', id(self)
id(MyClass):
>>> 48438744L
id(object)
>>> 506057936L
type(MyClass)
>>> <type 'type'>
isinstance(MyClass, type)
>>> True

i = MyClass()
>>> new self id: 42531472L
id(i)
>>> 42531472L
ii = MyClass()
>>> new self id: 34971944
id(ii)
>>> 34971944L

class MyClass(object):
	def __new__(cls, *args, **kwargs):
		instance = super(MyClass, cls).__new__(cls)
		#或者写成
		#instance = object.__new__(cls)
		return instance
	def __init__(self, *args, **kwargs):
		print 'new self  id:', id(self)
i = MyClass()
>>> new self  id: 69858136
id(i)
>>> 69858136L
class MyInt(object):
	def __new__(cls, *args, **kwargs):
		instance = int.__new__(cls)	# 用int的模型构造实例
		instance.to_str = lambda self: str(self)
		return instance
m = MyInt(1)
m
>>> 1
m.to_str()
>>> '1'

class Singleton(object):
	instance = None
	def __new__(cls, *args, **kwargs):	# __init__不能够做到这一点，因为在调用之前，实例就存在了
		if not cls.instance:
			cls.instance = super(Singleton, cls).__new__(cls)
		return cls.instnace
s1 = Singleton()
s2 = Singleton()
s1 is s2	# 同一个实例
>>> True

class MyClass(object):
	pass
MyClass = type('MyClass', (object,), {}) # 第二个参数必须是 tuple类型

class MyClass(object):
	__metaclass__ = MetaClass
	cls_var = 'var'
	def method(self): pass
>>> name: MyClass
>>> bases: (object,)
>>> attrs: {'cls_var': 'var', 'method': <function m at 0x000000000437E588>, \
'__module__': '__main__', '__metaclass__': <class '__main__.MetaClass'>}

import sys
import os
import sys.path
import sys.path.join as path_join

package/
    __init__.py
    subpackage1/
        __init__.py
        moduleX.py
        moduleY.py
    subpackage2/
        __init__.py
        moduleZ.py
    moduleA.py

from package.subpackage1 import moduleY
moduleY.main()

project/
	test.py
    package/
        __init__.py
        subpackage1/
            __init__.py
            moduleX.py
            moduleY.py
        subpackage2/
            __init__.py
            moduleZ.py
        moduleA.py

def NewClass(object):
	pass
def OldClass:
	pass

class A:
	def __init__(self):
		pass
	def method(self):
		print 'A'
class B:
	def __init__(self):
		pass
	def method(self):
		print 'B'
class Child(A, B):
	def __init__(self):
		A.__init__(self)
		B.__init__(self)
c = Child()
c.method()
>>>A

class Child(B, A):
	def __init__(self):
		A.__init__(self)
		B.__init__(self)
c = Child()
c.method()
>>>B

class A:
	def method(self):
		print 'A'
class AA(A):
	pass
class B:
	def method(self):
		print 'B'
class BB(B):
	pass
class Child(AA, BB):
	pass
c = Child()
c.method()
>>>A

class Child(A, B):
	def __init__(self):
		B.__init__(self) #修改初始化顺序
		A.__init__(self)
c = Child()
print c.var
>>> A

class A:
	INITIAL = 0
	def __init__(self):
		self.__class__.INITIAL += 1
		self.var = self.INITIAL
class AA(A):
	def __init__(self):
		A.__init__(self)
class BB(A):
	def __init__(self):
		A.__init__(self)
class Child(AA, BB):
	def __init__(self):
		AA.__init__(self)
		BB.__init__(self)
c = Child()
print c.var
>>> 2

class A(object):
	INITIAL = 0
	def __init__(self):
		self.__class__.INITIAL += 1
		self.var = self.INITIAL
class AA(A):
	def __init__(self):
		super(AA, self).__init__()
class BB(A):
	def __init__(self):
		super(BB, self).__init__()
class Child(AA, BB):
	def __init__(self):
		super(Child, self).__init__()
c = Child()
print Child.__mro__
>>>(__main__.Child, __main__.AA, __main__.BB, __main__.A, object)
print c.var
>>>1

class A:
	def __init__(self):
		self.a = 'A'
	def method(self):
		print 'A'
	
class Child(A):
	def __init__(self):
		super(Child, self).__init__()
c = Child()
>>>TypeError: must be type, not classobj

class Child(A, object):
	def __init__(self):
		super(Child, self).__init__()
c = Child()
print c.method()
>>> A

class Child(object):
	def __init__(self):
		self._base = A()
	def __getattr__(self, attr):
		return getattr(self._base, attr)
c = Child()
print c.method()
>>> A

class A(object):
	def __init__(self, arg1):
		self.arg1 = arg1
class B(object):
	def __init__(self, arg2, arg3):
		self.arg2 = arg2
		self.arg3 = arg3
class Child(A, B):
	def __init__(self):
		super(Child, self).__init__('arg1')
c = Child()
print c.arg1
>>> arg1
print c.arg2
>>> AttributeError: 'Child' object has no attribute 'arg2'
print c.arg3
>>> AttributeError: 'Child' object has no attribute 'arg3'
print Child.__mro__
>>> (__main__.Child, __main__.A, __main__.B, object)

class Child(B, A):
	def __init__(self):
		super(Child, self).__init__()
c = Child()
>>>TypeError: __init__() takes exactly 3 
>uments (1 given)
print Child.__mro_
>>>(__main__.Child, __main__.B, __main__.A, object)

class Child(A, B):
	def __init__(self):
		A.__init__(self, 'arg1')
		B.__init__(self, 'arg2', 'arg3')
c = Child()
print c.arg1, c.arg2, c.arg3
>>>'arg1', 'arg2', 'arg3'

def do_something():
	#do_something
==>
def do_something():
	pre_do_something	#装饰器附加操作
	do_something
	post_do_somthding	#装饰器附件操作

def decorator(func):
	def wrapper(*args, **kwargs):
		return func(*args, **kwargs)
	return wrapper
	
def wrapped(arg):
	print arg
wrapped = decorator(wrapped)
wrapped('hello,world')
>>> hello,world
	
wrapped.__name__
>>>'wrapper'

@decorator
def wrapped(arg):
	print arg

def decorator(func):
	def wrapper(name):
	return func(' '.join(name, 'are a dog'))
return wrapper
@decorator
def echo_name(name):
	print name
echo_name('you')
>> 'you are a dog'

@decorator_2
@decorator_1
@decorator_0
def func():
	pass

def decorator_outer(arg):
	def decorator_inner(func, arg=arg):
		def inner(*args, **kwargs):
			args = args + (arg,)
			return func(*args, **kwargs)
		return inner
	return decorator_inner

class decorator(object):
	def __init__(self, arg):
		self.arg = arg
	def inner(self, *args, **kwargs):
		return self.func(*args, **kwarg)
	def __call__(self, func):
		self.func = func
		return self.inner

def func(a, b, c):
	print a,b,c
func = partial(func, a=1)
func = partial(func, b=2)
func = partial(func, c=3)
func()
>>>1, 2, 3

class Klass(object):
	@classmethod
	def get(cls):
		print 'classmethod'
	@staticmethod:
	def echo():
		print 'staticmethod'
	@property
	def value(self):
		if self._value < 1: 
			return 0
		else:
			return self._value

def decorator(func):
	def wrapper(*args, **kwargs):
		return func(*args, **kwargs)
	wrapper.__name__ = func.__name__
	wrapper.__doc__ = func.__doc__
	wrapper.__module__ = func.__module__
	return _wraps
@decorator
def wrapped(var):
	print var
wrapped.__name__
wrapped.__doc__
wrapped.__module__
>>>'wrapped'
>>>''
>>>'__main__'

def decorator(func):
	@wraps(func)
	def wrapper(*args, **kwargs):
		return func(*args, **kwargs)
	return wrapper

def wraps(wrapped):
	def inner(func, wrapped=wrapped):
		def _inner(*args, **kwargs):
			return func(*args, **kwargs)
		_inner.__name__ == wrapped.__name__
	return inner
def decorator(func):
	@wraps(func)   #包装wrapper替换其属性
	def wrapper(*args, **kwargs):
		args = (s.title() for s in args)
		return func(*args, **kwargs)
	return wrapper
@decorator
def wrapped(var):
	print var
	
wrapped.__name__
>>>'wrapped'

WRAPPER_ASSIGNMENT = ('__module', '__name__', '__doc__')
WRAPPER_UPDATES = ('__dict__')
def update_wrapper(wrapper, wrapped,
                   assigned=WRAPPER_ASSIGNMENT, 
                   updated=WRAPPER_UPDATES):
	for attr in assigned:
		setattr(wrapper, getattr(wrapped, attr))
	for attr in updated:
		getattr(wrapper, attr).update(getattr(wrapped, attr, {}))
	return wrapper
def wraps(wrapped, 
          assigned=WRAPPER_ASSIGNMENT,   
          updated=WRAPPER_UPDATES):
	return functools.partial(update_wrapper,
                             wrapped=wrapped, 
                             assigned=assigned,
                             updated=updated)

def method():
if arg is type of TypeA:
    ...
elif arg is type of TypeB:
    ...
else:
    ...

def method(TypeA arg):
    ...
def method(TypeB arg):
    ...
def method(TypeA arga, TypeB argb):
    ...

class Poly(object):
    def method(self, *args): #def method(self, arga=None, argb=None)
        arga = args.get('arga', None)
        argb = args.get('argb', None)
        if arga and argb:
            ...
        elif arga:
            ...
        elif argb:
            ...

class Poly(object):
    def method(self, arg):
        if type(arg) == TypeA:
            ....
        elif type(arg) == TypeB:
            ....

class Context(object):
    def method(self, obj):
        obj.op(self)
class ArgA(object):
    def op(self, context):
        ....
class ArgB(object):
    def op(self, context):
        ...

lock.release() 
							  返回None; 或者raise thread.error
		a) 可以被任意线程调用，即一个线程锁可以被持有改锁的线程释放，或者其他不持有该锁的线程释放
			import threading
			import time
			def unlock(lock):
    			time.sleep(3)
				lock.release()
    			print 'unlock in another thread'
			lock = threading.Lock()
			lock.acquire()	#持有锁
			release_in_another_thread = threading.Thread(target=unlock, args=[lock,])	#在其他线程调用release
			release_in_another_thread.start()
			print 'acquire the lock again: ', lock.acquire()	#堵塞直到锁被释放，然后再次持有
			#2个线程同时print，顺序是任意的。
			>>>acquire the lock again:  True
			>>>unlock in another thread
		b) release一个处在unlocked状态的线程锁，会引起 thread.error异常。
			lock = threading.Lock()
			lock.release()
			>>>thread.error: release unlocked lock

a)verbose=None，不打印调试信息
b)acquire和release必须调用次数相同，release不能由不持有锁的线程调用(RuntimeError)
		rlock.acquire([wait])
								立即返回，获得锁返回True；反之返回False；非第一次获得锁返回 1。
	
		a) 第一次获取锁返回True; 非第一次获取锁返回 1; 不能获取锁返回 False。
		b) 持有锁的线程重复调用acquire，wait默认、设置为True、或者设置为False 均立即返回。
		c) 不持有锁的线程调用acquire，wait默认或者设置为True则堵塞；wait设置为False则立即返回 False。
		d) RLock可以反复获取多次，目前(2.7.5)没有上限(至少1024，估计受限于内存大小）。
		rlock.release()
								返回None；release非持有的锁raise RuntimeError;
		a) 只能由持有锁的线程调用，否则raise RuntimeError。
		b）释放一个unlocked的锁，raise RuntimeError 与Lock的情况不一致。

'{0} {0}'.format(1)
>>> 1 1
'{0} {0}'.format("hello") 
>>>'hello hello'
'{0} {1}'.format('world')	#不能有多余的大括号
>>>IndexError: tuple index out of range
'{var}'.format(var=1) >>>1
'{var}'.format(var="hello") 
>>>'hello'
'{ var }'.format(var = 1) 
>>> KeyError: ' var ' 
'{}{world}'.format('hello')
>>>KeyError: 'world'	#不能格式化目的字符串有大括号的字符串

t = (1, 2)  #tuple
>>>(1, 2)
2 * (1 + 3)	#优先级
>>> 8
(1)	#作用域， 所以单元素的tuple定义需要尾部的逗号，例如 (1,)
>>>1
type(('a'))	#('a') -> 'a', type('a') -> str
>>>str
if (1 + 1):print 'ok'  #if(1 + 1), 括号相当于作用域
>>>ok
('not'
 'a tuple, but str') #连接符
>>>'not a tuple, but str'

from functools import partial
with open('inputfile', 'rb') as infile:
	read64 = partial(infile.read, 64)
	blocks = list(iter(read64, ''))  # 以64byte为1个block,存入blocks
	#lines  = list(iter(file.readline, ''))   # file.readlines()

class Test(object):
	attr_in_class = 1
	def get(self):
		print self.attr_in_class
	def set(self):
		self.attr_in_class = 'set'
	def assign(self):
		self.attr_in_class += 1
	def set_in_class(self):
		self.__class__.attr_in_class = 'class'
	@classmethod
	def change_in_class(cls):
		cls.attr_in_class = 'cls'
Test.attr_in_class	
>>>1
ins = Test()
ins.attr_in_class
>>>1

Test.change_in_class()	#类方法实际是修改类(type的实例)的属性
Test.attr_in_class
>>>'cls'
ins.attr_in_class
>>>'cls'
Test().attr_in_class
>>>'cls'	#类的共享变量被修改

ins.set_in_class()
>>>'class'
Test.attr_in_class
>>>'class'

ins.attr_in_class = 'instance'
Test.attr_in_class
>>>'class'
Test().attr_in_class
>>>'class'
in.attr_in_class
>>>'instance'	#attr_in_class通过赋值，变为ins的实例变

class TestMutable(object):
	mut = []
t = TestMutable()
t.mut.append(1)
t.mut
>>>[1,]
TestMutable.mut
>>>[1,]
TestMutable().mut
>>>[1,]

class SumInstanceNum(object):
	cnt = 0
	def __init__(self):
		self.__class__.cnt += 1
		#do other construct thing
	@classmethod
	def get_instance_num(cls):
		return cls.cnt
	def __del__(self):
		self.__class__.cnt -= 1
		
```        
## 浅copy 和深copy
* 浅复制(shallow copy):只复制最外层对象，不复制内部的子对象(只复制引用)。属于浅复制的有，赋值=、裂片操作[:]、函数copy.copy等。
* 深复制(deep copy): 复制所有，包括对象(类，实例等）的内部对象。属于深复制的是copy.deepcopy
特殊方法 `__copy__` 定义浅复制的操作。
		
```python
# 浅复制
top = [1, 2, ['a', 'b']]
sec = top[:]
print top.append(3)
>>>[1, 2, ['a', 'b'], 3]; 
print sec 
>>>[1, 2, ['a', 'b']];
top[2].append('c') 
print top 
>>>[1, 2, ['a', 'b', 'c'], 3];
              
print sec  
>>>[1, 2, ['a', 'b', 'c']]; #同样增加元素 'c'
top[2] is sec[2]
>>>True
# 深复制
deep = [1, 2, ['a', 'b']]
deep2 = copy.deepcopy(deep)
deep[2] is deep2[2]
>>>False

def foo(numbers=[]):
	numbers.append(9)
	print numbers
foo()
>>>[9]
foo()
>>>[9, 9]

def foo(numbers=None):
    numbers = [] if numbers is None else numbers
    numbers.append(9)
    print numbers

la = [1, 2,]
lb = [3, 4,]
la + lb
>>>[1, 2, 3, 4]
lc = [1,]
la - lc
>>>TypeError: unsupported operands types(s) for '-': 'list' and 'list'

import re
def get_field(data, field,  linestart="", sep=" "):
'''
Parse data from string
@param data: Data to parse
example:
	data:
		cpu 1 2 3 4
		cpu0 5 6 7 8
		cpu1 9 10 11 12
		linestart filed 0 1 2 3
@param field: Position of data after linestart
@param linestart: String to which start line
@param sp: separator between parameters regular expression
'''
	search = re.compile(r'(<=^%s)\s*(.*)' % linestart, re.MULTILINE)
	find = search.search(data)
	if find is not None:
		return re.split("%s" % sep, find.group(1))[field]
	else:
		return None

#save bits to create __dict__
class Slot(object):
__slots__ = []
s = Slot()
try:
	s.var  = 1
except AttributeError:
	print "can not create attribute, __slot__  stops it"
try:
	s.__dict__
except AttributeError:
	print "no __dict__ attribute, __slot__ stops it"

import json
from collections import defaultdict
def tree():	return defaultdict(tree)
t = tree()
t['a']['b']['c'] = 1
t['a']['c'] = 2
print t['a']['b']['c']
>>>1
print t['a']['c']
>>>2
print json.dumps(t)
>>> {'a':{'b':{'c':1}, 'c':2}}
def dicts(t):
	return {k: dicts(t[k]) for k in t}

with open('./temp', 'w') as outfile:
	outfile.write('this is a test for context manager')

class EnterException(object):
	def __enter__(self):
		raise IOError('test')	#用IOError模拟异常
	def __exit__(self， *args):
		print 'exit'
		return True
with EnterException():
	print 'in block'
>>>IOError: 'test'		#程序直接抛出异常，

class IngoreException(object):
	def __enter__(self):
		print 'enter'
	def __exit__(self, *args):
		print args
		return True
with IngoreException():
	raise IOError('will be slienced')
>>>enter
>>>[IOError, IOError('will be slienced'), traceback]
>>> 	#不会有异常被抛出。

import contexlib
@contexlib.contexmanager
def go():
	print 'before try'
	try:						#__enter__
		print 'in enter'
		yield 'ret value'		# return
	except:						# __exit__
		print 'in exit'
with go() as ret:
	print 'in block'
	print ret
>>>before try
>>>in enter
>>>in block
>>>ret value
>>>in exit

with open('infile', 'r') as infile, open('outfile', 'w') as outfile:
	outfile.write(infile.read())

class Meter(object):
'''Descriptor for a meter.'''
	def __init__(self, value=0.0):
    	self.value = float(value)
	def __get__(self, instance, owner):
  	  return self.value
	def __set__(self, instance, value):
	    self.value = float(value)
class Foot(object):
	'''Descriptor for a foot.'''
	def __get__(self, instance, owner):
 		return instance.meter * 3.2808
	def __set__(self, instance, value):
    	instance.meter = float(value) / 3.2808
class Distance(object):
	'''Class to represent distance holding two descriptors for feet and meters.'''
	meter = Meter()
	foot = Foot()
d = Distance()
d.meter		#d.meter --> Distance.__getattribute__('meter') --> Meter.__get__(meter, d, Distance)  --> meter.value --> 0.0
>>>0.0
d.foot
>>>0.0
d.meter = 100
print d.meter, d.foot
>>>(100, 3048.0370641306997)
d.foot = 100
print d.meter, d.foot
>>>(30.480370641306997,  100)

def memeto(obj, deep=False):
	"""memeto is a decrotor to store the attributes"""
	"""False == 0; True == 1"""
	state = (copy.copy, copy.deepcopy)[deep](obj.__dict__)
	def restore():
    	obj.__dict__.clear()
    	obj.__dict__.update(state)
	return restore
class Transactional(object):
	def __init__(self, method):
    	self.method = method
	def __get__(self, instance, owner):
    	def transaction(*args, **kwargs):
        	self.memeto = memeto(instance)
        	try:
            	self.method(*args, **kwargs)
        	except:
            	self.memeto()
    	return transaction
class NumObj(object):
	def __init__(self, v):
    	self.value = v
	def increase(self):
    	self.value += 1
	@Transactional
	def DoStuff(self):
    	self.value = 's'
    	self.value += 1		#will fail
    	print 'error'
n = NumObj(0)
n.DoStuff()
print n.value		#value is restored by Transactional
>>>0

class Cache(object):
	def __getattr__(self, real_name):
		print 'through getattr to get attribute %r' % real_name
		value = str(real_name)
		setattr(self, real_name, value)
		return value
cache = Cache()
cache.__dict__
>>>{}
cache.a
>>>through getattr to get attribute 'a'
>>>a
cache.__dict__
>>>{'a':'a'}
cache.a
>>>a

# 输出字符串中特殊字符的下一个字符
def print_next_char(s, ch):
	s_iter = iter(s)
	for c in s_iter:
		if c == ch:
			try:
				print next(s_iter)
			except StopIteration:
				pass
print_next_char('abadeac', 'a')  # b d c

i = iter([1, 2, 3, 4, 5])
zip(i, i)		# [(1, 2), (3, 4)]
i = iter([1, 2, 3, 4, 5])
zip(i, i, i)    # [(1, 2, 3,)]

i = iter([1, 2, 3, 4, 5])
map(None, i, i)	# [(1, 2), (3, 4), (5, None)]

def print_slice(s, iss):
	iter_is = iter(iss)
	for start, end in map(None, iter_is, iter_is):
		print s[start:end],
print_slice('abcde', [0, 1, 2, 7])  # a cde

import signal, errno
from contextlib import contextmanager
import fcntl
@contextmanager
def timeout(seconds):
    def timeout_handler(signum, frame):
        pass
    original_handler = signal.signal(signal.SIGALRM, timeout_handler)
    try:
        signal.alarm(seconds)
        yield
	# 清理部分，获取或者超时都恢复信号
    finally:
        signal.alarm(0)
        signal.signal(signal.SIGALRM, original_handler)
with timeout(1):
    f = open("test.lck", "w")
    try:
		# 如果不能获取就堵塞
        fcntl.flock(f.fileno(), fcntl.LOCK_EX)
    except IOError, e:
		# SIGALRM到达errno.EINTR产生， 其他报错
        if e.errno != errno.EINTR:
            raise e
        print "Lock timed out"

def hello():
  print('hello,github')