Quel est le moyen le plus simple mais pas le plus rapide de formater cette chaîne en une liste? Python

Question

Je veux ajouter des lignes de chiffres sous la forme d'une longue chaîne à ajouter à une liste dans une liste en fonction de leur ligne. Par exemple, je sais à l'avance que chaque rangée a 4 chiffres qui ne peuvent aller jusqu'à 99 qu'à partir de 01, et il y a un total de 3 lignes. Comment auriez-vous traversé la chaîne, transformer chaque nombre en un int et le mettre dans la bonne liste pour montrer dans quelle rangée il se trouve?

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

Je dois prendre des centaines de ces points de données en lignes, mais de comprendre le concept je reste petit dans l'exemple. Je ne cherche pas la façon la plus concise et professionnelle de gérer le problème, juste une méthode qui se lit facilement serait mieux.

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

Ou, au lieu de la boucle, vous pouvez utiliser à nouveau la compréhension de la liste.

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

Answer 2

Ceci stocke tous les éléments des lignes sous forme de chaînes car vous vouliez des éléments comme 01 dans votre sortie. Puisque vous vouliez simplement simple/facile à lire, c'est probablement très bien.

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

C'est ce que je ferais ...

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

Hope this helps!

Answer 4

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

ou

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

Si vous ne me dérange pas si les éléments internes sont tuples vs listes, vous pouvez le faire:

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

ZIP tronquer tous les groupes incomplets. S'il est possible que vos vos lignes sont inégales, utilisez une tranche:

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

Si vous voulez une recette intertools, utilisez la recette de mérou:

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

bonnes réponses déjà. Voici une approche méthodique, si vous n'êtes pas à l'aise avec compréhensions de liste et 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) 

Ensuite morceaux contient ce que vous voulez, et tout à gauche sur les bits si votre chaîne d'origine est pas un multiple entier de la taille de votre groupe.

Answer 6

Je ferais probablement cela.

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

Vous pouvez faire sans la dernière carte si vous êtes d'accord avec une liste de tuples. Avant d'apprendre l'idiome de l'utilisation de zip, j'aurais probablement utilisé le découpage, un autre idiome pour grouper des éléments d'une séquence.

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

Si vous cherchez « une méthode qui se lit facilement », je pense que cela devrait faire.

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

En outre, sur la même idée

n = 4 

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

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