1.迭代器

迭代器：不是函数，只是一个称呼

python中一些皆对象（数据类型）

可迭代对象：含有.__iter__方法的数据类型就叫可迭代对象

x = 10  # 不是可迭代对象

s = 'abc'
s.__iter__()

lt = [1,2,3]
lt.__liter__()

tup = (1,)
tup.__liter__()

dic = {'a': 1}
dic.__iter__

se = {1}
se.__iter__()

fw = open('text.txt', 'a+', encoding='utf8')
fw.seek(0,0)
fw.__iter__

除了数字类型，所有数据类型都是可迭代对象

s = 'abc'
s_iter = s.__iter__()
print(s_iter.__next__())
print(s[0])
print(s_iter.__next__())
print(s[1])
print(s_iter.__next__())
print(s[2])


dic = {'a':1,'b':2,'c':3}
dic_iter = dic.__iter__()
print(dic_iter.__next__())
print(dic_iter.__next__())
print(dic_iter.__next__())


fw_iter = fw.__iter__()
print(fw_iter.__iter__())
print(fw_iter.__iter__())
print(fw_iter.__iter__())

迭代器对象：含有__iter__ 和 __next__方法的对象就是迭代器对象

为什么要有迭代器对象：提供了不依赖索引取值的手段

for循环的原理（for循环本质就是一个while循环，只不过是一个一定可控的while循环）

dic = {'a':1, 'b':2, 'c':3,}

print(dic_iter.__next__())
print(dic_iter.__next__())
print(dic_iter.__next__())
print(dic_iter.__next__())

# 如果用C写，这就是for循环

dic_iter = dic.__iter__()
while True:
    try:
        print(dic_iter.__next__())
    except StopIteratino:
        break
        
        
for i in dic:  # for循环 --》迭代循环
    print(i)
    
    
print(dic.__iter__())
print(dic.__iter__())

fw.__iter__()
fw.__next__()

for i in fw: # fw.iter = fw.__iter__()
    print(i)
    
    
# C写
def for1(iterable):
    iterator = iterable.__iter__()
    while True:
        try:
            print(iterator.__next__())
        except StopIteration:
            break
            
for([1,2,3])

可迭代对象：含有__iter__ 方法叫做可迭代对象--》除了数字类型都是可迭代对象 --》可迭代对象使用 __iter__变成可迭代器

迭代器对象：含有 __iter__ 和 __next__ 方法叫做迭代器对象--》只有文件时迭代器对象--》迭代器使用 __iter__依然是迭代器

可迭代对象不一定是迭代器对象；迭代器对象一定是可迭代对象

2.三元表达式

x = 10
y = 20

if x > y
    print(x)
else:
    print(y)
    
三元表达式---》三目表达式

print(x) if x > y else print(y)  -->仅作了解
# 条件成立走这里 if 条件 else 条件不成立走这里

3.列表推导式

lt = []

for i in range(10):
    lt.append(i)
    
    
lt = [i**2 for i in range(10)]
# lt = [i**2(可做运算) for i in [1,2,3]]
lt = [i**2 for i in [1,2,3]]

print(lt)

from typing import Iterable #　到处一个可迭代对象类型

print(isinstance(range(10), Iterable)) # 判断是否属于该数据类型

4.字典生成式

dic = {}

for i in range(10):
    dic[i] = i
    
print(dic)

dic = {i:i**2 for i in range(10)}
print(dic)


zip()
res = zip([1,2,3],[4,2,4.5,3,2,3,2,],'agabcxbds')  # res是一个迭代器，__next__返回元组
print(res.__next__())  # type:tuple
print(res.__next__())  # type:tuple
print(res.__next__())  # type:tuple

lt1 = ['a','b','c']
lt2 = [1,2,3]

dic = {k: v ** 2 for k, v in zip(lt1,lt2)}
print(dic)

lt = list('abc')
print(lt)

5.生成器生成式

# generator 本质是一个迭代器 --》生成器：本质就是一个迭代器，生成器就是一个自定义的迭代器

g = (i for i in range(10000000))
print(g)
# for i in g:
#   print(i)

lt = [i for i in range(10000000)]
print(lt)

# 生成器表达式：看成老母鸡，节省内存空间，用就下蛋
# 列表推导式：看成一筐鸡蛋，非常占用内存空间

6.生成器

含有yield关键字的函数叫做生成器

def func():
    pass

print(func())

def ge():
    yield 3  # 一个yield相当于一个next；暂停函数
    yield 4
    
# print(ge())  # ge()得到一个生成器--》生成器本质就是迭代器

g = ge()  # 得到一个生成器

# print(g.__next__())
# print(g.__next__())
# print(g.__next__())

for i in g:
    print(i)
    
    
# yield的特性

#1、暂停函数
#2、通过next取值

#　return的特性

#1、终止函数
#2、通过调用函数拿到值

# 写一个range方法

# 1.生成器
# 2.可变长参数

def range(start):
    count = 0
    while count < start:
        yield count
        count += 1

for i in range(10):
    print(i)

7.递归

函数a内部直接调用函数a本身

import sys
sys.setrecursionlimit(10)
printt(sys.getrcursionlimit())

def a():
    x = 1
    print(x)
    a()
    
a()

# 每一次递归，会不会结束函数？不会，

day 13小结