<strike id="rrvnz"></strike>

    <noframes id="rrvnz">
    <noframes id="rrvnz"><span id="rrvnz"><pre id="rrvnz"></pre></span><address id="rrvnz"></address>
    <address id="rrvnz"><nobr id="rrvnz"></nobr></address><noframes id="rrvnz">
      <em id="rrvnz"></em>

        首 頁IT知識庫翔宇問吧收藏內容
        當前位置:翔宇亭IT樂園IT知識庫Python

        Python Tuple數據類型的定義與使用

        減小字體 增大字體 作者:本站  來源:本站整理  發布時間:2020-07-10 12:35:26

        Python中的元組(tuple)屬于不可變數據類型,即定義后不能修改,包括新增元素,刪除元素或修改元素的值。

        一、tuple數據的定義

        tuple中的每一項使用英文半角的逗號進行分隔,并且所有元素值放在一對英文半角的圓括號中“()”,tuple中每一項的數據類型可以不同。

        >>> t1 = (1, 2, 3, 1)
        >>> print(t1)
        (1, 2, 3, 1)
        >>> 

        從上面的例子中,我們還可以知道,tuple中的元素值可以相同,如上面的例子 t1中有兩個 1.

        tuple類型也可以像下面這種方式進行定義:

        >>> t2 = 1, 2, 3, None, "Python"
        >>> print(t2)
        (1, 2, 3, None, 'Python')
        >>>

        也就是說,在省略圓括號時,Python也把具有逗號分隔的多個值視為tuple類型,同時,None 也可以是tuple的元素。

        這個例子也向我們說明了,Python中的tuple可以具有不同數據類型的數據,如上面的數值類型,字符串類型和None類型。

        >>> t3 =(('001', '張濤'), ('002', '劉紅', 23))
        >>> print(t3)
        (('001', '張濤'), ('002', '劉紅', 23))
        >>> 

        Python中的tuple類型可以為空,即沒有任何元素:

        >>> t4 = ()
        >>> print(t4)
        ()
        >>>

        但是在定義tuple類型時,只有一個元素且沒有逗號時,Python將會把該數據解釋成簡單的數據類型,如:

        >>> t5 = (10)
        >>> print(t5)
        10
        >>> print(type(t5))
        <class 'int'>
        >>>

        也就是說,并沒有像用戶期待的輸出(10),同時,通過使用type來判斷t5的類型發現,t5 是int類型的,這與直接使用 t5 = 10的效果相同。

        對于其它類型也有相同的效果,下面給出了幾個例子:

        >>> t6 = (12.3)
        >>> print(t6, type(t6))
        12.3 <class 'float'>
        >>> t7 = ("Hello")
        >>> print(t7, type(t7))
        Hello <class 'str'>
        >>>

        如果tuple中確只有一個元素值,可以使用在其值后加逗號的方式來定義:

        >>> t8 = (12.3,)
        >>> print(t8, type(t8))
        (12.3, ) <class 'tuple'>
        >>> t9 = ('Hello', )
        >>> print(t9, type(t9))
        ('Hello', ) <class 'tuple'>
        >>>

        二、訪問tuple的元素

        我們可以使用tuple元素的索引來訪問元素值,其索引從0開始到tuple的長度-1(即元素個數-1)。訪問的語法格式如下:

        tuple_name[索引值]

        在使用時索引值不能越界,即當以正數索引訪問時,索引的最大值為:元素個數 - 1,超過此值將會引發 IndexError的錯誤;當以負數索引進行訪問時,索引的最小值是: -元素個數,比此值再小時也會引發 IndexError 錯誤。

        t10 = (1, 2, 3, 4, 5)
        print(t10[0])  # 輸出 1
        print(t10[2])  # 輸出 3
        print(t10[4])  # 輸出 5
        print(t10[5])  # 索引越界,引發異常
        print(t10[-1]) # 輸出 5
        print(t10[-4]) # 輸出 2
        print(t10[-5]) #輸出 1
        print(t10[-6]) #索引越界,引發異常

        以上在Python3.8.2中的輸出如下:

        訪問tuple中的元素

        從以上可以看出,索引不在有效范圍內時將引發:IndexError 異常,告知:tuple index out of range(元組索引超出范圍)。

        下面再介紹一下嵌套元組的訪問方法:

        >>> t11 = (1, 2, (3, 4), (5, 6, 7))
        >>> t11[0]
        1
        >>> t11[2][0]
        3
        >>> t11[3][2]
        7
        >>> t11[-2][1]
        4
        >>> t11[-2][-2]
        3
        >>> t11[3][-2]
        6
        >>>

        從以上各例可以看出,我們可以靈活使用正數索引和負數索引來訪問元組中不同的元素值。

        三、元組的切片操作

        我們可以使用切邊功能創建一個子元組,即通過切片獲取元組中的部分值。切片的基本語法格式為:

        tuple_name[ start : end : step ]

        • start:切片開始時的索引,默認為0;
        • end:切片結束位置的索引,默認為元組長度-1;
        • step:步長,即每 step 獲取一個元素值,默認為1。

        根據實際操作情況,三個索引都可以有選擇的使用。

        下面使用具體的例子來介紹具體使用方法:

        >>> t = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
        >>> t1 = t[2 : ]  # 截取從索引2開始到最后的所有元素值
        >>> print(t1)
        (3, 4, 5, 6, 7, 8, 9, 10)
        >>> t2 = t[ :7]  #從開頭到索引7停止,注意不含 索引7處的值
        >>> print(t2)
        (1, 2, 3, 4, 5, 6, 7)
        >>> t3 = t[2 : 8]  # 從索引2開始到索引8停止,不含8處的值
        >>> print(t3)
        (3, 4, 5, 6, 7, 8)
        >>> t4 = t[ 3 : 9 : 2]  # 從索引3到索引9 每2個取1個值
        >>> print(t4)
        (4, 6, 8)
        >>> t5 = t[-5: ]  # 從后端進行索引
        >>> print(t5)
        (6, 7, 8, 9, 10)
        >>> t6 = t[ : -5] # 截止到索引-5,不含-5
        >>> print(t6)
        (1, 2, 3, 4, 5)
        >>> t7 = t[ -8 : -3 ]  # 從索引 -8 截取到 -3
        >>> print(t7)
        (3, 4, 5, 6, 7)
        >>> t8 = t[-8 : -3 : 2] # 從索引 -8 截取到 -3,每2個取1個
        >>> print(t8)
        (3, 5, 7)
        >>> t9 = t[-3 : -8 : -2]  # 從索引-3 開始到索引-8,從后往前每2截取1
        >>> print(t9)
        (8, 6, 4)
        >>> t10 = t[9 : 2 : -2] # 從索引9到索引2,從后往前每2截1
        >>> print(t10)
        (10, 8, 6, 4)
        >>> 

        以上各例演示了實際中可能用到的切片方式,特別需要注意:

        (1)start 處的值包含在截取結果中,end 指定的是截止位置,end 處的值不含在截取結果中;

        (2)在不指定 step 時,start 指定的索引只有在邏輯上處于end的左側或與end相等時才會截取到值;

        (2)step指定的截取步,可以理解為 每 step 個截取1個,不能理解為每隔 step 進行截取;

        (3)step為正值時是從左往右進行截取,start邏輯上必須在end的左側才會截取到結果;

        (4)step為負值時是從右往左截取,start邏輯上必須在end的右側才會截取到結果,如例子中的 t9和t10.

        (5)startendstep 的值都可以省略,省略時,start = 0, end = len(t) - 1, step = 1,但是冒號不能省,

        如下幾個例子:

        >>> t11 = t[ : ]
        >>> print(t11)
        (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
        >>> t11 = t[ : : ]
        >>> print(t11)
        (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
        >>> t11 = t[]  # 企圖連冒號都要省
        SyntaxError: invalid syntax
        >>>

        當把冒號都省略時會出現語法錯誤:無效的語法格式

        以上各例在Python3.8.2中的運行情況如下圖所示:

        Python 元組切片

        關于Python中索引的使用方式,大家可以參照這篇文章《Python中創建列表、訪問列表、刪除列表等操作方法》里關于索引的示意圖與說明。Python中關于序列類型的索引方法是一致的。

        四、元組不能增加元素、修改元素或刪除元素操作

        因為元組tuple屬于不可變類型,其值無法像列表那樣進行增加、修改或刪除。

        >>> t = (1, 2, 3, 4)
        >>> t[1] = 10  # 企圖修改索引1處的值
        Traceback (most recent call last):
            File "<pyshell#30>", line 1, in <module>
                t[1] = 10
        TypeError: 'tuple' object does not support item assignment

        >>> 

        從上例可以看出,企圖修改元組的值是不允許的,給出 TypeError 錯誤。

        但是如果元組中的元素是可變類型的話,我們仍可以修改這個元素的值,如下例:

        >>> t = (1, 2, ['apple', 'orange', 'banana'], 3)
        >>> t
        (1, 2, ['apple', 'orange', 'banana'], 3)
        >>> t[2][1] = 'berry'
        >>> t
        (1, 2, ['apple', 'berry', 'banana'], 3)
        >>> t[2].remove('banana')
        >>> t
        (1, 2, ['apple', 'berry'], 3)
        >>> 

        五、刪除元組的定義

        使用 del 命令可以刪除元組的定義。

        >>> t = (1, 2, 3)
        >>> print(t)
        (1, 2, 3)
        >>> del t
        >>> print(t)
        Traceback (most recent call last):
            File "pyshell#40", line 1, in <module>
                t
        NameError: name 't' is not defined

        >>> 

        從上例可以看出,使用 del 命令刪除元組 t 的定義后,企圖再次使用時,將會產生 NameError 錯誤,即名稱 't' 未定義。

        六、元組中的運算符

        1、元組的連接

        使用 + 運算符可以把 2 個或多個元組連接成一個新的元組。

        >>> t1 = (1, 2, 3)
        >>> t2 = (4, 5, 6, 7)
        >>> t = t1 + t2
        >>> print(t)
        (1, 2, 3, 4, 5, 6, 7)
        >>>

        2、元組的重復運算

        使用 * 可以把元組重復若干次后生成一個新的元組。

        >>> t = (1, 2, 'apple', 3)
        >>> t1 = t * 3
        >>> print(t1)
        (1, 2, 'apple', 3, 1, 2, 'apple', 3, 1, 2, 'apple', 3)
        >>> 

        3、成員檢測運算

        使用 "in" 運算符可以檢測一個元組中是否包含某個元素值,也可以使用 "not in" 運算符檢測某個元素值是否不在一個元組中。

        >>> t = ('python', 'C#', 'HTML', 'CSS', 'Java', 'R')
        >>> print('python' in t)
        True
        >>> print('HTML' not in t)
        False
        >>> print('PHP' in t)
        False
        >>> 

        七、迭代輸出元組中的值

        我們可以使用for循環迭代輸出元組中的每個值。

        langs = ("Python", "R", "PHP", "Java")
        for e in langs:
            print(e)

        for v in reversed(langs):
            print(v

        第1個for循環正常順序輸出每個元組中的值,第2個for循環使用了reversed函數,把元組反轉后輸出。

        輸出結果:

        Python
        R
        PHP
        Java
        Java
        PHP
        R
        Python

        八、可以運用元組中的一些函數

        1、len()函數

        len()函數可以獲取元組的長度,即元組中值的個數。

        >>> t1 = (1, 2, "python")
        >>> print(len(t1))
        3
        >>> t2 = (1, 2, ["python", "R", "C#"], 'apple')
        >>> print(len(t2))
        4
        >>>
         

        2、count()函數

        count()函數可以統計元組中某元素的個數。

        >>> t = ("A", "B", "A", "C", "D", "A")
        >>> icnt = t.count("A")
        >>> print(icnt)
        3
        >>> 

        3、index()函數

        index()函數返回元組中某個范圍內某元素第一次出現的位置索引。

        index()函數的語法格式如下:

        tup_name.index( x, start, end)

        >>> t = (1, 2, 3, 1, 3, 4, 5)
        >>> t.index(3)
        2
        >>> t.index(3, 3)
        4
        >>> t.index(3, 3, 5)
        4
        >>> t.index(3, -3)
        4
        >>> 

        九、使用tuple()函數把其他序列值轉換為元組

        我們可以只用tuple()函數來創建一個元組。可以把列表,字符串等作為其參數來創建元組。

        >>> lst1 = [1, 2, 3] # 列表
        >>> t1 = tuple(lst1) # 使用列表來創建元組
        >>> print(t1)
        (1, 2, 3)
        >>> s = "Python" # 字符串
        >>> t2 = tuple(s) # 使用字符串來創建元組
        >>> print(t2)
        ('P', 'y', 't', 'h', 'o', 'n')
        >>> r = range(1, 5) # 生成范圍值
        >>> t3 = tuple(r) # 使用范圍值來創建元組
        >>> print(t3)
        (1, 2, 3, 4, 5)
        >>>

        Python tuple類型詳解

         以上是關于tuple類型的全部內容,如有什么疑問請留言評論。


        如需轉載,請注明出處并給出本文鏈接地址:翔宇亭IT樂園(http://www.sunyaoshi.com)

        本文鏈接地址:http://www.sunyaoshi.com/article/python/2020/6477.html

        知識評論評論內容只代表網友觀點,與本站立場無關!

           評論摘要(共 0 條,得分 0 分,平均 0 分) 查看完整評論
        愿您的精彩評論引起共鳴,帶來思考和價值。
        用戶名: 查看更多評論
        分 值:100分 90分 80分 70分 60分 40分 20分
        內 容:
        驗證碼:
        關于本站 | 網站幫助 | 廣告合作 | 網站聲明 | 友情連接 | 網站地圖
        本站部分內容來自互聯網,如有侵權,請來信告之,謝謝!
        Copyright © 2007-2020 biye5u.com. All Rights Reserved.
        特黄特色三级在线观看 - 视频 - 在线观看 - 影视资讯 -心晴网