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

我想以一个长字符串的形式将数字行附加到一个列表中，该列表基于它们的行。例如，我提前知道每一行有4位数字，从01到99，总共有3行。您如何通过字符串，将每个数字转换为整数，并将其放入正确的列表中，以显示它所在的行

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]]

---

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

这将行中的所有元素存储为字符串，因为您希望在输出中包含

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

---

这会将行中的所有元素存储为字符串，因为您希望在输出中包含

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

或者，代替for循环，您可以再次使用列表理解

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

或者，代替for循环，您可以再次使用列表理解

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

---

这就是我要做的

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])

---

希望这有帮助

这就是我要做的

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])

希望这有帮助

使用：

或

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

>>> 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]]

使用：

或

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

>>> 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]]

---

答案已经很好了。如果您对列表理解和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)

---

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

答案已经很好了。如果您对列表理解和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)

---

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

我可能会这样做

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

---

我可能会这样做

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

还有，基于同样的想法

n = 4

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

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

还有，基于同样的想法

n = 4

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

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

---

01可以是字符串，但如果它是整数，它将自动为1。是的，这是正确的，我写得很清楚。01可以是字符串，但如果它是整数，它将自动为1。是的，这是正确的，我写得很清楚。你为什么要删除那个元素，为什么它会神奇地改变这个：

[['01'，02'，03'，04']，['01'，02'，03'，04']，['01'，02'，03'，04']，['01'，02'，03'，04'，03'，04']，['01'，02'，03'，04']，['11'，12'，13'，14']，['21'，22'，23'，24']

？为什么要删除那个元素，为什么它会神奇地把它变成：

['01'，02'，03'，04']，[01'，02'，03'，04']，[01'，02'，03'，04']，[01'，02'，03'，04'，11'，12'，13'，14'，21'，22'，23'，24']]进入[[01'，02'，03'，04']，[11'，12'，13'，14']，[21'，22'，23'，24']

？