python处理一个文本文件

Question

这个文本文件核心有几种情况：1.序号 ID 操作者 操作行为 操作行为 操作对象6883 556773833 RemyMCMXI6880 556772838 Mindmatrix restored undeleted RemyMCMXI6882 556771715 RemyMCMXI6881 556770863 RemyMCMXI...

迷茫 · Answer

对于第一种情形，可以参考下列做法:

如果使用的是 Python3 以上的版本:

with open('G:\reserve9.txt', 'r') as reader:
    flag = False
    flag_number = None

    for line in reader:
        number, ID, *items =  line.split()

        if not flag and 'restored' in items:
            flag = True
            flag_number = number
        elif flag and number==flag_number:
            flag = False
            flag_number = None
        
        if flag:
            print(ID)

稍微解释一下代码，使用open产生的 file object 可以直接当作一个 iterator, 利用 for line in reader: 比起 readlines 会更简明。 open產生的 file object 可以直接當作一個 iterator, 利用 for line in reader: 比起 readlines 會更簡明。

另外 number, ID, *items = line.split() 是 unpacking 的用法, 他會將 line.split() 切割出來的字串分別配給 number(配到第一個切割字串) ID(配到第二個), 最後會把其他的切割字串集成一個 list 配給 items (打星號的那個變數)。

不過這個用法不一定適用所有的 Python 版本，所以如果你用的是 Python2.7，可以採行下列做法:

with open('reserve9.txt') as reader:
    flag = False
    flag_number = None

    for line in reader:
        items =  line.split()
        number = items[0]
        ID = items[1]

        if not flag and 'restored' in items:
            flag = True
            flag_number = number
        elif flag and number==flag_number:
            flag = False
            flag_number = None
        
        if flag:
            print ID

至於這種做法的思路很單純，設置一個 flag 標誌用來判斷該行的 ID 是否要被印出或收集。其次每一行都要用 number 和 flag_number 來判斷是否要開關 flag。

下面是Python3的代碼，如果有需要，可以自行將 print 改為 Python2 的用法，差別應該只有在這。(抱歉因為寫得很快，代碼可能不夠精緻)

考慮到所有情形，首先定義了兩個類: IdCollect 用來收集 ID 以及 Action 用來對象化一個操作:

*IdCollect 類

class IdCollect:

    def __init__(self):
        self.dic = {}
        self.outputs = []
        self.idx = 0
        self.newest_action = None

    def do_new_a_collect(self, action):
        if not self.dic.get(action.number, {}):
            if 'restored' in action.ops:
                return True
        return False

    def do_finish_a_collect(self, action):
        collect = self.dic.get(action.number, {})
        if collect:
            return True
        return False

    def handle(self, action):
        print('handle...', action)
        if self.do_new_a_collect(action):
            print('--- do collect new...')
            self.collect_new(action)
        elif self.do_finish_a_collect(action):
            print('--- do collect finish...')
            self.collect_finish(action)
        else:
            print('--- do collect...')
            self.collect(action)

    def collect(self, action):
        if self.newest_action:
            current_collect = self.dic[self.newest_action.number]
        else:
            print('do nothing')
            return

        # collect undeleted
        if not current_collect['undeleted_finish']:
            if action.user1==current_collect['undeleted_user']:
                print('------ collect undeleted')
                current_collect['undeleted_buffer'].append(action)
            else:
                print(action.user1, current_collect['undeleted_user'])
                print('------ finish undeleted')
                current_collect['undeleted_finish'] = True

        # collect restored
        print('------ collect restored')
        current_collect['restored_buffer'].append(action)

    def collect_new(self, action):
        undeleted_buffer = []
        undeleted_user = None
        restored_buffer = []

        if 'undeleted' in action.ops:
            undeleted_buffer.append(action)
            undeleted_user = action.user2
        restored_buffer.append(action)

        self.dic[action.number] = {
            'undeleted_buffer': undeleted_buffer,
            'undeleted_user': undeleted_user,
            'undeleted_finish': False,
            'restored_buffer': restored_buffer,
            'restored_finish': False,
            'idx': self.idx
        }
        self.idx += 1
        self.newest_action = action

    def collect_finish(self, action):
        collect = self.dic[action.number]
        collect['restored_finish'] = True
        self.outputs.append(collect)
        self.dic[action.number] = {}
        self.newest_action = None

    def output(self):
        for number, collect in self.dic.items():
            if collect:
                self.outputs.append(collect)

        self.outputs.sort(key=lambda collect: collect['idx'])

        for collect in self.outputs:
            if collect['restored_finish']:
                for action in collect['restored_buffer']:
                    print('r', action.ID)
            else:
                if collect['undeleted_buffer']:
                    for action in collect['undeleted_buffer']:
                        print('d', action.ID)

*Action

另外number, ID, *items = line.split() 是unpacking 的用法, 他会将line.split() 切割出来的字串分别配给number(配到第一个切割字串) ID(配到第二个), 最后会把其他的切割字串集成一个list 配给items (打星号的那个变数)。

不过这个用法不一定适用所有的 Python 版本，所以如果你用的是 Python2.7，可以采行下列做法:

class Action:

    def __init__(self, action_str):
        action_str = action_str.strip()
        items = action_str.split()
        self.number = items[0]
        self.ID = items[1]
        self.user1 = items[2]
        self.ops = items[3:]

        if len(self.ops) > 1:
            self.ops = self.ops[:-1]
            self.user2 = items[-1]
        else:
            self.user2 = ''

    def __str__(self):
        return ' '.join([str(item) for item in [self.number, self.ID, self.user1, self.ops, self.user2]])

至于这种做法的思路很单纯，设置一个 flag 标志用来判断该行的 ID 是否要被印出或收集。其次每一行都要用 number 和 flag_number 来判断是否要开关 flag。

下面是Python3的代码，如果有需要，可以自行将 print 改为 Python2 的用法，差别应该只有在这。 (抱歉因为写得很快，代码可能不够精致)🎜 🎜考虑到所有情形，首先定义了两个类: IdCollect 用来收集 ID 以及 Action 用来对象化一个操作:🎜 🎜*IdCollect 类🎜

with open('reserve9.txt') as reader:

    id_collect = IdCollect()

    for line in reader:
        action = Action(line)

        id_collect.handle(action)

    print('-- output --')
    id_collect.output()

🎜*Action 类:🎜

6883 556773833 RemyMCMX
6880 556772838 Mindmatrix restored undeleted RemyMCMXI
6882 556771715 RemyMCMXI
6881 556770863 RemyMCMXI
6880 556673938 Liua97
6879 554350969 Epicgenius
6880 554332653 Alex
13 82239 194.205.123.10 restored undeleted 62.30.0.4
14 64090 62.30.0.4
13 64041 Lee Daniel Crocker
12 61789 JeLuF
11 55828 Conversion script
10 294279 62.82.226.xxx
9 294278 Larry_Sanger
8 294277 Larry_Sanger
7 334555726 24.112.58.xxx
5 334555725 156.62.18.xxx restored undeleted 156.62.18.xxx
6 334555724 156.62.18.xxx
5 334555723 AxelBoldt
4 334555722 The Cunctator
3 334555721 The Cunctator
1 334555720 Alan D
2 334555718 64.38.175.xxx
1 334555717 The Cunctator
5 334555725 156.62.18.xxx restored undeleted 156.62.18.xxx
6 334555724 156.62.18.xxx
6 334555724 156.62.18.xxx
6 334555724 156.62.18.xxx
6 334555724 156.62.18.xxx
6 334555724 156.62.18.xxx
1 334555720 Alan D
1 334555720 Alan D
1 334555720 Alan D
1 334555720 Alan D
1 334555720 Alan D
1 334555720 Alan D
1 334555720 Alan D
13 82239 194.205.123.10 restored undeleted 62.30.0.4
13 64041 Lee Daniel Crocker

🎜最后是使用的方法:🎜

...一些省略掉的收集過程...
-- output --
r 556772838
r 556771715
r 556770863
r 82239
r 64090
r 334555725
r 334555724
d 334555725
d 334555724
d 334555724
d 334555724
d 334555724
d 334555724
r 82239

🎜 🎜以下是我乱写的一个测试文件:🎜 rrreee 🎜输出长这样:🎜 rrreee