IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Python Discussion :

tester qu'une liste est "sorted"


Sujet :

Python

  1. #1
    Membre à l'essai
    Inscrit en
    Septembre 2010
    Messages
    17
    Détails du profil
    Informations forums :
    Inscription : Septembre 2010
    Messages : 17
    Points : 14
    Points
    14
    Par défaut tester qu'une liste est "sorted"
    Bonjour,

    je bloque sur une bêtise, qui révèle surement une incompréhension...
    Je veux tester qu'une liste est triée, dans l'ordre croissant
    après l'avoir créée :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    x1 = pylab.arange(0,1,0.1)
    , j'aurais bien vu quelquechose du genre :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    if(sorted(x1) != x1): ...
    mais quand je fais :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    print sorted(x1)
    print x1
    print sorted(x1) != x1
    j'obtiens :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    [0.0, 0.10000000000000001, 0.20000000000000001, 0.30000000000000004, 0.40000000000000002, 0.5, 0.60000000000000009, 0.70000000000000007, 0.80000000000000004, 0.90000000000000002]
    [ 0.   0.1  0.2  0.3  0.4  0.5  0.6  0.7  0.8  0.9]
    [False False False False False False False False False False]
    Et alors, pourquoi la fonction sorted() se permet-elle de modifier le contenu de ma liste ?
    Aussi, pourquoi 0.10000000000000001 == 0.1 ?
    ducoup,
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    if(all(sorted(x1) != x1)):...
    semble faire le boulot, mais je doute!

    merci pour vos eclaircicements !

  2. #2
    Membre éprouvé
    Avatar de afranck64
    Homme Profil pro
    Étudiant
    Inscrit en
    Janvier 2009
    Messages
    592
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 33
    Localisation : Cameroun

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Janvier 2009
    Messages : 592
    Points : 1 006
    Points
    1 006
    Par défaut
    Bonjour,
    alors tout d abord les listes, dictionnaires et classes python sont modifiable n importe ou d ou cet facheuse tendance a toujours retourner de nouveaux objets.
    Mais du moins la version de Python (<=2.6) que j utilise retourne une nouvelle liste et ne modifie pas l originale.
    Bref tu devrais creer une liste temporaire pour ton test.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    l = [1, 65, 3, -45, 99, -48]
    tmp = list[l]
    print sorted(tmp)==l
    Tu pourrais si tu le veux en faire une fonction.

  3. #3
    Membre confirmé
    Avatar de Captain'Flam
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Février 2011
    Messages
    273
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Février 2011
    Messages : 273
    Points : 455
    Points
    455
    Billets dans le blog
    1
    Par défaut
    No comprendo !
    Excuse moi alefriedx, mais je ne comprends même pas ton exemple...
    Moi ça me donne ça :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    >>> x1 = [ 1,5,96,7,5,2,32,6 ] # les valeurs n'ont pas grande importance
    >>> print sorted( x1 )
    [1, 2, 5, 5, 6, 7, 32, 96]
    >>> print x1
    [1, 5, 96, 7, 5, 2, 32, 6]
    >>> print sorted( x1 ) != x1
    True
    --> je n'obtiens pas une liste de True/False comme toi...
    Es-tu sûr que les affichages que tu as postés sont ceux des commandes du dessus ?

  4. #4
    Expert éminent
    Avatar de tyrtamos
    Homme Profil pro
    Retraité
    Inscrit en
    Décembre 2007
    Messages
    4 478
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Var (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2007
    Messages : 4 478
    Points : 9 280
    Points
    9 280
    Billets dans le blog
    6
    Par défaut
    Bonjour,

    Eh non, sorted modifie l'ordre mais pas les données elles-mêmes. Dans le raisonnement, il manque quelque chose: quand on veut saisir un nombre flottant, on tape des touches, et Python doit stocker le nombre en mémoire sous une forme normalisée binaire. Et il n'est pas toujours possible de stocker exactement le nombre saisi. Et quand on demande l'affichage, Python reprend, non pas le nombre saisi, mais le nombre stocké sous forme binaire.

    Exemple:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
     
    x1 = [0.0, 0.10000000000000001, 0.20000000000000001, 0.30000000000000004, 0.40000000000000002, 0.5, 0.60000000000000009, 0.70000000000000007, 0.80000000000000004, 0.90000000000000002]
    print x1
    x2 = sorted(x1)
    print x2
    print x2 == x1
    Ce qui affiche:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    [0.0, 0.1, 0.2, 0.30000000000000004, 0.4, 0.5, 0.6000000000000001, 0.7000000000000001, 0.8, 0.9]
    [0.0, 0.1, 0.2, 0.30000000000000004, 0.4, 0.5, 0.6000000000000001, 0.7000000000000001, 0.8, 0.9]
    True
    Tyrtamos

  5. #5
    Futur Membre du Club
    Profil pro
    Inscrit en
    Avril 2011
    Messages
    6
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Avril 2011
    Messages : 6
    Points : 7
    Points
    7
    Par défaut
    Voici une fonction permettant d'éviter de passer par le tri d'un tableau qui peut s'avérer couteux si ce dernier contient de nombreux éléments :

    Check if a list of numbers is sorted

    A+

  6. #6
    Membre éprouvé
    Homme Profil pro
    Inscrit en
    Décembre 2007
    Messages
    758
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 45
    Localisation : France

    Informations professionnelles :
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Décembre 2007
    Messages : 758
    Points : 970
    Points
    970
    Par défaut
    bonsoir,

    je ne pense pas que la question portait sur le formatage des nombres flotants, mais sur le fait que l'opérateur de comparaison renvoie 1 ou plusieurs valeurs.

    Captain'Flam, toi tu utilises des listes et l'op utilse des tableaux numpy. C'est pour cela que vous n'avez pas le même type de résultat.

    alefriedx

    je te conseille d'utiliser les fonctions numpy avec les tableaux numpy plutôt que les built-in Python.

    par exemple:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    import numpy as np
    a = np.arange(0., 5., 1.)
    b = np.sort(a)
    if np.all(a==b):
      print "ok"

  7. #7
    Membre expérimenté
    Homme Profil pro
    Inscrit en
    Mars 2007
    Messages
    941
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations forums :
    Inscription : Mars 2007
    Messages : 941
    Points : 1 384
    Points
    1 384
    Par défaut
    Comme le dit uther78, autant éviter de passer par un tri de tableau (bizarrement, son code posté utilise tout de même sorted mais le lien qu'il donne contient le bon code).

    Voici une autre possibilité, courte et élégante:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    all(x<=y for x,y in zip(x1,x1[1:]))
    Le défaut est qu'on copie la séquence (sans le premier élément) en écrivant x1[1:]. Cela signifie aussi que le conteneur doit supporter le slicing.
    Pour éviter cela, on peut utiliser un itérateur:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    it = iter(x1)
    next(it) # drop first element
    all(x<=y for x,y in zip(x1,it))
    ou bien:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    from itertools import islice
    all(x<=y for x,y in zip(l,islice(l,1,None)))
    (En Python 2.x, considérer aussi l'usage de itertools.izip au lieu de zip; en Python 3.x, zip est l'ancien izip, de la même façon que range est l'ancien xrange).

  8. #8
    Expert confirmé Avatar de PauseKawa
    Homme Profil pro
    Technicien Help Desk, maintenance, réseau, système et +
    Inscrit en
    Juin 2006
    Messages
    2 725
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Technicien Help Desk, maintenance, réseau, système et +
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juin 2006
    Messages : 2 725
    Points : 4 005
    Points
    4 005
    Par défaut
    bonjour dividee,

    Dans ton exemple il y a quand même création d'une liste (zip) et comparaison de ses éléments (all(x<=y for x,y...).
    L'exemple du parcours de la liste proprement dite et le return False à la première erreur donné dans le lien n'est il pas plus rapide pour des listes plus importantes ?

    @+

    PS: De plus cela devrait satisfaire tyrtamos puisque on travaille sur le même objet stocké.

  9. #9
    Expert confirmé Avatar de PauseKawa
    Homme Profil pro
    Technicien Help Desk, maintenance, réseau, système et +
    Inscrit en
    Juin 2006
    Messages
    2 725
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Technicien Help Desk, maintenance, réseau, système et +
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juin 2006
    Messages : 2 725
    Points : 4 005
    Points
    4 005
    Par défaut
    Plus rapide même si la liste est triée en fait.

    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
    import time
     
    l = [val for val in range(10000000)]
     
    def dividee(l):
        it = iter(l)
        next(it)
        return all(x<=y for x,y in zip(l,it))
     
    def issorted(l):
        last = None
        for e in l:
            if last and last > e:
                return False
            last = e
        return True
     
    t1 = time.clock()
    print(dividee(l))
    t2 = time.clock()
    print(t2-t1)
    t1 = time.clock()
    print(issorted(l))
    t2 = time.clock()
    print(t2-t1)

  10. #10
    Membre expérimenté Avatar de plxpy
    Homme Profil pro
    Ingénieur géographe
    Inscrit en
    Janvier 2009
    Messages
    792
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 59
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Ingénieur géographe
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Janvier 2009
    Messages : 792
    Points : 1 481
    Points
    1 481
    Par défaut
    J'aime beaucoup le

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    all(x<=y for x,y in zip(x1,x1[1:]))
    au pire, si l'on veut être robuste au problème de "slicing" :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    >>> x1 = xrange(5)
    >>> all(x<=y for x,y in zip(x1,x1[1:]))
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: sequence index must be integer, not 'slice'
    on peut passer par les indices (un peu moins élégant, certes) :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    >>> x1 = xrange(5)
    >>> all(x1[i]<=x1[i+1] for i in xrange(len(x1)-1))
    True
    Niveau temps, sur l'exemple de PauseKawa, elle se situe entre les 2 propositions précédentes.

    Dans l'ordre 4.3, 0.9 et 2.0 pour cette troisième façon.

    Je suis assez étonné du temps pris par cette dernière approche, comparativement à l'utilisation de issorted (je pensais que ce serait du même ordre de grandeur)

    C'est le xrange pour la génération des indices qui fait, à ce point, chuter les perfos ?

  11. #11
    Expert confirmé Avatar de PauseKawa
    Homme Profil pro
    Technicien Help Desk, maintenance, réseau, système et +
    Inscrit en
    Juin 2006
    Messages
    2 725
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Technicien Help Desk, maintenance, réseau, système et +
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juin 2006
    Messages : 2 725
    Points : 4 005
    Points
    4 005
    Par défaut
    Les résultats ne sont pas vraiment surprenants.
    Avec xrange on se retrouve avec un générateur (c'est déjà mieux que zip) mais qui retourne toujours une nouvelle liste. On se retrouve donc toujours avec la création d'une nouvelle liste.
    On parcours toujours cette dite liste au complet dans tous les cas contrairement à l'exemple donné.

  12. #12
    Expert éminent
    Avatar de tyrtamos
    Homme Profil pro
    Retraité
    Inscrit en
    Décembre 2007
    Messages
    4 478
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Var (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2007
    Messages : 4 478
    Points : 9 280
    Points
    9 280
    Billets dans le blog
    6
    Par défaut
    Bonjour,

    Je suis souvent très impressionné par les opérations très concises, mais je suis souvent déçu par leurs performances.

    Aussi, je préfère nettement un code plus "rustique" comme celui-ci:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    def triok(x):
        for i in xrange(0,len(x)-1):
            if x[i]>x[i+1]:
                return False
        return True
    Sur une liste de 10 millions d'entiers triés, cette fonction est environ 5 fois plus rapide que la fonction "all(x<=y for x,y in zip(x1,x1[1:]))".

    En plus, c'est très lisible.

    Tyrtamos

  13. #13
    Expert confirmé Avatar de PauseKawa
    Homme Profil pro
    Technicien Help Desk, maintenance, réseau, système et +
    Inscrit en
    Juin 2006
    Messages
    2 725
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Technicien Help Desk, maintenance, réseau, système et +
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juin 2006
    Messages : 2 725
    Points : 4 005
    Points
    4 005
    Par défaut
    Tout à fais

    Par contre la génération de liste par xrange ralenti encore le traitement par rapport au simple parcour de la liste d'origine.

  14. #14
    Membre expérimenté
    Homme Profil pro
    Inscrit en
    Mars 2007
    Messages
    941
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations forums :
    Inscription : Mars 2007
    Messages : 941
    Points : 1 384
    Points
    1 384
    Par défaut
    Comme je l'ai dit il vaut mieux utiliser izip en Python 2.x (on passe de 4.3s à 1.5s). Mais c'est vrai que la version impérative est quand-même plus rapide (0.9s). Je crois que je me suis habitué aux idiomes fonctionnels, et je comprends tout de suite le code avec all et zip, alors que la version impérative me demande plus d'efforts...

    On peut éviter de tester last dans la boucle;
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    def issorted(l):
        if len(l) == 0 : return True
        last = l[0]
        for e in l:
            if last > e:
                return False
            last = e
        return True
    En fait, en Python 2.x, on peut même laisser le code original et juste supprimer le test de last dans la boucle, car None est plus petit que toute autre valeur (None > e sera toujours évalué à False, quel que soit la valeur de e) mais ce n'est plus le cas en Python 3.

    [EDIT]
    Tyrtamos, que penses-tu de ceci, au niveau lisibilité je ne pense pas qu'on puisse faire mieux:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    all(x[i]<=x[i+1] for i in xrange(len(l)-1))

  15. #15
    Membre éprouvé
    Avatar de afranck64
    Homme Profil pro
    Étudiant
    Inscrit en
    Janvier 2009
    Messages
    592
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 33
    Localisation : Cameroun

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Janvier 2009
    Messages : 592
    Points : 1 006
    Points
    1 006
    Par défaut
    Et pourquoi creer une xrange juste pour eviter de faire un while? Dans ce que je rabattrais volontier a un bon vieux <while> a la Pascal/C

  16. #16
    Expert éminent
    Avatar de tyrtamos
    Homme Profil pro
    Retraité
    Inscrit en
    Décembre 2007
    Messages
    4 478
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Var (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2007
    Messages : 4 478
    Points : 9 280
    Points
    9 280
    Billets dans le blog
    6
    Par défaut
    Bonjour dividee,

    Effectivement, le dernier code issorted(l) qui évite xrange et les indices est d'environ 20% plus rapide que ma fonction triok(): j'adopte!

    Citation Envoyé par dividee Voir le message
    Tyrtamos, que penses-tu de ceci, au niveau lisibilité je ne pense pas qu'on puisse faire mieux:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    all(x[i]<=x[i+1] for i in xrange(len(l)-1))
    Effectivement, je la comprends mieux, même s'il m'arrive assez souvent d'utiliser zip. Mais je ne sais pas comment fonctionne "all": si il attend que tout soit calculé pour répondre, c'est plus long avec les mauvais tris. Avec les bons tris, elle reste encore 60% moins rapide que ma fonction triok(). La solution avec izip de itertools gagne encore un peu (env. 5%).

    Tyrtamos

  17. #17
    Expert confirmé Avatar de PauseKawa
    Homme Profil pro
    Technicien Help Desk, maintenance, réseau, système et +
    Inscrit en
    Juin 2006
    Messages
    2 725
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Technicien Help Desk, maintenance, réseau, système et +
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juin 2006
    Messages : 2 725
    Points : 4 005
    Points
    4 005
    Par défaut
    Bonjour,

    Joli dividee.

    Citation Envoyé par dividee Voir le message
    En fait, en Python 2.x, on peut même laisser le code original et juste supprimer le test de last dans la boucle, car None est plus petit que toute autre valeur (None > e sera toujours évalué à False, quel que soit la valeur de e) mais ce n'est plus le cas en Python 3.
    Pas suivit... c'est à dire ?

    @+

    Edit : Erreur de quote...

  18. #18
    Expert confirmé Avatar de PauseKawa
    Homme Profil pro
    Technicien Help Desk, maintenance, réseau, système et +
    Inscrit en
    Juin 2006
    Messages
    2 725
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Technicien Help Desk, maintenance, réseau, système et +
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juin 2006
    Messages : 2 725
    Points : 4 005
    Points
    4 005
    Par défaut
    Citation Envoyé par PauseKawa Voir le message
    Pas suivit... c'est à dire ?
    Courge attitude... TypeError NoneType() Int()...

  19. #19
    Membre expérimenté Avatar de plxpy
    Homme Profil pro
    Ingénieur géographe
    Inscrit en
    Janvier 2009
    Messages
    792
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 59
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Ingénieur géographe
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Janvier 2009
    Messages : 792
    Points : 1 481
    Points
    1 481
    Par défaut
    Citation Envoyé par tyrtamos Voir le message
    ...
    Mais je ne sais pas comment fonctionne "all": si il attend que tout soit calculé pour répondre
    ...
    quand même pas (mais je me suis posé la question) :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    >>> def compare(a,b):
    ...     print "compare", a, "et", b
    ...     return a <= b
    ... 
    >>> liste= [1,2,3,4,1,5,6,7]
    >>> all(compare(x,y) for x,y in zip(liste,liste[1:]))
    compare 1 et 2
    compare 2 et 3
    compare 3 et 4
    compare 4 et 1
    False
    >>>

  20. #20
    Membre expérimenté
    Homme Profil pro
    Inscrit en
    Mars 2007
    Messages
    941
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations forums :
    Inscription : Mars 2007
    Messages : 941
    Points : 1 384
    Points
    1 384
    Par défaut
    Dans la documentation de Python (2.7) :
    all(iterable)
    Return True if all elements of the iterable are true (or if the iterable is empty). Equivalent to:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    def all(iterable):
        for element in iterable:
            if not element:
                return False
        return True
    Cela ressemble fortement à la version impérative de issorted, n'est-ce pas? Cette "brique" est trop belle pour ne pas l'utiliser
    Dommage que les performances soient inférieures... C'est le prix à payer pour un niveau d'abstraction supérieur, je suppose.

Discussions similaires

  1. [WD17] Tester si une liste est initialisée ou pas
    Par droliprane dans le forum WinDev
    Réponses: 10
    Dernier message: 10/12/2013, 17h45
  2. Réponses: 4
    Dernier message: 17/12/2007, 14h46
  3. Tester si une liste (SELECT) est ouverte ?
    Par Hibou57 dans le forum Général JavaScript
    Réponses: 2
    Dernier message: 29/07/2007, 18h59

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo