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 est basé sur le cours d'introduction à Python proposé en interne. Comme indiqué sur la page de configuration, ce document 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 souhaitez suivre une formation en ligne à votre rythme sans regarder de vidéos, essayez celles listées à la fin de cet article. Chacune d'elles propose du contenu pédagogique ainsi qu'un interpréteur interactif Python avec lequel vous pouvez vous entraîner. De quoi s'agit-il ? Vous le découvrirez dans la section suivante.

Présentation du langage

Python est un langage dynamique, interprété (compilé en bytecode). Aucune déclaration de type de variables, de paramètres, de fonctions ou de méthodes n'est présente dans le code source. Le code est ainsi court et flexible, et vous perdez la vérification de 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 moment de son exécution.

Un excellent moyen de voir comment fonctionne le code Python est d'exécuter l'interpréteur Python et de saisir du code directement dedans. Si vous vous posez des questions comme "Que se passe-t-il si j'ajoute un int à un list ?", il vous suffit de les saisir dans l'interpréteur Python pour obtenir une réponse rapide et probablement la meilleure. (Voir ci-dessous pour découvrir ce qui se passe vraiment !)

$ 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 imprime après que vous avez saisi python et avant l'invite >>> vous indiquent la version de Python que vous utilisez et l'endroit où elle a été compilée. Tant que la première chose imprimée est "Python 3", ces exemples devraient fonctionner.

Comme vous pouvez le voir ci-dessus, il est facile de tester les variables et les opérateurs. De plus, l'interpréteur génère une erreur d'exécution si le code tente de lire une variable à laquelle aucune valeur n'a été attribuée. Tout 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 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 sources 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 à l'aide d'indentations au lieu 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 se présente comme suit :

$ 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 unique. Ces instructions s'exécutent de haut en bas la première fois que le module est importé quelque part, et configurent ses variables et fonctions. Un module Python peut être exécuté directement (comme python3 hello.py Bob ci-dessus) ou 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__". Par conséquent, il est courant que le code if __name__ ==... standard illustré ci-dessus appelle une fonction main() lorsque le module est exécuté directement, mais pas lorsqu'il 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, sys.argv[0] étant le programme lui-même, sys.argv[1] le premier argument, etc. Si vous connaissez argc ou le nombre d'arguments, vous pouvez simplement demander cette valeur à Python avec len(sys.argv), comme nous l'avons fait dans le code d'interpréteur interactif ci-dessus pour demander 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 tupels (une autre structure de données semblable à un 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 constituent la fonction ou l'instruction if sont regroupées en fonction de leur niveau d'indentation. Nous avons également présenté deux façons différentes de répéter des chaînes, à l'aide de l'opérateur +, qui est plus convivial, mais * fonctionne également, car il s'agit de l'opérateur "repeat" de Python, ce qui signifie que '-' * 10 donne '----------', une façon pratique de créer une "ligne" à l'écran. Dans le commentaire de code, nous avons indiqué que * fonctionne plus rapidement que +, car * calcule la taille de l'objet résultant une seule fois, tandis que avec +, ce calcul est effectué chaque fois que + est appelé. + et * sont tous deux appelés opérateurs "surchargés", car ils ont une signification différente pour les nombres et pour les chaînes (et 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 son rôle. La docstring peut être une ligne unique ou une description 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 du code qui appelle la fonction repeat() ci-dessus et qui affiche ce qu'elle renvoie :

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

Au moment de l'exécution, les fonctions doivent être définies par l'exécution d'une instruction "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 caractéristique inhabituelle de Python est que l'indentation des espaces blancs d'un code affecte sa signification. Un bloc logique d'instructions telles que celles qui constituent une fonction doit toutes avoir la même indentation, définie à partir de l'indentation de leur fonction parente ou de leur "si", etc. 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 dans Python peut sembler un peu étrange au début, mais elle est logique et je me suis très vite habitué. Évitez d'utiliser des tabulations, car elles compliquent grandement le schéma d'indentation (sans compter que les tabulations peuvent avoir des significations différentes sur différentes plates-formes). Configurez votre éditeur pour qu'il insère des espaces au lieu de tabulations pour le code Python.

Les débutants se demandent souvent : "Combien d'espaces dois-je ajouter à l'indentation ?" Selon le guide de style officiel Python (PEP 8), vous devez utiliser quatre espaces en retrait. Bon à savoir: les consignes de style internes de Google imposent un retrait 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, reportant 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, où la fonction repeat() est accidentellement saisie comme repeeeet(). L'aspect amusant de Python 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 essaie réellement d'exécuter repeeeet() qu'elle remarque l'absence de cette fonction et génère une erreur. Il existe également une deuxième erreur dans cet extrait. aucune valeur n'a été attribuée au nom avant qu'il ne soit comparé à "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 des fautes de frappe simples ou des variables non initialisées comme celles-ci. C'est un domaine dans lequel les langages disposant d'un système de types plus verbeux, comme Java, ont un avantage : ils peuvent détecter ces erreurs au moment de la compilation (mais bien sûr, vous devez gérer toutes ces informations de type : c'est un compromis).

Python 3 a introduit les indications de type. Les indices 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 plus tard ce que ces types signifient. Les indications de type sont toutefois totalement facultatives. Vous verrez de plus en plus de code adopter des annotations de type, car si vous les utilisez, certains éditeurs tels que cider-v et VS.code peuvent exécuter des vérifications pour vérifier que vos fonctions sont appelées avec les types d'arguments appropriés. Ils peuvent même suggérer et valider des arguments lorsque vous modifiez du code. Ce tutoriel ne couvrira pas les indications de type, mais nous voulons nous assurer que vous en avez connaissance si vous en entendez parler ou les voyez dans la nature.

Noms de variables

Étant donné que le type des variables Python n'est pas indiqué dans le code source, il est très utile de leur donner des noms significatifs pour vous rappeler ce qui se passe. Utilisez donc "name" si vous ne spécifiez qu'un seul nom, "names" si vous indiquez une liste de noms et "tuples" si vous indiquez une liste de tupels. De nombreuses erreurs Python de base résultent de l'oubli du type de valeur dans chaque variable. Utilisez donc les noms de vos variables (tout ce que vous avez) pour vous aider à garder les choses en ordre.

En ce qui concerne la dénomination, certains langages préfèrent les underscores_parts pour les noms de variables composés de plusieurs mots, tandis que d'autres préfèrent le camelCasing. En général, Python préfère la méthode des traits de soulignement, mais recommande aux développeurs d'utiliser la casse camel si l'intégration s'effectue dans du code Python existant qui utilise déjà ce style. La lisibilité est importante. Pour en savoir plus, consultez la section sur les conventions d'attribution de noms dans PEP 8.

Comme vous pouvez le deviner, 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 mots clés intégrés comme noms de variables. Par exemple, si "str", "list" et "print" peuvent sembler être de bons noms, vous auriez à remplacer ces variables système. Les éléments intégrés ne sont pas des mots clés et sont donc susceptibles d'être utilisés par inadvertance par les nouveaux développeurs Python.

En savoir plus sur les modules et leurs espaces de noms

Supposons que vous disposiez d'un module "binky.py" contenant une "def foo()". Le nom complet de cette fonction foo est "binky.foo". De cette manière, les différents modules Python peuvent nommer leurs fonctions et variables comme ils le souhaitent, et les noms de variables ne se chevaucheront pas : module1.foo est différent de module2.foo. Dans le vocabulaire Python, nous disons que binky, module1 et module2 ont chacun leurs propres "espaces de noms", qui, comme vous pouvez le deviner, sont des liaisons nom-objet de variable.

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

  import sys

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

Il existe un autre formulaire d'importation qui se présente comme suit : "from sys import argv, exit". argv et exit() sont ainsi disponibles sous leurs noms courts. Toutefois, nous vous recommandons d'utiliser la forme d'origine avec les noms complets, car il est beaucoup plus facile de déterminer d'où vient 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 d'autre à faire pour les utiliser. On les désigne collectivement par la "bibliothèque standard Python". Voici quelques modules/paquets couramment utilisés :

sys : accès àexit(), argv, stdin, stdout, ...
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 plusieurs 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 première réponse. Pour une raison quelconque, cette technique semble fonctionner mieux avec Python qu'avec d'autres langages.
Le site de documentation officiel de Python (docs.python.org) propose des documents de haute qualité. Néanmoins, je trouve souvent qu'une recherche Google de quelques mots est souvent plus rapide.
Il existe également une liste de diffusion officielle pour les tuteurs, 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() extrait des chaînes de documentation pour divers modules, fonctions et méthodes. Ces chaînes de documentation sont semblables aux javadocs de Java. La fonction dir() vous indique quels sont les attributs d'un objet. Voici quelques façons d'appeler help() et dir() à partir de 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 de la fonction, ce que nous ne souhaitons pas.
help(sys) : chaîne d'aide pour le module sys (vous devez d'abord effectuer une commande import sys)
dir(sys) : dir() est semblable à help(), mais ne fournit qu'une liste rapide de ses symboles définis, ou "attributs".
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() des objets de chaîne. Vous pouvez appeler help() avec l'objet lui-même ou un exemple de cet objet et son attribut. Par exemple, appeler help('xyz'.split) revient à 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() des objets list