Les bases de Python

Je ne sais pas vous mais moi je switche souvent d'un langage à l'autre. C, C++, perl, python, javascript, bash.....

Quand je passe un moment sur l'un j'oublie l'autre donc je vais faire une petite page de rafraichissement pour chacun.

Généralités

ATTENTION: Tout ce qui va suivre concerne Python3. Si je parles d'une syntaxe Python2 ce sera précisé. La syntaxe Python2 est très moche. Je ne l'utilise que quand je suis obligé (module écrit en python2 seulement)

Python est un langage de script qui vient après des langages comme perl. Il est plus structuré que ce dernier. Il est de nos jours utilisé partout. Vraiment partout! Même si on n'en est pas fan il faut y passer.

Python est un langage "WISIWIG" dit on. En gros la structure se voit a l'écran en lisant le code. On est OBLIGE de bien écrire le code.

Ce qui en "C" s'écrirait :

#include <stdio.h>

int min(int a, int b) {
    if (a<b)
        return a;
    else 
        return b;
}

void main (){
    printf (min(3,2));
}

ou bien :

#include <stdio.h>

int min(int a, int b) {(a<b)?a:b;}

void main (){printf (min(3,2));}

Finalement on ferait pluôt :

void main(){
    printf (3<2:3;2);
}

Mais ça n'a aucun sens! En Python:

def min(a,b):
    if (a<b):
        return a 
    else:
        return b

print (min(1,5))

ATTENTION

Il n'y a pas d'accolades "{ }" mais des ":" et des tabulations... Il n'y a pas de point virgules (c'est ce qui me troubles! Normalement y'a TOUJOURS des virgules) les blocs de codes sont définis par l'indentation L'indentation peut être faite par des tabulation ou des espaces mais attention ce n'est pas parceque c'est indenté proprement dans l'éditeur que c'est correct syntaxiquement. Si votre éditeur fait des tabulations de 8 caractères (la norme normalement) on ne voit pas la différence entre 8 espaces et une tab sur l'écran mais Python vas hurler à la faute d'indentation! WISIWIG mes fesses!

Les types de données composites

Ce sont tous les types de données autres que les scalaires.

Attention pour ces types, ile fonctionnement par défaut par références.

a=[1,2,3]
print (a)
[1, 2, 3]
b=a
print (b)
[1, 2, 3]
a[0]=33
print (b)
[33, 2, 3]

On voit que a et b sont des références vers la même variable. Si on veut que a et b soient des variables indépendantes:

a=[1,2,3]
b=a.copy()
print (a)
[1, 2, 3]
print (b)
[1, 2, 3]
a[0]=33
print (a)
[33, 2, 3]
print (b)
[1, 2, 3]

Chaque objet composite à une méthode copy() par défaut.

Les listes et le tuples

C'est un truc qui trouble beaucoup. En python il y a deux types de structures... les listes (des tableaux) et les tuples.

Listes

Une liste est ce que l'on appelle tableau (array) dans la majorités des langages (en C par exemple). La syntaxe est une liste de valeurs séparées par des "," et encadrées par des "[ ]".

# Classiquement (oui un commentaire c'est #)
a=[1,2,3,4,5]
b=["un","deux","trois","quatre","cinq"]
# Ou même
c=["un",1,"quatorze",22,"vla les flics"]

print (c[1])
# écrira 1
print (c[2])
# écrira quatorze
# C'est très "objet" Python :)


a=[0]*5
# Un tableau de 5 entiers à 0: [0, 0, 0, 0, 0]
a=[0.0]*5
# Un tableau de 5 flottants à 0: [0.0, 0.0, 0.0, 0.0, 0.0]

La fonction len() donnera la taille de la liste (son nombre d'éléments).

a=[1,2,3,4]
print (len(a))

Nous donnera la valeur 4

ATTENTION : Le premier index est 0 donc le dernier est len() - 1

Ajouter un élément

La méthode append de liste est là pour ça.

liste = ['un', 'deux','trois']
print (liste)
liste.append('quatre')
print (liste)

Nous donnera la sortie :

['un', 'deux', 'trois']
['un', 'deux', 'trois', 'quatre']

Supprimer un élément

Là il y a deux façons de faire, le mot clé del et la methode remove.

liste = ['un', 'deux','trois','quatre','cinq']
print (liste)
del liste[3]              # on détruit la variable liste[3]
print (liste)
liste.remove('un')        # on retire la valeur correspondante
print (liste)
liste.remove('douze')     # on retire une valeur qui n'est pas dans la liste

Nous donne le résultat:

['un', 'deux', 'trois', 'quatre', 'cinq']
['un', 'deux', 'trois', 'cinq']
['deux', 'trois', 'cinq']
Traceback (most recent call last):

  File "<ipython-input-76-adaeb2afb161>", line 7, in <module>
    liste.remove('douze')     # on retire une valeur qui n'est pas dans la liste

ValueError: list.remove(x): x not in list

Attention si on remove une valeur présente plus d'une fois dans la liste, seulement la première est retirée. Les autres restent!

Tuples

C'est une structure de plus bas niveau. Un exemple

# Exemple de tuple
tuple=(1,2,3)
print (tuple)

La on imprime l'objet tuple. La sortie est :

(1, 2, 3)

Les valeurs ne sont pas indexées on ne peut par écrire

tuple=(1,2,3)
print (tuple[0])  ### Erreur de syntaxe pas d'index sur un tuple

Pour accéder aux valeurs on fait:

tuple=(1,2,3)
x,y,z=tuple
print (x)

Là on écris bien la valeur du premier élément d'un tuple.

On ne peut pas, simplement, changer une seule valeur du tuple. C'est une donnée a part entière.

ATTENTION: On doit avoir le même nombre de variables devant le "=" que d'éléments dans le tuple! En revanche len(tuple) donne bien le nombre de valeurs dans le tuple.

En revanche les éléments d'un tuple n'ont pas forcément le même type.

label=(3,4,"Strat")
# pourrait être une étiquette "Start" disposée à la position x=3 y=4 à l'écran.

# mieux! 
label=[(0,0,"message")]*3
label[0]=(0,10,"begin")
label[1]=(5,20,"middle")
label[2]=(10,30,"end")
# Un objet du type [(0, 10, 'begin'), (5, 20, 'middle'), (10, 30, 'end')]

Je n'aime pas trop Python mais là on à une structure assez élégante... j'avoue.

Les dictionnaires

Ce sont des couples "name" "value". Ca pourrait ressembler a des objets en javascript.

thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964 
}

A la virgule près c'est du javascript! On y accède par :

thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
print(thisdict["brand"])
thisdict["brand"]="Renault"
thisdict["model"]="R8"

On peut avoir le nombre de membres:

thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
print(thisdict)

Nous donne 3.

Les ensembles "set"

Les ensembles ont les caractéristiques suivantes:

Dans les exemples suivants je vais utiliser des ensembles d'entiers mais cela peut être des ensembles de n'importe quoi. Des ensembles de chaines, de réels et de n'importe quels autres objets (Ils doivent cependants estre des types "hashables") on ne peut pas faire des ensembles d'ensembles ce qui n'est pas très "mathématique".

On peut faire que des ensembles de "scalaires"!

Le type d'éléments de l'ensemble n'est évidement pas nécessairement le même. On peut avoir un ensemble d'entiers ET de chaines par exemple.

• Il sont sans ordre (unordered)

e=set()
e.add(23)
e.add(12)
e.add(90)
e.add(0)
print(e)

Nous donne (par exemple) :

{0, 90, 12, 23}

L'ordre n'est pas garanti. Le moteur python utilisera la structure qu'il jugera la plus favorable pour le stockage. (dans notre exemple il semble que ce soit l'ordre d'ajout)

• Chaque élément est unique (pas deux fois la même valeur)

e=set();
e.add(1); e.add(5); e.add(12)
print (e)
e.add(5)
print (e)

Nous donne:

{1, 12, 5}
{1, 12, 5}

On voit que l'ordre c'est vraiment... comme le veut le moteur et qu'il est impossible d'ajouter deux fois la même valeur.

• Les valeurs des éléments ne sont pas modifiables

Rien a dire sur ce point là. C'est une propriété.

• On peut ajouter ou retirer un élement

On a vu le add mais on a aussi un remove.

e=set(); e.add(1); e.add(5); e.add(10); e.add(4)
print (e)
e.remove(5)
print (e)
e.remove(12)
print (e)

Va nous donner:

{1, 4, 5, 10}
{1, 4, 10}
Traceback (most recent call last):

  File "<ipython-input-43-2aa4ea5031ce>", line 1, in <module>
    e.remove(100)

KeyError: 100

Là on remarque qu'ajouter une valeur déjà existante ne fait rien et ne provoque aucune erreur mais retirer une valeur qui n'est pas dans l'ensemble provoque bien une erreur.

• Ils sont "itérables"

e={1,3,5,7,11,17}   # On peut aussi déclarer un "set" de façon statique.
for x in e:
    print ("Element "+str(x))

Donne l'affichage:

Element 1
Element 3
Element 5
Element 7
Element 11
Element 17

• On peut faire des opérations "ensemblistes"

# Nombres de 1 à 24
p={2, 3, 5, 7, 11, 13, 17, 19, 23}     # Les nombres premiers
o={1,3,5,7,9,11,13,15,17,19,21,23}     # Les nombres impairs
e={2,4,6,8,10,12,14,16,18,20,22,24}    # Les nombres pairs
b={1,2,4,8,16}                         # Les puissances de deux (valeurs digits binaires)

On peut faire une union:

N=e.union(o)
print (N)

Donne logiquement l'ensemble des entiers entre 1 et 24

{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 20, 21, 22, 23, 24}

Avec des tuples On peut faire une union entre un ensemble et un "tuple".

T=e.union((1,2,3,4))
print (T)

Nous donne :

{1, 2, 3, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24}

Je trouve cette syntaxe assez moche et source d'erreurs. (mais c'est mon avis) Syntaxe alternative :

N=e | o
print (N)

Attention ça ne marche pas avec des tuples.

Donne le même résultat.

Equivalance

union = |

Une intersection

I=e.intersection(p)
print (I)

nous donne :

{2}

Effectivement le seul nombre premier pair est 2! La syntaxe alternative :

I=p & e
print (I)

Donne toujours {2}

Equivalance

intersect = &

Soustractions

Toujours dans la suite des opérateurs "ensemblistes" on peut faire des soustractions.

On cherche l'ensemble des nombres pairs qui ne sont pas premiers:

print (e.difference(p))
print (e-p)

Les deux syntaxes affichent :

{4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24}

Equivalance

difference = -

Différences symétriques.

Cet opérateur ne garde que les élément qui ne sont pas présents dans les deux ensembles.

On peut dire que c'est :

print (p.symmetric_difference(e))
print (p ^ e)
print ((p | e) - (p & e))

Les trois lignes nous donnent la même réponse:

{3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 16, 17, 18, 19, 20, 22, 23, 24}
{3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 16, 17, 18, 19, 20, 22, 23, 24}
{3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 16, 17, 18, 19, 20, 22, 23, 24}

Soit tous les éléments de e (nombres pairs) qui ne sont pas dans p (nombres premiers) et tous ceux de p qui ne sont pas dans e. En d'autre terme on prends tout le monde et on vire 2.

Update

Un cas particulier est update. Dans toutes les operations ensembliste on prends un ensemble, on lue applique un opérateur sur un autre ensemble et le résultat est retourné en retour. Les ensembles "opérandes" ne sont pas touchés.

La méthode update de l'objet ensemble fait une union entre l'ensemble et son paramètre mais l'objet est mis a jour.

n={1,3,5,7,9,11,13,15,17,10,21,23}     # des nombres
e={2,4,6,8,10,12,14,16,18,20,22,24}    # Les nombres pairs
n.update(e)
print (n)

l'ensemble "n" contient bien, à la fin, l'union du "n" initial avec e:

{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 20, 21, 22, 23, 24}

Même chose pour :

intersection_update()
difference_update()
symmetric_difference_update()

Les boucle

Il y a beaucoup de façons de faire des boucles en Python.

Itération sur un objet liste

Pour faire une itération sur les éléments de la liste:

a=[1,2,3,4,5]
for i in a:
    print (i)

Pour le coup c'est simple et élégant.

Itération sur un dictionaire

Le dictionnaire est une variable déclarée :

mondic={"nom":"Volfoni", "prenom":"Raoul", "age": 45}

on boucle sur les clés par :

mondic={"nom":"Volfoni", "prenom":"Raoul", "age": 45}

for key in mondic:
    print (key)

Donne:

nom
prenom
age

Bon c'est pas très utile... En revanche:

mondic={"nom":"Volfoni", "prenom":"Raoul", "age": 45}

for key in mondic:
    nom=key
    valeur=mondic[key]
    print (nom,"\t",valeur)

Nous donne :

nom 	 Volfoni
prenom 	 Raoul
age 	 45

Ça sembles plus utile. Si on combines les deux (liste et dictionnaires):

o=[{"a":1,"b":23},{"a":34,"b":2}]

i=0
for d in o:
    print ("Element ",i)
    i+=1
    for k in d:
        print ("\t",k,"=",d[k])

On boucle sur la liste et, dans chacun des éléments, on boucle sur les attributs du dictionnaire.

Element  0
	 a = 1
	 b = 23
Element  1
	 a = 34
	 b = 2

While

Qu'on se rassure le while est toujours là.

i = 1
while i < 6:
  print(i)
  i += 1

En revanche adieux le i++ on est obligé d'utiliser le moche i+=1.