Introduction à Python

Préface

Bienvenue dans le didacticiel en ligne Python de Google. Il est basé sur le cours d'introduction à Python proposé en interne. Comme indiqué sur la page de configuration, ce support concerne Python 3.

Si vous cherchez un cours MOOC associé, essayez ceux d'Udacity et de Coursera (introduction à la programmation [débutant] ou introduction à Python). Enfin, si vous souhaitez apprendre en ligne à votre rythme, sans regarder de vidéos, essayez les ressources indiquées à la fin de cet article. Chaque contenu d'apprentissage de fonctionnalité et un interpréteur interactif Python avec lequel vous pouvez vous entraîner. Quel est cet "interpréteur" que nous parlons ? Nous le découvrirons dans la section suivante.

Présentation du langage

Python est un langage dynamique interprété (compilé en bytecode). Le code source ne comporte pas de déclarations de type pour les variables, les paramètres, les fonctions ou les méthodes. Cela rend le code court et flexible, et 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 lors de son exécution.

Un excellent moyen de comprendre le fonctionnement du code Python est d'exécuter l'interpréteur Python et de saisir du code directement dans celui-ci. Si vous avez une question du type : "Que se passe-t-il si j'ajoute un élément int à un list ?". Il suffit de le saisir dans l'interpréteur Python. C'est un moyen rapide, et probablement le meilleur moyen de voir ce qui se passe. (Voir ci-dessous pour voir 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 affichées par Python après avoir saisi "python" et avant l'invite >>> vous indiquent la version de python que vous utilisez et où elle a été créée. Tant que la première chose affichée est "Python 3.", ces exemples devraient vous convenir.

Comme vous pouvez le voir ci-dessus, il est facile de tester des variables et des 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. Comme C++ et Java, Python est sensible à la casse. "a" et "A" sont donc des variables différentes. La fin d'une ligne marque la fin d'une instruction. Par conséquent, contrairement à C++ et Java, Python ne nécessite pas de point-virgule à la fin de chaque instruction. Les commentaires commencent par le caractère "#" 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 consiste à 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 officielle de la documentation sur les différentes options dont vous disposez 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 strictement par un retrait plutôt que par des accolades. Nous reviendrons sur ce point 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 : elles 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 dans python3 hello.py Bob) 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 récurrent if __name__ ==... 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 façon standard : sys.argv[0] correspond au programme lui-même, sys.argv[1] correspond au 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 de l'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 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 ceci:

# 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 selon le même niveau de retrait. 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 aussi, car il s'agit de l'opérateur "repeat" de Python, ce qui signifie que '-' * 10 donne '----------', un moyen pratique de créer une "ligne" à l'écran. Dans le commentaire du code, nous indiquons que * fonctionne plus rapidement que +, car * calcule la taille de l'objet obtenu une seule fois, tandis qu'avec +, ce calcul est effectué chaque fois que + est appelé. Les opérateurs + et * sont appelés des opérateurs « 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 en retrait. La première ligne d'une fonction peut être une chaîne de documentation ("docstring") qui décrit son rôle. Il peut s'agir d'une seule ligne ou d'une description sur plusieurs lignes, comme dans l'exemple ci-dessus. (oui, ce sont des "guillemets triples", une fonctionnalité propre à Python !) Les variables définies dans la fonction sont locales. Le "résultat" de la fonction ci-dessus est donc 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, en affichant 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 fonction "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 le retrait d'espaces blancs d'un morceau de code affecte sa signification. Un bloc d'instructions logique comme celles qui composent une fonction doit tous avoir le même retrait, défini à partir de l'indentation de leur fonction parente ou "if" ou autre. Si l'une des lignes d'un groupe présente un retrait différent, cela est signalé comme une erreur de syntaxe.

L'utilisation des espaces blancs par Python semble un peu étrange au début, mais c'est logique et j'ai trouvé que je m'y habituerais très rapidement. Évitez d'utiliser les TAB car ils compliquent grandement le schéma de retrait (sans oublier que les TAB peuvent avoir des significations différentes selon les plateformes). Configurez votre éditeur de sorte qu'il insère des espaces au lieu de TAB pour le code Python.

Les débutants se posent souvent la question suivante : "Combien d'espaces dois-je mettre en retrait ?" Conformément au guide de style officiel de Python (PEP 8), vous devez créer un retrait avec quatre espaces. (Bon à savoir: conformément aux consignes de style internes de Google, les retraits doivent être 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 et différencie presque tous les contrôles de type, de nom, etc. sur chaque ligne jusqu'à l'exécution de cette ligne. 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 fonctionrepeat() est accidentellement saisie sous la forme repeeeet(). Ce qui est amusant dans Python, c'est que ce code se compile et fonctionne 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 repeeeet() qu'elle remarquera qu'il n'existe aucune fonction et génère une erreur. Il y a aussi une deuxième erreur dans cet extrait. de nom n'a pas reçu de valeur avant la 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 détaillé, comme Java, présentent un avantage. Ils peuvent détecter de telles erreurs au moment de la compilation (mais vous devez bien sûr conserver toutes ces informations de type... c'est un compromis).

Python 3 introduit les indications 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 int et la valeur renvoyée est bool. Nous verrons plus tard la signification de ces types. Toutefois, les indications de type sont totalement facultatives. Vous constaterez que le code adopte de plus en plus d'indications de type, car si vous les utilisez, certains éditeurs tels que cider-v et VS.code peuvent effectuer des vérifications pour vérifier que vos fonctions sont appelées avec les types d'argument appropriés. Ils peuvent même suggérer et valider des arguments lorsque vous modifiez du code. Ce tutoriel ne traite pas des indications de type, mais nous tenons à nous assurer que vous les connaissez si vous les connaissez ou si vous les voyez.

Noms des variables

Étant donné que les variables Python n'ont aucun type écrit dans le code source, il est particulièrement utile d'attribuer des noms pertinents à vos variables 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 dans chaque variable. Utilisez donc les noms de vos variables (tout ce que vous avez réellement) pour que tout soit correct.

En ce qui concerne le nom réel, certaines langues préfèrent underscored_parts pour les noms de variables composés de « plusieurs mots », mais d'autres langues préfèrent camelCase. En général, Python préfère la méthode underscore, mais aide les développeurs à se reporter à camelCasing s'il est intégré dans un code Python existant qui utilise déjà ce style. La lisibilité compte. Pour en savoir plus, consultez la section sur les conventions de dénomination dans PEP 8.

Comme vous pouvez le deviner, vous ne pouvez pas utiliser de mots clés tels que "if" et "while" en tant que noms de variables. Dans ce cas, vous obtiendrez une erreur de syntaxe. Toutefois, veillez à ne pas utiliser de variables intégrées comme noms de variables. Par exemple, si "str", "liste" et "imprimer" semblent être de bons noms, vous remplacez ces variables système. Les éléments intégrés ne sont pas des mots clés. Ils peuvent donc ê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 ayez un module "binky.py" qui contient une fonction "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 à leur guise, sans entrer en conflit les noms des variables, car "module1.foo" est différent de "module2.foo". Dans le vocabulaire Python, 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, nous avons le module "sys" standard qui contient des installations 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" 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 ressemble à ceci: "from sys import argv, exit". argv et exit() sont ainsi disponibles grâce à leurs noms courts. Toutefois, nous recommandons le format d'origine avec des noms complets, car il est beaucoup plus facile de déterminer l'origine d'une fonction ou d'un attribut.

De nombreux modules et packages sont fournis avec une installation standard de l'interpréteur Python. Vous n'avez donc rien à faire pour les utiliser. C'est ce que l'on appelle collectivement la "bibliothèque standard Python". Voici les modules/packages 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 différentes manières d'obtenir de l'aide concernant Python.

  • Effectuez une recherche sur Google en commençant par le mot "python", comme "python list" ou "python string minuscule". La réponse est souvent le premier appel. Pour une raison quelconque, cette technique semble fonctionner mieux pour Python que pour d'autres langages.
  • Le site officiel de documentation Python, docs.python.org, propose des documents de haute qualité. Néanmoins, je trouve qu'une recherche Google comportant quelques mots est souvent plus rapide.
  • Il existe également une liste de diffusion officielle de Tutor, spécialement conçue pour les nouveaux utilisateurs de Python et/ou de la programmation.
  • De nombreuses questions (et leurs réponses) sont disponibles 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 document sont similaires à Javadoc 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 de 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 souhaitons pas).
  • help(sys) : chaîne d'aide pour le module sys (doit d'abord effectuer une opération import sys)
  • dir(sys) : dir() est semblable à help(), mais donne 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 de la méthode split() pour les objets de chaîne. Vous pouvez appeler help() avec cet objet lui-même, ou avec 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 d'objet list, y compris ses méthodes.
  • help(list.append) : chaîne d'aide de la méthode append() pour les objets list