th 75 - Why [] == False is False, but 'if not []' works?

Why [] == False is False, but ‘if not []’ works?

Posted on
th?q=Why Does - Why [] == False is False, but 'if not []' works?

Have you ever come across the comparison expression, Why [] == False is False, but ‘if not []’ works? and wondered what’s going on here? It’s a common confusion that exists among many Python programmers. At first glance, it might seem like both expressions should evaluate to the same thing, but they don’t.

The expression ‘if not []’ checks for the truthiness of an empty list, which is considered to be false in Python. On the other hand, the expression ‘[] == False’ compares an empty list to the Boolean value False. But why doesn’t this comparison work?

Well, the answer lies in how Python evaluates truthiness and falsiness. In Python, empty sequences like lists, tuples, and strings are considered false. However, the Boolean value False is not the same as an empty sequence. Therefore, when we compare an empty list to False using the == operator, we get False as the result because these two values are not equivalent.

So, if you’re wondering why ‘if not []’ works, it’s because the ‘not’ keyword flips the truthiness of an empty list and returns the opposite value, which is True. Therefore, the if statement executes the code inside the block because True is considered true in Python.

In conclusion, while these two expressions might seem similar, they are actually quite different in their evaluation. Understanding truthiness and falsiness in Python is crucial to writing effective code that performs as expected. So, always remember the difference between comparing an empty sequence to False and checking for the truthiness of an empty sequence using the ‘not’ keyword.

th?q=Why%20Does%20%22%5B%5D%20%3D%3D%20False%22%20Evaluate%20To%20False%20When%20%22If%20Not%20%5B%5D%22%20Succeeds%3F - Why [] == False is False, but 'if not []' works?
“Why Does “[] == False” Evaluate To False When “If Not []” Succeeds?” ~ bbaz


In Python, you might have encountered the expressions such as ‘if not []’ or ‘[] == False’. While both expressions might seem to be equivalent, they return different results. In this blog, we will discuss the reason behind this disparity and why one expression works, but the other doesn’t.

Python’s Truth Value Testing

Before diving deeper, let’s take a quick look at Python’s truth value testing mechanism. In Python, every object has an associated Boolean value, which is either True or False. Python considers every non-zero value as True and every zero value as False. Similarly, an empty container is considered to be False, while a non-empty container is considered to be True.

‘[] == False’ Comparison

Now consider the expression ‘[] == False’. This expression compares an empty list with a boolean False. A list is a non-zero value, while False is a zero-value. Therefore, the comparison returns False. We can verify this through the following code:

Expression Result
[] == False False
[] == True False
[] []


The above table shows that the expression ‘[] == False’ returns False, while ‘[] == True’ also returns False. It is because an empty list is neither equal to True nor equal to False. Hence, it is recommended to use the ‘if not’ statement for testing empty containers, which we will discuss next.

‘if not []’ Statement

On the other hand, ‘if not []’ is an expression that checks the truth value of an empty list. Since an empty list is considered to be False in Python’s truth value testing mechanism, the expression returns True, and the block inside the if statement is executed. Let’s see the code snippet below:

if not []:    print(The list is empty)


The above code snippet prints The list is empty because Python considers the empty list as False, which satisfies the condition of ‘if not’ statement, and thus the code block inside it is executed.

Other Empty Containers

So far, we have discussed only empty lists. However, this concept applies to all other empty containers such as empty dictionaries, sets, tuples, etc. Python takes every empty container as False in its truth value testing mechanism. Therefore, you can use ‘if not’ statement to check for empty containers in general. Let’s see the code snippet below:

my_dict = {}if not my_dict:    print(The dictionary is empty)


The above code snippet prints The dictionary is empty because Python takes an empty dictionary as False, and hence the condition of ‘if not’ statement satisfies.


Python’s truth value testing mechanism treats empty containers as False, while non-empty containers as True. Therefore, the expression ‘[] == False’ returns False, while ‘if not []’ statement returns True. The ‘if not’ statement works for all empty containers and not just lists. Use the ‘if not’ statement to check for empty containers in your Python code.

To summarize, do not use the ‘== False’ expression to check for empty containers. Instead, use the ‘if not’ statement to write more pythonic and idiomatic code.

Thank you for taking the time to read this article about the difference between ‘[] == False’ and ‘if not []’ in Python. We hope that you found the information provided helpful in gaining a better understanding of this topic.

As we discussed in the previous paragraphs, the reason why ‘[] == False’ is false in Python is because the ‘==’ operator performs type conversion before comparison, while ‘if not []’ checks if the list is empty or not.

It is important to understand these distinctions because they can have a significant impact on the performance and behavior of your code. By using the correct syntax, you can ensure that your programs are executing efficiently and producing accurate results.

Once again, thank you for reading our article on this important topic in Python programming. We hope that you continue to find useful information and insights on our blog, and we welcome any feedback or questions you may have about what we’ve discussed here today or in future posts.

People often ask why [] == False is False, but if not [] works. Here are some possible explanations:

  1. Boolean coercion: When Python tries to evaluate an object in a Boolean context (such as a condition for an if statement), it applies a set of rules to determine whether the object should be considered True or False. One of these rules is that empty containers (such as lists, tuples, and dictionaries) are considered False, while non-empty containers are considered True. Therefore, [] == False is False, because an empty list is not the same as False. However, if not [] is True, because the not operator reverses the Boolean value of the empty list, making it True.
  2. Type comparison: When Python compares two objects with the == operator, it first checks whether they have the same type. If they do not have the same type, they are considered unequal, regardless of their values. In this case, an empty list ([]) is not the same type as a Boolean value (False), so they are not equal. However, when Python evaluates a Boolean expression such as if not [], it does not need to compare types, because it already knows that the result should be a Boolean value.
  3. Contextual meaning: The meaning of [] == False and if not [] can depend on the context in which they are used. For example, if you are testing whether a variable contains a non-empty list, you might use if my_list:, which is equivalent to if bool(my_list):, rather than if not my_list:.