查找txt文件中第二列最大值

timespace

回复 20# hothat007
看你需要什么，只要简单变通下前面的例子就可以了吧，当然前提是看懂前面那个例子。

1. 取最早出现的那个最大数。利用已有的行序号，修改max的key参数

1. key=lambda e: (e[2], -e[0])

复制代码

2. 取最晚出现的那个最大数。开始的例子已经实现了。

3. 取所有的最大数。没有系统函数，那么自定义一个函数取代max，然后就会取出一个list，包含所有最大数

1. def my_max(iterable, key):
   
2.     maxs = [next(iterable)]
   
3.     for e in iterable:
   
4.         key_e, key_max = key(e), key(maxs[0])
   
5.         if key_e > key_max:
   
6.             maxs = [e]
   
7.         elif key_e == key_max:
   
8.             maxs.append(e)
   
9.     return maxs

复制代码

建议还是多看看标准库的前几章，包含很多基本的迭代排序和数据结构，足以应付很多问题了。



   

timespace

其实当查询条件越来越复杂时，直接编码就很麻烦，不如用DB处理这种关系型数据。

1. #!/usr/bin/env python
   
2. # -*- coding: utf-8 -*-
   
3. 
   
4. import itertools
   
5. import sqlite3
   
6. 
   
7. def getitems(fobj):
   
8.     for idx, line in enumerate(fobj):
   
9.         items = line.split()
   
10.         if len(items) != 2:
    
11.             continue
    
12.         # （行索引，一列浮点数，二列整数）
    
13.         yield idx, float(items[0]), int(items[1])
    
14. 
    
15. def main():
    
16.     # 内存数据库统计
    
17.     with open('tmp.txt') as fp, sqlite3.connect(':memory:') as con:
    
18.         con.executescript('''
    
19.             CREATE TABLE foo ( no, float, int );
    
20.             CREATE INDEX bar ON foo ( float, int );
    
21.         ''')
    
22.         con.executemany('INSERT INTO foo VALUES(?,?,?)', getitems(fp))
    
23.         for row in con.execute('SELECT no,float,int  FROM foo \
    
24.                 WHERE float >= 28.0 and float <= 29.0 \
    
25.                 ORDER BY int DESC LIMIT 10'):
    
26.             print row
    
27. 
    
28. if __name__ == '__main__':
    
29.     main()
    

复制代码

icymirror

回复 1# hothat007

1. 
   
2. def compareItem(item1, item2):
   
3.     ''' Function provide 2nd column comparing method for reduce to use.'''
   
4.     if int(item1.split()[1]) > int(item2.split()[1]):
   
5.         return item1
   
6.     else:
   
7.         return item2
   
8. 
   
9. def readRecords(filename):
   
10.     ''' read all data from file for coming reduce to filter.'''
    
11.     result = []
    
12.     file_handle = open(filename)
    
13.     for item in file_handle.readlines():
    
14.         result.append(item)
    
15.     return result
    
16. 
    
17. def main():
    
18.     data = readRecords('DYC-P072-2 2014-01-21 12.txt')
    
19.     print(reduce(compareItem, data))
    
20. 
    
21. if __name__ == '__main__':
    
22.     main()
    

复制代码

hothat007

回复 21# timespace


   

好像不太对呀，原来的那个代码是提取的第一个最大值呀

hothat007

回复 21# timespace


    key=lambda e: (e[2], -e[0])这句怎么理解呀，理解不了了T_T

timespace

回复 24# hothat007
嗯，你说对了。更正下：
1.取最早的最大数，开始已实现。

2.取最晚的最大数，修改max的key参数为

1. key=lambda e: (e[2], e[0])

复制代码

timespace

回复 25# hothat007
1. 理解max(..., key)执行的逻辑。顺序迭代，元素a和b比较等价于key(a)和key(b)比较，最终迭代完成时返回一个最大值。

1. lambda e: (e[2], e[0])

复制代码

等价于

1. def key(e):
   
2.     return e[2], e[0] # 返回的是一个tuple

复制代码

2. 理解tuple比较的逻辑。简单说就是当tuple第i个元素已经可以比较出大小时，就不会再去比较第i+1个元素。下面的例子就可以看出这个特性：

1. >>> max([(1, 1), (2, 2), (3, 2)], key=lambda e: e[1])
   
2. (2, 2)
   
3. >>> max([(1, 1), (2, 2), (3, 2)], key=lambda e: (e[1],e[0]))
   
4. (3, 2)
   
5. >>> max([(1, 1), (2, 2), (3, 2)], key=lambda e: (e[1],-e[0]))
   
6. (2, 2)
   
7. >>> max([(1, 1), (2, 2), (3, 2), (4, 0)], key=lambda e: (e[1],e[0]))
   
8. (3, 2)
   

复制代码

3. 你的需求中，元素出现早晚可以用行序号表示，所以将e[0]作为比较参数，但它是次要关系。

hothat007

回复 27# timespace


    感动哭了，太给力了！！