C'est parti, tapez :

>>> print "Hello, world!"

Vous devriez avoir quelque chose comme cela à l'écran maintenant :

>>> print "Hello, world!"
Hello, world !

print "Hello, world!"

Permet donc d'écrire le texte Hello, world ! dans le terminal.

Nous allons créer un nouveau fichier hello.py :

print "Hello, world!"

Maintenant, créons un fichier maths.py avec le contenu suivant :

1+1
( 1 + 2 * 12 ) / 3
(1+3j)**2
sinus(3.14159)

Ré-essayons avec ce contenu maintenant dans le fichier maths2.py

print 1+1
print ( 1 + 2 * 12 ) / 3
print (1+3j)**2

Ce qui donne :

$ python Training_Python/1_first_script/maths2.py
2
8
(-8+6j)

YES, c'est bon cette fois !

• Beautiful is better than ugly.
• Explicit is better than implicit.
• Simple is better than complex.
• Complex is better than complicated.
• ...
• Readability counts.
• ...

Pour voir l’intégralité du PEP20, dans l'invite de commandes Python, tapez ceci :

>>> import this
Beautiful is better than ugly.
...

La lisibilité est importante.

Pour rendre du code plus lisible on peut utiliser des lignes d'explications qui ne seront pas exécutées par Python : les commentaires.

En Python, pour écrire un commentaire, il suffit d'écrire # puis votre commentaire, comme cela :

# compute 1+1 ?
print 1+1

print 1+1 # expected result : 2

Comme on l'a vu récemment, on peut manipuler des entiers :

>>> 3*5
15

On peut aussi manipuler des nombres réels :

>>> 3.14159*2
6.28318

Et oui, on l'a déjà vu aussi:

>>> (3+2j)**3
(-9+46j)

Contrairement à beaucoup de langages, il n'y a pas besoin, en Python, de dire que l'on veut manipuler des grands nombres, Python adapte tout seul :

>>> 10*9*8*7*6*5*4*3*2*1*100000000
362880000000000

Un texte est un ensemble de lettres qui sont placées entre des double quotes.

>>> "Hello!"
'Hello!'

Et bien, en Python on peut aussi le placer entre simple quote cela n'a pas d'importance.

>>> 'Hello!'
'Hello!'

Et pour taper des textes sur plusieurs lignes on peut aussi utiliser les triples simple quotes, ou les triples double quotes.

>>> """Hello
... world"""
'Hello\nworld'

Exemple :

>>> pi = 3.14159
>>> print pi
3.14159
>>> pi*2
6.28318

Il est important de remarquer qu'en Python, une variable n'est pas figée, et aussi bizarre que ça paraisse, on peut changer le type de donnée stocké dans une variable :

>>> pi = 3.14159
>>> pi
3.14159
>>> pi = "Hi"
>>> pi
'Hi'

Comment allons nous stocker des notes pour des élèves afin de calculer une moyenne ? Une variable par élève avec son prénom, ou son nom ? Non, Python a une structure pour stocker ce genre de données : les listes.

Pour créer une liste il suffit de taper ce code :

>>> my_first_list = list()
>>> print my_first_list
[]

Pour remplir une liste il suffit d'appeler append() sur cette liste :

>>> my_first_list.append(1)
>>> my_first_list
[1]
>>> my_first_list.append(2)
>>> my_first_list.append(3)
>>> my_first_list.append(4)
>>> my_first_list
[1, 2, 3, 4]

Écrire append() pour chaque élément de la liste n'est pas très aisé, mais aussi pas très "lisible", ni simple. On peut donc aussi initialiser une liste avec ses éléments en écrivant :

>>> a_second_list = [1,2,3,4]
>>> a_second_list
[1, 2, 3, 4]

C'est tout de suite plus simple.

On peut aussi mélanger les types dans une liste :

>>> misc_list = [1.0, "a", [1,2,3]]
>>> misc_list
[1.0, 'a', [1,2,3]]

Pour accéder à un élément donné, connaissant son ordre dans la liste, on utilise les crochets :

>>> misc_list[1]
'a'
>>> misc_list[0]
1.0

On peut aussi partir de la fin en utilisant un index négatif : -1 permet de récupérer le dernier élément d'une liste; -2 l'avant dernier...

>>> misc_list[-1]
[1,2,3]
>>> misc_list[-2]
'a'

On peut aussi changer un élément :

>>> l = [1, 2, 3]
>>> l[0] = 5
>>> l
[5, 2, 3]

On peut connaître la taille d'une liste en utilisant la fonction pré-définie len() :

>>> len(misc_list)
3
>>> misc_list.append(2)
>>> len(misc_list)
4

On peut aussi connaître le maximum ou le minimum d'une liste (il faut cependant que la liste soit triable) :

>>> min(my_first_list)
1
>>> max(my_first_list)
4

On peut connaître la somme des éléments d'une liste (il faut une liste constituée que de nombres donc) :

>>> sum([1, 2, 3])
6

On peut trier une liste :

>>> sorted([2,3,1,4])
[1, 2, 3, 4]

On peut enlever un élément de la liste :

>>> misc_list.pop(0)
1.0
>>> misc_list
['a', [1, 2, 3], 2]
>>> misc_list.pop()
2
>>> misc_list.pop()
[1, 2, 3]
>>> misc_list.pop()
'a'
>>> len(misc_list)
0

Les tuples sont une sorte de liste, mais dont le contenu est figé : on ne peut pas ajouter de nouvel élément et on ne peut pas changer un élément.

Les tuples sont utiles pour des questions de performances et de place mémoire.

Pour créer un tuple on fait comme pour une liste mais on échange [] par () :

>>> t = (1,2,3)
>>> t
(1, 2, 3)

On peut aussi créer un tuple à partir d'une liste :

>>> t = tuple([1,2,3])
>>> t
(1, 2, 3)

Un set est comme une liste, mais diffère sur 2 points :

• Il n'est pas ordonné : l'ordre de création n'est pas conservé
• Il ne peut contenir qu'une seule fois le même élément

On peut créer dynamiquement un ensemble d'élements uniques par exemple, à partir d'une liste :

>>> uniq_set_of_values = set([1, 2, 1, 3, 1, 4, 2])
>>> uniq_set_of_values
set([1, 2, 3, 4])

On peut aussi ajouter des éléments dans un set, en enlever, connaître sa taille :

>>> uniq_set_of_values.add(1)
>>> len(uniq_set_of_values)
4
>>> uniq_set_of_values.add(5)
>>> len(uniq_set_of_values)
5
>>> uniq_set_of_values.remove(5)
>>> uniq_set_of_values
set([1, 2, 3, 4])

Notés dict en Python, les dictionnaires permettent de faire correspondre une clé à une valeur dans une table.

Si nous reprenons notre exemple des notes dans une classe, on peut faire correspondre à chaque élève sa note lors d'un contrôle.

Un dictionnaire vide peut se créer avec la fonction dict():

>>> marks = dict()

Par exemple :

>>> marks = {
    "toto": 0,
    "riri": 12,
    "fifi": 14,
    "loulou": 20
}

On peut connaître la note d'un élève en demandant la valeur dans la table qui correspond à son prénom :

>>> marks["toto"]
0
>>> marks["loulou"]
20

On peut demander la taille d'un dictionnaire, comme pour les autres types en passant par len():

>>> len(marks)
4

On peut changer une valeurs affecté à une clé (existante ou non) :

>>> marks["fabien"] = 10
>>> marks["toto"] = 2

On peut supprimer une entrée dans la table avec le mot-clé del :

>>> del marks["fabien"]
>>> len(marks)
4

Sur un dictionnaires il est intéressant d'avoir la liste de clés (keys()) et la liste des valeurs (values()) :

>>> marks.keys()
['riri', 'fifi', 'toto', 'loulou']
>>> marks.values()
[12, 14, 2, 20]

help() affiche l'aide d'un objet.
Interactif dans la console

Dans un script :
Donne le "texte" de l'aide, telle qu'on peut la voir sur docs.python.org Il faut passer par print pour voir le texte.

>>> help(set)
Help on class set in module __builtin__:

class set(object)
 |  set() -> new empty set object
 |  set(iterable) -> new set object
...

type() done le type d'une variable ou d'un objet.

>>> d = dict()
>>> type(d)
<type 'dict'>
>>> type(3.14159)
<type 'float'>

dir() donne la liste de ce que propose un objet en Python.

Vraiment très puissant et permet d'avoir plein d'informations lorsque l'on écrit un script.

Un petit exemple :

>>> dir(dict)
[...
    'keys',
    'values',
    ...]

hasattr() permet de savoir si un objet détient un attribut.

L'exemple étant plus parlant qu'un long discours :

>>> hasattr(dict, 'keys')
True
>>> hasattr(dict, 'val')
False

Ensemble de lignes de codes que l'on veut exécuter "d'un bloc".

Très souvent délimité par un indicateur (un caractère) de début et de fin (un autre caractère). En C++ :

{CODE_BLOCK}

Indentation pour rendre le code plus clair :

{
    CODE_BLOCK
}

Seulement une bonne pratique, pas d'obligations.

En début de ce chapitre, je disais que nous voulions exécuter du code si une certaine condition était vérifiée, nous y voila avec la structure de contrôle if.

Pour exécuter un bloc de code si une condition est vraie il faut taper :

if CONDITION:
    CODE_BLOCK

Une condition est une sorte de formule qui est soit vraie soit fausse.

Par exemple, on peut tester si une variable a une valeur donnée en utilisant == :

>>> note = 10   # assign a value to variable
>>> note == 11  # check value content against another value
False
>>> note == 10
True

On peut tester si une variable a une valeur different d'une autre en utilisant != :

>>> note = 10   # assign a value to variable
>>> note != 11  # check value content against another value
True
>>> note != 10
False

On peut aussi tester si une variable est supérieure, inférieure, stricte ou non à une certaine valeur :

>>> note = 10
>>> note <= 10
True
>>> note < 10
False
>>> note >= 10
True
>>> note >10
False

On peut tester en une fois qu'une variable est est dans un intervale:

>>> note = 10
>>> 0 <= note <= 20
True
>>> 5 < note < 10
False

in est un mot-clé vraiment très pratique, et surtout très lisible non?

"Si cet élément est dans ma liste, alors faire ce bout de code" s'écrit pratiquement comme si on parlait :

if element in my_list:
    CODE_BLOCK

Le mot clé not, permet d'inverser une condition. Donc si une condition est vraie, alors not condition est fausse, et vice-versa.

Les parenthèses ne sont pas nécessaires, mais conseillées lorsque la condition devient complexe, pour améliorer la lisibilité.

>>> not True
False
>>> not( True )
False
>>> not False
True

• Afin d'améliorer la lisibilité, il y a une exception pour le mot clé in.
• Il est possible d'écrire not élément in liste.
• Mais c'est moins lisible que élément not in liste

Exemple : deux codes équivalents, mais le second est bien plus facile à lire et à comprendre !

>>> if not 1 in range(5):
...     print True
>>> if 1 not in range(5):
...     print True

and permet de faire un "et logique" entre deux conditions.

La condition formée par un and entre deux sous conditions n'est vraie que si les deux sous conditions sont vraies :

>>> False and False
False
>>> False and True
False
>>> True and False
False
>>> True and True
True

or permet de faire un "ou logique" entre deux conditions.

Il suffit qu'une seule sous condition soit vraie pour que la condition globale soit vraie :

>>> False or False
False
>>> True or False
True
>>> False or True
True
>>> True or True
True

Je n'en ai pas encore parlé, mais il est temps maintenant de vous parler d'une valeur particulière en Python : None.

None permet d'initialiser une variable à une sorte de non-valeur. Ceci est très pratique lorsqu'on veut avoir une variable mais que, par défaut, on ne sait pas encore quoi mettre dedans. Pour revenir à l'exemple de la classe, un élève absent ne doit pas avoir 0 comme note, on pourra dont utiliser 'None' comme note pour cet élève.

>>> marks["McFly"] = None

Pour savoir si une valeur est None, on peut utiliser les doubles égale :

>>> marks["McFly"] == None
True

On peut aussi utiliser un mot clé : is

>>> n is None
True
>>> 1 is None
False

Il se peut que l'on ai besoin de tester si une variable n'est pas à None. Auquel cas on peut utiliser not, comme précédemment, mais une fois de plus pour la lisibilité, on peut utiliser is not :

>>> if not( marks["loulou"] is None ):
...     marks_sum += marks["loulou"]
>>> if marks["loulou"] is not None:
...     marks_sum += marks["loulou"]

for permet d’itérer sur les éléments d'une liste :

for element in list:
    CODE_BLOCK

Mais alors, vous me direz, comment je fais si je dois faire un certain nombre d’opérations mais que je ne n'ai pas de liste ? Et bien, vous vous souvenez du chapitre sur les listes, on a vu une liste particulière : range(). C'est à elle que nous allons demander de faire le travail :

result = 0
for i in range(4):
    result = result + i
print result

while permet d'exécuter un bloc de code tant qu'une condition est vraie :

while condition:
    CODE_BLOCK

Il est possible de faire en sorte que Python n'aille pas plus loin dans l’exécution du bloc d'une boucle (for ou while) afin de passer à l'élément suivant. Pour cela on utilise le mot-clé continue. Par exemple :

for i in xrange(2):
    if i == 1:
        continue
    CODE_BLOCK

Si on veut sortir de la boucle en elle même, on peut utiliser break. Il s'utilise comme continue, mais permet de stopper la boucle :

while True:
    if condition:
        break
    CODE_BLOCK

Pour définir une fonction on fait comme ça :

def name_of_function():
    CODE_BLOCK

Si on veut rajouter des argument on rajoute leur nom entre les parenthèses, et séparés par des virgules :

def set_temperatur(wanted_temperature):
    CODE_BLOCK

def show_color(red_intensity, red_intensity, red_intensity):
    CODE_BLOCK

Pour retourner une valeur, on utilise le mot clé return, comme ceci :

def pi():
    return 3.14159

Tout simplement en utilisant son nom avec les parenthèses :

>>> def pi():
...     return 3.14156
...
>>> print pi()
3.14159

Si la fonction prend des paramètres, on les passe dans les parenthèses :

>>> def echo(valeurs):
...     print valeurs
...
>>> echo(1)
1
>>> echo("ABC")
'ABC'
>>> echo([1,2])
[1,2]

Comme je le disais, une fonction en Python est aussi une variable :

>>> print echo
<function echo at 0x7f7ad7bf4668>
>>> type(echo)
<type 'function'>

Simplement en rajoutant un texte après sa définition (son nom).

Le plus commun est d'utiliser les triples doubles quotes :

def my_function():
    """This is the documentation of my_function."""
    CODE_BLOCK

print help(my_function)
# this will print 'This is the documentation of my_function.'

Afin de pouvoir utiliser un module il faut l'importer de cette façon :

import MODULE_NAME

Ensuite on peut utiliser la document ation officielle de ce module, mais aussi l'introspection (dir() ou bien help()), pour savoir quelles variables ou fonctions ce module met à disposition.

On utilise les variables et les fonctions en utilisant le nom du module, un point, ainsi que le nom de la variable/fonction, comme ceci :

import MODULE
MODULE.useful_function()

Exemple :

>>> import os
>>> os.getlogin()
'fabien'

Permet d'obtenir des informations sur l'état de l'interpreteur Python.

Par exemple quelle version de Python est utilisée :

>>> import sys
>>> print sys.version_info
sys.version_info(major=2, minor=7, micro=15, releaselevel='candidate', serial=1)

Besoin d'utiliser le module de mathématiques pour faire toutes sortes de calculs.

math propose tout un tas de fonctions comme copier le signe d'un nombre sur un autre, connaitre la valeur entière la plus proche d'un nombre, calculer un factoriel, des puissances de logarithmes, des sinus/cosinus, etc.

>>> import math
>>> math.sin(math.PI)
1.2246467991473532e-16

Ce module met à disposition un certain nombre de fonctions relatives à la gestion du temps, mais aussi la gestion de l'heure.

Il permet notement de connaitre l'heure courante avec une précision generalement meilleure que la seconde, mais cela ne peut pas être garanti et dépends du système.

>>> import time
>>> time.time()
1547158168.292978

random, comme son nom l'indique, va permettre d'ajouter de l'aléatoire dans un script. Comme initialiser une variable avec un entier entre deux bornes, ou alors un nombre réél entre 0 et 1 :

>>> import random
>>> random.random()
0.9406027006427641
>>> random.randint(0, 30)
9

Lors de l'écriture de scripts, on a parfois besoin de poser des questions à l'utilisatuer afin de rendre le script "interactif".

En Python 2.7 il faut passer par la fonction raw_input(). Elle prend en paramètre optionnel un texte à afficher avant de poser la question à l'utilisateur :

>>> s = raw_input('--> ')
--> Monty Python's Flying Circus
>>> s
"Monty Python's Flying Circus"

Il existe une façon simple et (au moins) une façon avancé de gérer les paramètres d'un script. Je me contenterais ici de donner la façon simple, mais sachez que la version compliqué peut être trouvé sur cette page de la documentation officielle.

La façon simple est d'utiliser le module sys qui met à disposition une variable argv qui contient tous les éléments de la ligne de commande qui a été utilisée pour lancer Python.

>>> import sys
>>> sys.argv
['']

Écrivons ce script :

import sys
print sys.argv

Maintenant, lançons le avec plusieurs options :

$ python argv_printer.py
['argv_printer']
$ python argv_printer.py argument_1
['argv_printer.py','argument_1']

Un peu de maths : un triangle est un polygone à 3 cotés (ou 3 sommets). La somme des angles d'un triangle vaut 180°. On pourra donc finir de dessiner un triangle avec le code suivant :

>>> t.right(90+45)
>>> import math
>>> t.forward( math.sqrt( 100**2 + 100**2 ) )

• La fonction open() permet de créer un fichier.
• Elle prend deux paramètres :
  • un texte qui donne le nom ou le chemin (absolu ou relatif) du ficher à créer,
  • un texte qui donne le mode d'ouverture du fichier :
    • 'w' pour l'écriture, 'a' pour écrire à la fin du ficher, 'r' en mode lecture.

Créer le fichier toto.txt dans le répértoire courant :

>>> fd = open("toto.txt","w")
>>> fd.close() # Don't forget to close!

Pour faciliter l'ouverture et la fermeture de fichier, on peut utiliser with.

À la sortie du bloc, le fichier sera fermé automatiquement :

>>> with open("toto.txt", "w") as fd:
...     pass
...

Soit avec une forme spéciale de print

Soit en utilisant la méthode write du descripteur de fichiers.

>>> with open("toto.txt", "w") as fd:
...    print >>fd, "My first line"
...    fd.write("#My second line\n")
...

Ouverture en mode lecture

Utiliser le descripteur de fichier dans une boucle pour itérer sur les lignes du fichier :

>>> with open("toto.txt", "r") as fd:
... for line in fd:
...     if line.startswith("#"):
...         print line
...
'#My second line'

Permet de traiter facilement des données d'une liste.

Quand on utilise les [], on peut faire beaucoup plus que de se limiter à donner un simple index.

>>> l = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> l[2,4]    # l[start:end] -> items from start through end-1
[2,3]

>>> l[7:]     # l[start:] -> items from start through the rest of the array
[7,8,9]

>>> l[:4]     # l[:end] -> items from the beginning through end-1
[0,1,2,3]

>>> l[:]      # l[:] -> a copy of the whole array
[0,1,2,3,4,5,6,7,8,9]

On peut aussi utiliser un paramètre supplémentaire qui defini l'incrément :

# l[start:end:step] # start through not past end, by step
>>> l[2:9:3]
[2,5,8]

Le départ ou la fin peuvent être des nombres négatifs ! Donc :

>>> l[-2:]   # last two items in the array
[8,9]
>>> l[:-2]   # everything except the last two items
[0,1,2,3,4,5,6,7]

De la même manière, l'incrément aussi peut être négatif :

>>> l[::-1]    # all items in the array, reversed
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
>>> l[1::-1]   # the first two items, reversed
[1,0]
>>> l[:-3:-1]  # the last two items, reversed
[9,8]
>>> l[-3::-1]  # everything except the last two items, reversed
[7,6,5,4,3,2,1,0]

Note : on peut faire la même chose avec des tuples, le résultat du slice sera un tuple.

Note 2 : on peut utiliser le slicing sur des textes aussi ! Ceci permet d'obtenir un sous texte de façon simple.

>>> t = "abcdefghij"
>>> t[-3::-1]
'hgfedcba'

Mais alors, comment tourner les tests ? Très simple, il faut copier le code si-dessus dans un fichier TrainingPython/DocTests/first_doctests.py_ (doctest n'a d'utilité qu'avec des scripts), puis lancer la commande suivante :

$ python -m doctest Training_Python/DocTests/first_doctests.py

L'affichage est vide : tous les tests passent ! Plus de détails avec l'option verbose (-v en abrégé) :

$ python -m doctest -v Training_Python/DocTests/first_doctests.py
Trying:
    absolute(1)
Expecting:
    1
ok
[...]
1 items had no tests:
    first_doctests
1 items passed all tests:
   4 tests in first_doctests.absolute
4 tests in 2 items.
4 passed and 0 failed.
Test passed.