kaya3

有几种方法可以让我认为程序可能有这种行为,但所有这些方法看起来 不太可能。很难想象这会发生,除非有人故意这样做,作为一个恶作剧,或者作为一个抽象的难题/挑战的解决方案,比如 “你能让程序做这个吗?” .

bar 可能导致 foo 立即返回。如果 酒吧 福 会在打印前停止,但也会 main 因为它没有 try / except 封锁。有些事你可以做 sys.excepthook 设置 global exception handler ,这可以解释为什么 酒吧 福 如果没有看到堆栈跟踪,但是异常处理程序不会导致 主要的 继续 福 离开了。

好吧,这是我解决这个难题的方法 我希望 不是你的程序真正在做什么:

def bar():
    # we will change which function `print` refers to
    global print

    # keep a reference to the built-in `print` function
    old_print = print

    # define a function which ignores its argument, then restores the old `print` function
    def ignore_one_print(s):
        global print
        print = old_print

    # change `print` to be the function we just defined
    print = ignore_one_print

当与代码结合时,它输出:

Only this line will get printed

通常,当您发现自己需要无限多的嵌套循环时,应该编写一个递归函数。下面是一个作为生成器函数的实现:

def generate_strings(letters, transitions, k):
    def helper(s):
        if len(s) == k:
            yield s
        elif len(s) < k:
            for letter in transitions[s[-1]]:
                yield from helper(s + letter)
    for letter in letters:
        yield from helper(letter)

示例:请注意,不必使用字符列表,因为字符串也是一个字符序列。

>>> letters = 'abcd'
>>> transitions = {'a': 'bc', 'b': 'a', 'c': 'd', 'd': 'bcd'}
>>> for s in generate_strings(letters, transitions, 4):
...     print(s)
... 
abab
abac
acdb
acdc
acdd
baba
bacd
cdba
cdcd
cddb
cddc
cddd
dbab
dbac
dcdb
dcdc
dcdd
ddba
ddcd
dddb
dddc
dddd

Python 3.8+有 walrus operator ,它允许您分配给表达式中的变量。表达 var := expr 分配的值 expr 到 var ,并得到相同的值。

预增量运算符 ++var var := var + 1 . 这个增量 风险价值 风险价值 . 这似乎是你想要的行为。

后递增运算符 var++ 风险价值 ,但是表达式的值 是指 风险价值 . 从您的代码示例来看,这似乎不是您要寻找的行为,但是为了完整性,可以通过 (var, var := var + 1)[0] . 它的计算结果为一个元组,该元组包含 风险价值 以及 风险价值 在执行增量之后,然后获取该元组的第一个组件(即旧的、未增量的值)。

也就是说,我建议不要使用前者,并且 强烈地 num

itertools ,这是我的解决方案。

>>> a = [2, 1, 3]
>>> from itertools import chain, repeat
>>> list(chain.from_iterable(repeat(i, v) for i, v in enumerate(a, 1)))
[1, 1, 2, 3, 3, 3]

下面是一个使用列表理解和 itertools.zip_longest :仅当元素不是空字符串且不等于下一个元素时才保留该元素。您可以使用迭代器跳过第一个元素,以避免切片列表的成本。

from itertools import zip_longest

def remove_consecutive_duplicates(lst):
    ahead = iter(lst)
    next(ahead)
    return [ x for x, y in zip_longest(lst, ahead) if x and x != y ]

用法:

>>> remove_consecutive_duplicates([1, 1, 2, 2, 3, 1, 3, 3, 3, 2])
[1, 2, 3, 1, 3, 2]
>>> remove_consecutive_duplicates(my_list)
['a', 'b', 'c', 'd', 'e', 'a', 'b', 'c', 'd', 'e', 'a', 'b', 'c', 'd',
 'e', 'a', 'b', 'c', 'd', 'e']

我假设没有由空字符串分隔的重复项(例如。 'a', '', 'a' ),或者不希望删除此类重复项。如果这个假设是错误的,那么您应该首先过滤掉空字符串:

>>> example = ['a', '', 'a']
>>> remove_consecutive_duplicates([ x for x in example if x ])
['a']