Rangement chronologique de liste

**Tequilapaf** · 30/06/2009, 13h27

Bonjour,

Voila mon problème:
J'ai plusieurs fichiers dans un dossier, chaque fichier présente des relevés de points avec la date du relevé. Les dates ne sont pas du tout fixe ( je ne sais pas a quelle heure il a fait son relevé). Les relevés entre 2 fichiers peuvent être a des heures totalement différentes.

J'ai réussi a isoler les dates de chaque fichier et a les stocker dans une liste pour en faire un axe des temps (pour un plot futur).
J'ai donc une liste de dates mais rangées n'importe comment.

Et maintenant, j'aimerais ranger chronologiquement cette liste.
Les dates sont au format JapanUTC : 2009/01/01 00:02:54

Est ce que vous connaissez une fonction qui fait ça bien ou est ce que je dois tout me faire a la main.... ?

Merci pour vos futures réponses

TeqPAF

**N.tox** · 30/06/2009, 13h57

heu... en utilisant sort ou sorted ?

Tes dates sont sous forme de chaînes ? ou tu les as converties ?
Si tu les à converties sous forme de tuples ou de listes, sort et sorted marcheront, mais il faut impérativement que l'ordre d'affichage de la date soit anglophone (YYYY/MM/DD)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
>>> a=[(2009,02,01),(2009,01,31),(2008,12,15)]
>>> sorted(a)
[(2008, 12, 15), (2009, 1, 31), (2009, 2, 1)]
>>> a.sort()
>>> a
[(2008, 12, 15), (2009, 1, 31), (2009, 2, 1)]

**Tequilapaf** · 30/06/2009, 14h24

Bon bah voila ca marche !

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
tupleDate = []
        for date in listDate:
            annee = date.split('/')[0]
            mois = date.split('/')[1]
            jour = date.split('/')[2].split(' ')[0]
            heure = date.split(' ')[1].split(':')[0]
            minute = date.split(' ')[1].split(':')[1]
            seconde = date.split(' ')[1].split(':')[2]
            paquet = date.split(' ')[2]
            splitedDate = [annee, mois, jour, heure, minute, seconde, paquet]
            tupleDate.append(splitedDate)
        tupleDate = sorted(tupleDate)

Merci beaucoup !

TeqPAF

**N.tox** · 30/06/2009, 14h27

De rien, mais j'avais oublié un mot, donc le sens de la phrase n'est complètement celui que je voulais... bref, ce que je voulais dire, c'est que si c'est des chaines, ça marche tout aussi bien

**pacificator** · 30/06/2009, 18h43

pourquoi ne pas profiter des libs disponibles?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import datetime
 
dirty_dates = ['2009/01/01 10:00:25', '2008/12/12 01:00:00',
        '2008/12/12 00:50:00', '2009/06/02 20:35:00']
 
dates = []
format = "%Y/%m/%d %H:%M:%S"
for date in dirty_dates:
    d = datetime.datetime.strptime(date, format)
    dates.append(d)
 
order_dates = sorted(dates)
format = 'fichier generer le %d/%m/%Y a %Hh %Mmin %Ssec'
for date in order_dates:
    print date.strftime(format)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
fichier generer le 12/12/2008 a 00h 50min 00sec
fichier generer le 12/12/2008 a 01h 00min 00sec
fichier generer le 01/01/2009 a 10h 00min 25sec
fichier generer le 02/06/2009 a 20h 35min 00sec

**eyquem** · 01/07/2009, 22h08

Tequilapaf,

Cette file est taguée “Résolu“ mais aucune des solutions avancées ne me plaît.

Celle de N.tox parce qu’il faut une conversion préalable en tuple d’entiers, la tienne parce qu’elle est anti-optimisée, celle de pacificator parce qu’elle est trop compliquée.

Si tes listes de date-paquet sont grandes, ton code va être long à tourner.
En effet pour trouver annee,mois et jour tu le fais spliter 3 fois de la même manière avec “/“ + un split avec “ “.
Puis pour trouver heure,minute,seconde et le paquet tu lui fait spliter 4 fois de la même manière avec “ “ + 3 fois avec “:“.
Autrement dit , ton code passe son temps à répéter des actions identiques.

Si tu as vraiment besoin de récuperer annee,mois etc dans des variables, il y a vraiment plus simple et plus rapide:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
li = ['2009/01/23 10:00:25 relevé du Mont Aigoual',
      '2008/12/12 01:00:00 amplitude radada',
      '2008/12/12 00:50:00 jhgkjhdkdd',
      '2009/06/02 20:35:00 station balnéaire du Touquet',
      '2009/06/01 19:13:28 phare XY7654' ]
 
for el in li:
    annee = el[0:4]
    mois = el[5:7]
    jour = el[8:10]
    heure = el[11:13]
    minute = el[14:16]
    seconde = el[17:19]
    paquet = el[20:]

Les extractions de segment de chaîne au moyen des indices est extrêmement rapide.

Quant à ordonner la liste, Python ordonne aussi les chaînes d’après leurs caractères:
le format de tes dates est idéal pour mettre à profit cette possibilité et faire un code très court.
Utiliser sort() plutôt que sorted() évite de créer un liste supplémentaire: avec sort() la liste est triée sur place.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
li = ['2009/01/23 10:00:25 relevé du Mont Aigoual',
      '2008/12/12 01:00:00 amplitude radada',
      '2008/12/12 00:50:00 jhgkjhdkdd',
      '2009/06/02 20:35:00 station balnéaire du Touquet',
      '2009/06/01 19:13:28 phare XY7654' ]
 
li.sort(key=lambda x: x[0:19])
print li

2008/12/12 00:50:00 jhgkjhdkdd
2008/12/12 01:00:00 amplitude radada
2009/01/23 10:00:25 relevé du Mont Aigoual
2009/06/01 19:13:28 phare XY7654
2009/06/02 20:35:00 station balnéaire du Touquet

**N.tox** · 01/07/2009, 22h24

c'est exactement ce que je voulais dire au niveau des chaines, simplement un mot qui saute, et la phrase n'a plus le même sens...

Mais le mieux ne serait-il pas d'utiliser le module bisect, qui permet de de garder une liste trié directement depuis l'ajout d'un élément, donc directement lors de la collecte des dates ?

**Tequilapaf** · 02/07/2009, 09h14

Merci Eyquem

Optimisation du code ==> Gain de temps de 6minutes

Merci a tous en tout cas...

Une dernière petite question pour ne pas refaire un post:
J'utilise le module datetime, les dates a la sortie de ce module sont au format de type 2009-01-01 00:00:00.000000
Or, moi je voudrais me retrouver avec mes dates d'origine de type :
2009/01/01 00:00:00.000

J'ai vu qu'il y avait une fonction strftime qui permet d'imposer un format mais je ne trouve pas si il est possible de prendre en compte les milisecondes?
format = %Y/%m/%d %H:%M:%S.??

Ou il faut que je fasse du bricolage du type :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Date.replace('-', '/')[0:23]

Merfi !

TeqPAF

**eyquem** · 02/07/2009, 13h06

Salut,

La réponse est simple: il suffit de bien comprendre ce que fait une fonction , et pour cela il suffit de bien lire une docu (si elle est bien faite)..

Mais d’abord un petit préalable.
Je trouve que la formule «les dates a la sortie de ce module » ne veut rien dire.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
dt = datetime(2008,11,3,minute = 27,second=45,microsecond=2356)
print type(dt),'   ',dt

me sort

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

<type 'datetime.datetime'>     2008-11-03 00:27:45.002356

dt n’est donc pas une chaîne et logiquement, quand je fais

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

print dt.replace('-','/')

j’obtiens l’erreur

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
Traceback (most recent call last):
  File "E:\Python\Essais Python\zom vide.py", line 18, in <module>
    print dt.replace('-','/')
TypeError: an integer is required

parce que le replace() d'une variable de type datetime existe et est différente du replace() d’une chaîne.

Bref, pour moi:
- dt n’est pas une «sortie du module», c’est au contraire , en tant qu’une instance de la classe datetime, un objet contenu en quelque sorte dans l’ensemble des instances de cette classe.
- 2008-11-03 00:27:45.002356 n’est pas l’objet dt, c’est entendu, mais ce n’est pas non plus une «sortie du module» de dt, c’est à dire que ça ne résulte pas d’une instruction interne du genre x = obtenir_la_chaine_de(dt) qui donnerait la valeur 2008-11-03 00:27:45.002356 ou '2008-11-03 00:27:45.002356’ à x, suivi d’un affichage de x.

2008-11-03 00:27:45.002356 est simplement directement l’affichage de dt, c’est à dire il n’y a que print qui le produise.

--------------------------------------------

Ceci étant, quand tu écris «je voudrais me retrouver avec mes dates d'origine de type 2009/01/01 00:00:00.000» , ce ne peut donc être que d’un type chaîne dont tu parles, puisque je ne vois pas comment on pourrait aller bidouiller le module datetime pour que print dt sorte 2008/11/03 00:27:45 comme affichage de dt. Et de toutes façons, pour des manipulations, un programme a besoin de valeurs dans des variables, pas de sorties d’affichage.

Ton problème est donc, apparemment, de tirer une chaîne ’2008/11/03 00:27:45’ de l’objet dt.

En essayant repr()

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
dt = datetime(2008,11,3,minute = 27,second=45,microsecond=2356)
print type(repr(dt)),'   ',repr(dt)

on obtient

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

<type 'str'>     datetime.datetime(2008, 11, 3, 0, 27, 45, 2356)

Pas la bonne voie.

En essayant timetuple()

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
dt = datetime(2008,11,3,minute = 27,second=45,microsecond=2356)
print type(dt.timetuple()),'   dt.timetuple() =',dt.timetuple()

on obtient

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

<type 'time.struct_time'>    dt.timetuple() = (2008, 11, 3, 0, 27, 45, 0, 308, -1)

Pas ce qu’on cherche non plus.

La solution est effectivement d’utiliser strftime(). Ta question a été l’occasion pour moi de mieux comprendre encore ce que fait strftime().

D’abord le strftime() du module datetime agit comme le strftime() du module time:
«Broadly speaking, d.strftime(fmt) acts like the time module's time.strftime(fmt, d.timetuple()) »
http://www.python.org/doc/2.5.2/lib/...ftime-behavior
et
«strftime(format [,t]) Convert a tuple or struct_time representing a time as returned by gmtime() or localtime() to a string as specified by the format argument.»
http://www.python.org/doc/2.5.2/lib/....html#l2h-2826

C’est à dire que le format sert à écrire le string voulu, il ne sert pas à extraire les données voulues.

Autrement dit, strftime() tire de l’argument qu’on lui refile les valeurs de year,month,day,hour,minute,second,millisecond et tzinfo (valeurs numériques qui peuvent êre obtenues individuellement en tant qu’attributs d’instance par dt.year, dt,month,etc ) mais elle ne transforme en caractères et organise ces caractères en une chaîne renvoyée que pour celles de ces 8 valeurs qui sont spécifiées via le format.

Il n’y a donc pas à se préoccuper de dire à strftime() “tu vas trouver les millisecondes après les secondes et le point“, elle se débrouille toute seule pour tirer les minutes,secondes,millisecondes de l’objet dt et on n’a qu’à se préoccuper de ce qu’on veut tirer comme chaîne.

Tout ça se résume à:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
dt = datetime(2008,11,3,minute = 27,second=45,microsecond=2356)
x = dt.strftime('%Y/%m/%d %H:%M:%S')
print type(x),'   ',x

Ça marche:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

<type 'str'>     2008/11/03 00:27:45

**Tequilapaf** · 02/07/2009, 14h19

Hum petit moment d'égarement Eyquem

J'ai bien compris ce que faisait strftime...
Mais la question était de trouver une solution afin d'imposer un format pour l'affichage de la date qui prenne en compte les microsecondes comme pour le %S pour les secondes.

Sur les anciennes versions de python (me semble-t-il) il y avait %f qui le faisait mais ca ne marche plus avec python 2.5...

Donc voila ou est le probleme !

**pacificator** · 02/07/2009, 14h50

je suis sous python 2.5 et cela fonctionne bien:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
>>> import datetime
>>> now = datetime.datetime.now()
>>> now.strftime('%f microsecondes')
'645107 microsecondes'

**Tequilapaf** · 02/07/2009, 15h00

alors la, je colle :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
>>> import datetime
>>> date = datetime.datetime(2009,01,01,00,00,00,215240)
>>> print date
2009-01-01 00:00:00.215240
>>> date.strftime('%f microsec')
' microsec'
>>> now = datetime.datetime.now()
>>> now.strftime('%f')
''
>>>

Chez moi ça marche pas

...
Et en plus il ne me renvoie aucune erreur !

MOUARF keskisspass

**pacificator** · 02/07/2009, 15h25

Au temps pour moi!

Mon interpréteur est en version 2.6 ... sûrement une mise à jour à laquelle je n'ai pas fait attention!

Effectivement avec la version 2.5r254:67916 j'obtiens:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
>>> import datetime
>>> date = datetime.datetime(2009,01,01,00,00,00,215240)
>>> print date
2009-01-01 00:00:00.215240
>>> date.strftime('%f microsec')
'%f microsec'
>>> now = datetime.datetime.now()
>>> now.strftime('%f')
'%f'

**eyquem** · 02/07/2009, 17h04

GROS moment d’égarement. Je suis parti en balade sans tenir compte de la question.
Il faut aussi bien lire les questions !

Je reviens dans le sentier:

Dans un premier temps, je me suis basé sur ceci:

1/ «d.strftime(fmt) acts like time.strftime(fmt, d.timetuple())»
(dans la documentation de 2.5
http://www.python.org/doc/2.5.2/lib/...-behavior.html)

2/ timetuple() ne conserve pas “l’information microsecondes“ contenue dans la valeur d’une variable datetime puisque:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
dt = datetime(2008,11,3,minute = 27,second=45,microsecond=2356)
print '   dt.timetuple() =',dt.timetuple()

donne

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

dt.timetuple() = (2008, 11, 3, 0, 27, 45, 0, 308, -1)

pour conclure que, contrairement à ce que j’ai écrit ( «strftime() tire de l’argument qu’on lui refile les valeurs year,month,day,hour,minute,second,millisecond et tzinfo» ), strftime() ne soutire pas les microsecondes à partir de l’argument qu’on lui passe.

La réponse est alors bien qu’il faut bricoler. Mais ça n’est pas la mer à boire: personnellement, après avoir découvert que str() s’applique aussi aux datetime objects en produisant un string, je ferais:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
dt = datetime(2008,11,3,minute = 27,second=45,microsecond=2356)
x = dt.strftime('%Y/%m/') + str(dt)[8:]
print x

2008/11/03 00:27:45.002356

Ceci est la solution dans le cadre de Python 2.5.

-----------

En voyant le message de pacificator, il apparaît que sous 2.6, il a évidemment la meilleure solution.

Je suis allé voir ce que la documentation de 2.6 dit à propos du strftime() de datetime.
On y relit la même phrase:
«Broadly speaking, d.strftime(fmt) acts like the time module’s time.strftime(fmt, d.timetuple()) »
Mais il y a en plus:
«time and datetime objects support a %f format code which expands to the number of microseconds in the object, zero-padded on the left to six places.»
Et dans la liste des directives de strftime() il y aussi en plus la directive ’%f’.
http://www.python.org/doc/2.6/librar...ftime-behavior

Mais quand on va voir la documentation de 2.6 à propos du strftime() du module time, la nouveauté de ’%f’ n’est pas signalée et la liste des directives ne comporte pas ’%f’
http://www.python.org/doc/2.6/librar...#time.strftime

Soit la documentation de 2.6 est mal faite sur ce point,
soit strftime() de datetime et strftime() de time ne sont plus exactement les mêmes et la première n’est pas basée sur la seconde comme dans 2.5

**Tequilapaf** · 03/07/2009, 08h46

Merci de vous etre penché sur mon cas en tout cas !
Finalement j'ai opté pour une solution de bricolage:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
>>> dt.strftime("%Y/%m/%d %H:%M:%S.")+str(dt)[-6:-3]
'2008/11/03 00:27:45.235'
>>>

Tant que c'est pour l'affichage qu'on concaténe je vais pas chipoter !

Merci beaucoup les gens !

TeqPAF

**eyquem** · 03/07/2009, 13h22

Et si on faisait une petite mesure de temps ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
from timeit import Timer
from datetime import datetime
 
def rep(dt):
    return str(dt).replace('-','/')
 
def dkp(dt):
    sdt =str(dt)
    return sdt[0:4]+'/'+sdt[5:7]+'/'+sdt[8:]
 
def strf(dt):
    return dt.strftime("%Y/%m/%d %H:%M:%S.")+str(dt)[-6:]
 
 
dt = datetime(2009,12,13,4,0,6,237800)
print 'dt =',dt,'   ',type(dt)
print 'dkp(dt)  =',dkp(dt)
print 'rep(dt)  =',rep(dt)
print 'strf(dt) =',strf(dt)
print
 
 
 
repet = 6
iterat = 50
tr = Timer("rep(dt)","from __main__ import dt,rep").repeat(repet,iterat)
td = Timer("dkp(dt)",'from __main__ import dt,dkp').repeat(repet,iterat)
ts = Timer('strf(dt)','from __main__ import dt,strf').repeat(repet,iterat)
 
 
 
for u in tr:
    print str(u)[0:10].ljust(11),
mr = sum(tr)/len(tr)
print 'moyenne replace : '.rjust(20),mr
 
for u in td:
    print str(u)[0:10].ljust(11),
md = sum(td)/len(td)
print 'moyenne decoupe : '.rjust(20),md
 
for u in ts:
    print str(u)[0:10].ljust(11),
ms = sum(ts)/len(ts)
print 'moyenne strftime : '.rjust(20),ms
 
print
print 'moyenne strftime / moyenne replace : '.rjust(92),ms/mr

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
dt = 2009-12-13 04:00:06.237800     <type 'datetime.datetime'>
dkp(dt)  = 2009/12/13 04:00:06.237800
rep(dt)  = 2009/12/13 04:00:06.237800
strf(dt) = 2009/12/13 04:00:06.237800
 
0.00153203  0.00166278  0.00143370  0.00143761  0.00143230  0.00160607    moyenne replace :  0.00151741818211
0.00187928  0.00151499  0.00145437  0.00145521  0.00145409  0.00150996    moyenne decoupe :  0.0015446562808
0.00630694  0.00625498  0.00592561  0.00617983  0.01010491  0.00606417   moyenne strftime :  0.00680607917114
 
                                                       moyenne strftime / moyenne replace :  4.48530223995

Il y a une variabilité assez importante des mesures. En faisant tourner plusieurs fois ce code, on obtient tantôt méthode avec replace() plus rapide, tantôt méthode avec découpage plus rapide. Bien que la différence soit très minime et n’a pas d’importance pour choisir l’une ou l’autre méthode, j’ai voulu savoir laquelle des deux est vraiment plus rapide que l’autre, de base.

Je me suis alors apeçu que, sur mon ordi en tous cas, il y a des valeurs de temps carrément aberrantes qui sortent de temps à autres (4 à 50 fois plus que la moyenne).

Pour diminuer la survenue de ces durées aberrantes j’ai fixé iterat basse et pour diminuer l’influence de ces valeurs aberrantes sur la moyenne je les ai noyées dans un grand nombre d’autres valeurs en prenant repet grand.

Mais comme ça ne suffisait pas à obtenir des résultats assez stables pour comparer replace() et la découpe, j’ai ajouté du code pour éliminer les valeurs de temps aberrantes et obtenir des moyennes plus significatives des vitesses normales des différentes méthodes.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
from timeit import Timer
from datetime import datetime
 
def rep(dt):
    return str(dt).replace('-','/')
 
def dkp(dt):
    sdt =str(dt)
    return sdt[0:4]+'/'+sdt[5:7]+'/'+sdt[8:]
 
def strf(dt):
    return dt.strftime("%Y/%m/%d %H:%M:%S.")+str(dt)[-6:]
 
 
dt = datetime(2009,12,13,4,0,6,237800)
print 'dt =',dt,'   ',type(dt)
print 'dkp(dt)  =',dkp(dt)
print 'rep(dt)  =',rep(dt)
print 'strf(dt) =',strf(dt)
print
 
repet = 3000
iterat = 20
tr = Timer("rep(dt)","from __main__ import dt,rep").repeat(repet,iterat)
td = Timer("dkp(dt)",'from __main__ import dt,dkp').repeat(repet,iterat)
ts = Timer('strf(dt)','from __main__ import dt,strf').repeat(repet,iterat)
 
 
mr = sum(tr)/len(tr)
trslim = []
traber = []
for u in tr:
    if u < 2*mr:
        trslim.append(u)
    else:
        traber.append(u)
mrslim = sum(trslim)/len(trslim)
print '\nmoyenne replace :'
print ('len de tr ='+str(len(tr))).rjust(20),('len de tr sans valeurs aberrantes ='+str(len(trslim))).rjust(47)
print str(mr).rjust(20),str(mrslim).rjust(47)
print "liste des rapports 'valeurs aberrantes de temps / moyenne' :"
for el in [str(u/mrslim)[0:4] for u in traber]:
    print el+' - ',
print '\n'
 
 
md = sum(td)/len(td)
tdslim = []
tdaber = []
for u in td:
    if u < 2*md:
        tdslim.append(u)
    else:
        tdaber.append(u)
mdslim = sum(tdslim)/len(tdslim)
print 'moyenne decoupe :'
print ('len de td ='+str(len(td))).rjust(20),('len de td sans valeurs aberrantes ='+str(len(tdslim))).rjust(47)
print str(md).rjust(20),str(sum(tdslim)/len(tdslim)).rjust(47)
print "liste des rapports 'valeurs aberrantes de temps / moyenne' :"
for el in [str(u/mdslim)[0:4] for u in traber]:
    print el+' - ',
print '\n'
 
 
ms = sum(ts)/len(ts)
tsslim = []
tsaber = []
for u in ts:
    if u < 2*ms:
        tsslim.append(u)
    else:
        tsaber.append(u)
msslim = sum(tsslim)/len(tsslim)
print '\nmoyenne strftime :'
print ('len de ts ='+str(len(ts))).rjust(20),('len de ts sans valeurs aberrantes ='+str(len(tsslim))).rjust(47)
print str(ms).rjust(20),str(sum(tsslim)/len(tsslim)).rjust(47)
print "liste des rapports 'valeurs aberrantes de temps / moyenne' :"
for el in [str(u/msslim)[0:4] for u in tsaber]:
    print el+' - ',
print '\n'
 
 
print
print 'moyenne strftime / moyenne replace : ',ms/mr,'  ',(msslim/mrslim)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
moyenne replace :
     len de tr =3000         len de tr sans valeurs aberrantes =2954
   0.000651302144081                               0.000601970729093
liste des rapports 'valeurs aberrantes de temps / moyenne' :
7.32 -  3.45 -  7.12 -  4.35 -  2.51 -  4.54 -  4.31 -  23.2 -  4.58 -  4.60 -  4.37 -  3.69 -  6.31 -  3.37 -  5.08 -  4.75 -  4.39 -  2.35 -  5.19 -  4.56 -  4.07 -  11.3 -  6.23 -  8.97 -  20.0 -  3.51 -  31.9 -  2.44 -  6.12 -  6.66 -  2.49 -  5.11 -  4.11 -  23.3 -  4.32 -  2.35 -  3.77 -  4.53 -  2.17 -  4.70 -  2.51 -  4.84 -  3.60 -  4.77 -  4.16 -  3.51 -  
 
moyenne decoupe :
     len de td =3000         len de td sans valeurs aberrantes =2950
   0.000721216988938                               0.000612001747879
liste des rapports 'valeurs aberrantes de temps / moyenne' :
7.20 -  3.39 -  7.01 -  4.28 -  2.47 -  4.47 -  4.24 -  22.8 -  4.51 -  4.52 -  4.29 -  3.63 -  6.20 -  3.31 -  5.00 -  4.67 -  4.32 -  2.32 -  5.11 -  4.48 -  4.01 -  11.1 -  6.12 -  8.82 -  19.7 -  3.46 -  31.4 -  2.40 -  6.02 -  6.55 -  2.45 -  5.02 -  4.04 -  22.9 -  4.24 -  2.31 -  3.71 -  4.45 -  2.13 -  4.62 -  2.47 -  4.76 -  3.54 -  4.69 -  4.09 -  3.46 -  
 
 
moyenne strftime :
     len de ts =3000         len de ts sans valeurs aberrantes =2958
    0.00276666336085                                0.00255249152689
liste des rapports 'valeurs aberrantes de temps / moyenne' :
2.36 -  5.51 -  8.47 -  2.67 -  6.18 -  7.55 -  2.88 -  6.33 -  8.43 -  2.98 -  12.6 -  12.6 -  5.55 -  12.9 -  8.45 -  13.0 -  12.7 -  12.7 -  6.29 -  6.23 -  4.89 -  2.22 -  6.16 -  2.42 -  8.48 -  2.72 -  3.26 -  2.38 -  5.86 -  6.28 -  12.7 -  12.7 -  12.9 -  14.2 -  6.36 -  4.63 -  12.7 -  2.38 -  2.63 -  2.40 -  6.21 -  2.18 -  
 
 
moyenne strftime / moyenne replace :  4.24789536775    4.24022531915

Il apparait que la méthode avec replace() est très très très légèrement plus rapide que celle avec une découpe de str(dt) ( moins de 1% de gain).

Comme replace() me plaît bien parce que la méthode a quelque chose de plus épuré et simple que la découpe, c’est la solution que je préférerais à l’utilisation de strftime() et str([-6:-3]

Finalement , ce à quoi tu avais pensé en premier est mieux: utiliser replace()

Rangement chronologique de liste

Python

Discussions similaires

Partager

Partager