Publicité
+ Répondre à la discussion
Page 1 sur 2 12 DernièreDernière
Affichage des résultats 1 à 20 sur 24
  1. #1
    Futur Membre du Club
    Homme Profil pro
    Inscrit en
    août 2011
    Messages
    46
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : août 2011
    Messages : 46
    Points : 18
    Points
    18

    Par défaut [Script] Scan de réseau

    Bonjour à tous,

    Je rencontres un petit soucis dans le cadre d'un script.

    Celui ci à pour but de scanner une plage d'adresses IP afin de retourner le nom de domaine correspondant grace à un socket.gethostbyaddr(ip).

    J'ai donc une variable de type liste 'list' (list = [192.9.202.1, 192.9.202.2, ...] avec toutes les IP, voici comment je fonctionnes (j'utilise le threading pour que les requêtes soit effectué simultanément) :

    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
     
    for x in list:
        t=threading.Thread(target=scan, args=(x,))
        t.start
     
    def scan(ip):
        try:
            name,alias,addresslist = socket.gethostbyaddr(ip)
            final = final.append(ip + ' <-> ' + name)
        except socket.herror:
            final = final.append(ip + ' <->  Aucune reponse')
    Je me retrouves donc avec une liste 'final' contenant les résultats des requêtes. Après sa, je créé un document excel qui liste tout sa ... Mon problème vient ici, car les ip ne sont pas en ordre croissant ...

    Comment est il possible d'enregistrer les résultats, tout en liant l'ip + name et de pouvoir réorganiser sa avec les adressis ip par ordre croissant ? Dictionnaire ? Tuple ? N'ayant pas trop utilisé ceux ci je vous avou être en difficulté ...

  2. #2
    Expert Confirmé
    Avatar de tyrtamos
    Profil pro
    Inscrit en
    décembre 2007
    Messages
    2 285
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : décembre 2007
    Messages : 2 285
    Points : 3 780
    Points
    3 780

    Par défaut

    Bonjour,

    Donne un exemple de la liste 'avant', et le résultat que tu souhaites 'après'.
    Ne rien ranger permet d'observer la loi universelle d'entropie: l'inévitable convergence vers le chaos...
    Mes recettes python: http://www.jpvweb.com

  3. #3
    Expert Confirmé Sénior
    Avatar de Sve@r
    Homme Profil pro Frédéric
    Ingénieur développement logiciels
    Inscrit en
    février 2006
    Messages
    4 441
    Détails du profil
    Informations personnelles :
    Nom : Homme Frédéric
    Âge : 46
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : février 2006
    Messages : 4 441
    Points : 8 727
    Points
    8 727

    Par défaut

    Citation Envoyé par BUENOO Voir le message
    Comment est il possible d'enregistrer les résultats, tout en liant l'ip + name et de pouvoir réorganiser sa avec les adressis ip par ordre croissant ? Dictionnaire ? Tuple ? N'ayant pas trop utilisé ceux ci je vous avou être en difficulté ...
    Salut
    Moi je passerais par un dictionnaire de type "ip" => "name".
    Exemple
    Code python :
    1
    2
    3
    4
    5
    final={
        "127.0.0.1" : "localhost",
        "158.55.42.123" : "www.truc.com",
        "222.41.77.30" : "www.chose.com",
    }

    Ensuite, en utilisant sorted(final.keys(), fct) ça te donnerait les IP par ordre croissant (à toi de programmer la fonction "fct" pour que sorted connaisse ta façon de comparer 2 IP) ce qui amènerait automatiquement les noms associés...
    Exemple
    Code python :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    def fct(ip1, ip2):
        if ip1 < ip2: return -1
        if ip1 > ip2: return 1
        return 0
        # Bien entendu à toi d'écrire le vrai code permettant de comparer 2 IP
    # fct()
     
    for k in sorted(final.keys(), fct):
        print "ip:[%s] => [%s]" % (k, final[k])
    Vous ne pouvez pas apporter la prospérité au pauvre en la retirant au riche.
    Tout ce qu'un individu reçoit sans rien faire pour l'obtenir, un autre individu a dû travailler pour le produire sans en tirer profit.
    Tout Pouvoir ne peut distribuer aux uns que ce qu'il a préalablement confisqué à d'autres car on n'accroît pas les biens en les divisant.
    Quand la moitié d'un peuple croit qu'il ne sert à rien de faire des efforts car l'autre moitié les fera pour elle, et quand cette dernière moitié se dit qu'il ne sert à rien d'en faire car ils bénéficieront à d'autres, cela s'appelle le déclin et la fin d'une nation.
    Dr. Adrian Rogers (1931-2005)

  4. #4
    Membre Expert
    Profil pro
    Développeur en systèmes embarqués
    Inscrit en
    mars 2006
    Messages
    838
    Détails du profil
    Informations personnelles :
    Localisation : France, Bas Rhin (Alsace)

    Informations professionnelles :
    Activité : Développeur en systèmes embarqués
    Secteur : Industrie

    Informations forums :
    Inscription : mars 2006
    Messages : 838
    Points : 1 064
    Points
    1 064

    Par défaut

    Salut,

    pour trier de l' ip, le plus simple est de s'arranger pour le faire en mode texte, mais en formatant les ips. Par exemple trier '127.0.0.1' et '127.255.0.0' ne donnera pas forcément le même résultat que trier '127000000001' et '127255000000'. En python on a hérité du printf du C, le "f" de printf signifiant format.

    Code :
    1
    2
    text = "%03u%03u%03u%03u"%(127, 0, 0, 1)
    print text
    Il y a également une méthode split qui se révèle très utile:

    Code :
    1
    2
    words = '127.0.0.1'.split('.')
    print words
    Avec ça, tu devrais t'en sortir

    A+

    Pfeuh

  5. #5
    Futur Membre du Club
    Homme Profil pro
    Inscrit en
    août 2011
    Messages
    46
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : août 2011
    Messages : 46
    Points : 18
    Points
    18

    Par défaut

    Bonjour,

    Merci pour vos réponses.

    Alors voilà comment ma liste est construite :
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
     
    #Recuperation des donnees (ip debut et ip fin)
    debut = raw_input('Ip du debut de la plage a scanner : \n')
    fin = raw_input('Ip de la fin de la plage a scanner : \n')
     
    #Separation des ip par les points 192.9.200.1 = '192', '9', '200', '1'
    d_split = debut.split('.')
    f_split = fin.split('.')
     
    #Creation d'une ip de base 192.9.200
    base = '.'.join(d_split[0:3])
     
    #Creation list vide pour reception des ip a scanner
    list = []
    i = int(d_split[3])
     
    #Listing et ajout des ip a scanner dans list
    while i <= int(f_split[3]):
    			list.append(str(base) + '.' + str(i))
    			i += 1
    Sa me donne donc par exemple : list = ['192.9.202.1','192.9.202.2','192.9.202.3','192.9.202.4',.....]

    La solution de Svear est ce que je recherches je penses. Le but étant simplement de pouvoir réorganiser les IP une fois qu'un nom lui à été attribué par la requête.
    Par exemple pour réorganiser une liste comme celle ci :
    Code :
    1
    2
    3
    4
    5
    6
    7
     
    final= {
        "192.9.202.15" : "Toto.domaine",
        "192.9.202.11" : "Stagiaire.domaine",
        "192.9.202.8" : "Thomas.domaine",
        "192.9.202.5" : "Benjamin.domaine",
    }
    De sorte que sa donne :
    Code :
    1
    2
    3
    4
    5
    6
    7
     
    final = {
        "192.9.202.5" : "Benjamin.domaine",
        "192.9.202.8" : "Thomas.domaine",
        "192.9.202.11" : "Stagiaire.domaine",
        "192.9.202.15" : "Toto.domaine",
    }
    Je vais regarder sa cette après midi dès que j'ai le temps et je me retournes vers vous pour vous tenir informer.

    Merci bien.

  6. #6
    Modérateur

    Homme Profil pro
    Architecte technique
    Inscrit en
    juin 2008
    Messages
    5 368
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Architecte technique
    Secteur : Industrie

    Informations forums :
    Inscription : juin 2008
    Messages : 5 368
    Points : 7 511
    Points
    7 511

    Par défaut

    Pour info.

    Python 3.3 vient avec le module "ipaddress" - ce module doit pouvoir être installé sur des versions antérieures. Il contient des tas de fonctions pour convertir des adresses IPv4 et v6 dans tous les sens.

    Si vous voulez convertir des adresses IP en entiers (et les ranger par ordre croissants par exemple) :
    Code :
    1
    2
    >>> int(ipaddress.IPv4Address('192.168.1.0'))
    3232235776
    Réciproquement,
    Code :
    1
    2
    >>> ipaddress.IPv4Address(3232235776)
    IPv4Address('192.168.1.0')
    D'un autre côté, une plage d'adresse IP est généralement associé à un s/réseau "192.168.1.0/24" et les numéros 1.255 sont des numéros de host dans ce s/réseau.
    => ranger par s/réseau puis par numéro de "host" est une autre façon de faire.

    - W
    Architectures Post-Modernes

  7. #7
    Expert Confirmé
    Avatar de tyrtamos
    Profil pro
    Inscrit en
    décembre 2007
    Messages
    2 285
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : décembre 2007
    Messages : 2 285
    Points : 3 780
    Points
    3 780

    Par défaut

    Bonjour,

    Intéressant, merci wiztricks.

    Il s'agit en fait de convertir en décimal un nombre écrit en base 256, et vice versa:

    Code :
    1
    2
    3
    x1, x2, x3, x4 = 192, 168, 1, 0
    print x4 + x3*256 + x2*256**2 + x1*256**3
    3232235776
    Code :
    1
    2
    3
    4
    5
    6
    7
    x = 3232235776
    x, x4 = divmod(x, 256)
    x, x3 = divmod(x, 256)
    x, x2 = divmod(x, 256)
    x1 = x
    print x1, x2, x3, x4
    192 168 1 0
    Ne rien ranger permet d'observer la loi universelle d'entropie: l'inévitable convergence vers le chaos...
    Mes recettes python: http://www.jpvweb.com

  8. #8
    Modérateur

    Homme Profil pro
    Architecte technique
    Inscrit en
    juin 2008
    Messages
    5 368
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Architecte technique
    Secteur : Industrie

    Informations forums :
    Inscription : juin 2008
    Messages : 5 368
    Points : 7 511
    Points
    7 511

    Par défaut

    Salut,
    Citation Envoyé par tyrtamos Voir le message
    Il s'agit en fait de convertir en décimal un nombre écrit en base 256, et vice versa:
    C'est une représentation commode.
    Mais en exprimant les s/réseau, on y perd vite son latin.
    En fait, le module inclus la comparaison d'adresses et ces objets sont hashables.

    On peut donc écrire:
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
     
    >>> net = ipaddress.ip_network('192.168.1.0/29')
    >>> for z in net: 
    ...         print(z)
    ...
    192.168.1.0
    192.168.1.1
    192.168.1.2
    192.168.1.3
    192.168.1.4
    192.168.1.5
    192.168.1.6
    192.168.1.7
    >>> z1 = net[0]
    >>> z2 = net[1]
    >>> z1 < z2
    True
    >>> dd = { z1: None, z2: None }
    >>> dd
    {IPv4Address('192.168.1.0'): None, IPv4Address('192.168.1.1'): None}
    Inutile de convertir l'adresse en entier pour "ranger" tout est dedans.
    Vous pouvez bien sur faire votre cuisine à vous.
    Il n'est jamais inutile de comprendre comment çà marche.

    Mais si ce module a été intégré à la PSL, c'est en général suite à de nombreuses discussions pour valider que l'API répondait à de nombreux cas d'utilisation.
    Et çà fait toujours çà de moins à maintenir, documenter, tester,..
    - W
    Architectures Post-Modernes

  9. #9
    Membre Expert
    Homme Profil pro
    Inscrit en
    mars 2007
    Messages
    895
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations forums :
    Inscription : mars 2007
    Messages : 895
    Points : 1 196
    Points
    1 196

    Par défaut

    Personne ne tique sur la mutation d'une liste sans lock dans les threads ? Il se peut que ça ne pose pas de problème ici, si on se contente de faire un append, mais je ne prendrais pas ça pour acquis...

  10. #10
    Modérateur

    Homme Profil pro
    Architecte technique
    Inscrit en
    juin 2008
    Messages
    5 368
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Architecte technique
    Secteur : Industrie

    Informations forums :
    Inscription : juin 2008
    Messages : 5 368
    Points : 7 511
    Points
    7 511

    Par défaut

    Citation Envoyé par dividee Voir le message
    Personne ne tique sur la mutation d'une liste sans lock dans les threads ? Il se peut que ça ne pose pas de problème ici, si on se contente de faire un append, mais je ne prendrais pas ça pour acquis...
    Bonne remarque.
    En fait, je ne suis pas sûr que .gethostbyaddr puisse s'exécuter en parallèle.
    Ca doit sérialiser sur un verrou de l'OS protégeant ses structures partagées.
    - W
    Architectures Post-Modernes

  11. #11
    Membre Expert
    Homme Profil pro
    Inscrit en
    mars 2007
    Messages
    895
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations forums :
    Inscription : mars 2007
    Messages : 895
    Points : 1 196
    Points
    1 196

    Par défaut

    Citation Envoyé par wiztricks Voir le message
    En fait, je ne suis pas sûr que .gethostbyaddr puisse s'exécuter en parallèle.
    Ca m'étonnerait qu'il ne puisse pas; si c'était la cas, il n'y aurait pas grand intérêt à utiliser des threads, il me semble.

    Je me demandais plutôt si le GIL était libéré lors de l'appel à append.

  12. #12
    Modérateur

    Homme Profil pro
    Architecte technique
    Inscrit en
    juin 2008
    Messages
    5 368
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Architecte technique
    Secteur : Industrie

    Informations forums :
    Inscription : juin 2008
    Messages : 5 368
    Points : 7 511
    Points
    7 511

    Par défaut

    Citation Envoyé par dividee Voir le message
    Je me demandais plutôt si le GIL était libéré lors de l'appel à append.
    Pour CPython, çà dit:
    global interpreter lock

    The mechanism used by the CPython interpreter to assure that only one thread executes Python bytecode at a time. This simplifies the CPython implementation by making the object model (including critical built-in types such as dict) implicitly safe against concurrent access. Locking the entire interpreter makes it easier for the interpreter to be multi-threaded, at the expense of much of the parallelism afforded by multi-processor machines.

    However, some extension modules, either standard or third-party, are designed so as to release the GIL when doing computationally-intensive tasks such as compression or hashing. Also, the GIL is always released when doing I/O.

    Past efforts to create a “free-threaded” interpreter (one which locks shared data at a much finer granularity) have not been successful because performance suffered in the common single-processor case. It is believed that overcoming this performance issue would make the implementation much more complicated and therefore costlier to maintain.
    Et le code fait ce que dit la doc donc c'est "thread safe" (dans le cas CPython).
    - W
    Architectures Post-Modernes

  13. #13
    Futur Membre du Club
    Homme Profil pro
    Inscrit en
    août 2011
    Messages
    46
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : août 2011
    Messages : 46
    Points : 18
    Points
    18

    Par défaut

    Bonjour

    Je suis en plein de test de ce que Svear m'avait montré. Concernant ta remarque Wiz, sur le module "ipadress", je n'utilises pas python 3.x car enfaite derrière j'ai besoin de la bibliothèque pour les fichiers excels qui il me semble n'est pas disponible avec python 3.x ...

    Par contre là "Personne ne tique sur la mutation d'une liste sans lock dans les threads ?" vous m'avez un peu perdu
    Enfête j'ai utilisé les threads, car imaginons que j'avais 50ip à faire, c'était super long, car il attend que le premier gethostbyaddr() se finisse ... alors quand y'a pas de réponse et que du coup il attend ... je vous laisses imaginer

  14. #14
    Modérateur

    Homme Profil pro
    Architecte technique
    Inscrit en
    juin 2008
    Messages
    5 368
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Architecte technique
    Secteur : Industrie

    Informations forums :
    Inscription : juin 2008
    Messages : 5 368
    Points : 7 511
    Points
    7 511

    Par défaut

    Salut,
    En fait ce sont de faux problèmes.
    Désolé pour avoir semé la confusion dans votre esprit.
    - W
    Architectures Post-Modernes

  15. #15
    Futur Membre du Club
    Homme Profil pro
    Inscrit en
    août 2011
    Messages
    46
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : août 2011
    Messages : 46
    Points : 18
    Points
    18

    Par défaut

    Bonjour,

    Je reviens vers vous car je n'arrives pas à trouver une solution ...

    Actuellement j'ai pensé à ceci. J'ai ma list_ip = ['192.9.202.1','192.9.202.2','19.9.202.3','192.9.202.4','192.9.202.5'] qui est dans l'ordre et que j'utilises pour faire les requêtes ET list_dic = {'192.9.202.3' : 'toto', '192.9.202.2' : 'titi', '192.9.202.5' : 'tutu', '192.9.202.4' : 'tata', '192.9.202.1' : 'tyty'}.
    Je me suis donc dit qu'en utilisant les deux j'aurais moyen de faire sa :

    Code :
    1
    2
    3
    4
     
    for x,y in list_dic:
        if x == z in list_ip:
            #Ici, j'aurais souhaité ajouter y (la value de mon dictionnaire) lors que les ip concordent, mais est ce possible car je n'y parviens pas ?
    Par avance merci pour vos idées à venir.

  16. #16
    Modérateur

    Homme Profil pro
    Architecte technique
    Inscrit en
    juin 2008
    Messages
    5 368
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Architecte technique
    Secteur : Industrie

    Informations forums :
    Inscription : juin 2008
    Messages : 5 368
    Points : 7 511
    Points
    7 511

    Par défaut

    Je ne vois pas trop ce que vous cherchez à faire avec l'instruction
    if x == z in list_ip:
    "z in list_ip" retourne un boolean alors que x est un "str".

    Si votre soucis est de préserver l'ordre, pourquoi ne pas utiliser un OrderedDict?
    C'est un dict dans le module collection qui devrait être dispo en 2.7
    - W
    Architectures Post-Modernes

  17. #17
    Modérateur

    Homme Profil pro
    Architecte technique
    Inscrit en
    juin 2008
    Messages
    5 368
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Architecte technique
    Secteur : Industrie

    Informations forums :
    Inscription : juin 2008
    Messages : 5 368
    Points : 7 511
    Points
    7 511

    Par défaut

    Je ne vois pas trop ce que vous cherchez à faire avec l'instruction
    if x == z in list_ip:
    "z in list_ip" retourne un boolean alors que x est un "str".

    Si votre soucis est de préserver l'ordre, pourquoi ne pas utiliser un OrderedDict?
    C'est un dict dans le module collection qui devrait être dispo en 2.7
    - W
    Architectures Post-Modernes

  18. #18
    Futur Membre du Club
    Homme Profil pro
    Inscrit en
    août 2011
    Messages
    46
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : août 2011
    Messages : 46
    Points : 18
    Points
    18

    Par défaut

    Re,

    J'ai donc essayé OrderedDict mais sa ne fonctionne pas pour mon problème ...

    Code :
    1
    2
    3
    4
    5
    6
    7
     
    final= {
        "192.9.202.15" : "Toto.domaine",
        "192.9.202.11" : "Stagiaire.domaine",
        "192.9.202.8" : "Thomas.domaine",
        "192.9.202.5" : "Benjamin.domaine",
    }
    Mon but est que les ip dans final soit croissante sachant que je ne peux utiliser le module ipadresse car je suis sous python 2.7.

  19. #19
    Expert Confirmé
    Avatar de tyrtamos
    Profil pro
    Inscrit en
    décembre 2007
    Messages
    2 285
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : décembre 2007
    Messages : 2 285
    Points : 3 780
    Points
    3 780

    Par défaut

    Bonjour,

    Voilà une solution avec OrderedDict (Python 2.7):

    Code :
    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
    from collections import OrderedDict
     
    final= {
        "192.9.202.15" : "Toto.domaine",
        "192.9.202.11" : "Stagiaire.domaine",
        "192.9.202.8" : "Thomas.domaine",
        "192.9.202.5" : "Benjamin.domaine",
    }
     
    def cle(ip):
        """conversion de l'IP en nombre pour trier les IP"""
        c1, c2, c3, c4 = ip.split('.')
        return int(c4) + int(c3)*256 + int(c2)*256**2 + int(c1)*256**3
     
    odict = OrderedDict(sorted(final.items(), key=lambda t: cle(t[0])))
     
    print odict
    OrderedDict([('192.9.202.5', 'Benjamin.domaine'), ('192.9.202.8', 'Thomas.domaine'), ('192.9.202.11', 'Stagiaire.domaine'), ('192.9.202.15', 'Toto.domaine')])
     
    print odict['192.9.202.8']
    'Thomas.domaine'
     
    for ip in odict:
        print ip, odict[ip]
    192.9.202.5 Benjamin.domaine
    192.9.202.8 Thomas.domaine
    192.9.202.11 Stagiaire.domaine
    192.9.202.15 Toto.domaine
    Ne rien ranger permet d'observer la loi universelle d'entropie: l'inévitable convergence vers le chaos...
    Mes recettes python: http://www.jpvweb.com

  20. #20
    Futur Membre du Club
    Homme Profil pro
    Inscrit en
    août 2011
    Messages
    46
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : août 2011
    Messages : 46
    Points : 18
    Points
    18

    Par défaut

    Merci Tyrtamos ! J'avais pensé à refaire un split des ip comme j'ai fait pour générer la plage d'ip, j'étais entrain d'essayer de faire fonctionner sa. Un grand merci à vous !

    Par contre j'aurais une petite question à ce sujet :

    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
     
    from collections import OrderedDict
     
    final = {'192.9.202.15' : 'tutu', '192.9.202.10' : 'tata', '192.9.202.1' : 'toto', '192.9.202.11' : 'titi'}
     
    def cle(ip):
        c1,c2,c3,c4 = ip.split('.')
        return int(c4)
     
    final_sorted = OrderedDict(sorted(final.items(), key=lambda t: cle(t[0])))
    Sa fonctionne parfaitement, donc pourquoi tu as utilisé les c1, c2 et c3 ET pourquoi les avoir multiplié comme tu l'as fait ?

+ Répondre à la discussion
Cette discussion est résolue.
Page 1 sur 2 12 DernièreDernière

Liens sociaux

Règles de messages

  • Vous ne pouvez pas créer de nouvelles discussions
  • Vous ne pouvez pas envoyer des réponses
  • Vous ne pouvez pas envoyer des pièces jointes
  • Vous ne pouvez pas modifier vos messages
  •