Session 5: List Comprehension and Python Functions

Date: 04-04-2026 4:00 pm to 6:00 pm**

Agenda

1. Review of previous sessions
2. Answers to queries
3. List comprehensions
4. Unpacking rules
5. Function parameters and arguments revisited

List comprehensions

There are several ways to create a list:

>>> a = [1, 2, 3, 4, 5]  # Assign a list to an object
>>> a
[1, 2, 3, 4, 5]
>>> b = list([1, 2, 3, 4, 5])  # Use list() with a list argument
>>> b
[1, 2, 3, 4, 5]
>>> c = list(range(1, 6))  # Use list() with a range() argument
>>> c
[1, 2, 3, 4, 5]

Another way is to start with an empty list and append elements one at a time.

>>> a = []
>>> for i in range(1, 6):
...     a.append(i)
...
>>> a
[1, 2, 3, 4, 5]

>>> a = [i for i in range(1, 6)]
>>> a
[1, 2, 3, 4, 5]

1. The for loop iterates over range(1, 6), namely, generates the values 1, 2, 3, 4, 5
2. The iterator i is assigned these values in sequence, one at a time
3. The value of the iterator i is appended to the list being generated

Instead of appending the value generated by the range(1, 6) generator, if we wished to store not i but its square i * i, the list comprehension would be as follows:

>>> a = [i * i for i in range(1, 6)]
>>> a
[1, 4, 9, 16, 250]

Consider another example that applies a condition to select elements to be added to the list. For exampe, if only the elements that satisfy a given condition are to be appended to the list:

>>> a = [i * i for i in range(10)]
>>> a
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> b = [i * i for i in range(10) if i * i % 2]
>>> b
[1, 9, 25, 49, 81]

An if-else condition can be incorporated into a list comprehension. In the following example i * i is appended if i * i % 2 is True and i is appended if i * i % 2 is False:

>>> a = [i * i if (i*i % 2) else i for i in range(10)]
>>> a
[0, 1, 2, 9, 4, 25, 6, 49, 8, 81]

Unpacking rules

Elements of a container can be unpacked into objects:

>>> a, b, c = [10, "Hello", 20]
>>> print(a, b, c)
10 Hello 20

>>> x, _, z = [10, "Hello", 20]
>>> print(x, z)
10 20
>>> m, _, _ = [10, "Hello", 20]
>>> print(m)
10

a, _, b = [10, 20, 30]
print(_)  # Prints 20

>>> a, b = [10, "Hello", 20]
Traceback (most recent call last):
File "<python-input-0>", line 1, in <module>
    a, b = [10, "Hello", 20]
    ^^^^
ValueError: too many values to unpack (expected 2, got 3)

Python offers a way to unpack where an object on the left side can collect zero or more values.

>>> a, *b = [10, "Hello", 20]
>>> type(a), a
(<class 'int'>, 10)
>>> type(b), b
(<class 'list'>, ['Hello', 20])

It is possible to use this technique in the following ways:

>>> a, *b, c = [10, "Hello", 20, "Last"]
>>> a
10
>>> b
["Hello", 20]
>>> c
'Last'

a, *_, b = [10, 20, 30, 40]
print(_)  # Prints [20, 30]

Note

1. When unpacked, the right side will result in four elements.
2. The first element is assigned to a.
3. The last element is assigned to c.
4. The remaining two elements inbetween the first and the last are assigned to b, which is a list and can hold zero or more elements. Even when there is only one element assigned to b, it is a list with one element, not a single non-container object.

   >>> a, *b, c, d = [10, "Hello", 20, "Last"]
   >>> a
   10
   >>> b
   ['Hello']
   >>> c
   20
   >>> d
   'Last'
   

5. b can be an empty list. Since the values on the right side are unpacked to the objects on the left and none are left over to assign to b.

   >>> a, *b, c, d, e = [10, "Hello", 20, "Last"]
   >>> b
   []
   

6. When the objects on the left are more than the values on the right, an exception is raised.

   >>> a, b, c, d, e, f = [10, "Hello", 20, "Last"]
   Traceback (most recent call last):
     File "<python-input-1>", line 1, in <module>
       a, b, c, d, e = [10, "Hello", 20, "Last"]
       ^^^^^^^^^^^^^
   ValueError: not enough values to unpack (expected 5, got 4)
   

>>> a, *b = (10, 20, 30)
>>> print(type(b), b)
<class 'list'>, [20, 30]

Function parameters and arguments revisited

The previous discussion on function interface, parameters and arguments can be summarized as follows:

This offers the following advantages:

1. The design of a function can be done independent of how the function will be called later and what the names of arguments are going to be named.
2. The body of the function, which may contain any number of lines and implement any complex logic, can now be represented by a single function call.
3. Variables used within the body of the function and the parameters are local to the function. Therefore these names can be used anywhere outside the function without clashing or overwriting these names.

A function achieves two important goals (See Think Python, Allen Downey 3ed.):

1. Wrapping a piece of code up in a function is called encapsulation. One of the benefits of encapsulation is that it attaches a name to the code, which serves as a kind of documentation. Another advantage is that if you re-use the code, it is more concise to call a function twice than to copy and paste the body!
2. Adding a parameter to a function is called generalization

By default, a function must be called with the correct number of arguments. Exception to the rule is when the function has default parameters. In that case, you can provide fewer arguments than there are parameters, and the missing arguments are assigned the values specified for the default parameter. For this reason, all the default parameters (if a function has any) must be defined at he end of the parameter list. It is not permitted to define parameters without default values after a parameter has been assigned a default value.

Therefore the following function signature results in an error:

>>> def func(a = 10, b):
  File "<python-input-5>", line 1
    def func(a = 10, b):
                     ^
SyntaxError: parameter without a default follows parameter with a default

If such a function could be defined and is called with one argument, say func(20), then it results in an ambiguous situation where it is not possible to decide whether it is to be interpreted as

• a = 20 and b is missing

or

• a = 10, the default value and b = 20

Calling functions with named arguments

def echo_lines(line: str, n: int) -> str:
    if n < 0:
        raise ValueError(f"n = {n} must not be negative")
    s = ""
    for i in range(n):
        s += f"{line}\n"
    return s

print(echo_lines("Hello, world!", 2))
print(echo_lines(n=2, line="Hello, world!"))

1. When arguments are passed without names, they are assigned to the parameters based on their position. The first argument is assigned to the first parameter and the second argument to the second parameter.
2. Python allows naming arguments when calling a function and in such a case, the order of the arguments can be arbitrary. The names must be the same as the names of the parameters.

This works with default parameters as well. If a parameter with a default value is missing from the arguments, it is assigned the default value for that parameter during the specific function call.

Defining functions with a variable number of positional arguments

Consider the built-in function print() which prints the values of the arguments furnished when it is called, and this is not a fixed number. Without any arguments, print() prints an empty line, and when called with one, or two or any number of arguments, it prints all the arguments, and this number can be different in another onvocation of the function.

Python has a mechanism to define a function with a variable number of arguments, which enables a user-defined functin to accept a variable number of arguments.

>>> def func(name: str, *args):
...     print(type(name), name)
...     print(type(args), len(args), args)

>>> func('Satish', 10, "Hubli")
<class 'str'> Satish
<class 'tuple'> 2 (10, 'Hubli')
>>> func('Satish', 10, "Hubli", "Engineer")
<class 'str'> Satish
<class 'tuple'> 3 (10, 'Hubli', 'Engineer')
>>> func('Satish')
<class 'str'> Satish
<class 'tuple'> 0 ()

The values of the elements of the tuple can be copied into local variables within the function for subsequent use. The programmer can choose which of the elements to choose and which to ignore using the unpacking rules described above. With the number of elements can be known using len(args), it is possible to decide the way the elements of args are to be used.

Defining functions with a variable number of named arguments

Consider the following lines of code:

>>> def func(a, **kwargs):
...     print(type(a), a)
...     print(type(kwargs), len(kwargs), kwargs)
...     
>>> func(10, line="Hello", n=2)
<class 'int'> 10
<class 'dict'> 2 {'line': 'Hello', 'n': 2}

The values of the elements of the dict can be copied into local variables within the function for subsequent use. The programmer can choose which of the elements to choose and which to ignore using the keys of the dict. With the number of elements can be known using len(args), it is possible to decide the way the elements of kwargs are to be used.

There are some rules on how the various parameters must be ordered in the function definition:

1. Positional-only parameters (x, /)
2. Positional-or-keyword parameters (a, b)
3. Default-valued parameters (c=10, d=20)
4. Variable positional parameters (*args)
5. Keyword-only parameters (e, f)
6. Keyword-only defaults (g=30)
7. Variable keyword parameters (**kwargs)

This can be a bit flustering in the beginning, but will begin to make sense as the programmer gains experience.