Imprimindo tupla com formatação de string em Python

Então, eu tenho esse problema. Eu tenho tupla (1,2,3) que eu deveria imprimir com formatação de string. por exemplo.

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

e isso deve imprimir a representação da tupla com colchetes, como

Esta é uma tupla (1,2,3)

Mas eu entendo TypeError: not all arguments converted during string formatting .

Como no mundo eu sou capaz de fazer isso? Meio que perdi aqui, então se vocês pudessem me indicar uma direção certa :)

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

Fazer uma tupla singleton com a tupla de interesse como o único item, ou seja, a (thetuple,)peça, é o ponto principal aqui.

Observe que a %sintaxe é obsoleta. Use str.format, que é mais simples e mais legível:

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

Muitas respostas dadas acima estavam corretas. A maneira correta de fazer isso é:

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

No entanto, houve uma disputa sobre se o '%'operador String está obsoleto. Como muitos apontaram, definitivamente não é obsoleto, pois o '%'operador String é mais fácil de combinar uma instrução String com os dados da lista.

Exemplo:

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

No entanto, usando a .format()função, você terminará com uma declaração detalhada.

Exemplo:

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

Ainda mais, '%'operador de corda também útil para nós para validar o tipo de dados, como %s, %d, %i, enquanto .format () suportam apenas dois sinalizadores de conversão : '!s'e '!r'.

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

Observe que (tup,)é uma tupla que contém uma tupla. A tupla externa é o argumento para o operador%. A tupla interna é o seu conteúdo, que é realmente impresso.

(tup)é uma expressão entre colchetes que, quando avaliada, resulta em tup.

(tup,)com a vírgula à direita é uma tupla, que contém tupcomo único membro.

Isso não usa formatação de string, mas você deve ser capaz de:

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

Se você realmente deseja usar a formatação de string:

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

Observe que isso pressupõe que você esteja usando uma versão Python anterior à 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)

Mesmo que essa pergunta seja bastante antiga e tenha muitas respostas diferentes, eu ainda gostaria de adicionar a resposta imho mais "pitônica" e também legível / concisa.

Como o tuplemétodo de impressão geral já é mostrado corretamente pelo Antimony, isso é um complemento para imprimir cada elemento em uma tupla separadamente, como Fong Kah Chun mostrou corretamente com a %ssintaxe.

Curiosamente, isso foi mencionado apenas em um comentário, mas o uso de um operador de asterisco para descompactar a tupla gera flexibilidade e legibilidade total usando o str.formatmétodo ao imprimir elementos de tupla separadamente .

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

Isso também evita a impressão de uma vírgula à direita ao imprimir uma tupla de elemento único, conforme contornado por Jacob CUI replace. (Mesmo que imho, a representação de vírgula à direita esteja correta se desejar preservar a representação de tipo ao imprimir ):

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

Eu acho que a melhor maneira de fazer isso é:

t = (1,2,3)

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

Se você está familiarizado com a formatação no estilo printf , o Python suporta sua própria versão. No Python, isso é feito usando o operador "%" aplicado às strings (uma sobrecarga do operador do módulo), que pega qualquer string e aplica a formatação no estilo printf.

No nosso caso, dizemos para imprimir "Esta é uma tupla:" e, em seguida, adicionamos uma string "% s" e, para a string real, estamos passando uma representação de string da tupla (chamando str ( t)).

Se você não está familiarizado com a formatação no estilo printf, sugiro o aprendizado, pois é muito padrão. A maioria dos idiomas suporta de uma maneira ou de outra.

Observe que uma vírgula à direita será adicionada se a tupla tiver apenas um item. por exemplo:

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

e você terá:

'this is a tuple (1,)'

em alguns casos, por exemplo, você deseja que uma lista entre aspas seja usada na string de consulta do mysql como

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

é necessário considerar remover a vírgula de rejeição, use replace (',)', ')') após a formatação, pois é possível que a tupla tenha apenas 1 item como ('Tom'), para que a vírgula de rejeição precise ser removida:

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

Por favor, sugira se você tem uma maneira decente de remover esta vírgula na saída.

Além dos métodos propostos nas outras respostas, desde o Python 3.6 você também pode usar a Literal String Interpolation (f-strings):

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

Tente isto para obter uma resposta:

>>>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 colocarmos apenas uma tupla dentro de (), ela produzirá uma tupla:

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

Isso significa que a declaração de impressão acima será parecida com: print ("Value:% s"% ('1', '2')), o que é um erro!

Conseqüentemente:

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

Acima será alimentado corretamente aos argumentos da impressão.

Para python 3

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

Você pode tentar este também;

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

Você não pode usar %somethingcom (tup)apenas por causa de embalagem e descompactar conceito com tupla.

O papo é barato, mostre o código:

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