Что такое самый простой, но не самый быстрый способ форматирования этой строки в список? Python

Question

Я хочу добавить строки цифр в виде одной длинной строки, которая будет добавлена ​​в список внутри списка на основе их строки. Например, я знаю заранее, что каждая строка имеет 4 цифры, которые могут достигать 99 с 01, и всего 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

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

Или, вместо того, чтобы цикл, вы можете использовать список понимание снова.

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

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

Это то, что я хотел бы сделать ...

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