如何对一个迭代器执行某些操作，然后对python中的下一个迭代器执行其他操作

python对第一个元素执行某些操作的“正确”方式是什么，对第二个元素执行其他操作，对列表中的第三个元素执行不同的操作，然后重复，例如：

a = [2, "foo1", "bar1", 5, "foo3", "bar2", 3, "foo2", "bar3"]
my_function(a)

应该给

20
foo1
foobar1
50
foo3
foobar2
30
foo2
foobar3

其中“my_函数”类似于：

def my_function(a):
    i = 0
    for line in a:
        if i == 0:
            line = line*10
        if i == 2:
            line = "foo"+line
        i = i + 1
        if i == 3:
            i = 0
        print line

def my_function(lst):
    items = (lst[i:i+3] for i in xrange(0, len(lst), 3))
    for group in items:
       yield group[0] * 10
       yield group[1]
       yield 'foo' + group[2]

---

但这看起来很“不对劲”。没有

int

来跟踪，有没有更好的方法？也就是说，我第一次调用这个函数，做这个，但是第二次，做这个，然后第三次，做这个，然后回到开始，做你第一次做的。一个跟踪调用次数的函数。

我可以执行以下操作：

def my_function(a):
    i = 0
    for line in a:
        if i == 0:
            line = line*10
        if i == 2:
            line = "foo"+line
        i = i + 1
        if i == 3:
            i = 0
        print line

def my_function(lst):
    items = (lst[i:i+3] for i in xrange(0, len(lst), 3))
    for group in items:
       yield group[0] * 10
       yield group[1]
       yield 'foo' + group[2]

根据您的输入运行：

>>> list(my_function(a))
[20, 'foo1', 'foobar1', 50, 'foo3', 'foobar2', 30, 'foo2', 'foobar3']

---

我在这里做了两个大的假设——您的列表确实是一个列表（或者至少是一个序列），并且序列的长度可以被3整除（否则您将得到一个

索引器

）。这两个假设都可以不费吹灰之力解决，但如果你真的感兴趣，我将把它作为练习；-）

我可能会这样做：

def my_function(a):
    i = 0
    for line in a:
        if i == 0:
            line = line*10
        if i == 2:
            line = "foo"+line
        i = i + 1
        if i == 3:
            i = 0
        print line

def my_function(lst):
    items = (lst[i:i+3] for i in xrange(0, len(lst), 3))
    for group in items:
       yield group[0] * 10
       yield group[1]
       yield 'foo' + group[2]

根据您的输入运行：

>>> list(my_function(a))
[20, 'foo1', 'foobar1', 50, 'foo3', 'foobar2', 30, 'foo2', 'foobar3']

---

我在这里做了两个大的假设——您的列表确实是一个列表（或者至少是一个序列），并且序列的长度可以被3整除（否则您将得到一个

索引器

）。这两个假设都可以不费吹灰之力解决，但如果你真的感兴趣，我将把它作为练习；-）

您可以使用以下内容：

def my_function (a):
    actions = [lambda l: l * 10,
               lambda l: l,
               lambda l: "foo" + l]
    for i, line in enumerate(a):
        line = actions[i % 3](line)
        print line

---

您可以使用以下内容：

def my_function (a):
    actions = [lambda l: l * 10,
               lambda l: l,
               lambda l: "foo" + l]
    for i, line in enumerate(a):
        line = actions[i % 3](line)
        print line

---

使用迭代器，可以执行以下操作：

def my_function(a):
    a = iter(a)
    while True:
        yield 10 * next(a)    
        yield next(a)
        yield "foo" + next(a)

a = [2, "foo1", "bar1", 5, "foo3", "bar2", 3, "foo2", "bar3"]    
print list(my_function(a))
#prints [20, 'foo1', 'foobar1', 50, 'foo3', 'foobar2', 30, 'foo2', 'foobar3'] 

---

如果有人想知道列表末尾发生了什么，

next（a）

将引发

StopIteration

。异常终止生成器

my_函数

，但对其进行迭代的代码（在本例中为

list（）

）将其识别为迭代的正常结束。

使用迭代器时，可以执行以下操作：

def my_function(a):
    a = iter(a)
    while True:
        yield 10 * next(a)    
        yield next(a)
        yield "foo" + next(a)

a = [2, "foo1", "bar1", 5, "foo3", "bar2", 3, "foo2", "bar3"]    
print list(my_function(a))
#prints [20, 'foo1', 'foobar1', 50, 'foo3', 'foobar2', 30, 'foo2', 'foobar3'] 

---

如果有人想知道列表末尾发生了什么，

next（a）

将引发

StopIteration

。异常终止生成器

my_函数

，但在其上迭代的代码（在本例中为

list（）

）将其识别为迭代的正常结束。

使用

zip

和

iter

的组合对现有函数的其他选项（解释）：

---

使用

zip

和

iter

组合的现有选项的其他选项（解释）：

为此，我发现它最优雅，对元素/动作的数量最有弹性：

导入itertools
def my_功能（a）：
操作=itertools.cycle(
（lambda l:l*10，lambda l:l，lambda l:foo+l）
)
对于val，itertools.izip中的操作（a，操作）：
屈服作用（val）
a=[2，“foo1”，“bar1”，5，“foo3”，“bar2”，3，“foo2”，“bar3”，7]
打印列表（my_功能（a））

结果:

[20, 'foo1', 'foobar1', 50, 'foo3', 'foobar2', 30, 'foo2', 'foobar3', 70]

正如您从示例中看到的，即使元素计数不是操作计数的乘法（或甚至小于操作计数），这也会起作用

这是python2版本，如果您需要3，请指定。

使用它，我发现它最优雅，对元素/动作的数量最有弹性：

导入itertools
def my_功能（a）：
操作=itertools.cycle(
（lambda l:l*10，lambda l:l，lambda l:foo+l）
)
对于val，itertools.izip中的操作（a，操作）：
屈服作用（val）
a=[2，“foo1”，“bar1”，5，“foo3”，“bar2”，3，“foo2”，“bar3”，7]
打印列表（my_功能（a））

结果:

[20, 'foo1', 'foobar1', 50, 'foo3', 'foobar2', 30, 'foo2', 'foobar3', 70]

正如您从示例中看到的，即使元素计数不是操作计数的乘法（或甚至小于操作计数），这也会起作用

---

这是python2版本，如果您需要3，请指定。

假设

a

列表作为函数的输入

def my_function(a):
   a[::3] = map(lambda x: 10*x, a[::3])
   a[2::3] = map(lambda x: "foo"+x, a[2::3])

---

在这里，我将在python中使用。我认为这更像是一种python方式。

假设一个

列表作为函数的输入

def my_function(a):
   a[::3] = map(lambda x: 10*x, a[::3])
   a[2::3] = map(lambda x: "foo"+x, a[2::3])

在这里，我将在python中使用。我认为这更像是一种pythonic的方式。
这是
C
类似的方式，而不是
pythonic
。因此，如果你知道
C
，你只需几秒钟就能理解它

def my_function(a):
    for n, line in enumerate(a):
        if n % 3 == 0:
            line = line * 10
        elif n % 3 == 2:
            line = "foo" + line
        print line

这是
C
类似的方式，而不是
Pythonic
。因此，如果你知道
C
，你只需几秒钟就能理解它

def my_function(a):
    for n, line in enumerate(a):
        if n % 3 == 0:
            line = line * 10
        elif n % 3 == 2:
            line = "foo" + line
        print line

我喜欢这个，yeild似乎是正确的选择，尽管我还没有完全理解它。你能给我解释一下你函数的第二行吗？这似乎就是神奇发生的地方。首先看看
xrange
——它将产生从0开始的每三个数字，直到（但不包括）列表的长度。所以…，
0,3,6,9，…
。从那里，它只是一个简单的切片来提取3个元素<代码>lst[0:3]、lst[3:6]、lst[6:9]、…

。这3个元素的列表是从

项生成器中拉出的
组。啊，是的，这非常好。虽然不确定哪一个答案是最好的，但它们都是很好的建议。我喜欢这个，yeild似乎是正确的选择，尽管我还没有完全理解它。你能给我解释一下你函数的第二行吗？这似乎就是神奇发生的地方。首先看看
xrange
——它将产生从0开始的每三个数字，直到（但不包括）列表的长度。所以…，
0,3,6,9，…
。从那里，它只是一个简单的切片来提取3个元素<代码>lst[0:3]、lst[3:6]、lst[6:9]、…
。这3个元素的列表是从
项生成器中拉出的
组。啊，是的，这非常好。但不确定哪种答案是最好的，它们都是好建议。是的，正准备提出这个建议。不过，我会将iter移动到我的函数内部，我应该想到这一点