The Ultimate Beginner’s Guide to Python

Functions

Introduction

Python is renowned for being accessible and beginner-friendly, making it an ideal first
language for students and future programmers. However, one area that often
confuses beginners—especially those preparing for O/L (Ordinary Level) exams or
embarking on their programming journey—is the concept of functions.
Understanding functions is essential, as they allow you to reuse code, break programs
into manageable pieces, and think in a structured, logical way about problem-solving.

This comprehensive guide will explain Python functions in complete detail, specifically
designed for those who are struggling and want simple language, step-by-step
explanations, and practical, exam-relevant examples. Along the way, you’ll learn
about function definitions, parameters (including positional, keyword, default, and
variable-length), return values, scope, recursion, lambda functions, decorators,
documentation, comments, and best practices. Each section includes clear code
samples and hands-on exercises to reinforce key concepts.

What Is a Function in Python?

A function is a named block of code that carries out a specific task when you call it.
Functions help you avoid repetition, organize your code, and solve complex problems
by breaking them into smaller parts12. Functions are a cornerstone of the Python
language and are a vital skill for every aspiring programmer to master.

Key points about functions:

 Functions perform a specific task.

 They can take inputs (called parameters or arguments).

 They often produce an output (called a return value).

 You can call (use) them as many times as you want, with different inputs each
time.

Example:

def greet():

print("Hello, world!")

Here, def is used to define a function. The function is named greet. When you call
greet(), it prints "Hello, world!"31.
How to Define and Call a Function

To define a function in Python:

1. Use the def keyword.

2. Give the function a name.

3. Add parentheses, which can include parameters.

4. End the line with a colon :.

5. Indent the next lines; this is the function body.

6. Optionally, use return to send values back to where it was called.

Example:

def say_hello():

print("Hello from a function!")

To call (execute) the function, write its name followed by parentheses:

say_hello() # Output: Hello from a function!

Exercise:
Write a function called display_message that prints "Welcome to Python functions!".

Parameters and Arguments

Difference Between Parameters and Arguments

 A parameter is the variable in the function definition:

 def greet(name): # name is a parameter

print("Hello", name)

 An argument is the actual value you pass to the function:

greet("Alice") # "Alice" is the argument

Both terms are sometimes used interchangeably, but this distinction is useful.
Types of Function Parameters

Python functions allow you to specify a variety of parameter types, giving you
flexibility in how you define and call functions.

1. Positional Parameters and Arguments

With positional parameters, the order matters. When you call a function, the first
argument is matched to the first parameter, the second to the second, and so on.

Example:

def add_numbers(a, b):

print(a + b)

add_numbers(5, 3) # Output: 8

❗ If you switch the order, you change the meaning.

def subtract(a, b):

print(a - b)

subtract(9, 5) # Output: 4

subtract(5, 9) # Output: -4

Exercise:
Write a function that multiplies two numbers and prints the result.

2. Keyword Arguments

Keyword arguments allow you to specify which value should go to which parameter
by name, so order does not matter456.

Example:

def describe_pet(animal_type, pet_name):

print(f"I have a {animal_type} named {pet_name}.")

describe_pet(animal_type="cat", pet_name="Whiskers")

describe_pet(pet_name="Rover", animal_type="dog")

In this case, naming the arguments makes your code more readable and flexible.
Key Takeaway:

 Use keyword arguments for clarity and to avoid mistakes with order.

 Required when a function is called with many parameters.

3. Default Arguments

You can give parameters default values. If the argument is not supplied, Python uses
the default.

Example:

def greet(name, greeting="Hello"):

print(f"{greeting}, {name}!")

greet("Alice") # Output: Hello, Alice!

greet("Bob", greeting="Hi") # Output: Hi, Bob!

If you don’t provide the greeting, it uses "Hello".

Important:

 Default arguments must follow non-default arguments in the function definition:

def func(a, b=10) is correct, but def func(a=10, b) is not allowed.

Exercise:
Create a function welcome that takes a name and country (default country is "Sri
Lanka") and prints "Welcome NAME from COUNTRY".

4. Variable-Length Arguments

a. *args (Arbitrary Positional Arguments)

Use an asterisk * in front of a parameter to accept an arbitrary (unlimited) number of

positional arguments. They come in as a tuple.

def add_all(*numbers):

total = sum(numbers)

print("Total:", total)

add_all(1, 2, 3) # Output: Total: 6

add_all(5, 10, 15, 20) # Output: Total: 50

You can loop through numbers just like you would with a tuple.
b. **kwargs (Arbitrary Keyword Arguments)

Use double asterisks ** to accept an arbitrary number of keyword arguments. They

come in as a dictionary.

def print_info(**kwargs): for key, value in [Link](): print(f"{key}:

{value}") print_info(name="Alice", age=30, subject="Math") # Output: # name:
Alice # age: 30 # subject: Math

Tip:

 *args must come before **kwargs if both are used in a function 789.

 Use *args when you don’t know how many positional arguments will be passed.

 Use **kwargs when you need to handle named arguments dynamically.

Exercise:
Write a function that takes any number of numbers as arguments and prints only the
even ones.

Understanding Return Values

A function can send a value back to where it was called using the return statement.
This is known as the return value.

Why Use Return Values?

 To get a result from a function (e.g. a calculation)

 To use function outputs as input to other parts of your program

How to Use return:

def multiply(a, b):

return a * b

result = multiply(4, 5)

print(result) # Output: 20

What if You Don’t Use return?

If a function doesn’t have a return statement, or you use just return with no value, the
function returns None10111213.

def foo():

print("Hi")

x = foo() # prints "Hi"

print(x) # prints None

Returning Multiple Values

Python functions can return multiple values as a tuple:

def get_name_and_age():

return "Alice", 16

name, age = get_name_and_age()

print(name) # Output: Alice

print(age) # Output: 16

Exercise:
Write a function that takes two numbers, returns both their sum and their difference.

Scope in Python Functions: Local, Global, and Nonlocal

Variable scope determines where in your code a variable can be accessed or

modified.

Local Scope

Variables defined inside a function are local to that function. They cannot be accessed
outside:

def test():

message = "Hello"

print(message) # Works

test()

print(message) # Error: message is only inside test()

Global Scope

Variables defined outside all functions are global. They can be read inside any function
unless a local variable with the same name is used.

name = "Ravi" # global

def greet():
 print(name)

greet() # Output: Ravi

print(name) # Output: Ravi

Modifying Global Variables Inside a Function

To change a global variable from inside a function, declare it with global:

count = 0

def increment():

global count

count += 1

increment()

print(count) # Output: 1

Nonlocal Scope (Advanced, for Nested Functions)

nonlocal allows a nested (inner) function to modify a variable from the enclosing
(outer) function, not just global scope141516.

def outer():

x = "local"

def inner():

nonlocal x

x = "nonlocal"

inner()

print(x) # Output: nonlocal

outer()

Summary Table: Scope

Scope Where Where Available How to Modify

Declared
Local Inside Only in that function Direct assignment
 function
Global Outside func Everywhere in Use global
file/module keyword
Nonloc Nested Enclosing function (not Use nonlocal
al function global) keyword

Exercise:
Write a function that uses a local variable and try to print it outside. What happens?

Recursion: Functions Calling Themselves

What Is Recursion?

A recursive function is a function that calls itself, usually to solve a smaller version
of the same problem. Recursion is especially useful for problems that can be broken
down into similar subproblems, such as mathematical calculations (factorials,
Fibonacci numbers) and traversing structures (trees).

Anatomy of a Recursive Function

 Base Case: Stop condition (prevents infinite recursion)

 Recursive Case: Function calls itself with a modified parameter

Example: Factorial Calculation

def factorial(n):

if n == 0 or n == 1: # Base case

return 1

else:

return n * factorial(n - 1) # Recursive case

print(factorial(5)) # Output: 120

How does this work?

1. factorial(5) calls factorial(4)

2. factorial(4) calls factorial(3)

3. ...and so on, down to factorial(1)

4. The base case returns 1, and all computations are resolved from the inside out

Another Example: Sum from 1 to n

def sum_to_n(n):
 if n == 0:

return 0

else:

return n + sum_to_n(n - 1)

print(sum_to_n(10)) # Output: 55

Warning About Recursion

 Always ensure you have a base case.

 Too many recursive calls can cause a "maximum recursion depth exceeded"
error.

 Sometimes an iterative (loop) solution is more efficient.

Exercise:
Write a recursive function to compute the nth Fibonacci number (where fib(0)=0,
fib(1)=1, and fib(n)=fib(n-1)+fib(n-2)).

Lambda Functions: Small, Anonymous Functions

A lambda function is a quick way to write simple, single-expression functions

without giving them a name. They’re also called anonymous functions17181920.

Syntax:

lambda arguments: expression

Example:

square = lambda x: x * x

print(square(5)) # Output: 25

You can also use lambdas directly:

print((lambda x, y: x + y)(2, 3)) # Output: 5

Where Are Lambda Functions Used?

 As quick custom functions for map(), filter(), sorted(), etc.

 When you need a simple function only once and don’t want to define it using
def.

Examples:

numbers = [1, 2, 3, 4, 5]
doubled = list(map(lambda x: x * 2, numbers)) # [2, 4, 6, 8, 10]

evens = list(filter(lambda x: x % 2 == 0, numbers)) # [2, 4, 6, 8, 10]

# Sorting a list of tuples by second element

data = [('apple', 5), ('banana', 2), ('cherry', 8), ('date', 1)]

sorted_data = sorted(data, key=lambda x: x[1])

# Output: [('date', 1), ('banana', 2), ('apple', 5), ('cherry', 8)]

Best Practice:
Use lambda for short, throwaway functions. Use def for anything more complex, for
readability and debugging.

Exercise:
Use a lambda function inside filter() to get all odd numbers from a list.

Decorators: Modifying Function Behavior

A decorator is a function that takes another function as input and returns a new
function with added or modified behavior—without changing the original function’s
code21222324.

When to Use Decorators?

 Add logging, timing, or validation to many functions at once

 Modify or extend function behavior in a reusable, DRY way

Basic Decorator Example:

def shout(func):

def wrapper():

result = func()

return [Link]()

return wrapper

@shout

def greet():

return "hello"
print(greet()) # Output: HELLO

 @shout is syntactic sugar for greet = shout(greet)

 The decorator can add code before, after, or even change the result

Decorator with Arguments:

def emphasize(func):

def wrapper(*args, **kwargs):

return func(*args, **kwargs) + "!"

return wrapper

@emphasize

def say(word):

return word

print(say("nice")) # Output: nice!

Common Uses:

 @staticmethod, @classmethod (built-in decorators for classes)

 @property (turns a method into an attribute)

Exercise:
Write a decorator that prints "Start" before and "End" after a function call.

Function Docstrings and Comments

Comments in Python

 Use # for single-line comments to explain code.

 Use comments to describe why, not what if code is obvious.

Example:

# This function adds two numbers

def add(a, b):

return a + b
Docstrings

A docstring is a string placed immediately after the function definition. It describes

what the function does, how to use it, its parameters and return value. This makes
your code self-documenting and helps others or your future self 252627.

How to write a docstring:

 Place it within triple quotes ("""..."'') just after the def line.

 Should begin with a summary, followed by details if necessary.

Example:

def multiply(a, b):

"""

Multiply two numbers and return the product.

Args:

a (int or float): First number.

b (int or float): Second number.

Returns:

int or float: The product of a and b.

"""

return a * b

Why Docstrings Matter:

 They’re accessible through Python’s help() function and tools.

 They’re essential for maintaining, testing, and sharing your code.

Good practices:

 Always supply a docstring for public functions.

 Use clear language and document arguments and return values.

Exercise:
Write a function with a docstring that checks if a number is even or odd.
Best Practices for Python Functions

Writing clean, readable, and efficient functions is crucial, both for your exams and
real-world coding2829303132.

Naming and Structure Guidelines:

 Use descriptive names for your functions: calculate_average, send_email, not

foo or do_stuff.

 Use snake_case for function and variable names: print_hello, not PrintHello or
printHello.

 Write short, focused functions: Each function should do one thing well.

 Always write docstrings for functions.

 Avoid using global variables unless necessary.

 Prefer keyword arguments when a function takes many parameters.

 Avoid using mutable default arguments like lists or dictionaries; use None as a
default, then assign inside the function.

Example Table: Good vs Bad Naming

Good Name Bad

Name
add_number a
s
check_is_pri check
me
calculate_are ca
a
display_resul dr
ts

Advanced Tips:

 Type hinting: You can document what types a function expects and returns
(optional for exams, but very useful).

def add(a: int, b: int) -> int:

return a + b

 Use *args and **kwargs for flexible functions.

 Keep your indentation consistent (4 spaces per level).

 Use blank lines between top-level functions for clarity.

 Return None explicitly if a function sometimes doesn’t return a result.

Style Guide Reference:
Familiarize yourself with PEP 8 (Python’s official style guide) for more elaborate
guidelines on formatting and style.

Example Functions for Beginners

Let’s reinforce everything with beginner-friendly sample functions:

def square(n):

"""Return the square of a number."""

return n * n

def is_even(n):

"""Check if a number is even."""

return n % 2 == 0

def is_prime(n):

"""Return True if n is a prime number, False otherwise."""

if n < 2:

return False

for i in range(2, n):

if n % i == 0:

return False

return True

def factorial(n):

"""Return the factorial of n using recursion."""

if n == 0:

return 1

else:

return n * factorial(n - 1)

Practice calling and observing the results of each function.

Short Exercises for Practice

Try these exercises to test your understanding (answers at the end):

1. Write a function that returns the cube of a number.

2. Create a function that takes a number and prints "Even" if the number is
even, or "Odd" otherwise.

3. Write a function that takes a list and returns the largest number.

4. Write a decorator that prints “Calling function” before running a function.

5. Use a lambda inside map() to square every number in a list.

6. Write a recursive function for the nth Fibonacci number.

Example Exercise Solution:

Exercise 1 Solution:

def cube(n):

"""Return the cube of n."""

return n ** 3

Summary Table: Key Concepts & Syntax

Concept Syntax Example Description

Function def greet(): Defines a new function named

definition greet
Calling a greet() Executes the code inside greet
function
Parameter def add(a, b): a and b are parameters
Argument add(2, 3) 2 and 3 are arguments
Keyword add(b=3, a=2) Assigns arguments by
argument parameter name
Default def greet(name="Sri Lanka"): name defaults to "Sri Lanka" if
argument not provided
*args def fun(*args): Collects extra positional
arguments (tuple)
**kwargs def fun(**kwargs): Collects extra keyword
arguments (dict)
Return value return a + b Sends value back to caller
Recursion def factorial(n): return 1 if n == 0 Function that calls itself
else n*factorial(n-1)
Lambda lambda x: x+1 Small, single-expression
“anonymous” function
Decorator @log_calls Modifies/extents function
behavior
Docstring """Return the sum of two Describes function purpose and
numbers.""" usage
Comment # This adds numbers In-line explanation for code

Expanded Practice Problems

Here are a few more beginner exercises to try:

a) Print all even numbers from 1 to N using a function.

def print_evens(N):

for i in range(1, N+1):

if i % 2 == 0:

print(i)

print_evens(10) # Output: 2 4 6 8 10

b) Write a function to check if a string is a palindrome.

def is_palindrome(s):

return s == s[::-1]

print(is_palindrome("madam")) # True

print(is_palindrome("school")) # False
c) Write a function to return the maximum of three numbers.

def maximum_of_three(a, b, c):

return max(a, b, c)

Concluding Advice and Common Pitfalls

 Indentation is not optional: Every code block inside a function must be

consistently indented (usually 4 spaces).

 Parameter order matters: Positional arguments must come before keyword

arguments, and you can’t pass a positional argument after a keyword argument.

 Avoid using mutable objects (lists, dicts) as default parameter values.

Use None instead.

 Don’t forget return: If you want the function to give back a value—use return.

 Practice, practice, practice: The best way to understand functions is to write

and call them often, experimenting with parameters, returns, and combining
them.

Final Words

Functions are the backbone of clean, manageable, and powerful Python code.
Learning to use them well will give you a strong foundation for success in exams and
in the real world of programming. Review this guide, practice the examples and
exercises, and soon, Python functions will feel familiar and natural.

Happy Coding!

References:
This comprehensive guide synthesizes and builds upon materials from W3Schools,
GeeksforGeeks, Programiz, RealPython, StackOverflow, Google Python Style Guide,
Python PEPs, DataCamp, and hands-on tutorials designed for O/L-level learners.
References (45)

1Python Functions (With Examples) - Programiz. [Link]

programming/function

2How to Define and Call a Function in Python - GeeksforGeeks.

[Link]

3Python Functions - W3Schools.

[Link]

4Keyword and Positional Argument in Python - GeeksforGeeks.

[Link]

5Positional argument vs keyword argument - Stack Overflow.

[Link]
argument

6Best Practices: Positional and Keyword Arguments in Python.

[Link]

7*args and **kwargs in Python - GeeksforGeeks.

[Link]

8Python args and kwargs: Demystified – Real Python. [Link]

kwargs-and-args/

9Python *args and **kwargs (With Examples) - Programiz.

[Link]

10The Python return Statement: Usage and Best Practices.

[Link]

11Python return statement - GeeksforGeeks.

[Link]

12What Is Python Return Statement?. [Link]

statement/

13Python Return Function [With Examples]. [Link]

function/

14Python Scope - W3Schools. [Link]

15Python Variable Scope (With Examples) - Programiz.

[Link]

16Global keyword in Python - GeeksforGeeks.

[Link]

17Python Lambda - W3Schools.

[Link]

18How to Use Python Lambda Functions – Real Python. [Link]

lambda/
19Python Lambda Functions - GeeksforGeeks.
[Link]
map-reduce/

20Python Lambda/ Function (With Examples) - Programiz.

[Link]

21Primer on Python Decorators – Real Python. [Link]

python-decorators/

22Python Decorators Introduction - Python Tutorial.

[Link]

23Python Decorators - W3Schools.

[Link]

24Decorators in Python - GeeksforGeeks.

[Link]

25PEP 257 – Docstring Conventions | [Link]. [Link]

0257/

26Python Docstrings - GeeksforGeeks. [Link]

docstrings/

27How to Write Docstrings in Python. [Link]

in-python/

28styleguide | Style guides for Google-originated open-source projects.

[Link]

29PEP 8 – Style Guide for Python Code | [Link]. [Link]

0008/

30How to Write Beautiful Python Code With PEP 8. [Link]

pep8/

31PEP-8: Python Naming Conventions & Code Standards | DataCamp.

[Link]

32Best Practices to Write Clean Python Code - GeeksforGeeks.

[Link]

33Python def Keyword - GeeksforGeeks.

[Link]

34Python Function Parameters and Arguments - GeeksforGeeks.

[Link]
python/

35Default arguments in Python - GeeksforGeeks.

[Link]

36Global and Local Variables in Python - GeeksforGeeks.

[Link]
37Recursion in Python - GeeksforGeeks.
[Link]

38Recursion in Python: An Introduction – Real Python. [Link]

recursion/

39Python Recursion (Recursive Function) - Programiz.

[Link]

40Python program to find the factorial of a number using recursion.

[Link]
number-using-recursion/

4110 Python Function Practice Exercises for Beginners.

[Link]

42Python Functions Exercise with Solution [10 Programs] - PYnative.

[Link]

43Python Arithmetic Operators - GeeksforGeeks.

[Link]

44Python functions - Exercises, Practice, Solution - w3resource.

[Link]

45Python Functions Quiz [15 Functions Quiz Questions] - PYnative.

[Link]
🌀 Phase 1 – Kick-Off (Oct 7 – Nov 7, 2025)

Goal: Build rhythm, no excuses.

 Morning (3:00–5:45 AM):

o Freshen up 30 min

o Maths/Science core study

o Meditation inside Brahma Muhurtha (4:20–4:30 AM)

o English/Sinhala writing

o Quick flashcards (History, Science, ICT, Civics)

 After school: 2 hrs study + workout

 Night: Past papers + memory recall

 Focus: Discipline, daily flow, no breaks.

🌀 Phase 2 – Power Vacation (Nov 8 – Dec 7, 2025)

Goal: Heavy knowledge input & memory building.

 Daily 8–9 hrs study (3 AM start).

 Brahma Muhurtha meditation (4:25–4:35 AM).

 Strong focus on Maths + Science + English in mornings.

 Afternoons → History, ICT, Civics, Buddhism.

 Evenings → Past papers.

 Workout: 30–45 mins daily.

 Sleep: 10 PM – 3 AM.

🌀 Phase 3 – 3rd Term Exam Prep (Dec 8 – Dec 31, 2025)

Goal: Exam simulation + stress training.

  Morning routine same (Brahma Muhurtha ~4:30–4:40 AM).

 Focus on exam-style practice (timed writing, problem solving).

 Do mock papers weekly.

 Use evenings for corrections & teacher feedback.

 Meditation keeps calmness before exams.

🌀 Phase 4 – O/L Final Build-Up (Jan 1 – Feb 16, 2026)

Goal: Long-term memory + exam fitness.

 Morning routine same (Brahma Muhurtha ~4:35–4:50 AM).

 January → Consolidation (review all 9 subjects, fill gaps).

 February → Final polishing, 1–2 papers daily.

 Focus on speed + accuracy + recall.

 Meditation daily to stay sharp & stress-free.

 Sleep must be fixed at 10 PM → 3 AM.

🌀 Phase 5 – Exam Execution (Feb 17 onward, O/L exams)

Goal: Stay calm, recall instantly, perform like a champion.

 Light review only in mornings (no new study).

 Brahma Muhurtha meditation = mind calm & sharp.

 Affirmations: “I am ready, I know everything, I will succeed.”

 Before each paper → 5 deep breaths, recall key points.

 Trust the system → 9A’s are yours.

 📅 October 2025 (Brahma Muhurtha: 4:20–5:10 AM)

 3:00–3:30 → Freshen up

 3:30–4:20 → Maths / Science

 4:20–4:30 → Meditation (Brahma Muhurtha)

 4:30–5:05 → English / Sinhala

 5:05–5:35 → Quick review / flashcards

 5:35–5:45 → Pack bag & mindset prep

📅 November 2025 (Brahma Muhurtha: 4:25–5:15 AM)

 3:00–3:30 → Freshen up

 3:30–4:25 → Maths / Science

 4:25–4:35 → Meditation (Brahma Muhurtha)

 4:35–5:05 → English / Sinhala

 5:05–5:35 → Quick review / flashcards

 5:35–5:45 → Pack bag & mindset prep

📅 December 2025 (Brahma Muhurtha: 4:30–5:20 AM)

 3:00–3:30 → Freshen up

 3:30–4:30 → Maths / Science

 4:30–4:40 → Meditation (Brahma Muhurtha)

 4:40–5:05 → English / Sinhala

 5:05–5:35 → Quick review / flashcards

 5:35–5:45 → Pack bag & mindset prep

📅 January 2026 (Brahma Muhurtha: 4:35–5:25 AM)

 3:00–3:30 → Freshen up

 3:30–4:35 → Maths / Science

 4:35–4:45 → Meditation (Brahma Muhurtha)

 4:45–5:10 → English / Sinhala

 5:10–5:35 → Quick review / flashcards

 5:35–5:45 → Pack bag & mindset prep

📅 February 2026 (Brahma Muhurtha: 4:40–5:30 AM)

 3:00–3:30 → Freshen up

 3:30–4:40 → Maths / Science

 4:40–4:50 → Meditation (Brahma Muhurtha)

 4:50–5:15 → English / Sinhala

 5:15–5:35 → Quick review / flashcards

 5:35–5:45 → Pack bag & mindset prep

🧠 Memory Training System (Daily Cycle)

1. Encoding (learn actively) – Morning sessions (Maths/Science).

2. Reinforcement (review) – Same night 15–30 mins.

3. Consolidation (spaced repetition) – Review after 3, 7, 30 days.

4. Integration (exam practice) – Past papers weekly.

5. Teaching – Explain aloud to yourself.

🏋️Body + Mind

 Workout: 30–45 mins, 5 days a week (after school or afternoon).

 Meditation: 10 mins daily in Brahma Muhurtha.

 Sleep: 10 PM – 3 AM (non-negotiable).

⚡ Tools You Need

✅ Printed wall timetable (school-day + vacation-day + month-based Brahma

Muhurtha)
✅ Flashcards (Science formulas, History dates, ICT definitions)
✅ Past papers (timed practice)
✅ Affirmations (stick on wall: “Discipline > Excuses”)
✅ Pen + rough book for active recall

🧠 How to Make Study Memory Last Longer

🔹 Modern Science Methods

1. Active Recall (Test Yourself)

o Don’t just read → close the book and try to recall it.
 o Example: After studying Science, ask yourself “What are the 5 parts of the
digestive system?”

2. Spaced Repetition

o Review the same content at intervals:

 1st review → next day

 2nd review → after 3 days

 3rd review → after 7 days

 4th review → after 30 days

3. Pomodoro Focus

o Study in 25–45 min chunks + 5–10 min breaks.

o Breaks refresh the brain → better long-term storage.

4. Interleaving (Mix Subjects)

o Instead of 3 hours of only Maths, do 1 hr Maths + 1 hr Science + 1 hr

English.

o Brain learns better when switching topics.

🔹 Ancient & Traditional Methods

1. Visualization (Memory Palaces)

o Imagine your house. Put “Maths formulas” in your bedroom, “Science

terms” in the kitchen, etc.

o When recalling, walk through your house in your mind.

2. Chanting / Reciting Out Loud

o Old monks and scholars repeated important texts out loud.

o Works especially for Sinhala, Buddhism, History.

3. Writing & Rewriting

o Copying notes by hand makes memory deeper (not typing).

o Ancient scholars always wrote repeatedly on palm leaves.

4. Physical Anchoring

o Link movement with memory (e.g., while walking, recite).

o This locks memory in body + mind.

🔹 Lifestyle Memory Boost

 Sleep at least 5–6 hrs solid (your brain stores memory during sleep).
  Workout → better blood flow = sharper memory.

 Omega-3 foods (fish, nuts, eggs) help neurons grow stronger.

⚡ If you combine these, your memory won’t just last for “a few hours” → it will stay for
weeks and months until exam day.