python multiple assignment from function

• Learn Python
• Python Lists
• Python Dictionaries
• Python Strings
• Python Functions
• Learn Pandas & NumPy
• Pandas Tutorials
• Numpy Tutorials
• Learn Data Visualization
• Python Seaborn
• Python Matplotlib

Python: Return Multiple Values from a Function

• October 29, 2021 December 19, 2022

In this tutorial, you’ll learn how to use Python to return multiple values from your functions . This is a task that is often quite difficult in some other languages, but very easy to do in Python.

You’ll learn how to use tuples, implicitly or explicitly, lists, and dictionaries to return multiple values from a function. You’ll also learn how to identify which method is best suited for your use case. You’ll also learn how to unpack items of unequal length, using the unpacking operator ( * ).

Being able to work with functions is an incredibly useful skill that allows you to more readily follow the DRY (don’t repeat yourself) principle. Functions allow your code to be significantly more readable and less repetitive. All of this allows your code to be more maintainable and reduces complexity of the code.

The Quick Answer: Use Tuple Unpacking

Table of Contents

How do Functions Return Values in Python?

Python functions are easy ways to structure code into dynamic processes that are readable and reusable. While Python functions can accept inputs, in this tutorial, we’ll be looking at function outputs . Specifically, we’ll be look at how functions return values.

Let’s take a look at how a function in Python is designed and how to return one value and how to return two values.

In the example above, we have defined two different functions, return_one() and return_two() . The former of these returns only a single value. Meanwhile, the latter function, return_two() , returns two values. This is done by separating the values by commas.

In the next section, you’ll learn how and why returning multiple values actually works.

Want to learn more about calculating the square root in Python? Check out my tutorial here , which will teach you different ways of calculating the square root, both without Python functions and with the help of functions.

How to Return Multiple Values from a Python Function with Tuples

In the previous section, you learned how to configure a Python function to return more than a single value.

The way that this works, is that Python actually turns the values (separated by commas) into a tuple. We can see how this works by assigning the function to a variable and checking its type.

We can see in the code above that when we assign our function to a variable, that a tuple is generated.

This may surprise you, however, since you don’t actually tell the function to return (1, 2, 3) . Python implicitly handles converting the return values into a tuple. It’s not the parentheses that turn the return value into a tuple, but rather the comma along with the parentheses.

We can verify this by checking the type of the value (1), for example. This returns: int .

Again, this might surprise you. If we changed our value to (1,) , however, we return a different result.

A lot of this may seem like semantics, but it allows you to understand why these things actually work. Now, let’s learn how to assign these multiple variables to different variables.

Let’s look at the same function as before. Instead of assigning the return values to a single tuple, let’s unpack our tuple and return three separate values .

The reason this works is that Python is handling unpacking these values for us. Because we have the same number of assignment variables as we do values in the return statement, Python handles the assignment of these values for us.

In the next section, you’ll learn how to unpack multiple values from a Python to variables with mismatched lengths.

Want to learn more about Python for-loops? Check out my in-depth tutorial that takes your from beginner to advanced for-loops user! Want to watch a video instead? Check out my YouTube tutorial here .

How to Unpack Multiple Values from a Python Function to Unequal Lengths

In the example above, you learned how to return multiple values from a Python function by unpacking values from the return tuple.

There may be many times when your function returns multiple values, but you only care about a few. You don’t really care about the other values, but Python will not let you return only a few of them.

Let’s see what this looks like:

This happens because our assignment needs to match the number of items returned.

However, Python also comes with an unpacking operator , which is denoted by * . Say that we only cared about the first item returned. We still need to assign the remaining values to another variable, but we can easily group them into a single variable, using the unpacking operator.

Let’s see how this works in Python:

Here, we have unpacked the first value to our variable a , and all other variables to the variable b , using the notation of *b .

In the next section, you’ll learn how to return multiple values from a Python function using lists.

Want to learn how to use the Python zip() function to iterate over two lists? This tutorial teaches you exactly what the zip() function does and shows you some creative ways to use the function.

How to Return Multiple Values from a Python Function with Lists

Similar to returning multiple values using tuples, as shown in the previous examples, we can return multiple values from a Python function using lists.

One of the big differences between Python sets and lists is that lists are mutable in Python , meaning that they can be changed. If this is an important characteristic of the values you return, then this is a good way to go.

Let’s see how we can return multiple values from a function, using both assignment to a single variable and to multiple variables.

In the next section, you’ll learn how to use Python dictionaries to better understand return values.

Want to learn more about Python list comprehensions? Check out this in-depth tutorial that covers off everything you need to know, with hands-on examples. More of a visual learner, check out my YouTube tutorial here .

How to Return Multiple Values from a Python Function with Dictionaries

In both examples above, if you’re returning all values to a single variable, it can be difficult to determine what each value represents. For example, while you can access all the items in a tuple or in a list using indexing, it can be difficult to determine what each value represents.

Let’s take a look at a more complicated function that creates variables for speed , time , and distance travelled for a car.

If we returned this as a tuple or as a list, then we would need to know which variable represents what item. However, we can also return these items as a dictionary. When we do this, we can access each item by its key .

Let’s see how we can do this in Python:

Need to check if a key exists in a Python dictionary? Check out this tutorial , which teaches you five different ways of seeing if a key exists in a Python dictionary, including how to return a default value.

In this tutorial, you learned how to return multiple values from Python functions. You learned how and why multiple values can be returned and how to optimize how values are returned for your use cases, by learning how to return tuples, lists, and dictionaries. You also learned how to unpack multiple values to variables of different lengths.

To learn more about Python functions, check out the official documentation here .

Nik Piepenbreier

Nik is the author of datagy.io and has over a decade of experience working with data analytics, data science, and Python. He specializes in teaching developers how to use Python for data science using hands-on tutorials. View Author posts

1 thought on “Python: Return Multiple Values from a Function”

Pingback:  Functions in Python • datagy

Leave a Reply Cancel reply

Your email address will not be published. Required fields are marked *

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

note.nkmk.me

Multiple assignment in python: assign multiple values or the same value to multiple variables.

In Python, the = operator is used to assign values to variables.

You can assign values to multiple variables in one line.

Assign multiple values to multiple variables

Assign the same value to multiple variables.

You can assign multiple values to multiple variables by separating them with commas , .

You can assign values to more than three variables, and it is also possible to assign values of different data types to those variables.

When only one variable is on the left side, values on the right side are assigned as a tuple to that variable.

If the number of variables on the left does not match the number of values on the right, a ValueError occurs. You can assign the remaining values as a list by prefixing the variable name with * .

For more information on using * and assigning elements of a tuple and list to multiple variables, see the following article.

• Unpack a tuple and list in Python

You can also swap the values of multiple variables in the same way. See the following article for details:

• Swap values ​​in a list or values of variables in Python

You can assign the same value to multiple variables by using = consecutively.

For example, this is useful when initializing multiple variables with the same value.

After assigning the same value, you can assign a different value to one of these variables. As described later, be cautious when assigning mutable objects such as list and dict .

You can apply the same method when assigning the same value to three or more variables.

Be careful when assigning mutable objects such as list and dict .

If you use = consecutively, the same object is assigned to all variables. Therefore, if you change the value of an element or add a new element in one variable, the changes will be reflected in the others as well.

If you want to handle mutable objects separately, you need to assign them individually.

after c = []; d = [] , c and d are guaranteed to refer to two different, unique, newly created empty lists. (Note that c = d = [] assigns the same object to both c and d .) 3. Data model — Python 3.11.3 documentation

You can also use copy() or deepcopy() from the copy module to make shallow and deep copies. See the following article.

• Shallow and deep copy in Python: copy(), deepcopy()

Related Categories

Related articles.

• Move a file/directory in Python (shutil.move)
• pandas: How to fix SettingWithCopyWarning: A value is trying to be set on ...
• Extract specific key values from a list of dictionaries in Python
• pandas: Interpolate NaN (missing values) with interpolate()
• Draw circle, rectangle, line, etc. with Python, Pillow
• Convert pandas.DataFrame, Series and numpy.ndarray to each other
• Flatten a NumPy array with ravel() and flatten()
• Get calendar as text, HTML, list in Python
• Create transparent png image with Python, Pillow (putalpha)
• NumPy: Add elements, rows, and columns to an array with np.append()
• Reading and saving image files with Python, OpenCV (imread, imwrite)
• Python if statements (if, elif, else)
• pandas: Get/Set values with loc, iloc, at, iat
• pandas: Remove NaN (missing values) with dropna()
• Check Python version on command line and in script

Unpacking And Multiple Assignment in

About unpacking and multiple assignment.

Unpacking refers to the act of extracting the elements of a collection, such as a list , tuple , or dict , using iteration. Unpacked values can then be assigned to variables within the same statement. A very common example of this behavior is for item in list , where item takes on the value of each list element in turn throughout the iteration.

Multiple assignment is the ability to assign multiple variables to unpacked values within one statement. This allows for code to be more concise and readable, and is done by separating the variables to be assigned with a comma such as first, second, third = (1,2,3) or for index, item in enumerate(iterable) .

The special operators * and ** are often used in unpacking contexts. * can be used to combine multiple lists / tuples into one list / tuple by unpacking each into a new common list / tuple . ** can be used to combine multiple dictionaries into one dictionary by unpacking each into a new common dict .

When the * operator is used without a collection, it packs a number of values into a list . This is often used in multiple assignment to group all "leftover" elements that do not have individual assignments into a single variable.

It is common in Python to also exploit this unpacking/packing behavior when using or defining functions that take an arbitrary number of positional or keyword arguments. You will often see these "special" parameters defined as def some_function(*args, **kwargs) and the "special" arguments used as some_function(*some_tuple, **some_dict) .

*<variable_name> and **<variable_name> should not be confused with * and ** . While * and ** are used for multiplication and exponentiation respectively, *<variable_name> and **<variable_name> are used as packing and unpacking operators.

Multiple assignment

In multiple assignment, the number of variables on the left side of the assignment operator ( = ) must match the number of values on the right side. To separate the values, use a comma , :

If the multiple assignment gets an incorrect number of variables for the values given, a ValueError will be thrown:

Multiple assignment is not limited to one data type:

Multiple assignment can be used to swap elements in lists . This practice is pretty common in sorting algorithms . For example:

Since tuples are immutable, you can't swap elements in a tuple .

The examples below use lists but the same concepts apply to tuples .

In Python, it is possible to unpack the elements of list / tuple / dictionary into distinct variables. Since values appear within lists / tuples in a specific order, they are unpacked into variables in the same order:

If there are values that are not needed then you can use _ to flag them:

Deep unpacking

Unpacking and assigning values from a list / tuple inside of a list or tuple ( also known as nested lists/tuples ), works in the same way a shallow unpacking does, but often needs qualifiers to clarify the values context or position:

You can also deeply unpack just a portion of a nested list / tuple :

If the unpacking has variables with incorrect placement and/or an incorrect number of values, you will get a ValueError :

Unpacking a list/tuple with *

When unpacking a list / tuple you can use the * operator to capture the "leftover" values. This is clearer than slicing the list / tuple ( which in some situations is less readable ). For example, we can extract the first element and then assign the remaining values into a new list without the first element:

We can also extract the values at the beginning and end of the list while grouping all the values in the middle:

We can also use * in deep unpacking:

Unpacking a dictionary

Unpacking a dictionary is a bit different than unpacking a list / tuple . Iteration over dictionaries defaults to the keys . So when unpacking a dict , you can only unpack the keys and not the values :

If you want to unpack the values then you can use the values() method:

If both keys and values are needed, use the items() method. Using items() will generate tuples with key-value pairs. This is because of dict.items() generates an iterable with key-value tuples .

Packing is the ability to group multiple values into one list that is assigned to a variable. This is useful when you want to unpack values, make changes, and then pack the results back into a variable. It also makes it possible to perform merges on 2 or more lists / tuples / dicts .

Packing a list/tuple with *

Packing a list / tuple can be done using the * operator. This will pack all the values into a list / tuple .

Packing a dictionary with **

Packing a dictionary is done by using the ** operator. This will pack all key - value pairs from one dictionary into another dictionary, or combine two dictionaries together.

Usage of * and ** with functions

Packing with function parameters.

When you create a function that accepts an arbitrary number of arguments, you can use *args or **kwargs in the function definition. *args is used to pack an arbitrary number of positional (non-keyworded) arguments and **kwargs is used to pack an arbitrary number of keyword arguments.

Usage of *args :

Usage of **kwargs :

*args and **kwargs can also be used in combination with one another:

You can also write parameters before *args to allow for specific positional arguments. Individual keyword arguments then have to appear before **kwargs .

Arguments have to be structured like this:

def my_function(<positional_args>, *args, <key-word_args>, **kwargs)

If you don't follow this order then you will get an error.

Writing arguments in an incorrect order will result in an error:

Unpacking into function calls

You can use * to unpack a list / tuple of arguments into a function call. This is very useful for functions that don't accept an iterable :

Using * unpacking with the zip() function is another common use case. Since zip() takes multiple iterables and returns a list of tuples with the values from each iterable grouped:

Learn Unpacking And Multiple Assignment

Unlock 3 more exercises to practice unpacking and multiple assignment.

Multiple Function Arguments

Get started learning Python with DataCamp's free Intro to Python tutorial . Learn Data Science by completing interactive coding challenges and watching videos by expert instructors. Start Now !

Ready to take the test? Head onto LearnX and get your Python Certification!

Every function in Python receives a predefined number of arguments, if declared normally, like this:

It is possible to declare functions which receive a variable number of arguments, using the following syntax:

The "therest" variable is a list of variables, which receives all arguments which were given to the "foo" function after the first 3 arguments. So calling foo(1, 2, 3, 4, 5) will print out:

It is also possible to send functions arguments by keyword, so that the order of the argument does not matter, using the following syntax. The following code yields the following output: The sum is: 6 Result: 1

The "bar" function receives 3 arguments. If an additional "action" argument is received, and it instructs on summing up the numbers, then the sum is printed out. Alternatively, the function also knows it must return the first argument, if the value of the "number" parameter, passed into the function, is equal to "first".

Fill in the foo and bar functions so they can receive a variable amount of arguments (3 or more) The foo function must return the amount of extra arguments received. The bar must return True if the argument with the keyword magicnumber is worth 7, and False otherwise.

This site is generously supported by DataCamp . DataCamp offers online interactive Python Tutorials for Data Science. Join over a million other learners and get started learning Python for data science today!

Stack Exchange Network

Stack Exchange network consists of 183 Q&A communities including Stack Overflow , the largest, most trusted online community for developers to learn, share their knowledge, and build their careers.

Code Review Stack Exchange is a question and answer site for peer programmer code reviews. It only takes a minute to sign up.

Q&A for work

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

Improving multiple assignment using an iterator function

Often I need to perform multiple assignment from a sequence (e.g. from the result of a split() ) but with some semantics that, AFAIK, are not available in the language:

Assign N first elements and silently ignore the rest (like Perl's list assignment ).

Assign the remaning items to the last variable in the variable list:

If the sequence doesn't have enough values, set the variables to a default value ( None or any other, again similar to Perl ):

I have designed an iterator function to help me with this, but I'm concerned about my solution to this problem from the point of view of pythonic adherence:

Usefulness: Using an iterator for this kind of job is the right option, or there is something more appropriate? Or even worse: my need to do this kind of assignment in Python is not favoring other language features?

Clearness: The implementation is solid and clear enough? Or is there some other way to implement this that would be cleaner?

In other words, this solution is better discarded or can it be improved?

Usage examples:

• functional-programming

• 2 \$\begingroup\$ In Python 3, I think you can use : a, b, *c , where the c will swallow the rest of the list. \$\endgroup\$ –  holroy Nov 14, 2015 at 18:56
• \$\begingroup\$ @holroy And thus use a, b, *_ for the first form. You can't have default values out-of-the-box though. \$\endgroup\$ –  301_Moved_Permanently Nov 14, 2015 at 19:54

I'll look at each of your three examples individually.

Ignoring remaining values

In Python 2:

In Python 3 ( _ used by convention, double underscore, __ , is also appropriate):

When ignoring remaining values, using the built-in language features would be the most Pythonic approach. I think they're clear enough that they do not need to be re-invented.

Capture remaining values

In Python 3:

In Python 3, the * feature is again more Pythonic than your approach. In Python 2, that approach won't work if you're dealing with a non-indexable type.

Fill remaining values with None . Here is a somewhat similar question . That question and the Python 2 solution only work for lists.

Python 3.5 (this is not very clear in my opinion):

There isn't really a built-in language construct for this so this case might warrant re-inventing. However, this kind of None -filling seems rare and may not necessarily be clear to other Python programmers.

A review of your actual implementation

Don't use import * in Python. In Python we value our namespaces highly because namespaces allow us to see what variables came from what modules.

Do this instead:

You didn't use use_default in your code at all. It seems like you could use another islice instead of an enumerate to restructure your code like this:

Iterators are the right solution to this problem (assuming we've decided it's one that needs solving).

If we want to rewrite this to only handle case 3 (because we've already decided we can just use Python's built-in language features for case 1 and 2, we could rewrite like this:

Which would work like this:

Your Answer

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 that you have read and understand our privacy policy and code of conduct .

Not the answer you're looking for? Browse other questions tagged python python-3.x functional-programming iterator or ask your own question .

• The Overflow Blog
• Journey to the cloud part I: Migrating Stack Overflow Teams to Azure
• Featured on Meta
• Our Design Vision for Stack Overflow and the Stack Exchange network

Hot Network Questions

• How likely is it that the Voyager spacecrafts haven't yet been damaged by micrometeoroids?
• Proper way to combine same-frequency PCB antennas
• Why is there nearly no 1x road bikes?
• Is it possible that sunlight reflecting off a camera lens could cause sufficient glare to dazzle a driver?
• Confused about the notion of overfitting and noisy target function
• Question about number format for numbers between zero and one
• Is there any way I can recycle a device that has been iCloud locked?
• Partition a random sequence composed of three numbers
• Why can't I move my knight from d5 to c7?
• How to pass a statistics exam that overly relies on memorizing formulas?
• Meaning of "retiring" in "free admission with retiring donations"
• Why does the ECB hold a large foreign currency reserve?
• Intercepting a grappled Bite Swallow attack in place of an ally with Vigilant Guardian: What happens?
• Was the recent ruling against Jordan Peterson an infringement of his free speech?
• Why people buy high dividend stock?
• Why is the convolution of two sine waves a sinc function?
• What should the table do when using multicolumn multiple times?
• In how many ways can four distinctive letters be posted in 6 post boxes such that any two go in same post box and remaining go to different boxes?
• Does political lobbying exist in North Korea?
• reading device or board specific properties from the Arduino MKR WiFi 1010 device
• CAT: Cat Approved TUIs
• Rutherford's gold foil experiment thin sheets
• Why do people do a postdoc, rather than getting another PhD?
• Are multiple extension cords in series causing significant increase in electric use?

Your privacy

By clicking “Accept all cookies”, you agree Stack Exchange can store cookies on your device and disclose information in accordance with our Cookie Policy .

• Python »
• 3.11.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 expression 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.

For simple names as 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.

For expressions as assignment targets, the annotations are 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.

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, which is writable. 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 .

New in version 3.3: 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 ¶

The nonlocal statement causes the listed identifiers to refer to previously bound variables in the nearest enclosing scope excluding globals. This is important because the default behavior for binding is to search the local namespace first. The statement allows encapsulated code to rebind variables outside of the local scope besides the global (module) scope.

Names listed in a nonlocal statement, unlike those listed in a global statement, must refer to pre-existing bindings in an enclosing scope (the scope in which a new binding should be created cannot be determined unambiguously).

Names listed in a nonlocal statement must not collide with pre-existing bindings in the local scope.

The specification for the nonlocal statement.

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

Previous topic

6. Expressions

8. Compound statements

• Report a Bug
• Show Source

Python Return Multiple Values – How to Return a Tuple, List, or Dictionary

You can return multiple values from a function in Python.

To do so, return a data structure that contains multiple values, like a list containing the number of miles to run each week.

Data structures in Python are used to store collections of data, which can be returned from  functions. In this article, we’ll explore how to return multiple values from these data structures: tuples, lists, and dictionaries.

A tuple is an ordered, immutable sequence. That means, a tuple can’t change.

Use a tuple, for example, to store information about a person: their name, age, and location.

Here’s how you’d write a function that returns a tuple.

Notice that we didn’t use parentheses in the return statement. That’s because you can return a tuple by separating each item with a comma, as shown in the above example.

“It is actually the comma which makes a tuple, not the parentheses,” the documentation points out. However, parentheses are required with empty tuples or to avoid confusion.

Here’s an example of a function that uses parentheses () to return a tuple.

A list is an ordered, mutable sequence. That means, a list can change.

You can use a list to store cities:

Or test scores:

Take a look at the function below. It returns a list that contains ten numbers.

Here’s another example. This time we pass in several arguments when we call the function.

It’s easy to confuse tuples and lists. After all, both are containers that store objects. However, remember these key differences:

• Tuples can’t change.
• Lists can change.

Dictionaries

A dictionary contains key-value pairs wrapped in curly brackets {} . Each “key” has a related “value.”  

Consider the dictionary of employees below. Each employee name is a “key” and their position is the “value.”

Here’s how you’d write a function that returns a dictionary with a key, value pair.

In the above example, “Boston” is the key and “United States” is the value .  

We’ve covered a lot of ground. The key point is this: you can return multiple values from a Python function, and there are several ways to do so.

I write about the programming skills you need to develop and the concepts you need to learn, and the best ways to learn them at amymhaddad.com .

Programmer and writer | howtolearneffectively.com | dailyskillplanner.com

If you read this far, tweet to the author to show them you care. Tweet a thanks

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

• Stack Overflow Public questions & answers
• Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers
• Talent Build your employer brand
• Advertising Reach developers & technologists worldwide
• Labs The future of collective knowledge sharing
• About the company

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.

Python assign a function to another function

I am trying to assign a function to another function the left hand side of the assignment is available to me as a String. For example the body of the method I am looking for is

• How do I achieve this? Obviously if I call the above method and then call the module.function1 I expect the new function to be picked up.
• I am doing this in the context of unit testing i.e, Mock several functions, run the test and then basically "unmock" them. Are there any problems with the said approach?

• 1 possible duplicate of How to dynamically load a Python class –  Martijn Pieters ♦ May 9, 2013 at 10:20
• 2 Like classes, functions are first-class objects. You can dynamically import the module, then retrieve the function as an attribute. –  Martijn Pieters ♦ May 9, 2013 at 10:22
• Please note this is definitely different from the "How to dynamically load a Python class" question. I have explicitly asked for any improvements/problems with the eval approach and quite rightly I have been pointed to the MOCK framework of python which is included by default in python 3.3 –  Kannan Ekanath May 9, 2013 at 11:15
• There isn't anything special about mocking. The problem you were facing is one of importing and referencing an object (a function in this case, but that is no different from referencing a class) by a string specifying the import path. The other question answers that specific problem for you. The mock library does the exact same thing (see the source code ) in that regard. –  Martijn Pieters ♦ May 9, 2013 at 11:19

6 Answers 6

I think it would be better to use a mocking library like Mock . Using patch you can change the function's behaviour within the scope of a context manager or a function and have it change back to normal afterwards. For example:

if function1 is called inside the with block it will be replaced with function_object .

Similarly, patching within a function:

• This is what I ended up doing. Thanks !! –  Kannan Ekanath May 9, 2013 at 11:15

There are some problems with mocking and you might consider a different testing approach if possible:

• unittesting without patching
• unittesting without patching followup
• unittesting with localized patching

My approach:

Now the longer rant:

That approach will probably work, if module1 is already imported in the local namespace , for instance, you can do something like:

In the context of mocking for unit tests, there might be a better way of doing so.

You can check here: http://pycheesecake.org/wiki/PythonTestingToolsTaxonomy#MockTestingTools for some libraries that will allow you to have more control around mocking objects in your unit tests.

You can do something like this, to dynamically import modules:

Then, you can access the available functions inside the module, or get them via eval/getattr:

Of, if you want to swap that function to something else:

• But it requires module1 to be imported already in the local namespace. –  Martijn Pieters ♦ May 9, 2013 at 10:20

I think the following will do what you want (but you might want more robust parsing):

The assumptions here are:

• the module owning the function is already imported, and
• you need to refer to the target function as a fully qualified name

The two assumptions are slightly in tension. There must be a great many cases where you can simply do:

Python function decorator

First, the notion you are talking about is the notion of function decorator . A function decorator is applied to a function definition by placing it on the line before that function definition begins (symbol @ ). It is a tool to modify the behavior of a function, or do operate composition of functions. Here is an example

Python unittest.mock.patch()

patch acts as a function decorator, class decorator or a context manager. Inside the body of the function or with statement, the target is patched with a new object. When the function/with statement exits the patch is undone.

Patch lets you modify the function behavior within the with statement.

Here is an example where patch() is used as a context manager with a with statement.

Can use "getattr" to get the function using the string name of the function (A function is an object). Then you can change the name and call / call something else (original named function) in the new named call.

Your Answer

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 that you have read and understand our privacy policy and code of conduct .

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

• The Overflow Blog
• Journey to the cloud part I: Migrating Stack Overflow Teams to Azure
• Featured on Meta
• Our Design Vision for Stack Overflow and the Stack Exchange network
• Temporary policy: Generative AI (e.g., ChatGPT) is banned
• Call for volunteer reviewers for an updated search experience: OverflowAI Search
• Discussions experiment launching on NLP Collective

Hot Network Questions

• Why is the French embassy in Niger still considered an embassy?
• I’m feeling overwhelmed about writing a novel, can anyone help?
• Why is there an indefinite article before the proper noun in "He lacked the analytic processing power of a Hamilton"?
• Meaning of "retiring" in "free admission with retiring donations"
• Loading LSB first or MSB first?
• Was the recent ruling against Jordan Peterson an infringement of his free speech?
• What program in Linux computes the hash of the input password when you log in?
• Idiom for frustrating someone else's plans by taking what the other person wanted in the first place
• Male and female seahorses: which is which
• Are multiple extension cords in series causing significant increase in electric use?
• Why are all eigen solvers iterative?
• Did D-Wave show quantum advantage in 2023?
• Will a buck converter clean the power output from an automotive?
• anova degrees of freedom
• How many counts does a mouse need to report to move the windows cursor for 1 pixel exactly?
• Bijective group homomorphisms are isomorphisms
• Electrical issues while central air is running
• How time flies or flew?
• Why is there nearly no 1x road bikes?
• Does theism have the burden of proof?
• Do Killing vectors form a Lie-algebra?
• reading device or board specific properties from the Arduino MKR WiFi 1010 device
• Graphic3D, white face, black edge in any view?
• What does ggf reserviert mean on DB trains?

Your privacy

By clicking “Accept all cookies”, you agree Stack Exchange can store cookies on your device and disclose information in accordance with our Cookie Policy .

• Free Python 3 Course
• Control Flow
• Exception Handling
• Python Programs
• Python Projects
• Python Interview Questions
• Python Database
• Data Science With Python
• Machine Learning with Python
• Write an Interview Experience
• Share Your Campus Experience
• Python Exercises, Practice Questions and Solutions
• Python List Exercise
• Python String Exercise
• Python Tuple Exercise
• Python Dictionary Exercise
• Python Set Exercise

Python Matrix Exercises

• Python program to a Sort Matrix by index-value equality count
• Python Program to Reverse Every Kth row in a Matrix
• Python Program to Convert String Matrix Representation to Matrix
• Python – Count the frequency of matrix row length
• Python – Convert Integer Matrix to String Matrix
• Python Program to Convert Tuple Matrix to Tuple List
• Python – Group Elements in Matrix
• Python – Assigning Subsequent Rows to Matrix first row elements
• Adding and Subtracting Matrices in Python
• Python – Convert Matrix to dictionary
• Python – Convert Matrix to Custom Tuple Matrix
• Python – Matrix Row subset
• Python – Group similar elements into Matrix
• Python – Row-wise element Addition in Tuple Matrix
• Create an n x n square matrix, where all the sub-matrix have the sum of opposite corner elements as even

Python Functions Exercises

• Python splitfields() Method
• How to get list of parameters name from a function in Python?
• How to Print Multiple Arguments in Python?
• Python program to find the power of a number using recursion
• Sorting objects of user defined class in Python

Assign Function to a Variable in Python

• Returning a function from a function – Python
• What are the allowed characters in Python function names?
• Defining a Python function at runtime
• Explicitly define datatype in a Python function
• Functions that accept variable length key value pair as arguments
• How to find the number of arguments in a Python function?
• How to check if a Python variable exists?
• Python – Get Function Signature
• Python program to convert any base to decimal by using int() method

Python Lambda Exercises

• Python – Lambda Function to Check if value is in a List
• Difference between Normal def defined function and Lambda
• Python: Iterating With Python Lambda
• How to use if, else & elif in Python Lambda Functions
• Python – Lambda function to find the smaller value between two elements
• Lambda with if but without else in Python
• Python Lambda with underscore as an argument
• Difference between List comprehension and Lambda in Python
• Nested Lambda Function in Python
• Python lambda
• Python | Sorting string using order defined by another string
• Python | Find fibonacci series upto n using lambda
• Overuse of lambda expressions in Python
• Python program to count Even and Odd numbers in a List
• Intersection of two arrays in Python ( Lambda expression and filter function )

Python Pattern printing Exercises

• Simple Diamond Pattern in Python
• Python – Print Heart Pattern
• Python program to display half diamond pattern of numbers with star border
• Python program to print Pascal’s Triangle
• Python program to print the Inverted heart pattern
• Python Program to print hollow half diamond hash pattern
• Program to Print K using Alphabets
• Program to print half Diamond star pattern
• Program to print window pattern
• Python Program to print a number diamond of any given size N in Rangoli Style
• Python program to right rotate n-numbers by 1
• Python Program to print digit pattern
• Print with your own font using Python !!
• Python | Print an Inverted Star Pattern
• Program to print the diamond shape

Python DateTime Exercises

• Python – Iterating through a range of dates
• How to add time onto a DateTime object in Python
• How to add timestamp to excel file in Python
• Convert string to datetime in Python with timezone
• Isoformat to datetime – Python
• Python datetime to integer timestamp
• How to convert a Python datetime.datetime to excel serial date number
• How to create filename containing date or time in Python
• Convert “unknown format” strings to datetime objects in Python
• Extract time from datetime in Python
• Convert Python datetime to epoch
• Python program to convert unix timestamp string to readable date
• Python – Group dates in K ranges
• Python – Divide date range to N equal duration
• Python – Last business day of every month in year

Python OOPS Exercises

• Get index in the list of objects by attribute in Python
• Python program to build flashcard using class in Python
• How to count number of instances of a class in Python?
• Shuffle a deck of card with OOPS in Python
• What is a clean, Pythonic way to have multiple constructors in Python?
• How to Change a Dictionary Into a Class?
• How to create an empty class in Python?
• Student management system in Python
• How to create a list of object in Python class

Python Regex Exercises

• Validate an IP address using Python without using RegEx
• Python program to find the type of IP Address using Regex
• Converting a 10 digit phone number to US format using Regex in Python
• Python program to find Indices of Overlapping Substrings
• Python program to extract Strings between HTML Tags
• Python – Check if String Contain Only Defined Characters using Regex
• How to extract date from Excel file using Pandas?
• Python program to find files having a particular extension using RegEx
• How to check if a string starts with a substring using regex in Python?
• How to Remove repetitive characters from words of the given Pandas DataFrame using Regex?
• Extract punctuation from the specified column of Dataframe using Regex
• Extract IP address from file using Python
• Python program to Count Uppercase, Lowercase, special character and numeric values using Regex
• Categorize Password as Strong or Weak using Regex in Python
• Python – Substituting patterns in text using regex

Python LinkedList Exercises

• Python program to Search an Element in a Circular Linked List
• Implementation of XOR Linked List in Python
• Pretty print Linked List in Python
• Python Library for Linked List
• Python | Stack using Doubly Linked List
• Python | Queue using Doubly Linked List
• Program to reverse a linked list using Stack
• Python program to find middle of a linked list using one traversal
• Python Program to Reverse a linked list

Python Searching Exercises

• Binary Search (bisect) in Python
• Python Program for Linear Search
• Python Program for Anagram Substring Search (Or Search for all permutations)
• Python Program for Binary Search (Recursive and Iterative)
• Python Program for Rabin-Karp Algorithm for Pattern Searching
• Python Program for KMP Algorithm for Pattern Searching

Python Sorting Exercises

• Python Code for time Complexity plot of Heap Sort
• Python Program for Stooge Sort
• Python Program for Recursive Insertion Sort
• Python Program for Cycle Sort
• Bisect Algorithm Functions in Python
• Python Program for BogoSort or Permutation Sort
• Python Program for Odd-Even Sort / Brick Sort
• Python Program for Gnome Sort
• Python Program for Cocktail Sort
• Python Program for Bitonic Sort
• Python Program for Pigeonhole Sort
• Python Program for Comb Sort
• Python Program for Iterative Merge Sort
• Python Program for Binary Insertion Sort
• Python Program for ShellSort

Python DSA Exercises

• Saving a Networkx graph in GEXF format and visualize using Gephi
• Dumping queue into list or array in Python
• Python program to reverse a stack
• Python – Stack and StackSwitcher in GTK+ 3
• Multithreaded Priority Queue in Python
• Python Program to Reverse the Content of a File using Stack
• Priority Queue using Queue and Heapdict module in Python
• Box Blur Algorithm – With Python implementation
• Python program to reverse the content of a file and store it in another file
• Check whether the given string is Palindrome using Stack
• Take input from user and store in .txt file in Python
• Change case of all characters in a .txt file using Python
• Finding Duplicate Files with Python

Python File Handling Exercises

• Python Program to Count Words in Text File
• Python Program to Delete Specific Line from File
• Python Program to Replace Specific Line in File
• Python Program to Print Lines Containing Given String in File
• Python – Loop through files of certain extensions
• Compare two Files line by line in Python
• How to keep old content when Writing to Files in Python?
• How to get size of folder using Python?
• How to read multiple text files from folder in Python?
• Read a CSV into list of lists in Python
• Python – Write dictionary of list to CSV
• Convert nested JSON to CSV in Python
• How to add timestamp to CSV file in Python

Python CSV Exercises

• How to create multiple CSV files from existing CSV file using Pandas ?
• How to read all CSV files in a folder in Pandas?
• How to Sort CSV by multiple columns in Python ?
• Working with large CSV files in Python
• How to convert CSV File to PDF File using Python?
• Visualize data from CSV file in Python
• Python – Read CSV Columns Into List
• Sorting a CSV object by dates in Python
• Python program to extract a single value from JSON response
• Convert class object to JSON in Python
• Convert multiple JSON files to CSV Python
• Convert JSON data Into a Custom Python Object
• Convert CSV to JSON using Python

Python JSON Exercises

• Flattening JSON objects in Python
• Saving Text, JSON, and CSV to a File in Python
• Convert Text file to JSON in Python
• Convert JSON to CSV in Python
• Convert JSON to dictionary in Python
• Python Program to Get the File Name From the File Path
• How to get file creation and modification date or time in Python?
• Menu driven Python program to execute Linux commands
• Menu Driven Python program for opening the required software Application
• Open computer drives like C, D or E using Python

Python OS Module Exercises

• Rename a folder of images using Tkinter
• Kill a Process by name using Python
• Finding the largest file in a directory using Python
• Python – Get list of running processes
• Python – Get file id of windows file
• Python – Get number of characters, words, spaces and lines in a file
• Change current working directory with Python
• How to move Files and Directories in Python
• How to get a new API response in a Tkinter textbox?
• Build GUI Application for Guess Indian State using Tkinter Python
• How to stop copy, paste, and backspace in text widget in tkinter?
• How to temporarily remove a Tkinter widget without using just .place?
• How to open a website in a Tkinter window?

Python Tkinter Exercises

• Create Address Book in Python – Using Tkinter
• Changing the colour of Tkinter Menu Bar
• How to check which Button was clicked in Tkinter ?
• How to add a border color to a button in Tkinter?
• How to Change Tkinter LableFrame Border Color?
• Looping through buttons in Tkinter
• Visualizing Quick Sort using Tkinter in Python
• How to Add padding to a tkinter widget only on one side ?
• Python NumPy – Practice Exercises, Questions, and Solutions
• Pandas Exercises and Programs
• How to get the Daily News using Python
• How to Build Web scraping bot in Python
• Scrape LinkedIn Using Selenium And Beautiful Soup in Python
• Scraping Reddit with Python and BeautifulSoup
• Scraping Indeed Job Data Using Python

Python Web Scraping Exercises

• How to Scrape all PDF files in a Website?
• How to Scrape Multiple Pages of a Website Using Python?
• Quote Guessing Game using Web Scraping in Python
• How to extract youtube data in Python?
• How to Download All Images from a Web Page in Python?
• Test the given page is found or not on the server Using Python
• How to Extract Wikipedia Data in Python?
• How to extract paragraph from a website and save it as a text file?
• Automate Youtube with Python
• Controlling the Web Browser with Python
• How to Build a Simple Auto-Login Bot with Python
• Download Google Image Using Python and Selenium
• How To Automate Google Chrome Using Foxtrot and Python

Python Selenium Exercises

• How to scroll down followers popup in Instagram ?
• How to switch to new window in Selenium for Python?
• Python Selenium – Find element by text
• How to scrape multiple pages using Selenium in Python?
• Python Selenium – Find Button by text
• Scrape Table from Website using Python – Selenium
• Selenium – Search for text on page

In this article, we are going to see how to assign a function to a variable in Python. In Python, we can assign a function to a variable. And using that variable we can call the function as many as times we want. Thereby, increasing code reusability. 

Implementation

Simply assign a function to the desired variable but without () i.e. just with the name of the function. If the variable is assigned with function along with the brackets (), None will be returned.

Output:  

The following programs will help you understand better:

Example 1: 

Example 2: parameterized function

Please Login to comment...

Improve your coding skills with practice.

• Coding Ground
• Corporate Training

• Python Basic Tutorial
• Python - Home
• Python - Overview
• Python - Environment Setup
• Python - Basic Syntax
• Python - Comments
• Python - Variables
• Python - Data Types
• Python - Operators
• Python - Decision Making
• Python - Loops
• Python - Numbers
• Python - Strings
• Python - Lists
• Python - Tuples
• Python - Dictionary
• Python - Date & Time
• Python - Functions
• Python - Modules
• Python - Files I/O
• Python - Exceptions
• Python Advanced Tutorial
• Python - Classes/Objects
• Python - Reg Expressions
• Python - CGI Programming
• Python - Database Access
• Python - Networking
• Python - Sending Email
• Python - Multithreading
• Python - XML Processing
• Python - GUI Programming
• Python - Further Extensions
• Python Useful Resources
• Python - Questions and Answers
• Python - Quick Guide
• Python - Tools/Utilities
• Python - Useful Resources
• Python - Discussion

Multiple Assignments to Single Value in Python

Python allows you to assign a single value to several variables simultaneously. For example −

a = b = c = 1

Here, an integer object is created with the value 1, and all three variables are assigned to the same memory location. You can also assign multiple objects to multiple variables. For example −

a,b,c = 1,2,"john"

Here, two integer objects with values 1 and 2 are assigned to variables a and b respectively, and one string object with the value "john" is assigned to the variable c.

• Related Articles
• Print Single and Multiple variable in Python?
• How to check multiple columns for a single value in MySQL?
• How to assign same value to multiple variables in single statement in C#?
• How to provide multiple statements on a single line in Python?
• MySQL query to increase item value price for multiple items in a single query?
• Would you recommend to define multiple Python classes in a single file?
• Convert list to Single Dictionary Key Value list in Python
• How to save multiple plots into a single HTML file in Python Plotly?
• Program to find maximum credit we can get by finishing some assignments in python
• Why doesn’t Python have a “with” statement for attribute assignments?
• How to check multiple variables against a value in Python?
• Passing Multiple ids to single parameter in MySQL?
• How to write a single MySQL query for displaying a value for multiple inputs?
• How to convert a single character to its integer value in Python?
• How to merge multiple excel files into a single file with Python?

Python Tutorial

File handling, python modules, python numpy, python pandas, python matplotlib, python scipy, machine learning, python mysql, python mongodb, python reference, module reference, python how to, python examples, python variables, varia b l e s.

Variables are containers for storing data values.

Creating Variables

Python has no command for declaring a variable.

A variable is created the moment you first assign a value to it.

Variables do not need to be declared with any particular type , and can even change type after they have been set.

If you want to specify the data type of a variable, this can be done with casting.

Advertisement

Get the Type

You can get the data type of a variable with the type() function.

Single or Double Quotes?

String variables can be declared either by using single or double quotes:

Case-Sensitive

Variable names are case-sensitive.

This will create two variables:

COLOR PICKER

Report Error

If you want to report an error, or if you want to make a suggestion, do not hesitate to send us an e-mail:

[email protected]

Thank You For Helping Us!

Your message has been sent to W3Schools.

Top Tutorials

Top references, top examples, get certified.

Course Level Programming Assignment - Programming a Calculator using Python

In this assignment you will write a computer program from scratch using the Python programming language. This program will function as a simple calculator.

• Write a simple Python program that performs arithmetic operations based on the user input

Stage 1: A simple calculator

Your calculator should provide the following arithmetic and control operations.

• Addition (+) add(a,b)
• Subtraction (-) subtract(a,b)
• Multiplication (*) multiply(a,b)
• Division (/) divide(a,b)
• Power (^) power(a,b)
• Remainder (%) remainder(a,b)
• Terminate (#)

Write a function select_op(choice) to select the appropriate mathematics function based on the users selection.

The behavior of the program should be as follows:

The program should ask the user to specify the desired operation (addition/subtraction/multiplication/division/power/remainder/terminate/reset). You can start with the code already given in the answer box . Also, check the example test cases given below.

Once the user inputs/selects an arithmetic operation, the program should ask the user to enter the two operands one by one, separated by Enter key. If the user made a mistake while entering the parameters, he can return to main menu by pressing ‘$’ key at the end of the input string, followed by the Enter key

Calculate the result and display the result. Inputs need to be processed as floating point values, even thought the values entered are integers. Example: 2.0 + 4.0 = 6.0

Return to main menu after displaying the calculation result

All possible errors (at input or at generation of result) should be handled by the program

Anything other than a number as operand input

Anything other than +, -, *, /, ^ and % as arithmetic operators

Anything other than # and $ as control operators

Division by zero

The program should keep running until it is stopped by the user (using the terminate command #)

Task 1: Get user input

Input Arithmetic operation

Reset or Termination

Input first operand

Input second operand

Task 2: Implement functions that performs given arithmetic operation on the given operands and produces the result

• Arithmetic operation and the two operands as parameters
• Return the result of the arithmetic operation

Task 3: Call the calculation function by passing user input to select_op(choice) and display the result from within the select_op(choice) function

Here are some of the messages you might want to display to the users at certain occasions. Copy and paste them as necessary in your code in appropriate situations to help with auto-grading. If there is any differences between the output of your code and the expected output, it will be displayed once you click the “Check” button. You can click on “Show differences” button to highlight the difference between outputs. This will be helpful for you to change your code to match the expected output.

"Enter first number: " "Enter second number: " “Not a valid number,please enter again” “Unrecognized operation” “Something Went Wrong”

Some common issues and solutions are explained in This Forum Post

For example:

PLEASE HELP !!!

We’re going to need a little more than “PLEASE HELP !!!”, such as:

• How far have you got?
• What are stuck on?
• How would you describe your Python skills?

Please help us, so that we can help you.

FYI: I have in fact written a CLI calculator app (as I’m sure many of us here have) that I use almost every day, so I (or indeed we) will have some good insights on this.

Okay, so did you read this? Does it help?

What code did you try writing? What problem did you encounter with the code? Or else what help are you looking for?