【Finish】Python Day 11

# 写函数，检查获取传入列表或元祖对象的所有奇数位所有奇数位所有对应的元素，并将其作为新列表返回调用者
# def func(l):
#     return l[1::2]
# print(func((1,2,3,4,5)))

# 写函数，判断用户传入的对象（字符串、列表、元祖）长度是否大于5
# def func(l):
#     return len(l)>5
# print(func('abcd'))

# 写函数，检查传入的列表长度，如果>2，那么保留前2个长度的内容，并将新内容返回给调用者
# def func(l):
#     if len(l)>2:
#         return l[:2]
# print(func([1,2,3,4,5]))

# 写函数，计算传入字符串中 数字、字母、空格、以及其他的个数，并返回结果
# def func(l):
#     dic = {'number':0,'alpha':0,'space':0,'other':0}
#     for i in l:
#         if i.isdigit():
#             dic['number'] += 1
#         elif i.isalpha():
#             dic['alpha'] += 1
#         elif i.isspace():
#             dic['space'] += 1
#         else:
#             dic['other'] += 1
#     return dic
# print(func('123sfdf wqere '))

# 写函数，检查用户传入的对象（字符串、列表、元祖）的每一个元素是否含有空内容，并返回结果
# def func(l):
#     if type(l) is str and l:  # 参数是字符串
#         for i in l:
#             if i == ' ':
#                 return l
#     elif l and type(l) is list or type(l) is tuple:  # 参数是列表或者元祖
#         for i in l:
#             if not i:
#                 return l
#     elif not l:
#         return l
# print(func(''))

# 写函数，检查传入字典的每一个value的长度，如果大于2，那么仅保留前2个长度的内容，并将内容返回给调用者
# def func(l):
#     for k in l:
#         if len(l[k])>2:
#             l[k] = l[k][0:2]
#     return l
#
# print(func( {'k1':'dfew','k2':'1dff'} ))

# 写函数，接收2个数字参数，返回比较大的那个数字
# def func(a,b):
#     if a>b:
#         return a
#     elif a<b:
#         return b
#     else:
#         return a
# print(func(2,2))

# # 三元运算：必须要有结果；必须要有if和else；只能是简单的情况
# a = 1
# b = 5
# c = a if a>b else b # 变量 = 条件返回True的结果 if 条件 else 条件返回 False的结果
# print(c)

# 写函数，用户传入修改的文件名，与要修改的内容，执行函数，完成整个文件的批量修改操作（进阶）
# def func(filename,old,new):
#     with open(filename,'r+',encoding='UTF-8')as f,open('%s.txt' % filename,'w',encoding='UTF-8') as f2:
#         for line in f:
#             if old in line:
#                 line = line.replace(old,new)
#             f2.write(line)
#
#     # 删除文件和重命名文件
#     import os
#     os.remove(filename) # 删除文件
#     os.rename('%s.txt' % filename,filename) # 重命名文件
# func('log.txt','哈哈','么么哒')

# 装饰器：最简单的装饰器 有返回值的 有一个参数 万能参数
# 装饰器的作用
# 原则：开放封闭原则
# 装饰器的固定模式
# 语法糖：@


# import time
#
# def func():
#     time.sleep(1)
#     print('大家好')
#
# def timmer(f):    # 装饰器函数
#     def inner():
#         start = time.time()
#         f()   # 被装饰的函数
#         end = time.time()
#         print(end-start)
#     return inner
#
# ff = timmer(func)
# ff()

# 不修改函数的调用方式，单是还想在原来的函数前后添加功能，timmer 就是一个装饰器函数，只是对一个函数 有一些装饰作用
# 原则：开放封闭原则 ——> 开放（对扩展是开放的），封闭（对修改是封闭的）

# import time
#
# # 装饰带参数函数的装饰器
# def timmer(f):    # 装饰器函数
#     def inner(*args,**kwargs):
#         start = time.time()
#         ret = f(*args,**kwargs)   # 被装饰的函数
#         end = time.time()
#         print(end-start)
#         return ret
#     return inner
#
# @timmer # 语法糖 @装饰器函数名
# def func(a,b): # 被装饰的函数
#     time.sleep(1)
#     print('hello world ',a,b)
#     return '新年好'
# f = func(1,b=6)
# print(f)

# def outer():
#     def inner():
#         return 'inner'
#     inner()
# print(outer())

#
# import time
# # 装饰带参数函数的装饰器
# def wrapper(f):    # 装饰器函数，f是被装饰的函数
#     def inner(*args,**kwargs):
#
#         ''' 在被装饰函数之前要做的事 '''
#         ret = f(*args,**kwargs)   # 被装饰的函数
#         ''' 在被装饰函数之后要做的事 '''
#         return ret
#     return inner
#
# @wrapper # 语法糖 @装饰器函数名
# def func(a,b): # 被装饰的函数
#     time.sleep(1)
#     print('hello world ',a,b)
#     return '新年好'
# f = func(1,b=6)
# print(f)

# 装饰器固定模式
def wrapper(func):  # testqa
    def inner(*args,**kwargs):
        ret = func(*args,**kwargs)  # 被装饰的函数
        return ret
    return inner

@wrapper    # testqa = wrapper(testqa)
def testqa():
    print(123)
testqa()    # inner