python数据类型-元组

总结：Python3.6版本

• 创建元组：tuple()【空元组】
• 创建元组：tuple(iterable)【新元组-由可迭代对象的成员初始化】
• 元组分类：单层、嵌套
• 元组长度：len(tuple)
• 元组索引：tuple[i]【i从0开始】
• 成员测试：x in tuple【返回布尔值】、for x in tuple:print(x)【遍历】
• 元组比较：【运算符重载，>、=、<=、==、!=】
• 元组拼接：tuple1 + tuple2
• 元组重复：tuple1 + tuple2 、tuple1 * N(N>=1)
• 元组切片：tuple[a:b] 【正向从0开始，反向从-1开始，a、b均可以忽略，不包含后标】
• 元组切片：tuple[a:b:c] 【a、b为区间，c为切片间隔，a、b均可以忽略，不包含后标】
• 元组查找：tuple.index(value, start=None, stop=None)【返回查询值首次出现的索引位置】
• 元组计数：tuple.count(value)【返回给定数据出现的次数】

<code># 空元组【手动创建、类实例化】
# 【运算符重载方法__init__解释-->tuple()调用】
print(())  # ()
print(tuple())  # ()

# 创建元组【手动创建、类实例化】
# 【运算符重载方法__init__解释-->tuple()调用】
print((1, 2, 3))  # (1, 2, 3)
print(tuple([1, 2, 3]))  # (1, 2, 3)
print(tuple('123'))  # ('1', '2', '3')
print(tuple(x for x in "123"))  # ('1', '2', '3')

# 无嵌套的列表
print((1, '2', 3))  # (1, '2', 3)

# 嵌套的列表
print(("123", 456, ["12", 34]))  # ('123', 456, ['12', 34])

# 元组长度【返回长度，运算符重载方法，长度运算，相当于调用了__len__方法】
print(len((1, 2, 3)))  # 3
print((1, 2, 3).__len__())  # 3

# 元组索引【正向0标开始，反向-1标开始】
# 【返回索引值，运算符重载方法，索引运算，相当于调用了__getitem__方法】
for x in range(3):
    print((1, 2, 3)[x], end=" ")  # 1 2 3
print("", (1, 2, 3)[-1])  # 3
print((1, 2, 3).__getitem__(-1))  # 3

# 成员测试【返回布尔值，运算符重载方法，成员关系测试in，相当于调用了__contains__方法】
print(3 in (1, 2, 3))  # True
for x in (1, 2, 3): 

    print(x, end=" ")  # 1 2 3
print((1, 2, 3).__contains__(3))  # True

# 元组比较【返回布尔值，运算符重载方法，特定的比较，调用方式(,<=,>=,==,!=)】
print((1, 2, 3) == (1, 2, 3))  # True
print((1, 2, 3).__eq__((1, 2, 3)))  # True

print((1, 2, 3) != (1, 2, 3))  # False
print((1, 2, 3).__ne__((1, 2, 3)))  # False

print((1, 2, 3) > (1, 2, 3))  # False
print((1, 2, 3).__gt__((1, 2, 3)))  # False

print((1, 2, 3) < (1, 2, 3))  # False
print((1, 2, 3).__lt__((1, 2, 3)))  # False

print((1, 2, 3) >= (1, 2, 3))  # True
print((1, 2, 3).__ge__((1, 2, 3)))  # True

print((1, 2, 3) <= (1, 2, 3))  # True
print((1, 2, 3).__le__((1, 2, 3)))  # True

# 元组拼接【运算符重载方法 运算符a+b、a+=b】
# 【__add__-->a+b，生成的是一个新对象】
# 【a+=b，等价于a=a+b，a引用了新对象，但不是重载__iadd__，没有这个方法】
a = (1, 2)
b = (3,)
c = a + b
print(c, a)  # [1, 2, 3] [1, 2]
print(a.__add__(b), a)  # [1, 2, 3] [1, 2]

a = (1, 2)
b = (3,)
print(id(a))  # 56097848
a += b
print(a, id(a))  # (1, 2, 3) 56097888

# 元组重复【运算符重载方法 运算符a*b、a*=b】
# 【__mul__-->a*b，生成的是一个新对象、
# 【__rmul__--a*=b，等价于a=a*b，等价于a=a.__mul__,a引用了新对象】 

a = (1,)
b = 3
c = a * b  # 等价于 c=a.__mul__(b)
print(c)  # (1, 1, 1)
print(a.__mul__(b), a)  # (1, 1, 1) (1,)

a = (1,)
b = 3
print(id(a))  # 11549776
a *= b  # 等价于【a=a*b、a=a.__mul__】
print(a, id(a))  # (1, 1, 1) 11598904

# 元组切片【正向从0标开始，反向走-1标开始】
# tuple[a:b]正向操作【等价于tuple[a:b:1]】，a、b可以为负，表示的是字符正反向的坐标
# tuple[a:b:c]【c为整数正向操作--ab】
print((1, 2, 3)[:])  # (1, 2, 3)
print((1, 2, 3)[::-1])  # (3, 2, 1)
print((1, 2, 3)[0:1])  # (1,)
print((1, 2, 3)[-2:-1])  # (2,)
print((1, 2, 3)[0:3:2])  # (1, 3)
print((1, 2, 3, 4)[3:0:-2])  # (4, 2)
print((1, 2, 3, 4)[-1:-4:-2])  # (4, 2)

# 元组查询【index函数返回查询值首次出现的位置】
My_tuple = (1, 2, 3, 4, 3)
print(My_tuple.index(3))  # 2
print(My_tuple.index(3, 0, len(My_tuple)))  # 2

# 元组计数【count函数返回给定数据出现的次数】
My_tuple = (1, 2, 3, 4, 3)
print(My_tuple.count(3))  # 2/<code>

原型类或者方法：

<code>class tuple(object):
 

    tuple() -> empty tuple
    tuple(iterable) -> tuple initialized from iterable's items
    If the argument is a tuple, the return value is the same object.
    #空参数返回空元组、参数为可迭代对象则返回由可迭代对象成员初始化的新元组

    def count(self, value):
        T.count(value) -> integer -- return number of occurrences of value
        return 0
    #计算给定值出现的次数

    def index(self, value, start=None, stop=None):
        T.index(value, [start, [stop]]) -> integer -- return first index of value.
        Raises ValueError if the value is not present.
        return 0
    #返回给定值首次出现的索引值，不存在抛出ValueError

    def __add__(self, *args, **kwargs):
        Return self+value.
        pass
    #运算符重载运算方法 + 调用

    def __contains__(self, *args, **kwargs):
        Return key in self.
        pass
    #运算符重载运算方法--成员关系测试  in 调用

    def __eq__(self, *args, **kwargs):
        Return self==value.
        pass
    #运算符重载运算方法 == 调用

    def __getattribute__(self, *args, **kwargs):
        Return getattr(self, name).
        pass
    
    def __getitem__(self, *args, **kwargs):
        Return self[key].
        pass
    #索引运算 a=(1,2,3) a[1]===a.__getitem__(1)
 

    def __getnewargs__(self, *args, **kwargs):
        pass

    def __ge__(self, *args, **kwargs):
        Return self>=value.
        pass
    #运算符重载运算方法 >= 调用

    def __gt__(self, *args, **kwargs):
        Return self>value.
        pass
    #运算符重载运算方法 > 调用

    def __hash__(self, *args, **kwargs):
        Return hash(self).
        pass

    def __init__(self, seq=()):
        tuple() -> empty tuple
        tuple(iterable) -> tuple initialized from iterable's items
        If the argument is a tuple, the return value is the same object.
        # (copied from class doc)
        pass
    #构造函数，创建实例类的时候调用，初始化一个对象

    def __iter__(self, *args, **kwargs):
        Implement iter(self).
        pass
    #返回一个迭代器

    def __len__(self, *args, **kwargs):
        Return len(self).
        pass
    #运算符重载运算方法 len() 调用

    def __le__(self, *args, **kwargs):
        Return self<=value.
        pass
    #运算符重载运算方法 <= 调用

    def __lt__(self, *args, **kwargs):
        Return self<value.>        pass
    #运算符重载运算方法 < 调用 


    def __mul__(self, *args, **kwargs):
        Return self*value.n
        pass
    #运算符重载运算方法 tuple*N 调用

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs):
        Create and return a new object.  See help(type) for accurate signature.
        pass
    
    def __ne__(self, *args, **kwargs):
        Return self!=value.
        pass
    #运算符重载运算方法 != 调用

    def __repr__(self, *args, **kwargs):
        Return repr(self).
        pass
    #更好的显示

    def __rmul__(self, *args, **kwargs):
        Return self*value.
        pass
    #运算符重载运算方法 tuple *=tuple1<==>tuple =tuple*tuple1/<value.>/<code>

閱讀更多 少年風 的文章

關鍵字: Python 镜音双子 元组