python函数参数指定一个类 python函数作为参数

 

 

1、函数可以作为参数

1）函数名相当于变量指向函数

2）函数名后面加括号表示调用函数

#!usr/bin/env python
# -*- coding:utf-8 -*-

def f1(args):
    print(args)
def f2(args):
    args('你好')
    print("hello")

#f1与变量的作用是相同的指向f1函数
#f1() 表示执行函数
f2(f1)  #打印出你好  hello

 3）内置函数filter()的实现方法

#!usr/bin/env python
# -*- coding:utf-8 -*-
def MyFilter(fun,sq):
    result = []
    for i in sq:
        bol = fun(i)
        if bol:
            result.append(i)
    return result

def f1(x):
    return x>30

r = MyFilter(f1,[11,22,33,44,55])
print(r)  #结果返回[33, 44, 55]

 4）内置函数map()的实现方法

#!usr/bin/env python
# -*- coding:utf-8 -*-
def MyMap(fun,seq):
    li = []
    for i in seq:
        li.append(fun(i))
    return li
def f1(x):
    return x+100

re = MyMap(f1,[11,22,33])
print(re) #打印输出[111, 122, 133]

 2、闭包

1）内层函数调用了外层函数的变量叫闭包，可以让一个局部变量常驻内存

def func():
    name = "sun"

    def inner():
        print(name) #内层函数调用了外层函数的变量叫闭包，可以让一个局部变量常驻内存

    return inner


fun = func()
fun() #结果返回sun,那么这个函数所用到的name,会常驻内存，当函数调用的时候直接返回

2）闭包的应用

from urllib.request import  urlopen
def but():
    content = urlopen("http://www.baidu.com").read()
    def inner():
        # 在函数中使用了外部变量，属于闭包，那么对inner函数来说content常驻内存，随用随取
        return content
    print(inner.__closure__) #如果返回内容则表示是闭包函数
    return inner

fn =but() #执行but函数，返回inner函数，并把inner返回给fn
con1 = fn() #调用inner函数，不再去加载网站
print(con1)
con2 = fn() #调用inner函数，不再去加载网站
print(con2)

 

内层函数调用了外层函数的变量叫闭包，可以让一个局部变量常驻内存

import time

def getNum():
    li = [i for i in range(100000000)]
    def inner():
        return li
    return inner

t0 = time.clock()

fun1 = getNum()
t1 = time.clock()
print(t1 - t0)

fun2 = fun1()
t2 = time.clock()
print(t2 - t1)

fun3 = fun1()
t3 = time.clock()
print(t3 - t2)

# 结果输出：
# 9.215686900000001
# 0.00221929999999837
# 3.0999999999892225e-

# 说明li生成后放到内存中后面调用函数直接去内存取数