python---------函数高级应用

#abs是函数本身 abs(-10)是函数调用，
# 函数名<==>变量 两者可以相互
f = abs
print(f(-1))
print(abs(-1))
print(abs)
print(f)
'''
    #把函数当作参数传递给其他函数 相当于是代理模式，将f函数实现之后传递给add函数,add函数本身是不管你是怎么实现的，add只负责执行
'''
def add(x,y,f):
    return f(x)+f(y)
print(add(1,-19,abs))

'''
    Python内置的map函数
    map()函数接收两个参数，一个是函数，一个是Iterable
    map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回
'''
l= [1,2,3,4,5,6,7,8,9]
def f(x):
    return x*x
m = map(f,l)
print(m)
#print(list(m)) 第一种打印 list函数可以将生成器对象强转成list列表
# for i in m:   第二种打印
#     print(i)
print(next(m))  #第三种打印
print(next(m))
print(next(m))

# l列表中每个int 转化成字符串
#str 函数的作用：返回一个对象的string格式。
l= [1,2,3,4,5,6,7,8,9]
l2=[]
print(list(map(str,l))) #方法1，
for i in l:             #方法2，
    l2.append(str(i))
print(l2)

'''
    reduce把一个函数作用在一个序列[x1, x2, x3, ...]上 ，reduce把结果继续和序列的下一个元素做累积计算
    reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
'''
from functools import reduce
l = [4,3,5,7,8,9]
def f(x,y):
    return x*10+y
print(reduce(f,l))

'''
    map和reduce两个函数联合调用
'''
#str() int()
# '1234'-->1234 1.字符串每个元素取出来，转换成对应的数字，得到一个数字序列
#2.通过数字序列每两个*10 相加，得到一个整数

str1='5632'
def charToNum(s):
    digits = {'0' :0,'1' :1,'2' :2, '3' :3,'4' :4,'5' :5,'6' :6,'7' :7,'8' :8,'9':9}
    return  digits[s] # 每次返回的都是字典中所对应的值

m = map(charToNum,str1)     #map()函数接收两个参数，一个是函数，一个是Iterable 将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回
nums = reduce(f,m)          #reduce函数接受一个序列 可以迭代的对象，将每个元素传递给f函数进行后期处理
print(nums)                 # 输出的是int类型的   5632

'''
    匿名函数(私有函数)  位置是 在函数中定义函数而不是在类中定义的 
    如果命名的时候使用的是大写进行命名 则认为这个变量是一个 “常量”
'''
DIGITS = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
def strToInt(s):
    def f(x, y):
        return x * 10 + y
    def charToNum(s):
        return DIGITS[s]  # 每次返回的都是字典中所对应的值
    return reduce(f,map(charToNum,s))

print(strToInt('789456'))

#上面的函数使用lambda函数 实现 lambda替换了函数f这样的话减少了代码的工作量
#lambda 表达式  lambda x,y:x*10+y
# lambda相当于是一个函数 比如可以使用：
#a = lambda x,y : x+y   print(a(1,2)) 输出的结果是3
def strToInt(s):
    def charToNum(s):
        return DIGITS[s]  # 每次返回的都是字典中所对应的值
    return reduce(lambda x,y:x*10+y,map(charToNum,s))

print(strToInt('789456'))


'''
    装饰器模式原理
    在代码运行期间动态增加功能的方式，称为“装饰器”（Decorator）
     @property
     @setter
     
'''
import datetime

#now是最开始的方法，这里就是对now函数开始进行装饰
import datetime


# 定义一个log的装饰器 以一个函数作为参数，并返回一个函数function,不是函数的执行function（）切记
def log(f):
    #定义了一个匿名函数，因为装饰器要返回一个函数，所以定义匿名函数是
    # 为了返回函数，这个匿名函数，包含两个功能，一个是打印时间，一个是打印日志
    def write_log(*args,**kwargs):  #刚开始的时候是不会执行的
        with open('./a.txt','w')as f1:#这样写不需要关闭，自动关闭close
            f1.write(f.__name__) #将当前函数的名字写入到a.txt中
            print('写入日志成功，函数名称是：%s'%f.__name__)
            return f(*args,**kwargs)    #相当于执行了now函数并返回
    return  write_log           #返回一个函数 而不是函数的执行 执行到这一行的时候，就会去执行上面定义的def write_log(*args,**kwargs):了只会执行一次，

@log
def now():
    print(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S' ))


'''
    调用方式一 ：反人类调用
    ff=log(now)     #以now作为参数，返回ff
    ff()            #执行返回的函数 ff相当于是write_log方法
    调用方式一二：在调用的函数上添加 @装饰器函数名称就可以了
'''
now()

'''
    Python内置的装饰器 @property @setter
'''
class Student(object):
    def __init__(self,score):
        self.__score = score

    #加上装饰器 @property，方法变属性
    @property
    def score(self):
        return self.__score
    #属性.setter
    @score.setter
    def score(self, value) :
        if not isinstance(value, int) :
            raise ValueError('score must be an integer!')
        if value < 0 or value > 100:
            raise ValueError( 'score must between 0 ~ 100!')
        self.__score = value

stu1 = Student(90)
stu1.score=59
print(stu1.score)



'''
    ---------------------------------------------------------------------------------------------------练习----------------------------------------------------------------------------------
'''


'''
    将输入的字符串的首字母大写，其余字母小写
    ['MIKE', 'Adidas', 'coffee']，输出：
    ['Mike', 'Adidas', 'Coffee']：
    Python capitalize()将字符串的第一个字母变成大写,其他字母变小写。对于 8 位字节编码需要根据本地环境。
'''
def normalize(name):
    return name.capitalize()
L1 = ['MIKE', 'Adidas', 'coffee','在是']
L2 = list(map(normalize, L1))
print(map(normalize, L1))
print(L2)


'''
一个装饰器，它可以作用于任何函数上，打印函数执行时间
'''
import time
import datetime
def metric(f):
    #定义了一个匿名函数，因为装饰器要返回一个函数，所以定义匿名函数是
    # 为了返回，这个匿名函数，
    def exe_time(*args,**kwargs):  #刚开始的时候是不会执行的
        t1 = time.time()#开始时间
        f(*args, **kwargs)
        t2 = time.time()#结束时间
        print('函数名称:{},执行时间{}'.format(f.__name__,t2-t1))
        return t2-t1    #相当于执行了now函数并返回
    return  exe_time           #返回一个函数 而不是函数的执行 执行到这一行的时候，就会去执行上面定义的def write_log(*args,**kwargs):了只会执行一次，
@metric
def test():
    for i in range(10000):
        print(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
test()