Bonjour, mon problème est très simple:
soit un tableau
t = [ 1,2,8,12,74]
je veux obtenir le tableau suivant:
[ 1,1,2,2,8,8,12,12,74,74]
ou d'un manière plus générale:
soit 2 fonctions f et g:
par exemple:
def f(x):
return & % 255
def g(x):
return (x >> 8) % 255
je veux obtenir:
[f(t[0],g(t[0]),f(t[1],g(t[1]),...]
ou encore mieux avec une fontion
def h(x):
return f(x),g(x)
du coup je fait un truc du genre:
[h(x) for x in t] mais ca me donne un tableau de tupple et je veux un tableau 'à plat'.
Bonjour, mon problème est très simple: soit un tableau t = [ 1,2,8,12,74]
Disons une liste, puisque c'est le nom de ce type en Python.
je veux obtenir le tableau suivant: [ 1,1,2,2,8,8,12,12,74,74] ou d'un manière plus générale: soit 2 fonctions f et g: par exemple: def f(x): return & % 255 def g(x): return (x >> 8) % 255
je veux obtenir: [f(t[0],g(t[0]),f(t[1],g(t[1]),...]
ou encore mieux avec une fontion def h(x): return f(x),g(x)
du coup je fait un truc du genre: [h(x) for x in t] mais ca me donne un tableau de tupple et je veux un tableau 'à plat'.
Y a sûrement un moyen très simple de faire ça.
Bref, tu veux passer d'une liste de tuples à une liste à plat...
# Q&D, y a surement plus élégant (et plus générique), # mais ca répond à tes specs def flatten(tlist): flat = [] extend = flat.extend for item in tlist: extend(item) return flat
flatten([h(x) for x in t])
Bonjour, mon problème est très simple:
soit un tableau
t = [ 1,2,8,12,74]
Disons une liste, puisque c'est le nom de ce type en Python.
je veux obtenir le tableau suivant:
[ 1,1,2,2,8,8,12,12,74,74]
ou d'un manière plus générale:
soit 2 fonctions f et g:
par exemple:
def f(x):
return & % 255
def g(x):
return (x >> 8) % 255
je veux obtenir:
[f(t[0],g(t[0]),f(t[1],g(t[1]),...]
ou encore mieux avec une fontion
def h(x):
return f(x),g(x)
du coup je fait un truc du genre:
[h(x) for x in t] mais ca me donne un tableau de tupple et je veux un
tableau 'à plat'.
Y a sûrement un moyen très simple de faire ça.
Bref, tu veux passer d'une liste de tuples à une liste à plat...
# Q&D, y a surement plus élégant (et plus générique),
# mais ca répond à tes specs
def flatten(tlist):
flat = []
extend = flat.extend
for item in tlist:
extend(item)
return flat
Bonjour, mon problème est très simple: soit un tableau t = [ 1,2,8,12,74]
Disons une liste, puisque c'est le nom de ce type en Python.
je veux obtenir le tableau suivant: [ 1,1,2,2,8,8,12,12,74,74] ou d'un manière plus générale: soit 2 fonctions f et g: par exemple: def f(x): return & % 255 def g(x): return (x >> 8) % 255
je veux obtenir: [f(t[0],g(t[0]),f(t[1],g(t[1]),...]
ou encore mieux avec une fontion def h(x): return f(x),g(x)
du coup je fait un truc du genre: [h(x) for x in t] mais ca me donne un tableau de tupple et je veux un tableau 'à plat'.
Y a sûrement un moyen très simple de faire ça.
Bref, tu veux passer d'une liste de tuples à une liste à plat...
# Q&D, y a surement plus élégant (et plus générique), # mais ca répond à tes specs def flatten(tlist): flat = [] extend = flat.extend for item in tlist: extend(item) return flat
flatten([h(x) for x in t])
Maric Michaud
Bruno Desthuilliers wrote:
...
du coup je fait un truc du genre: [h(x) for x in t] mais ca me donne un tableau de tupple et je veux un tableau 'à plat'.
Y a sûrement un moyen très simple de faire ça.
Bref, tu veux passer d'une liste de tuples à une liste à plat...
# Q&D, y a surement plus élégant (et plus générique), # mais ca répond à tes specs def flatten(tlist): flat = [] extend = flat.extend for item in tlist: extend(item) return flat
flatten([h(x) for x in t])
Peut-être plus simple et plus générique :
from itertools import chain nested = (["1", "2"], ["3", "4", "5"]) [ int(e) for e in chain(*nested) ] [1, 2, 3, 4, 5]
_____________
Maric Michaud
Bruno Desthuilliers wrote:
...
du coup je fait un truc du genre:
[h(x) for x in t] mais ca me donne un tableau de tupple et je veux un
tableau 'à plat'.
Y a sûrement un moyen très simple de faire ça.
Bref, tu veux passer d'une liste de tuples à une liste à plat...
# Q&D, y a surement plus élégant (et plus générique),
# mais ca répond à tes specs
def flatten(tlist):
flat = []
extend = flat.extend
for item in tlist:
extend(item)
return flat
flatten([h(x) for x in t])
Peut-être plus simple et plus générique :
from itertools import chain
nested = (["1", "2"], ["3", "4", "5"])
[ int(e) for e in chain(*nested) ]
[1, 2, 3, 4, 5]
du coup je fait un truc du genre: [h(x) for x in t] mais ca me donne un tableau de tupple et je veux un tableau 'à plat'.
Y a sûrement un moyen très simple de faire ça.
Bref, tu veux passer d'une liste de tuples à une liste à plat...
# Q&D, y a surement plus élégant (et plus générique), # mais ca répond à tes specs def flatten(tlist): flat = [] extend = flat.extend for item in tlist: extend(item) return flat
flatten([h(x) for x in t])
Peut-être plus simple et plus générique :
from itertools import chain nested = (["1", "2"], ["3", "4", "5"]) [ int(e) for e in chain(*nested) ] [1, 2, 3, 4, 5]
_____________
Maric Michaud
Bruno Desthuilliers
(snip - en bref, passer d'une liste de tuples à une liste plate)
Peut-être plus simple et plus générique :
from itertools import chain nested = (["1", "2"], ["3", "4", "5"]) [ int(e) for e in chain(*nested) ] [1, 2, 3, 4, 5]
je me disais bien qu'il y avait quelque chose à faire avec itertools.
(snip - en bref, passer d'une liste de tuples à une liste plate)
Peut-être plus simple et plus générique :
from itertools import chain
nested = (["1", "2"], ["3", "4", "5"])
[ int(e) for e in chain(*nested) ]
[1, 2, 3, 4, 5]
je me disais bien qu'il y avait quelque chose à faire avec itertools.
(snip - en bref, passer d'une liste de tuples à une liste plate)
Peut-être plus simple et plus générique :
from itertools import chain nested = (["1", "2"], ["3", "4", "5"]) [ int(e) for e in chain(*nested) ]
c'est quoi cette syntaxe avec un '*' ? encore une partie (obscure ) de python que je ne connais pas
[1, 2, 3, 4, 5]
je me disais bien qu'il y avait quelque chose à faire avec itertools.
Laurent Pointal
(snip - en bref, passer d'une liste de tuples à une liste plate)
Peut-être plus simple et plus générique :
from itertools import chain nested = (["1", "2"], ["3", "4", "5"]) [ int(e) for e in chain(*nested) ]
c'est quoi cette syntaxe avec un '*' ? encore une partie (obscure ) de python que je ne connais pas
C'est la contrepartie de la définition d'une fonction avec *args pour permettre de recevoir un nombre variable de paramètres [1].
Utilisé lors d'un appel, la syntaxe f(*x) te permet d'appeler f comme si tu lui avait donné les éléments de x en paramètre: f(*x) <===> f(x[0],x[1],...,x[n-1])
Avant on utilisait la fonction builtin apply().
A+
[1] Voir **kwargs pour les paramètres nommés, passés via un dictionnaire.
(snip - en bref, passer d'une liste de tuples à une liste plate)
Peut-être plus simple et plus générique :
from itertools import chain
nested = (["1", "2"], ["3", "4", "5"])
[ int(e) for e in chain(*nested) ]
c'est quoi cette syntaxe avec un '*' ?
encore une partie (obscure ) de python que je ne connais pas
C'est la contrepartie de la définition d'une fonction avec *args pour
permettre de recevoir un nombre variable de paramètres [1].
Utilisé lors d'un appel, la syntaxe f(*x) te permet d'appeler f comme si
tu lui avait donné les éléments de x en paramètre:
f(*x) <===> f(x[0],x[1],...,x[n-1])
Avant on utilisait la fonction builtin apply().
A+
[1] Voir **kwargs pour les paramètres nommés, passés via un dictionnaire.
(snip - en bref, passer d'une liste de tuples à une liste plate)
Peut-être plus simple et plus générique :
from itertools import chain nested = (["1", "2"], ["3", "4", "5"]) [ int(e) for e in chain(*nested) ]
c'est quoi cette syntaxe avec un '*' ? encore une partie (obscure ) de python que je ne connais pas
C'est la contrepartie de la définition d'une fonction avec *args pour permettre de recevoir un nombre variable de paramètres [1].
Utilisé lors d'un appel, la syntaxe f(*x) te permet d'appeler f comme si tu lui avait donné les éléments de x en paramètre: f(*x) <===> f(x[0],x[1],...,x[n-1])
Avant on utilisait la fonction builtin apply().
A+
[1] Voir **kwargs pour les paramètres nommés, passés via un dictionnaire.
Maric Michaud
JBB wrote:
[ int(e) for e in chain(*nested) ]
c'est quoi cette syntaxe avec un '*' ? encore une partie (obscure ) de python que je ne connais pas
C'est nouveau (depuis 2.4 de mémoire) c'est l'équivalent de :
apply(chain, nested)
Cela veut dire que nested doit être compris comme la liste des arguments appliqués à la fonction chain.
La notation est symétrique avec la déclaration des arguments variables :
[ int(e) for e in chain(*nested) ] c'est quoi cette syntaxe avec un '*' ?
encore une partie (obscure ) de python que je ne connais pas
C'est nouveau (depuis 2.4 de mémoire)
Heu... Pas vraiment, non. C'était déjà là dans la 1.5.2 (en 1999).
Laurent Pointal
Bruno Desthuilliers wrote:
JBB wrote:
[ int(e) for e in chain(*nested) ] c'est quoi cette syntaxe avec un '*' ?
encore une partie (obscure ) de python que je ne connais pas
C'est nouveau (depuis 2.4 de mémoire)
Heu... Pas vraiment, non. C'était déjà là dans la 1.5.2 (en 1999).
Tu es sûr ?
Côté tutoriel Python, ça apparaît dans le 2.4 (chapitre "4.7.4 Unpacking Argument Lists" du tutoriel). Et je ne me souviens pas de l'avoir déjà vu avant (en tout cas, pour PyExp dont le développement a commencé sur une 1.5.2 et s'est continué jusqu'à la 2.1, j'ai été obligé d'utiliser apply).
A+
Laurent.
Bruno Desthuilliers wrote:
JBB wrote:
[ int(e) for e in chain(*nested) ]
c'est quoi cette syntaxe avec un '*' ?
encore une partie (obscure ) de python que je ne connais pas
C'est nouveau (depuis 2.4 de mémoire)
Heu... Pas vraiment, non. C'était déjà là dans la 1.5.2 (en 1999).
Tu es sûr ?
Côté tutoriel Python, ça apparaît dans le 2.4 (chapitre "4.7.4 Unpacking
Argument Lists" du tutoriel). Et je ne me souviens pas de l'avoir déjà vu
avant (en tout cas, pour PyExp dont le développement a commencé sur une
1.5.2 et s'est continué jusqu'à la 2.1, j'ai été obligé d'utiliser apply).
[ int(e) for e in chain(*nested) ] c'est quoi cette syntaxe avec un '*' ?
encore une partie (obscure ) de python que je ne connais pas
C'est nouveau (depuis 2.4 de mémoire)
Heu... Pas vraiment, non. C'était déjà là dans la 1.5.2 (en 1999).
Tu es sûr ?
Côté tutoriel Python, ça apparaît dans le 2.4 (chapitre "4.7.4 Unpacking Argument Lists" du tutoriel). Et je ne me souviens pas de l'avoir déjà vu avant (en tout cas, pour PyExp dont le développement a commencé sur une 1.5.2 et s'est continué jusqu'à la 2.1, j'ai été obligé d'utiliser apply).
A+
Laurent.
Maric Michaud
Bruno Desthuilliers wrote:
C'est nouveau (depuis 2.4 de mémoire)
Heu... Pas vraiment, non. C'était déjà là dans la 1.5.2 (en 1999).
Ok, c'est juste, enfin ça marche pour 2.1 en tout cas, je suis juste passé à côté à cette époque. J'étais resté sur cette idée puisque la fonction apply n'est signalée "deprecated" que depuis 2.3 (et non 2.4).
-- _____________
Maric Michaud
Bruno Desthuilliers wrote:
C'est nouveau (depuis 2.4 de mémoire)
Heu... Pas vraiment, non. C'était déjà là dans la 1.5.2 (en 1999).
Ok, c'est juste, enfin ça marche pour 2.1 en tout cas, je suis juste passé à
côté à cette époque. J'étais resté sur cette idée puisque la fonction apply
n'est signalée "deprecated" que depuis 2.3 (et non 2.4).
Heu... Pas vraiment, non. C'était déjà là dans la 1.5.2 (en 1999).
Ok, c'est juste, enfin ça marche pour 2.1 en tout cas, je suis juste passé à côté à cette époque. J'étais resté sur cette idée puisque la fonction apply n'est signalée "deprecated" que depuis 2.3 (et non 2.4).
