"Vous ne pouvez pas écrire facilement une notation inclusive en utilisant Python."
Une personne formidable m'a dit, alors j'ai visité divers sites et étudié. (Les connaissances préalables sont le niveau "Eh bien, ce n'est pas seulement l'inclusion de liste!?")
Wikipedia-inclusion et extension
extension_li = []
for x in range(10):
extension_li.append(x**2)
extension_li
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
Défini dans []. Renvoie une liste.
comprehension_li = [x**2 for x in range(10)]
comprehension_li
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
Défini par {}.
comprehension_set = {i/2 for i in range(1,11)}
comprehension_set
{0.5, 1.0, 2.0, 2.5, 1.5, 3.0, 3.5, 4.0, 4.5, 5.0}
abb = ("NY","TX","MA","WA","CT")
state = ("New York", "Texas", "Massachusetts", "Washington", "Connecticut")
comprehension_dict = {i:j for i,j in zip(abb,state)}
comprehension_dict
{'WA': 'Washington',
'TX': 'Texas',
'NY': 'New York',
'MA': 'Massachusetts',
'CT': 'Connecticut'}
Défini entre (). Ce n'est jamais une notation d'inclusion de tapple, et ce qui est renvoyé est un générateur qui génère des éléments. Il économise de la mémoire car tous les éléments ne sont pas stockés en mémoire comme une liste.
comprehension_gen = (i%3 for i in range(1,10))
comprehension_gen
<generator object <genexpr> at 0x014CD900>
for i in comprehension_gen:print(i)
1
2
0
1
2
0
1
2
0
extension = [i for i in range(1,10) if i%2==0]
extension
[2, 4, 6, 8]
comprehension = [i if i%2==0 else 0 for i in range(1,10)]
comprehension
[0, 2, 0, 4, 0, 6, 0, 8, 0]
Quand else est entré, la notation conditionnelle vient en premier. La raison est claire: "Simply if statement" est une grammaire de notation d'inclusion normale, tandis que "if ~ else statement" est traité comme un opérateur ternaire.
À propos, l'opérateur ternaire python est
** "(Valeur lorsque la condition est True) if (Condition) else (Valeur lorsque la condition est False)" **
Cela devient la description. (Attention car il est différent de Java, du langage C, etc.)
Je suis désolé de dire qu'il a été beaucoup utilisé, mais FizzBuzz peut être facilement écrit en une seule ligne en utilisant l'instruction if ~ else.
print(["FizzBuzz" if n % 15 == 0 else "Fizz" if n % 3 == 0 else "Buzz" if n % 5 == 0 else n for n in range(1,101)])
Ou vous pouvez écrire comme ça.
print([(i%3==0 and 1 or 0)*"Fizz"+(i%5==0 and 1 or 0)*"Buzz" or i for i in range(1, 101)])
print([(i%3==0)*"Fizz"+(i%5==0)*"Buzz" or i for i in range(1, 101)])
[1, 2, 'Fizz', 4, 'Buzz', 'Fizz', 7, 8, 'Fizz', 'Buzz', 11, 'Fizz', 13, 14, 'FizzBuzz', 16, 17, 'Fizz', 19, 'Buzz', 'Fizz', 22, 23, 'Fizz', 'Buzz', 26, 'Fizz', 28, 29, 'FizzBuzz', 31, 32, 'Fizz', 34, 'Buzz', 'Fizz', 37, 38, 'Fizz', 'Buzz', 41, 'Fizz', 43, 44, 'FizzBuzz', 46, 47, 'Fizz', 49, 'Buzz', 'Fizz', 52, 53, 'Fizz', 'Buzz', 56, 'Fizz', 58, 59, 'FizzBuzz', 61, 62, 'Fizz', 64, 'Buzz', 'Fizz', 67, 68, 'Fizz', 'Buzz', 71, 'Fizz', 73, 74, 'FizzBuzz', 76, 77, 'Fizz', 79, 'Buzz', 'Fizz', 82, 83, 'Fizz', 'Buzz', 86, 'Fizz', 88, 89, 'FizzBuzz', 91, 92, 'Fizz', 94, 'Buzz', 'Fizz', 97, 98, 'Fizz', 'Buzz']
Je peux répondre.
Ici, à titre d'exemple, nous allons comparer les opérations pour créer une liste de valeurs au carré de [1,2,3,4,5,6,7,8,9,10].
%%timeit
list(map(lambda i : i**2, range(1,11)))
10000 loops, best of 3: 23.8 µs per loop
%%timeit
[i**2 for i in range(1,11)]
100000 loops, best of 3: 15.8 µs per loop
Pour le filtre, comparez les opérations de suppression des nombres pairs de [1,2,3,4,5,6,7,8,9,10].
%%timeit
list(filter(lambda i : i%2==0, range(1,11)))
10000 loops, best of 3: 19.3 µs per loop
%%timeit
[i for i in range(1,11) if i%2==0]
100000 loops, best of 3: 10.2 µs per loop
Comme vous pouvez le voir, la vitesse est différente. La lisibilité va également jusqu'à la notation d'inclusion (dans le sens où vous pouvez facilement comprendre ce que vous faites) (différence individuelle).
Puisque nous avons parlé de vitesse de traitement, d'ailleurs. Que se passe-t-il lorsque vous comparez les vitesses de la notation d'inclusion de liste apparue en premier et de la génération de liste normale?
def for_loop(n):
extension = []
for x in range(n):
extension.append(x**2)
return extension
def comprehension(n):
return [x**2 for x in range(n)]
%timeit for_loop(1000)
1000 loops, best of 3: 1.58 ms per loop
%timeit comprehension(1000)
1000 loops, best of 3: 1.16 ms per loop
Il est difficile de remarquer la différence avec mon PC à basse vitesse, mais la différence est toujours claire. La raison en est simplement que le premier prend du temps pour récupérer l'attribut append à chaque fois que l'instruction for est activée. La chose est un essai, et seule la référence de l'attribut append est exclue de l'instruction for et le temps est mesuré.
def for_loop2(n):
extension = []
app = extension.append
for x in range(n):
app(x**2)
return extension
%timeit for_loop2(1000)
>>>1000 loops, best of 3: 1.27 ms per loop
Comme prévu, le temps de traitement était de l'ordre de for_loop> for_loop2> compréhension. La différence entre for_loop2 et compréhension signifie probablement la vitesse de l'ajout lui-même.
D'une manière ou d'une autre, j'ai compris comment gérer la notation d'inclusion.
Avec ça, je ne peux pas aller à Python Master ... à partir d'aujourd'hui ...
Ou plutôt, je pensais que c'était un style d'écriture propre à cette notation d'inclusion python, mais il semble être utilisé normalement dans de nombreux autres langages fonctionnels.
Je publierai les sites que j'ai utilisés comme référence en les incluant.
Salle des développeurs DSAS - Pourquoi la notation d'inclusion de Python est-elle si rapide?
Qiita - Un peu plus de détails sur la notation d'inclusion de python
stackoverflow - if else in a list comprehension
Maladie menant à la classification des connaissances lors de l'utilisation de if ~ else dans la notation d'inclusion de Python
La vie avec Python - Résumé de l'utilisation de la notation d'inclusion de Python
Recommended Posts