Impression d'un tuple avec formatage de chaîne en Python

Donc, j'ai ce problème. J'ai eu un tuple (1, 2, 3) que je devrais imprimer avec un formatage de chaîne. par exemple.

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

et cela devrait afficher une représentation de tuple avec des crochets, comme

Ceci est un tuple (1,2,3)

Mais je reçois à la TypeError: not all arguments converted during string formattingplace.

Comment diable suis-je capable de faire ça? Un peu perdu ici, alors si vous pouviez m'indiquer la bonne direction :)

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

Faire un tuple singleton avec le tuple d'intérêt comme seul élément, c'est-à-dire la (thetuple,)partie, est le bit clé ici.

Notez que la %syntaxe est obsolète. Utilisation str.format, qui est plus simple et plus lisible:

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

De nombreuses réponses données ci-dessus étaient correctes. La bonne façon de procéder est:

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

Cependant, il y a eu un différend quant à savoir si l' '%'opérateur String est obsolète. Comme beaucoup l'ont souligné, il n'est certainement pas obsolète, car l' '%'opérateur String est plus facile à combiner une instruction String avec des données de liste.

Exemple:

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

Cependant, en utilisant la .format()fonction, vous vous retrouverez avec une déclaration détaillée.

Exemple:

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

De plus, l' '%'opérateur de chaîne également utile pour nous de valider le type de données telles que %s, %d, %i, alors que .format () soutenir seulement deux drapeaux de conversion : '!s'et '!r'.

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

Notez qu'il (tup,)s'agit d'un tuple contenant un tuple. Le tuple externe est l'argument de l'opérateur%. Le tuple interne est son contenu, qui est en fait imprimé.

(tup)est une expression entre crochets qui, une fois évaluée, donne tup.

(tup,)avec la virgule de fin est un tuple, qui contient tupcomme seul membre.

Cela n'utilise pas de formatage de chaîne, mais vous devriez pouvoir faire:

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

Si vous voulez vraiment utiliser le formatage de chaîne:

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

Notez que cela suppose que vous utilisez une version Python antérieure à 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)

Même si cette question est assez ancienne et a de nombreuses réponses différentes, je voudrais quand même ajouter la réponse à mon humble avis la plus "pythonique" et aussi lisible / concise.

Puisque la tupleméthode d'impression générale est déjà montrée correctement par Antimoine, c'est un ajout pour imprimer chaque élément dans un tuple séparément, comme Fong Kah Chun l'a montré correctement avec la %ssyntaxe.

Fait intéressant, cela n'a été mentionné que dans un commentaire, mais l'utilisation d'un opérateur astérisque pour décompresser le tuple offre une flexibilité et une lisibilité complètes en utilisant la str.formatméthode lors de l'impression des éléments de tuple séparément .

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

Cela évite également d'imprimer une virgule de fin lors de l'impression d'un tuple à un seul élément, comme contourné par Jacob CUI avec replace. (Même si à mon humble avis la représentation par virgule de fin est correcte si vous souhaitez conserver la représentation de type lors de l'impression ):

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

Je pense que la meilleure façon de procéder est:

t = (1,2,3)

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

Si vous êtes familier avec le formatage de style printf , Python prend en charge sa propre version. En Python, cela se fait en utilisant l'opérateur "%" appliqué aux chaînes (une surcharge de l'opérateur modulo), qui prend n'importe quelle chaîne et lui applique un formatage de style printf.

Dans notre cas, nous lui disons d'afficher "Ceci est un tuple:", puis en ajoutant une chaîne "% s", et pour la chaîne réelle, nous passons une représentation sous forme de chaîne du tuple (en appelant str ( t)).

Si vous n'êtes pas familier avec le formatage de style printf, je suggère fortement d'apprendre, car c'est très standard. La plupart des langues le prennent en charge d'une manière ou d'une autre.

Veuillez noter qu'une virgule de fin sera ajoutée si le tuple n'a qu'un seul élément. par exemple:

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

et vous obtiendrez:

'this is a tuple (1,)'

dans certains cas, par exemple, vous voulez obtenir une liste entre guillemets à utiliser dans la chaîne de requête mysql comme

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

vous devez envisager de supprimer la virgule de fin, utilisez replace (',)', ')') après le formatage car il est possible que le tuple n'ait qu'un seul élément comme ('Tom',), donc la virgule de fin doit être supprimée:

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

Veuillez suggérer si vous avez un moyen décent de supprimer cette virgule dans la sortie.

Outre les méthodes proposées dans les autres réponses, depuis Python 3.6, vous pouvez également utiliser l' interpolation de chaîne littérale (f-strings):

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

Essayez ceci pour obtenir une réponse:

>>>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 nous ne mettons qu'un seul tuple à l'intérieur (), cela crée un tuple lui-même:

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

Cela signifie que l'instruction d'impression ci-dessus ressemblera à: print ("Valeur:% s"% ('1', '2')) qui est une erreur!

Par conséquent:

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

Ci-dessus sera alimenté correctement aux arguments de l'impression.

Pour python 3

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

Vous pouvez également essayer celui-ci;

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

Vous ne pouvez pas utiliser %somethingavec (tup)juste à cause du concept d'emballage et de déballage avec tuple.

Talk est bon marché, montrez-vous le code:

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