import time
import signal
run_flag = threading.Event()
run_flag.set()


def signal_handler(signal, frame):
    print " get singal !!"
    run_flag.clear()


if __name__ == '__main__':
    signal.signal(signal.SIGINT, signal_handler)
    while run_flag.is_set():
        time.sleep(1)

import logging, logging.config
from logging.handlers import TimedRotatingFileHandler
def create_logger():
    logger = logging.getLogger("Rotating Log_" + area + '_' + str(index))
    logger.setLevel(logging.DEBUG)
    handler = TimedRotatingFileHandler(logname,
                                       when="H",
                                       interval=3,
                                       backupCount=24)
    formatter = logging.Formatter(
        '[%(asctime)s][%(process)d][%(levelname)s] %(message)s')
    handler.setFormatter(formatter)
    logger.addHandler(handler)
    return logger

wget https://bootstrap.pypa.io/{version}/get-pip.py

curl --silent --show-error --retry 5 https://bootstrap.pypa.io/2.6/get-pip.py | sudo python

python2 -m pip intall redis

def task_result_hash(self):
    return hash(self.task_id + "#" + str(self.exec_time))

task_pb2.TaskResult.__hash__ = task_result_hash

"{0:b}".format(37)

bin(10)
hex(10)

for job in iter(queue.get, None):
  print(job)

for job in queue.queue:
  print(job)

TypeError: Parameter to MergeFrom() must be instance of same class: expected Hello_msg got Hello_msg.

def f(x):
    return {
        'a': 1,
        'b': 2
    }.get(x, 9)    # 9 is default if x not found

b"abcde".decode()  # Python3 默认编码方式就是utf-8
u"abcde".encode()

bytes_data = [112, 52, 52]
"".join(map(chr, bytes_data))

import enum

@enum.unique
class ChannelConnectivity(enum.Enum):
    IDLE = (_cygrpc.ConnectivityState.idle, 'idle')
    CONNECTING = (_cygrpc.ConnectivityState.connecting, 'connecting')
    READY = (_cygrpc.ConnectivityState.ready, 'ready')
    TRANSIENT_FAILURE = (_cygrpc.ConnectivityState.transient_failure,
                         'transient failure')
    SHUTDOWN = (_cygrpc.ConnectivityState.shutdown, 'shutdown')

[(d, p) for d in dests for p in ports]
[(x, y) for x in [1, 2] for y in [3,4]]

class MyClass:
     i = 3

isinstance(q, Queue)

type(q) is Queue

q = NewQueue()
print(type(q) is Queue)  # False
print(isinstance(q, Queue))  # True

yum install libffi-devel -y

make && make install

pip uninstall sacc_tool_pkg

python3 -m pylint

pic_url = ("http://graph.facebook.com/{0}/"
           "picture?width=100&height=100".format(me['id']))

import dpkt

def _period_func_wrapper(func, scheduler, delay, priority, *args):
    scheduler.enter(delay, priority, _period_func_wrapper, (func, scheduler, delay, priority, *args))
    func(*args)


def run_process_per_minute(func, *args):
    s = sched.scheduler(time.time, time.sleep)
    _period_func_wrapper(func, s, 60, 1, *args)
    s.run()

[x for x in L if x is not None]

import tempfile
_, temp_file_path = tempfile.mkstemp()
print("File path: " + temp_file_path)

os.remove
os.rmdir

try:
    return read_config()['global']['appid']
except KeyError:
    return ""

if getattr(sys, 'frozen', False):
    base_dir = sys._MEIPASS

if getattr(sys, 'frozen', False) and hasattr(sys, '_MEIPASS'):
    base_dir = sys._MEIPASS

import os
stream = os.popen('free -b -t -w')
output = stream.read()
#print(output)


```bash
python2 -m pylint --msg-template='{msg_id}:{line:3d},{column}: {obj}: {msg}' express_check.py > pylint.out

csv = open("titanic.txt")
keys = next(csv).strip().split(",")
print([{k: v for k, v in zip(keys, row.strip().split(","))} for row in csv])
csv.close()

# 安装 pip
wget https://bootstrap.pypa.io/pip/2.7/get-pip.py
python get-pip.py --user

# 更新 setuptools 解决下边链接中提到的问题
# > 'install_requires' must be a string or list ...
# https://github.com/sdispater/pendulum/issues/187#issuecomment-375820769
python -m pip install setuptools -U --user

# 安装 requests
git clone git://github.com/psf/requests.git
cd requests/
python setup.py install --user

print "Zip:"
for x, y in zip(a, b):
    print x, y

print "List comprehension:"
for x, y in [(x,y) for x in a for y in b]:
    print x, y

[sum(x) for x in zip(*blocked_lines)]

queue_name += '_QUEUE_NORMAL',

os.listdir("/usr")

try:
    ...
except requests.exceptions.RequestException as e
    logger.error(traceback.format_exc())
    raise RequestDataError('API Request failed {}'.format(str(e))
finally:
    return user_label

    def check_redis(self, redis_key, input_text)
        """判断缓存中是否有模板"""
        ...

    def check_once(self, username, input_text):
        """判断是否要取消订阅和是否是帮助"""
        ...

    if tmp["by_relation"] in [u'业务属于', u'维护人']:

if xx is not None:
  pass

answer = answer + data["opinion_type"]

if nick["Workspace"].get("status") is not None and nick["Workspace"]["status"] == "normal":

for i in range(len(t)):
    t[i].start()

record_num, record_data, user_list = t.record_false_job_result(user_id, biz_id)
return record_num, record_data, user_list

if 'start_timestamp' not in req.keys() or 'end_timestamp' not in req.keys():

for ccid in ccid_list:
    is_exist, cash_dict = GetRedis().get_reids_key_exist(redis_key, warn_text

answer = self.no_match.get_text_answer(input_text)
ans_list = answer.split(u".")
if answer != []:
  ...

class RecordItem(object):
    def __init__(self):
        self.update_time = 0
 
 
class JudgeUserCoreRecord(RecordItem):
    def __init__(self, user_account=None):
        super(JudgeUserCoreRecord, self).__init__()
        # 核心用户信息
        self.game_id = user_account.game_id if user_account else Non
        self.user_id = user_account.user_id if user_account else None
        self.account_type = user_account.account_type if user_account else None
        self.account_info = user_account.account_info if user_account else None

xx = xx or "xxx"
evidence_type = evidence_type or ''  # 处理None值

return False if resp == True else True

records = filter(lambda x: not xxx(x), records)

records = [for x i records if not xxx(x)]

 if old_type_patt.match(line):
     old_type = int(old_type_patt.match(line).group(1).strip()
     if is_free_punish_patt.match(line):

if not limit.get('user_msg') or limit['user_msg'] == 'null':

if limit.get('user_msg', 'null) == 'null':

        md5 = evidence[evidence.find('md5'):].strip().split('&')[0].split('=')[1]

class User:
    @property
    def password(self):
        raise AttributeError('password is not readable attribute')

    @password.setter
    def password(self, password):
        self.password_hash = generate_password_hash(password)

    def verify_password(self, password):
        return check_password_hash(self.password_hash, password)

super(JudgeUserCoreInfo, self)

class JudgeUserSeasonRecord(RecordItem):
 
    def __init__(self):
        super(JudgeUserSeasonRecord, self).__init__()
        self.season_right_punish_case_num = 0
        self.season_total_case_num = 0
        self.season_right_case_num = 0
        self.season_wrong_case_num = 0
        self.season_accuracy = 0
 
    @staticmethod
    def init_value(record):
        record.season_accuracy = -1
        return record

record = get_cache_record(cache_record_cls=JudgeUserSeasonRecord)
if record is None:
    record = JudgeUserSeasonRecord.init_value(JudgeUserSeasonRecord())

class Cache(kv_client.KVJSONObject):
    """基于kv存储实现cache
 
    屏蔽kv存储中value的json格式，支持将类实例作为入参，并将实例中的属性字段存入cache中
    读取时，将cache中的内容作为类实例的属性进行存储
 
    """
    _KV_PREFIX = "gs:1029:court:cache:"
    _CACHE_FIELD = 'cache_info'
 
    def __init__(self, game_id, user_id, extra_prefix=None):
        """初始化cache
        :param game_id: 游戏id
        :param user_id: 用户id
        :param extra_prefix: 业务层指定的key前缀
        """
        self.user_id = user_id
        self.game_id = game_id
        key_prefix = self._KV_PREFIX + get_cache_env_prefix()
        if extra_prefix is not None:
            key_prefix += extra_prefix
        super(Cache, self).__init__("court", str(game_id) + '_' + str(user_id), key_prefix)
 
    @property
    def cache_info(self):
        """获取cache info信息"""
        if not self.value or not self.value.get(self._CACHE_FIELD):
            return None
        return self.value[self._CACHE_FIELD]
 
    def update_cache_info(self, cache_record, expire_sec):
        """更新cache内容
        :param cache_record: 需要写入cache的记录，需要具备__dict__属性, 对于属性为None的字段不进行更新
        :param expire_sec: 过期时间，单位为秒
        :return: None
        """
        if not self.value:
            self.value = {}
        if self._CACHE_FIELD not in self.value:
            self.value[self._CACHE_FIELD] = {}
        cache_info_dict = self.value[self._CACHE_FIELD]
        for key, val in cache_record.__dict__.items():
            if val is None:
                continue
            cache_info_dict[key] = val
        self.save_value(expire=expire_sec)
 
    def get_cache_record(self, cache_record_cls):
        """获取cache中的记录
 
        读取cache中的内容，然后存入cache_record_cls对应的实例中
        存储的字段通过cached_record_cls包含的属性进行限定,如果
        cached)_record_cls中所需的字段在cache中不存在，则用None填充
 
        :param cache_record_cls: 需要将cache中的内容写入类实例记录类型
        :return: cache_record_cls对应的实例
        """
        cache_info_dict = self.cache_info
        if cache_info_dict is None:
            return None
        cache_record = cache_record_cls()
        for key in cache_record.__dict__:
            setattr(cache_record, key, cache_info_dict.get(key, None))
        return cache_record

class A(object):
    def __init__(self):
        super().__init__()
        print('A')


class B(A):
    def __init__(self):
        super().__init__()
        print('B')


class C(A):
    def __init__(self):
        super().__init__()
        print('C')


class D(C, B):
    def __init__(self):
        super().__init__()
        print('D')


class E(D):
    def __init__(self):
        super(C, self).__init__()
        print('E')


d = D()
print('###')
e = E()

kv_ins = kv_client.RedisClient.get_instance(name)
# 批量操作不使用事务属性(互娱分布式redis目前不支持事务)
pipe = kv_ins.client.pipeline(False)
for incr_item in incr_list:
    inc_key = incr_item['inc_key']
    delta_num = incr_item['delta_num']
    expire = incr_item['expire']
    pipe_key = inc_key
    app_log.info('incr key:%s|%s|%s', pipe_key, delta_num, expire)
    pipe.incrby(name=pipe_key, amount=delta_num)
    expire = None if int(expire) < 0 else expire
    if expire is not None:
        pipe.expire(name=pipe_key, time=expire)
pipe.execute()

except:
    processing ...
    raise

async def main(): ...
main() # 不能运行

        for i in res_list:
            rule = i['name']
            for res in i["result"]:
                metric = res["metric"]
                for value in res["values"]:
                    timestamp = value[0]
                    val = value[1]
                    utc_date = self.pktime_to_utc(timestamp)
                    point_list.append(Point(activity_name) \
                        .tag("metric", metric) \
                        .field(rule, val) \
                        .time(utc_date, WritePrecision.S))

    def __init__(self, config_file, filter_chain=[]):
        ...

    def __init__(self, config_file, filter_chain=None):
        # TODO validate config file format
        if filter_chain is None:
            filter_chain = []
        ...

listA = [0]
listB = listA
listB.append(1)
print(listA)