python进修笔记（二）
添加时间:2013-5-14 点击量:
python数据布局
学一门说话，最根蒂根基和首要的就是数据布局了，而在python中最根蒂根基的数据布局是序列，也可以懂得为数组，但貌似比数组强大。
>>> jason=[jason，42]
>>> james=[james，45]
>>> database=[jason，james]
>>> database
[[jason， 42]， [james， 45]]
>>>
索引：
>>> greeting=hello
>>> greeting[0]
h
>>> greeting[-1] ==>反着的时辰从-1而不是0开端开端
o
>>> digital=raw_input （year:）[3]
year:2013
>>> digital
3
索引示例：
>>> months=[January，February，March，April， May，June，July，August，September，October November，December] ＃按照指定的年代日以数字情势打印出日期
>>> endings=[st，nd，rd]+17[th]+[st，nd，rd]+7[th]+[st] ＃以1-31的数字作为结尾的列表
>>> year=raw_input （Year:）
Year:2013
>>> month=raw_input（Month（1-12）:）
Month（1-12）:3
>>> day=raw_input（Day（1-31）:）
Day（1-31）:30
>>> month_num=int（month）
>>> day_num=int（day）
>>> month_name=months[month_num-1] ==>重视这里索引要减1
>>> ordinal=day+endings[day_num-1]
>>> print month_name + +ordinal + ， + year
March 30th， 2013
>>>
分片：
应用索引能接见单个元素，应用分片能接见必然局限的元素，分片经由过程冒号相隔的两个索引来实现。
>>> 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[-3:-1]
[8， 9]
>>> numbers[-3:0] ＃分片中的最左边的索引比它右边索引的晚呈如今序列中，成果就是一个空序列
[]
>>> numbers[-3:] ＃默认到最后
[8， 9， 10]
>>> numbers[:3] ＃默认从第一个开端
[1， 2， 3]
>>> numbers[:] ＃默认全部
[1， 2， 3， 4， 5， 6， 7， 8， 9， 10]
很显然，分片操纵的实现须要供给两个索引作为鸿沟，第一个索引的元素包含在分片内，而第二个不包含在分片内。
分片步长：默认步长没有写，是1，分片格局：上鸿沟：下鸿沟：步长
>>> numbers[0:10:1] ＃默认步长是1
[1， 2， 3， 4， 5， 6， 7， 8， 9， 10]
>>> numbers[0:10:2] ＃步长设为2
[1， 3， 5， 7， 9]
>>> numbers[3:6:3] ＃步长设为3
[4]
>>> numbers[::4]
[1， 5， 9]
>>> numbers[8:3:-1] ＃步长不克不及为0，因为不会向下履行，可认为负数，向前履行
[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]
>>>
序列相加：
>>> [1，2，3]+[4，5，6]
[1， 2， 3， 4， 5， 6]
>>> [1，2，3]+world ＃列表和字符串都是序列，然则不克不及连在一路，两种同类型的序列才干进行连接操纵
Traceback （most recent call last）:
File <pyshell＃141>， line 1， in <module>
[1，2，3]+world
TypeError: can only concatenate list （not str） to list
>>>
序列乘法：
>>> python5
pythonpythonpythonpythonpython
>>> [25]10
[25， 25， 25， 25， 25， 25， 25， 25， 25， 25]
空列表可以简单的经由过程[ ]默示，但若想要创建一个占用十个元素空间，却不包含任何有效的有效的内容列表。这时须要应用None，None是Python的内建值，初始化一个长度为10的列表如下：
>>> sequence=[None]10
>>> sequence
[None， None， None， None， None， None， None， None， None， None]
序列乘法示例：（存在脚本中运行）
sentence=raw_input （Sentence:）
screen_width=60
text_width=len（sentence）
box_width=text_width+6
left_margin=（screen_width-box_width）//2
print
print left_margin + + + - （box_width-2） + +
print left_margin + | + text_width + |
print left_margin + | + sentence + |
print left_margin + | + text_width + |
print left_margin + + + - （box_width-2） + +
print
raw_input（）
成果如下：
in运算符：搜检一个值是否在序列中
>>> permission=rwx ＃有木有感觉这个像断定Linux中某个文件的履行权限，确切可以这么断定
>>> w in permission
True
>>> xx in permission
False
>>> users=[jason，james，jzhou]
>>> raw_input （enter your name:） in users
enter your name:jzhou
True
序列成员资格示例：
database=[[jason，42]，[james，45]，[jzhou，22]]
username=raw_input（Username:）
age=raw_input（Age:）
if [username，age] in database:
print OK，right
raw_input（）
内建函数len、min、max
>>> numbers
[1， 2， 3， 4， 5， 6， 7， 8， 9， 10]
>>> len（numbers）
10
>>> max（numbers）
10
>>> min（numbers）
1
>>>
列表：
列表不合于元组和字符串，列表是可变的，并且列表有很多专门的办法。字符串不克不及像列表一样被批改，然则列表中的list函数可以实现批改。列表的常用用法：
>>> list（hello）
[h， e， l， l， o]
>>> x=[1，1，1]
>>> x[1]=2 ＃可以改变列表为元素赋值
>>> x[2]=3
>>> x
[1， 2， 3]
>>> names=[james，jason，jzhou，liwear] ＃可以删除列表中的元素
>>> del names[3]
>>> names
[james， jason， jzhou]
>>> name=list（jzhou）
>>> name
[j， z， h， o， u]
>>> name[2:]=list（1314） ＃可以分片赋值
>>> name
[j， z， 1， 3， 1， 4]
>>> numbers=[1，5] ＃分片赋值可以在不须要调换任何元素的景象下插入新元素
>>> numbers[1:1]=[2，3，4]
>>> numbers
[1， 2， 3， 4， 5]
>>> numbers[1:4]=[] ＃也可以变相的删除元素
>>> numbers
[1， 5]
列表的办法首要有append， count，extend，index，，pop，remove，reverse，sort，简单用法如下：
>>> list=[1，2，3]
>>> list .append（4） ＃ append用于在列表末尾追加新对象
>>> list
[1， 2， 3， 4]
>>> [to，be，or，to].count（to） ＃count用于统计某个元素在列表中呈现的次数
2
>>> x=[[1，2]，1，1，[2，1，[1，2]]]
>>> x.count（1）
2
>>> x.count（[1，2]）
1
>>> a=[1，2，3]
>>> b=[4，5，6]
>>> a.extend（b） ＃extend在列表的末尾一次性追加另一个序列的多个值，扩大原有列表
>>> a
[1， 2， 3， 4， 5， 6] ＃重视这个操纵与连接操纵不合，extend批改了被扩大的序列即a，而连接只是姑且显示并没有变
>>> a=[1，2，3]
>>> b=[4，5，6]
>>> a[len（a）:]=b ＃也可以经由过程分片赋值来扩大，然则可读性不强
>>> a
[1， 2， 3， 4， 5， 6]
>>> sentence=[we，are，good，student]
>>> sentence.index （are） ＃index用于从列表中找出某个值第一个匹配项的索引地位
1
>>> numbers=[1，2，3，4，5，6，7]
>>> numbers.（3，four） ＃用于将对象插入列表中，和数据布局中的链表操纵很是类似
>>> numbers
[1， 2， 3， four， 4， 5， 6， 7]
>>> numbers=[1，2，3，4，5，6，7]
>>> numbers[3:3]=[four] ＃也可以应用分片赋值的办法实现，然则可读性不强
>>> numbers
[1， 2， 3， four， 4， 5， 6， 7]
>>> x=[1，2，3]
>>> x.pop（） ＃出栈操纵，和数据布局中的栈操纵一样，即移除列表中的最后一个，并且返回该元素的值
3
>>> x
[1， 2]
>>> x.pop（）
2
>>> x=[1，2，3]
>>> x.append（x.pop（）） ＃这个操纵和数据布局中的push、pop是一样的，追加方才出栈的值，很有趣，最后获得的还是是本来的值
>>> x
[1， 2， 3]
>>> x=[to，be，or，not，to，be]
>>> x.remove （be） ＃remove用于移除列表中某个值的第一个匹配项
>>> x ＃值得重视的是remove办法是没有返回值的原地位改变办法，重视和pop的差别
[to， or， not， to， be]
>>> x=[1，2，3]
>>> x.reverse （） ＃将列表中的元素反向存放，重视这种办法改变了列表但没有返回值
>>> x
[3， 2， 1]
>>> x=[4，5，6，7，1，2，3]
>>> x.sort（） ＃sort用于在原地位对列表进行排序，也改变了序列的值，然则没有返回值
>>> x
[1， 2， 3， 4， 5， 6， 7]
>>>
重视以上办法除了count和index，都是会使列表的内容的产生变更。
介于sort办法批改列表然则没有返回值的景象有待细说一下：
>>> x=[4，6，2，1，7，9]
>>> y=x.sort（） ＃因为x.sort（）不反回值，所以y并没有赋到值
>>> print y
None
>>>
看下正确的做法吧，其实也就是将步调拆开罢了：（sort函数不反回值的特点决意了不克不及在它的后面持续后续操纵，比如x.sort（）.reverse（），然则serted（x）.reverse（）是正确的）
>>> x=[4，6，2，1，7，9]
>>> y=x[:] ＃先将x复制给y
>>> y.sort（） ＃将y排序
>>> x
[4， 6， 2， 1， 7， 9]
>>> y
[1， 2， 4， 6， 7， 9]
>>> x=y>>> x
[1， 2， 4， 6， 7， 9]
>>> y
[1， 2， 4， 6， 7， 9]
另一种获取已排序的列表副本的办法是应用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） ＃默认按ASCII码排序
[P， h， n， o， t， y]
若是想把一些元素按相反的次序排出，可以先用sort或者sorted函数，在调用reverse函数。嵌套应用的功能很强大。
关于高等排序：元素能遵守特定的体式格式进行排序，可以应用compare（x，y）自定义斗劲函数，compare（x，y）函数会在x<y时返回负值，x>y时返回正值，x=y时返回0。定义好该函数之后，就可以供给给sort办法作为参数了。
>>> cmp（42，23）
1
>>> cmp（99，100）
-1
>>> cmp（1，1）
0
>>> numbers=[5，2，6，7]
>>> numbers.sort（cmp） ＃这个机制之后会介绍
>>> numbers
[2， 5， 6， 7]
元组——不成变序列
元组和列表一样，也是一种序列，独一的不合是元组不克不及批改，字符串也是如此；创建元素很简单，用逗号分隔一些值，就主动创建了元组：
>>> 1，2，3
（1， 2， 3）
>>> （1，2，3）
（1， 2， 3）
>>> （42，） ＃ 逗号申明它是一个元组，不然加括号（如：（42））也没用
（42，）
>>> 3（40+2） ＃这个例子说了然逗号的首要性，42和（42）是完全一样的
126
>>> 3（40+2，）
（42， 42， 42）
>>>
tuple函数：
tuple函数的功能与list函数根蒂根基一样：以一个序列作为参数把它转换为元组。若是参数是数组，那么该参数就会被原样返回：
>>> 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）
那么元组的存在意义是什么呢，起首元组可以在映射中当做键应用，而列表不可；其次，元组作为很多内建函数和办法的返回值存在。只要不涉及到批改元组，大项目组景象下和列表根蒂根基功能雷同。一般来说，列表可更能满足对序列的所有请求。
用到的函数总结：cmp（x，y）、len（seq）（返回序列长度）、list（seq）（把序列转换成列表）、max（args）、min（args）、reverse（seq）（对序列进行反向迭代）、sorted（seq）（返回已排序的包含seq所有元素的列表）、tuple（seq）（把序列转换成元组）
（转）
彼此相爱，却不要让爱成了束缚：不如让它成为涌动的大海，两岸乃是你们的灵魂。互斟满杯，却不要同饮一杯。相赠面包，却不要共食一个。一起歌舞欢喜，却依然各自独立，相互交心，却不是让对方收藏。因为唯有生命之手，方能收容你们的心。站在一起却不要过于靠近。—— 纪伯伦《先知》
python数据布局
学一门说话，最根蒂根基和首要的就是数据布局了，而在python中最根蒂根基的数据布局是序列，也可以懂得为数组，但貌似比数组强大。
>>> jason=[jason，42]
>>> james=[james，45]
>>> database=[jason，james]
>>> database
[[jason， 42]， [james， 45]]
>>>
索引：
>>> greeting=hello
>>> greeting[0]
h
>>> greeting[-1] ==>反着的时辰从-1而不是0开端开端
o
>>> digital=raw_input （year:）[3]
year:2013
>>> digital
3
索引示例：
>>> months=[January，February，March，April， May，June，July，August，September，October November，December] ＃按照指定的年代日以数字情势打印出日期
>>> endings=[st，nd，rd]+17[th]+[st，nd，rd]+7[th]+[st] ＃以1-31的数字作为结尾的列表
>>> year=raw_input （Year:）
Year:2013
>>> month=raw_input（Month（1-12）:）
Month（1-12）:3
>>> day=raw_input（Day（1-31）:）
Day（1-31）:30
>>> month_num=int（month）
>>> day_num=int（day）
>>> month_name=months[month_num-1] ==>重视这里索引要减1
>>> ordinal=day+endings[day_num-1]
>>> print month_name + +ordinal + ， + year
March 30th， 2013
>>>
分片：
应用索引能接见单个元素，应用分片能接见必然局限的元素，分片经由过程冒号相隔的两个索引来实现。
>>> 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[-3:-1]
[8， 9]
>>> numbers[-3:0] ＃分片中的最左边的索引比它右边索引的晚呈如今序列中，成果就是一个空序列
[]
>>> numbers[-3:] ＃默认到最后
[8， 9， 10]
>>> numbers[:3] ＃默认从第一个开端
[1， 2， 3]
>>> numbers[:] ＃默认全部
[1， 2， 3， 4， 5， 6， 7， 8， 9， 10]
很显然，分片操纵的实现须要供给两个索引作为鸿沟，第一个索引的元素包含在分片内，而第二个不包含在分片内。
分片步长：默认步长没有写，是1，分片格局：上鸿沟：下鸿沟：步长
>>> numbers[0:10:1] ＃默认步长是1
[1， 2， 3， 4， 5， 6， 7， 8， 9， 10]
>>> numbers[0:10:2] ＃步长设为2
[1， 3， 5， 7， 9]
>>> numbers[3:6:3] ＃步长设为3
[4]
>>> numbers[::4]
[1， 5， 9]
>>> numbers[8:3:-1] ＃步长不克不及为0，因为不会向下履行，可认为负数，向前履行
[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]
>>>
序列相加：
>>> [1，2，3]+[4，5，6]
[1， 2， 3， 4， 5， 6]
>>> [1，2，3]+world ＃列表和字符串都是序列，然则不克不及连在一路，两种同类型的序列才干进行连接操纵
Traceback （most recent call last）:
File <pyshell＃141>， line 1， in <module>
[1，2，3]+world
TypeError: can only concatenate list （not str） to list
>>>
序列乘法：
>>> python5
pythonpythonpythonpythonpython
>>> [25]10
[25， 25， 25， 25， 25， 25， 25， 25， 25， 25]
空列表可以简单的经由过程[ ]默示，但若想要创建一个占用十个元素空间，却不包含任何有效的有效的内容列表。这时须要应用None，None是Python的内建值，初始化一个长度为10的列表如下：
>>> sequence=[None]10
>>> sequence
[None， None， None， None， None， None， None， None， None， None]
序列乘法示例：（存在脚本中运行）
sentence=raw_input （Sentence:）
screen_width=60
text_width=len（sentence）
box_width=text_width+6
left_margin=（screen_width-box_width）//2
print left_margin + + + - （box_width-2） + +
print left_margin + | + text_width + |
print left_margin + | + sentence + |
print left_margin + | + text_width + |
print left_margin + + + - （box_width-2） + +
raw_input（）
成果如下：
in运算符：搜检一个值是否在序列中
>>> permission=rwx ＃有木有感觉这个像断定Linux中某个文件的履行权限，确切可以这么断定
>>> w in permission
True
>>> xx in permission
False
>>> users=[jason，james，jzhou]
>>> raw_input （enter your name:） in users
enter your name:jzhou
True
序列成员资格示例：
database=[[jason，42]，[james，45]，[jzhou，22]]
username=raw_input（Username:）
age=raw_input（Age:）
if [username，age] in database:
print OK，right
raw_input（）
内建函数len、min、max
>>> numbers
[1， 2， 3， 4， 5， 6， 7， 8， 9， 10]
>>> len（numbers）
10
>>> max（numbers）
10
>>> min（numbers）
1
>>>
列表：
列表不合于元组和字符串，列表是可变的，并且列表有很多专门的办法。字符串不克不及像列表一样被批改，然则列表中的list函数可以实现批改。列表的常用用法：
>>> list（hello）
[h， e， l， l， o]
>>> x=[1，1，1]
>>> x[1]=2 ＃可以改变列表为元素赋值
>>> x[2]=3
>>> x
[1， 2， 3]
>>> names=[james，jason，jzhou，liwear] ＃可以删除列表中的元素
>>> del names[3]
>>> names
[james， jason， jzhou]
>>> name=list（jzhou）
>>> name
[j， z， h， o， u]
>>> name[2:]=list（1314） ＃可以分片赋值
>>> name
[j， z， 1， 3， 1， 4]
>>> numbers=[1，5] ＃分片赋值可以在不须要调换任何元素的景象下插入新元素
>>> numbers[1:1]=[2，3，4]
>>> numbers
[1， 2， 3， 4， 5]
>>> numbers[1:4]=[] ＃也可以变相的删除元素
>>> numbers
[1， 5]
列表的办法首要有append， count，extend，index，，pop，remove，reverse，sort，简单用法如下：
>>> list=[1，2，3]
>>> list .append（4） ＃ append用于在列表末尾追加新对象
>>> list
[1， 2， 3， 4]
>>> [to，be，or，to].count（to） ＃count用于统计某个元素在列表中呈现的次数
2
>>> x=[[1，2]，1，1，[2，1，[1，2]]]
>>> x.count（1）
2
>>> x.count（[1，2]）
1
>>> a=[1，2，3]
>>> b=[4，5，6]
>>> a.extend（b） ＃extend在列表的末尾一次性追加另一个序列的多个值，扩大原有列表
>>> a
[1， 2， 3， 4， 5， 6] ＃重视这个操纵与连接操纵不合，extend批改了被扩大的序列即a，而连接只是姑且显示并没有变
>>> a=[1，2，3]
>>> b=[4，5，6]
>>> a[len（a）:]=b ＃也可以经由过程分片赋值来扩大，然则可读性不强
>>> a
[1， 2， 3， 4， 5， 6]
>>> sentence=[we，are，good，student]
>>> sentence.index （are） ＃index用于从列表中找出某个值第一个匹配项的索引地位
1
>>> numbers=[1，2，3，4，5，6，7]
>>> numbers.（3，four） ＃用于将对象插入列表中，和数据布局中的链表操纵很是类似
>>> numbers
[1， 2， 3， four， 4， 5， 6， 7]
>>> numbers=[1，2，3，4，5，6，7]
>>> numbers[3:3]=[four] ＃也可以应用分片赋值的办法实现，然则可读性不强
>>> numbers
[1， 2， 3， four， 4， 5， 6， 7]
>>> x=[1，2，3]
>>> x.pop（） ＃出栈操纵，和数据布局中的栈操纵一样，即移除列表中的最后一个，并且返回该元素的值
3
>>> x
[1， 2]
>>> x.pop（）
2
>>> x=[1，2，3]
>>> x.append（x.pop（）） ＃这个操纵和数据布局中的push、pop是一样的，追加方才出栈的值，很有趣，最后获得的还是是本来的值
>>> x
[1， 2， 3]
>>> x=[to，be，or，not，to，be]
>>> x.remove （be） ＃remove用于移除列表中某个值的第一个匹配项
>>> x ＃值得重视的是remove办法是没有返回值的原地位改变办法，重视和pop的差别
[to， or， not， to， be]
>>> x=[1，2，3]
>>> x.reverse （） ＃将列表中的元素反向存放，重视这种办法改变了列表但没有返回值
>>> x
[3， 2， 1]
>>> x=[4，5，6，7，1，2，3]
>>> x.sort（） ＃sort用于在原地位对列表进行排序，也改变了序列的值，然则没有返回值
>>> x
[1， 2， 3， 4， 5， 6， 7]
>>>
重视以上办法除了count和index，都是会使列表的内容的产生变更。
介于sort办法批改列表然则没有返回值的景象有待细说一下：
>>> x=[4，6，2，1，7，9]
>>> y=x.sort（） ＃因为x.sort（）不反回值，所以y并没有赋到值
>>> print y
None
>>>
看下正确的做法吧，其实也就是将步调拆开罢了：（sort函数不反回值的特点决意了不克不及在它的后面持续后续操纵，比如x.sort（）.reverse（），然则serted（x）.reverse（）是正确的）
>>> x=[4，6，2，1，7，9]
>>> y=x[:] ＃先将x复制给y
>>> y.sort（） ＃将y排序
>>> x
[4， 6， 2， 1， 7， 9]
>>> y
[1， 2， 4， 6， 7， 9]
>>> x=y>>> x
[1， 2， 4， 6， 7， 9]
>>> y
[1， 2， 4， 6， 7， 9]
另一种获取已排序的列表副本的办法是应用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） ＃默认按ASCII码排序
[P， h， n， o， t， y]
若是想把一些元素按相反的次序排出，可以先用sort或者sorted函数，在调用reverse函数。嵌套应用的功能很强大。
关于高等排序：元素能遵守特定的体式格式进行排序，可以应用compare（x，y）自定义斗劲函数，compare（x，y）函数会在x<y时返回负值，x>y时返回正值，x=y时返回0。定义好该函数之后，就可以供给给sort办法作为参数了。
>>> cmp（42，23）
1
>>> cmp（99，100）
-1
>>> cmp（1，1）
0
>>> numbers=[5，2，6，7]
>>> numbers.sort（cmp） ＃这个机制之后会介绍
>>> numbers
[2， 5， 6， 7]
元组——不成变序列
元组和列表一样，也是一种序列，独一的不合是元组不克不及批改，字符串也是如此；创建元素很简单，用逗号分隔一些值，就主动创建了元组：
>>> 1，2，3
（1， 2， 3）
>>> （1，2，3）
（1， 2， 3）
>>> （42，） ＃ 逗号申明它是一个元组，不然加括号（如：（42））也没用
（42，）
>>> 3（40+2） ＃这个例子说了然逗号的首要性，42和（42）是完全一样的
126
>>> 3（40+2，）
（42， 42， 42）
>>>
tuple函数：
tuple函数的功能与list函数根蒂根基一样：以一个序列作为参数把它转换为元组。若是参数是数组，那么该参数就会被原样返回：
>>> 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）
那么元组的存在意义是什么呢，起首元组可以在映射中当做键应用，而列表不可；其次，元组作为很多内建函数和办法的返回值存在。只要不涉及到批改元组，大项目组景象下和列表根蒂根基功能雷同。一般来说，列表可更能满足对序列的所有请求。
用到的函数总结：cmp（x，y）、len（seq）（返回序列长度）、list（seq）（把序列转换成列表）、max（args）、min（args）、reverse（seq）（对序列进行反向迭代）、sorted（seq）（返回已排序的包含seq所有元素的列表）、tuple（seq）（把序列转换成元组）
（转）
彼此相爱，却不要让爱成了束缚：不如让它成为涌动的大海，两岸乃是你们的灵魂。互斟满杯，却不要同饮一杯。相赠面包，却不要共食一个。一起歌舞欢喜，却依然各自独立，相互交心，却不是让对方收藏。因为唯有生命之手，方能收容你们的心。站在一起却不要过于靠近。—— 纪伯伦《先知》
