60

我正在努力将字符串转换为元组，而不会在此过程中拆分字符串的字符。有人可以建议一个简单的方法来做到这一点。需要一个班轮。

失败 

   a = 'Quattro TT'
   print tuple(a)

作品 

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

由于我的输入是一个字符串，我通过将字符串转换为列表来尝试下面的代码，该列表再次将字符串拆分为字符..

失败 

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

预期输出： 

('Quattro TT')

生成的输出： 

('Q', 'u', 'a', 't', 't', 'r', 'o', ' ', 'T', 'T')
4

10 回答 10

91

你可以这样做(a,)。无需使用函数。（请注意，逗号是必需的。）

本质上，tuple(a)意味着制作 的内容的元组a，而不是仅由a自身组成的元组。字符串的“内容”（迭代它时得到的）是它的字符，这就是它被分成字符的原因。

于 2013-05-08T20:00:45.410 回答
20

看看关于元组的 Python 教程：

一个特殊的问题是包含 0 或 1 项的元组的构造：语法有一些额外的怪癖来适应这些。空元组由一对空括号构成；一个包含一个项目的元组是通过一个带有逗号的值来构造的（将单个值括在括号中是不够的）。丑陋，但有效。例如：

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

如果您只在字符串对象周围放置一对括号，它们只会将该表达式转换为带括号的表达式（添加了重点）：

带括号的表达式列表产生该表达式列表产生的任何内容：如果列表包含至少一个逗号，则产生一个元组；否则，它会产生构成表达式列表的单个表达式。

一对空的括号产生一个空的元组对象。由于元组是不可变的，因此适用于文字规则（即，空元组的两次出现可能会或可能不会产生相同的对象）。

请注意，元组不是由括号组成，而是由逗号运算符组成。一个例外是空元组，它需要括号——在表达式中允许不带括号的“无”会导致歧义，并允许常见的拼写错误通过而未被捕获。

也就是说（假设 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

输出如预期：

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

在打印语句上添加一些注释。当您尝试在 Python 2.7 中创建单元素元组作为printprint (a,)语句的一部分时（如在 中），您需要使用带括号的形式，因为结尾的逗号print a,否则将被视为 print 语句的一部分，从而导致换行从输出中抑制而不是创建元组：

一个 '\n' 字符写在末尾，除非 print 语句以逗号结尾。

在 Python 3.x 中，示例中的大多数上述用法实际上都会 raise SyntaxError，因为在 Python 3 中print 变成了一个函数（您需要添加一对额外的括号）。但尤其是这可能会引起混淆：

print (a,)            # <-- this prints a tuple containing `a` in Python 2.x
                      #     but only `a` in Python 3.x
于 2013-05-08T20:18:43.803 回答
12

我使用此函数将字符串转换为元组

import ast

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

用法

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



在你的情况下，你做

value = parse_tuple("('%s',)" % a)
于 2017-07-06T08:29:27.450 回答
5

万一有人来到这里试图知道如何创建一个元组，将字符串“Quattro”和“TT”的每个部分分配给列表的一个元素，它会是这样的 print tuple(a.split())

于 2013-09-13T23:31:04.260 回答
2

您可以使用以下解决方案：

s="jack"

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

output=('jack')
于 2018-08-18T12:16:58.383 回答
1

您可以使用eval()

>>> a = ['Quattro TT']  
>>> eval(str(a))
['Quattro TT']
于 2020-09-16T19:02:19.517 回答
0

看：

'Quattro TT'

是一个字符串。

由于 string 是一个字符列表，这与

['Q', 'u', 'a', 't', 't', 'r', 'o', ' ', 'T', 'T']

现在...

['Quattro TT']

是一个字符串在第一个位置的列表。

还...

a = 'Quattro TT'

list(a)

是转换为列表的字符串。

同样，由于 string 是字符列表，因此没有太大变化。

另一个信息...

tuple(something)

这会将某些内容转换为元组。

了解了这一切，我想你可以得出结论，没有什么是失败的。

于 2020-05-22T17:33:44.610 回答
0

将其中一些子类实例可能需要是单字符串实例的子类化元组会引发一些有趣的事情。

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

注意，正如我从这个线程中学到的，你必须把逗号放在args[ 0 ].

打印行显示单个字符串没有被拆分。

注意子类的构造函数中的逗号现在变为可选的：

Sequence( u'silly' )

或者

Sequence( u'silly', )
于 2015-12-07T12:10:23.083 回答
-1 
val_1=input("").strip(")(").split(",") #making a list from the string

if val_1[0].isdigit()==True: #checks if your contents are all integers
  val_2 = []
  for i in val_1:
    val_2.append(int(i))
  val_2 = tuple(val_2)
  print(val_2)
else: # if the contents in your tuple are of string, tis case is applied
  val_2=[]
  for i in range(0,len(val_1)):
      if i==0:
         val_2.append(val_1[i][1:-1])
      else:
         val_2.append(val_1[i][2:-1])

  val_2=tuple(val_2)
  print(val_2)
于 2021-08-08T09:31:28.650 回答
-1

这仅涵盖一个简单的案例：

a = ‘Quattro TT’
print tuple(a)

如果你只使用像'，'这样的分隔符，那么它可以工作。

我使用了configparser这样的字符串：

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

在这种情况下，上述解决方案不起作用。但是，这确实有效：

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())
于 2017-12-13T15:01:08.067 回答