Question

我希望以一个长字符串的形式追加数字行，以根据行的行将其附加到列表内的列表中。例如，我提前知道每行有4个数字，从01开始只能达到99，总共有3行。你如何通过字符串，将每个数字转换成一个int并将其放在正确的列表中以显示它在哪一行？

myStr = "01 02 03 04 11 12 13 14 21 22 23 24"
myList = [[01, 02, 03, 04],[11, 12, 13, 14],[21, 22, 23, 24]]

我需要将数百个这些数据点分成几行，但要理解我在示例中保持较小的概念。我不是在寻找最简洁和专业的方法来处理这个问题，只是一个简单易读的方法会更好。

Answer 1

这就是我要做的......

numDigits = 4 #Number of digits per row
a = [int(val) for val in myStr.split()]
myList = []
for i in arange(0, len(a), numDigits):
    myList.append(a[i:i+numDigits])

希望这有帮助！

Answer 2

这会将行的所有元素存储为字符串，因为您需要输出中的01等元素。既然你只想简单/易读，这可能就好了。

nums = myStr.split(' ')

myList[]
li=[]

int i = 0;
for n in nums:
    if i == 4:
        i = 0
        myList.append(list)
        li= []
    li.append(n)
    i += 1

Answer 3

myStr = "01 02 03 04 11 12 13 14 21 22 23 24"
myStr= [int(n) for n in myStr.split()]
myList=[]
for i in xrange(0,len(myStr),4):
    myList.append(myStr[i:i+4])

或者，您可以再次使用列表推导而不是for循环。

myList=[myStr[i:i+4] for i in xrange(0,len(myStr),4)]

Answer 4

使用zip：

>>> myStr = "01 02 03 04 11 12 13 14 21 22 23 24"
>>> n=4
>>> myList=[list(t) for t in zip(*[(int(x) for x in myStr.split())]*n)]
>>> myList
[[1, 2, 3, 4], [11, 12, 13, 14], [21, 22, 23, 24]]

或

>>> myList=map(list,zip(*[(int(x) for x in myStr.split())]*n))

如果你不介意内部元素是元组还是列表，你可以这样做：

>>> zip(*[(int(x) for x in myStr.split())]*n)
[(1, 2, 3, 4), (11, 12, 13, 14), (21, 22, 23, 24)]

Zip将截断任何不完整的组。如果您的行可能不均匀，请使用切片：

>>> myList=map(int,myStr.split())
>>> n=5
>>> [myList[i:i+n] for i in range(0,len(myList),n)]   # use xrange on Py 2k...
[[1, 2, 3, 4, 11], [12, 13, 14, 21, 22], [23, 24]]

如果您需要intertools配方，请使用石斑鱼配方：

>>> from itertools import izip_longest
def grouper(iterable, n, fillvalue=None):
    "Collect data into fixed-length chunks or blocks"
    # grouper('ABCDEFG', 3, 'x') --> ABC DEF Gxx
    args = [iter(iterable)] * n
    return izip_longest(fillvalue=fillvalue, *args)

>>> map(list,grouper(map(int,myStr.split()),4))
[[1, 2, 3, 4], [11, 12, 13, 14], [21, 22, 23, 24]]

Answer 5

已经有了很好的答案。如果你对列表推导和xrange不满意，这是一种有条不紊的方法：

# get or build your string
myStr = "01 02 03 04 11 12 13 14 21 22 23 24"

#set a group size
GROUP_SZ = 4

item_list=myStr.split(' ')
groups= len(item_list)
chunks=[]

for j in range(groups/GROUP_SZ):
    slice=item_list[:GROUP_SZ]
    del item_list[:GROUP_SZ]
    chunks.append(slice)

# account for left over bits, if myStr is not a multiple of GROUP_SZ
if len(item_list) > 0:
   chunks.append( item_list)

然后，如果您的原始字符串不是您的组大小的整数倍，则块包含您想要的内容以及任何剩余的位。

Answer 6

我可能会这样做。

def gridify(s, cols):
    ls = map(int, s.split())
    return map(list, zip(*[iter(ls)]*cols))

如果你对元组列表没问题，你可以不用最后一张地图。在我了解使用zip的习语之前，我可能会使用切片，这是另一个用于对序列中的元素进行分组的习惯用法。

def gridify(s, cols):
    flatList = map(int, s.split())
    return [flatList[x:x+cols] for x in range(0, len(flatList), cols)]

如果您正在寻找“一种易读的方法”，我认为应该这样做。

def gridify(s, rows, cols):
    flatList = s.split()
    gridList = []
    for r in range(rows):
        rowList = []
        for c in range(cols):
            ind = (r * rows) + c
            val = flatList[ind]
            rowList.append(int(val))
        gridList.append(rowList)
    return gridList

Answer 7

import re

myStr = "01 02 03 04 11 12 13 14 21 22 23 24"

n = 4
print [map(int,x)
       for x in re.findall(n *('(\d\d?) *'),myStr)]

另外，同样的想法

n = 4

def fff(x):
    return map(int,x)

print map(fff, re.findall(n *('(\d\d?) *'),myStr))

将此字符串格式化为列表的最简单但不是最快的方法是什么？蟒蛇

7 个答案: