Posso fidarmi dell'ordinanza di un dict di rimanere uguale ogni volta che viene ripetuto?

Question

ho i seguenti tre corde (che esistono indipendentemente ma vengono visualizzate qui insieme per comodità):

from mx2.x.org (mx2.x.org. [198.186.238.144]) 
      by mx.google.com with ESMTPS id g34si6312040qgg.122.2015.04.22.14.49.15 
      (version=TLSv1 cipher=ECDHE-RSA-RC4-SHA bits=128/128); 
      Wed, 22 Apr 2015 14:49:16 -0700 (PDT) 

from HQPAMAIL08.x.org (10.64.17.33) by HQPAMAIL13.x.x.org 
(10.34.25.11) with Microsoft SMTP Server (TLS) id 14.2.347.0; Wed, 22 Apr 
2015 17:49:13 -0400 

from HQPAMAIL13.x.org ([fe80::7844:1f34:e8b2:e526]) by 
HQPAMAIL08.iadb.org ([fe80::20b5:b1cb:9c01:aa86%18]) with mapi id 
14.02.0387.000; Wed, 22 Apr 2015 17:49:12 -0400 

Sto cercando di compilare un dict con alcuni valori basati sul invertita (basso verso l'alto) ordine di le stringhe. In particolare, per ogni stringa, sto estraendo l'indirizzo IP come indice di ordinamento e quindi la stringa completa come valore.

Dato che l'ordine è importante, ho deciso di andare con le liste, e inizialmente ha fatto qualcosa di simile (pseudocodice, con il gruppo al di sopra del testo):

IPs =[] 
fullStrings =[] 
for string in strings: 
    IPs.append[$theIpAddressFoundInTheString] 
    fullstrings.append[$theWholeString] 

risultato i seguenti due liste (di nuovo, solo un esempio):

IPs ['198.186.238.144', '10.64.17.33', 'fe80::7844:1f34:e8b2:e526'] 

fullstrings ['from mx2.x.org (mx2.x.org. [198.186.238.144]) 
       by mx.google.com with ESMTPS id g34si6312040qgg.122.2015.04.22.14.49.15 
       (version=TLSv1 cipher=ECDHE-RSA-RC4-SHA bits=128/128); 
       Wed, 22 Apr 2015 14:49:16 -0700 (PDT)', 'from HQPAMAIL08.x.org (10.64.17.33) by HQPAMAIL13.x.x.org 
    (10.34.25.11) with Microsoft SMTP Server (TLS) id 14.2.347.0; Wed, 22 Apr 
    2015 17:49:13 -0400', 'from HQPAMAIL13.x.org ([fe80::7844:1f34:e8b2:e526]) by 
    HQPAMAIL08.x.org ([fe80::20b5:b1cb:9c01:aa86%18]) with mapi id 
    14.02.0387.000; Wed, 22 Apr 2015 17:49:12 -0400'] 

Ciò ha funzionato benissimo fino ad un certo punto, ma ora mentre inizio popolare un dict con i valori in queste liste (a indici hardcoded), confrontandoli valori di altre liste (nuovamente a har indici codificati) ecc., non solo il debug diventa un dolore, il codice diventa insostenibile.

Sto iniziando a riscrivere utilizzando un dict (restituendo un dict in cui gli indirizzi IP sono le chiavi e le stringhe complete sono i valori). Allora io eseguire operazioni quali:

for k,v in myDictOfIpsAndStrings: 
    anotherDict[$someHardcodedText] = k 
    anotherDict[$otherHardcodedText] = v   

Ecco la mia preoccupazione: posso essere sicuro che il dict, ogni volta che viene iterato sopra, sarà sempre fatto nell'ordine in cui è stato creato il dict? In caso contrario, è la mia unica opzione per tornare agli elenchi (e il noioso e fragile confronto lunghezza, le assegnazioni inerenti a farlo), ecc?

So che un ditt è, per sua stessa natura, non ordinato. E so della funzione sorted, ma non sto cercando di ordinare le chiavi in ​​base a qualsiasi ordine discendente/ascendente, ecc. Piuttosto si tratta di mantenere (in qualche modo) l'ordine in cui è stato creato il dict.

Answer 1

posso essere sicuro che il comando, ogni volta che viene ripetuto, verrà sempre eseguito nell'ordine in cui è stato creato il comando?

No, uno dict non è ordinato, e disporrà il suo ordine ma la particolare implementazione decide di farlo.

>>> d = {3: 'c', 2: 'b', 1: 'a'} 
>>> d 
{1: 'a', 2: 'b', 3: 'c'} 

Sede, subito dopo ho creato il dict l'ordine è cambiato.

Se si vuole essere sicuri di avere un deterministico, ordine controllabile, è possibile utilizzare un collections.OrderedDict

>>> from collections import OrderedDict 
>>> d = OrderedDict([(3, 'c'), (2, 'b'), (1, 'a')]) 
>>> d 
OrderedDict([(3, 'c'), (2, 'b'), (1, 'a')]) 

È ancora possibile accedere al OrderedDict nelle convenzioni che si sono abituati a

>>> d[3] 
'c' 
>>> d.get(3) 
'c' 

Nota che non devi inserire tutti gli elementi al momento della creazione. Puoi inserirli uno alla volta se vuoi.

>>> d = OrderedDict() 
>>> d[3] = 'c' 
>>> d[2] = 'b' 
>>> d[1] = 'a' 
>>> d[4] = 'd' 
>>> d 
OrderedDict([(3, 'c'), (2, 'b'), (1, 'a'), (4, 'd')]) 

Answer 2

Non si deve fare affidamento sull'ordine di iterazione di un dettato. Il modo in cui solo è possibile ottenere qualsiasi ordinamento stabile e ripetibile è facendo qualcosa di simile:

for key in sorted(yourdict): 
    more code here 

che vi darà un ordinamento stabile, ma probabilmente non quello che si desidera.

È probbaly desidera utilizzare un OrderedDict