python基础（装饰器、pyhton内置函数）

一、装饰器：

　　1.1 装饰器原则：

　　　　对扩展开发
　　　　对修改封闭
　　　　不改变调用方式

　　1.2 应用场景：

　　　　框架
　　　　面向对象
　　　　程序登录认证等

　　1.3 装饰器建立与示例：

　　　　1.3.1 装饰器建立：

　　 
import time

# 装饰器
def warpper(f):   # 接收被装饰的函数内存地址

    # 装饰器闭包函数
    def inner(*args, **kwargs):
        print('.........start..........')
        start_time = time.time()   # 起始时间
        f(*args, **kwargs)    # 调用被装饰的函数 func1 func2
        end_time = time.time()   # 结束时间
        print('这个{} 函数，执行时间为：{}'.format(f.__name__, end_time - start_time))
        print('.........end..........')

    return inner


# 装饰器普通调用(方法一)：

# 普通传参
# 被装饰函数
def func1(s):      # 普通传参
    print(s)  # 打印位置参数
    print('这是一个旧函数')
    time.sleep(1)   # 睡一秒

func = warpper(func1)
func(5)



# 动态传参
# 被装饰函数
def func2(*args, **kwargs):
    print(args)  # 打印动态位置参数
    print(kwargs)   #  打印动态默认参数
    print('这是一个旧函数')
    time.sleep(1)   # 睡一秒

func = warpper(func2)
func(5, 2, **{'a': 1, 'b': 2})




# 装饰器语法糖调用(方法二)：

def warpper(f):  # 接收被装饰的函数内存地址
    def inner(*args,**kwargs):  # 接受被装饰函数的参数
        start_time = time.time() # 新功能
        ret = f(*args,**kwargs)  # 调用被装饰的函数,被装饰参数带上
        end_time = time.time()
        print('%s函数的运行时间:%s'%(f.__name__,end_time - start_time))
        return ret               # 被装饰的函数返回值
    return inner

@warpper       # func = warpper(func)  语法糖
def func(*args,**kwargs):
    print(args)   # 打印被装饰的函数参数
    print('这是主功能!')
    time.sleep(1)
    return '小姐姐'  # 返回值
ret = func(5)   # ret = func(5)  == inner(5)  返回值  func(5)
print(ret)  # 被装饰的函数返回值 小姐姐
View Code

　　　　1.3.2 语法糖的多层调用示例1：

　　 
# 装饰器语法糖的多层调用：


def warpper(f):
    def inner(a):  # 接受一个被装饰的函数的参数 a = 1
        print('这是一个warpper装饰器')  # func
        f(a)  # 调用被装饰的函数   f(1) == func(1)
        print('这是一个warpper装饰器')
    return inner


def auto(f):
    def inner(a):  # 接受一个被装饰的函数的参数 a = 1
        print('这是一个auto装饰器')  # func
        f(a)  # 调用被装饰的函数   f(1) == func(1)
        print('这是一个auto装饰器')
    return inner

def login_auot(f):
    def inner(a):   # 接受一个被装饰的函数的参数 a = 1
        print('这是一个login_auot装饰器')  # func
        f(a)  # 调用被装饰的函数   f(1) == func(1)
        print('这是一个login_auot装饰器')
    return inner


# 每个语法糖必须单层，每个装饰器一层
# 使用规范,装饰放在被装饰的函数离它最近正上方
# 执行的时候 从最上层装饰器开始执行  中间执行被装饰的函数  返回的时候是从下往上走
@warpper      # func = warpper(func)
@auto         # func = auto(func)
@login_auot   # func = login_auot(func)
def func(a):
    print('>>>')
    print('func是一个被装饰的函数')
    print('>>>')

func(1)

# 结果：
# 这是一个warpper装饰器
# 这是一个auto装饰器
# 这是一个login_auot装饰器
# >>>
# func是一个被装饰的函数
# >>>
# 这是一个login_auot装饰器
# 这是一个auto装饰器
# 这是一个warpper装饰器
View Code

　　　　多层装饰器图例：

　　　　

　　　　1.3.3  语法糖多层调用示例2：

　　　　当我们对f传入参数1进行调用时，inner_b被调用了，他会先打印Get in inner_b,然后在inner_b内部调用了inner_a,所以会再打印Get in inner_a,然后再inner_a内部调用原来的f,并且将结果作为最终的返回总结：装饰器函数在被装饰函数定义好后立即执行从下往上执行函数调用时从上到下执行　　

def decorator_a(func):
    print('Get in decorator_a')
    def inner_a(*args, **kwargs):
        print('Get in inner_a')
        return func(*args, **kwargs)
    return inner_a
    
def decorator_b(func):
    print('Get in decorator_b')
    def inner_b(*args, **kwargs):
        print('Get in inner_b')
        return func(*args, **kwargs)
    return inner_b
    
@decorator_b #f=decorator_b(f)
@decorator_a #f=decorator_a(f)
def f(x):
    print('Get in f')
    return x * 2
f(1)

# 答案：
Get in decorator_a 
Get in decorator_b 
Get in inner_b 
Get in inner_a Get 
in f

　　　　1.3.4  装饰器的wraps装饰方法：

　　 
# 装饰器的wraps装饰方法：

from functools import wraps

def warpper(f):
    """
    这是一个装饰器函数
    :param f: f->func的函数内存地址
    :return: 无返回值
    """
    @wraps(f)    # 显示被装饰的函数
    def inner(*args,**kwargs):
        print(f)
    return inner  #


def func():
    """
    这是一个被装饰的函数
    :return: 无返回值
    """
    print(1)


func = warpper(func)
print(func.__name__)  # 显示被装饰的函数名
print(func.__doc__)   # 显示装饰器的注释文档
View Code

　　　   1.3.5 有参装饰器

　　 
# 有参装饰器的应用：


def a(flag):
    def b(f):
        def c(*args, **kwargs):
            if flag:
                print('扩展的功能')
                f(*args, **kwargs)
            else:
                f(*args, **kwargs)  # 原功能
        return c
    return b


@a(False)   # func = b(func) = a(False)
def func():
    print(1)

b = a(False)
func = b(func)
func()
View Code

二、 内置函数：

　　2.1 不常用方法：

　　 
 1 # 内置函数：
 2 
 3 print(abs(-98))          # 求绝对值  正的负的 出来后全都是正的
 4 
 5 print(all([1,0,3,4]))    # all 判断元素中都为真的才是真
 6 
 7 print(any([1,False,0]))  # any 判断元素中只要有一个为真就是真
 8 
 9 print(ascii('你'))       #  查看元素对应的内容
10 
11 print(bin(10))           # 将10进制转行2进制
12 
13 print(bool([1]))         # 将内容转换成布尔值
14 
15 # 返回一个新的元组,元组可以切片,切片的内容对应的编码表地址
16 b = bytearray('你好'.encode('utf-8'))
17 print(b[0])
18 
19 print(bytes('你', encoding='utf-8'))   # b'\xe4\xbd\xa0'
20 print('你'.encode('utf-8'))            # b'\xe4\xbd\xa0'
21 
22 
23 def func():
24     pass
25 print(callable(func))   # 检查这个对象是否可以调用
26 
27 print(chr(20013))  # 输入数字,返回对应的unicode表位上对应的内容
28 
29 print(complex(8))  # 复数
30 
31 print(dict(key=1,name=2))
32 
33 print(dir([1,2]))  # 查看对象的所有方法
34 
35 print(divmod(5,2))   # 返回一个元组,元组的第一个元素是商,第二个元素是余数
36 
37 a = compile('input(">>>")', '', 'exec')   # 函数预编译
38 exec(a)
39 
40 print(float(20))    # 浮点型数据 20.0
41 
42 print(hash(123))  # 求对象的哈希值(哈希对象必须不可变数据类型)
43 
44 print(help(input))      # help查看一下对象的使用方法
45 
46 print(hex(33))           #  将10进制转换成16进制
47 
48 print(hex(33))           #  将10进制转换成16进制
49 
50 print(id('s'))             # 查看数据的内存地址
51 
52 print(input(">>>"))         # 获取用户输入的内容
53 
54 print(int('123'))                  # 将数据转换成整型
55 
56 print(isinstance([1,2,3],str))   #判断这个数据时什么类型
57 
58 iter                             # 判断是不是可迭代对象
59 
60 len()                              # 获取数据的长度
61 
62 list()                              # 转换成一个列表
63 
64 print(max(1,2,3,4,5))      # 求最大值
65 
66 print(min(1,2,3,4))        # 求最小值
67 
68 print(memoryview(b'a'))        # 查看字节的内存地址
69 
70 print(next())               # 迭代器中的取下一个值
71 
72 print(oct(9))                 # 将10进制转换成8进制
73 
74 print(ord('中'))     # 输入的是unicode编码的内容
75 print(chr(20013))    # 输入的是unicode的内容
76 
77 print(pow(2, 3))  # 两个参数的时候求幂运算
78 print(pow(2, 3, 1))    # 三个参数的时候先求幂运算再取余
79 
80 print('123')         # 是处理后给你显示的  123
81 print(repr('123'))   # 显示的是原数据  '123'
82 
83 print(list(reversed()))  # 反转 元组,列表,字符串
84 
85 print(round(5.672343212))   # 四舍六入五留双
86 print(round(5.472343212, 3))   # 四舍六入五留双  后面指定小数位数
87 
88 li = [1,2,3,4]
89 # s = slice(2)   # 切片
90 print(li[3])
91 
92 print(sum([1,2,3]))   # 求和(字典，元组，列表)
93 print(sum({1:4,2:5}))   # 字典求和，只取键作运算，且字典的键必须为数字
94 
95 print(vars(str))   #
96 
97 time = __import__('time')   # 导入的方式(内置方法)
98 import time           # __import__('time') == import time
View Code

　　2.2 常用方法：

　　 
  1 # globals() 方法：
  2 b = 1
  3 print(globals())  # 查看全局都哪些内容
  4 print(b)
  5 print(globals().get('b'))  # 查找全局变量b，如果找到返回b的值，否则则报错
  6 
  7 
  8 # locals() 方法：
  9 # (如果locals()在全局调用时，全局没有定义全局变量时，globals()与locals()获取的内容相同)
 10 def func():
 11     a = 1
 12     print(locals())  # 查看局部空间的内容
 13 
 14 func()
 15 
 16 
 17 
 18 's'.format()  # 字符串的格式化方法
 19 
 20 format() 函数方法：
 21 print(format('a','>10'))      # 公用函数  右对齐
 22 print(format('a','<10'))      # 公用函数  左对齐
 23 print(format('a','^10'))      # 公用函数  居中
 24 
 25 
 26 print(format(3,'08b'))  # 00000011   二进制
 27 print(format(3,'o'))    # 八进制
 28 print(format(3,'x'))    # 十六进制
 29 
 30 
 31 
 32 # eval()用法：
 33 s = '3 + 5'      # 将字符串中内容执行
 34 print(eval(s))   # 慎用
 35 
 36 
 37 # exec()用法：
 38 li = [1,23,4,]
 39 s = """
 40 def func():
 41     print(1)
 42 func()
 43 """
 44 g = exec(s)   # 执行已注释的函数(慎用)
 45 print(g)
 46 
 47 
 48 # enumerate 枚举用法：
 49 li = [1,2,3,4,5,6,7]
 50 for i,em in enumerate(li,1):  # enumerate不写值默认是0
 51     # enumerate  第一个参数是可迭代对象,第二参数是计数
 52     print(i,em)
 53 
 54 
 55 # zip() 用法：
 56 li = [1,2,3,4]
 57 ls = [5,6,7,4,5,6]
 58 lst = ['a','b','c','d','e']
 59 print(list(zip(li,ls,lst)))  # 拉链
 60 
 61 
 62 
 63 # 匿名函数lambda()使用：:
 64 
 65 # lambda 关键字  x参数:x是返回值
 66 # lambda 的返回值只能是一个
 67 print((lambda x:x)(5))
 68 
 69 # 示例：
 70 f = lambda x, y: x*y
 71 print(f.__name__)     # <lambda>
 72 print(f(5, 6))
 73 
 74 
 75 # sorted()使用：
 76 # 可迭代对象 key=指定排序方式 可以调整排序方式
 77 # 普通方法：
 78 li = ['你好啊','我好','大家都挺好']
 79 def func(li):
 80     return len(li)
 81 print(sorted(li,key=func))   # key指定一个排序的规则
 82 
 83 # lambda方法：
 84 print(sorted(li,key=lambda x:len(x)))
 85 
 86 
 87 
 88 # filter()使用：
 89 # 普通方法：
 90 li = [1,2,3,4]
 91 def func(a):
 92     if a > 2:
 93         return a
 94 print(list(filter(func, li)))
 95 
 96 # lambda方法：
 97 print(list(filter(lambda x:x>2, li)))
 98 
 99 
100 
101 # map()使用：
102 # 普通方法：
103 li = [1,2,3,4,5]
104 def func(i):
105     return i+10
106 print(list(map(func,li)))  # 映射 将每个元素进行同样的操作
107 
108 # lambda方法：
109 li = [1,2,3,4,5]
110 print(list(map(lambda x:x+10,li)))
111 
112 
113 
114 # reduce()使用：
115 from functools import reduce
116 
117 li = [1,2,3,4,5]
118 
119 def func(x,y):        # x=12345
120     return x*10+y     # reduce 做累计算
121 print(reduce(func,li))
122 
123 # lambda方法：
124 print(reduce(lambda x, y: x*10+y, li))
View Code

 　　2.3 内置函数与容器型数据操作方法比较：

　　　　python内置函数：

　　　　　　代表类型：sorted、reversed函数

　　　　　　内存方式：新建内存地址，生成一个新的容器型数据

　　　　　　sorted:生成一个新列表，reversed生成一个 list_reverseiterator

　　　　容器型数据类型：

　　　　　　代表类型：list.sort、list.reverse函数

　　　　　　内存方式：在原数据类型上做修改，节省内存

 

　　　　

　　　　　

posted @ 2019-03-23 16:54  Amorphous  阅读(198)  评论(0)  编辑  收藏  举报