¿Por qué obtengo “TypeError: no todos los argumentos convertidos durante el formateo de cadenas” al intentar formatear una tupla?

Quiero usar %formato de cadena de estilo para imprimir una tupla:

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

Espero que se imprima como This is a tuple: (1,2,3).pero en su lugar me sale un error que dice TypeError: not all arguments converted during string formatting.

¿Qué está mal y cómo lo soluciono?

_{Al editar esta pregunta para mayor claridad y modernización, conservé un aspecto interesante del ejemplo original: los paréntesis alrededor tup. Estos son no es necesario Para el % sintaxis, y también no crees una tupla. Es posible que OP entendiera que el ajuste de tupla (descrito en las respuestas aquí) era necesario, pero simplemente se equivocó. Para obtener más información sobre ese problema, consulte Cómo crear una tupla “singleton” con un solo elemento.}

>>> 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 único elemento, es decir, el (thetuple,) parte, es la parte clave aquí.

El % la sintaxis es obsoleta. Usar str.formatque es más simple y más legible:

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

La forma correcta de hacerlo es:

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

El % El operador de cadena todavía es compatible con Python 3.x y facilita el formateo de una tupla (o lista) como valores separados. Usando .format para este caso, se requerirá algo de trabajo adicional: los valores deben pasarse como argumentos separados o la secuencia deberá indexarse:

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

El % El operador también es útil para validar el tipo de los argumentos, utilizando diferentes códigos de formato (%s, %d, %i), mientras que .formato() solo admite dos banderas de conversión: '!s' y '!r'.

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

Aquí, (tup,) – con la coma final – es una tupla que contiene una tupla. La tupla exterior es el argumento del operador %. La tupla interior es su contenido, que en realidad se imprime. Sin la coma final, (tup) es lo mismo que tup – los paréntesis son solo paréntesis de agrupación normales.

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 Antimony ya muestra correctamente el método general de impresión de tuplas, esta es una adición para imprimir cada elemento en una tupla por separado, como Fong Kah Chun ha demostrado correctamente con el %s sintaxis.

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.format método cuando 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 al final cuando se imprime una tupla de un solo elemento, como lo evita Jacob CUI con replace. (Aunque en mi humilde opinión, la representación de la coma final es correcta si desea conservar la representación del tipo al imprimir):

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

Además de los métodos propuestos en las otras respuestas, desde Python 3.6 también podemos usar Interpolación de cadenas literales (cuerdas f):

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

t = (1, 2, 3)

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

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

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