Pas de modules s'il vous plaît.
J'ai une liste de listes de nombres et une chaîne vide.
new_lst = []
for i in range(3):
lst = ['', 0.0, 0.1, 0.2] , ['', 0.1, 0.2, 0.3], [0.1, 0.1, 0.2, 0.3]]
lst = [x for x in lst if x!= '']
#do calculations here . for example, for x in lst, add 1.0
new_lst.append(lst)
new_lst[:1].insert(0, '')
print(new_lst)
#expected output:
new_lst = [['', 1.0, 1.1, 1.2] , ['', '', 1.2, 1.3], [1.1, 1.1, 1.2, 1.3]]
J'ai utilisé
new_lst[:1].insert(0, '')
pour supprimer ''.
J'ai un tas de calculs après cela, donc j'ai dû supprimer '' (à moins qu'il n'y ait d'autres moyens de faire des calculs et d'ignorer tous les str?). Après ces calculs, je veux pouvoir insérer le '' retour là où le '' a été supprimé sans avoir à taper l'index comme ceci:
lst = [x for x in lst if x!= '']
J'ai besoin d'un code qui trouve partout où le "" a été supprimé et réinsère "" dans cet index.
new_lst = [['', 0.0, 0.1, 0.2] , ['', '', 0.2 , 0.3], [0.1, 0.1, 0.2, 0.3]]
4 Réponses :
Vous pouvez utiliser la compréhension de liste:
def logic_func(x):
return x+ 1.0
single_lst = ['', 0.0, 0.1, 0.2]
new_single_lst = [logic_func(x) if x != '' else x for x in single_lst]
print(new_single_lst)
De cette façon, vous n'appliquez la logique qu'aux chaînes non vides.
Vous pouvez écrire if x! = '' comme if x . Je pense que c'est plus propre.
Ce sera un problème avec des valeurs nulles.
Ouais! Bien remarqué, @Michal Yanko
C'est mieux (plus propre, plus court, plus simple) que ma solution et fonctionne également bien si plusieurs citations sont présentes dans une liste.
En supposant que vous n'ayez pas besoin de toutes les valeurs de la liste à la fois. Ensuite, vous pouvez:
lists = [['', 0.0, 0.1, 0.2], ['', 0.1, 0.2, 0.3], [0.1, 0.1, '', 0.2, 0.3]]
for lst in lists:
try:
split_index = lst.index('')
first_part = lst[:split_index]
second_part = lst[split_index + 1:]
# perform calculation
# join lists again and insert the quotes in the correct place
new_list = first_part + [''] + second_part
except ValueError:
# no need to split and join here, you can just use the complete list
# perform calculation
new_list = lst
[['', 1.0, 1.1, 1.2], ['', 1.1, 1.2, 1.3], [1.1, 1.1, 1.2, 1.3]]
Cela devrait faire ce que vous avez demandé: supprime, calcule et réinsère.
Dans l'exemple suivant, j'ajoute max et min à chaque valeur:
[['', 0.2, 0.30000000000000004, 0.4], ['', '', 0.7, 0.8], [0.5, 0.5, 0.6000000000000001, 0.7]]
Sortie:
new_lst = [['', 0.0, 0.1, 0.2] , ['', '', 0.2 , 0.3], [0.1, 0.1, 0.2, 0.3]]
def foo(subl):
# get indxes and remove empty strings
indx = [i for i, x in enumerate(subl) if x == ""]
subl = list(filter(lambda x: x != "", subl))
# do calculations here
M, m = max(subl), min(subl)
subl = [x + (M+m) for x in subl]
# empty strings back
[subl.insert(i, "") for i in indx]
return subl
new_lst = [foo(subl) for subl in new_lst]
new_lst
Avez-vous besoin de toutes les valeurs de la liste en même temps? Sinon, je diviserais simplement la liste en 2 listes, effectuerais les calculs, puis les rejoindrais à nouveau.
Est-il garanti qu'il n'y aura qu'une seule valeur
''dans chaque liste? Si tel est le cas, vous pouvez utiliserlst.index ('')pour trouver le premier index d'une chaîne vide@ G.Anderson a édité mon message. Ma liste actuelle de listes est longue et certaines d'entre elles en ont plus d'une ''.
dans l'un de vos commentaires, vous avez dit que vos «calculs» peuvent être une opération
max,minsur une sous-liste. Mais en faisant cela, les longueurs de vos sous-listes vont changer, donc ma question: les chaînes vides sont-elles toutes situées au début d'une sous-liste? Si non, où souhaitez-vous les réinsérer?