Hexo
0%

13、元组.md

Posted on In

一、简介

  1. 在 Python 中，元组是一种不可变序列，它使用圆括号来表示。
  2. 不可变的tuple有什么意义？因为tuple不可变，所以代码更安全。
  3. tuple也是 python 中一个标准的序列类型。
  4. Python 的元组与列表类似，不同之处在于元组的元素不能修改。
  5. 元组使用小括号，列表使用方括号。
  6. 元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可
  7. 如果元组的元素只有一个可以省略不写

二、定义元组

2.1、通过()来定义

  1. 说明

    元组使用 () 定义，用于存储一串信息，使用逗号隔开的多个值就组成了tuple索引从0开始。(索引就是数据在元组中的位置编号)

  2. 语法格式

    1
    tuple = (元素,元素,元素,...)

  3. 结构图

  4. 示例代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    t = ()  #空元组
    print(type(t)) # <class 'tuple'>

    t =(1,)  #单个元素元组，注意逗号必须
    print(type(t)) # <class 'tuple'>

    names =('空空','佟亚丽','赵丽颖')
    print(type(names)) # <class 'tuple'>

    t = (‘abs’,(‘def’,’ghi’)) #嵌套元组
    print(type(t)) # <class 'tuple'>

    t = 0, ’达康书记’, 1.2, 3 #四个元素的元组，混合类型,知道就行,不要这么写
    print(type(t)) # <class 'tuple'>

  5. 常见的错误代码

    1
    2
    3
    4
    5
    6
    7
    t = (1)
    print(type(t)) # <class 'int'>
    #定义的不是tuple，是1这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1
    #所以，只有1个元素的tuple定义时必须加一个逗号,，来消除歧义

    t1 =('abc')
    print(type(t1)) # <class 'str'>

2.2、通过tuple()定义

  1. 语法格式

    1
    t = tuple(seq=())

  2. 说明

    将一个序列对象(可迭代对象)的项转换为元组

  3. 参数

    要转换为元组的序,默认是空元组

  4. 示例代码

    1
    2
    3
    4
    5
    6
    7
    8
    names = ['元素1','元素2','元素3']
    t = tuple(names)
    print(type(t))  #<class 'tuple'>
    print(t) #('元素1', '元素2', '元素3')

    s='123456'
    nums = tuple(s)
    print(nums) # ('1', '2', '3', '4', '5', '6')
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    #传入非迭代器会报错
    test = tuple(1)
    """
    TypeError  Traceback (most recent call last)
    <ipython-input-21-8d74e633de98> in <module>()
    ----> 1 test = tuple(1)
    TypeError: 'int' object is not iterable
    """

    test = tuple(1.2,)
    """
    TypeError  Traceback (most recent call last)
    <ipython-input-20-e66128089188> in <module>()
    ----> 1 test = tuple(1.2,)
    TypeError: 'float' object is not iterable
    """

三、获取元素

3.1、通过索引获取

  1. 语法格式

    1
    tuple[index]

  2. 说明

    index：表示列表中元素的下标(或者理解为位置，从0开始。到长度-1。不能越界)

  3. 示例代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    tup = ('Python', 'Java', 'H5', 'C++');
    print(tup[0])
    print(tup[-1])#从右边开始取元素
    print(tup[6])#抛出异常
    """
    Traceback (most recent call last):
      File "tup.py", line 5, in <module>
        print(tup[6])
    IndexError: tuple index out of range
    """

3.2、通过for循环获取

  1. 语法格式

    1
    2
    for 变量 in 元组:
      	# todo

  2. 说明

    跟列表的操作是一样的

  3. 示例代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    its = ("Python",'Java',"Android",'IOS')
    for item in its:
        print(item)
         
    #输出结果    
    Python
    Java
    Android
    IOS

3.3、通过while循环

  1. 语法格式

    1
    2
    3
    4
    5
    tup = (元素1,元素2,元素3)
    index = 0
    while index < len(tup):
    	tup[index]
    	index += 1

  2. 说明

    跟列表的操作是一样的

  3. 示例代码

    1
    2
    3
    4
    5
    its = ("Python",'Java',"Android",'IOS')
    index = 0
    while index < len(its):
    	print(its[index])
    	index += 1

四、元组的更新(了解)

4.1、添加元组元素

  1. 语法格式

    1
    2
    tup1 = ('元素1','元素2','元素3',...,'元素n')
    tup1 += tup2

  2. 说明

    不能操作添加单个元素,通过+号连接元组对象

  3. 示例代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    # 示例代码1
    tup = (1, 'happy', ['name', 'sex'], ('小花', '女') )
    tup += (1, 1.2)
    print(tup)

    # 说明 不能添加单个元素
    # 示例代码2
    tup = (1, 'happy', ['name', 'sex'], ('小花', '女'))
    tup += '元素'
    print(tup)
    ```
    TypeError: can only concatenate tuple (not "str") to tuple
    ```

5.2、元组整体合并

  1. 语法格式

    1
    2
    3
    4
    5
    tup = ('元素1','元素2','元素3',...,'元素n')
    tup = obj1, obj2
    #等同于
    #tup1 = (obj1,obj2)
    #tup += tup1

  2. 说明

    不能操作添加单个元素,但是可以通过逗号 , 号连接其它类型的数据,并且其它类型的数据自动转化成元组添加到末尾

    **注意:**返回的是一个新的元组

  3. 示例代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    #示例代码1
    tup = (1, 'happy', ['name', 'sex'], ('小花', '女'))
    tup2 = "GG", [1,'元素'], 'str'
    # 生成新的元组
    tup += tup2
    print(tup)
    # 相当于
    # tup2 = ("GG", [1,'元素'], 'str')
    #示例代码2 合并成一个新的元组
    tup += [1,False,True]

五、删除元组(了解)

  1. 说明

    由于元组是不可变的,所以不能单独删除某个元素,只能整体删除对象

  2. 语法格式

    1
    del tup

  3. 举个栗子

    1
    2
    3
    4
    5
    6
    # 删除整个元组对象
    tup = tuple((1, 2, 3, 3, '快扶我起来我还能送', ['name', 'sex'], ('小明', '男')))
    del tup

    # 不能是删除单个元素
    del tup[1]

六、常见元组常量和运算总结

运算 解释
() 空元组
tup = (0,) 单个元素的元组（非表达式）
tup = (0,’str’,1.2,3) 四个元素的元组，混合类型
tup = 0,’str’,1.2,3 四个元素元组，与前列相同
tup = (‘a’,(‘b’,’c’)) 嵌套元组
tup = tuple(‘hello’) 一个可迭代对象的项转换为元组
tup[i], tup[i], tup[start:end],len(tup) 索引，索引的索引，分片，长度
tup+tup2, tup2 * 3 合并，重复(元素项重复)
for x in tup : print(x) 迭代
‘元素’ in tup 成员关系
[i ** 2 for i in tup] 列表解析
tup.index(‘元素’) 搜索
tup.count(元素) 计数