Tout ce que vous devez savoir

La documentation n'est pas adaptée aux débutants et les tutoriels laissent souvent des lacunes. Apprendre le python peut être écrasant, donc vous n'êtes pas seul. Pour y remédier, j'ai préparé un guide concis et sans fioritures pour augmenter rapidement vos compétences avec des listes de python – en moins de 30 minutes aussi!

Les listes sont une séquence d'articles qui vivent côte à côte en mémoire, comme une liste de courses sur un morceau de papier. Les listes fournissent également des opérations (appelées méthodes) qui vous permettent d'effectuer des actions sur eux. Par exemple, pour ajouter un élément à une liste, utilisez my_shopping_list.append ('lait'). Il existe de nombreuses méthodes et nous couvrirons la plupart des importants au fur et à mesure.

Liste des bases: création et accéder aux articles

Créer une liste

Pour créer une liste, affectez simplement les crochets à une variable:

        my_shopping_list = ()
    

Vous pouvez initialiser les listes avec des éléments prédéfinis:

        my_shopping_list = ("milk", "bread", "sugar")
    

Vous pouvez stocker différents types dans les listes, et même d'autres listes:

        my_shopping_list = ("milk", 1, (1, 2, 3), True)
    

Affectations directes

Lorsqu'une liste existante contient des éléments, nous pouvons modifier directement ces éléments:

        my_shopping_list = ("milk", "bread", "sugar")
my_shopping_list(0) = "coffee"
print(my_shopping_list)
my_shopping_list(2) = "bananas"
print(my_shopping_list)
    

Le nombre entre les crochets est appelé l'index, et nous l'utilisons pour aborder les éléments individuels dans la liste. Le premier élément est toujours 0, alors le second est 1, et ainsi de suite.

Éléments de liste d'accès

Maintenant que votre liste a des articles, vous voudrez y accéder:

        my_shopping_list = ("milk", "bread", "sugar")
print(my_shopping_list(0))
print(my_shopping_list(1))
    

Inversement, Python vous permet d'accéder aux éléments à partir de la fin à l'aide de nombres négatifs:

        my_shopping_list = ("milk", "bread", "sugar")
print(my_shopping_list(-1))
print(my_shopping_list(-2))
    

Le Nombres finaux commencer à -1pas 0.

Boucle sur une liste

UN boucle En général, la programmation est une construction qui répète une action n fois. Par exemple, si une liste contient trois éléments, la boucle iratera à travers elle, ce qui nous permet d'effectuer des actions sur chaque élément. Ce qui suit est un exemple de boucle pour une boucle:

        my_shopping_list = ("milk", "bread", "sugar")
for item in my_shopping_list:
    print(item)
    

Pour chaque élément de « my_shopping_list », la boucle l'affecte à la variable « élément ». Nous pouvons simplement imprimer cette variable pour montrer comment cela fonctionne.

Il est possible d'effectuer une action sur chaque article. Par exemple, ajoutez un point d'exclamation à l'article, puis imprimez:

        my_shopping_list = ("milk", "bread", "sugar")
for item in my_shopping_list:
    print(item + "!") 
    

Récupération des parties d'une liste (alias tranchants)

La récupération des parties d'une liste est appelée tranchage. Le tranchage ne modifie pas la liste d'origine, il renvoie une nouvelle liste avec les éléments souhaités.

Si vous souhaitez récupérer les deux premiers éléments:

        my_shopping_list = ("milk", "bread", "sugar")
print(my_shopping_list(0:2))
    

Vous pouvez voir que nous fournissons des indices 0 et 2, séparés par un côlon – c'est la même chose que de dire zéro, jusqu'à, mais sans inclure, deux.

N'oubliez pas que 0 et 1 sont les deux premiers éléments.

Si vous ne fournissez pas de numéro après ou avant le côlon, il renvoie le reste de la liste. Par exemple, le code suivant renvoie le deuxième élément et le reste de la liste:

        my_shopping_list = ("milk", "bread", "sugar")
print(my_shopping_list(1:))
    

Cela rendra tout jusqu'à 2:

        my_shopping_list = ("milk", "bread", "sugar")
print(my_shopping_list(:2))
    

Tranchage inversé

Vous pouvez effectuer le tranchage dans un ordre inverse en utilisant des nombres négatifs pour les index. Python traite les index négatifs par rapport à la fin de la liste; Par exemple, -1 signifie le dernier élément, et -2 signifie le deuxième à dernier élément.

L'exemple suivant commence à l'article du deuxième à l'avant-dernier (-2) et va à la fin de la liste.

        my_shopping_list = ("milk", "bread", "sugar")
print(my_shopping_list(-2:))
    

Rappelez-vous que index finaux Ne commencez pas de 0; Ils commencent de -1.

Modification de la liste: ajout, supprimer et trier les éléments

Pour modifier la structure d'une liste (pas ses valeurs existantes), il est plus simple (et meilleure pratique) d'utiliser les méthodes standard fournies par Python.

ajouter()

L'ajout signifie ajouter à la fin d'une liste.

        my_shopping_list = ("milk", "bread", "sugar")
my_shopping_list.append("bananas")
print(my_shopping_list)
my_shopping_list.append("cheese")
print(my_shopping_list)
    

insérer()

L'insert est comme ajouter, sauf qu'il ajoute des éléments à un index spécifié.

        my_shopping_list = ("milk", "bread", "sugar")

my_shopping_list.insert(0, "bananas")
print(my_shopping_list)

my_shopping_list.insert(2, "cheese")
print(my_shopping_list)
    

Vous pouvez voir que l'insertion à l'index 0 le place au début et l'insertion à l'index 2 le place au troisième élément.

Utiliser le insérer Méthode avec soin. Pour les grandes listes (par exemple, des millions), cela peut avoir un impact sur les performances, car Python déplace chaque élément suivant un endroit pour faire de la place pour le nouvel élément.

retirer()

Fournir le retirer Méthode avec un échantillon de ce que vous souhaitez supprimer, et il supprimera le d'abord Instance qu'il rencontre.

        my_shopping_list = ("milk", "bread", "sugar")

my_shopping_list.remove("milk")
print(my_shopping_list)

my_shopping_list.remove("sugar")
print(my_shopping_list)
    

Tri

Le tri d'une liste dans Python est simple, et vous avez deux options:

• En place: modifie la liste.

• En dehors de la place: renvoie une nouvelle liste et ne modifie pas la liste d'origine.

Le trier La méthode est en place et modifie la liste originale.

        my_shopping_list = ("milk", "bread", "sugar")
my_shopping_list.sort()
print(my_shopping_list)
    

Remarquez que les éléments sont triés par ordre alphabétique? Remarquez également que nous n'avons pas réaffecté « my_shopping_list », mais l'impression a montré une liste triée? C'est le tri sur place.

Le trié La méthode est hors de propos et ne modifie pas la liste originale.

        my_shopping_list = ("milk", "bread", "sugar")
my_sorted_list = sorted(my_shopping_list)
print(my_shopping_list) 
print(my_sorted_list) 
    

Remarquez que « my_shopping_list » est resté intact? La méthode « triée » renvoie une nouvelle liste: « my_sorted_list ».

Utilisation d'informations sur la liste pour prendre des décisions intelligentes

Vérification de la longueur de liste

L'opération de liste la plus courante consiste probablement à vérifier la longueur de la liste à l'aide du Len fonction.

        my_shopping_list = ("milk", "bread", "sugar")
if len(my_shopping_list) > 0:
    print("The list is not empty.")
    

Comme vous pouvez le voir, la longueur de liste est supérieure ou égale à zéro.

Utilisation de listes conditionnellement

Il est possible d'utiliser des listes dans des instructions conditionnelles (par exemple, si instructions). Une liste vide est Falsy (équivalent à false); Une liste peuplée est la vérité (équivalente à vrai).

        if ():
    print("An empty list is truthy.") 
if ("foo"):
    print("A populated list is truthy.")
    

C'est un moyen courant de vérifier si une liste a n'importe lequel articles.

Comparaison des listes

Pour comparer les listes, il est important de comprendre deux concepts clés:

• Égalité: les listes ont-elles la même chose contenu?

• Identité: les listes sont-elles Exactement même objet en mémoire?

L'égalité se concentre sur le fait que les listes contiennent les mêmes éléments; S'ils le font, les listes sont considérées comme égales. Pour vérifier l'égalité, nous utilisons l'opérateur « == ».

        one = (1)
two = (2)
also_one = (1)
if one == two:
    print("Different lists are equal.") 
if one == one:
    print("A list is equal to itself.")
if one == also_one:
    print("Different lists with the same items are equal.")
    

Une vérification d'identité compare les adresses mémoire de deux objets (listes) pour déterminer s'ils pointent vers le même emplacement exactement en mémoire. Nous utilisons le est Opérateur pour effectuer des contrôles d'identité:

        one = ()
two = ()
if one is two:
    print("Different lists have the same identity.") 
if one is one:
    print("A list has the same identity as itself.")
    

Lister l'adhésion

Vous voudrez souvent savoir si une liste contient quelque chose, et vous pouvez le faire avec le spécial dans opérateur.

        my_shopping_list = ("milk", "bread", "sugar")
if "milk" in my_shopping_list:
    print("Got milk!")
if "cookies" in my_shopping_list:
    print("Got cookies!") 
    

Transformer les listes: transformer les éléments en quelque chose d'autre

Utilisez map () pour modifier les éléments

Carte est un moyen courant de transformer les listes dans la plupart des langages de programmation. En python, carte est une fonction qui boucle sur une liste et applique une fonction (que vous fournissez) à chaque élément. Votre fonction reçoit chaque élément comme argument, et vous êtes libre de faire ce que vous voulez. La valeur que vous retournez remplace cet élément dans la liste.

En bref: MAP applique une fonction fournie par l'utilisateur à chaque élément. Utilisez cette fonction pour transformer chaque valeur.

        my_shopping_list = ("milk", "bread", "sugar")
def apply_uppercase(item):
    return item.upper()
map_object = map(apply_uppercase, my_shopping_list)
mapped_list = list(map_object) 
print(mapped_list)
    

Utilisez Filter () pour supprimer les éléments

Le filtre fonctionne un peu comme cartesauf qu'il supprime les éléments de la liste. La fonction reçoit chaque valeur et détermine s'il faut conserver ou rejeter l'élément. Retourner les vraies moyens garder la valeuret faux moyens jeter.

        my_shopping_list = ("milk", "bread", "sugar")
def sugar_free(item):
    
    return item != "sugar" 
filter_object = filter(sugar_free, my_shopping_list)
mapped_list = list(filter_object) 
print(mapped_list)
    

Conseils bonus: vous voudrez les lire

Liste des compréhensions

Les compréhensions de la liste sont un moyen compact de générer une liste à partir d'une autre liste. Ça fonctionne un peu comme carte (couvert plus tôt).

        my_shopping_list = ("milk", "bread", "sugar")

copied_list = (item for item in my_shopping_list)
print(copied_list)

changed_list = (item.upper() for item in my_shopping_list)
print(changed_list)
  
    

Le deuxième La compréhension de la liste est la même que:

        my_shopping_list = ("milk", "bread", "sugar")

changed_list = ()
for item in my_shopping_list:
    changed_list.append(item.upper())
    print(changed_list)
  
    

Cette image montre comment une compréhension de la liste se rapporte à une liste de python normale.

• Token 1: Je l'ai souligné, et il se rapporte à l'autre jeton souligné. Ce jeton est la variable sur laquelle vous opérez; C'est cette valeur que vous changez.

• Token 2: fait référence à la déclaration variable; C'est là que vous attribuez un nom au jeton, qui est « élément » dans cet exemple.

• Token 3: fait référence à la liste sur laquelle vous boucle (itérer).

Listes de déballage

Obtenir des articles d'une liste peut être une affaire laide:

        my_shopping_list = ("milk", "bread", "sugar")
milk = my_shopping_list(0)
bread = my_shopping_list(1)
sugar = my_shopping_list(2)
    

Préférez plutôt la liste du déballage, une méthode propre pour extraire chaque élément en variables:

        my_shopping_list = ("milk", "bread", "sugar")
milk, bread, sugar = my_shopping_list
print(milk, bread, sugar)
    

Les positions des noms de variables sont liées aux positions dans la liste, et le nombre de variables doit correspondre au nombre d'éléments. Voici ce qui se passe lorsqu'il y a des variables insuffisantes:

Pour y remédier, nous pouvons utiliser l'opérateur Star (un astérisque) sur un élément. Dans ce scénario, la variable étoilée représente plusieurs variables en tant que liste – essentiellement, c'est tout ce qui n'est pas explicitement attribué à une variable. Gardez à l'esprit que l'ordre compte:

        my_shopping_list = ("milk", "bread", "butter", "bananas", "sugar")
milk, bread, *misc, sugar = my_shopping_list
print(milk, bread, misc, sugar)
    

Copie profonde

Lorsque vous utilisez des objets complexes (instances de classe, listes, etc.), il est important de comprendre qu'ils ne sont pas des valeurs simples. Lorsque vous stockez un objet dans une variable, c'est en fait une adresse mémoire qui pointe vers une place en mémoire où vit l'objet.

Prenez l'exemple suivant:

        
milk_and_bread = ("milk", "bread")

list_a = ("list_a", milk_and_bread)
list_b = ("list_b", milk_and_bread)

print("BEFORE CHANGE")
print(list_a)
print(list_b)

milk_and_bread(0) = "apples"

print("nAFTER CHANGE")
print(list_a)
print(list_b)
    

Les modifications se reflètent dans les deux listes car « Milk_and_bread » est un objet, et Python agit toujours sur les objets via leur adresse mémoire (aka référence). Lorsque nous ajoutons un objet à une liste, nous ajoutons en fait une référence à la liste à la place. Maintenant, lorsque nous changeons l'objet, le résultat se reflète partout.

La raison pour laquelle cela est important est qu'il peut être une source de bugs. Lorsque vous considérez les valeurs complexes comme des références, au lieu de simples variables, il est plus facile d'éviter ce problème. Il n'est pas toujours possible d'éviter un tel problème, et une solution consiste à copier en profondeur la liste:

        from copy import deepcopy
milk_and_bread = ("milk", "bread")

list_a = deepcopy(("list_a", milk_and_bread))
list_b = deepcopy(("list_b", milk_and_bread))

print("BEFORE CHANGE")
print(list_a)
print(list_b)

milk_and_bread(0) = "apples"

print("nAFTER CHANGE")
print(list_a)
print(list_b)
    

Une copie profonde permettra de percer dans chaque objet et les copiera toutes. C'est récursif.

---

Les sujets abordés ici devraient répondre à la plupart de vos besoins de listes, mais ils ne couvrent pas le sujet Python plus large. Pour continuer à apprendre, vous pouvez trouver nos autres articles utiles, tels que de grands jeux qui vous enseignent Python ou des scripts Python basiques mais utiles pour vous aider à démarrer. Enfin, notre guide sur l'écriture de code La voie pythonique comprend des sujets supplémentaires sur les listes, y compris le tous et chaque fonctions.