if else variable assignment python

Python Conditional Assignment

When you want to assign a value to a variable based on some condition, like if the condition is true then assign a value to the variable, else assign some other value to the variable, then you can use the conditional assignment operator.

In this tutorial, we will look at different ways to assign values to a variable based on some condition.

1. Using Ternary Operator

The ternary operator is very special operator in Python, it is used to assign a value to a variable based on some condition.

It goes like this:

Here, the value of variable will be value_if_true if the condition is true, else it will be value_if_false .

Let's see a code snippet to understand it better.

You can see we have conditionally assigned a value to variable c based on the condition a > b .

2. Using if-else statement

if-else statements are the core part of any programming language, they are used to execute a block of code based on some condition.

Using an if-else statement, we can assign a value to a variable based on the condition we provide.

Here is an example of replacing the above code snippet with the if-else statement.

3. Using Logical Short Circuit Evaluation

Logical short circuit evaluation is another way using which you can assign a value to a variable conditionally.

The format of logical short circuit evaluation is:

It looks similar to ternary operator, but it is not. Here the condition and value_if_true performs logical AND operation, if both are true then the value of variable will be value_if_true , or else it will be value_if_false .

Let's see an example:

But if we make condition True but value_if_true False (or 0 or None), then the value of variable will be value_if_false .

So, you can see that the value of c is 20 even though the condition a < b is True .

So, you should be careful while using logical short circuit evaluation.

While working with lists , we often need to check if a list is empty or not, and if it is empty then we need to assign some default value to it.

Let's see how we can do it using conditional assignment.

Here, we have assigned a default value to my_list if it is empty.

Assign a value to a variable conditionally based on the presence of an element in a list.

Now you know 3 different ways to assign a value to a variable conditionally. Any of these methods can be used to assign a value when there is a condition.

The cleanest and fastest way to conditional value assignment is the ternary operator .

if-else statement is recommended to use when you have to execute a block of code based on some condition.

Happy coding! 😊

Conditional Statements in Python

Table of Contents

Introduction to the if Statement

Python: it’s all about the indentation, what do other languages do, which is better, the else and elif clauses, one-line if statements, conditional expressions (python’s ternary operator), the python pass statement.

Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Conditional Statements in Python (if/elif/else)

From the previous tutorials in this series, you now have quite a bit of Python code under your belt. Everything you have seen so far has consisted of sequential execution , in which statements are always performed one after the next, in exactly the order specified.

But the world is often more complicated than that. Frequently, a program needs to skip over some statements, execute a series of statements repetitively, or choose between alternate sets of statements to execute.

That is where control structures come in. A control structure directs the order of execution of the statements in a program (referred to as the program’s control flow ).

Here’s what you’ll learn in this tutorial: You’ll encounter your first Python control structure, the if statement.

In the real world, we commonly must evaluate information around us and then choose one course of action or another based on what we observe:

If the weather is nice, then I’ll mow the lawn. (It’s implied that if the weather isn’t nice, then I won’t mow the lawn.)

In a Python program, the if statement is how you perform this sort of decision-making. It allows for conditional execution of a statement or group of statements based on the value of an expression.

The outline of this tutorial is as follows:

• First, you’ll get a quick overview of the if statement in its simplest form.
• Next, using the if statement as a model, you’ll see why control structures require some mechanism for grouping statements together into compound statements or blocks . You’ll learn how this is done in Python.
• Lastly, you’ll tie it all together and learn how to write complex decision-making code.

Ready? Here we go!

Take the Quiz: Test your knowledge with our interactive “Python Conditional Statements” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Test your understanding of Python conditional statements

We’ll start by looking at the most basic type of if statement. In its simplest form, it looks like this:

In the form shown above:

• <expr> is an expression evaluated in a Boolean context, as discussed in the section on Logical Operators in the Operators and Expressions in Python tutorial.
• <statement> is a valid Python statement, which must be indented. (You will see why very soon.)

If <expr> is true (evaluates to a value that is “truthy”), then <statement> is executed. If <expr> is false, then <statement> is skipped over and not executed.

Note that the colon ( : ) following <expr> is required. Some programming languages require <expr> to be enclosed in parentheses, but Python does not.

Here are several examples of this type of if statement:

Note: If you are trying these examples interactively in a REPL session, you’ll find that, when you hit Enter after typing in the print('yes') statement, nothing happens.

Because this is a multiline statement, you need to hit Enter a second time to tell the interpreter that you’re finished with it. This extra newline is not necessary in code executed from a script file.

Grouping Statements: Indentation and Blocks

So far, so good.

But let’s say you want to evaluate a condition and then do more than one thing if it is true:

If the weather is nice, then I will: Mow the lawn Weed the garden Take the dog for a walk (If the weather isn’t nice, then I won’t do any of these things.)

In all the examples shown above, each if <expr>: has been followed by only a single <statement> . There needs to be some way to say “If <expr> is true, do all of the following things.”

The usual approach taken by most programming languages is to define a syntactic device that groups multiple statements into one compound statement or block . A block is regarded syntactically as a single entity. When it is the target of an if statement, and <expr> is true, then all the statements in the block are executed. If <expr> is false, then none of them are.

Virtually all programming languages provide the capability to define blocks, but they don’t all provide it in the same way. Let’s see how Python does it.

Python follows a convention known as the off-side rule , a term coined by British computer scientist Peter J. Landin. (The term is taken from the offside law in association football.) Languages that adhere to the off-side rule define blocks by indentation. Python is one of a relatively small set of off-side rule languages .

Recall from the previous tutorial on Python program structure that indentation has special significance in a Python program. Now you know why: indentation is used to define compound statements or blocks. In a Python program, contiguous statements that are indented to the same level are considered to be part of the same block.

Thus, a compound if statement in Python looks like this:

Here, all the statements at the matching indentation level (lines 2 to 5) are considered part of the same block. The entire block is executed if <expr> is true, or skipped over if <expr> is false. Either way, execution proceeds with <following_statement> (line 6) afterward.

Notice that there is no token that denotes the end of the block. Rather, the end of the block is indicated by a line that is indented less than the lines of the block itself.

Note: In the Python documentation, a group of statements defined by indentation is often referred to as a suite . This tutorial series uses the terms block and suite interchangeably.

Consider this script file foo.py :

Running foo.py produces this output:

The four print() statements on lines 2 to 5 are indented to the same level as one another. They constitute the block that would be executed if the condition were true. But it is false, so all the statements in the block are skipped. After the end of the compound if statement has been reached (whether the statements in the block on lines 2 to 5 are executed or not), execution proceeds to the first statement having a lesser indentation level: the print() statement on line 6.

Blocks can be nested to arbitrary depth. Each indent defines a new block, and each outdent ends the preceding block. The resulting structure is straightforward, consistent, and intuitive.

Here is a more complicated script file called blocks.py :

The output generated when this script is run is shown below:

Note: In case you have been wondering, the off-side rule is the reason for the necessity of the extra newline when entering multiline statements in a REPL session. The interpreter otherwise has no way to know that the last statement of the block has been entered.

Perhaps you’re curious what the alternatives are. How are blocks defined in languages that don’t adhere to the off-side rule?

The tactic used by most programming languages is to designate special tokens that mark the start and end of a block. For example, in Perl blocks are defined with pairs of curly braces ( {} ) like this:

C/C++, Java , and a whole host of other languages use curly braces in this way.

Other languages, such as Algol and Pascal, use keywords begin and end to enclose blocks.

Better is in the eye of the beholder. On the whole, programmers tend to feel rather strongly about how they do things. Debate about the merits of the off-side rule can run pretty hot.

On the plus side:

• Python’s use of indentation is clean, concise, and consistent.
• In programming languages that do not use the off-side rule, indentation of code is completely independent of block definition and code function. It’s possible to write code that is indented in a manner that does not actually match how the code executes, thus creating a mistaken impression when a person just glances at it. This sort of mistake is virtually impossible to make in Python.
• Use of indentation to define blocks forces you to maintain code formatting standards you probably should be using anyway.

On the negative side:

• Many programmers don’t like to be forced to do things a certain way. They tend to have strong opinions about what looks good and what doesn’t, and they don’t like to be shoehorned into a specific choice.
• Some editors insert a mix of space and tab characters to the left of indented lines, which makes it difficult for the Python interpreter to determine indentation levels. On the other hand, it is frequently possible to configure editors not to do this. It generally isn’t considered desirable to have a mix of tabs and spaces in source code anyhow, no matter the language.

Like it or not, if you’re programming in Python, you’re stuck with the off-side rule. All control structures in Python use it, as you will see in several future tutorials.

For what it’s worth, many programmers who have been used to languages with more traditional means of block definition have initially recoiled at Python’s way but have gotten comfortable with it and have even grown to prefer it.

Now you know how to use an if statement to conditionally execute a single statement or a block of several statements. It’s time to find out what else you can do.

Sometimes, you want to evaluate a condition and take one path if it is true but specify an alternative path if it is not. This is accomplished with an else clause:

If <expr> is true, the first suite is executed, and the second is skipped. If <expr> is false, the first suite is skipped and the second is executed. Either way, execution then resumes after the second suite. Both suites are defined by indentation, as described above.

In this example, x is less than 50 , so the first suite (lines 4 to 5) are executed, and the second suite (lines 7 to 8) are skipped:

Here, on the other hand, x is greater than 50 , so the first suite is passed over, and the second suite executed:

There is also syntax for branching execution based on several alternatives. For this, use one or more elif (short for else if ) clauses. Python evaluates each <expr> in turn and executes the suite corresponding to the first that is true. If none of the expressions are true, and an else clause is specified, then its suite is executed:

An arbitrary number of elif clauses can be specified. The else clause is optional. If it is present, there can be only one, and it must be specified last:

At most, one of the code blocks specified will be executed. If an else clause isn’t included, and all the conditions are false, then none of the blocks will be executed.

Note: Using a lengthy if / elif / else series can be a little inelegant, especially when the actions are simple statements like print() . In many cases, there may be a more Pythonic way to accomplish the same thing.

Here’s one possible alternative to the example above using the dict.get() method:

Recall from the tutorial on Python dictionaries that the dict.get() method searches a dictionary for the specified key and returns the associated value if it is found, or the given default value if it isn’t.

An if statement with elif clauses uses short-circuit evaluation, analogous to what you saw with the and and or operators. Once one of the expressions is found to be true and its block is executed, none of the remaining expressions are tested. This is demonstrated below:

The second expression contains a division by zero, and the third references an undefined variable var . Either would raise an error, but neither is evaluated because the first condition specified is true.

It is customary to write if <expr> on one line and <statement> indented on the following line like this:

But it is permissible to write an entire if statement on one line. The following is functionally equivalent to the example above:

There can even be more than one <statement> on the same line, separated by semicolons:

But what does this mean? There are two possible interpretations:

If <expr> is true, execute <statement_1> .

Then, execute <statement_2> ... <statement_n> unconditionally, irrespective of whether <expr> is true or not.

If <expr> is true, execute all of <statement_1> ... <statement_n> . Otherwise, don’t execute any of them.

Python takes the latter interpretation. The semicolon separating the <statements> has higher precedence than the colon following <expr> —in computer lingo, the semicolon is said to bind more tightly than the colon. Thus, the <statements> are treated as a suite, and either all of them are executed, or none of them are:

Multiple statements may be specified on the same line as an elif or else clause as well:

While all of this works, and the interpreter allows it, it is generally discouraged on the grounds that it leads to poor readability, particularly for complex if statements. PEP 8 specifically recommends against it.

As usual, it is somewhat a matter of taste. Most people would find the following more visually appealing and easier to understand at first glance than the example above:

If an if statement is simple enough, though, putting it all on one line may be reasonable. Something like this probably wouldn’t raise anyone’s hackles too much:

Python supports one additional decision-making entity called a conditional expression. (It is also referred to as a conditional operator or ternary operator in various places in the Python documentation.) Conditional expressions were proposed for addition to the language in PEP 308 and green-lighted by Guido in 2005.

In its simplest form, the syntax of the conditional expression is as follows:

This is different from the if statement forms listed above because it is not a control structure that directs the flow of program execution. It acts more like an operator that defines an expression. In the above example, <conditional_expr> is evaluated first. If it is true, the expression evaluates to <expr1> . If it is false, the expression evaluates to <expr2> .

Notice the non-obvious order: the middle expression is evaluated first, and based on that result, one of the expressions on the ends is returned. Here are some examples that will hopefully help clarify:

Note: Python’s conditional expression is similar to the <conditional_expr> ? <expr1> : <expr2> syntax used by many other languages—C, Perl and Java to name a few. In fact, the ?: operator is commonly called the ternary operator in those languages, which is probably the reason Python’s conditional expression is sometimes referred to as the Python ternary operator.

You can see in PEP 308 that the <conditional_expr> ? <expr1> : <expr2> syntax was considered for Python but ultimately rejected in favor of the syntax shown above.

A common use of the conditional expression is to select variable assignment. For example, suppose you want to find the larger of two numbers. Of course, there is a built-in function, max() , that does just this (and more) that you could use. But suppose you want to write your own code from scratch.

You could use a standard if statement with an else clause:

But a conditional expression is shorter and arguably more readable as well:

Remember that the conditional expression behaves like an expression syntactically. It can be used as part of a longer expression. The conditional expression has lower precedence than virtually all the other operators, so parentheses are needed to group it by itself.

In the following example, the + operator binds more tightly than the conditional expression, so 1 + x and y + 2 are evaluated first, followed by the conditional expression. The parentheses in the second case are unnecessary and do not change the result:

If you want the conditional expression to be evaluated first, you need to surround it with grouping parentheses. In the next example, (x if x > y else y) is evaluated first. The result is y , which is 40 , so z is assigned 1 + 40 + 2 = 43 :

If you are using a conditional expression as part of a larger expression, it probably is a good idea to use grouping parentheses for clarification even if they are not needed.

Conditional expressions also use short-circuit evaluation like compound logical expressions. Portions of a conditional expression are not evaluated if they don’t need to be.

In the expression <expr1> if <conditional_expr> else <expr2> :

• If <conditional_expr> is true, <expr1> is returned and <expr2> is not evaluated.
• If <conditional_expr> is false, <expr2> is returned and <expr1> is not evaluated.

As before, you can verify this by using terms that would raise an error:

In both cases, the 1/0 terms are not evaluated, so no exception is raised.

Conditional expressions can also be chained together, as a sort of alternative if / elif / else structure, as shown here:

It’s not clear that this has any significant advantage over the corresponding if / elif / else statement, but it is syntactically correct Python.

Occasionally, you may find that you want to write what is called a code stub: a placeholder for where you will eventually put a block of code that you haven’t implemented yet.

In languages where token delimiters are used to define blocks, like the curly braces in Perl and C, empty delimiters can be used to define a code stub. For example, the following is legitimate Perl or C code:

Here, the empty curly braces define an empty block. Perl or C will evaluate the expression x , and then even if it is true, quietly do nothing.

Because Python uses indentation instead of delimiters, it is not possible to specify an empty block. If you introduce an if statement with if <expr>: , something has to come after it, either on the same line or indented on the following line.

Consider this script foo.py :

If you try to run foo.py , you’ll get this:

The Python pass statement solves this problem. It doesn’t change program behavior at all. It is used as a placeholder to keep the interpreter happy in any situation where a statement is syntactically required, but you don’t really want to do anything:

Now foo.py runs without error:

With the completion of this tutorial, you are beginning to write Python code that goes beyond simple sequential execution:

• You were introduced to the concept of control structures . These are compound statements that alter program control flow —the order of execution of program statements.
• You learned how to group individual statements together into a block or suite .
• You encountered your first control structure, the if statement, which makes it possible to conditionally execute a statement or block based on evaluation of program data.

All of these concepts are crucial to developing more complex Python code.

The next two tutorials will present two new control structures: the while statement and the for statement. These structures facilitate iteration , execution of a statement or block of statements repeatedly.

🐍 Python Tricks 💌

Get a short & sweet Python Trick delivered to your inbox every couple of days. No spam ever. Unsubscribe any time. Curated by the Real Python team.

About John Sturtz

John is an avid Pythonista and a member of the Real Python tutorial team.

Each tutorial at Real Python is created by a team of developers so that it meets our high quality standards. The team members who worked on this tutorial are:

Master Real-World Python Skills With Unlimited Access to Real Python

Join us and get access to thousands of tutorials, hands-on video courses, and a community of expert Pythonistas:

Join us and get access to thousands of tutorials, hands-on video courses, and a community of expert Pythonistas:

What Do You Think?

What’s your #1 takeaway or favorite thing you learned? How are you going to put your newfound skills to use? Leave a comment below and let us know.

Commenting Tips: The most useful comments are those written with the goal of learning from or helping out other students. Get tips for asking good questions and get answers to common questions in our support portal . Looking for a real-time conversation? Visit the Real Python Community Chat or join the next “Office Hours” Live Q&A Session . Happy Pythoning!

Keep Learning

Related Topics: basics python

Recommended Video Course: Conditional Statements in Python (if/elif/else)

Keep reading Real Python by creating a free account or signing in:

Already have an account? Sign-In

How to use python if else in one line with examples

December 31, 2023

How do I write a simple python if else in one line? What are ternary operator in Python? Can we use one liner for complex if and else statements?

In this tutorial I will share different examples to help you understand and learn about usage of ternary operator in one liner if and else condition with Python. Conditional expressions (sometimes called a “ ternary operator ”) have the lowest priority of all Python operations. Programmers coming to Python from C, C++, or Perl sometimes miss the so-called ternary operator ?:. It’s most often used for avoiding a few lines of code and a temporary variable for simple decisions.

I will not go into details of generic ternary operator as this is used across Python for loops and control flow statements. Here we will concentrate on learning python if else in one line using ternary operator

Python if else in one line

The general syntax of single if and else statement in Python is:

Now if we wish to write this in one line using ternary operator, the syntax would be:

In this syntax, first of all the else condition is evaluated.

• If condition returns True then value_when_true is returned
• If condition returns False then value_when_false is returned

Similarly if you had a variable assigned in the general if else block based on the condition

The same can be written in single line:

Here as well, first of all the condition is evaluated.

• if condition returns True then true-expr is assigned to value object
• if condition returns False then false-expr is assigned to value object

For simple cases like this, I find it very nice to be able to express that logic in one line instead of four. Remember, as a coder, you spend much more time reading code than writing it, so Python's conciseness is invaluable.

Some important points to remember:

• You can use a ternary expression in Python, but only for expressions , not for statements
• You cannot use Python if..elif..else block in one line.
• The name " ternary " means there are just 3 parts to the operator: condition , then , and else .
• Although there are hacks to modify if..elif..else block into if..else block and then use it in single line but that can be complex depending upon conditions and should be avoided
• With if-else blocks , only one of the expressions will be executed.
• While it may be tempting to always use ternary expressions to condense your code, realise that you may sacrifice readability if the condition as well as the true and false expressions are very complex.

Python Script Example

This is a simple script where we use comparison operator in our if condition

• First collect user input in the form of integer and store this value into b
• If b is greater than or equal to 0 then return " positive " which will be True condition
• If b returns False i.e. above condition was not success then return " negative "
• The final returned value i.e. either " positive " or " negative " is stored in object a
• Lastly print the value of value a

The multi-line form of this code would be:

Python if..elif..else in one line

Now as I told this earlier, it is not possible to use if..elif..else block in one line using ternary expressions. Although we can hack our way into this but make sure the maximum allowed length of a line in Python is 79 as per PEP-8 Guidelines

We have this if..elif..else block where we return expression based on the condition check:

We can write this if..elif..else block in one-line using this syntax:

In this syntax,

• First of all condition2 is evaluated, if return True then expr2 is returned
• If condition2 returns False then condition1 is evaluated, if return True then expr1 is returned
• If condition1 also returns False then else is executed and expr is returned

As you see, it was easier if we read this in multi-line if..elif..else block while the same becomes hard to understand for beginners.

We can add multiple if else block in this syntax, but we must also adhere to PEP-8 guidelines

Python Script Example-1

In this sample script we collect an integer value from end user and store it in " b ". The order of execution would be:

• If the value of b is less than 0 then " neg " is returned
• If the value of b is greater than 0 then " pos " is returned.
• If both the condition return False , then " zero " is returned

The multi-line form of the code would be:

Output(when if condition is True )

Output(when if condition is False and elif condition is True )

Output(when both if and elif condition are False )

Python script Example-2

We will add some more else blocks in this sample script, the order of the check would be in below sequence :

• Collect user input for value b which will be converted to integer type
• If value of b is equal to 100 then return " equal to 100 ", If this returns False then next if else condition would be executed
• If value of b is equal to 50 then return " equal to 50 ", If this returns False then next if else condition would be executed
• If value of b is equal to 40 then return " equal to 40 ", If this returns False then next if else condition would be executed
• If value of b is greater than 100 then return " greater than 100 ", If this returns False then next go to else block
• Lastly if all the condition return False then return " less than hundred "

The multi-line form of this example would be:

Python nested if..else in one line

We can also use ternary expression to define nested if..else block on one line with Python.

If you have a multi-line code using nested if else block , something like this:

The one line syntax to use this nested if else block in Python would be:

Here, we have added nested if..elif..else inside the else block using ternary expression. The sequence of the check in the following order

• If condition1 returns True then expr1 is returned, if it returns False then next condition is checked
• If condition-m returns True then expr-m is returned, if it returns False then else block with nested if..elif..else is checked
• If condition3 returns True then expr3 is returned, if it returns False then next condition inside the nested block is returned
• If condition-n returns True then expr-n is returned, if it returns False then expr5 is returned from the else condition

In this example I am using nested if else inside the else block of our one liner. The order of execution will be in the provided sequence:

• First of all collect integer value of b from the end user
• If the value of b is equal to 100 then the if condition returns True and " equal to 100 " is returned
• If the value of b is equal to 50 then the elif condition returns True and " equal to 50 " is returned
• If both if and elif condition returns False then the else block is executed where we have nested if and else condition
• Inside the else block , if b is greater than 100 then it returns " greater than 100 " and if it returns False then " less than 100 " is returned

In this tutorial we learned about usage of ternary operator in if else statement to be able to use it in one line. Although Python does not allow if..elif..else statement in one line but we can still break it into if else and then use it in single line form. Similarly we can also use nested if with ternary operator in single line. I shared multiple examples to help you understand the concept of ternary operator with if and else statement of Python programming language

Lastly I hope this tutorial guide on python if else one line was helpful. So, let me know your suggestions and feedback using the comment section.

Deepak Prasad

He is the founder of GoLinuxCloud and brings over a decade of expertise in Linux, Python, Go, Laravel, DevOps, Kubernetes, Git, Shell scripting, OpenShift, AWS, Networking, and Security. With extensive experience, he excels in various domains, from development to DevOps, Networking, and Security, ensuring robust and efficient solutions for diverse projects. You can connect with him on his LinkedIn profile.

Can't find what you're searching for? Let us assist you.

Enter your query below, and we'll provide instant results tailored to your needs.

If my articles on GoLinuxCloud has helped you, kindly consider buying me a coffee as a token of appreciation.

For any other feedbacks or questions you can send mail to [email protected]

Thank You for your support!!

Leave a Comment Cancel reply

Save my name and email in this browser for the next time I comment.

Notify me via e-mail if anyone answers my comment.

We try to offer easy-to-follow guides and tips on various topics such as Linux, Cloud Computing, Programming Languages, Ethical Hacking and much more.

Recent Comments

Popular posts, 7 tools to detect memory leaks with examples, 100+ linux commands cheat sheet & examples, tutorial: beginners guide on linux memory management, top 15 tools to monitor disk io performance with examples, overview on different disk types and disk interface types, 6 ssh authentication methods to secure connection (sshd_config), how to check security updates list & perform linux patch management rhel 6/7/8, 8 ways to prevent brute force ssh attacks in linux (centos/rhel 7).

Privacy Policy

HTML Sitemap

• Subscription

Tutorial: Using If Statements in Python

Our life is full of conditions even if we don’t notice them most of the time. Let’s look at a few examples:

If tomorrow it doesn't rain, I’ll go out with my friends in the park. Otherwise, I’ll stay home with a cup of hot tea and watch TV.

If tomorrow it isn't too hot, I’ll go to the sea, but if it is, I’ll have a walk in the forest. However, if it rains, I’ll stay home.

You get the idea. Let’s see how conditions work in computers. You may already know that programs in Python are executed line by line. However, sometimes, we need to skip some code and execute only some of it only if certain conditions are met. This is where control structures become useful. Conditional statements in Python are built on these control structures. They will guide the computer in the execution of a program.

In this tutorial, you'll learn how to use conditional statements. This guide is for beginners in Python, but you'll need to know some basics of coding in Python. If you don’t, then check this free Python Fundamentals course .

Basic if Statement

In Python, if statements are a starting point to implement a condition. Let’s look at the simplest example:

When <condition> is evaluated by Python, it’ll become either True or False (Booleans). Thus, if the condition is True (i.e, it is met), the <expression> will be executed, but if <condition> is False (i.e., it is not met), the <expression> won’t be executed.

We are pretty free to decide what conditions and expressions can be because Python is very flexible.

Let’s look at a concrete example.

First of all, we define two variables, x and y . Then we say that if variable x is smaller than variable y , print out x is smaller than y ). Indeed, if we execute this code, we’ll print out this output because 3 is smaller than 10.

Output: x is smaller than y.

Let’s look at a more complex example.

In this case, if the condition is met, then a value of 13 will be assigned to the variable z . Then Variable z is now 13. will be printed out (note that the print statement can be used both outside and inside the if statement).

As you can see, we aren't restrained in the choice of an expression to execute. You can now practice more by writing more complex code.

Let’s know see what happens if we execute the following code:

Here we changed the direction of the comparison symbol (it was less than , and now it’s greater than ). Can you guess the output?

There will be no output! This happened because the condition hadn't been met. 3 is not greater than 10, so the condition evaluated to False , and the expression wasn’t executed. How do we solve this problem? With the else statement.

else Statement

What if we want to execute some code if the condition isn't met? We add an else statement below the if statement. Let’s look at an example.

Here, Python first executes the if condition and checks if it’s True . Since 3 is not greater than 10, the condition isn't met, so we don’t print out “x is greater than y.” Then we say that in all other cases we should execute the code under the else statement: x is smaller than y.

Let’s get back to our first example of a conditional statement:

Here the else statement is “Otherwise.”

What happens if the condition is met?

In this case, Python just prints out the first sentence as before.

What if x is equal to y ?

The output is clearly wrong because 3 is equal to 3! We have another condition outside the greater or less than comparison symbols; thus, we have to use the elif statement.

elif Statement

Let’s rewrite the above example and add an elif statement.

Output: x is equal to y .

Python first checks if the condition x < y is met. It isn't, so it goes on to the second condition, which in Python, we write as elif , which is short for else if . If the first condition isn't met, check the second condition, and if it’s met, execute the expression. Else, do something else. The output is “x is equal to y.”

Let’s now get back to one of our first examples of conditional statements:

Here, our first condition is that tomorrow it’s not too hot ( if statement). If this condition isn't met, then we go for a walk in the forest ( elif statement). Finally, if neither condition is met, we’ll stay home ( else statement).

Now let’s translate this sentence into Python.

In this example, we're going to use strings instead of integers to demonstrate the flexibility of the if condition in Python.

Python first checks if the variable tomorrow is equal to “warm” and if it is, then it prints out I'll go to the sea. and stops the execution. What happens if the first condition isn't met?

In this case, Python evaluates the first condition to False and goes to the second condition. This condition is True , so it prints out I'll go to the forest. and stops the execution.

If neither of the two conditions is met, then it’ll print out I’ll stay home.

Of course, you can use whatever number of elif statements you want. Let’s add more conditions and also change what is printed out under the else statement to Weather not recognized. (for example, if tomorrow is “f”, we don’t know what it means).

Guess what’s printed out?

Multiple Conditions

Let’s now add some complexity. What if we want to meet multiple conditions in one if statement?

Let’s say we want to predict a biome (i.e., desert or tropical forest) based on two climate measurements: temperature and humidity. For example, if it’s hot and dry, then it’s a hot desert, but if it’s cold and dry, then it’s an arctic desert. You can see that we cannot classify these two biomes based only on their humidity (they are both dry) so we also have to add the temperature measure.

In Python, we can use logical operators (i.e., and, or) to use multiple conditions in the same if statement.

Look at the code below.

The output will be It's a hot desert. because only when humidity is low and temperature is high, the combined condition is True . It’s not sufficient to have only one of the conditions to be True .

Formally, Python checks if the first condition of humidity is True (indeed, it is), then it checks if the second condition of temperature is True (and it is) and only in this case the combined condition is True . If at least one of these conditions isn't met, then the combined condition evaluates to False .

What if we want either of two (or more) conditions is met? In this case we should use the or logical operator.

Let’s look at an example. Say you have a list of numbers from 1 to 14 (inclusive), and you want to extract all the numbers that are smaller than 3 or greater or equal to 10. You can achieve the result using an or operator!

Output: [1, 2, 10, 11, 12, 13, 14]

Here Python checks whether the current number in the for loop is less than 3, and if it’s True , then the combined if statement evaluates to True . The same happens if the current number is equal to or greater than 10. If the combined if statement is True , then the expression is executed and the current number is appended to the list nums_less_3_greater_equal_10 .

For the sake of experiment, let’s change or to and .

In this case, the current number should be simultaneously smaller than 3 and greater or equal to 10, which is clearly not possible so the combined if statement evaluates to False and the expression isn't executed.

To make things even more clear, look at this print statement.

Output: True

Here Python evaluates the combination of False and True , and since we have the or logical operator, it’s sufficient that at least one of these Booleans is True to evaluate the combined statement to True .

Now, what happens if we change or to and ?

Output: False

Both Booleans should be True to evaluate the combined condition to True . Since one of them is False , the combined condition is also False . This is what happens in the example with numbers.

You can even combine multiple logical operators in one expression. Let’s use the same list of numbers, but now, we want to find all the numbers that are either smaller than 3 or greater or equal to 10 and simultaneously are even numbers.

Output: [2, 10, 12, 14]

Why is the first number of the output 2? In the second for loop, 2 is evaluated in the first condition in parentheses. It is smaller than 3, so the combined condition in parentheses is True . 2 is also divisible by 2 with the remainder 0, so the second condition is also True . Both conditions are True , so this number is appended to the list.

Why do we use parentheses? It’s because of the operator precedence in Python. What if we remove them?

Output: [1, 2, 10, 12, 14]

We have 1 in the list! In Python, all operators are evaluated in a precise order. For example, the and operator takes precedence over the or operator. But if we place the or operator in parentheses, it’ll take precedence over the and operator.

First we evaluate the conditions on both sides of the and operator (it has precedence). 1 is neither greater than 10 nor yields 0 if divided by 2, so the combined condition is False . We are left with the condition if num < 3 or False . 1 is smaller than 3, so the first condition is True . The condition becomes True or False . We have an or operator, so the combined condition evaluates to True , and 1 is appended to the list. Practice by checking what happens with the other numbers.

Finally, have a look at this truth table to understand how logical operators work. Here, we will describe only the and and or logical operators, but in Python, we also have the not operator. We invite you to learn more about it and practice using it inside if statements.

We have two inputs, A and B, that can be either True or False . For example, in the second row, A is True , while B is False ; thus, A AND B evaluate to False but A OR B evaluate to True . The rest of the table is read in the same way. Take a minute to understand what it tells you.

Nested if Statements

Python is a very flexible programming language, and it allows you to use if statements inside other if statements, so called nested if statements . Let’s look at an example.

Output: Well done!

Here, if the mark is between 60 and 100, the expression under the if statement is executed. But then we have other conditions that are also evaluated. So, our mark is 85, which is between 60 and 100. However, 85 is smaller than 90, so the first nested if condition is False , and the first nested expression isn't executed. But 85 is higher than 80, so the second expression is executed and “Well done!” is printed out.

Of course, we also have elif statements outside the expression below the first if statement. For example, what if the mark is higher than 100? If the first condition (number between 60 and 100) is False , then we go directly to the elif statement mark > 100 and print out This mark is too low. .

Try to assign different numbers to the mark variable to understand the logic of this code.

Pattern Matching in Python 3.10

The pattern matching was added in Python 3.10, released in October, 2021. In short, it can be seen a different syntax for if..elif statements. Let's look at an example by rewrting a previous example using the pattern matching.

We can see similarities between using the if..elif statements and the match..case syntax. First, we define what variable we want to match , and when we define the cases (or values this variable can take). The rest of the code is similar. If a case is matched (that's equivalent of a double equal sign), then the print expression is executed.

Note the last case statement, it's the _ case, which is equivalent to else : if no cases are matched, then we print Weather not recognized .

pass Statement

As you start writing more complex code, you may find yourself in the situation where you have to use a placeholder instead of the code you want to implement later. The pass statement is this placeholder. Let’s look at an example with and without the pass statement.

Python expects some code under the if statement, but you are yet to implement it! You can write pass there and solve this problem.

Output: I'll write this code later.

If instead you place pass in the if statement, Python won’t throw any error and will pass to any code you have below the if statement. This works even if you have other conditions below the first if statement.

Output: The variable num is 4.

Conclusions

In Python, if statements are used all the time, and you’ll find yourself using them in basically any project or script you're building, so it's essential to understand the logic behind them. In this article, we’ve covered the most important aspects of if conditions in Python:

• Creating basic if statements
• Adding complexity by using else and elif statements
• Combining multiple conditions in one if statement using logical operators ( or , and )
• Using nested if statements
• Using pass statements as placeholders

With this knowledge, you can now start working with conditional statements in Python.

Feel free to connect with me on LinkedIn and GitHub . Happy coding!

More learning resources

Python datetime tutorial: manipulate times, dates, and time spans, pandas tutorial: analyzing video game data with python and pandas.

Learn data skills 10x faster

Join 1M+ learners

Enroll for free

• Data Analyst (Python)
• Gen AI (Python)
• Business Analyst (Power BI)
• Business Analyst (Tableau)
• Machine Learning
• Data Analyst (R)

• Control Flow

Python Inline If Else (With 5 Examples)

You can use Python inline if to write an if else statement on a single line.

It allows you to write a single line of code instead of using a traditional if-else statement block.

Python inline if is also known as the Python Ternary Operator.

Syntax of Python inline if else assignment

The syntax of Python inline if else assignment is as follows:

Let’s break down the syntax of an inline if statement.

value_if_true : This value will be returned if the condition is true.

condition : This is a Boolean expression that evaluates to be either true or false.

value_if_false : This value will be returned if the condition is false.

For example, the following code would return the value “Hello” if the variable x is greater than 10, and the value “Goodbye” if it is not:

This code would print the following output:

Here are some additional things to keep in mind when using inline if in Python:

• The condition must be a Boolean expression.
• The value_if_true and value_if_false expressions must be of the same type.
• If the condition is false, the value_if_false expression will be evaluated.
• If the condition is true, the value_if_true expression will be evaluated.

Uses & Examples

Uses of Python inline if else

You can use Inline ifs in a variety of situations, such as:

• Assigning values to variables
• Calling functions
• Making decisions

They can be a helpful way to make your code more concise and readable.

However, it is important to use them sparingly.

As they can make your code more difficult to understand if you overused the inline if else assignment.

Assigning values to variables using Python inline if

Here’s an example to illustrate how to use the inline if statement to assign values to variables.

In this example, first of all, we have to evaluate the condition age >= 18 .

Since the value of age is 20, the condition is true, and the value True is assigned to the variable is_adult .

You can use the inline if statement as nested inline if else statements as well.

This allows you for more complex assignments.

Here’s an example.

y is greater

In this example, we checked if x is greater than y .

If true, we assigned “x is greater” to z .

Then we checked If y is greater than x .

If true, the program executes the nested inline if statement, and assigns the value “y is greater” to z . Otherwise, if x and y are equal, we assign the innermost value “x and y are equal”.

Calling functions using Python inline if

Here’s another example that calls a function with the inline if else statement.

Click on this code and it will be copied automatically.

Then you can run it on our  free Online Python Compiler .

The code gives the following output.

Even and positive

In this example, we have two custom functions: is_even() and is_positive() .

The is_even() function takes a number as input and checks if it’s an even number, returning True if it is, and False otherwise.

The is_positive() function takes a number as input and checks if it’s a positive number, returning True if it is, and False otherwise.

We then have a variable x set to 8.

Then, we used the inline if else statement to evaluate the conditions is_even(x) and is_positive(x) .

If both conditions are true (in this case, x is even and positive), the value assigned to the message variable is “Even and positive”.

If any of the conditions is false (if x is either not even or not positive), the value assigned to the message is “Not even or positive”.

Making decisions using Python inline if

You can make decisions in Python using the inline if else assignment.

Here is an example,

Error occurred

In this example, we used the inline if statement to format a message based on the value of is_error .

If is_error is True, we assigned the value “Error occurred” to the message .

Otherwise, if is_error is False, the program assigns the value “No errors found” to the message .

Related Articles:

Python program to add two matrices using numpy, python program to generate cube of numbers, what is random module in python (all functions explained), python program for lottery game (with complete code), what is os module in python (with all methods and examples), python ampersand (&), beautifulsoup findall by class (with code & examples), python program to print fibonacci numbers using while loop, web scraping real estate data python (with example), find the index of an element in a list python, python program for alarm clock (step by step guide + code), recent articles:, python program to convert integer to roman, python program to convert miles to kilometers, python program to convert fahrenheit to celsius, python program to convert binary to decimal, python program to convert decimal to binary, python program to convert kilometers to miles, python program to convert celsius to fahrenheit, python program to print hello world: a beginner’s guide, python program to print prime numbers, python program to add two numbers without addition operator, python program to add two numbers with user input, related tutorials:, python fundamentals: learn the basics of python programming., control flow: learn about conditional statements and loops, functions: learn modular programming from basics, oop: the art of organizing code for maximum reusability..

This community is dedicated to spreading the knowledge and benefits of Python programming to people of all ages and skill levels. This community driven platform is dedicated to providing comprehensive, up-to-date education in a fun and interactive way.

Whether you’re looking to start a new career, enhance your current skills, or just learn for fun, Python Mania is your one-stop-shop for all of your need. Join us today and become a part of the rapidly growing community of Python programmers!

FOR THE LOVE OF PYTHON! Copyright © 2023 PythonMania.org

• Module 2: The Essentials of Python »
• Conditional Statements
• View page source

Conditional Statements 

There are reading-comprehension exercises included throughout the text. These are meant to help you put your reading to practice. Solutions for the exercises are included at the bottom of this page.

In this section, we will be introduced to the if , else , and elif statements. These allow you to specify that blocks of code are to be executed only if specified conditions are found to be true, or perhaps alternative code if the condition is found to be false. For example, the following code will square x if it is a negative number, and will cube x if it is a positive number:

Please refer to the “Basic Python Object Types” subsection to recall the basics of the “boolean” type, which represents True and False values. We will extend that discussion by introducing comparison operations and membership-checking, and then expanding on the utility of the built-in bool type.

Comparison Operations 

Comparison statements will evaluate explicitly to either of the boolean-objects: True or False . There are eight comparison operations in Python:

The first six of these operators are familiar from mathematics:

Note that = and == have very different meanings. The former is the assignment operator, and the latter is the equality operator:

Python allows you to chain comparison operators to create “compound” comparisons:

Whereas == checks to see if two objects have the same value, the is operator checks to see if two objects are actually the same object. For example, creating two lists with the same contents produces two distinct lists, that have the same “value”:

Thus the is operator is most commonly used to check if a variable references the None object, or either of the boolean objects:

Use is not to check if two objects are distinct:

bool and Truth Values of Non-Boolean Objects 

Recall that the two boolean objects True and False formally belong to the int type in addition to bool , and are associated with the values 1 and 0 , respectively:

Likewise Python ascribes boolean values to non-boolean objects. For example,the number 0 is associated with False and non-zero numbers are associated with True . The boolean values of built-in objects can be evaluated with the built-in Python command bool :

and non-zero Python integers are associated with True :

The following built-in Python objects evaluate to False via bool :

Zero of any numeric type: 0 , 0.0 , 0j

Any empty sequence, such as an empty string or list: '' , tuple() , [] , numpy.array([])

Empty dictionaries and sets

Thus non-zero numbers and non-empty sequences/collections evaluate to True via bool .

The bool function allows you to evaluate the boolean values ascribed to various non-boolean objects. For instance, bool([]) returns False wherease bool([1, 2]) returns True .

if , else , and elif 

We now introduce the simple, but powerful if , else , and elif conditional statements. This will allow us to create simple branches in our code. For instance, suppose you are writing code for a video game, and you want to update a character’s status based on her/his number of health-points (an integer). The following code is representative of this:

Each if , elif , and else statement must end in a colon character, and the body of each of these statements is delimited by whitespace .

The following pseudo-code demonstrates the general template for conditional statements:

In practice this can look like:

In its simplest form, a conditional statement requires only an if clause. else and elif clauses can only follow an if clause.

Similarly, conditional statements can have an if and an else without an elif :

Conditional statements can also have an if and an elif without an else :

Note that only one code block within a single if-elif-else statement can be executed: either the “if-block” is executed, or an “elif-block” is executed, or the “else-block” is executed. Consecutive if-statements, however, are completely independent of one another, and thus their code blocks can be executed in sequence, if their respective conditional statements resolve to True .

Reading Comprehension: Conditional statements

Assume my_list is a list. Given the following code:

What will happen if my_list is [] ? Will IndexError be raised? What will first_item be?

Assume variable my_file is a string storing a filename, where a period denotes the end of the filename and the beginning of the file-type. Write code that extracts only the filename.

my_file will have at most one period in it. Accommodate cases where my_file does not include a file-type.

"code.py" \(\rightarrow\) "code"

"doc2.pdf" \(\rightarrow\) "doc2"

"hello_world" \(\rightarrow\) "hello_world"

Inline if-else statements 

Python supports a syntax for writing a restricted version of if-else statements in a single line. The following code:

can be written in a single line as:

This is suggestive of the general underlying syntax for inline if-else statements:

The inline if-else statement :

The expression A if <condition> else B returns A if bool(<condition>) evaluates to True , otherwise this expression will return B .

This syntax is highly restricted compared to the full “if-elif-else” expressions - no “elif” statement is permitted by this inline syntax, nor are multi-line code blocks within the if/else clauses.

Inline if-else statements can be used anywhere, not just on the right side of an assignment statement, and can be quite convenient:

We will see this syntax shine when we learn about comprehension statements. That being said, this syntax should be used judiciously. For example, inline if-else statements ought not be used in arithmetic expressions, for therein lies madness:

Short-Circuiting Logical Expressions 

Armed with our newfound understanding of conditional statements, we briefly return to our discussion of Python’s logic expressions to discuss “short-circuiting”. In Python, a logical expression is evaluated from left to right and will return its boolean value as soon as it is unambiguously determined, leaving any remaining portions of the expression unevaluated . That is, the expression may be short-circuited .

For example, consider the fact that an and operation will only return True if both of its arguments evaluate to True . Thus the expression False and <anything> is guaranteed to return False ; furthermore, when executed, this expression will return False without having evaluated bool(<anything>) .

To demonstrate this behavior, consider the following example:

According to our discussion, the pattern False and short-circuits this expression without it ever evaluating bool(1/0) . Reversing the ordering of the arguments makes this clear.

In practice, short-circuiting can be leveraged in order to condense one’s code. Suppose a section of our code is processing a variable x , which may be either a number or a string . Suppose further that we want to process x in a special way if it is an all-uppercased string. The code

is problematic because isupper can only be called once we are sure that x is a string; this code will raise an error if x is a number. We could instead write

but the more elegant and concise way of handling the nestled checking is to leverage our ability to short-circuit logic expressions.

See, that if x is not a string, that isinstance(x, str) will return False ; thus isinstance(x, str) and x.isupper() will short-circuit and return False without ever evaluating bool(x.isupper()) . This is the preferable way to handle this sort of checking. This code is more concise and readable than the equivalent nested if-statements.

Reading Comprehension: short-circuited expressions

Consider the preceding example of short-circuiting, where we want to catch the case where x is an uppercased string. What is the “bug” in the following code? Why does this fail to utilize short-circuiting correctly?

Links to Official Documentation 

Truth testing

Boolean operations

Comparisons

‘if’ statements

Reading Comprehension Exercise Solutions: 

Conditional statements

If my_list is [] , then bool(my_list) will return False , and the code block will be skipped. Thus first_item will be None .

First, check to see if . is even contained in my_file . If it is, find its index-position, and slice the string up to that index. Otherwise, my_file is already the file name.

Short-circuited expressions

fails to account for the fact that expressions are always evaluated from left to right. That is, bool(x.isupper()) will always be evaluated first in this instance and will raise an error if x is not a string. Thus the following isinstance(x, str) statement is useless.

Conditional expression (ternary operator) in Python

Python has a conditional expression (sometimes called a "ternary operator"). You can write operations like if statements in one line with conditional expressions.

• 6. Expressions - Conditional expressions — Python 3.11.3 documentation

Basics of the conditional expression (ternary operator)

If ... elif ... else ... by conditional expressions, list comprehensions and conditional expressions, lambda expressions and conditional expressions.

See the following article for if statements in Python.

• Python if statements (if, elif, else)

In Python, the conditional expression is written as follows.

The condition is evaluated first. If condition is True , X is evaluated and its value is returned, and if condition is False , Y is evaluated and its value is returned.

If you want to switch the value based on a condition, simply use the desired values in the conditional expression.

If you want to switch between operations based on a condition, simply describe each corresponding expression in the conditional expression.

An expression that does not return a value (i.e., an expression that returns None ) is also acceptable in a conditional expression. Depending on the condition, either expression will be evaluated and executed.

The above example is equivalent to the following code written with an if statement.

You can also combine multiple conditions using logical operators such as and or or .

• Boolean operators in Python (and, or, not)

By combining conditional expressions, you can write an operation like if ... elif ... else ... in one line.

However, it is difficult to understand, so it may be better not to use it often.

The following two interpretations are possible, but the expression is processed as the first one.

In the sample code below, which includes three expressions, the first expression is interpreted like the second, rather than the third:

By using conditional expressions in list comprehensions, you can apply operations to the elements of the list based on the condition.

See the following article for details on list comprehensions.

• List comprehensions in Python

Conditional expressions are also useful when you want to apply an operation similar to an if statement within lambda expressions.

In the example above, the lambda expression is assigned to a variable for convenience, but this is not recommended by PEP8.

Refer to the following article for more details on lambda expressions.

• Lambda expressions in Python

Related Categories

Related articles.

• Shallow and deep copy in Python: copy(), deepcopy()
• Composite two images according to a mask image with Python, Pillow
• OpenCV, NumPy: Rotate and flip image
• pandas: Check if DataFrame/Series is empty
• Check pandas version: pd.show_versions
• Python if statement (if, elif, else)
• pandas: Find the quantile with quantile()
• Handle date and time with the datetime module in Python
• Get image size (width, height) with Python, OpenCV, Pillow (PIL)
• Convert between Unix time (Epoch time) and datetime in Python
• Convert BGR and RGB with Python, OpenCV (cvtColor)
• Matrix operations with NumPy in Python
• pandas: Replace values in DataFrame and Series with replace()
• Uppercase and lowercase strings in Python (conversion and checking)
• Calculate mean, median, mode, variance, standard deviation in Python

Learn Python practically and Get Certified .

Popular Tutorials

Popular examples, reference materials, learn python interactively, python introduction.

• Get Started With Python
• Your First Python Program
• Python Comments

Python Fundamentals

• Python Variables and Literals
• Python Type Conversion
• Python Basic Input and Output
• Python Operators

Python Flow Control

• Python if...else Statement
• Python for Loop

Python while Loop

Python break and continue

Python pass Statement

Python Data types

• Python Numbers and Mathematics
• Python List
• Python Tuple
• Python String
• Python Dictionary
• Python Functions
• Python Function Arguments
• Python Variable Scope
• Python Global Keyword
• Python Recursion
• Python Modules
• Python Package
• Python Main function

Python Files

• Python Directory and Files Management
• Python CSV: Read and Write CSV files
• Reading CSV files in Python
• Writing CSV files in Python
• Python Exception Handling
• Python Exceptions
• Python Custom Exceptions

Python Object & Class

• Python Objects and Classes
• Python Inheritance
• Python Multiple Inheritance
• Polymorphism in Python
• Python Operator Overloading

Python Advanced Topics

• List comprehension
• Python Lambda/Anonymous Function
• Python Iterators
• Python Generators
• Python Namespace and Scope
• Python Closures
• Python Decorators
• Python @property decorator
• Python RegEx

Python Date and Time

• Python datetime
• Python strftime()
• Python strptime()
• How to get current date and time in Python?
• Python Get Current Time
• Python timestamp to datetime and vice-versa
• Python time Module
• Python sleep()

Additional Topic

• Precedence and Associativity of Operators in Python
• Python Keywords and Identifiers
• Python Asserts
• Python Json
• Python *args and **kwargs

Python Tutorials

Python Assert Statement

• Python Looping Techniques

In computer programming, the if statement is a conditional statement. It is used to execute a block of code only when a specific condition is met. For example,

Suppose we need to assign different grades to students based on their scores.

• If a student scores above 90 , assign grade A
• If a student scores above 75 , assign grade B
• If a student scores above 65 , assign grade C

These conditional tasks can be achieved using the if statement.

• Python if Statement

An if statement executes a block of code only when the specified condition is met.

Here, condition is a boolean expression, such as number > 5 , that evaluates to either True or False .

• If condition evaluates to True , the body of the if statement is executed.
• If condition evaluates to False , the body of the if statement will be skipped from execution.

Let's look at an example.

• Example: Python if Statement

Sample Output 1

If user enters 10 , the condition number > 0 evaluates to True . Therefore, the body of if is executed.

Sample Output 2

If user enters -2 , the condition number > 0 evaluates to False . Therefore, the body of if is skipped from execution.

Indentation in Python

Python uses indentation to define a block of code, such as the body of an if statement. For example,

Here, the body of if has two statements. We know this because two statements (immediately after if ) start with indentation.

We usually use four spaces for indentation in Python, although any number of spaces works as long as we are consistent.

You will get an error if you write the above code like this:

Here, we haven't used indentation after the if statement. In this case, Python thinks our if statement is empty, which results in an error.

An if statement can have an optional else clause. The else statement executes if the condition in the if statement evaluates to False .

Here, if the condition inside the if statement evaluates to

• True - the body of if executes, and the body of else is skipped.
• False - the body of else executes, and the body of if is skipped

• Example: Python if…else Statement

If user enters 10 , the condition number > 0 evalutes to True . Therefore, the body of if is executed and the body of else is skipped.

If user enters 0 , the condition number > 0 evalutes to False . Therefore, the body of if is skipped and the body of else is executed.

• Python if…elif…else Statement

The if...else statement is used to execute a block of code among two alternatives.

However, if we need to make a choice between more than two alternatives, we use the if...elif...else statement.

• Example: Python if…elif…else Statement

Here, the first condition, number > 0 , evaluates to False . In this scenario, the second condition is checked.

The second condition, number < 0 , evaluates to True . Therefore, the statements inside the elif block is executed.

In the above program, it is important to note that regardless the value of number variable, only one block of code will be executed.

• Python Nested if Statements

It is possible to include an if statement inside another if statement. For example,

Here's how this program works.

More on Python if…else Statement

In certain situations, the if statement can be simplified into a single line. For example,

This code can be compactly written as

This one-liner approach retains the same functionality but in a more concise format.

Python doesn't have a ternary operator. However, we can use if...else to work like a ternary operator in other languages. For example,

can be written as

If needed, we can use logical operators such as and and or to create complex conditions to work with an if statement.

Here, we used the logical operator and to add two conditions in the if statement.

We also used >= (comparison operator) to compare two values.

Logical and comparison operators are often used with if...else statements. Visit Python Operators to learn more.

Table of Contents

• Introduction

Write a function to check whether a student passed or failed his/her examination.

• Assume the pass marks to be 50 .
• Return Passed if the student scored more than 50. Otherwise, return Failed .

Video: Python if...else Statement

Sorry about that.

Related Tutorials

Python Tutorial

Python One Line Conditional Assignment

Problem : How to perform one-line if conditional assignments in Python?

Example : Say, you start with the following code.

You want to set the value of x to 42 if boo is True , and do nothing otherwise.

Let’s dive into the different ways to accomplish this in Python. We start with an overview:

Exercise : Run the code. Are all outputs the same?

Next, you’ll dive into each of those methods and boost your one-liner superpower !

Method 1: Ternary Operator

The most basic ternary operator x if c else y returns expression x if the Boolean expression c evaluates to True . Otherwise, if the expression c evaluates to False , the ternary operator returns the alternative expression y .

Let’s go back to our example problem! You want to set the value of x to 42 if boo is True , and do nothing otherwise. Here’s how to do this in a single line:

While using the ternary operator works, you may wonder whether it’s possible to avoid the ...else x part for clarity of the code? In the next method, you’ll learn how!

If you need to improve your understanding of the ternary operator, watch the following video:

You can also read the related article:

• Python One Line Ternary

Method 2: Single-Line If Statement

Like in the previous method, you want to set the value of x to 42 if boo is True , and do nothing otherwise. But you don’t want to have a redundant else branch. How to do this in Python?

The solution to skip the else part of the ternary operator is surprisingly simple— use a standard if statement without else branch and write it into a single line of code :

To learn more about what you can pack into a single line, watch my tutorial video “If-Then-Else in One Line Python” :

Method 3: Ternary Tuple Syntax Hack

A shorthand form of the ternary operator is the following tuple syntax .

Syntax : You can use the tuple syntax (x, y)[c] consisting of a tuple (x, y) and a condition c enclosed in a square bracket. Here’s a more intuitive way to represent this tuple syntax.

In fact, the order of the <OnFalse> and <OnTrue> operands is just flipped when compared to the basic ternary operator. First, you have the branch that’s returned if the condition does NOT hold. Second, you run the branch that’s returned if the condition holds.

Clever! The condition boo holds so the return value passed into the x variable is the <OnTrue> branch 42 .

Don’t worry if this confuses you—you’re not alone. You can clarify the tuple syntax once and for all by studying my detailed blog article.

Related Article : Python Ternary — Tuple Syntax Hack

Python One-Liners Book: Master the Single Line First!

Python programmers will improve their computer science skills with these useful one-liners.

Python One-Liners will teach you how to read and write “one-liners”: concise statements of useful functionality packed into a single line of code. You’ll learn how to systematically unpack and understand any line of Python code, and write eloquent, powerfully compressed Python like an expert.

The book’s five chapters cover (1) tips and tricks, (2) regular expressions, (3) machine learning, (4) core data science topics, and (5) useful algorithms.

Detailed explanations of one-liners introduce key computer science concepts and boost your coding and analytical skills . You’ll learn about advanced Python features such as list comprehension , slicing , lambda functions , regular expressions , map and reduce functions, and slice assignments .

You’ll also learn how to:

• Leverage data structures to solve real-world problems , like using Boolean indexing to find cities with above-average pollution
• Use NumPy basics such as array , shape , axis , type , broadcasting , advanced indexing , slicing , sorting , searching , aggregating , and statistics
• Calculate basic statistics of multidimensional data arrays and the K-Means algorithms for unsupervised learning
• Create more advanced regular expressions using grouping and named groups , negative lookaheads , escaped characters , whitespaces, character sets (and negative characters sets ), and greedy/nongreedy operators
• Understand a wide range of computer science topics , including anagrams , palindromes , supersets , permutations , factorials , prime numbers , Fibonacci numbers, obfuscation , searching , and algorithmic sorting

By the end of the book, you’ll know how to write Python at its most refined , and create concise, beautiful pieces of “Python art” in merely a single line.

Get your Python One-Liners on Amazon!!

Python If Else Statement – Conditional Statements Explained

There are many cases where you don't want all of your code to be executed in your programs.

Instead, you might want certain code to run only when a specific condition is met, and a different set of code to run when the condition is not satisified.

That's where conditional statements come in handy.

Conditional statements allow you to control the logical flow of programs in a clean and compact way.

They are branches – like forks in the road – that modify how code is executed and handle decision making.

This tutorial goes over the basics of if , if..else , and elif statements in the Python programming language, using examples along the way.

Let's get started!

The syntax of a basic if statement

An if statement in Python essentially says:

"If this expression evaluates to True, then run once the code that follows the exprerssion. If it isn't True, then don't run the block of code that follows."

The general syntax for a basic if statement looks something like this:

An if statement consists of:

• The if keyword, which starts the if statement.
• Then comes a condition. A condition can evaluate to either True or False. Parentheses ( () ) surrounding the condition are optional, but they do help improve the readability of the code when more than one condition is present.
• A colon : that separates the condition from the executable statement that follows.
• A new line.
• A level of indentation of 4 spaces, which is a Python convention. The level of indentation is associated with the body of the statement that follows.
• Lastly comes the body of the statement. This is the code that will run only if the statement evaluated to True. We can have multiple lines in the body that can be executed, and in that case we need to be careful they all have the same level of indentation.

Let's take the following example:

In the example above, we created two variables, a and b , and assigned them the values 1 and 2 , respectively.

The phrase in the print statement does in fact get printed to the console because the condition b > a evaluated to True, so the code that followed it ran. If it wasn't True, nothing would have happend. No code would have run.

If we had instead done this:

No code would have been executed and nothing would have been printed to the console.

How do Python if..else statements work?

An if statement runs code only when a condition is met. Nothing happens otherwise.

What if we also want code to run when the condition is not met? That's where the else part comes in.

The syntax of an if..else statement looks like this:

An if..else statement in Python means:

"When the if expression evaluates to True, then execute the code that follows it. But if it evalates to False, then run the code that follows the else statement"

The else statement is written on a new line after the last line of indented code and it can't be written by itself. An else statement is part of an if statement.

The code following it also needs to be indented with 4 spaces to show it is part of the else clause.

The code following the else statement gets executed if and only if the if statement is False. If your if statement is True and therefore the code ran, then the code in the else block will never run.

Here, the line of code following the else statement, print("a is in fact bigger than b") , will never run. The if statement that came before it is True so only that code runs instead.

The else block runs when:

Be aware that you can't write any other code between if and else . You'll get a SyntaxError if you do so:

How does elif work in Python?

What if we want to have more than just two options?

Instead of saying: "If the first condition is true do this, otherwise do that instead", now we say "If this isn't True, try this instead, and if all conditions fail to be True, resort to doing this".

elif stands for else, if.

The basic syntax looks like this:

We can use more than one elif statement. This gives us more conditions and more options.

For example:

In this example, the if statement tests a specific condition, the elif blocks are two alternatives, and the else block is the last solution when all the previous conditions have not been met.

Be aware of the order in which you write your elif statements.

In the previous example, if you had written:

The line x is less than 20! would have been executed because it came first.

The elif statement makes code easier to write. You can use it instead of keeping track of if..else statements as programs get more complex and grow in size.

If all the elif statements are not considered and are False, then and only then as the last resort will the code following the else statement run.

For example, here's a case when the else statement would run:

And that's it!

Those are the basic principles of if , if..else and elif in Python to get you started with conditional statements.

From here the statements can get more advanced and complex.

Conditional statements can be nested inside of other conditional statements, depending on the problem you're trying to solve and the logic behind the solution.

Thanks for reading and happy coding!

Read more posts .

If this article was helpful, share it .

Learn to code for free. freeCodeCamp's open source curriculum has helped more than 40,000 people get jobs as developers. Get started

Python - if, elif, else Conditions

By default, statements in the script are executed sequentially from the first to the last. If the processing logic requires so, the sequential flow can be altered in two ways:

Python uses the if keyword to implement decision control. Python's syntax for executing a block conditionally is as below:

Any Boolean expression evaluating to True or False appears after the if keyword. Use the : symbol and press Enter after the expression to start a block with an increased indent. One or more statements written with the same level of indent will be executed if the Boolean expression evaluates to True .

To end the block, decrease the indentation. Subsequent statements after the block will be executed out of the if condition. The following example demonstrates the if condition.

In the above example, the expression price < 100 evaluates to True , so it will execute the block. The if block starts from the new line after : and all the statements under the if condition starts with an increased indentation, either space or tab. Above, the if block contains only one statement. The following example has multiple statements in the if condition.

Above, the if condition contains multiple statements with the same indentation. If all the statements are not in the same indentation, either space or a tab then it will raise an IdentationError .

The statements with the same indentation level as if condition will not consider in the if block. They will consider out of the if condition.

The following example demonstrates multiple if conditions.

Notice that each if block contains a statement in a different indentation, and that's valid because they are different from each other.

else Condition

Along with the if statement, the else condition can be optionally used to define an alternate block of statements to be executed if the boolean expression in the if condition evaluates to False .

As mentioned before, the indented block starts after the : symbol, after the boolean expression. It will get executed when the condition is True . We have another block that should be executed when the if condition is False . First, complete the if block by a backspace and write else , put add the : symbol in front of the new block to begin it, and add the required statements in the block.

In the above example, the if condition price >= 100 is False , so the else block will be executed. The else block can also contain multiple statements with the same indentation; otherwise, it will raise the IndentationError .

Note that you cannot have multiple else blocks, and it must be the last block.

elif Condition

Use the elif condition is used to include multiple conditional expressions after the if condition or between the if and else conditions.

The elif block is executed if the specified condition evaluates to True .

In the above example, the elif conditions are applied after the if condition. Python will evalute the if condition and if it evaluates to False then it will evalute the elif blocks and execute the elif block whose expression evaluates to True . If multiple elif conditions become True , then the first elif block will be executed.

The following example demonstrates if, elif, and else conditions.

All the if, elif, and else conditions must start from the same indentation level, otherwise it will raise the IndentationError .

Nested if, elif, else Conditions

Python supports nested if, elif, and else condition. The inner condition must be with increased indentation than the outer condition, and all the statements under the one block should be with the same indentation.

• Compare strings in Python
• Convert file data to list
• Convert User Input to a Number
• Convert String to Datetime in Python
• How to call external commands in Python?
• How to count the occurrences of a list item?
• How to flatten list in Python?
• How to merge dictionaries in Python?
• How to pass value by reference in Python?
• Remove duplicate items from list in Python
• More Python articles

We are a team of passionate developers, educators, and technology enthusiasts who, with their combined expertise and experience, create in -depth, comprehensive, and easy to understand tutorials.We focus on a blend of theoretical explanations and practical examples to encourages hands - on learning. Visit About Us page for more information.

• Python Questions & Answers
• Python Skill Test
• Python Latest Articles

10 if-else Practice Problems in Python

• learn python
• python programming

If you're trying to learn Python, you need to practice! These ten if-else Python practice problems provide you some hands-on experience. And don’t worry – we’ve provided full code solutions and detailed explanations!

Python is particularly good for beginners to learn. Its clear syntax can be read almost as clearly as a normal sentence. The if-else statement is a good example of this; it lets you build logic into your programs. This article will walk you through ten i f-else practice exercises in Python. Each one is specifically designed for beginners, helping you hone your understanding of if-else statements.

The exercises in this article are taken directly from our courses, including Python Basics: Part 1 . This course helps absolute beginners understand computer programming with Python; if you’ve never written a line of code, this course is a great place to start.

As the saying goes, practice makes perfect. Learning Python is no exception. As we discuss in Different Ways to Practice Python , doing online courses is a great way to practice a variety of topics. The more you practice writing code, the more comfortable and confident you'll become in your abilities. So – whether you aim to build your own software, delve into data science, or automate mundane tasks – dedicating time to practice is key.

The Python if-else Statement

Before we dive into the exercises, let's briefly discuss the workings of if-else statements in Python. An if-else statement allows your program to make decisions based on certain conditions. The syntax is straightforward:

• You provide a condition to evaluate within the if
• If that condition is true, the corresponding block of code is executed.
• If the condition is false, the code within the optional else block is executed instead.

Here's a simple example:

In this example, if the value of x is greater than 5, the program will print "x is greater than 5"; otherwise, it will print "x is not greater than 5".

This concept forms the backbone of decision-making in Python programs.

To get the most benefit from this article, attempt the problems before reading the solutions. Some of these exercises will have several possible solutions, so also try to think about alternative ways to solve the same problem. Let’s get started.

10 if-else Python Practice Exercises

Exercise 1: are you tall.

Exercise: Write a program that will ask the user for their height in centimeters. Use the input() built-in function to do this. If the height is more than 185 centimeters, print the following line of code:

Explanation: This is a similar syntax to the above template example. The height variable stores the user input as an integer and tests if it’s greater than 185 cm. If so, the message is printed. Notice there is no else; this means if the height is less than or equal to 185, nothing happens.

Exercise 2: More Options

Exercise: Write a program that will ask the user the following question:

• If the user answers y , print: Wrong! Canberra is the capital!
• If the user answers n , print: Correct!
• If the user answers anything else, print: I do not understand your answer!

Explanation: The if statement can be extended with an elif (i.e. else if) to check any answer that returns False to the first condition. If the elif statement also returns False , the indented block under the else is executed.

Exercise 3: Check If a Character Is in a String

Exercise: Write a program to ask the user to do the following:

• Provide the name of a country that does not contain any lowercase a or e letters. (Use the prompt: The country is : )
• If the user provides a correct string (i.e. one with no a or e inside it), print: You won... unless you made this name up!
• Otherwise, print: You lost!

(By the way, possible answers include Hong Kong, Cyprus, and Togo.)

Explanation: This code prompts the user to input a country name using the built-in input() function. Then, it checks if the letters 'a' or 'e' is present in the inputted country name using the in operator. If either letter is found, it prints "You lost!". Otherwise, it prints "You won... unless you made this name up!" using the else statement.

Exercise 4: Count Letter Frequency in a String

Exercise: The letter e is said to be the most frequent letter in the English language. Count and print how many times this letter appears in the poem below:

John Knox was a man of wondrous might, And his words ran high and shrill, For bold and stout was his spirit bright, And strong was his stalwart will. Kings sought in vain his mind to chain, And that giant brain to control, But naught on plain or stormy main Could daunt that mighty soul. John would sit and sigh till morning cold Its shining lamps put out, For thoughts untold on his mind lay hold, And brought but pain and doubt. But light at last on his soul was cast, Away sank pain and sorrow, His soul is gay, in a fair to-day, And looks for a bright to-morrow. (Source: "Unidentified," in Current Opinion, July 1888)

Explanation: The solution starts by initializing a counter with the value of 0. Then a for loop is used to loop through every letter in the string variable poem. The if statement tests if the current letter is an e; if it is, the counter is incremented by 1. Finally, the result of the counter is printed. Note that there is no else needed in this solution, since nothing should happen if the letter is not an e.

Exercise 5: Format Recipes

Exercise: Anne loves cooking and she tries out various recipes from the Internet. Sometimes, though, she finds recipes that are written as a single paragraph of text. For instance:

When you're in the middle of cooking, such a paragraph is difficult to read. Anne would prefer an ordered list, like this:

• Cut a slit into the chicken breast.
• Stuff it with mustard, mozzarella and cheddar.
• Secure the whole thing with rashers of bacon.
• Roast for 20 minutes at 200C.

Write a Python script that accepts a recipe string from the user ('Paste your recipe: ') and prints an ordered list of sentences, just like in the example above.

Each sentence of both the input and output should end with a single period.

Explanation: The solution takes a recipe input from the user with input() , then iterates through each character in the recipe. Whenever it encounters a period ( '.' ), it increments a counter, adds a new line character ( '\n' ) and the incremented counter followed by a period to an ordered list. If it encounters any other character, it simply adds that character to the ordered list. Finally, it calculates the length of the counter, removes the last part of the ordered list to exclude the unnecessary counter, and prints the modified ordered list, which displays the recipe with numbered steps.

Exercise 6: Nested if Statements

Exercise: A leap year is a year that consists of 366 (not 365) days. It occurs roughly every four years. More specifically, a year is considered leap if it is either divisible by 4 but not by 100 or it is divisible by 400.

Write a program that asks the user for a year and replies with either leap year or not a leap year.

Explanation: This program takes a year from the user as input. It checks if the year is divisible by 4. If it is, it then checks if the year is divisible by 100. If it is, it further checks if the year is divisible by 400. If it is, it prints 'leap year' because it satisfies all the conditions for a leap year. This is all achieved with nesting.

If it's divisible by 4, but not by 100, or if it’s not divisible by 400, the program prints 'not a leap year'. If the year is not divisible by 100, it directly prints 'leap year' because it satisfies the basic condition for a leap year (being divisible by 4). If the year is not divisible by 4, it prints 'not a leap year'.

Exercise 7: Scrabble

Exercise: Create a function called can_build_word(letters_list, word) that takes a list of letters and a word. The function should return True if the word uses only the letters from the list.

Like in real Scrabble, you cannot use one tile twice in the same word. For example, if a list of letters contains only one 'a', ‘banana’ returns False. The function should also return False if the word contains any letters not in the list.

For example …

… should return True. On the other hand …

… should return False because there is only one 'f'.

One thing to keep in mind: Neither the provided letter list nor the word should be changed by your function. It may be tempting to remove letters from the letters list to remove the used tiles. This should not be the case. Instead, you should copy the passed list. Simply use the list() function and pass it another list:

This way we can safely operate on a copy of the list without changing the contents of the original list.

Explanation: The function starts by making a copy of the list of letters to avoid modifying the original. Then, it iterates through each letter in the word. For each letter, it checks if that letter exists in the list copy. If it does, it removes that letter from the copy, which ensures each letter is used only once.

If the letter doesn't exist in the copy of the letters list, it means the word cannot be formed using the available letters; it returns False. If all the letters in the word can be found and removed from the list copy, it means the word can indeed be formed; it returns True .

If you are looking for additional material to help you learn how to work with Python lists, our article 12 Beginner-Level Python List Exercises with Solutions has got you covered.

Exercise 8: for Loops and if Statements

Exercise: Write a program that asks for a positive integer and prints all of its divisors, one by one, on separate lines in ascending order.

A divisor is a number that divides a particular number with no remainder. For example, the divisors of 4 are 1, 2, and 4.

To check if a is a divisor of b , you can use the modulo operator %. a % b returns the remainder of dividing a by b . For example, 9 % 2 is 1 because 9 = (4 * 2) + 1, and 9 % 3 is 0 because 9 divides into 3 with no remainder. If a % b == 0 , then b is a divisor of a .

Explanation: This solution takes an input number from the user and then iterates through numbers from 1 to that input number (inclusive). For each number i in this range, it checks if the input number is divisible by i with no remainder ( number % i == 0 ). If the condition is satisfied, it means that i is a factor of the input number.

Looping is another important skill in Python. This problem could also be solved with a while loop. Take a look at 10 Python Loop Exercises with Solutions to learn more about for and while loops.

Exercise 9: if Statements and Data Structures

Exercise: Write a function named get_character_frequencies() that takes a string as input and returns a dictionary of lowercase characters as keys and the number of their occurrences as values. Ignore the case of a character.

Explanation: This function initializes an empty dictionary ( freq_dict ) to store the frequencies of characters. It iterates through each character in the input word using a for loop. Within the loop, it converts each character to lowercase using the lower() method; this ensures case-insensitive counting.

The program checks if the lowercase character is already a key in the dictionary. If it's not, it adds the character as a key and sets its frequency to 1. If it is already a key, it increments the frequency count for that character by 1 and returns the dictionary.

If you’re not familiar with how Python dictionaries work, Top 10 Python Dictionary Exercises for Beginners will give you experience working with this important data structure.

Exercise 10: if Statements and Multiple Returns

Exercise: Write a function named return_bigger(a, b) that takes two numbers and returns the bigger one. If the numbers are equal, return 0.

Explanation: When using if statements in a function, you can define a return value in the indented block of code under the if-else statement. This makes your code simpler and more readable – another great example of the clear syntax which makes Python such an attractive tool for all programmers.

Do You Want More Python Practice Exercises?

Learning anything new is a challenge. Relying on a variety of resources is a good way to get a broad background. Read some books and blogs to get a theoretical understanding, watch videos online, take advantage of the active Python community on platforms like Stack Overflow . And most importantly, do some hands-on practice. We discuss these points in detail in What’s the Best Way to Practice Python?

The Python practice exercises and solutions shown here were taken directly from several of our interactive online courses, including Python Basics Practice , Python Practice: Word Games , and Working with Strings in Python . The courses build up your skills and knowledge, giving you exposure to a variety of topics.

And if you’re already motivated to take your skills to the next level, have a go at another 10 Python Practice Exercises for Beginners with Solutions . Happy coding!

3.3.2.4. __slots__ ¶

__slots__ allow us to explicitly declare data members (like properties) and deny the creation of __dict__ and __weakref__ (unless explicitly declared in __slots__ or available in a parent.)

The space saved over using __dict__ can be significant. Attribute lookup speed can be significantly improved as well.

This class variable can be assigned a string, iterable, or sequence of strings with variable names used by instances. __slots__ reserves space for the declared variables and prevents the automatic creation of __dict__ and __weakref__ for each instance.

Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Get early access and see previews of new features.

What happens to re-assignment of previous variables [duplicate]

I always thought if you assigned a new variable to a variable holding a mutable type that it stores the address of the mutable type rather than copying it. But why has a re-assignment of a variable holding a mutable type caused a copying of the mutable? Does dict1 allocate new memory to store None and dict2 stores the dictionary or how does it work?

Googled but nothing came up

• 2 nedbatchelder.com/text/names.html –  John Gordon Commented 1 hour ago
• How did you find that so quick? Are you ned? –  Wander verse Commented 1 hour ago
• Python does the allocation of memory itself. The variables only hold a single reference to memory, but can be reseated at any time. –  quamrana Commented 1 hour ago
• 1 Many programmers ask the same question. I too have a link to that article. –  quamrana Commented 1 hour ago
• 1 If it helps, you can think of a variable in python as a "box of stuff" (the value), with a post-it note stuck to the side with a name written on it (the name). On the first line of code in your question, you created a box of stuff (the dictionary) and stuck the name "dict1" to it. Then on the second line you stuck the name "dict2" onto the same box (so now the box has two names). Then on the third line you removed the name "dict1" from that box, leaving it with only the name "dict2", and stuck the name "dict1" onto a different box. –  John Gordon Commented 1 hour ago

2 Answers 2

• The {"1": "Hello", "2": "Joe", "3": "Bloggs"} creates a dictionary.
• The dict1 = assigns the name dict1 to refer to that dictionary.
• After dict2 = dict1 both names dict1 and dict2 refer to the same dictionary
• None references a None object.
• The dict1 = now assigns the name dict1 to refer to that None obejct.
• After all that, dict2 still refers to the dictionary created in step 1.

• Ooooo look at you –  Wander verse Commented 5 mins ago

What is happening is that:

• You are creating a dictionary called dict1.
• You are saying that dict2 = dict1, making dict2 have all the same things as dict1.
• dict1 is changed to None, dict2 is not affected, as it was assigned to dict1 when dict1 wasn't None. Therefore, when you print dict2, it will print what was in dict1 in the beginning ({"1": "Hello", "2": "Joe", "3": "Bloggs"})

• Nice, thanks for repeating what i said. Now, whats the reason. –  Wander verse Commented 1 hour ago
• 2 This answer makes it sound like there are two dicts (" making dict2 have all the same things as dict1 ") which is very much not the case, and the crux of the issue (i.e. how Python names are not variables in the traditional sense). –  Andras Deak -- Слава Україні Commented 1 hour ago

Not the answer you're looking for? Browse other questions tagged python or ask your own question .

• The Overflow Blog
• Ryan Dahl explains why Deno had to evolve with version 2.0
• From PHP to JavaScript to Kubernetes: how one backend engineer evolved over time
• Featured on Meta
• We've made changes to our Terms of Service & Privacy Policy - July 2024
• Bringing clarity to status tag usage on meta sites
• Feedback requested: How do you use tag hover descriptions for curating and do...
• What does a new user need in a homepage experience on Stack Overflow?

Hot Network Questions

• How should I respond to a former student from my old institution asking for a reference?
• Short story in which the protagonist shrinks to the size of his model train set and is run over by one of his trains
• The hat-check problem
• Is there anything that stops the majority shareholder(s) from destroying company value?
• How would I make an agent noun out of the word "autodice -es f" or "autodicia"
• How to justify a ban on single-deity religions?
• How does quantum field theory affect the ontological tenability of composite objects?
• Data pipeline that handles errors and cancellations
• Thai word not breaking properly between lines, in LuaLaTeX
• What does the Fizeau experiment now do?
• Are there any original heat shield tiles on any of the retired space shuttles that flew to space?
• Which translation of Psalm 113:9 is closest to the original?
• Do cities usually form at the mouth of rivers or closer to the headwaters?
• python stats.spearmanr and R cor.test(method='spearman') don't return the same p-value?
• Is the error in translation of Genesis 19:5 deliberate?
• Why do combinatorists care about Kazhdan–Lusztig polynomials?
• If Miles doesn’t consider Peter’s actions as hacking, then what does he think Peter is doing to the computer?
• Fast circular buffer
• Are there any virtues in virtue ethics that cannot be plausibly grounded in more fundamental utilitarian principles?
• Sticker on caption phone says that using the captions can be illegal. Why?
• Can I use rear (thru) axle with crack for a few rides, before getting a new one?
• Was there a term in OT times to describe the relationship between two wives of the same man?
• How to extract code into library allowing changes without workflow overhead
• Should a single person handle communication between team and external entities?