Impresión de tuplas con formato de cadena en Python

Entonces, tengo este problema. Tengo una tupla (1,2,3) que debo imprimir con formato de cadena. p.ej.

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

y esto debería imprimir la representación de tuplas entre paréntesis, como

Esta es una tupla (1,2,3)

Pero en su lugar me sale TypeError: not all arguments converted during string formatting.

¿Cómo puedo hacer esto? Un poco perdido aquí, así que si ustedes pudieran señalarme en la dirección correcta :)

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

Hacer una tupla singleton con la tupla de interés como el único elemento, es decir, la (thetuple,)parte, es la clave aquí.

Tenga en cuenta que la %sintaxis es obsoleta. Uso str.format, que es más simple y más legible:

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

Muchas respuestas dadas anteriormente fueron correctas. La forma correcta de hacerlo es:

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

Sin embargo, hubo una disputa sobre si el '%'operador String es obsoleto. Como muchos han señalado, definitivamente no es obsoleto, ya que el '%'operador String es más fácil de combinar una instrucción String con una lista de datos.

Ejemplo:

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

Sin embargo, utilizando la .format()función, terminará con una declaración detallada.

Ejemplo:

>>> 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

Adicionalmente, '%'operador de cadena también es útil para nosotros para validar el tipo de datos tales como %s, %d, %i, mientras que .formato () sólo admiten dos indicadores de conversión : '!s'y '!r'.

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

Tenga en cuenta que (tup,)es una tupla que contiene una tupla. La tupla externa es el argumento para el operador%. La tupla interna es su contenido, que en realidad está impreso.

(tup)es una expresión entre paréntesis, que cuando se evalúa da como resultado tup.

(tup,)con la coma final es una tupla, que contiene tupcomo único miembro.

Esto no utiliza el formato de cadena, pero debería poder hacer:

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

Si realmente quieres usar el formato de cadena:

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

Tenga en cuenta que esto supone que está utilizando una versión de Python anterior a la 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)

Aunque esta pregunta es bastante antigua y tiene muchas respuestas diferentes, todavía me gustaría agregar la respuesta más "pitónica" y también legible / concisa.

Dado que tupleAntimony ya muestra correctamente el método de impresión general , esta es una adición para imprimir cada elemento en una tupla por separado, como Fong Kah Chun ha mostrado correctamente con la %ssintaxis.

Curiosamente, solo se ha mencionado en un comentario, pero el uso de un operador de asterisco para desempaquetar la tupla produce una flexibilidad y legibilidad completas utilizando el str.formatmétodo al imprimir elementos de tupla por separado .

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

Esto también evita imprimir una coma final cuando se imprime una tupla de un solo elemento, como lo evitó Jacob CUI con replace. (Aunque en mi opinión, la representación de coma final es correcta si desea conservar la representación de tipo al imprimir ):

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

Creo que la mejor manera de hacer esto es:

t = (1,2,3)

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

Si está familiarizado con el formato de estilo printf , Python admite su propia versión. En Python, esto se hace usando el operador "%" aplicado a las cadenas (una sobrecarga del operador de módulo), que toma cualquier cadena y le aplica el formato de estilo printf.

En nuestro caso, le estamos diciendo que imprima "Esto es una tupla:", y luego agregamos una cadena "% s", y para la cadena real, estamos pasando una representación de cadena de la tupla (llamando a str ( t)).

Si no está familiarizado con el formato de estilo printf, le recomiendo que aprenda, ya que es muy estándar. La mayoría de los idiomas lo admiten de una forma u otra.

Tenga en cuenta que se agregará una coma final si la tupla solo tiene un elemento. p.ej:

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

y obtendrás:

'this is a tuple (1,)'

en algunos casos, por ejemplo, desea obtener una lista citada para ser utilizada en la cadena de consulta mysql como

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

debe considerar eliminar la coma de colas, use replace (',)', ')') después de formatear porque es posible que la tupla tenga solo 1 elemento como ('Tom',), por lo que la coma de colas debe eliminarse:

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

Sugiera si tiene una forma decente de eliminar esta coma en la salida.

Además de los métodos propuestos en las otras respuestas, desde Python 3.6 también puede usar Literal String Interpolation (f-strings):

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

Intenta esto para obtener una respuesta:

>>>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

Si ponemos solo una tupla dentro (), se crea una tupla en sí misma:

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

Esto significa que la declaración de impresión anterior se verá así: print ("Valor:% s"% ('1', '2')) ¡lo cual es un error!

Por lo tanto:

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

Lo anterior se alimentará correctamente a los argumentos de la impresión.

Para python 3

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

Puedes probar este también;

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

No se puede utilizar %somethingcon (tup)sólo por concepto de embalaje y desembalaje con tupla.

Hablar es barato, muéstrale el código:

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