DY

TP00: Découverte du Python

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

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.

Voici un autre exemple:

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

Hello World !

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:

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 (instructions et structures de base)

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

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

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 le cast explicite:

a = '4'
print(type(a))
int_a = int(a)
type(int_a)
Listes, tuples et dictionnaires

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)

Les listes Python viennent 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)])

Voici un exemple plus parlant:

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 (on dit « immutable »).

Les tuples sont écrits entre parenthèses.

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.

Voici quelques exemples :

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})
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:
    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 peut parfois être déroutante pour les débutants. En effet, elle ne fonctionne pas comme un compteur, comme c'est le cas dans beaucoup de langages, mais comme une implémentation du design pattern itérateur. Donc, grosso modo, comme un « foreach » :

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

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

Assez classique

compteur = 10

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

La déclaration d'une fonction Python peut se faire à peu près partout dans le code d'un programme : au début, à l'intérieur d'une autre fonction, dans une classe (on parle alors de méthode bien que la syntaxe soit identique). On utilise pour cela le mot clé def :

def say_hello(name):
    print("Hello %s" % (name))
Opérateurs

Opérateurs

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

En particulier :

L'addition (+)
La soustraction (-)
La multiplication (*)
La division (/)
Le modulo (%)
La puissance (**)

Idem pour la comparaison :

Égalité (==)
Non égalité (!=)
Inférieur, inférieur ou égal (<, <=)
Supérieur, supérieur ou égal (>, >=)

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

and
or
not

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