11.python中的元组

　　在学习什么是元组之前，我们先来看看如何创建一个元组对象：

a = ('abc',123)
b = tuple(('def',456))
print a
print b

　　aaarticlea/png;base64,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" alt="" />

　　使用()或者 tuple() 函数创建，不过注意这里的传参还是要用()括起来的，所以一般不用函数的方式创建，函数的作用多在于强制转换数据类型（在内置函数中说明）。

　　另外，当元组只有一个元素的时候：

　　aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAH8AAAAqCAIAAAAVnBMAAAABX0lEQVRoge2ZWxaDIAwF2XWXT3/6sBLJ5RFi6J3jh6UoOCDkxJQBUkqVn4uptN7dseOFs54OuU+tRnqjFi7Drksuz+U5i0ls+ytXCQu+rT6kHuCF6ymViSXgSuUyAD9NxhoA0elVhc/51Qbrbz/HGQBRFmIfrL+GIdfIACCxRCpAbgsW4vVvYT/PGwC7V7vJ/tV+AF5uh/ncz8D0N537+Avhb99C/elkCqBodcXDK1tgG/OYBhWq60gxj1G007qkNN1ZbEhtWuyMs/2IzFLmoj5Htx8d2veE9j0JnGXbgMBZtg2ImmXbg1tk2f6WqFm2PbhFlu1viZpl24PAWbYNCJxl2wDq8IT2PaF9T2jfk/LjXFEjvQ61kLRy+romWC7PxULSgTL3VdG0P4K+8tT/ov0RUPtX+wEZAbLf+kIQECjmqV1P+wP07LqMeWYhRJwnucejUpN0QH+e0L4ntO/JE84NzKTV3k5gAAAAAElFTkSuQmCC" alt="" />

　　这样写是不行的，因为函数的传参也是用()，所以解释器不知道你是要传参还是创建元组。

　　所以创建元组的时候尤其是只有一个元素的元祖的时候一定要加逗号。

　　aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAJcAAAArCAIAAAD69Y0gAAABiElEQVR4nO2ZWw7DIAwEuXXPktOmH5Wqqhj84BFYdtSPyrIgYoQhTrqu6yabk2gRAByLKaVNB29HtviSHtoenE++ymLkgxo0TrEOxb24l0jRTSnh+18MGqdYilpF3UWkuL4Wi+oggZxHUM7FviIt5StlWIY1BmP5rpxH0G83vUS6ypcLl5XSeRmeaAWm7sXbsB2H7kXvBg3kPMLUc1G8VrRjFKZW8thEKzDvjjquoooDhu+opQKwrMJ78vuit1S6RhYnUqcWHwbE4o70WuXtFN5IFk+GFhGgRQRAuuGHA9INPxyEbjhZrhtOAiB0w8ly3XASAKEbTkC64YcD0g0/HPZuEKBFBGgRAd3i0POLh2MXFIv5KouRz08NGqcgXnwWRVv5fzFonIIEqFkU19diUR0kkEMqtFpsyXflkArdLJbOS9ND0GIbfSx6N2ggh1ToYLHugBYn0PqmYb+jlgosFbYTedP4k/T7q2Tmo1WCxMW83g0VjoN9VARmWOTXxNHQIgIzvvXT4mjem7EJ+TmwGyoAAAAASUVORK5CYII=" alt="" />

---

　  接下来我们开始学习元组的内置方法。

　　按照我之前惯用的学习方法，首先还是先来 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个部分要讲了，下面看分析。

---

1.元组中大于、小于、等于等比较运算符

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

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

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMQAAAA0CAIAAABaVgAlAAADAUlEQVR4nO2aYXLtIAiF3XX31E3aH23vzRVEMEgwOd+8eZNQNMScImpL3Z9Syt/Fdynf5dpgGsJCeg3ChbQRfHEx6Y3xNIPo/uV+1cB2q3yWKSSqifKPxqh/0ApOSSeDno4juC4HTPdsVZKgj3cC5ow1p5jqPnoKG76w2VMjJqV/PN1n++qJTcs9H43zq8nQpx6mqqMmZCPtge2w9yBNVHyo/TfaWEzVT0/rUrFKcJ9asRrZ26HP/LTYeaNeLaVsHkNQZqqK5LQ6MzUW1q3noC/ATyYnTfoRfpRRTCuU1Fy4YOptmDnOi4lNciasySa7mNYpqS5422GHCac5Ie/eajW3aB1nnb9MPQ8cuEL7aJeNx+ZH2Q2L+qGeWGMzPr1xY0cynZh25PJBtLIi4AyDcH0E4DZATMCNO4jpXZmGnao+6fhWz/IC3L3ipv1/3Cq+8ZwUaK1ta64oqys3XBvpKXprwJ2Pj6T+wHN55cw2kmYNP1z8Jydi03LdcEz3fFJM5oZkYc/6CM3nnhtMN0pHPSl3mApB7rYaj1OGp7w9u3LrSA6yN81RN/pS24up4qC3b5wIsjcIx6mNnebobVqCMhN7Td0WZaZKktNQN/SnPQdlhGfqpL3FtK5mis9MlZNLpJjor0cvM1Eje5uW6NWc+7gMOwyb5uRsqpnmhs7JaQNdcdBrmrmsKMumpoieO/2dO76thxEQLIJx+IJJ2CZQgSTDfdWvSh52ihUkB2ICbkBMwI2IAtwQDbf5u1fd8GQitgZsAW17mAAiNi2t7Ls2fjgRxym1s4Mi+9O2UFVypM9z7UGv5pwBpCIoM1VjcrrB2cIDCaqZhofnrDO9hZgyk+6gV17NQUyZCdpnYv8Sg3WT2+qfCOLB5wFuQEzADYgJuAExATfo0unjHwB6GDE1/wOgpPc3y8FhgDugEtNryqMXzXWtmCKfizYzUX00AhKM4CEYxCRYmiyF5PRM/MUEHouDmJr6SWgC7g17sNqtqYeFOdscPAR8c+AGxATcgJiAGz8Nygj55X/ZqgAAAABJRU5ErkJggg==" alt="" />

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

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAOkAAAA1CAIAAAArqVvgAAADUElEQVR4nO2aW3LlIAxE2XX2lE0yH8ncYBB6YCTA7lNTKUeRsYAeWWBSfgQppd+L75S+09pgKsJC+gzCSyB6+0UNgd4YTzVn04XyIz6yWeWzTCG1Ekz/0Rj1DzoduqtnybecML8MN9yyVbiMHP9eL5QxQ7s/nCLfsNkKK0U02lX6Pxuun3PlS77jej4a588tok8u3vulBHlj2wLZYO9BmqjoUPs9gnZLhH7Okq/fe02l76s0rUbyV9FnvMbo9KhXBytvfx5xeTcrUq933q0spFvPQb9Wu5l6NcmV+RO06yLc6mIKptbEvHhfu2QKN2FNpdDuBT/hZofBFRvcsGZg3irYZ1ByS6OmHQZrMWBqWXCg1mSlnTeWt5cqF9d/onxJYzU+vXEjR/Lt2j2R4+bMI+DjBuEm7+oteBLQLjiVh2j3bxETdvBl6aGftd3cpDiJWKtNX5y17V9+VUzq2Ny3yzLb7YoVWFYPV9w3anKDZQP5Ltgjm85FE+oZHZv7O9u3ms0s5S74WuHmnbWbHQ4zmMLSM9zyTe2ab2x2uEifscaXsDxa7vET5avc2U0NfLPZ+E1YPIjTsyu3bPkgezVD6zYmC/0+tGnHmu/UQoTH4yxOzzgQZG8QyjpBWTPQT5nUNWUft9bu3LxLXrduTnk3N6lXP203tSvKkXSYWwvdNNIP2la7fvVufN7NlDojtdv+b+zl3dZoftzLtYuzOKKxFwn/VuGvxUJCJKxsWC7cTGrX4yyOqQywoix5q4WIuFbjb7cGQ67M2gHpGcUO9oJ0Wqttqt0T2WEos08Ym3StZJOQtggCgAGgXXAq0C44laC1miGgPc73gP0J2iMzoZfv9EeDgwj6NmFl7hc18EiCvgnnzs4l769sECJ+J8Ksrz2Lw3u6fqsD+xOXd7Mx9Wryrt4ZPI+4elc8TkU6K32g3Rey41mcgcQM7b6QuP1d8igg6TbQoD4M8Bgw6+BUoF1wKtAuOBVoF5wKod2ULv8A2BNau9VPADaE2auKDAMAM1rtfuqH9qK6zhn1BojAkHdbOVZ6ZYwATMemXcZS5WCkXuCNi3YBCGCOdqval7kFgFnQ4mrf+L0ygFm6QbjAFegLnAq0C07FXbs4XwucgHbBqfwD/k942mkz69kAAAAASUVORK5CYII=" alt="" />

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

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

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

　　但如果是这样的情况：

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAN4AAAA4CAIAAAAdGNF/AAAC20lEQVR4nO2aaZLEIAiFufXcaS7J/JheEoOKUSLo+6prKs3glrzGJRCDxSCa3YMxLDIM8ILo9YnPCmMASxJVmvQODPRL9OtrFI91iZaIjjmImX+kEeqNz5M8kuE6+NeWWK2yraYuXRVGbzRGfUOxeA0sljqPz8MuPt2uuVWXBbV9JwfJyDtIk+Oo87GH8dg6QSNNpf9KnEY1Vp3iBJTz0Th/ilR9+DApHxVWNl5rECvMNaTpldzV/IggzS+j1Gk36ajke1Zeq1H8WvW5vwDIjCi3BlUWj45h1GRF4LSOmolFdMs56LdBnYFTExoL/1pfmha6TC6G0FRbNar1S1MMwE20BsK9pGmnSza4d9UKHU7ohTkBO3QRYrO9eetM3VRzxUHa7hztZeOx+FHE1a1VVZ2iMbk/ufsm3snFpRmRcI/EosPhbkITK48NhAbSBE6JKs3v/mDj9A5967LR93rAZBs0fN9zrf/0deP0Dn3rstGxOp84PBrOad+6d3qHsvVclwJIkw1eoPd0a0rNaUNB0jvGtu6HU7cGqlN5okkX6j1GeseG0mSkd2Qq0fjMSu/oJIY0x0ZN8frqZho1E4volnOIkt7RSQBp2q01J97KHdI7OvEuTaR38C1pzk3v6J/f3eqSjc41Wb0NuodGmkjv0OBdmhHxfE9FpvxETYtb47pzYGcgTeAUSBM4xWQb1LT7cb7iAbN44vBorDPYhCeO3FX9gDrBGcMXla3nmsq3lEZnpcAb6TOem96hf0EHdS7P5PSOXJGyGwLnDnhJ72iVL6S5PC7SO26EVUhzeeand7QeM5kmjgA/4OkCp0CawCmQJnAKpAmcQsxMdPoA4IGXNJO/AEzneFI4sRsApGSl+ZncrxfJNTMWA2A8pah5VVsix4IRgE4q0ixYkgiKwAnGMkaaAAznpjSTdWehCAD3+OSYZXc21e2RWByATqAm4BRIEzgF0gROgTSBU/4AHgMOYULl/ZsAAAAASUVORK5CYII=" alt="" />

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

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAJoAAAAbCAIAAAALcQE9AAABH0lEQVRoge2aYQ7DIAhGufWusXP0kuzHFjMRHS1WA/teTEOMrY0vonYjBomg2zs4iA7Zi1oJ/FRj+iBliO2V3T40c0adZOvoSc93EfG/IQdrulGPy0/jM0ZLbH9+JlzyTs1RDxaj0Mm9tTOi0ZJpudYpcq/IyeIJ0bN0d4zCGVV1Cq8laBuoLcORfHb2dKqV32Xeiy8l1dpZgms6p7zqXm7f2fqx72xL4NQZV+2Kc6eHC+dONmyF1BNq9EzLC74KgZVAZyqgMxXQmYpKJ1FVQDikTnEFsdB+7oDIsPzWWRJvG4iYGYl6M6bZ2RoSCgeVYCVWnYMaMVMxQTcyWSfYi1enWEcHt4AFNP+xa1JlL38OdkZwuQsMfCqgMxXQmYoXt20H16WjiO8AAAAASUVORK5CYII=" alt="" />

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

---

2.普通的内置方法2个

　　2.1  T.count(value) -> integer

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

　　　　aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAUEAAABDCAIAAACN0yDZAAAD+UlEQVR4nO2dW3brIAxFPes7p06Sfty2cbAQwiCwyN6rH44ixCMco+DGPhIAROZY3QAA6AINA8QmtoaP46f9x9dxfD2rLw9sUifTejSvomOHD+jVh39Sf+zG+WQfwPBP/f9MEsMa62pq0nU+Hb9UjdNi+kkrG+ppQ7eBjN86EEvG59F3nVsTCupz65VuSMZpMb3Xxr/4M4duNw2nODKeNvTT8mHLRFT8p8X04/7psq+b0WXcpViLjC152nHBErbqk075cJanKcZrBDFgqSJLq+Smlns0SsNDYgqlzOOpG0dpuPrW/hpO42Tsl7S0fnkT8zTdKL6s+gyfiKUve6ti5gVrY3h75Bva0NfNDTU8PJ2urq7e63BmEd1KDvY9LY/FpHWFmRAzL/JUDdu7uZuGPQScHQyhKVp1ovRr+N5+zFuExvXhnob7Ywql1BPlEg03dXMrDfsJODmMVDXgA3NpJcuwbMyUjDNj5lWYz4mdGvbo5rVsRF4dcNqRbk2SmyJXHAqbJUbjufh5zlX3yapzUTRm41MaN3Ekp8WUe9QxyOmRQxeL2B0I9wF4NHhtzCHJsKmiIEM3nx36AGvpv64GPTDuALH5aA2PSqX2SMkgKO57Wo/lKjzRIu6CbLk1AkHxvba0HEVaojJLDn/HolGvCMCVfOZtJuOStEpXKUovW/0BptGl2FG/ecg8lWt64vH1IItmSZtLRrs/GoYlyNNu/m8e7IlryVhNd0vV3XC2nxcAvHFfh5NtKa6K6oawS2Et1VUjXN9Cw7AE9+/DoswUt5JxiYab2oyGYQm++9LVvLfqqRgt+bNyBqlahpwsALx5zbxpv3ko5dViyq0YleCZuiyrbqmgYleiAUzjo2feKOEhYFgIkw8gNmgYIDZoGCA22cbMzx8AROG83ZrEYwB4MqV/gZjcDAC4CRoGiM31f5UQMEAkWIcBYoOGAWLDvjRAbLg+DBAb9AoQGzQMEBs0DBCbj9bw6+4c5scFiZ78fhgW4n4fj8eS34hDeqCmXFB84u4WYwIR8b2f1nIUab3dXsfwoHDFqFcE4Ir7fS3XUpKWRXKtD+NExrCELsVu9pyH3OfrSKnh4bpoGJYgT7vPfM5D7vOrW+t2FxqGFbivw8m2FFdvH3tD2KWwiv3N53cdrnraYwIMx/37sCgzxa1kXKJh+zUnY0yA4fjuS1fz3qqnYrTkz8oZpCq5plwaAcMq3K8PX/eWSnm1mHIrRiV4JuPqIi+8e1qELasxGoZVfPTMGyU8BAwLYfIBxAYNA8QGDQPEJtsr4j4eAME4798m8RgAngwaBogNGgaIDRoGiA0aBogNGgaIDRoGiA3XhwFig14BYoOGAWLzDUqxeJ419GvyAAAAAElFTkSuQmCC" alt="" />

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

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

　　　　aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAATEAAABTCAIAAAB4TKfaAAAESklEQVR4nO3c3ZajIBBFYd96Ht++cRKCUBQ/BaXsb/XFhEZA5QRjTzxO6B3H6hEMIu/Ia3bTlNlR4uirHcf1A1hOBmYY4AuZBHy5MvkvtQrrCwGM8g0YsQQ8+EkXsQSWi6M1NpbHf22DAzbUlUA5lmEUiSWgZLtOniyVQCXbz5OfKJJJQMnwvivXrkAD279PHr/ahghshZwAvpBJwBcyCfiSyOTnc5/DbyY5HNJa0w7I2iO/1UmP9zXa+eHHQvjembKv/iHdW0iOqv8rcnM6spuv0ajWHvl9Yill0vRkT94wbEE42eE1QmenczqynqnJcTY31XNANs3ktN1ee3w1M0Oo77AjO2OH1HlAHB4fCy2Z/FxaRMdUKLy3kGww19FYQoOmmbTrKNmU8nTIhaaZLP6KTKr2WX+9IbwL1p6AOTMj96bgv6Nc+8XrQKPr9uLAiuWat/K3al8nixt2ZjLsa8LMqH0Ld9VRrp1HZFJ/QMhkacuaDwNtmUzOkn61b8ADM2nUUbIpzXXH8kxWHZAdM3kqdtvhtWvtQtozWX12JPfb0LvcVPjbOQekOJI3aclk8npSWRhuHk1BZeXcqJT0veT2yFtHyt7bCp945J8usaOP2/lpA35KR9OWl6cckGfZaV93olni4BMnDfBl30yO+o4139XGWNd88vBk16rJ3fnggvu2yZJ7L7nC5pEAke9k8hDLKgMzKccs+aQvnjYEIz+T6VmxbE5CckNNJpX1gR7xTFryHPR7tc9L4erxXj9c0OQWkmMQhlcsJJMYpSuBY5+DLlxPylePcqHmo6MwwtznTOXmQC3bdfJUL5Wn7uoxVygsnsWOaguLowV62H6eFBYrofL9pX6djFroiZ88ZjIJI4b3XYU1rVhf2Ly2sC2B+o5yXQBtrsk07TnouQ9jyWr3fycr5+rcy8MekwMQhpSreW8N6LHvZBoVJAKJsZhPgC9kEvCFTAK+RPcqVg0DwCW8o0gmgfVYJwFfyCTgC5kEfCGTgC9kEvCFTAK+xH8LIZbAWkQQ8IVMAr6QScCXfTP5uO89Pm7AaGP7nIG6odQ/wWBgX8LTD4qFwgiVg9T3rmkNj2b4PB5rAzMpz/7wkSLK3vU19b1rmsIL2D63zlTzBE1uqEyFsvfaIOl7J5avF59gnoOu/JU+G2QSVboSyHPQi9o+T5LJndmuk2flTZHcy2L8hMWz2FFtYfFXVXWSNcnkzmw/TwqLlVD5/lK/TkYt9MRPHnNxj6rCQybxYXjfVVjTivWFzWsL2xJYu0oLrY3a99y+4GWuc8xz0KNqyV5yDWr2KFdTaFPTEd5n33M8an7r2+nskUBugtMM+EImAV/IJOBLePvh+gGw0OdGZVBELIF1yCTgS/LPZfOHAeBy/2P3kmEAuET/TWTVMABcfu67AliOezyAL99Mhj8AViF/gC9kEvDFJJPJrywC0CCTgC8mzxkgk0CzP8g0rDs4xNidAAAAAElFTkSuQmCC" alt="" />

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

　　　　aaarticlea/png;base64,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" alt="" />

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

---

　　好了，关于元组的内置方法就讲完了，这时候就会有同学说：教练，你怎么能这么短！

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

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

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

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

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

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

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