Inserimento di un carattere a intervalli regolari in un elenco

Question

Sto cercando di convertire 10000000C9ABCDEF-10:00:00:00:c9:ab:cd:ef

Questo è necessario perché formato 10000000C9ABCDEF è come vedo HBA o adapaters busto ospitano quando faccio il login al mio array di storage. Ma gli switch SAN comprendono la notazione 10:00:00:00:c9:ab:cd:ef.

Ho solo stato in grado di realizzare fino a quanto segue:

#script to convert WWNs to lowercase and add the :. 
def wwn_convert(): 
    while True: 
     wwn = (input('Enter the WWN or q to quit- ')) 
     list_wwn = list(wwn) 
     list_wwn = [x.lower() for x in list_wwn] 
     lower_wwn = ''.join(list_wwn) 
     print(lower_wwn) 
    if wwn == 'q': 
     break 

wwn_convert() 

ho provato ':'.join, ma che inserisce : dopo ogni personaggio, così ho ottenere 1:0:0:0:0:0:0:0:c:9:a:b:c:d:e:f

Voglio che il .join di passare attraverso un loop in cui posso dire qualcosa come for i in range (0, 15, 2) in modo che inserisca il : dopo due caratteri, ma non sono sicuro di come procedere. (Bene che Python mi offre di loop in passi di 2 o un qualsiasi numero che voglio.)

Inoltre, sarò grato se qualcuno mi potesse indirizzare ai puntatori, dove ho potuto scritto questo meglio ...

Per favore aiuto.

Sto usando Python Version 3.2.2 su Windows 7 (64 bit)

Answer 1

>>> s = '10000000C9ABCDEF' 
>>> ':'.join([s[x:x+2] for x in range(0, len(s)-1, 2)]) 
'10:00:00:00:C9:AB:CD:EF' 

Spiegazione:

':'.join(...) restituisce un nuovo inserimento stringa ':' tra le parti del iterabile

s[x:x+2] restituisce una stringa di lunghezza 2 a partire da x da s

range(0, len(s) - 1, 2) restituisce una lista di interi con un passaggio di 2

in modo che la comprensione dell'elenco divida la stringa s in sottostringhe di lunghezza 2, quindi join le rimetterebbe insieme ma inserendo ':' tra di esse.

Answer 2

Ecco un'altra opzione:

>>> s = '10000000c9abcdef' 
>>> ':'.join(a + b for a, b in zip(*[iter(s)]*2)) 
'10:00:00:00:c9:ab:cd:ef' 

O ancora più conciso:

>>> import re 
>>> ':'.join(re.findall('..', s)) 
'10:00:00:00:c9:ab:cd:ef' 

Answer 3

Può essere fatto utilizzando grouper ricetta da here.

from itertools import izip_longest 

def grouper(n, iterable, fillvalue=None): 
    "grouper(3, 'ABCDEFG', 'x') --> ABC DEF Gxx" 
    args = [iter(iterable)] * n 
    return izip_longest(fillvalue=fillvalue, *args) 

Usando questa funzione, il codice sarà simile:

def join(it): 
    for el in it: 
     yield ''.join(el) 

':'.join(join(grouper(2, s))) 

Funziona in questo modo:

grouper(2,s) restituisce le tuple '1234...' -> ('1','2'), ('3','4') ...

def join(it) fa questo: ('1','2'), ('3','4') ... -> '12', '34' ...

':'.join(...) crea una stringa da iteratore: '12', '34' ... -> '12:34...'

Inoltre, può essere riscritta come:

':'.join(''.join(el) for el in grouper(2, s)) 

Answer 4

Penso che quello che vi aiutano a uscire di più è una costruzione in pitone chiamato una fetta. Credo che tu possa usarli su qualsiasi oggetto iterabile, incluse le stringhe, rendendoli abbastanza utili e qualcosa che generalmente è una buona idea sapere come usarli.

>>> s = '10000000C9ABCDEF' 
>>> [s.lower()[i:i+2] for i in range(0, len(s)-1, 2)] 
['10', '00', '00', '00', 'c9', 'ab', 'cd', 'ef'] 
>>> ':'.join([s.lower()[i:i+2] for i in range(0, len(s)-1, 2)]) 
'10:00:00:00:c9:ab:cd:ef' 

Se vuoi leggere un po 'di più su fette, loro sono spiegati molto bene in this question, così come una parte del reale python documentation.

Answer 5

>>> s='10000000C9ABCDEF' 
>>> si=iter(s) 
>>> ':'.join(c.lower()+next(si).lower() for c in si) 
>>> '10:00:00:00:c9:ab:cd:ef' 

In forma di lambda:

>>> (lambda x: ':'.join(c.lower()+next(x).lower() for c in x))(iter(s)) 
'10:00:00:00:c9:ab:cd:ef'