Stampa tupla con formattazione delle stringhe in Python

Quindi ho questo problema. Ho tupla (1,2,3) che dovrei stampare con la formattazione delle stringhe. per esempio.

tup = (1,2,3)
print "this is a tuple %something" % (tup)

e questo dovrebbe stampare la rappresentazione della tupla con parentesi, come

Questa è una tupla (1,2,3)

Ma ottengo TypeError: not all arguments converted during string formattinginvece.

Come posso farlo nel mondo? Un po 'perso qui, quindi se voi ragazzi potreste indicarmi la giusta direzione :)

>>> thetuple = (1, 2, 3)
>>> print "this is a tuple: %s" % (thetuple,)
this is a tuple: (1, 2, 3)

Fare una tupla singleton con la tupla di interesse come unico elemento, cioè la (thetuple,)parte, è il bit chiave qui.

Si noti che la %sintassi è obsoleta. Usa str.format, che è più semplice e più leggibile:

t = 1,2,3
print 'This is a tuple {0}'.format(t)

Molte risposte fornite sopra erano corrette. Il modo giusto per farlo è:

>>> thetuple = (1, 2, 3)
>>> print "this is a tuple: %s" % (thetuple,)
this is a tuple: (1, 2, 3)

Tuttavia, si è verificata una controversia se l' '%'operatore String è obsoleto. Come molti hanno sottolineato, non è sicuramente obsoleto, poiché l' '%'operatore String è più facile combinare un'istruzione String con i dati di un elenco.

Esempio:

>>> tup = (1,2,3)
>>> print "First: %d, Second: %d, Third: %d" % tup
First: 1, Second: 2, Third: 3

Tuttavia, usando la .format()funzione, si finirà con un'istruzione dettagliata.

Esempio:

>>> tup = (1,2,3)
>>> print "First: %d, Second: %d, Third: %d" % tup
>>> print 'First: {}, Second: {}, Third: {}'.format(1,2,3)
>>> print 'First: {0[0]}, Second: {0[1]}, Third: {0[2]}'.format(tup)

First: 1, Second: 2, Third: 3
First: 1, Second: 2, Third: 3
First: 1, Second: 2, Third: 3

Più ulteriormente più, '%'stringa operatore anche utile di validare il tipo di dati quali %s, %d, %i, mentre .format () supportano solo due flag di conversione : '!s'e '!r'.

>>> tup = (1, 2, 3)
>>> print "Here it is: %s" % (tup,)
Here it is: (1, 2, 3)
>>>

Nota che (tup,)è una tupla contenente una tupla. La tupla esterna è l'argomento per l'operatore%. La tupla interna è il suo contenuto, che è effettivamente stampato.

(tup)è un'espressione tra parentesi, che se valutata risulta in tup.

(tup,)con la virgola finale è una tupla, che contiene tupcome solo membro.

Questo non usa la formattazione di stringhe, ma dovresti essere in grado di fare:

print 'this is a tuple ', (1, 2, 3)

Se vuoi davvero usare la formattazione delle stringhe:

print 'this is a tuple %s' % str((1, 2, 3))
# or
print 'this is a tuple %s' % ((1, 2, 3),)

Nota, questo presuppone che tu stia utilizzando una versione di Python precedente alla 3.0.

t = (1, 2, 3)

# the comma (,) concatenates the strings and adds a space
print "this is a tuple", (t)

# format is the most flexible way to do string formatting
print "this is a tuple {0}".format(t)

# classic string formatting
# I use it only when working with older Python versions
print "this is a tuple %s" % repr(t)
print "this is a tuple %s" % str(t)

Anche se questa domanda è piuttosto vecchia e ha molte risposte diverse, mi piacerebbe comunque aggiungere la risposta più "pitonica" e anche leggibile / concisa.

Poiché il tuplemetodo di stampa generale è già mostrato correttamente da Antimonio, questa è un'aggiunta per stampare ogni elemento in una tupla separatamente, come Fong Kah Chun ha mostrato correttamente con la %ssintassi.

È interessante notare che è stato menzionato solo in un commento, ma l'uso di un asterisco per decomprimere la tupla produce piena flessibilità e leggibilità usando il str.formatmetodo quando si stampano separatamente gli elementi di tupla .

tup = (1, 2, 3)
print('Element(s) of the tuple: One {0}, two {1}, three {2}'.format(*tup))

Questo evita anche di stampare una virgola finale quando si stampa una tupla a singolo elemento, come eluso da Jacob CUI con replace. (Anche se imho la rappresentazione della virgola finale è corretta se si desidera conservare la rappresentazione del tipo durante la stampa ):

tup = (1, )
print('Element(s) of the tuple: One {0}'.format(*tup))

Penso che il modo migliore per farlo sia:

t = (1,2,3)

print "This is a tuple: %s" % str(t)

Se hai familiarità con la formattazione dello stile printf , Python supporta la sua versione. In Python, questo viene fatto usando l'operatore "%" applicato alle stringhe (un sovraccarico dell'operatore modulo), che accetta qualsiasi stringa e vi applica la formattazione in stile printf.

Nel nostro caso, gli stiamo dicendo di stampare "Questa è una tupla:", e quindi aggiungendo una stringa "% s", e per la stringa effettiva, stiamo passando una rappresentazione di stringa della tupla (chiamando str ( t)).

Se non hai familiarità con la formattazione dello stile printf, ti consiglio vivamente di imparare, poiché è molto standard. La maggior parte delle lingue lo supporta in un modo o nell'altro.

Nota che verrà aggiunta una virgola finale se la tupla ha un solo elemento. per esempio:

t = (1,)
print 'this is a tuple {}'.format(t)

e otterrai:

'this is a tuple (1,)'

in alcuni casi, ad esempio, si desidera ottenere un elenco citato da utilizzare nella stringa di query mysql come

SELECT name FROM students WHERE name IN ('Tom', 'Jerry');

è necessario prendere in considerazione la rimozione della virgola di coda usare sostituire (',)', ')') dopo la formattazione perché è possibile che la tupla abbia solo 1 elemento come ('Tom',), quindi la virgola di coda deve essere rimossa:

query_string = 'SELECT name FROM students WHERE name IN {}'.format(t).replace(',)', ')')

Si prega di suggerire se si dispone di un modo decente per rimuovere questa virgola nell'output.

Oltre ai metodi proposti nelle altre risposte, da Python 3.6 puoi anche usare Interpolazione letterale di stringhe (f-stringhe):

>>> tup = (1,2,3)
>>> print(f'this is a tuple {tup}')
this is a tuple (1, 2, 3)

Prova questo per ottenere una risposta:

>>>d = ('1', '2') 
>>> print("Value: %s" %(d))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: not all arguments converted during string formatting

Se mettiamo una sola tupla dentro (), crea una tupla stessa:

>>> (d)
('1', '2')

Questo significa che la dichiarazione di stampa sopra sarà simile a: print ("Value:% s"% ('1', '2')) che è un errore!

Quindi:

>>> (d,)
(('1', '2'),)
>>> 

Sopra sarà alimentato correttamente agli argomenti della stampa.

Per Python 3

tup = (1,2,3)
print("this is a tuple %s" % str(tup))

Puoi provare anche questo;

tup = (1,2,3)
print("this is a tuple {something}".format(something=tup))

Non è possibile utilizzare %somethingcon il (tup)solo a causa di fare e disfare concetto con tuple.

Parlare è economico, mostrarti il ​​codice:

>>> tup = (10, 20, 30)
>>> i = 50
>>> print '%d      %s'%(i,tup)
50  (10, 20, 30)
>>> print '%s'%(tup,)
(10, 20, 30)
>>>