- Assignment Statement
An Assignment statement is a statement that is used to set a value to the variable name in a program .
Assignment statement allows a variable to hold different types of values during its program lifespan. Another way of understanding an assignment statement is, it stores a value in the memory location which is denoted by a variable name.
![what is a assignment statement Assignment Statement Method](https://d1whtlypfis84e.cloudfront.net/guides/wp-content/uploads/2021/03/08194209/Assign-statement.jpg)
The symbol used in an assignment statement is called as an operator . The symbol is ‘=’ .
Note: The Assignment Operator should never be used for Equality purpose which is double equal sign ‘==’.
The Basic Syntax of Assignment Statement in a programming language is :
variable = expression ;
variable = variable name
expression = it could be either a direct value or a math expression/formula or a function call
Few programming languages such as Java, C, C++ require data type to be specified for the variable, so that it is easy to allocate memory space and store those values during program execution.
data_type variable_name = value ;
In the above-given examples, Variable ‘a’ is assigned a value in the same statement as per its defined data type. A data type is only declared for Variable ‘b’. In the 3 rd line of code, Variable ‘a’ is reassigned the value 25. The 4 th line of code assigns the value for Variable ‘b’.
![](http://mangareview.fun/777/templates/cheerup/res/banner1.gif)
Assignment Statement Forms
This is one of the most common forms of Assignment Statements. Here the Variable name is defined, initialized, and assigned a value in the same statement. This form is generally used when we want to use the Variable quite a few times and we do not want to change its value very frequently.
Tuple Assignment
Generally, we use this form when we want to define and assign values for more than 1 variable at the same time. This saves time and is an easy method. Note that here every individual variable has a different value assigned to it.
(Code In Python)
Sequence Assignment
(Code in Python)
Multiple-target Assignment or Chain Assignment
In this format, a single value is assigned to two or more variables.
Augmented Assignment
In this format, we use the combination of mathematical expressions and values for the Variable. Other augmented Assignment forms are: &=, -=, **=, etc.
Browse more Topics Under Data Types, Variables and Constants
- Concept of Data types
- Built-in Data Types
- Constants in Programing Language
- Access Modifier
- Variables of Built-in-Datatypes
- Declaration/Initialization of Variables
- Type Modifier
Few Rules for Assignment Statement
Few Rules to be followed while writing the Assignment Statements are:
- Variable names must begin with a letter, underscore, non-number character. Each language has its own conventions.
- The Data type defined and the variable value must match.
- A variable name once defined can only be used once in the program. You cannot define it again to store other types of value.
- If you assign a new value to an existing variable, it will overwrite the previous value and assign the new value.
FAQs on Assignment Statement
Q1. Which of the following shows the syntax of an assignment statement ?
- variablename = expression ;
- expression = variable ;
- datatype = variablename ;
- expression = datatype variable ;
Answer – Option A.
Q2. What is an expression ?
- Same as statement
- List of statements that make up a program
- Combination of literals, operators, variables, math formulas used to calculate a value
- Numbers expressed in digits
Answer – Option C.
Q3. What are the two steps that take place when an assignment statement is executed?
- Evaluate the expression, store the value in the variable
- Reserve memory, fill it with value
- Evaluate variable, store the result
- Store the value in the variable, evaluate the expression.
Customize your course in 30 seconds
Which class are you in.
![what is a assignment statement tutor](https://www.toppr.com/bytes/wp-content/themes/bytes-v2/images/live-classes/tutor-1.png)
Data Types, Variables and Constants
- Variables in Programming Language
- Concept of Data Types
- Declaration of Variables
- Type Modifiers
- Access Modifiers
- Constants in Programming Language
Leave a Reply Cancel reply
Your email address will not be published. Required fields are marked *
Download the App
![what is a assignment statement Google Play](https://www.toppr.com/guides/wp-content/themes/toppr-guides-v1/images/play-store.png)
- Python Course
- Python Basics
- Interview Questions
- Python Quiz
- Popular Packages
- Python Projects
- Practice Python
- AI With Python
- Learn Python3
- Python Automation
- Python Web Dev
- DSA with Python
- Python OOPs
- Dictionaries
Different Forms of Assignment Statements in Python
We use Python assignment statements to assign objects to names. The target of an assignment statement is written on the left side of the equal sign (=), and the object on the right can be an arbitrary expression that computes an object.
There are some important properties of assignment in Python :-
- Assignment creates object references instead of copying the objects.
- Python creates a variable name the first time when they are assigned a value.
- Names must be assigned before being referenced.
- There are some operations that perform assignments implicitly.
Assignment statement forms :-
1. Basic form:
This form is the most common form.
2. Tuple assignment:
When we code a tuple on the left side of the =, Python pairs objects on the right side with targets on the left by position and assigns them from left to right. Therefore, the values of x and y are 50 and 100 respectively.
3. List assignment:
This works in the same way as the tuple assignment.
4. Sequence assignment:
In recent version of Python, tuple and list assignment have been generalized into instances of what we now call sequence assignment – any sequence of names can be assigned to any sequence of values, and Python assigns the items one at a time by position.
5. Extended Sequence unpacking:
It allows us to be more flexible in how we select portions of a sequence to assign.
Here, p is matched with the first character in the string on the right and q with the rest. The starred name (*q) is assigned a list, which collects all items in the sequence not assigned to other names.
This is especially handy for a common coding pattern such as splitting a sequence and accessing its front and rest part.
6. Multiple- target assignment:
In this form, Python assigns a reference to the same object (the object which is rightmost) to all the target on the left.
7. Augmented assignment :
The augmented assignment is a shorthand assignment that combines an expression and an assignment.
There are several other augmented assignment forms:
Please Login to comment...
Similar reads.
- Python Programs
- python-basics
- How to Delete Discord Servers: Step by Step Guide
- Google increases YouTube Premium price in India: Check our the latest plans
- California Lawmakers Pass Bill to Limit AI Replicas
- Best 10 IPTV Service Providers in Germany
- 15 Most Important Aptitude Topics For Placements [2024]
Improve your Coding Skills with Practice
What kind of Experience do you want to share?
![what is a assignment statement what is a assignment statement](https://runestone.academy/ns/books/published/csjava/_static/img/RAIcon.png)
- Table of Contents
- Course Home
- Assignments
- Peer Instruction (Instructor)
- Peer Instruction (Student)
- Change Course
- Instructor's Page
- Progress Page
- Edit Profile
- Change Password
- Scratch ActiveCode
- Scratch Activecode
- Instructors Guide
- About Runestone
- Report A Problem
- 1.1 Preface
- 1.2 Why Programming? Why Java?
- 1.3 Variables and Data Types
- 1.4 Expressions and Assignment Statements
- 1.5 Compound Assignment Operators
- 1.6 Casting and Ranges of Variables
- 1.7 Java Development Environments (optional)
- 1.8 Unit 1 Summary
- 1.9 Unit 1 Mixed Up Code Practice
- 1.10 Unit 1 Coding Practice
- 1.11 Multiple Choice Exercises
- 1.12 Lesson Workspace
- 1.3. Variables and Data Types" data-toggle="tooltip">
- 1.5. Compound Assignment Operators' data-toggle="tooltip" >
1.4. Expressions and Assignment Statements ¶
In this lesson, you will learn about assignment statements and expressions that contain math operators and variables.
1.4.1. Assignment Statements ¶
Remember that a variable holds a value that can change or vary. Assignment statements initialize or change the value stored in a variable using the assignment operator = . An assignment statement always has a single variable on the left hand side of the = sign. The value of the expression on the right hand side of the = sign (which can contain math operators and other variables) is copied into the memory location of the variable on the left hand side.
![what is a assignment statement Assignment statement](https://runestone.academy/ns/books/published/csjava/_images/assignment.png)
Figure 1: Assignment Statement (variable = expression) ¶
Instead of saying equals for the = operator in an assignment statement, say “gets” or “is assigned” to remember that the variable on the left hand side gets or is assigned the value on the right. In the figure above, score is assigned the value of 10 times points (which is another variable) plus 5.
The following video by Dr. Colleen Lewis shows how variables can change values in memory using assignment statements.
As we saw in the video, we can set one variable to a copy of the value of another variable like y = x;. This won’t change the value of the variable that you are copying from.
![what is a assignment statement coding exercise](https://runestone.academy/ns/books/published/csjava/_images/codingExercise.png)
Click on the Show CodeLens button to step through the code and see how the values of the variables change.
The program is supposed to figure out the total money value given the number of dimes, quarters and nickels. There is an error in the calculation of the total. Fix the error to compute the correct amount.
Calculate and print the total pay given the weekly salary and the number of weeks worked. Use string concatenation with the totalPay variable to produce the output Total Pay = $3000 . Don’t hardcode the number 3000 in your print statement.
![what is a assignment statement exercise](https://runestone.academy/ns/books/published/csjava/_images/exercise.png)
Assume you have a package with a given height 3 inches and width 5 inches. If the package is rotated 90 degrees, you should swap the values for the height and width. The code below makes an attempt to swap the values stored in two variables h and w, which represent height and width. Variable h should end up with w’s initial value of 5 and w should get h’s initial value of 3. Unfortunately this code has an error and does not work. Use the CodeLens to step through the code to understand why it fails to swap the values in h and w.
1-4-7: Explain in your own words why the ErrorSwap program code does not swap the values stored in h and w.
Swapping two variables requires a third variable. Before assigning h = w , you need to store the original value of h in the temporary variable. In the mixed up programs below, drag the blocks to the right to put them in the right order.
The following has the correct code that uses a third variable named “temp” to swap the values in h and w.
The code is mixed up and contains one extra block which is not needed in a correct solution. Drag the needed blocks from the left into the correct order on the right, then check your solution. You will be told if any of the blocks are in the wrong order or if you need to remove one or more blocks.
After three incorrect attempts you will be able to use the Help Me button to make the problem easier.
Fix the code below to perform a correct swap of h and w. You need to add a new variable named temp to use for the swap.
1.4.2. Incrementing the value of a variable ¶
If you use a variable to keep score you would probably increment it (add one to the current value) whenever score should go up. You can do this by setting the variable to the current value of the variable plus one (score = score + 1) as shown below. The formula looks a little crazy in math class, but it makes sense in coding because the variable on the left is set to the value of the arithmetic expression on the right. So, the score variable is set to the previous value of score + 1.
Click on the Show CodeLens button to step through the code and see how the score value changes.
1-4-11: What is the value of b after the following code executes?
- It sets the value for the variable on the left to the value from evaluating the right side. What is 5 * 2?
- Correct. 5 * 2 is 10.
1-4-12: What are the values of x, y, and z after the following code executes?
- x = 0, y = 1, z = 2
- These are the initial values in the variable, but the values are changed.
- x = 1, y = 2, z = 3
- x changes to y's initial value, y's value is doubled, and z is set to 3
- x = 2, y = 2, z = 3
- Remember that the equal sign doesn't mean that the two sides are equal. It sets the value for the variable on the left to the value from evaluating the right side.
- x = 1, y = 0, z = 3
1.4.3. Operators ¶
Java uses the standard mathematical operators for addition ( + ), subtraction ( - ), multiplication ( * ), and division ( / ). Arithmetic expressions can be of type int or double. An arithmetic operation that uses two int values will evaluate to an int value. An arithmetic operation that uses at least one double value will evaluate to a double value. (You may have noticed that + was also used to put text together in the input program above – more on this when we talk about strings.)
Java uses the operator == to test if the value on the left is equal to the value on the right and != to test if two items are not equal. Don’t get one equal sign = confused with two equal signs == ! They mean different things in Java. One equal sign is used to assign a value to a variable. Two equal signs are used to test a variable to see if it is a certain value and that returns true or false as you’ll see below. Use == and != only with int values and not doubles because double values are an approximation and 3.3333 will not equal 3.3334 even though they are very close.
Run the code below to see all the operators in action. Do all of those operators do what you expected? What about 2 / 3 ? Isn’t surprising that it prints 0 ? See the note below.
When Java sees you doing integer division (or any operation with integers) it assumes you want an integer result so it throws away anything after the decimal point in the answer, essentially rounding down the answer to a whole number. If you need a double answer, you should make at least one of the values in the expression a double like 2.0.
With division, another thing to watch out for is dividing by 0. An attempt to divide an integer by zero will result in an ArithmeticException error message. Try it in one of the active code windows above.
Operators can be used to create compound expressions with more than one operator. You can either use a literal value which is a fixed value like 2, or variables in them. When compound expressions are evaluated, operator precedence rules are used, so that *, /, and % are done before + and -. However, anything in parentheses is done first. It doesn’t hurt to put in extra parentheses if you are unsure as to what will be done first.
In the example below, try to guess what it will print out and then run it to see if you are right. Remember to consider operator precedence .
1-4-15: Consider the following code segment. Be careful about integer division.
What is printed when the code segment is executed?
- 0.666666666666667
- Don't forget that division and multiplication will be done first due to operator precedence.
- Yes, this is equivalent to (5 + ((a/b)*c) - 1).
- Don't forget that division and multiplication will be done first due to operator precedence, and that an int/int gives an int result where it is rounded down to the nearest int.
1-4-16: Consider the following code segment.
What is the value of the expression?
- Dividing an integer by an integer results in an integer
- Correct. Dividing an integer by an integer results in an integer
- The value 5.5 will be rounded down to 5
1-4-17: Consider the following code segment.
- Correct. Dividing a double by an integer results in a double
- Dividing a double by an integer results in a double
1-4-18: Consider the following code segment.
- Correct. Dividing an integer by an double results in a double
- Dividing an integer by an double results in a double
1.4.4. The Modulo Operator ¶
The percent sign operator ( % ) is the mod (modulo) or remainder operator. The mod operator ( x % y ) returns the remainder after you divide x (first number) by y (second number) so 5 % 2 will return 1 since 2 goes into 5 two times with a remainder of 1. Remember long division when you had to specify how many times one number went into another evenly and the remainder? That remainder is what is returned by the modulo operator.
![what is a assignment statement ../_images/mod-py.png](https://runestone.academy/ns/books/published/csjava/_images/mod-py.png)
Figure 2: Long division showing the whole number result and the remainder ¶
In the example below, try to guess what it will print out and then run it to see if you are right.
The result of x % y when x is smaller than y is always x . The value y can’t go into x at all (goes in 0 times), since x is smaller than y , so the result is just x . So if you see 2 % 3 the result is 2 .
1-4-21: What is the result of 158 % 10?
- This would be the result of 158 divided by 10. modulo gives you the remainder.
- modulo gives you the remainder after the division.
- When you divide 158 by 10 you get a remainder of 8.
1-4-22: What is the result of 3 % 8?
- 8 goes into 3 no times so the remainder is 3. The remainder of a smaller number divided by a larger number is always the smaller number!
- This would be the remainder if the question was 8 % 3 but here we are asking for the reminder after we divide 3 by 8.
- What is the remainder after you divide 3 by 8?
1.4.5. FlowCharting ¶
Assume you have 16 pieces of pizza and 5 people. If everyone gets the same number of slices, how many slices does each person get? Are there any leftover pieces?
In industry, a flowchart is used to describe a process through symbols and text. A flowchart usually does not show variable declarations, but it can show assignment statements (drawn as rectangle) and output statements (drawn as rhomboid).
The flowchart in figure 3 shows a process to compute the fair distribution of pizza slices among a number of people. The process relies on integer division to determine slices per person, and the mod operator to determine remaining slices.
![what is a assignment statement Flow Chart](https://runestone.academy/ns/books/published/csjava/_images/flow_1.png)
Figure 3: Example Flow Chart ¶
A flowchart shows pseudo-code, which is like Java but not exactly the same. Syntactic details like semi-colons are omitted, and input and output is described in abstract terms.
Complete the program based on the process shown in the Figure 3 flowchart. Note the first line of code declares all 4 variables as type int. Add assignment statements and print statements to compute and print the slices per person and leftover slices. Use System.out.println for output.
1.4.6. Storing User Input in Variables ¶
Variables are a powerful abstraction in programming because the same algorithm can be used with different input values saved in variables.
![what is a assignment statement Program input and output](https://runestone.academy/ns/books/published/csjava/_images/iostream.png)
Figure 4: Program input and output ¶
A Java program can ask the user to type in one or more values. The Java class Scanner is used to read from the keyboard input stream, which is referenced by System.in . Normally the keyboard input is typed into a console window, but since this is running in a browser you will type in a small textbox window displayed below the code. The code below shows an example of prompting the user to enter a name and then printing a greeting. The code String name = scan.nextLine() gets the string value you enter as program input and then stores the value in a variable.
Run the program a few times, typing in a different name. The code works for any name: behold, the power of variables!
Run this program to read in a name from the input stream. You can type a different name in the input window shown below the code.
Try stepping through the code with the CodeLens tool to see how the name variable is assigned to the value read by the scanner. You will have to click “Hide CodeLens” and then “Show in CodeLens” to enter a different name for input.
The Scanner class has several useful methods for reading user input. A token is a sequence of characters separated by white space.
Method | Description |
---|---|
nextLine() | Scans all input up to the line break as a String |
next() | Scans the next token of the input as a String |
nextInt() | Scans the next token of the input as an int |
nextDouble() | Scans the next token of the input as a double |
nextBoolean() | Scans the next token of the input as a boolean |
Run this program to read in an integer from the input stream. You can type a different integer value in the input window shown below the code.
A rhomboid (slanted rectangle) is used in a flowchart to depict data flowing into and out of a program. The previous flowchart in Figure 3 used a rhomboid to indicate program output. A rhomboid is also used to denote reading a value from the input stream.
![what is a assignment statement Flow Chart](https://runestone.academy/ns/books/published/csjava/_images/flow_2.png)
Figure 5: Flow Chart Reading User Input ¶
Figure 5 contains an updated version of the pizza calculator process. The first two steps have been altered to initialize the pizzaSlices and numPeople variables by reading two values from the input stream. In Java this will be done using a Scanner object and reading from System.in.
Complete the program based on the process shown in the Figure 5 flowchart. The program should scan two integer values to initialize pizzaSlices and numPeople. Run the program a few times to experiment with different values for input. What happens if you enter 0 for the number of people? The program will bomb due to division by zero! We will see how to prevent this in a later lesson.
The program below reads two integer values from the input stream and attempts to print the sum. Unfortunately there is a problem with the last line of code that prints the sum.
Run the program and look at the result. When the input is 5 and 7 , the output is Sum is 57 . Both of the + operators in the print statement are performing string concatenation. While the first + operator should perform string concatenation, the second + operator should perform addition. You can force the second + operator to perform addition by putting the arithmetic expression in parentheses ( num1 + num2 ) .
More information on using the Scanner class can be found here https://www.w3schools.com/java/java_user_input.asp
1.4.7. Programming Challenge : Dog Years ¶
In this programming challenge, you will calculate your age, and your pet’s age from your birthdates, and your pet’s age in dog years. In the code below, type in the current year, the year you were born, the year your dog or cat was born (if you don’t have one, make one up!) in the variables below. Then write formulas in assignment statements to calculate how old you are, how old your dog or cat is, and how old they are in dog years which is 7 times a human year. Finally, print it all out.
Calculate your age and your pet’s age from the birthdates, and then your pet’s age in dog years. If you want an extra challenge, try reading the values using a Scanner.
1.4.8. Summary ¶
Arithmetic expressions include expressions of type int and double.
The arithmetic operators consist of +, -, * , /, and % (modulo for the remainder in division).
An arithmetic operation that uses two int values will evaluate to an int value. With integer division, any decimal part in the result will be thrown away, essentially rounding down the answer to a whole number.
An arithmetic operation that uses at least one double value will evaluate to a double value.
Operators can be used to construct compound expressions.
During evaluation, operands are associated with operators according to operator precedence to determine how they are grouped. (*, /, % have precedence over + and -, unless parentheses are used to group those.)
An attempt to divide an integer by zero will result in an ArithmeticException to occur.
The assignment operator (=) allows a program to initialize or change the value stored in a variable. The value of the expression on the right is stored in the variable on the left.
During execution, expressions are evaluated to produce a single value.
The value of an expression has a type based on the evaluation of the expression.
![what is a assignment statement Logo for Rebus Press](https://press.rebus.community/app/uploads/2019/03/cropped-RC-New-Logo-Horizontal-01.png)
Want to create or adapt books like this? Learn more about how Pressbooks supports open publishing practices.
Kenneth Leroy Busbee
An assignment statement sets and/or re-sets the value stored in the storage location(s) denoted by a variable name; in other words, it copies a value into the variable. [1]
The assignment operator allows us to change the value of a modifiable data object (for beginning programmers this typically means a variable). It is associated with the concept of moving a value into the storage location (again usually a variable). Within most programming languages the symbol used for assignment is the equal symbol. But bite your tongue, when you see the = symbol you need to start thinking: assignment. The assignment operator has two operands. The one to the left of the operator is usually an identifier name for a variable. The one to the right of the operator is a value.
Simple Assignment
The value 21 is moved to the memory location for the variable named: age. Another way to say it: age is assigned the value 21.
Assignment with an Expression
The item to the right of the assignment operator is an expression. The expression will be evaluated and the answer is 14. The value 14 would be assigned to the variable named: total_cousins.
Assignment with Identifier Names in the Expression
The expression to the right of the assignment operator contains some identifier names. The program would fetch the values stored in those variables; add them together and get a value of 44; then assign the 44 to the total_students variable.
- cnx.org: Programming Fundamentals – A Modular Structured Approach using C++
- Wikipedia: Assignment (computer science) ↵
Programming Fundamentals Copyright © 2018 by Kenneth Leroy Busbee is licensed under a Creative Commons Attribution-ShareAlike 4.0 International License , except where otherwise noted.
Share This Book
![what is a assignment statement Python's Assignment Operator: Write Robust Assignments](https://files.realpython.com/media/Pythons-Assignment-Statements-How-Do-They-Work_Watermarked.0a994e47f63c.jpg)
Python's Assignment Operator: Write Robust Assignments
Table of Contents
The Assignment Statement Syntax
The assignment operator, assignments and variables, other assignment syntax, initializing and updating variables, making multiple variables refer to the same object, updating lists through indices and slices, adding and updating dictionary keys, doing parallel assignments, unpacking iterables, providing default argument values, augmented mathematical assignment operators, augmented assignments for concatenation and repetition, augmented bitwise assignment operators, annotated assignment statements, assignment expressions with the walrus operator, managed attribute assignments, define or call a function, work with classes, import modules and objects, use a decorator, access the control variable in a for loop or a comprehension, use the as keyword, access the _ special variable in an interactive session, built-in objects, named constants.
Python’s assignment operators allow you to define assignment statements . This type of statement lets you create, initialize, and update variables throughout your code. Variables are a fundamental cornerstone in every piece of code, and assignment statements give you complete control over variable creation and mutation.
Learning about the Python assignment operator and its use for writing assignment statements will arm you with powerful tools for writing better and more robust Python code.
In this tutorial, you’ll:
- Use Python’s assignment operator to write assignment statements
- Take advantage of augmented assignments in Python
- Explore assignment variants, like assignment expressions and managed attributes
- Become aware of illegal and dangerous assignments in Python
You’ll dive deep into Python’s assignment statements. To get the most out of this tutorial, you should be comfortable with several basic topics, including variables , built-in data types , comprehensions , functions , and Python keywords . Before diving into some of the later sections, you should also be familiar with intermediate topics, such as object-oriented programming , constants , imports , type hints , properties , descriptors , and decorators .
Free Source Code: Click here to download the free assignment operator source code that you’ll use to write assignment statements that allow you to create, initialize, and update variables in your code.
Assignment Statements and the Assignment Operator
One of the most powerful programming language features is the ability to create, access, and mutate variables . In Python, a variable is a name that refers to a concrete value or object, allowing you to reuse that value or object throughout your code.
To create a new variable or to update the value of an existing one in Python, you’ll use an assignment statement . This statement has the following three components:
- A left operand, which must be a variable
- The assignment operator ( = )
- A right operand, which can be a concrete value , an object , or an expression
Here’s how an assignment statement will generally look in Python:
Here, variable represents a generic Python variable, while expression represents any Python object that you can provide as a concrete value—also known as a literal —or an expression that evaluates to a value.
To execute an assignment statement like the above, Python runs the following steps:
- Evaluate the right-hand expression to produce a concrete value or object . This value will live at a specific memory address in your computer.
- Store the object’s memory address in the left-hand variable . This step creates a new variable if the current one doesn’t already exist or updates the value of an existing variable.
The second step shows that variables work differently in Python than in other programming languages. In Python, variables aren’t containers for objects. Python variables point to a value or object through its memory address. They store memory addresses rather than objects.
This behavior difference directly impacts how data moves around in Python, which is always by reference . In most cases, this difference is irrelevant in your day-to-day coding, but it’s still good to know.
The central component of an assignment statement is the assignment operator . This operator is represented by the = symbol, which separates two operands:
- A value or an expression that evaluates to a concrete value
Operators are special symbols that perform mathematical , logical , and bitwise operations in a programming language. The objects (or object) on which an operator operates are called operands .
Unary operators, like the not Boolean operator, operate on a single object or operand, while binary operators act on two. That means the assignment operator is a binary operator.
Note: Like C , Python uses == for equality comparisons and = for assignments. Unlike C, Python doesn’t allow you to accidentally use the assignment operator ( = ) in an equality comparison.
Equality is a symmetrical relationship, and assignment is not. For example, the expression a == 42 is equivalent to 42 == a . In contrast, the statement a = 42 is correct and legal, while 42 = a isn’t allowed. You’ll learn more about illegal assignments later on.
The right-hand operand in an assignment statement can be any Python object, such as a number , list , string , dictionary , or even a user-defined object. It can also be an expression. In the end, expressions always evaluate to concrete objects, which is their return value.
Here are a few examples of assignments in Python:
The first two sample assignments in this code snippet use concrete values, also known as literals , to create and initialize number and greeting . The third example assigns the result of a math expression to the total variable, while the last example uses a Boolean expression.
Note: You can use the built-in id() function to inspect the memory address stored in a given variable.
Here’s a short example of how this function works:
The number in your output represents the memory address stored in number . Through this address, Python can access the content of number , which is the integer 42 in this example.
If you run this code on your computer, then you’ll get a different memory address because this value varies from execution to execution and computer to computer.
Unlike expressions, assignment statements don’t have a return value because their purpose is to make the association between the variable and its value. That’s why the Python interpreter doesn’t issue any output in the above examples.
Now that you know the basics of how to write an assignment statement, it’s time to tackle why you would want to use one.
The assignment statement is the explicit way for you to associate a name with an object in Python. You can use this statement for two main purposes:
- Creating and initializing new variables
- Updating the values of existing variables
When you use a variable name as the left operand in an assignment statement for the first time, you’re creating a new variable. At the same time, you’re initializing the variable to point to the value of the right operand.
On the other hand, when you use an existing variable in a new assignment, you’re updating or mutating the variable’s value. Strictly speaking, every new assignment will make the variable refer to a new value and stop referring to the old one. Python will garbage-collect all the values that are no longer referenced by any existing variable.
Assignment statements not only assign a value to a variable but also determine the data type of the variable at hand. This additional behavior is another important detail to consider in this kind of statement.
Because Python is a dynamically typed language, successive assignments to a given variable can change the variable’s data type. Changing the data type of a variable during a program’s execution is considered bad practice and highly discouraged. It can lead to subtle bugs that can be difficult to track down.
Unlike in math equations, in Python assignments, the left operand must be a variable rather than an expression or a value. For example, the following construct is illegal, and Python flags it as invalid syntax:
In this example, you have expressions on both sides of the = sign, and this isn’t allowed in Python code. The error message suggests that you may be confusing the equality operator with the assignment one, but that’s not the case. You’re really running an invalid assignment.
To correct this construct and convert it into a valid assignment, you’ll have to do something like the following:
In this code snippet, you first import the sqrt() function from the math module. Then you isolate the hypotenuse variable in the original equation by using the sqrt() function. Now your code works correctly.
Now you know what kind of syntax is invalid. But don’t get the idea that assignment statements are rigid and inflexible. In fact, they offer lots of room for customization, as you’ll learn next.
Python’s assignment statements are pretty flexible and versatile. You can write them in several ways, depending on your specific needs and preferences. Here’s a quick summary of the main ways to write assignments in Python:
Up to this point, you’ve mostly learned about the base assignment syntax in the above code snippet. In the following sections, you’ll learn about multiple, parallel, and augmented assignments. You’ll also learn about assignments with iterable unpacking.
Read on to see the assignment statements in action!
Assignment Statements in Action
You’ll find and use assignment statements everywhere in your Python code. They’re a fundamental part of the language, providing an explicit way to create, initialize, and mutate variables.
You can use assignment statements with plain names, like number or counter . You can also use assignments in more complicated scenarios, such as with:
- Qualified attribute names , like user.name
- Indices and slices of mutable sequences, like a_list[i] and a_list[i:j]
- Dictionary keys , like a_dict[key]
This list isn’t exhaustive. However, it gives you some idea of how flexible these statements are. You can even assign multiple values to an equal number of variables in a single line, commonly known as parallel assignment . Additionally, you can simultaneously assign the values in an iterable to a comma-separated group of variables in what’s known as an iterable unpacking operation.
In the following sections, you’ll dive deeper into all these topics and a few other exciting things that you can do with assignment statements in Python.
The most elementary use case of an assignment statement is to create a new variable and initialize it using a particular value or expression:
All these statements create new variables, assigning them initial values or expressions. For an initial value, you should always use the most sensible and least surprising value that you can think of. For example, initializing a counter to something different from 0 may be confusing and unexpected because counters almost always start having counted no objects.
Updating a variable’s current value or state is another common use case of assignment statements. In Python, assigning a new value to an existing variable doesn’t modify the variable’s current value. Instead, it causes the variable to refer to a different value. The previous value will be garbage-collected if no other variable refers to it.
Consider the following examples:
These examples run two consecutive assignments on the same variable. The first one assigns the string "Hello, World!" to a new variable named greeting .
The second assignment updates the value of greeting by reassigning it the "Hi, Pythonistas!" string. In this example, the original value of greeting —the "Hello, World!" string— is lost and garbage-collected. From this point on, you can’t access the old "Hello, World!" string.
Even though running multiple assignments on the same variable during a program’s execution is common practice, you should use this feature with caution. Changing the value of a variable can make your code difficult to read, understand, and debug. To comprehend the code fully, you’ll have to remember all the places where the variable was changed and the sequential order of those changes.
Because assignments also define the data type of their target variables, it’s also possible for your code to accidentally change the type of a given variable at runtime. A change like this can lead to breaking errors, like AttributeError exceptions. Remember that strings don’t have the same methods and attributes as lists or dictionaries, for example.
In Python, you can make several variables reference the same object in a multiple-assignment line. This can be useful when you want to initialize several similar variables using the same initial value:
In this example, you chain two assignment operators in a single line. This way, your two variables refer to the same initial value of 0 . Note how both variables hold the same memory address, so they point to the same instance of 0 .
When it comes to integer variables, Python exhibits a curious behavior. It provides a numeric interval where multiple assignments behave the same as independent assignments. Consider the following examples:
To create n and m , you use independent assignments. Therefore, they should point to different instances of the number 42 . However, both variables hold the same object, which you confirm by comparing their corresponding memory addresses.
Now check what happens when you use a greater initial value:
Now n and m hold different memory addresses, which means they point to different instances of the integer number 300 . In contrast, when you use multiple assignments, both variables refer to the same object. This tiny difference can save you small bits of memory if you frequently initialize integer variables in your code.
The implicit behavior of making independent assignments point to the same integer number is actually an optimization called interning . It consists of globally caching the most commonly used integer values in day-to-day programming.
Under the hood, Python defines a numeric interval in which interning takes place. That’s the interning interval for integer numbers. You can determine this interval using a small script like the following:
This script helps you determine the interning interval by comparing integer numbers from -10 to 500 . If you run the script from your command line, then you’ll get an output like the following:
This output means that if you use a single number between -5 and 256 to initialize several variables in independent statements, then all these variables will point to the same object, which will help you save small bits of memory in your code.
In contrast, if you use a number that falls outside of the interning interval, then your variables will point to different objects instead. Each of these objects will occupy a different memory spot.
You can use the assignment operator to mutate the value stored at a given index in a Python list. The operator also works with list slices . The syntax to write these types of assignment statements is the following:
In the first construct, expression can return any Python object, including another list. In the second construct, expression must return a series of values as a list, tuple, or any other sequence. You’ll get a TypeError if expression returns a single value.
Note: When creating slice objects, you can use up to three arguments. These arguments are start , stop , and step . They define the number that starts the slice, the number at which the slicing must stop retrieving values, and the step between values.
Here’s an example of updating an individual value in a list:
In this example, you update the value at index 2 using an assignment statement. The original number at that index was 7 , and after the assignment, the number is 3 .
Note: Using indices and the assignment operator to update a value in a tuple or a character in a string isn’t possible because tuples and strings are immutable data types in Python.
Their immutability means that you can’t change their items in place :
You can’t use the assignment operator to change individual items in tuples or strings. These data types are immutable and don’t support item assignments.
It’s important to note that you can’t add new values to a list by using indices that don’t exist in the target list:
In this example, you try to add a new value to the end of numbers by using an index that doesn’t exist. This assignment isn’t allowed because there’s no way to guarantee that new indices will be consecutive. If you ever want to add a single value to the end of a list, then use the .append() method.
If you want to update several consecutive values in a list, then you can use slicing and an assignment statement:
In the first example, you update the letters between indices 1 and 3 without including the letter at 3 . The second example updates the letters from index 3 until the end of the list. Note that this slicing appends a new value to the list because the target slice is shorter than the assigned values.
Also note that the new values were provided through a tuple, which means that this type of assignment allows you to use other types of sequences to update your target list.
The third example updates a single value using a slice where both indices are equal. In this example, the assignment inserts a new item into your target list.
In the final example, you use a step of 2 to replace alternating letters with their lowercase counterparts. This slicing starts at index 1 and runs through the whole list, stepping by two items each time.
Updating the value of an existing key or adding new key-value pairs to a dictionary is another common use case of assignment statements. To do these operations, you can use the following syntax:
The first construct helps you update the current value of an existing key, while the second construct allows you to add a new key-value pair to the dictionary.
For example, to update an existing key, you can do something like this:
In this example, you update the current inventory of oranges in your store using an assignment. The left operand is the existing dictionary key, and the right operand is the desired new value.
While you can’t add new values to a list by assignment, dictionaries do allow you to add new key-value pairs using the assignment operator. In the example below, you add a lemon key to inventory :
In this example, you successfully add a new key-value pair to your inventory with 100 units. This addition is possible because dictionaries don’t have consecutive indices but unique keys, which are safe to add by assignment.
The assignment statement does more than assign the result of a single expression to a single variable. It can also cope nicely with assigning multiple values to multiple variables simultaneously in what’s known as a parallel assignment .
Here’s the general syntax for parallel assignments in Python:
Note that the left side of the statement can be either a tuple or a list of variables. Remember that to create a tuple, you just need a series of comma-separated elements. In this case, these elements must be variables.
The right side of the statement must be a sequence or iterable of values or expressions. In any case, the number of elements in the right operand must match the number of variables on the left. Otherwise, you’ll get a ValueError exception.
In the following example, you compute the two solutions of a quadratic equation using a parallel assignment:
In this example, you first import sqrt() from the math module. Then you initialize the equation’s coefficients in a parallel assignment.
The equation’s solution is computed in another parallel assignment. The left operand contains a tuple of two variables, x1 and x2 . The right operand consists of a tuple of expressions that compute the solutions for the equation. Note how each result is assigned to each variable by position.
A classical use case of parallel assignment is to swap values between variables:
The highlighted line does the magic and swaps the values of previous_value and next_value at the same time. Note that in a programming language that doesn’t support this kind of assignment, you’d have to use a temporary variable to produce the same effect:
In this example, instead of using parallel assignment to swap values between variables, you use a new variable to temporarily store the value of previous_value to avoid losing its reference.
For a concrete example of when you’d need to swap values between variables, say you’re learning how to implement the bubble sort algorithm , and you come up with the following function:
In the highlighted line, you use a parallel assignment to swap values in place if the current value is less than the next value in the input list. To dive deeper into the bubble sort algorithm and into sorting algorithms in general, check out Sorting Algorithms in Python .
You can use assignment statements for iterable unpacking in Python. Unpacking an iterable means assigning its values to a series of variables one by one. The iterable must be the right operand in the assignment, while the variables must be the left operand.
Like in parallel assignments, the variables must come as a tuple or list. The number of variables must match the number of values in the iterable. Alternatively, you can use the unpacking operator ( * ) to grab several values in a variable if the number of variables doesn’t match the iterable length.
Here’s the general syntax for iterable unpacking in Python:
Iterable unpacking is a powerful feature that you can use all around your code. It can help you write more readable and concise code. For example, you may find yourself doing something like this:
Whenever you do something like this in your code, go ahead and replace it with a more readable iterable unpacking using a single and elegant assignment, like in the following code snippet:
The numbers list on the right side contains four values. The assignment operator unpacks these values into the four variables on the left side of the statement. The values in numbers get assigned to variables in the same order that they appear in the iterable. The assignment is done by position.
Note: Because Python sets are also iterables, you can use them in an iterable unpacking operation. However, it won’t be clear which value goes to which variable because sets are unordered data structures.
The above example shows the most common form of iterable unpacking in Python. The main condition for the example to work is that the number of variables matches the number of values in the iterable.
What if you don’t know the iterable length upfront? Will the unpacking work? It’ll work if you use the * operator to pack several values into one of your target variables.
For example, say that you want to unpack the first and second values in numbers into two different variables. Additionally, you would like to pack the rest of the values in a single variable conveniently called rest . In this case, you can use the unpacking operator like in the following code:
In this example, first and second hold the first and second values in numbers , respectively. These values are assigned by position. The * operator packs all the remaining values in the input iterable into rest .
The unpacking operator ( * ) can appear at any position in your series of target variables. However, you can only use one instance of the operator:
The iterable unpacking operator works in any position in your list of variables. Note that you can only use one unpacking operator per assignment. Using more than one unpacking operator isn’t allowed and raises a SyntaxError .
Dropping away unwanted values from the iterable is a common use case for the iterable unpacking operator. Consider the following example:
In Python, if you want to signal that a variable won’t be used, then you use an underscore ( _ ) as the variable’s name. In this example, useful holds the only value that you need to use from the input iterable. The _ variable is a placeholder that guarantees that the unpacking works correctly. You won’t use the values that end up in this disposable variable.
Note: In the example above, if your target iterable is a sequence data type, such as a list or tuple, then it’s best to access its last item directly.
To do this, you can use the -1 index:
Using -1 gives you access to the last item of any sequence data type. In contrast, if you’re dealing with iterators , then you won’t be able to use indices. That’s when the *_ syntax comes to your rescue.
The pattern used in the above example comes in handy when you have a function that returns multiple values, and you only need a few of these values in your code. The os.walk() function may provide a good example of this situation.
This function allows you to iterate over the content of a directory recursively. The function returns a generator object that yields three-item tuples. Each tuple contains the following items:
- The path to the current directory as a string
- The names of all the immediate subdirectories as a list of strings
- The names of all the files in the current directory as a list of strings
Now say that you want to iterate over your home directory and list only the files. You can do something like this:
This code will issue a long output depending on the current content of your home directory. Note that you need to provide a string with the path to your user folder for the example to work. The _ placeholder variable will hold the unwanted data.
In contrast, the filenames variable will hold the list of files in the current directory, which is the data that you need. The code will print the list of filenames. Go ahead and give it a try!
The assignment operator also comes in handy when you need to provide default argument values in your functions and methods. Default argument values allow you to define functions that take arguments with sensible defaults. These defaults allow you to call the function with specific values or to simply rely on the defaults.
As an example, consider the following function:
This function takes one argument, called name . This argument has a sensible default value that’ll be used when you call the function without arguments. To provide this sensible default value, you use an assignment.
Note: According to PEP 8 , the style guide for Python code, you shouldn’t use spaces around the assignment operator when providing default argument values in function definitions.
Here’s how the function works:
If you don’t provide a name during the call to greet() , then the function uses the default value provided in the definition. If you provide a name, then the function uses it instead of the default one.
Up to this point, you’ve learned a lot about the Python assignment operator and how to use it for writing different types of assignment statements. In the following sections, you’ll dive into a great feature of assignment statements in Python. You’ll learn about augmented assignments .
Augmented Assignment Operators in Python
Python supports what are known as augmented assignments . An augmented assignment combines the assignment operator with another operator to make the statement more concise. Most Python math and bitwise operators have an augmented assignment variation that looks something like this:
Note that $ isn’t a valid Python operator. In this example, it’s a placeholder for a generic operator. This statement works as follows:
- Evaluate expression to produce a value.
- Run the operation defined by the operator that prefixes the = sign, using the previous value of variable and the return value of expression as operands.
- Assign the resulting value back to variable .
In practice, an augmented assignment like the above is equivalent to the following statement:
As you can conclude, augmented assignments are syntactic sugar . They provide a shorthand notation for a specific and popular kind of assignment.
For example, say that you need to define a counter variable to count some stuff in your code. You can use the += operator to increment counter by 1 using the following code:
In this example, the += operator, known as augmented addition , adds 1 to the previous value in counter each time you run the statement counter += 1 .
It’s important to note that unlike regular assignments, augmented assignments don’t create new variables. They only allow you to update existing variables. If you use an augmented assignment with an undefined variable, then you get a NameError :
Python evaluates the right side of the statement before assigning the resulting value back to the target variable. In this specific example, when Python tries to compute x + 1 , it finds that x isn’t defined.
Great! You now know that an augmented assignment consists of combining the assignment operator with another operator, like a math or bitwise operator. To continue this discussion, you’ll learn which math operators have an augmented variation in Python.
An equation like x = x + b doesn’t make sense in math. But in programming, a statement like x = x + b is perfectly valid and can be extremely useful. It adds b to x and reassigns the result back to x .
As you already learned, Python provides an operator to shorten x = x + b . Yes, the += operator allows you to write x += b instead. Python also offers augmented assignment operators for most math operators. Here’s a summary:
Operator | Description | Example | Equivalent |
---|---|---|---|
Adds the right operand to the left operand and stores the result in the left operand | |||
Subtracts the right operand from the left operand and stores the result in the left operand | |||
Multiplies the right operand with the left operand and stores the result in the left operand | |||
Divides the left operand by the right operand and stores the result in the left operand | |||
Performs of the left operand by the right operand and stores the result in the left operand | |||
Finds the remainder of dividing the left operand by the right operand and stores the result in the left operand | |||
Raises the left operand to the power of the right operand and stores the result in the left operand |
The Example column provides generic examples of how to use the operators in actual code. Note that x must be previously defined for the operators to work correctly. On the other hand, y can be either a concrete value or an expression that returns a value.
Note: The matrix multiplication operator ( @ ) doesn’t support augmented assignments yet.
Consider the following example of matrix multiplication using NumPy arrays:
Note that the exception traceback indicates that the operation isn’t supported yet.
To illustrate how augmented assignment operators work, say that you need to create a function that takes an iterable of numeric values and returns their sum. You can write this function like in the code below:
In this function, you first initialize total to 0 . In each iteration, the loop adds a new number to total using the augmented addition operator ( += ). When the loop terminates, total holds the sum of all the input numbers. Variables like total are known as accumulators . The += operator is typically used to update accumulators.
Note: Computing the sum of a series of numeric values is a common operation in programming. Python provides the built-in sum() function for this specific computation.
Another interesting example of using an augmented assignment is when you need to implement a countdown while loop to reverse an iterable. In this case, you can use the -= operator:
In this example, custom_reversed() is a generator function because it uses yield . Calling the function creates an iterator that yields items from the input iterable in reverse order. To decrement the control variable, index , you use an augmented subtraction statement that subtracts 1 from the variable in every iteration.
Note: Similar to summing the values in an iterable, reversing an iterable is also a common requirement. Python provides the built-in reversed() function for this specific computation, so you don’t have to implement your own. The above example only intends to show the -= operator in action.
Finally, counters are a special type of accumulators that allow you to count objects. Here’s an example of a letter counter:
To create this counter, you use a Python dictionary. The keys store the letters. The values store the counts. Again, to increment the counter, you use an augmented addition.
Counters are so common in programming that Python provides a tool specially designed to facilitate the task of counting. Check out Python’s Counter: The Pythonic Way to Count Objects for a complete guide on how to use this tool.
The += and *= augmented assignment operators also work with sequences , such as lists, tuples, and strings. The += operator performs augmented concatenations , while the *= operator performs augmented repetition .
These operators behave differently with mutable and immutable data types:
Operator | Description | Example |
---|---|---|
Runs an augmented concatenation operation on the target sequence. Mutable sequences are updated in place. If the sequence is immutable, then a new sequence is created and assigned back to the target name. | ||
Adds to itself times. Mutable sequences are updated in place. If the sequence is immutable, then a new sequence is created and assigned back to the target name. |
Note that the augmented concatenation operator operates on two sequences, while the augmented repetition operator works on a sequence and an integer number.
Consider the following examples and pay attention to the result of calling the id() function:
Mutable sequences like lists support the += augmented assignment operator through the .__iadd__() method, which performs an in-place addition. This method mutates the underlying list, appending new values to its end.
Note: If the left operand is mutable, then x += y may not be completely equivalent to x = x + y . For example, if you do list_1 = list_1 + list_2 instead of list_1 += list_2 above, then you’ll create a new list instead of mutating the existing one. This may be important if other variables refer to the same list.
Immutable sequences, such as tuples and strings, don’t provide an .__iadd__() method. Therefore, augmented concatenations fall back to the .__add__() method, which doesn’t modify the sequence in place but returns a new sequence.
There’s another difference between mutable and immutable sequences when you use them in an augmented concatenation. Consider the following examples:
With mutable sequences, the data to be concatenated can come as a list, tuple, string, or any other iterable. In contrast, with immutable sequences, the data can only come as objects of the same type. You can concatenate tuples to tuples and strings to strings, for example.
Again, the augmented repetition operator works with a sequence on the left side of the operator and an integer on the right side. This integer value represents the number of repetitions to get in the resulting sequence:
When the *= operator operates on a mutable sequence, it falls back to the .__imul__() method, which performs the operation in place, modifying the underlying sequence. In contrast, if *= operates on an immutable sequence, then .__mul__() is called, returning a new sequence of the same type.
Note: Values of n less than 0 are treated as 0 , which returns an empty sequence of the same data type as the target sequence on the left side of the *= operand.
Note that a_list[0] is a_list[3] returns True . This is because the *= operator doesn’t make a copy of the repeated data. It only reflects the data. This behavior can be a source of issues when you use the operator with mutable values.
For example, say that you want to create a list of lists to represent a matrix, and you need to initialize the list with n empty lists, like in the following code:
In this example, you use the *= operator to populate matrix with three empty lists. Now check out what happens when you try to populate the first sublist in matrix :
The appended values are reflected in the three sublists. This happens because the *= operator doesn’t make copies of the data that you want to repeat. It only reflects the data. Therefore, every sublist in matrix points to the same object and memory address.
If you ever need to initialize a list with a bunch of empty sublists, then use a list comprehension :
This time, when you populate the first sublist of matrix , your changes aren’t propagated to the other sublists. This is because all the sublists are different objects that live in different memory addresses.
Bitwise operators also have their augmented versions. The logic behind them is similar to that of the math operators. The following table summarizes the augmented bitwise operators that Python provides:
Operator | Operation | Example | Equivalent |
---|---|---|---|
Augmented bitwise AND ( ) | |||
Augmented bitwise OR ( ) | |||
Augmented bitwise XOR ( ) | |||
Augmented bitwise right shift | |||
Augmented bitwise left shift |
The augmented bitwise assignment operators perform the intended operation by taking the current value of the left operand as a starting point for the computation. Consider the following example, which uses the & and &= operators:
Programmers who work with high-level languages like Python rarely use bitwise operations in day-to-day coding. However, these types of operations can be useful in some situations.
For example, say that you’re implementing a Unix-style permission system for your users to access a given resource. In this case, you can use the characters "r" for reading, "w" for writing, and "x" for execution permissions, respectively. However, using bit-based permissions could be more memory efficient:
You can assign permissions to your users with the OR bitwise operator or the augmented OR bitwise operator. Finally, you can use the bitwise AND operator to check if a user has a certain permission, as you did in the final two examples.
You’ve learned a lot about augmented assignment operators and statements in this and the previous sections. These operators apply to math, concatenation, repetition, and bitwise operations. Now you’re ready to look at other assignment variants that you can use in your code or find in other developers’ code.
Other Assignment Variants
So far, you’ve learned that Python’s assignment statements and the assignment operator are present in many different scenarios and use cases. Those use cases include variable creation and initialization, parallel assignments, iterable unpacking, augmented assignments, and more.
In the following sections, you’ll learn about a few variants of assignment statements that can be useful in your future coding. You can also find these assignment variants in other developers’ code. So, you should be aware of them and know how they work in practice.
In short, you’ll learn about:
- Annotated assignment statements with type hints
- Assignment expressions with the walrus operator
- Managed attribute assignments with properties and descriptors
- Implicit assignments in Python
These topics will take you through several interesting and useful examples that showcase the power of Python’s assignment statements.
PEP 526 introduced a dedicated syntax for variable annotation back in Python 3.6 . The syntax consists of the variable name followed by a colon ( : ) and the variable type:
Even though these statements declare three variables with their corresponding data types, the variables aren’t actually created or initialized. So, for example, you can’t use any of these variables in an augmented assignment statement:
If you try to use one of the previously declared variables in an augmented assignment, then you get a NameError because the annotation syntax doesn’t define the variable. To actually define it, you need to use an assignment.
The good news is that you can use the variable annotation syntax in an assignment statement with the = operator:
The first statement in this example is what you can call an annotated assignment statement in Python. You may ask yourself why you should use type annotations in this type of assignment if everybody can see that counter holds an integer number. You’re right. In this example, the variable type is unambiguous.
However, imagine what would happen if you found a variable initialization like the following:
What would be the data type of each user in users ? If the initialization of users is far away from the definition of the User class, then there’s no quick way to answer this question. To clarify this ambiguity, you can provide the appropriate type hint for users :
Now you’re clearly communicating that users will hold a list of User instances. Using type hints in assignment statements that initialize variables to empty collection data types—such as lists, tuples, or dictionaries—allows you to provide more context about how your code works. This practice will make your code more explicit and less error-prone.
Up to this point, you’ve learned that regular assignment statements with the = operator don’t have a return value. They just create or update variables. Therefore, you can’t use a regular assignment to assign a value to a variable within the context of an expression.
Python 3.8 changed this by introducing a new type of assignment statement through PEP 572 . This new statement is known as an assignment expression or named expression .
Note: Expressions are a special type of statement in Python. Their distinguishing characteristic is that expressions always have a return value, which isn’t the case with all types of statements.
Unlike regular assignments, assignment expressions have a return value, which is why they’re called expressions in the first place. This return value is automatically assigned to a variable. To write an assignment expression, you must use the walrus operator ( := ), which was named for its resemblance to the eyes and tusks of a walrus lying on its side.
The general syntax of an assignment statement is as follows:
This expression looks like a regular assignment. However, instead of using the assignment operator ( = ), it uses the walrus operator ( := ). For the expression to work correctly, the enclosing parentheses are required in most use cases. However, there are certain situations in which these parentheses are superfluous. Either way, they won’t hurt you.
Assignment expressions come in handy when you want to reuse the result of an expression or part of an expression without using a dedicated assignment to grab this value beforehand.
Note: Assignment expressions with the walrus operator have several practical use cases. They also have a few restrictions. For example, they’re illegal in certain contexts, such as lambda functions, parallel assignments, and augmented assignments.
For a deep dive into this special type of assignment, check out The Walrus Operator: Python’s Assignment Expressions .
A particularly handy use case for assignment expressions is when you need to grab the result of an expression used in the context of a conditional statement. For example, say that you need to write a function to compute the mean of a sample of numeric values. Without the walrus operator, you could do something like this:
In this example, the sample size ( n ) is a value that you need to reuse in two different computations. First, you need to check whether the sample has data points or not. Then you need to use the sample size to compute the mean. To be able to reuse n , you wrote a dedicated assignment statement at the beginning of your function to grab the sample size.
You can avoid this extra step by combining it with the first use of the target value, len(sample) , using an assignment expression like the following:
The assignment expression introduced in the conditional computes the sample size and assigns it to n . This way, you guarantee that you have a reference to the sample size to use in further computations.
Because the assignment expression returns the sample size anyway, the conditional can check whether that size equals 0 or not and then take a certain course of action depending on the result of this check. The return statement computes the sample’s mean and sends the result back to the function caller.
Python provides a few tools that allow you to fine-tune the operations behind the assignment of attributes. The attributes that run implicit operations on assignments are commonly referred to as managed attributes .
Properties are the most commonly used tool for providing managed attributes in your classes. However, you can also use descriptors and, in some cases, the .__setitem__() special method.
To understand what fine-tuning the operation behind an assignment means, say that you need a Point class that only allows numeric values for its coordinates, x and y . To write this class, you must set up a validation mechanism to reject non-numeric values. You can use properties to attach the validation functionality on top of x and y .
Here’s how you can write your class:
In Point , you use properties for the .x and .y coordinates. Each property has a getter and a setter method . The getter method returns the attribute at hand. The setter method runs the input validation using a try … except block and the built-in float() function. Then the method assigns the result to the actual attribute.
Here’s how your class works in practice:
When you use a property-based attribute as the left operand in an assignment statement, Python automatically calls the property’s setter method, running any computation from it.
Because both .x and .y are properties, the input validation runs whenever you assign a value to either attribute. In the first example, the input values are valid numbers and the validation passes. In the final example, "one" isn’t a valid numeric value, so the validation fails.
If you look at your Point class, you’ll note that it follows a repetitive pattern, with the getter and setter methods looking quite similar. To avoid this repetition, you can use a descriptor instead of a property.
A descriptor is a class that implements the descriptor protocol , which consists of four special methods :
- .__get__() runs when you access the attribute represented by the descriptor.
- .__set__() runs when you use the attribute in an assignment statement.
- .__delete__() runs when you use the attribute in a del statement.
- .__set_name__() sets the attribute’s name, creating a name-aware attribute.
Here’s how your code may look if you use a descriptor to represent the coordinates of your Point class:
You’ve removed repetitive code by defining Coordinate as a descriptor that manages the input validation in a single place. Go ahead and run the following code to try out the new implementation of Point :
Great! The class works as expected. Thanks to the Coordinate descriptor, you now have a more concise and non-repetitive version of your original code.
Another way to fine-tune the operations behind an assignment statement is to provide a custom implementation of .__setitem__() in your class. You’ll use this method in classes representing mutable data collections, such as custom list-like or dictionary-like classes.
As an example, say that you need to create a dictionary-like class that stores its keys in lowercase letters:
In this example, you create a dictionary-like class by subclassing UserDict from collections . Your class implements a .__setitem__() method, which takes key and value as arguments. The method uses str.lower() to convert key into lowercase letters before storing it in the underlying dictionary.
Python implicitly calls .__setitem__() every time you use a key as the left operand in an assignment statement. This behavior allows you to tweak how you process the assignment of keys in your custom dictionary.
Implicit Assignments in Python
Python implicitly runs assignments in many different contexts. In most cases, these implicit assignments are part of the language syntax. In other cases, they support specific behaviors.
Whenever you complete an action in the following list, Python runs an implicit assignment for you:
- Define or call a function
- Define or instantiate a class
- Use the current instance , self
- Import modules and objects
- Use a decorator
- Use the control variable in a for loop or a comprehension
- Use the as qualifier in with statements , imports, and try … except blocks
- Access the _ special variable in an interactive session
Behind the scenes, Python performs an assignment in every one of the above situations. In the following subsections, you’ll take a tour of all these situations.
When you define a function, the def keyword implicitly assigns a function object to your function’s name. Here’s an example:
From this point on, the name greet refers to a function object that lives at a given memory address in your computer. You can call the function using its name and a pair of parentheses with appropriate arguments. This way, you can reuse greet() wherever you need it.
If you call your greet() function with fellow as an argument, then Python implicitly assigns the input argument value to the name parameter on the function’s definition. The parameter will hold a reference to the input arguments.
When you define a class with the class keyword, you’re assigning a specific name to a class object . You can later use this name to create instances of that class. Consider the following example:
In this example, the name User holds a reference to a class object, which was defined in __main__.User . Like with a function, when you call the class’s constructor with the appropriate arguments to create an instance, Python assigns the arguments to the parameters defined in the class initializer .
Another example of implicit assignments is the current instance of a class, which in Python is called self by convention. This name implicitly gets a reference to the current object whenever you instantiate a class. Thanks to this implicit assignment, you can access .name and .job from within the class without getting a NameError in your code.
Import statements are another variant of implicit assignments in Python. Through an import statement, you assign a name to a module object, class, function, or any other imported object. This name is then created in your current namespace so that you can access it later in your code:
In this example, you import the sys module object from the standard library and assign it to the sys name, which is now available in your namespace, as you can conclude from the second call to the built-in dir() function.
You also run an implicit assignment when you use a decorator in your code. The decorator syntax is just a shortcut for a formal assignment like the following:
Here, you call decorator() with a function object as an argument. This call will typically add functionality on top of the existing function, func() , and return a function object, which is then reassigned to the func name.
The decorator syntax is syntactic sugar for replacing the previous assignment, which you can now write as follows:
Even though this new code looks pretty different from the above assignment, the code implicitly runs the same steps.
Another situation in which Python automatically runs an implicit assignment is when you use a for loop or a comprehension. In both cases, you can have one or more control variables that you then use in the loop or comprehension body:
The memory address of control_variable changes on each iteration of the loop. This is because Python internally reassigns a new value from the loop iterable to the loop control variable on each cycle.
The same behavior appears in comprehensions:
In the end, comprehensions work like for loops but use a more concise syntax. This comprehension creates a new list of strings that mimic the output from the previous example.
The as keyword in with statements, except clauses, and import statements is another example of an implicit assignment in Python. This time, the assignment isn’t completely implicit because the as keyword provides an explicit way to define the target variable.
In a with statement, the target variable that follows the as keyword will hold a reference to the context manager that you’re working with. As an example, say that you have a hello.txt file with the following content:
You want to open this file and print each of its lines on your screen. In this case, you can use the with statement to open the file using the built-in open() function.
In the example below, you accomplish this. You also add some calls to print() that display information about the target variable defined by the as keyword:
This with statement uses the open() function to open hello.txt . The open() function is a context manager that returns a text file object represented by an io.TextIOWrapper instance.
Since you’ve defined a hello target variable with the as keyword, now that variable holds a reference to the file object itself. You confirm this by printing the object and its memory address. Finally, the for loop iterates over the lines and prints this content to the screen.
When it comes to using the as keyword in the context of an except clause, the target variable will contain an exception object if any exception occurs:
In this example, you run a division that raises a ZeroDivisionError . The as keyword assigns the raised exception to error . Note that when you print the exception object, you get only the message because exceptions have a custom .__str__() method that supports this behavior.
There’s a final detail to remember when using the as specifier in a try … except block like the one in the above example. Once you leave the except block, the target variable goes out of scope , and you can’t use it anymore.
Finally, Python’s import statements also support the as keyword. In this context, you can use as to import objects with a different name:
In these examples, you use the as keyword to import the numpy package with the np name and pandas with the name pd . If you call dir() , then you’ll realize that np and pd are now in your namespace. However, the numpy and pandas names are not.
Using the as keyword in your imports comes in handy when you want to use shorter names for your objects or when you need to use different objects that originally had the same name in your code. It’s also useful when you want to make your imported names non-public using a leading underscore, like in import sys as _sys .
The final implicit assignment that you’ll learn about in this tutorial only occurs when you’re using Python in an interactive session. Every time you run a statement that returns a value, the interpreter stores the result in a special variable denoted by a single underscore character ( _ ).
You can access this special variable as you’d access any other variable:
These examples cover several situations in which Python internally uses the _ variable. The first two examples evaluate expressions. Expressions always have a return value, which is automatically assigned to the _ variable every time.
When it comes to function calls, note that if your function returns a fruitful value, then _ will hold it. In contrast, if your function returns None , then the _ variable will remain untouched.
The next example consists of a regular assignment statement. As you already know, regular assignments don’t return any value, so the _ variable isn’t updated after these statements run. Finally, note that accessing a variable in an interactive session returns the value stored in the target variable. This value is then assigned to the _ variable.
Note that since _ is a regular variable, you can use it in other expressions:
In this example, you first create a list of values. Then you call len() to get the number of values in the list. Python automatically stores this value in the _ variable. Finally, you use _ to compute the mean of your list of values.
Now that you’ve learned about some of the implicit assignments that Python runs under the hood, it’s time to dig into a final assignment-related topic. In the following few sections, you’ll learn about some illegal and dangerous assignments that you should be aware of and avoid in your code.
Illegal and Dangerous Assignments in Python
In Python, you’ll find a few situations in which using assignments is either forbidden or dangerous. You must be aware of these special situations and try to avoid them in your code.
In the following sections, you’ll learn when using assignment statements isn’t allowed in Python. You’ll also learn about some situations in which using assignments should be avoided if you want to keep your code consistent and robust.
You can’t use Python keywords as variable names in assignment statements. This kind of assignment is explicitly forbidden. If you try to use a keyword as a variable name in an assignment, then you get a SyntaxError :
Whenever you try to use a keyword as the left operand in an assignment statement, you get a SyntaxError . Keywords are an intrinsic part of the language and can’t be overridden.
If you ever feel the need to name one of your variables using a Python keyword, then you can append an underscore to the name of your variable:
In this example, you’re using the desired name for your variables. Because you added a final underscore to the names, Python doesn’t recognize them as keywords, so it doesn’t raise an error.
Note: Even though adding an underscore at the end of a name is an officially recommended practice , it can be confusing sometimes. Therefore, try to find an alternative name or use a synonym whenever you find yourself using this convention.
For example, you can write something like this:
In this example, using the name booking_class for your variable is way clearer and more descriptive than using class_ .
You’ll also find that you can use only a few keywords as part of the right operand in an assignment statement. Those keywords will generally define simple statements that return a value or object. These include lambda , and , or , not , True , False , None , in , and is . You can also use the for keyword when it’s part of a comprehension and the if keyword when it’s used as part of a ternary operator .
In an assignment, you can never use a compound statement as the right operand. Compound statements are those that require an indented block, such as for and while loops, conditionals, with statements, try … except blocks, and class or function definitions.
Sometimes, you need to name variables, but the desired or ideal name is already taken and used as a built-in name. If this is your case, think harder and find another name. Don’t shadow the built-in.
Shadowing built-in names can cause hard-to-identify problems in your code. A common example of this issue is using list or dict to name user-defined variables. In this case, you override the corresponding built-in names, which won’t work as expected if you use them later in your code.
Consider the following example:
The exception in this example may sound surprising. How come you can’t use list() to build a list from a call to map() that returns a generator of square numbers?
By using the name list to identify your list of numbers, you shadowed the built-in list name. Now that name points to a list object rather than the built-in class. List objects aren’t callable, so your code no longer works.
In Python, you’ll have nothing that warns against using built-in, standard-library, or even relevant third-party names to identify your own variables. Therefore, you should keep an eye out for this practice. It can be a source of hard-to-debug errors.
In programming, a constant refers to a name associated with a value that never changes during a program’s execution. Unlike other programming languages, Python doesn’t have a dedicated syntax for defining constants. This fact implies that Python doesn’t have constants in the strict sense of the word.
Python only has variables. If you need a constant in Python, then you’ll have to define a variable and guarantee that it won’t change during your code’s execution. To do that, you must avoid using that variable as the left operand in an assignment statement.
To tell other Python programmers that a given variable should be treated as a constant, you must write your variable’s name in capital letters with underscores separating the words. This naming convention has been adopted by the Python community and is a recommendation that you’ll find in the Constants section of PEP 8 .
In the following examples, you define some constants in Python:
The problem with these constants is that they’re actually variables. Nothing prevents you from changing their value during your code’s execution. So, at any time, you can do something like the following:
These assignments modify the value of two of your original constants. Python doesn’t complain about these changes, which can cause issues later in your code. As a Python developer, you must guarantee that named constants in your code remain constant.
The only way to do that is never to use named constants in an assignment statement other than the constant definition.
You’ve learned a lot about Python’s assignment operators and how to use them for writing assignment statements . With this type of statement, you can create, initialize, and update variables according to your needs. Now you have the required skills to fully manage the creation and mutation of variables in your Python code.
In this tutorial, you’ve learned how to:
- Write assignment statements using Python’s assignment operators
- Work with augmented assignments in Python
- Explore assignment variants, like assignment expression and managed attributes
- Identify illegal and dangerous assignments in Python
Learning about the Python assignment operator and how to use it in assignment statements is a fundamental skill in Python. It empowers you to write reliable and effective Python code.
🐍 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.
![what is a assignment statement Python Tricks Dictionary Merge](https://realpython.com/static/pytrick-dict-merge.4201a0125a5e.png)
About Leodanis Pozo Ramos
![what is a assignment statement Leodanis Pozo Ramos](https://realpython.com/cdn-cgi/image/width=862,height=862,fit=crop,gravity=auto,format=auto/https://files.realpython.com/media/Perfil_final1.9f896bc212f6.jpg)
Leodanis is an industrial engineer who loves Python and software development. He's a self-taught Python developer with 6+ years of experience. He's an avid technical writer with a growing number of articles published on Real Python and other sites.
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:
![what is a assignment statement Aldren Santos](https://realpython.com/cdn-cgi/image/width=959,height=959,fit=crop,gravity=auto,format=auto/https://files.realpython.com/media/PP.9b8b026f75b8.jpg)
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: intermediate best-practices python
Keep reading Real Python by creating a free account or signing in:
Already have an account? Sign-In
Almost there! Complete this form and click the button below to gain instant access:
Python's Assignment Operator: Write Robust Assignments (Source Code)
🔒 No spam. We take your privacy seriously.
CS101: Introduction to Computer Science I
Variables and Assignment Statements
Read this chapter, which covers variables and arithmetic operations and order precedence in Java.
9. Assignment Statements
No. The incorrect splittings are highlighted in red:
Assignment Statement
public class AssignmentExample |
So far, the example programs have been using the value initially put into a variable. Programs can change the value in a variable. An assignment statement changes the value that is held in a variable. The program uses an assignment statement.
The assignment statement puts the value 123 into the variable. In other words, while the program is executing there will be a 64 bit section of memory that holds the value 123.
Remember that the word "execute" is often used to mean "run". You speak of "executing a program" or "executing" a line of the program.
Question 10:
![what is a assignment statement clear sunny desert yellow sand with celestial snow bridge](https://www.therevisionist.org/wp-content/uploads/2016/07/desert-space-bridge-Java-Statements-Expressions.png?x47895)
1.7 Java | Assignment Statements & Expressions
An assignment statement designates a value for a variable. An assignment statement can be used as an expression in Java.
After a variable is declared, you can assign a value to it by using an assignment statement . In Java, the equal sign = is used as the assignment operator . The syntax for assignment statements is as follows:
An expression represents a computation involving values, variables, and operators that, when taking them together, evaluates to a value. For example, consider the following code:
You can use a variable in an expression. A variable can also be used on both sides of the = operator. For example:
In the above assignment statement, the result of x + 1 is assigned to the variable x . Let’s say that x is 1 before the statement is executed, and so becomes 2 after the statement execution.
To assign a value to a variable, you must place the variable name to the left of the assignment operator. Thus the following statement is wrong:
Note that the math equation x = 2 * x + 1 ≠ the Java expression x = 2 * x + 1
![what is a assignment statement Java Assignment Statement vs Assignment Expression](https://www.therevisionist.org/wp-content/uploads/2016/07/Java-Assignment-Statement-vs-Assignment-Expression.png?x47895)
Which is equivalent to:
And this statement
is equivalent to:
Note: The data type of a variable on the left must be compatible with the data type of a value on the right. For example, int x = 1.0 would be illegal, because the data type of x is int (integer) and does not accept the double value 1.0 without Type Casting .
◄◄◄BACK | NEXT►►►
What's Your Opinion? Cancel reply
Enhance your Brain
Subscribe to Receive Free Bio Hacking, Nootropic, and Health Information
HTML for Simple Website Customization My Personal Web Customization Personal Insights
DISCLAIMER | Sitemap | ◘
![what is a assignment statement SponserImageUCD](https://www.therevisionist.org/wp-content/uploads/2016/08/SponserImageUCD.png?x47895)
HTML for Simple Website Customization My Personal Web Customization Personal Insights SEO Checklist Publishing Checklist My Tools
Top Posts & Pages
![what is a assignment statement The Best Keyboard Tilt for Reducing Wrist Pain to Zero](https://i0.wp.com/www.therevisionist.org/wp-content/uploads/2019/05/Positive-Keyboard-Tilt-Feet-up-Thumbnail-Picture.jpg?resize=40%2C40&ssl=1)
What Is an Assignment Statement in Java?
![what is a assignment statement ...](https://img.techwallacdn.com/375/photos.demandstudios.com/getty/article/129/69/90269670.jpg)
Java programs store data values in variables. When a programmer creates a variable in a Java application, he declares the type and name of the variable, then assigns a value to it. The value of a variable can be altered at subsequent points in execution using further assignment operations. The assignment statement in Java involves using the assignment operator to set the value of a variable. The exact syntax depends on the type of variable receiving a value.
Advertisement
Video of the Day
In Java, variables are strongly typed. This means that when you declare a variable in a Java program, you must declare its type, followed by its name. The following sample Java code demonstrates declaring two variables, one of primitive-type integer and one of an object type for a class within the application: int num; ApplicationHelper myHelp;
Once a program contains a variable declaration, the kind of value assigned to the variable must be suited to the type declared. These variable declarations could be followed by assignment statements on subsequent lines. However, the assignment operation could also take place on the same line as the declaration.
Assignment in Java is the process of giving a value to a primitive-type variable or giving an object reference to an object-type variable. The equals sign acts as assignment operator in Java, followed by the value to assign. The following sample Java code demonstrates assigning a value to a primitive-type integer variable, which has already been declared: num = 5;
The assignment operation could alternatively appear within the same line of code as the declaration of the variable, as follows: int num = 5;
The value of the variable can be altered again in subsequent processing as in this example: num++;
This code increments the variable value, adding a value of one to it.
Instantiation
When the assignment statement appears with object references, the assignment operation may also involve object instantiation. When Java code creates a new object instance of a Java class in an application, the "new" keyword causes the constructor method of the class to execute, instantiating the object. The following sample code demonstrates instantiating an object variable: myHelp = new ApplicationHelper();
This could also appear within the same line as the variable declaration as follows: ApplicationHelper myHelp = new ApplicationHelper();
When this line of code executes, the class constructor method executes, returning an instance of the class, a reference to which is stored by the variable.
Referencing
Once a variable has been declared and assigned a value, a Java program can refer to the variable in subsequent processing. For primitive-type variables, the variable name refers to a stored value. For object types, the variable refers to the location of the object instance in memory. This means that two object variables can point to the same instance, as in the following sample code: ApplicationHelper myHelp = new ApplicationHelper(); ApplicationHelper sameHelp = myHelp;
This syntax appears commonly when programs pass object references as parameters to class methods.
- Oracle: The Java Tutorials - Variables
- Oracle: The Java Tutorials - Assignment, Arithmetic, and Unary Operators
- Oracle: The Java Tutorials - Primitive Data Types
- Oracle: The Java Tutorials - Creating Objects
- Oracle: The Java Tutorials - What Is an Object?
- Oracle: The Java Tutorials - Summary of Variables
- Java Language Specification; Types, Values, and Variables; 2000
- Oracle: The Java Tutorials - Understanding Instance and Class Members
Variable Assignment
To "assign" a variable means to symbolically associate a specific piece of information with a name. Any operations that are applied to this "name" (or variable) must hold true for any possible values. The assignment operator is the equals sign which SHOULD NEVER be used for equality, which is the double equals sign.
The '=' symbol is the assignment operator. Warning, while the assignment operator looks like the traditional mathematical equals sign, this is NOT the case. The equals operator is '=='
Design Pattern
To evaluate an assignment statement:
- Evaluate the "right side" of the expression (to the right of the equal sign).
- Once everything is figured out, place the computed value into the variables bucket.
We've already seen many examples of assignment. Assignment means: "storing a value (of a particular type) under a variable name" . Think of each assignment as copying the value of the righthand side of the expression into a "bucket" associated with the left hand side name!
Read this as, the variable called "name" is "assigned" the value computed by the expression to the right of the assignment operator ('=');
Now that you have seen some variables being assigned, tell me what the following code means?
The answer to above questions: the assignment means that lkjasdlfjlskdfjlksjdflkj is a variable (a really badly named one), but a variable none-the-less. jlkajdsf and lkjsdflkjsdf must also be variables. The sum of the two numbers held in jlkajdsf and lkjsdflkjsdf is stored in the variable lkjasdlfjlskdfjlksjdflkj.
Examples of builtin Data and Variables (and Constants)
For more info, use the "help" command: (e.g., help realmin);
Examples of using Data and Variable
Pattern to memorize, assignment pattern.
The assignment pattern creates a new variable, if this is the first time we have seen the "name", or, updates the variable to a new value!
Read the following code in English as: First, compute the value of the thing to the right of the assignment operator (the =). then store the computed value under the given name, destroying anything that was there before.
Or more concisely: assign the variable "name" the value computed by "right_hand_expression"
- Python »
- 3.12.5 Documentation »
- The Python Language Reference »
- 7. Simple statements
- Theme Auto Light Dark |
7. Simple statements ¶
A simple statement is comprised within a single logical line. Several simple statements may occur on a single line separated by semicolons. The syntax for simple statements is:
7.1. Expression statements ¶
Expression statements are used (mostly interactively) to compute and write a value, or (usually) to call a procedure (a function that returns no meaningful result; in Python, procedures return the value None ). Other uses of expression statements are allowed and occasionally useful. The syntax for an expression statement is:
An expression statement evaluates the expression list (which may be a single expression).
In interactive mode, if the value is not None , it is converted to a string using the built-in repr() function and the resulting string is written to standard output on a line by itself (except if the result is None , so that procedure calls do not cause any output.)
7.2. Assignment statements ¶
Assignment statements are used to (re)bind names to values and to modify attributes or items of mutable objects:
(See section Primaries for the syntax definitions for attributeref , subscription , and slicing .)
An assignment statement evaluates the expression list (remember that this can be a single expression or a comma-separated list, the latter yielding a tuple) and assigns the single resulting object to each of the target lists, from left to right.
Assignment is defined recursively depending on the form of the target (list). When a target is part of a mutable object (an attribute reference, subscription or slicing), the mutable object must ultimately perform the assignment and decide about its validity, and may raise an exception if the assignment is unacceptable. The rules observed by various types and the exceptions raised are given with the definition of the object types (see section The standard type hierarchy ).
Assignment of an object to a target list, optionally enclosed in parentheses or square brackets, is recursively defined as follows.
If the target list is a single target with no trailing comma, optionally in parentheses, the object is assigned to that target.
If the target list contains one target prefixed with an asterisk, called a “starred” target: The object must be an iterable with at least as many items as there are targets in the target list, minus one. The first items of the iterable are assigned, from left to right, to the targets before the starred target. The final items of the iterable are assigned to the targets after the starred target. A list of the remaining items in the iterable is then assigned to the starred target (the list can be empty).
Else: The object must be an iterable with the same number of items as there are targets in the target list, and the items are assigned, from left to right, to the corresponding targets.
Assignment of an object to a single target is recursively defined as follows.
If the target is an identifier (name):
If the name does not occur in a global or nonlocal statement in the current code block: the name is bound to the object in the current local namespace.
Otherwise: the name is bound to the object in the global namespace or the outer namespace determined by nonlocal , respectively.
The name is rebound if it was already bound. This may cause the reference count for the object previously bound to the name to reach zero, causing the object to be deallocated and its destructor (if it has one) to be called.
If the target is an attribute reference: The primary expression in the reference is evaluated. It should yield an object with assignable attributes; if this is not the case, TypeError is raised. That object is then asked to assign the assigned object to the given attribute; if it cannot perform the assignment, it raises an exception (usually but not necessarily AttributeError ).
Note: If the object is a class instance and the attribute reference occurs on both sides of the assignment operator, the right-hand side expression, a.x can access either an instance attribute or (if no instance attribute exists) a class attribute. The left-hand side target a.x is always set as an instance attribute, creating it if necessary. Thus, the two occurrences of a.x do not necessarily refer to the same attribute: if the right-hand side expression refers to a class attribute, the left-hand side creates a new instance attribute as the target of the assignment:
This description does not necessarily apply to descriptor attributes, such as properties created with property() .
If the target is a subscription: The primary expression in the reference is evaluated. It should yield either a mutable sequence object (such as a list) or a mapping object (such as a dictionary). Next, the subscript expression is evaluated.
If the primary is a mutable sequence object (such as a list), the subscript must yield an integer. If it is negative, the sequence’s length is added to it. The resulting value must be a nonnegative integer less than the sequence’s length, and the sequence is asked to assign the assigned object to its item with that index. If the index is out of range, IndexError is raised (assignment to a subscripted sequence cannot add new items to a list).
If the primary is a mapping object (such as a dictionary), the subscript must have a type compatible with the mapping’s key type, and the mapping is then asked to create a key/value pair which maps the subscript to the assigned object. This can either replace an existing key/value pair with the same key value, or insert a new key/value pair (if no key with the same value existed).
For user-defined objects, the __setitem__() method is called with appropriate arguments.
If the target is a slicing: The primary expression in the reference is evaluated. It should yield a mutable sequence object (such as a list). The assigned object should be a sequence object of the same type. Next, the lower and upper bound expressions are evaluated, insofar they are present; defaults are zero and the sequence’s length. The bounds should evaluate to integers. If either bound is negative, the sequence’s length is added to it. The resulting bounds are clipped to lie between zero and the sequence’s length, inclusive. Finally, the sequence object is asked to replace the slice with the items of the assigned sequence. The length of the slice may be different from the length of the assigned sequence, thus changing the length of the target sequence, if the target sequence allows it.
CPython implementation detail: In the current implementation, the syntax for targets is taken to be the same as for expressions, and invalid syntax is rejected during the code generation phase, causing less detailed error messages.
Although the definition of assignment implies that overlaps between the left-hand side and the right-hand side are ‘simultaneous’ (for example a, b = b, a swaps two variables), overlaps within the collection of assigned-to variables occur left-to-right, sometimes resulting in confusion. For instance, the following program prints [0, 2] :
The specification for the *target feature.
7.2.1. Augmented assignment statements ¶
Augmented assignment is the combination, in a single statement, of a binary operation and an assignment statement:
(See section Primaries for the syntax definitions of the last three symbols.)
An augmented assignment evaluates the target (which, unlike normal assignment statements, cannot be an unpacking) and the expression list, performs the binary operation specific to the type of assignment on the two operands, and assigns the result to the original target. The target is only evaluated once.
An augmented assignment statement like x += 1 can be rewritten as x = x + 1 to achieve a similar, but not exactly equal effect. In the augmented version, x is only evaluated once. Also, when possible, the actual operation is performed in-place , meaning that rather than creating a new object and assigning that to the target, the old object is modified instead.
Unlike normal assignments, augmented assignments evaluate the left-hand side before evaluating the right-hand side. For example, a[i] += f(x) first looks-up a[i] , then it evaluates f(x) and performs the addition, and lastly, it writes the result back to a[i] .
With the exception of assigning to tuples and multiple targets in a single statement, the assignment done by augmented assignment statements is handled the same way as normal assignments. Similarly, with the exception of the possible in-place behavior, the binary operation performed by augmented assignment is the same as the normal binary operations.
For targets which are attribute references, the same caveat about class and instance attributes applies as for regular assignments.
7.2.2. Annotated assignment statements ¶
Annotation assignment is the combination, in a single statement, of a variable or attribute annotation and an optional assignment statement:
The difference from normal Assignment statements is that only a single target is allowed.
The assignment target is considered “simple” if it consists of a single name that is not enclosed in parentheses. For simple assignment targets, if in class or module scope, the annotations are evaluated and stored in a special class or module attribute __annotations__ that is a dictionary mapping from variable names (mangled if private) to evaluated annotations. This attribute is writable and is automatically created at the start of class or module body execution, if annotations are found statically.
If the assignment target is not simple (an attribute, subscript node, or parenthesized name), the annotation is evaluated if in class or module scope, but not stored.
If a name is annotated in a function scope, then this name is local for that scope. Annotations are never evaluated and stored in function scopes.
If the right hand side is present, an annotated assignment performs the actual assignment before evaluating annotations (where applicable). If the right hand side is not present for an expression target, then the interpreter evaluates the target except for the last __setitem__() or __setattr__() call.
The proposal that added syntax for annotating the types of variables (including class variables and instance variables), instead of expressing them through comments.
The proposal that added the typing module to provide a standard syntax for type annotations that can be used in static analysis tools and IDEs.
Changed in version 3.8: Now annotated assignments allow the same expressions in the right hand side as regular assignments. Previously, some expressions (like un-parenthesized tuple expressions) caused a syntax error.
7.3. The assert statement ¶
Assert statements are a convenient way to insert debugging assertions into a program:
The simple form, assert expression , is equivalent to
The extended form, assert expression1, expression2 , is equivalent to
These equivalences assume that __debug__ and AssertionError refer to the built-in variables with those names. In the current implementation, the built-in variable __debug__ is True under normal circumstances, False when optimization is requested (command line option -O ). The current code generator emits no code for an assert statement when optimization is requested at compile time. Note that it is unnecessary to include the source code for the expression that failed in the error message; it will be displayed as part of the stack trace.
Assignments to __debug__ are illegal. The value for the built-in variable is determined when the interpreter starts.
![](http://mangareview.fun/777/templates/cheerup/res/banner1.gif)
7.4. The pass statement ¶
pass is a null operation — when it is executed, nothing happens. It is useful as a placeholder when a statement is required syntactically, but no code needs to be executed, for example:
7.5. The del statement ¶
Deletion is recursively defined very similar to the way assignment is defined. Rather than spelling it out in full details, here are some hints.
Deletion of a target list recursively deletes each target, from left to right.
Deletion of a name removes the binding of that name from the local or global namespace, depending on whether the name occurs in a global statement in the same code block. If the name is unbound, a NameError exception will be raised.
Deletion of attribute references, subscriptions and slicings is passed to the primary object involved; deletion of a slicing is in general equivalent to assignment of an empty slice of the right type (but even this is determined by the sliced object).
Changed in version 3.2: Previously it was illegal to delete a name from the local namespace if it occurs as a free variable in a nested block.
7.6. The return statement ¶
return may only occur syntactically nested in a function definition, not within a nested class definition.
If an expression list is present, it is evaluated, else None is substituted.
return leaves the current function call with the expression list (or None ) as return value.
When return passes control out of a try statement with a finally clause, that finally clause is executed before really leaving the function.
In a generator function, the return statement indicates that the generator is done and will cause StopIteration to be raised. The returned value (if any) is used as an argument to construct StopIteration and becomes the StopIteration.value attribute.
In an asynchronous generator function, an empty return statement indicates that the asynchronous generator is done and will cause StopAsyncIteration to be raised. A non-empty return statement is a syntax error in an asynchronous generator function.
7.7. The yield statement ¶
A yield statement is semantically equivalent to a yield expression . The yield statement can be used to omit the parentheses that would otherwise be required in the equivalent yield expression statement. For example, the yield statements
are equivalent to the yield expression statements
Yield expressions and statements are only used when defining a generator function, and are only used in the body of the generator function. Using yield in a function definition is sufficient to cause that definition to create a generator function instead of a normal function.
For full details of yield semantics, refer to the Yield expressions section.
7.8. The raise statement ¶
If no expressions are present, raise re-raises the exception that is currently being handled, which is also known as the active exception . If there isn’t currently an active exception, a RuntimeError exception is raised indicating that this is an error.
Otherwise, raise evaluates the first expression as the exception object. It must be either a subclass or an instance of BaseException . If it is a class, the exception instance will be obtained when needed by instantiating the class with no arguments.
The type of the exception is the exception instance’s class, the value is the instance itself.
A traceback object is normally created automatically when an exception is raised and attached to it as the __traceback__ attribute. You can create an exception and set your own traceback in one step using the with_traceback() exception method (which returns the same exception instance, with its traceback set to its argument), like so:
The from clause is used for exception chaining: if given, the second expression must be another exception class or instance. If the second expression is an exception instance, it will be attached to the raised exception as the __cause__ attribute (which is writable). If the expression is an exception class, the class will be instantiated and the resulting exception instance will be attached to the raised exception as the __cause__ attribute. If the raised exception is not handled, both exceptions will be printed:
A similar mechanism works implicitly if a new exception is raised when an exception is already being handled. An exception may be handled when an except or finally clause, or a with statement, is used. The previous exception is then attached as the new exception’s __context__ attribute:
Exception chaining can be explicitly suppressed by specifying None in the from clause:
Additional information on exceptions can be found in section Exceptions , and information about handling exceptions is in section The try statement .
Changed in version 3.3: None is now permitted as Y in raise X from Y .
Added the __suppress_context__ attribute to suppress automatic display of the exception context.
Changed in version 3.11: If the traceback of the active exception is modified in an except clause, a subsequent raise statement re-raises the exception with the modified traceback. Previously, the exception was re-raised with the traceback it had when it was caught.
7.9. The break statement ¶
break may only occur syntactically nested in a for or while loop, but not nested in a function or class definition within that loop.
It terminates the nearest enclosing loop, skipping the optional else clause if the loop has one.
If a for loop is terminated by break , the loop control target keeps its current value.
When break passes control out of a try statement with a finally clause, that finally clause is executed before really leaving the loop.
7.10. The continue statement ¶
continue may only occur syntactically nested in a for or while loop, but not nested in a function or class definition within that loop. It continues with the next cycle of the nearest enclosing loop.
When continue passes control out of a try statement with a finally clause, that finally clause is executed before really starting the next loop cycle.
7.11. The import statement ¶
The basic import statement (no from clause) is executed in two steps:
find a module, loading and initializing it if necessary
define a name or names in the local namespace for the scope where the import statement occurs.
When the statement contains multiple clauses (separated by commas) the two steps are carried out separately for each clause, just as though the clauses had been separated out into individual import statements.
The details of the first step, finding and loading modules, are described in greater detail in the section on the import system , which also describes the various types of packages and modules that can be imported, as well as all the hooks that can be used to customize the import system. Note that failures in this step may indicate either that the module could not be located, or that an error occurred while initializing the module, which includes execution of the module’s code.
If the requested module is retrieved successfully, it will be made available in the local namespace in one of three ways:
If the module name is followed by as , then the name following as is bound directly to the imported module.
If no other name is specified, and the module being imported is a top level module, the module’s name is bound in the local namespace as a reference to the imported module
If the module being imported is not a top level module, then the name of the top level package that contains the module is bound in the local namespace as a reference to the top level package. The imported module must be accessed using its full qualified name rather than directly
The from form uses a slightly more complex process:
find the module specified in the from clause, loading and initializing it if necessary;
for each of the identifiers specified in the import clauses:
check if the imported module has an attribute by that name
if not, attempt to import a submodule with that name and then check the imported module again for that attribute
if the attribute is not found, ImportError is raised.
otherwise, a reference to that value is stored in the local namespace, using the name in the as clause if it is present, otherwise using the attribute name
If the list of identifiers is replaced by a star ( '*' ), all public names defined in the module are bound in the local namespace for the scope where the import statement occurs.
The public names defined by a module are determined by checking the module’s namespace for a variable named __all__ ; if defined, it must be a sequence of strings which are names defined or imported by that module. The names given in __all__ are all considered public and are required to exist. If __all__ is not defined, the set of public names includes all names found in the module’s namespace which do not begin with an underscore character ( '_' ). __all__ should contain the entire public API. It is intended to avoid accidentally exporting items that are not part of the API (such as library modules which were imported and used within the module).
The wild card form of import — from module import * — is only allowed at the module level. Attempting to use it in class or function definitions will raise a SyntaxError .
When specifying what module to import you do not have to specify the absolute name of the module. When a module or package is contained within another package it is possible to make a relative import within the same top package without having to mention the package name. By using leading dots in the specified module or package after from you can specify how high to traverse up the current package hierarchy without specifying exact names. One leading dot means the current package where the module making the import exists. Two dots means up one package level. Three dots is up two levels, etc. So if you execute from . import mod from a module in the pkg package then you will end up importing pkg.mod . If you execute from ..subpkg2 import mod from within pkg.subpkg1 you will import pkg.subpkg2.mod . The specification for relative imports is contained in the Package Relative Imports section.
importlib.import_module() is provided to support applications that determine dynamically the modules to be loaded.
Raises an auditing event import with arguments module , filename , sys.path , sys.meta_path , sys.path_hooks .
7.11.1. Future statements ¶
A future statement is a directive to the compiler that a particular module should be compiled using syntax or semantics that will be available in a specified future release of Python where the feature becomes standard.
The future statement is intended to ease migration to future versions of Python that introduce incompatible changes to the language. It allows use of the new features on a per-module basis before the release in which the feature becomes standard.
A future statement must appear near the top of the module. The only lines that can appear before a future statement are:
the module docstring (if any),
blank lines, and
other future statements.
The only feature that requires using the future statement is annotations (see PEP 563 ).
All historical features enabled by the future statement are still recognized by Python 3. The list includes absolute_import , division , generators , generator_stop , unicode_literals , print_function , nested_scopes and with_statement . They are all redundant because they are always enabled, and only kept for backwards compatibility.
A future statement is recognized and treated specially at compile time: Changes to the semantics of core constructs are often implemented by generating different code. It may even be the case that a new feature introduces new incompatible syntax (such as a new reserved word), in which case the compiler may need to parse the module differently. Such decisions cannot be pushed off until runtime.
For any given release, the compiler knows which feature names have been defined, and raises a compile-time error if a future statement contains a feature not known to it.
The direct runtime semantics are the same as for any import statement: there is a standard module __future__ , described later, and it will be imported in the usual way at the time the future statement is executed.
The interesting runtime semantics depend on the specific feature enabled by the future statement.
Note that there is nothing special about the statement:
That is not a future statement; it’s an ordinary import statement with no special semantics or syntax restrictions.
Code compiled by calls to the built-in functions exec() and compile() that occur in a module M containing a future statement will, by default, use the new syntax or semantics associated with the future statement. This can be controlled by optional arguments to compile() — see the documentation of that function for details.
A future statement typed at an interactive interpreter prompt will take effect for the rest of the interpreter session. If an interpreter is started with the -i option, is passed a script name to execute, and the script includes a future statement, it will be in effect in the interactive session started after the script is executed.
The original proposal for the __future__ mechanism.
7.12. The global statement ¶
The global statement is a declaration which holds for the entire current code block. It means that the listed identifiers are to be interpreted as globals. It would be impossible to assign to a global variable without global , although free variables may refer to globals without being declared global.
Names listed in a global statement must not be used in the same code block textually preceding that global statement.
Names listed in a global statement must not be defined as formal parameters, or as targets in with statements or except clauses, or in a for target list, class definition, function definition, import statement, or variable annotation.
CPython implementation detail: The current implementation does not enforce some of these restrictions, but programs should not abuse this freedom, as future implementations may enforce them or silently change the meaning of the program.
Programmer’s note: global is a directive to the parser. It applies only to code parsed at the same time as the global statement. In particular, a global statement contained in a string or code object supplied to the built-in exec() function does not affect the code block containing the function call, and code contained in such a string is unaffected by global statements in the code containing the function call. The same applies to the eval() and compile() functions.
7.13. The nonlocal statement ¶
When the definition of a function or class is nested (enclosed) within the definitions of other functions, its nonlocal scopes are the local scopes of the enclosing functions. The nonlocal statement causes the listed identifiers to refer to names previously bound in nonlocal scopes. It allows encapsulated code to rebind such nonlocal identifiers. If a name is bound in more than one nonlocal scope, the nearest binding is used. If a name is not bound in any nonlocal scope, or if there is no nonlocal scope, a SyntaxError is raised.
The nonlocal statement applies to the entire scope of a function or class body. A SyntaxError is raised if a variable is used or assigned to prior to its nonlocal declaration in the scope.
The specification for the nonlocal statement.
Programmer’s note: nonlocal is a directive to the parser and applies only to code parsed along with it. See the note for the global statement.
7.14. The type statement ¶
The type statement declares a type alias, which is an instance of typing.TypeAliasType .
For example, the following statement creates a type alias:
This code is roughly equivalent to:
annotation-def indicates an annotation scope , which behaves mostly like a function, but with several small differences.
The value of the type alias is evaluated in the annotation scope. It is not evaluated when the type alias is created, but only when the value is accessed through the type alias’s __value__ attribute (see Lazy evaluation ). This allows the type alias to refer to names that are not yet defined.
Type aliases may be made generic by adding a type parameter list after the name. See Generic type aliases for more.
type is a soft keyword .
Added in version 3.12.
Introduced the type statement and syntax for generic classes and functions.
Table of Contents
- 7.1. Expression statements
- 7.2.1. Augmented assignment statements
- 7.2.2. Annotated assignment statements
- 7.3. The assert statement
- 7.4. The pass statement
- 7.5. The del statement
- 7.6. The return statement
- 7.7. The yield statement
- 7.8. The raise statement
- 7.9. The break statement
- 7.10. The continue statement
- 7.11.1. Future statements
- 7.12. The global statement
- 7.13. The nonlocal statement
- 7.14. The type statement
Previous topic
6. Expressions
8. Compound statements
- Report a Bug
- Show Source
- Trending Categories
![what is a assignment statement Data Structure](https://www.tutorialspoint.com/images/Data-Structure.png)
- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
Different Forms of Assignment Statements in Python
Assignment statement in python is the statement used to assign the value to the specified variable. The value assigned to the variable can be of any data type supported by python programming language such as integer, string, float Boolean, list, tuple, dictionary, set etc.
Types of assignment statements
The different types of assignment statements are as follows.
Basic assignment statement
Multiple assignment statement
Augmented assignment statement
Chained assignment statement, unpacking assignment statement, swapping assignment statement.
Let’s see about each one in detail.
Basic Assignment Statement
The most frequently and commonly used is the basic assignment statement. In this type of assignment, we will assign the value to the variable directly. Following is the syntax.
Variable_name is the name of the variable.
value is the any datatype of input value to be assigned to the variable.
In this example, we are assigning a value to the variable using the basic assignment statement in the static manner.
In this example, we will use the dynamic inputting way to assign the value using the basic assignment statement.
Multiple Assignment statement
We can assign multiple values to multiple variables within a single line of code in python. Following is the syntax.
v1,v2,……,vn are the variable names.
val1,val2,……,valn are the values.
In this example, we will assign multiple values to the multiple variables using the multiple assignment statement.
By using the augmented assignment statement, we can combine the arithmetic or bitwise operations with the assignment. Following is the syntax.
variable is the variable name.
value is the input value.
+= is the assignment operator with the arithmetic operator.
In this example, we will use the augmented assignment statement to assign the values to the variable.
By using the chained assignment statement, we can assign a single value to the multiple variables within a single line. Following is the syntax -
v1,v2,v3 are the variable names.
value is the value to be assigned to the variables.
Here is the example to assign the single value to the multiple variables using the chain assignment statement.
We can assign the values given in a list or tuple can be assigned to multiple variables using the unpacking assignment statement. Following is the syntax -
val1,val2,val3 are the values.
In this example, we will assign the values grouped in the list to the multiple variables using the unpacking assignment statement.
In python, we can swap two values of the variables without using any temporary third variable with the help of assignment statement. Following is the syntax.
var1, var2 are the variables.
In the following example, we will assign the values two variables and swap the values with each other.
![what is a assignment statement Niharika Aitam](https://www.tutorialspoint.com/assets/profiles/654775/profile/60_3867437-1684125242.jpg)
- Related Articles
- What is assignment statements with Integer types in compiler design?
- Give the different forms of silica in nature.
- A += B Assignment Riddle in Python
- Python – Priority key assignment in dictionary
- Python Program to Minimum Value Key Assignment
- What is vertical bar in Python bitwise assignment operator?
- Multiple Statements in Python
- Multi-Line Statements in Python
- Loop Control Statements in Python
- The import Statements in Python
- What are the different types of conditional statements supported by C#?
- Compound Assignment Operators in C++
- Compound assignment operators in C#
- Short Circuit Assignment in JavaScript
- Assignment operators in Dart Programming
Kickstart Your Career
Get certified by completing the course
- Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers
- Advertising & Talent Reach devs & technologists worldwide about your product, service or employer brand
- OverflowAI GenAI features for Teams
- OverflowAPI Train & fine-tune LLMs
- Labs The future of collective knowledge sharing
- About the company Visit the blog
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.
Why do assignment statements return a value?
This is allowed:
To my understanding, assignment s = ”Hello”; should only cause “Hello” to be assigned to s , but the operation shouldn’t return any value. If that was true, then ((s = "Hello") != null) would produce an error, since null would be compared to nothing.
What is the reasoning behind allowing assignment statements to return a value?
- 49 For reference, this behavior is defined in the C# spec : "The result of a simple assignment expression is the value assigned to the left operand. The result has the same type as the left operand and is always classified as a value." – Michael Petrotta Commented Sep 27, 2010 at 19:41
- 1 @Skurmedel I am not the downvoter, I agree with you. But maybe because it was thought to be a rhetorical question? – jsmith Commented Sep 27, 2010 at 19:48
- 1 In pascal/delphi assignment := returns nothing. i hate it. – Andrey Commented Sep 27, 2010 at 19:51
- 20 Standard for languages in the C branch. Assignments are expressions. – Hans Passant Commented Sep 27, 2010 at 19:52
- "assignment ... should only cause “Hello” to be assigned to s, but the operation shouldn’t return any value" -- Why? "What is the reasoning behind allowing assignment statements to return a value?" -- Because it's useful, as your own examples demonstrate. (Well, your second example is silly, but while ((s = GetWord()) != null) Process(s); is not). – Jim Balter Commented Jul 23, 2015 at 21:40
14 Answers 14
To my understanding, assignment s = "Hello"; should only cause "Hello" to be assigned to s, but the operation shouldn’t return any value.
Your understanding is 100% incorrect. Can you explain why you believe this false thing?
First off, assignment statements do not produce a value. Assignment expressions produce a value. An assignment expression is a legal statement; there are only a handful of expressions which are legal statements in C#: awaits of an expression, instance construction, increment, decrement, invocation and assignment expressions may be used where a statement is expected.
There is only one kind of expression in C# which does not produce some sort of value, namely, an invocation of something that is typed as returning void. (Or, equivalently, an await of a task with no associated result value.) Every other kind of expression produces a value or variable or reference or property access or event access, and so on.
Notice that all the expressions which are legal as statements are useful for their side effects . That's the key insight here, and I think perhaps the cause of your intuition that assignments should be statements and not expressions. Ideally, we'd have exactly one side effect per statement, and no side effects in an expression. It is a bit odd that side-effecting code can be used in an expression context at all.
The reasoning behind allowing this feature is because (1) it is frequently convenient and (2) it is idiomatic in C-like languages.
One might note that the question has been begged: why is this idiomatic in C-like languages?
Dennis Ritchie is no longer available to ask, unfortunately, but my guess is that an assignment almost always leaves behind the value that was just assigned in a register. C is a very "close to the machine" sort of language. It seems plausible and in keeping with the design of C that there be a language feature which basically means "keep on using the value that I just assigned". It is very easy to write a code generator for this feature; you just keep on using the register that stored the value that was assigned.
- 1 Wasn't aware that anything which returns a value ( even instance construction is considered an expression ) – user437291 Commented Sep 27, 2010 at 20:56
- 9 @user437291: If instance construction wasn’t an expression, you couldn’t do anything with the constructed object — you couldn’t assign it to something, you couldn’t pass it into a method, and you couldn’t call any methods on it. Would be pretty useless, wouldn’t it? – Timwi Commented Sep 27, 2010 at 22:45
- 1 Changing a variable is actually "just" a side effect of the assignment operator, which, creating an expression, yields a value as its primary purpose. – mk12 Commented Aug 24, 2012 at 22:08
- 2 "Your understanding is 100% incorrect." -- While the OP's use of English isn't the greatest, his/her "understanding" is about what should be the case, making it an opinion, so it isn't the sort of thing than can be "100% incorrect". Some language designers agree with the OP's "should", and make assignments have no value or otherwise ban them from being subexpressions. I think that's an overreaction to the = / == typo, which is easily addressed by disallowing using the value of = unless it is parenthesed. e.g., if ((x = y)) or if ((x = y) == true) is allowed but if (x = y) is not. – Jim Balter Commented Jul 23, 2015 at 21:01
- 1 @BobKaufman: Fun fact, JavaScript still does that . Never do this, but in JavaScript you can say x=eval("if(whatever)y=2; else z=3;"); and x will be either 2 or 3 . eval is pure unmitigated evil . – Eric Lippert Commented Aug 29, 2018 at 18:55
Haven’t you provided the answer? It’s to enable exactly the kinds of constructs you have mentioned.
A common case where this property of the assignment operator is used is reading lines from a file...
- 1 +1 This has to be one of the most practical uses of this construct – Mike Burton Commented Sep 27, 2010 at 20:40
- 13 I really like it for really simple property initializers, but you have to be careful and draw your line for "simple" low for readability: return _myBackingField ?? (_myBackingField = CalculateBackingField()); A lot less chaff than checking for null and assigning. – Tom Mayfield Commented Sep 27, 2010 at 22:02
My favorite use of assignment expressions is for lazily initialized properties.
- 6 Which is why so many people have suggested the ??= syntax. – configurator Commented Sep 10, 2011 at 19:39
- 2 Now that ??= is there, you can still use it with an assignment expression, makes it even easier: public string Name => this.name ??= ExpensiveNameGeneratorMethod(); – jsabrooke Commented Oct 14, 2020 at 8:52
- Sad that ??= is only available for .NET Core :( – Alex from Jitbit Commented Mar 29, 2021 at 10:29
For one, it allows you to chain your assignments, as in your example:
For another, it allows you to assign and check a result in a single expression:
Both are possibly dubious reasons, but there are definitely people who like these constructs.
- 6 +1 Chaining isn't a critical feature but it's nice to see it "just works" when so many things don't. – Mike Burton Commented Sep 27, 2010 at 20:41
- +1 for chaining also; I'd always thought of that as a special case that was handled by the language rather than the natural side effect of "expressions return values". – Caleb Bell Commented Nov 30, 2011 at 17:59
- 2 It also allows you to use assignment in returns: return (HttpContext.Current.Items["x"] = myvar); – Serge Shultz Commented Mar 12, 2013 at 9:48
Aside from the reasons already mentioned (assignment chaining, set-and-test within while loops, etc), to properly use the using statement you need this feature:
MSDN discourages declaring the disposable object outside of the using statement, as it will then remain in scope even after it has been disposed (see the MSDN article I linked).
- 4 I don't think this is really assignment chaining per se. – kenny Commented Sep 27, 2010 at 20:53
- 1 @kenny: Uh... No, but I never claimed it was, either. As I said, aside from the reasons already mentioned -- which includes assignment chaining -- the using statement would be a lot more difficult to use were it not for the fact that the assignment operator returns the result of the assignment operation. This isn't really related to assignment chaining at all. – Martin Törnwall Commented Sep 27, 2010 at 21:32
- 1 But as Eric noted above, "assignment statements do not return a value". This is actually just language syntax of the using statement, proof to that is that one can't use an "assignment expression" in a using statement. – kenny Commented Sep 27, 2010 at 22:31
- 2 @kenny: Actually, one can use either a definition-and-assignment statement, or any expression in using . All of these are legal: using (X x = new X()) , using (x = new X()) , using (x) . However, in this example, the contents of the using statement is a special syntax that doesn't rely at all on assignment returning a value - Font font3 = new Font("Arial", 10.0f) is not an expression and is not valid in any place that expects expressions. – configurator Commented Sep 10, 2011 at 19:37
- 1 " to properly use the using statement you need this feature" -- No, you most certainly do not. "without the language having general support for assignment expressions returning a value" -- why are you talking about assignment expressions? This is a variable definition with an initializer -- which is not an expression. "That would, in my eyes, be terribly inconsistent though." -- Your example of using (definition) completely contradicts you ... there's nowhere else such a construction can be used. – Jim Balter Commented Jul 23, 2015 at 21:18
I'd like to elaborate on a specific point Eric Lippert made in his answer and put the spotlight on a particular occasion that hasn't at all been touched upon by anyone else. Eric said:
[...] an assignment almost always leaves behind the value that was just assigned in a register.
I'd like to say that the assignment will always leave behind the value we tried to assign to our left operand. Not just "almost always". But I don't know because I haven't found this issue commented in the documentation. It might theoretically be a very effective implemented procedure to "leave behind" and not reevaluate the left operand, but is it efficient?
'Efficient' yes for all the examples so far constructed in the answers of this thread. But efficient in the case of properties and indexers that use get- and set accessors? Not at all. Consider this code:
Here we have a property, which isn't even a wrapper for a private variable. Whenever called upon he shall return true, whenever one tries to set his value he shall do nothing. Thus whenever this property is evaluated, he shall be truthy. Let's see what happens:
Guess what it prints? It prints Unexpected!! . As it turns out, the set accessor is indeed called, which does nothing. But thereafter, the get accessor is never called at all. The assignment simply leaves behind the false value we tried to assign to our property. And this false value is what the if statement evaluates.
I'll finish off with a real world example that got me researching this issue. I made an indexer which was a convenient wrapper for a collection ( List<string> ) that a class of mine had as a private variable.
The parameter sent to the indexer was a string, which was to be treated as a value in my collection. The get accessor would simply return true or false if that value existed in the list or not. Thus the get accessor was another way to use the List<T>.Contains method.
If the indexer's set accessor was called with a string as an argument and the right operand was a bool true , he would add that parameter to the list. But if the same parameter was sent to the accessor and the right operand was a bool false , he would instead delete the element from the list. Thus the set accessor was used as a convenient alternative to both List<T>.Add and List<T>.Remove .
I thought I had a neat and compact "API" wrapping the list with my own logic implemented as a gateway. With the help of an indexer alone I could do many things with a few set of keystrokes. For instance, how can I try to add a value to my list and verify that it's in there? I thought this was the only line of code necessary:
But as my earlier example showed, the get accessor which is supposed to see if the value really is in the list wasn't even called. The true value was always left behind effectively destroying whatever logic I had implemented in my get accessor.
- Very interesting answer. And it's made me think positively about test-driven development. – Elliot Commented Feb 12, 2015 at 15:04
- 1 While this is interesting, it's a comment upon Eric's answer, not an answer to the OP's question. – Jim Balter Commented Jul 23, 2015 at 21:25
- 1 I wouldn't expect an attempted assignment expression to first get the value of the target property. If the variable is mutable, and the types match, why would it matter what the old value was? Just set the new value. I'm not a fan of assignment in IF tests though. Is it returning true because the assignment was successful, or it's some value e.g. a positive integer that is coerced to true, or because you are assigning a boolean? Regardless of the implementation, the logic is ambiguous. – Davos Commented Sep 1, 2016 at 11:42
If assignment didn't return a value, the line a = b = c = 16 wouldn't work either.
Also being able to write things like while ((s = readLine()) != null) can be useful sometimes.
So the reason behind letting assignment return the assigned value, is to let you do those things.
- Nobody's mentioned disadvantages - I came here wondering why assignments couldn't return null, in order that the common assignment vs comparison bug 'if (something = 1){}' would fail to compile rather than always returning true. I now see that that would create... other issues! – Jon Commented Mar 11, 2014 at 15:35
- 1 @Jon that bug could be easily prevented by disallowing or warning about = occurring in an expression that isn't parenthesized (not counting the parens of the if/while statement itself). gcc gives such warnings and has thereby essentially eliminated this class of bugs from C/C++ programs that are compiled with it. It's a shame that other compiler writers have paid so little attention to this and several other good ideas in gcc. – Jim Balter Commented Jul 23, 2015 at 21:10
I think you're misunderstanding how the parser is going to interpret that syntax. The assignment will be evaluated first , and the result will then be compared to NULL, i.e. the statement is equivalent to:
As others have pointed out, the result of an assignment is the assigned value. I find it hard to imagine the advantage to having
((s = "Hello") != null)
not be equivalent...
- While you are right from a practical sense that your two lines are equivalent your statement that the assignment is not returning a value is not technically true. My understanding is that the result of an assignment is a value (per the C# spec), and in that sense is no different from say the addition operator in an expression like 1 + 2 + 3 – Steve Ellinger Commented Sep 27, 2010 at 20:25
I think the main reason is the (intentional) similarity with C++ and C. Making the assigment operator (and a lot of other language constructs) behave like their C++ counterparts just follows the principle of least surprise, and any programmer coming from another curly-bracket language can use them without spending much thought. Being easy to pick up for C++ programmers was one of the main design goals for C#.
For the two reasons you include in your post 1) so you can do a = b = c = 16 2) so you can test if an assignment succeeded if ((s = openSomeHandle()) != null)
The fact that 'a++' or 'printf("foo")' may be useful either as a self-contained statement or as a part of a larger expression means that C has to allow for the possibility that expression results may or may not be used. Given that, there's a general notion that expressions which might usefully 'return' a value may as well do so. Assignment chaining can be slightly "interesting" in C, and even more interesting in C++, if all the variables in question do not have precisely the same type. Such usages are probably best avoided.
An extra advantage I don't see given in the answers here, is that the syntax for assignment is based on arithmetic.
Now x = y = b = c = 2 + 3 means something different in arithmetic than a C-style language; in arithmetic its an assertion, we state that x is equal to y etc. and in a C-style language it's an instruction that makes x equal to y etc. after it is executed.
This said, there's still enough relation between the arithmetic and the code that it doesn't make sense to disallow what is natural in the arithmetic unless there's a good reason. (The other thing that C-style languages took from the use of the equals symbol is the use of == for equality comparison. Here though because the right-most == returns a value this sort of chaining would be impossible.)
- @JimBalter I wonder whether, in five years time, you might actually make an argument against. – Jon Hanna Commented Jul 23, 2015 at 21:27
- @JimBalter no, your second comment is actually a counter argument, and a sound one. My thinking retort was because your first comment was not. Still, when learning arithmetic we learn a = b = c means that a and b and c are the same thing. When learning a C style language we learn that after a = b = c , a and b are the same thing as c . There's certainly a difference in semantics, as my answer itself says, but still when as a child I first learned to program in a language which did use = for assignment but didn't allow a = b = c this seemed unreasonable to me, though … – Jon Hanna Commented Jul 23, 2015 at 22:01
- … unavoidable because that language also used = for equality comparison, so in that a = b = c would have to mean what a = b == c means in C-style languages. I found the chaining allowed in C a lot more intuitive because I could draw an analogy to arithmetic. – Jon Hanna Commented Jul 23, 2015 at 22:04
Another great example use-case, I use this all the time:
I like using the assignment return value when I need to update a bunch of stuff and return whether or not there were any changes:
Be careful though. You might think you can shorten it to this:
But this will actually stop evaluating the or statements after it finds the first true. In this case that means it stops assigning subsequent values once it assigns the first value that is different.
See https://dotnetfiddle.net/e05Rh8 to play around with this
![what is a assignment statement Luke Kubat's user avatar](https://lh4.googleusercontent.com/-7nXsE2DIRIg/AAAAAAAAAAI/AAAAAAAAAXw/9fIdkiMQQ_E/photo.jpg?sz=64)
Your Answer
Reminder: Answers generated by artificial intelligence tools are not allowed on Stack Overflow. Learn more
Sign up or log in
Post as a guest.
Required, but never shown
By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy .
Not the answer you're looking for? Browse other questions tagged c# syntax or ask your own question .
- The Overflow Blog
- At scale, anything that could fail definitely will
- Featured on Meta
- Announcing a change to the data-dump process
- Bringing clarity to status tag usage on meta sites
- What does a new user need in a homepage experience on Stack Overflow?
- Feedback requested: How do you use tag hover descriptions for curating and do...
- Staging Ground Reviewer Motivation
Hot Network Questions
- Why is a USB memory stick getting hotter when connected to USB-3 (compared to USB-2)?
- Nearly stalled on takeoff after just 3 hours training on a PPL. Is this normal?
- Proof of the principle of explosion
- Sum of reciprocals of rough numbers
- World Building Knowledgebase - How to write good Military World Building
- Expensive constructors. Should they exist? Should they be replaced?
- Avoiding USA "gambling tax"
- Not a cross, not a word (number crossword)
- Admissibility of withdrawn confession
- Invest smaller lump sum vs investing (larger) monthly amount
- How do Trinitarian Christians defend the unfalsifiability of the Trinity?
- Could an empire rise by economic power?
- How to find the x-coordinate of the point circled(non-differentiable points) in this trigonometric function graph?
- What is Zion's depth in the Matrix?
- quantulum abest, quo minus . .
- How to resolve hostname by mDNS?
- Using rule-based symbology for overlapping layers in QGIS
- How would you slow the speed of a rogue solar system?
- Is it possible to travel to USA with legal cannabis?
- Difference between 失敬する and 盗む
- Can it be acceptable to take over CTRL + F shortcut in web app
- 5 deep Apex soql: System.QueryException: SOQL statements cannot query aggregate relationships more than 1 level away from the root entity object
- figuring out the speed controller of a cassette tape motor
- In Lord Rosse's 1845 drawing of M51, was the galaxy depicted in white or black?
![what is a assignment statement what is a assignment statement](https://www.theknowledgeacademy.com/_public/images/home/halloween.png)
- Onsite training
3,000,000+ delegates
15,000+ clients
1,000+ locations
- KnowledgePass
- Log a ticket
01344203999 Available 24/7
![what is a assignment statement what is a assignment statement](https://www.theknowledgeacademy.com/_public/images/home/trust-stars.png)
Operators in C Programming: A Complete Overview
Curious about Operators in C Programming? Operators in C are symbols that perform operations on variables and values, such as addition, subtraction, and comparison. This blog will delve into various operators, including arithmetic, logical, and bitwise, explaining their functions and how they are used in C programming.
![what is a assignment statement stars](https://www.theknowledgeacademy.com/_public/images/blog/stars.png)
Exclusive 40% OFF
Training Outcomes Within Your Budget!
We ensure quality, budget-alignment, and timely delivery by our expert instructors.
Share this Resource
- Introduction of Embedded C Programming
- C# and .NET Training
- C# Engineer Training
- C++ Programming (C Plus Plus)
![what is a assignment statement course](https://www.theknowledgeacademy.com/_public/images/blog/course.png)
Are you struggling to master the foundational concepts of programming? Understanding operators in C programming is crucial for anyone looking to write efficient and powerful code. These operators are the building blocks that enable you to perform calculations, manipulate data, and make decisions within your programs.
In this blog, we'll delve into the various types of operators in C programming, from arithmetic to logical, and explore how they work together to bring your code to life. By mastering these operators, you'll gain the confidence to tackle more complex programming challenges, making your code both cleaner and more effective. Stay with us as we guide you through the essentials of operators in C programming, helping you unlock the true potential of your coding skills.
Table of Contents
1) What is a C Operator?
2) Types of Operators in C
a) Arithmetic Operations in C
b) Relational Operators in C
c) Logical Operator in C
d) Bitwise Operators in C
e) Assignment Operators in C
f) Increment and Decrement Operators
g) sizeof Operator
h) Other Operators
3) Conclusion
What is a C Operator?
In C Programming, an operator is a symbol that instructs the compiler to perform specific mathematical, relational, or logical operations on variables and values to produce a result. Operators are fundamental in manipulating data and are used extensively in expressions to perform calculations, comparisons, and logical evaluations.
They enable programmers to write concise and efficient code by simplifying complex operations into manageable components. From simple arithmetic operations like addition and subtraction to more complex tasks like bitwise manipulations and logical decision-making, operators in C are essential tools that facilitate a wide range of programming tasks and functionalities.
![what is a assignment statement C Programming Course](https://www.theknowledgeacademy.com/_files/images/C_Programming_Course%C2%A0%283%29.png)
Types of Operators in C
C Operators are categorised based on the type of operation they perform. These categories include arithmetic, relational, logical, sbitwise, assignment, increment and decrement, size of, and other miscellaneous operators. Each category has specific functions and uses in programming. Understanding these operators in conjunction with the various Data Types in C allows programmers to effectively manipulate and process data.
1) Arithmetic Operations in C
Arithmetic operators perform basic mathematical operations such as addition, subtraction, multiplication, division, and modulus.
Operators and Their Functions:
a) + (Addition): Adds two operands.
b) - (Subtraction): Subtracts the second operand from the first.
c) * (Multiplication): Multiplies two operands.
d) / (Division): Divides the numerator by the denominator.
e) % (Modulus): Returns the remainder of a division operation.
Example:
#include int main() { int a = 10, b = 5; printf("Addition: %dn", a + b); // 15 printf("Subtraction: %dn", a - b); // 5 printf("Multiplication: %dn", a * b); // 50 printf("Division: %dn", a / b); // 2 printf("Modulus: %dn", a % b); // 0 return 0; } |
Boost your programming skills—join our C Programming Trainings today and become an expert coder!
2) Relational Operators in C
Relational operators compare two values or variables. They return a boolean result (true or false).
a) == (Equal to): Checks if two operands are equal.
b) != (Not equal to): Checks if two operands are not equal.
c) > (Greater than): Checks if the left operand is greater than the right.
d) < (Less than): Checks if the left operand is less than the right.
e) >= (Greater than or equal to): Checks if the left operand is greater than or equal to the right.
f) <= (Less than or equal to): Checks if the left operand is less than or equal to the right.
#include int main() { int a = 10, b = 5; printf("a == b: %dn", a == b); // 0 (false) printf("a != b: %dn", a != b); // 1 (true) printf("a > b: %dn", a > b); // 1 (true) printf("a printf("a } |
3) Logical Operators in C
Logical operators are used to combine multiple relational expressions.
a) && (Logical AND): Returns true if both operands are true.
b) || (Logical OR): Returns true if at least one operand is true.
c) ! (Logical NOT): Returns true if the operand is false.
#include int main() { int a = 1, b = 0; printf("a && b: %dn", a && b); // 0 (false) printf("a || b: %dn", a || b); // 1 (true) printf("!a: %dn", !a); // 0 (false) return 0; } |
Master the fundamentals of coding—Join our C Programming Course today!
4) Bitwise Operators in C
Bitwise operators perform operations on binary representations of integers.
a) & (AND): Performs bitwise AND.
b) | (OR): Performs bitwise OR.
c) ^ (XOR): Performs bitwise XOR.
d) ~ (NOT): Performs bitwise NOT.
e) << (Left Shift): Shifts bits to the left.
f) >> (Right Shift): Shifts bits to the right.
#include int main() { int a = 5, b = 3; printf("a & b: %dn", a & b); // 1 printf("a | b: %dn", a | b); // 7 printf("a ^ b: %dn", a ^ b); // 6 printf("~a: %dn", ~a); // -6 printf("a return 0; } |
5) Assignment Operators in C
Assignment operators assign values to variables.
a) =: Simple assignment.
b) +=: Adds and assigns.
c) -=: Subtracts and assigns.
d) *=: Multiplies and assigns.
e) /=: Divides and assigns.
f) %=: Takes modulus and assigns.
#include int main() { int a = 10; a += 5; // a = a + 5 printf("a += 5: %dn", a); // 15 a -= 3; // a = a - 3 printf("a -= 3: %dn", a); // 12 a *= 2; // a = a * 2 printf("a *= 2: %dn", a); // 24 a /= 4; // a = a / 4 printf("a /= 4: %dn", a); // 6 a %= 3; // a = a % 3 printf("a %%= 3: %dn", a); // 0 return 0; } |
6) Increment and Decrement Operators
Increment and decrement operators increase or decrease the value of a variable by one.
a) ++: Increment operator.
b) --: Decrement operator.
#include int main() { int a = 10; a++; printf("a++: %dn", a); // 11 a--; printf("a--: %dn", a); // 10 return 0; } |
Take your coding skills to the next level—Register for our C++ Programming Course today!
7) sizeof Operator
The sizeof operator returns the size of a variable or data type in bytes.
#include int main() { int a; float b; double c; char d; printf("Size of int: %lun", sizeof(a)); // Typically 4 bytes printf("Size of float: %lun", sizeof(b)); // Typically 4 bytes printf("Size of double: %lun", sizeof(c)); // Typically 8 bytes printf("Size of char: %lun", sizeof(d)); // Typically 1 byte return 0; } |
8) Other Operators
Other miscellaneous operators include the comma operator, the conditional operator (ternary), and the cast operator.
a) , (Comma): Separates expressions.
b) ?: (Ternary): A shorthand for the if-else statement.
c) (type) (Cast): Converts a variable from one type to another.
Example :
#include int main() { int a = 10, b = 20, c; c = (a > b) ? a : b; printf("Ternary operator: %dn", c); // 20 float d = 3.14; int e; e = (int)d; printf("Cast operator: %dn", e); // 3 return 0; } |
Conclusion
Understanding and effectively using operators in C programming is crucial for writing efficient and effective code. By mastering these operators, you can perform a wide range of operations, from simple arithmetic to complex bitwise manipulations, enhancing your programming capabilities.
Transform your career—Join our C# and .NET Training today and master the skills needed to build robust applications!
Frequently Asked Questions
Operators in C are symbols that instruct the compiler to perform specific mathematical, relational, or logical operations on variables and values. They enable manipulation of data, facilitating various operations such as arithmetic calculations, comparisons, and logical evaluations, which are essential for writing functional C programs.
The '=' operator is an assignment operator that assigns the value on its right to the variable on its left. The '==' operator is a relational operator used to compare two values, returning true if they are equal and false if they are not.
Logic operators in C include && (logical AND), || (logical OR), and ! (logical NOT). These operators are used to combine or invert logical expressions, enabling decision-making processes within the program based on multiple conditions.
The Knowledge Academy takes global learning to new heights, offering over 30,000 online courses across 490+ locations in 220 countries. This expansive reach ensures accessibility and convenience for learners worldwide.
Alongside our diverse Online Course Catalogue, encompassing 17 major categories, we go the extra mile by providing a plethora of free educational Online Resources like News updates, Blogs , videos, webinars, and interview questions. Tailoring learning experiences further, professionals can maximise value with customisable Course Bundles of TKA .
The Knowledge Academy’s Knowledge Pass , a prepaid voucher, adds another layer of flexibility, allowing course bookings over a 12-month period. Join us on a journey where education knows no bounds.
The Knowledge Academy offers various C Programming Courses , including the E C# Programming Course, C Programming Course and the C++ Programming Training. These courses cater to different skill levels, providing comprehensive insights into C vs Java .
Our Programming and DevOps Blogs cover a range of topics related to C Programming, offering valuable resources, best practices, and industry insights. Whether you are a beginner or looking to advance your Programming skills, The Knowledge Academy's diverse courses and informative blogs have got you covered.
Upcoming Programming & DevOps Resources Batches & Dates
Thu 19th Sep 2024
Thu 19th Dec 2024
Get A Quote
WHO WILL BE FUNDING THE COURSE?
My employer
By submitting your details you agree to be contacted in order to respond to your enquiry
- Business Analysis
- Lean Six Sigma Certification
Share this course
Our biggest summer sale.
![what is a assignment statement red-star](https://www.theknowledgeacademy.com/_public/images/home/red-star.png)
We cannot process your enquiry without contacting you, please tick to confirm your consent to us for contacting you about your enquiry.
By submitting your details you agree to be contacted in order to respond to your enquiry.
We may not have the course you’re looking for. If you enquire or give us a call on 01344203999 and speak to our training experts, we may still be able to help with your training requirements.
Or select from our popular topics
- ITIL® Certification
- Scrum Certification
- ISO 9001 Certification
- Change Management Certification
- Microsoft Azure Certification
- Microsoft Excel Courses
- Explore more courses
Press esc to close
Fill out your contact details below and our training experts will be in touch.
Fill out your contact details below
Thank you for your enquiry!
One of our training experts will be in touch shortly to go over your training requirements.
Back to Course Information
Fill out your contact details below so we can get in touch with you regarding your training requirements.
* WHO WILL BE FUNDING THE COURSE?
Preferred Contact Method
No preference
Back to course information
Fill out your training details below
Fill out your training details below so we have a better idea of what your training requirements are.
HOW MANY DELEGATES NEED TRAINING?
HOW DO YOU WANT THE COURSE DELIVERED?
Online Instructor-led
Online Self-paced
WHEN WOULD YOU LIKE TO TAKE THIS COURSE?
Next 2 - 4 months
WHAT IS YOUR REASON FOR ENQUIRING?
Looking for some information
Looking for a discount
I want to book but have questions
One of our training experts will be in touch shortly to go overy your training requirements.
Your privacy & cookies!
Like many websites we use cookies. We care about your data and experience, so to give you the best possible experience using our site, we store a very limited amount of your data. Continuing to use this site or clicking “Accept & close” means that you agree to our use of cookies. Learn more about our privacy policy and cookie policy cookie policy .
We use cookies that are essential for our site to work. Please visit our cookie policy for more information. To accept all cookies click 'Accept & close'.
Cash Flow Statement: Definition, Importance, And Examples
In the realm of business finance, a cash flow statement is not just another document—it is a crucial tool that provides insights into the financial health of a company. At Payro Finance, we emphasize the importance of understanding such financial tools, empowering businesses to manage their finances effectively. When used correctly, it can offer a clear view of a company’s liquidity, financial flexibility, and overall financial performance. In this article, we will explore the significance of the cash flow statement, its role in assessing financial health, and provide illustrative examples to clarify its practical application in business analysis.
What is a Cash Flow Statement?
The cash flow statement stands as one of the three fundamental financial statements essential for evaluating a company’s financial health. Alongside the income statement, which details revenue and expenses over a period, and the balance sheet, which provides a snapshot of assets, liabilities, and equity at a specific point in time, the cash flow statement offers a holistic view of a company’s financial operations. It tracks how cash and cash equivalents change due to operational, investment, and financing activities, revealing crucial insights into liquidity, solvency, and overall financial performance.
- Operating Activities
Operating activities represent the heartbeat of a company’s cash flow, converting accrual-based income statement figures into actual cash flows. This section meticulously tracks cash receipts from customers for goods sold or services rendered and cash payments for various expenses like raw materials, wages, taxes, and interest.
By aligning cash inflows and outflows with core business operations, stakeholders gain deep insights into the company’s ability to generate cash from its primary activities, highlighting operational efficiency and the sustainability of cash flow.
- Investing Activities
Investing activities encompass transactions involving assets and investment securities, providing a window into a company’s capital expenditures and strategic investments. Cash flows from purchasing or selling property, equipment, or marketable securities are recorded here, shedding light on the company’s commitment to acquiring income-generating assets and expanding its operational capacity.
Investors use this section to assess management’s allocation of capital, evaluate long-term investment strategies, and anticipate future revenue streams based on the company’s capital expenditure decisions.
- Financing Activities
Financing activities detail cash flows related to a company’s financing structure and capital management. This section captures transactions such as issuing or repurchasing equity shares, borrowing or repaying debt, and distributing dividends.
It offers critical insights into how the company raises capital to fund its operations and growth initiatives, demonstrating its financial health, risk management practices, and shareholder value distribution strategies. By analyzing financing activities, stakeholders can gauge the company’s reliance on internal funds versus external financing sources and evaluate its ability to sustainably manage financial obligations while pursuing growth opportunities.
Importance of a Cash Flow Statement
Understanding the cash flow statement is crucial for managing day-to-day operations, making strategic planning decisions, and ensuring long-term financial stability. Here is why:
- Transparency in Financial Health
Transparency in financial health provides stakeholders with a comprehensive understanding of a company’s liquidity and financial stability. It offers clarity on the cash available to meet immediate obligations, crucial for ensuring operational continuity.
Regular analysis of cash flow patterns not only helps anticipate potential liquidity challenges but also allows stakeholders to assess the company’s overall financial robustness. This transparency enables proactive measures to maintain stability and implement corrective actions if needed, ensuring sustained operational efficiency and resilience in the face of economic uncertainties.
- Informed Decision-Making
Detailed insights derived from a cash flow statement empower business leaders to make informed strategic decisions. A consistent positive cash flow from operations instills confidence to pursue growth opportunities, while identifying negative trends prompts timely adjustments like cost management strategies or securing additional funding.
This proactive approach ensures prudent financial management, aligning operational capabilities with strategic goals for sustainable growth and profitability. By leveraging these insights, businesses enhance their ability to navigate market fluctuations and capitalize on emerging opportunities with confidence and foresight.
- Evaluating the Efficiency of Operations
Cash flow from operating activities serves as a critical indicator of operational efficiency. It reflects how effectively a company converts sales into cash, demonstrating operational competence beyond mere profitability figures. This metric provides stakeholders with tangible evidence of the company’s financial health and operational prowess, validating its ability to manage cash flow effectively and sustain long-term growth.
By focusing on cash generation capabilities, businesses can optimize operational efficiencies and enhance overall financial performance, ensuring resilience and competitiveness in the marketplace.
- Planning and Forecasting
Effective cash management is essential for strategic planning and operational resilience. Forecasting future cash flows through a detailed cash flow statement enables businesses to anticipate financial needs, allocate resources efficiently, and make informed decisions.
This proactive approach guides daily budgeting, facilitates strategic investments, and prepares businesses to navigate economic uncertainties with agility. By aligning financial strategies with market conditions and growth objectives, companies foster sustainable expansion and profitability, maintaining a robust financial position over the long term.
- Maintaining an Optimal Cash Balance
Regular scrutiny of cash flow statements enables companies to uphold an optimal cash balance. Understanding cash flow patterns helps mitigate risks associated with excessive idle cash or inadequate reserves, optimizing financial resources for operational needs and strategic initiatives. This proactive approach safeguards against financial instability, ensuring businesses maintain resilience and agility in a dynamic economic environment.
The Impact of Cash Flow on Business Decisions
The information gleaned from a cash flow statement is invaluable for strategic planning and operational adjustments. Here are a few ways how:
- Strategic Investments and Cost Management
A deep understanding of the cash flow statement empowers businesses to strategically allocate resources. By identifying trends, such as consistent negative cash flow from investments, companies can reassess their investment strategies or postpone capital expenditures as needed. This informed approach allows for prudent investment in areas with high potential returns while optimizing cost management efforts to enhance overall profitability and financial health.
- Managing Debt and Equity
Analysis of the financing section in a cash flow statement guides decisions on debt management and equity utilization. Companies can determine whether to seek additional financing to fuel growth initiatives or prioritize debt repayment to strengthen financial stability. Maintaining a balanced leverage-to-equity ratio is crucial to avoid over-leveraging and unnecessary equity dilution, ensuring sustainable financial health and investor confidence in the company’s long-term viability.
- Forecasting and Future Planning
Regular examination of cash flow patterns enables businesses to forecast future financial conditions with greater accuracy. This proactive approach includes building cash reserves during periods of strong cash flow to buffer against future downturns or planning strategic expansions during favorable economic conditions.
Forecasting based on historical cash flow data supports informed decision-making in daily operations and long-term strategic planning, fostering resilience and agility in responding to market dynamics and opportunities.
Real-world Examples
- Retail Industry
In the retail sector, a cash flow statement might show positive cash flows from operating activities due to cash receipts from customers for merchandise sold. Operating cash outflows may include payments to suppliers for inventory. Investing activities could include cash outflows for store renovations or new equipment. Financing activities might show cash inflows from issuing new shares or taking on debt to expand operations.
- Technology Industry
In the technology sector, operational cash inflows often stem from sales of software licenses or subscriptions. Outflows typically encompass expenditures on research and development, as well as salaries for software engineers. Investments might entail spending on acquiring new technology or intellectual property rights. Financing activities could include receiving cash inflows from venture capital investments or issuing bonds to support the company’s growth initiatives.
- Construction Industry
In the construction industry , operating cash inflows may come from progress payments from clients for completed projects. Cash outflows could include payments to subcontractors and suppliers for materials and labor. Investing activities might include cash outflows for purchasing heavy equipment or acquiring land for new projects. Financing activities could involve cash inflows from bank loans or issuing bonds to finance large-scale construction projects.
- Healthcare Industry
Within healthcare, cash inflows typically derive from payments by insurance companies and patients for rendered medical services. Cash outflows encompass expenses such as medical supplies, salaries for healthcare professionals, and administrative costs. Investments may involve expenditures on medical equipment or technological enhancements aimed at improving patient care. Financing activities could encompass raising funds through bonds or loans to facilitate expansions of hospital facilities or acquisitions of medical practices.
- Manufacturing Industry
For a manufacturing company, operating cash inflows may come from sales of finished goods to distributors or wholesalers. Cash outflows could include payments for raw materials, factory overhead costs, and wages for production workers. Investing activities can include cash outflows for purchasing new manufacturing equipment or upgrading production facilities. Financing activities could include cash inflows from issuing preferred stock or obtaining loans to finance production expansion or new product development.
- Restaurant & Food Industry
In the restaurant industry , the cash flow statement might reflect cash inflows from operating activities such as sales revenue from meals served to customers. Operating cash outflows could include payments for ingredients, staff wages, and rent for the restaurant space.
Investing activities might show cash outflows for purchasing kitchen equipment or renovating the dining area. Financing activities could include cash inflows from investors or loans obtained to expand the restaurant chain or open new locations.
- Healthcare Sector
For a healthcare organization , operating cash inflows may come from payments received from insurance companies, Medicare, and Medicaid for medical services rendered. Cash outflows could include payments for medical supplies, pharmaceuticals, salaries for healthcare professionals, and administrative expenses.
Investing activities might involve cash outflows for purchasing medical equipment, upgrading electronic health record systems, or expanding clinic facilities. Financing activities could include cash inflows from issuing bonds or obtaining loans to fund hospital expansions, medical research initiatives, or mergers and acquisitions of medical practices.
Embracing the Cash Flow Statement as a Strategic Tool
The cash flow statement is much more than a financial document—it is a strategic asset that can guide a company through the complexities of financial management and strategic planning. By mastering the art of cash flow analysis, businesses can not only safeguard their financial stability but also seize opportunities for growth and expansion with confidence.
Business leaders and financial managers are encouraged to delve deeper into understanding and utilizing their cash flow statements, as doing so will undoubtedly equip them with the knowledge and skills needed to steer their companies toward a successful future.
Partnering with Payro Finance equips businesses with essential tools to streamline employee payroll management. By leveraging our expertise and accessing tailored lines of credit, businesses can effectively navigate their financial obligations.
Payro Finance ensures businesses have the necessary resources to manage payroll efficiently, enhancing financial stability and operational efficiency. Understanding how Payro Finance works enables businesses to make informed decisions, ensuring they maintain optimal cash flow and meet payroll obligations seamlessly. This partnership empowers businesses to focus on growth and strategic initiatives while ensuring employees are paid promptly and accurately.
Related articles
![what is a assignment statement what is a assignment statement](https://payrofinance.com/wp-content/uploads/2024/06/Image-2-3-1.jpg)
Need a short term loan to cover payroll?
Need a short-term loan to cover payroll.
Apply in under two minutes, and get approved within 2 days. Once approved, funds are in your account the same day.
- Always 1.5% weekly
- Up to $500,000
- Same-day funding
Related reads
![what is a assignment statement Medical staffing](https://payrofinance.com/wp-content/uploads/2024/06/Image-2-3-1.jpg)
Partner with Payro
Complete the form below and a representative from Payro will reach out
![](http://mangareview.fun/777/templates/cheerup/res/banner1.gif)
COMMENTS
Assignment Statement. An Assignment statement is a statement that is used to set a value to the variable name in a program. Assignment statement allows a variable to hold different types of values during its program lifespan. Another way of understanding an assignment statement is, it stores a value in the memory location which is denoted.
Assignment (computer science) In computer programming, an assignment statement sets and/or re-sets the value stored in the storage location (s) denoted by a variable name; in other words, it copies a value into the variable. In most imperative programming languages, the assignment statement (or expression) is a fundamental construct.
Multiple- target assignment: x = y = 75. print(x, y) In this form, Python assigns a reference to the same object (the object which is rightmost) to all the target on the left. OUTPUT. 75 75. 7. Augmented assignment : The augmented assignment is a shorthand assignment that combines an expression and an assignment.
Assignment Statements ¶. Assignment statements initialize or change the value stored in a variable using the assignment operator =. An assignment statement always has a single variable on the left hand side. The value of the expression (which can contain math operators and other variables) on the right of the = sign is stored in the variable ...
Assignment statements initialize or change the value stored in a variable using the assignment operator =. An assignment statement always has a single variable on the left hand side of the = sign. The value of the expression on the right hand side of the = sign (which can contain math operators and other variables) is copied into the memory ...
An assignment statement sets and/or re-sets the value stored in the storage location(s) denoted by a variable name; in other words, it copies a value into the variable. [1] Discussion. The assignment operator allows us to change the value of a modifiable data object (for beginning programmers this typically means a variable). It is associated ...
Python's assignment operators allow you to define assignment statements. This type of statement lets you create, initialize, and update variables throughout your code. Variables are a fundamental cornerstone in every piece of code, and assignment statements give you complete control over variable creation and mutation.
The meaning of the first assignment is computing the sum of the value in Counter and 1, and saves it back to Counter. Since Counter 's current value is zero, Counter + 1 is 1+0 = 1 and hence 1 is saved into Counter. Therefore, the new value of Counter becomes 1 and its original value 0 disappears. The second assignment statement computes the ...
An assignment statement changes the value that is held in a variable. The program uses an assignment statement. The assignment statement puts the value 123 into the variable. In other words, while the program is executing there will be a 64 bit section of memory that holds the value 123.
Declaration: int a; Assignment: a = 3; Declaration and assignment in one statement: int a = 3; Declaration says, "I'm going to use a variable named "a" to store an integer value."Assignment says, "Put the value 3 into the variable a." (As @delnan points out, my last example is technically initialization, since you're specifying what value the variable starts with, rather than changing the value.
An assignment statement designates a value for a variable. An assignment statement can be used as an expression in Java. After a variable is declared, you can assign a value to it by using an assignment statement. In Java, the equal sign = is used as the assignment operator. The syntax for assignment statements is as follows: variable ...
The Assignment Statement The "= " symbol indicates assignment. The assignment statement r = 10 creates the variable r and assigns to it the value of 10. >>> r = 10 r -> 10 Formal: " r is assigned the value of 10" Informal: "r gets 10"
Assignment. Assignment in Java is the process of giving a value to a primitive-type variable or giving an object reference to an object-type variable. The equals sign acts as assignment operator in Java, followed by the value to assign. The following sample Java code demonstrates assigning a value to a primitive-type integer variable, which has ...
A simple assignment statement consists of a variable name, an equal sign (assignment operator) and the value to be stored. >>> a = 7 # -> Assignment statement a in the above expression is assigned the value 7. >>> a = a + 2 >>> a 9 Here we see that the variable a has 2 added to it's previous value. The resulting number is 9, the addition of 7 ...
Assignment means: "storing a value (of a particular type) under a variable name". Think of each assignment as copying the value of the righthand side of the expression into a "bucket" associated with the left hand side name! Read this as, the variable called "name" is "assigned" the value computed by the expression to the right of the ...
Resource: Variables, Declarations & Assignment Statements Three interrelated programming concepts are variables, declarations and assignment statements. Variables The concept of a variable is a powerful programming idea. It's called a variable because - now pay attention - it varies. When you see it used in a program, the variable is often
Annotated assignment statements¶ Annotation assignment is the combination, in a single statement, of a variable or attribute annotation and an optional assignment statement: annotated_assignment_stmt::= augtarget ":" expression ["=" (starred_expression | yield_expression)] The difference from normal Assignment statements is that only a single ...
An assignment statement creates a new variable and gives it a value: This example makes three assignments. The first assigns a string to a new variable named message; the second gives the integer 17 to n; the third assigns the (approximate) value of π π to pi. A common way to represent variables on paper is to write the name with an arrow ...
ASSIGNMENT STATEMENTS Expressions can be part of a condition statement ((num+num2/5)>num3) or part of an output statement (cout num + num2). But the most common use of expressions is to be the right hand side of an assignment statement. BNF syntax for an assignment statement: <target_var> <assign_operator> <expression>
Assignment statement in python is the statement used to assign the value to the specified variable. The value assigned to the variable can be of any data type supported by python programming language such as integer, string, float Boolean, list, tuple, dictionary, set etc.
First off, assignment statements do not produce a value. Assignment expressions produce a value. An assignment expression is a legal statement; there are only a handful of expressions which are legal statements in C#: awaits of an expression, instance construction, increment, decrement, invocation and assignment expressions may be used where a ...
e) Assignment Operators in C . f) Increment and Decrement Operators . g) sizeof Operator . h) Other Operators . 3) Conclusion . What is a C Operator? In C Programming, an operator is a symbol that instructs the compiler to perform specific mathematical, relational, or logical operations on variables and values to produce a result.
The cash flow statement stands as one of the three fundamental financial statements essential for evaluating a company's financial health. Alongside the income statement, which details revenue and expenses over a period, and the balance sheet, which provides a snapshot of assets, liabilities, and equity at a specific point in time, the cash ...
President of Mongolia Ukhnaagiin Khurelsukh Khurelsukh Ukhnaagiin President of Mongolia (retranslated): Mr President, . Ladies and gentlemen, First of all, I would like to thank President Vladimir Putin for his official visit to our country to attend the celebrations of the 85 th anniversary of our shared victory in the battle on the river Khalkhin Gol, the 75 th anniversary of the ...