python之函数名,闭包、迭代器

一、函数名的运用(第一类对象)

函数名是一个变量,但它是一个特殊的变量,与括号配合可以执行函数的变量。

1,函数名的内存地址:

  def func():
        print("呵呵")
    print(func)
    # 结果为:<function func at 0x00000000029299D8>   打印出func的内存地址

2,函数名可以赋值给其他变量:

def func():
        print("呵呵")

    a = func   # 把函数当成一个变量赋值给另一个变量
    a()    # 函数调用  func()

3,函数名可以当做容器类的元素:

def func1():
        print("呵呵")
    def func2():
        print("呵呵")
    def func3():
        print("呵呵")
    lst = [func1 , func2 , func3]
    for i in lst:
        i()

4,函数名可以当做函数的参数:

 def func():
        print("吃了么")

    def func2(fn):
        print("我是func2")
        fn()    # 执行传递过来的fn
        print("我是func2")

    func2(func)   # 把函数名func当成参数传递给func2的参数fn

5,函数名可以作为函数的返回值:

def func_1():
        print("这里是函数1")
        def func_2():
            print("这里是函数2")
        print("这里是函数1")
        return func_2
    fn = func_1()
    # 执行函数1,函数1返回的是函数2,这时fn指向的就是上面函数2
    # 结果为:
    # 这里是函数1
    # 这里是函数1
    fn()   # 执行上面返回的函数2
    # 结果为:
    # 这里是函数2

二、闭包

什么是闭包?闭包就是内层函数对外层函数(非全局)的变量的引用,如下示例:

 def func():
        a = 10
        def inner():
            print(a)    # 闭包
        inner()
    func()   # 结果为:10

我们可以用__closure__来检测函数是不是闭包,函数名.__closure__返回cell就是闭包,返回None就不是闭包。

def func():
        a = 10
        def inner():
            print(a)
        inner()
        print(inner.__closure__)  # (<cell at 0x00000000025875B8: int object at 0x0000000058E26D40>,)
    func()

问题:如何在函数外边调用内部函数呢?具体示例如下:

def outer():
        a = ‘hello‘
        # 内部函数
        def inner():
            print(a)
        return inner

    fn = outer()    # 访问外部函数,获取到内部函数的内存地址
    fn()   # 访问内部函数

那如果多层嵌套呢?很简单,只需要一层一层的往外层返回就行了,具体示例如下:

def func1():
        def func2():
            def func3():
                print("嘿嘿")
            return func3
        return func2
    func1()()()   # 执行func3,结果为:嘿嘿

由它我们可以引出闭包的好处,由于我们在外界可以访问内部函数,那这个时候内部函数访问的时间和时机就不一定了,因为在外部,我可以选择在任意的时间去访问内部函数,这个时候,想一想,我们之前说过,如果一个函数执行完毕,则这个函数中的变量以及局部命名空间中内容将会被销毁,在闭包中,如果变量被销毁了,那内部函数将不能正常执行,所以,python规定:如果你在内部函数中访问了外层函数中的变量,那么这个变量将不会消亡,将会常驻在内存中,也就是说,使用闭包,可以保证外层函数中的变量在内存中常驻。这样做有什么好处呢?有非常大的好处,下面来看一个简单的关于爬虫的代码:

 from urllib.request import urlopen

    def but():
        content = urlopen("http://www.xiaohua100.cn/index.html").read()
        def get_content():
            return content
        return get_content

    fn = but()  # 这个时候就开始加载校花100的内容
    # 后面需要用到这里面的内容就不需要再执行非常耗时的网络连接操作了
    content = fn()   # 获取内容
    print(content)

    content2 = fn()   # 重新获取内容
    print(content2)

综上可得:闭包的作用就是让一个变量能够常驻内存,供后面的程序使用。

三,迭代器

我们之前一直在用可迭代对象进行迭代操作,那么到底什么是可迭代对象?首先我们先回顾一下目前我们所熟知的可迭代对象有哪些,有str,list,tuple,dict,set,那为什么我们可以称它们为可迭代对象呢?因为它们都遵循了可迭代协议,什么是可迭代协议?首先我们看下面一段错误代码:

# 正确
    s = ‘abc‘
    for c in s:
        print(c)

    # 错误
    for i in 123:
        print(i)
    # 结果:
    # Traceback (most recent call last):
    #   File "E:/pythonDemo/1-basis/test10.py", line 107, in <module>
    #     for i in 123:
    # TypeError: ‘int‘ object is not iterable

注意看报错信息中有这样一句话:‘int‘ object is not iterable,翻译过来就是整数类型对象是不可迭代的,iterable表示可迭代的,表示可迭代协议,那么如何进行验证你的数据类型是否符合可迭代协议,我们可以通过dir函数来查看类中定义好的所有方法。具体示例如下:

s = "我的哈哈哈"
    print(dir(s))   # 可以打印对象中的方法和函数
    print(dir(str))   # 也可以打印类中声明的方法和函数

在打印结果中,寻找__iter__,如果能找到,那么这个类的对象就是一个可迭代对象。我们发现在字符串中可以找到__iter__,继续看一下list,tuple,dict,set,具体如下:

    print(dir(list))
    print(dir(tuple))
    print(dir(dict))
    print(dir(set))
    print(dir(open("test9.py")))   # 文件对象

我们发现这几个可以进行for循环的东西都有__iter__函数,包括range也有,可以自己试一下。

综上可知,通过寻找__iter__可以查看一个对象是否是可迭代对象,除此之外,我们还可以通过isinstence()函数来查看一个对象是什么类型的,具体示例如下:

ls = [1,2,3]
    ls_iter = ls.__iter__()   # 获取列表ls的迭代器
    from collections import Iterable
    from collections import Iterator
    print(isinstance(ls,Iterable))   #True  ls是可迭代对象的一个实例
    print(isinstance(ls,Iterator))    #False  ls不是迭代器的一个实例
    print(isinstance(ls_iter,Iterable))   #True  ls_iter是可迭代对象的一个实例
    print(isinstance(ls_iter,Iterator))   #True  ls_iter是迭代器的一个实例

综上,我们可以确定,如果对象中有__iter__函数,那么我们认为这个对象遵守了可迭代协议,就可以获取到相应的迭代器,上面代码中的__iter__就是帮我们获取到对象的迭代器,我们使用迭代器中的__next__()来获取到一个迭代器中的元素,那么我们之前讲的for循环的工作原理到底是什么呢?继续看下面代码:

s = "我爱北京天安门"
    c = s.__iter__()   # 获取迭代器
    print(c.__next__())   # 使用迭代器进行迭代,获取一个元素:我
    print(c.__next__())   # 爱
    print(c.__next__())   # 北
    print(c.__next__())   # 京
    print(c.__next__())   # 天
    print(c.__next__())   # 安
    print(c.__next__())   # 门
    print(c.__next__())   # StopIteration

for循环如下:

for i in [1,2,3]:
        print(i)

下面使用while循环+迭代器来模拟for循环(必须要掌握):

lst = [1,2,3]
    lst_iter = lst.__iter__()
    while 1:
        try:
            i = lst_iter.__next__()
            print(i)
        except StopIteration:
            break

总结:

Iterable:可迭代对象,内部包含__iter__()函数,不包含__next__()函数;

Iterator:迭代器,内部包含__iter__()函数,同时包含__next__()函数;

迭代器特点:

1,节省内存(下篇生成器中介绍);

2,惰性机制(遇到__next__才取一个);

3,不能反复,只能向下执行;

我们可以把要迭代的内容当成子弹,然后呢,获取到迭代器__iter__(),就把子弹都装在弹夹中,然后发射就是__next__()把每一个子弹(元素)打出来,也就是说,for循环的时候,一开始是__iter__()来获取迭代器,后面每次获取元素都是通过__next__()来完成的,当程序遇到StopIteration将结束循环。

原文地址:https://www.cnblogs.com/wxj1129549016/p/9459457.html

时间: 2024-10-10 04:18:53

python之函数名,闭包、迭代器的相关文章

python之路---11 第一类对象 函数名 闭包 迭代器

二十九. 1.函数名的运用    ①函数名是?个变量, 但它是?个特殊的变量, 与括号配合可以执?函数的变量 ②函数名是一个内存地址    ③ 函数名可以赋值给其他变量         ④函数名可以当做容器类的元素     ⑤函数名可以当做函数的参数     ⑥函数名可以作为函数的返回值 2.闭包 闭包就是内层函数, 对外层函数(非全局)的变量的引?. 标准的闭包   ①优点:1).可以保护变量不受侵害 2),保持一个变量常驻内存 ②    .__closure__    查看是否是闭包 返回

函数名 闭包 迭代器

函数名 函数名就是变量;  函数名可以作为参数进行传递 1. 函数名的内存地址 def func(): print("哈哈") print(func) #<function func at 0x01CDD4B0> 2. 函数名可以赋值给其他变量 def func(): print("呵呵") print(func) a = func #把函数当成变量 赋值给另一个变量 a() # 函数调用 func() 3. 函数名可以作为列表中的元素进行存储 def

python 11 函数名 迭代器

今日内容大纲 global nonlocal 函数名的运用 新特性:格式化输出 迭代器: 可迭代对象 获取对象的方法 判断一个对象是否是可迭代对象 小结 迭代器 迭代器的定义 判断一个对象是否是迭代器 迭代器的取值 可迭代对象如何转化成迭代器 while循环模拟for循环机制 小结 可迭代对象与迭代器的对比 昨日内容回顾以及作业讲解 函数的参数: 实参角度:位置参数,关键字参数,混合参数. 形参角度:位置参数,默认参数,仅限关键字参数,万能参数. 形参角度参数顺序:位置参数,*args, 默认参

11.Python初窥门径(函数名,可迭代对象,迭代器)

Python(函数名,可迭代对象,迭代器) 一.默认参数的坑 # 比较特殊,正常来说临时空间执行结束后应该删除,但在这里不是. def func(a,l=[]): l.append(a) return l print(func(1)) # [1] print(func(2)) # [1,2] print(func(3)) # [1,2,3] 二.函数名的应用 函数名指向的是函数的内存地址,加上()就执行这个函数 def func(args): return args print(func) #

python notice8 函数名应用和闭包

一.函数名的应用 函数名是一个特殊的变量,函数名配合括号(函数名())可以执行函数. 1.函数名的内存地址. def func(): print("呵呵") print(func) 结果: <function func at 0x1101e4ea0> 2.函数名可以赋值给其他变量,该变量配合括号即可调用函数. def func(): print("呵呵") a = func a() # 相当于调用func() 3.可以作为list的元素,for循环调用.

python动态函数名的研究

所谓动态函数名,就是使用时完全不知道是叫什么名字,可以由用户输入那种. 一般人习惯性会想到eval或exec, 但是众所周知,这样的写法不安全而且容易引起问题,而且不pythonic.而且使用时必须把函数定义写在动态函数名调用之前. def _phyCPU(): print "ok" values = ["_phyCPU"]#, "_proCPU", "_cpuModel"] for value in values: eval

python:返回函数,闭包

函数作为返回值 高阶函数除了可以接受函数作为参数外,还可以把函数作为结果值返回. 我们来实现一个可变参数的求和.通常情况下,求和的函数是这样定义的: def calc_sum(*args): ax = 0 for n in args: ax = ax + n return ax 但是,如果不需要立刻求和,而是在后面的代码中,根据需要再计算怎么办?可以不返回求和的结果,而是返回求和的函数: In [23]: def lazy_sum(l): ...: def sum(): ...: x=0 ...

python自动化--函数(闭包函数和装饰器)

闭包函数 闭包函数定义,定义在函数内部的函数,特点是:包含对外部作用域而不是对全局作用域名字的引用.该函数就称之为闭包函数. 简单装饰器实现 1,为什么要使用装饰器,开放封闭原则,对扩展是开放的,对修改是封闭的 2,什么是装饰器 用来装饰他人,装饰器本身可以是任意可调用对象,被装饰器的对象也可以是任意可调用对象 遵循的原则,1,不修改被装饰对象的源代码 2,不修改被装饰器对象的调用方式. 目标是: 在遵循原则1和2的前提,为被装饰器对象添加上新的功能. 原文地址:https://www.cnbl

go 匿名函数和闭包

匿名函数 1. 函数也是一种类型,因此可以定义作为一个函数类型的变量 package main import "fmt" // 函数作为参数 func add(a, b int) int { return a + b } func testfunc(a, b int, fun func(int, int) int) int { sum := fun(a, b) return sum } func main() { sum := testfunc(2, 3, add) fmt.Print