# 常量大写
USER_CONSTANT = 'xxx'


# 类名: 首字母大小
class UserDetail(object):
    def __init__(self):
        # 变量名称, 小写加下划线
        self.user_name = 'user'
        # 私有属性: 双下划线前缀
        self.__encrpyped_password = ''

    # 函数/方法: 小写加下划线
    def query_roles(self):
        pass

    # 私有方法: 单下划线前缀
    def _encrypt_password(self):
        pass

example.py:35:5: F821 undefined name 'undefined_method'
example.py:36:9: F821 undefined name 'undefined_var'

# 使用占位符格式化
'ps -ef|grep %s' % 'java'
 
# 使用字典进行格式化
'ps -ef|grep %(keyword)s' % {'keyword': 'java'}
 
# 使用 format 方法格式化
'ps -ef|grep {keyword}'.format(keyword='java')
 
# 对于复杂一些的内容可以通过 Jinja2 来完成，例如生成一段 YML
template = jinja2.Template('\
- hosts: {{project.name}}-{{name}}\n\
  tasks:\n\
    - name: copy captain.jar\n\
      copy:\n\
        src: /home/ci/captain/captain.jar\n\
        dest: {{captain.path}}/\n\
    - name: restart captain\n\
      shell: bash {{captain.path}}/restart-captain.sh\n\
')
 
yml = template.render(model)

# 定义一个生成命令的函数
In [7]: def ps_cmd(x):
   ...:     return 'ps -ef|grep %s' % (x)
   ...:

In [8]: datas = ['lc-auth', 'lc-cmdb']

# 对所有元素执行方法并生成列表
In [9]: [ps_cmd(x) for x in datas]
Out[9]: ['ps -ef|grep lc-auth', 'ps -ef|grep lc-cmdb']

# 使用 map 方法
In [10]: map(ps_cmd,datas)
Out[10]: ['ps -ef|grep lc-auth', 'ps -ef|grep lc-cmdb']

# 对于这类序列的处理，还需要掌握 map, filter, reduce 这三个函数

# 也可以使用 lambda 表达式来处理
In [11]: map(lambda x: 'ps -ef|grep %s' % x, datas)
Out[11]: ['ps -ef|grep lc-auth', 'ps -ef|grep lc-cmdb']

# 包含 tuple 的列表处理, 将 tuple 转成字典存储结构
In [17]: [{'username': x, 'password': y} for x, y in userlist]
Out[17]:
[{'password': '000000', 'username': 'user'},
 {'password': '123456', 'username': 'admin'},
 {'password': '123456', 'username': 'ops'}]

# 转换成以用户名作为键值的字典
In [18]: userdatas = [{'username': x, 'password': y} for x, y in userlist]
In [20]: {item['username']:item for item in userdatas}
Out[20]:
{'admin': {'password': '123456', 'username': 'admin'},
 'ops': {'password': '123456', 'username': 'ops'},
 'user': {'password': '000000', 'username': 'user'}}

# 生成器，可以看到上面的例子中外面都是以 [] 来表达的，这样会直接生成一个列表，但如果改为 () 的话可以创建生成器
In [26]: (ps_cmd(x) for x in datas)
Out[26]: <generator object <genexpr> at 0x7f0ef1339be0>

In [27]: gen = (ps_cmd(x) for x in datas)

In [28]: gen
Out[28]: <generator object <genexpr> at 0x7f0ef1339c80>

In [29]: gen.next()
Out[29]: 'ps -ef|grep lc-auth'

# 生成器也可以通过 for 语句或者 map, filter, reduce 等方法来遍历
# 生成器与列表的区别主要是列表在创建时需要分配内存，而生成器不需要，用来减少内存开销，这一特性通过 yield 关键字来实现
# 上面创建生成器的语句 (ps_cmd(x) for x in datas) 等价于

In [31]: def gen(datas):
   ....:     for x in datas:
   ....:         yield ps_cmd(x)
   ....:

import traceback

try:
    do something
except Exception as ex:
    print ex
    traceback.print_exc()

Exception
  StandardError
  	IOError (I/O 包括文件系统，网络等)
  	OSError (系统相关)
  	LookupError (访问数组/字典)
  	TypeError (方法接收了不合法的类型等)
  	ValueError (编解码相关)

class AESUtils(object):
    @staticmethod
    def encrypt(text):
        pass

    @staticmethod
    def decrypt(text):
        pass

class Query(object):
    DEFAULT_LIMIT = 100

    def __init__(self, offset, limit, keyword):
        self.offset = 0
        self.limit = 0
        self.keyword = keyword

    @classmethod
    def limit(cls, limit):
        # 改变类的全局选项
        cls.DEFAULT_LIMIT = limit

    @classmethod
    def from_keyword(cls, keyword):
        # 通过 cls 参数来创建一个查询对象
        return cls(0, DEFAULT_LIMIT, keyword)

query = Query.from_keyword('test')

class AbstractProcess(object):
    __metaclass__ = abc.ABCMeta
    
    @abc.abstractmethod
    def start(self):
        'start a process'
        return NotImplemented
 
    @abc.abstractmethod
    def stop(self):
        'stop a process'
        return NotImplemented


class SpringbootProcess(AbstractProcess):
    def __init__(self, name):
        self.name = name

# 这样就对 AbstractProcess 的子类进行了约束, 没有实现 start, stop 方法的类不能被实例化
Traceback (most recent call last):
  File "example.py", line 97, in <module>
    proc = SpringbootProcess('xxx')
TypeError: Can't instantiate abstract class SpringbootProcess with abstract methods start, stop

# 序列化并且通过Redis读取
class RedisMixin:
    def redis_key(self):
        raise NotImplemented

    @classmethod
    def from_redis(cls, key):
        r = redis.Redis(host='192.168.100.101', port=6379)
        data = r.get(key)
        return pickle.loads(data)

    def to_redis(self):
        r = redis.Redis(host='192.168.100.101', port=6379)
        data = pickle.dumps(self)
        r.set(self.redis_key, data)


# 创建用户类, 并提供序列化到Redis的功能
class User(RedisMixin):
    def __init__(self, name, email):
        self.name = name
        self.email = email

    def redis_key(self):
        return 'username:%s' % (self.name)

user = User('user', 'user@xiaopeng.com')
print(user.to_redis())

user = User.from_redis('username:user')
print(user.name, user.email)

class Application(object):
    def __init__(self):
        self.router_mapper = {}

    # 这里定义装饰器, 将URI注册到对象中
    def route(self, path):
        def decorator(callfunc):
            self.router_mapper[path] = callfunc
            return callfunc
        
        return decorator

    def dispatch(self, uri, kwargs={}):
        return self.router_mapper[uri](**kwargs)

if __name__ == '__main__':
    app = Application()

    @app.route('/hello')
    def hello():
        return 'hello'

    @app.route('/echo')
    def echo(message):
        return 'echo %s' % (message)

    print(app.dispatch('/hello'))
    print(app.dispatch('/echo', {'message': 'test'}))

# 对字符串进行操作
redis> set message "hello world"
# 对列表进行操作
redis> rpush alphabet "a" "b" "c"
# 对哈希表进行操作
redis> hset book name "Redis in action"
redis> hset book author "Josiah L. Carlson"
redis> hset book publisher "Manning"

# 设置10秒的过期时间
127.0.0.1:6379> expire msg 10
(integer) 1
# 进行查询
127.0.0.1:6379> get msg
"wait expired"
# 等待几秒后再次查询
127.0.0.1:6379> get msg
(nil)

save <seconds> <changes>
save 900 1
save 300 10
save 60 10000

#是否设置为AOF持久化方式
appendonly yes
#默认的文件名
appendfilename "appendonly.aof"
#将aof_buf缓冲区中的所有内容写入并同步到 AOF 文件
appendfsync always
#将aof_buf缓冲区中的所有内容写入到 AOF 文件, 每秒进行同步
appendfsync everysec 
#将aof_buf缓冲区中的所有内容写入到 AOF 文件, 由操作系统决定同步
appendfsync no

auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb
#min-size 表示最小大小，当AOF文件大于这个值时进行第一次重写操作
#percentage表示增量(默认100)，当AOF文件增量超过这个值时触发一次重写操作

slaveof ip port

redis-sentinel /path/to/sentinel.conf
redis-server /path/to/sentinel.conf --sentinel

sentinel monitor master 127.0.0.1 6379 1
sentinel down-after-milliseconds master 60000
sentinel failover-timeout master 90000
sentinel parallel-syncs master 1 

sentinel monitor resque 127.0.0.1 6380 1
sentinel down-after-milliseconds resque 10000
sentinel failover-timeout resque 180000
sentinel parallel-syncs resque 1

@Decorator
def function()
    ...

def function()
    ...
Decorator(function)

queue = Queue.Queue(10)
@Thread(queue, 2)
def testThread(a, b):
    print 'a+b=%s'%(a+b)

def Thread(Q, threads = 1, interval = 1):
    def decorator(callfunc):
        def process():
            while True:
                kwargs = Q.get()
                print 'Thread %s Run...' % (thread.get_ident())
                json = callfunc(**kwargs)
                time.sleep(interval)
        for i in range(0, threads):
            thread.start_new_thread(process, ())
    return decorator

@Thread(queue, 2)
def testThread(a, b):
    print 'a+b=%s'%(a+b)

def producer():
    for i in range(0, 10):
        queue.put({'a': i, 'b': i*2})
    time.sleep(10)

if __name__ == '__main__':
    producer()

class Student:
    def __init__(self, ID, name, age):
        self.ID = ID
        self.name = name
        self.age = age

    def say(self):
        print 'I am a Student'

>>> ss = Student(0,'Li Lei',20)
>>> dir(Student)
['__doc__', '__init__', '__module__', 'say']
>>> dir(ss)
['ID', '__doc__', '__init__', '__module__', 'age', 'name', 'say']

>>> type(ss)
<type 'instance'>
>>> type(Student)
<type 'classobj'>

>>> isinstance(ss,Student)
True

>>> ss.__class__
<class student.Student at 0x7f55ef61b328>
>>> type(ss.__class__)
<type 'classobj'>
>>> ss.__dict__
{'age': 20, 'ID': 0, 'name': 'Li Lei'}
>>> ss.__class__.__dict__
{'__module__': 'student', 'say': <function say at 0x7f55ef625de8>, '__init__': <function __init__ at 0x7f55ef625d70>, '__doc__': None}

>>> ss.__class__.__dict__['say']()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: say() takes exactly 1 argument (0 given)

>>> ss.__class__.__dict__['say'](ss)
I am a Student

>>> def selfkill(s):
...     print 'I going to kill myself, and my name is %s'%(s.name)
... 
>>> Student.__dict__['selfkill']=selfkill
>>> 
>>> ss.selfkill()
I going to kill myself, and my name is Li Lei

>>> hasattr(ss, 'say')
True
>>> getattr(ss, 'say')()
I am a Student
>>> hasattr(ss, 'sing')
False

>>> def wrapper(s):
...     def sing():
...         print 'My name is %s'%(s.name)
...     return sing
... 
>>> setattr(ss, 'sing', wrapper(ss))
>>> ss.sing()
My name is Li Lei
>>> hh = Student(2,"Han MeiMei",20)
>>> hasattr(hh,'sing')
False

def thread_print_args(*args, **kwargs):
    for i in range(0, 10):
        print args, kwargs
        time.sleep(0.1)

def thread_create_test():
    threading.Thread(None, thread_print_args, args = ('a1','a2'), kwargs = {'name': 'test'}).start()
    threading.Thread(None, thread_print_args, args = ('b1','b2'), kwargs = {'name': 'hello'}).start()

class ThreadPrint(threading.Thread):
    def run(self):
        for i in range(0, 10):
            print self.name
            time.sleep(0.1)

def thread_create_test():
    ThreadPrint().start()
    ThreadPrint().start()

mutex = threading.Lock()
count = 0
class ThreadLockTest(threading.Thread):
    def __init__(self, interval):
        threading.Thread.__init__(self)
        self.interval = interval
    def run(self):
        global count
        while count < 100:
            print "%s acquires..." % (self.name)
            mutex.acquire()
            print "%s enter..." % (self.name)
            count = count + 1
            print '%s : %d' %(self.name, count)
            time.sleep(self.interval)
            mutex.release()
            print "%s exit..." % (self.name)


def thread_lock_test():
    ThreadLockTest(0.1).start()
    ThreadLockTest(0.3).start()

condition = threading.Condition()
class ThreadCondTest(threading.Thread):
    def run(self):
        print "%s runs.." %(self.name)
        condition.acquire()
        print "%s wait.." %(self.name)
        condition.wait()
        condition.release()
        for i in range(0, 5):
            print "Hi, I'm runs now"

def thread_cond_test():
    ThreadCondTest().start()
    time.sleep(3)
    condition.acquire()
    condition.notify()
    condition.release()

MAX_THREADS = 4

class TestThread(threading.Thread):
    def __init__(self, poll, cond, num):
        threading.Thread.__init__(self)
        self.poll = poll
        self.task = None
        self.task_args = None
        self.cond = cond
        self.threadID = num

    def run(self):
        while True:
            print 'Thread: %s wait now...'%(self.getName())
            self.cond.acquire()
            self.poll.threads.put(self)
            self.cond.wait()
            self.cond.release()
            print 'Thread: %s run now...'%(self.getName())

            if self.task != None:
                print 'Call Function : %s(%s)' %(self.task, self.task_args)
                self.task(self.task_args)
                del self.task, self.task_args


class ThreadPoll():
    def __init__(self, n):
        self.threads = Queue.Queue(n)
        self.maxsize = n
        self.__init__threads()

    def __init__threads(self):
        for i in range(0, self.maxsize):
            thr = TestThread(poll = self, cond = threading.Condition(), num = i)
            thr.start()

    def dispatch(self, func, arg):
        thr = self.threads.get()
        thr.task = func
        thr.task_args = arg
        thr.cond.acquire()
        thr.cond.notify()
        thr.cond.release()
        return thr.threadID

def thread_print(s):
    for i in range(0, 10):
        print 'Thread: %s' % (s)
        time.sleep(0.1)

def thread_poll_test():
    threadpoll = ThreadPoll(MAX_THREADS)
    threadpoll.dispatch(thread_print, 'Test-1')
    threadpoll.dispatch(thread_print, 'Test-2')
    threadpoll.dispatch(thread_print, 'Test-3')
    threadpoll.dispatch(thread_print, 'Test-4')

    threadpoll.dispatch(thread_print, 'Test-1')
    threadpoll.dispatch(thread_print, 'Test-2')
    threadpoll.dispatch(thread_print, 'Test-3')
    threadpoll.dispatch(thread_print, 'Test-4')