it-swarm.com.de

Konvertieren von Zeichenfolgen in Tupel ohne Aufteilen von Zeichen

Ich bemühe mich, eine Zeichenfolge in ein Tupel zu konvertieren, ohne dabei die Zeichen der Zeichenfolge zu teilen. Kann jemand eine einfache Methode vorschlagen, um dies zu tun. Brauche einen Einzeiler.

schlägt fehl

   a = 'Quattro TT'
   print Tuple(a)

Works

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

Da meine Eingabe eine Zeichenfolge ist, habe ich den folgenden Code ausprobiert, indem ich die Zeichenfolge in eine Liste konvertiert habe, die die Zeichenfolge erneut in Zeichen aufteilt.

schlägt fehl

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

Erwartete Ausgabe:

('Quattro TT')

Generierte Ausgabe:

('Q', 'u', 'a', 't', 't', 'r', 'o', ' ', 'T', 'T')
35
Shankar

Sie können einfach (a,) Ausführen. Keine Notwendigkeit, eine Funktion zu verwenden. (Beachten Sie, dass das Komma erforderlich ist.)

Im Wesentlichen bedeutet Tuple(a), dass ein Tupel aus dem content von a erstellt wird, und kein Tupel, das nur aus a selbst besteht. Der "Inhalt" einer Zeichenfolge (was Sie erhalten, wenn Sie darüber iterieren) sind die Zeichen, weshalb sie in Zeichen aufgeteilt wird.

58
BrenBarn

Schauen Sie sich das Python-Tutorial zu Tupeln an :

Ein besonderes Problem ist die Konstruktion von Tupeln mit 0 oder 1 Elementen: Die Syntax enthält einige zusätzliche Macken, um diese aufzunehmen. Leere Tupel werden durch ein leeres Klammerpaar gebildet. Ein Tupel mit einem Element wird erstellt, indem einem Wert ein Komma folgt (es reicht nicht aus, einen einzelnen Wert in Klammern zu setzen). Hässlich, aber effektiv. Beispielsweise:

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

Wenn Sie nur ein Paar Klammern um Ihr Zeichenfolgenobjekt setzen, wird dieser Ausdruck nur in einen Ausdruck mit Klammern (Hervorhebung hinzugefügt) umgewandelt:

Eine in Klammern gesetzte Ausdrucksliste liefert alles, was diese Ausdrucksliste liefert: Wenn die Liste mindestens ein Komma enthält, liefert sie ein Tupel; Andernfalls wird der einzelne Ausdruck ausgegeben, aus dem die Ausdrucksliste besteht.

Ein leeres Klammerpaar ergibt ein leeres Tupel-Objekt. Da Tupel unveränderlich sind, gelten die Regeln für Literale (d. H. Zwei Vorkommen des leeren Tupels können das gleiche Objekt ergeben oder nicht).

Beachten Sie, dass Tupel nicht durch Klammern, sondern durch Verwendung des Komma-Operators gebildet werden. Die Ausnahme ist das leere Tupel, für das Klammern erforderlich sind. Das Zulassen eines nicht in Klammern gesetzten "Nichts" in Ausdrücken würde zu Mehrdeutigkeiten führen und häufigen Tippfehlern erlauben, nicht erfasst zu werden.

Das heißt (vorausgesetzt 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

Die Ausgabe ist wie erwartet:

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

Hinzufügen einiger Anmerkungen zur Druckanweisung. Wenn Sie versuchen, ein Tuple mit einem einzelnen Element als Teil einer print - Anweisung in Python 2.7 (wie in print (a,)) zu erstellen, benötigen Sie Verwenden Sie das in Klammern gesetzte Formular, da das nachstehende Komma von print a, sonst als Teil der print-Anweisung betrachtet wird und die Zeilenumbruchzeile in der Ausgabe unterdrückt wird und kein Tupel erstellt wird:

Ein '\ n'-Zeichen wird am Ende geschrieben, es sei denn, die print-Anweisung endet mit einem Komma.

In Python 3.x würden die meisten der oben genannten Verwendungen in den Beispielen tatsächlich SyntaxError auslösen, da in Python 3 printwird zu einer Funktion (Sie müssen ein zusätzliches Klammerpaar hinzufügen.) Dies kann jedoch insbesondere Verwirrung stiften:

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

Ich benutze diese Funktion, um Zeichenketten in Tupel umzuwandeln

import ast

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

Verwendung

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



In deinem Fall tust du das

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

Nur für den Fall, dass jemand hierher kommt und versucht, ein Tupel zu erstellen, das jeden Teil der Zeichenfolge "Quattro" und "TT" einem Element der Liste zuweist, sieht das so aus: print Tuple(a.split())

5
igorgruiz

Sie können die folgende Lösung verwenden:

s="jack"

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

output=('jack')
2
sameer_nubia

Unterklassen-Tupel, bei dem einige dieser Unterklassen-Instanzen aus einer Zeichenfolge bestehen müssen, löst etwas Interessantes aus.

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 wie ich aus diesem Thread gelernt habe, musst du das Komma nach args[ 0 ] Setzen.

Die Druckzeile zeigt, dass eine einzelne Zeichenfolge nicht aufgeteilt wird.

Hinweis: Das Komma im Konstruktor der Unterklasse wird jetzt optional:

Sequence( u'silly' )

oder

Sequence( u'silly', )
0
mike rodent