*args和**kwargs传参的注意点 + 装饰器

传参的时候,字典格式的形参2种写法.

如下方示例

def aa(**kwargs):
    print(kwargs)

# 第一种 等式写法
aa(name = "alex")
#第二种字典键值对加**写法
aa(**{"name":"alex"})

　　

列表传参 注意点

def test(*args):
    print(args,"参数个数为%s"%len(args))
str = [1, 2, 3, 4]

test(str) #输出结果([1, 2, 3, 4],) 参数个数为1
test(*str) #输出结果(1, 2, 3, 4) 参数个数为4

 

 

传形参时候,test(str)是将列表整体作为一个数据传入.而test(*str) 是将str作为一个列表传入.

所以前者用len函数输出为1,而后者作为列表传入则显示有4个元素

一个装饰器例子如下:

def zsq(func):
    def wrapper(*args):
        import re
        v = func(*args)
        ret = []
        for i in args:
            ret.append(re.findall("\d+",i))
        return ret

    return wrapper
@zsq
def a(*args):
    print(*args)
str = ["a88d66e3a","wwa665wwa"]
print(a(*str))
-----------------------------------------------------　　
输出结果为

a88d66e3a wwa665wwa
[['88', '66', '3'], ['665']]

 

装饰器代码详解

def deco1(func):
    def outter1(*args, **kwargs):
        print("start  deco1>>outer1")
        res1 = func(*args, **kwargs)
        return res1
    return outter1

def deco2(func):
    def outter2(*args, **kwargs):
        print("start  deco2>>outer2")
        res2 = func(*args, **kwargs)
        return res2
    return outter2

def deco3(x):
    def outter3(func3):
        print("deco3传入的参数为%s" % x)
        def wrapper3(*args, **kwargs):
            print("start deco3>>outter3>>wrappre3")
            res3 = func3(*args, **kwargs)
            return res3
        return wrapper3
    return outter3

# 多个装饰器加载顺序自下而上,deco3() → deco2 →deco1,
# 运行顺序自上而下 deco1 → deco2 →deco3()

@deco1# index = deco1(outter2的内存地址)  ==> outter1的内存地址
@deco2 # index = deco2(wrapper3的内存地址) ==> outter2 的内存地址
@deco3(5)  # 加载 deco3 就是得到outter3地址==>index = outter3(index) = wrapper3
def index(x, y):
    print("Index函数开始运行,参数为%s和%s" % (x, y))


index("A", "B")

# 运行结果
'''deco3传入的参数为5
start  deco1>>outer1
start  deco2>>outer2
start deco3>>outter3>>wrappre3
Index函数开始运行,参数为A和B'''

 

 装饰器 实现爬虫 错误重试次数

import requests

def time_count(time_count):
    def wrapper(func):
        def inner(*args,**kwargs):
            flg =1
            while time_count >= flg:
                try:
                    # print(args,"try里面",kwargs)
                    ret = func(*args,**kwargs)
                    print(ret.status_code)
                    print(func.__name__)
                    return ret
                except:
                        print("第%s出错了,错误的参数是"%flg,args,kwargs)
                        flg += 1
        return inner
    return wrapper

@time_count(3)
def fun(**kwargs):
    url = kwargs.get("url")
    timeout = kwargs.get("timeout")
    print("获取的url参数是%s,time参数是%s"%(url,timeout))
    ret = requests.get(url=url,timeout=timeout)
    print("from fun 访问url >>",url)
    return ret

url_list=["https://www.baidu.com/","https://www.b.com/","https://www.c.com/"]

for i in  url_list:
    fun(**{"url":i,"timeout":3})

输出内容如下

获取的url参数是https://www.baidu.com/,time参数是3
from fun 访问url >> https://www.baidu.com/
200
fun
获取的url参数是https://www.b.com/,time参数是3
第1出错了,错误的参数是 () {'url': 'https://www.b.com/', 'timeout': 3}
获取的url参数是https://www.b.com/,time参数是3
第2出错了,错误的参数是 () {'url': 'https://www.b.com/', 'timeout': 3}
获取的url参数是https://www.b.com/,time参数是3
第3出错了,错误的参数是 () {'url': 'https://www.b.com/', 'timeout': 3}
获取的url参数是https://www.c.com/,time参数是3
第1出错了,错误的参数是 () {'url': 'https://www.c.com/', 'timeout': 3}
获取的url参数是https://www.c.com/,time参数是3
第2出错了,错误的参数是 () {'url': 'https://www.c.com/', 'timeout': 3}
获取的url参数是https://www.c.com/,time参数是3
第3出错了,错误的参数是 () {'url': 'https://www.c.com/', 'timeout': 3}

 

给类方法添加装饰器

装饰器的基本语法是 func = wrapper(func(*args,**kwargs)),但是如果给类方法添加装饰器,并且还要使用里面实例的self,

在调用的时候采用的是类方法的调用方式而不是对象方法的调用方式，所以是func(self, *args, **kwargs)（在本例中等价于class.func(self, *args, **kwargs)）。

装饰器需要改写成

def wrapper(func):
    def inner(self,*args, **kwargs):
        res = func(self,*args, **kwargs)
        return res
    return inner