🐍 Syntaxe Python#

A propos

Cette page a pour but d’apprendre à écrire un tout premier programme Python, très simple, et à utiliser l’interpréteur Python.

Sans écrire un programme#

Avant même concevoir notre programme nous allons utiliser l’interpréteur Python pour exécuter quelques commandes.

  1. Lancez l’interpréteur python dans un terminal via $ python

  2. Tapez la commande suivantes: >>> a=2

  3. Puis >>> a+3

  4. Vous devriez obtenir le résultant suivant: 5

Note

On peut utiliser l’interpréteur Python pour exécuter tout un tas de commandes, à des fins de test ou pour se familiariser avec le langage, sans même avoir à créer de fichiers de code.

Un exemple plus concret#
name = input("What's your name ?")
if name.lower() == 'ben':
... print('Hello Ben Kenobi!')
else:
... print('Bonjour %(who)s !' % {'who': name.title()})

Hello Python !#

Nous allons désormais écrire notre premier programme Python dans un fichier. Les programmes Python s’écrivent dans des fichier .py.

Quelque part dans un dossier perdu de votre machine, créez le fichier hello_world.py avec le contenu suivant:

Hello World classique en Python#
print("Hello World")

Puis dans votre terminal, rendez-vous dans le répertoire où est stocké votre fichier hello_world.py puis tapez la commande suivante: $ python hello_world.py, vous devriez obtenir le résultat suivant:

Hello World

Kit de survie#

Le but de ce paragraphe n’est pas d’être exhaustif mais de fournir quelques informations sur les instructions et structures de base en python.

Commentaires#

Les commentaires permettent de rendre le code plus compréhensible.

En Python, les commentaires sont précédés du caractère #.

Remarque

Les documentations des modules, classes et fonctions sont réalisés à l’aide de commentaires spéciaux, les « doc strings », délimités par des double cotes (1 ou 3 : """) et accessibles à l’exécution contrairement aux commentaires standards.

def say_hello():
    """
    This function only say hello
    Nothing less, nothing more
    But this is a cute doc string.
    """
    print("Hello") # What a complex line of code

Types de données prédéfinis#

Note

Voici les types de données de base les plus importants en python:

  • Les nombres entiers (int et long) , réels (float) et complexes (complex)

  • Les string (str) et unicode (unicode )

  • Les booléens (bool )

Pour connaître le type d’une variable, il existe la fonction type() :

name = 'ben'
print(type(name))

Pour caster une variable il suffit d’utiliser un cast explicite:

a = '4'
print(type(a))
int_a = int(a)
type(int_a)

Listes, tuples et dictionnaires#

Remarque

Les listes, tuples et dictionnaires sont des structures de données qui peuvent être vus comme des conteneurs de plusieurs éléments. Ils ressemblent à des tableaux, dans lesquels on peut stocker n’importe quel type d’objet.

Listes#

Une liste est représentée par une suite d’éléments délimitée par des crochets et séparés par des virgules. Une fois créée, on peut modifier une liste, en lui ajoutant, modifiant ou supprimant des éléments. Quelques exemples :

ints = [0, 1, 1, 2, 2, 3, 5, 8, 13]
print(ints)
print(type(ints))
print(ints[6])

ints[6] = 'Hello'
print(ints)
ints.pop(4)
print(ints)

ints.append(42)
print(ints)
other = ['etc.']
print(ints + other)
print(ints[2:])
len(ints)

Important

Python vient avec un outil extrêmement puissant: la compréhension de liste (list comprehension). Il s’agit de construire une liste à l’aide d’une boucle for potentiellement avec une condition:

print([x ** 2 for x in range(4)])

chars = {
   'luke': {'job': 'jedi', 'name': 'Luke Skywalker', },
   'han': {'job': 'smuggler', 'name': 'Han Solo', },
   'ben': {'job': 'jedi', 'name': 'Ben Kenobi', },
}

print([value['name'] for key, value in chars.items() if value['job'] == 'jedi'])

Tuples#

Les tuples ressemblent très fort aux listes, sauf qu’ils ne sont pas modifiables (ils sont « immutable »).

jobs = ('jedi', 'smuggler', 'farmer', )

print(jobs)
print(jobs[1])

print('jedi' in jobs)
jobs.pop(1)

Dictionnaires#

Les dictionnaires Python sont l’équivalent de ce que l’on appelle parfois « tableaux associatifs ». Ils contiennent des éléments indexés par des clés. Les gens qui connaissent PHP ou javascript par exemple, devraient se trouver familiers avec ces constructions.

chars = {
    'luke': {'job': 'jedi', 'name': 'Luke Skywalker', },
    'han': {'job': 'smuggler', 'name': 'Han Solo', },
    'ben': {'job': 'jedi', 'name': 'Ben Kenobi', },
}

print(chars['luke'])
print(chars['luke']['name'])
La constuction de dictionnaire par compréhension est également possible#
chars = ['BEN', 'Luke', 'han']

print({c.lower(): len(c) for c in chars})

Les dictionnaires en Python sont aussi des itérables. Nous pouvons accéder à l’index d’un dictionnaire via la notation par crochet mais également via la méthode .get.

Attention

Les clés d’un dictionnaire sont case-sensitive. Pour rappel, un dictionnaire peut contenir également des (sous-)dictionnaires.

data = {'Hello': 'World'}
data['Hello'] # Return value stored at 'Hello' key, if key doesn't exist raise a KeyError
'Hello' in data # Check if key 'Hello' is in data dictionnary
data.get('hello', 'default') # Return value at key 'hello', if key doesn't exist return given default value which is None by default
data = {'greetings': {'Hello': 'World'}} # Create a new dict
data['greetings']['Hello'] # Get value from 'Hello' key which is inside dict stored at 'greetings' key.

Structures conditionnelles#

Comme tout langage de programmation, Python fournit les structures conditionnelles nécessaires à toutes les applications (if/else/elif) :

age = int(input('What\'s your age ?'))

if age < 16:
    print("Go to school!")
elif age >= 60: #TODO: change this to 64
    print("Retirement times!")
else:
    print("Go to works (or school ?)!")

Structures itératives#

Les structures itératives sont plus généralement connues sous le nom de « boucles ». On retrouve notamment en Python les classiques boucles while et for.

Boucle for#

La boucle for de Python fonctionne comme un itérateur sur un élément itérable (liste, tuple, dictionnaire, etc.).

for name in ['ben', 'han', 'luke']:
    print(name)

for i in range(10):
    print(i)

Boucle while#

compteur = 10

while compteur > 0:
    print ("T- {nombre}".format(nombre=compteur))
    compteur = compteur  - 1

Indication

Même les chaînes de caractères sont des objets itérables en effet elles contiennent une séquence de caractères.

ord('s') # get ascii value of given char
chr(126) # convert given ascii value to char (a string of length 1) here 126 stand for ~
';'.join(['C', 'e', 's', 'a', 'r', ]) # return a string equal to C;e;s;a;r

Fonctions Python#

Une fonction est définie comme un bloc de code structuré qui:

  • prend un ensemble d’arguments en entrée

  • effectue une action spécifique via un ensemble d’instructions

  • retourne un résultat en sortie

../../_images/function.png

La déclaration d’une fonction Python peut se faire à peu près partout dans le code d’un programme :

  • au début de notre script,

  • à l’intérieur d’une autre fonction,

  • dans une classe (on parle alors de méthode bien que la syntaxe soit identique).

Le mot clé def permet de définir une fonction.

def say_hello(name: str):
   print("Hello %s" % (name))
   return f"Hello {name}"

L’instruction def spécifie le nom de la fonction (say_hello), les arguments attendus et l’ensemble d’opérations exécutés par celle-ci.

L’instruction return spécifie que la fonction retourne un résultat.

Important

Notez que les instructions sont indentées d’un niveau par rapport à la déclaration.

Les fonctions Python admettent deux modes de passage des arguments:

  • par position, les arguments sont passés dans l’ordre de définition de la fonction

  • par mot-clé, les arguments sont passés par leur nom respectif

Passage par position

Passage par mot-clé

 
def greetings(word: str, name: str) -> str:
   return f"{word} {name}"

greetings("Hello", "Sam")

def greetings(word: str, name: str) -> str:
   return f"{word} {name}"

greetings(name="Sam", word="Hello")

Arguments obligatoires et optionnels

Il est possible de faire cohabiter des arguments que doit absolument spécifier l’utilisateur avec des arguments optionnels qui ont une valeur par défaut.

def greetings(name: str, word: str = 'Hello') -> str:
      return f"{word} {name}"

greeings(name="Sam")
greetings(name="Sam", word="Holà")

Nombre d’arguments variable

Une fonction peut avoir besoin de prendre un nombre variable d’arguments.

Le paramètre args permet de créer une fonction qui accepte un nombre indéfini d’arguments.

def foo(*args):
   print(args)

foo()
foo(1)
foo(1, 'Hello', True)

Le paramètre args est un tuple.

Avertissement

Il est important de noter que le nom args n’est qu’une convention, on pourrait utiliser n’importe quel nom et cela fonctionnerait de la même façon. Le seul requis est la présence de l’opérateur splat * devant le paramètre.

Le paramètre kwargs permet de créer une fonction qui accepte un nombre indéfini d’arguments nommés.

def foo(**kwargs):
   print(kwargs)

foo()
foo(value=1)
foo(value=1, word='Hello', is_love=True)

Le paramètre kwargs est un dict.

Avertissement

Il est important de noter que le nom kwargs n’est qu’une convention, on pourrait utiliser n’importe quel nom et cela fonctionnerait de la même façon. Le seul requis est la présence du double opérateur splat ** devant le paramètre.

Important

L’avantage est de nommer les paramètres comme bon nous semble.

Opérateurs

Les opérateurs arithmétiques fonctionnent de manière analogue à ce que l’on peut voir dans la plupart des langages.

L’addition

+

La soustraction

-

La multiplication

*

La division

/

Le modulo

%

La puissance

**

Idem pour la comparaison :

Égalité

==

Inégalité

!=

Inférieur, inférieur ou égal

<, <=

Supérieur, supérieur ou égal

>, >=

Enfin, Python fournit des opérateurs de conjonction d’expressions :

Et

and

Ou

or

Non

not

Indication

Bien entendu, les opérateurs peuvent être utilisés conjointement.

Promenade avec Python#

Indication

Réaliser un simple programme de type Hello World pour vérifier le fonctionnement de votre environnement de développement.

Calcul de masse au sein du système solaire

Écrire un programme permettant de calculer une masse à différents endroits du système solaire.

Pour ce faire nous allons stocker une masse arbitraire de 42 dans une variable. Puis dans un dictionnaire nous allons stocker les valeurs respectives suivantes de G pour chaque astre.

Sur mercure elle est de 0.378, sur la lune de 0.166 et sur Jupiter de 2.364. La sortie de votre programme doit produire un affichage semblable :

The mass of the object on Earth is 42.0.
The mass of the object on Mercury is 15.876.
The mass of the object on the Moon is 6.972.
The mass of the object on Jupiter is 99.288.

Test de performance de votre machine

Nous allons écrire un programme de « benchmarking » très simple. Pour ce faire nous allons compter le nombre de tours que fait une boucle infinie sur un intervalle de temps donnée à savoir une minute.

Quelques pistes:

import time
time.time() # current timestamp (in seconds)

La compagnie des treizes nains

dwarfs = ('Thorin', 'Balin', 'Dwalin', 'Fili', 'Kili',
         'Dori', 'Nori', 'Ori', 'Oin', 'Gloin', 'Bifur',
         'Bofur', 'Bombur', )

  • Afficher la taille du tuple

  • Afficher les élèments du tuple un à un

  • Afficher les élèments du tuple et la longueur de chacun

dwarfs = ['Thorin', 'Balin', 'Dwalin', 'Fili', 'Kili',
         'Dori', 'Nori', 'Ori', 'Oin', 'Gloin', 'Bifur',
         'Bofur', 'Bombur', ]

  • Rajouter Bilbo Baggins à cette joyeuse compagnie

  • Afficher les élèments de la liste un à un

  • Retirer Thorin, Fili et Kili de la liste

  • Créer une nouvelle liste par compréhension à partir de la liste de nains

Encodage des fichiers sources et UTF-8#

Avertissement

Attention il s’agissait de l’utilisation faites en Python 2, Python3 est nativement en UTF-8. Ceci est laissé à titre d’information.

Pour pouvoir utiliser des caractères « spéciaux » (accents notamment) dans vos programmes (même dans les commentaires), vous devez dire à Python, de manière explicite, que vous souhaitez utiliser l’encodage de caractères UTF-8.

Pour cela, ajoutez simplement, systématiquement en haut de tous vos fichiers, la ligne suivante :

# coding: utf8

Une fonction main ?#

La fonction main() n’existe pas en Python, comme on peut la trouver en C par exemple. Ce n’est pas un problème en soi et ça ne vous empêchera sûrement pas de dormir.

Il y a néanmoins un cas de figure où le fait de ne pas avoir ce genre de fonction peut être problématique : quand on inclut un module dans un autre, Python réalise un import de tout le contenu du module (logique !).

Le problème, c’est que si on y place des instructions à l’extérieur de toute fonction ou méthode, elles seront exécutées systématiquement, même lors de l’inclusion du module !

Indication

Fichier module.py#
def say_hello(name):
   return 'Hello %s !' % name


print(say_hello('Ben Kenobi'))
Fichier myprog.py#
import module

print(module.say_hello('Luke Skywalker'))

Avertissement

Si vous exécutez le programme myprog.py vous constaterez que la fonction say_hello est appellée deux fois, une fois dans notre programme principale et une autre fois au sein de notre module. Pour corriger ce problème:

Fichier module.py#
def say_hello(name):
   return 'Hello %s !' % name


if __name__ == '__main__':
   print say_hello('Ben Kenobi')

Formattage des strings#

Que ce soit en Python ou dans n’importe quel autres langage de programmation pour créer/formatter des chaînes de caractères on n’utilise pas d’opérateur de concaténation ! (C’est moche et illisible)

name = 'Mark Hamill'
movie = 'Star Wars'
date_begin = '1977'
date_end = 'today'

print ('{name} played in {movie} from {begin} à {end}.'
       .format(name=name, movie=movie,
               begin=date_begin, end=date_end))
print(f'{name} played in {movie} from {begin} à {end}.')

Quelques modules à connaître#

Python est un langage très complet, qui inclut en standard beaucoup de modules permettant de résoudre bon nombre des problèmes auxquels le programmeur doit faire face dans la vie quotidienne.

Parmi ces modules, quelques-uns sont incontournables :

  • re : Gestion des expressions régulières (recherche, remplacement, etc.)

  • datetime : Types de données date et time, et opérations associées (comparaison, génération, etc.)

  • os : Accès aux fonctions système (fichiers, listing de répertoires, etc.)

  • json : Encodage et décocage json/Python

Le module datetime permet de manipuler facilement les dates

import datetime
current_date = datetime.datetime.strptime('2019-09-21', '%Y-%m-%d') # convert given string to a datetime object based on given pattern
current_date.strftime('%Y-%d-%m') # return a string formatted datetime with given pattern

Python et l’aléatoire#

Pour programmer avec de l’aléatoire en Python on utilise le module random:

import random

random.random() # valeur entre 0 et 1, 1 exclus.
random.randint(0, 3) # entier entre 0 et 3 inclus.