1.元組的概念

Python中的元組和列表很相似，元組也是Python語言提供的內(nèi)置數(shù)據(jù)結構之一，可以在代碼中直接使用。

元組和列表就像是一個孿生兄弟，表現(xiàn)形式和使用上都大差不差，但是兩者又有非常明顯的區(qū)別：

• 元組是用小括號表示的，列表的小括號還可以直接省略，而列表是使用中括號表示的，列表的中括號必須存在。
• 元組的對象是不可變類型的，也就是說，一旦定義了元組，元組中的數(shù)據(jù)時不能進行更改的。
• 列表中的對象是可變類型的，定義了列表之后，可以對列表中的數(shù)據(jù)進行增刪改。

一個元組中也會定義很多個數(shù)據(jù)元素，每個數(shù)據(jù)元素也都可以通過索引的方式獲取，也有正數(shù)、負數(shù)索引一說。

當一個元組中的數(shù)據(jù)元素是一個列表時，對于元素是不允許修改的，但是元素中列表的數(shù)據(jù)時可以被修改的，有種多維列表的概念，這個列表在元組中相當于一個子列表，這種情況在下面的操作中會進行演示。

問題來了，既然元組和列表那么的相似，為什么還要設計元組這種數(shù)據(jù)結構呢？

其實也并不難理解，元組的對象是不可變類型的，一旦創(chuàng)建了元組這種不可變類型的對象，對象中的所有數(shù)據(jù)將不能修改，也能夠避免由于修改數(shù)據(jù)從而引發(fā)的Bug錯誤，此外，對于不可變類型的對象值，在多并發(fā)的環(huán)境下是不需要加鎖的，因為它的數(shù)據(jù)不可能會被改變，因此多并發(fā)的時候就不需要加鎖，從而避免并發(fā)1修改了數(shù)據(jù)并發(fā)2依舊是舊數(shù)據(jù)。

因此在程序中我們也要盡量使用不可變類型的對象。

當元組中存在一個列表對象時，為什么列表中的元素可以被修改？不是說元組的對象是不可變類型嗎？

因為一個元組中有很多個元素，列表呢只屬于其中的一個元素，對應一個索引，對于元組而言存儲的是引用元素所在內(nèi)存中的地址，存儲引用的內(nèi)存地址是不會被改變的，也就意味著元組中的元素定義好之后，不能再添加、刪除元組中的對象元素，但是列表只是元組中的一個元素，即使修改列表的數(shù)據(jù)也不會對元組中的對象元素有改動，根據(jù)列表的特點以及列表有自己的數(shù)據(jù)結構，就可以對元組中元素為列表的對象進行修改。

2.元組的基本使用

在前面說了那么多的理論，例如元組用小括號表示，元組的特性等等，在本小結，我們通過案例來是驗證。

2.1.定義一個元組

元組用小括號定義。

#定義一個元組
mytuple = ("jiangxl", 123, "python")
print(mytuple)

#輸出結果：('jiangxl', 123, 'python')

定義元組時小括號可以省略。

mytuple = "jiangxl", 123, "python"
print(mytuple)

#輸出結果：('jiangxl', 123, 'python')

2.2.定義一個空元組

可以使用()表示一個空元組，也可以使用tuple()函數(shù)定義一個空元組

mytuple = ()
print(mytuple)

print(tuple())

2.3.元組的元素是不可變的

元組中的對象元素是不可變的，已定義好的元組，其中的元素是不能被修改的，如下所示：

mytuple = ("jiangxl", 123, "python")

#嘗試修改索引為1的元素
mytuple[1] = 678

直接回拋出錯誤：TypeError: ‘tuple’ object does not support item assignment

2.4.當元組中的元素是一個列表時列表中的元素可變

當一個元組中的元素是一個列表時，這個列表相當于元組的一個元素，面向一個索引，此時這個列表相當于多維列表中子列表的概念，有自己的索引分布，因此當元組中的元素是列表時，這個列表中的元素可以改變。

元組會存儲元素在內(nèi)存中的地址，這個地址是不能被修改的，因此可以保證元素在元組中不會改變，但是列表是元組中的一個元素，這個元素對象不變就可以，至于元素中的元素就受列表的特性控制了。

#定義一個元組，其中索引1對應的元素是[1, 2, 3]列表
mytuple2 = ("jiangxl", [1, 2, 3], "python")

#修改[1, 2, 3]列表中1元素為123
'''
    首先找到[1, 2, 3]列表所在元組中的元素對應的索引：mytuple2[1]
    然后在找到元素1對應在列表中的索引：mytuple2[1][0]
'''
mytuple2[1][0] = 123

#打印元組的內(nèi)容觀察是否被修改
print(mytuple2)

#輸出結果：('jiangxl', [123, 2, 3], 'python')

2.5.當元組中只定義一個元素時的注意事項

當在元素中只定義一個元素時，有一些注意事項，即使是只定義一個元素，也要在元組中至少包含一個逗號，否則Python就認為我們定義的并非是元組，只是一個字符串。

1）定義元組中只有一個元素且不加逗號

當定義的元組中只有一個元素時，并且沒有加逗號，此時Python認為這并不是一個元組，只是一個字符串，()括號也被認為是數(shù)學中的括號。

#元組中只有一個元素，且不添加逗號
mytuple = ("jiangxl")

#打印這個元組中的元素
print(mytuple)
#輸出結果：jiangxl

#竟然只輸出了一個字符串，并不是元組的形式，我們打印這個數(shù)據(jù)的類型
print(type(mytuple))
#輸出結果：<class 'str'>
#發(fā)現(xiàn)只是一個字符串類型，并不是元組

2）定義元組中只有一個元素且加逗號

在元組()中只要有一個逗號，Python就認為這是一個元組。

mytuple = ("jiangxl",)

3.列表的所有操作同樣適用于元組

元組和列表很類似，幾乎一樣，只不過元組是不可變的類型，列表能實現(xiàn)的操作，也同樣適用于元組。

理論就不再敘說了，不明白的去看前面列表這類操作的理論，說的非常明白了。

1）元組的切片

#元組的切片
mytuple = ("jiangxl", 123, "python", 111, 22, 45, "abc")
print(mytuple[1:4])                 

#輸出結果； (123, 'python', 111)

2）查詢元組中某個元素的索引

#查詢元組中某個元素的索引
mytuple = ("jiangxl", 123, "python", 111, 22, 45, "abc")
print(mytuple.index(123))           

#輸出結果；1

3）使用乘法運算符操作列表

#使用乘法運算符操作列表
mytuple = ("jiangxl", 123, "python", 111, 22, 45, "abc")
mytuple2 = mytuple * 2
print(mytuple2)     

#輸出結果：('jiangxl', 123, 'python', 111, 22, 45, 'abc', 'jiangxl', 123, 'python', 111, 22, 45, 'abc')

4）使用加法運算符操作列表

#使用加法運算符操作列表
mytuple3 = ("abc", "k8s", "jenkins")
mytuple4 = (123, 456, 789, 111)
print(mytuple3 + mytuple4)         

#輸出結果：('abc', 'k8s', 'jenkins', 123, 456, 789, 111)

5）元組之間的比較

元組的比較也是基于元組中的所有元素都是數(shù)字的情況下，才能進行比較。

#元組的比較
mytuple5 = (1, 2, 3, 4)
mytuple6 = (1, 2, 5, 8, 9)
print(mytuple5 < mytuple6)

#輸出結果：True

6）元組的反轉

元組是不可變的類型，不能通過方法reverse實現(xiàn)元組的反轉，因為調(diào)用類方法會修改元組本身的元素，所以只能通過reversed函數(shù)實現(xiàn)反轉。

mytuple = ("jiangxl", 123, "python", 111, 22, 45, "abc")
print(list(reversed(mytuple)))            

#輸出結果：['abc', 45, 22, 111, 'python', 123, 'jiangxl']

7）元組的排序

元組是不可變的類型，不能通過方法sort實現(xiàn)元組排序，因為調(diào)用類方法會修改元組本身的元素，所以只能通過sorted函數(shù)實現(xiàn)排序。

元組進行排序時，如果元組中存在字符串類型的元素，那么其他所有的元素無論什么類型，都需要單獨用引號引起來，否則不能排序，會拋出錯誤。

mytuple = (1, 2, 5, 8, 9)
##升序
print(sorted(mytuple))                      
#輸出結果：[1, 2, 5, 8, 9]

##降序
print(sorted(mytuple, reverse=True))            
#輸出結果：[9, 8, 5, 2, 1]

4.就是想修改元組中的某個元素

元組的對象是不可變類型的，不允許增、刪、改，但是我們就是想改元組的對象元素，也是有辦法的。

• 重新聲明元組，對元素進行增刪改
• 使用切片截取元組中需要的元素，然后是還有加法運算符拼接新的對象元素。

第一種方法無需演示，懂得都會，重點看第二種方法。

這種方法的核心思想就是：利用切片（保留元組中想要的元素）+拼接（將多個切片的元組合并）的方式即可對元組中的元素改變。

需求：

? (“jiangxl”, 123, “python”, 111, 22, 45, “abc”)

有一個元組，對象元素如上所示，我想刪掉元組中的“22”和“45”這兩個對象元素。

實現(xiàn)思路：

• 我們都知道元組是不可變的類型，不允許修改其中的元素，但是我們就要反其道而行之，運用所學的知識實現(xiàn)這個需求。
• 想刪掉元組中的“22”和“45”這兩個對象元素，可以使用切片的方式將這兩個元素之外的元素從列表中切出來。
• 由于這兩個元素前后都有其他元素，一個切片截取22元素之前的其他元素，一個切片截取45元素之后的其他元素。
• 最后通過加法運算符將兩個切片合并在一起，形成一個新的元組，此時這個元組中就不包含22”和“45”這兩個對象元素。通過切片+拼接的方法就可以將元組中的元素進行刪除操作，如果是修改也是同樣的方法：切片+拼接。

代碼如下：

#定義初始元組
'''
    定義好初始元組后，突然想修改元組中的元素了，但是又不想去調(diào)整初始元組，故而通過切片+拼接的方法產(chǎn)生一個新的元組，也就相當于對元組的元素進行改變了。
    需求：刪掉元組中的“22”和“45”這兩個對象元素
'''
mytuple = ("jiangxl", 123, "python", 111, 22, 45, "abc")


'''
    使用切片截取22元素之前的其他元素，無需指定起始索引，從第一個元素處開始截取，指定結束索引為4
    索引4是元素22的索引，指定結束元素是4，結束元素不會被納入切片
'''
mytuplestart = mytuple[:4]

'''
    22元素之前的全部元素都截取出來后，還要對45之后的元素進行截取，因為我們只是不想要22和45了，45之后還有其他的元素
    指定開始索引為6，索引為6的元素是abc，完美避開了22和45這兩個元素，不指定結束索引，一直切片到最后一個元素
'''
mytuolestop = mytuple[6:]

'''
    使用加法運算符將兩個切片拼接在一起，形成新的元組
'''
mytuplenew = mytuplestart + mytuolestop
print(mytuplenew)

#輸出結果：('jiangxl', 123, 'python', 111, 'abc')

到此這篇關于Python中元組的概念以及應用的文章就介紹到這了,更多相關Python中元組概念內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

最新評論