之前总结的知识中设计的数据类型有整形、浮点、字符串等，这些类型表示的都是一个单独的独立数据对象。在Python有也有表示复数改变的数据类型，也就是下面将要总结整理的袁术、列表以及字典。
元组
元组的语法表达方式是把一系列的数据对象放到小括号里，用逗号分开。在IDLE环境中做相应的演示如下：
>>> t1 =
(1,2,1.8,2.0,'a','bcd')
>>> t1
(1, 2, 1.8, 2.0, 'a', 'bcd')
其中，元组的数据成员可以是整形、浮点、字符串等。另外，元组的数据成员的数据类型也可以使元组。例如：
>>> t2 = (t1,123)
>>> t2
((1, 2, 1.8, 2.0, 'a', 'bcd'), 123)
需要注意的式，t1是作为一个整体成为了t2的一个成员而不是，每个t1的成员都是t2的组成成员。
另外，需要注意的是单元素的元组定义的时候需要加上一个逗号分隔符，否则定义的其实是一个单数的数据类型。如下：
>>> t_single = (1)
>>> type(t_single)
>>> t_single = (1,)
>>> type(t_single)
>>> t_single
(1,)
从上面的运行结果可以看出，(1)构造的仅仅是一个整形的数据。
下面再看一下元组的加法，两个元组可以相加构造出一个新的元组对象。例如，接着上面的操作，利用t1以及t_single来构造一个新的元组t3，利用t1以及t2构造新的元组t4：
>>> t3 = t1 + t_single
>>> t4 = t1 + t2
>>> t3
(1, 2, 1.8, 2.0, 'a', 'bcd', 1)
>>> t4
(1, 2, 1.8, 2.0, 'a', 'bcd', (1, 2, 1.8, 2.0, 'a',
'bcd'), 123)
元组元素的遍历
可以使用for循环去遍历元组中的每一个元素，例如设计如下程序：
在IDLE中load执行的结果：
>>> ================================
RESTART ================================
>>>
>>> WalkTuple(t1)
1
2
1.8
2.0
a
bcd
(1, 2, 1.8, 2.0, 'a', 'bcd')
123
元组元素的访问与切片：
如同字符串，元组也支持索引访问以及切片操作。在IDLE环境中进行相关演示如下：
>>> t1 = (1,3,5,7,9)
>>> t1[3]
7
>>> t1[:4]
(1, 3, 5, 7)
>>> t1[0:3]
(1, 3, 5)
需要注意的是元组是不可以修改的。当尝试修改元组中的元素时会报错：
>>> t1[3] = 8
Traceback (most recent call last):
File "", line 1, in
t1[3] = 8
TypeError: 'tuple' object does not support item
assignment
元组的使用（寻找公约数）：
设计代码如下：
在IDLE环境中load执行结果：
>>> ================================
RESTART ================================
>>>
>>> Divisors(20,100)
(1, 2, 4, 5, 10, 20)
>>> Divisors(6,12)
(1, 2, 3, 6)
列表
列表在形式上与元组有一定的相似性，但是在单元素定义以及表现形式上有一定的差异。同时，列表是可以修改的。
列表在语法形式上，使用的式方括号括起它的每个元素。而在单个元素的列表定义时，不用担心会跟单数的数据类型发生混淆，因此不用像元组一样增加一个逗号。在IDLE环境中示范如下：
>>> l1 = [1]
>>> l1
[1]
列表的每个元素都可以通过索引的方式访问以及修改，同时也支持切片。在IDLE环境中示范如下：
>>> L2 = [1,2,3,4,'abc','def']
>>> L2
[1, 2, 3, 4, 'abc', 'def']
>>> L2[3]
4
>>> L2[3] = 'abcd'
>>> L2
[1, 2, 3, 'abcd', 'abc', 'def']
>>> L2[:3]
[1, 2, 3]
>>> L2[0:4]
[1, 2, 3, 'abcd']
关于列表的可变性，可以通过一个更加形象的例子来说明：
>>> L3 = ['abc','def']
>>> L4 = [1,2,3]
>>> L5 = [L3,L4]
>>> L6 =
[['abc','def'],[1,2,3]]
>>> L5
[['abc', 'def'], [1, 2, 3]]
>>> L6
[['abc', 'def'], [1, 2, 3]]
>>> L3.append(12345)
>>> L5
[['abc', 'def', 12345], [1, 2, 3]]
>>> L6
[['abc', 'def'], [1, 2, 3]]
通过以上例子可以更好地看出列表的可变性。尽管第一次构造后，L5与L6在IDLE中输出的信息是一致的，但是两者并不相同。由于L5是对两个列表L3，L4的引用，因此当L3发生变化时，L5随之变化而L6并不会有任何改变。这有时候会在程序设计时给我们带来很多麻烦，当然，也会带来很多好处。如果我们不期望发生一个被引用列表变化时影响到我们引用它的列表，那我们设计程序的时候最好采用列表拷贝的方式。如下：
>>> L1 = [1,2,3]
>>> L2 = [4,5,6]
>>> L3 = [L1[:],L2[:]]
>>> L4 = [L1,L2]
>>> L1.remove(3)
>>> L3
[[1, 2, 3], [4, 5, 6]]
>>> L4
[[1, 2], [4, 5, 6]]
以上示范中，L3的构造采用了列表的拷贝而L4的构造则是采用了引用。当L1发生变化时，拷贝不受影响但是引用随之变化。
列表元素的增加和删除：
上面的例子中，分别用到了append()以及remove()的方法，这两个方法分别是列表增加以及删除元素的内置方法。
列表的遍历：
如同元组，列表可以通过for循环来遍历每个元素成员，IDLE演示如下：
>>> L4 = [1,2,3,4,'abc','efd']
>>> for each_element in L4:
print(each_element)
1
2
3
4
abc
efd
列表扩展：
这里扩展介绍一种Python中的一种设计方法，把函数作为函数的参数。代码示范1：
IDLE中执行：
>>> ================================
RESTART ================================
>>>
>>> Func1(L1,abs)
1
2.3
5
123
>>> Func1(L1,str)
1
2.3
5
-123
>>> Func1(L1,float)
1.0
2.3
5.0
-123.0
>>> Func2(L1,L2)
1
2.3
5
123
1
2
5
-123
1.0
2.3
5.0
-123.0
这在数据处理上确实是带来很多方便。但是，如果传入函数的接受参数超过一个，其实还有更好的实现方式：
map(func,L1)，下面给出一段示例代码：
在IDLE中的执行结果：
>>> ================================
RESTART ================================
>>>
[124, 999, 54]
字典
如果接触过C语言或者Perl等，这种数据类型其实并不让人感到陌生。字典其实就是C或者Perl中的哈希，MATLAB中的map。Python中的字典示例：
>>> d1 =
{'mon':1,'tue':2,'wed':3}
>>> d1
{'wed': 3, 'mon': 1, 'tue': 2}
>>> d1['wed']
3
字典元素的增加
>>> d1['thr'] = 4
>>> d1
{'thr': 4, 'wed': 3, 'mon': 1, 'tue':
2}
字典的遍历
>>> for each_element in d1:
print(each_element)
thr
wed
mon
tue
>>> d1.keys()
['thr', 'wed', 'mon', 'tue']
>>> d1.values()
[4, 3, 1, 2]
字典元素的删除
>>> d1.pop('tue')
2
>>> d1
{'thr': 4, 'wed': 3, 'mon': 1}
通过for循环遍历，得到的其实是字典的key值。这与字典的keys()方法得到的结果是一致的。而通过values()的方法则可以得到字典的各个value。这两个方法得到的返回结果都是列表。
此外，字典的key可以是一种符合形式的数据，比如元组。继续以上的IDLE环境，通过操作示范一下：
>>> d1[(1,2,3)] = 'three
values'
>>> d1
{'thr': 4, 'wed': 3, 'mon': 1, (1, 2, 3): 'three
values'}
>>> d1[(1,2,3)]
'three values'
