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()
# 每一次递归，会不会结束函数？不会，并且每一次递归都会开辟内存空间,如果一直开辟内存就会撑爆,最多递归1000次
# 真正的递归必须要有推退出条件
count = 0
def a()
global count
count += 1
print(count)
if count == 5:
return
a()
a()
递归:
- 函数内部必须调用自己
- 必须要有退出条件
- 递归必须要有规律
# 玉阳 20岁 ; 后面的同学大2岁,后面的后面的同学比后面的同学大2岁; 求第6位同学的年龄
'''
20
20 + 2
20 + 2 + 2
20 + 2 + 2
'''
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
'''