Skip to main content
 首页 » 编程设计

python之Deuglify 元素变异 Python for 循环

2025年05月04日11myhome

我正在寻找成语来消除 Python for 循环,这些循环替换(而不是变异)正在迭代的 iterable 中的元素。具体来说,考虑以下四个 (for-) 循环:

循环 A:由 C 程序员编写的只读 Python 循环

for i in range(len(iterable)): 
    print(iterable[i]) 

循环 B:由 Python 程序员编写的只读 Python 循环

for e in iterable: 
    print(e) 

循环 C:由缺乏经验的 Python 程序员编写的变异 Python 循环的失败尝试

for e in iterable: 
    if condition(e): 
        e = new_value(e) 

循环 D:循环 C 的修复,恢复到循环 A 的丑陋风格

for i in range(len(iterable)): 
    if condition(iterable[i]): 
        iterable[i] = new_value((iterable[i])) 

除了非常丑陋之外,循环 D 对于非序列可迭代对象也是失败的。

我正在寻找习语和技巧

  • a) 减轻循环 D 的丑陋

  • b) 允许循环修改非序列可迭代对象的内容(在有意义的情况下)

注意事项:

  1. 原始容器应该修改;重点不是创建新容器。

  2. 我非常熟悉循环 C 失败的原因:您真的不需要向我解释为什么它不起作用。我正在寻找的是编写 Loop D 的更好方法。

  3. 我并不是要在任何循环中修改整个容器,而只是修改它的一些单独包含的元素:您不需要向我解释在遍历整个容器时修改它是一件坏事想法。

  4. 我敏锐地意识到,一般来说,修改可迭代对象的元素是不可能的。但在某些特定情况下这是可能的,这就是 b) 部分的内容。

请您参考如下方法:

在回答我自己的问题时,我提出了一个受 enumerate 启发并允许将此类循环编写为一种并不那么丑陋的方式。使用该协议(protocol)的循环如下所示:

for setit, e in muterate(iterable): 
    if e%2: 
        setit(1000*e) 

就像 enumerate 一样,muterate 返回一个生成对的迭代器:enumerate 的索引被一个 setter 函数替换,它接受用于替换容器中原始值的新值。 muterate 将适用于实现 muterate 方法的任何类型的可迭代对象,就像 iter 适用于实现适当的 __iter__ 的任何类型一样 方法。这意味着可以用完全相同的方式为任何支持可变的类型编写可变循环。

下面是一个概念验证实现。不能说我对此太过分了,但也许这是朝着正确方向迈出的一步。

from functools import partial 
from itertools import chain 
 
# The global muterate function which dispatches to the various 
# implementations 
def muterate(it): 
    try: 
        return muterate.builtins[type(it)](it) 
    except KeyError: 
        try: 
            return it.muterate() 
        except AttributeError: 
            raise TypeError('No muterator available for {}'.format(type(it))) 
muterate.builtins = {} 
 
# As I can't implement the muterate method on the builtins, these have 
# to be installed externally in some place where muterate can find 
# them 
def make_muterator(get_iterator): 
    def muterator(container): 
        def make_setter(locator): 
            def setter(new_value): 
                container[locator] = new_value 
            return setter 
        for locator, value in get_iterator(container): 
            yield make_setter(locator), value 
    return muterator 
muterate.builtins[list] = make_muterator(enumerate) 
muterate.builtins[dict] = make_muterator(dict.items) 
 
# An iterable, mutable type which does not (AND SHOULD NOT) support 
# item setting. 
def make_linked_list(data): 
    the_list = EmptyList() 
    for datum in data: 
        the_list = LinkedList(datum, the_list) 
    return the_list 
 
class EmptyList: 
 
    def __iter__(self): 
        return; yield 
 
    def muterate(self): 
        return; yield 
 
class LinkedList: 
 
    def __init__(self, head, tail): 
        self._head = head 
        self._tail = tail 
 
    def __iter__(self): 
        return chain((self._head,), self._tail) 
 
    def muterate(self): 
        def setter(new_value): 
            self._head = new_value 
        return chain(((setter, self._head),), self._tail.muterate()) 
 
    def __repr__(self): 
        return "<{}>".format(', '.join(map(str,tuple(self)))) 
    __str__ = __repr__ 
 
# Putting the muterate protocol through its paces 
l = range(10) 
d = {letter:rank for (rank, letter) in enumerate('abcdefghij')} 
ll = make_linked_list(reversed(range(10))) 
for iterable in (l,d,ll): 
    for setit, e in muterate(iterable): 
        if e%2: 
            setit(1000*e) 
    print iterable 

给出输出:

[0, 1000, 2, 3000, 4, 5000, 6, 7000, 8, 9000] 
{'a': 0, 'c': 2, 'b': 1000, 'e': 4, 'd': 3000, 'g': 6, 'f': 5000, 'i': 8, 'h': 7000, 'j': 9000} 
<0, 1000, 2, 3000, 4, 5000, 6, 7000, 8, 9000> 

换句话说,所有奇数元素都已通过可变循环在原始容器内乘以 1000,看起来相同涉及的所有类型,不是'太丑了,而且不依赖元素设置的可用性。