Nous continuons de traduire une série d'articles sur les analogues en Python et JavaScript
Dans les versions précédentes, nous nous appuyions sur la syntaxe des versions classiques de Python (2.7) et JS basées sur ECMAScript 5. Cette fois, nous utiliserons les nouvelles fonctions apparues dans Python 3.6 et JS de la norme ECMAScript 6.
ECMAScript 6 est une norme relativement nouvelle prise en charge par la plupart des navigateurs modernes . Pour utiliser la norme 6 dans les navigateurs plus anciens, vous aurez besoin de Babel pour traduire les conceptions JS6 modernes en support multi-navigateur.
Dans l'article d'aujourd'hui: variables dans les chaînes, décompresser les listes, fonctions lambda, itération sans index, générateurs et ensembles.
Contenu d'autres questions:
- La première partie - conversion de type, opérateur ternaire, accès à une propriété par nom de propriété, dictionnaires, listes, chaînes, concaténation de chaînes
- La deuxième partie est la sérialisation des dictionnaires, JSON, des habitués, des erreurs et des exceptions.
- Cet article
- La quatrième partie concerne les arguments de fonction, la création et l'utilisation de classes, l'héritage, les accesseurs de définition et les propriétés de classe.
Variables dans les lignes
La manière traditionnelle de construire des chaînes avec des variables utilise la concaténation de chaînes et de variables:
name = 'World' value = 'Hello, ' + name + '!\nWelcome!'
Un tel enregistrement peut sembler dispersé et mal lu, et vous pouvez souvent faire des erreurs dans les espaces entourant les mots dans les lignes.
À partir de la version 3.6 en Python et en JS ECMAScrip6, vous pouvez utiliser l'interpolation de chaînes ou, en termes Python, les chaînes f. Ce sont des modèles de chaîne dans lesquels les valeurs des variables sont substituées.
En Python, les lignes f sont marquées d'un f avant les guillemets:
name = 'World' value = f"""Hello, {name}! Welcome!""" price = 14.9 value = f'Price: {price:.2f} €'
Dans JS, les modèles de chaînes commencent et se terminent par un retour
name = 'World'; value = `Hello, ${name}! Welcome!`; price = 14.9; value = `Price ${price.toFixed(2)} €`;
Notez que les modèles peuvent être à la fois unifilaires et multilignes.
En Python, vous pouvez définir la mise en forme des variables.
Déballage des listes
En Python, et maintenant en JS, il existe une opportunité intéressante d'assigner des éléments de séquence à différentes variables. Par exemple, nous pouvons attribuer trois valeurs de la liste à trois variables:
[a, b, c] = [1, 2, 3]
Pour les tuples, les parenthèses peuvent être omises.
L'exemple suivant est très populaire en Python comme moyen d'échanger les valeurs de deux variables:
a = 1 b = 2 a, b = b, a
En JS6 +, il est également possible:
a = 1; b = 2; [a, b] = [b, a];
En Python, si nous avons un nombre indéfini d'éléments dans une liste ou un tuple, nous pouvons affecter ces éléments à un tuple de variables dans lequel les dernières valeurs retournent sous forme de liste:
first, second, *the_rest = [1, 2, 3, 4]
La même chose peut être faite dans JS (ECMAScrip6):
[first, second, ...the_rest] = [1, 2, 3, 4];
Fonctions lambda
Python et JS ont tous deux des fonctionnalités assez claires pour créer des fonctions sur une seule ligne. Ces fonctions sont appelées fonctions lambda. Les lambdas sont des fonctions qui acceptent un ou plusieurs arguments et renvoient une valeur calculée. En règle générale, les fonctions lambda sont utilisées lorsque vous devez transférer une fonction vers une autre fonction en tant que rappel, ou lorsqu'il est nécessaire de traiter chaque élément de la séquence.
En Python, vous pouvez définir une fonction lambda à l'aide du mot clé lambda :
sum = lambda x, y: x + y square = lambda x: x ** 2
JS utilise la notation => . S'il y a plusieurs arguments, ils sont placés entre crochets:
sum = (x, y) => x + y; square = x => Math.pow(x, 2);
Itération sans index
De nombreux PL vous permettent de contourner les tableaux uniquement en utilisant l'accès à un élément spécifique par numéro d'index et de faire un cycle avec l'incrément de cet index.
for (i=0; i<items.length; i++) { console.log(items[i]); }
Ce n'est pas un joli disque, et un peu compliqué pour les débutants - un tel disque n'a pas l'air naturel. Python a une belle manière concise de contourner la liste:
for item in ['A', 'B', 'C']: print(item)
Dans JS moderne, ceci est implémenté en utilisant l'opérateur for..of :
for (let item of ['A', 'B', 'C']) { console.log(item); }
Vous pouvez également contourner la ligne caractère par caractère en Python:
for character in 'ABC': print(character)
Et en JavaScript moderne:
for (let character of 'ABC') { console.log(character); }
Générateurs
Python et JS moderne vous permettent de définir des fonctions spéciales qui ressembleront à des itérateurs. À chaque appel (itération), ils renverront la prochaine valeur générée à partir de la séquence. Ces fonctions sont appelées générateurs.
Les générateurs sont généralement utilisés pour obtenir: des nombres à partir d'une plage, des lignes à partir d'un fichier, des données page par page à partir d'une API externe, des nombres fibonacci et d'autres séquences générées dynamiquement.
Techniquement, les générateurs ressemblent à des fonctions ordinaires, mais au lieu de renvoyer une seule valeur (et d'arrêter le travail), ils renvoient une seule valeur et interrompent l'opération jusqu'au prochain appel. Ils généreront les valeurs suivantes à partir de la liste à chaque appel jusqu'à la fin de la liste.
Prenons un exemple en Python dans lequel le générateur countdown () est créé, qui renvoie les nombres d'un nombre donné à 1 dans l'ordre inverse (10,9,8, ..., 1):
def countdown(counter): while counter > 0: yield counter counter -= 1 for counter in countdown(10): print(counter)
La même chose peut être obtenue dans JS moderne, mais faites attention à * dans la description de la fonction. Cela la définit comme un générateur:
function* countdown(counter) { while (counter > 0) { yield counter; counter--; } } for (let counter of countdown(10)) { console.log(counter); }
Ensembles
Nous nous sommes déjà familiarisés avec les listes (listes), les tuples (tuples), les tableaux (tableaux). Mais il existe un autre type d'ensembles de données. Les ensembles sont des tableaux de données dans lesquels chaque élément unique n'est présent que dans une seule copie. La théorie des ensembles définit les opérations avec les ensembles comme union, intersection et différence, mais nous ne les considérerons pas maintenant.
Nous créons un ensemble, y ajoutons un élément, vérifions l'existence de l'élément, obtenons le nombre total d'éléments, contournons l'ensemble par éléments et supprimons un élément à l'aide de Python:
s = set(['A']) s.add('B'); s.add('C') 'A' in s len(s) == 3 for elem in s: print(elem) s.remove('C')
Même chose sur JS:
s = new Set(['A']); s.add('B').add('C'); s.has('A') === true; s.size === 3; for (let elem of s.values()) { console.log(elem); } s.delete('C')
Pour résumer
- Les modèles de chaînes (lignes f) peuvent améliorer la lisibilité et simplifier le code, même dans le cas d'objets multilignes.
- Vous pouvez contourner les tableaux, les groupes ou les chaînes sans utiliser d'index.
- En utilisant des générateurs, vous pouvez obtenir des séquences avec un nombre presque illimité d'éléments.
- L'utilisation d'ensembles permet de vérifier facilement l'unicité d'un élément dans un tableau.
- Utilisez lambdas lorsque vous avez besoin de petites fonctions sur une seule ligne.
Dans la partie suivante, nous parlerons des arguments de fonction, des classes, de l'héritage et des propriétés.