13、元组

一、概要

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

二、定义元组

2.1、通过()来定义

  1. 说明
    元组使用 () 定义,用于存储一串信息,使用逗号隔开的多个值就组成了tuple索引从0开始。(索引就是数据在元组中的位置编号)
  2. 语法格式
    tuple = (元素,元素,元素,...)
    
  3. 结构图


    image
  4. 示例代码
    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. 常见的错误代码
    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. 语法格式
    t = tuple(seq=())
    
  2. 说明
    将一个序列对象(可迭代对象)的项转换为元组
  3. 参数
    要转换为元组的序,默认是空元组
  4. 示例代码
    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')
    
    #传入非迭代器会报错
    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. 语法格式
    tuple[index]
    
  2. 说明
    index:表示列表中元素的下标(或者理解为位置,从0开始。到长度-1。不能越界)
  3. 示例代码
    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. 语法格式
    for 变量 in 元组:
       # todo
    
  2. 说明
    跟列表的操作是一样的
  3. 示例代码
    its = ("Python",'Java',"Android",'IOS')
    for item in its:
        print(item)
    #输出结果    
    Python
    Java
    Android
    IOS    
    

3.3、通过while循环

  1. 语法格式
    tup = (元素1,元素2,元素3)
    index = 0
    while index < len(tup):
       tup[index]
       index += 1
    
  2. 说明
    跟列表的操作是一样的
  3. 示例代码
    its = ("Python",'Java',"Android",'IOS')
    index = 0
    while index < len(its):
       print(its[index])
       index += 1
    

四、元组的更新(了解)

4.1、添加元组元素

  1. 语法格式
    tup1 = ('元素1','元素2','元素3',...,'元素n')
    tup1 += tup2
    
  2. 说明
    不能操作添加单个元素,通过+号连接元组对象
  3. 示例代码
    # 示例代码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. 语法格式
    tup = ('元素1','元素2','元素3',...,'元素n')
    tup = obj1, obj2
    #等同于
    #tup1 = (obj1,obj2)
    #tup += tup1
    
  2. 说明
    不能操作添加单个元素,但是可以通过逗号 , 号连接其它类型的数据,并且其它类型的数据自动转化成元组添加到末尾
    注意:返回的是一个新的元组
  3. 示例代码
    #示例代码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. 语法格式
    del tup
    
  3. 举个栗子
    # 删除整个元组对象
    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(元素) 计数
最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
平台声明:文章内容(如有图片或视频亦包括在内)由作者上传并发布,文章内容仅代表作者本人观点,简书系信息发布平台,仅提供信息存储服务。

推荐阅读更多精彩内容