率先类对象,函数名的行使以及第二类对象www.

2019-05-03 22:25 来源:未知

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

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

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

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

 

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

def func1():
    pass
def func2():
    pass
lst = [func1, func2]
for el in lst:
    el()

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

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

def func():
    pass
def proxy(fn):
    fn()
proxy(func)

 

可以作为返回值返回

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

def func():
    def inner():
        pass
    return inner
func()()

可以作为参数进行传递

  4.函数名的内存地址

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

结果为:
<function func at 0x0000022951B03E18>
def wrapper():    def inner():        print("alex")    return inner  # 可以返回函数名ret = wrapper  # 在函数外访问函数内的函数

二丶闭包

闭包

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

 闭包

    好处:

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

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

好处:

      2.可以让变量常驻内存

  1. 保护变量不被侵害

  2. 让一个变量常驻内存

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

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

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

    写法:

def outer():
    a = 10
    def inner():
        print(a)
    return inner

 

迭代器

    如何判断是不是闭包,可以用__closure__来检测函数是否是闭包,使用函数名__closure__返回cell就是闭包,返回None就不是闭包

def func1():
    name = "alex"
    def func2():
        print(name)
    func2()
    print(func2.__closure__) #(<cell at 0x0000023BA6A6B498: str object at 0x0000023BA6AFA7A0>,)
func1()

 

 

 固定的思路: for循环

三丶迭代器

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

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

#对的
s = "abc"
for c in s:
    print(c)

#错的
for i in 123:
    print(i)

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

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

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

 

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

   在打印结果中,寻找 __iter__如果能找到,那么这个类的对象就是一个可迭代对象. 

www.weide1946.com 1

  

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

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

__iter__ 可迭代的

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

 

__iter__ __next__ 迭代器

    迭代器特点:

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

      1.只能向前

from collections import Iterable, Iterator

      2.惰性机制

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

      3.省内存(生成器)

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循环的内部机制.

模拟for循环

      1.首先获取到迭代器

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

      2.使用while循环获取数据

特征:

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

  1. 省内存

  2. 惰性机制

  3. 只能向前. 不能后退

    作用:

      4.处理异常  try:XXXX  except StopIteration:

 

it = xx.__iter__()
while 1:
    try:
        data = it.__next__()
        xxxx
    except StopIteration:
        break

 

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

版权声明:本文由韦德娱乐1946_韦德娱乐1946网页版|韦德国际1946官网发布于网络编程,转载请注明出处:率先类对象,函数名的行使以及第二类对象www.