Cinq conseils pour dériver de la fonction list vers la fonction zip() en Python

Dans cet article, l'auteur présente 5 méthodes. Peut-être que nous ne les connaissons pas beaucoup au début, mais ces 5 compétences sont très pratiques en combat réel.

Opérations sur les chaînes

Une chaîne est essentiellement un tuple, mais il existe de nombreuses "opérations" sur les chaînes. Les plus intuitives sont les opérations + et * sur les chaînes, qui représentent respectivement la répétition et la concaténation.

>>> my_string = "Hi Medium..!"
>>> print(my_string * 2)
Hi Medium..!Hi Medium..!
>>> print(my_string + " I love Python" * 2)
Hi Medium..! I love Python I love Python

De plus, si vous souhaitez obtenir la chaîne inversée, vous pouvez également utiliser directement [::-1] pour l'indexation :

>>> print(my_string[::-1])
!..muideM iH>>> my_list = [1,2,3,4,5]
>>> print(my_list[::-1])
[5, 4, 3, 2, 1]

Si les éléments de la liste sont tous des chaînes, alors nous peut rapidement utiliser la méthode join() pour assembler tous les éléments :

>>> word_list = ["awesome", "is", "this"]
>>> print(' '.join(word_list[::-1]) + '!')
this is awesome!

Comme ci-dessus, nous utilisons la méthode .join() pour assembler les éléments de la liste, où 『 』 indique que la méthode de connexion est un espace . En fait, dans le traitement du langage naturel, cette méthode est souvent utilisée. Par exemple, si nous divisons la phrase en caractères, la fusion post-traitement doit utiliser join().

Recommandations associées : "Tutoriel de base de Python"

Compréhensions de liste

Si vous ne savez pas comment utiliser la liste compréhensions, puis apprenez-le rapidement. Comme l'a dit l'auteur de cet article : « Quand j'ai appris cette méthode pour la première fois, tout mon monde a changé. » La compréhension des listes est vraiment très puissante. Elle est non seulement plus rapide que les méthodes ordinaires, mais aussi intuitive et la lisibilité est très forte. Si vous souhaitez parcourir une liste et effectuer des calculs, utilisez-la.

Nous commençons par définir une fonction simple qui met au carré une variable et ajoute 5 :

>>> def stupid_func(x):
>>>     return x**2 + 5

Si nous voulons appliquer cette fonction aux éléments impairs de la liste, alors n'utilisez pas la compréhension de liste dans le cas de formule, nous l'écrivons généralement sous la forme suivante :

>>> my_list = [1, 2, 3, 4, 5]
>>> new_list = []
>>> for x in my_list:
>>>     if x % 2 != 0:
>>>         new_list.append(stupid_func(x))
>>> print(new_list)
[6, 14, 30]

Mais maintenant que nous avons une compréhension de liste, le code ci-dessus peut être modifié de manière équivalente en :

>>> my_list = [1, 2, 3, 4, 5]
>>> print([stupid_func(x) for x in my_list if x % 2 != 0])
[6, 14, 30]

Syntaxe générale de compréhension de liste Il peut être exprimé sous la forme [expression pour l'élément dans la liste]. Si vous souhaitez ajouter des instructions conditionnelles booléennes, la syntaxe ci-dessus peut être modifiée en [expression pour l'élément dans la liste si conditionnelle].

>>> for item in list:
>>>     if conditional:
>>>         expression

La compréhension de la liste ci-dessus peut être encore simplifiée, c'est-à-dire qu'il n'est pas nécessaire de définir une nouvelle fonction.

>>> print([x ** 2 + 5 for x in my_list if x % 2 != 0])
[6, 14, 30]

Lambda et Map

Lambda est une fonction anonyme, elle peut paraître un peu étrange, mais une fois qu'on la comprend, elle devient très intuitive et puissante.

De manière générale, les fonctions Lambda sont relativement petites et n'ont pas besoin de définir des noms de fonction. Alors pourquoi avez-vous besoin de fonctions anonymes ? Pour faire simple, Lambda effectue le plus souvent des opérations intuitives. Il ne nécessite pas de définitions de fonctions standard et ne nécessite pas non plus d'appeler à nouveau de nouveaux noms de fonctions.

Prenons le carré ci-dessus puis ajoutons 5 comme exemple. Plus tôt, nous avons défini une fonction standard, def stupid_func(x), maintenant nous pouvons essayer la fonction anonyme Lambda :

>>> stupid_func = (lambda x : x ** 2 + 5)
>>> print([stupid_func(1), stupid_func(3), stupid_func(5)])
[6, 14, 30]

Alors pourquoi le faire. on utilise l'expression ci-dessus ? Cela s'explique en grande partie par le fait que lorsque nous voulons effectuer des opérations simples, nous pouvons le faire sans définir de fonction réelle. Par exemple, pour trier les éléments d'une liste, une manière intuitive peut être d'utiliser la méthode sorted() :

>>> my_list = [2, 1, 0, -1, -2]
>>> print(sorted(my_list))
[-2, -1, 0, 1, 2]

Cela ne peut trier que de grand à petit ou de petit à grand par défaut, mais avec l'aide d'expressions Lambda , nous pouvons obtenir plus de liberté sur les critères de tri. Comme indiqué ci-dessous, nous souhaitons trier la liste en fonction du plus petit nombre carré, qui peut être défini à l'aide d'une fonction Lambda pour indiquer à la méthode sorted() comment trier.

>>> print(sorted(my_list, key = lambda x : x ** 2))
[0, -1, 1, -2, 2]

Map est une fonction simple qui applique une fonction à un autre élément de séquence, comme une liste. Si nous avons deux listes et que nous voulons multiplier les éléments correspondants des deux listes, nous pouvons rapidement réaliser cette fonction en utilisant la fonction lambda et map :

>>> print(list(map(lambda x, y : x * y, [1, 2, 3], [4, 5, 6])))
[4, 10, 18]

Le code ci-dessus est très élégant, si vous ne le faites pas utilisez-les tous les deux. Ou, alors l'expression générale doit être écrite comme ceci :

>>> x, y = [1, 2, 3], [4, 5, 6]
>>> z = []
>>> for i in range(len(x)):
>>>     z.append(x[i] * y[i])
>>> print(z)
[4, 10, 18]

Instruction conditionnelle sur une seule ligne

Si nous utilisons des instructions conditionnelles, alors il est préférable susceptible d'être écrit comme ceci :

>>> x = int(input())
>>> if x >= 10:
>>>     print("Horse")
>>> elif 1 < x < 10:
>>>     print("Duck")
>>> else:
>>>     print("Baguette")

Mais en fait, nous pouvons également écrire toutes les conditions dans la fonction d'impression, c'est-à-dire que les 7 lignes de code ci-dessus peuvent être écrites de manière équivalente comme la ligne suivante :

print("Horse" if x >= 10 else "Duck" if 1 < x < 10 else "Baguette")

Cela a l'air vraiment concis. Si vous regardez ce que vous avez écrit auparavant, il y a vraiment beaucoup de codes qui peuvent être transformés en ce genre d'expression.

zip()

Lors de l'introduction de la fonction map() plus tôt, nous avons donné un exemple d'application d'une certaine fonction à deux listes parallèles, et la fonction zip() fait c'est plus facile de faire ça.

Si nous avons deux listes, la première liste contient les prénoms et la deuxième liste contient les noms de famille. En utilisant la fonction zip(), nous pouvons les assembler comme suit.

>>> first_names = ["Peter", "Christian", "Klaus"]
>>> last_names = ["Jensen", "Smith", "Nistrup"]
>>> print([' '.join(x) for x in zip(first_names, last_names)])
['Peter Jensen', 'Christian Smith', 'Klaus Nistrup']

En d'autres termes, zip transforme deux listes de longueur égale en paires un-à-un, c'est-à-dire (("Peter", "Jensen"), ("Christian", "Smith"), ("Klaus", "Nistrup")).

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!