编写装饰器实现python请求错误重试功能,后台日
分类:计算机编程

在做接口自动化测量检验的时候,总会遭受,因连年超时等张冠李戴变成,接口脚本失利。

  1. __new__.__init__分别,如何促成单例情势,有何样亮点
    __new__是五个静态方法,__init__是多少个实例方法
    __new__再次回到五个创设的实例,__init__什么样都不回去
    __new__回到贰个cls的实例时前面包车型客车__init__工夫被调用
    当创设一个新实例时调用__new__,起先化三个实例时调用__init__
  2. 浓度拷贝
    浅拷贝只是增添了八个指针指向一个设有的地点,而深拷贝是充实三个指针何况开采了新的内部存款和储蓄器,这么些扩充的指针指向这几个新的内部存储器,
    利用浅拷贝的情事,释放内部存储器,会放出同一内部存款和储蓄器,深拷贝就不会产出释放同一内部存款和储蓄器的谬误

Decorator是贰个经文的结构式设计格局,有着十三分分布的使用。在特出的Design Patterns:Elements of Reusable Object-Oriented Software中,它的意向被描述为:动态地为多个目的增添额外的职分与功能。对于扩张成效,装饰器提供了比子类化越来越灵敏的代替方案。
在不菲编制程序语言中,比方Python,在语法上就提供了装饰器的扶植,能够透明地采用装饰器。而Java则相比烦琐一些,通过Decorator接口的各个达成,针对被decorate的机件接口的兑现来装饰。本文介绍一种基于annotation的decorator达成,固然无法兑现如python日常的晶莹使用装饰器,在某个场景下,也是一种灵活的达成格局。

  后台权限和尾巴部分框架的改建终于造成了,小白也终归得以放下紧悬着的心,能够轻便一下了。那不他为了多谢老菜,又找老菜聊了四起。

官方给出的不二秘技:

通过decorator实现refactor_test

大家想要通过装饰器达成如此的三个测量试验工具:我们重新完毕了一个函数A,原函数是B。在调用函数A时,能够活动运维函数B,对双边的结果作比较,假设不对等,将这段时间的条件音信输出到日志中,以便追查。同有时候,不应现对函数的不奇怪化使用。
此间的函数,大家必要是幂等的无副作用的
下列全体的代码在这里。

  小白:多谢老大的助手,系统终于更换实现了,能够卓越放松一下了。

max_retries=5 出错重试5次
注意的是,这个只对DNS,连接错误进行重试。

    from requests.adapters import HTTPAdapter
    s = requests.Session()
    s.mount('http://',HTTPAdapter(max_retries=5))
    s.mount('https://',HTTPAdapter(max_retries=5))
    s.get('https://www.baidu.com')
注意赋值和浅拷贝的区别
如l1 = ['a','b','c'] # 这段代码是是对l1 的初始化操作,开辟一个内存空间存储列表,l1 这个变量指向这个列表
l2 = l1 # 这属于赋值操作
# 如果更改l1,l2也会一起改变,因为两个变量指向的是同一个位置
import copy
浅拷贝:不管多么复杂的数据结构,浅拷贝都只会copy一层
copy.copy(...),在多层嵌套时可能会一个数据可改变可能会影响其他的数据.
深拷贝:深拷贝会完全复制原变量相关的所有数据,在内存中生成一套完全一样的内容,在这个过程中我们对这两个变量中的一个进行任意修改都不会影响其他变量.
深拷贝就是在内存中重新开辟一块空间,不管数据结构多么复杂,只要遇到可能发生改变的数据类型,就重新开辟一块内存空间把内容复制下来,直到最后一层,不再有复杂的数据类型,就保持其原引用。这样,不管数据结构多么的复杂,数据之间的修改都不会相互影响
copy.deepcopy(...)

Python的decorator

使用python能够特别自由地贯彻装饰器@refactor_test。代码如下(GitHub):

import functools
import logging

LOGGER = logging.getLogger('refactor_test')

def refactor_test(comp_func):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kws):
            comp_res = comp_func(*args, **kws)
            res = func(*args, **kws)
            if res != comp_res:
                message = "not equals for function:{} from {} 
                        with arguments:{}-{}".format(func.__name__, 
                                comp_func.__name__, args, kws)
                LOGGER.debug(message)
                print(message)
            return res
        return wrapper
    return decorator

def refactor_from(message):
    return message

@refactor_test(refactor_from)
def refactor_to0(message):
    return message

@refactor_test(refactor_from)
def refactor_to1(message):
    return "!"   message

if __name__ == '__main__':
    refactor_to0('Hello python!')
    refactor_to1('Hello python!')

这是拾叁分卓越的python decorator实现,是一心透明的,调用者不须要关切到大家在调用时候实践了贰个refacor_test的过程。refactor_to0是一个相符供给的重构完结,而refactor_to1不是。

  老菜:呵呵,对于后台管理连串功效,你以为已经完工了啊?未有怎么遗漏的吗?

 

  1. HTTP/IP相关心下一代组织商,分别位于哪层
    http合同是超文本传输合同,http公约是依靠TCP/IP通讯契约来传递数据
    http协议专门的学业与c/s架构上,浏览器作为http的顾客端通过UEvoqueL向http服务端即web服务器发送所用诉求。web服务器收到全数央浼后,向客商端发送响应音信,
    http特点是短连接,无状态
    地方栏键输入UENVISIONL,按下回车之后经历了如何?
    1.浏览器向DNS服务器央浼分析该U奥迪Q5L中的域名所对应的IP地址
    2.解析出IP地址后,根据IP地址和私下认可端口80,和服务器创立TCP连接
    3.浏览器发出读取文件的http要求,该乞请报文作为TCP三遍握手的第三个报文的数据发送给服务器
    4.服务器对浏览器必要做出响应,并把相应的html文件发送给浏览器
    5.释放TCP连接
    6.浏览器将该HMTL渲染并出示内容

  2. TCP/UDP区别
    TCP协议是面向连接,保险高可信赖性(数据无错失,数据无失序,数据无不当,数据无重复达到)传输层公约
    UDP:数据遗失,无秩序的传输层协议(qq基于udp合同)

  3. webscoket
    websocket是依靠http左券的,可持续化连接
    轮询:浏览器每间距几秒就发送一回呼吁,询问服务器是或不是有新新闻
    长轮询:客户端发起连接后,若无音信,就径直不回去response给客商端,直到有音信重回,再次来到完事后,顾客端再度发起连接

  4. RabbitMQ:
    劳动器端有Erlang语言来编排,帮忙二种客商端,只会ajax,用于布满式系统中蕴藏转载音讯,在易用性、扩张性、高可用性的地方不俗。
    connection是RabbitMQ的socket连接,它包裹了socket部分连锁协商逻辑
    connectionFactroy为connection的炮制工厂
    channel是大家与RabbitMQ打交道的最要害的多少个接口,大多数的作业操作是在chaanel这几个接口中完结,包含定义Queue、定义Exchange、
    绑定Queue与Exchange,公布新闻等

  5. 装饰器
    调用装饰器其实是五个闭包函数,为别的函数增加附加成效,不改换被修改的源代码和不改换被修饰的法子,装饰器的重临值也是一个函数对象。
    譬喻:插入日志、质量测验、事物管理、缓存、权限验证等,有了装饰器,就可以抽离出大方与函数功能自身无关的均等代码并持续起用。

  6. 闭包
    1.不能够不有二个内嵌函数
    2.内嵌函数必需援用外部函数的变量(该函数蕴含对外成效域实际不是全局作用域名字的援用)
    3.表面函数的重返值必须是内嵌函数

  7. 迭代器与生成器
    迭代可迭代对象对应iter(方法)和迭代器对应next(方法)的二个进度
    生成器:包包涵有yield这些根本字,生成器也是迭代器,调动next把函数产生迭代器。

  8. classmethod,staticmethod,property
    类措施:将类的函数调换来类方法,函数上装修@classmethod会将函数的自行传值参数改成cls
    静态方法:此措施也便是给类扩张三个效果,将类内的函数实例化,给类或对象使用,此时类内的函数就是何足为奇函数,不管是类依然实例化的对象都能够行使
    实例化:类的实例化就能生出叁个实例(对象),可以精晓为类()把虚构的东西实例化,获得实际存在的值

  9. 常用的状态码
    200--服务器成功再次来到网页
    204--乞请收到,但回来音信为空
    304--客商端已经实行了GET,但文件未退换
    400--错误诉求,如语法错误
    403--无权力访问
    404--央浼的页面官样文章
    500--服务器发生内部错误

  10. 多进程,多线程,协程,GIL
    GIL:全局解释器锁,是锁在cpython解释器上,导致同有的时候刻,同一进程只可以有叁个线程被实施
    多进度:多进程模块multiprocessing来贯彻,cpu密集型,IO计算型能够用多进程
    八线程:多线程模块threading来实现,IO密集型,十六线程能够升高功用
    协程:信任于geenlet,对于二十多线程应用。cpu通过切块的章程来切换线程间的施行,蒙受IO操作自动切换,线程切换时供给耗费时间,
    而协成好处未有切换的消耗,未有锁定概念。
    进程:是能源管理单位,实行是并行独立的,达成产出和出现
    线程:是小小的的进行单位,线程的出现为了降低上下文切换的消耗,提供系统的并发性

  11. IO多路复用/异步非阻塞
    IO多路复用:通过一种机制,可以监听五个描述符 select/poll/epoll
    select:连接数受限,查找配成对进程慢,数据由基础拷贝到客商态
    poll:改正了连接数,可是仍旧查找配成对进程慢,数据由基础拷贝到客户态
    epoll:epoll是linux下多路复用IO接口,是select/poll的巩固版,它能刚烈提升程序在大气油不过生连接中唯有微量欢蹦乱跳的图景下的系统CPU利用率
    异步非阻塞:异步映以往回调上,回调正是有音讯再次来到时报告一声儿进程打开管理。非阻塞正是不等待,无需进度等待下去,
    继续试行别的操作,不管别的进度的动静。

  12. PEP8规范,标准的功利是怎么?
    1.缩进:4个空完成缩进,尽量不行使Tab
    2.行:没行最大尺寸不超越79,换行能够采取反斜杠
    3.命名正规:
    4.评释标准:

  13. range-and-xrange
    都在循环时接纳,xrange内部存款和储蓄器质量越来越好,xrange用法与range完全同样,range三个生成list对象,xrange是生成器

  14. with上下文机制原理
    enterexit,上下文管理左券,即with语句,为了让八个目的包容with语句,必需在此个指标类中扬言enterexit方法,
    行使with语句的目标正是把代码块纳入with中试行,with甘休后,自动完结清理职业,无须收到干预

  15. 经典类、新式类
    经文类遵循:深度优先,python第22中学
    新式类服从:广度优先,Python3中

  16. 有未有八个工具得以支持寻觅Python的bug和展开静态的代码剖析?
    PyChecker是五个Python代码的静态剖判工具,它能够扶助搜索Python代码的bug,会对代码的复杂度和格式提议警告,
    Pylint是别的贰个工具得以展开codingstandard检查

  17. Python是何许进展内部存款和储蓄器管理的

    • 目的引用计数:
      引用计数扩大的场地:
      来保持追踪内部存款和储蓄器中的对象,全体指标都用援用计数,一个对象分配贰个新名称将其放入五个容器中(列表,字典,元祖)援引计数收缩的意况:
      选取del语句对目的小名展现的消亡
      援用超过成效域或被重新赋值
      sys.getrefcount()函数可以取得对象的当下援用计数
    • 标记-清除机制
    • 分代才能

Java实现

是因为java语法的限定,无法像动态语言python同样晶莹地为给定方法增添decorator。当然可以遵守杰出的布置性实现,如下图所示。
[图形上传失利...(image-5dfcd6-1510413037923)]

对此大家想要解决的难题,在python中,通过装饰器语法,在编码时,就钦命了由重构后措施到重构前方法的投射。而只要依据守旧的法子完毕,大家率先,必要拥戴三个重构后的点子到重构在此以前方法的映射表,其余,大家不能为每二个重构的主意都编写制定叁个装饰器方法,非常不足灵活,过于繁缛。所以,大家供给利用java的反光机制,动态调用方法。第一点也是很麻烦的,或然写到配置文件,只怕hard code到代码里,都以极不佳的。我们通过java的annotation评释成效来贯彻。Oracle的官方tutorial中,有对java annotations相比较缜密的认证。大家来看看哪些落到实处。

RefactorUtil.java (GitHub):

import org.slf4j.Logger;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.AbstractMap;
import java.util.Map;

public class RefactorTestUtil {
    private static Logger LOGGER = null;

    public interface Equality <T, S> {
        public boolean isEqual(T obj0, S obj1);
    }

    public static void setLogger(Logger logger) {
        LOGGER = logger;
    }

    @Target( ElementType.METHOD )
    @Retention( RetentionPolicy.RUNTIME )
    public @interface RefactorTest {
        String classRef();
        String methodName();
        int[] paramClassIndex2ThisParams() default {};
    }

    private static void testFailLog(String message, Map.Entry<Class<?>, String> migTo, Map.Entry<Class<?>, String>
            migFrom, Object ... params) {
        String argsStr = null;
        if (params != null && params.length > 0) {
            StringBuilder args = new StringBuilder();
            for (Object param : params) {
                args.append(param).append(":").append(param.getClass().getSimpleName());
                args.append(",");
            }
            if (args.length() > 0) {
                argsStr = args.substring(0, args.length() - 1);
            }
            else {
                argsStr = args.toString();
            }
        }
        String logStr = String.format("[MigrationTest]%s-TO(%s)-FROM-(%s)-ARGS(%s)", message, migTo.toString(),
                migFrom.toString(), argsStr);

        if (LOGGER != null) {
            LOGGER.error(logStr);
        }
        else {
            System.err.println(logStr);
        }
    }

    public static <T> T decorateFunctionWithRefactorTest(Class<?> cls, String method, Object ... params) throws
            NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        return decorateFunctionWithRefactorTest(cls, method, new Equality<T, Object>() {
            public boolean isEqual(T obj0, Object obj1) {
                return obj0.equals(obj1);
            }
        }, params);
    }

    public static <T, S> T decorateFunctionWithRefactorTest(Class<?> cls, String method, 
            Equality<T, S> equals, Object... params) throws NoSuchMethodException,   
            InvocationTargetException, IllegalAccessException {
        Method refactorTo = TypeUtil.getClassMethodWithNotAccurateTypedParams(cls, method,
                 params);
        if (refactorTo == null) {
            throw new NoSuchMethodException(String.format("There is no method %s in class 
                    %s", method, cls
                    .getSimpleName()));
        }

        T toResult = (T) refactorTo.invoke(null, params);

        RefactorTest refactorAnno = refactorTo.getAnnotation(RefactorTest.class);
        String refactorFromCls =  refactorAnno.classRef();
        String refactorFromMethod = refactorAnno.methodName();
        int[] paramClassesIndex = refactorAnno.paramClassIndex2ThisParams();

        try {
            Class<?> refactorFromClass = ClassLoader.getSystemClassLoader()
                    .loadClass(refactorFromCls);


            Object[] fromParams = null;
            if (paramClassesIndex != null && paramClassesIndex.length > 0) {
                fromParams = new Object[paramClassesIndex.length];
                for (int i = 0; i < paramClassesIndex.length; i   ) {
                    fromParams[i] = params[paramClassesIndex[i]];
                }
            }
            else {
                fromParams = params;
            }

            Method refactorFrom = TypeUtil.getClassMethodWithNotAccurateTypedParams
                    (refactorFromClass, refactorFromMethod,
                    fromParams);
            if (refactorFrom == null) {
                testFailLog("No refactor-from method found", new AbstractMap.
                        SimpleEntry<Class<?>, String>(cls, method)
                        , new AbstractMap.SimpleEntry<Class<?>,String>
                        (refactorFromClass, refactorFromMethod), params);
                return toResult;
            }

            S fromResult = (S) refactorFrom.invoke(null, fromParams);

            if (! equals.isEqual(toResult, fromResult)) {
                testFailLog("Not equal after refactoring", new AbstractMap.SimpleEntry
                        <Class<?>, String>(cls, method)
                        , new AbstractMap.SimpleEntry<Class<?>, String>
                        (refactorFromClass, refactorFromMethod), params);
            }


        } catch (ClassNotFoundException e) {
            testFailLog("No refactor-from Class found", new AbstractMap.SimpleEntry
                    <Class<?>, String>(cls, method), new AbstractMap.SimpleEntry<Class<?>,  
                    String>(null, refactorFromMethod), params);

        } finally {
            return toResult;
        }
    }
}

RefactorTestUtil.decorateFunctionWithRefactorTest()方法通过传播对应类与艺术名,还可能有参数列表,通过RefactorTest表明获取该办法对应重构前方法,动态相比较五回调用的结果是或不是一致,决定是或不是计入日志。
@interface RefactorTest是二个讲明的扬言,再待注脚的艺术前增添@RefactorTest(...),通过七个本性classRef,methodName,paramClassIndex2ThisParams来给定重构前方法及调用参数的不对齐问题。
透过表明和反光大家贯彻了这么些职能,而出于java反射的限定,对于参数列表的品种不是艺术签字中参数列表的花色完全合营无法找到明确的不二秘技,笔者完结了TypeUtil,提供了简便易行的动态机制,找到相应措施。比方size(Collection)方法,再传播三个Set时,仅仅通过java的反射API,不能找到size(Collection)方法。

TypeUtil.java(GitHub):

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class TypeUtil {
    public static boolean isMatchedBoxingType(Class<?> cls0, Class<?> cls1) {
        if (cls0 == null || cls1 == null) {
            return false;
        }
        if (! cls0.isPrimitive() && ! cls1.isPrimitive()) {
            return cls0.equals(cls1);
        }
        if (cls0.isPrimitive() && cls1.isPrimitive()) {
            return cls0.equals(cls1);
        }

        Class<?> primitive = cls0.isPrimitive() ? cls0 : cls1, boxing = cls1.isPrimitive() ? cls0 : cls1;

        if (primitive.equals(int.class)) {
            return boxing.equals(Integer.class);
        }
        if (primitive.equals(short.class)) {
            return boxing.equals(Short.class);
        }
        if (primitive.equals(float.class)) {
            return boxing.equals(Float.class);
        }
        if (primitive.equals(double.class)) {
            return boxing.equals(Double.class);
        }
        if (primitive.equals(boolean.class)) {
            return boxing.equals(Boolean.class);
        }
        if (primitive.equals(long.class)) {
            return boxing.equals(Long.class);
        }
        if (primitive.equals(char.class)) {
            return boxing.equals(Character.class);
        }
        if (primitive.equals(byte.class)) {
            return boxing.equals(Byte.class);
        }
        return false;
    }

    private static boolean isSubClassOf(Class<?> subCls, Class<?> superCls) {
        if (subCls == null || superCls == null) {
            return false;
        }
        if (superCls.equals(Object.class)) {
            return true;
        }
        if (superCls.isInterface() && ! subCls.isInterface()) {
            for (Class<?> interf : subCls.getInterfaces()) {
                if (interf.equals(superCls)) {
                    return true;
                }
            }
            return false;
        }
        Class<?> cls = subCls;
        for (; cls != null && ! cls.equals(superCls); cls = cls.getSuperclass());
        return cls != null;
    }

    public static Method getClassMethodWithNotAccurateTypedParams(Class<?> cls, String methodName, Object ...
            params) {
        if (cls == null || methodName == null) {
            return null;
        }

        Class<?>[] paramClasses = new Class<?>[params.length];
        int i = 0;
        for (Object param : params) {
            paramClasses[i  ] = param.getClass();
        }

        Method method = null;
        try {
            method = cls.getMethod(methodName, paramClasses);
        } catch (NoSuchMethodException e) {
            Method[] methods = cls.getMethods();

            List<Method> capableMethods = new ArrayList<Method>();
            for (Method candidateMethod : methods) {
                if (! candidateMethod.getName().equals(methodName)) {
                    continue;
                }
                if (! candidateMethod.isVarArgs() && candidateMethod.getParameterTypes().length != params.length) {
                    continue;
                }

                Class<?>[] methodParamClasses = candidateMethod.getParameterTypes();
                boolean found = true;
                for (int j = 0; j < methodParamClasses.length; j   ) {
                    Class<?> methodParamClass = methodParamClasses[j];
                    if(! TypeUtil.isInstanceOf(methodParamClass, params[j])) {
                        found = false;
                        break;
                    }
                }

                if (found) {
                    capableMethods.add(candidateMethod);
                }
            }

            if (capableMethods.size() == 1) {
                method = capableMethods.get(0);
            }
            else if (capableMethods.size() > 1) {
                for (int pi = 0; pi < params.length; pi   ) {
                    Class<?> bottom = Object.class;
                    int mindex = 0;
                    int bottomCount = 0;
                    for (int mi = 0; mi < capableMethods.size(); mi   ) {
                        Method m = capableMethods.get(mi);
                        Class<?> pclass = m.getParameterTypes()[pi];
                        if (pclass.equals(bottom) || isMatchedBoxingType(pclass, bottom)) {
                            bottomCount   ;
                            continue;
                        }
                        if (isSubClassOf(pclass, bottom)) {
                            bottom = pclass;
                            mindex = mi;
                            bottomCount = 1;
                        }
                    }
                    if (bottomCount < capableMethods.size() && bottomCount > 0) {
                        method = capableMethods.get(mindex);
                        break;
                    }
                }
            }
        }
        return method;
    }

    public static boolean isInstanceOf(Class<?> cls, Object instance) {
        if (cls == null) {
            return false;
        }

        if (instance == null) {
            return true;
        }

        if (cls.isPrimitive()) {
            Class<?> insType = instance.getClass();
            return isMatchedBoxingType(cls, insType);
        }
        else if (cls.isArray()) {
            Class<?> insType = instance.getClass();
            if (! insType.isArray()) {
                return false;
            }
            Class<?> cls0 = cls.getComponentType(), cls1 = insType.getComponentType();
            if (isMatchedBoxingType(cls0, cls1)) {
                return true;
            }
        }
        return cls.isInstance(instance);
    }
}

比如说大家有4个艺术:

public class Util {
    public static String refactorFrom(String message, int time) {
        return message   "("   time   ")";
    }

    @RefactorTestUtil.RefactorTest(
        classRef = "Util",
        methodName = "refactorFrom"
    )
    public static String refactorTo0(String message, int time) {
        return message   "("   time   ")";
    }

    @RefactorTestUtil.RefactorTest(
        classRef = "Util",
        methodName = "refactorFrom",
        paramClassIndex2ThisParams = {1, 0}
    )
    public static String refactorTo1(int time, String message) {
        return message   "("   time   ")";
    }

    @RefactorTestUtil.RefactorTest(
        classRef = "Util",
        methodName = "refactorFrom"
    )
    public static String refactorTo2(String message, int time) {
        return message   "["   time   "]";
    }

refactorTo0, refactorTo1, refactorTo2都以重构自refactorFrom。此中refactorTo1更动了参数类型的逐个,使用了paramClassIndex2ThisParams参数。而refactorTo2是一个会被告知错误的重构函数。我们做如下的测量试验:

public RefactorTestUtilTest {
    @Test
    public void testDecorateFunctionWithRefactorTest() {
        String message = "OK";
        int time = 3;

        assertEquals(message   "("   time   ")", RefactorUtil.
                decorateFunctionWithRefactorTest(Util.class, "refactorTo0", message, time);
        assertEquals(message   "("   time   ")", RefactorUtil.
                decorateFunctionWithRefactorTest(Util.class, "refactorTo1", time, message);
        assertEquals(message   "["   time   "]", RefactorUtil.
                decorateFunctionWithRefactorTest(Util.class, "refactorTo2", message, time);
    }
}

与上述同类,通过java的annotations,大家贯彻了一种特定必要的decorator设计形式,然则出于语言特色与语法,无法完毕python同样的透明使用。

  小白:啊......权限管理到位后不就完了吗?还或者有意义要弄的呢?

 

20、什么是python?使用python有怎么样低价?
python是一种编制程序语言,它有对象、模块、线程、万分管理和机动内部存款和储蓄器管理。它简洁,轻巧、方便、轻松扩大、有好多自带的数量结果,何况它开源

  老菜:一经光从利用角度来讲,也恐怕说成功了,但还或许有一部分细节还亟需管理的,比方说日志和充足。

自编写装饰器一

  1. 什么是pickling和unpickling?
    Pickle模块读入任何python对象,将它们转变到字符串,然后使用dump函数将其转储到三个文书中——这一个进程叫做pickling
    反之从存款和储蓄的字符串文件中提取原始python对象的长河,叫做unpickling

  2. python是怎么被分解的?
    Python是一种解释性语言,它的源代码能够间接运营,Python解释器会将源代码转变来人中学间语言,之后再翻译成机器码再进行

  3. 数组和元祖之间的分别是怎么?
    数组和元祖之间的分别:数组内容能够被改造,而元祖内容是只读的,不可被涂改的,此外元祖能够被哈希,举个例子作为字典的key

  4. 参数按值传递和引用传递是怎么落到实处的?
    python中的一切都以类,全体的变量都以多个对象的援用。引用的值是由函数明确的,由此无法被退换,不过假诺八个对象是能够被涂改的,你能够退换对象
    python中对四个函数能够传递参数,可是什么辨别是值传递依旧引用传递,不是程序猿手动调整的,而是python遵照你传入的数额对象,自动识别的。
    只要您传入的参数对象是可变对象:列表,字典,那个时候便是援引传递,即使参数在函数体内被改变,那么源对象也会被涂改。
    假设你传入的参数对象是不可变的对象:数字,元组,字符串,那一年就是值传递。那么源对象是不会转移的,

  5. Python都有如何自带的数据结构?
    Python自带的数据结构分为可变和不可变的:可变的有:数组、集结、字典,不可变的是:字符串、元祖、整数

  6. 如何是python的命名空间?
    在python中,全数的名字都设有于叁个空中中,它们在改空间中存在和被操作——这便是命名空间,它就就像三个盒子,在各样变量名字都对应装着三个目的,当查问变量的时候,会从该盒子里面找寻对应的目的

  7. python中的unittest是什么?
    在python中,unittest是python中的单元测量试验框架,它具有帮衬分享搭建、自动测量试验、在测量检验中间断代码、将区别测量检验迭代成一组

  8. args与*kwargs
    *args代表职责参数,它会收下大肆八个参数并把这么些参数作为元祖传递给函数。
    **kwargs代表的重大字参数,重回的是字典,地方参数应当要放在第一字前边

  9. 在Python中怎么着是slicing?切成丝
    slicing是一种在稳步的指标类型中(数组、元祖、字符串)节选某一段的语法

  10. python中的docstring是什么?
    Python汉语档字符串被称为docstring
    轻便的话,就是出现在模块、函数、类、方法里第八个语句的,正是docstring。会活动成为属性__doc__

  11. os与sys区别:
    os是模块担负程序与操作系统的相互,提供了会见操作系统底层的接口
    sys模块是背负程序与python解释器的互动,提供了一密密麻麻的函数和变量,用于操控Python时运维的条件
    32、完毕贰个单例情势
    __new__()__init__()事先被调用,用于转移实例对象。利用这些法子和类的性子的性状可以达成设计形式的单例情势。
    单例方式是指创制独一指标,单例方式设计的类只好实例,实例化1个目的

  小白:前面不是做过日志管理了,将全数的极其都自动写到日志中,方便开荒人士分析查看,还是可以半自动发送分外文告邮件,别的对于客户端提交的具备数据,在bottle勾子那里也做了拍卖,都写入到日志中了,还会有如何要管理的?

from requests.exceptions import ConnectionError
import requests
def retry(**kw):
    def war(func):
        def w(*args,**kwargs):
            try:
                ret = func(*args,**kwargs)
            except ConnectionError:
                kw['reNum'] = int(kw['reNum']) - 1
                if kw['reNum'] >=0:
                    print kw['reNum']
                    ret = w(*args,**kwargs)
                else:
                    ret = ConnectionError
            return ret
        return w
    return war

  老菜:对于日记来讲可以分为两块:

 

  一是组织者的操作日志,因为后台管理操作涉及到数量安全,管理员的具备操作都需求记录下来,以便产生难题时得以找到关系人,同不平日候某一件事情系列提交相关人口使用以往,BOSS却不知晓他们到底有未有记名使用,每一日在系统做如何;

自编写装饰器二

  二是系统的要命和要害数据的笔录,这一个属于系统底层的日志,将持有特别和与钱财有关的操作消息全部记录下来,有故障时开采职员能够依附日志快速稳固,及时修复难题。那上边大家前边早就做一些了,在前头底层非常多地点都做了try...except...管理,那是很供给的,但您有没有察觉,大家的代码在地点平时运维的完美的,而将代码更新上服务器后即通常爆500错误却不驾驭,想要排查极度时也十分不方便人民群众,但翻看uwsgi等多少个系统日志才行,有个别非常你查来查去都查不出来,非常浪费时间,你知道那几个格外主要是由哪些引起的吧?有未有想过用哪些点子也足以做到实时通过推送文告理解这几个不当啊?当然对于充裕的发生是很难防止的,但是大家得以经过一些花招,让那些非常产生后即时通过邮件或微信等艺术,将万分实际情况公告大家,然后异常的快修复难题。假如你对系统特别熟识的话,有希望客商还没影响过来,十几秒你就将故障修复了,做到人不知鬼不觉,哈哈。

from requests.exceptions import ConnectionError

def retry(**kw):
    def wrapper(func):
        def _wrapper(*args,**kwargs):
            raise_ex = None
            for _ in range(kw['reNum']):
                print _
                try:
                    return func(*args,**kwargs)
                except ConnectionError as ex:
                    raise_ex = ex
            #raise raise_ex
        return _wrapper
    return wrapper

  小白:是啊,格外难点是自家最大痛的作业,比相当多时候显明本地调节和测量试验的完美的,一到劳动就挂了,找到找去也找不出难点所在,浪费了大量的大运。那么我们要怎么来进展退换呢?

 

  老菜:接下去你看自身教学就明白了,首倘若对已有代码进行改造。

动用办法:reNum = 5 代表,出现ConnectionError时最多可重试5次。

  在日前的数据结构划设想计时,我们有贰个总指挥操作日志表,接下去的改建入眼是对这么些表展开连锁的操作。

@retry(reNum=5)
def demo():
    raise ConnectionError

  首先大家需求成立那些日志表的逻辑类,由于大家的ORM是用字典来举办增改操作的,所以要求先组合字段字典,然后再实施相应的方法,为了让操作简化,我们须求在日记表逻辑类中增加贰个艺术,通过传参的办法来张开日志的丰盛操作,那样就足避防去大家结合字典的操作了。

 

 1 #!/usr/bin/env python 2 # coding=utf-8 3  4 from logic import _logic_base 5 from common.string_helper import string 6 from config import db_config 7  8  9 class ManagerOperationLogLogic(_logic_base.LogicBase):10     """管理员操作日志管理表逻辑类"""11 12     def __init__:13         # 表名称14         self.__table_name = 'manager_operation_log'15         # 初始化16         _logic_base.LogicBase.__init__(self, db_config.DB, db_config.IS_OUTPUT_SQL, self.__table_name)17 18 19     def add_operation_log(self, manager_id, manager_name, ip, remark):20         """记录用户登录日志"""21         # 组合要更新的字段内容22         fields = {'manager_id':manager_id, 'manager_name':string(manager_name), 'ip':string, 'remark':string}23         # 新增记录24         self.add_model

总结:

  从代码中能够看见,add_operation_log()方法,它实在正是将要更新到数据库的参数字传送进来,在艺术里组合成字典,然后调用add_model()举行更新操作,调用时用下边代码就足以了

1.编纂装饰器,其实并未有那么难,只要驾驭方法。 这么些能够参考,作者事先写的关于装饰器的小说

_manager_operation_log_logic.add_operation_log(manager_id, manager_name, ip, '登陆成功')

2.装饰器的通熟解释,便是在函数从前后之后做点什么。通过那个我们得以做过多。

  达成那一个操作日志逻辑类和日志增添艺术之后,要改造登入接口就总结多了,只必要在阴差阳错和成功时张开调用,记录到数据表就能够了,具体看代码。

3.关于央浼连接错误,重试,装饰器;原理正是做三个巡回,只要捕获到有ConnectionError 错误,就步入下三次巡回

  登录接口除了供给增多日志记录以外,还须要管理一个康宁难点,大家并没有对屡屡输出密码错误进行管理,假诺有人想要登入种类写个密码劳举器,大概很轻松后台就给人侵占了,所以咱们供给对这么些做三个限量,比如说同一ip在指定时间内只好出错多少次,每回出错开上下班时间都记录一下失误次数,当出错次数超过限制时,则拒绝客户登陆。具体活动查看代码,这里小编就不再详细表明了。

调用;只要有不易的时候,直接回到函数。

图片 1图片 2

 

  1 #!/usr/bin/env python  2 # coding=utf-8  3   4 from bottle import put  5 from common import web_helper, encrypt_helper, security_helper  6 from common.string_helper import string  7 from logic import manager_logic, manager_operation_log_logic  8   9  10 @put('/api/login/') 11 def post_login(): 12     """用户登陆验证""" 13     ############################################################## 14     # 获取并验证客户端提交的参数 15     ############################################################## 16     username = web_helper.get_form('username', '帐号') 17     password = web_helper.get_form('password', '密码') 18     verify = web_helper.get_form('verify', '验证码') 19     ip = web_helper.get_ip() 20  21     ############################################################## 22     # 从session中读取验证码信息 23     ############################################################## 24     s = web_helper.get_session() 25     verify_code = s.get('verify_code') 26     # 删除session中的验证码(验证码每提交一次就失效) 27     if 'verify_code' in s: 28         del s['verify_code'] 29         s.save() 30     # 判断用户提交的验证码和存储在session中的验证码是否相同 31     if verify.upper() != verify_code: 32         return web_helper.return_msg(-1, '验证码错误') 33  34     ############################################################## 35     ### 判断用户登录失败次数,超出次做登录限制 ### 36     # 获取管理员登录密码错误限制次数,0=无限制,x次/小时 37     limit_login_count = 10 38     # 获取操作出错限制值 39     is_ok, msg, operation_times_key, error_count = security_helper.check_operation_times('login_error_count', limit_login_count, False) 40     # 判断操作的出错次数是否已超出了限制 41     if not is_ok: 42         return web_helper.return_msg(-1, msg) 43  44     ############################################################## 45     ### 获取登录用户记录,并进行登录验证 ### 46     ############################################################## 47     # 初始化操作日志记录类 48     _manager_operation_log_logic = manager_operation_log_logic.ManagerOperationLogLogic() 49     # 初始化管理员逻辑类 50     _manager_logic = manager_logic.ManagerLogic() 51     # 从数据库中读取用户信息 52     manager_result = _manager_logic.get_model_for_cache_of_where('login_name='   string) 53     # 判断用户记录是否存在 54     if not manager_result: 55         return web_helper.return_msg(-1, '账户不存在') 56  57     # 获取管理员id 58     manager_id =  manager_result.get('id', 0) 59     # 获取管理员姓名 60     manager_name = manager_result.get('name', '') 61  62     ############################################################## 63     ### 验证用户登录密码与状态 ### 64     ############################################################## 65     # 对客户端提交上来的验证进行md5加密将转为大写(为了密码的保密性,这里进行双重md5加密,加密时从第一次加密后的密串中提取一段字符串出来进行再次加密,提取的串大家可以自由设定) 66     # pwd = encrypt_helper.md5(encrypt_helper.md5[1:30]).upper() 67     # 对客户端提交上来的验证进行md5加密将转为大写 68     pwd = encrypt_helper.md5.upper() 69     # 检查登录密码输入是否正确 70     if pwd != manager_result.get('login_password').upper(): 71         # 记录出错次数 72         security_helper.add_operation_times(operation_times_key) 73         # 记录日志 74         _manager_operation_log_logic.add_operation_log(manager_id, manager_name, ip, '【'   manager_name   '】输入的登录密码错误') 75         return web_helper.return_msg(-1, '密码错误') 76     # 检查该账号虽否禁用了 77     if not manager_result.get('is_enabled'): 78         # 记录出错次数 79         security_helper.add_operation_times(operation_times_key) 80         # 记录日志 81         _manager_operation_log_logic.add_operation_log(manager_id, manager_name, ip, '【'   manager_name   '】账号已被禁用,不能登录系统') 82         return web_helper.return_msg(-1, '账号已被禁用') 83  84     # 登录成功,清除登录错误记录 85     security_helper.del_operation_times(operation_times_key) 86  87     ############################################################## 88     ### 把用户信息保存到session中 ### 89     ############################################################## 90     manager_id = manager_result.get('id') 91     s['id'] = manager_id 92     s['login_name'] = username 93     s['name'] = manager_result.get('name') 94     s['positions_id'] = manager_result.get('positions_id') 95     s.save() 96  97     ############################################################## 98     ### 更新用户信息到数据库 ### 99     ##############################################################100     # 更新当前管理员最后登录时间、Ip与登录次数(字段说明,请看数据字典)101     fields = {102         'last_login_time': 'now()',103         'last_login_ip': string,104         'login_count': 'login_count 1',105     }106     # 写入数据库107     _manager_logic.edit_model(manager_id, fields)108     # 记录日志109     _manager_operation_log_logic.add_operation_log(manager_id, manager_name, ip, '【'   manager_name   '】登陆成功')110 111     return web_helper.return_msg(0, '登录成功')

qq手艺调换群,期望你的投入:

View Code

python|测量试验|本领调换群:563227894

  security_helper.py代码

python|测试|本事沟通群:563227894

图片 3图片 4

python|测量检验|本领调换群:563227894

 1 #!/usr/bin/env python 2 # coding=utf-8 3  4 from common import cache_helper, convert_helper, encrypt_helper 5  6  7 def check_operation_times(operation_name, limiting_frequency, ip, is_add=True): 8     """ 9     检查操作次数10     参数:11     operation_name      操作名称12     limiting_frequency  限制次数13     is_add              是否累加14     返回参数:15     True    不限制16     False   限制操作17     """18     if not operation_name or limiting_frequency is None:19         return False, '参数错误,错误码:-400-001,请与管理员联系', '', 020 21     # 如果限制次数为0时,默认不限制操作22     if limiting_frequency <= 0:23         return True, '', '', 024 25     ##############################################################26     ### 判断用户操作次数,超出次数限制执行 ###27     # 获取当前用户已记录操作次数28     operation_times_key = operation_name   '_'   encrypt_helper.md5(operation_name   ip)29     operation_times = convert_helper.to_int0(cache_helper.get(operation_times_key))30 31     # 如果系统限制了出错次数,且当前用户已超出限制,则返回错误32     if limiting_frequency and operation_times >= limiting_frequency:33         return False, '您在10分钟内连续操作次数达到'   str(limiting_frequency)   '次,已超出限制,请稍候再试', operation_times_key, operation_times34 35     if is_add:36         # 记录操作次数,默认在缓存中存储10分钟37         cache_helper.set(operation_times_key, operation_times   1, 600)38 39     return True, '', operation_times_key, operation_times40 41 42 def add_operation_times(operation_times_key):43     """44     累加操作次数45     参数:46     operation_times_key 缓存key47     """48     # 获取当前用户已记录操作次数49     get_operation_times = convert_helper.to_int0(cache_helper.get(operation_times_key))50     # 记录获取次数51     cache_helper.set(operation_times_key, get_operation_times   1, 600)52 53 54 def del_operation_times(operation_times_key):55     """56     清除操作次数57     参数:58     operation_times_key 缓存key59     """60     # 记录获取次数61     cache_helper.delete(operation_times_key)62 63 64 def check_login_power(id, k, t, sessionid):65     """66     检查拨号小信接口,验证用户是否有权限访问67     :param id: 用户id68     :param k:  32位长度的密钥串69     :param t:  时间戳70     :param sessionid: 当前用户的密钥71     :return: False=验证失败,True=验证成功72     """73     if not sessionid:74         return False75 76     return encrypt_helper.md5   sessionid   str   sessionid   str == k

 

View Code

  想要记录顾客的每叁个操作记录,有二种方法,一是在各个接口这里丰富日志记录,那样可以更详尽的编辑撰写自定义日志表达,不过尔尔做的话职业量会非常的大,也易于在复制粘贴中出错;还大概有正是,每二个后台接口都会调用权限决断情势,大家也足以在此个措施中央市直机关接助长日志记录,瑕玷正是各类访问操作想要表达的很留心很难做到,这里大家通过各类判定与组合格局,来写入对应的接口日志访谈记录,难免会现身记录重复或记录申明不科学的气象。

  上边是后台权限检查格局(_common_logic.py)

 1 #!/usr/bin/env python 2 # coding=utf-8 3  4 from bottle import request 5 from common import web_helper, string_helper 6 from logic import menu_info_logic, positions_logic, manager_operation_log_logic 7  8 def check_user_power(): 9     """检查当前用户是否有访问当前接口的权限"""10     # 读取session11     session = web_helper.get_session()12     # session不存在则表示登录失效了13     if not session:14         web_helper.return_raise(web_helper.return_msg(-404, "您的登录已失效,请重新登录"))15 16     # 获取当前页面原始路由17     rule = request.route.rule18     # 获取当前访问接口方式(get/post/put/delete)19     method = request.method.lower()20     # 获取当前访问的url地址21     url = string_helper.filter_str(request.url, '<|>|%|'')22 23     # 初始化日志相关变量24     _manager_operation_log_logic = manager_operation_log_logic.ManagerOperationLogLogic()25     ip = web_helper.get_ip()26     manager_id = session.get('id')27     manager_name = session.get('name')28     # 设置访问日志信息29     if method == 'get':30         method_name = '访问'31     else:32         method_name = '进行'33 34     # 获取来路url35     http_referer = request.environ.get('HTTP_REFERER')36     if http_referer:37         # 提取页面url地址38         index = http_referer.find('?')39         if index == -1:40             web_name = http_referer[http_referer.find('/', 8)   1:]41         else:42             web_name = http_referer[http_referer.find('/', 8)   1: index]43     else:44         web_name = ''45 46     # 组合当前接口访问的缓存key值47     key = web_name   method   '('   rule   ')'48     # 从菜单权限缓存中读取对应的菜单实体49     _menu_info_logic = menu_info_logic.MenuInfoLogic()50     model = _menu_info_logic.get_model_for_url51     if not model:52         # 添加访问失败日志53         _manager_operation_log_logic.add_operation_log(manager_id, manager_name, ip, '用户访问[%s]接口地址时,检测没有操作权限' % 54         web_helper.return_raise(web_helper.return_msg(-1, "您没有访问权限1"   key))55 56     # 初始化菜单名称57     menu_name = model.get('name')58     if model.get('parent_id') > 0:59         # 读取父级菜单实体60         parent_model = _menu_info_logic.get_model_for_cache(model.get('parent_id'))61         if parent_model:62             menu_name = parent_model.get('name').replace('列表', '').replace('管理', '')   menu_name63 64     # 从session中获取当前用户登录时所存储的职位id65     positions = positions_logic.PositionsLogic()66     page_power = positions.get_page_power(session.get('positions_id'))67     # 从菜单实体中提取菜单id,与职位权限进行比较,判断当前用户是否拥有访问该接口的权限68     if page_power.find(','   str(model.get('id', -1))   ',') == -1:69         # 添加访问失败日志70         _manager_operation_log_logic.add_operation_log(manager_id, manager_name, ip, '用户%s[%s]操作检测没有权限' % (method_name, menu_name))71         web_helper.return_raise(web_helper.return_msg(-1, "您没有访问权限2"))72 73     if not (method == 'get' and model.get('name') in ('添加', '编辑')):74         # 添加访问日志75         _manager_operation_log_logic.add_operation_log(manager_id, manager_name, ip, '用户%s[%s]操作' % (method_name, menu_name))

  这里记录的日记与菜单管理记录相关,假诺菜单项的命名或树列表不正规,则记录的日记恐怕就能偏侧相当大。当然即便您有人格障碍追求八面后珑的话,可机关对它举办改建。比方说在菜单管理中增加一个字段,用来编排日志表达的,访谈那么些页面时直接将表明更新到操作日志表中就足以了,轻巧方便。而即使对操作内容想要更全面包车型大巴,也得以在日志表中增添贰个字段,将客户端提交的参数全体写入到字段里记录,这样对客商的操作就能够更清楚了,当然要是客商更新新闻或小说类内容时,字段值也会非常的大。大家能够依据要求来开展对应改动。

  下图为操作日志表记录内容

图片 5

  后台管理还亟需做个日志查看的页面,接口代码不会细小略,具体直接看源码,这里也不详细表达了

图片 6

  对于充裕处理,我们实在都晓得使用try...except...进行捕捉,然后记录特别新闻或作对应管理。

  而在接口产生500破绽百出时,由于程序在劳务器端试行,服务器情形与地面包车型客车支付遇到有所不一样,就很难直观的决断是怎么来头引起的,大概是少上传了有个别调用文件,也大概是新援用的包没有设置,又也许是代码中写错了代码,也可以有望是变量为空引起的至极,反正恐怕情状特别之多,当接口相当多时,这么些非凡通过很掩盖,独有等到该接口被调用时技艺窥见,假设拍卖不佳,开拓职员可能会开支不菲时间在这里方面。

  当然也会有艺术是,全数的接口代码都献身try...except...里面实施,那样发生500的情况会大大减少,但代码看起来层级多了也欠美观。对于这种总结重复统一的代码,python有二个蛮好用的工具,那正是装饰器,我们能够编写三个装饰器方法给接口使用,进而完结我们想要的指标。

  装饰器达成的原理正是,通过在函数尾部引用装饰器,进而使程序奉行代码时,先施行装饰器里面包车型客车代码,然后再调用援引装饰器的函数,最终再回来装饰器实践剩下的代码。轻便的理解便是,原有A函数和装饰器B函数,当A函数援引装饰器B函数以往,A函数实际就改为B函数中被调用的二个主意,即B函数在奉行进程中会调用A函数,实行到位A函数后回去想要的结果再继续试行前面包车型客车代码

  先上代码,大家在老大操作包中(except_helper.py),加多底下方法:

 1 def exception_handling: 2     """接口异常处理装饰器""" 3     def wrapper(*args, **kwargs): 4         try: 5             # 执行接口方法 6             return func(*args, **kwargs) 7         except Exception as e: 8             # 捕捉异常,如果是中断无返回类型操作,则再执行一次 9             if isinstance(e, HTTPResponse):10                 func(*args, **kwargs)11             # 否则写入异常日志,并返回错误提示12             else:13                 log_helper.error(str14                 return web_helper.return_msg(-1, "操作失败")15     return wrapper

  func正是流入到装饰器方法中的别的格局,由于大家的装饰器是给接口使用,所以进行进度中央直属机关接再次来到结果,由于大家的代码在实行进度,一时会调用raise来脚刹踏板代码施行,那样的话接口方法是从未有过再次回到值的,即便选拔return来调用方法就能现身极度,所以在第9到10行,会调用方法重新实践一回接口方法,所以在付出时要注意,独有对那个出错开上下班时间须求及时暂停的地点,才使用raise那样有限扶助再也推行接口方法不会促成数据失实。

  当接口方法实行出现分外要抛出500时,那一个装饰器就能够捕捉到,然后经过调用log_helper.error()方法,将那一个写入日志,并发送分外文告邮件文告开拓人士。对于非常文告,若是您注册了微信公司号,你可以编写对应的代码与集团号进行对接,让您和血脉相通人口在微信上能够实时收到到极度推送新闻,方便即时发现难点然后管理难点。

  上面是调用方法:

 1 @get('/api/system/department/<id:int>/') 2 @exception_handling 3 def callback: 4     """ 5     获取指定记录 6     """ 7     # 检查用户权限 8     _common_logic.check_user_power() 9 10     _department_logic = department_logic.DepartmentLogic()11     # 读取记录12     result = _department_logic.get_model_for_cache13     if result:14         return web_helper.return_msg(0, '成功', result)15     else:16         return web_helper.return_msg(-1, "查询失败")

  只须要在接口路由和接口方法之间,增多@exception_handling就足以兑现接口500时,接收相当邮件推送了。特别有帮忙好用。

  本文对应的源码下载

版权注明:本文原创发布于微博,小编为AllEmpty本文招待转发,但未经小编同意必须保留此段注明,且在小说页面明显地方给出原来的文章连接,不然视为侵害版权。

python开辟QQ群:669058475、733466321 笔者博客:

本文由pc28.am发布于计算机编程,转载请注明出处:编写装饰器实现python请求错误重试功能,后台日

上一篇:python入门函数,python中lambda函数使用用法 下一篇:没有了
猜你喜欢
热门排行
精彩图文