在python

时间：2018-06-21 02:57:43

标签： python python-3.x list iterator

说我名单很长：

>>> import string
>>> my_list = list(string.ascii_lowercase)
>>> my_list
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']

我想遍历此列表并重复按顺序选择n个项目。例如。如果我要选择5个项目，则应为：

step 1: ['a', 'b', 'c', 'd', 'e']
step 2: ['f', 'g', 'h', 'i', 'j']
step 3: ['k', 'l', 'm', 'n', 'o']
step 4: ['p', 'q', 'r', 's', 't']
step 5: ['u', 'v', 'w', 'x', 'y']
step 6: ['z', 'a', 'b', 'c', 'd']
step 7: ['e', 'f', 'g', 'h', 'i']
......

因此，重点是：我想确保当我到达列表的最后一项时，可以将第一项添加到最后一项，并且循环将继续进行。

为了将第一个项目附加到最后一个项目，我已经尝试过这样的事情：

def loop_slicing(lst_, i):
    """ Slice iterable repeatedly """
    if i[0] > i[1]:
        return [n for n in lst_[i[0]:]+lst_[:i[1]]]
    else:
        return lst_[i[0]:i[1]]

调用此函数时，可以执行以下操作：

>>> loop_slicing(my_list, (0, 5))
['a', 'b', 'c', 'd', 'e']
>>> loop_slicing(my_list, (25, 4))
['z', 'a', 'b', 'c', 'd']

我可以在其中生成一个可以在range(0, 26)中生成5个序号的生成器，以循环遍历my_list并每次获取5个项。

我不知道这是否是最好的方法。那么，有没有更有效的方法来做这些事情？

5 个答案:

答案 0 :(得分：4)

使用PHAssetChangeRequest.creationRequestForAssetFromVideo(atFileURL: newURL)模块，您可以通过无限生成器循环和切片字符串：

itertools

答案 1 :(得分：0)

使用列表理解的解决方案简单得多：

def batch_list(ns, batch_size):
    return [ns[i:i+batch_size] for i in range(0, len(ns), batch_size)]

>>> batch_list('abcdefghijk', 3) 
['abc', 'def', 'ghi', 'jk']

这是一个简单的结构，当我想批量执行一些任务列表时，我发现自己经常写。

编辑：刚意识到OP会要求构造从头到尾循环以完成最后一批（如果需要）。这不会这样做，并且最后一批将被截断。

答案 2 :(得分：0)

感谢您的提问，

我花了一些时间来了解算法的目标，但是如果您想循环并保存所有子列表，我认为这应该可以工作：

confirmDelete(item) {
    this.confirmationService.confirm({
      ...
      accept: () => {
        this.appService.deleteUser(item.id).subscribe(res => {
            this.employeeTemp = this.employeeTemp.filter(employee => employee.id != item.id)
            this.dataSource = new MatTableDataSource(this.employeeTemp);
            //this.dataSource.data = this.employeeTemp; <=== You can also change only data
            ...
          },
          ...
      }
      ...
    });
}

输出：

def slicing_items(slc_len = 5, lst, iterate_num = 25):
# slc_len correspond to the number of slices, lst is the list of sequences
n = len(lst)
k = 1
p = k * slc_len
slicing_list = []
while k < iterate_num:
    current_slice = []
    if p >= n:    
        for i in range (1, p//n):
            current_slice += lst                  #How many times we passed the length of the list
        p = p % n                                 #How many items remaining ?
        current_slice += lst[-(slc_len-p):] 
        current_slice += lst[:p]

    else:
        current_slice = lst[p-slc_len:p]
    k += 1
    p += slc_len
    slicing_list.append(current_slice)

return slicing_list

但是，如果只希望将最后一个切片放在slicing_items(5,my_list,10) >>> [['a', 'b', 'c', 'd', 'e'], ['f', 'g', 'h', 'i', 'j'], ['k', 'l', 'm', 'n', 'o'], ['p', 'q', 'r', 's', 't'], ['u', 'v', 'w', 'x', 'y'], ['z', 'a', 'b', 'c', 'd'], ['e', 'f', 'g', 'h', 'i'], ['j', 'k', 'l', 'm', 'n'], ['o', 'p', 'q', 'r', 's']] 上，则您的函数应该非常合适（也许您应该使用切片而不是为了快速而重写第一个布尔语句中的列表）

答案 3 :(得分：0)

使用生成器和切片：

from string import ascii_lowercase

def gen(x, n):
    start, stop = 0, n
    while True:
        if start < stop:
            yield list(x[start:stop])
        else:
            yield ((list(x[start:])) + (list(x[:stop])))
        start = stop
        stop = (stop + n) % len(x)


G = gen(ascii_lowercase, 5)

print(next(G))  # ['a', 'b', 'c', 'd', 'e']
print(next(G))  # ['f', 'g', 'h', 'i', 'j']
print(next(G))
print(next(G))
print(next(G))  # ['u', 'v', 'w', 'x', 'y']
print(next(G))  # ['z', 'a', 'b', 'c', 'd']
print(next(G))

输出：

['a', 'b', 'c', 'd', 'e']
['f', 'g', 'h', 'i', 'j']
['k', 'l', 'm', 'n', 'o']
['p', 'q', 'r', 's', 't']
['u', 'v', 'w', 'x', 'y']
['z', 'a', 'b', 'c', 'd']
['e', 'f', 'g', 'h', 'i']

答案 4 :(得分：0)

这是一个非常有趣的问题，如果您想“只是”解决问题，请使用itertools循环方法，它已经内置了功能，但是如果您想享受算法构建的乐趣，请自行尝试解决方案并尝试一些方法：

我在这里尝试了递归方法，正如您所说的那样，它将继续进行，因此您必须通过设置最大限制来处理递归：

import math
import sys
sys.setrecursionlimit(500)

data=['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
try:
    def recursive_approch(m, x, n, hold=0, value=0, left=0):
        print(hold)

        max_time = len(m) / n
        max_t = int(math.modf(max_time)[1])
        left = len(m) % n

        if value == max_t:

            if len(x) == left:
                x = x + m[:-len(x)]
                value = 0
                left = 0
        else:

            hold = x[:n]
            value = value + 1
            return recursive_approch(m, x[n:], n, hold=hold, value=value, left=left)
        return recursive_approch(m, x, n, hold=hold, value=value, left=left)


    print(recursive_approch(data, data, 6))
except RecursionError:
    print('maximum recursion')

您必须传递切片的编号，因此，如果要切片6-6，则： 打印（recursive_approch（数据，数据，6）） 输出：

['a', 'b', 'c', 'd', 'e', 'f']
['g', 'h', 'i', 'j', 'k', 'l']
['m', 'n', 'o', 'p', 'q', 'r']
['s', 't', 'u', 'v', 'w', 'x']
['s', 't', 'u', 'v', 'w', 'x']
['y', 'z', 'a', 'b', 'c', 'd']
['e', 'f', 'g', 'h', 'i', 'j']
['k', 'l', 'm', 'n', 'o', 'p']
['q', 'r', 's', 't', 'u', 'v']
['q', 'r', 's', 't', 'u', 'v']
['w', 'x', 'a', 'b', 'c', 'd']
['e', 'f', 'g', 'h', 'i', 'j']
['k', 'l', 'm', 'n', 'o', 'p']
['q', 'r', 's', 't', 'u', 'v']
['q', 'r', 's', 't', 'u', 'v']
['w', 'x', 'a', 'b', 'c', 'd']
['e', 'f', 'g', 'h', 'i', 'j']
...................

如果您想要3-3，则：

['a', 'b', 'c']
['d', 'e', 'f']
['g', 'h', 'i']
['j', 'k', 'l']
['m', 'n', 'o']
['p', 'q', 'r']
['s', 't', 'u']
['v', 'w', 'x']
['v', 'w', 'x']
['y', 'z', 'a']
['b', 'c', 'd']
['e', 'f', 'g']
['h', 'i', 'j']
['k', 'l', 'm']
['n', 'o', 'p']
['q', 'r', 's']
['t', 'u', 'v']
['t', 'u', 'v']
['w', 'x', 'a']
['b', 'c', 'd']
['e', 'f', 'g']
['h', 'i', 'j']
['k', 'l', 'm']
['n', 'o', 'p']
['q', 'r', 's']
['t', 'u', 'v']
['t', 'u', 'v']
['w', 'x', 'a']
['b', 'c', 'd']
['e', 'f', 'g']
['h', 'i', 'j']
['k', 'l', 'm']
['n', 'o', 'p']
['q', 'r', 's']
['t', 'u', 'v']
['t', 'u', 'v']
['w', 'x', 'a']
['b', 'c', 'd']
['e', 'f', 'g']
['h', 'i', 'j']
['k', 'l', 'm']
['n', 'o', 'p']
['q', 'r', 's']
['t', 'u', 'v']
['t', 'u', 'v']
['w', 'x', 'a']
['b', 'c', 'd']
.......

如果您通过12：

0
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l']
['m', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x']
['m', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x']
['y', 'z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
['k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v']
['k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v']
['w', 'x', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
['k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v']
['k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v']
['w', 'x', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
['k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v']
['k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v']
['w', 'x', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
['k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v']
['k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v']
['w', 'x', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
['k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v']
['k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v']
....
相关问题
最新问题