What is false in python?

In this article, you will learn:

Let's begin! ✨

Let me introduce you to these concepts by comparing them with the values True and False that we typically work with.

Expressions with operands and operators evaluate to either True or False and they can be used in an if or while condition to determine if a code block should run.

Here we have an example:

In this example, everything is working as we expected because we used an expression with two operands and an operator 5 < 3.

But what do you think will happen if we try to run this code?

Notice that now we don't have a typical expression next to the if keyword, only a variable:

Surprisingly, the output is:

If we change the value of a to zero, like this:

There is no output.

I'm sure that you must be asking this right now: what made the code run successfully?

The variable a is not a typical expression. It doesn't have operators and operands, so why did it evaluate to True or False depending on its value?

The answer lies on the concept of Truthy and Falsy values, which are not truth values themselves, but they evaluate to either True or False.

In Python, individual values can evaluate to either True or False. They do not necessarily have to be part of a larger expression to evaluate to a truth value because they already have one that has been determined by the rules of the Python language.

The basic rules are:

According to the Python Documentation:

When we use a value as part of a larger expression, or as an if or while condition, we are using it in a boolean context.

You can think of a boolean context as a particular "part" of your code that requires a value to be either True or False to make sense.

For example, (see below) the condition after the if keyword or after the while keyword has to evaluate to either True or False:

💡 Tip: The value can be stored in a variable. We can write the name of the variable after the if or while keyword instead of the value itself. This will provide the same functionality.

Now that you know what truthy and falsy values are and how they work in a boolean context, let's see some real examples of truthy and falsy values.

Sequences and Collections:

Numbers

Constants

Falsy values were the reason why there was no output in our initial example when the value of a was zero.

The value 0 is falsy, so the if condition will be False and the conditional will not run in this example:

According to the Python Documentation:

Truthy values include:

This is why the value of a was printed in our initial example because its value was 5 (a truthy value):

You can check if a value is either truthy or falsy with the built-in bool() function.

According to the Python Documentation, this function:

You only need to pass the value as the argument, like this:

💡 Tip: You can also pass a variable as the argument to test if its value is truthy or falsy.

One of the advantages of using truthy and falsy values is that they can help you make your code more concise and readable. Here we have two real examples.

Example: We have this function print_even() that takes as an argument a list or tuple that contains numbers and only prints the values that are even. If the argument is empty, it prints a descriptive message:

Notice this line:

We can make the condition much more concise with truthy and falsy values:

If the list is empty, data will evaluate to False. If it's not empty, it will evaluate to True. We get the same functionality with more concise code.

This would be our final function:

Example: We could also use truthy and falsy values to raise an exception (error) when the argument passed to a function is not valid.

In this case, by using not data as the condition of the if statement, we are getting the opposite truth value of data for the if condition.

Let's analyze not data in more detail:

If data is empty:

If data is not empty:

If you are familiar with classes and Object-Oriented Programming, you can add a special method to your classes to make your objects act like truthy and falsy values.

With the special method __bool__(), you can set a "customized" condition that will determine when an object of your class will evaluate to True or False.

According to the Python Documentation:

For example, if we have this very simple class:

You can see that no special methods are defined, so all the objects that you create from this class will always evaluate to True:

We can customize this behavior by adding the special method __bool__():

Now, if the account balance is greater than zero, the object will evaluate to True. Otherwise, if the account balance is zero, the object will evaluate to False.

Booleans represent one of two values: True or False.

In programming you often need to know if an expression is True or False.

You can evaluate any expression in Python, and get one of two answers, True or False.

When you compare two values, the expression is evaluated and Python returns the Boolean answer:

When you run a condition in an if statement, Python returns True or False:

The bool() function allows you to evaluate any value, and give you True or False in return,

Almost any value is evaluated to True if it has some sort of content.

Any string is True, except empty strings.

Any number is True, except 0.

Any list, tuple, set, and dictionary are True, except empty ones.

In fact, there are not many values that evaluate to False, except empty values, such as (), [], {}, "", the number 0, and the value None. And of course the value False evaluates to False.

One more value, or object in this case, evaluates to False, and that is if you have an object that is made from a class with a __len__ function that returns 0 or False:

You can create functions that returns a Boolean Value:

You can execute code based on the Boolean answer of a function:

Python also has many built-in functions that return a boolean value, like the isinstance() function, which can be used to determine if an object is of a certain data type:

Summary: in this tutorial, you’ll learn about the Python boolean data type, falsy and truthy values.

In programming, you often want to check if a condition is true or not and perform some actions based on the result.

To represent true and false, Python provides you with the boolean data type. The boolean value has a technical name as bool.

The boolean data type has two values: True and False.

Note that the boolean values True and False start with the capital letters (T) and (F).

The following example defines two boolean variables:

When you compare two numbers, Python returns the result as a boolean value. For example:

Also, comparing two strings results in a boolean value:

To find out if a value is True or False, you use the bool() function. For example:

As you can see clearly from the output, some values evaluate to True and the others evaluate to False.

When a value evaluates to True, it’s truthy. And if a value evaluates to False, it’s falsy.

The following are falsy values in Python:

The truthy values are the other values that aren’t falsy.

Note that you’ll learn more about the None, list, tuple, and dictionary in the upcoming tutorials.

Definition and Usage. The False keyword is a Boolean value, and result of a comparison operation. The False keyword is the same as 0 ( True is the same as 1).

The most common comparison operators are the equality operator (==) and the inequality operator (!=). It’s almost impossible to write any meaningful amount of Python code without using at least one of those operators.

The equality operator (==) is one of the most used operators in Python code. You often need to compare either an unknown result with a known result or two unknown results against each other. Some functions return values that need to be compared against a sentinel to see if some edge condition has been detected. Sometimes you need to compare the results from two functions against each other.

The equality operator is often used to compare numbers:

You may have used equality operators before. They’re some of the most common operators in Python. For all built-in Python objects, and for most third-party classes, they return a Boolean value: True or False.

Second only to the equality operator in popularity is the inequality operator (!=). It returns True if the arguments aren’t equal and False if they are. The examples are similarly wide-ranging. Many unit tests check that the value isn’t equal to a specific invalid value. A web client might check that the error code isn’t 404 Not Found before trying an alternative.

Here are two examples of the Python inequality operator in use:

Perhaps the most surprising thing about the Python inequality operator is the fact that it exists in the first place. After all, you could achieve the same result as 1 != 2 with not (1 == 2). Python usually avoids extra syntax, and especially extra core operators, for things easily achievable by other means.

However, inequality is used so often that it was deemed worthwhile to have a dedicated operator for it. In old versions of Python, in the 1.x series, there were actually two different syntaxes.

As an April Fools’ joke, Python still supports an alternative syntax for inequality with the right __future__ import:

This should never be used in any code meant for real use. It could come in handy for your next Python trivia night, however.