How can I replace part of a string with a pattern

What you're looking to do can be accomplished by using regex, or more commonly known as, Regular Expressions. Regular Expressions in programming enables you to extract what you want and just what you want from a string. In your case, you want to match the string with the pattern abba so using the following regex:

(\w+)(\w+)\2\1

https://regex101.com/r/hP8lA3/1

You can match two word groups and use backreferences to make sure that the second group comes first, then the first group.

So implementing this in python code looks like this:

First, import the regex module in python

import re

Then, declare your variable

text = "abbacdeffel"

The re.finditer returns an iterable so you can iterate through all the groups

matches = re.finditer(r"(\w)(\w)\2\1", text)

Go through all the matches that the regexp found and replace the pattern with "1234"

for match in matches:
  text = text.replace(match.group(0), "1234")

For debugging:

print(text)

Complete Code:

import re

text = "abbacdeffel"

matches = re.finditer(r"(\w)(\w)\2\1", text)

for match in matches:
    text = text.replace(match.group(0), "1234")

print(text)

You can learn more about Regular Expressions here: https://regexone.com/references/python

New version of code (there was a bug):

def replace_with_pattern(pattern, line, replace):
    from collections import OrderedDict
    set_of_chars_in_pattern = set(pattern)

    indice_start_pattern = 0
    output_line = ""
    while indice_start_pattern < len(line):
        potential_end_pattern = indice_start_pattern + len(pattern)
        subline               = line[indice_start_pattern:potential_end_pattern] 
        print(subline)
        set_of_chars_in_subline = set(subline)
        if len(set_of_chars_in_subline)!= len(set_of_chars_in_pattern):
            output_line += line[indice_start_pattern]
            indice_start_pattern +=1
            continue

        map_of_chars = OrderedDict()
        liste_of_chars_in_pattern = []
        for char in pattern:
            if char not in liste_of_chars_in_pattern:
                liste_of_chars_in_pattern.append(char)
        print(liste_of_chars_in_pattern)

        for subline_char in subline:
            if subline_char not in map_of_chars.values():
                map_of_chars[liste_of_chars_in_pattern.pop(0)] =subline_char 

        print(map_of_chars)
        wanted_subline = ""
        for char_of_pattern in pattern:
            wanted_subline += map_of_chars[char_of_pattern]
        print("wanted_subline =" + wanted_subline)
        if subline == wanted_subline:
            output_line += replace
            indice_start_pattern += len(pattern)
        else:
            output_line += line[indice_start_pattern]
            indice_start_pattern += 1
    return output_line

some test :

test1 = replace_with_pattern("xyyx", "abbacdeffel", "1234")
test2 = replace_with_pattern("abbacdeffel", "abbacdeffel", "1234")
print(test1, test2)

=> 1234cd1234l 1234

Here goes my attempt:

([a-zA-Z])(?!\1)([a-zA-Z])\2\1

Assuming you want to match letters only (if other ranges, change both [a-zA-Z] as appropriate, we have:

([a-zA-Z])

Find the first character, and note it so we can later refer to it with \1.

(?!\1)

Check to see if the next character is not the same as the first, but without advancing the search pointer. This is to prevent aaaa being accepted. If aaaa is OK, just remove this subexpression.

([a-zA-Z])

Find the second character, and note it so we can later refer to it with \2.

\2\1

Now find the second again, then the first again, so we match the full abba pattern.

And finally, to do a replace operation, the full command would be:

import re
re.sub(r'([a-zA-Z])(?!\1)([a-zA-Z])\2\1',
       '1234',
       'abbacdeffelzzzz')

The r at the start of the regex pattern is to prevent Python processing the backslashes. Without it, you would need to do:

import re
re.sub('([a-zA-Z])(?!\\1)([a-zA-Z])\\2\\1',
       '1234',
       'abbacdeffelzzzz')

Now, I see the spec has expanded to a user-defined pattern; here is some code that will build that pattern:

import re

def make_re(pattern, charset):
    result = ''
    seen = []
    for c in pattern:
        # Is this a letter we've seen before?
        if c in seen:
            # Yes, so we want to match the captured pattern
            result += '\\' + str(seen.index(c)+1)
        else:
            # No, so match a new character from the charset,
            # but first exclude already matched characters
            for i in xrange(len(seen)):
                result += '(?!\\' + str(i + 1) + ')'
            result += '(' + charset + ')'
            # Note we have seen this letter
            seen.append(c)
    return result

print re.sub(make_re('xzzx', '\\d'), 'abba', 'abba1221b99999889')
print re.sub(make_re('xyzxyz', '[a-z]'), '123123', 'abcabc zyxzyyx zyzzyz')

Outputs:

abbaabbab9999abba
123123 zyxzyyx zyzzyz