内置函数+装饰器day5

一.一个函数自己调用自己的就是递归调用，最多调用999次

1.必须有一个明确的结束条件

2.每次递归的时候，减少循环次数

3.递归效率不高，少用递归

def hello():
    print('hello ')
    hello()

hello()

　　

二.高阶函数

1.如果一个函数的入参是一个函数名的话，那么这个函数就是高阶函数

2.函数既变量，

def hello(name):
    print(name)

new_hello = hello

new_hello('hahah')

　　

def add(x,y,z):
    res = z(x)+z(y)
    return res

print(add(98,100,int))

三.装饰器

作用是在不改变原有韩束的条用方式，入参的情况下，给函数添加新功能

偷偷摸摸的给函数加上新功能，到那时不改变原来的函数

1.函数里面也可以嵌套的定义一个函数

def warpper():
    print('hahah')
    def deco():
        print('你好啊')
        def hh():
            print('你好')
        hh()
    deco()

warpper()

2.函数的作用域，就近原则获取，如果自己的函数里面没有的话，就去它父级函数里面找.　　

函数只有被调用才能执行

name = 'python'
def warpper():
    name='黄牛'
    def deco():
        name ='大黄牛'
        print('我在里面%s'%name)
        def hhh():
            name = '小黄牛'
            print('xxx%s'%name)
        hhh()
    deco()
    print('外面的name是%s'%name)
warpper()

3.装饰器说白就是函数嵌套+高阶函数　

import time
def run():
    print('run...')
    time.sleep(1)
start_time = time.time()
run()
end_time = time.time()
print('run函数运行是%.2f'%(end_time-start_time))

import time
def run():
    print('run...')
    time.sleep(1)
def rum_time(func):
    start_time = time.time()
    func()
    end_time = time.time()
    print('run函数运行是%.2f'%(end_time-start_time))
    
rum_time(run)

　　

四.内置函数

判断可迭代的对象的值为真

print(all([1,2,3,4]))#判断可迭代的对象里面的值是否都为真        
 print(any([0,1,2,3,4]))#判断可迭代的对象里面的值是否有一个为真
 print(bin(10))#十进制转二进制
 print(bool('s'))#把一个对象转换成布尔类型
 print(callable('aa'))#判断传入的对象是否可调用
 print(chr(10))#打印数字对应的ascii
 print(ord('b'))#打印字符串对应的ascii码
 print(dict(a=1,b=2))#转换字典
 print(dir(1))#打印传入对象的可调用方法
 print(eval('[]'))#执行python代码，只能执行简单的，定义数据类型和运算
 print(exec('def a():pass'))#执行python代码
 def func(num):

    return num

print(list(filter(func,[1, 2, 3, 4])))#根据前面的函数处理逻辑，依次处理后面可迭代对象里面的每个元素，返回true 保存 map(func,[1,2,3,4])#根据前面的函数处理逻辑，依次处理后面可迭代对象里面的每个元素，保存前面函数返回的所有结 果 
  print(globals())#返回程序内所有的变量，返回的是一个字典，函数的局部变量不会返回

  print(locals())#返回局部变量
  print(hex(111))#数字转成16进制
  print(max(111,12))#取最大值
  print(oct(111))#把数字转换成8进制
  print(round(11.11,2))#取几位小数
  print(sorted([2,31,34,6,1,23,4]))#排序
  dic={1:2,3:4,5:6,7:8}
  print(sorted(dic.items()))#按照字典的key排序
  print(sorted(dic.items(),key=lambda x:x[1]))#按照字典的value排序
  __import__('decorator')#导入一个模块
from 文件名 import 函数 #

improt sys #引用环境变量
print(sys.path)#查看环境变量

import sys
sys.path.append(r'd:')#r代表转义   加入环境变量

　　

　　

 print(all([1,2,3,4]))#判断可迭代的对象里面的值是否都为真        

        print(any([0,1,2,3,4]))#判断可迭代的对象里面的值是否有一个为真

        print(bin(10))#十进制转二进制

        print(bool('s'))#把一个对象转换成布尔类型

        print(callable('aa'))#判断传入的对象是否可调用

        print(chr(10))#打印数字对应的ascii

        print(ord('b'))#打印字符串对应的ascii码

        print(dict(a=1,b=2))#转换字典

        print(dir(1))#打印传入对象的可调用方法

        print(eval('[]'))#执行python代码，只能执行简单的，定义数据类型和运算

        print(exec('def a():pass'))#执行python代码

 

 

1	filter(func,[1,2,3,4])#根据前面的函数处理逻辑，依次处理后面可迭代对象里面的每个元素，返回true保存

 

 

1 2 3 4 5 6 7 8 9 10 11

map(func,[1,2,3,4])<span style="font-family:'sans serif', tahoma, verdana, helvetica;line-height:1.5;">#根据前面的函数处理逻辑，依次处理后面可迭代对象里面的每个元素，保存前面函数返回的所有结果 </span>        print(globals())#返回程序内所有的变量，返回的是一个字典         print(locals())#返回局部变量         print(hex(111))#数字转成16进制         print(max(111,12))#取最大值         print(oct(111))#把数字转换成8进制         print(round(11.11,2))#取几位小数         print(sorted([2,31,34,6,1,23,4]))#排序         dic={1:2,3:4,5:6,7:8}         print(sorted(dic.items()))#按照字典的key排序         print(sorted(dic.items(),key=lambda x:x[1]))#按照字典的value排序         __import__('decorator')#导入一个模块