Python regex individual negative lookaheads for different letters

I'm writing a program to find words that you can write on a calculator. I've set up regex so that it'll find words that contain 'bad' letters, so we can eliminate them.

Here's the search pattern:

badLetters = "[ghjknpqrtuvwzGHJKNPQRTUVWZ]"

Those letters can't be written on my calculator

However, buttons like 'sin' and 'cos' exist. That means that I want to return a match for t only if it is not immediately followed by 'an'

My first try looked like this:

badLetters = "[ghjknpqrt(?!an)uvwzGHJKNPQRT(?!an)UVWZ]"

But this doesn't work. I think it's treating the (?!an) as more bad characters, rather than applying the negative lookahead.

So I tried giving the 't' and 'T' their own square bracket for the condition to be applied to.

badLetters = "[ghjknpqruvwzGHJKNPQRUVWZ][tT](?!an)"

That's not working either.

How can I implement several different letters with different conditions for each in regex? Putting them in the main square bracket doesn't work, and neither does giving them their own square brackets.

And then obviously after this I'm going to expand it to allow 'n' only if it's preceeded by 'ta', or 'si' and such.

Thanks!

I believe using the | symbol (meaning 'or') in your regex will help.

With the regex [ghjknpqruvwzGHJKNPQRUVWZ][tT](?!an), you're looking for a 'bad letter' followed by a 't' that does no precede 'an', whereas [ghjknpqruvwzGHJKNPQRUVWZ]|(?:[tT](?!an)) looks for a 'bad letter' or a 't' that does no precede 'an'. You can then build on top of this as you suggest.

A tool like Regex101 may help with understanding and forming new regex searches.

Use verbose mode for complicated patterns, so you can use white space to break out and comment the pieces of the regex pattern. The re.IGNORECASE flag may make things simpler too.

Trying to come up with a regex that finds all "bad" letters may be difficult. For example, it would be harder to write a rule for 't' is bad unless it is part of 'tan' or 'sqrt'.

It may be easier to create a regex for acceptable letters. For example, the words on the calculator can be listed explicitly, and the individual "good" letters can be added as a group. Generally, put longer alternatives (e.g. words) before shorter words or letters. So it may look something like this:

good_letters = """
    ( sqrt | tan | sin | cos | log   # words on my calculator
    | exp | ln
    | [abcdefilmosuvwz]              # letters that can be displayed
    )+
"""

regex = re.compile(good_letters, re.VERBOSE | re.IGNORECASE)

regex.fullmatch(test_string)