# What is == in Python

## Understanding the '==' Operator in Python

When you're starting your journey in programming, especially with Python, you will come across various symbols and operators that might seem cryptic at first. One such operator is `==`, which is used to compare values. Let's demystify this operator and understand how you can use it in your Python code.

### The Basics of Comparison

In real life, we often compare things: is this apple as big as that one? Is your piece of cake the same size as mine? In programming, we also need to make comparisons, and that's where the `==` operator comes into play. In Python, `==` is the equality operator, and it checks whether the values on either side of it are equal.

### How Does the '==' Operator Work?

When you write `a == b` in Python, you're asking the question, "Is the value of `a` equal to the value of `b`?" Python then evaluates this expression and gives you an answer in the form of a boolean value. Boolean values are another concept in programming, which can only be `True` or `False`.

Here's a simple example:

``````# Comparing integers
number1 = 10
number2 = 20
print(number1 == number2)  # Output: False

# Comparing strings
text1 = "Hello"
text2 = "Hello"
print(text1 == text2)  # Output: True
``````

In the first comparison, `10` is not equal to `20`, so Python returns `False`. In the second comparison, both strings are exactly the same, so Python returns `True`.

### Comparing Different Data Types

What happens when you try to compare values of different data types, like a number and a string? Let's see:

``````number = 5
text = "5"
print(number == text)  # Output: False
``````

Even though `number` and `text` look similar, they're different types of values. One is a number (integer), and the other is text (string). Python sees them as different, so it returns `False`.

### Deep Dive: Identity vs. Equality

Now, let's delve a bit deeper. In Python, every object (an object is a value or data that you work with in your code) has an identity, a type, and a value. The `==` operator only compares the value, not the identity or the type.

There's another operator, `is`, which checks whether two variables point to the same object, i.e., have the same identity. This is often a source of confusion for beginners, so let's clarify with an example:

``````a = [1, 2, 3]  # A list of numbers
b = [1, 2, 3]  # Another list with the same numbers

print(a == b)  # Output: True, because the values are equal
print(a is b)  # Output: False, because they are different objects in memory
``````

Here, `a` and `b` have the same values, so `a == b` is `True`. However, `a` and `b` are two separate objects stored at different locations in memory, so `a is b` is `False`.

### When '==' Gets Tricky

Sometimes, using `==` can lead to unexpected results, especially when dealing with floating-point numbers (numbers with decimal points) due to how computers represent these numbers. Here's an example that often trips up beginners:

``````number1 = 0.1 + 0.2
number2 = 0.3
print(number1 == number2)  # Output: False
``````

You might expect the output to be `True`, but it's `False`. This is because of the precision and rounding errors in floating-point arithmetic. To compare such numbers, you might need to use a method that allows for a small margin of error.

### Practical Use Cases of '=='

In real-world programming, you'll often use `==` in conditional statements like `if` to make decisions in your code:

``````user_input = input("Enter 'yes' to continue: ")
if user_input == "yes":
print("Continuing...")
else:
print("Exiting...")
``````

Here, the program checks if the user's input is equal to the string `"yes"` and acts accordingly.

Think of the `==` operator as asking if two puzzle pieces fit together perfectly. They might look similar or have similar colors (values), but unless they fit perfectly, they're not considered equal (`True`). The `is` operator, on the other hand, is like asking if two puzzle pieces are actually the same piece from the box, not just similar ones.

### Conclusion: The Power of '=='

The `==` operator is a fundamental part of Python and programming in general. It allows you to compare values and make decisions based on those comparisons. As you've seen, it's important to understand both what `==` does and its limitations.

Remember, `==` is like asking, "Are these two things the same in value?" It's a question you'll ask a lot as you write Python code, whether you're comparing numbers, strings, or other objects. With practice, you'll become adept at using `==` and other comparison operators to control the flow of your programs and make them do exactly what you want.

As you continue your programming journey, cherish these moments of discovery and clarity. Each operator you master is another tool in your toolbox, another step towards fluency in the language of computers. Happy coding!

## Learn to code in our 100% online programs

Altcademy coding bootcamp offers beginner-friendly, online programs designed by industry experts to help you become a coder. 85%+ of Altcademy alumni are hired within 6 months after graduation. See how we teach, or click on one of the following programs to find out more.