Regex pattern that does not match certain extensions?

Question

I have this pattern written

^.*\.(?!jpg$|png$).+$

However there is a problem - this pattern matches file.name.jpg (2 dots)

It works correctly (does not match) on filename.jpg. I am trying to figure out how to make it not match ANY .jpg files even if the file's name has 2 or more dots in it. I tried using a look behind but python complains about not using a fixed width (which I'm not exactly sure what that means, but the file name will be variable length.)

Solution 1

This should work: ^.*\.(?!jpg$|png$)[^.]+$

Solution 2

Use os.path's nifty functions to properly split up the filepath into components for easier parsing:

filepath, filename = os.path.split(str)
basename, extension = os.path.splitext(filename)

if exension[1:] in ['jpg', 'png']:
  # The extension matches

---

Try this regex (don't do it. It does the exact opposite of what you want to do):

\.(jpg|png)([^\.]|$)

Solution 3

If you only care that the string doesn't end with .jpg or .png, you can use this:

^.+$(?<!\.jpg)(?<!\.png)

The ^.+ isn't strictly necessary, but depending on how the JSON parser is coded you might need to force the regex to consume the whole string. If you're using the regex for other validations as well, you might want something more elaborate, like:

^\w+(?:\.\w+)+$(?<!\.jpg)(?<!\.png)

You probably tried to use (?<!\.jpg|\.png), which wouldn't work because Python's regex flavor is one of the most restrictive when it comes to lookbehinds. PHP and Ruby 1.9+ would accept it because each of the alternatives has a fixed length. They don't even have to be the same length; (?<!\.jpg|\.jpeg|\.png) would work, too. Just don't try to factor out the dot, as in (?<!\.(?:jpg|jpeg|png)); the alternation has to be at the top level of the lookbehind.

Java would accept the factored-out version because it does a little more work at compile time to determine the maximum number of characters the lookbehind might need to match. The lookbehind expression needs to be fairly simple though, and it can't use the + or * quantifiers. Finally, the .NET and JGSoft flavors place no restrictions at all on lookbehinds. But Python makes a very simple-minded attempt to figure out the exact number of characters the lookbehind needs to match, generating that cryptic error message when it fails.

Solution 4

Looks like you almost had it:

.*\.(?!jpg$|png$)[^.]+

According to my tests (in java) I get these results:

file.jpg - false
file.png - false
file.name.jpg - false
file.name.png - false
file.gif - true
file.name.gif - true
file.jpg.gif - true
file.jpge - true

If this is not what you wanted pleas update your question with your expectations.

View more solutions