【python-Day4（内置函数补充、装饰器）】

一、内置函数补充

1. python内置函数表

 

2. ASCII码表

# chr # ASCII码表  查询十进制对应的字符
ret = chr(65)
print(ret)
==> A

# ord # ASCII码表  查询字符对应的十进制
ret = ord('A')
print(ret)
==> 65

# 产生随机字母
for i in range(10):
    temp = random.randrange(65,91) # ascii码中，65-90是代表A-Z
    aa = chr(temp)
    li.append(aa)
print(li)
==> ['N', 'V', 'P', 'A', 'D', 'B', 'K', 'O', 'M', 'Q']

# 产生随机验证码
for i in range(10):
    r = random.randrange(0,5)
    if r == 2 or r == 4:
        num = random.randrange(0,10)  # 随机产生0-9数字
        li.append(str(num))
    else:
        temp = random.randrange(65,91) # ascii码中，65-90是代表A-Z
        aa = chr(temp)
        li.append(aa)
print(li)
==> ['2', '5', 'K', 'D', '3', 'O', '3', '1', 'T', '8']

# 产生随机验证码
for i in range(10):
    r = random.randrange(0,5)
    if r == 2 or r == 4:
        num = random.randrange(0,10)  # 随机产生0-9数字
        li.append(str(num))
    else:
        temp = random.randrange(65,91) # ascii码中，65-90是代表A-Z
        aa = chr(temp)
        li.append(aa)
# print(li)
result = "".join(li) # 将元素拼接，元素中都必须为字符串
print(result)
==> 33SLATUZDE

# eval()      执行python代码，只执行表达式并获取结果，有返回值！
ret = eval("8*8")
print(ret) # 有返回值
==> 64

# exec()      执行python代码，接收代码或者字符串比eval更牛逼，只执行但是没有返回值！
aa = exec("8+8")
print(aa) # 没有返回值
==> None

# 快速查看对象提供了哪些功能
print(dir(dict))

# 提供对象的详细功能，其实就是读源码
help(list) 

# 97条数据，每页显示10条，需要多少页(也就是分页)
r = divmod(99,10) # 得到商，得到余数
print(r)
print(r[0])
print(r[1])
==> (9, 9)
==> 9
==> 9

# isinstance()  判断对象是否是某个类的实例
s = "hexu"
r1 = isinstance(s,str)
r2 = isinstance(s,list)
r3 = isinstance(s,dict)
print(r1,r2,r3)
==> True False False

s1 = [11,22,33]
s2 = {"name":"hexu"}
r4 = isinstance(s1,list)
r5 = isinstance(s2,dict)
print(r4,r5)
==> True True

# filter 可迭代的对象（可以for循环的东西）
# 函数返回True，将元素添加到结果中
li = [11,22,33,44,55]

def f1(a):
    if a > 22:
        return True
# 循环li中的元素，如果满足f1中的条件，返回True，表示元素合法，然后就放到ret中
ret = filter(f1,li)
print(list(ret)) # 因为ret是元素，所以要加list()
==> [33, 44, 55]

# 用lambda快速实现实现
li = [11,22,33,44,55]
ret = filter(lambda a: a > 33,li) # 定义元素a
print(list(ret))
==> [44, 55]

# map  可迭代的对象（可以for循环的东西）
# 将函数返回值添加到结果中 ，所以跟filter还是有区别的
li = [11,22,33,44,55]

def f2(a):
    return a + 100

result = map(f2,li)
print(list(result))
==> [111, 122, 133, 144, 155]

# 用lambda快速实现
li = [11,22,33,44,55]
result = map(lambda a: a + 100,li)
print(list(result))
==> [111, 122, 133, 144, 155]

总结：利用filter、map可以做一些批量处理，让代码更简洁

# globals() 全局变量,返回当前范围的全局变量，返回的是字典形式
# locals()  局部变量，返回的是字典形式
NAME = "xuelu"
def f1():
    sec_name = "Li"
    print(locals())
    print(globals())
f1()
==> {'sec_name': 'Li'}
==> {'__doc__': None, '__cached__': None, 'NAME': 'xuelu', '__builtins__': <module 'builtins' (built-in)>, 'f1': <function f1 at 0x000000000069BC80>, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000000000634C50>, '__spec__': None, '__name__': '__main__', '__file__': 'E:/project/day4/内置函数2.py', '__package__': None}

# hash() 将对象转换成hash值，作为字典的key来储存到内存中
s = "hexu"
print(hash(s))
==> 4720577176872117953

# len()
# py3按字符计算,也可以按字节计算，转化一下就可以了
# py2按字节计算,只能按字节计算
s = "贺旭"
print(len(s))
==> 2

s = '贺旭'
b = bytes(s,encoding='utf-8')  # py3，换算成字节计算
print(len(b))
==> 6

# max() min() sum()
s1 = ([11,22,33,100])
print(max(s1))  #最大
print(min(s1))   #最小
print(sum(s1))  #求和
==> 100
==> 11
==> 166

# pow()
r =pow(2,4)# 2的4次方,想当于2**4
print(r)
==> 16

# 三个参数是计算 2**4 % 2      % --> 取模
r = pow(2, 4, 2) 
print(r)
==> 0

# round() 四舍五入
print(round(1.6))
print(round(1.4))
==> 2
==> 1

# zip() 接受任意多个（包括0个和1个）序列作为参数，返回的是元组
l1 = ["Hexu",11,22]
l2 = ["is",11,22]
l3 = ["god",11,22]

r = zip(l1,l2,l3)
temp = list(r)[0]
print(temp)
==> ('Hexu', 'is', 'god')

ret = ' '.join(temp)
print(ret)
==> Hexu is god

二、装饰器

装饰器也是函数，是为了不改变原函数的情况下，定义了一层函数，原函数引用这一层函数。使用装饰器可以在函数执行前和执行后添加相应操作。

装饰器也可以装饰类。

文件：s1.py

# 定义了一个outer函数，也就是装饰器
def outer(func):
    def inner(*args,**kwargs):  # 支持多参数调用,万能参数
        print("before")
        r = func(*args,**kwargs) # 获取原函数返回值，注意：调用的时候如果想显示原函数返回值，要print一下--> print(s1.f1("原函数要传参"))
        print("after")
        return r
    return inner # 不加()代指函数体

# 将下面的函数名f1、f2当做参数传递
# 调用执行f1函数时，自动执行outer函数，并且将函数名f1当做参数传递给outer
# 将outer函数的返回值，实例中为函数名inner，重新赋值给f1

@outer
def f1(arg):
    print(arg)
    return "我是原函数f1返回值" 

def f2(name,age):
    print(name,age)
    return "我是原函数f2返回值"

文件：b1.py

import  s1

p1 = s1.f1("原函数f1要传参")
print(p1)

print("#############################")

p2 = s1.f2("传参1","传参2")
print(p2)

执行b1.py，输出如下：

before
原函数f1要传参
after
我是原函数f1返回值
#############################
传参1 传参2
我是原函数f2返回值

 三、多层装饰器

USER_INFO = {}
USER_INFO['is_login'] = True
USER_INFO['user_type'] = 2

def check_login(func):
    def inner(*args,**kwargs):
        if USER_INFO.get('is_login',None):  # （1）
            ret = func(*args,**kwargs)  # 引用的是check_admin函数下的innner （2）
            return ret  # （7）
        else:
            print("请登录")
    return inner

def check_admin(func):
    def inner(*args,**kwargs):
        if USER_INFO.get('user_type',None) == 2:   #（3）
            ret = func(*args,**kwargs)  # 引用的是index原函数  （4）
            return ret  #（6）
        else:
            print("您不是管理员，无权限查看")
    return inner


# 从上到下调用,从下到上编译
@check_login
@check_admin
def index():  # （5）
    '''
    管理员功能
    :return:
    '''
    print("管理员功能")
index()