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 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.