How do I compare version numbers in Python?

Why packaging.version steals the show

The packaging.version library follows the PEP 440 standard, so it's great for accurately comparing PEP compliant versions. The version.parse method generates a Version object for standard-compliant versions, and a LegacyVersion object if not:

v1 = version.parse("2.0.1")
v2 = version.parse("2.0.1a1")
print(v1 > v2)  # Output: True, Final release always gets the crown, sorry Alpha!


Remember, with great version power, comes great packaging.version responsibility.

Beware: Keep distance from distutils

It's super important to note that distutils.version is now like a treasure chest that's been buried (deprecated) in the sea of Python. You should not rely on LooseVersion and StrictVersion for version comparison; use packaging.version.parse instead.

When versions play hide and seek

Dealing with suffixes (alpha, beta, pre-release) and metadata could be like playing hide and seek with versions. Luckily, packaging.version.parse has a keen eye:

alpha_version = version.parse("1.0a1")
release_version = version.parse("1.0")
assert alpha_version < release_version  # Alpha who? Release is always the real deal. Phew, assertion passed!


The tuple trick: Like packing versions in a lunchbox

For straightforward, dot-separated version strings, tuple comparison can be a cool trick. It's like packing your versions in a lunchbox:

v1 = tuple(map(int, "1.0.2".split('.')))
v2 = tuple(map(int, "1.0.10".split('.')))
print(v1 < v2)  # Output: True, That sneaky little '10'! Only tuple comparison spots it.


This method slingshots the version strings into tuples of integers that reflect the correct hierarchy of versions.

The pkg_resources tool: Your version Swiss knife

The pkg_resources.parse_version function is a Swiss knife that can handle different version formats. It's PEP440 compliant and can work with prefixes and suffixes:

from pkg_resources import parse_version

print(parse_version("2.0.1rc1") < parse_version("2.0.1"))  # Output: True, Oops! Release Candidate, better luck next time.


Better keep this tool in your Python toolbox. You never know when you'll need it!

Your sys.path needs a diet

When it comes to managing Python environments (read: .egg files), you might want to make sure you only load the latest version of the library:

sorted_paths = sorted(egg_paths, key=lambda p: version.parse(p.split('-')[1]), reverse=True)
sys.path.extend(sorted_paths[:1])  # Egg diet: Only the freshest for my sys.path!


Remember, a healthy sys.path is a happy sys.path.

The art of comparison: Positively handling resources

Using the packaging.version library over pkg_resources means using a lighter and faster method for comparison that's less resource-intensive.

Best practices and pitfalls: Avoid falling into a version trap

While Python provides several ways to compare versions, there are best practices to keep and potential pitfalls to avoid. If you remember these, you can, as they say, keep Python in your pocket:

Best Practices:

1. Follow the PEP 440 - your passport to standardisation.
2. Use packaging.version.parse - It's your version's best friend.
3. Try tuple comparison for simple scenarios - a minimalist's dream.

Potential Pitfalls:

1. Don't dig up the buried distutils.version - It's deprecated for a reason!
2. Avoid manually parsing version strings - It can lead you down a rabbit hole.
3. Don't ignore pre-release and build metadata - It might catch you off guard in comparisons.