Python che converte stringa in tupla senza dividere i caratteri

Question

Sto cercando di convertire una stringa in una tupla senza dividere i caratteri della stringa nel processo. Qualcuno può suggerire un metodo semplice per farlo. Hai bisogno di un solo rivestimento.

Fails

a = 'Quattro TT' 
    print tuple(a) 

Opere

a = ['Quattro TT'] 
    print tuple(a) 

Dal momento che il mio ingresso è una stringa, ho provato il codice qui sotto convertendo la stringa in una lista, che divide ancora una volta la stringa in caratteri ..

Errore

a = 'Quattro TT' 
print tuple(list(a)) 

Output previsto:

('Quattro TT') 

output generato:

('Q', 'u', 'a', 't', 't', 'r', 'o', ' ', 'T', 'T') 

Answer 1

Si può solo fare (a,). Non c'è bisogno di usare una funzione. (Si noti che la virgola è necessaria.)

Essenzialmente, tuple(a) mezzi per effettuare una tupla dei contenuti di a, non una tupla consistente nel solo a stessa. I "contenuti" di una stringa (ciò che si ottiene quando si itera su di esso) sono i suoi caratteri, motivo per cui è suddiviso in caratteri.

Answer 2

Date un'occhiata al Python tutorial on tuples:

Un problema particolare è la costruzione di tuple contenenti 0 o 1 articoli: la sintassi fornisce alcuni sotterfugi per per accogliere questi. Le tuple vuote sono costruite da una coppia vuota di parentesi; una tupla con un elemento è costruita seguendo un valore con una virgola (non è sufficiente racchiudere un singolo valore tra parentesi). Brutto, ma efficace. Per esempio:

>>> empty =() 
>>> singleton = 'hello', # <-- note trailing comma 
>>> len(empty) 
0 
>>> len(singleton) 
1 
>>> singleton 
('hello',) 

Se si mette solo un paio di parentesi intorno al vostro oggetto stringa, che si trasformerà solo che l'espressione in un parenthesized expression (enfasi aggiunta):

Un'espressione tra parentesi lista rendimenti qualunque cosa la lista di espressioni produce: se la lista contiene almeno una virgola, produce una tupla; in caso contrario, restituisce la singola espressione che costituisce l'elenco di espressioni.

Una coppia di parentesi vuota restituisce un oggetto tupla vuoto. Poiché le tuple sono immutabili, si applicano le regole per i letterali (cioè, due occorrenze della tupla vuota possono o meno produrre lo stesso oggetto).

Si noti che le tuple non sono formate dalle parentesi, ma piuttosto dall'operatore di virgola. L'eccezione è la tupla vuota, per la quale sono richieste le parentesi - consentendo che il "nulla" non convertito nelle espressioni causi ambiguità e permetta il passaggio di errori di battitura comuni.

Che è (ammesso Python 2.7),

a = 'Quattro TT' 
print tuple(a)  # <-- you create a tuple from a sequence 
         #  (which is a string) 
print tuple([a])  # <-- you create a tuple from a sequence 
         #  (which is a list containing a string) 
print tuple(list(a)) # <-- you create a tuple from a sequence 
         #  (which you create from a string) 
print (a,)   # <-- you create a tuple containing the string 
print (a)    # <-- it's just the string wrapped in parentheses 

L'uscita è come previsto:

('Q', 'u', 'a', 't', 't', 'r', 'o', ' ', 'T', 'T') 
('Quattro TT',) 
('Q', 'u', 'a', 't', 't', 'r', 'o', ' ', 'T', 'T') 
('Quattro TT',) 
Quattro TT 

---

Per aggiungere alcune note sulla dichiarazione di stampa. Quando si tenta di creare una tupla a elemento singolo come parte di una istruzione print in Python 2.7 (come in print (a,)) è necessario utilizzare il modulo tra parentesi, perché la virgola finale di print a, sarebbe altrimenti considerata parte dell'istruzione di stampa e quindi causa la nuova riga da sopprimere dall'output e non una tupla creata:

Un carattere '\ n' viene scritto alla fine, a meno che l'istruzione di stampa termini con una virgola.

In Python 3.x maggior parte degli usi di cui sopra negli esempi sarebbero effettivamente aumentare SyntaxError, perché in Python 3 printturns into a function (è necessario aggiungere un altro paio di parentesi). Ma soprattutto questo può causare confusione:

print (a,)   # <-- this prints a tuple containing `a` in Python 2.x 
         #  but only `a` in Python 3.x 

Answer 3

Solo nel caso qualcuno viene qui a cercare di sapere come creare una tupla assegnando ad ogni parte della stringa "Quattro" e "TT" per un elemento della lista, sarebbe così print tuple(a.split())

Answer 4

La tupla di sottoclassi in cui alcune di queste istanze di sottoclassi possono richiedere di essere istanze a stringa unica solleva qualcosa di interessante.

class Sequence(tuple): 
    def __init__(self, *args): 
     # initialisation... 
     self.instances = [] 

    def __new__(cls, *args): 
     for arg in args: 
      assert isinstance(arg, unicode), '# arg %s not unicode' % (arg,) 
     if len(args) == 1: 
      seq = super(Sequence, cls).__new__(cls, (args[ 0 ],)) 
     else: 
      seq = super(Sequence, cls).__new__(cls, args) 
     print('# END new Sequence len %d' % (len(seq),)) 
     return seq 

NB come ho imparato da questa discussione, è necessario mettere la virgola dopo args[ 0 ].

La riga di stampa mostra che una singola stringa non viene suddivisa.

NB la virgola nel costruttore della sottoclasse ora diventa facoltativa:

Sequence(u'silly') 

o

Sequence(u'silly',) 

Answer 5

Io uso questa funzione per convertire la stringa di tuple

def parse_tuple(string): 
    try: 
     s = eval(str(string)) 
     if type(s) == tuple: 
      return s 
     return 
    except: 
     return 

Uso

foo = '("A","B","C",)' 
value = parse_tuple(foo) # Result: ('A', 'B', 'C') 

Nel tuo caso, si fanno

value = parse_tuple("('%s',)" % a) 

Answer 6

Questo copre solo un semplice caso:

a = ‘Quattro TT’ 
print tuple(a) 

Se si utilizza solo delimitatore come ‘’, allora potrebbe funzionare.

Ho usato una stringa da configparser modo:

list_users = (‘test1’, ‘test2’, ‘test3’) 
and the i get from file 
tmp = config_ob.get(section_name, option_name) 
>>>”(‘test1’, ‘test2’, ‘test3’)” 

In questo caso la soluzione di cui sopra non funziona. Tuttavia, questo funziona:

def fot_tuple(self, some_str): 
    # (‘test1’, ‘test2’, ‘test3’) 
    some_str = some_str.replace(‘(‘, ”) 
    # ‘test1’, ‘test2’, ‘test3’) 
    some_str = some_str.replace(‘)’, ”) 
    # ‘test1’, ‘test2’, ‘test3’ 
    some_str = some_str.replace(“‘, ‘”, ‘,’) 
    # ‘test1,test2,test3’ 
    some_str = some_str.replace(“‘”, ‘,’) 
    # test1,test2,test3 
    # and now i could convert to tuple 
    return tuple(item for item in some_str.split(‘,’) if item.strip())