Python学习笔记 - 9.元组(Tuple)

元组(tuple)是不可变得

元组用圆括号括起来,虽然这不是必需的,但可帮我们在Python代码中快速识别出哪些是元组。

    >>> t = ('a','b','c','d','e')

创建单个元素的元组,必须在末尾加一个逗号。

    >>> t1 = ('a',)
    >>> type(t1)
    <type 'tuple'>

否则,Python会将(’ a ‘)作为一个字符串处理:

    >>> t2 = ('a')
    >>> type(t2)
    <type 'str'>

构造元组的另一种方法是,使用内置函数tuple。如果不带参数,tuple函数会创建一个空元组:

    >>> t = tuple()
    >>> print t
    ()

如果参数是一个序列(字符串、列表或元组),tuple函数的调用结果是产生一个包含序列元素的元组:

    >>> t = tuple('lupins')
    >>> print t
    ('l','u','p','i','n','s')

大部分的列表操作符也适用于元组。方括号索引一个元素:

    >>> t = ('a','b','c','d','e')
    >>> print t[0]
    'a'

切片操作符选择一组元素。

    >>> print t[1:3]
    ('b','c')

不能修改元组的元素,但可以用另一个元组替换当前元组:

    >>> t = ('A',) + t[1:]
    >>> print t
    ('A','b','c','d','e')

元组的比较

比较运算符适用于元组和其它序列,Python从每个序列的第一个元素开始比较。如果它们相等,继续比较下一个元素,以此
类推,直到找到不同的元素。找到不同元素之后,随后的元素就不再考虑了 (即便它们真得很大)。

    >>> (0,1,2) < (0,3,4)
    True
    >>> (0,1,2000000) < (0,3,4)
    True

元组中sort函数正是这个工作原理。它首先对第一个元素排序,如果第一个元素相同,则按第二个元素排序,以此类推。
这一特性使其拥有一种DSU模式:
修饰(Decorate):修饰:在序列的元素之前放置一个或多个排序键,
排序(Sort):使用Python内置函数sort进行排序,
去修饰(Undecorate):提取出序列中已排序的元素。
举例来说,有一组单词,对它们进行由长到短的排序:

    txt = 'but soft what light in yonder window breaks'
    words = txt.split()
    t = list()
    for word in words:
    #创建元组（单词以及长度）
        t.append((len(word),word)) #在列表的末尾添加一个元素，只能是一个
    t.sort(reverse=True)
    res = list()
    for length, word in t:
        res.append(word)
    print res

第一个循环创建了一个元组,每个元组包括单词及长度,单词长度在前,单词在后。
sort函数进行两两比较,首先比较单词长度,如果长度相等,则比较元组中的第二个元素。**关键字参数reverse=True指定sort
函数按照倒序排列**。
第二个循环遍历了元组,创建了一个按照长度降序排列的单词列表。这五个单词按照反向字母顺序排序,所以“what”出现
在“soft”之前。
程序输出结果如下:

    ['yonder','window','breaks','light','what',
    'soft','but','in']

元组的赋值

在本例中,一个列表(序列)包含两个元素。使用一行语句,将第一个元素和第二个元素分别赋予变量x和变量y。

    >>> m = ['have','fun']
    >>> x,y = m
    >>> x
    'have'
    >>> y
    'fun'
    >>>

从文体上看,在赋值语句左侧使用元组,我们忽略了括号,以下是有效的等价语法:

m = [‘have’,’fun’ ]
(x, y) = m
x
‘have’
y
‘fun’

元组赋值有一个特别巧妙的用途,可以在一条语句中交换两个变量的值:

    >>> a,  b   =   b,  a

这条语句两侧都是元组,左侧是变量元组,右侧是表达式元组。右侧的每个值分别赋予左侧的每个变量。右侧的所有表达式
在赋值之前进行检查。
左侧的变量个数与右侧的值个数必须相同。

更普遍的情况是,右侧可以是任何类型的序列,如字符串、列表或元组。例如,将邮件地址拆分成用户名与域名的程序代码
如下:

    >>> addr = 'monty@python.org'
    >>> uname,domain = addr.split('@')

字典与元组

元组拥有items方法,该方法返回元组列表,每个元组是一个键值对。

    >>> d = {'a':10,'b':1,'c':22}
    >>> t = d.items()
    >>> print t
    [('a',10),('c',22),('b',1)]

如果是字典的话,其中的数据项是没有特定顺序的。
由于元组列表本身是一个列表,元组之间可以进行比较,以及对元组列表进行排序。将字典转化为元组列表,这样可以根据
键对字典进行排序,并输出字典的内容。

    >>> d = {'a':10,'b':1,'c':22}
    >>> t = d.items()
    >>> t
    [('a',10),('c',22), ('b',1)]
    >>> t.sort()
    >>> t
    [('a',10),('b',1),('c',22)]

新的列表根据键值以字母升序排列。

通过字典进行多个赋值

将items方法、元组赋值与for循环结合起来,你可以拥有一个良好的代码模式,使用单循环就可以遍历字典中的键与值。

    for key,val in d.items():
        print val,key

这个循环中存在两个迭代变量。由于items返回一个元组列表,变量key和val通过字典的键值对进行迭代,继而得到赋值。
循环中的每次迭代都会使得key和value被赋予下一个字典键值对(仍然以哈希顺序，也就是没有特定顺序)。

将两种方法结合,按照每个键值对中的值来排序,输出字典的内容。
要做到这一点,首先创建一个元组列表,其中每个元组为(value, key)。通过items方法得到(key, value)元组列表。此时,我们想要根据value排序,而不是key。(value, key)元组列表一旦生成,排序就变得简单了,按照反向次序对列表排序,输出已
排序的新列表。

    >>> d = {'a':10,'b':1,'c':22}
    >>> l = list()
    >>> for key,val in d.items():
    ...     l.append((val,key)  )
    ...
    >>> l
    [(10,'a'),(22,'c'),(1,'b')]
    >>> l.sort(reverse=True)
    >>> l
    [(22,'c'),(10,'a'),(1,'b')]
    >>>

创建元组列表时要非常谨慎,确保每个元组的第一个元素是值,这样就能对元组列表进行排序,获得所需的字典内容,该字
典已按值进行排序。

高频词汇（信息分析）

输出文本中出现次数最多的前十个单词,代码如下所示:

    import  string
    fhand = open('romeo-full.txt')
    counts = dict()
    for line in fhand:
        line = line.translate(None, string.punctuation)
        line = line.lower()
        words = line.split()
        for word in words:
            if  word not in counts:                                                     
                counts[word] = 1
            else:                                       
                counts[word] += 1
    #Sort the dictionary by value
    lst = list()
    for key,val in counts.items():
        lst.append( (val,   key)    )
    lst.sort(reverse=True)
    for key,val in lst[:10] :
        print key,val

简洁，高效。