web-dev-qa-db-fra.com

Conversion de chaîne en tuple sans fractionner les caractères

Je m'efforce de convertir une chaîne en un tuple sans scinder les caractères de la chaîne au cours du processus. Quelqu'un peut-il suggérer une méthode facile pour ce faire? Besoin d'un one-liner.

échec

   a = 'Quattro TT'
   print Tuple(a)

Fonctionne

  a = ['Quattro TT']  
  print Tuple(a)

Comme mon entrée est une chaîne, j'ai essayé le code ci-dessous en convertissant la chaîne en une liste, qui scinde à nouveau la chaîne en caractères.

échec

a = 'Quattro TT'
print Tuple(list(a))

Résultat attendu:

('Quattro TT')

Sortie générée:

('Q', 'u', 'a', 't', 't', 'r', 'o', ' ', 'T', 'T')
pythonlistpython-2.7python-3.xtuples
35
Shankar

Vous pouvez simplement faire (a,). Pas besoin d'utiliser une fonction. (Notez que la virgule est nécessaire.)

Essentiellement, Tuple(a) signifie créer un tuple du conten de a, et non un tuple constitué uniquement de a lui-même. Le "contenu" d'une chaîne (ce que vous obtenez lorsque vous la parcourez) correspond à ses caractères, c'est pourquoi elle est scindée en caractères.

58
BrenBarn

Regardez le tutoriel Python sur les n-uplets :

Un problème particulier est la construction de n-uplets contenant 0 ou 1 items: la syntaxe a quelques défauts supplémentaires pour les adapter. Les tuples vides sont construits par une paire de parenthèses vides; un tuple avec un élément est construit en suivant une valeur avec une virgule (il ne suffit pas de mettre une seule valeur entre parenthèses). Moche, mais efficace. Par exemple:

>>> empty = ()
>>> singleton = 'hello',    # <-- note trailing comma
>>> len(empty)
0
>>> len(singleton)
1
>>> singleton
('hello',)

Si vous mettez juste une paire de parenthèses autour de votre objet string, ils transformeront uniquement cette expression en un expression entre parenthèses (emphase ajoutée):

Une liste d'expressions entre parenthèses génère ce que cette liste d'expressions donne: si la liste contient au moins une virgule, elle génère un Tuple; sinon, il génère l'expression unique qui constitue la liste d'expressions.

Une paire de parenthèses vide donne un objet Tuple vide. Comme les tuples sont immuables, les règles pour les littéraux s'appliquent (c'est-à-dire que deux occurrences du tuple vide peuvent ou non donner le même objet).

Notez que les n-uplets ne sont pas formés par les parenthèses, mais par l'utilisation de l'opérateur de virgule. L'exception est le tuple vide, pour lequel des parenthèses sont requises - n'autoriser que des expressions "sans rien" dans les expressions créerait des ambiguïtés et permettrait aux fautes de frappe courantes de passer inaperçues.

C’est-à-dire (en supposant Python 2.7),

a = 'Quattro TT'
print Tuple(a)        # <-- you create a Tuple from a sequence 
                      #     (which is a string)
print Tuple([a])      # <-- you create a Tuple from a sequence 
                      #     (which is a list containing a string)
print Tuple(list(a))  # <-- you create a Tuple from a sequence 
                      #     (which you create from a string)
print (a,)            # <-- you create a Tuple containing the string
print (a)             # <-- it's just the string wrapped in parentheses

La sortie est comme prévu:

('Q', 'u', 'a', 't', 't', 'r', 'o', ' ', 'T', 'T')
('Quattro TT',)
('Q', 'u', 'a', 't', 't', 'r', 'o', ' ', 'T', 'T')
('Quattro TT',)
Quattro TT

Pour ajouter quelques notes sur la déclaration d'impression. Lorsque vous essayez de créer un tuple à un seul élément dans le cadre d'une instruction print in Python 2.7 (comme dans print (a,)), vous devez utiliser la forme entre parenthèses, car la virgule de fin print a, serait sinon considérée comme faisant partie de l'instruction print et provoquerait ainsi la suppression de la nouvelle ligne de la sortie et non la création d'un tuple:

Un caractère '\ n' est écrit à la fin, à moins que l'instruction print ne se termine par une virgule.

Dans Python 3.x, la plupart des utilisations ci-dessus dans les exemples déclencheraient en fait SyntaxError, car dans Python 3 printse transforme en une fonction (vous devez ajouter une paire de parenthèses supplémentaire). Mais cela peut surtout être source de confusion:

print (a,)            # <-- this prints a Tuple containing `a` in Python 2.x
                      #     but only `a` in Python 3.x
16
moooeeeep

J'utilise cette fonction pour convertir une chaîne en tuple

import ast

def parse_Tuple(string):
    try:
        s = ast.literal_eval(str(string))
        if type(s) == Tuple:
            return s
        return
    except:
        return

Usage

parse_Tuple('("A","B","C",)')  # Result: ('A', 'B', 'C')



Dans votre cas, vous faites

value = parse_Tuple("('%s',)" % a)
5
Shameem

Juste au cas où quelqu'un viendrait ici essayer de savoir comment créer un tuple assignant chaque partie de la chaîne "Quattro" et "TT" à un élément de la liste, ce serait comme ceci print Tuple(a.split())

5
igorgruiz

Vous pouvez utiliser la solution suivante:

s="jack"

tup=Tuple(s.split(" "))

output=('jack')
2
sameer_nubia

Sous-classe Tuple où certaines de ces instances de sous-classe peuvent nécessiter une instance d'une chaîne génère quelque chose d'intéressant.

class Sequence( Tuple ):
    def __init__( self, *args ):
        # initialisation...
        self.instances = []

    def __new__( cls, *args ):
        for arg in args:
            assert isinstance( arg, unicode ), '# arg %s not unicode' % ( arg, )
        if len( args ) == 1:
            seq = super( Sequence, cls ).__new__( cls, ( args[ 0 ], ) )
        else:
            seq = super( Sequence, cls ).__new__( cls, args )
        print( '# END new Sequence len %d' % ( len( seq ), ))
        return seq

NB Comme j'ai appris de ce fil, vous devez mettre la virgule après args[ 0 ].

La ligne d’impression indique qu’une seule chaîne ne peut être scindée.

NB: la virgule dans le constructeur de la sous-classe devient maintenant facultative:

Sequence( u'silly' )

ou

Sequence( u'silly', )
0
mike rodent