Beyond the Basics of Function

Python tutorial · PySpark.in

1 Anonymous (Lambda) Functions

Small, one-line functions without a name.
Defined using the lambda keyword.
Commonly used for short, throwaway tasks or as arguments in other functions.

1square = lambda x: x * x

2print(square(5)) # Output: 25

▶ Output will appear here.

Use Case: Useful in functions like map(), filter(), and sorted().

2 Recursion (Function Calling Itself)

A recursive function is one that calls itself until a base condition is met.

def factorial(n):
 if n == 1:
 return 1
 return n * factorial(n - 1)

▶ Output will appear here.

Use Case: Solving problems like factorial, Fibonacci, or tree traversal.

3 Scope and Lifetime of Variables

Local variables → exist only inside the function.
Global variables → can be accessed from anywhere.

x = 10  # Global
def show():
 y = 5  # Local
 print(x + y)

▶ Output will appear here.

Use Case: Understanding variable access and avoiding name conflicts.

4 The global and nonlocal Keywords

global → allows modifying global variables inside a function.
nonlocal → allows modifying a variable in the enclosing (non-global) scope.

count = 0
def increment():
 global count
 count += 1
def outer():
 x = 10
 def inner():
 nonlocal x
 x += 5
 print(x)
 inner()

▶ Output will appear here.

5 Docstrings (Documentation Strings)

Used to describe what a function does.
Written just below the function definition inside triple quotes """.

def add(a, b):
 """Return the sum of two numbers."""
 return a + b
print(add.__doc__)

▶ Output will appear here.

Use Case: Improves readability and helps tools like help() and IDE tooltips.

6 Function Annotations (Type Hints)

Help specify expected data types for parameters and return values.

1def greet(name: str, age: int) -> str:

2 return f"Hello {name}, you are {age} years old!"

▶ Output will appear here.

Use Case: Improves code clarity and helps static type checkers.

7 Higher-Order Functions

Functions that take other functions as arguments or return functions.

def apply(func, value):
 return func(value)
print(apply(lambda x: x**2, 5))  # Output: 25

▶ Output will appear here.

Use Case: Common in functional programming and frameworks.

8 Closures

Inner functions that “remember” variables from the outer function even after the outer function has finished executing.

def outer(x):
 def inner(y):
 return x + y
 return inner
add_five = outer(5)
print(add_five(10))  # Output: 15

▶ Output will appear here.

Use Case: Useful for decorators and encapsulation.

9 Decorators

Special functions that modify the behavior of other functions without changing their code.

def decorator(func):
 def wrapper():
 print("Before function")
 func()
 print("After function")
 return wrapper
@decorator
def say_hello():
 print("Hello!")
say_hello()

▶ Output will appear here.

Use Case: Logging, authentication, timing, etc.

10 Built-in Higher-Order Functions

These built-in functions take other functions as arguments:

map(function, iterable)
filter(function, iterable)
reduce(function, iterable) (from functools)
sorted(iterable, key=function)

nums = [1, 2, 3, 4]
squares = list(map(lambda x: x*x, nums))
print(squares)

▶ Output will appear here.

11 Generator Functions & yield Keyword

Used to create iterators.
Instead of returning all values at once, they yield one value at a time.

def countdown(n):
 while n > 0:
 yield n
 n -= 1
for i in countdown(3):
 print(i)

▶ Output will appear here.

Use Case: Memory-efficient iteration.

12 Function Introspection

You can get information about a function using built-in attributes:

__name__, __doc__, __defaults__, __annotations__, etc.

def sample(x: int) -> int:
 """Example function"""
 return x + 1
print(sample.__name__) # sample
print(sample.__doc__) # Example function
print(sample.__annotations__) # {'x':  , 'return':  }  

▶ Output will appear here.

13 Partial Functions (from functools)

Allow you to “fix” some arguments of a function and create a new one.

from functools import partial
def power(base, exp):
 return base ** exp
square = partial(power, exp=2)
print(square(5))

▶ Output will appear here.

Use Case: Simplify frequently used function calls.

14 Async (Asynchronous) Functions

Introduced with async def, used with await keyword for concurrency.

import asyncio
async def greet():
 print("Hello")
 await asyncio.sleep(1)
 print("World")

▶ Output will appear here.

Use Case: For non-blocking I/O operations and web apps.

Beyond the Basics of Function

1 Anonymous (Lambda) Functions

2 Recursion (Function Calling Itself)

3 Scope and Lifetime of Variables

4 The global and nonlocal Keywords

5 Docstrings (Documentation Strings)

6 Function Annotations (Type Hints)

7 Higher-Order Functions

8 Closures

9 Decorators

10 Built-in Higher-Order Functions

11 Generator Functions & yield Keyword

12 Function Introspection

13 Partial Functions (from functools)

14 Async (Asynchronous) Functions

More Python tutorials