浅谈Ruby里的生成器天性,Python之流程语句

在老东家写了一段时间Python后,我被告知Python里面有个很经典的被称之为生成器的特性,而这个特性至今让我难以忘怀。后来我接触了Ruby,我就纳闷了Ruby怎么就没看到这个特性?

在Python中,一个程序区块是使用冒号开头,之后同一个区块中要有相同的缩进,不能混用不同的空格数,也不可混用空格和Tab,Python
建议使用4个空格作为缩进。

直到最近在读《松本行弘的程序员世界》的时候我才意识到我错了,这个特性早在Ruby1.9就已经具备,只不过是我资历尚浅,察觉不到它的存在罢了。

if分支语句

if condition1:
    if condtion2:
        doSomething()
    else:
        doSomething()
elif condition:
    doSomething()
else:
    doSomething()

Python区块定义的方式避免了像C/C++、Java等语言某些读起来不明确的情况,比如:

if(condition1)
    if(condition2)
        doSomething()
else
    doSomething2()

看起来else好像是跟第一个if语句对应的,但实际上这些语言采用的是就近配对原则,是和第二个if语句对应的,Python中就没有这个问题,是以语句缩进来对应的。

if condition:
    if condition2:
         do_something()
else :
    do_something2()
#else跟第一个if语句配对

if condition:
    if condition2:
         do_something()
    else :
        do_something2()
# else与第二个if配对

在Python中还有个 if…else 表达式:

# 判断奇偶数
>>> num = 11
>>> print('{} 是 {}'.format(num, '奇数' if num % 2 else '偶数'))
11 是 奇数

当if条件满足时,会返回if前面的值,若不满足则返回else后面的值。


图片 1松本行弘

while 循环

Python 提供了while 循环,根据while语句后面的内容来判断是否执行循环体:

while condition:
    do_something()
else
    do_something()

当判断条件成立时,会执行while区块,else是可选的,如果有else语句,不管条件成不成立都会执行else下的语句,若不想让else执行就在while区块中加入break语句中断循环,最好还是不要使用,这样容易产生混乱。

print('请输入两个数字')
a = int(input('数字 1 :'))
b = int(input('数字 2 :'))
while b != 0:
    r = a % b
    a = b
    b = r
    if a == 1:
        print('互质')
        break
else:
    print('最大公因数:', a)

还是下面的代码比较直观:

print('请输入两个数字')
a = int(input('数字 1 :'))
b = int(input('数字 2 :'))
while b != 0:
    r = a % b
    a = b
    b = r
    if a == 1:
        print('互质')
    else:
        print('最大公因数:', a)

下面是一个简单的Python生成器例子,它的功能是遍历0-max范围内的所有数字

for in 循环

若要按顺序迭代某个序列(字符串,元组,列表),则可以使用for in 语句:

>>> num = ['a', 1, '2', '3']
>>> for i in num:
...     print(i)
... 
a
1
2
3

如果在迭代的时候需要使用到索引,则可以配合 range() 函数使用,range()
函数可以产生一个指定的数字范围:

>>> for i in range(len(num)):
...     print(i, num[i])
... 
0 a
1 1
2 2
3 3

range() 函数的形式是 range(start, stop[, step]),
start默认是0,step是步长默认为1。

也可以使用 zip()
函数,将两个序列的各个元素像拉链一样一一配对,它返回的是一个zip对象,这个对象并没有包含真正配对的元素,具有惰性求值的特性(关于惰性求值请看我的另一篇文章:Python中的优化:惰性求值详解),像range()函数也是产生一个range对象不是列表:

>>> zip([1,2,3],[4,5,6],[7,8,9])
<zip object at 0x108498e08>
>>> for i, j, k in zip([1,2,3],[4,5,6],[7,8,9]):
...     print(i, j, k)
... 
1 4 7
2 5 8
3 6 9

若真的要迭代时具有索引信息,建议使用 enumerate() 函数而不是 range()
函数,enumerate() 返回一个 enumerate 对象,也是惰性求值,可使用for in
进行迭代,enumerate 可用于获取元组元素:

>>> num = [1,2,3,4,5,6]
>>> list(enumerate(num))
[(0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (5, 6)]

可以利用元组拆解的特性获取索引信息:

>>> for i, j in enumerate(num):
...     print(i, j)
... 
0 1
1 2
2 3
3 4
4 5
5 6

只要是实现了__iter__() 方法的对象,都可以通过__iter__()
方法返回一个迭代器,这个迭代器可以使用for
in语句来迭代,如:range、zip、enumerate对象,集合也实现了__iter__()
方法,因此也可以进行迭代,但是集合是无序的,每次的迭代结果顺序都不一样;字典也是可以迭代的,使用keys()、values()、items()方法,分别返回dict_keys、dict_values、dict_items对象,也都实现了__iter__()
方法,因此也可以使用for in进行迭代,如果直接对字典进行for
in操作,默认对键进行迭代。


def range: n = 0 while n < max: yield n n += 1if __name__ == '__main__': for i in range: print

pass、break、continue

在某个区块中,并不想执行任何程序语句或者稍后需要些什么语句,对于还没打算编写的区块,可以加上个pass语句,只是用来维持代码的完整性,将来可能会用到它,因为可能会做一些小测试,看看其他的代码是否正常运行。break和continue都是用来跳出循环的,break是直接跳出循环不在进行循环操作,continue是中止本次循环,继续进行下一轮的循环。

PS: 结果就是打印0~99这里就不贴出来了。

list comprehension

将一个列表进行操作转为另外一个列表是很常见的操作,Python提供了 list
comprehension 语句:

# 将数组元素平方
#一般做法:
>>> array = [1, 2, 3, 4]
>>> array2 = []
>>> for i in array:
...     array2.append(i ** 2)
... 
>>> print(array2)
[1, 4, 9, 16]
#list comprehension语句
>>> array = [1, 2, 3, 4]
>>> array2 = [i ** 2 for i in array]
>>> print(array2)
[1, 4, 9, 16]

可以看到代码精简了很多,上述语句逐一迭代出数组元素并赋值给i变量,之后执行for左边的表达式运算,使用
[] 括起来,表示每次迭代的结果收集为一个列表。
list comprehension 还可以与条件判断式结合,构成过滤的功能:

#筛选出数组中的奇数
>>> array = [1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
>>> new_array = [i for i in array if i % 2]
>>> print(new_array)
[1, 3, 5, 7, 9]

在上述代码中,只有满足了if条件才会执行for左边的语句,然后并入数组中。
当然,它还可以嵌套使用,不过这样可读性会变低,简单两层的还可以,复杂的不推荐使用:

# 将二维矩阵转为一维
>>> matrix = [
... [1,2,3],
... [4,5,6],
... [7,8,9]
... ]
>>> array = [e for row in matrix for e in row]
>>> print(array)
[1, 2, 3, 4, 5, 6, 7, 8, 9]

#得到两个序列的排列组合
```python
>>> num1 = [1, 2, 3, 4]
>>> num2 = [1, 2, 3, 4]
>>> [(i ,j) for i in num1 for j in num2 ]
[(1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 2), (2, 3), (2, 4), (3, 1), (3, 2), (3, 3), (3, 4), (4, 1), (4, 2), (4, 3), (4, 4)]
>>> [word1 + word2 for word1 in 'hello' for word2 in 'world']
['hw', 'ho', 'hr', 'hl', 'hd', 'ew', 'eo', 'er', 'el', 'ed', 'lw', 'lo', 'lr', 'll', 'ld', 'lw', 'lo', 'lr', 'll', 'ld', 'ow', 'oo', 'or', 'ol', 'od']

在 list comprehension
两边放上[],会产生列表,如果数据很多,直接返回列表会占用太多内存,可以用()
取代 [] ,这样就会创建一个generator对象,具有惰性求值的特性:

>>> num = (i for i in range(99999999999999999))
>>> num
<generator object <genexpr> at 0x106e29fc0>

list comprehension语句也可以用来创建集合,在语句两边放上{}:

>>> num = [1,2,3,4,5,6,7,8,9,0]
>>> {i for i in num if i % 2}
{1, 3, 5, 7, 9}

也可以用来创建字典,使用zip()函数将键值一一配对:

>>> keys = ['JYH', 'JY']
>>> values = ['123', '456']
>>> {key : value for key, value in zip(keys, values)}
{'JYH': '123', 'JY': '456'}

还可以用来创建元组,由于()会创建生成器,所以要换一种方式,将生成器表达式传给tuple():

>>> tuple(i for i in range(10))
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

关于惰性求值请看我的另一篇文章:Python中的优化:惰性求值详解

有没有感觉这个函数很有梯度感?(这是我放弃Python的理由之一
)T_T。如果我们直接在REPL环境里面运行range函数,会得到下面的结果

In [8]: rangeOut[8]: <generator object range at 0x102f41460>

从字面上可以看出它是一个generator,也就是我们所说的生成器。

当然,我们也可以直接构造一个数组,通过遍历数组来完成以上的打印过程。但生成器的好处就是它是惰性的,也就是说当你访问某个元素的时候对应元素才会被生成,而不是先生成一个完整的数组,然后我们再去遍历它。

现在我们看看Ruby的yield语句是用来做什么的,举个简单的例子就能够看出来

def handler yieldendresult = handler { |i| i * 20 }puts result

程序的运行结果是

> 2000

简单来说,Ruby里面的yield可以用来接收方法块,调用它就相当于调用方法块。上面的例子里我们的方法块是{ |i| i * 20 },它接收一个参数i并返回i * 20的值,结果就是
100 * 20 = 2000

那问题来了,yield这个语句已经被用作方法块的代理了,那我们在Ruby里面要怎么实现如Python般可以返回生成器的函数?还是说Ruby中压根没有生成器这种机制?

怎么可能呢?其实生成器就在我们身边,只不过我们很多时候都察觉不到它的存在,具体我们可以参考一下这篇文章。在Ruby1.9之后就实现了Enumerator这个类,它的机制跟Python里面的生成器类似,可以用作惰性求值。使用方式如下

发表评论

电子邮件地址不会被公开。 必填项已用*标注