[PY3]——内置数据结构(2)——元组及其常用操作

定义和初始化

#tuple()          使用工厂函数tuple定义一个空元组

#()               使用圆括号定义一个空元组

#(1,2,3)          使用圆括号定义有初始值的元组

#tuple(可迭代对象)  把可迭代对象转换为一个元组

In [1]: tup=tuple();print(tup)
()

In [2]: tup=();print(tup)
()

In [3]: tup=(1,2,3);print(tup)
(1, 2, 3)

In [5]: tup=tuple(range(0,2));print(tup)
(0, 1)

#要定义一个只有1个元素的tuple，如果这么定义：
In [30]: tup=(1)
In [31]: type(tup)
Out[31]: int  
#定义的不是tuple，是1这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。
#所以只有1个元素的tuple定义时必须加一个逗号,，来消除歧义
In [32]: tup=(1,)
In [33]: type(tup)
Out[33]: tuple
In [34]: print(tup)
(1,)
# Python在显示只有1个元素的tuple时，也会加一个逗号,，以免误解成数学计算意义上的括号

元组是不可修改的

访问元组元素

1. 通过索引访问元素

In [7]: t=tuple(range(0,7));print(t)
(0, 1, 2, 3, 4, 5, 6)

In [8]: t[1]
Out[8]: 1

In [9]: t[-1]
Out[9]: 6

2. index()

In [21]: help(t.index)
index(...) method of builtins.tuple instance
    T.index(value, [start, [stop]]) -> integer -- return first index of value.
    Raises ValueError if the value is not present.

In [16]: print(t)
(1, 2, 3, 2, 6)

In [17]: t.index(2)
Out[17]: 1

In [20]: t.index(2,1,3)
Out[20]: 1

3. count()

In [21]: help(t.count)
count(...) method of builtins.tuple instance
    T.count(value) -> integer -- return number of occurrences of value

In [22]: t.count(2)
Out[22]: 2

命名元组 nametuple

# namedtuple('名称', [属性list]):
# namedtuple是一个函数，它用来创建一个自定义的tuple对象，并且规定了tuple元素的个数，并可以用属性而不是索引来引用tuple的某个元素。
# 这样一来，我们用namedtuple可以很方便地定义一种数据类型，它具备tuple的不变性，又可以根据属性来引用，使用十分方便。

# 例如我们可以使用namedtuple来表示坐标：
In [35]: from collections import namedtuple

In [36]: Circle=namedtuple('Circle',['x','y','z'])

In [37]: C=Circle(2,2,3)

In [38]: print(C.x);print(C.z)
2
3

# 创建的Circle对象是tuple的一种子类
In [39]: isinstance(C,Circle)
Out[39]: True

In [40]: isinstance(C,tuple)
Out[40]: True

# 所以C完全可以当做元组去使用
In [46]: C.index(2)
Out[46]: 0

In [47]: print(C[1])
2

In [48]: C.count(2)
Out[48]: 2

#列表和元组的异同？
#<相同点>
   列表和元组都是容器，可以包含任意类型的元素(甚至是包含一个序列)
   列表和元素也都包含元素的顺序
#<差别>
    列表是可变的，元组是不可变的
    所以通常，在你有一些不确定长度的相同类型队列时使用列表
    在已知元素数量的情况下用元组