Discussion :

[selmagsi]

Slaut les dev, Besoin de vous, du coup je vous écris!

j'ai cette petite ligne de code

Code :

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

1
2
 
Pt = [ xx for xx,d in zip(Q,norm) if d >= delta]

Pt une liste, xx un element de Q , d un element de norm et delta un certain seuil, je veux dans cette fonction intégrer une autre condition afin de limiter la taille de Pt.

Merci d'avance pour votre aide

[VinsS]

Salut,

Et simplement un slice, ce n'est pas bon ?
Par exemple si tu ne veux pas plus de 10 éléments:

Code :

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

1
2
 
Pt = [ xx for xx,d in zip(Q,norm) if d >= delta][:10]

[lg_53]

Où aussi tu peux augmenter la valeur du paramètre delta. Plus il sera grand, moins tu ne sélectionnera d'éléments dans ta liste Pt

[Supernul]

Pour t'aider, il faut que tu sois plus précis. Par exemple :
- veux-tu obtenir les X plus grandes valeurs ?
- veux-tu obtenir X valeurs supérieures à ton seuil, si besoin retenue de manière aléatoire ?
- ...

Sinon, on te proposera autant de solutions que de mqnière dont on comprend ta question.

[selmagsi]

Merci à tous , ce que je cherchais c'est ce qui a proposé VinsS, merci encore

[Sve@r]

Bonjour

Cette solution consiste à générer toute la liste pour n'en garder que les 10 premiers, ce qui n'est pas vraiment optimal.

Peut-être qu'un algorithme plus classique, à base de boucle et de break quand on atteint les 10 éléments, pourra être ici plus efficace...

[Pyramidev]

Cette solution consiste à générer toute la liste pour n'en garder que les 10 premiers, ce qui n'est pas vraiment optimal.

Dans ce cas, on peut remplacer la liste en compréhension par une generator expression et ne générer que les premiers éléments en filtrant avec itertools.islice :

Code :

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

Pt = list(itertools.islice((xx for xx,d in zip(Q,norm) if d >= delta), 10))

[Sve@r]

Dans ce cas, on peut remplacer la liste en compréhension par une generator expression et ne générer que les premiers éléments en filtrant avec itertools.islice

[Supernul]

@Pyramidev : c'est très beau et très malin. Un très bel exemple tout simple d'optimisation. Si on pouvait enseigner ce type de réflexion aux lycéens et étudiants, informaticiens ou non, ...

[Sve@r]

Si on pouvait enseigner ce type de réflexion aux lycéens et étudiants, informaticiens ou non, ...

C'est aussi un problème lié à l'immensité Python. Python est un très beau langage mais il possède une foule immense de bibliothèques diverses. Ce qui est un tel avantage que ça en devient presque un défaut. Qui en effet peut tout savoir sur ce qui existe ? Un tel voudra faire papamaman et le fera avec des boucles alors qu'il existe la librairie papamaman qui peut le faire pour lui mais il ne le sait pas.
On enseigne aux lycéens et étudiants informaticiens l'algorithmique qui est l'art de résoudre des problèmes finis au travers d'instructions simples accessibles par une machine de Turing. Et qui est donc bien évidemment la base de l'informatique. Mais personne ne pourra enseigner tout ce qui existe en termes d'outils permettant de remplacer ces algorithmes classiques.

Et donc on ne peut s'en remettre qu'à la chance. Si j'étais pas passé par là et si je n'avais pas fait une remarque, Pyramidev n'y aurait pas répondu et personne n'aurait découvert ce fameux itertools.islice (enfin moi je ne l'aurais pas découvert).

[wiztricks]

Salut,

Si on pouvait enseigner ce type de réflexion aux lycéens et étudiants, informaticiens ou non, ...

S'il y a une réflexion à avoir, c'est plutôt sur comment arriver à connaitre l'existence de trucs pareils et "si je sais" comment s'en rappeler le jour où un cas d'utilisation se présentera (dans quelques semaines ou quelques mois).

Dans la pratique, on ne peut pas et le sujet dans ces cas là est un arbitrage entre trouver un truc magique ou se résoudre à l'écrire soi-même (puisqu'on sait programmer).

Si on part de la solution proposée par Sve@r basée sur "si on ne sait pas le faire par compréhension, on peut quand même le faire avec une boucle simple".
Ca donne:

Code :

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

1
2
3
4
5
6
7
result = []
for xx, d in zip(Q, norm):
        if d > delta:
           result.append( xx )
           count -= 1
           if count == 0:
                 break

Pour "condenser" çà en une seule ligne, rien n'empêche d'en faire une fonction et écrire:

Code :

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

result = extract(Q, norm, count, delta)

Et passer d'un tas de lignes de codes à son découpage en fonctions est bien plus important que d'écrire des one-liners car on a déjà non seulement un code fonctionnel mais aussi une interface qui permettra de ré-écrire la fonction un peu plus tard si nécessaire.

Dit autrement, on aurait bien pu commencer par écrire comme VinsS le suggérait:

Code :

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

1
2
def extract(Q, norm, count, delta):
       return [ xx for xx, d in zip(Q, norm) if d > delta ][:count]

Puis optimiser avec des générateurs:

Code :

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

1
2
3
def extract(Q, norm, count, delta):
    g = (xx for xx, d in zip(Q, norm) if d > delta)
    return [ next(g) for _ in range(count) ]

En connaissant les constructions de base, le programmeur a déjà plein de solutions.

Il peut même retomber sur itertools.islice et écrire:

Code :

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

extract = lambda Q, norm, delta, count: list(itertools.islice((xx for xx,d in zip(Q,norm) if d >= delta), count))

La question pourra être alors de savoir qu'est ce qui sera le plus lisible (dans 6 mois et/ou par les collègues qui auront à revoir le code).

- W

[Pyramidev]

Si j'étais pas passé par là et si je n'avais pas fait une remarque, Pyramidev n'y aurait pas répondu et personne n'aurait découvert ce fameux itertools.islice.

D'ailleurs, au moment où j'avais lu ta remarque, je ne connaissais pas encore itertools.islice.

En fait :

• Je connaissais les generator expressions.
• Je me rappelais que le module itertools avait des fonctions pour manipuler des itérables, même si je ne les avais pas toutes mémorisées.
• Je savais que, dans plusieurs autres langages, il existait une fonction take qui prenait en paramètre un entier n et un itérable (ou une autre entité du même style) et retournait un itérable qui ne parcourait que les n premiers éléments. Exemples :
  
  • take en Haskell,
  • std.range.take en D et
  • std::iter::Iterator::take en Rust.

Alors, j'ai recherché cette fonction take dans la bibliothèque standard de Python et, en fouillant dans itertools, j'ai fini par tomber sur itertools.islice.

[Supernul]

Je suis d'accord avec vous. Ma remarque portait sur l'analyse de la situation et la résolution : J'ai une solution qui fonctionne mais je détecte un point d'optimisation possible que je résous en utilisant un outil présent dans Python.

Beaucoup d'étudiants que je croise, des non informaticiens, s'arrêtent à sa marche donc c'est bien sans se poser plus de question, ce qui peut être un problème quand on en arrive à travailler avec des jeux de données de plus en plus gros, comme en science (biologie, environnements, sociologie, ...). Dans les enseignements on travaille souvent avec des petits jeux de données (quelques centaines à quelques milliers) mais dans leur travaux, il arrive qu'on joue avec de plus gros jeu de données (quelques millions ou plus) et là leur code s'effondre à cause du temps de calcul et du code que les étudiants ne remettent pas en question.

Ensuite, pour l'existence de "trucs pareils", il n'y a qu'une solution : la pratique et la recherche (documentation, lecture de codes existant, recherche sur internet, ... comme ici avec des magiciens comme vous).