Question de débutant sur la modification de la liste python

Lorsque vous souhaitez ajouter un mot dans la liste en tant qu'élément.

utilise généralement .append ()

fhand = open("words.txt")
words = list()
for line in fhand:
    for word in line.split():
        words.append(word)
print(words)

Word est une chaîne, qui est elle-même une collection d'objets (caractères), si vous avez utilisé word [0] , vous obtiendrez le 1er élément du mot , par défaut les listes python conservent les types de données, donc une collection de caractères reste une collection de caractères lorsque vous l'ajoutez à la liste et donne une liste de caractères, dans le second cas vous déclarez explicitement que vous voulez ajouter [mot] à la liste, et non ses caractères, cela devient donc une liste de chaînes. Si ce n'est toujours pas clair, n'hésitez pas à commenter.

vous ne pouvez ajouter qu'une liste à la liste, donc lorsque vous ajoutez une chaîne à la liste, vous traitez la chaîne comme une liste de caractères afin qu'elle ajoute les caractères en tant qu'éléments, dans un second temps, vous avez déclaré que vous avez une liste et le mot est l'élément lui-même donc il ajoute le mot entier comme élément.

En python, une chaîne elle-même est en interne une liste de caractères 'unicode', bien que considérés comme un type de données différent. Alors quand tu fais mots + = mot il ajoute chaque nouveau caractère à la liste vide. Mais lorsque vous faites words + = [word] , [word] est considéré comme une liste d'une seule chaîne, il ajoute donc un seul élément à la liste vide

L'opérateur + = sur une liste équivaut à appeler son extend , qui prend un itérable comme argument et ajoute chaque élément à la liste. Avec words + = word , l'opérande de droite de + = est une chaîne, qui est un itérable, donc équivaudrait à écrire words.extend (word ) .

Passons en revue votre code:

Considérez que words.txt se compose du texte suivant:

with open("words.txt", 'r') as fhand:
    words = [word for line in fhand for word in line.split()]
print(words)
#Output:
['hello,', 'I', 'am', 'Solomon', 'Nice', 'to', 'meet', 'you', 'Solomon']

Donc, vous ouvrez d'abord ceci fichier avec fhand = open ("words.txt") , puis vous initialisez une liste appelée words:

print(words1==final_concatenation)
#True

Suggestion : Ici, il est conseillé d'utiliser le gestionnaire de contexte avec pour ouvrir le fichier. De cette façon, vous n'auriez pas à fermer le fichier explicitement ultérieurement. Si vous utilisez simplement open () comme ci-dessus, vous devrez fermer le fichier à la fin avec fhand.close().

words1 = list()
words_splitted = ["Hello", "World"]
for word in words_splitted:
  words1.append(word)
print(words1)
#['Hello', 'World']

Dans la ligne suivante, vous parcourez chaque ligne de f et . Permet d'imprimer ligne qui montre essentiellement chaque ligne dans le texte:

words = list()
word = ["Hello"]
concat_words = words + word
print(concat_words)
#['Hello']
another_word = ["World"]
concat_some_more_words = words + another_word
print(concat_some_more_words)
#['World']
final_concatenation = concat_words + concat_some_more_words
print(final_concatenation)
#Output:
['Hello', 'World']

Ensuite, vous itérez sur line.split () code > qui divise les lignes de texte ci-dessus en listes individuelles de mots. Si nous imprimons line.split():

print([word])
#Output:
['hello,']
['I']
['am']
['Solomon']
['Nice']
['to']
['meet']
['you']
['Solomon']

Suggestion : Vous pouvez également utiliser splitlines () pour diviser chaque ligne (limite) en une liste séparée. Ceci est différent de split () car il ne divise pas chaque ligne en mots. Cette méthode préserve également les espaces, vous devrez donc vous en débarrasser avec strip ('') si votre texte a des espaces à la fin ou au début. Cette méthode n'a pas d'effets secondaires et vous pouvez toujours l'utiliser:

for word in line.split():
    words += [word]
print(words)
#Output:
['hello,', 'I', 'am', 'Solomon', 'Nice', 'to', 'meet', 'you', 'Solomon']

Dans le morceau de code suivant, vous itérez sur chaque (mot? Ou plutôt lettre) dans line.split () (comme vous le savez, nous avons déjà reçu une liste de mots avec cette méthode) puis incrémentation de mots avec le jeu de lettres pour chaque mot . Donc, en gros, vous obtenez un ensemble de lettres parce que vous avez itéré sur chaque mot dans les listes:

for word in line.split():
    words.append(word)
#Output:
['hello,', 'I', 'am', 'Solomon', 'Nice', 'to', 'meet', 'you', 'Solomon']

Mais vous vous attendez probablement à une liste de mots dans une seule liste mots . Nous pouvons y parvenir avec la méthode append () car elle prend chaque mot dans line.split () et ajoute simplement (ou ajoute au fin de la liste) à words:

for word in line.split():
    words+=word
#Output:
['h', 'e', 'l', 'l', 'o', ',', 'I', 'a', 'm', 'S', 'o', 'l', 'o', 'm', 'o', 'n', 'N', 'i', 'c', 'e', 't', 'o', 'm', 'e', 'e', 't', 'y', 'o', 'u', 'S', 'o', 'l', 'o', 'm', 'o', 'n']

Et puis quand on regarde l'autre variante words + = [word] code>:

for line_str in fhand:
    print(line_str.strip(' ').splitlines())
    #Output:
    ['hello, I am Solomon']
    ['Nice to meet you Solomon']
    for line in line_str.strip(' ').splitlines(): #watch the indentation
        print(line.split())
        #Output:
        ['hello,', 'I', 'am', 'Solomon']
        ['Nice', 'to', 'meet', 'you', 'Solomon']

Cela a le même effet que append () . Pourquoi est-ce si? Permet d'imprimer [mot] qui n'est rien d'autre qu'une liste de chaque mot. Ceci est normal car vous prenez chaque mot de line.split () , puis concaténez en mots :

for line in fhand:
    print(line.split())
#Output:
['hello,', 'I', 'am', 'Solomon']
['Nice', 'to', 'meet', 'you', 'Solomon']

mots + = [mot] équivaut à mots = mots + [mot] . Pour voir comment cette concaténation fonctionne, considérez l'exemple suivant qui équivaut à cette instruction:

for line in fhand:
    print(line)
#Output:
hello, I am Solomon

Nice to meet you Solomon

Essayons append () sur cet exemple:

with open("words.txt", 'r') as fhand:
    #<--code--->

Cela montre que la concaténation équivaut à l'ajout, mais il est recommandé d'utiliser append () pour les listes:

fhand = open("words.txt")
words = list()

Revenant à la question initiale, rendons le code plus compact en utilisant des listes de compréhension:

hello, I am Solomon
Nice to meet you Solomon

Vous remarquerez que j'ai utilisé le avec gestionnaire de contexte pour laisser le fichier ouvert / proche de Python une fois le travail terminé (quitte le contexte). Ensuite, j'ai créé une liste de mots avec les mêmes boucles à l'intérieur. Ceci est également appelé une compréhension de liste et est l'une des fonctionnalités les plus puissantes de Python. Cela rend le code plus compact, plus facile à lire et plus rapide que l'ajout .

Enfin, l'initialisation de words = [] est beaucoup plus propre que words = list () code >. Il est également beaucoup plus rapide .