Functions Class 11 Computer Science Chapter 7 CBSE Notes 2025-26

Functions are an important concept in Python programming, helping you write simple, organized, and reusable code. When problems get complicated, a program can become lengthy and difficult to manage. To avoid this, complex problems are divided into smaller parts called functions. Each function carries out a specific task, making the code cleaner and easier to debug. In modular programming, functions are reused and managed easily, perfect for large programs.

A function is a named group of instructions that carries out a particular job. Once a function is defined, it can be used multiple times without rewriting the code every time. This saves effort and reduces errors. Functions improve readability by allowing you to focus on one task at a time, instead of juggling lines of code for many processes at once.

Functions make your code shorter and easier to test. For example, if a company needs to calculate the cost of different types of tents, many calculations will repeat for every type. Using functions avoids repeating the same formula everywhere, allowing you to reuse code and quickly make changes in just one place. Functions also let team members work independently on different parts of a larger project.

• Shorter, more readable code
• Easy code reuse—no need to rewrite formulas
• Debugging is easier—changes made once update everywhere the function is used
• Multiple people can work independently on different functions

A user-defined function in Python is created with the def keyword, followed by the function name and a set of parentheses. The parentheses may contain parameters—inputs required for the task. For example:

def greet():
    print("Hello!")

To use the function, call it by writing its name followed by parentheses, like greet(). You can also create functions that take inputs, called parameters, to work with different values.

Arguments are values you send into a function, while parameters are the variables that receive those values in the function's header. For example, in addnum(a, b), "a" and "b" are parameters, and when calling addnum(5, 6), 5 and 6 are arguments. Both refer to the same value inside the function during that call.

It’s possible for functions to accept different kinds of inputs, including numbers, strings, or lists. You can even set default parameter values so that if an argument is not provided, the function uses the default.

Functions can return values back to the part of the program that called them. To return a value, the return keyword is used. For example, a function that calculates the square of a number might return the answer, which can then be assigned to a variable or printed. If you want to return more than one value, return them as a tuple, like return (area, perimeter) in a rectangle-calculating function. If there is no return statement, the function gives back "None" by default.

The Python interpreter reads your code from top to bottom. Function definitions are not executed unless the function is called. Always define a function before calling it in your program, or Python will show an error saying it doesn't recognize the function name. Once a function is called, control jumps to that function, executes its code, and then returns to where it left off to resume the rest of the program.

Variables inside a function exist only while the function runs. These local variables cannot be accessed outside the function. Variables defined outside any function are global and can be used in any function throughout the code. If a local variable shares its name with a global one, the local takes priority in that function. To change the value of a global variable from inside a function, use the global keyword.

• Global variable: Defined outside all functions; can be used everywhere
• Local variable: Defined inside a function; exists only in that function

Python provides many built-in functions that save programmers time, such as print(), len(), pow(), and many more. These are functions already written, tested, and stored in Python’s standard library. Here are some examples:

You can use these functions directly without importing anything.

In addition to built-in functions, Python has modules that are collections of related functions. Popular modules are math, random, and statistics. Import a module with import math, then use its functions, like math.sqrt(9) for square root, or random.randint(1,10) for a random number between 1 and 10. To avoid loading an entire module, use from math import sqrt to bring in only the parts you need.

• math: Functions like ceil(), floor(), pow(), sqrt()
• random: Functions for randomization like random(), randint(), randrange()
• statistics: Statistical operations like mean(), median(), mode()

Functions can have default parameter values, making some arguments optional when calling the function. For example, def greet(name="student"): will use "student" if no name is given while calling. Always put default-valued parameters at the end of the parameter list.

For documentation, multi-line comments called docstrings are inserted at the start of functions or modules using triple double quotes ("""). They help describe what the code does. You can display a module’s docstring with print(module.__doc__).

The chapter includes many useful examples and exercises, such as writing functions to add numbers, calculate areas, compute factorials, and more. There's practice in identifying program errors, understanding the difference between arguments and parameters, and experimenting with variable scope. Working with user-defined functions, built-in functions, and modules is essential for mastering Python's approach to structured and efficient programming.

Class 11 Computer Science Chapter 7 Notes – Functions: Key Revision Points

These CBSE Class 11 Computer Science Chapter 7 Functions notes explain how to use and create functions in Python. Learn about arguments, parameters, scope of variables, and the importance of the standard library—all in simple language for quick revision.

Using these revision notes, you'll understand core programming concepts like modular coding and reusability. Grasp the difference between local and global variables, master user-defined functions, and become confident with both built-in and custom functions for exam success.