trouver un expert Python
La syntaxe Python est claire, concise et axée sur la lisibilité. La lisibilité est sans doute l'une des caractéristiques les plus attrayantes de la langue elle-même. Cela rend Python idéal pour les personnes qui apprennent à programmer. Dans cette section, vous découvrirez plusieurs composants importants de la syntaxe Python:
Ces connaissances vous aideront à vous familiariser avec Python. Vous serez en mesure de créer vos propres programmes en un rien de temps.
Variables
En Python, les variables sont des noms attachés à un objet particulier. Ils contiennent une référence, ou un pointeur, vers l'adresse mémoire à laquelle un objet est stocké. Une fois qu'un objet est affecté à une variable, vous pouvez accéder à l'objet en utilisant le nom de la variable.
Vous devez définir vos variables à l'avance. Voici la syntaxe:
Nom de variable = variable_value
Vous devez utiliser un schéma de dénomination qui rend vos variables intuitives et lisibles. Le nom de la variable doit fournir une indication sur les valeurs qui lui sont attribuées.
Parfois, les programmeurs utilisent des noms de variables courts, tels que X
et y
. Ce sont des noms parfaitement adaptés dans le contexte des mathématiques, de l'algèbre, etc. Dans d'autres contextes, vous devez éviter les noms à caractère unique et utiliser quelque chose de plus descriptif. De cette façon, d'autres développeurs peuvent faire une estimation éclairée de ce que contiennent vos variables. Pensez aux autres, ainsi qu'à votre futur moi, lors de la rédaction de vos programmes. Votre futur moi vous remerciera.
Voici quelques exemples de noms de variables valides et non valides en Python:
>>> Nombres = [[[[1, 2, 3, 4, 5]
>>> Nombres
[1, 2, 3, 4, 5]
>>> first_num = 1
>>> first_num
1
>>> 1rst_num = 1
Fichier "", ligne 1
1rst_num = 1
^
Erreur de syntaxe: Syntaxe invalide
>>> π = 3,141592653589793
>>> π
3,141592653589793
Vos noms de variables peuvent être de n'importe quelle longueur et peuvent être composés de lettres majuscules et minuscules (A-Z
, a-z
), chiffres (0-9
), ainsi que le caractère de soulignement (_
). En résumé, les noms de variables doivent être alphanumériques, mais notez que même si les noms de variables peuvent contenir des chiffres, leur premier caractère ne peut pas être un chiffre.
Remarque: le lower_case_with_underscores La convention de dénomination, également connue sous le nom de snake_case, est couramment utilisée en Python. Elle n’est pas appliquée, mais c’est une norme largement adoptée.
Enfin, Python offre désormais un support Unicode complet, vous pouvez donc également utiliser des caractères Unicode dans vos noms de variables comme vous l'avez vu ci-dessus avec la variable π
.
Mots clés
Comme tout autre langage de programmation, Python a un ensemble de mots spéciaux qui font partie de sa syntaxe. Ces mots sont connus comme mots clés. Pour obtenir la liste complète des mots-clés disponibles dans votre installation Python actuelle, vous pouvez exécuter le code suivant dans une session interactive:
>>> Aidez-moi("mots clés")
Voici une liste des mots-clés Python. Entrez n'importe quel mot-clé pour obtenir plus d'aide.
Fausse classe de ou
Aucun continue global pass
Vrai def si relance
et del import retour
comme elif dans try
affirmer que c'est pendant
async sauf lambda avec
attendre enfin le rendement non local
pause pour pas
Chacun de ces mots-clés joue un rôle dans la syntaxe Python. Ce sont des mots réservés qui ont des significations et des objectifs spécifiques dans la langue. Vous ne devez donc pas les utiliser à d’autres fins que celles-ci. Par exemple, vous ne devez pas les utiliser comme noms de variables dans votre code.
Il existe un autre moyen d'accéder à la liste complète des mots-clés Python:
>>> importer mot-clé
>>> mot-clé.kwlist
['Faux''Aucun''Vrai''et''as''assert''async''attend''break''cla['False''None''Vrai''et''as''assert''async''attend''break''cla['False''None''True''and''as''assert''async''await''break''cla['False''None''True''and''as''assert''async''await''break''cla
ss ',' continue ',' def ',' del ',' elif ',' else ',' except ',' finally ',' for ',' from
',' global ',' if ',' import ',' in ',' is ',' lambda ',' nonlocal ',' not ',' or ',' pas
s ',' lever ',' return ',' try ',' while ',' with ',' yield ']
mot-clé
fournit un ensemble de fonctions qui vous permettent de déterminer si une chaîne donnée est un mot-clé. Par exemple, keyword.kwlist
contient une liste de tous les mots-clés actuels en Python. Celles-ci sont pratiques lorsque vous devez manipuler des mots-clés par programmation dans vos programmes Python.
Types de données intégrés
Python a une poignée de types de données intégrés, tels que des nombres (entiers, flottants, nombres complexes), des booléens, des chaînes, des listes, des tuples, des dictionnaires et des ensembles. Vous pouvez les manipuler avec plusieurs outils:
Dans les prochaines sections, vous apprendrez les bases de l’incorporation des types de données intégrés de Python dans vos programmes.
Nombres
Python fournit des entiers, des nombres à virgule flottante et des nombres complexes. Les nombres entiers et les nombres à virgule flottante sont les types numériques les plus couramment utilisés dans la programmation quotidienne, tandis que les nombres complexes ont des cas d'utilisation spécifiques en mathématiques et en sciences. Voici un résumé de leurs fonctionnalités:
Nombre | La description | Exemples | Type de données Python |
---|---|---|---|
Entier | Nombres entiers | 1 , 2 , 42 , 476 , -99999 |
int |
Point flottant | Nombres avec points décimaux | 1.0 , 2.2 , 42,09 , 476,1 , -99999,9 |
flotte |
Complexe | Numéros avec un réel partie et un imaginaire partie | complexe (1, 2) , complexe (-1, 7) , complexe ("1 + 2j") |
complexe |
Les nombres entiers ont une précision illimitée. Les informations de précision des nombres à virgule flottante sont disponibles dans sys.float_info
. Les nombres complexes ont une partie réelle et une partie imaginaire, qui sont toutes deux des nombres à virgule flottante.
Les opérateurs représentent des opérations, telles que l'addition, la soustraction, la multiplication, la division, etc. Lorsque vous les combinez avec des nombres, ils forment des expressions que Python peut évaluer:
>>> # Une addition
>>> 5 + 3
8
>>> # Soustraction
>>> 5 - 3
2
>>> # Multiplication
>>> 5 * 3
15
>>> # Division
>>> 5 / 3
1,6666666666666667
>>> # Division étage
>>> 5 // 3
1
>>> # Module (renvoie le reste de la division)
>>> 5 % 3
2
>>> # Puissance
>>> 5 ** 3
125
Ces opérateurs travaillent avec deux opérandes et sont communément appelés opérateurs arithmétiques. Les opérandes peuvent être des nombres ou des variables contenant des nombres.
Outre les opérateurs, Python vous fournit un tas de fonctions intégrées pour manipuler les nombres. Ces fonctions sont toujours disponibles pour vous. En d’autres termes, vous n’avez pas besoin de les importer pour pouvoir les utiliser dans vos programmes.
Remarque: Il existe des modules disponibles dans la bibliothèque standard Python, tels que math
, qui vous fournissent également des fonctions pour manipuler les nombres.
Pour utiliser les fonctions associées à ces modules, vous devez d'abord importer le module puis accéder à la fonction à l'aide de module.function_name ()
. Vous pouvez également importer une fonction directement depuis le module en utilisant à partir du module import nom_fonction
.
Étant donné un nombre entier ou une chaîne représentant un nombre comme argument, flotte()
renvoie un nombre à virgule flottante:
>>> # Nombres entiers
>>> flotte(9)
9,0
>>> flotte(-99999)
-99999,0
>>> # Chaînes représentant des nombres
>>> flotte("2")
2.0
>>> flotte("-200")
-200,0
>>> flotte("2,25")
2,25
>>> # Nombres complexes
>>> flotte(complexe(1, 2))
Traceback (dernier appel le plus récent):
Fichier "", ligne 1, dans
flotte(complexe(1, 2))
Erreur-type: impossible de convertir un complexe en flottant
Avec flotte()
, vous pouvez convertir des nombres entiers et des chaînes représentant des nombres en nombres à virgule flottante, mais vous ne pouvez pas convertir un nombre complexe en nombre à virgule flottante.
Étant donné un nombre à virgule flottante ou une chaîne comme argument, int ()
renvoie un entier. Cette fonction n’arrondit pas l’entrée à l’entier le plus proche. Il tronque simplement l'entrée, jetant tout ce qui se trouve après la virgule décimale et renvoie le nombre. Donc, une entrée de 10,6
Retour dix
au lieu de 11
. De même, 3,25
Retour 3
:
>>> # Nombres à virgule flottante
>>> int(10,6)
dix
>>> int(3,25)
3
>>> # Chaînes représentant des nombres
>>> int("2")
2
>>> int(«2,3»)
Traceback (dernier appel le plus récent):
Fichier "", ligne 1, dans
int(«2,3»)
ValueError: littéral invalide pour int () avec base 10: '2.3'
>>> # Nombres complexes
>>> int(complexe(1, 2))
Traceback (dernier appel le plus récent):
Fichier "", ligne 1, dans
int(complexe(1, 2))
Erreur-type: impossible de convertir complexe en int
Notez que vous pouvez passer une chaîne représentant un entier à int ()
, mais vous ne pouvez pas transmettre une chaîne représentant un nombre à virgule flottante. Les nombres complexes ne fonctionnent pas non plus.
Outre ces fonctions intégrées, il existe quelques méthodes associées à chaque type de nombre. Vous pouvez y accéder à l'aide de la référence d'attribut, également appelée notation par points:
>>> 10,0.is_integer()
Vrai
>>> 10.2.is_integer()
Faux
>>> (dix).bit_length()
4
>>> dix.bit_length()
Fichier "", ligne 1
dix.bit_length()
^
Erreur de syntaxe: Syntaxe invalide
Ces méthodes peuvent être un outil utile pour en savoir plus. Dans le cas des nombres entiers, pour accéder à leurs méthodes via un littéral, vous devez utiliser une paire de parenthèses. Sinon, vous obtenez un Erreur de syntaxe
.
Booléens
Les booléens sont implémentés comme une sous-classe d'entiers avec seulement deux valeurs possibles en Python: Vrai
ou Faux
. Notez que ces valeurs doivent commencer par une majuscule.
Vous utilisez des valeurs booléennes pour exprimer la valeur de vérité d'une expression ou d'un objet. Les booléens sont pratiques lorsque vous écrivez des fonctions de prédicat ou lorsque vous utilisez des opérateurs de comparaison, tels que supérieur à (>
), plus bas que (<
), égal (==
), etc:
>>> 2 < 5
Vrai
>>> 4 > dix
Faux
>>> 4 <= 3
Faux
>>> 3 > = 3
Vrai
>>> 5 == 6
Faux
>>> 6 ! = 9
Vrai
Les opérateurs de comparaison s'évaluent en valeurs booléennes, Vrai
ou Faux
. N'hésitez pas à jouer avec eux dans votre session interactive Python.
Python fournit une fonction intégrée, booléen ()
, qui est étroitement liée aux valeurs booléennes. Voici comment ça fonctionne:
>>> booléen(0)
Faux
>>> booléen(1)
Vrai
>>> booléen("")
Faux
>>> booléen("une")
Vrai
>>> booléen([])
Faux
>>> booléen([[[[1, 2, 3])
Vrai
booléen ()
prend un objet comme argument et retourne Vrai
ou Faux
selon la valeur de vérité de l’objet. Pour évaluer la valeur de vérité d'un objet, la fonction utilise les règles de test de vérité de Python.
D'autre part, int ()
prend une valeur booléenne et retourne 0
pour Faux
et 1
pour Vrai
:
>>> int(Faux)
0
>>> int(Vrai)
1
En effet, Python implémente ses valeurs booléennes en tant que sous-classe de int
, comme vous l'avez vu auparavant.
Cordes
Les chaînes sont des morceaux de texte ou des séquences de caractères que vous pouvez définir à l'aide de guillemets simples, doubles ou triples:
>>> # Utilisez des guillemets simples
>>> salutation = 'Bonjour!'
>>> salutation
'Bonjour!'
>>> # Utilisez des guillemets doubles
>>> Bienvenue = "Bienvenue dans Real Python!"
>>> Bienvenue
«Bienvenue dans Real Python!
>>> # Utilisez des guillemets triples
>>> message = """Merci de vous joindre a nous!"""
>>> message
'Merci de vous joindre a nous!'
>>> # Personnages d'échappement
>>> échappé = 'pouvez 't '
>>> échappé
"ne peut pas"
>>> not_escaped = "ne peut pas"
>>> not_escaped
"ne peut pas"
Notez que vous pouvez utiliser différents types de guillemets pour créer des objets chaîne en Python. Vous pouvez également utiliser la barre oblique inverse () à échapper caractères avec une signification particulière, comme les guillemets eux-mêmes.
Une fois que vous avez défini vos objets chaîne, vous pouvez utiliser l'opérateur plus (+
) à enchaîner les dans une nouvelle chaîne:
>>> "Content" + "" + "python!"
«Joyeux python!
Lorsqu'il est utilisé sur des chaînes, l'opérateur plus (+
) les concatène en une seule chaîne. Notez que vous devez inclure un espace vide (""
) entre les mots pour avoir un espacement approprié dans votre chaîne résultante. Si vous avez besoin de concaténer beaucoup de chaînes, vous devriez envisager d'utiliser .joindre()
, ce qui est plus efficace. Vous découvrirez .joindre()
un peu plus tard dans ce tutoriel.
Python est livré avec de nombreuses fonctions et méthodes intégrées utiles pour la manipulation de chaînes. Par exemple, si vous passez une chaîne comme argument à len ()
, alors vous obtiendrez la chaîne longueur, ou le nombre de caractères qu'il contient:
>>> len("Joyeux python!")
16
Quand vous appelez len ()
en utilisant une chaîne comme argument, vous obtenez le nombre de caractères, y compris les espaces vides, dans la chaîne d'entrée.
La classe de chaîne (str
) fournit un riche ensemble de méthodes utiles pour manipuler et traiter des chaînes. Par exemple, str.join ()
prend un itérable de chaînes et les joint ensemble dans une nouvelle chaîne. La chaîne sur laquelle vous appelez la méthode joue le rôle d'un séparateur:
>>> "".joindre([[[["Content", "python!"])
«Joyeux python!
str.upper ()
renvoie une copie de la chaîne sous-jacente avec toutes les lettres converties en majuscules:
>>> "Joyeux python!".plus haut()
«JOYEUX PYTHONING!
str.lower ()
renvoie une copie de la chaîne sous-jacente avec toutes les lettres converties en minuscules:
>>> "JOYEUX PYTHONING!".inférieur()
'joyeux python!'
str.format ()
effectue une opération de formatage de chaîne. Cette méthode offre une grande flexibilité pour le formatage des chaînes et l'interpolation:
>>> Nom = «John Doe»
>>> âge = 25
>>> "Je m'appelle 0 et je suis 1 ans".format(Nom, âge)
"Je m'appelle John Doe et j'ai 25 ans"
Vous pouvez également utiliser une chaîne f pour formater vos chaînes sans utiliser .format()
:
>>> Nom = «John Doe»
>>> âge = 25
>>> F"Je m'appelle Nom et je suis âge ans"
"Je m'appelle John Doe et j'ai 25 ans"
Les f-strings de Python sont une syntaxe de formatage de chaîne améliorée. Ce sont des chaînes littérales avec un F
au début, en dehors des guillemets. Expressions qui apparaissent entre accolades incorporées () sont remplacés par leurs valeurs dans la chaîne formatée.
Les chaînes sont des séquences de caractères. Cela signifie que vous pouvez récupérer des caractères individuels d'une chaîne en utilisant leur indice de position. Un index est un nombre entier de base zéro associé à une position spécifique dans une séquence:
>>> Bienvenue = "Bienvenue dans Real Python!"
>>> Bienvenue[[[[0]
«W»
>>> Bienvenue[[[[11]
«R»
>>> Bienvenue[[[[-1]
'!'
Une opération d'indexation récupère le caractère à la position indiquée par l'index donné. Notez qu'un index négatif récupère l'élément dans l'ordre inverse, avec -1
étant l'index du dernier caractère de la chaîne.
Vous pouvez également récupérer une partie d'une chaîne en trancher il:
>>> Bienvenue = "Bienvenue dans Real Python!"
>>> Bienvenue[[[[0:sept]
'Bienvenue'
>>> Bienvenue[[[[11:22]
'Vrai Python'
Les opérations de tranchage prennent l'élément sous la forme [start:end:step]
. Ici, début
est l'index du premier élément à inclure dans la tranche, et fin
est l'index du dernier élément, qui n'est pas inclus dans la tranche renvoyée. Finalement, étape
est un entier facultatif représentant le nombre d'éléments à sauter lors de l'extraction des éléments de la chaîne d'origine. UNE étape
de 2
, par exemple, renverra tous les autres éléments entre début
et Arrêtez
.
Listes
Les listes sont généralement appelées tableaux dans presque tous les autres langages de programmation. En Python, les listes sont des séquences modifiables qui regroupent divers objets. Pour créer une liste, vous utilisez une affectation avec une séquence d'objets séparés par des virgules entre crochets ([]
) sur son côté droit:
>>> # Définir une liste vide
>>> vide = []
>>> vide
[]
>>> # Définir une liste de nombres
>>> Nombres = [[[[1, 2, 3, 100]
>>> Nombres
[1, 2, 3, 100]
>>> # Modifier la liste en place
>>> Nombres[[[[3] = 200
>>> Nombres
[1, 2, 3, 200]
>>> # Définir une liste de chaînes
>>> super héros = [[[["homme chauve-souris", "Superman", "homme araignée"]
>>> super-héros
['batman', 'superman', 'spiderman']
>>> # Définir une liste d'objets avec différents types de données
>>> mixed_types = [[[["Bonjour le monde", [[[[4, 5, 6], Faux]
>>> mixed_types
['Hello World', [4, 5, 6], Faux]
Les listes peuvent contenir des objets de différents types de données, y compris d'autres listes. Ils peuvent également être vides. Étant donné que les listes sont des séquences mutables, vous pouvez les modifier sur place à l'aide de la notation d'index et d'une opération d'affectation.
Étant donné que les listes sont des séquences comme des chaînes, vous pouvez accéder à leurs éléments individuels à l'aide d'indices entiers de base zéro:
>>> Nombres = [[[[1, 2, 3, 200]
>>> Nombres[[[[0]
1
>>> Nombres[[[[1]
2
>>> super héros = [[[["homme chauve-souris", "Superman", "homme araignée"]
>>> super-héros[[[[-1]
"homme araignée"
>>> super-héros[[[[-2]
"Superman"
Les opérations d'indexation fonctionnent également avec les listes Python, vous pouvez donc récupérer n'importe quel élément d'une liste en utilisant son index de position. Les indices négatifs récupèrent les éléments dans l'ordre inverse, à partir du dernier élément.
Vous pouvez également créer de nouvelles listes à partir d'une liste existante à l'aide d'une opération de découpage:
>>> Nombres = [[[[1, 2, 3, 200]
>>> Nouvelle liste = Nombres[[[[0:3]
>>> Nouvelle liste
[1, 2, 3]
Si vous imbriquez une liste, une chaîne ou toute autre séquence dans une autre liste, vous pouvez accéder aux éléments internes à l'aide de plusieurs index:
>>> mixed_types = [[[["Bonjour le monde", [[[[4, 5, 6], Faux]
>>> mixed_types[[[[1][[[[2]
6
>>> mixed_types[[[[0][[[[6]
«W»
Dans ce cas, le premier index obtient l'élément de la liste de conteneurs et le deuxième index récupère un élément de la séquence interne.
Vous pouvez également concaténer vos listes à l'aide de l'opérateur plus:
>>> des fruits = [[[["pommes", "les raisins", "des oranges"]
>>> légumes = [[[["blé", "chou frisé", "champignons"]
>>> liste_épicerie = des fruits + légumes
>>> liste_épicerie
['apples', 'grapes', 'oranges', 'corn', 'kale', 'mushrooms']
Les listes étant des séquences d'objets, vous pouvez utiliser les mêmes fonctions que celles que vous utilisez sur toute autre séquence, comme des chaînes.
Étant donné une liste comme argument, len ()
renvoie la longueur de la liste ou le nombre d’objets qu’elle contient:
>>> Nombres = [[[[1, 2, 3, 200]
>>> len(Nombres)
4
Vous pouvez consulter la documentation Python pour voir toutes les méthodes de liste disponibles. Vous trouverez ci-dessous un résumé de certaines des méthodes les plus couramment utilisées.
list.append ()
prend un objet comme argument et l'ajoute à la fin de la liste sous-jacente:
>>> des fruits = [[[["pommes", "les raisins", "des oranges"]
>>> des fruits.ajouter("myrtilles")
>>> des fruits
['apples', 'grapes', 'oranges', 'blueberries']
list.sort ()
trie la liste sous-jacente en place:
>>> des fruits.Trier()
>>> des fruits
['apples', 'blueberries', 'grapes', 'oranges']
list.pop ()
prend un index entier comme argument, puis supprime et renvoie l'élément à cet index dans la liste sous-jacente:
>>> numéros_liste = [[[[1, 2, 3, 200]
>>> numéros_liste.pop(2)
3
>>> numéros_liste
[1, 2, 200]
Les listes sont des structures de données assez courantes et polyvalentes en Python. Ils sont si populaires que les développeurs ont parfois tendance à en abuser, ce qui peut rendre le code inefficace.
Tuples
Les tuples sont similaires aux listes, mais ce sont des séquences immuables. Cela signifie que vous ne pouvez pas les modifier après leur création. Pour créer un objet tuple, vous pouvez utiliser une opération d'affectation avec une séquence d'éléments séparés par des virgules sur son côté droit. Vous utilisez généralement des parenthèses pour délimiter un tuple, mais elles ne sont pas obligatoires:
>>> employé = ("Jeanne", "Biche", 31, "Développeur de logiciels")
>>> employé[[[[0] = "John"
Traceback (dernier appel le plus récent):
Fichier "", ligne 1, dans
employé[[[[0] = "John"
Erreur-type: L'objet 'tuple' ne prend pas en charge l'attribution d'éléments
Si vous essayez de changer un tuple en place, vous obtenez un Erreur-type
indiquant que les tuples ne prennent pas en charge les modifications sur place.
Tout comme les listes, vous pouvez également effectuer une indexation et un découpage avec des tuples:
>>> employé = ("Jeanne", "Biche", 31, "Développeur de logiciels")
>>> employé[[[[0]
'Jeanne'
>>> employé[[[[1:3]
('Biche', 31 ans)
Les tuples étant des séquences, vous pouvez utiliser des index pour récupérer des éléments spécifiques dans les tuples. Notez que vous pouvez également récupérer des tranches d'un tuple avec une opération de découpage.
Vous pouvez également ajouter deux tuples à l'aide de l'opérateur de concaténation:
>>> premier_tuple = (1, 2)
>>> second_tuple = (3, 4)
>>> troisième_tuple = premier_tuple + second_tuple
>>> troisième_tuple
(1, 2, 3, 4)
Une opération de concaténation avec deux tuples crée un nouveau tuple contenant tous les éléments des deux tuples d'entrée.
Comme avec les listes et les chaînes, vous pouvez utiliser certaines fonctions intégrées pour manipuler les tuples. Par exemple, len ()
renvoie la longueur du tuple ou le nombre d'éléments qu'il contient:
>>> Nombres = (1, 2, 3)
>>> len(Nombres)
3
Avec un tuple comme argument, liste()
renvoie une liste avec tous les éléments du tuple d'entrée:
>>> Nombres = (1, 2, 3)
>>> liste(Nombres)
[1, 2, 3]
Les tuples étant des séquences immuables, la plupart des méthodes disponibles pour les listes ne fonctionnent pas sur les tuples. Cependant, les tuples ont deux méthodes intégrées:
.compter()
.indice()
tuple.count ()
prend un objet comme argument et renvoie le nombre de fois où l'élément apparaît dans le tuple sous-jacent. Si l’objet n’est pas dans le tuple, alors .compter()
Retour 0
:
>>> des lettres = ("une", "b", "b", "c", "une")
>>> des lettres.compter("une")
2
>>> des lettres.compter("c")
1
>>> des lettres.compter("ré")
0
tuple.index ()
prend un objet comme argument et retourne l'index de la première instance de cet objet dans le tuple en question. Si l’objet n’est pas dans le tuple, alors .indice()
soulève un ValueError
:
>>> des lettres = ("une", "b", "b", "c", "une")
>>> des lettres.indice("une")
0
>>> des lettres.indice("c")
3
>>> des lettres.indice("ré")
Traceback (dernier appel le plus récent):
Fichier "", ligne 1, dans
des lettres.indice("ré")
ValueError: tuple.index (x): x pas dans le tuple
Les tuples sont des structures de données très utiles. Ils sont efficaces en mémoire, immuables et ont un grand potentiel pour gérer des données qui ne devraient pas être modifiées par l'utilisateur. Ils peuvent également être utilisés comme clés de dictionnaire, que vous découvrirez dans la section suivante.
Dictionnaires
Les dictionnaires sont un type de tableau associatif contenant une collection de paires clé-valeur dans lequel chaque clé est un objet hachable qui correspond à un objet arbitraire, la valeur. Il existe plusieurs façons de créer un dictionnaire. En voici deux:
>>> personne1 = "Nom": «John Doe», "âge": 25, "emploi": "Développeur Python"
>>> personne1
'name': 'John Doe', 'age': 25, 'job': 'Python Developer'
>>> personne2 = dict(Nom="Jane Doe", âge=24, emploi="Développeur web")
>>> personne2
'name': 'Jane Doe', 'age': 24, 'job': 'Web Developer'
La première approche utilise une paire de parenthèses dans lesquelles vous ajoutez une liste de paires clé-valeur séparées par des virgules, en utilisant un signe deux-points (:
) pour séparer les clés des valeurs. La deuxième approche utilise la fonction intégrée dict ()
, qui peut prendre des arguments de mots-clés et les transformer en dictionnaire, avec les mots-clés comme clés et les arguments comme valeurs.
Vous pouvez récupérer la valeur associée à une clé donnée en utilisant la syntaxe suivante:
>>> personne1 = "Nom": «John Doe», "âge": 25, "emploi": "Développeur Python"
>>> personne1[[[["Nom"]
«John Doe»
>>> personne1[[[["âge"]
25
C'est assez similaire à une opération d'indexation, mais cette fois, vous utilisez une clé au lieu d'un index.
Vous pouvez également récupérer les clés, les valeurs et les paires clé-valeur dans un dictionnaire à l'aide de .clés()
, .valeurs()
, et .articles()
, respectivement:
>>> # Récupérer toutes les clés
>>> personne1.clés()
dict_keys (['name', 'age', 'job'])
>>> # Récupérer toutes les valeurs
>>> personne1.valeurs()
dict_values (['John Doe', 25, 'Python Developer'])
>>> # Récupérer toutes les paires clé-valeur
>>> personne1.articles()
dict_items ([('name', 'John Doe'), ('age', 25), ('job', 'Python Developer')])
Ces trois méthodes sont des outils fondamentaux pour manipuler des dictionnaires en Python, en particulier lorsque vous parcourez un dictionnaire.
Ensembles
Python fournit également un ensemble Structure de données. Les ensembles sont des collections non ordonnées et modifiables d'objets Python arbitraires mais hachables. Vous pouvez créer des ensembles de plusieurs manières. En voici deux:
>>> employés1 = "John", "Jeanne", «Linda»
'John', 'Linda', 'Jane'
>>> employés2 = ensemble([[[[«David», "Marque", «Marie»])
'Mark', 'David', 'Marie'
>>> vide = ensemble()
>>> vide
ensemble()
Dans le premier exemple, vous utilisez des accolades et une liste d'objets séparés par des virgules pour créer un ensemble. Si tu utilises ensemble()
, vous devez alors fournir un itérable avec les objets que vous souhaitez inclure dans l'ensemble. Enfin, si vous souhaitez créer un ensemble vide, vous devez utiliser ensemble()
sans arguments. L'utilisation d'une paire de parenthèses vides crée un dictionnaire vide au lieu d'un ensemble.
L'un des cas d'utilisation les plus courants d'ensembles est de les utiliser pour supprimer les objets en double d'un itérable existant:
>>> ensemble([[[[1, 2, 2, 3, 4, 5, 3])
1, 2, 3, 4, 5
Les ensembles étant des collections d'objets uniques, lorsque vous créez un ensemble à l'aide de ensemble()
et un itérable comme argument, le constructeur de classe supprime tous les objets en double et ne conserve qu'une seule instance de chacun dans l'ensemble résultant.
Remarque: Python fournit également une variation immuable d'un ensemble appelé frozenset. Vous pouvez les créer en appelant frozenset ()
avec un itérable comme argument. Si vous appelez frozenset ()
sans arguments, alors vous obtiendrez un frozenset vide.
Vous pouvez utiliser certaines fonctions intégrées avec des ensembles comme vous l'avez fait avec d'autres structures de données intégrées. Par exemple, si vous passez un ensemble comme argument à len ()
, puis vous obtenez le nombre d'éléments dans l'ensemble:
>>> employés1 = "John", "Jeanne", «Linda»
>>> len(employés1)
3
Vous pouvez également utiliser des opérateurs pour gérer des ensembles en Python. Dans ce cas, la plupart des opérateurs représentent des opérations d'ensemble typiques comme syndicat (|
), intersection (&
), différence (-
), etc:
>>> nombres premiers = 2, 3, 5, sept
>>> égalise = 2, 4, 6, 8
>>> # Syndicat
>>> nombres premiers | égalise
2, 3, 4, 5, 6, 7, 8
>>> # Intersection
>>> nombres premiers & égalise
2
>>> # Différence
>>> nombres premiers - égalise
3, 5, 7
Les ensembles fournissent un tas de méthodes, y compris des méthodes qui exécutent des opérations d'ensemble comme celles de l'exemple ci-dessus. Ils fournissent également des méthodes pour modifier ou mettre à jour l'ensemble sous-jacent. Par exemple, set.add ()
prend un objet et l'ajoute à l'ensemble:
>>> nombres premiers = 2, 3, 5, sept
>>> nombres premiers.ajouter(11)
>>> nombres premiers
2, 3, 5, 7, 11
set.remove ()
prend un objet et le supprime de l'ensemble:
>>> nombres premiers = 2, 3, 5, sept, 11
>>> nombres premiers.retirer(11)
>>> nombres premiers
2, 3, 5, 7
Les ensembles Python sont des structures de données très utiles qui constituent un ajout important au kit d'outils du développeur Python.
Conditionnels
Parfois, vous devez exécuter (ou non) un bloc de code donné selon que certaines conditions sont remplies. Dans ce cas, expressions conditionnelles sont votre allié. Ces instructions contrôlent l'exécution d'un groupe d'instructions basées sur le valeur de vérité d'une expression. Vous pouvez créer une instruction conditionnelle en Python avec le si
mot-clé et la syntaxe générale suivante:
si expr0:
# Exécuter si expr0 est vrai
# Votre code va ici ...
elif expr1:
# Exécuter si expr1 est vrai
# Votre code va ici ...
elif expr2:
# Exécuter si expr2 est vrai
# Votre code va ici ...
...
autre:
# Exécuter si toutes les expressions sont fausses
# Votre code va ici ...
# Prochaine déclaration
le si
L'instruction exécute un seul bloc de code. En d'autres termes, si expr0
est vrai, alors seul son bloc de code associé s'exécutera. Après cela, l'exécution passe à l'instruction directement sous le si
déclaration.
La première elif
clause évalue expr1
seulement si expr0
c'est faux. Si expr0
est faux et expr1
est vrai, alors seul le bloc de code associé à expr1
fonctionnera, et ainsi de suite. le autre
La clause est facultative et ne fonctionnera que si toutes les conditions précédemment évaluées sont fausses. Vous pouvez en avoir autant elif
clauses dont vous avez besoin, y compris aucune du tout, mais vous ne pouvez en avoir qu'une autre
clause.
Voici quelques exemples de comment cela fonctionne:
>>> âge = 21
>>> si âge > = 18:
... impression("Vous êtes un adulte légal")
...
Vous êtes un adulte légal
>>> âge = 16
>>> si âge > = 18:
... impression("Vous êtes un adulte légal")
... autre:
... impression("Tu n'es PAS un adulte")
...
Tu n'es PAS un adulte
>>> âge = 18
>>> si âge > 18:
... impression("Vous avez plus de 18 ans")
... elif âge == 18:
... impression("Vous avez exactement 18 ans")
...
Tu as exactement 18 ans
Dans le premier exemple, âge
est égal à 21
, donc la condition est vraie et Python imprime Vous êtes un adulte légal
à votre écran. Dans le deuxième exemple, l'expression âge> = 18
évalue à Faux
, donc Python exécute le bloc de code du autre
clause et imprime Tu n'es PAS un adulte
sur votre écran.
Dans le dernier exemple, la première expression, âge> 18
, est faux, donc l'exécution passe au elif
clause. La condition de cette clause est vraie, donc Python exécute le bloc de code associé et imprime Tu as exactement 18 ans
.
Boucles
Si vous devez répéter un morceau de code plusieurs fois pour obtenir un résultat final, vous devrez peut-être utiliser un boucle. Les boucles sont un moyen courant d'itérer plusieurs fois et d'effectuer certaines actions à chaque itération. Python fournit deux types de boucles:
pour
boucles pour itération définie, ou effectuer un nombre défini ou des répétitionstandis que
boucles pour itération indéfinie, ou répéter jusqu'à ce qu'une condition donnée soit remplie
Voici la syntaxe générale pour créer un pour
boucle:
pour loop_var dans itérable:
# Répétez ce bloc de code jusqu'à ce que l'itérable soit épuisé
# Faites quelque chose avec loop_var ...
si break_condition:
Pause # Laissez la boucle
si continue_condition:
continuer # Reprendre la boucle sans exécuter le code restant
# Code restant ...
autre:
# Exécutez ce bloc de code si aucune instruction break n'est exécutée
# Prochaine déclaration
Ce type de boucle effectue autant d'itérations que d'éléments dans itérable
. Normalement, vous utilisez chaque itération pour effectuer une opération donnée sur la valeur de loop_var
. le autre
clause est facultative et s'exécute lorsque la boucle se termine. le Pause
et continuer
les instructions sont également facultatives.
Consultez l'exemple suivant:
>>> pour je dans (1, 2, 3, 4, 5):
... impression(je)
... autre:
... impression("La boucle n'a pas été interrompue")
...
1
2
3
4
5
La boucle n'a pas été interrompue
Lorsque la boucle traite le dernier nombre du tuple, le flux d'exécution saute dans le autre
clause et imprime La boucle n'a pas été interrompue
sur votre écran. C'est parce que votre boucle n'a pas été interrompue par un Pause
déclaration. Vous utilisez couramment un autre
clause dans des boucles qui ont un Pause
instruction dans leur bloc de code. Sinon, ce n’est pas nécessaire.
Si la boucle atteint un break_condition
, puis le Pause
L'instruction interrompt l'exécution de la boucle et passe à l'instruction suivante sous la boucle sans consommer le reste des éléments de itérable
:
>>> nombre = 3
>>> pour je dans (1, 2, 3, 4, 5):
... si je == nombre:
... impression("Numéro trouvé:", je)
... Pause
... autre:
... impression("Numéro introuvable")
...
Nombre trouvé: 3
Quand i == 3
, la boucle imprime Nombre trouvé: 3
sur votre écran, puis frappe le Pause
déclaration. Cela interrompt la boucle et l'exécution saute à la ligne sous la boucle sans exécuter le autre
clause. Si vous définissez nombre
à 6
ou tout autre nombre qui n'est pas dans le tuple de nombres, alors la boucle n'atteint pas le Pause
déclaration et impressions Numéro introuvable
.
Si la boucle atteint un continue_condition
, puis le continuer
L'instruction reprend la boucle sans exécuter le reste des instructions dans le bloc de code de la boucle:
>>> pour je dans (1, 2, 3, 4, 5):
... si je == 3:
... continuer
... impression(je)
...
1
2
4
5
Cette fois, le continuer
L'instruction redémarre la boucle lorsque i == 3
. C’est pourquoi vous ne voyez pas le nombre 3
dans la sortie.
Les deux déclarations, Pause
et continuer
, doit être enveloppé dans un conditionnel. Sinon, la boucle se cassera toujours lorsqu'elle frappe Pause
et continuez quand ça frappe continuer
.
Vous utilisez normalement un tandis que
boucle lorsque vous ne savez pas à l'avance combien d'itérations vous avez besoin pour terminer une opération donnée. C’est pourquoi cette boucle est utilisée pour effectuer des itérations indéfinies.
Voici la syntaxe générale d'un tandis que
boucle en Python:
tandis que expression:
# Répétez ce bloc de code jusqu'à ce que l'expression soit fausse
# Faire quelque chose...
si break_condition:
Pause # Laissez la boucle
si continue_condition:
continuer # Reprendre la boucle sans exécuter le code restant
# Code restant ...
autre:
# Exécutez ce bloc de code si aucune instruction break n'est exécutée
# Prochaine déclaration
Cette boucle fonctionne de la même manière qu'un pour
boucle, mais il continuera à être itéré jusqu'à ce que expression
c'est faux. Un problème courant avec ce type de boucle survient lorsque vous fournissez un expression
qui n'évalue jamais à Faux
. Dans ce cas, la boucle sera itérée pour toujours.
Voici un exemple de la façon dont le tandis que
la boucle fonctionne:
>>> compter = 1
>>> tandis que compter < 5:
... impression(compter)
... compter = compter + 1
... autre:
... impression("La boucle n'a pas été interrompue")
...
1
2
3
4
La boucle n'a pas été interrompue
Encore une fois, le autre
clause est facultative et vous l’utiliserez généralement avec un Pause
instruction dans le bloc de code de la boucle. Ici, Pause
et continuer
fonctionne de la même manière que dans un pour
boucle.
Il y a des situations dans lesquelles vous avez besoin d'un boucle infinie. Par exemple, les applications GUI s’exécutent dans une boucle infinie qui gère les événements de l’utilisateur. Cette boucle a besoin d'un Pause
pour terminer la boucle lorsque, par exemple, l'utilisateur quitte l'application. Otherwise, the application would continue running forever.
Les fonctions
In Python, a function is a named code block that performs actions and optionally computes the result, which is then returned to the calling code. You can use the following syntax to define a function:
def function_name(arg1, arg2, ..., argN):
# Do something with arg1, arg2, ..., argN
revenir return_value
le def
keyword starts the function header. Then you need the name of the function and a list of arguments in parentheses. Note that the list of arguments is optional, but the parentheses are syntactically required.
The final step is to define the function’s code block, which will begin one level of indentation to the right. In this case, the revenir
statement is also optional and is the statement that you use if you need to send a return_value
back to the caller code.
Remarque: The full syntax to define functions and their arguments is beyond the scope of this tutorial. For an in-depth resource on this topic, check out Defining Your Own Python Function.
To use a function, you need to call il. A function call consists of the function’s name, followed by the function’s arguments in parentheses:
function_name(arg1, arg2, ..., argN)
You can have functions that don’t require arguments when called, but the parentheses are always needed. If you forget them, then you won’t be calling the function but referencing it as a function object.
[ad_2]