自我总结12
迭代器
迭代器：不是函数，只是一个称呼而已
x = 10 # 不是可迭代对象
s = 'abc'
s.__iter__()
lt = [1, 2, 3]
lt.__iter__()
tup = (1,)
tup.__iter__()
dic = {'a': 1}
dic.__iter__()
se = {1}
se.__iter__()
fw = open('test.txt', 'a+', encoding='utf8')
fw.seek(0, 0)
fw.__iter__()
# 除了数字类型，所有数据类型都是可迭代对象
# 迭代器对象: 含有__iter__和__next__方法的对象就是迭代器对象
# 为什么要有迭代器对象：提供了 不依赖索引取值的 手段
#字符串
s = 'abc'
s_iter = s.__iter__()
print(s_iter.__next__()) # a
print(s[0]) # a
print(s_iter.__next__()) # b
print(s[1]) # b
print(s_iter.__next__()) # c
print(s[2]) # c
#字典
dic = {'a': 1, 'b': 2, 'c': 3}
dic_iter=dic.__iter__()
print(dic_iter.__next__()) # a # 迭代取值 --》 基于上一个值
print(dic_iter.__next__()) # b
print(dic_iter.__next__()) # c
# 如果用c写,这就是for循环
# for循环自动捕捉个数，用尽停止
dic_iter = dic.__iter__()
while True:
try:
print(dic_iter.__next__())
except StopIteration:
break
# for循环原理（for循环本质就是一个while循环，只不过是一个一定可控的while循环）
#文件
fw = open('test.txt', 'a+', encoding='utf8')
fw.seek(0, 0)
fw.__iter__()
fw_iter = fw.__iter__()
print(fw_iter.__next__())
print(fw_iter.__next__())
print(fw_iter.__next__())
# 总结
# 可迭代对象: 含有__iter__方法叫做可迭代对象 --> 除了数字类型都是可迭代对象 --> 可迭代对象使用__iter__变成迭代器
# 迭代器对象: 含有__iter__和__next__方法叫做迭代器对象 --> 只有文件时迭代器对象 --> 迭代器使用__iter__依然是迭代器
# 可迭代对象不一定是迭代器对象; 迭代器对象一定是可迭代对象
三元表达式（装逼用）
# 普通表达式
x = 10
y = 20
if x > y:
print(x)
else:
print(y)
# 三元表达式 --> 三目表达式
print(x) if x > y else print(y) # --> 仅作了解
# 条件成立走这里 if 条件 else 条件不成立走这里
列表推导式
# 基本代码
lt = []
for i in range(10):
lt.append(i) # 输出0-9
# 列表推导式
lt = [i for i in range(10)] # 输出0-9
#扩展
lt = [i**2 for i in [1,2,3]]
# lt = [i**2(可以做运算) for i in [1,2,3]] # [1,4,9]
print(lt)
# python一切皆对象，range(10)属于可迭代对象
from typing import Iterable # 导出一个可迭代对象类型
print(isinstance(range(10),Iterable)) # 判断是否属于该数据类型
# True
字典生成式
# 基本代码
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,3,4,2,3,4,2,3],'abcadsfasdfasdf') # res是一个迭代器,__next__返回元组
print(res.__next__()) # (1,4,'a') # type:tuple
print(res.__next__()) # (2.2,'b') # type:tuple
print(res.__next__()) # (3.3,'c') # type:tuple
# print(res.__next__()) # type:tuple # 超过次数报错
lt1 = ['a', 'b', 'c']
lt2 = [1, 2, 3]
dic = {k: v for k, v in zip(lt1, lt2)} #两个列表变成一个字典
# dic = {k: v ** 2 for k, v in zip(lt1, lt2)}
print(dic)
lt = list('abc') # list列表-->属于可迭代对象，一个值一个值迭代进去，list为容器类元素
print(lt)
# ['a','b','c']
生成器生成
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)
生成器
# 生成器:含有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. 通过调用函数拿到值
递归函数
# 传递 ; 回归
# 递归: 函数a内部直接调用函数a本身
# 真正的递归必须得要有 退出条件
# 看思路
# 递归:
# 1. 函数内部调用函数自己
# 2. 必须要有退出条件
# 3. 递归必须要有规律
def age(x):
if x == 0:
return 18
x -= 1
return age(x) + 2
res = age(6)
print(res) # 32
'''
res = 30
res = 28 + 2
res = 26 + 2 + 2
res = 24 + 2 + 2 + 2
res = 22 + 2 + 2 + 2 + 2
res = 20 + 2 + 2 + 2 + 2 + 2
res = 18 + 2 + 2 + 2 + 2 + 2 + 2
'''
