List faisant partie intégrante de la programmation Python doit être appris par tous les utilisateurs de Python et avoir une connaissance de son utilité et de ses opérations est essentiel et toujours un plus.
De nombreuses opérations sont effectuées dans les listes, mais dans cet article, nous aborderons la longueur d'une liste. La longueur d'une liste signifie le nombre d'éléments qu'elle contient. Nous allons examiner 8 méthodes différentes pour trouver la longueur d'une liste dans Python .
films
Exemple:
Input: lst = [10,20,30,40] Output: 4 Explanation: The output is 4 because the length of the list is 4.>
Trouver la longueur d'une liste en Python
Vous trouverez ci-dessous les méthodes que nous aborderons dans cet article :
- En utilisant seulement() fonction
- Utiliser la méthode naïve
- Utiliser length_hint()
- En utilisant somme() méthode
- Utilisant un compréhension de liste
- En utilisant récursivité
- En utilisant énumérer fonction
- En utilisant Collections Module
1. Trouver la longueur d'une liste à l'aide de la fonction len()
Python seulement() La fonction est une fonction intégrée à Python. Il peut être utilisé pour trouver la longueur d'un objet en passant l'objet entre parenthèses de la fonction len.
Python3
# Python len()> li>=> [>10>,>20>,>30>]> n>=> len>(li)> print>(>'The length of list is: '>, n)> |
>
>
Sortir:
The length of list is: 3>
Complexité temporelle : O(n), où n est la longueur de la liste
Espace auxiliaire : O(1)
2. Trouvez la longueur d'une liste à l'aide de la méthode naïve
Dans cette méthode, il suffit d'exécuter une boucle et d'augmenter le compteur jusqu'au dernier élément de la liste pour connaître son décompte. Il s’agit de la stratégie la plus élémentaire qui puisse être utilisée en l’absence d’autres techniques actuelles.
Python3
# Initializing list> test_list>=> [>1>,>4>,>5>,>7>,>8>]> # Printing test_list> print>(>'The list is : '> +> str>(test_list))> # Finding length of list using loop> # Initializing counter> counter>=> 0> for> i>in> test_list:> ># incrementing counter> >counter>=> counter>+> 1> # Printing length of list> print>(>'Length of list using naive method is : '> +> str>(counter))> |
>
>
Sortir:
The list is : [1, 4, 5, 7, 8] Length of list using naive method is : 5>
Complexité temporelle : Sur)
Espace auxiliaire : O(1)
3. Recherchez la longueur d'une liste à l'aide de la méthode length_hint()
Cette technique est une technique moins connue pour déterminer la longueur d’une liste. Cette méthode particulière est définie dans la classe d'opérateur et elle peut également indiquer le non. des éléments présents dans la liste. Ici, nous trouvons la longueur de la liste en utilisant len() et length_hint()
Python3
from> operator>import> length_hint> # Initializing list> test_list>=> [>1>,>4>,>5>,>7>,>8>]> # Printing test_list> print>(>'The list is : '> +> str>(test_list))> # Finding length of list using len()> list_len>=> len>(test_list)> # Finding length of list using length_hint()> list_len_hint>=> length_hint(test_list)> # Printing length of list> print>(>'Length of list using len() is : '> +> str>(list_len))> print>(>'Length of list using length_hint() is : '> +> str>(list_len_hint))> |
>
>
Sortir :
The list is : [1, 4, 5, 7, 8] Length of list using len() is : 5 Length of list using length_hint() is : 5>
4. Trouver la longueur d'une liste à l'aide de la fonction sum()
Utilisez l'itération à l'intérieur de la somme et à chaque itération en ajoute une et à la fin de l'itération, nous obtenons la longueur totale de la liste.
Python3
# Initializing list> test_list>=> [>1>,>4>,>5>,>7>,>8>]> # Printing test_list> print>(>'The list is : '> +> str>(test_list))> # Finding length of list> # using sum()> list_len>=> sum>(>1> for> i>in> test_list)> # Printing length of list> print>(>'Length of list using len() is : '> +> str>(list_len))> print>(>'Length of list using length_hint() is : '> +> str>(list_len))> |
>
>
Sortir:
The list is : [1, 4, 5, 7, 8] Length of list using len() is : 5 Length of list using length_hint() is : 5>
5. Trouver la longueur d'une liste à l'aide d'une compréhension de liste
Initialisez une liste appelée liste_test avec quelques valeurs, puis initialisez une variable appelée length à 0. Utilisez une compréhension de liste pour générer une séquence de un pour chaque élément de la test_list.
Cela créera une liste de ceux de la même longueur que test_list. Utilisez maintenant la fonction sum() pour additionner tous ceux de la liste générée par le compréhension de liste . Attribuez la somme à la variable de longueur. Imprimez la variable de longueur.
Python3
# Define the list to be used for the demonstration> test_list>=> [>1>,>4>,>5>,>7>,>8>]> # Calculate the length of the list using a list comprehension and the sum function> # The list comprehension generates a sequence of ones for each element in the list> # The sum function then sums all the ones to give the length of the list> length>=> sum>(>1> for> _>in> test_list)> # Print the length of the list> print>(>'Length of list using list comprehension is:'>, length)> |
>
>Sortir
Length of list using list comprehension is: 5>
Complexité temporelle : La compréhension de liste crée une nouvelle liste d'une longueur égale à la longueur de test_list. La fonction sum() parcourt ensuite cette liste pour calculer la somme. Par conséquent, la complexité temporelle de cet algorithme est O(N), où N est la longueur de la liste de tests.
Espace auxiliaire : L'algorithme crée une nouvelle liste de uns d'une longueur égale à la longueur de test_list en utilisant la compréhension de liste. Par conséquent, la complexité de l’espace auxiliaire est également O(N), où N est la longueur de la test_list.
6. Trouver la longueur d'une liste à l'aide de la récursivité
Nous pouvons utiliser un fonction récursive ça prend une liste premier en entrée et s'appelle récursivement, en passant une tranche de la liste qui exclut le premier élément jusqu'à ce que la liste soit vide.
Le cas de base est lorsque la liste est vide, auquel cas la fonction renvoie 0. Sinon, elle ajoute 1 au résultat de l'appel de la fonction sur le reste de la liste.
Python3
# Define a function to count the number of elements in a list using recursion> def> count_elements_recursion(lst):> ># Base case: if the list is empty, return 0> >if> not> lst:> >return> 0> ># Recursive case: add 1 to the count of the remaining elements in the list> >return> 1> +> count_elements_recursion(lst[>1>:])> # Test the function with a sample list> lst>=> [>1>,>2>,>3>,>4>,>5>]> print>(>'The length of the list is:'>, count_elements_recursion(lst))> # Output: The length of the list is: 5> |
>
>Sortir
The length of the list is: 5>
Complexité temporelle : O(n) où n est la longueur de la liste. En effet, la fonction effectue n appels récursifs, chacun prenant un temps O(1), et il y a également un travail O(1) effectué à chaque niveau en dehors de l'appel récursif.
Complexité spatiale : O(n) où n est la longueur de la liste. En effet, la fonction crée n frames de pile sur la pile d'appels en raison des appels récursifs.
7. Trouver la longueur d'une liste à l'aide de la fonction enumerate()
Python énumérer() La méthode ajoute un compteur à un itérable et le renvoie sous la forme d'un objet énumérant.
Python3
# python code to find the length> # of list using enumerate function> list1>=> [>1>,>4>,>5>,>7>,>8>]> s>=> 0> for> i, a>in> enumerate>(list1):> >s>+>=> 1> print>(s)> |
>
numéro alphabétique
>Sortir
5>
8. Trouver la longueur d'une liste à l'aide de collections
Alternativement, vous pouvez également utiliser le somme() fonction avec la méthode values() du Collections Objet Counter pour obtenir la longueur de la liste.
Python3
from> collections>import> Counter> # Initializing list> test_list>=> [>1>,>4>,>5>,>7>,>8>]> # Finding length of list using Counter()> list_len>=> sum>(Counter(test_list).values())> print>(>'Length of list using Counter() is:'>, list_len)> # This code is contributed by Edula Vinay Kumar Reddy> |
>
>Sortir
Length of list using Counter() is: 5>
Complexité temporelle : O(n), où n est la longueur de la liste. En effet, la fonction Counter() a une complexité temporelle de O(n) lorsqu'elle est appliquée à une liste de longueur n, et la méthode values() et la fonction sum() ont toutes deux une complexité temporelle de O(n) lorsqu'elles sont appliquées. à une liste de longueur n.
La complexité spatiale : O(n), en tant que fonction Counter(), crée un dictionnaire avec n paires clé-valeur, chacune représentant respectivement un élément et son nombre dans la liste. Ce dictionnaire occupe un espace O(n).
Analyse des performances : Naive vs Python len() vs Python length_hint()
Lorsque vous choisissez parmi des alternatives, il est toujours nécessaire d’avoir une raison valable pour choisir l’une plutôt que l’autre. Cette section effectue une analyse temporelle du temps nécessaire pour les exécuter tous afin d'offrir un meilleur choix d'utilisation.
Python3
from> operator>import> length_hint> import> time> # Initializing list> test_list>=> [>1>,>4>,>5>,>7>,>8>]> # Printing test_list> print>(>'The list is : '> +> str>(test_list))> # Finding length of list> # using loop> # Initializing counter> start_time_naive>=> time.time()> counter>=> 0> for> i>in> test_list:> ># incrementing counter> >counter>=> counter>+> 1> end_time_naive>=> str>(time.time()>-> start_time_naive)> # Finding length of list> # using len()> start_time_len>=> time.time()> list_len>=> len>(test_list)> end_time_len>=> str>(time.time()>-> start_time_len)> # Finding length of list> # using length_hint()> start_time_hint>=> time.time()> list_len_hint>=> length_hint(test_list)> end_time_hint>=> str>(time.time()>-> start_time_hint)> # Printing Times of each> print>(>'Time taken using naive method is : '> +> end_time_naive)> print>(>'Time taken using len() is : '> +> end_time_len)> print>(>'Time taken using length_hint() is : '> +> end_time_hint)> |
>
>
Sortir:
The list is : [1, 4, 5, 7, 8] Time taken using naive method is : 2.6226043701171875e-06 Time taken using len() is : 1.1920928955078125e-06 Time taken using length_hint() is : 1.430511474609375e-06>
Dans les images ci-dessous, on voit clairement que le temps pris est naïf>> length_hint()> len() , mais le temps nécessaire dépend fortement du système d'exploitation et de plusieurs de ses paramètres.
En deux exécutions consécutives, vous pouvez obtenir des résultats contrastés, en fait, parfois, naïf prend le moins de temps sur trois. Toutes les 6 permutations possibles sont possibles.
naïf> len()> length_hint()
naïf> len()=length_hint()
naïf> length_hint()>len()
naïf> length_hint()> len()
Nous avons discuté de 8 méthodes différentes pour trouver la longueur d'une liste en Python. Nous avons également effectué une analyse des performances pour vérifier quelle méthode est la meilleure.
Vous pouvez utiliser l’une des méthodes ci-dessus pour trouver la longueur d’une liste. La recherche de la longueur d'une liste est très utile lorsque vous traitez des listes volumineuses et que vous souhaitez vérifier le nombre d'entrées.
Consultez plus de pages de listes Python :
- Méthodes de liste Python
- Exercice de liste Python
- Complexité spatiale des opérations de liste en Python