Functions – NCERT Class 11 Computer Science Chapter 7 – Defining, Calling, and Understanding Functions in Python

Introduces the concept of functions as modular blocks of code that perform specified tasks. Covers function definition, function calling, parameters, return statements, and the advantages of using functions like code reusability and improved readability. Explains built-in functions and user-defined functions with examples in Python programming.

Updated: just now

Categories: NCERT, Class XI, Computer Science, Python, Functions, Modular Programming, Chapter 7

Tags: Functions, Python Functions, Function Definition, Function Call, Parameters, Return Statement, Built-in Functions, User-defined Functions, Modularity, Code Reusability, NCERT Class 11, Computer Science, Chapter 7

Functions: NCERT Class 11 Chapter 7 - Enhanced Study Guide, Precise Notes, Diagrams & Quiz 2025

Enhanced Full Chapter Summary & Precise Notes from NCERT PDF (32 Pages)

Overview & Key Concepts

Exact Definition: "Function can be defined as a named group of instructions that accomplish a specific task when it is invoked."

Introduction: Modular programming for complex problems (tent example: Programs 7-1 without functions vs 7-2 with); Benefits: Readability, reusability. Quote: R. Tarjan on algorithms.
Chapter Structure: Functions intro/advantages, User-defined (syntax/examples), Arguments/parameters, Scope, Python Standard Library.
2025 Relevance: Functions in ML pipelines (e.g., scikit-learn); Modular code in microservices; Reusability for APIs.

7.1 Introduction

Precise: As programs grow bulky, modular approach divides into blocks (Fig 7.2). Tent: Accept inputs, calc areas/cost/tax (Prog 7-1 vs 7-2).

7.2 Functions

Precise: Named instructions for tasks; Invoked by name; Reusable. Expanded: Achieves modularity; Prog 7-2 reuses con(l,r) for new tents.

Precise Fig 7.2: Modular Calculation (SVG)

7.2.1 Advantages

Precise: Readability, reduces length/debugging, reusability, team division. Expanded: Reuse post_tax_price(18%) across services.

7.3 User Defined Functions

Precise: Custom def for tasks; Syntax: def func([params]): body [return]. Expanded: Optional params/return; Call by name().

Program 7-3: addnum() Example

# Program 7-3
def addnum():
    fnum = int(input("Enter first number: "))
    snum = int(input("Enter second number: "))
    sum = fnum + snum
    print("The sum of ",fnum,"and ",snum,"is ",sum)
addnum()

Output: Enter first number: 5
Enter second number: 6
The sum of 5 and 6 is 11

7.3.2 Arguments and Parameters

Precise: Args passed to params; Same value/ID initially (Fig 7.3); Changes may reassign (Prog 7-5). Strings as params (Prog 7-8).

Precise Fig 7.3: Argument/Parameter Binding (SVG)

Program 7-4: sumSquares(n)

# Program 7-4
def sumSquares(n):
     sum = 0
     for i in range(1,n+1): 
          sum = sum + i
     print("The sum of first",n,"natural numbers is: ",sum)
num = int(input("Enter the value for n: "))
sumSquares(num)

Output (n=5): The sum of first 5 natural numbers is: 15

Scope of Variables

Precise: Local (inside func), Global (outside); Use global keyword. Expanded: Avoid name clashes.

7.5 Python Standard Library

Precise: Pre-built functions (e.g., math.sqrt); Import modules. Expanded: math, random for reusability.

Enhanced Features (2025)

Full PDF integration, expanded programs (7-1 to 7-8), SVGs (Figs 7.1-7.4), detailed tables/examples, 30 Q&A updated, 10-Q quiz. Focus: Modular Python coding.

Exam Tips

Write functions (area/sum/factorial); Explain args/params with ID; Advantages list; Syntax diagram; Scope examples; Standard lib import.

30 Questions & Answers - NCERT Precise (Updated with Full Chapter)

Expanded: 10 (1-mark), 10 (4-marks), 10 (8-marks) based on full chapter; Mark-based with precise lines.

1-Mark Questions (10 Questions, One-Line Answers)

Q1: What is a function?

Ans: Named group of instructions for a task.

Q2: Keyword to define function?

Ans: def.

Q3: Modular programming means?

Ans: Dividing into independent blocks.

Q4: Parameter in def header?

Ans: Receives argument.

Q5: Advantage of functions?

Ans: Reusability.

Q6: Local scope?

Ans: Inside function.

Q7: Standard library example?

Ans: math module.

Q8: Argument passed how?

Ans: At function call.

Q9: Return statement?

Ans: Optional, sends value back.

Q10: Function call syntax?

Ans: name(args).

4-Mark Questions (10 Questions, Five-Line Answers)

Q11: List advantages of functions.

Ans: Increases readability; Reduces code/debugging; Reusability across funcs/programs; Enables team parallel work. Key for modular code. 2025: Essential for scalable apps.

Q12: Explain UDF syntax.

Ans: def name([params]): indented body; return optional. Header ends :; Name unique. E.g., def add(a,b): return a+b. Call: add(2,3).

Q13: Differentiate arg/parameter.

Ans: Arg: Value at call; Param: Variable in header. Bind same ID initially (Fig 7.3). Change may reassign (Prog 7-5). For passing data.

Q14: Scope of variables.

Ans: Local: Func only; Global: Whole module. Use global to access/modify global in func. Prevents clashes.

Q15: How to call function?

Ans: Write name() with args if needed. Control transfers; Executes body; Returns if specified. E.g., cyl(h,r) in Prog 7-2.

Q16: Purpose of return.

Ans: Sends value back to caller; Optional (void func prints). E.g., return area_cyl in cyl(). Enables chaining.

Q17: String as parameters.

Ans: Pass strings to params; Concat with +. Prog 7-8: first + " " + last. For text processing.

Q18: Modular programming benefit.

Ans: Divides complex into sub-problems; Easier manage (Fig 7.2). From bulky (7-1) to organized (7-2).

Q19: Example of reusability.

Ans: con(l,r) for conical in new tents; post_tax_price for services. Avoid rewrite.

Q20: Standard library use.

Ans: Pre-built funcs; Import e.g., import math. Reuses without def; E.g., math.pi.

8-Mark Questions (10 Questions, Ten-Line Answers)

Q21: Explain introduction with tent example.

Ans: Complex programs bulky; Modular: Divide blocks (Fig 7.1-7.2). Prog 7-1: Inline calc; 7-2: Funcs cyl/con/post_tax. Inputs: h,r,l; Areas: 2πrh + πrl; Cost: unit*area; Net: +18% tax. Tarjan quote. 2025: Modularity in devops.

Q22: Describe functions and advantages.

Ans: Named reusable code; Invoke by name. Adv: Organized/readable; Short/debug easy; Reusable (call multiple); Team divide. E.g., Reuse for rectangular tents. Essential for large code.

Q23: Detail UDF creation with examples.

Ans: Syntax: def... (Prog 7-3 no params). Examples: 7-4 sum natural (param n); 7-6 myMean(list); 7-7 factorial (range loop). Call transfers control; Indentation key.

Q24: Discuss args/parameters with ID.

Ans: Pass at call; Receive in header (Fig 7.3). Same ID init (Prog 7-5: 1712903328); Reassign on op (new ID). Strings: Concat (7-8). Binding like pass-by-object-ref.

Q25: Explain scope with example.

Ans: Local: Func vars; Global: Outside. global x to modify global. Example: def f(): x=5 (local); x=10 outside (global). Clashes avoided; nonlocal for nested.

Q26: Programs for numeric/string funcs.

Ans: Numeric: 7-5 incrValue (ID change); 7-7 fact (loop). String: 7-8 full name (+ space). Outputs: 13 new ID; Hello Gyan Vardhan. Reusable blocks.

Q27: Advantages in team/program dev.

Ans: Parallel: One func per member. Reusability: Build on existing. Less rep: No copy-paste. Debug: Isolate issues. 2025: CI/CD with modular tests.

Q28: Standard library vs UDF.

Ans: Std: Pre-built (import math); UDF: Custom def. Use std for common (sqrt); UDF for specific (tent area). Both reusable; Std saves time.

Q29: How functions achieve modularity?

Ans: Independent blocks/sub-problems. Tent: Separate cyl/con/tax funcs. Easier manage/complex. From inline (7-1) to modular (7-2). Scalable design.

Q30: Apply chapter to real program.

Ans: Tent calc: Inputs funcs, area funcs, cost/tax funcs. Reusable for variants. Scope: Local vars. Std: Use pi from math. Builds efficient code. 2025: Funcs in serverless.

Tip: Include programs/ID examples; Practice def/call.

Concept	Precise Description	Example	Process/2025 Note
Function	Named task group	def cyl(h,r): return 23.14r*h	Invoke by name
UDF	Custom def	Prog 7-3 addnum()	Syntax with :
Args/Params	Pass/receive	sumSquares(5)	ID binding
Advantages	Read/Reuse	Modular tent calc	Team dev
Scope	Local/Global	global x in func	No clashes
Std Lib	Pre-built	import math	Reusability
Modular	Sub-blocks	Fig 7.2 flow	Complex mgmt

This article has been published in CBSE Class 11 Annual Assessment. Explore everything related to it here.

Group Discussions

No forum posts available.

Easily Share with Your Tribe

Functions – NCERT Class 11 Computer Science Chapter 7 – Defining, Calling, and Understanding Functions in Python

Functions

Enhanced Full Chapter Summary & Precise Notes from NCERT PDF (32 Pages)

Overview & Key Concepts

7.1 Introduction

7.2 Functions

Precise Fig 7.2: Modular Calculation (SVG)

7.2.1 Advantages

7.3 User Defined Functions

Program 7-3: addnum() Example

7.3.2 Arguments and Parameters

Precise Fig 7.3: Argument/Parameter Binding (SVG)

Program 7-4: sumSquares(n)

Scope of Variables

7.5 Python Standard Library

Enhanced Features (2025)

Exam Tips

User Defined Functions - Syntax & Examples Expanded

7.3.1 Creating UDF (Detailed)

UDF Syntax (SVG)

Examples:

Program 7-7: calcFact(num)

Arguments & Parameters - Binding & ID Changes Expanded

7.3.2 Args/Params (Detailed)

Fig 7.4: ID Before/After Increment (SVG)

Program 7-8: Full Name Concat

Advantages of Functions & Scope - Expanded

7.2.1 Advantages (Detailed)

Scope (Detailed)

Scope Diagram (SVG)

Python Standard Library - Modules & Reusability

7.5 Standard Library (Detailed)