проверка ввода с помощью регулярного выражения

Question

Проверка и классифицированный ввод с RE

здесь теперь используется ввод типа '1-1-AA' и каждая точка разбивается на '-' Но ввод может быть различным, например, "chr1-1- C - G "," 3-1- C -A "," CHRX-34-AT "и et c.

Какая первая позиция должна принимать" chr1, chr2, ... chr 23 , chrX, ChrY ", вторая позиция должна принимать только положительные числа, третья и четвертая должны принимать только одну букву из {A, C, G, T}

, так что я думаю об использовании '' 're .findall '' 'и используйте случаи ошибок, чтобы вернуть предупреждение о неправильном вводе. Но не уверен, как выдавать ошибки с помощью регулярного выражения.

может кто-нибудь помочь?

def _check_input(var_str):  # maybe better to check each input seperately
    """
    Checks if the input is a valid variant string
    :param var_str: string supposed to be in the format 'chr-pos-ref-alt'
    :return: bool which tells wether the input is valid
    """
    pattern = re.compile(
        r"""([1-9]|[1][0-9]|[2][0-2]|[XY])  # the chromosome
                        -(\d+)     # the position
                        -[ACGT]+   #RawDescriptionHelpFormatter,
                        -[ACGT]+  # alt""",
        re.X,
    )
    if re.fullmatch(pattern, var_str) is None:
        return False
    else:
        return True


def string_to_dict(inp):
    """
    Converts a variant string into a dictionary
    :param inp: string which should be a valid variant
    :return: dictionary with the variants keys and values
    """
    inp_list = inp.split("-")
    inp_dict = {
        "chr": inp_list[0],
        "pos": inp_list[1],
        "ref": inp_list[2],
        "alt": inp_list[3],
    }
    return inp_dict

Answer 1

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

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

import re


def _check_input(var_str):
    """
    Checks if the input is a valid variant string
    :param var_str: string supposed to be in the format 'chr-pos-ref-alt'
    :return: a match object
    :raises: ValueError on invalid input        
    """
    pattern = re.compile(
        r"(?:chr)?(?P<chr>[1-9]|[1][0-9]|[2][0-3]|[XY])"  # the chromosome
        r"-(?P<pos>\d+)"  # the position
        r"-(?P<ref>[ACGT])"  # RawDescriptionHelpFormatter
        r"-(?P<alt>[ACGT])",  # alt
        re.X | re.IGNORECASE,
    )
    match = re.match(pattern, var_str)

    if not match:
        _input_error_suggestion(var_str)

    return match # you can access values like so match['chr'], match['pos'], match['ref'], match['alt']

def _input_error_suggestion(var_str):
    parts = var_str.split('-')

    if len(parts) != 4:
        raise ValueError('Input should have 4 parts separated by -')

    chr, pos, nucleotide1, nucleotide2 = parts

    # check part 1
    chr_pattern = re.compile(r'(?:chr)?([1-9]|[1][0-9]|[2][0-3]|[XY])', re.IGNORECASE)
    if not re.match(chr_pattern, chr):
        raise ValueError('Input first part should be a chromosome chr1, chr2, ..., chr 23, chrX, chrY')

    # check part 2
    try:
        p = int(pos)
    except ValueError:
        raise ValueError('Input second part should be an integer')
    if p < 0:
        raise ValueError('Input second part should be a positive integer')

    # check part 3 and 4
    for i, n in enumerate((nucleotide1, nucleotide2)):
        if n not in 'ACGT':
            raise ValueError(f"Input part {3 + i} should be one of {{A,C,G,T}}")

    # something else
    raise ValueError(f"Input was malformed, it should be in the format 'chr-pos-ref-alt'")

примечания:

Я улучшил исходное регулярное выражение на

• добавление необязательного «chr»,
• группы имен,
• одна и только одна буква на нуклеотид,
• исправление отсутствующих хромосом 23 и
• позволяет не учитывать регистр.