说完了可变序列list，今天我们来说下不可变序列tuple，它有一下特性：
(1)可以包含任意对象的有序集合(集合后面会单独说)
(2)可以通过下标索引来访问元素
(3)固定长度，异质，可任意嵌套
(4)对象引用数组
(5)不支持原位改变
声明一个空的元素：x=(),使用大括号来表示元组，使用方括号来表示列表(后面会介绍使用花括号来表示字典)
先前列表的通用方法基本都适合元组。
1：in/not in
2：A*2------>重复序列或元组的内容，A代表序列
3：A1+A2------>连接两个序列
4：A[x]------>A代表序列或元组，x代表列表或元组下标
5：A[x:y]------>访问指定索引范围，A代表列表或元组，x和y代表下标，含头不含尾
6：len(A)------>获取序列或元组的长度，A代表序列或元组
7：A[x:y:z]------>按步长访问指定索引范围，z代表步长
8:min(A)/max(A)------>获取序列或元组的最大元素和最小元素，A代表序列或元组
9:sum(A)------>统计序列或元组总和
10：A.index(a)------>获取序列或元组某个元素第一次出现的下标位置，A代表序列或元组，a代表A里面某个元素
11：A.count(a)------>查看序列或元组中某个元素出现的次数，A代表序列或元组，a代表某个元素
因为元组有这个不支持原位改变的特性，所以不支持del，remove，append，extend的操作
但是元组还有一个方法：

>>> a=[1,2,3]
>>> b=tuple(a)
>>> b
(1, 2, 3)
>>> type(a)
<class 'list'>
>>> type(b)
<class 'tuple'>
>>> a
[1, 2, 3]

>>> c=list(b)
>>> c
[1, 2, 3]
>>> b
(1, 2, 3)
从上面可以得知：序列a可以转换成元组，同时a还是list型，b就是tuple型了，

                             元组b可以转换成序列，b是tuple型，c就是list型了。

	

列表(List)
列表、元组和字符串 因为成员有序，可以通过下标访问，又称为序列。列表有序，长度内容可变，使用中括号[]表示，元素间用逗号分隔，元素的数据类型可以不一样！列表的相关操作有：元素访问、切片、修改、追加、插入、删除、扩展、统计、排序、下标获取、拷贝。
// 列表创建 //
直接把元素放在中括号[]中，逗号分隔，示例如下：
data_list = [1,2,0,"a",True]
// 访问列表元素 //
列表是有序的，可以通过下标索引来访问列表中的元素，可以从左开始索引，也可以从右开始索引。从左开始索引的下标范围：[0, 列表长度-1]，从右开始索引的下标范围：[-1, 列表长度]，如果索引下标不在范围里的话，会报数组越界错误！代码示例如下：
num_list = [1,2,3,4,5]
print(num_list[0])
print(num_list[-3])
print(num_list[5])# 运行结果如下13
IndexError: list index out of range
// 列表切片 //
通过索引的方式只能获取一个元素，如果想获取多个元素呢？只能通过多个下标先获取多个元素再另外拼接一个列表么？当然不用，Python为我们提供了强大的切片操作。通过「:(冒号)」分割前后索引来实现，要注意索引的边界是顾头不顾尾，比如a[1:3]，包含的是a[1]，a[2]，不包含a[3]！详细用法示例如下：
num_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]# 截取[0,2)间的数据，输出结果：[0, 1]
print(num_list[0:2])# 截取[1,9]，输出结果：[1, 2, 3, 4, 5, 6, 7, 8, 9]
print(num_list[1:])# 截取[0,7]，输出结果：[0, 1, 2, 3, 4, 5, 6, 7]
print(num_list[:-2])# 截取所有元素，输出结果：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(num_list[:])# 截取[0,10)的元素，步长为2，输出结果：[0, 2, 4, 6, 8]
print(num_list[0:10:2])# 截取[2,10)的元素，步长为3，输出结果：[2, 5, 8]
print(num_list[2::3])
// 更新、追加、插入列表元素 //
更新列表元素直接通过下标索引获得对应元素进行修改即可，比如上面的num_list，修改第二个元素的值只需：num_list[1] = 'xxx'。另外，如果你不知道修改的元素下标索引是哪一个，但是你知道元素的值，可以先通过index("元素的值")找到对应的下标索引值，再去修改元素的值。追加列表元素可以通过append函数在列表的表位追加一个元素，比如num_list调用append(10)后，追加后列表里的元素就变成了 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10]。append函数只是在队尾插入一个元素，如果想插入到特定位置则需要使用insert函数了。参数有两个，插入的下标位置(从0开始) 和 插入元素值。比如num_list调用insert(3, 2.5)后的列表：[0, 1, 2, 2.5, 3, 4, 5, 6, 7, 8, 9, 10]
// 删除列表元素 //
要区分是 删除整个列表 还是 删除列表中某个元素，代码示例如下：
num_list = [0, 1, 2, 3, 4, 5]# remove()直接对列表中的元素进行检索删除，根据值不是下标，返回删除后的列表
num_list.remove(2)
print(num_list)# del()根据下标进行检索删除，不返回删除值del num_list[2]
print(num_list)# pop()根据下标进行检索删除，不填下标默认删除最后一项，返回删除值
num_list.pop()
print(num_list)# 删除列表引用del num_list
print(num_list)# 运行结果如下
[0, 1, 3, 4, 5]
[0, 1, 4, 5]
[0, 1, 4]
NameError: name 'num_list' is not defined
// 列表遍历 //
可以通过循环对列表进行遍历，遍历的方式有多种，代码示例如下：
num_list = [0, 1, 2, 3, 4, 5]for num in num_list:
    print(num, end='\t')for index in range(0, len(num_list)):
    print(num_list[index], end='\t')for index, value in enumerate(num_list):
    print('index = %d values = %d' % (index, value))# 输出结果如下：0    1    2    3    4    5    0    1    2    3    4    5    
index = 0 values = 0
index = 1 values = 1
index = 2 values = 2
index = 3 values = 3
index = 4 values = 4
index = 5 values = 5
// 列表的其他操作 //
除了上面的这些常用操作外，还有一些其他的操作，使用代码示例如下：
a_list = [1, 2.0, 'a', True]
b_list = [3, 2, 9, 4, 11]# 列表脚本操作符：可以使用+号组合列表，*号重复列表
print(a_list + a_list)
print(a_list * 2)# 判断元素是否在列表中
print('a' in a_list)# 获得列表长度
print('列表长度：%d' % len(a_list))# 统计元素在列表中出现的次数,True的值也是1
print('列表中1出现的次数 %d' % a_list.count(1))# 统计最大值，最小值，列表元素类型需要为数字
print('列表中的最大值 %d' % max(b_list))
print('列表中的最小值 %d' % min(b_list))# 排序，本地排序(会修改值)，返回None，只能比较数字！默认从小到大，# 从大到小可以用可选参数，括号里加上key = lambda x:-1*x
b_list.sort()
print('升序排列：%s' % b_list)
b_list.sort(key=lambda x: -1 * x)
print('降序排列：%s' % b_list)# 列表元素反转，会修改列表，返回None
a_list.reverse()
print('反转后的列表：%s' % a_list)# extend()函数，在列表末尾一次性追加另一个列表中的多个值
a_list.extend(b_list)
print("追加后的列表：",a_list)# 输出结果如下：
[1, 2.0, 'a', True, 1, 2.0, 'a', True]
[1, 2.0, 'a', True, 1, 2.0, 'a', True]True
列表长度：4
列表中1出现的次数 2
列表中的最大值 11
列表中的最小值 2
升序排列：[2, 3, 4, 9, 11]
降序排列：[11, 9, 4, 3, 2]
反转后的列表：[True, 'a', 2.0, 1]
追加后的列表：[True, 'a', 2.0, 1, 11, 9, 4, 3, 2]
元组(Tuple)
元组，受限的列表，元组中的元素不能修改，使用()小括号标识。如果元组中只有一个元素，需要在元素后添加逗号，如(100,)，否则会被当做括号运算符使用！！！
比起列表，元组占用更少的内存，常用于不能修改的参数传递给函数。除了没有修改元素的函数外，其他函数与列表基本一致，还提供了一个tuple()函数，用于：将字符串和列表转换为元组。
还有一点要注意：没有小括号包裹，只用逗号分隔，Python也会把这个变量认作元组，比如：a = 1,2,3,4，如果此时调用print(type(a))，输出的结果会是：。

元组
python将不能修改的值称为不可变的，而不可变的列表被称为元组。元组也是有序的。具有可读性。可迭代对象，不可变数据类型。
创建空元组
tup1 = ();

元组中只包含一个元素时，需要在元素后面添加逗号
tup1 = (50,);
元组与字符串类似，下标索引从0开始，可以进行截取，组合。
元组可以使用下标索引来访问元组中的值。
　　　　
输出结果：
　　　　
 
#如何修改元组变量：
　　　　
#输出结果：
　　　　
 
元组内置函数（跟列表一样）：

 
 
 
 
 
转载于:https://www.cnblogs.com/zqxqx/p/8012846.html

很久之前写过一篇博客，关于使用到了元组方面的内容。参考了相关的资料，元组经过初始化后就不能再修改了。和列表声明相类似，只不过元组使用了小括号将元素组装起来。

元组的声明

使用小括号构建元素。注意：元组可以将不同的数据类型整合到一起，比如下面的第三条数据中就是将字符、数字、布尔类型的数据放到一起。 



元组的访问

可以使用下标对元组进行访问，注意下标可以访问多个元素，也可访问一个元素。还要注意下标不要越界了。



元组的操作：

元组一旦声明好后，就不能修改了，但是元组可以使用del函数将整个元组值删除掉。使用in函数来判断元组中是否包含某个特定字符。使用+符号来合并元组，使用len函数来计算长度，使用for来遍历元组。我们来看一下测试代码。



Arcpy中使用到元组的地方，在之前的博客中有使用过arcpy.da.Walk()来返回元组类型的数据。