###如何快速生成验证码(内推码)###
验证码(内推码）一般由大小写字母或数字组成
import random #添加随机模块
import string #添加字符模块
str = string.ascii_letters + string.digits ##所有大小写字母和数字
str = string.digits ##所有数字
str1 = string.ascii_lowercase ##所有小写字母
str2 = string.ascii_uppercase ##所有大写字母
code_str = string.ascii_letters + string.digits
# code_str1 = string.ascii_lowercase
# code_str2 = string.ascii_uppercase
# print(code_str1)
# print(code_str2)
print(code_str)
# print(random.sample(code_str,4))
def gen_code(len=4):
# code = ''
# for i in range(len):
# new_s = random.choice(code_str)
# code += new_s
#
# return code
return ''.join(random.sample(code_str, len))
# print(gen_code())
print([gen_code() for i in range(1000)])
random.choice( 列表) #随机在列表中选择一个
random.sample(列表，个数 )#随机在列表中选择指定个数
生成100个8位数的验证码
方式一
import random
import string
def passwd( ):
str = string.ascii_letters + string.digits
s = ''.join([random.choice(str)for i in range(8)])
return s
result = [passwd() for t in range(100)]
print(result)
方法二：
import random
import string
str1 = string.ascii_letters + string.digits
result1 = [''.join(random.sample(str1,8))for i in range(100)]
print(result1)
####装饰器###
在python程序中，可以使用装饰器给不同的函数插入相同的功能，与其他高级语言相比python不仅简化了装饰器代码还在为函数增加功能时变的透明
装饰器：
概念：把一个函数当作参数传递给一个函数，返回一个替代版的函数
本质上就是一个返回函数的函数
“在不改变原函数的基础上，给函数增加功能”
创建装饰器：
一个装饰器简单来说就是一个函数，只不过装饰器函数的参数必须是一个函数，然后再装饰器函数中重新定义一个新的函数，并在其中执行某些功能前后或中间使用装饰器，最后返回新定义的函数
def outer(fun):
def inner():
print('第一层装饰器：原函数执行前打印语句')
fun()
print('第一层装饰器：原函数执行后打印语句')
return inner
def original_fun():
print('原函数内容')
original_fun()
original_fun = outer(original_fun)
original_fun()
运行
原函数内容
第一层装饰器：原函数执行前打印语句
原函数内容
第一层装饰器：原函数执行后打印语句
语法糖装饰器
可以使用“@”来实现，使用@+装饰其名称放在函数的定义行之前
def outer(fun):
def inner():
print('第一层装饰器：原函数执行前打印语句')
fun()
print('第一层装饰器：原函数执行后打印语句')
return inner
@outer
def original_fun():
print('原函数内容')
original_fun()
运行
第一层装饰器：原函数执行前打印语句
原函数内容
第一层装饰器：原函数执行后打印语句
装饰器实现一个函数计时器
import time #调入时间模块
import string
import random
import functools
li = [random.choice(string.ascii_letters)
for i in range(1000)]
def timeit(fun):
# 问题1：被装饰的函数有返回值的时候怎么办？
# 问题2：被装饰的函数如何保留自己的函数名和帮助信息文档？
@functools.wraps(fun)
def wapper(*args, **kwargs):
"""这是一个wapper函数"""
# 在函数的执行之前
start_time = time.time()
# 执行函数
res = fun(*args, **kwargs)
# 在函数执行之后
end_time = time.time()
print('运行的时间为:%.6f' % (end_time - start_time))
return res
return wapper
@timeit
def con_add():
s = ''
for i in li:
s += (i + '+')
print(s)
@timeit
def join_add():
print('+'.join(li))
con_add()
join_add()
@timeit
def fun_list(n):
"""这是fun_list函数，被timeit装饰"""
return [2 * i for i in range(n)]
@timeit
def fun_map(n):
"""这是fun_map函数，被timeit装饰"""
return list(map(lambda x:x*2,range(n)))
#fun_list(5000)
fun_map(5000)
print(fun_list.__doc__)
print(fun_map.__doc__)
print(fun_list.__name__）
print(fun_map.__name__)
多个装饰器
"""
def decorator_a(fun):
def inner_a(*args,**kwargs):
print('Get in inner_a')
return fun(*args,**kwargs)
return inner_a
def decorator_b(fun):
def inner_b(*args,**kwargs):
print('Get in inner_b')
return fun(*args,**kwargs)
return inner_b
##多个装饰器装饰函数，从上到下执行
@decorator_b
@decorator_a
def f(x):
print('Gat in f')
return x*2
f(1)
带参数的装饰器
import functools
import time
def log(kind):
def add_log(func):
@functools.wraps(func)
def wrapper(*args,**kwargs):
start_time = time.time()
res = func(*args,**kwargs)
end_time = time.time()
print('<%s>[%s] 函数名:%s,运行时间:%.6f,运行返回值的'
'结果：%d' %(kind,time.ctime(),func.__name__,
end_time-start_time,res))
return res
return wrapper
return add_log
@log('debug')
def add(x,y):
time.sleep(1)
return x+y
print(add(1,2))
被装饰的函数存在参数的时候
在构建装饰器的时候作为返回值的函数是用来替代作为参数的函数的，所以这两个函数所用的参数必须一致。在定义装饰器的时候，指定的参数的函数可以有任意个参数以及作为返回值的函数可以有任意个参数，这样使用装饰器的时候就更便捷
def store(func):#定义一个函数，参数也是函数
def inner_f(*args,**kwargs):#指定返回的函数可以有任意个参数
"""这是装饰器store的函数"""
print('welcome!!!')
func(*args,**kwargs)
return inner_f #返回值是另一个函数
@store
def thing1(name): #装饰一个参数的函数
print('%s is frute' %name)
@store
def thing2(name,price): #装饰两个参数的函数
print('%s is frute ,price is %d' %(name,price))
thing1('apple')
thing2('apple',10)
输出：
welcome!!!
apple is frute
welcome!!!
apple is frute ,price is 10
2.装饰有返回值的函数
需要在函数装饰装饰器中作为返回值的函数中接受作为参数的返回值，返回后再返回
def store(func):#定义一个函数，参数也是函数
def inner_f(*args,**kwargs):#指定返回的函数可以有任意个参数
"""这是装饰器store的函数"""
print('welcome!!!')
res = func(*args,**kwargs) #使用变量接受返回值
return res #将变量接受的返回值再次返回
return inner_f
@store
def thing1(name):
print('%s is frute' %name)
@store
def thing2(name,price):
print('%s is frute ,price is %d' %(name,price))
thing1('apple')
thing2('apple',10)
3.被装饰的函数保留自己的函数名和帮助文档信息
当函数被装饰后，装饰器会返回新的函数代替原函数执行，这时函数名称及函数文档都会变成装饰器中定义的函数
def store(func):#定义一个函数，参数也是函数
def inner_f(*args,**kwargs):#指定返回的函数可以有任意个参数
"""这是装饰器store的函数"""
print('welcome!!!')
res = func(*args,**kwargs) #使用变量接受返回值
return res #将变量接受的返回值再次返回
return inner_f
@store #使用装饰器装饰
def frutes1(name):
"""这是被装饰frute的函数"""
print('%s is frute' %name)
@store
def frutes2(name,price):
return ('%s is frute ,price is %d' %(name,price))
print(frutes1.__doc__) #输出函数文档
print(frutes2.__doc__)
print(frutes1.__name__）#输出函数名称
print(frutes2.__name__)
Python提供了functools.wraps，可以让我们在装饰器李访问之前的函数属性
先要调用:import functolls
import functools
def store(func):#定义一个函数，参数也是函数
@functools.wraps(func) ##使用该函数保留原函数的名称和文档等属性
def inner_f(*args,**kwargs):#指定返回的函数可以有任意个参数
"""这是装饰器store的函数"""
print('welcome!!!')
res = func(*args,**kwargs) #使用变量接受返回值
return res #将变量接受的返回值再次返回
return inner_f
@store #使用装饰器装饰
def frutes1(name):
"""这是被装饰frute1的函数"""
return ('%s is frute' %name)
@store
def frutes2(name,price):
"""这是被装饰frute2的函数"""
return ('%s is frute ,price is %d' %(name,price))
print(frutes1.__doc__) #输出函数文档
print(frutes1.__name__) #输出函数名称
print(frutes2.__doc__)
print(frutes2.__name__)
运行：
这是被装饰frute1的函数
frutes1
这是被装饰frute2的函数
frutes2 #原函数的内容
多个装饰器同时装饰一个函数时，从上到下执行
import functools
def store(func):#第一个装饰器
@functools.wraps(func)
def inner_f(*args,**kwargs):
print('welcome!!!')
res = func(*args,**kwargs)
return res
return inner_f
def goods(func):#第二个装饰器
@functools.wraps(func)
def inner_f(*args, **kwargs):
print('Hello!!!')
res = func(*args, **kwargs)
return res
return inner_f
@goods
@store
def frutes1(name,price):
print('%s is frute ,price is %d' %(name,price))
frutes1('apple',13)
运行：
Hello!!!
welcome!!!
apple is frute ,price is 13
带参数的装饰器
装饰器也是一个函数，通过函数名（参数）可调用，然后在@函数名调用最外层传入参数之后返回的函数
import functools
def welcome(time):
def store(func):
@functools.wraps(func)
def inner_f(*args,**kwargs):
print(time)
print('welcome!!!')
res = func(*args,**kwargs)
return res
return inner_f
return store
@welcome(20190603)
def frutes1(name,price):
print('%s is frute ,price is %d' %(name,price))
frutes1('apple',13)