Introduction à Python

Avant-propos

Bienvenue dans le tutoriel 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 document couvre 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 celles indiquées à la fin de ce post. Chacune des fonctionnalités est accompagnée d'un interprète interactif Python avec lequel vous pouvez vous entraîner. Qu'est-ce que cet "interprète" ? que nous mentionnons ? Vous le découvrirez dans la section suivante.

Présentation du langage

Python est un langage dynamique interprété (compilé en bytecode). Le code source ne contient pas de déclarations de type de variables, de paramètres, de fonctions ou de 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 pendant son exécution.

Une excellente façon de voir comment fonctionne le code Python consiste à exécuter l'interpréteur Python et à y saisir directement du code. Si vous avez une question telle que "Que se passe-t-il si j'ajoute un int à un list ?" Le simple fait de le saisir dans l'interpréteur Python est un moyen rapide, et probablement le meilleur, de voir ce qui se passe. (Voir ci-dessous 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 imprime après la saisie de "python" et avant la commande >>> vous indique la version de Python que vous utilisez et où elle a été créée. Tant que la première chose imprimée est "Python 3". Ces exemples devraient vous convenir.

Comme vous pouvez le voir ci-dessus, il est facile de tester les variables et les opérateurs. De plus, l'interprète lance, ou "lève", dans le jargon 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. 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 signe "#" et s'étendent jusqu'à la fin de la ligne.

Code source Python

Les fichiers sources Python utilisent l'extension 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 de documentation officielle sur 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 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 leur configuration unique. Ces instructions s'exécutent de haut en bas la première fois que le module est importé quelque part, ce qui configure ses variables et ses fonctions. Un module Python peut être exécuté directement (comme indiqué ci-dessus 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éfini sur "__main__". Par conséquent, il est courant que le code récurrent if __name__ ==... présenté 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 standards, sys.argv[0] étant le programme lui-même, sys.argv[1] comme 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 tuples (autre structure de données de type tableau) et le nombre de paires clé/valeur dans un dictionnaire.

Fonctions définies par l'utilisateur

En Python, les fonctions 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 selon le même niveau de retrait. Nous avons également présenté 2 façons différentes de répéter des chaînes, en utilisant l'opérateur +, qui est plus facile à utiliser, mais * fonctionne aussi parce qu'il s'agit de la fonction de répétition 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 +. Cela s'explique par le fait que * calcule la taille de l'objet obtenu une seule fois, tandis qu'avec +, ce calcul est effectué chaque fois que + est appelé. Les + et les * sont tous deux 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. La docstring peut être une ligne unique ou une description sur plusieurs lignes, comme dans l'exemple ci-dessus. (Oui, il s'agit bien de "guillemets triples", une fonctionnalité unique à Python.) Les variables définies dans la fonction sont locales pour celle-ci. Par conséquent, le "résultat" dans la fonction ci-dessus est distincte d'un "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 répét() ci-dessus et 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 fonctionnalité Python inhabituelle est que le retrait d'espace blanc d'un extrait de code affecte sa signification. Un bloc logique d'instructions telles que celles qui constituent une fonction doit avoir le même retrait, défini à partir du retrait de leur fonction parente ou "if". ou autre. Si l'une des lignes d'un groupe a un retrait différent, elle est signalée comme une erreur de syntaxe.

L'utilisation des espaces blancs dans Python est un peu étrange au début, mais c'est logique et j'ai trouvé que je m'y suis habitué très rapidement. Évitez d'utiliser les TAB, car ils compliquent considérablement le système d'indentation (sans parler des TAB pouvant avoir différentes significations selon les plateformes). Configurez votre éditeur pour qu'il insère des espaces au lieu des TAB pour le code Python.

Les débutants se demandent souvent combien d'espaces dois-je mettre en retrait ? Selon le guide de style Python officiel (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 la quasi-totalité des vérifications de type, de nom, etc. sur chaque ligne jusqu'à ce que cette ligne s'exécute. Supposons que la commande main() ci-dessus appelle "repeat()" de la manière suivante:

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

L'instruction if contient une erreur évidente, où la fonction répét() est accidentellement saisie 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 essaie réellement d'exécuter repeeeet() qu'elle remarque l'absence de cette fonction et génère une erreur. Il y a également une deuxième erreur dans cet extrait. Aucune valeur n'a été attribuée à ce nom avant d'être comparé à "Guido". Python génère une erreur "NameError" si vous essayez d'évaluer une variable non attribuée. Ces exemples montrent que lorsque vous exécutez un programme Python pour la première fois, les 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 dotés d'un système de types plus détaillé, comme Java, ont un avantage ... Ils peuvent détecter de telles erreurs au moment de la compilation (mais vous devez bien sûr gérer toutes ces informations de type ... C'est un compromis).

Python 3 a introduit les indicateurs de type. Les indications de type vous permettent d'indiquer le type de chaque argument d'une fonction, 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 de type int et la valeur renvoyée est bool. Nous verrons plus tard ce que ces types signifient. 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 tels que cider-v et VS.code peuvent exécuter des vérifications pour vérifier que vos fonctions sont appelées avec les bons types d'arguments. Ils peuvent même suggérer et valider des arguments lorsque vous modifiez le code. Ce tutoriel ne traite pas des indications de type, mais nous voulons nous assurer que vous en connaissez ou de les voir dans la nature.

Noms des variables

Étant donné que les variables Python ne comportent aucun type épelé dans le code source, il est très utile d'attribuer des noms explicites à vos variables pour vous rappeler ce qui se passe. Alors, utilisez « name » s'il s'agit d'un seul nom, et « noms » S'il s'agit d'une liste de noms et de "tuples" s'il s'agit d'une liste de tuples. De nombreuses erreurs Python de base sont le résultat de l'oubli du type de valeur dans chaque variable. Vous devez donc utiliser les noms des variables (il s'agit de tout ce que vous avez réellement) pour éviter toute confusion.

En ce qui concerne les noms réels, certaines langues préfèrent utiliser underscored_parts pour les noms de variables composés de « plusieurs mots », mais d'autres langues préfèrent le camelCasing. En général, Python préfère la méthode des traits de soulignement, mais oriente les développeurs vers le camelCasing en cas d'intégration 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, des mots clés comme "si" et "while" ne peuvent pas être utilisées comme noms de variables. Dans ce cas, vous obtiendrez une erreur de syntaxe. Toutefois, veillez à ne pas utiliser d'éléments intégrés comme noms de variables. Par exemple, si "str", "list" et "imprimer" 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 ayez un module "binky.py" qui contient une fonction "def foo()". Le nom complet de cette fonction foo est "binky.foo". Ainsi, les différents modules Python peuvent nommer leurs fonctions et variables comme ils le souhaitent, sans conflit (module1.foo est différent de module2.foo). Dans le vocabulaire Python, on dirait que binky, module1 et module2 ont chacun leur propre "espace de noms", qui, comme vous pouvez le deviner, sont des liaisons nom-objet de variable.

Par exemple, la valeur standard "sys" qui contient des fonctionnalités système standards, comme la liste argv et la fonctionexit(). Avec l'instruction « import sys », vous pouvez ensuite accéder aux définitions dans le module "sys" et les rendre disponibles sous 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 se présente comme suit : "from sys import argv, exit". Cela rend argv et exit() disponibles par leurs noms courts ; Cependant, nous recommandons le format d'origine avec les noms complets, car il est beaucoup plus facile de déterminer la provenance 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 de plus à faire pour les utiliser. Elles sont collectivement désignées sous le nom de "bibliothèque standard Python". Les modules/packages couramment utilisés incluent les suivants:

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

La documentation de tous les modules et packages de la bibliothèque standard est disponible à l'adresse http://docs.python.org/library.

Aide en ligne, help() et dir()

Il existe de nombreuses façons d'obtenir de l'aide pour Python.

• Effectuer 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 mieux fonctionner avec Python que pour d'autres langages.
• Le site de documentation officiel de Python docs.python.org : ce service 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 du tuteur 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 à la bibliothèque 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 pour la fonction len() intégrée noter que c'est "len" et non "len()", qui est un appel à la fonction, que nous ne voulons 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 fournit une liste rapide des symboles définis, ou "attributs".
• help(sys.exit) : chaîne d'aide de 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 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 d'objet list, y compris ses méthodes
• help(list.append) : chaîne d'aide de la méthode append() pour les objets list