Je suis nouveau sur Python et je n'arrive pas à corriger mon erreur avec une quantité quelconque de Google. Je veux diviser une liste en utilisant une boucle, mais je ne parviens pas à obtenir la syntaxe correcte.
Traceback (most recent call last):
File "C:\Users\EALDEN3\Documents\Python Code\Scratch.py", line 5, in <module>
alist[n] = alist[n].split("|")
TypeError: list indices must be integers or slices, not str
Ce qui précède fonctionne pour le cas de la division de la première entrée de la première entrée, mais je voudrais diviser la première entrée de chaque élément de la liste.
Sortie donnée:
alist = ["aa-aa-aa-aa|bb|cc","bb-bb-bb|abc|ab","cc-cccc-cc|abc|a"]
n = 0
for n in alist:
alist[n] = alist[n].split("|")
alist[n][0] = alist[n][0].split("-")
print(alist)
Sortie souhaitée:
[[['aa', 'aa', 'aa', 'aa'], 'bb', 'cc'], [['bb','bb','bb'],'abc','ab'], [['cc','cccc','cc'],'abc','a']
Cependant quand j'essaye de boucler comme Je voudrais pour un fichier, j'obtiens une erreur.
[[['aa', 'aa', 'aa', 'aa'], 'bb', 'cc'], 'bb-bb-bb|abc|ab', 'cc-cccc-cc|abc|a']
Message d'erreur:
alist = ["aa-aa-aa-aa|bb|cc","bb-bb-bb|abc|ab","cc-cccc-cc|abc|a"]
alist[0] = alist[0].split("|")
alist[0][0] = alist[0][0].split("-")
print(alist)
Toute aide serait grandement appréciée.
4 Réponses :
Dans une boucle for n est l'élément et non l'index, vous devez faire la boucle différemment si vous voulez travailler avec des index:
result = [[val.split('-') if index == 0 else val for index, val in enumerate(substr.split('|'))] for substr in alist]
Pourquoi ne voudrais-je pas faire l'opération en place?
Cela dépend de votre cas d'utilisation. Parfois, vous voulez faire quelque chose en place, d'autres fois vous ne voulez pas toucher l'entrée d'origine. Donc, c'est juste la préférence de l'utilisateur. Je voulais juste m'assurer que vous reconnaissiez qu'avec cette solution, alist changera.
Je l'ai. Vous disiez que j'écrasais ma liste d'origine au lieu d'en créer une nouvelle. (Je travaille sur l'amélioration de mes connaissances en jargon)
Question rapide: Vous dites que le code à une seule ligne est plus efficace. Voulez-vous dire en termes d'espace ou traite-t-il réellement les données plus efficacement? (D'autres `` nouveaux '' utilisateurs utiliseront mon code et je préfère la lisibilité à l'efficacité.)
@EmilyAlden Je voulais dire plus efficace que les autres réponses en une seule ligne (ce sera proche de l'efficacité de votre réponse actuelle). Je recommande vivement de vous en tenir au code que vous avez obtenu (la lisibilité compte). Quelqu'un qui connaît beaucoup de python n'aura pas beaucoup de mal à lire la compréhension de liste avancée, mais ce n'est certainement pas amusant à lire pour les débutants ou les novices :). (Surtout que méchant d'une compréhension de liste).
Vous pouvez essayer une compréhension de liste imbriquée pour ceci:
[[['aa', 'aa', 'aa', 'aa'], 'bb', 'cc'], [['bb', 'bb', 'bb'], 'abc', 'ab'], [['cc', 'cccc', 'cc'], 'abc', 'a']]
Sortie :
alist = ["aa-aa-aa-aa|bb|cc","bb-bb-bb|abc|ab","cc-cccc-cc|abc|a"]
alist = [[j.split('-') if j.count('-')>0 else j for j in i.split('|')] for i in alist]
[Corrigé] J'aime les compréhensions de liste et je pense que cela fonctionnera:
[[['aa', 'aa', 'aa', 'aa'], 'bb', 'cc'], [['bb', 'bb', 'bb'], 'abc', 'ab'], [['cc', 'cccc', 'cc'], 'abc', 'a']]
Ceci est juste une boucle sur chaque élément de la liste originale, puis divisée sur le '|' puis diviser sur «-» si «-» est dans la sous-chaîne.
Le résultat est:
alist = ["aa-aa-aa-aa|bb|cc","bb-bb-bb|abc|ab","cc-cccc-cc|abc|a"]
output = [[y.split('-') if '-' in y else y for y in x.split('|')] for x in alist]
print(output)
Cela ne correspond pas à la sortie souhaitée.
argh, oups. Etre prêt
@ Error-SyntacticalRemorse - devrait être corrigé maintenant ... pas aussi court ....
Agréable. Cependant, juste pour que vous sachiez que l'appel dans signifie que vous le ferez deux fois (une fois [ou juste partiellement] pour rechercher - et un autre pour effectuer le fractionnement réel) , plus vous le faites pour chaque entrée et pas seulement pour la première). Ma solution est plus sujette aux bogues (car elle suppose que le premier élément de la liste sera divisé par - ) que le vôtre et le mien ne divisera jamais que le premier champ. C'est donc juste une autre solution valable :). (La vôtre est plus rapide que l'autre réponse cependant).
@ Error-SyntacticalRemorse True sur le dans , mais étant donné le type d'algorithme, je ne pense pas que dans va réellement faire une vérification sur chaque caractère. Je pense qu’elle s’arrête quand elle trouve la première correspondance. (Mais je n'ai pas de documentation pour sauvegarder ma pensée). Je pense que dans devrait être plus efficace qu’une opération count car in va exister. (??)
Corriger dans est plus efficace que count car il court-circuite. (c'est pourquoi votre réponse est plus rapide que l'autre).
[ [x.split('|')[0].split('-')]+ x.split('|')[1:] for x in alist]
the above works, however split('|') will be called twice per item in alist