RENSEIGNEMENTS
Tel : 06 83 10 82 97
e-mail: mdr at irif.fr
Michel de Rougemont

edit SideBar

• View
• Edit
• History
• Print

Intro

Objectif du cours

L'objectif de ce cours consiste à faire de l'analyse de données web en utilisant le langage Python.

En particulier, nous allons nous intéresser à une technique d'apprentissage supervisé afin de :

- Regrouper les acheteurs par types.
- Prédire le nombre de ventes d'un nouveau produit.
- Prédire les tendances d'achat.

Langage Python

Python est un langage moderne, multi-objectif et de haut niveau. Depuis quelques années, il suscite un grand engouement. Il s'agit d'un langage :

- rapide, multi-paradigme (programmation fonctionnelle/procédurale/objet) ;
- permet de traiter différents types de problèmes, de différentes tailles : gestion de base de données, déploiement de sites web, développement de jeux, gestion de fichiers, calcul scientifique, etc;
- possède une énorme bibliothèque de modules prêts à l'emploi ;
- gratuit.

Notions de base

Variables

Les noms de variables peuvent être de taille illimitée. On utilise les conventions suivantes :

- noms de variables en minuscule ;
- noms de classe en Camel style (première lettre du mot en majuscule) ;
- on évite d'utiliser les mots clé du langage.

class IntrumentsAVent():

    def __init__(self, nom):
        self.instrument = nom

 # variable

variable_pour_stocker_des_trucs_variables = 2
flute = IntrumentsAVent("flute traversiere")

Liste des mots-clé réservés du langage

import pprint
import keyword
print(keyword.kwlist)

['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

Affectation, suppression, type, etc

 # affectation

a = 1

 # affectation multiple

b, c, d = True, 8.3, "une chaîne de caractères"

print("a = ", a)
print("b = ", b)
print("c = ", c)
print("d = ", d)

a = 1
b = True
c = 8.3
d = une chaîne de caractères

 # types 

print("type(a) = ", type(a))
print("type(b) = ", type(b))
print("type(c) = ", type(c))
print("type(d) = ", type(d))

type(a) = <class 'int'>
type(b) = <class 'bool'>
type(c) = <class 'float'>
type(d) = <class 'str'>

Python propose un typage dynamique :

a = 1
print("a=1", type(a))
a = a + 0.0
print("a=a+0.0", type(a))
a = 'a'
print("a='a'", type(a))

a=1 <class 'int'>
a=a+0.0 <class 'float'>
a='a' <class 'str'>

 # suppression

del a, b, c, d

Les structures de données

Les structures de données standard sont : list, dict, tuples, sets, strings.

Listes

Elles permettent d’agréger un ensemble de données hétérogènes. Les éléments peuvent être de n'importe quel type et de types différents entre eux.

 # listes -- entre crochets

ma_liste = [1, 2, "texte", ['a', 'b', 'c'], "tralala", 9, 8, 7, 6, 5]
print(ma_liste)

[1, 2, 'texte', ['a', 'b', 'c'], 'tralala', 9, 8, 7, 6, 5]

Les éléments sont indexés à partir de 0. Dans le cas d'un index négatif, la liste est parcourue à partir de la fin.

print("Element 0 : ", ma_liste[0])
print("Element 3 : ", ma_liste[3])
print("Element -3 : ", ma_liste[-3])
print("Element -1 : ", ma_liste[-1])

Element 0 : 1
Element 3 : ['a', 'b', 'c']
Element -3 : 7
Element -1 : 5

ma_liste[3][-1]

'c'

Slicing

import numpy as np
x = np.random.randint(10, size=100)
print(x)
print("Les 10 premières valeurs : ", x[0:10])
print("Les 10 dernières valeurs : ", x[-1:-11:-1])
print("Les 10 premières valeurs, par pas de 2 : ", x[0:20:2])
print("Les valeurs x>7 : ", x[x > 7])
print("avec les indices correspondants", np.where(x > 7))
print("*" * 60)

[3 5 1 2 7 1 8 4 9 9 0 9 5 8 7 8 4 8 4 6 5 6 4 7 3 2 8 2 3 6 3 6 6 8 4 8 4

 9 9 3 7 9 2 5 4 6 7 1 1 3 7 7 5 2 2 3 9 1 8 3 7 4 9 8 0 4 4 0 9 1 6 1 1 9
 5 1 0 9 5 5 0 0 9 6 9 8 7 1 7 1 2 8 3 3 3 3 1 9 4 0]

Les 10 premières valeurs : [3 5 1 2 7 1 8 4 9 9]
Les 10 dernières valeurs : [0 4 9 1 3 3 3 3 8 2]
Les 10 premières valeurs, par pas de 2 : [3 1 7 8 9 0 5 7 4 4]
Les valeurs x>7 : [8 9 9 9 8 8 8 8 8 8 9 9 9 9 8 9 8 9 9 9 9 9 8 8 9]
avec les indices correspondants (array([ 6, 8, 9, 11, 13, 15, 17, 26, 33, 35, 37, 38, 41, 56, 58, 62, 63,

       68, 73, 77, 82, 84, 85, 91, 97]),)

************************************************************

Cela fonctionne aussi pour des listes quelconques :

print("Bien entendu, ça fonctionne pour des listes quelconques \n")
liste_legumes = [

    "Ail", "Artichaut", "Asperge blanche", "Asperge verte", "Aubergine",
    "Bette", "Betterave rouge", "Brocoli", "Carotte", "Catalonia", "Céleri",
    "Céleri branche", "Céleri rave", "Chou blanc", "Chou de Bruxelles"
    "Chou frisé", "Chou Romanesco", "Chou rouge", "Chou-chinois", "Chou-fleur",
    "Chou-rave", "Cima di Rapa", "Citrouille", "Concombre", "Courge",
    "Courgette", "Endive", "Epinard", "Fenouil", "Haricot", "Laitue romaine",
    "Mâche", "Maïs", "Navet", "Oignon", "Panais", "Pâtisson",
    "Petit oignon blanc", "Petit pois", "Poireau", "Pois mange-tout",
    "Poivron", "Pomme de terre", "Potimarron", "Potiron", "Radis",
    "Radis long", "Rhubarbe", "Salsifis", "Topinambour"

]
print("Un légume sur 5 : ", liste_legumes[::5])
print()
print("Les 7 derniers légumes : ", liste_legumes[-8:-1])

Le résultat est :

Bien entendu, ça fonctionne pour des listes quelconques

Un légume sur 5 : ['Ail', 'Bette', 'Céleri', 'Chou Romanesco', 'Cima di Rapa', 'Endive', 'Mâche', 'Pâtisson', 'Poivron', 'Radis long']

Les 7 derniers légumes : ['Pomme de terre', 'Potimarron', 'Potiron', 'Radis', 'Radis long', 'Rhubarbe', 'Salsifis']

Tuples

Les tuples sont du même style qu'une liste, mais sont immutables, ce qui veut dire qu'on ne peut pas les modifier après leur création (on ne peut pas modifier un élément, en ajouter, etc). La raison de l'existence de ce type et de son caractère immutable est une question d'efficacité d'implantation et de stockage mémoire.

Un tuple est désigné par des parenthèses et une énumération séparée par des virgules.

t = ('truc', 2, [1, 2, 3])
print(type(t))

<class 'tuple'>

En réalité les parenthèses ne sont pas nécessaires :

t = 'truc', 2, [1, 2, 3]
print(type(t))
print('t[2]=', t[2])

<class 'tuple'>
t[2]= [1, 2, 3]

Dictionnaires

Les dictionnaires sont formés par une liste de clés et valeurs associées. Les clés peuvent être de n'importe quel type, et les valeurs aussi. On peut même avoir des valeurs qui soient d'autres dictionnaires. Le constructeur est dict.

 #un dico

d = dict()
d['clé'] = "valeur"
print('dico d:', d)
e = {'un truc': 'une valeur', "a": 247, "c": {}}
print('dico e["a"]:', e['a'])
f = dict([(1, "aa"), (2, "bb"), (3, "cc"), ("clé", e)])
print('dico f[2]:', f[2])
print("dico f['clé']['a']:", f['clé']['a'])

dico d: {'clé': 'valeur'}
dico e["a"]: 247
dico f[2]: bb
dico f['clé']['a']: 247

w=dict()
w['k']= ['a', 'b']
w

{'k': ['a', 'b']}

Ensembles

Avec le type set, on peut faire des opérations d'union, d'intersection, de compléments etc. Cela peut également être pratique pour ne conserver que les éléments uniques.

avent=set(['1', 'flute', 'trompette',2])
acordes=set(['violon', 2, 'guitare', 'piano'])
instruments=avent.difference(acordes)
print(instruments)

{'flute', '1', 'trompette'}

set([1, 1, 3, 'a', 'a'])

{1, 3, 'a'}

Les structures de contrôle

for

En python, on n'itère pas seulement sur des nombres, mais sur un peu tout ce qui est itérable.

print("--> Itération sur une liste de nombres")
for x in "chaine de caractères":
print(x, end=', ')
print('\n ok')
#
print(x)

 --> Itération sur une liste de nombres

c, h, a, i, n, e, , d, e, , c, a, r, a, c, t, è, r, e, s,
ok
s

 # Pour itérer sur une liste régulière de nombres, on utilisera `range`

for nb in range(20):
print(nb, end=', ')

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,

chaine = "Bonjour tout le monde"
for lettre in chaine:
print(lettre)

 --> Itération sur un dictionnaire

clé2, 22, clé, ok

 # print("--> Itération sur les valeurs d'un dictionnaire")

for element in {22:12, "clé":"des_champs", "clé2":"des_rêves",}.values():

    print(element, end=', ')

print('ok')

 #

 --> Itération sur les valeurs d'un dictionnaire

des_rêves, 12, des_champs, ok

 # print("--> Itération sur une chaîne de caractères...")

for element in "voici une chaîne de caractères pour essayer":

    print(element, end=', ')

print('ok')

 # 

 --> Itération sur une chaîne de caractères...

v, o, i, c, i, , u, n, e, , c, h, a, î, n, e, , d, e, , c, a, r, a, c, t, è, r, e, s, , p, o, u, r, , e, s, s, a, y, e, r, ok

 # print("--> Itération sur un fichier")
 # with open("test.txt",'rt') as f:
   #  for element in f.readlines():
     #    print(element[:-1])
    # print('ok')  



 --> Itération sur un fichier

ceci est un texte
- rapide
- et concis
pour faire une
mini démonstration
ok

if

Comme dans les langages courants, le if sert à faire des exécutions conditionnelles. On dispose d'une clause else et même d'un elif, contraction de else if. Pas de then. Indentation pour identifier les blocs.

 # Programme testant si une année, saisie par l'utilisateur, est bissextile ou non

annee = input("Saisissez une année : ")
annee = int(annee)
bissextile = False \\ if annee % 400 == 0:
bissextile = True
elif annee % 100 == 0:
bissextile = False
elif annee % 4 == 0:
bissextile = True
else:
bissextile = False
if bissextile: # Si l'année est bissextile
print("L'année saisie est bissextile.")
else:
print("L'année saisie n'est pas bissextile.")

x=-3
if x>=0 and x%2 : # deux tests à la fois combinés
print("x est à la fois positif et impair")
elif x<0:
print("x est négatif")
else:
print("x est positif et pair" )

x est négatif

Les structures en intention

Vous voulez fabriquer une liste qui contienne les longueurs des mots de ce texte, si leur longueur est supérieure à 4 caractères. Cela ne sert à rien, c'est pour expliquer.

texte="""Vous voulez fabriquer une liste qui contienne toutes les lettres si les mots de ce texte, si leur longueur est supérieure à 4 caractères. Cela ne sert à rien, c'est pour expliquer. """

tri=[(mot) for mot in texte.split() if len(mot)>4]
print(tri)

['voulez', 'fabriquer', 'liste', 'contienne', 'toutes', 'lettres', 'texte,', 'longueur', 'supérieure', 'caractères.', 'rien,', "c'est", 'expliquer.']

while

Structure classique: tant que condition, faire. Exemple :

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)
i += 1 # Dans le cas classique on ajoute juste 1 à i

Exercice

Définir la liste : liste = [4, 9, 10, 22, 42], puis effectuez les actions suivantes :

– triez et affichez la liste ;
– ajoutez l’élément 12 à la liste et affichez la liste ;
– renversez et affichez la liste ;
– affichez l’indice de l’élément 4 ;
– enlevez l’élément 9 et affichez la liste ;
– affichez la sous-liste du 2ème au 3ème élément ;
– affichez la sous-liste du début au 2ème élément ;
– affichez la sous-liste du 3ème élément à la fin de la liste ;
– affichez la sous-liste complète de la liste ;
– affichez le dernier élément en utilisant un index négatif.