Python中关于循环技术的总结

Python中关于循环技术的短文

Python中有很多数据结构可用来存储数据集合，而当我们想读取调用这些存储在数据结构中的数据时，常常使用一些循环遍历技术。根据我们对调用数据方式的要求以及不同数据结构的特点，我们有许多不同的循环技术，本文将对这些技术进行总结。

基础

-对于基本的数据结构，像列表、元组，如果我们只是想按顺序调用读取存储在其中的数据，我们只需用简单的for循环就可以了。

例子

列表：

代码：

List = [1,2,3,4]

for i in List:
    print(i)

输出结果:

1
2
3
4

元组：

代码：

Tuple = ("a","b","c","d")

for i in Tuple:
    print(i)

输出结果:

a
b
c
d

特殊数据结构

-对于集合和字典这两种数据结构，有特殊的循环技术。

集合

	-集合中数据是无序的，如果直接用for循环技术遍历输出，则不会按输入的顺序输出。

例子：

代码：

Set = {"a","b","f","s"}

for i in Set:
    print(i)

输出：

b
a
s
f

字典

	-字典中数据以键值对形式存储，想要循环遍历输出key和对应的value值可以使用item()函数。

例子：

代码：

Dict = {1:"a",2:"b",3:"c"}

for i,j in Dict.items():
    print(i,"--",j)

输出：

1 -- a
2 -- b
3 -- c

特殊遍历要求

-在实际情况中，我们有时候需要按顺序遍历之外的循环技术。

列表下标和值共同输出

	-当我们在遍历列表时，如果想要将下标和值一起输出，可以使用enumerate()函数。

例子：

代码：

List = [1,2,3,4]

for i,j in enumerate(List):
    print(i,"--",j)

输出：

0 -- 1
1 -- 2
2 -- 3
3 -- 4

同样适用于元组，集合。

例子：

代码（元组）：

Tuple = ("a","b","c","d")

for i,j in enumerate(Tuple):
    print(i,"--",j)

输出：

0 -- a
1 -- b
2 -- c
3 -- d

代码（集合）：

Set = {"a","b","f","s"}

for i,j in enumerate(Set):
    print(i,"--",j)

输出：

0 -- b
1 -- a
2 -- s
3 -- f

-集合输出依旧是无序的。

多个列表同时遍历

-当我们想同时遍历两个或以上的列表时，我们可以使用zip()函数。下面仅以两个列表为例。

例子：

代码：

List1 = ["a","b","c","d"]
List2 = ["e","f","g","h"]

for i,j in zip(List1,List2):
    print(i,"--",j)

输出：

a -- e
b -- f
c -- g
d -- h

同样适用于元组，集合。

例子：

代码（元组）：

Tuple1 = ("a","b","c","d")
Tuple2 = ("e","f","g","h")

for i,j in zip(Tuple1,Tuple2):
    print(i,"--",j)

输出：

a -- e
b -- f
c -- g
d -- h

代码（集合）：

Set1 = {"a","b","f","s"}
Set2 = {1,2,3,4}

for i,j in zip(Set1,Set2):
    print(i,"--",j)

b -- 1
a -- 2
s -- 3
f -- 4

-集合输出依旧是无序的。

逆序遍历

-当我们想倒着输出一个列表时，我们可以使用reversed()函数。

例子：

代码

List = [1,2,3,4]

for i in reversed(List):
    print(i)

输出：

4
3
2
1

排序后输出

-当我们循环遍历一个列表时，想对其中排序后再输出可以使用sorted()函数

例子：

代码

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

for i in sorted(List):
    print(i)

输出

1
2
3
4
5

循环技巧

-有时候我们想循环遍历对一个列表进行操作，我们可以直接新定义一个列表

例子:

代码

import math
raw_data = [56.2, float('NaN'), 51.7, 55.3, 52.5, float('NaN'), 47.8]
filtered_data = []
for value in raw_data:
    if not math.isnan(value):
        filtered_data.append(value)
print(filtered_data)

输出

[56.2, 51.7, 55.3, 52.5, 47.8]

关于python生成器技术的补充

本文简单对python中生成器的一些应用做出介绍

-可以通过yield实现在单线程的情况下实现并发运算的效果

例子

代码

import time
def consumer(name):
    print("%s 准备学习啦!" %name)
    while True:
       lesson = yield
 
       print("开始[%s]了,[%s]老师来讲课了!" %(lesson,name))
 
 
def producer(name):
    c = consumer('A')
    c2 = consumer('B')
    c.__next__()
    c2.__next__()
    print("同学们开始上课 了!")
    for i in range(10):
        time.sleep(1)
        print("到了两个同学!")
        c.send(i)
        c2.send(i)

输出结果

A 准备学习啦!
B 准备学习啦!
同学们开始上课 了!
到了两个同学!
开始[0]了,[A]老师来讲课了!
开始[0]了,[B]老师来讲课了!
到了两个同学!
开始[1]了,[A]老师来讲课了!
开始[1]了,[B]老师来讲课了!
到了两个同学!
开始[2]了,[A]老师来讲课了!
开始[2]了,[B]老师来讲课了!
到了两个同学!
开始[3]了,[A]老师来讲课了!
开始[3]了,[B]老师来讲课了!
到了两个同学!
开始[4]了,[A]老师来讲课了!
开始[4]了,[B]老师来讲课了!
到了两个同学!
开始[5]了,[A]老师来讲课了!
开始[5]了,[B]老师来讲课了!
到了两个同学!
开始[6]了,[A]老师来讲课了!
开始[6]了,[B]老师来讲课了!
到了两个同学!

解析

-由上面的例子我么可以发现，python提供了两种基本的方式
-生成器函数：也是用def定义的，利用关键字yield一次性返回一个结果，阻塞，重新开始
-生成器表达式：返回一个对象，这个对象只有在需要的时候才产生结果

-用定义函数来使用生成器

例子：

定义一个可生成斐波那契数列的函数，生成的值存储到生成器中

代码

def fib(max):
    n,a,b =0,0,1
    while n < max:
        yield b
        a,b =b,a+b
        n = n+1
    return 'done'
g = fib(6)
while True:
    try:
        x = next(g)
        print('generator: ',x)
    except StopIteration as e:
        print("生成器返回值：",e.value)
        break

输出结果

generator:  1
generator:  1
generator:  2
generator:  3
generator:  5
generator:  8
生成器返回值： done

解析：

-这段代码中利用了yield将生成结果存储到生成器中。然后用next()函数不断获取生成器的值，直到全部获取完。
-在用异常处理捕获StopIteration异常，获取函数返回值。

-生成器表达式
-生成器表达式来源于迭代和列表解析的组合，生成器和列表解析类似，但是它使用尖括号而不是方括号

例子

代码

>>> # 列表解析生成列表
>>> [ x ** 3 for x in range(5)]
[0, 1, 8, 27, 64]
>>>
>>> # 生成器表达式
>>> (x ** 3 for x in range(5))
<generator object <genexpr> at 0x000000000315F678>
>>> # 两者之间转换
>>> list(x ** 3 for x in range(5))
[0, 1, 8, 27, 64]

-一个迭代既可以被写成生成器函数，也可以被协程生成器表达式，均支持自动和手动迭代。而且这些生成器只支持一个active迭代，也就是说生成器的迭代器就是生成器本身。

对yield的几点总结

（1）通常的for…in…循环中，in后面是一个数组，这个数组就是一个可迭代对象，类似的还有链表，字符串，文件。他可以是a = [1,2,3]，也可以是a = [x*x for x in range(3)]。

它的缺点也很明显，就是所有数据都在内存里面，如果有海量的数据，将会非常耗内存。

（2）生成器是可以迭代的，但是只可以读取它一次。因为用的时候才生成，比如a = (x*x for x in range(3))。!!!注意这里是小括号而不是方括号。

（3）生成器（generator）能够迭代的关键是他有next()方法，工作原理就是通过重复调用next()方法，直到捕获一个异常。

（4）带有yield的函数不再是一个普通的函数，而是一个生成器generator，可用于迭代

（5）yield是一个类似return 的关键字，迭代一次遇到yield的时候就返回yield后面或者右面的值。而且下一次迭代的时候，从上一次迭代遇到的yield后面的代码开始执行

（6）yield就是return返回的一个值，并且记住这个返回的位置。下一次迭代就从这个位置开始。

（7）带有yield的函数不仅仅是只用于for循环，而且可用于某个函数的参数，只要这个函数的参数也允许迭代参数。

（8）send()和next()的区别就在于send可传递参数给yield表达式，这时候传递的参数就会作为yield表达式的值，而yield的参数是返回给调用者的值，也就是说send可以强行修改上一个yield表达式值。

（9）send()和next()都有返回值，他们的返回值是当前迭代遇到的yield的时候，yield后面表达式的值，其实就是当前迭代yield后面的参数。

（10）第一次调用时候必须先next（）或send（）,否则会报错，send后之所以为None是因为这时候没有上一个yield，所以也可以认为next（）等同于send(None)