迭代器，内置函数，面向过程编程

1 迭代器

什么是迭代器：更新换代，每次重复的过程，每次迭代都要基于上一次的结果，迭代取值的工具

为什么要用迭代器：迭代器给我们提供了一种不依赖索引取值的方式

 

需要迭代取值的数据类型有

字符串，列表，元组，字典，集合

 2 可迭代对象

什么叫可迭代对象： 只有内置有__iter__方法的都叫做可迭代对象

字符串，列表，元组 ，字典，集合，文件

注意，文件用了内置方法__iter__过后，还是他本身

 

补充；

针对双下划线开头，双下划线结尾的方法

推荐读法，双下+方法名

 

l = [1,2,3,4,5,6]

ret = l.__iter__()
print(ret)  # <list_iterator object at 0x000002D0B4F37160>

with open(r"user.txt",mode="r",encoding="utf-8") as f:
    print(f)  # <_io.TextIOWrapper name='user.txt' mode='r' encoding='utf-8'> 
    ret = f.__iter__()
print(ret)  # <_io.TextIOWrapper name='user.txt' mode='r' encoding='utf-8'>

3 迭代器对象

迭代器定义

内置__iter__方法

内置__next__方法

迭代对象一定是可迭代对象

可迭代对象，不一定是迭代对象

l = [1,2,3,4,5]

ret = l.__iter__()  # 生成一个迭代对象


print(ret.__next__())  # 迭代对象取值
print(ret.__next__())
print(ret.__next__())
print(ret.__next__())
print(ret.__next__())
print(ret.__next__())  # 注意，当迭代对象取完了值在取值是，报错

注意，迭代对象，不管执行了多少次__iter__都还是他本身

l = [1,2,3,4,5]

ret = l.__iter__()
print(ret is ret.__iter__().__iter__().__iter__())  # True 

 迭代器的取值特点；只能往后秋，不能后退

迭代对象的取值异常处理

while True:
    try:
        print(iter_d.__next__())
    except StopIteration:
        # print('老母猪生不动了')
        break　

4 for 循环的原理

for 后面的 in 跟的是一个可迭代对象

 

原理；

1 将 in 后面的可迭代对象调用__iter__方法，转换成一个迭代对象

2 调用 __next__ 方法迭代取值

3 内部有异常捕获StopIteration，当__next__报错，自动结束循环

 

迭代对象，既有__iter__方法，也有__enxt__方法

可迭代对象，只有__iter__方法

文件是迭代对象，迭代对象是支持自身调用__iter__方法的，调用过后还是它本身，支持fou循环的三个条件

 

迭代取值的优点；

不依赖索引取值

内存中永远只占用一份空间，不会导致内存溢出

迭代取值的缺点

不能够获取指定的值

取完之后再取，会报错

5 生成器

生成器的本质就是迭代器，是用户自定义的迭代器

def func():
    print('first')
    yield  666,777  # 函数内如果有yield关键字,那么加括号执行函数的时候并不会触发函数体代码的运行
    print('second')
    yield  777
    print('third')
    yield  888
    print('forth')
    yield
    yield
# yield后面跟的值就是调用迭代器__next__方法你能得到的值
# yield既可以返回一个值也可以返回多个值 并且多个值也是按照元组的形式返回
g = func()  # 生成器初始化:将函数变成迭代器
print(g)
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())

实现Python内置方法range()

def func(a,b,c=1):
    while a < b:
        yield a
        a += c

ret = func(1,10)

for i in ret:
    print(i)




l = [1,2,3,4,5,6]

ret = l.__iter__()

for i in ret:
    print(i)

# 比较的，生成器就是一个迭代对象，都可以通过for循环取值
#也可以通过__next__方法取值　

yield是可以通过外接传参的

# yield支持外界为其传参
def dog(name):
    print('%s 准备开吃'%name)
    while True:
        food = yield
        print('%s 吃了 %s'%(name,food))
# def index():
#     pass

# 当函数内有yield关键字的时候,调用该函数不会执行函数体代码
# 而是将函数变成生成器
# g = dog('egon')
# g.__next__()  # 必须先将代码运行至yield 才能够为其传值
# g.send('狗不理包子')  # 给yield左边的变量传参  触发了__next__方法
# g.send('饺子')　

yield 特点

1 帮你提供了一种自定义生成器的方式

2 会帮你将函数的运行状态暂停住

3 可以返回值

 

yield 与 return 的异同点

相同点；都可以返回值，并且可以返回多个

不同点；yield 可以返回多个值，而return只能返回一次就结束函数

　　　　yield 还可以接受外界传值

6 生成器表达式

格式；ret = （变量 for 变量 in 可迭代对象）

注意；生成器，不会主动的运行执行一行代码

必须同过__next__方法触发代码运行

7 常用内置方法

abs()　　求绝对值

l = -1
ret = abs(l)
print(ret)  # 1

all()　　只有有一个元素为False 就返回false

any()　　只要有一个元素为true，就返回true

l = [1,2,3,4,0]

print(all(l))  # False
print(any(l))  # True

bytes()　　将字符转换为二进制形式

l = "hello"

print(bytes(l,encoding="utf-8"))

callable()　　可调用的

l = [1,2,3]
def index():
    pass
print(callable(l))  # Flase
print(callable(index))  # True

chr()　　将数值转换成ascii表的字符

ord()　　将支符转换成ascii表的数值

print(chr(97))  # 将数字转换成ascii码表对应的字符
print(ord('a'))  # 将字符按照ascii表转成对应的数字

dir()　　获取当前对象名称空间里面的名字

l = [1,2,3]
print(dir(l))

import test
print(dir(test))
print(test.name)

divmod　　分页器

print(divmod(101,10))
total_num,more = divmod(900,11)
if more:
    total_num += 1
print('总页数:',total_num)

eval（）　　将字符串中代码提取出来，并运行（不支持逻辑代码。只支持一些简单的Python代码）

exec（）　　将字符串中代码提取出来，并运行（可以是任意代码）

a= """
l = print("hello")

"""
eval(a)


b= """
print("hello")
a = 1
b = 2
print(a + b)

"""
exec(b)

isinstance()　　以后判断对象是否是某种数据内型统一用这个方法

n = 1
print(type(n))
print(isinstance(n,list))  # 判断对象是否属于某个数据类型

pow()　　求某个数的幂

 print(pow(2,3))

round()　　四舍五入

print(round(3.4))　　

8 面向过程编程

类似于设计一条流水线

好处；将复杂的问题流程化，简单化

坏处；可扩展性差，一旦需要修改，整体都会修改

 

转载于:https://www.cnblogs.com/cherish937426/p/11190216.html