读入后，要进行组内排序，按groupseq字段排序后，然后统计前后两个项的个数，累加到全局。

sorted函数使用如下：

def sortlist(alllist):

    sorted_key1_1=sorted(alllist,key=lambda k:k['groupseq'])

    return sorted_key1_1

keylist = readline()

for key in keylist:

       sortlist=(keylist[key])

全段代码如下

#!/usr/bin/python

# -*- coding: utf-8 -*-

#vim set ts=4 expandtab

import sys

keylist={}

def readline():

    global keylist

    filecontent= open('g:\\test.txt','r')

    for line in filecontent.xreadlines():

    #for line in sys.stdin:

        line.strip()

        items=line.split("\t")

        count=0

        appid = items[count]

        count= count+1

        app_version = items[count]

        count= count+1

        act_name=items[count]

        count=count+1

        groupkey=items[count]

        count=count+1

        ggg=items[count]

        groupseq=int(ggg)

        count=count+1

        act_dur=items[count]

        act_dur.strip()

        count=count+1

        key1 = "\t".join((appid,app_version,groupkey))

        value1={}

        value1['act_name']=act_name

        value1['groupseq']=groupseq

        value1['act_dur']=act_dur

        if not key1 in keylist:

            keylist[key1]=[]

        keylist[key1].append(value1)

        #it="\t".join((appid,app_version,groupkey,act_name,groupseq,act_dur))

        #print it.strip()

    #return keylist

def sortlist(alllist):

    sorted_key=sorted(alllist,key=lambda k:k['groupseq'])

    #print sorted_key

    #print type(sorted_key)

    return sorted_key

if __name__ == '__main__':

     countall={}

     duration={}

     readline()

     for keys in keylist.keys():

         sorted_list=sortlist(keylist[keys])

         #print sorted_list[0]

         length=len(sorted_list)

         #for value in sorted_list:

         prev_page=""

         for i in range(length):

             current_page = sorted_list[i]['act_name']

             if "unknown" == current_page:

                 prev_page = current_page  

                 #continue

             else:

                 num=sorted_list[i]['act_dur']

                 count_duration=float(num.strip())

                 allkeys=keys.split("\t")

                 keycount='\t'.join((allkeys[0],allkeys[1],prev_page,current_page))

                 if not keycount in countall:

                    countall[keycount]=0

                 countall[keycount]+=1

                 if not keycount in duration:

                    duration[keycount]=0

                 duration[keycount] += count_duration                   

                 if current_page == "exit":

                     break

                 prev_page = current_page

           

     for key_cou in countall:

         output="\t".join((key_cou,str(countall[key_cou]),str(duration[key_cou])))

         #output = "\t".join((key_cou,str(countall[key_cou])))    

         print output.strip()

这里的列表中，元素为字典。用key传函数，参数为x["key]，这里的x在运行时，会被赋成列表中每个字典对象

f = [{'name':'abc','age':20},{'name':'def','age':30},{'name':'ghi','age':25}]

def age(s):

    return s['age']

print sorted(f,key = age)#列表按f中字典的age从小到大排序。也就是说，传给s的是每个字典对象，s是一个字典形参，调用s["key"]，则按key排序每个子元素。

也可以：print sorted(f,key = lambda x:x["name"])。#lambda见下面解释使用时，相当于调用key（x）这个函数，其中x被赋值为传入的对象，在这里是每个子对象字典。返回值为x[0]，而正是按这个返回值排序。

结果如下：

[{'age': 20, 'name': 'abc'}, {'age': 25, 'name': 'ghi'}, {'age': 30, 'name': 'def'}]

lambda这个匿名函数，使用如下：

m = lambda x,y,z: (x-y)*z#x是参数，函数名是标示符m

print m(3,1,2)#使用时，标示符m作为参数名，,x,y,z作为参数传入。

结果是4

总结，m为函数名，xyz为形参，表达式为返回值

而字典排序：

sl={'b':2,'a':1,'d':4,'c':3}

print sorted(sl,key=lambda x:x[0])#等同于：print sorted(sl,key=lambda x:x

['a', 'b', 'c', 'd']，注意如果是x[1]就报错了。

python对容器内数据的排序有两种，一种是容器自己的sort函数，一种是内建的sorted函数。

不同在于sort是在原位重新排列列表，而sorted()是产生一个新的列表：

--------------------------------sorted---------------------------------------

>>> help(sorted)

Help on built-in function sorted in module __builtin__:

sorted(...)

sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list

---------------------------------sort----------------------------------------

>>> help(list.sort)

Help on method_descriptor:

sort(...)

L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;

-----------------------------------------------------------------------------

>>> print sorted([5, 2, 3, 1, 4])

[1, 2, 3, 4, 5]

>>> L = [5, 2, 3, 1, 4]

>>> L.sort()

>>> print L

[1, 2, 3, 4, 5]

def lastchar(s): 

            return s[-1]

e = ['abc','b','AAz','ef']

sorted(e,key = lastchar) #自定义函数排序,lastchar为函数名，这个函数返回列表e中每个元素的最后一个字母

['b', 'abc', 'ef', 'AAz'] #sorted(e,key=lastchar)作用就是 按列表e中每个元素的最后一个字母的ascii码从小到大排序

sorted(...)

sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list

iterable：是可迭代类型;

cmp：是带两个参数的比较函数，比较内容由另一个参数key决定，返回值: 负数: e1 < e2， 0: e1 == e2， 正数: e1 > e2. 默认为 None, 即内建的比较函数.

key：是带一个参数的函数, 用来为每个元素提取比较值. 默认为 None, 即直接比较每个元素.

reverse：排序规则. reverse = True 或者 reverse = False，有默认值。

返回值：是一个排序的可迭代类型，与iterable一样。

通常, key 和 reverse 比 cmp 快很多, 因为对每个元素它们只处理一次; 而 cmp 会处理多次

对由字典排序

引自：http://www.cnblogs.com/linyawen/archive/2012/03/15/2398292.html

Python的内置dictionary数据类型是无序的，通过key来获取对应的value。可是有时我们需要对dictionary中 的item进行排序输出，可能根据key，也可能根据value来排。

list的排序，使用如下

使用cmp:

>>>L = [('b',2),('a',1),('c',3),('d',4)]

>>>print sorted(L, cmp=lambda x,y:cmp(x[1],y[1]))

[('a', 1), ('b', 2), ('c', 3), ('d', 4)]

使用keys:

>>>L = [('b',2),('a',1),('c',3),('d',4)]

>>>print sorted(L, key=lambda x:x[1]))

[('a', 1), ('b', 2), ('c', 3), ('d', 4)]

reverse是决定正序还是倒序的：

>>> print sorted([5, 2, 3, 1, 4], reverse=True)

[5, 4, 3, 2, 1]

>>> print sorted([5, 2, 3, 1, 4], reverse=False)

[1, 2, 3, 4, 5]

注：效率key>cmp(key比cmp快)

在Sorting Keys中：我们看到，此时排序过的L是仅仅按照第二个关键字来排的，如果我们想用第二个关键字

排过序后再用第一个关键字进行排序呢?

>>> L = [('d',2),('a',4),('b',3),('c',2)]

>>> print sorted(L, key=lambda x:(x[1],x[0]))

>>>[('c', 2), ('d', 2), ('b', 3), ('a', 4)]

用 operator 函数来加快速度, 上面排序等价于:(itemgetter的用法见 注释2)

>>> from operator import itemgetter, attrgetter

>>> sorted(students, key=itemgetter(2))

用 operator 函数进行多级排序

>>> sorted(students, key=itemgetter(1,2))  # sort by grade then by age

[('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)]