6 approches différentes pour afficher des listes en Python

Introduction

En Python, imprimer des listes ne consiste pas seulement à afficher des valeurs ; c'est un moyen pour les programmeurs de mieux comprendre leur code et de s'assurer que les données semblent correctes. Explorons différentes manières d'imprimer des listes, avec des exemples pratiques et des conseils pour rendre les choses plus claires. Plongeons dans le monde des listes Python.

Inscrivez-vous à notre cours gratuit de Python.

Imprimer des listes en Python

Impression listes en Python ouvre une gamme de méthodes, et dans cet article, nous explorerons plusieurs approches efficaces :

• Utilisation de la boucle for
• Convertir une liste en chaîne pour l'affichage
• Utilisation du paramètre sep dans print()
• Utilisation de la fonction map()
• Utilisation de l'indexation et du découpage
• Utilisation de la compréhension de liste

Afficher une liste en Python à l'aide d'une boucle For

Parcourez la liste de 0 à sa longueur et imprimez chaque élément individuellement à l'aide d'une boucle for ; c'est la manière conventionnelle d'y parvenir.

Vous trouverez ci-dessous un exemple d'affichage d'une liste en Python à l'aide d'une boucle for :

# Creating a list of fruits

fruits = ["apple", "banana", "orange", "grape", "kiwi"]

# Displaying each fruit using a for loop

print("List of Fruits:")

for fruit in fruits:

    print(fruit)

Dans cet exemple, nous avons une liste de fruits et la boucle for parcourt chaque élément de la liste, les affichant un par un.

Sortie :

Complexité temporelle (O(n)) :

La complexité temporelle est O(n) car, dans une boucle for, chaque élément de la liste est visité une fois et le temps nécessaire à l'exécution de la boucle est directement proportionnel au nombre d'éléments dans la liste d'entrée.

Complexité spatiale (O(1)) :

La complexité spatiale est O(1) car la boucle utilise une quantité constante de mémoire, quelle que soit la taille de l'entrée ; il n'utilise qu'une seule variable (élément) pour représenter chaque élément de la liste et ne crée pas de structures de données supplémentaires qui grandissent avec l'entrée.

Afficher une liste en la convertissant en chaîne

Lorsqu'il s'agit d'une liste de instruments à cordes, une approche simple consiste à utiliser la fonction join() pour une concaténation facile. Cependant, lorsque la liste contient des entiers, un processus en deux étapes est nécessaire : tout d'abord, les convertir en chaînes, puis utiliser la fonction join() pour créer une chaîne unifiée à afficher.

Voici un exemple :

# Example list of fruits

fruits = ["apple", "banana", "orange", "grape", "kiwi"]

# Convert the list to a string and display it

result_string = ', '.join(fruits)

print("List of Fruits: " + result_string)

Dans cet exemple, la méthode join concatène les éléments de la liste en un seul un magnifique, séparés par une virgule et un espace. Le résultat est ensuite affiché sous forme de chaîne formatée.

Sortie :

Complexité temporelle (O(n)) :

La complexité temporelle est O(n) car, dans une boucle for, chaque élément de la liste est traité une fois et le temps d'exécution évolue linéairement avec le nombre d'éléments dans la liste d'entrée. À mesure que l’entrée augmente, la durée d’exécution de l’algorithme augmente proportionnellement.

Complexité spatiale (O(1)) :

La complexité spatiale est O(1) car l'algorithme utilise une quantité constante de mémoire quelle que soit la taille d'entrée. La boucle ne nécessite qu'une seule variable (élément) pour représenter chaque élément de la liste, et elle ne crée pas de structures de données ou de mémoire supplémentaires qui dépendent de la taille de la liste d'entrée.

Afficher avec le paramètre sep dans Print()

Le paramètre sep de la fonction print() vous permet de spécifier un séparateur entre les éléments que vous imprimez. 

L'utilisation du symbole astérisque (*) vous permet de présenter les éléments de la liste sur une seule ligne avec des espaces. Pour un affichage avec chaque élément sur une nouvelle ligne ou séparé par des virgules, utilisez sep=”n” ou sep=”, ” respectivement. 

Voici un exemple utilisant une liste de fruits :

# Example list of fruits

fruits = ["apple", "banana", "orange", "grape", "kiwi"]

# Displaying the list with a custom separator using the sep parameter

print("List of Fruits:", *fruits, sep=", ")

Dans cet exemple, sep=", " spécifie qu'une virgule et un espace doivent être utilisés comme séparateur entre les éléments de la liste.

Sortie :

Complexité temporelle (O(n)) :

La complexité temporelle est O(n) car, avec une boucle for, chaque élément de la liste est traité individuellement. À mesure que le nombre d'éléments (n) augmente, le temps d'exécution augmente linéairement, reflétant une relation directe entre la taille d'entrée et le temps de calcul.

Complexité spatiale (O(1)) :

La complexité spatiale est O(1) puisque l'algorithme utilise une quantité constante de mémoire, quelle que soit la taille de l'entrée. La boucle utilise un ensemble fixe de variables (comme « élément ») et évite de créer des structures de données supplémentaires ou d'allouer dynamiquement de la mémoire en fonction de la taille d'entrée.

Afficher une liste en Python à l'aide de la fonction Map()

Utilisez la fonction map() pour vous assurer que chaque élément de la liste est une chaîne, en particulier lorsque la liste comprend des éléments non-chaînes. Ensuite, fusionnez ces éléments transformés à l'aide de la fonction de jointure pour un affichage unifié.

Voici un exemple d'affichage d'une liste de fruits en Python :

# Example list of fruits

fruits = ["apple", "banana", "orange", "grape", "kiwi"]

# Displaying the list of fruits

print("List of Fruits:", fruits)

Sortie :

La fonction print() formate automatiquement la liste pour l'affichage. Si vous souhaitez personnaliser davantage la sortie, vous pouvez parcourir la liste et imprimer chaque élément individuellement ou utiliser la méthode de jointure, comme indiqué dans les exemples précédents.

Afficher une liste en Python à l'aide de l'indexation et du découpage

Vous pouvez afficher une liste en Python en utilisant l'indexation et le découpage pour accéder à des éléments spécifiques ou à un sous-ensemble de la liste. 

Voici un exemple :

# Example list of fruits

fruits = ["apple", "banana", "orange", "grape", "kiwi"]

# Displaying the entire list

print("Complete List of Fruits:", fruits)

# Displaying specific elements using indexing

print("First Fruit:", fruits[0])

print("Third Fruit:", fruits[2])

# Displaying a subset using slicing

print("Subset of Fruits:", fruits[1:4])

Sortie :

Dans cet exemple, l'indexation est utilisée pour accéder à des éléments individuels (par exemple, fruits[0] pour le premier élément), et le découpage est utilisé pour afficher un sous-ensemble de la liste (par exemple, fruits[1:4] pour les éléments à l'index 1, 2 et 3).

Complexité temporelle (O(n)) :

La complexité temporelle est O(n) car parcourir une liste à l’aide de l’indexation ou du découpage implique de visiter chaque élément une fois. À mesure que la taille de la liste (n) augmente, le temps nécessaire pour accéder ou découper la liste augmente de manière linéaire.

Complexité spatiale (O(1)) :

La complexité spatiale est O(1) pour les opérations d'indexation et de découpage car elles utilisent une quantité constante de mémoire supplémentaire, quelle que soit la taille de la liste. La mémoire requise pour les variables d'index/tranche reste constante et ne s'adapte pas à la taille d'entrée.

Afficher une liste en Python à l'aide de la compréhension de liste

La compréhension de liste est une fonctionnalité concise de Python permettant de créer des listes en appliquant une expression à chaque élément d'un itérable existant. Il fournit une syntaxe compacte qui combine les étapes de création d'une nouvelle liste et d'application d'une transformation à ses éléments.

Voici un exemple d'affichage d'une liste modifiée de fruits en utilisant la compréhension de liste :

# Example list of fruits

fruits = ["apple", "banana", "orange", "grape", "kiwi"]

# Using list comprehension to create a new list with capitalized fruits

capitalized_fruits = [fruit.capitalize() for fruit in fruits]

# Displaying the new list

print("Capitalized Fruits:", capitalized_fruits)

Sortie :

Dans cet exemple, la compréhension de liste est utilisée pour créer une nouvelle liste (capitalized_fruits). Le résultat est une liste de fruits avec leurs noms en majuscules.

Complexité temporelle (O(n)) :

La complexité temporelle est O(n) pour cet exemple car elle parcourt chaque élément de la liste originale de fruits. Le temps d'exécution évolue linéairement avec le nombre de fruits, ce qui le rend proportionnel à la taille de la liste d'entrée.

Complexité spatiale (O(n)) :

La complexité spatiale est O(n) car la compréhension de la liste crée une nouvelle liste (capitalized_fruits) qui grandit avec la taille de la liste d'entrée (fruits). Chaque élément de la liste d'origine correspond à un élément de la nouvelle liste, contribuant à une relation linéaire entre la taille d'entrée et la mémoire utilisée.

Conclusion

En Python, maîtriser l’art de l’impression de listes est crucial pour la compréhension du code et la visualisation des données. Ce guide a exploré six façons efficaces d'afficher des listes, offrant des exemples pratiques et des conseils pour plus de clarté. Qu'il s'agisse de boucles, de conversion de chaînes, de séparateurs personnalisés, de fonctions de mappage, d'indexation, de découpage ou de compréhension de liste, chaque approche répond à un objectif spécifique, améliorant ainsi vos compétences en programmation Python.

Foire aux Questions

Services Connexes

• Contenu propulsé par le référencement et distribution de relations publiques. Soyez amplifié aujourd'hui.
• PlatoData.Network Ai générative verticale. Autonomisez-vous. Accéder ici.
• PlatoAiStream. Intelligence Web3. Connaissance Amplifiée. Accéder ici.
• PlatonESG. Carbone, Technologie propre, Énergie, Environnement, Solaire, La gestion des déchets. Accéder ici.
• PlatoHealth. Veille biotechnologique et essais cliniques. Accéder ici.
• La source: https://www.analyticsvidhya.com/blog/2024/01/approaches-to-displaying-lists-in-python/