Python2_c2 [Mode de compatibilité] - Polytech Nice Sophia

Un peu plus sur chaînes
Programmation Langage de
script : PYTHON
Rappel : Les chaînes de caractères constituent un type de donnée
composite, c'est-à-dire une entité faite elle-même d'un ensemble
d'entités plus petites (caractères).
Nous pouvons traiter ces données tantôt comme un seul objet,
tantôt comme une suite ordonnée d'éléments.
Ce sont des séquences (dont font partie aussi les listes)
Niveau 2
Concaténation / Répétition : + ou *
Indiçage ([]), Extractions ([:-1]),
longueur ( méthodes len()) …
Parcours d'une séquence (instruction for … in …)
Formatage des chaînes de caractères
Les chaînes de caractères ne sont pas modifiables
(Création d'une nouvelle chaîne à chaque fois)
2
1
Le module string
Le module string
le module string contient de nombreux outils de traitement des
chaînes de caractères:
Voici quelques exemples de fonction du module string:
s.split([sep]) Convertit une chaîne en une liste de sous-chaînes
(caractère séparateur = espace par défaut)
Ces nombreuses fonctions vont vous simplifier le travail lors de la
récupération ou le traitement de fichiers de données.
>>> c2="Votez pour moi"
>>>a=c2.split()
>>>print(a)
["Votez","pour","moi"]
>>>c4="Cet exemple, parmi d'autres, peut servir"
>>>print(c4.split(","))
["Cet exemple", "parmi d'autres","peut servir"]
Pour consulter la liste des fonctions disponibles, aller sur le site de
python:
http://docs.python.org/lib/string-methods.html
sep.join(liste) Rassemble une liste de chaînes en une seule chaine de
caractères
Plus besoin d'importer le module dans les versions récentes de
python
3
>>>b2=["Salut","les","copains"]
>>>print(" ".join(b2))
Salut les copains
>>>print("---".join(b2,))
Salut---les---copains
4
1
Le module string
s.find(sch)
Le module string
s.lower()
cherche la position d'une sous-chaîne dans la chaîne
s.count(sch)
compte le nombre de sous-chaînes sch dans la chaîne
>>>ch1="le héron au long bec emmanché d'un long cou"
>>>ch2="long"
>>>print(ch1.count(ch2))
2
s.upper()
convertit une chaîne en majuscules
s.swapcase()
versa
convertit toutes les majuscules en minuscules et vice-
>>> ch4="La CIGALe et LA FourMi"
print(ch4.swapcase())
lA cigalE ET la fOURmI
s.index(c, [pos])
retrouve l'indice de la première occurrence
du caractère c dans la chaîne
>>> ch3="Portez ce vieux whisky au juge blond qui fume"
>>>print(ch3.index("w"))
16
>>> print(ch3.index("e",5)) cherche seulement à partir
8
convertit une chaîne en minuscules
>>> ch="ATTENTION : Danger !"
>>>print(ch.lower())
attention : danger !
>>>ch1="Cette leçon vaut bien un fromage, sans doute ?"
>>>ch2="fromage"
>>>print(ch1.find(ch2))
25
s.replace(c1,c2)
remplace tous les caractères c1 par des
caractères c2 dans la chaîne
>>> ch5="Si ce n'est pas toi c'est donc ton frère"
>>>print(ch5.replace(" ","*"))
Si*ce*n'est*pas*toi*c'est*donc*ton*frère
de l'indice 5
5
Le module string
6
Les chaînes sont des objets Rappel
s.strip()
renvoie une chaîne de caractères avec la suppression
des espaces avant et après.
Appartenance d'un élément à une séquence
>>> tutu=" \tBonjour, voici une chaine \t \n"
>>> print(tutu)
Bonjour, voici une chaine
L'instruction in peut être utilisée indépendamment de for, pour
vérifier si un élément donné fait partie ou non d'une séquence.
>>> tata=tutu.strip()
>>> print(tata)
Bonjour, voici une chaine
>>>
>>>car="e"
>>>voyelles="aeiouyAEIOUY"
>>>if car in voyelles:
print(car, "est une voyelle")
Renvoie un <Bool> True or False
Il existe bien sur d'autres fonctions associées au module string
../..
7
8
2
Un peu plus sur les listes
Un peu plus sur les listes: méthodes
Nous savons comment modifier un de ses éléments, mais il est aussi
parfois très pratique d'en remanier la taille (e.g. ajouter, insérer ou
supprimer un ou plusieurs éléments etc...). Les listes possèdent pour
ça des méthodes:
Rappel : Une liste est une structure de données qui contient une
série de valeurs.
>>>toto=[]
>>>mix = ['girafe',5.0,'dahu',2]
>>>Mix[1]
5.0
>>>Mix[-2]
'dahu'
>>>Mix[1:3]
[5.0,'dahu']
Création d'une liste vide
Différents types acceptés
Notion d'indiçage
list.append(element) : ajoute un élément à la fin de la liste.
>>> x = [1,2,3]
>>> x.append(2239)
>>> x
[1, 2, 3, 2239]
Indiçage négatif
Sélection d'une partie
del liste[indice] : supprime un élément à la position indice de la
liste.
Outils particuliers :
>>>range(0,10)
>>>len(Mix)
Création d'une liste de taille 10
Longueur de la liste
>>> del x[1]
>>> x
[1, 3, 2239]
Utilisation de listes de listes
>>>Mix[0][1]
'i'
9
Un peu plus sur les listes: méthodes
Un peu plus sur les listes : exemple
Exemple: Ecrivez un script qui recopie une chaîne (dans une nouvelle
variable) en l'inversant. ("program" -> "margorp").
On peut l'améliorer grâce aux méthodes des listes et des chaînes de
caractères:
list.insert(indice,objet) : insère un objet dans une liste avant
l'indice.
>>> x.insert(2,-15)
>>> x
[1, 3, -15, 2239]
Solution 1:
chaine="zorglub"*500000
newchaine=""
i=len(chaine)-1
while i >=0:
newchaine=newchaine+chaine[i]
i=i-1
print(newchaine)
list.sort() : tri la liste. (Attention au mélange de type !)
>>> x.sort()
>>> x
[-15, 1, 3, 2239]
list.reverse() : inverse la liste.
>>> x.reverse()
>>> x
[2239, 3, 1, -15]
list.index(objet) : retrouver l'indice d'un élément.
>>> x.index(-15)
3
10
11
Pb: si on traire une chaîne de
milliers de caractères : coûteux en
temps de calcul !
Tps= 7.20s
Solution 2:
chaine="zorglub"*500000
listch=[]
i=len(chaine)-1
while i >=0:
listch.append(chaine[i])
i=i-1
newchaine="".join(listch)
print(newchaine)
Plus rapide si chaîne longue !
Tps=1.53s
12
3
Un peu plus sur les listes
Attention copie de listes
Rappel : Les listes sont modifiables et une liste remaniée n'est pas
renvoyée. (directement modifiée)
Il est très important de savoir que l'affectation d'une liste (à partir
d'une liste préexistante) crée en réalité une référence et non une
copie :
La méthode append est particulièrement pratique car elle permet de
construire une liste associée à une boucle.
Par exemple, si on veut convertir une chaîne de caractères en liste on
peut utiliser quelque chose de la forme :
>>> x = [1,2,3]
>>> y = x
>>> y
[1, 2, 3]
>>> x[1] = -15
>>> y
[1, -15, 3]
>>> seq = "CAAAGGTAACGC"
>>> seq_list = []
>>> for i in seq:
seq_list.append(i)
Vous voyez que la modification de x modifie aussi y. Techniquement,
Python utilise des pointeurs (la nouvelle liste pointe sur l'adresse
machine de l'ancienne liste) vers les mêmes objets et ne crée pas de
copie à moins que vous n'en ayez fait la demande explicitement.
>>> seq_list
['C', 'A', 'A', 'A', 'G', 'G', 'T', 'A', 'A', 'C', 'G', 'C']
Remarquez que l'on peut utiliser directement la fonction list(seq) qui
prend n'importe quel objet séquentiel (liste, chaîne de caractères,
etc...) et qui renvoie une liste.
13
>>> x = [1,2,3]
>>> y = x[:]
>>> x[1] = -15
>>> y
[1, 2, 3]
Attention copie de listes
Notion de pointeurs
Pour le vérifier, on peut utiliser la fonction id() qui renvoie un
objet correspondant à la position en mémoire d'une variable:
Principe :
>>> fable=["Je","plie","mais","ne","romps","point"]
>>> phrase=fable
>>> fable[4]="casse"
>>> phrase
["Je","plie","mais","ne","casse","point"]
>>> x = [1,2,3]
>>>id(x)
30872064
>>> y = x
>>> y
[1, 2, 3]
>>> id(y)
30872064
>>> z = x[:]
>>> id(z)
31022472
14
fable
>>> x[1] = -15
>>>x
[1, -15, 3]
"Je" "plie" "mais" "ne" "romps" "point"
phrase
fable[4]="casse"
>>> z
[1, 2, 3]
fable
"Je" "plie" "mais" "ne" "casse" "point"
15
phrase
16
4
Notion de pointeurs
Importation de modules
>>> fable=["Je","plie","mais","ne","romps","point"]
>>> phrase=fable[:]
>>> fable[4]="casse"
>>> phrase
["Je","plie","mais","ne", "romps","point"]
Il existe des questions tellement courantes qu'il serait peu productif
de les réécrire à chaque fois des fonctions correspondantes. Les
programmes qui les résolvent sont souvent fournis avec le langage de
programmation dans des bibliothèques de fonctions (librairies).
"Je" "plie" "mais" "ne" "romps" "point"
fable
En Python, un telle bibliothèque est constituée de nombreux modules
et un module est constitué de plusieurs fonctions (ou procédures)
déjà programmées.
"Je" "plie" "mais" "ne" "romps" "point"
phrase
fable[4]="casse"
fable
"Je" "plie" "mais" "ne" "casse" "point"
phrase
"Je" "plie" "mais" "ne" "romps" "point"
17
Importation de modules
18
Importation de modules
Dans un module, on prend soin de regrouper les fonctions qui
permettent de gérer un type de problème donné, bien souvent ce
sont simplement les opérations associées à une structure de données
adaptée au problème.
La plupart de ces modules sont déjà installés dans les versions
standards de Python, voir
http://docs.python.org/3/py-modindex.html
On va avoir des modules pour des calculs mathématiques, la gestion
de nombre aléatoire, des modules graphiques etc…
Exemple: le module random (tirage aléatoire)
Il faudra ne pas oublier en début du script d'importer les modules
nécessaires à la résolution de notre problème. Un module est
constitué:
De variables comme des listes, des chaines de caractères, des
dictionnaires… module.variable
De fonctions et des procédures déjà programmées module.fonction()
19
>>> import random
>>> random.randint(0,10)
9
L'instruction import vous permet d'importer toutes les fonctions du
module random.
Ensuite, nous utilisons la fonction randint() du module random.
Notation: objet random.randint (la fonction randint est considérée
comme une méthode de l'objet random, comme f.close() avec les
fichiers).
20
5
Importation de modules
Module math
Le module math contient les définitions de nombreuses opérations
mathématiques telles que sinus, cosinus, tangente, racine carré, etc…
>>> random.randint(0,100)
52
>>> random.uniform(0,3.1415926535897931)
1.3634213820695191
Exemple:
On peut ainsi utiliser toutes ses fonctions, par exemple shuffle, qui
permute une liste aléatoirement, choice, sample, etc…
>>> x = [1,2,3,4,5,6,8,9,10]
>>> random.shuffle(x)
>>> x
[1, 4, 8, 10, 3, 5, 9, 6, 2]
>>> random.shuffle(x)
>>> x
[6, 9, 5, 10, 8, 3, 4, 1, 2]
>>> random.choice(x)
5
>>>
>>> random.sample(x, 3)
[9, 2, 4]
import math
nombre=121
angle=math.pi/6
print("racine carre de ", nombre, "=", math.sqrt(nombre))
print("sinus de ", angle, "radians =", math.sin(angle))
print(math.sqrt(121))
21
22
Module turtle (rigolo !)
Module turtle (rigolo !)
Module Python qui permet de réaliser des "graphiques tortue", c'està-dire des dessins correspondant à la trace laissée par la "tortue
virtuelle". Exemple:
import turtle
turtle.forward(120)
turtle.left(90)
turtle.color("red")
turtle.backward(10)
turtle.reset()
# avancer d'une distance donnée
# Tourner à gauche d'un angle donné (en degré)
# couleur
# reculer
# effacer tout
Exemple:
import turtle
import random
color=["red","green","blue","black","yellow"]
turtle.reset()
a=0
while a <12:
a=a+1
turtle.color(random.choice(color))
turtle.forward(150)
turtle.left(150)
Etc… voir http://www.python.org/doc/current/lib/module-turtle.html
input("taper sur entree pour terminer")
23
24
6
Importation modules perso
Importation modules perso exemple
On peut même écrire soi-même des modules. Lorsque l’on veut écrire
un gros logiciel, c’est généralement une bonne idée de le découper en
modules (qui seront du même coup réutilisables par ailleurs).
Il suffit alors d’importer les modules pour utiliser les fonctions qui y
ont été programmées.
Pour créer un module, il suffit de programmer les fonctions qui le
constituent dans un fichier portant le nom du module, suivi du suffixe
« .py ».
Depuis un (autre) programme en Python, il suffit alors d’utiliser la
commande import pour pouvoir utiliser ces fonctions.
25
Importation modules perso exemple
26
Gestions des exceptions
Les exceptions sont les opérations qu'effectue un interpréteur ou un
compilateur lorsqu'une erreur est détectée au cours de l'exécution
d'un programme. L'exécution du programme est interrompue et un
message d'erreur s'affiche:
Librairie HeliQuest
>>> print(55/0)
Traceback (most recent call last):
File "<pyshell#25>", line 1, in -toplevelprint(55/0)
ZeroDivisionError: integer division or modulo by zero
Il est possible de prévoir à l'avance certaines erreurs qui risque de
se produire à tel ou tel endroit du programme, et d'inclure à cet
endroit des instructions particulières qui seront activées seulement
si l'erreur se produit.
Instructions try – except - else
27
28
7
Gestions des exceptions
Gestions des exceptions
Exemple: Ne pas planter si le fichier n'est pas au bon endroit
try :
file=input("Entrez un nom de fichier:")
try:
f=open(file,"r")
except:
print("Le fichier", file, "est introuvable")
bloc d'instructions
except:
bloc instruction
Le bloc d'instructions qui suit directement try est exécuté par
Python sous réserve.
Si une erreur survient, Python annule l'instruction et exécute à sa
place le code inclus dans le bloc qui suit l'instruction except.
Si aucune erreur s'est produite dans les instructions qui suivent try,
c'est le bloc qui suit l'instruction else qui est exécuté (facultatif).
29
Autre exemple:
an=input("Entrez une annee: ")
try:
an=int(an)
print(an)
print("Merci")
except:
print("Vous n'avez pas entre une annee")
print("c'est pas gentil")
t=input("Tapez sur Entree pour terminer")
else:
print("Fin du programme")
print("je peux faire plein de chose avec cette variable")
t=input("Tapez sur Entree pour terminer")
Un peu plus les dictionnaires
Exemple
30
Un peu plus les dictionnaires
En créant une liste de dictionnaires possédant les mêmes clés, on
accède à leur intérêt principal (qui pourrait rappeler les bases de
données) :
>>> disque1
{'style': 'Trash Metal', 'author': 'Pantera', 'name': 'Far beyond driven', 'year': 2000}
>>> disque2
{'style': 'Rock Pop', 'author': 'U2', 'name': 'War', 'year': 1983}
Les méthodes keys et values renvoient les clés et les valeurs d'un
dictionnaire (sous forme d'un objet dict_keys) :
>>> disque1.keys()
dict_keys(['style', 'author', 'name', 'year'])
>>> disque1.values()
dict_values(['Trash Metal', 'Pantera', 'Far beyond driven', 2000])
>>> discotheque = [disque1,disque2]
>>> discotheque
[{'style': 'Trash Metal', 'author': 'Pantera', 'name': 'Far beyond driven', 'year': 2000}, {'style':
'Rock Pop', 'author': 'U2', 'name': 'War', 'year': 1983}]
>>> for i in discotheque:
print(i['author'] )
Pantera
U2
Pour vérifier si une clé existe, vous pouvez utiliser:
>>> if "style" in disque2:
print("la cle style existe dans le dico")
la cle style existe dans le dico
31
32
8
Modules lié à Internet (! python 3)
Modules lié à Internet
Les URL (Universal Ressource Locator) sont des chaînes, ressemblant
par exemple à : http://www.python.org .
Des modules, urllib, urllib.request, urlparse fournissent des outils
pour manipuler les url. (attention aux versions de Python !)
urllib définit quelques fonctions pour créer des programmes destinés
à être des utilisateurs actifs du Web.
Par exemple:
urlopen(url) ouvre en lecture un objet réseau auquel une URL fait
référence.
>>>import urllib.request
>>>page=urllib.request.urlopen("http://www.python.org")
>>>page.readline()
'<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"\n'
33
Module lié à l'OS
Exemple
import urllib.request
u=urllib.request.urlopen("http://www.pdb.org/pdb/files/1BTA.pdb")
pdblines=u.readlines()
u.close()
for ligne in pdblines:
print(ligne[:-1].decode("utf8") [:-1])
HEADER
COMPND
SOURCE
SOURCE
EXPDTA
AUTHOR
REVDAT
JRNL
JRNL
JRNL
JRNL
JRNL
RIBONUCLEASE INHIBITOR
09-MAY-94
1BTA
BARSTAR (NMR, MINIMIZED AVERAGE STRUCTURE)
(BACILLUS AMYLOLIQUEFACIENS) RECOMBINANT FORM EXPRESSED IN
2 (ESCHERICHIA COLI)
NMR
M.J.LUBIENSKI,M.BYCROFT,S.M.V.FREUND,A.R.FERSHT
1
31-JUL-94 1BTA
0
AUTH
M.J.LUBIENSKI,M.BYCROFT,S.M.V.FREUND,A.R.FERSHT
TITL
THREE-DIMENSIONAL SOLUTION STRUCTURE AND ==13==C
TITL 2 ASSIGNMENTS OF BARSTAR USING NUCLEAR MAGNETIC
TITL 3 RESONANCE SPECTROSCOPY
REF
TO BE PUBLISHED
1BTA
1BTA
1BTA
1BTA
1BTA
1BTA
1BTA
1BTA
1BTA
1BTA
1BTA
1BTA
…/…
2
3
4
5
6
7
8
9
10
11
12
13
34
Module lié à l'OS
Module OS
Le module os est la principale interface avec le système
d'exploitation. Il offre un accès générique au système ainsi qu'une
interface indépendant de la plateforme.
Possibilités beaucoup plus limitées sous windows (!= Linux):
>>>import os
>>> os.getcwd()
Création de répertoire (à partir du répertoire courant)
>>>os.mkdir("TITITI")
Suppression de fichier
>>>os.remove("Fichier")
Suppression d'un répertoire (doit être vide)
>>>os.rmdir("TITITI")
'C:\\Enseignements\\EPU\\Python1EPU'
Renommer un fichier ou un repertoire
>>>os.rename(source, destination)
Notez le \\ comme séparateur sous windows.
>>> chemin=os.chdir("E:\\Enseignements")
Attention : pas de demande de confirmation
Fait de c:\\Enseignements le répertoire courant.
>>> os.getcwd()
'E:\\Enseignements'
>>>os.listdir(chemin)
Renvoie une liste contenant les noms de tous les fichiers et sous
répertoire de Chemin. (ordre quelconque).
35
>>> os.curdir
'.'
>>> os.sep
'\\'
# chaine représentant le répertoire courant
# séparateur des composants d'un chemin
36
9
Module : re
Module : re
Le module re vous permet d'utiliser des expressions régulières au sein
de Python.
Les expressions régulières sont de très puissants outils de
manipulation de texte et de données. C'est une sorte de "minilanguage" de programmation qui permettent de décrire et de "parser"
du texte. Exemple sous Windows : *.txt l'étoile signifie "remplace
n'importe quoi"
La fonction search vous permet de rechercher un 'pattern' au sein
d'une chaîne de caractères avec une syntaxe de la forme
search(pattern, string). Si pattern existe dans string, python renvoie
une instance MatchObject, si on utilise cette instance dans un test, il
sera considéré comme vrai:
>>> import re
>>> chaine = "totogogototo"
>>> if re.search("gogo",chaine):
print(chaine)
totogogototo
37
Pour chercher un motif (pattern) particulier, utilisation des
métacaractères pour construire la demande:
"^"
ATGCGT mais pas à la chaîne CCATGTT.
"$"
n'importe quel caractère sauf A et B
Exemple : l'expression CG[^AB]T correspond à CG9T, CGCT...
mais pas à CGAT ni à CGBT.
caractère d'échappement (pour protéger certains
caractères)
Exemple : l'expression \+ désigne le caractère + sans autre
signification particulière. L'expression A\.G correspond à A.G
et non pas à A suivi de n'importe quel caractère, suivi de G.
"*"
0 à n fois le caractère précédent ou l'expression entre
parenthèses précédente
Exemple : l'expression A(CG)*T correspond à AT, ACGT,
ACGCGT...
"+"
1 à n fois le caractère précédent ou l'expression entre
parenthèses précédente
Exemple : l'expression
ACGCGT... mais pas à AT.
n'importe quel caractère (mais un caractère quand même)
Exemple : l'expression A.G correspond à ATG, AtG, A4G, mais aussi
à A-G ou à A G.
"[ABC]" le caractère A ou B ou C (un seul caractère)
Exemple : l'expression T[ABC]G correspond à TAG, TBG ou TCG,
mais pas à TG.
"[A-Z]" n'importe quelle lettre majuscule
Exemple : l'expression C[A-Z]T correspond à CAT, CBT, CCT...
"[a-z]" n'importe quelle lettre minuscule
"[0-9]" n'importe quelle chiffre
38
Module : re
"[A-Za-z0-9]" n'importe quelle caractère alphanumérique
"\"
fin de chaîne de caractères ou de ligne
Exemple : l'expression ATG$ correspond à la chaîne de caractères
TGCATG mais pas avec la chaîne CCATGTT.
"."
Module : re
"[^AB]"
début de chaîne de caractères ou de ligne
Exemple : l'expression ^ATG correspond à la chaîne de caractères
A(CG)+T
correspond
à
0 à 1 fois le caractère précédent ou l'expression entre
parenthèses précédente
Exemple : l'expression A(CG)?T correspond à AT ou ACGT.
n fois le caractère précédent ou l'expression entre
"{n}"
parenthèses précédente
n à m fois le caractère précédent ou l'expression entre
"{n,m}"
parenthèses précédente
au moins n fois le caractère précédent ou l'expression
"{n,}"
entre parenthèses précédente
au plus n fois le caractère précédent ou l'expression
"{,m}"
entre parenthèses précédente
"(CG|TT)" chaînes de caractères CG ou TT
Exemple : l'expression A(CG|TT)C correspond à ACGC ou ATTC.
"?"
ACGT,
39
40
10
Module : re
Module : re
Création de l'expression régulière:
Exemples de motif:
ch=" Sous ses pins, on trouve ses chaussures sous le transat "
exp=re.compile("(sous|ses)")
>>> type(exp)
<class '_sre.SRE_Pattern'>
"^L": la lettre L au début de la chaîne
"[A-Z]$": n'importe quelle lettre à la fin de la chaîne
Recherche cette expression dans la chaîne : result=re.search(exp,ch)
va chercher l'expression dans la chaîne et stoppe dès succès.
"(toto)" : le motif toto
"(toto).*(tutu)" : motif toto n'importe quel caractère répété de 0 à n
fois puis tutu
"(toto|tutu)" : motif toto ou tutu
>>> res=re.search(exp,ch)
>>> if res:
print("trouve")
trouve
result=re.findall(exp,chaine) va chercher toutes les expressions dans la
chaîne. Renvoie une liste de ces motifs.
"(tat)[^u]": motif tat puis n'importe quel caractère sauf le u
>>> res=re.findall(exp,ch)
>>> print(res)
['ses', 'ses', 'sous']
"(toto){2,4}": motif toto répété de 2 à 4 fois
41
Module : re
>>>
>>>
>>>
>>>
>>>
>>>
>>>
42
Vitesse d'itération
import time
# creation d'une liste de x elements
# (A adapter suivant la vitesse de vos machines)
taille = 50000000
print("Création d'une liste avec %d elements" %( taille))
toto = range( taille )
# la variable 'a' accede à un element de la liste
expression= re.compile("([0-9]+)\.([0-9]+)")
resultat = re.search(expression, "pi vaut 3.14")
resultat.group(0) '3.14'
resultat.group(1) '3'
resultat.group(2) '14'
resultat.start() 8
resultat.end() 12
Dans cet exemple, on recherche un nombre composé de plusieurs
chiffres [0-9]+, suivi d'un point \. (le point a une signification comme
méta-caractère, donc il faut l'échapper avec \ pour qu'il ait une
signification de point), suivi d'un nombre à plusieurs chiffres [0-9]+.
Les parenthèses dans l'expression régulière permettent de créer des
groupes qui seront récupérés ultérieurement par la fonction group().
La totalité de la correspondance est donné par group(0), le premier
élément entre parenthèse est donné par group(1) et le second par
group(2).
43
Exemple
# méthode 1
print("method 1")
start = time.time()
for i in range( len(toto) ):
a = toto[i]
print("methode 1 (for in range) : %.1f secondes" %( time.time() - start ))
# méthode 2
print("method 2")
start = time.time()
for ele in toto:
a = ele
print("methode 2 (for in) : %.1f secondes" %( time.time() - start ))
44
11
Vitesse d'itération
Vitesse d'itération
Creation d'une liste avec 50000000 elements
methode 1 (for in range) : 13.2 secondes
methode 2 (for in) : 4.7 secondes
>>>
#methode 3
start=time.time()
for idx, ele in enumerate(toto):
a=ele
print("methode 3 (for in enumerate): %.1f secondes"%(time.time()-start))
La méthode la plus rapide pour parcourir une liste est donc d'itérer
directement sur les éléments (for element in liste). Cette instruction
est à privilégier le plus possible.
La méthode for i in range(len(liste)) est particulièrement lente car la
commande range(len(liste)) génère une énorme liste avec tous les
indices des éléments (la création de liste est assez lente en Python).
Creation d'une liste avec 50000000 elements
methode 1 (for in range) : 13.2 secondes
methode 2 (for in) : 4.7 secondes
methode 3 (for in enumerate): 7.5 secondes
La variable idx va correspondre à l'indice (utilisable en toto[idx]), ele
sera l'élément de la liste toto.
Par contre, si il vous faut récupérer le numéro d'indice ??
Une solution: fonction enumerate()
45
46
12