De nombreux codeurs Python, même à des niveaux de compétence intermédiaires, sont souvent perplexes lorsqu'il s'agit du caractère astérisque en Python. Qu'est-ce que ça veut dire? Comment ça marche? Quel est son but ? Cet article répond à toutes ces questions et plus encore.
Après avoir étudié cet article, vous aurez une solide compréhension de l'opérateur astérisque * en Python et devenez un meilleur codeur dans le processus !
** Temps de lecture :3h30 **
En un mot, l'opérateur astérisque en Python a 6 significations différentes :
a*b— Multiplication,a**b— Exponentation,[a] * b— Création de types de conteneurs,def f(*args)— Déballage 1 :Définissez un nombre arbitraire d'arguments positionnels,def f(**kwargs)— Déballage 2 :Définissez un nombre arbitraire d'arguments de mots-clés, etf(**dic)— Décompresser un type de conteneur (par exemple, un dictionnaire).
Avant de commencer à apprendre, ouvrons d'abord votre écart de connaissances. Essayez ce shell de code interactif :
Exercice :Devinez la sortie de chaque exemple d'astérisque. Exécutez le code pour vérifier si vous avez bien deviné.
Vous sentez-vous à l'aise avec l'opérateur astérisque (étoile) ? Non? Je le pensais !
Quand utiliser l'opérateur étoile * en Python ?
Il y a six réponses différentes à cette question :
1) Multiplier deux valeurs
print(2 * 3) # 6
C'est ainsi que vous avez déjà utilisé l'opérateur étoile des milliers de fois dans votre propre code.
2) Calculer la puissance d'une valeur
print(2 ** 3) # 8
L'utilisation de l'opérateur étoile pour calculer l'exponentiation d'une valeur est un peu plus inhabituelle, mais toujours très courante. Utilisez simplement l'expression x ** y pour calculer "x à la puissance y" .
3) Créer des types de données de conteneur
lst = [999999] * 5 print(lst) # [999999, 999999, 999999, 999999, 999999]
La création de listes à l'aide de l'opérateur étoile est une fonctionnalité pratique. Gardez-le à l'esprit et essayez de l'utiliser dans vos prochains projets (utilisez-le ou perdez-le).
4) Créer une fonction avec un nombre arbitraire d'arguments positionnels
def average(*args):
return sum(args) / len(args)
print(average(999.0, 966.3, 988.2, 1344.5))
# 1074.5 Enfin, nous avons atteint un cas d'utilisation beaucoup plus intéressant de l'opérateur étoile que vous devez comprendre à fond.
Comment s'assurer qu'une fonction peut prendre un nombre arbitraire d'arguments ? La fonction average dans l'exemple vous montre comment faire cela avec votre argument de fonction *args . L'opérateur astérisque crée une séquence de valeurs à partir d'un nombre arbitraire d'arguments positionnels. C'est vraiment ça :il crée une nouvelle variable avec le nom args qui est visible dans la fonction.
La variable est de type tuple comme vous pouvez le voir ici :
def average(*args):
print(type(args))
return sum(args) / len(args)
print(average(999.0, 966.3, 988.2, 1344.5))
# 1074.5 5) Créer une fonction avec un nombre arbitraire d'arguments de mots clés
Tout d'abord, quels sont les arguments de mots clés ? Ce sont des arguments de fonction avec un nom (contrairement aux arguments positionnels).
def likes(**kwargs):
for key in kwargs:
print(key + " likes " + kwargs[key])
likes(Alice="Bob", Bob="Ann", Ann="Alice")
# Alice likes Bob
# Bob likes Ann
# Ann likes Alice
Dans l'exemple, nous passons trois arguments de mots clés lors de l'appel de la fonction likes(...) avec les noms :Alice, Bob et Ann. L'opérateur double astérisque ** avant la variable kwargs regroupe tous ces arguments (et potentiellement plus) dans un dictionnaire nommé kwargs .
Essayez vous-même :exécutez print(type(kwargs)) dans votre fonction et l'interpréteur vous dira que la variable est de type dict .
Maintenant, vous pouvez facilement accéder aux arguments de mot-clé dans votre fonction (en utilisant le nom de variable kwargs ).
On appelle cas 4) et 5) DÉBALLAGE des arguments. Pourquoi déballer ? Parce qu'ils sont déballés dans l'argument. Quelle est alors la forme emballée ? Vous pouvez obtenir le formulaire compressé en laissant de côté le ou les opérateurs astérisques. Par exemple, les valeurs dans args ou kwargs sont emballés dans un type de données de conteneur (c'est-à-dire un tuple dans le cas 4) et un dictionnaire dans le cas 5.
6) Décompressez un dictionnaire
def likes(**kwargs):
for key in kwargs:
print(key + " likes " + kwargs[key])
dic = {"Alice" : "Bob",
"Bob" : "Ann",
"Ann" : "Alice"}
likes(**dic)
# Alice likes Bob
# Bob likes Ann
# Ann likes Alice
Maintenant que vous savez comment déballer, il est facile de voir ce qui se passe ici. Vous créez un dictionnaire dic . Le dictionnaire contient les arguments des mots-clés, mais ils sont toujours regroupés dans le dictionnaire. Pour les décompresser, vous utilisez l'opérateur double astérisque lors de l'appel de la fonction.
Pensez-y de cette façon :si vous vouliez définir les valeurs dans le dictionnaire, vous les écririez sans la notation entre accolades {} . Pour supprimer la parenthèse, vous utilisez l'opérateur double astérisque ** .
Entraînez vos compétences de déballage !
À ce stade, vous avez découvert l'opérateur astérisque (étoile) en Python. Utilisez l'opérateur astérisque pour décompresser un type de données de conteneur tel qu'une liste ou un dictionnaire.
Pratiquons un peu le déballage. Voici la forme la plus élémentaire de déballage :
readers = ["Cata", "Brian", "Myu", "Joey"] print(readers) # ['Cata', 'Brian', 'Myu', 'Joey'] print(*readers) # Cata Brian Myu Joey
Comme vous pouvez le voir, l'opérateur astérisque supprime essentiellement le type de données wrapper (c'est-à-dire la liste). Voici comment vous pouvez utiliser le déballage simple lors de l'appel d'une fonction avec des arguments positionnels :
def say_hello(*args):
for arg in args:
print("hello " + arg)
readers = ["Cata", "Brian", "Myu", "Joey"]
say_hello(*readers)
"""
hello Cata
hello Brian
hello Myu
hello Joey
"""
Les quatre valeurs de liste "décompressent" dans l'argument fonctionnel en le passant avec *readers . Dans l'argument de la fonction, ils existent sous forme décompressée.
Dans la définition de la fonction, vous pouvez voir une autre application de l'opérateur astérisque :arguments arbitraires .
Logiquement - si vous mettez l'opérateur astérisque avant le nom de l'argument (*args ) lors de la définition de la fonction - vous lui dites que les arguments sont déjà décompressés. Autrement dit, l'expression *args contient les valeurs sous une forme décompressée. Ainsi, l'expression args (sans astérisque) fait référence à la forme compactée de ces valeurs. C'est pourquoi vous pouvez utiliser args dans votre fonction comme une liste normale.
À quoi cela ressemble-t-il pour les dictionnaires ?
elos = {"Alice" : 1988,
"Bob" : 2253,
"Frank" : 1574}
print(elos)
# {'Alice': 1988, 'Bob': 2253, 'Frank': 1574}
print(*elos)
# Alice Bob Frank Si vous décompressez un dictionnaire avec l'opérateur astérisque unique, le résultat est la forme décompressée des clés du dictionnaire.
Maintenant, comment déballer les paires (clé, valeur) du dictionnaire (et pas seulement les clés) ? En utilisant l'opérateur double astérisque !
def print_masters(**kwargs):
for key in kwargs:
if kwargs[key] > 2000:
print(str(key) + " " + str(kwargs[key]))
elos = {"Alice" : 1988,
"Bob" : 2253,
"Frank" : 1574}
print_masters(**elos)
# Bob 2253 Maintenant, voici une belle façon d'utiliser cette fonctionnalité pour fusionner deux dictionnaires en déballant les deux dans un nouveau dictionnaire…
elos_1 = {"Alice" : 1988,
"Bob" : 2253}
elos_2 = {"Pete" : 1324,
"Frank" : 1574}
elos = {**elos_1, **elos_2}
print(elos)
# {'Alice': 1988, 'Bob': 2253, 'Pete': 1324, 'Frank': 1574} Quelle belle fonctionnalité Python ! 😀
Questions fréquemment posées
Que sont les arguments de mot-clé en Python ?
Tous les arguments de la fonction ont des noms (=mots-clés). Lors de l'appel de la fonction, vous avez deux choix :utiliser des arguments de position ou des arguments de mots clés. Contrairement aux arguments de position, les arguments de mots clés rendent les noms explicites lors de l'appel de la fonction. En utilisant des arguments de mots-clés, vous n'avez pas besoin de vous soucier de l'ordre des arguments.
Voici un exemple :
def minus(a, b, c): # all arguments are named
print(a - b - c)
# positional arguments:
minus(3,2,1)
# 0
# keyword arguments:
minus(c=1, b=2, a=3)
# 0 (keyword overwrites order / position) Pourquoi **kwargs est-il utilisé en Python ?
L'expression **kwargs est utilisé lors de la définition d'une fonction pour indiquer que vous pouvez appeler cette fonction avec un nombre arbitraire d'arguments de mots clés. Voici un exemple :
def likes(**kwargs):
for key in kwargs:
print(str(key) + " likes " + str(kwargs[key]))
likes(Alice="Bob")
" Alice likes Bob"
likes(Alice="Bob", Bob="Alice")
"""
Alice likes Bob
Bob likes Alice
"""
likes(Alice="Bob", Bob="Alice", spam=42)
"""
Alice likes Bob
Bob likes Alice
spam likes 42
""" Comme vous pouvez le voir, nous pouvons appeler la fonction avec un nombre arbitraire d'arguments de mots-clés.
Que signifie l'opérateur astérisque pour les expressions régulières Python ?
Tout informaticien connaît le quantificateur astérisque des expressions régulières. Mais de nombreux non-techniciens le savent aussi. Chaque fois que vous recherchez un fichier texte *.txt sur votre ordinateur, vous utilisez l'opérateur astérisque.
Lorsqu'il est appliqué à l'expression régulière A , le A* de Python le quantificateur correspond à zéro ou plusieurs occurrences de A . Le quantificateur * est appelé opérateur astérisque et s'applique toujours uniquement à l'expression régulière précédente. Par exemple, l'expression régulière 'oui*' correspond aux chaînes ‘ye’ , "oui" , et 'ouiiii' . Mais il ne correspond pas à la chaîne vide car le quantificateur astérisque * ne s'applique pas à l'ensemble de la regex 'yes' mais uniquement à la regex précédente ‘s’ .
Étudions deux exemples de base pour vous aider à mieux comprendre. Les obtenez-vous tous ?
>>> import re
>>> text = 'finxter for fast and fun python learning'
>>> re.findall('f.* ', text)
['finxter for fast and fun python ']
>>> re.findall('f.*? ', text)
['finxter ', 'for ', 'fast ', 'fun ']
>>> re.findall('f[a-z]*', text)
['finxter', 'for', 'fast', 'fun']
>>> Si vous avez du mal à comprendre l'opérateur astérisque Python regex dans ces exemples, lisez le didacticiel suivant :
Tutoriel associé :Python Re * – Le quantificateur astérisque pour les expressions régulières
