首页 文章

列表和元组之间有什么区别？

提问于
浏览 次
887

有什么不同？

元组/列表有哪些优点/缺点？

python list tuples

19 回答

  • 72

    如果你去散步，你可以在 (x,y) 元组的任何瞬间记下你的坐标 .

    如果您想记录您的旅程，您可以每隔几秒将您的位置附加到列表中 .

    但是你无法反过来做到这一点 .

    回复于
  • 31

    PEP 484 -- Type Hints表示 tuple 的元素类型可以单独输入;这样你就可以说 Tuple[str, int, float] ;但 list ， List 输入类只能使用一个类型参数： List[str] ，暗示2的差异实际上是前者是异质的，而后者本质上是同质的 .

    此外，标准库主要使用元组作为此类标准函数的返回值，其中C将返回 struct .

    回复于
  • 19

    列表用于循环，元组用于结构，即 "%s %s" %tuple .

    列表通常是同类的，元组通常是异构的 .

    列表用于可变长度，元组用于固定长度 .

    回复于
  • 0

    正如人们已经在这里回答的那样 tuples 是不可改变的，而 lists 是可变的，但使用元组有一个重要的方面，我们必须记住

    如果 tuple 中包含 list 或 dictionary ，那么即使 tuple 本身是不可变的，也可以更改它们 .

    例如，假设我们有一个包含列表和字典的元组

    my_tuple = (10,20,30,[40,50],{ 'a' : 10})

    我们可以将列表的内容更改为

    my_tuple[3][0] = 400
my_tuple[3][1] = 500

    这让新元组看起来像

    (10, 20, 30, [400, 500], {'a': 10})

    我们也可以将元组里面的字典改为

    my_tuple[4]['a'] = 500

    这将使整个元组看起来像

    (10, 20, 30, [400, 500], {'a': 500})

    发生这种情况是因为 list 和 dictionary 是对象，并且这些对象不会更改，而是指向的内容 .

    所以 tuple 仍然是不可变的，没有任何例外

    回复于
  • 15

    我发现的基本区别是列表是可变的，因为元组是不可变的 . 元组适用于无需更改的计算 .

    回复于
  • 310

    列表和元组之间的区别

    • Literal
    someTuple = (1,2)
someList  = [1,2]
    • Size
    a = tuple(range(1000))
b = list(range(1000))

a.__sizeof__() # 8024
b.__sizeof__() # 9088

    由于元组操作的大小较小，它变得有点快，但在你拥有大量元素之前，没什么可说的 .

    • Permitted operations
    b    = [1,2]   
b[0] = 3       # [3, 2]

a    = (1,2)
a[0] = 3       # Error

    这也意味着您无法删除元素或对元组进行排序 . 但是，您可以向列表和元组添加新元素，唯一的区别是您将通过添加元素来更改元组的id

    a     = (1,2)
b     = [1,2]  

id(a)          # 140230916716520
id(b)          # 748527696

a   += (3,)    # (1, 2, 3)
b   += [3]     # [1, 2, 3]

id(a)          # 140230916878160
id(b)          # 748527696
    • Usage

    由于列表是可变的，因此它不能用作字典中的键，而可以使用元组 .

    a    = (1,2)
b    = [1,2] 

c = {a: 1}     # OK
c = {b: 1}     # Error
    回复于
  • 2

    这是Python列表的一个例子：

    my_list = [0,1,2,3,4]
top_rock_list = ["Bohemian Rhapsody","Kashmir","Sweet Emotion", "Fortunate Son"]

    这是Python元组的一个例子：

    my_tuple = (a,b,c,d,e)
celebrity_tuple = ("John", "Wayne", 90210, "Actor", "Male", "Dead")

    Python列表和元组是相似的，因为它们都是有序的值集合 . 除了使用括号"[ ... , ... ]"和使用括号"( ... , ... )"的元组创建列表的浅层差异之外，它们之间的核心技术区别在于特定元组的元素是不可变的，而列表是可变的（...所以只有元组是可以清除的并且可以是用作字典/哈希键！） . 这导致了他们能够或者能够如何做到最佳实践的差异，“后验，这就是聪明的程序员所做的事情” . 当使用元组与使用列表时区分后验的主要区别在于人们对元素顺序的含义 .

    对于元组，'order'仅表示用于保存信息的特定'structure' . 在第一个字段中找到的值可以很容易地切换到第二个字段，因为每个字段提供跨两个不同维度或比例的值 . 它们提供不同类型问题的答案，通常具有以下形式：对于给定的对象/主题，它的属性是什么？对象/主体保持不变，属性不同 .

    对于列表，'order'表示序列或方向性 . 第二个元素必须位于第一个元素之后，因为它基于特定和常见的比例或维度位于第二个位置 . 这些元素作为一个整体被提取，并且主要提供表格的单个问题的答案，对于给定的属性，这些对象/主题如何比较？属性保持不变，对象/主题不同 .

    流行文化和程序员中有无数的例子不符合这些差异，并且有无数人可能会使用沙拉叉作为他们的主菜 . 在一天结束时，它很好，通常都可以完成工作 .

    To summarize some of the finer details

    Similarities:

    • 重复 - 元组和列表都允许重复

    • 索引，选择和切片 - 使用括号内的整数值对元组和列表进行索引 . 所以，如果你想要给定列表或元组的前3个值，语法将是相同的：

    >>> my_list[0:3]
[0,1,2]
>>> my_tuple[0:3]
[a,b,c]
    • 比较和排序 - 两个元组或两个列表都通过它们的第一个元素进行比较，如果存在平局，则通过第二个元素进行比较，依此类推 . 在先前元素显示出差异之后，不再进一步关注后续元素 .
    >>> [0,2,0,0,0,0]>[0,0,0,0,0,500]
True
>>> (0,2,0,0,0,0)>(0,0,0,0,0,500)
True

    Differences: - 根据定义，先验

    • 语法 - 列表使用[]，元组使用（）

    • Mutability - 给定列表中的元素是可变的，给定元组中的元素是不可变的 .

    # Lists are mutable:
>>> top_rock_list
['Bohemian Rhapsody', 'Kashmir', 'Sweet Emotion', 'Fortunate Son']
>>> top_rock_list[1]
'Kashmir'
>>> top_rock_list[1] = "Stairway to Heaven"
>>> top_rock_list
['Bohemian Rhapsody', 'Stairway to Heaven', 'Sweet Emotion', 'Fortunate Son']

# Tuples are NOT mutable:       
>>> celebrity_tuple
('John', 'Wayne', 90210, 'Actor', 'Male', 'Dead')
>>> celebrity_tuple[5]
'Dead'
>>> celebrity_tuple[5]="Alive"
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
    • Hashtables（字典） - 由于哈希表（字典）要求其键是可清除的，因此不可变，只有元组可以充当字典键，而不是列表 .
    #Lists CAN'T act as keys for hashtables(dictionaries)
>>> my_dict = {[a,b,c]:"some value"}
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

#Tuples CAN act as keys for hashtables(dictionaries)
>>> my_dict = {("John","Wayne"): 90210}
>>> my_dict
{('John', 'Wayne'): 90210}

    差异 - 后验，使用中

    • Homo与元素的异构性 - 通常列表对象是同质的和元组的对象是异构的 . 也就是说，列表用于相同类型的对象/主题（如所有总统候选人，或所有歌曲，或所有跑步者），尽管它不是强制的），而元组更多用于异类对象 .

    • 循环与结构 - 尽管两者都允许循环（对于my_list中的x ...），但只对列表进行循环才有意义 . 元组更适合于构造和呈现信息（％s％s居住在％s中是％s，目前％s％（“John”，“Wayne”，90210，“Actor”，“Dead”））

    回复于
  • -1

    列表和元组按特定顺序存储一个或多个对象或值 . 存储在列表或元组中的对象可以是任何类型，包括None关键字定义的任何类型 .

    Syntax Differences

    list和tuple的语法略有不同 . 列表由方括号[]包围，元组由括号（）括起 .

    Example 1.1 ：创建列表与创建元组

    list_num = [1,2,3,4]
tup_num = (1,2,3,4)

print(list_num)
print(tup_num)

    Output:

    [1,2,3,4]
(1,2,3,4)

    Mutable List vs Immutable Tuples

    列表具有可变性质，即列表可以根据需要在其创建之后被改变或修改，而元组具有不可变性质，即元组在其创建之后不能被改变或修改 .

    Example 2.1 ：修改项目列表与元组

    list_num[2] = 5
print(list_num)

tup_num[2] = 5

    Output:

    [1,2,5,4]
Traceback (most recent call last): 
 File "python", line 6, in <module> 
TypeError: 'tuple' object does not support item assignment

    Available Operations

    列表具有比元组更多的内置函数 . 我们可以使用dir（[object]）内置函数来获取列表和元组的所有相关函数 .

    Example 3.1 ：列出目录

    dir(list_num)
dir(tup_num)

    Size Comparison

    元组操作的大小比列表小，这使得它更快，但在你有大量元素之前没有多少提及 .

    Example 5.1 ：计算List与Tuple的大小

    a= (1,2,3,4,5,6,7,8,9,0)
b= [1,2,3,4,5,6,7,8,9,0]

print('a=',a.__sizeof__())
print('b=',b.__sizeof__())

    Output:

    a= 104
b= 120

    Different Use Cases

    • 乍一看，似乎列表总是可以替换元组 . 但是元组是非常有用的数据结构

    • 使用元组而不是列表可以为程序员和解释器提供不应更改数据的提示 .

    • 元组通常用作字典的等效词，没有用于存储数据的键 .

    Key points to remember:

    • 元组的字面语法由括号（）显示，而列表的字面语法由方括号[]显示 .

    • 列表具有可变长度，元组具有固定长度 .

    • List具有可变性，元组具有不变性 .

    • List具有比元组更多的功能 .

    回复于
  • 18

    首先，它们都是Python中的非标量对象（也称为复合对象） .

    • 元组，有序的元素序列（可以包含任何没有别名问题的对象）

    • 不可变（tuple，int，float，str）

    • 使用 + 连接（当然会创建全新的元组）

    • 索引

    • 切片

    • Singleton (3,) # -> (3) 而不是 (3) # -> 3

    • List（其他语言中的数组），有序的值序列

    • 可变

    • Singleton [3]

    • 克隆 new_array = origin_array[:]

    • 列表理解 [x**2 for x in range(1,7)] 给你 [1,4,9,16,25,36] （不可读）

    使用列表也可能导致别名错误（两个不同的路径指向同一个对象） .

    回复于
  • 9

    list 的值可以随时更改，但 tuples 的值不能更改 .

    advantages and disadvantages 取决于用途 . 如果你有这样的数据，你永远不想改变那么你应该使用元组，否则列表是最好的选择 .

    回复于
  • -1

    列表和元组之间的区别

    元组和列表在Python中看似相似的序列类型 .

    • Literal syntax

    我们使用括号（ `` ）来构造元组和方括号 [ ] 以获得新列表 . 此外，我们可以使用适当类型的调用来获取所需的结构 - 元组或列表 .

    someTuple = (4,6)
someList  = [2,6]
    • Mutability

    元组是不可变的，而列表是可变的 . 这一点是以下几点的基础 .

    • Memory usage

    由于可变性，您需要更多的内存用于列表，而更少的内存用于元组 .

    • Extending

    您可以向元组和列表添加新元素，唯一的区别是元组的id将被更改（即，我们将有一个新对象） .

    • Hashing

    元组是可以清洗的，而列表则不是 . 这意味着您可以将元组用作字典中的键 . 该列表不能用作字典中的键，而a可以使用元组

    tup      = (1,2)
list_    = [1,2] 

c = {tup   : 1}     # ok
c = {list_ : 1}     # error
    • Semantics

    这一点更多的是关于最佳实践 . 您应该使用元组作为异构数据结构，而列表是同质序列 .

    回复于
  • 925

    列表是可变的，元组是不可变的 . 试试这个例子吧 .

    a = ["1", "2", "ra", "sa"]    #list
b = ("1", "2", "ra", "sa")    #tuple

    现在更改list和tuple的索引值 .

    a[2] = 1000
print a     #output : ['1', '2', 1000, 'sa']
b[2] = 1000
print b     #output : TypeError: 'tuple' object does not support item assignment.

    因此证明以下代码对元组无效，因为我们试图更新一个不允许的元组 .

    回复于
  • 2

    关键的区别在于元组是不可变的 . 这意味着一旦创建了元组，就无法更改元组中的值 .

    因此，如果您需要更改值，请使用List .

    对元组的好处：

    • 性能略有改善 .

    • 由于元组是不可变的，它可以用作字典中的键 .

    • 如果你可以't change it neither can anyone else, which is to say you don't需要担心任何API函数等改变你的元组而不被问到 .

    回复于
  • 1

    List是可变的，元组是不可变的 . 可变和不可变的主要区别在于您尝试追加项目时的内存使用情况 .

    创建变量时，会为变量分配一些固定内存 . 如果是列表，则分配的内存比实际使用的内存多 . 例如 . 如果当前存储器分配是100个字节，当你想要追加第101个字节时，可能会分配另外100个字节（在这种情况下总共200个字节） .

    但是，如果您知道不经常添加新元素，那么您应该使用元组 . 元组分配所需内存的大小，因此可以节省内存，尤其是在使用大块内存时 .

    回复于
  • 0

    除了元组是不可变的之外，还有一个语义上的区别应该指导它们的使用 . 元组是异构数据结构（即，它们的条目具有不同的含义），而列表是同构序列 . Tuples have structure, lists have order.

    使用这种区别使代码更加明确和易懂 .

    一个例子是一对页面和行号来引用书中的位置，例如：

    my_location = (42, 11)  # page number, line number

    然后，您可以将其用作字典中的键来存储位置注释 . 另一方面，列表可用于存储多个位置 . 当然，人们可能希望在列表中添加或删除位置，因此列表是可变的是有道理的 . 另一方面，在现有位置添加或删除项目没有意义 - 因此元组是不可变的 .

    在某些情况下，您可能希望更改现有位置元组中的项目，例如在遍历页面行时 . 但元组不可变性迫使您为每个新值创建一个新的位置元组 . 这看起来很不方便，但使用这样的不可变数据是 Value 类型和函数编程技术的基石，它们具有很大的优势 .

    关于这个问题有一些有趣的文章，例如"Python Tuples are Not Just Constant Lists"或"Understanding tuples vs. lists in Python" . 官方Python文档also mentions this

    “元组是不可变的，通常包含异构序列......” .

    在像Haskell这样的静态类型语言中，元组中的值通常具有不同的类型，并且元组的长度必须是固定的 . 在列表中，值都具有相同的类型，并且长度不固定 . 所以差异非常明显 .

    最后在Python中有namedtuple，这是有道理的，因为元组已经被认为具有结构 . 这强调了元组是类和实例的轻量级替代品的想法 .

    回复于
  • 6

    列表是可变的;元组不是 .

    来自docs.python.org/2/tutorial/datastructures.html

    元组是不可变的，并且通常包含异构的元素序列，这些元素可以通过解包（参见本节后面部分）或索引（或者甚至是在namedtuples的情况下通过属性）来访问 . 列表是可变的，它们的元素通常是同类的，可以通过遍历列表来访问 .

    回复于
  • 183

    这是差异主要是语义的：人们期望元组和列表代表不同的信息 . 但这比指南更进一步;一些库实际上根据它们传递的内容表现不同 . 以NumPy为例（复制自another post，我要求更多示例）：

    >>> import numpy as np
>>> a = np.arange(9).reshape(3,3)
>>> a
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])
>>> idx = (1,1)
>>> a[idx]
4
>>> idx = [1,1]
>>> a[idx]
array([[3, 4, 5],
       [3, 4, 5]])

    关键是，虽然NumPy可能不是标准库的一部分，但它是一个主要的Python库，并且在NumPy列表和元组中是完全不同的东西 .

    回复于
  • 3

    列表旨在是同构序列，而元组是异构数据结构 .

    回复于
  • 6

    来自5.3. Tuples and Sequences文档的方向引用：

    尽管元组看起来与列表类似，但它们通常用于不同的情况并用于不同的目的 . 元组是不可变的，并且通常包含异构的元素序列，这些元素可以通过解包（参见本节后面部分）或索引（或者甚至是在namedtuples的情况下通过属性）来访问 . 列表是可变的，它们的元素通常是同类的，可以通过遍历列表来访问 .

    回复于

相关问题