python matplotlib教學 列表和元組有什麼區別?




scatter plot python (12)

PEP 484-Type Hints指出tuple的元素類型可以單獨輸入; 所以你可以說Tuple[str, int, float] ; 但是一個帶有List類的List只能使用一個類型參數: List[str] ,這意味著2的區別實際上是前者是異構的,而後者本質上是同類的。

而且,標準庫通常使用元組作為C返回struct標準函數的返回值。

有什麼不同?

元組/列表有什麼優點/缺點?


列表的值可以隨時更改,但元組的值不能更改。

優點和缺點取決於使用情況。 如果你有這樣一個你永遠不想改變的數據,那麼你應該使用元組,否則列表是最好的選擇。


列表是可變的,元組是不可變的。 只要考慮這個例子。

a = ["1", "2", "ra", "sa"]    #list
b = ("1", "2", "ra", "sa")    #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.

因此證明下面的代碼對於元組是無效的,因為我們試圖更新一個不允許的元組。


如果你去散步,你可以在任何時刻在(x,y)元組中記下你的坐標。

如果你想記錄你的旅程,你可以每隔幾秒將你的位置追加到列表中。

但是你不能以相反的方式去做。


關鍵的區別是元組是不可變的。 這意味著一旦創建它就不能更改元組中的值。

因此,如果您需要更改值,請使用List。

對元組的好處:

  1. 性能略有改善。
  2. 作為一個元組是不可變的,它可以用作字典中的一個鍵。
  3. 如果你不能改變任何人,也就是說你不需要擔心任何API函數等等,在不被詢問的情況下改變你的元組。

列表是可變的; 元組不是。

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

元組是不可變的,並且通常包含通過解包(參見本節後面的內容)或索引(甚至在命名的情況下通過屬性)訪問的異構元素序列。 列表是可變的,它們的元素通常是同類的,並且通過遍歷列表來訪問。


這是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列表和元組類似,因為它們都是有序的值集合。 除了使用括號“[...,...]”和使用括號“(...,...)”的元組創建列表之間的淺表差別之外,核心技術“Python語法中的硬編碼”差異是特定元組的元素是不可變的,而列表是可變的(...所以只有元組是可哈希的,可以用作字典/哈希鍵!)。 這會導致他們如何使用或不能使用(由語法強制先驗)以及人們如何選擇使用它們的差異(鼓勵為'最佳實踐',後驗,這是聰明的程序員所做的)。 在使用元組和使用列表時區分後驗差異的主要區別在於人們對元素順序的含義

對於元組來說,'秩序'只不過是一個用於存儲信息的特定“結構”。 在第一個字段中找到的值可以很容易地切換到第二個字段,因為每個字段都提供了兩個不同維度或比例的值。 他們為不同類型的問題提供答案,並且通常具有以下形式: 對於給定的對象/主題,它的屬性是什麼? 對象/對象保持不變,屬性不同。

對於列表,“秩序”表示序列或方向性。 第二個元素必須位於第一個元素之後 ,因為它位於第二個位置,基於特定的公用比例或維度。 這些元素是作為一個整體來考慮的,主要為一個典型的單個問題提供答案, 對於一個給定的屬性,這些對象/主題如何比較? 該屬性保持不變,對象/主題不同。

流行文化和程序員中有不計其數的人不符合這些差異的例子,並且有無數人可能會使用沙拉叉作為他們的主菜。 在一天結束時,這很好,兩者通常都可以完成工作。

總結一些更好的細節

相似點:

  1. 重複 - 元組和列表都允許重複
  2. 索引,選擇和切片 - 元組和列表索引使用括號內的整數值。 因此,如果您想要給定列表或元組的前3個值,則語法將是相同的:

    >>> my_list[0:3]
    [0,1,2]
    >>> my_tuple[0:3]
    [a,b,c]
    
  3. 比較和排序 - 兩個元組或兩個列表通過它們的第一個元素進行比較,並且如果有聯繫,則通過第二個元素進行比較,依此類推。 之前的元素顯示出不同之處後,不再關注隨後的元素。

    >>> [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
    

差異:根據定義,先驗

  1. 語法 - 列表使用[],元組使用()

  2. 可變性 - 給定列表中的元素是可變的,給定元組中的元素不可變。

    # 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
    
  3. 哈希表(字典) - 隨著哈希表(字典)要求其鍵可哈希因此不可變,只有元組可以充當字典鍵,而不是列表。

    #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}
    

差異 - 後驗,在使用中

  1. 元素的元素與元素的異質性 - 通常列表對像是同質的,元組對像是異構的。 也就是說,列表被用於相同類型的對象/主題(如所有總統候選人,或所有歌曲,或所有參賽者),而不是被迫的),而元組則更多地用於異構對象。

  2. 循環與結構 - 雖然兩者都允許循環(對於my_list中的x ...),但它對於列表來說只有真正有意義。 元組更適合構造和呈現信息(%s%s存在於%s中,是%s,現在是%s%(“John”,“Wayne”,90210,“Actor”,“Dead”))


列表用於循環,元組用於結構,即"%s %s" %tuple

列表通常是同構的,元組通常是異構的。

列表是可變長度的,元組是固定長度的。


有人提到 ,差異主要是語義上的:人們期望一個元組和列表來表示不同的信息。 但是這比一個準則更進一步。 一些圖書館的行為基於他們傳遞的內容而有所不同。 以NumPy為例(從另一篇帖子中復制我要求更多的例子):

>>> 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列表和元組中是完全不同的東西。


列表和元組之間的區別

  1. 文字

    someTuple = (1,2)
    someList  = [1,2] 
    
  2. 尺寸

    a = tuple(range(1000))
    b = list(range(1000))
    
    a.__sizeof__() # 8024
    b.__sizeof__() # 9088
    

    由於元組操作的規模較小,它會變得更快一些,但是除非您有大量元素,否則不會提及。

  3. 允許的操作

    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
    
  4. 用法

    由於列表是可變的,它不能用作字典中的鍵,而可以使用元組。

    a    = (1,2)
    b    = [1,2] 
    
    c = {a: 1}     # OK
    c = {b: 1}     # Error
    

除了元組是不可變的,還有一個應該引導它們用法的語義區別。 元組是異構數據結構(即它們的條目具有不同的含義),而列表是同類序列。 元組有結構,列表有順序。

使用這種區別使代碼更加明確和易於理解。

一個例子是成對的頁面和行號來引用書中的位置,例如:

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

然後,您可以將其用作字典中的關鍵字來存儲位置的註釋。 另一方面,列表可用於存儲多個位置。 當然,人們可能希望添加或刪除列表中的位置,所以列表是可變的是有意義的。 另一方面,從現有位置添加或移除項目是沒有意義的 - 因此元組是不可變的。

可能會出現您想要更改現有位置元組內的項目的情況,例如,在遍歷頁面行時。 但是元組的不變性迫使你為每個新值創建一個新的位置元組。 這看起來似乎很不方便,但像這樣使用不可變的數據是價值類型和函數式編程技術的基石,它們可能具有相當大的優勢。

在這個問題上有一些有趣的文章,例如“Python元組不僅僅是常量列表”或者“在Python中理解元組與列表” 。 官方的Python文檔也提到了這一點“元組是不可變的,通常包含一個異構的序列......” )。

在像Haskell這樣的靜態類型語言中,元組中的值通常具有不同的類型,並且元組的長度必須是固定的。 在一個列表中,這些值都具有相同的類型,並且長度不固定。 所以差別非常明顯。

最後是Python中的namedtuple ,這是有道理的,因為元組已經被認為具有結構。 這強調了元組是類和實例的輕量級替代的想法。


首先,它們都是Python中的非標量對象(也稱為複合對象)。

  • 元組,有序的元素序列(可以包含任何沒有鋸齒問題的對象)
    • 不可變(tuple,int,float,str)
    • 使用+連接(當然會創建全新的元組)
    • 索引
    • 切片
    • 單身(3,) # -> (3)而不是(3) # -> 3
  • 列表(其他語言的數組),有序的值序列
    • 易變的
    • 辛格爾頓[3]
    • 克隆new_array = origin_array[:]
    • 列表理解[x**2 for x in range(1,7)]給你[1,4,9,16,25,36] (不可讀)

使用列表還可能導致別名錯誤(兩個不同的路徑指向同一對象)。







tuples