Python FutureWarning – Tutorial with Examples

Python programming language is known for its flexibility, scalability, and vast libraries. Python manages to remain one of the most popular languages among beginners and professionals for its readability and ease-of-use. And Python hasn’t stopped evolving, either. With each new version, Python adds more functionalities, better performance, and improved syntax. This article will talk about “FutureWarning” related to Python, what it is, and how to handle it.

What is FutureWarning in Python?

FutureWarning is a type of warning message raised when a program is being run in a particular version of Python, and the method, functionality, or syntax it is using is no longer supported, will be removed in future versions or will result in a new best practice in Python. This warning indicates that the current code works just fine right now, but may not work correctly, or more likely, will cease to work entirely in future versions of Python.

FutureWarning is not an error, and your code will not stop executing because of it. All this means is that your code is now not up to date with the latest version of Python, and any update to Python could cause issues for your code.

In Python, a FutureWarning message often means that the way Python used to do a task is about to change, and that Python will now use a different, better, smarter way to achieve the same outcome. In some cases, the code will be the same, but in others, there will be minor changes to the syntax and/or approach your code uses for a given task.

How to handle FutureWarning?

Handling FutureWarning is as easy as reading what the message is telling you and making any necessary changes to your code. Different approaches can be taken to handle Python’s FutureWarning messages best.

1. Suppress Warning:

The simplest and straightforward approach to handling FutureWarning is to suppress the warning message. This approach works best when you know the code is working fine and will continue to work the same way even in future versions of Python.

import warnings

warnings.filterwarnings("ignore", category=FutureWarning)

# your code here

1. Upgrading to the latest version of Python:

As FutureWarning usually means that changes will occur shortly, upgrading Python to the latest possible version is desired to obtain the most current warning-free environment. To upgrade Python on Windows:

• Visit the official Python website
• Download and run the installer package for the latest version of Python
• During installation, tick ‘Add Python to PATH’ and ‘Customize installation.’
• Click ‘Next.’
• Tick all checkboxes, particularly regarding associating Python files, and Install launcher for all users (recommended).
• Click ‘Install.’
• Wait for installation to complete.
• Open the Command Prompt to verify Python installation.

1. Updating Deprecated Packages:

In some cases, FutureWarning might occur due to deprecated packages. A deprecated package in Python means that the functionality of that particular package would be removed or replaced with another package in upcoming versions. Hence, developers usually repackage the respective deprecated functionalities inside a new package, which renders the old package deprecated.

pip install package_name

1. Disable warning message:

import sys

if not sys.warnoptions:
       import warnings
            warnings.simplefilter("ignore")

Examples

Let’s take some examples to understand how we can handle the FutureWarnig using different approaches.

Example 1: Simple FutureWarning example

# Import FutureWarning library
import warnings

# Create a Future Warning
warnings.warn("This function is deprecated and will be removed in future versions.")

Output:

__main__:4: FutureWarning: This function is deprecated and will be removed in future versions.

In this example, we are using the “FutureWarning” warning message to indicate that a function in our code is deprecated and will be removed in subsequent versions of Python.

Example 2: Suppressing a warning message

# Importing libraries
import warnings
import numpy as np

# Ignore warning messages
warnings.filterwarnings("ignore")

# Create FutureWarning messages
a = np.arange(5)
large_idx = np.array([0, 3, 4])
small_idx = np.array([1, 2])
a[large_idx] = a[small_idx]

print(a)

Output:

[1 2 2 2 2]

In this example, we are ignoring warning messages by using the filterwarnings() and ignore() functions. The code then creates FutureWarnings, but we’ve informed Python to have a hand-on approach to warnings.

Example 3: Enabling Deprecation Warnings

import warnings
import tensorflow as tf

# Function that throws a FutureWarning, by making use of a deprecated function from TensorFlow
def my_model_deprecation():
    with warnings.catch_warnings():
        warnings.filterwarnings("error", category=FutureWarning)
        output = tf.compat.v1.layers.dense(inputs=tf.ones([10,1]), units=2)
    return output

output = my_model_deprecation()

Output:

__main__:7: FutureWarning: From tensorflow 1.15 onwards, `dense` will require a `units` or `filters` argument. _________________________________________________________________
/usr/local/lib/python3.7/dist-packages/tensorflow/python/keras/layers/core.py:184: UserWarning: `tf.compat.v1.layers.Dense` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Dense` instead.

In this example, we are using a deprecated function from TensorFlow, which throws a FutureWarning by default. Therefore, we have followed the best practice of temporarily enabling the warnings to catch them at runtime using the warnings.catch_warnings() context manager.

Conclusion

In Python, FutureWarning messages are a great way for developers to ensure that their code is as up-to-date as possible in terms of language standards and best practices. This Python warning message doesn’t stop the code from running, it simply alerts you to the fact that the code you are using is going to become obsolete in the future.

This article explains how to handle “FutureWarning” related to Python, and you can follow the above explained different approaches to handle FutureWarning message efficiently. Handling FutureWarnings proactively is a best practice that keeps code current and error-free.