11.python中的元祖

　　按照我之前惯用的学习方法，首先还是先来 help(tuple) 看看其内置方法有哪些。

Help on class tuple in module __builtin__:

class tuple(object)
 |  tuple() -> empty tuple
 |  tuple(iterable) -> tuple initialized from iterable‘s items
 |
 |  If the argument is a tuple, the return value is the same object.
 |
 |  Methods defined here:
 |
 |  __add__(...)
 |      x.__add__(y) <==> x+y
 |
 |  __contains__(...)
 |      x.__contains__(y) <==> y in x
 |
 |  __eq__(...)
 |      x.__eq__(y) <==> x==y
 |
 |  __ge__(...)
 |      x.__ge__(y) <==> x>=y
 |
 |  __getattribute__(...)
 |      x.__getattribute__(‘name‘) <==> x.name
 |
 |  __getitem__(...)
 |      x.__getitem__(y) <==> x[y]
 |
 |  __getnewargs__(...)
 |
 |  __getslice__(...)
 |      x.__getslice__(i, j) <==> x[i:j]
 |
 |      Use of negative indices is not supported.
 |
 |  __gt__(...)
 |      x.__gt__(y) <==> x>y
 |
 |  __hash__(...)
 |      x.__hash__() <==> hash(x)
 |
 |  __iter__(...)
 |      x.__iter__() <==> iter(x)
 |
 |  __le__(...)
 |      x.__le__(y) <==> x<=y
 |
 |  __len__(...)
 |      x.__len__() <==> len(x)
 |
 |  __lt__(...)
 |      x.__lt__(y) <==> x<y
 |
 |  __mul__(...)
 |      x.__mul__(n) <==> x*n
 |
 |  __ne__(...)
 |      x.__ne__(y) <==> x!=y
 |
 |  __repr__(...)
 |      x.__repr__() <==> repr(x)
 |
 |  __rmul__(...)
 |      x.__rmul__(n) <==> n*x
 |
 |  count(...)
 |      T.count(value) -> integer -- return number of occurrences of value
 |
 |  index(...)
 |      T.index(value, [start, [stop]]) -> integer -- return first index of value.
 |      Raises ValueError if the value is not present.
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __new__ = <built-in method __new__ of type object>
 |      T.__new__(S, ...) -> a new object with type S, a subtype of T

tuple

　　可以看见元祖的内置方法好像有点少，总体可分为下面几种：

　　1.序列相关的操作，如索引，切片，加法，乘法，成员运算等。（这些都在我前一篇python的序列中博文中讲过了，这里不再重复）

　　2.内置函数相关（按照惯例，内置函数将另起一篇总结，这里暂时忽略）

　　3.大于、小于、等于等比较运算符

　　4.普通内置方法2个。

　　所以去除讲过的和暂时不讲的，就还要2个部分要讲了，下面看分析。

　　元祖之间的大小应该怎么比较呢？

　　其实很简单，总结起来就一句话，按照索引取出里面的元素逐一比较。

　　当 a 和 b 两个元祖比较的时候，首先都取出其第一个元素，这里第一个元素都是字符串，那么就按照字符串的比较方式，逐个字符比较。而 ‘s‘ 比 ‘a‘ 大，所以元祖 a 大于元祖 b 。也就是说，只要当其中一个元素大于另一个，那么整个元祖就比另一个大，这和元素的数量无关。

　　这里可以总结元祖比较的规则是：

　　　　元祖之间按照索引逐一取出相应位置的元素，让元素之间进行比较，如果取出的元素相等，则比较下一个元素，直到分出大小为止。如果比较完所以的元素还是相等，那么两个元祖相等。

　　其实元祖的比较就像比赛打擂台，双方各派出一名选手，如果某个选手赢了，那这个选手所在的队伍就获得了胜利，如果未分胜负则双方再派出下一个选手，如果双方到最后都没有分出胜负的话，就只能握手言和了。

　　但如果是这样的情况：

　　虽然前面是未分胜负，但是我多一个，就算这个是空字符串什么都好。这种情况就相当于和一个空对象 None 相比，而空对象 None 是最小的，和最小的相比肯定要大于它。

　　有些同学可能会疑惑如果元素的数据类型不同要怎么比较，例如字符串和数字怎么比较，这部分就要参照我在python的数字中关于比较运算符的总结了：戳这里

　　2.1  T.count(value) -> integer

　　　　返回 value 在元祖中出现的次数（计数器），如果没找到的话则返回0。

　　2.2 T.index(value, [start, [stop]])

　　　　返回 value 在元祖中的给定范围内的第一个索引，如果没找到则触发ValueError错误。

　　　　有多个时找到第一个，可以通过索引指定范围，索引超过了python也会优雅地处理掉。但指定范围并不意味着重新计算索引，索引还是从整个元祖的开头计算的。

　　　　没找到的报错，注意这里的 ‘123‘ 是字符串，别搞混了。

　　好吧，确实有点短，那我在这里就谈谈我个人对于元祖的理解吧。

　　首先，我在python的序列中已经证明了元祖中的每个元素都是一个对象了吧（没看的同学回去看），那么元祖是不是就类似于一个容器，容器里面放了一系列的对象。而当我们说元祖是不可变的，是不是就意味着这个容器的大小是固定的。但这个说法还不够完善，因为我可以在里面放各种对象，例如我放一个列表，而列表的大小是可以改变的。如果我不断地增大列表，而列表又放在了元祖这个容器里，是不是有一天列表会占满这个容器，这时候就不能在增大列表了？

　　肯定不是的，所以更形象的比喻应该是把元祖当成是一个菜单，这个菜单的页数是固定的。菜单里的每一道菜都有一个标号，也就是索引，但这个菜单比较特别，我不仅可以点菜，我还可以通过这个菜单去点另一个菜单，而得到另一个菜单再怎么添加页数也与原来的那个菜单无关。

　　这就是我个人对于元祖的理解。

　　好了，关于元祖就先说到这里，浓缩就是精华，就算短了点还不是干货满满。

　　这么好的文章，你怎么能不点个赞呢？

　　真是心累，明明感觉自己写得不错，结果博客里面一片冷清，再这样下去我可是要得五月病的，什么，已经到五月底了？