Python--元组的操作

1，元组的定义和初始化

t = tuple()

t = ()

t = (1,2,3)

t = tuple(range(3)) #通过迭代的方式产生一个元组

2，元组的操作

元组不可变，所以元组没有增加，删除，修改的操作

元组的查询，可以通过下标（索引）查询

>>> t = (1,2,3,4,5)
>>> t[0]
1
>>> t[3]
4

元组的index 方法和列表一致，t.index(value) 通过元素的值查看元素的索引位置

>>> t = (1,2,3,4,5)

>>> t.index(2)
1
>>> t.index(5)
4

元组的另一个方法是count(),count方法和列表的表现一致，t.count(value) 会打印出元素为value的个数

>>> t = (1,1,1,2,3,3,4,5,5,5,5,3)
>>> t.count(1)
3
>>> t.count(3)
3

3，元组的运算

元组之间可以使用+或*  对元组进行运算，可以进行组合和复制，运算后生成了新的元组

创建了一个新元组t3

>>> t1 = (1,2,3)
>>> t2 = (4,5,6)
>>> t3 = t1 + t2
>>> t3
(1, 2, 3, 4, 5, 6)

>>> t1
(1, 2, 3)
>>> t1*2
(1, 2, 3, 1, 2, 3)

4，元组中的元素是不允许删除的，但是可以使用del语句删除元组

del 函数可以对tuple进行删除

>>> t1
(1, 2, 3)
>>> del t1
>>> t1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 't1' is not defined

5,元组的截取

因为元组也是个序列，所以可以通过索引进行截取和访问

>>> t
(1, 1, 1, 2, 3, 3, 4, 5, 5, 5, 5, 3)
>>> t[1:6]
(1, 1, 2, 3, 3)

>>> t[0:100]
(1, 1, 1, 2, 3, 3, 4, 5, 5, 5, 5, 3)

6，Python元组包含了以下内置函数

1、cmp(tuple1, tuple2)：比较两个元组元素。
2、len(tuple)：计算元组元素个数。
3、max(tuple)：返回元组中元素最大值。
4、min(tuple)：返回元组中元素最小值。

5、tuple(seq)：将列表转换为元组。

7.命名元组

我们知道c/c++语言中，有结构体这种数据类型：

struct{
        string name;
        int age;
        char sex;
   }student;
 
 
1
2
3
4
5
 
 
1
2
3
4
5

在对结构体对象进行赋值或者取值时可以使用.运算符进行操作。
那么问题来，python中有没有这个数据类型呢？答案是肯定有的，它就是命名元组（namedtyple）。

首先来看一下Python中普通元组的不方便之处:

Bob=("bob",30,'male')
#如果想知道Bobde 名字，则需要使用索引位置进行读取，如下
name=Bob[0]
for people in [Bob]:
    print("%s is %d years old %s" % peole)
#显示结果
bob is 30 years old male

 
 
1
2
3
4
5
6
7
8
 
 
1
2
3
4
5
6
7
8

namedtuple基础

通过上面的例子，访问元组数据的时候是通过索引下标来操作的，对此需要熟记每个下标对应的具体含义，如果元组有成千上百个数据，那么想记住每个下标对应的意义那是相当困难的，于是就出现了命名元组namedtuple。

namedtuple对象的定义如以下格式：

collections.namedtuple(typename, field_names, verbose=False, rename=False) 

返回一个命名元组子类typename，其中参数的意义如下： 
typename,：此元组的名称； 
field_names: 元组中元素的名称（类似于c结构体中的age等），此字段有多种表达方式，见例子； 
rename:如果元素名称中含有python的关键字，则必须设置为rename=True,具体见下面； 
verbose:默认就好；

举个小例子，加深一下自己的理解：

import collections
#其中field_names 有多种表达方式，如下
student=collections.namedtuple('student','name age sex')
student=cpllections.namedtuple('student',['name','age','sex'])
student=cpllections.namedtuple('student','name,age,sex')

spark=student(name='sunYang',age=20,sex='male')
print(spark)
print("spark's name is %s" % spark.name)
print("%s is %d years old %s" % spark)

显示结果如下：
student(name='sunYang', age=20, sex='male')
spark's name is sunYang
sunYang is 20 years old male
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

通过上面的例子 其中student是元组名称，‘name age sex’是元组总元素名称，用空格隔开，我们访问元组对象中的元素时可以使用逗号操作符（.）读取对象中某个感兴趣的元素，而不必像元组中，需要记录下标代表的元素含义。

下面了解一下rename参数的作用：

    import collections
    with_class=collections.namedtuple('Person','name age class gender',rename=True)
    print with_class._fields
    two_ages=collections.namedtuple('Person','name age gender age',rename=True)

    print two_ages._fields其输出结果为：
    ('name', 'age', '_2', 'gender')
    ('name', 'age', 'gender', '_3')
 
 
1
2
3
4
5
6
7
8
 
 
1
2
3
4
5
6
7
8

我们使用rename=True的方式打开重命名选项。 
可以看到第一个集合中的class被重命名为 ‘2′ ； 第二个集合中重复的age被重命名为 ‘_3′；这是因为namedtuple在重命名的时候使用了下划线 加元素所在索引数的方式进行重命名。

8，一个"可变"的tuple

>>> t = ('a','b',['A','B'])
>>> t[2][0]='X'
>>> t[2][1]='Y'
>>> t
('a', 'b', ['X', 'Y'])

为什么这里的tuple发生了改变了呢，不是说tuple不可改变的吗？

这个tuple定义的时候有3个元素，分别是'a'，'b'和一个list，当我们把list的元素'A'和'B'修改为'X'和'Y'后，表面上看，tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向'a'，就不能改成指向'b'，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！
理解了“指向不变”后，要创建一个内容也不变的tuple怎么做？那就必须保证tuple的每一个元素本身也不能变。

7，一个"可变"的tuple