Nanterre p10 - Dev Data

Logo

semaine s14

semaine s15

semaine courante (s17)

planning des veilles 

from notebook.services.config import ConfigManager
cm = ConfigManager()
cm.update('livereveal', {
#        'width': 1024,
#        'height': 768,
        'scroll': True,
})

Dessine moi un Python

serpent

Python est un langage de programmation. Nous allons ici découvrir les bases de son utilisation.

Un langage de programmation est destiné à permettre l’écriture et la manipulation de structures de données par un terminal informatique (ordinateur, téléphone, …). Comme tout langage de programmation, Python possède un vocabulaire (des mots clés) et des règles de grammaire (comment agencer les mots clés).

Python est un langage interprété, les mots clés que nous allons utiliser dans nos lignes de code seront lues par un interpreteur qui “dira quoi faire à notre machine”.

Il est beaucoup utilisé dans le monde de la data car il possède de nombreuses bibliothèques mathématiques (morceaux de code réutilisables) accessibles pour les développeurs.

Dans ce cours nous verrons comment écrire et exécuter du Python. Deux méthodes différentes s’offrent à nous :

Commenter le code

Avant toute chose, il convient de parler des commentaires ! C’est certainement une des choses les plus importantes que l’on écrit lorsque l’on code. Ce sont des lignes de code qui ne seront pas interprétées mais qui donnent des indications primordiales pour les programmeurs qui liront le code (y compris vous dans quelques mois / années).

# Voici comment j'écris un commentaire en Python : en démarrant ma ligne de code par le caractère #
# C'est vraiment très important de documenter son code en mettant des bons commentaires pour les futurs développeur•euse•s
# J'espère que vous le ferez !

Variable et type de données

En Python, nous allons pouvoir définir des variables. Ce sont des blocs de la mémoire de l’ordinateur que le programme va réserver pour y stocker des données (un age, un prénom, la liste des numéros gagnants du loto, votre adresse IP, …). Chaque variable aura un type de données associé (un age sera un nombre, un prénom sera une chaîne de caractères, …)

Pour déclarer une variable en Python il suffit de donner un nom à notre variable et de lui donner une valeur.

data_analyst = True
age = 30
prenom = "Jules"

Les booléens

Le type de données élémentaire à connaître qui est à la base de l’informatique d’aujourd’hui est le booléen. Il s’agit d’un type de données qui n’a que deux valeurs possibles : Trueou False. Cela correspond au 0 et au 1 du binaire. Nous l’utiliserons beaucoup lorsque nous aborderons les conditions.

# Une vérité
je_suis_homme = True

# Un mensonge
je_suis_femme = False

Les nombres

Deux grand types de nombre nous seront utiles : les int qui représentent les nombres entiers et les float qui représentent les nombres décimaux.

# Mon age
age = 30

# Ma taille en cm
taille = 184.5
print(age)

print("taille =", taille)
## affichage formate :
print("{}".format("-"*23))
print("taille = {:.2f}".format(taille)) # arrondi a 2 chiffres

Pour plus de détails : La documentation officielle de Python

Les chaînes de caractères

Afin de stocker du texte (un prénom, un nom, une phrase, …) nous utiliserons les str qui représentent les chaînes de caractères. Il y a deux méthodes pour déclarer un str (avec guillemets simples ou doubles):

prenom = "Jules"
nom = 'Dupont'
print(nom)

nom = input("ton nom ? ")
print(nom)

Parfois on peut avoir envie d’utiliser des guillemets dans la chaîne de caractères. Dans ce cas on peut procéder comme suit :

presentation = "Je m'appelle Jules"
citation = "J'adore la Data."

Parfois on peut avoir envie de combiner les deux :

citation = 'Sans connaissance de son audience, et sans hypothèses préalables solides, la Big data ne sert à rien.'


citation = "Je n'aime pas les chiffres ! Je préfère les décortiquer pour percevoir leur véritable signification."

Dans cette dernière citation, j’ai besoin d’échapper le guillemet simple afin qu’il ne soit pas interprété comme la fin de la chaîne de caractères. On utilise dans ce cas le caractère backslash.

On peut aussi avoir besoin d’écrire une chaine de caractères qui contient plusieurs lignes de texte. Dans ce cas, deux solutions : utiliser le caractère spécial \n pour indiquer un retour à la ligne ou utiliser le commentaire multiligne.

presentation = "Je m'appelle Jules\nJ'ai 30 ans."
passions = """- Films
- Self-Hacking
- voyage"""

Pour plus de détails : La documentation officielle de Python

Opérateurs

Opérations de base sur des nombres

On peut utiliser les 4 opérations sur des nombres. Les résultats obtenus sont sans surprise.

soldeCompte = 150
retrait = 20

nouveauSolde = soldeCompte - retrait

depot = 105
nouveauSolde = soldeCompte + depot

Les opérations +,-,* sur des nombres entiers donnent des nombres entiers. Les opérations +,-,* sur au moins un nombre float donnent des nombres float.

soldeCompte = 150
depot = 10.0

nouveauSolde = soldeCompte + depot

pourcentage = 0.3
nouveauSolde = soldeCompte * 0.3

La division a toujours pour résultat un float.

nbPartPizza = 4
nbPersonne = 2

nbPart = 4/2 # 2.0

Les priorités de calcul sont les priorités habituelles, on peut utiliser des parenthèses.

a = (2+4)*3 # 18
b = 2+(4*3) # ?
print(b)

Puissance

L’opérateur puissance se note **

a = 3 ** 2

Division entière

On utilise souvent en informatique la division entière qui donne deux résultats : le reste et le quotient.

etudiants = 26
nbGroupes = 3

etudiantsParGroupe = 26 // 3 # pour obtenir un résultat entier
etudiantsRestant = 26 % 3 # on dit 26 modulo 3
print(etudiantsRestant)

Opérations avec des chaînes

On peut concaténer (mettre bout à bout) des chaînes de caractères avec l’opérateur +.

nom = "Odile"
age = 34

presentation = "Bonjour, je m'appelle "+nom+ " et j'ai "+age+ " ans" # ne fonctionne pas, il faut convertir d'abord age en chaîne
presentation2 = "Bonjour, je m'appelle "+ nom+ " et j'ai "+ str(age)+ " ans"
print(presentation)

On peut aussi utiliser d’autres opérations arithmétiques avec du texte.

initial = "pain"
magic = 3*initial

print(magic)

Comparaison

Les relations d’ordre produisent des booleans. Ils se basent sur l’ordre lexicographique (du dictionnaire).

18 < 22 # True
3*5 < 10 # False
2*3 <= 6 # True
"rocky3" > 2 # erreur

Egalité

On compare des variables avec ==, puisque le = est déjà utilisé pour l’affectation. Cela produit aussi un boolean.

line1 = "Nah nah nah nah nah nah nah nah nah yeah";
line2 = "Nah nah nah nah nah nah, nah nah nah, hey Jude";
line3 = "Nah nah nah nah nah nah, nah nah nah, hey Jude";

line1 == line2
line2 == line3

isDifferent = line1 != line3 # il est vrai que ces lignes ne sont pas égales!

ressources utiles:

Booleans et conditions

Conditions

Pour effectuer un bloc d’instructions si une condition est vraie, on utilise le mot-clé if. Pour délimiter la taille du bloc d’instructions, on utilise l’indentation.

temperature = 20
vetement = "teeshirt"

if temperature < 15 : # début du bloc après les :
    print("c'est deja l'automne")
    vetement = "pull"

print(vetement)

Si la condition est vraie, on exécute les instructions du blocs. Sinon on saute le bloc. On peut ajouter un bloc à exécuter seulement si la condition est fausse avec else.

temperature = 10
vetement = "teeshirt"

if temperature < 15 : # début du bloc après les :
    print("c'est deja l'automne")
    vetement = "pull"

else :
    print("vive le rechauffement")


print(vetement)

On peut aussi ajouter d’autres conditions intermédiaires avec elif, a exécuter seulement si les précédentes sont fausses.

age = 2

if age < 0 :
    print("merci d'entrer un age valide (positif)")

elif age < 3 : # on ne rentre pas ici si on est déjà entré dans le cas d'avant
    print("tarif : gratuit")

elif age < 18 :
    print("tarif : réduit")

elif age > 65 :
    print("tarif : réduit")

else : # dans tous les autres cas
    print("tarif : normal")

Opérations sur les booleans

Dans le cas précédent, on obtient un tarif réduit si l’âge est inférieur à 18 ou supérieur à 65. On peut rassembler les deux cas.

age = 12

if age < 0 :
    print("merci d'entrer un age valide (positif)")

elif age < 3 : # on ne rentre pas ici si on est déjà entré dans le cas d'avant
    print("tarif : gratuit")

elif age < 18 or age > 65 :
    print("tarif : réduit")

else : # dans tous les autres cas
    print("tarif : normal")

Une erreur classique est d’utiliser un or lorsqu’il faudrait un and ou inversement. Ici par exemple, un age qui est inférieur à 18 et supérieur à 65 n’existe pas, il fallait bien utiliser ou.

brocoli = 4
aubergine = 6
concombre = 5
radis = 2
pomme = 3
mure = 9

quelle condition sur les prix pour ne sélectionner que :

brocoli = 4
radis = 2
pomme = 3
mure = 9

Les listes

Il est souvent pratique de gérer plusieurs variables à l’aide de listes (ou de tableaux).

eleve1 = "sam"
eleve2 = "bob"
eleve3 = "al"
# etc ...

Les éléments sont entre crochets et séparés par des virgules.

eleves = ["sam", "bob", "al"]
# une seule variable !

On peut faire des listes de nombres, de chaînes, de booléens, etc …

listeNb = [1,2,3]
listeMot = ['celeri', 'muscade', 'agneau']
listeMixe = ['odile', 2, 'ray']

listeNb.reverse() # fonction de base
listeMot.sort() # trie en place
len(listeMot) # taille de la liste

Indices

Les éléments sont numérotés à partir de 0. On accède aux éléments avec []

eleves = ["sam", "bob", "al", "odile"]
print(eleves[0]) # l'élément n°1 de la liste est bob

On peut extraire une sous-liste avec :

eleves = ["sam", "bob", "al", "odile"]
print(eleves[1:3]) # les éléments 1 à 3 (exclu)
print(eleves[1:]) # tous les éléments à partir du 1

Pour plus de détails : La documentation officielle de Python

Range

Python sait aussi compter! pour générer une liste de nombre, on utilise simplement la fonction range

Pour plus de détails : La documentation officielle de Python

liste = range(2,10) # de 2 jusqu'à 10 (exclu)
liste2 = range(50) # de 0 jusqu'à 50 (exclu)
liste3 = range(1,50,2)
list(liste)

Les listes sont un type de structure de donnée qui permet de stocker un ensemble de valeur.

a = list(range(1000))
print(a[0])
print(a[-1])

Ajouter/Modifier/Supprimer des elements

La fonction len() renvoie le nombre d’éléments. Par exemple :

a = list(range(7,10))
print(a)
len(a)

Interpréter ce résultat ?

b = a + a
print(b)

Ajouter des éléments à une liste:

a.append(5)
print(a)

il est possible de mélanger dans une même liste des variables de type différent. On peut aussi mettre une liste dans une liste.

Etudier le code ci dessous et interpréter les outputs.

# On construit une liste avec des crochets []
liste1 = [ 1, 2 ]
# on peut mélanger les types dans une liste
liste2 = [ "trois", 4.1]

#additionner 2 listes
liste = liste1 + liste2

#Ajouter dans liste l'élement "cinq"
liste.append("cinq")

#Afficher le contenu des 3 listes
print(liste1)
print(liste2)
print(liste)

Application

1- Remplir une liste d’apprenants, afficher le nombre des enregistrés ainsi que le premier et le dernier de la liste .

2- Ajouter, ensuite, un nouvel apprenant et afficher la liste finale

#TBD

1- avec del : del variable_a_supprimer.

2- avec la méthode remove: qui prend en paramètre l’élément (et non pas l’indice de l’élément à supprimer).

apprenants=['François','Sarah','Corine','Mathilde']
print(apprenants)
del apprenants [0]
print(apprenants)
apprenants.remove('Corine')
print(apprenants)

Pour plus de détails : La documentation officielle de Python

Boucles

On va parler ici de répétitions. C’est quelque chose qu’un programme sait très bien faire, répéter plusieurs fois (parfois un grand nombre) un bloc d’instructions.

While (tant que)

Tant que tu n’auras pas fini ta purée, tu n’auras pas de dessert!

i = 10 # cuilleres

while i > 0 : # puree > 0 est une condition, comme pour le if
    print("je continue mon décompte")
    i = i -1

print( "j'ai fini")

For (pour)

Si on veut faire le même traitement pour chaque élément d’une liste, il suffit d’utiliser le mot pour, mais en anglais. Dans ce cas, on doit choisir un nom pour l’élément courant à parcourir.

eleveListe = ["sam", "bob", "Jack", "odile"]
print("bonjour "+eleveListe[0])
for eleve in eleveListe : # on commence toujours un bloc avec :
    print("bonjour "+eleve)


for i , elt in enumerate ( eleveListe ) :
    print (" À l ' indice {} se trouve {}.". format (i , elt ) )

Ou aussi avec des nombres, pour répéter 100 fois une action (utile!).

for i in range(10) :
    print(str(i)+" Hello!")

Ou encore si je veux remplir une liste au fur et à mesure avec des entrée utilisateur :

n = int(input("combien de personnes? "))

personnes = [] # au début, on crée une liste vide

for i in range(n) : # le nombre n est le nombre de répétitions à faire
    nom = input("entrez le nom de la personne n°"+str(i))
    personnes.append(nom) # la fonction append permet d'ajouter à la fin de la liste

for i in range(len(personnes)) :
    print("bonjour "+personnes[i]) # personne[i] permet d'accéder à la personne de la liste d'indice i

Pour la 2e boucle du code précédent, parfois on a besoin de l’indice, mais si on ne l’utilise pas, la syntaxe for … in est plus pratique :

n = int(input("combien de personnes? "))

personnes = [] # au début, on crée une liste vide

for i in range(n) : # le nombre n est le nombre de répétitions à faire
    nom = input("entrez le nom de la personne n°"+str(i))
    personnes.append(nom)

for nom in personnes :
    print("bonjour "+nom)

while 1 : # 1 est toujours vrai -> boucle infinie
    lettre = input (" Tapez 'Q' pour quitter : ")
    if lettre == "Q":
        print ("Fin de la boucle ")
        break

i = 1
while i < 20 : # Tant que i est inf é rieure à 20
    if i % 3 == 0 :
        i += 4 # On ajoute 4 à i
        print ("On incrémente i de 4. i est maintenant égale à",i )
        continue # On retourne au while sans exécuter les autres lignes
        print ("La variable i =", i )
    print ("i=",i)   
    i += 1 # Dans le cas classique on ajoute juste 1 à i

Pour plus de détails : La documentation officielle de Python

Les Listes de compréhension:

Comprehension lists fournissent un moyen de construire des listes de manière très concise. Une application classique est la construction de nouvelles listes où chaque élément est le résultat d’une opération appliquée à chaque élément d’une autre séquence ; ou de créer une sous-séquence des éléments satisfaisant une condition spécifique.

Par exemple, supposons que l’on veuille créer une liste de carrés, comme :

squares = []
for x in range(10):
    squares.append(x**2)

print(squares)

squares = [x**2 for x in range(10)]
print(squares)

Une compréhension de liste consiste à placer entre crochets une expression suivie par une clause for puis par zéro ou plus clauses for ou if. Le résultat est une nouvelle liste résultat de l’évaluation de l’expression dans le contexte des clauses for et if qui la suivent. Par exemple, cette compréhension de liste combine les éléments de deux listes s’ils ne sont pas égaux :

[(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]

combs = []
for x in [1,2,3]:
    for y in [3,1,4]:
        if x != y:
             combs.append((x, y))
combs

Remarque: La première expression dans une compréhension de liste peut être n’importe quelle expression, y compris une autre compréhension de liste.

 matrix = [
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12],
    ]
print([[row[i] for row in matrix] for i in range(3)])

“Bonjour, l’intelligence artificielle c’est trop bien”

Utiliser split pour découper la chaîne de caractère en mots.

texte = "Bonjour, je suis un Data Analyst"
print(texte)
a=texte.split('n')
print(len(a))
print( a)

Utiliser cette méthode pour stocker le contenu de cette liste en une chaine de caractère .

liste=[“Ma formation”,”IA”,”démarre bien !”]

liste=["Ma formation","IA","démarre bien !"]
print(liste)
s = " "
s = s.join(liste)
print(s)

Application

soit la liste suivante:

weekdays = [‘mon’, ‘tues’, ‘wed’, ‘thurs’, ‘fri’]

weekdays = ['mon', 'tues', 'wed', 'thurs', 'fri']
# Afficher le premier element de la liste
#TBD

#Afficher les elements 0 (inclus) à 3 (exclus)
#TBD

#Afficher avec un pas de 2 (les indices: 0,2,4)
#TBD

#Afficher la liste inversée
#TBD

#Afficher la liste triée
#TBD

#Afficher la liste inversement triée

print(weekdays)

Application

#TBD

#Interpréter les affichages suivants ?
saisons[2]
saisons[1][0]
saisons[1:2]
saisons[:][1]

Les Sets

Les sets sont un type de donnée similaire aux listes mais avec quelques petites particularités.. un Set est défini par des accolades et non par des crochets (liste)

Un ensemble est une collection non ordonnée sans élément dupliqué. Parmi les utilisations basiques des sets on trouve les tests d’appartenance ou des suppressions de doublons

Pour plus de détails : La documentation officielle de Python

A partir de cette liste précédente créer un set. Parcourir la liste précédente et le set et afficher les éléments.

liste= [1, 2, 1, 3, 5, 6, 3]
print(liste)

set(liste)
print(len(s))

=> cannot have multiple occurrences of the same element and store unordered values. it makes sets highly useful to efficiently remove duplicate values from a list or tuple and to perform common math operations like unions and intersections.

# Demonstrate set operations on unique letters from two words
a = set('abracadabra')
b = set('alacazam')
print(a )                                 # unique letters in a

print(a - b )                             # letters in a but not in b

print(a | b)                              # letters in a or b or both

print(a & b)                              # letters in both a and b

print(a ^ b)                              # letters in a or b but not both

Tout comme pour les compréhensions de listes, il est possible d’écrire des compréhensions d’ensembles :

a = {x for x in 'abracadabra' if x not in 'abc'}
a

Application

Définir une intersection d’ensembles (sets) E1 et E2 :

indication: E1 Δ E2 = (E1 - E2) ∪ (E2 - E1)

Exemple d’exécution:

E1={3,5,6,7}

E2={4,3,7,9}

diff_sym(E1,E2)

{4, 5, 6, 9}

#TBD

Les tuples

Un tuple est une liste qui ne peut plus être modifiée. On les utilise pour définir des constantes qui n’ont pas vocation à changer. Un n-uplet consiste en différentes valeurs séparées par des virgules

mon_tuple1 = (1, "Hello", "François",[1,2,3])
mon_tuple2 = 1, 2, 3
print(type(mon_tuple1))
print(type(mon_tuple2))

Application

soit cette liste:

a= [0,3,1]

suivre les instructions ci dessous:

a=[0,3,1]
# creer un tuple t à partir de la liste a et afficher son length
#

# compter le nombre d'instances de 0 dans t
#TBD
# trouver l'index de la première instance de cet element trouvé:
#TBD
# Que remarquez vous si vous lancer la commande cidessous:
#t[2] = 2

#Ajouter au tuple t, les 2 elements (3, 4)
#
#t += (3,4)
#print(t)
#trier le tuple t
#TBD

La Reference complete est ici

Les dictionnaires

un dictionnaire contient un ensemble de couples (clé ➞ valeur) Contrairement aux listes qui sont délimitées par des crochets, on utilise des accolades pour les dictionnaires. Un élément est définit en précisant une clé (une chaîne de caractères) suivie de : puis de la valeur associée

clé: valeur

Les dictionnaires sont des objets qui peuvent en contenir d’autres. Au lieu d’héberger des informations dans un ordre précis comme les listes, un dictionnaire associe chaque objet contenu à une clé (généralement une chaîne de caractères).

Un dictionnaire est un type de données extrêmement puissant et pratique. Il se rapproche des listes sur certains points mais, sur beaucoup d’autres, il en diffère totalement.

Objet conteneur d’autres objets. Pour accéder aux objets contenus, il faut connaître leur position dans la liste. Cette position se traduit par des entiers, appelés indices, compris entre 0 (inclus) et la taille de la liste (non incluse).

Objet conteneur d’autres objets également. Mais aucune structure ordonnée. Pour accéder aux objets contenus, on n’utilise pas nécessairement des indices mais des clés qui peuvent être de bien des types distincts.

=> Les parenthèses délimitent les tuples, les crochets délimitent les listes et les accolades {} délimitent les dictionnaires.

Création et édition

Il existe deux moyens de créer des dictionnaires:

mydict =dict() #creation du dictionnaire mydict
print(type(mydict))
mydict['couleur']='rouge'
print(mydict)

mon_dictionnaire = {"voiture": "véhicule à quatre roues", "vélo": "véhicule à deux roues"}
print(type(mon_dictionnaire))
print(mon_dictionnaire)


#On accède à une valeur du dictionnaire en utilisant la clé entourée par des crochets avec la syntaxe suivante :

mon_dictionnaire["voiture"]


d = {}
d['a'] = '1'
d['b'] = '2'
print(d)
#Modifier la valeur de la clé a
d['a']= '3'
print(d)

dic = {
    'firstname': 'Jean',
    'lastname': 'Dupont'
}

print(dic['firstname'])


dic['age'] = '20 ans'
dic

La méthode get permet de récupérer une valeur dans un dictionnaire et si la clé est introuvable??

vous pouvez donner une valeur à retourner par défaut ..

data = {"firstname": "Jean", "lastname": "Dupont","age": 30}
print(data.get("firstname"))
print(data.get("adresse", "Adresse inconnue"))
print(data)

Supprimer des clés

Comme pour les listes, il existe deux méthodes:

data = {"firstname": "Jean", "lastname": "Dupont","age": 30}
print(data)
del(data['age'])
print(data)

data = {"firstname": "Jean", "lastname": "Dupont","age": 30}
print(data)
print(data.pop('lastname'))
print(data)

Parcourir un dictionnaire

Parcours des clés

Comme les dictionnaires n’ont pas de structure ordonnée, les clés ne s’affichent pas dans l’ordre dans lequel on les a entrées.

data = {"firstname": "Jean", "lastname": "Dupont","age": 30}
for key in data:
    print(key)

data = {"firstname": "Jean", "lastname": "Dupont","age": 30}
for key in data.keys():
    print(key)

Parcours des valeurs

On peut aussi parcourir les valeurs contenues dans un dictionnaire à l’aide de la méthode values() mais qui reste peu utilisée car il est plus pratique de parcourir la liste des clés, puis les valeurs correspondantes.

data = {"firstname": "Jean", "lastname": "Dupont","age": 30}
for val in data.values():
    print(val)

Il est peut etre plus pertinent de l’utiliser dans une condition:

data = {"firstname": "Jean", "lastname": "Dupont","age": 30}
if 'Jean' in data.values():
    print(key)

Parcours des clés et valeurs simultanément

Pour avoir en même temps les clés et les valeurs on utilise la méthode items().

data = {"firstname": "Jean", "lastname": "Dupont","age": 30}
for key, value in data.items():
    print("la clé {0} contient la valeur {1}".format(key,value))

horaires = [
    {'film': 'Seul sur Mars', 'heure': 9},
    {'film': 'Astérix et Obélix Mission Cléopâtre', 'heure': 10},
    {'film': 'Star Wars VII', 'heure': 15},
    {'film': 'Time Lapse', 'heure': 18},
    {'film': 'Fatal', 'heure': 20},
    {'film': 'Limitless', 'heure': 20},
]

#à completer!

Créer un second dictionnaire d2 contenant les valeurs suivantes :

age: 22
firstname: "John"
adresse: "Paris"

#Fusionner le dictionnaire d1 dans d2

#TBD

# A l'aide d'une boucle for afficher à la fois la clé du dictionnaire d2 et sa valeur pour chaque élément

#TBD

# Supprimer la clé adresse du dictionnaire d2

#TBD

Les fonctions

Pourquoi utiliser des fonctions

Une fonction est un bout de code que l’on va définir afin d’être réutilisé. Pourquoi devrions-nous faire cela ? En programmation, nous cherchons à résoudre des problèmes, et comme nous l’avons vu en découvrant l’algorithmique très souvent nous pouvons découper un problème en plusieurs sous-problèmes à résoudre et cela nous aide à rendre le problème plus simple à résoudre. Une des premières utilité d’une fonction est donc de rendre le problème plus simple a résoudre en le découpant en sous problèmes. Cela a aussi l’avantage de rendre le code plus lisible en le découpant et en nommant les actions.

Si l’on se rappelle les notions d’algorithmique on a le programme suivant pour résoudre le problème de la cuisson des pâtes.

début
  remplir_casserole(eau)
  tant_que (eau_non_bouillante)
    chauffer_casserole(feu_max)
  fin_tant_que

  remplir_casserole(pâtes)
  tant_que (pâtes_non_cuites)
    chauffer_casserole(feu_vif)
  fin_tant_que

  égouter_pâtes
  servir_pâtes
fin

Chaque ligne de code peut être une fonction qu’il faut redécouper en actions plus précises. Par exemple chauffer_casserole(feu_vif) peut avoir plusieurs actions à réaliser comme ouvrir_robinet_gaz(70%), craquer_allumette(), approcher_allumette() et poser_casserole(). En utilisant chauffer_casserole(feu_vif) dans notre programme global on comprend directement ce qu’il y a lieu de faire. Grâce à cette fonction chauffer_casserole(feu_vif) on gagne en lisibilité.

En plus cette fonction peut être réutilisée à différents endroits en fonction des besoins et avec différents arguments. Ici pour faire bouillir l’eau, on l’utilise avec l’argument feu_max puis pour cuire les pâtes avec l’argument feu_vif. Si on voulait faire cuire une ratatouille, on pourrait l’utiliser avec l’argument feu_doux.

Définir et appeler des fonctions en Python

En Python, pour déclarer une fonction on procède de la manière suivante :

def definir_prenom():
    prenom = "Jules"

Cette fonction ne fait pas grand chose, elle déclare juste une variable prenom à l’intérieur de la fonction qui contiendra la chaîne de caractères Jules. On peut maintenant l’appeler dans la suite de notre programme.

def definir_prenom():
    prenom = "Jules"

definir_prenom()

Il ne se passera rien de bien intéressant mais nous avons défini notre première fonction !

Les fonctions deviennent intéressantes lorsque l’on :

def dire_bonjour(prenom):
    return "Bonjour " + prenom

# Ici on range le retour de la fonction dans la variable message_bienvenue
message_bienvenue = dire_bonjour("Jules")

Avec cette fonction, je peux maintenant générer des messages de bienvenue différents car dire_bonjour(prenom) prend en paramètre une chaîne de caractères nommée prenom et retourne la valeur “Bienvenue valeur de prenom”

On peut définir autant d’arguments que l’on veut (même si ça va vite devenir compliqué si une fonction dépasse 5 arguments) et on ne pourra retourner qu’une seule valeur de retour.

Pour plus de détails : La documentation officielle de Python

# on définit une fonction qui retourne 'autorisé ou 'Non Autorisé' pour particpier à une attraction

def controle(x):
    # Faire attention aux indentations pour indenifier la zone du code de la fonction
    if x < 120:
        print("La taille minimale pour l'attraction est de 150cm !") 
        return "Non Autorisé"
    elif x > 210:
        #print("Vous êtes trop grand, vous ne pouvez pas entrer !")
        return "Non Autorisé"
    else:
        return "Autorisé"
    
print(controle(170))

Application

Coder une fonction duplicate_last_item qui prend une liste en argument et qui lui rajoute le dernier élément.

par exemple si l = [1, 2, 3] après application de la fonction l doit être égale à [1, 2, 3, 3]

#TBD

#Interpréter ce code

l1 = ['a', 'b', 'c']
l2 = [1, 2, 3]

print(zip(l1, l2))
print(list(zip(l1, l2)))

Application

Coder une fonction Client qui prend en argument trois listes l1: les noms des clients d’un magasin et l2:les id des produits et l3: les prix de chaque produit. sachant que chaque client a acheté un seul produit -> la fct retourne une liste c avec c[i] = l1[i] + l2[i] + l3[i]

Vous pouvez utiliser la fonction zip

#TBD

Application

Coder une fonction multiply_liste qui prend en argument une liste et retourne une liste dont tous les éléments sont multipliés par un coefficient 𝛼 donné en argument

def multiply_list(l, alpha):
    #a completer
    
l = [1, 2, 3]
alpha = 2
multiply_list(l, alpha)

#Coder une fonction filter_even_values qui filtre toutes les valeurs paire d'une liste

def filter_even_values(l):
    #a completer
l = [1, 2, 3, 4, 5, 6]
filter_even_values(l)

Application

Coder la fonction is_adult qui affiche “mineur” si le nombre en entré est inférieur à 18, “adulte” si supérieur ou égale à 18 et inférieur à 65 et “senior” sinon


#TBD

Application

Faire une fonction qui prend un nombre en argument et qui retoure sa racine carrée (usuellement notée sqrt pour “square root”). Pour cela on pourra aller rechercher comment importer un module (une librairie) en python et import la librairie que vous jugez utile !


#TBD

Application

coder la fonction average qui prend en argument une liste de nombre et qui retourne la moyenne de celle-ci. On utilisera une boucle for obligatoirement

#TBD

Application

Faire une fonction reverse_string qui prend en argument une chaîne de caractère et qui retourne la chaîne retournée.

#TBD

Les_fonctions_recursives

Une fonction récursive est une fonction qui s’appelle elle-même et ce processus est appelé récursivité/récursion de fonction.

Par exemple, calculons la fct factorielle d’un nombre, par exemple, 6.

6 * 5 * 4 * 3 * 2 * 1

def fact(n):
    """Recursive function to find factorial"""
    if n == 1:
        return 1
    else:
        return (n * fact(n - 1))
a = 6
print("Factorial of", a, "=", fact(a))

Application

Ecrire une fonction Python récursive positif_number() qui impose à l’utilisateur de saisir un entier positif.

si l’entier saisi est négatif , on redemande à l’utilisateur un autre entier.

#TBD

Les Exceptions

il y a au moins deux types d’erreurs à distinguer : les erreurs de syntaxe et les exceptions.

Try except

Try signifie “essayer”, ce mot clé permet d’essayer une action et si l’action échoue on peut lui donner d’autres instructions dans un bloc except àfin d’éviter un arret brusque et non controlé de notre application .

https://docs.python.org/fr/3.5/tutorial/errors.html

v = 0
w = 5
#w/v
try:
    w/v
    print("Ok pas erreur")
except:
    print("Erreur")


v = "test"
w = 5
try:
    w/v
    print("Ok pas erreur")
except TypeError:
    print("Merci d'utiliser des chiffres")
except ZeroDivisionError:
    print("Merci de ne pas utiliser le 0")



try:
    pass 
except:
    pass
finally:
    print("Execution")

La Reference complete est ici

Entrées / Sorties

Lorsque l’on exécute un programme, on peut avoir besoin de lui fournir des données en entrée ou bien d’en récupérer en sortie. Plusieurs méthodes existent et nous allons en explorer deux : en utilisant la console et les fichiers.

Console

La console (ou terminal) est une interface en ligne de commande qui permet de dialoguer avec notre machine en lui écrivant des instructions et en lisant les retours faits une fois les instructions réalisées. Lorsque nous écrivons un programme Python dans un fichier et que nous lançons ce programme via la console, les instructions du programme s’enchaîne et on reprend la main sur la console lorsque toutes les instructions du programme sont terminées. On pourrait avoir envie d’afficher des informations lors de la réalisation du programme et aussi de demander à l’utilisateur d’en saisir.

Pour afficher quelque chose dans la console, il suffit d’utiliser l’instruction print().

Pour récupérer une entrée utilisateur, il suffit d’utiliser la fonction input().

def dire_bonjour(prenom):
    return "Bonjour " + prenom

prenom_utilisateur = input("Bonjour, comment t'appelles-tu ? ")

print(dire_bonjour(prenom_utilisateur))

Fichiers

Parfois nous aurons aussi besoin de lire ou d’écrire dans des fichiers. Dans les deux cas, il faudra ouvrir le fichier et lire ou écrire dedans.

Pour ouvrir un fichier il faut utiliser la fonction open() et lui donnant en argument l’emplacement du fichier et le mode (façon dont on va utiliser le fichier). Pour le mode, on peut utiliser 'r' pour lire, 'w' pour écrire, ‘a’ pour écrire à la fin ou ‘r+’ pour lire et écrire.

Lire

Ci dessous un exemple de lecture de la première ligne d’un fichier markdown. On utilisera la fonction readline() pour récupérer le contenu d’une ligne du fichier que nous souhaitons lire.

f = open('cours.md', 'r')
print(f.readline())
f.close()

Si l’on veut lire toutes les lignes du fichier on peut écrire le code suivant :

f = open('test.txt', 'r')

for line in f:
    print(line)

f.close()

Dans cet exemple, il est important de noter que l’on ouvre le fichier avant de lire ses lignes et une fois la lecture terminée, on le ferme avec la fonction close(). On peut simplifier ce fonctionnement grâce à l’instruction with qui fermera automatiquement le fichier pour nous :

with open('test.txt', 'r') as f:
    for line in f:
        print(line)

print('end')

Ecrire

Ci dessous un exemple d’écriture d’une ligne dans fichier texte. On utilisera la fonction write() pour écrire du contenu dans un fichier.

f = open('./output.txt', 'w')
f.write('Mon premier fichier écrit en Python')
f.close()

Modules et Packages

On regroupe des fonctions dans un fichier (ou aussi script) python, on crée un ensemble de fonctions que l’on nomme “ module “.

Lorsque l’on cherche à regrouper des modules, on parle de package .

Les modules de python

Voici une liste de modules de base que vous serez amené un jour ou l’autre à utiliser.

Les Packages Pour créer votre propre package, il faut créer dans le même dossier que votre programme - un dossier portant le nom de votre package. par exmple “ utils “.

Dans ce dossier, créer le fichier : init.py , cela indique à python qu’il s’agit d’un package . Ce fichier peut être vide, seule sa présence est importante.

Ensuite créer un fichier toujours dans ce réportoire utils avec votre code d’application python exemple: “ operations.py “

project_folder

et dans utils:

utils

Afin d’accéder et d’utiliser les différents fichier du projet à partir du fihcier fiche.py il faut déclarer les modules

from func import *
from utils.operations import ajoute_deux

La Reference complete est ici