Scribd
Upload
16 views4 pages

Python Functions and Subprograms Guide

Uploaded by

basmah.basheer
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
16 views4 pages

Python Functions and Subprograms Guide

Uploaded by

basmah.basheer
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd

Python Subprograms: Functions and Subroutines

What is a Subprogram?

A subprogram is a small, separate piece of code inside a bigger program. It performs a specific task. In Python,
functions are used as subprograms.

Why Use Functions?

- Avoid repeating the same code


- Break problems into small parts
- Reuse code
- Make programs easier to fix and update

How to Define a Function

Syntax:
def function_name(parameters):
# code block
return result

Example:
def greet():
print("Hello! Welcome to Python.")
greet()

Function with Parameters

def greet(name):
print("Hello,", name)

greet("Asmitha")

Function with Return Value

def add(a, b):


return a + b

result = add(10, 5)
print("Sum is:", result)

Types of Functions

- No parameters, no return: def show(): print("Hi")


- Parameters, no return: def display(x): print(x)
Python Subprograms: Functions and Subroutines

- Parameters, with return: def square(x): return x*x


- No parameters, with return: def get_pi(): return 3.14

Default Arguments

def greet(name="Student"):
print("Hello,", name)

greet()
greet("John")

Keyword Arguments

def student_info(name, age):


print(name, "is", age, "years old")

student_info(age=16, name="Priya")

Variable-Length Arguments

*args:
def total(*numbers):
print("Sum:", sum(numbers))
total(1, 2, 3, 4)

**kwargs:
def show_info(**info):
for key, value in [Link]():
print(key, ":", value)
show_info(name="Ravi", age=17)

Local vs Global Variables

x = 10 # Global

def show():
x = 5 # Local
print("Inside:", x)

show()
print("Outside:", x)
Python Subprograms: Functions and Subroutines

Recursive Function (Function Calling Itself)

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

print(factorial(5))

Anonymous Function (Lambda)

square = lambda x: x * x
print(square(6))

Practice Exercises

1. Area of a Circle:
def area_circle(radius):
pi = 3.1416
return pi * radius * radius

2. Prime Checker:
def is_prime(n):
if n < 2: return False
for i in range(2, n):
if n % i == 0: return False
return True

3. Max of Variable Inputs:


def find_max(*nums):
return max(nums)

4. Fibonacci using Recursion:


def fibonacci(n):
if n <= 1: return n
return fibonacci(n-1) + fibonacci(n-2)
for i in range(6):
print(fibonacci(i), end=" ")

Summary Chart

Concept | Keyword/Method | Example


------------------|------------------|---------------------------
Python Subprograms: Functions and Subroutines

Function def | def | def hello():


Return value | return | return x + y
Call function | function name | hello()
Optional input | default args | name="guest"
Unlimited input | *args, **kwargs | *nums, **info
One-line function | lambda | lambda x: x*x
Repeated call | recursion | factorial(n-1)

Common questions

Powered by AI

Recursive functions in Python call themselves to solve smaller instances of a problem, facilitating solutions to complex problems like calculating factorials or generating Fibonacci numbers. For example, 'def factorial(n)' recursively calculates factorial values by reducing 'n' step-by-step until it reaches the base case (n==1). This approach simplifies problem-solving and code readability but demands careful management of base cases to prevent infinite recursion .

Parameterized functions in Python accept input values through defined parameters, allowing customization and flexibility across different calls, as seen in 'def greet(name):'. Non-parameterized functions like 'def show():' perform the same operation during every invocation. Parameterized functions enhance reusability and computational efficiency, enabling functions to handle diverse data with consistent logic .

Using functions as subprograms in Python has several benefits: it avoids repeating the same code, breaks problems into smaller parts, facilitates code reuse, and makes programs easier to fix and update. These advantages derive from structuring code into units that perform specific tasks, thus enhancing readability and maintainability .

In Python, global variables are accessible throughout the entire program, while local variables are only accessible within the function or code block where they are defined. For example, in the code 'x = 10' is a global variable; 'x = 5' inside the function 'show()' is a local variable. When 'show()' is called, it prints 'Inside: 5,' while 'Outside: 10' confirms the global scope of 'x' outside the function .

Python implements anonymous functions using the 'lambda' keyword to create concise, one-line functions. For example, 'square = lambda x: x * x' defines a function that squares a number. These functions are ideal for short-term, throwaway purposes, particularly in situations where a simple functional operation is needed, such as sorting or mapping operations within larger algorithms .

Python supports default arguments by allowing parameter values to be specified in a function definition, such as def greet(name='Student'). These parameters assume their default values if no argument is provided during the function call, allowing the function to be called with varying numbers of arguments. This flexibility benefits code by reducing the need for overloaded functions and increasing function versatility .

Python can handle functions with a varying number of arguments using *args for variable-length positional arguments and **kwargs for variable-length keyword arguments. For instance, def total(*numbers) allows aggregation of multiple positional arguments into a tuple, while def show_info(**info) gathers keyword arguments into a dictionary. This syntax supports flexible function calls that can adapt to different input scenarios .

Lambda functions in Python offer a shorthand for defining simple, single-expression functions without naming them. Unlike regular functions defined using 'def', lambda functions are in-line, facilitating quick, throwaway computations ideal for customizing operations within functions like 'map()' or 'filter()'. Although they offer conciseness, lambda functions are limited to a single expression, contrasting with the full scalability of regular functions .

Python differentiates between local and nonlocal variables within subprograms. Local variables, defined inside a function, are isolated from the global and nonlocal scopes. Variables declared nonlocal are at least one level outside the currently executing function, allowing nested functions to modify them. This mechanism is crucial for creating closures, facilitating encapsulation of state without relying solely on global variables .

Keyword arguments enhance Python function calls by improving readability and flexibility. They allow calling a function with arguments specified in any order using named parameters, as in 'student_info(age=16, name="Priya")'. This method improves clarity by directly associating values with parameters and reduces errors in functions with numerous parameters, promoting cleaner and more maintainable code .

You might also like