date_plus_recente=max([t.date for t in list_t_recents])
J'ai construit mes données comme ça.
Moi je voudrais ne garder dans la liste des titres récents que ceux dont
la date == date_plus_recente.
J'ai essayé un algorithme utilisant pop(), mais pop() se base sur l'indice.
y a il un moyen plus subtil que d'utiliser une liste temporaire et ensuite
écraser la liste initiale?
Je ferais la même opération pour liste vieux, qui regroupera tout
simplement les titres dont la date != date_plus_recente.
Merci de vos suggestion.
PS: Sinon, là j'ai rendu mes bouquins sur Python, mais il faudrait que je
vois quel est le comportement si je faisais initialement un
list_t_vieux=list_t_recents
et que j'en retire de list_t_recents. Y aura-t-il aussi des element
retirés de list_t_vieux?
(je sais que j'ai vu ça dans la dc mais il me reste à voir comment c'est
exactement) Dans le doute j'ai opté pour la duplication bourine.
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
F. Petitjean
Bonjour, Soit des objets, instances de la classe Titre
class Titre Il manque au moins un « : » ici, j'écrirais
class Titre(object): """on ne conserve que la date """
def __init__(self, d) self.date=d
qui sont dans une liste.
t1=Titre(4534) t2=Titre(786) t3 > ... tn=Titre(...) list_t_recents=[t1,t2,...tn] list_t_vieux=[t1,t2,...tn]
date_plus_recente=max([t.date for t in list_t_recents])
J'ai construit mes données comme ça.
Moi je voudrais ne garder dans la liste des titres récents que ceux dont la date == date_plus_recente. date_plus_recente = ... # comme co-dessus
list_t_recents = [ titre for titre in list_t_vieux if titre.date = date_plus_recente ] Le mécanisme de « liste en intention » (sic) me paraît approprié.
J'ai essayé un algorithme utilisant pop(), mais pop() se base sur l'indice. y a il un moyen plus subtil que d'utiliser une liste temporaire et ensuite écraser la liste initiale?
Je ferais la même opération pour liste vieux, qui regroupera tout simplement les titres dont la date != date_plus_recente. en chnageant la condition.
Merci de vos suggestion.
PS: Sinon, là j'ai rendu mes bouquins sur Python, mais il faudrait que je vois quel est le comportement si je faisais initialement un
list_t_vieux=list_t_recents Ce qui donne deux noms pour le même objet liste (qui n'est pas
immutable) et qui n'est dons pas ce que vous désirez : list_t_vieux = lis(list_t_recents) # une copie list_t_vieux = list_t_recents[:] # une autre manière d'écrire la copie
et que j'en retire de list_t_recents. Y aura-t-il aussi des element retirés de list_t_vieux? (je sais que j'ai vu ça dans la dc mais il me reste à voir comment c'est exactement) Dans le doute j'ai opté pour la duplication bourine. duplication bourine effectuée comment ?
Bonjour,
Soit des objets, instances de la classe Titre
class Titre
Il manque au moins un « : » ici, j'écrirais
class Titre(object):
"""on ne conserve que la date
"""
def __init__(self, d)
self.date=d
qui sont dans une liste.
t1=Titre(4534)
t2=Titre(786)
t3 > ...
tn=Titre(...)
list_t_recents=[t1,t2,...tn]
list_t_vieux=[t1,t2,...tn]
date_plus_recente=max([t.date for t in list_t_recents])
J'ai construit mes données comme ça.
Moi je voudrais ne garder dans la liste des titres récents que ceux dont
la date == date_plus_recente.
date_plus_recente = ... # comme co-dessus
list_t_recents = [ titre for titre in list_t_vieux if titre.date = date_plus_recente ]
Le mécanisme de « liste en intention » (sic) me paraît approprié.
J'ai essayé un algorithme utilisant pop(), mais pop() se base sur l'indice.
y a il un moyen plus subtil que d'utiliser une liste temporaire et ensuite
écraser la liste initiale?
Je ferais la même opération pour liste vieux, qui regroupera tout
simplement les titres dont la date != date_plus_recente.
en chnageant la condition.
Merci de vos suggestion.
PS: Sinon, là j'ai rendu mes bouquins sur Python, mais il faudrait que je
vois quel est le comportement si je faisais initialement un
list_t_vieux=list_t_recents
Ce qui donne deux noms pour le même objet liste (qui n'est pas
immutable) et qui n'est dons pas ce que vous désirez :
list_t_vieux = lis(list_t_recents) # une copie
list_t_vieux = list_t_recents[:] # une autre manière d'écrire la copie
et que j'en retire de list_t_recents. Y aura-t-il aussi des element
retirés de list_t_vieux?
(je sais que j'ai vu ça dans la dc mais il me reste à voir comment c'est
exactement) Dans le doute j'ai opté pour la duplication bourine.
duplication bourine effectuée comment ?
Bonjour, Soit des objets, instances de la classe Titre
class Titre Il manque au moins un « : » ici, j'écrirais
class Titre(object): """on ne conserve que la date """
def __init__(self, d) self.date=d
qui sont dans une liste.
t1=Titre(4534) t2=Titre(786) t3 > ... tn=Titre(...) list_t_recents=[t1,t2,...tn] list_t_vieux=[t1,t2,...tn]
date_plus_recente=max([t.date for t in list_t_recents])
J'ai construit mes données comme ça.
Moi je voudrais ne garder dans la liste des titres récents que ceux dont la date == date_plus_recente. date_plus_recente = ... # comme co-dessus
list_t_recents = [ titre for titre in list_t_vieux if titre.date = date_plus_recente ] Le mécanisme de « liste en intention » (sic) me paraît approprié.
J'ai essayé un algorithme utilisant pop(), mais pop() se base sur l'indice. y a il un moyen plus subtil que d'utiliser une liste temporaire et ensuite écraser la liste initiale?
Je ferais la même opération pour liste vieux, qui regroupera tout simplement les titres dont la date != date_plus_recente. en chnageant la condition.
Merci de vos suggestion.
PS: Sinon, là j'ai rendu mes bouquins sur Python, mais il faudrait que je vois quel est le comportement si je faisais initialement un
list_t_vieux=list_t_recents Ce qui donne deux noms pour le même objet liste (qui n'est pas
immutable) et qui n'est dons pas ce que vous désirez : list_t_vieux = lis(list_t_recents) # une copie list_t_vieux = list_t_recents[:] # une autre manière d'écrire la copie
et que j'en retire de list_t_recents. Y aura-t-il aussi des element retirés de list_t_vieux? (je sais que j'ai vu ça dans la dc mais il me reste à voir comment c'est exactement) Dans le doute j'ai opté pour la duplication bourine. duplication bourine effectuée comment ?
Pierre Quentel
Merci de vos suggestion.
Ceci devrait marcher :
class Titre:
def __init__(self,d): self.date = d
# contruction des instances au hasard, pour l'exemple import random liste_t = [ Titre(random.randint(100,200)) for i in range(200) ]
date_plus_recente = max(t.date for t in liste_t) liste_t_recents = [ t for t in liste_t if t.date == date_plus_recente ] liste_t_vieux = [ t for t in liste_t if t.date != date_plus_recente ]
Je pars d'une liste unique liste_t d'où j'extrais les deux sous-listes par des "list comprehensions"
On peut sûrement optimiser le temps de calcul mais ça ne vaut le coup que si la liste est de grande taille
PS: Sinon, là j'ai rendu mes bouquins sur Python, mais il faudrait que je vois quel est le comportement si je faisais initialement un
list_t_vieux=list_t_recents
et que j'en retire de list_t_recents. Y aura-t-il aussi des element retirés de list_t_vieux? (je sais que j'ai vu ça dans la dc mais il me reste à voir comment c'est exactement) Dans le doute j'ai opté pour la duplication bourine.
Pas besoin de relire la doc, il suffit de tester avec l'interpréteur interactif :
Python 2.4 (#60, Nov 30 2004, 11:49:19) [MSC v.1310 32 bit (Intel)] on win32 Type "help", "copyright", "credits" or "license" for more information.
a = [1,2,3] b = a a.remove(2) b [1, 3]
b.append(100) a [1, 3, 100]
Comme b et a sont le même objet, toute modification de a modifie aussi b
A+ Pierre
Merci de vos suggestion.
Ceci devrait marcher :
class Titre:
def __init__(self,d):
self.date = d
# contruction des instances au hasard, pour l'exemple
import random
liste_t = [ Titre(random.randint(100,200)) for i in range(200) ]
date_plus_recente = max(t.date for t in liste_t)
liste_t_recents = [ t for t in liste_t if t.date == date_plus_recente ]
liste_t_vieux = [ t for t in liste_t if t.date != date_plus_recente ]
Je pars d'une liste unique liste_t d'où j'extrais les deux sous-listes
par des "list comprehensions"
On peut sûrement optimiser le temps de calcul mais ça ne vaut le coup
que si la liste est de grande taille
PS: Sinon, là j'ai rendu mes bouquins sur Python, mais il faudrait que je
vois quel est le comportement si je faisais initialement un
list_t_vieux=list_t_recents
et que j'en retire de list_t_recents. Y aura-t-il aussi des element
retirés de list_t_vieux?
(je sais que j'ai vu ça dans la dc mais il me reste à voir comment c'est
exactement) Dans le doute j'ai opté pour la duplication bourine.
Pas besoin de relire la doc, il suffit de tester avec l'interpréteur
interactif :
Python 2.4 (#60, Nov 30 2004, 11:49:19) [MSC v.1310 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
a = [1,2,3]
b = a
a.remove(2)
b
[1, 3]
b.append(100)
a
[1, 3, 100]
Comme b et a sont le même objet, toute modification de a modifie aussi b
# contruction des instances au hasard, pour l'exemple import random liste_t = [ Titre(random.randint(100,200)) for i in range(200) ]
date_plus_recente = max(t.date for t in liste_t) liste_t_recents = [ t for t in liste_t if t.date == date_plus_recente ] liste_t_vieux = [ t for t in liste_t if t.date != date_plus_recente ]
Je pars d'une liste unique liste_t d'où j'extrais les deux sous-listes par des "list comprehensions"
On peut sûrement optimiser le temps de calcul mais ça ne vaut le coup que si la liste est de grande taille
PS: Sinon, là j'ai rendu mes bouquins sur Python, mais il faudrait que je vois quel est le comportement si je faisais initialement un
list_t_vieux=list_t_recents
et que j'en retire de list_t_recents. Y aura-t-il aussi des element retirés de list_t_vieux? (je sais que j'ai vu ça dans la dc mais il me reste à voir comment c'est exactement) Dans le doute j'ai opté pour la duplication bourine.
Pas besoin de relire la doc, il suffit de tester avec l'interpréteur interactif :
Python 2.4 (#60, Nov 30 2004, 11:49:19) [MSC v.1310 32 bit (Intel)] on win32 Type "help", "copyright", "credits" or "license" for more information.
a = [1,2,3] b = a a.remove(2) b [1, 3]
b.append(100) a [1, 3, 100]
Comme b et a sont le même objet, toute modification de a modifie aussi b
A+ Pierre
Eric Deveaud
R12y wrote:
Bonjour,
Moi je voudrais ne garder dans la liste des titres récents que ceux dont la date == date_plus_recente. J'ai essayé un algorithme utilisant pop(), mais pop() se base sur l'indice. y a il un moyen plus subtil que d'utiliser une liste temporaire et ensuite écraser la liste initiale?
voir du côté de list.remove(element) qui permet de retirer inplace d'une liste un element d'apres sa valeur, attention n'élimine que la première occurence de l'élément si celui-ci est present de multiples fois dans la liste
Je ferais la même opération pour liste vieux, qui regroupera tout simplement les titres dont la date != date_plus_recente.
Merci de vos suggestion.
PS: Sinon, là j'ai rendu mes bouquins sur Python, mais il faudrait que je vois quel est le comportement si je faisais initialement un
list_t_vieux=list_t_recents
et que j'en retire de list_t_recents. Y aura-t-il aussi des element retirés de list_t_vieux?
oui tu vas tout perdre
ex:
l = ['a','b', 'c', 'd'] l1 = l l.remove('a') l1 ['b', 'c', 'd']
si tu n'as qu'un niveau tu peux envisager un truc du genre list_t_vieux=list_t_recents[:] ce qui te fera une copie de la liste list_t_recents
MAIS ATTENTION ATTENTION DANGER si tes listes stockent des références tu cours au devant de soucis ex:
c'est le comportement que tu attends, JUSQUE LA TOUT VA BIEN
l[0]='toto' l ['toto', [5, 6]]
l1 [[1, 2], [3, 4], [5, 6]]
c'est le comportement que tu attends, JUSQUE LA TOUT VA BIEN
l[1][0] = 'ARGHHHHHHHHHH' l ['toto', ['ARGHHHHHHHHHH', 6]]
l1 [[1, 2], [3, 4], ['ARGHHHHHHHHHH', 6]]
BOUM ce N'EST PLUS le comportement que tu attends
(je sais que j'ai vu ça dans la dc mais il me reste à voir comment c'est exactement) Dans le doute j'ai opté pour la duplication bourine.
comment as-tu dupliqué ?? et quel traitement veux tu faire par la suite sur les éléments de tes listes ?? selon les cas [:] ou copy peuvent suffirent sinon il faut dégainer l'artillerie lourde et tapper du coté de deepcopy
Eric
-- C'est pas moi qui ait parlé du spam, d'ailleurs je vois mal comment on peut faire du spam sur Usenet Je ne défend pas les spammeurs, je défend la liberté d'expression. -+- LP in <http://www.le-gnu.net> : Neuneu d'or novembre 2000. -+-
R12y wrote:
Bonjour,
Moi je voudrais ne garder dans la liste des titres récents que ceux dont
la date == date_plus_recente.
J'ai essayé un algorithme utilisant pop(), mais pop() se base sur l'indice.
y a il un moyen plus subtil que d'utiliser une liste temporaire et ensuite
écraser la liste initiale?
voir du côté de list.remove(element) qui permet de retirer inplace d'une liste
un element d'apres sa valeur, attention n'élimine que la première occurence de
l'élément si celui-ci est present de multiples fois dans la liste
Je ferais la même opération pour liste vieux, qui regroupera tout
simplement les titres dont la date != date_plus_recente.
Merci de vos suggestion.
PS: Sinon, là j'ai rendu mes bouquins sur Python, mais il faudrait que je
vois quel est le comportement si je faisais initialement un
list_t_vieux=list_t_recents
et que j'en retire de list_t_recents. Y aura-t-il aussi des element
retirés de list_t_vieux?
oui tu vas tout perdre
ex:
l = ['a','b', 'c', 'd']
l1 = l
l.remove('a')
l1
['b', 'c', 'd']
si tu n'as qu'un niveau tu peux envisager un truc du genre
list_t_vieux=list_t_recents[:]
ce qui te fera une copie de la liste list_t_recents
MAIS ATTENTION ATTENTION DANGER
si tes listes stockent des références tu cours au devant de soucis
ex:
c'est le comportement que tu attends, JUSQUE LA TOUT VA BIEN
l[0]='toto'
l
['toto', [5, 6]]
l1
[[1, 2], [3, 4], [5, 6]]
c'est le comportement que tu attends, JUSQUE LA TOUT VA BIEN
l[1][0] = 'ARGHHHHHHHHHH'
l
['toto', ['ARGHHHHHHHHHH', 6]]
l1
[[1, 2], [3, 4], ['ARGHHHHHHHHHH', 6]]
BOUM ce N'EST PLUS le comportement que tu attends
(je sais que j'ai vu ça dans la dc mais il me reste à voir comment c'est
exactement) Dans le doute j'ai opté pour la duplication bourine.
comment as-tu dupliqué ?? et quel traitement veux tu faire par la suite sur les
éléments de tes listes ??
selon les cas [:] ou copy peuvent suffirent
sinon il faut dégainer l'artillerie lourde et tapper du coté de deepcopy
Eric
--
C'est pas moi qui ait parlé du spam, d'ailleurs je vois mal comment on
peut faire du spam sur Usenet Je ne défend pas les spammeurs, je défend
la liberté d'expression.
-+- LP in <http://www.le-gnu.net> : Neuneu d'or novembre 2000. -+-
Moi je voudrais ne garder dans la liste des titres récents que ceux dont la date == date_plus_recente. J'ai essayé un algorithme utilisant pop(), mais pop() se base sur l'indice. y a il un moyen plus subtil que d'utiliser une liste temporaire et ensuite écraser la liste initiale?
voir du côté de list.remove(element) qui permet de retirer inplace d'une liste un element d'apres sa valeur, attention n'élimine que la première occurence de l'élément si celui-ci est present de multiples fois dans la liste
Je ferais la même opération pour liste vieux, qui regroupera tout simplement les titres dont la date != date_plus_recente.
Merci de vos suggestion.
PS: Sinon, là j'ai rendu mes bouquins sur Python, mais il faudrait que je vois quel est le comportement si je faisais initialement un
list_t_vieux=list_t_recents
et que j'en retire de list_t_recents. Y aura-t-il aussi des element retirés de list_t_vieux?
oui tu vas tout perdre
ex:
l = ['a','b', 'c', 'd'] l1 = l l.remove('a') l1 ['b', 'c', 'd']
si tu n'as qu'un niveau tu peux envisager un truc du genre list_t_vieux=list_t_recents[:] ce qui te fera une copie de la liste list_t_recents
MAIS ATTENTION ATTENTION DANGER si tes listes stockent des références tu cours au devant de soucis ex:
c'est le comportement que tu attends, JUSQUE LA TOUT VA BIEN
l[0]='toto' l ['toto', [5, 6]]
l1 [[1, 2], [3, 4], [5, 6]]
c'est le comportement que tu attends, JUSQUE LA TOUT VA BIEN
l[1][0] = 'ARGHHHHHHHHHH' l ['toto', ['ARGHHHHHHHHHH', 6]]
l1 [[1, 2], [3, 4], ['ARGHHHHHHHHHH', 6]]
BOUM ce N'EST PLUS le comportement que tu attends
(je sais que j'ai vu ça dans la dc mais il me reste à voir comment c'est exactement) Dans le doute j'ai opté pour la duplication bourine.
comment as-tu dupliqué ?? et quel traitement veux tu faire par la suite sur les éléments de tes listes ?? selon les cas [:] ou copy peuvent suffirent sinon il faut dégainer l'artillerie lourde et tapper du coté de deepcopy
Eric
-- C'est pas moi qui ait parlé du spam, d'ailleurs je vois mal comment on peut faire du spam sur Usenet Je ne défend pas les spammeurs, je défend la liberté d'expression. -+- LP in <http://www.le-gnu.net> : Neuneu d'or novembre 2000. -+-
