How do I check the versions of Python modules?


I installed the Python modules construct and statlib using setuptools:

sudo apt-get install python-setuptools

sudo easy_install statlib
sudo easy_install construct

How do I check their versions from the command line?

Asked By: tarabyte



You can try

>>> import statlib
>>> print statlib.__version__

>>> import construct
>>> print contruct.__version__

This is the approach recommended by PEP 396. But that PEP was never accepted and has been deferred. In fact, there appears to be increasing support amongst Python core developers to recommend not including a __version__ attribute, e.g. in Remove importlib_metadata.version..

Answered By: damienfrancois

Use pip instead of easy_install.

With pip, list all installed packages and their versions via:

pip freeze

On most Linux systems, you can pipe this to grep (or findstr on Windows) to find the row for the particular package you’re interested in.


pip freeze | grep lxml



pip freeze | findstr lxml


For an individual module, you can try the __version__ attribute. However, there are modules without it:

python -c "import requests; print(requests.__version__)"

python -c "import lxml; print(lxml.__version__)"

Traceback (most recent call last):
File "<string>", line 1, in <module>
AttributeError: ‘module’ object has no attribute ‘version

Lastly, as the commands in your question are prefixed with sudo, it appears you’re installing to the global python environment. I strongly advise to take look into Python virtual environment managers, for example virtualenvwrapper.

Answered By: alko

Use pip show to find the version!

# In order to get the package version, execute the below command
pip show YOUR_PACKAGE_NAME | grep Version

You can use pip show YOUR_PACKAGE_NAME – which gives you all details of package. This also works in Windows.

grep Version is used in Linux to filter out the version and show it.

Answered By: 0x3bfc

In Python 3 with brackets around print:

>>> import celery
>>> print(celery.__version__)
Answered By: user224767

The previous answers did not solve my problem, but this code did:

import sys 
for name, module in sorted(sys.modules.items()): 
  if hasattr(module, '__version__'): 
    print name, module.__version__ 
Answered By: tashuhka

If the methods in previous answers do not work, it is worth trying the following in Python:

import modulename


See Get the Python Tornado version

Note, the .version worked for me on a few others, besides Tornado as well.

Answered By: D Adams

module.__version__ is a good first thing to try, but it doesn’t always work.

If you don’t want to shell out, and you’re using pip 8 or 9, you can still use pip.get_installed_distributions() to get versions from within Python:

The solution here works in pip 8 and 9, but in pip 10 the function has been moved from pip.get_installed_distributions to pip._internal.utils.misc.get_installed_distributions to explicitly indicate that it’s not for external use. It’s not a good idea to rely on it if you’re using pip 10+.

import pip

pip.get_installed_distributions()  # -> [distribute 0.6.16 (...), ...]

    pkg.key + ': ' + pkg.version
    for pkg in pip.get_installed_distributions()
    if pkg.key in ['setuptools', 'statlib', 'construct']
] # -> nicely filtered list of ['setuptools: 3.3', ...]
Answered By: waterproof

Python >= 3.8:

If you’re on Python >= 3.8, you can use a module from the built-in library for that. To check a package’s version (in this example construct) run:

>>> from importlib.metadata import version
>>> version('construct')

Python < 3.8:

Use pkg_resources module distributed with setuptools library. Note that the string that you pass to get_distribution method should correspond to the PyPI entry.

>>> import pkg_resources
>>> pkg_resources.get_distribution('construct').version

Side notes:

  1. Note that the string that you pass to the get_distribution method should be the package name as registered in PyPI, not the module name that you are trying to import. Unfortunately, these aren’t always the same (e.g. you do pip install memcached, but import memcache).

  2. If you want to apply this solution from the command line you can do something like:

python -c 
  "import pkg_resources; print(pkg_resources.get_distribution('construct').version)"
Answered By: Jakub Kukul

Some modules don’t have __version__ attribute, so the easiest way is check in the terminal: pip list

Answered By: Yuchao Jiang

To get a list of non-standard (pip) modules imported in the current module:

[{pkg.key : pkg.version} for pkg in pip.get_installed_distributions() 
   if pkg.key in set(sys.modules) & set(globals())]


>>> import sys, pip, nltk, bs4
>>> [{pkg.key : pkg.version} for pkg in pip.get_installed_distributions() if pkg.key in set(sys.modules) & set(globals())]
[{'pip': '9.0.1'}, {'nltk': '3.2.1'}, {'bs4': '0.0.1'}]


This code was put together from solutions both on this page and from How to list imported modules?

Answered By: Tobias Bleisch

The better way to do that is:

For the details of a specific package

pip show <package_name>

It details out the package_name, version, author, location, etc.

$ pip show numpy

Name: numpy
Version: 1.13.3
Summary: NumPy: array processing for numbers, strings, records, and objects.
Author: NumPy Developers
Author-email: [email protected]
License: BSD
Location: c:usersprowinjvmappdatalocalprogramspythonpython36libsite-packages

For more details: >>> pip help

pip should be updated to do this.

pip install --upgrade pip

On Windows the recommended command is:

python -m pip install --upgrade pip
Answered By: susan097

First add executables python and pip to your environment variables. So that you can execute your commands from command prompt. Then simply give Python command.

Then import the package:

import scrapy

Then print the version name


This will definitely work.

Answered By: suraj garla

Assuming we are using Jupyter Notebook (if using Terminal, drop the exclamation marks):

  1. if the package (e.g., xgboost) was installed with pip:

    !pip show xgboost
    !pip freeze | grep xgboost
    !pip list | grep xgboost
  2. if the package (e.g. caffe) was installed with Conda:

    !conda list caffe
Answered By: user10429366

This works in Jupyter Notebook on Windows, too! As long as Jupyter is launched from a Bash-compliant command line such as Git Bash (Mingw-w64), the solutions given in many of the answers can be used in Jupyter Notebook on Windows systems with one tiny tweak.

I’m running Windows 10 Pro with Python installed via Anaconda, and the following code works when I launch Jupyter via Git Bash (but does not when I launch from the Anaconda prompt).

The tweak: Add an exclamation mark (!) in front of pip to make it !pip.

>>>!pip show lxml | grep Version
Version: 4.1.0

>>>!pip freeze | grep lxml

>>>!pip list | grep lxml
lxml                               4.1.0

>>>!pip show lxml
Name: lxml
Version: 4.1.0
Summary: Powerful and Pythonic XML processing library combining libxml2/libxslt with the ElementTree API.
Author: lxml dev team
Author-email: [email protected]
License: BSD
Location: c:userskarlsanaconda2libsite-packages
Required-by: jupyter-contrib-nbextensions
Answered By: Karl Baker

Use dir() to find out if the module has a __version__ attribute at all.

>>> import selenium
>>> dir(selenium)
['__builtins__', '__doc__', '__file__', '__name__',
 '__package__', '__path__', '__version__']
>>> selenium.__version__
>>> selenium.__path__
Answered By: jturi

A Python program to list all packages (you can copy it to file requirements.txt):

from pip._internal.utils.misc import get_installed_distributions
print_log = ''
for module in sorted(get_installed_distributions(), key=lambda x: x.key):
    print_log +=  module.key + '~=' + module.version  + 'n'

The output would look like:

Answered By: Yarh

(See also How do I get the version of an installed module in Python programmatically?)

I found it quite unreliable to use the various tools available (including the best one pkg_resources mentioned by Jakub Kukul’ answer), as most of them do not cover all cases. For example

  • built-in modules
  • modules not installed but just added to the python path (by your IDE for example)
  • two versions of the same module available (one in python path superseding the one installed)

Since we needed a reliable way to get the version of any package, module or submodule, I ended up writing getversion. It is quite simple to use:

from getversion import get_module_version
import foo
version, details = get_module_version(foo)

See the documentation for details.

Answered By: smarie

Building on Jakub Kukul’s answer I found a more reliable way to solve this problem.

The main problem of that approach is that requires the packages to be installed "conventionally" (and that does not include using pip install --user), or be in the system PATH at Python initialisation.

To get around that you can use pkg_resources.find_distributions(path_to_search). This basically searches for distributions that would be importable if path_to_search was in the system PATH.

We can iterate through this generator like this:

avail_modules = {}
distros = pkg_resources.find_distributions(path_to_search)
for d in distros:
    avail_modules[d.key] = d.version

This will return a dictionary having modules as keys and their version as value. This approach can be extended to a lot more than version number.

Thanks to Jakub Kukul for pointing in the right direction.

Answered By: Alessio Arena

In the Python 3.8 version there is a new metadata module in the importlib package, which can do that as well.

Here is an example from documentation:

>>> from importlib.metadata import version
>>> version('requests')
Answered By: Davit Tovmasyan

I suggest opening a Python shell in the terminal (in the Python version you are interested), importing the library, and getting its __version__ attribute.

>>> import statlib
>>> statlib.__version__

>>> import construct
>>> contruct.__version__

Note 1: We must regard the Python version. If we have installed different versions of Python, we have to open the terminal in the Python version we are interested in. For example, opening the terminal with Python 3.8 can (surely will) give a different version of a library than opening with Python 3.5 or Python 2.7.

Note 2: We avoid using the print function, because its behavior depends on Python 2 or Python 3. We do not need it, and the terminal will show the value of the expression.

Answered By:

In summary:

conda list

(It will provide all the libraries along with version details.)


pip show tensorflow

(It gives complete library details.)

Answered By: Tejj

You can first install some package like this and then check its version:

pip install package
import package

It should give you the package version.

Answered By: Shaina Raza

This answer is for Windows users. As suggested in all other answers, you can use the statements as:

import [type the module name]
print(module.__version__) # module + '.' + double underscore + version + double underscore

But, there are some modules which don’t print their version even after using the method above. So, you can simply do:

  1. Open the command prompt.
  2. Navigate to the file address/directory by using cd (file address) where you’ve kept your Python and all supporting modules installed. If you have only one Python interpreter on your system, the PyPI packages are normally visible in the directory/folder: PythonLibsite-packages.
  3. use the command "pip install [module name]" and hit Enter.
  4. This will show you a message as "Requirement already satisfied: file addressfolder name (with version)".
  5. See the screenshot below for example: I had to know the version of a pre-installed module named "Selenium-Screenshot". It correctly showed as 1.5.0:

Command prompt screenshot

Answered By: lousycoder

You can try this:

pip list

This will output all the packages with their versions.


Answered By: CRBelhekar

You can simply use subprocess.getoutput(python3 --version):

import subprocess as sp
print(sp.getoutput(python3 --version))

# Or however it suits your needs!
py3_version = sp.getoutput(python3 --version)

def check_version(name, version):...

check_version('python3', py3_version)

For more information and ways to do this without depending on the __version__ attribute:

Assign output of os.system to a variable and prevent it from being displayed on the screen

You can also use subprocess.check_output() which raises an error when the subprocess returns anything other than exit code 0:

subprocess — Subprocess management

Answered By: DogeCode

I myself work in a heavily restricted server environment and unfortunately none of the solutions here are working for me. There may be no global solution that fits all, but I figured out a swift workaround by reading the terminal output of pip freeze within my script and storing the modules labels and versions in a dictionary.

import os
os.system('pip freeze > tmpoutput')
with open('tmpoutput', 'r') as f:
    modules_version =
module_dict = {item.split("==")[0]:item.split("==")[-1] for item in modules_versions.split("n")}

Retrieve your module’s versions through passing the module label key, e.g.:

>>  module_dict["seaborn"]
Answered By: Majte

After scouring the Internet, trying to figure out how to ensure the version of a module I’m running (apparently python_is_horrible.__version__ isn’t a thing in Python 2?) across operating systems and Python versions… literally none of these answers worked for my scenario…

Then I thought about it a minute and realized the basics… after ~30 minutes of fails…

assumes the module is already installed and can be imported

Python 3.7

>>> import sys,sqlite3
>>> sys.modules.get("sqlite3").version
>>> ".".join(str(x) for x in sys.version_info[:3])

Python 2.7

>>> import sys,sqlite3
>>> sys.modules.get("sqlite3").version
>>> ".".join(str(x) for x in sys.version_info[:3])

Literally that’s it…

Answered By: Carl Boneri

And in case your production system is hardened beyond comprehension so it has neither pip nor conda, here is a Bash replacement for pip freeze:

ls /usr/local/lib/python3.8/dist-packages | grep info | awk -F "-" '{print $1"=="$2}' | sed 's/.dist//g'

(make sure you update your dist-packages folder to your current python version and ignore inconsistent names, e.g., underscores vs. dashes).

Sample printout:

Answered By: mirekphd

Here’s a small Bash program to get the version of any package in your Python environment. Just copy this to your /usr/bin and provide it with executable permissions:


python -c "import ${packageName} as package; print(package.__version__)"

Then you can just run it in the terminal, assuming you named the script py-check-version:

py-check-version whatever_package

For situations where field __version__ is not defined:

    from importlib import metadata
except ImportError:
    import importlib_metadata as metadata # python<=3.7


Alternatively, and like it was already mentioned:

import pkg_resources
Answered By: renatodamas

Go to terminal like pycharm-terminal

Now write py or python
and hit Enter.

Now you are inside python in the terminal you can try this way:

# import <name_of_the_library>

import kivy

# So if the library has __version__ magic method, so this way will help you

kivy.__version__  # then hit Enter to see the version

# Output >> '2.1.0'

but if the above way not working for you can try this way to know information include the version of the library



pip show module pyperclip

       Name: pyperclip
       Version: 1.8.2
       Summary: A cross-platform clipboard module for Python. (Only handles plain text for now.)
       Author: Al Sweigart
       Author-email: [email protected]
       License: BSD
       Location: c:ckivymdvirtlibsite-packages

There is another way that could help you to show all the libraries and versions of them inside the project:

pip freeze
# I used the above command in a terminal inside my project this is the output
       kivymd @ file:///C:/c/kivymd/KivyMD

and sure you can try using the below command to show all libraries and their versions

pip list

Hope to Help anyone,

Categories: questions Tags:
Answers are sorted by their score. The answer accepted by the question owner as the best is marked with
at the top-right corner.