python第十三课

#函数 --2天
    #函数的定义和调用
    #def 函数名(形参)
        #函数体
        #return返回值
    #调用 函数名(实参)
    #站在形参的角度上:位置参数,*args,默认参数(陷阱),**kwargs
    #站在实参的角度上:按位置传,按照关键字传
    #返回值:没有返回值 返回一个值 返回多个值
    #接收返回值:没有返回值不接收,返回一个值作一个变量接收,返回多个值用一个变量或者对应数目变量接收
#闭包函数 --在内部函数引用外部函数的变量
#装饰器函数 --装饰器一定是闭包函数
    #装饰器的作用 --在不改变原来函数的调用方式的情况下,在这个函数前后添加新的功能
    #完美的符合了一个开发原则:开放封闭原则
        #对扩展是开发的
        #对修改是封闭的
    #基础的装饰器
        # from functools import wraps
        # def wrapper(func):
        #     @wraps(func)
        #     def inner(*args,**kwargs):
        #         '''在函数被调用之前添加的代码'''
        #         ret=func(*args,**kwargs) #func是被装饰的函数,在这里被调用
        #         return ret
        #     return inner
        # 使用---@wrapper
        # def func(): #inner
         #     pass
        #func name
       # 带参数的装饰器
    def outer(形参):
        def wrapper(func):
            def inner(*args,**kwargs):
                '''在函数被调用之前添加的代码'''
                ret=func(*args,**kwargs) #func是被装饰的函数,在这里被调用
            #    '''在函数被调用之前添加的代码'''
                return ret
            return inner
        return wrapper
        @outer(True)
        def func():
            pass

#迭代器和生成器--两天

#迭代器
l=[1,2,3]
#索引
#循环 for
#for i in l:
#   i
#
# for k in dic:
#     pass

#enumerate
# print(dir([]))#告诉我列表拥有的所有方法
# print(dir({}))#告诉我列表拥有的所有方法
# print(dir(''))#告诉我列表拥有的所有方法
# print(dir(range(10)))#告诉我列表拥有的所有方法
# ret=set(dir([]))&set(dir({}))&set(dir(''))&set(dir(range(10)))
# print(ret)#iterable
# print('__iter__'in dir(int))
# print('__iter__'in dir(bool))
# print('__iter__'in dir(list))
# print('__iter__'in dir(dict))
# print('__iter__'in dir(set))
# print('__iter__'in dir(tuple))
# print('__iter__'in dir(enumerate([])))
# print('__iter__'in dir(range(1)))
#只要能被for循环的数据类型 就一定拥有__iter__方法
# print([].__iter__())
#一个列表执行了__iter__()之后的返回值就是一个迭代器
# print(dir([]))
# print(dir([].__iter__()))
# print(set(dir([].__iter__()))-set(dir([])))
# print([l,'a','bbb'].__iter__().__length_hint__()) # 元素个数
# l=[1,2,3]
# iterator=l.__iter__()
# print(iterator.__next__())
# print(iterator.__next__())
# print(iterator.__next__())
# print(iterator.__next__())
#lterable 可迭代的--->_iter_ #只要含有__iter__的方法都是可迭代的
#[].__iter__()迭代器 -->__next__#通过next就可以从迭代器中一个一个的取值
#只要含有__iter__方法的都是可迭代的---可迭代协议
#迭代器协议--内部含有__next__和__iter__方法的就是迭代器
# print('__iter__'in dir([].__iter__()))
# print('__next_'in dir([].__iter__()))
#迭代器的概念
#迭代器协议---内含有__next__和__iter__方法的就是迭代器
#迭代器协议和可迭代协议
#可以被for循环的都是可迭代的
#可迭代的内部都有__iter__方法
#只要是迭代器一定可迭代
#可迭代的.__iter__()方法就可以得到一个迭代器
#迭代器中的__next__()方法可以一个一个的获取值
#for循环其实就是在使用迭代器
#iterator
#可迭代对象
# print([].__iter__())
# print(range(20))
#for
#只有是可迭代对象的时侯才能用for
#当我们遇到一个新的变量,不确定不能for循环的时侯,就判断它是否可迭代

#迭代器的好处
    #从容器类型中一个一个的取值,会把所的的值都取到
    #节省内存空间
        #迭代器并不会有内存中再占用一大块内存
            #而是随着循环每次生成一个
            #每次next每次给我一个
#rnge
#f
# l=[1,2,3,45]
# iterator=l.__iter__()
# while True:
#     print(iterator.__next__())
# print(range(100000000000))
# print(list(range(100000000)))

#生成器
# 生成器函数
# def generator():
#     print(1)
#     return 'a'
#
# ret=generator()
# print(ret)
#只要含有yield关键字的函数都是生成器函数
#yield不能和return共用并且需要写在函数内
# def generator():
#     print(1)
#     yield 'a'
#生成器函数:执行之后得到一个生成器作为返回值
# ret=generator()
# print(ret)
# print(ret.__next__())
def generator():
    print(1)
    yield 'a'
    print(2)
    yield 'b'
    yield 'c'
g=generator()
for i in g:
    print(i)
# ret=g.__next__()
# print(ret)
# ret=g.__next__()
# print(ret)
# ret=g.__next__()
# print(ret)

#姓哈哈%i
def wahaha():
    for i in range(200):
        yield '姓哈哈%s'%i
g=wahaha()
count=0
for i in g:
    print(i)
    if count > 50:
        print(i)
    if count > 50:
        break
print('*******',g.__next__())
for i in g:
    count+=1
    print(i)
    if count > 50:
        print(i)
    if count > 50:
        break