Cette page a été traduite par l'API Cloud Translation.

Introduction à Python

Avant-propos

Bienvenue dans le tutoriel en ligne de Google sur Python. Il s'appuie sur le cours d'introduction à Python proposé en interne. Comme indiqué sur la page de configuration, ce contenu couvre Python 3.

Si vous recherchez un cours MOOC complémentaire, essayez ceux d'Udacity et de Coursera (Introduction à la programmation [débutants] ou Introduction à Python). Enfin, si vous recherchez une formation en ligne à votre rythme sans regarder de vidéos, essayez celles listées à la fin de cet article. Elles proposent toutes du contenu pédagogique sur les fonctionnalités, ainsi qu'un interpréteur Python interactif avec lequel vous pouvez vous entraîner. Qu'est-ce que cet "interprète" dont nous parlons ? Vous le découvrirez dans la section suivante.

Présentation des langues

Python est un langage dynamique et interprété (compilé en bytecode). Le code source ne contient aucune déclaration de type pour les variables, les paramètres, les fonctions ou les méthodes. Le code est alors court et flexible, mais vous perdez la vérification du type au moment de la compilation du code source. Python suit les types de toutes les valeurs au moment de l'exécution et signale le code qui n'a pas de sens au fur et à mesure de son exécution.

Pour comprendre le fonctionnement du code Python, le meilleur moyen est d'exécuter l'interpréteur Python et de saisir le code directement dedans. Si vous vous posez une question du type "Que se passe-t-il si j'ajoute un int à un list ?", le moyen le plus rapide et probablement le plus efficace de le découvrir est de la saisir dans l'interpréteur Python. (Voir ci-dessous pour découvrir ce qui se passe réellement.)

$ python3        ## Run the Python interpreter
Python 3.X.X (XXX, XXX XX XXXX, XX:XX:XX) [XXX] on XXX
Type "help", "copyright", "credits" or "license" for more information.
>>> a = 6       ## set a variable in this interpreter session
>>> a           ## entering an expression prints its value
6
>>> a + 2
8
>>> a = 'hi'    ## 'a' can hold a string just as well
>>> a
'hi'
>>> len(a)      ## call the len() function on a string
2
>>> a + len(a)  ## try something that doesn't work
Traceback (most recent call last):
  File "", line 1, in 
TypeError: can only concatenate str (not "int") to str
>>> a + str(len(a))  ## probably what you really wanted
'hi2'
>>> foo         ## try something else that doesn't work
Traceback (most recent call last):
  File "", line 1, in 
NameError: name 'foo' is not defined
>>> ^D          ## type CTRL-d to exit (CTRL-z in Windows/DOS terminal)

Les deux lignes que Python affiche après la saisie de "python" et avant l'invite ">>>" vous indiquent la version de Python que vous utilisez et l'endroit où elle a été créée. Ces exemples devraient fonctionner pour vous tant que la première chose imprimée est "Python 3.".

Comme vous pouvez le voir ci-dessus, il est facile d'expérimenter avec des variables et des opérateurs. De plus, l'interpréteur génère (ou "déclenche", selon le terme Python) une erreur d'exécution si le code tente de lire une variable à laquelle aucune valeur n'a été attribuée. Comme C++ et Java, Python est sensible à la casse. Par conséquent, "a" et "A" sont des variables différentes. La fin d'une ligne marque la fin d'une instruction. Contrairement à C++ et Java, Python ne nécessite donc pas de point-virgule à la fin de chaque instruction. Les commentaires commencent par un "#" et s'étendent jusqu'à la fin de la ligne.

Code source Python

Les fichiers source Python utilisent l'extension ".py" et sont appelés "modules". Avec un module Python hello.py, le moyen le plus simple de l'exécuter est d'utiliser la commande shell "python hello.py Alice", qui appelle l'interpréteur Python pour exécuter le code dans hello.py, en lui transmettant l'argument de ligne de commande "Alice". Consultez la page de documentation officielle pour découvrir toutes les options disponibles lorsque vous exécutez Python à partir de la ligne de commande.

Voici un programme hello.py très simple (notez que les blocs de code sont délimités de manière stricte à l'aide d'indentations plutôt que d'accolades ; nous y reviendrons plus tard) :

#!/usr/bin/python3

# import modules used here -- sys is a very standard one
import sys

# Gather our code in a main() function
def main():
    print('Hello there', sys.argv[1])
    # Command line args are in sys.argv[1], sys.argv[2] ...
    # sys.argv[0] is the script name itself and can be ignored

# Standard boilerplate to call the main() function to begin
# the program.
if __name__ == '__main__':
    main()

L'exécution de ce programme à partir de la ligne de commande ressemble à ceci :

$ python3 hello.py Guido
Hello there Guido
$ ./hello.py Alice  ## without needing 'python3' first (Unix)
Hello there Alice

Importations, arguments de ligne de commande et `len()`

Les instructions les plus externes d'un fichier Python, ou "module", effectuent sa configuration ponctuelle. Ces instructions s'exécutent de haut en bas la première fois que le module est importé quelque part, en configurant ses variables et ses fonctions. Un module Python peut être exécuté directement (comme ci-dessus python3 hello.py Bob) ou il peut être importé et utilisé par un autre module. Lorsqu'un fichier Python est exécuté directement, la variable spéciale "__name__" est définie sur "__main__". Il est donc courant d'avoir le boilerplate if __name__ ==... indiqué ci-dessus pour appeler une fonction main() lorsque le module est exécuté directement, mais pas lorsque le module est importé par un autre module.

Dans un programme Python standard, la liste sys.argv contient les arguments de ligne de commande de manière standard, avec sys.argv[0] qui correspond au programme lui-même, sys.argv[1] au premier argument, et ainsi de suite. Si vous connaissez argv ou le nombre d'arguments, vous pouvez simplement demander cette valeur à Python avec len(sys.argv), comme nous l'avons fait dans le code de l'interpréteur interactif ci-dessus lorsque nous avons demandé la longueur d'une chaîne. En général, len() peut vous indiquer la longueur d'une chaîne, le nombre d'éléments dans les listes et les tuples (une autre structure de données de type tableau) et le nombre de paires clé-valeur dans un dictionnaire.

Fonctions définies par l'utilisateur

Les fonctions en Python sont définies comme suit :

# Defines a "repeat" function that takes 2 arguments.
def repeat(s, exclaim):
    """
    Returns the string 's' repeated 3 times.
    If exclaim is true, add exclamation marks.
    """

    result = s + s + s # can also use "s * 3" which is faster (Why?)
    if exclaim:
        result = result + '!!!'
    return result

Notez également que les lignes qui composent la fonction ou l'instruction "if" sont regroupées, car elles ont toutes le même niveau d'indentation. Nous avons également présenté deux façons différentes de répéter des chaînes, en utilisant l'opérateur +, qui est plus convivial, mais l'opérateur * fonctionne également, car il s'agit de l'opérateur de répétition de Python. Cela signifie que '-' * 10 donne '----------', ce qui permet de créer une "ligne" à l'écran. Dans le commentaire du code, nous avons indiqué que * fonctionne plus rapidement que +, car * calcule la taille de l'objet résultant une seule fois, alors qu'avec +, ce calcul est effectué chaque fois que + est appelé. Les opérateurs + et * sont dits "surchargés", car ils ont une signification différente pour les nombres et pour les chaînes (et d'autres types de données).

Le mot clé def définit la fonction avec ses paramètres entre parenthèses et son code mis en retrait. La première ligne d'une fonction peut être une chaîne de documentation ("docstring") qui décrit ce que fait la fonction. La docstring peut être une description sur une seule ligne ou sur plusieurs lignes, comme dans l'exemple ci-dessus. (Oui, il s'agit de "triples guillemets", une fonctionnalité propre à Python.) Les variables définies dans la fonction sont locales à cette fonction. Par conséquent, le "résultat" de la fonction ci-dessus est distinct d'une variable "résultat" dans une autre fonction. L'instruction return peut accepter un argument, auquel cas il s'agit de la valeur renvoyée à l'appelant.

Voici le code qui appelle la fonction repeat() ci-dessus et affiche ce qu'elle renvoie :

def main():
    print(repeat('Yay', False))      ## YayYayYay
    print(repeat('Woo Hoo', True))   ## Woo HooWoo HooWoo Hoo!!!

Lors de l'exécution, les fonctions doivent être définies par l'exécution d'un "def" avant d'être appelées. Il est courant de définir une fonction main() vers le bas du fichier, avec les fonctions qu'elle appelle au-dessus.

Retrait

Une fonctionnalité Python inhabituelle est que l'indentation des espaces blancs d'un morceau de code affecte sa signification. Un bloc logique d'instructions, tel que celles qui composent une fonction, doit avoir la même indentation, définie à partir de l'indentation de sa fonction parente ou de son "if" ou autre. Si l'une des lignes d'un groupe présente une indentation différente, elle est signalée comme erreur de syntaxe.

L'utilisation des espaces blancs en Python peut sembler un peu étrange au début, mais elle est logique et je m'y suis habitué très rapidement. Évitez d'utiliser des tabulations, car elles compliquent considérablement le système d'indentation (sans parler du fait que les tabulations peuvent avoir différentes significations sur différentes plates-formes). Configurez votre éditeur pour qu'il insère des espaces au lieu de tabulations pour le code Python.

Une question fréquente que se posent les débutants est : "Combien d'espaces dois-je utiliser pour l'indentation ?" Selon le guide de style Python officiel (PEP 8), vous devez utiliser une indentation de quatre espaces. (Pour info, les consignes de style internes de Google prévoient une indentation de deux espaces.)

Code vérifié au moment de l'exécution

Python effectue très peu de vérifications au moment de la compilation, en différant presque toutes les vérifications de type, de nom, etc. sur chaque ligne jusqu'à ce que cette ligne s'exécute. Supposons que la fonction main() ci-dessus appelle repeat() comme suit :

def main():
    if name == 'Guido':
        print(repeeeet(name) + '!!!')
    else:
        print(repeat(name))

L'instruction "if" contient une erreur évidente : la fonction repeat() est saisie par erreur sous la forme repeeeet(). Ce qui est amusant avec Python, c'est que ce code se compile et s'exécute correctement tant que le nom au moment de l'exécution n'est pas "Guido". Ce n'est que lorsqu'une exécution tente réellement d'exécuter la fonction repeeeet() qu'elle remarque qu'une telle fonction n'existe pas et génère une erreur. Il existe également une deuxième erreur dans cet extrait : aucune valeur n'a été attribuée à "name" avant sa comparaison avec "Guido". Python génère une erreur "NameError" si vous essayez d'évaluer une variable non attribuée. Voici quelques exemples qui montrent que, lorsque vous exécutez un programme Python pour la première fois, certaines des premières erreurs que vous voyez sont de simples fautes de frappe ou des variables non initialisées comme celles-ci. C'est un domaine dans lequel les langages avec un système de types plus verbeux, comme Java, ont un avantage : ils peuvent détecter de telles erreurs au moment de la compilation (mais bien sûr, vous devez conserver toutes ces informations de type… c'est un compromis).

Python 3 a introduit les annotations de type. Les indications de type vous permettent d'indiquer le type de chaque argument d'une fonction, ainsi que le type de l'objet renvoyé par la fonction. Par exemple, dans la fonction annotée def is_positive(n: int) -> bool:, l'argument n est un int et la valeur renvoyée est un bool. Nous verrons ce que signifient ces types plus tard. Toutefois, les indications de type sont totalement facultatives. Vous verrez de plus en plus de code adopter des indications de type, car si vous les utilisez, certains éditeurs comme cider-v et VS.code peuvent exécuter des vérifications pour s'assurer que vos fonctions sont appelées avec les bons types d'arguments. Il peut même suggérer et valider des arguments lorsque vous modifiez du code. Ce tutoriel ne couvre pas les annotations de type, mais nous voulons nous assurer que vous en êtes conscient si vous en entendez parler ou si vous en voyez dans la nature.

Noms de variables

Étant donné que les variables Python n'ont aucun type spécifié dans le code source, il est très utile de leur donner des noms explicites pour vous rappeler ce qui se passe. Utilisez donc "name" s'il s'agit d'un nom unique, "names" s'il s'agit d'une liste de noms et "tuples" s'il s'agit d'une liste de tuples. De nombreuses erreurs Python de base résultent de l'oubli du type de valeur contenu dans chaque variable. Utilisez donc vos noms de variables (tout ce que vous avez vraiment) pour vous aider à y voir clair.

En ce qui concerne la dénomination proprement dite, certaines langues préfèrent les parties_soulignées pour les noms de variables composés de "plusieurs mots", mais d'autres langues préfèrent la casseCamel. En général, Python préfère la méthode avec underscore, mais recommande aux développeurs d'utiliser la casse camel si l'intégration se fait dans un code Python existant qui utilise déjà ce style. La lisibilité compte. Pour en savoir plus, consultez la section sur les conventions d'attribution de noms dans PEP 8.

Comme vous pouvez l 'imaginer, les mots clés tels que "if" et "while" ne peuvent pas être utilisés comme noms de variables. Vous obtiendrez une erreur de syntaxe si vous le faites. Toutefois, veillez à ne pas utiliser de noms de variables intégrés. Par exemple, même si "str", "list" et "print" peuvent sembler être de bons noms, vous écraseriez ces variables système. Les fonctions intégrées ne sont pas des mots clés et peuvent donc être utilisées par inadvertance par les nouveaux développeurs Python.

En savoir plus sur les modules et leurs espaces de noms

Supposons que vous ayez un module "binky.py" qui contient une "def foo()". Le nom complet de cette fonction foo est "binky.foo". De cette façon, différents modules Python peuvent nommer leurs fonctions et variables comme ils le souhaitent, et les noms de variables ne seront pas en conflit (module1.foo est différent de module2.foo). Dans le vocabulaire Python, nous dirions que binky, module1 et module2 ont chacun leur propre "espace de noms ", qui, comme vous pouvez l'imaginer, sont des liaisons entre les noms de variables et les objets.

Par exemple, nous avons le module "sys" standard qui contient des utilitaires système standards, comme la liste argv et la fonction exit(). Avec l'instruction "import sys", vous pouvez ensuite accéder aux définitions du module sys et les rendre disponibles par leur nom complet, par exemple sys.exit(). (Oui, "sys" a aussi un espace de noms !)

  import sys

  # Now can refer to sys.xxx facilities
  sys.exit(0)

Il existe un autre formulaire d'importation qui ressemble à ceci : "from sys import argv, exit". Cela rend argv et exit() disponibles sous leur nom court. Toutefois, nous recommandons la forme d'origine avec les noms complets, car il est beaucoup plus facile de déterminer d'où provient une fonction ou un attribut.

De nombreux modules et packages sont fournis avec une installation standard de l'interpréteur Python. Vous n'avez donc rien à faire de plus pour les utiliser. C'est ce que l'on appelle collectivement la "bibliothèque standard Python". Voici quelques modules/packages couramment utilisés :

sys : accès à exit(), argv, stdin, stdout, etc.
re : expressions régulières
os : interface du système d'exploitation, système de fichiers

Vous trouverez la documentation de tous les modules et packages de la bibliothèque standard sur http://docs.python.org/library.

Aide en ligne, `help()` et `dir()`

Il existe différentes façons d'obtenir de l'aide pour Python.

Effectuez une recherche Google en commençant par le mot "python", par exemple "liste python" ou "chaîne python en minuscules". La première réponse est souvent la bonne. Cette technique semble mieux fonctionner pour Python que pour d'autres langages.
Le site officiel de la documentation Python, docs.python.org, propose une documentation de haute qualité. Néanmoins, je trouve souvent qu'une recherche Google de quelques mots est plus rapide.
Il existe également une liste de diffusion officielle Tutor spécialement conçue pour les débutants en Python et/ou en programmation.
Vous trouverez de nombreuses questions (et réponses) sur StackOverflow et Quora.
Utilisez les fonctions help() et dir() (voir ci-dessous).

Dans l'interpréteur Python, la fonction help() affiche les chaînes de documentation pour différents modules, fonctions et méthodes. Ces chaînes de documentation sont semblables à javadoc en Java. La fonction dir() vous indique les attributs d'un objet. Voici quelques façons d'appeler help() et dir() depuis l'interpréteur :

help(len) : chaîne d'aide pour la fonction len() intégrée. Notez qu'il s'agit de "len" et non de "len()", qui est un appel à la fonction, ce que nous ne voulons pas.
help(sys) : chaîne d'aide pour le module sys (vous devez d'abord effectuer une import sys)
dir(sys) — dir() est semblable à help(), mais fournit simplement une liste rapide de ses symboles ou "attributs" définis.
help(sys.exit) : chaîne d'aide pour la fonction exit() dans le module sys
help('xyz'.split) : chaîne d'aide pour la méthode split() pour les objets de chaîne. Vous pouvez appeler help() avec cet objet lui-même ou un exemple de cet objet, ainsi que son attribut. Par exemple, appeler help('xyz'.split) équivaut à appeler help(str.split).
help(list) : chaîne d'aide pour les objets list
dir(list) : affiche les attributs de l'objet list, y compris ses méthodes.
help(list.append) : chaîne d'aide pour la méthode append() pour les objets list

Introduction à Python Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.