当前位置: 澳门新濠3559 > 编程 > 正文

【澳门新濠3559】  函数名其实就是变量名, 

时间:2019-11-21 05:33来源:编程
1.函数名的应用(第一类对象) 函数名的命名规范和变量是一样的 函数名其实就是变量名 1.可以作为列表中的元素进行存储 1 def func1():2 pass3 def func2():4 pass5 lst = [func1,func2]6 for el in lst

1.函数名的应用(第一类对象)

  函数名的命名规范和变量是一样的

  函数名其实就是变量名

  1.可以作为列表中的元素进行存储

    

1 def func1():
2     pass
3 def func2():
4     pass
5 lst = [func1,func2]
6 for el in lst:
7     el()

  2.可以作为参数传递给函数

 

1 def fun():
2     pass
3 def proxy(fn):
4     fn()
5 proxy(func)

  3.可以作为函数的返回值

1 def fun():
2     def inner():
3         pass
4     return inner
5 fun()()

第一类对象

迭代器

2.闭包

闭包:在内层函数中访问外层函数的局部变量

好处:

  1.保护你的变量不受外界影响

  2.可以让变量常驻内存

  3.写法:

    

1 def outer():
2     a =  10
3     def inner():
4         print(a)
5     return inner

函数对象对象可以像变量一样进行赋值

  1.函数名的运用

      函数名是一个特殊的变量,与括号搭配可以调用函数

      1.函数名的内存地址

      澳门新濠3559 1

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

      澳门新濠3559 2

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

      澳门新濠3559 3

      4.函数名可以当做函数的参数

      澳门新濠3559 4

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

      澳门新濠3559 5

3.迭代器

使用dir来查看该数据包含了哪些方法

1 print(dir(str))#有__iter__
2 print(dir(int))#没有__iter__
3 print(dir(list))#有__iter__

4 print(dir(tuple))#有__iter__

 

用来遍历字符串,列表,元组...等可迭代对象

可迭代对象:iterable,里面有__iter__()可以获取迭代器,没有__next__()

迭代器:iterator,里面有__iter__()可以获取迭代器,有__next__()

所有的带__iter__可以使用for循环,是可迭代对象

可迭代对象可以使用__iter__()来获取迭代器,迭代器里面有__next__()

迭代器的特点:

  1.只能向前

  2.惰性机制

  3.省内存(生成器)

迭代器模拟for循环:

  

 1 lst = [1,2,3,4,5]
 2 for el in lst:
 3     print(el)
 4 
 5 lst = [1,2,3,4,5]
 6 it = lst.__iter__()#获取迭代器
 7 while 1:
 8     try:#尝试执行
 9         el = it.__next__()
10         print(el)
11     except StopIteration:#处理错误
12         break

 

通过dir来判断数据是否是可迭代的,以及数据是否是迭代器

1 print("__iter__" in dir(it))
2 print("__next__" in dir(it))

通过isinstance()来判断

1 from collections inport Iterable#可迭代对象
2 from collections import Iterator#迭代器
3 
4 
5 print(isstance(lst,Iterable))
6 print(isstance(lst,Iterator))

把参数放在list()里面进行迭代

1 lst = [1,2,3,4,5]
2 it = lst.__iter__()
3 s = list(it)
4 print(s)

结果为[1,2,3,4,5]

for 循环的内部机制:

  1.首先获取到迭代器

  2.使用while循环获取数据

  3.it.__next__()来获取数据

  4.处理异常  tyr:xxx  except StopIteration:xxx

  

1 it = xx.__iter__()
2 while 1:
3     try:
4         data = it.__next__()
5         xxx
6     except StopIteration:
7         break

 

还可以作为列表的元素进行使用

  2.闭包

    闭包:内层函数对外层函数变量的引用

    

1 def func1():    2 name = "alex"    3     def func2():        4         print     # 闭包    5     func2() 6 func1() 7 结果: alex    

    我们可以使用__closure__来检测函数是否是闭包. 使⽤用函数名.__closure__返回cell就是闭包. 返回None就不是闭包.
    在函数外边调用内部函数,只需使用return返回即可。

     闭包的好处:使用闭包,可以保证外层函数的变量在内存中常驻,供后面的程序使用。

可以作为返回值返回

  3.迭代器

    查看是否为可迭代对象,第一种办法,使用dir判断是否有__iter__()。

    澳门新濠3559 6

      如果对象中有__iter__函数. 那么我们认为这个对象遵守了可迭代协议. 就可以获取到相应的迭代器. 这⾥的__iter__是帮助我们获取到对象的迭代器. 我们使⽤迭代 器中的__next__()来获取到⼀一个迭代器中的元素.

      澳门新濠3559 7

      使用while循环+迭代器来模拟for循环

      澳门新濠3559 8

      总结:

      lterable:可迭代对象,内部包含__iter__()含糊

      lterator:迭代器。内部包含__iter()__同时包含__next__()

      迭代器的特点:

        1.节省内存

        2.惰性机制

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

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

可以作为参数进行传递

生成器和表达式

def wrapper():    def inner():        print("alex")    return inner  # 可以返回函数名ret = wrapper  # 在函数外访问函数内的函数

  1.生成器

      生成器实质就是迭代器。

      在python中有三种方式来获取生成器:

      1.通过生成器函数

      2.通过各种推导式来实现生成器。

      3.通过数据的转换也可以获取生成器。

      澳门新濠3559 9

      澳门新濠3559 10

      如果函数中存在了yield,那么这个函数就是个生成器函数。这个时候,我们在执行这个函数,就是在获取这个生成器了。

      澳门新濠3559 11

      注意:当程序运行完最后一个yield后,那么后面继续进行__next__()程序则会报错。

      send方法, send和__next__()一样都可以让生成器执⾏到下⼀个yield。     

      send和__next__()区别:

        1. send和next()都是让生成器向下走一次

        2. send可以给上⼀个yield的位置传递值, 不能给后一个yield发送值. 在第⼀次执行⽣成器代码的时候不能⽤用send()

      生成器可以用for循环来获取内部元素。

      澳门新濠3559 12

闭包

  2.列表推导式,生成器表达式以及其他推导式

      列表推导式:通过一行来构建你要的列表,

lst = [i for i in range]

      还可以对数据进行筛选:

      澳门新濠3559 13

      生成器表达式跟列表推导式的语法基本一样,只是[ ]换成()

      澳门新濠3559 14

      生成器表达式和列表推导式的区别:

        1.列表推导式比较耗内存,一次性加载。生成器表达式基本上不占内存,使用的时候分配和使用内存

        2.得到的值不一样,列表推导式得到了一个列表,生成器表达式得到了一个生成器。

        注意:生成器的惰性机制,只有在访问的时候取值。

        澳门新濠3559 15

      字典推导式:

澳门新濠3559 16

      集合推导式:生成一个集合。

      总结: 推导式有, 列表推导式, 字典推导式, 集合推导式, 没有元组推导式

        ⽣成器表达式: (结果 for 变量量 in 可迭代对象 if 条件筛选)

        生成器表达式可以直接获取到生成器对象. 生成器对象可以直接进行for循环. ⽣成器具有惰性机制.

 闭包

内层函数对外层函数中的变量的使用

好处:

  1. 保护变量不被侵害

  2. 让一个变量常驻内存

    如何通过代码查看一个闭包

    __closure__: 有东西就是闭包. 没东西就不是闭包

    def wrapper(): name = "peter" def inner(): print print(inner.closure) #是闭包# 查看是否是闭包. 有内容就是闭包, 没有内容就不是闭包 inner()wrapper()

迭代器

 固定的思路: for循环

一个数据类型中包含了__iter__函数表示这个数据是可迭代的

dir: 返回这个数据可以执行的所有操作

print("__iter__" in dir # 是Trueit = lst.__iter__()  # 拿到的是迭代器 <list_iterator object at 0x0000000001DCC160>

判断迭代器和可迭代对象的方案

__iter__ 可迭代的

__iter__ __next__ 迭代器

判断迭代器和可迭代对象的方案

from collections import Iterable, Iterator

isinstance(对象, Iterable) 是否是可迭代的

isinstance(对象, Iterator) 是否是迭代器

lst = ["a","b","c"]print(isinstance(lst, Iterable)) # xxx是否是xxx类型的. Trueprint(isinstance(lst, Iterator)) # Falseit = lst.__iter__()  # 迭代器一定可迭代,  可迭代的东西不一定是迭代器print(isinstance(it, Iterable)) # xxx是否是xxx类型的. Trueprint(isinstance(it, Iterator)) # True

模拟for循环

lst= ["a","b","c"]it = lst.__iter__()# 拿迭代器while 1:    try:        it.__next__()    except StopIteration:        break

特征:

  1. 省内存

  2. 惰性机制

  3. 只能向前. 不能后退

    作用:

   统一了各种数据类型的遍历

编辑:编程 本文来源:【澳门新濠3559】  函数名其实就是变量名, 

关键词: