Python中tuple的功能介绍

                                            Tuple的功能介绍

1. 元祖的两种方法

1. 元祖的内置方法

1. 两个元祖的相加

   格式：x.__add__(y)等同于x+y
   例如：tu1 = (1,2,3,)
        print(tu1.__add__((2,3,4,)))
    >>> (1, 2, 3, 2, 3, 4)
   返回值：tuple
   #只能是两个元祖相加，生成一个新元祖
   

2. 判断是否是包含关系

   格式：x.__contains__(y)等同于y in x
   例如：tu1 = (1,2,3,)
        print(tu1.__contains__(3))
    >>> True
   返回值：bool
   #上述的y可以是任意对象object
   

3. 判断两个元祖是否相等

   格式：x.__eq__(y)等同于x==y
   例如：tu1 = (1,2,3,)
        print(tu1.__eq__((2,3,)))
    >>> False
   返回值：bool
   #上述的y只能是元祖
   

4. 大于等于

   格式：x.__ge__(y)等同于x>=y
   例如：tu1 = (1,2,3,)
        print(tu1.__ge__((2,3,)))
    >>> False
   返回值：bool
   #上述的y只能是元祖
   

   注：两个元祖判断大小主要依据为元祖的第一个元素的大小。

5. 访问属性

   格式：x.__getattribute__(self,name)
   返回值：tuple
   

6. 取出指定索引的值

   格式：x.__getitem__(index)等同于tuple[index]
   例如：tu1 = (1,2,3,)
        print(tu1.__getitem___(2))
    >>> 3
   返回值：object
   

7. 元祖元素化

   格式：x.__getnewargs__()
   例如：tu1 = (1,2,3,)
        print(tu1.__getnewargs__())
    >>> ((1,2,3,),)
   返回值：tuple
   #把原元祖作为一个新元祖的一个元素
   

8. 大于

   格式：x.__gt__(y)等同于x>y
   例如：tu1 = (1,2,3,)
        print(tu1.__gt__((2,3,)))
    >>> False
   返回值：bool
   #上述的y只能是元祖
   

   注：两个元祖判断大小主要依据为元祖的第一个元素的大小。

9. 哈希化

   格式：x.__hash__()等同于hash(x)
   例如：tu1 = (1,2,3,)
        print(tu1.__hash__())
    >>> 2528502973977326415
   返回值：int
   

10. 迭代器

    格式：x.__iter__()等同于iter(x)
    例如：tu1 = (1,2,3,)
         die = tu1.__iter__()
         print(die.__next__())
     >>> 1
    返回值：迭代器
    

11. 小于等于

    格式：x.__le__(y)等同于x<=y
    例如：tu1 = (1,2,3,)
         print(tu1.__le__((2,3,)))
     >>> True
    返回值：bool
    #上述的y只能是元祖
    

    注：两个元祖判断大小主要依据为元祖的第一个元素的大小。

12. 长度

    格式：x.__len__()等同于len(x)
    例如：tu1 = (1,2,3,)
         print(tu1.__len__())
     >>> 3
    返回值：int
    

13. 小于

    格式：x.__lt__(y)等同于x<y
    例如：tu1 = (1,2,3,)
         print(tu1.__lt__((2,3,)))
     >>> True
    返回值：bool
    #上述的y只能是元祖
    

    注：两个元祖判断大小主要依据为元祖的第一个元素的大小。

14. 相乘（复制）

    格式：x.__mul__(num)等同于x*num
    例如：tu1 = (1,2,3,)
         print(tu1.__mul__(2))
     >>> (1,2,3,1,2,3)
    返回值：tuple
    

15. 不等于

    格式：x.__ne__(y)等同于x!=y
    例如：tu1 = (1,2,3,)
         print(tu1.__ne__((2,3,)))
     >>> True
    返回值：bool
    #上述的y只能是元祖
    

16. 创建新元祖

    格式：x.__new__(tuple)
    例如：tu1 = (1,2,3,)
         print(tu1.__new__(tuple))
     >>> ()
    返回值：tuple
    

17. 内置转换方法

    格式：x.__repr__(self)
    返回值：tuple
    

18. 右→左 相乘（复制）

    格式：x.__rmul__(num)等同于num*x
    例如：tu1 = (1,2,3,)
         print(tu1.__rmul__(2))
     >>> (1,2,3,1,2,3)
    返回值：tuple
    

19. 元祖在内存中的大小，转换为字节进行计算

    格式：x.__sizeof__()
    例如：tu1 = (2,3,)
         tu2 = (4,5,6,)
         print(tu1.__sizeof__())
     >>> 40
         print(tu2.__sizeof__())
     >>> 48
    返回值：int
    #元祖的长度不同，导致元祖在内存中大小也不一样。
    

2. 常用方法

1. 计数

   格式：x.count(value)
   例如：tu1 = (1,2,3,1,2,3,)
        print(tu1.count(2))
    >>> 2
   返回值：int
   

2. 索引

   格式：x.index(value,start,end)
   例如：tu1 = (1,2,3,1,2,3,)
        print(tu1.index(2,1,4))
    >>> 1
   返回值：int
   #不指定范围时，默认全元祖搜索
   

2. 元祖操作

1. 元祖的基础操作

1. 加法

   符号： +
   格式：tuple1 + tuple2
   例如：tu1 = (1,2,3,)
        tu2 = ('a','b',)
        print(tu1+tu2)
    >>> (1,2,3,'a','b')
   返回值：tuple
   

2. 乘法（复制）

   符号： *
   格式：tuple1 * num
   返回值：tuple
   

3. 索引

   符号： [index]
   格式：tuple[index]
   返回值：object
   

4. 切片

   符号： [:：]
   格式：tuple[index1:index2:num]
   返回值：tuple
   

5. 成员检测

   符号： in
   格式： object in tuple
   返回值：bool
   

2. 元祖的序列操作

1. 长度

   格式：len(tuple)
   返回值：int
   

2. 最大值

   格式：max(tuple)
   返回值：int
   

   注：该函数只能用于纯数字的元祖。

3. 最小值

   格式：min(tuple)
   返回值：int
   

   注：该函数只能用于纯数字的元祖。

4. 转换为元祖

   格式：tuple(序列)
   返回值：tuple     
   

3. 元祖的遍历

1. 使用for...in 遍历元祖

   格式：for variable in tuple:
            使用variable
   例如：tu1 = (1,2,3,)
        for i in tu1:
            print(i)
    >>> 1
    >>> 2
    >>> 3
   

2. 使用while循环遍历元祖

   格式：variable = 0
        while variable <len(tuple):
            使用元祖的元素（tuple[variable]）
            variable += 1
   例如：tu1 = (1,2,3,)
        i = 0
        while i < len(tu1):
            print(tu1[i])
            i += 1
     >>> 1
     >>> 2
     >>> 3
   

3. 二级元祖的遍历

   1. 格式：for variable1 in tuple:
               for variable2 in variable1:
                   使用variable
      例如：tu1 = ((1,2,3,),(4,5,6,),(7,8,9,),) 
           for i in tu1:
               for j in i:
                   print(j)
      #输出的结果j就是元祖中小元祖中的元素
   2. 格式：for varialbe1,variable2,... in tuple:
               直接使用variable1，variable2,...
      例如：tu1 = ((1,2,3,),(4,5,6,),(7,8,9,),) 
           for n1,n2,n3 in tu1:
               print(n1)
       >>> 1
       >>> 4
       >>> 7
   

   注：方法2只能遍历同等长度的二级元祖，由于元祖和列表可以相互转换，因此上述遍历的元祖中可以混合列表使用。

4. 元祖的推导式

1. 简单的元祖推导式

   格式：(variable for variable in tuple)
   例如：tu1 = (1,2,3,4,5,)
        ret = (i for i in tu1)
        print(ret.__next__())
    >>> 1
   返回值：生成器
   #把原元祖遍历完后生成一个生成器
   

2. 稍作修改的元祖推导式

   格式：(variable * 8 for variable in tuple)
   例如：tu1 = (1,2,3,4,5,)
        ret = (i*8 for i in tu1)
        print(ret.__next__())
    >>> 8
    #对变量进行修改，可以是int和str类型，具体需根据元祖元素的类型来选择不同的类型。
   

3. 带判断条件的元祖推导式

   格式：(variable for variable in tuple if 条件表达式)
   例如：tu1 = ('a','b','c','d','e',)
        ret = (i*2 for i in tu1 if tu1.index(i) < 3)
        print(ret.__next__())
    >>> 'aa'
   返回值：生成器 
   

4. 多个元祖推导式

   格式：(varialbe1*variable2 for variable1 in tuple1 for variable2 in tuple2)
   例如：tu1 = (2,1,3,)
        tu2 = ('a','b','c','d')
        ret = (i*j for i in tu1 for j in tu2)
        print(ret.__next__())
    >>> 'aa'
   返回值：生成器
   

5. 带判断条件的多个元祖推导式

   格式：(variable1*variable2 for variable1 in tuple1 for variable2 in tuple2 if 条件表达式)
   例如：tu1 = (3,1,2)
        tu2 = ('a','b','c','d')
        ret = (i*j for i in tu1 for j in tu2 if tu1.index(i)==tu2.index(j))
        print(ret.__next__())
    >>> 'aaa'
   返回值：生成器
   

   注：由于元祖和列表可以相互转换，因此上述推导式的元祖中的元祖可以混合列表使用，与列表推导式不同的就是返回值。列表推导式返回值为列表，元祖推导式返回值为生成器。