day12 python函数名的应用 闭包 迭代器

day12 python

 

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

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

    函数名其实就是变量名

def func():

    print('i am function')

print(func)         #是函数本身, 是一个内存地址

a = func            #变量可赋值, 函数名也可以

a()

func = 6            #函数名就是变量

print(func)

a = 10

b = 20

c = 30

lst = [a, b, c]     #变量可以作为元素加到列表里

print(lst)

 

def func1():

    print('in func1')

def func2():

    print('in func2')

def func3():

    print('in func3')

lst = [func1, func2, func3]     #函数名和变量一样也可以放到列表里, 说明函数是变量名

print(lst)

for el in lst:

    el()

    

    函数名可以作为参数传递给函数

def eat():

    print('eat some thing')

def func(fn):

    fn()

func(eat)

    

    可以作为返回值

def func():

    print('in func')

    a = 10

    def inner():

        print('in inner')

    return inner                #和变量一样可作为返回值, 返回函数名(即函数的内存地址)

 

rst = func()

rst()                           #或写为 func()()

 

二.闭包

    特点: 在内层函数中访问外层函数的变量

    作用: 1. 可以保护你的变量不受侵害(因为全局变量不安全, 因为谁的函数的global都可以改)

def outer():

    a = 10      #作用1.变量安全,只有函数 outer 里面可以改, 对外界的函数不开放

    def inner():

        print(a)

    inner()

outer()

    

    作用: 2. 可以让一个变量常驻内存

def outer():

    a = 10          #作用: 2.常驻内存, 为了inner执行的时候有值

    def inner():

        print(a)

    return inner

inner = outer()

inner()             #作用: 2.因为inner是在outer函数外面执行的, 什么时间执行不确定, 所以要求a要常驻内存

    

    超简易爬虫: 利用闭包把爬取到的内容常驻内存

from urllib.request import urlopen

 

def outer():

    s = urlopen('https://pythonav.com/index/').read()        #后端爬虫, (还有一种前端爬虫)

    def inner():

        print(s)

    return inner

 

rst = outer()

rst()    #第一次耗时

rst()    #第二次直接从内存取

 

#outer()()

#outer()()

#outer()()    #这样写每次都要进行 url 的请求, 是毛用都没有的

    

    __closure__ 判断一个函数是否是闭包

def func():

    a = 10

    def inner():

        print(a)

    print(inner.__closure__)        #如果不是闭包None; 如果是闭包会有一坨东西

func()

 

三.迭代器

    是通用的遍历对象的方式

        1.节省内存

        2.惰性机制

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

        4.for循环的内部就是迭代器

 

    dir() 查看对象里面有什么方法, 什么函数(打印出来, 先是带__的, 后是不带的)

print(dir(str))

print(dir(list))

    

    __iter__() 获取当前对象的迭代器, 可以用for循环, 可迭代对象

s = 'bajieai'

it = s.__iter__()   #获取迭代器

print(it)

>>>str_iterator object at 0x0000019B2E778EF0

 

print(dir(it))      #迭代器里面有 __iter__ 和 __next__

print(it.__next__())    #1. 只能向前

print(it.__next__())    #2. 几乎不占内存(明天生成器讲原因)

print(it.__next__())    #3. for循环

print(it.__next__())

print(it.__next__())    #当取完,数据, 会抛出异常StopIteration

    

    用迭代器模拟for循环

lst = ['bajie','wukong','datang','xiyu']

for el in lst:      #底层用的是迭代器

    print(el)

 

lst = ['bajie','wukong','datang','xiyu']

it = lst.__iter__()     #先拿到迭代器

while True:

    try:

        el = it.__next__()  #获取下一个元素

        print(el)

    except StopIteration:

        break

    

    用dir(), 判断数据是否是可迭代的, 是否是迭代器(野路子)

lst = ['bajie', 'wukong', 'datang']

print('__iter__' in dir(lst))       #True

print('__next__' in dir(lst))       #False      lst是可迭代的

 

it = lst.__iter__()

print('__iter__' in dir(it))        #True

print('__next__' in dir(it))        #True       it是迭代器

    

    isinstance(), 判断一个对象是不是Iterator或Iterable类的实例: 判断数据是否是可迭代的, 是否是迭代器(正规的)

from collections import Iterable

from collections import Iterator

 

lst = ['bajie', 'wukong', 'datang']

it = lst.__iter__()

 

print(isinstance(lst, Iterable))    #True

print(isinstance(lst, Iterator))    #False

print(isinstance(it, Iterable))     #True

print(isinstance(it, Iterator))     #True

 

 

 

    练习:

        sum()函数

print(sum((5,6,7)))         #求和, 参数是可迭代的

        reture 和 print()函数

a = print('bajie')       #print打印bajie, 但是不返回任何东西

print(a)                 #所以 a 是None

        max() min()函数

print(max(3,4,5))

print(min(3,4,5))

    求阶乘 如(7*6*5*4*3*2*1)

def func(num):

    sumn = 1

    for i in range(num, 0, -1):

        sumn *= i

    return sumn

print(func(7))

    笛卡尔积 (两个for嵌套)

def func():

    hua = ['hong','hei','hua','pian']

    dian = [2,3,4,5,6,7,8,9,10,'J','Q','K','A']

    rst = []

 

    for h in hua:

        for d in dian:

            rst.append((h, d))

    return rst

 

print(func())

        默认值参数: 可变时

def func(var, lst=[]):      #当默认值参数是可变的类型, 下次用默认值时,使用的是旧的内存空间, 不会分配新的内存空间

    lst.append(var)

    return lst

print(func(10))

print(func(123, []))

print(func('abc'))

        99乘法表

def func(num=9):

    for i in range(1, num+1):

        for j in range(1, i+1):

            print('%sx%s=%s' % (i, j, i*j), end=' ')

        print()

func()