Регулярное выражение по группам

Question

существует файл, который имеет форму:

FY4A-_AGRI--_N_DISK_1047E_L1-_FDI-_MULT_NOM_20191025000000_20191025001459_4000M_V0001.HDF

Регулярное выражение имеет следующую форму

/^[A-Z]{2}[0-9]{1}[A-Z]{1}[-]{1}[_]{1}[A-Z]{4}[-]{2}[_]{1}[A-Z]{1}[_]{1}[A-Z]{4}[_]{1}[0-9]{4}[A-Z]{1}[_]{1}[A-Z]{1}[0-9]{1}[-]{1}[_]{1}[A-Z]{3}[-]{1}[_]{1}[A-Z]{4}[_]{1}[A-Z]{3}[_]{1}[0-9]{14}[_]{1}[0-9]{14}[_]{1}[0-9]{4}[A-Z]{1}[_]{1}[A-Z]{1}[0-9]{4}[.]{1}[A-Z]{3}$/

Как мне убедиться, что все было в группах?

Я бы хотел получить что-то подобное:

(?P<ftype>[A-Z0-9]{5})      # band type of data file
            _[a-z]+                     # sat id
            _(?P<date>\d{8})           # acq date
            _(?P<time>\d{7})           # granule start time UTC
            _\d+                       # granule end time UTC
            _(?P<orbit>\d+)            # orbit number
            _\d+                       # file creation date/time
            _\w+.h5      

Answer 1

Вы можете сделать это следующим образом, используя regex.

import re
s = 'FY4A-_AGRI--_N_DISK_1047E_L1-_FDI-_MULT_NOM_20191025000000_20191025001459_4000M_V0001.HDF'
re.findall(pattern, s)

Выход :

[('FY4A',
  'AGRI',
  'N',
  'DISK',
  '1047E',
  'L1',
  'FDI',
  'MULT',
  'NOM',
  '20191025000000',
  '20191025001459',
  '4000M',
  'V0001',
  'HDF')]

Где шаблон:

pattern = ["^([A-Z]{2}[0-9]{1}[A-Z]{1})", # FF0F
           "[-]{1}[_]{1}",                # -_
           "([A-Z]{4})",                  # FFFF
           "[-]{2}[_]{1}",                # --_
           "([A-Z]{1})",                  # F
           "[_]{1}",                      # _
           "([A-Z]{4})",                  # FFFF
           "[_]{1}", 
           "([0-9]{4}[A-Z]{1})", 
           "[_]{1}", 
           "([A-Z]{1}[0-9]{1})", 
           "[-]{1}[_]{1}", 
           "([A-Z]{3})", 
           "[-]{1}[_]{1}", 
           "([A-Z]{4})", 
           "[_]{1}", 
           "([A-Z]{3})", 
           "[_]{1}", 
           "([0-9]{14})", 
           "[_]{1}", 
           "([0-9]{14})", 
           "[_]{1}", 
           "([0-9]{4}[A-Z]{1})", 
           "[_]{1}", 
           "([A-Z]{1}[0-9]{4})", 
           "[.]{1}", 
           "([A-Z]{3})$"]

pattern = ''.join(pattern)

Answer 2

Я мог бы предложить здесь просто попробовать разделить регулярное выражение для набора разделителей, которые вы уже использовали для определения групп в вашем шаблоне:

inp = "FY4A-_AGRI--_N_DISK_1047E_L1-_FDI-_MULT_NOM_20191025000000_20191025001459_4000M_V0001.HDF"
parts = re.split(r'[_.-]+', inp)
print(parts)

Это печатает:

['FY4A', 'AGRI', 'N', 'DISK', '1047E', 'L1', 'FDI', 'MULT', 'NOM', '20191025000000',
 '20191025001459', '4000M', 'V0001', 'HDF']

Вы можете легко получить доступ к любой группе, которую хотите, используя обычный индекс списка Python. Обратите внимание, что этот подход более понятен и легче поддерживать, чем такое подробное регулярное выражение.

Answer 3

Результат идентичен предыдущим параметрам, но метод немного отличается:

import re

inp = "FY4A-_AGRI--_N_DISK_1047E_L1-_FDI-_MULT_NOM_20191025000000_20191025001459_4000M_V0001.HDF"

inp = re.sub(r'-', '', inp)

pattern = re.findall(r'''   
                        ^([A-Z]{2}\d[A-Z])         # Comment1
                        _([A-Z]{4})                # Comment2
                        _([A-Z])                   # ...
                        _([A-Z]{4}) 
                        _(\d{4}[A-Z])
                        _([A-Z]\d)                         
                        _([A-Z]{3})                        
                        _([A-Z]{4})                        
                        _([A-Z]{3})                        
                        _(\d{8})0{6}                       
                        _(\d{8})\d{6}                      
                        _(\d{4}[A-Z])                      
                        _([A-Z]\d{4})\.([A-Z]{3})$         
                        ''', inp, re.VERBOSE)

Это дает мне:

[('FY4A', 'AGRI', 'N', 'DISK', '1047E', 'L1', 'FDI', 'MULT', 'NOM', '20191025', '20191025', '4000M', 'V0001', 'HDF')]

Затем можно удалить некоторые группы, чтобы поймать только те части, которые выхотеть. Как я уже сказал, это не лучше, но это нарезать ваши регулярные выражения на маленькие кусочки, надеюсь, это поможет