Python20-Day04

##########迭代器、生成器和面向过程编程##########

一、迭代器

　　迭代器是一个重复的过程，每次重复即一次迭代，并且每次迭代的结果都是下一次迭代的初始值；

l = [1,2,3]

count = 0

while count < len(l):

    print(l[count])

    count+=1

　　为何要有迭代器？

　　　　对于序列类型：字符串，列表，元组，可以通过使用索引的方式迭代取出其包含的元素，但是对于字典，集合文件等类型是没有索引的，若还想取出其内部包含的元素，

　　　　就必须使用不依赖于索引的迭代方式---迭代器。

　　什么是可迭代对象？

　　　　可迭代的对象指的是内置有__iter__方法的对象，即obj.__iter__，如下：

'hello'.__iter__

(1,2,3).__iter__

[1,2,3].__iter__

{'a':1}.__iter__

{'a','b'}.__iter__

open('a.txt').__iter__

　　什么是迭代器对象？

　　　　可迭代对象执行obj.__iter__()得到的结果就是迭代器对象

　　　　而迭代器器对象指的是内置有__iter__又内置有__next__方法的对象

　　　　文件类型是迭代器对象：

open('a.txt').__iter__()

open('b.txt').__next__()

　　注意：

　　　　迭代器对象一定是可迭代对象，而可迭代对象不一定是迭代器对象。

　　迭代器对象的使用

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

# iter_dic = dic.__iter__()  #得到迭代器对象，迭代器对象既有__iter__又有__next__。

# print(iter_dic.__iter__() is iter_dic)   #True 迭代器.__iter__()得到的仍然是迭代器本身

# print(iter_dic.__next__())  #等同于next(iter_dic)

# print(iter_dic.__next__())

# print(iter_dic.__next__())

# print(iter_dic.__next__())  #元素迭代完成，会抛出异常StopIteration

#有了迭代器，就可以不依赖索引迭代取值了   需要自己捕捉异常，控制next。

iter_dic = dic.__iter__()

print(iter_dic)

while 1:

    try:

        k = next(iter_dic)

        print(dic[k])

    except StopIteration:

        break

　　for循环

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

for key in dic:

    print(key,dic[key])
#基于for循环，可以不再依赖索引取值
#for循环的工作原理：
　　1. 执行in后对象的dic.__iter__()，得到一个迭代器对象iter_dic
　　2. 执行next(iter_dic)，将得到的值赋值给k，然后执行循环体代码
　　3. 重复过程2，直到捕捉到异常StopIteration

　　迭代器的优缺点：

　　　　优点：

　　　　　　- 提供一种统一的不依赖于索引的迭代方式

　　　　　　- 惰性计算，节省内存

　　　　缺点：

　　　　　　- 无法获取长度（只有在next完毕才知道到底有几个值）

　　　　　　- 一次性的，只能往后走，不能往前退

二、生成器

　　什么是生成器？

　　　　只要函数内部包含有yield关键字，那么函数名()得到的结果就是生成器，并且不会执行函数内部代码。

def func():

    print('====>first')

    yield 1

    print('====>second')

    yield 2

    print('====>third')

    yield 3

    print('====>end')

print(func())

# g=func()

# print(g)

# print(next(g))

# print(next(g))

# print(next(g))

# print(next(g))

　　生成器就是迭代器

　　　　g.__iter__

　　　　g.__next__

　　　　res = next(g)

　　　　print(res)

　　练习题：1、自定义函数模拟range(1,7,2)

#1、自定义函数模拟range(1,7,2)

def my_range(start,stop,step=1):

    while True:

        if start < stop:

            yield start

        start+=step

g = my_range(1,7,2)    #g为生成器  生成器就是迭代器，可以通过迭代器迭代取值

print(next(g))

print(next(g))

print(next(g))

# for i in my_range(1,7,2):  #也可以通过for循环取值

#     print(i)

　　　　　　2、模拟管道，实现功能：tail -f access.log | grep '404'

import time

def tail(filepath):

    with open(filepath,'rb') as f:

        f.seek(0,2)

        while True:

            line = f.readline()

            if line:

                yield line

            else:

                time.sleep(0.2)

def grep(parttern,lines):

    for line in lines:

        line = line.decode('utf-8')

        if parttern in line:

            yield line

for line in grep('',tail('access.log')):

    print(line,end='')

三、yield总结

　　#1、把函数做成迭代器

　　#2、对比return，可以返回多次值，可以挂起/保存函数的运行状态

四、面向过程编程

　　#1、强调：面向过程编程绝对不是用函数编程，面向过程是一种编程思想、思路，而编程思路是不依赖于具体的语言或者语法的。也可以说即使我们不依赖于函数，也可以基于面向过程的思想编写程序

　　#2、定义

　　　　面向过程的核心是过程，过程指的是解决问题的步骤，即先干什么后干什么。

　　　　基于面向过程设计程序就好比是设计一条流水线，是一种机械式的思维方式

　　#3、优点

　　　　复杂的问题流程化，进而简单化

　　#4、缺点

　　　　可扩展性差，修改流水线的任意一个阶段，都会牵一发而动全身

　　#5、应用

　　　　扩展性要求不高的场景，典型案例Linux内核

##########三元表达式、列表推导式、生成器表达式、递归、匿名函数、内置函数##########

一、三元表达式、列表推导式、生成器表达式

　　1、三元表达式　

name = input('姓名:> ').strip()

res = 'NB' if name == 'alex' else 'TNB'

print(res)

　　2、列表推导式

# egg_list = []

# for i in range(1,10):

#     egg_list.append('鸡蛋%s' %i)

# print(egg_list)

egg_list = ['鸡蛋%s' %i for i in range(1,10)]

print(egg_list)

　　3、生成器表达式

　　#1、把列表推导式的[]换成()就是生成器表达式

chicken = ('鸡蛋%s' %i for i in range(1,5))

print(chicken) #chicken = <generator object <genexpr> at 0x00000000021768E0>

# print(next(chicken))  #鸡蛋1

# print(next(chicken))  #鸡蛋2

# print(next(chicken))  #鸡蛋3

print(list(chicken)) #['鸡蛋1', '鸡蛋2', '鸡蛋3', '鸡蛋4', ]   因为chicken可迭代，因而可以转换成列表

　　#2、优点：省内存，一次只产生一个值在内存中

二、声明式编程练习题

#1、将names=['egon','alex_sb','wupeiqi','yuanhao']中的名字全部变大写

names=['egon','alex_sb','wupeiqi','yuanhao']

res = [name.upper() for name in names]

print(res)   #['EGON', 'ALEX_SB', 'WUPEIQI', 'YUANHAO']

#2、将names=['egon','alex_sb','wupeiqi','yuanhao']中以sb结尾的名字过滤掉，然后保存剩下的名字长度

names=['egon','alex_sb','wupeiqi','yuanhao']

# res = [name for name in names if 'sb' not in  name]   #以sb结尾的名字过滤掉    res = ['egon', 'wupeiqi', 'yuanhao']

res = [len(name) for name in names if 'sb' not in name]  #[4, 7, 7]

print(res)

#3、求文件a.txt中最长的行的长度（长度按字符个数算，需要使用max函数）

#笨方法

# num_list=[]

# with open('a.txt','r',encoding='utf-8') as f:

#     lines = f.readlines()

#     for line in lines:

#         num_list.append(len(line))

# print(max(num_list))

#声明式方法

with open('a.txt',encoding='utf-8') as f:

    print(max(len(line)for line in f))

三、内置函数

　　现阶段需要掌握的：

　　divmod

　　　　python divmod()函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组（a // b,a % b）

>>> divmod(7,2)

(3, 1)

>>> divmod(8,2)

(4, 0)

　　enumerate

　　　　enumerate是用来遍历可迭代容器中的元素，同时通过一个计数器变量记录当前元素所对应的索引值。

#示例：

names = ['Bob', 'Alice', 'Guido']

for index, value in enumerate(names):

    print(f'{index}: {value}')

#输入如下内容：

0: Bob

1: Alice

2: Guido

　　　　这个循环遍历了name列表的所有元素，并通过增加从零开始的计数器变量为每个元素生成索引。

　　　　enumerate()函数允许为循环自定义起始索引值。enumerate()函数中接收一个可选参数，该参数允许为本次循环中的计数器变量设置初始值。

names = ['Bob', 'Alice', 'Guido']

for index, value in enumerate(names, 1):

    print(f'{index}: {value}')

1: Bob

2: Alice

3: Guido

enumerate是Python的一个内置函数。你应该充分利用它通过循环迭代自动生成的索引变量。

索引值默认从0开始，但也可以将其设置为任何整数。

enumerate函数是从2.3版本开始被添加到Python中的，详情见PEP279。

Python的enumerate函数可以帮助你编写出更加Pythonic和地道的循环结构，避免使用笨重且容易出错的手动生成索引。

为了充分利用enumerate的特性，一定要研究Python的迭代器和数据结构解包功能。

作者：vimiix

链接：https://juejin.im/post/5a31146251882503eb4b4755

来源：掘金

著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

　　eval

　　　　功能：将字符串str当成有效的表达式来求值并返回结果。

　　　　参数：

　　　　　　source ：一个python表达式或者函数compile()返回的代码对象

　　　　　　globals ：可选，必须是dictionary

　　　　　　locals ：可选，任意map对象

可以把list,tuple,dict和string相互转化。

#################################################

字符串转换成列表

>>>a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]"

>>>type(a)

<type 'str'>

>>> b = eval(a)

>>> print b

[[1, 2], [3, 4], [5, 6], [7, 8], [9, 0]]

>>> type(b)

<type 'list'>

#################################################

字符串转换成字典

>>> a = "{1: 'a', 2: 'b'}"

>>> type(a)

<type 'str'>

>>> b = eval(a)

>>> print b

{1: 'a', 2: 'b'}

>>> type(b)

<type 'dict'>

#################################################

字符串转换成元组

>>> a = "([1,2], [3,4], [5,6], [7,8], (9,0))"

>>> type(a)

<type 'str'>

>>> b = eval(a)

>>> print b

([1, 2], [3, 4], [5, 6], [7, 8], (9, 0))

>>> type(b)

<type 'tuple'>

巴特西

Python20-Day04

最新文章

热门文章