python处理一个文本文件

Question

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

迷茫 · Answer

Pour la première situation, vous pouvez vous référer aux méthodes suivantes :

Si vous utilisez Python3 ou supérieur :

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)

Laissez-moi vous expliquer un peu le code. L'objet fichier généré en utilisant open peut être directement utilisé comme itérateur. L'utilisation de for line in reader: est plus concise que l'utilisation de readlines.

De plus, number, ID, *items = line.split() sert au déballage. Il attribuera les chaînes coupées par line.split() au numéro (à la première chaîne coupée) et à l'ID (à la seconde), et enfin il attribuera l'autre Couper le chaîne dans une liste et affectez-la à items (la variable marquée d'un astérisque).

Cependant, cette utilisation peut ne pas être applicable à toutes les versions de Python, donc si vous utilisez Python2.7, vous pouvez adopter les méthodes suivantes :

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

L'idée decette approche est très simple. Définissez un indicateur flag pour déterminer si l'ID de la ligne doit être imprimé ou collecté. Deuxièmement, chaque ligne doit utiliser number et flag_number pour déterminer s'il faut activer ou désactiver flag.

Ce qui suit est le code pour Python3 Si nécessaire, vous pouvez modifier print l'utilisation de Python2. La différence ne devrait être qu'ici. (Désolé car je l'ai écrit rapidement, le code n'est peut-être pas assez affiné)

Considérant tous les scénarios, deux classes sont d'abord définies : IdCollect pour la collecte des identifiants et Action pour l'objectivation d'une opération :

*IdCollectcours

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 Classe :

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]])

La dernière est la méthode utilisée :

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()

Ce qui suit est un fichier de test que j'ai griffonné :

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

Le résultat ressemble à ceci :

...一些省略掉的收集過程...
-- 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