• 函数之使用详解


    函数对象

    # 函数名就是存放了函数的内存地址,存放了内存地址的变量都是对象,即 函数名 就是 函数对象
    
    # 函数对应的原因
    # 1 可以直接被引用
    # 2 可以当作函数参数传递
    # 3 可以作为函数的返回值
    # 4 可以作为容器类型的元素
    
    a = 10
    print(a)
    
    def fn():
        num = 10
        print('fn function run')
    
    print(fn)
    # 函数名存放的就是函数的地址,所以函数名也是对象,称之为函数对象
    
    b = a
    print(b)
    
    # 1 可以直接被引用
    func = fn
    print(func)
    fn()
    func()
    
    # 2 可以当作函数参数传递
    
    def add(a, b):
        return a + b
    def low(a, b):
        return a - b
    def jump(a, b):
        return a * b
    def full(a, b):
        return a / b
    
    # 计算: 通过该函数可以完成对任意两个数的四则运算某一运算
    def computed(fn, n1, n2):
        # fn代表四则运算中的一种
        # res为运算结果
        res = fn(n1, n2)
        return res
    
    # 完成两个数的某一运算,拿到结果
    
    while True:
        cmd = input('cmd:')
        if cmd == 'add':
            result = computed(add, 100, 20)
        elif cmd == 'low':
            result = computed(low, 100, 20)
        else:
            print('输入有误')
            break
        print(result)
        
    # 3 可以作为容器类型的元素
    def add(a, b):
        return a + b
    def low(a, b):
        return a - b
    def jump(a, b):
        return a * b
    def full(a, b):
        return a / b
    def quyu(a, b):
        return a % b
    def computed(fn, n1, n2):
        res = fn(n1, n2)
        return res
    method_map = {
        'add': add,
        'low': low,
        'jump': jump,
        'full': full,
        'quyu': quyu,
    }
    while True:
        cmd = input('cmd: ')
        # 用户输入的指令只要有对应关系,就会自动去走对应的计算方法
        # 这样外界就不能去关系到底有哪些计算方法
        if cmd in method_map:
            cp_fn = method_map[cmd]  # 拿到计算方法
            result = computed(cp_fn, 100, 20)  # 通过计算方法得到计算结果
            print(result)
        else:
            print('输入有误,退出')
            break
            
    # 4 可以作为函数的返回值
    def add(a, b):
        return a + b
    def low(a, b):
        return a - b
    def jump(a, b):
        return a * b
    def full(a, b):
        return a / b
    def quyu(a, b):
        return a % b
    def computed(fn, n1, n2):
        res = fn(n1, n2)
        return res
    method_map = {
        'add': add,
        'low': low,
        'jump': jump,
        'full': full,
        'quyu': quyu,
    }
    # 根据指令获取计算方法
    def get_cp_fn(cmd):
        if cmd in method_map:
            return method_map[cmd]
        return add  # 输入有误用默认方法处理
    
    
    while True:
        cmd = input('cmd: ')
        if cmd == 'quit':
            break
        cp_fn = get_cp_fn(cmd)
        result = computed(cp_fn, 100, 20)
        print(result)
    

    名称空间

    # 名称空间:存放名字与内存空间地址对应关系的容器
    # 作用:解决由于名字有限,导致名字重复发送冲突的问题
    
    # 三种名称空间
    # Built-in:内置名称空间;系统级,一个;随解释器执行而产生,解释器停止而销毁
    # Global:全局名称空间;文件级,多个;随所属文件加载而产生,文件运行完毕而销毁
    # Local:局部名称空间;函数级,多个;随所属函数执行而产生,函数执行完毕而销毁
    
    # 注:
    # del 名字:可以移除查找最近的名字与内存空间地址的对应关系
    # 加载顺序:Built-in > Global > Local
    print(len('abc'))
    
    len = len('abcdef')
    print(len)
    
    del len
    
    # del len
    
    print(len('000111222'))
    '''
    [
        # ['len': 100001]  # 保存长度的变量
        ['len': 200001]  # 计算长度的函数
    ]
    '''
    
    def fn1():
        len = 10
        print(len)
    
    def fn2():
        len = 20
        print(len)
    
    fn1()
    fn2()
    

    函数的嵌套定义

    # 理由:一个函数要使用另一个函数中的变量
    # global关键词
    part1
    print(len)
    
    len = 10
    
    def fn():
        len = 20
        print(len)
    
    fn()
    print(len)
    
    part2
    ls = []
    def fn1():
        ls = []
        ls.append(100)
        print(ls)
    fn1()
    print(ls)
    
    # 定义一个函数,函数中有一个变量
    def fn2():
        num = 20
        return num
    
    # 再定义一个函数,该函数要使用上一个函数中的变量
    def fn3():
        print(num)
    num = fn2()
    fn3()
    
    part3
    num = 10
    def fn2():
        global num  # 将Local:num => Global: num
        num = 20
        num = 30
    
    # Local的名字一旦global,就办成Global的名字,一个文件中的Global名字就是一个
    def fn3():
        global num  
        num = 40
        print(num)
    fn2()
    print(num)
    fn3()
    print(num)
    
    # 将函数直接定义到另一个函数内部,就可以使用外部函数的中的名字
    def fn4():
        num = 20
        def fn5():
            print(num)
        fn5()
    fn4()
    

    作用域

    # 作用域:名字起作用的范围
    # 作业:解决同名字可以共存问题
    
    # 四种作用域
    # Built-in:内置作用域
    # Global:全局作用域
    # Enclosing:嵌套作用域
    # Local:局部作用域
    
    # 注:
    # 不同作用域之间名字不冲突,以达到名字的重用
    # 查找顺序:Local > Enclosing > Global > Built-in
    # 作用域:名字起作用的范围
    # 作用:解决同名字可以共存问题
    len = 10
    def outer():
        len = 20  # 外层函数的局部变量:Enclosing - 嵌套作用域
        def inner():
            len = 30
            print('1:', len)  # inner -> outer -> global -> built-in
        inner()
        print('2:', len)  # outer -> global -> built-in
    outer()
    print('3:', len)  # global -> built-in
    
    del len
    print('4:', len)  # built-in
    

    闭包

    # closure:被包裹的函数,称之为闭包
    
    # 完整的闭包结构:1.将函数进行闭包处理;2.提升函数名的作用域
    # 闭包就是函数嵌套(格式稍作改良)
    
    # inner可以使用outer的局部变量:可以将inner定义在outer中
    # inner的调用还是在外部:inner函数对象能被outer返回
    
    # 将内部函数对象作为外部函数的返回值:1.可以使用局部变量; 2.不改变函数的调用位置
    def outer():
        num = 10
        def inner():  # 闭包:定义在函数内部的函数称之为闭包
            print(num)
        return inner
    fn = outer()  # fn = inner
    fn()
    
    # 案例一:外部函数可以为闭包传递参数 (了解)
    import time
    def download():
        print('开始下载')
        time.sleep(2)
        print('下载完成')
        data = "下载得到的数据"
        outer(data)
    # 为闭包传参
    def outer(data):
        def inner():
            # 保存,播放,删除等操作
            print("闭包打印:", data)
        inner()
    download()
    
    # 案例二:延迟执行
    import requests
    # get_html一执行就获取页面
    def get_html(url):
        html = requests.get(url)
        print(html.text)
    get_html('https://www.baidu.com')
    get_html('https://www.python.org')
    get_html('https://www.sina.com.cn')
    get_html('https://www.baidu.com')
    
    def outer(url):
        def get_html():
            html = requests.get(url)
            print(html.text)
        return get_html
    # 先预定义多个爬虫方法,爬页面操作并未执行
    baidu = outer('https://www.baidu.com')
    python = outer('https://www.python.org')
    sina = outer('https://www.sina.com.cn')
    # 什么时候想爬什么页面就调用指定页面的爬虫方法
    baidu()
    sina()
    baidu()
    
  • 相关阅读:
    算法训练 图形显示
    P1002 谁拿了最多奖学金
    java并发编程实战笔记---(第五章)基础构建模块
    java并发编程实战笔记---(第四章)对象的组合
    java并发编程实战笔记---(第三章)对象的共享
    java并发编程实战笔记---(第二章)线程安全:正确性
    栈溢出
    聊聊分布式事务
    路径问题
    apache 软件历史版本查询
  • 原文地址:https://www.cnblogs.com/fuwei8086/p/10638113.html
Copyright © 2020-2023  润新知