Understanding the 'Only Named Arguments May Follow *Expression' Rule: A Comprehensive Guide to Python Programming


In Python, function arguments can be passed in various ways, including positional arguments, named arguments, and arbitrary argument lists. However, there are specific rules to follow when combining these different types of arguments. One of such rules is the 'Only Named Arguments May Follow *Expression' rule.

This guide will explain the concept of *Expression, the importance of the rule, and how to correctly pass arguments in Python functions. Additionally, we will provide examples to illustrate the proper usage of this rule and a FAQ section to address common questions.

## What is *Expression?

In Python, the single asterisk (*) before an expression is often used in function definitions to allow the function to accept an arbitrary number of arguments. This is called *args, and it is a tuple containing all additional positional arguments passed to the function.

def example_function(arg1, arg2, *args):
    print(arg1, arg2, args)

example_function(1, 2, 3, 4, 5)

The output of this code would be:

1 2 (3, 4, 5)

The 'Only Named Arguments May Follow *Expression' Rule

When using *Expression in a function call, any arguments that follow it must be named arguments. This is because *Expression unpacks all the remaining positional arguments, so any argument after it must be explicitly assigned to a parameter.

For example:

def example_function(arg1, arg2, *args, arg3):
    print(arg1, arg2, args, arg3)

example_function(1, 2, 3, 4, 5, arg3=6)

The output of this code would be:

1 2 (3, 4, 5) 6

If you try to pass a positional argument after *Expression, Python will raise a SyntaxError:

example_function(1, 2, 3, 4, 5, 6)  # Raises SyntaxError

Step-by-Step Solution

To ensure that you are using the 'Only Named Arguments May Follow *Expression' rule correctly, follow these steps:

  1. Identify the function parameters that should accept an arbitrary number of arguments and add a single asterisk (*) before them.
  2. Ensure that any arguments after *Expression are assigned to a named parameter in the function definition.
  3. When calling the function, pass positional arguments before *Expression and use named arguments for any parameters following it.


1. Can I use more than one *Expression in a function?

No, you can only use one *Expression in a function definition. Using multiple *Expression will result in a SyntaxError.

2. What is **kwargs?

**kwargs is a similar concept to *args but for named arguments. It is a dictionary containing all additional keyword arguments passed to the function. You can use **kwargs to accept any number of named arguments.

3. Can I use both *args and **kwargs in the same function?

Yes, you can use both *args and **kwargs in the same function definition. The *args must come before **kwargs, and any positional arguments should be passed before any named arguments.

4. Can I use *Expression with default argument values?

Yes, you can use *Expression with default argument values. When calling the function, if you don't provide a value for the default argument, it will use the default value specified in the function definition.

5. Can I use *Expression in a lambda function?

Yes, you can use *Expression in a lambda function, but keep in mind that lambda functions only accept a single expression, so the use of *Expression is limited.

Great! You’ve successfully signed up.

Welcome back! You've successfully signed in.

You've successfully subscribed to Lxadm.com.

Success! Check your email for magic link to sign-in.

Success! Your billing info has been updated.

Your billing was not updated.