第二章：列表和元组
前言
关于本章，我将会将两个新的数据结构（数据结构的定义请参见数据结构），在Python中，最基础的数据结构是序列，序列就是对每个元素进行编号（就是其位置或者索引，注意，其中第一个元素的索引为0，以此类推）。当然，书中也提到了负索引，后面会跟大家逐步介绍。
本章的前部分是对索引进行概述，然后介绍一些适用于所有序列（包括列表和元组）的操作。这些操作也适用于本章一些示例中将使用的字符串，下一章将全面介绍字符串操作。讨论这些基本知识后，将着手介绍列表，看看它们有什么特别之处，然后讨论元组。元组是一种特殊的序列，类似与列表，只是不能修改。
2.1 序列概述
Python内置了多种的序列，本章重点讨论其中用的最常见的两种：列表和元组。另外一种重要的序列是字符串，将在下一章更详细的讨论。
列表和元组主要的不同在于：列表是可以修改的，而元组不可以(注意：这意味着列表适用于需要中途添加元素的情况，而元组适用于处于某种情况需禁止修改的情况）。在自己编写的程序中，几乎在所有的情况下都可以使用列表来代替元组。一种例外的情况就是将元组作为字典键，这在后面的第四章进行讨论。在这种情况下，不能使用列表来代替元组，因为字典键是不允许修改的。
举例：
在需要处理一系列的值时，序列很有用。在数据库中，你可能使用序列来表示人，其中第一个元素为姓名，第二个元素为年龄。如果使用列表来表示（所有元素都放入方括号内，并用逗号隔开），将类似下面这样：
>>>edward=[ ' Edward Gumby ‘，42]
当然，序列中还可以包含其他序列，因此可以创建一个由数据库中所有人员组成的列表：
>>>edward=[ ' Edward Gumby ',42 ]
>>>john=[' John Smith ',50]
>>>database=[edward,john]
>>>database
[ [ ' Edward Gumby '，42] ，[ 'John Smith ' ，50] ]
注意：Python 支持一种数据结构的基本概念，名为容器。容器基本上就是可包括其他对象的对象（这个对象是生活中的对象还是当时将的C++中的这种对象？？？）。两种主要的容器是序列（如列表和元组）和映射（如字典)。在序列中，每个元素都有自己的编号，而在映射中，每个元素都有自己的名称（也叫键）。映射将在第四章详细的讨论。有一种既不是序列也不是映射的容器，就是集合（set），将在第十章讨论。
2.2 通用的序列操作
有几种操作适用于所有的序列，包括索引，切片，相加，相乘和成员资格检查。另外，Python还提供一些内置函数，可用于确定序列的长度以及找到序列中最大和最小的元素。
注意：有一些重要的操作这里不会介绍，它就是迭代，对序列进行迭代意味着对其每个元素都要执行特定的操作。有关迭代的具体信息，请参见5.5节
2.2.1 索引
序列中每个元素都要进行编号-----------从0开始递增。你可像下面这样使用编号来访问各个元素：
>>>greeting = 'Hello'
>>>greeting[0]
'H'
注意：字符串就是由字符组成的序列。索引0指向第一个元素，这里为字符H。不同于其他一些语言，Python没有专门用于表示字符串的类型，因此一个字符就是只包含一个元素的字符串
这称为索引。你可使用索引来获取元素。这种索引方式适用于所有索引。当你使用负数索引时，Python将从右（即最后一个元素）开始往左数，因此-1是最后一个元素的位置。
>>>greeting[-1]
'o'
对于字符串字面量（以及其他序列字面量），可直接对其执行索引操作，无需先将其赋给变量。这与先赋给变量在对变量执行索引操作的效果一样的。
>>> 'Hello' [1]
'e'
如果函数调用返回一个序列，可直接对其执行索引操作。例如，如果你只想获取用户输入的年份的第4位，可像下面这样做：
>>>fourth=input('Year: ‘）[3]
Year=2005
>>>fourth
'5'
代码清单2-1所示程序：要求你输入年、月（数1~12）、日（数1~31），再使用相应的月份名等将日期打印出来。
代码2-1：
moths=[
'January',
'February',
'March’，
‘April'，
'May',
'June',
'July',
'August',
'September',
'October',
'November',
'December'
]
#一个列表，其中包含数1~31对应的结尾
endings=['st','nd','rd']+17*['th']+['st','nd','rd']+7*['th']+['st']
year =input('Year: ')
month =input('Month(1-12): ')
day =input('Day(1-31): ')
month_number= int(month)
day_number= int(day)
#别忘了将代表年、月、日的数减1，这样才能得到正确的索引
month_name=month[month_number-1]
ordinal=day+endings[day_number-1]
print(month_name+' '+ordinal+’，‘+year）
程序运行结果类似这样：
Year： 1974
Month(1-12): 8
Day(1-31): 16
输出结果：
August 16th,1974
2.2.2 切片
除了使用索引来访问单个元素外，还可使用切片来访问特定范围内的元素。为此，可使用两个索引，并用冒号分割：
>>>tag='<a href="http://www.python.org">Python web site<a>'
>>>tag[9:30]
'http://www.python.org'
>>>tag[32:-4]
'Python web site'
切片适用于提取序列的一部分，其中的编号非常重要：第一个索引是包含的第一个元素的编号，第二个索引是切片后余下的第一个元素的编号。请看下面的示例：
>>>numbers=[1,2,3,4,5,6,7,8,9,10]
>>>numbers[3:6]
[4,5,6]
>>>numbers[0:1]
[1]
简而言之，你提供两个索引来指定切片的边界，其中一个索引是包含第一个元素的编号，但第二个索引是切片后余下的第一个元素的编号。
1.绝妙的简写
假设你要访问前述数字列表中的最后三个元素，显然可以明确地指定这一点。
>>>number[7:10]
[8,9,10]
在这里，索引10指的是第11个元素：它并不存在，但确定是到达最后一个元素后再前进一步所在的位置。明白了吗？如果要从从列表尾部开始数，可以使用负数索引。
>>>numbers[-3:-1]
[8,9]
然而，这样好像无法包含最后一个元素。如果使用索引0，即到达列表末尾再前进一步所处的位置，结果将如何呢？
>>>numbers[-3,0]
[]
结果并不是你想要的，实际上，执行切片操作时，如果第一个索引指定的元素位于第二个索引指定的元素后面（在这里，倒数第三个元素位于第一个元素的后面），结果就为空序列。好在你能使用一种简写：如果切片结束位于序列的尾部，可省略第二个索引。
>>>numbers[-3:]
[8,9,10]
同样，如果切片始于序列头部，可省略第一个索引：
>>>numbers[:3]
[1,2,3]
实际上，要复制整个序列，可将两个索引都省略：
numbers[:]
[1,2,3,4,5,6,7,8,9,10]
代码清单2-2是一个小程序，它提示用户输入一个URL，并从中提取域名。(这里假定输入的URL类似于http：//www.somedomainname.com。）
代码清单2-2:
#从类似于http://www.something.com的URL中提取域名
URL=input('Please enter the URL:')
domain=url[11:-4]
print("Domain name: “+domain）
Please enter the URL： http://www.Python.org
Domain name: python
2.更大的步长
执行切片操作时候，你将显式或者隐式的指定起点和终点，但通常省略另外一个参数，即步长。在普通切片中，步长为1，这意味着从一个元素移到另外一个元素，因此切片包含起点和终点之间所有的元素。
>>>numbers=[0:10:1]
[1,2,3,4,5,6,7,8,9,10]
在这个示例中，指定的另外一个参数就是步长。如果指定的步长大于1，将跳过一些元素，比如步长为2，将起点和终点之间每隔一个元素提取一个元素。
>>>numbers[0:10:2]
[1,3,5,7,9]
>>>numbrs[3:6:3]
[4]
显示地指定步长时，也可使用前面的简写。例如，要从序列中每个3个元素提取1个，只需要提供步长为4即可。
>>>numbers[::4]
[1,5,9]
当然，步长不能为0，否则无法向前移动，但可以为负数，即从右向左提取元素。
>>>numbers[8:3:-1]
[9,8,7,6,5]
>>>numbers[10:0:-2]
[10,8,6,4,2]
>>>numbers[0:10:-2]
[]
>>>numbers[::-2]
[10,8,6,4,2]
>>>numbers[5::-2]
[6,4,2]
>>>numbers[:5:-2]
[10,8]
注意：在这种情况下，要正确的提取颇费心思。如你所见，第一个索引依然包含在内，而第二个索引不包含在内。步长为负数时候，第一个索引必须比第二个索引大。可能有点令人迷惑的是，当你省略起始和结束索引的时候，Python竟然执行了正确的操作，步长为正数的时候，它从起点移到终点，而步长为负数时，它从终点移到了起点。
2.2.3序列相加
可使用加法运算符来拼接序列。
>>>[1,2,3]+[4,5,6]
[1,2,3,4,5,6]
>>>'Hello,'+'world'
'Hello,world'
>>>[1,2,3]+'world!'
Tackback(innermost last):
File "<pylist>", line1 ,in ?
[1,2,3]+'world!'
TyperError: can only concatenate list (not "String) to list
从错误消息可知，不能拼接列表和字符串，虽然它们都是序列。一般而言，不能拼接不同类型的序列。
2.2.4乘法
将序列与数x相乘，将重复这个序列x来创建一个新序列。
>>> 'python’*5
'pythonpythonpythonpythonpython'
>>>[42]*10
[42,42,42,42,42,42,42,42,42,42]
None、空列表和初始化
空列表是使用不包含任何内容的两个方括号( [ ] )来表示的。如果要创建一个可包含10个元素的列表，但没有任何任何有用的内容，可像前面那样使用[42]*10.但更准确的做法是[0]*10,这样创建一个包含10个0的列表。然而，在有些情况下，你可能想使用表示”什么都没有“的值，如表示还没有在列表添加任何内容，在这种情况下，可使用None，在Python中，None表示什么都没有。因此，要将列表的长度初始化为10 ，可像下面这样做：
>>>sequence =[None]*10
>>>sequence
[None,None,None,None,None,None,None,None,None,None]
2.2.5 成员资格
要检查特定的值是否包含在序列中，可使用运算符in。这个运算符与前面讨论的运算符（如乘法或者加法运算符稍有不同）。它检查是否满足指定的条件，并返回相应的值：满足时返回True，不满足返回False。这样的运算符称之为布尔运算符，而前述真值称为布尔值。布尔表达式将在5.4节详细介绍。
下面介绍一些in运算符的使用示例：
>>>permissions ='rw'
>>>'w' in permissions
True
>>>'x'in permissions
False
>>>users = ['mlh','foo','bar']
>>>input(‘Enter your user name: ') in users
Enter your user name: mlh
True
>>>subject = '$$$ Get rich now!!! $$$'
'$$$' in subject
True
注意：相比于其他示例，检查字符串是否包含'$$$'的示例稍有不同。一般而言，运算符in检查指定的对象是否是序列（或其他集合）的成员（即其中一个元素），但对字符串来说，只有它包含的字符才是成员变量或元素，因此下面的代码完全合理：
>>>'P' in 'Python'
True
事实上，在较早的Python版本中，只能对字符串执行这种成员资格检查-----------------------确定指定的字符串是否包含在字符串中，但现在可使用运算符in来检查指定的字符串是否为为宁外一个字符串的字串。
代码2-4所示的程序是从用户哪那里获取一个用户和一个PIN码，并检查他们组成的列表是否包含在数据库中（实际上也是一个列表）中。如果用户名-PIN码对包含在数据库中，就打印字符串'Acess granted’
代码2-4：
database=[
['albert','1234'],
['dilbert','4242'],
['smith','7524']
['jones','9843']
]
username=input('User name: ')
pin=input('PIN code: ')
if [username, pin) in databese :print('Acess granted')
长度、最小值和最大值
内置函数len、 min、max很有用，其中函数len返回列表包含元素的个数，而min和max分别返回序列中最小和最大的元素（对象比较将在5.4.6节的”比较运算符“部分详细介绍）
>>>numbers=[100,34,678]
>>>len(numbers)
3
>>>max(numbers)
678
>>>min(numbers)
34
>>>max(2,3)
3
>>>min(9,3,2,5)
2
基于前面的介绍，这些代码应该很容易理解，但最后两个表达式可能例外，在这两个表达式中，调用max和min时指定的实参并不是序列，而直接将数作为实参。
2.3列表：Python的主力
前面的示例大量的使用列表，你明白它们很有用，但本节主要讨论列表不同于元组和字符串的地方——列表是可变的，即可修改其内容，另外，列表有很多特定的方法。
2.3.1 函数list
鉴于不能像修改列表那样修改字符串，因此在有些情况下使用字符串来创建列表很有帮助。为此，可使用函数list
>>>list('Hello')
['H','e','l','l','o']
请注意，可将任何序列（而不仅仅是字符串）作为list的参数。
注意：要将字符串（如前述代码的字符列表）转换为字符串，可使用下面的表达式：
‘ ’.join(somelist)
其中somelist是要转换的列表，这到底是什么意思？3.4.3节对此作出了说明。
2.3.2基本的列表操作
可对列表执行的所有的标准序列操作，如索引、切片、拼接和相乘，但列表的有趣之处在于它是可以修改的。本节将介绍一些修改的列表的方式：给元素赋值、删除元素、给切片赋值以及使用列表的方法。(请注意：并非所有的列表方法都能修改列表）
1.修改列表：给元素赋值
修改列表很容易，只需使用第一章介绍的普通赋值语句即可，但不是使用类似的x=2这样的赋值语句，而是使用索引表示法给特定位置的元素赋值，如x[2]=3.
>>>x=[1,1,1]
>>>x[1]=2
>>>x
[1,2,1]
注意： 不能给不存在的元素赋值，因此如果列表的长度为2，就不能给索引为100的元素赋值。要这样做，列表的长度至少为101。请参阅本章前面的”None、空列表和初始化“一节。
2.删除列表
从列表中删除元素也很容易，只需要使用del语句即可。
>>>names=['Alice','Beth','Cecil','Dee-Dee','Earl']
>>>del names[2]
>>>names
['Alice','Beth','Dee-Dee','Earl']
除了能删除列表元素以外，del语句还可以删除其他东西，你可将其用于字典（参加第四章）乃至变量，有关相关的详细信息，请参阅第五章。
3.给切片赋值
切片是一项极其强大的功能，而能够给切片赋值让这项功能显得更加的强大。
>>>name=list('Perl')
>>>name
['P','e','r','l']
>>>name[2:]=list('ar')
>>>name
['P','e','a','r']
通过上述可知，可同时给多个元素赋值，你可能想，这又什么大不了，分别给每个元素赋值不是一样的吗？确实如此，但通过使用切片赋值，可将切片替换为长度与其不同的序列。
>>>name=list('Perl')
>>>name
['P','e','r','l']
>>>name[1:]=list('ython')
>>>name
['P','y','t','h','o','n']
使用切片赋值还可在不替换原有元素的情况下插入新元素。
>>>numbers=[1,5]
>>>numbers[1:1]=[2,3,4]
>>>numbers
[1,2,3,4,5]
在这里，我’替换‘了一个空切片，相当于插入了一个序列。你可采取相反的措施来删除切片
>>>numbers
[1,2,3,4,5]
>>>numbers[1:4]=[]
>>>numbers
[1,5]
你可能猜到了，上述代码与del numbers[1:4]等效。现在，你可自己尝试执行步长不为1（乃至为负）的切片赋值了。（值得多思考思考）
2.3.3列表方法
方法是与对象（列表、数、字符串等）联系紧密的函数。通常，像下面这样调用的函数：
object.method(arguments）
方法调用与函数调用很像，只是方法名前加上了对象和句号（第七章将详细阐述方法到底是什么？）。列表包含多个可用来查看或修改其内容的方法。
1.append
方法append用于将一个对象附加到列表末尾。
>>>lst=[1,2,3]
>>>lst.append(4)
>>>lst
[1,2,3,4]
你可能心存顾虑，为何给列表取lst这样糟糕的名字，而不称为list呢？我原本是可以这样做的，但你可能还记得，list是内置函数，如果我将前述列表命名为list，就无法调用这个函数。在特定的应用程序中，通常可给列表选择更好的名称。诸如lst等名称确实不能提供任何信息。因此，如果列表为价格列表，可能应该将其命名为prices、prices_of_eggs或pricesOfEggs。（个人觉得这段很有用，虽然文字有点多，注意，后面的举例的命名规则很常见）
另外请注意，与其他几个类似的方法一样，append也就地修改列表。这意味着它不会返回修改后的新列表，而是直接修改旧列表。这通常正是你想要的，但有时会带来麻烦。我将会在本章后面介绍sort时候再回过头来讨论这一点。
2.clear
方法clear就地清空列表的内容。
>>>lst=[1,2,3]
>>>lst.clear()
>>>lst
[]
这类似于切片赋值语句lst[:]=[].
3.copy（注意：这里区别deepcopy）
方法copy复制列表。前面讲过，常规复制只是将另外一个名称关联到列表
>>>a=[1,2,3]
>>>b=a
>>>b[1]=4
>>>a
[1,4,3]
要让a和指向不同的列表，就必须将b关联到a的副本。
>>>a=[1,2,3]
>>>b=a.copy()
>>>b[1]=4
>>>a
[1,2,3]
这类似使用a[:]或者list(a),它们都复制a。
4.count
方法count计算指定的元素再列表中出现了多少次。
>>>['to','be','or','not','to','be'].count('to')
2
>>>x=[[1,2],1,1,[2,1,[1,2]]]
>>>x.count([1,2]）
1
5.extend
方法extend让你能够同时将多个值附加到列表尾部，为此可将这些值组成的序列作为参数提供给方法extend。换而言之，你可使用一个列表来扩展另外一个列表。
>>>a=[1,2,3]
>>>b=[4,5,6]
>>>a.extend(b)
>>>a
[1,2,3,4,5,6]
这可能看起来像拼接，但存在一个重要的差别，那就是将修改被扩展的序列（这里是a）。在常规的拼接下，情况是返回一个全新的序列。
>>>a=[1,2,3]
>>>b=[4,5,6]
>>>a+b
[1,2,3,4,5,6]
>>>a
[1,2,3]
如你所见，拼接出来的列表与前面扩展得到的列表完全相同，但在这里a并没有被修改。鉴于常规拼接必须使用a和b的副本创建一个新列表，因此如果你要获得类似于下面的效果，拼接的效率将比extend低：
>>>a=a+b
另外，拼接操作并非就地操作，即它不会修改原来的列表。要获得于extend相同的效果，可将列表赋值给切片，如下所示：
>>>a=[1,2,3]
>>>b=[4,5,6]
>>>a[len(a):]=b
>>>a
[1,2,3,4,5,6]
6.index
方法index在列表中查找指定值第一次出现的索引。
>>>knights=['We','are','the','knights','who','say','ni']
>>>knights.index('who')
4
>>>knights.index('herring')
Traceback(innermost last):
File "<pyshell>",line1,in ?
knights.index('herring')
ValueError:list.index(x):x not in list
第一个找到，第二个没有发现。
7.insert
方法insert用于将一个对象插入列表。
>>>numbers=[1,2,3,5,6,7]
>>>numbers.insert(3,'four')
>>>numbers
[1,2,3,'four',5,6,7]
与extend一样，也可使用切片赋值来获得与insert一样的效果。
>>>numbers=[1,2,3,5,6,7]
>>>numbers[3:3]=['four']
>>>numbers
[1,2,3,'four',5,6,7]
这虽然很巧妙，但可读性根本无法与使用insert媲美。
8.pop
方法pop从列表删除一个元素（末尾为最后一个元素），并返回这个元素。
>>>x=[1,2,3]
>>>x.pop()
3
>>>x
[1,2]
>>>x.pop(0)
1
>>>x
[2]
注意：pop是唯一既修改列表又返回一个非None值的列表方法。
使用pop可实现一种非常常见的数据结构------栈（stack）。栈就像一叠盘子，你可在上上面添加盘子，还可从上面取走盘子。最后加入盘子最先取走盘子，这就是后进先出（LIFO）。
push和pop是大家普遍接受的两种栈操作（加入和取走)的名称。Python没有提供push，但可使用append来替代。方法pop和append的效果相反，因此将刚弹出的值压入（或附加）后，得到的栈与原来相同。
>>>x=[1,2,3]
>>>x.append(x.pop)
>>>x
[1,2,3]
提示：要创建先进先出（FIFO）的队列，可使用insert(0,...)代替append。另外，也可继续使用append，但用pop(0)代替pop()。一种更加的解决方案是，使用模板collections中的deque。有关这方面的详细信息，请参阅第十章。
9.remove
方法remove用于删除第一个为指定值的元素。
>>>x=['to','be','or','not','to','be']
>>>x.remove('be')
>>>x
['to','or','not','to',be']
>>>x.remove('bee')
Traceback （innermost last):
File "<pyshell>",line 1,in ?
x.remove('bee’)
ValueError:list.remove(x):x not in list
如你所见，这只删除了为指定值的第一个元素，无法删除列表中其他为指定值的元素（这里的字符串‘bee')。
请注意，remove是就地修改且不返回值的方法之一。不同于pop的是，它修改列表，但不返回任何值。
10.reverse
方法reverse按相反的顺序排列列表中的元素（我想你对此应该不会感到惊讶）
>>>x=[1,2,3]
>>>x.reverse()
>>>x
[3,2,1]
注意到reverse修改列表，但不返回值（与remove和sort等方法一样）
提示 如果按相反的顺序迭代序列，可使用函数reversed。这个函数不返回列表，而是返回一个迭代器（迭代器将在第九章详细介绍）。你可使用list将返回的对象转换为列表。
>>>x=[1,2,3]
>>>list(reversed(x))
[3,2,1]
11、sort
方法sort用于对列表就地排序。就地排序意味着对原来的列表进行修改，使用元素按顺序排列，而不是返回排序后的列表副本。
>>>x=[4,6,2,1,7,9]
>>>x.sort()
>>>x
[1,2,4,6,7,9]
值得注意：前面介绍了多个修改列表而不返回任何值的地方，在大多数情况下，这种行为都相当自然（例如,对append来说就如此）。需要强调sort的行为也是这样的，因为这种行为给许多人都带来了困惑。在需要排序后的列表副本并保留原始列表不变时，通常会遭遇这种困惑。为实现这种目标，一种直观（但错误）的方式是像下面这样做：
>>>x=[4,6,2,1,7,9]
>>>y=x.sort() #千万别这样做！
>>>print(y)
None
鉴于sort修改x且不返回任何值，最终的结果是x是经过排序的，而y包含None。为实现前述目标，正确的方式之一是先将y关联到x的副本，再对y进行排序，如下所示：
>>>x=[4,6,2,1,7,9]
>>>y=x.copy()
>>>y.sort()
>>>x
[4,6,2,1,7,9]
>>>y
[1,2,4,6,7,9]
只是将x赋给y是不可行的，因为这样x和y将指向同一个列表。为获取排列后的列表的副本，另一种方式是使用函数sorted。
>>>x=[4,6,2,1,7,9]
>>>y=sorted(x)
>>>x
[4,6,2,1,7,9]
>>>y
[1,2,4,6,7,9]
注意：实际上，函数sorted可用于任何可迭代的对象。可迭代的对象将在第九章详细介绍。
实际上，这个函数可用于任何排序，但总是返回一个列表。
>>>sorted('Python')
['P','h','n','o','t','y']
如果要将元素按相反的顺序排列，可先使用sort（或sorted），再调用方法reverse，也可使用参数reverse，这将在下一节介绍。
12、高级排序
方法sort接受两个可选参数：key和reverse。这两个参数通常是按名称指定的，称为关键字参数，将在第六章讨论。参数key类似于参数cmp：你将其设置为一个用于排序的函数。然而，不会直接使用这个函数来判断一个元素是否比另外一个元素小，而是使用它来为每个元素创建一个键，再根据这些键对元素进行排序。因此，要根据长度对元素进行排序，可将参数key设置为函数len。
>>>x=['arrdvark','abalone','acme','add','aerate']
>>>x.sort(key=len)
>>>x
['add','acme','aerate’，‘abalone','aardvark']
对于另一个关键字参数reverse，只需将指定为一个真值（True或False，将在第五章详细介绍），以指出是否按相反的顺序对列表进行排序。
>>>x=[4,6,2,1,7,9]
>>>x.sort(reverse=True)
>>>x
[9,7,6,4,2,1]
函数sorted也接受参数key和reverse。但很多情况下，将参数key设置为一个自定义函数很有用。第六章将介绍如何创建自定义函数。
提示：如果你想更深入地了解排序，可以参阅文章“Sorting Mini-HOW TO”：http：//wiki.python.org/moin/HowTo/Sorting
2.4 元组：不可修改的序列
与列表一样，元组也是序列，唯一的差别在于元组是不能修改的（你可能注意到了，字符串也不能修改）。元组语法很简单，只要将一些值用逗号隔开，就能自能创建一个元组。
>>>1,2,3
（1，2，3）
如你所见，元组还可用圆括号括起（这也是通常采用的做法）。
>>>(1,2,3)
(1,2,3)
空元组用两个不包含任何内容的圆括号表示。
>>>()
()
你可能会问，如何表示只包含一个值的元组呢？这有点特殊：虽然只有一个值，也必须在它后面加上逗号。
>>>42
42
>>>42,
(42,)
>>>(42,)
（42,）
注意，（42）与42完全等效，但仅仅加上一个逗号，就能完全改变表达式的值。
>>>3*(40+2)
126
>>>tuple([1,2,3])
(1,2,3)
>>>tuple('abc')
('a','b','c')
>>>tuple((1,2,3))
(1,2,3)
你可能意识到了，元组并不复杂，而且除创建和访问其元素外，可对元组执行的操作不多。元组的创建及其元素的访问方式与其他序列相同。
>>>x=1,2,3
>>>x[1]
2
>>>x[0:2]
(1，2）
元组的切片也是元组，就像列表的切片也是列表一样。为何要熟悉元组呢？原因有以下两个。
- 它们用映射中的键（以及集合的成员),而列表不行，映射将在第四章详细介绍。
- 有些内置函数和方法返回元组，这意味着必须跟它们打交道。只要不尝试修改元组，与元组“打交道”通常意味着像处理列表一样处理它们（需要使用元组没有的index和count等方法时例外）。
一般而言，使用列表足以满足对列表的需求。