3月的收获总结

1.循环体内定义的函数是无法保存循环执行过程中的不停变化的外部变量

    list = []
    for i in range(3):
        print i, 'iiiii'

        def func(a):
            print i, 'funcfunc'
            return i + a
        list.append(func)

    for f in list:
        print(f(1))

现象： 循环体内定义的函数获取的外部变量是循环体最后一次循环的变量值。

2.filter()函数 ——判断函数（过滤函数）
filter(function, iterable)
将iterable的每一个元素丢给function进行过滤，符合function规则的返回，所有符合function规则的作为一个新的iterable当成filter()的返回结果。

foo = [2, 18, 9, 22, 17, 24, 8, 12, 27]


def fun_filter(x):
    if x > 20 and x % 3 == 0:
        return x

y1 = filter(fun_filter, foo)
# 也可以简洁的写成
y2 = filter(lambda x: (x > 20 and x % 3 == 0), foo)
print y1, y2

结果：

[24, 27] [24, 27]

3.map()函数

map() 会根据提供的函数对指定序列做映射。

4.for…else…

    for x in xrange(1, 6):
        if x == 5:
            print 'find 5'
            break
    else:
        print 'can not find 5!'

5.脚本返回数据解析。
要求：脚本返回数据格式为json格式。

def deal_log_str(str_log):
    """
    字符串log日志
    :param str_log:脚本返回数据
    :return:
    """
    def is_json(log_content):
        '''
        能否转成json
        :param log_content:
        :return:
        '''
        try:
            json.loads(log_content)
        except Exception:
            return False
        return True

    re_result = re.findall("['{'].*['}']", str_log)
    if re_result and is_json(re_result[0]):
    	#  如果返回json格式数据 函数返沪json , True
        return json.loads(re_result[0]), True
    else:
    	#  如果不能返回json格式， 则返回脚本数据格式，False
        return str_log, False

6.对数据库每天数据记录数据入库次数进行限制。
①.如果只是一天一条数据记录，当天数据可以更新覆盖，采用：

RunProcess.objects.update_or_create(
            defaults={
                'step_data': val,
                'start_time': data_time,
                'handle_user': handle_user,
                'record_time': record_time,
                'apply_user': call_apply,
                'connected_internet': network,
                'network_time': network_time,
                'data_back_time': backup_data,
                'backup_data_time': backup_data_time,
                'phone_bank': phone_bank,
                'pc_room': pc_room,
                'server_group': server_group,
                'phone_transfer': phone_transfer,
                'remark': remark_dict,
                # 'time01': time01,
                # 'all_time': all_time,
                'network_remark': network_remark,
                'backup_data_remark': backup_data_remark,
                'pc_room_remark': pc_room_remark,
                'server_group_remark': server_group_remark,
                'phone_bank_remark': phone_bank_remark,
                'record_date': record_date,
                "status": (1 if 1 in status_list else 0)
            },
            **{
                'record_date': record_date,
                "category": 2,
            }
        )
		#  可以通过 **{key:value, key1:value1,···}  进行入库，通过多个字段构成数据库数据唯一

②.如果每天数据是多条，采用：

     run_process_obj = RunProcess.objects.filter(record_date=record_date, category=category)
                if run_process_obj.count() < 3:
                    process = RunProcess.objects.create(
                        handle_user=handle_user,
                        category=category,
                        result=content,
                        record_time=record_time,
                        record_date=record_date,
                        step_data={},
                        remark={},
                        start_time={},
                        status=(0 if status else 1)
                    )

七.操作审计
概念：记录什么人，在什么时间，做了什么事。
主要针对数据库发生更改的记录（以及造成该行为的请求方法，如POST等），包括创建、更新、删除等。

#  表结构
class Logs(models.Model):
    """
    操作日志
    """

    METHOD = (
        ('POST', u"创建"),
        ('DELETE', u"删除"),
        ('PUT', u"更新"),
        ('PATCH', u"更新"),
        ('EXECUTE', u"执行"),
    )

    operator = models.CharField(verbose_name=u"操作人", max_length=20, null=True, blank=True)
    object_id = models.IntegerField(verbose_name=u"操作对象id", null=True)
    object_name = models.CharField(verbose_name=u"操作对象名称", max_length=20, null=True, blank=True)
    object_module = models.CharField(verbose_name=u"操作对象所属模块", max_length=20, null=True, blank=True)
    operate_method = models.CharField(verbose_name=u"操作类型", max_length=20, null=True, blank=True, choices=METHOD)
    operate_content = models.TextField(verbose_name=u"操作内容", null=True, blank=True)
    create_time = models.DateTimeField(verbose_name=u"操作时间", default=datetime.datetime.now)

    class Meta:
        db_table = "system_logs"
        verbose_name = u"操作日志"

    def __unicode__(self):
        return u"[{}]：{}{}{}(id={})". \
            format(self.create_time, self.operator, self.get_operate_method_display(), self.object_name, self.object_id)

    @property
    def abstract(self):
        return u"{}{}(id={})".format(self.get_operate_method_display(), self.object_name, self.object_id)


from django.forms.models import model_to_dict
from common.log import logger

"""
# 添加操作日志
# 根据当前模块，创建模块日志示例
from apps.commons.audit import OperateAudit
# request：请求request对象，instance：操作model对象
OperateAudit.add_log(request, instance)
"""


class OperateAudit(object):
    __module__ = "OPERATE_AUDIT"

    def __init__(self):
        self.operator = None
        self.object_name = None
        self.object_module = None
        self.operate_method = None
        self.operate_content = None
        self.object_id = None

    @classmethod
    def add_log(cls, request=None, instance=None, method=None):
        """
        添加操作日志
        :param request:
        :param instance:
        :param method:
        :return:
        """
        try:
            cls.operate_method = method or request.method
            cls.operator = request.user.username
            cls.object_id = instance.id
            cls.object_name = instance._meta.verbose_name
            cls.object_module = instance._meta.object_name
            cls.operate_content = model_to_dict(instance)
            Logs.objects.create(
                operator=cls.operator,
                object_id=cls.object_id,
                object_name=cls.object_name,
                object_module=cls.object_module,
                operate_method=cls.operate_method,
                operate_content=cls.operate_content,
            )
        except Exception as e:
            log_data = {
                "operator": cls.operator,
                "object_id": cls.object_id,
                "object_name": cls.object_name,
                "object_module": cls.object_module,
                "operate_method": cls.operate_method,
            }
            error_msg = u'添加日志失败：{}；操作对象：{object_name}(id={object_id})；' \
                        u'操作人：{operator}；操作模块：{object_module}；操作类型：' \
                        u'{operate_method}'.format(e, **log_data)
            logger.error(error_msg)

八、创建django-cache表命令

python manage.py createcachetable django_cache