Python conversion de chaîne en tuple sans diviser les caractères

Jetez un oeil au tutoriel Python sur les tuples :

Un problème particulier est la construction de tuples contenant 0 ou 1 éléments: la syntaxe a quelques bizarreries supplémentaires pour les accommoder. 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 d'entourer 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 entre parenthèses autour de votre objet string, elles ne feront que transformer cette expression en une expression entre parenthèses (soulignement Ajouté):

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

Une paire vide de parenthèses donne un objet tuple vide. Puisque 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 tuples ne sont pas constitués par les parenthèses, mais plutôt par l'utilisation de l'opérateur virgule. l'exception est le tuple vide, pour lequel des parenthèses sont nécessaires-permettre un "rien" non-agrandi dans les expressions causerait 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 attendu:

('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 l'instruction d'impression. Lorsque vous essayez de créer un tuple à un seul élément dans le cadre d'une instruction print dans Python 2.7 (comme dans print (a,)), vous devez utiliser la forme entre parenthèses, car la virgule de fin de print a, serait considérée comme faisant partie de l'instruction print et provoquerait ainsi la suppression de la nouvelle ligne de la sortie]}

Un caractère '\n ' est écrit à la fin, à moins que la déclaration se termine par une virgule.

En Python 3.x la plupart des usages dans les exemples, fait lever SyntaxError, car en Python 3 print se transforme en une fonction (vous avez besoin d'ajouter une paire de parenthèses). Mais surtout cela peut causer de la confusion:

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

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

J'utilise cette fonction pour convertir la 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

Utilisation

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

Dans votre cas, vous faites

value = parse_tuple("('%s',)" % a)

Vous pouvez utiliser la solution suivante:

s="jack"

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

output=('jack')

Le tuple de sous-classe où certaines de ces instances de sous-classe peuvent avoir besoin d'être des instances à 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 que j'ai appris de ce fil, vous devez mettre la virgule après args[ 0 ].

La ligne d'impression montre qu'une seule chaîne ne se sépare pas.

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

Sequence( u'silly' )

Ou

Sequence( u'silly', )

Cela ne couvre qu'un cas simple:

a = ‘Quattro TT’
print tuple(a)

Si vous utilisez uniquement un délimiteur comme‘,', alors cela pourrait fonctionner.

J'ai utilisé une chaîne de configparser comme ceci:

list_users = (‘test1’, ‘test2’, ‘test3’)
and the i get from file
tmp = config_ob.get(section_name, option_name)
>>>”(‘test1’, ‘test2’, ‘test3’)”

, Dans ce cas, la solution ci-dessus ne fonctionne pas. Cependant, cela fonctionne:

def fot_tuple(self, some_str):
     # (‘test1’, ‘test2’, ‘test3’)
     some_str = some_str.replace(‘(‘, ”)
     # ‘test1’, ‘test2’, ‘test3’)
     some_str = some_str.replace(‘)’, ”)
     # ‘test1’, ‘test2’, ‘test3’
     some_str = some_str.replace(“‘, ‘”, ‘,’)
     # ‘test1,test2,test3’
     some_str = some_str.replace(“‘”, ‘,’)
     # test1,test2,test3
     # and now i could convert to tuple
     return tuple(item for item in some_str.split(‘,’) if item.strip())