Samacheer Kalvi Class 12 Computer Science Solutions Chapter 3 Scoping

I. Choose The Best Answer (I Marks)

 

Question 1. Which of the following refers to the visibility of variables in one part of a program to another part of the same program.
(a) Scope
(b) Memory
(c) Address
(d) Accessibility
Answer: (a) Scope
In simple words: Scope is like a boundary that controls where a variable can be seen and used within a program. It decides which parts of the code can 'see' and 'talk to' a specific variable.

🎯 Exam Tip: Remember that scope helps manage variables to prevent unexpected behavior and improve code readability, making it a key concept in programming.

 

Question 2. The process of binding a variable name with an object is called
(a) Scope
(b) Mapping
(c) late binding
(d) early binding
Answer: (b) Mapping
In simple words: Mapping is like giving a label (variable name) to a box (object) in your computer's memory. This way, when you use the label, the computer knows which box you are talking about.

🎯 Exam Tip: Understand that mapping links a variable name to its actual data in memory, allowing you to access and manipulate that data using the variable's name.

 

Question 3. Which of the following is used in programming languages to map the variable and object?
(a) :
(b) :=
(c) =
(d) ==
Answer: (c) =
In simple words: In most programming languages, the single equals sign \( = \) is used to assign a value to a variable, which means connecting the variable name to an object. It performs an assignment operation.

🎯 Exam Tip: Be careful not to confuse \( = \) (assignment operator) with \( == \) (comparison operator) in programming, as they have very different functions.

 

Question 4. Containers for mapping names of variables to objects is called
(a) Scope
(b) Memory
(c) Binding
(d) Name spaces
Answer: (d) Name spaces
In simple words: Namespaces are like special boxes that hold variable names and their corresponding values, keeping them organized. They help prevent different parts of a program from using the same name for different things.

🎯 Exam Tip: Namespaces are crucial for managing identifiers in larger programs, ensuring that names are unique within their context and avoiding conflicts.

 

Question 5. Which scope refers to variables defined in current function?
(a) Local Scope
(b) Global scope
(c) Module scope
(d) Function Scope
Answer: (a) Local Scope
In simple words: Local scope means a variable can only be seen and used inside the specific function where it was created. It's like a secret only that function knows.

🎯 Exam Tip: Variables with local scope are temporary and are created when the function runs, then destroyed when the function finishes, saving memory.

 

Question 6. The process of subdividing a computer program into separate sub-programs is called
(a) Procedural Programming
(b) Modular programming
(c) Event Driven Programming
(d) Object oriented Programming
Answer: (b) Modular programming
In simple words: Modular programming is like breaking a big problem into smaller, easier-to-solve mini-problems. Each mini-problem becomes a separate "module" or piece of code, making the whole program simpler to build and fix.

🎯 Exam Tip: Modular programming improves organization, reusability, and makes debugging much easier because you can test each part separately.

 

Question 7. Which of the following security technique that regulates who can use resources in a computing environment?
(a) Password
(b) Authentication
(c) Access control
(d) Certification
Answer: (c) Access control
In simple words: Access control is a security method that checks who is allowed to use certain computer resources. It makes sure only authorized people can open files or run programs.

🎯 Exam Tip: Access control is fundamental for protecting sensitive data by limiting user permissions based on their identity and role.

 

Question 8. Which of the following members of a class can be handled only from within the class?
(a) Public members
(b) Protected members
(c) Secured members
(d) Private members
Answer: (d) Private members
In simple words: Private members are like secrets of a class that only the class itself can see and change. Other parts of the program cannot directly use or modify them.

🎯 Exam Tip: Using private members helps encapsulate data, meaning the internal workings of a class are hidden, which protects data integrity and simplifies code maintenance.

 

Question 9. Which members are accessible from outside the class?
(a) Public members
(b) Protected members
(c) Secured members
(d) Private members
Answer: (a) Public members
In simple words: Public members are like things in a class that everyone can see and use from outside. They are designed to be easily accessible to other parts of the program.

🎯 Exam Tip: Public members provide the interface for other classes to interact with the object, acting as the 'face' of the class to the outside world.

 

Question 10. The members that are accessible from within the class and are also available to its sub-classes.
(a) Public members
(b) Protected members
(c) Secured members
(d) Private members
Answer: (b) Protected members
In simple words: Protected members are like family secrets. They can be seen and used by the class itself and by any classes that inherit from it, but not by unrelated parts of the program.

🎯 Exam Tip: Protected members are key in inheritance, allowing child classes to access parent functionality while still maintaining a degree of encapsulation from external access.

II. Answer The Following Questions (2 Marks)

 

Question 1. What is a scope?
Answer: Scope refers to the visibility of variables, parameters, and functions within a program. It defines which parts of the code can access or modify these elements. The scope ensures that names are unique and do not clash in different sections of a program.

🎯 Exam Tip: When defining scope, clearly state that it determines where an identifier (variable, function) can be accessed and that it helps manage naming conflicts.

 

Question 2. Why scope should be used for variables. State the reason.
Answer:
Using scope for variables is important for several reasons:
- It limits a variable's visibility and lifetime, preventing it from being accessed or changed unintentionally by other parts of the program.
- This ensures that changes inside a function do not affect variables outside it in unexpected ways, making code more predictable and easier to debug.
- By restricting access, scope also helps prevent naming conflicts when multiple programmers work on different parts of the same large program.
In simple words: Scope helps keep variables organized and private within their own parts of the program. This stops different parts of the code from accidentally changing each other's variables, making the program more reliable.

🎯 Exam Tip: Focus on 'avoiding conflicts', 'managing visibility', and 'preventing unintended side effects' as key reasons for using scope.

 

Question 3. What is Mapping?
Answer: Mapping is the process of linking a variable name with an object in a program. In languages like Python, the equals sign \( = \) is used for this mapping, connecting the variable name to its corresponding value or data in memory. This allows the program to refer to the object using its assigned variable name.
In simple words: Mapping is like giving a unique name (variable) to a piece of information (object) in your computer's memory. So, when you use that name, the computer knows exactly which information you want to use.

🎯 Exam Tip: Explain mapping as the association of a variable name to a memory location containing an object, highlighting the role of the assignment operator.

 

Question 4. What do you mean by Namespaces?
Answer: Namespaces are containers that store the names of variables and their corresponding objects, creating a structured way to manage identifiers. They help organize code by allowing the same name to be used for different variables or functions in different parts of a program without causing conflicts. This isolation ensures that each name has a clear and distinct meaning within its specific namespace.
In simple words: Namespaces are like special sections or boxes in a program that hold names of variables and other things. They stop names from getting mixed up, so you can have two different "apple" names in two different boxes without confusion.

🎯 Exam Tip: Emphasize that namespaces prevent naming collisions in larger codebases and provide a logical grouping for related identifiers.

 

Question 5. How Python represents the private and protected Access specifiers?
Answer: In Python, access specifiers like private and protected are not enforced as strictly as in languages like C++ or Java. Instead, Python uses a naming convention:
- **Private members:** Are typically denoted by prefixing the variable or method name with a double underscore (e.g., \( \_\_private\_variable \)). This triggers a process called "name mangling," making it harder but not impossible to access them from outside the class.
- **Protected members:** Are typically indicated by prefixing the name with a single underscore (e.g., \( \_protected\_variable \)). This is a convention to signal that the member should be treated as protected, but Python does not strictly prevent outside access.
In contrast, C++ and Java use keywords like `private` and `protected` to strictly control access to class members. Python relies more on convention and programmer discipline for these access specifiers.
In simple words: Python doesn't have strict 'private' or 'protected' keywords like some other languages. Instead, it uses special naming rules with underscores (\( \_ \) or \( \_\_ \)) to show that a variable or function is meant to be used only inside its class or by its family.

🎯 Exam Tip: Highlight that Python uses naming conventions (\( \_ \) for protected, \( \_\_ \) for private) rather than strict access keywords to indicate intended visibility.

III. Answer The Following Questions (3 Marks)

 

Question 1. Define Local scope with an example.
Answer:**Local Scope:** Local scope refers to the region where a variable is defined and accessible only within the current function or block of code. Variables declared in a local scope are temporary; they are created when the function starts and destroyed when the function finishes. When a function needs to find a variable, it first looks in its local scope. If it doesn't find the variable there, it then checks broader scopes.
**Example:**

In the example above, the variable `a` is defined inside the `Disp()` function with the value 7. When `print a` is executed within `Disp()`, it accesses this local `a`. When `Disp()` is called, it prints the value 7, showing that `a` is only visible and available within that function's local scope.
In simple words: Local scope means a variable can only be used inside the function where it was created. It's like a secret word only that function understands. In the example, the variable 'a' is only known inside the 'Disp()' function, so when we ask to print 'a', it shows the value that was set inside that function.

🎯 Exam Tip: When explaining local scope, provide a simple function example where a variable is defined and used only within that function to clearly demonstrate its limited visibility.

 

Question 2. Define Global scope with an example.
Answer:**Global Scope:** A global variable is one that is declared outside of all functions in a program. This means it has a global scope, making it accessible from anywhere within the program—both inside and outside any functions. Global variables are often used for data that needs to be shared across many different parts of a program.
**Example:**

In this example, `a:=10` is a global variable. When `Disp()` is called, it defines a local `a:=7` and prints 7. After `Disp()` finishes, the program prints the global `a`, which is still 10. This shows how local changes do not affect global variables unless explicitly specified.
In simple words: Global scope means a variable can be used anywhere in the whole program, like a general announcement everyone can hear. In the example, 'a' is set to 10 for everyone. Inside the 'Disp()' function, 'a' is temporarily changed to 7, but outside the function, it's still 10 for everyone else.

🎯 Exam Tip: Emphasize that global variables are declared outside all functions and are accessible everywhere, but modifying them inside functions requires specific commands (e.g., `global` keyword in Python).

 

Question 3. Define Enclosed scope with an example.
Answer:**Enclosed Scope:** Enclosed scope (also known as Nonlocal scope) refers to the scope of variables defined in an outer function that contains another inner function. The inner function can access the variables of its enclosing outer function, even if those variables are not global. This concept is fundamental to nested functions, where the inner function "remembers" the environment of its creator.
**Example:**

In this example, `a:=10` is defined within `Disp()`, making it part of `Disp()`'s enclosed scope. The `Disp1()` function is nested inside `Disp()`. `Disp1()` can access and print the `a` from `Disp()`'s scope, resulting in `10` being printed twice. This demonstrates that nested functions can use variables from their outer, enclosing functions.
In simple words: Enclosed scope is when an inner function can see and use variables from the function it is inside of. It's like a nested box where the smaller box can see what's in the bigger box it lives in. In the example, the `Disp1()` function can use the 'a' that was set in the `Disp()` function because `Disp1()` is inside `Disp()`.

🎯 Exam Tip: When illustrating enclosed scope, ensure your example clearly shows a nested function accessing a variable from its immediate outer function, not a global one.

 

Question 4. Why access control is required?
Answer: Access control is a security technique crucial for regulating who or what can view or use resources in a computing environment. It is needed because:
- **Data Security:** It restricts access to sensitive data, ensuring that only authorized users or parts of a program can interact with specific resources, thereby preventing unauthorized modifications or disclosure.
- **Minimizing Risk:** It's a fundamental concept in security that minimizes the risk of system compromise or data corruption by preventing malicious or accidental misuse of resources.
- **Data Integrity:** In object-oriented programming, access control (via access modifiers like public, private, protected) protects the internal state of objects, maintaining data integrity by preventing external code from directly manipulating critical data.
- **Encapsulation:** It supports encapsulation, allowing objects to hide their internal details and expose only necessary functionalities, simplifying code and making it more robust.
In simple words: Access control is needed to keep information safe and control who can use it. It stops people or programs from seeing or changing things they shouldn't, which protects important data and makes sure everything works correctly.

🎯 Exam Tip: Focus on the keywords 'security,' 'data integrity,' 'prevention of unauthorized access,' and 'encapsulation' when explaining the importance of access control.

 

Question 5. Identify the scope of the variables in the following pseudo-code and write its output
color:= Red
mycolor():
b:=Blue
myfavcolor():
g:=Green
printcolor, b, g
myfavcolor()
printcolor, b
mycolor()
print color
Answer:**Scopes:** - `g` - Local scope (defined inside `myfavcolor()`) - `b` - Enclosed scope (defined inside `mycolor()`, accessible to `myfavcolor()`) - `color` - Global scope (defined outside any function)
**Output:**
Red Blue Green
Red Blue
Red
In simple words: The variable 'g' can only be seen inside 'myfavcolor'. The variable 'b' can be seen inside 'mycolor' and 'myfavcolor'. The variable 'color' can be seen everywhere. The program will print the color 'Red', then 'Blue', then 'Green', then 'Red', then 'Blue' again, and finally 'Red' one more time.

🎯 Exam Tip: Trace the execution line by line, paying close attention to which variable definition (local, enclosed, or global) is active at each `print` statement.

IV. Answer The Following Questions (5 Marks)

 

Question 1. Explain the types of scopes for variable or LEGB rule with example.
Answer: The LEGB rule describes the order in which Python (and similar languages) searches for a variable's definition. It stands for Local, Enclosed, Global, and Built-in scopes. This hierarchy helps determine the visibility and lifetime of variables.
**1. Local Scope (L):** This refers to variables defined inside the current function. They are accessible only within that function and cease to exist once the function completes execution.
**Example:**

On execution, the variable `a` inside `Disp()` prints 7 because it's locally defined and available only within that scope.
**2. Global Scope (G):** A variable declared outside all functions in a program has a global scope. It can be accessed from any part of the program, both inside and outside functions.
**Example:**
Here, the global `a` is 10. `Disp()` creates a local `a` as 7. So, the first print shows 7, and the second print (outside the function) shows the global `a` as 10.
**3. Enclosed Scope (E):** This applies to variables defined in an outer function that encloses an inner (nested) function. The inner function can access these variables from its surrounding function's scope.
**Example:**
The variable `a` defined in `Disp()` (outer function) is accessible to `Disp1()` (inner function), leading to both prints showing 10.
**4. Built-in Scope (B):** This includes all the names pre-loaded into the program scope when the interpreter starts. These are built-in functions (like `print()`, `len()`) and built-in modules.
**Example:**
These functions are always available without needing to be imported or defined by the user. For instance, you can use `print()` in any part of your code because it's part of the built-in scope.
**LEGB Rule Summary:**
The interpreter searches for variables in this order: Local, then Enclosed, then Global, and finally Built-in. The first match found is used.
**Example for LEGB Rule:**
1. x:= 'outer x variable'
2. display ():
3. x:= 'inner x variable'
4. print x
5. display()
**Output:**
outer x variable
inner x variable
In this example: - When `print x` is called outside `display()`, it prints 'outer x variable' from the global scope. - When `display()` is called, it defines a local `x` as 'inner x variable' and prints that. This shows how the scope rule decides which `x` variable is used at different points in the program.
In simple words: The LEGB rule tells a computer where to look for a variable's name, starting from inside the current function (Local), then moving out to the function it's inside (Enclosed), then to the whole program (Global), and finally checking if it's a built-in word (Built-in). It finds the first matching name and uses it. The examples show how a variable 'a' or 'x' can mean different things depending on where you use it in the code.

🎯 Exam Tip: Clearly define each scope level (Local, Enclosed, Global, Built-in) and provide a concise example for each. Remember to explicitly state the search order (LEGB) as this is crucial for the rule.

 

Question 2. Write any Five Characteristics of Modules.
Answer: Here are five key characteristics of modules:
1. **Contain Instructions and Data:** Modules are self-contained units that bundle instructions, processing logic, and data together. They encapsulate related code and information.
2. **Separately Compilable:** Modules can often be compiled independently and stored in libraries. This allows them to be reused in various programs without recompiling the entire application.
3. **Reusable:** A significant advantage of modules is their reusability. A well-designed module can be included in multiple programs, reducing redundant code and development time.
4. **Invoked by Name:** Module segments (functions or classes within a module) can be used by simply invoking their name along with any necessary parameters, making interaction straightforward.
5. **Controlled Scoping:** Modules provide a clear boundary for variable scope. The variables defined within a module are generally local to it, preventing naming conflicts with other modules or parts of the program. This enhances code isolation and readability.
In simple words: Modules are like small, independent parts of a big program. They hold instructions and data, can be built separately, and can be used again and again in different programs. You can use their parts by calling their names, and they help keep variables tidy by having their own separate areas.

🎯 Exam Tip: When listing module characteristics, focus on 'reusability,' 'organization,' 'independent compilation,' 'encapsulation of logic/data,' and 'scope management' as primary benefits.

12th Computer Science Guide Scoping Additional Questions And Answers

 

Question 1. Names paces are compared with ................
(a) Programs
(b) Dictionaries
(c) Books
(d) Notebooks
Answer: (b) Dictionaries
In simple words: Namespaces act like dictionaries by storing names (keys) and their corresponding objects (values) to keep them organized. This helps prevent names from clashing in a program.

🎯 Exam Tip: Remember that namespaces help manage names in programming, much like a dictionary organizes words and their meanings.

 

Question 2. The scope of a ................ is that part of the code where it is visible
(a) Variable
(b) Keyword
(c) Function
(d) Operator
Answer: (a) Variable
In simple words: A variable's scope determines where in a program that variable can be seen and used. Think of it as the area where a variable is 'known'.

🎯 Exam Tip: Understanding variable scope is crucial because it controls how different parts of your program can access and modify data.

 

Question 3. Find the value of a.
1. a: = 5
2. b: = a
3. a: = 3
(a) 0
(b) 3
(c) 5
(d) 2
Answer: (b) 3
In simple words: First, 'a' is set to 5. Then, 'b' gets the value of 'a', so 'b' becomes 5. Finally, 'a' is changed to 3. The last value assigned to 'a' is 3, which is its current value.

🎯 Exam Tip: Always remember that a variable holds its most recently assigned value. When a variable is assigned a new value, the old value is overwritten.

 

Question 4. The inner function can access the variable of the outer function. This is called ................ scope.
(a) Local
(b) Enclosed
(c) Function
(d) Global
Answer: (b) Enclosed
In simple words: When a function is placed inside another function, the inner function can 'see' and use variables from the outer function. This special visibility is called enclosed scope.

🎯 Exam Tip: Enclosed scope allows for private variables within a function that can still be accessed by its nested functions, promoting better data control.

 

Question 5. The duration for which a variable is alive is called its ................
(a) Scale
(b) Life time
(c) Static
(d) Function
Answer: (b) Lifetime
In simple words: A variable's lifetime is how long it exists and can be used in a program. Once its lifetime ends, the variable is removed from memory.

🎯 Exam Tip: Understanding a variable's lifetime helps prevent errors where you try to use a variable that no longer exists, leading to more stable programs.

 

Question 6. In Object Oriented Programming Language Access control is implemented through
(a) Access modules
(b) Access modifiers
(c) Access variables
(d) Keywords
Answer: (b) Access modifiers
In simple words: Access modifiers are special keywords in object-oriented programming that decide who can use or change parts of a class, like its variables or functions. They help keep data safe.

🎯 Exam Tip: Always remember that access modifiers (like public, private, protected) are key to data encapsulation and securing data within objects.

 

Question 7. ................ is a selective restriction of access to data in a program?
(a) Control variable
(b) Access control
(c) System authentication
(d) Module
Answer: (b) Access control
In simple words: Access control is like a gatekeeper that decides which parts of a program can see or change specific data. It helps protect important information.

🎯 Exam Tip: Access control is a fundamental security technique, ensuring only authorized parts of a system can interact with sensitive resources.

 

Question 8. How many types of variable scopes are there?
(a) 1
(b) 2
(c) 3
(d) 4
Answer: (d) 4
In simple words: There are four main types of variable scopes that tell you where a variable can be seen or used in a program: Local, Enclosed, Global, and Built-in (LEGB). Each scope has its own rules for variable visibility.

🎯 Exam Tip: Familiarize yourself with the LEGB rule (Local, Enclosed, Global, Built-in) as it defines the order in which Python searches for variables.

 

Question 9. How many variables can be mapped to the same instance?
(a) 2
(b) 3
(c) Multiple
(d) 4
Answer: (c) Multiple
In simple words: Many different variables can point to, or 'map' to, the exact same piece of data in a program's memory. This means if you change the data through one variable, all other variables pointing to it will see the change.

🎯 Exam Tip: Be careful when multiple variables reference the same object, as changes made through one variable will affect all others referencing it.

 

Question 10. A variable which is declared outside of all the functions in a program is known as ................ variable.
(a) L
(b) E
(c) G
(d) B
Answer: (c) G
In simple words: A variable set up outside any specific function is called a global variable. It can be accessed and changed from almost anywhere in the program.

🎯 Exam Tip: Global variables are accessible throughout the entire program, which can be useful but should be used carefully to avoid unexpected side effects.

 

Question 11. Which of the following rule is used to decide the order in which the scopes are to be searched for scope resolution?
(a) LGEB
(b) LEGB
(c) LBEG
(d) LGBE
Answer: (b) LEGB
In simple words: The LEGB rule tells a program the order to look for variables: first in the Local scope, then Enclosed, then Global, and finally Built-in scope. This rule helps the program find the right variable if there are many with the same name.

🎯 Exam Tip: The LEGB rule is critical for understanding variable lookup behavior in Python, especially in programs with nested functions.

 

Question 12. How many types of variable scope are there?
(a) 2
(b) 3
(c) 4
(d) 6
Answer: (c) 4
In simple words: There are four main kinds of places a variable can exist and be seen in a program. These are called Local, Enclosed, Global, and Built-in scopes, and they help organize how variables work.

🎯 Exam Tip: Always list the four scopes (Local, Enclosed, Global, Built-in) when asked about types of variable scope to score full marks.

 

Question 13. A variable which is declared outside all the functions in a program is known as
(a) Local
(b) Enclosed
(c) Global
(d) Extern
Answer: (c) Global
In simple words: A variable created outside of any specific function in a program is called a global variable. It can be accessed and changed by any part of the program.

🎯 Exam Tip: When a variable is defined at the top level of a script, outside all functions, it has global scope.

 

Question 14. The scope of a nested function is ................ scope
(a) Local
(b) Global
(c) Enclosed
(d) Built-in
Answer: (c) Enclosed
In simple words: When one function is written inside another function, the inner function has access to the variables of the outer function. This specific type of visibility is known as enclosed scope.

🎯 Exam Tip: Remember that enclosed scope is specifically related to nested functions, allowing inner functions to access variables from their enclosing scope.

 

Question 15. Which of the following programming enables programmers to divide up the work and retry pieces of the program independently?
(a) Procedural Programming
(b) Modular Programming
(c) Object-Oriented Programming
(d) Structural Programming
Answer: (b) Modular Programming
In simple words: Modular programming is a way of building programs by breaking them into smaller, independent parts called modules. This makes it easier for teams to work on different parts at the same time and fix problems in one part without affecting others.

🎯 Exam Tip: Modular programming boosts efficiency by making code easier to manage, test, and reuse, which is crucial for large projects.

 

Question 16. Which of the following contain instructions, processing logic, and data?
(a) Scopes
(b) Indentation
(c) Modules
(d) Access control
Answer: (c) Modules
In simple words: Modules are like building blocks in a program; they hold all the instructions, how the program thinks, and the information it uses. They package code neatly.

🎯 Exam Tip: Modules are essential for organizing code into reusable and manageable units, making large programs easier to develop.

 

Question 17. Which of the following members of a class are denied access from outside the class?
(a) Protected
(b) Private
(c) Public
(d) Enclosed
Answer: (b) Private
In simple words: Private members of a class are like secrets; only the class itself can see or use them. No other part of the program from outside the class can directly touch these members.

🎯 Exam Tip: Private members enforce data hiding, a core concept of object-oriented programming that protects internal data integrity.

 

Question 18. Variables of built-in scopes are loaded as ................ files.
(a) Exe
(b) Linker
(c) Object
(d) Library
Answer: (d) Library
In simple words: Variables and functions that are part of the 'built-in' scope are loaded from special collection files called libraries. These are available to the program as soon as it starts running.

🎯 Exam Tip: Built-in scopes come from standard library modules that provide essential functions and variables, accessible without explicit imports in many languages.

 

Question 19. By default the Python class members are
(a) Private
(b) Protected
(c) Public
(d) Global
Answer: (c) Public
In simple words: In Python, by default, all parts of a class can be seen and used from anywhere in the program. This means they are public, unlike some other languages where things are private by default.

🎯 Exam Tip: Remember Python's default behavior: class members are public. To signal 'private' intent, developers use a single or double underscore prefix, but it's a convention, not strict enforcement.

 

Question 20. By default the C++ and Java class members are
(a) Protected
(b) Private
(c) Public
(d) Local
Answer: (b) Private
In simple words: In programming languages like C++ and Java, if you don't say otherwise, all parts of a class are automatically kept private. This means only the class itself can access them, keeping its inner workings safe.

🎯 Exam Tip: In C++ and Java, it's a good practice to explicitly define access specifiers (public, private, protected) to ensure proper data encapsulation.

 

Question 21. ................ are composed of one or more independently developed Modules
(a) Access control
(b) Programs
(c) Encapsulation
(d) Members of a class
Answer: (b) Programs
In simple words: Big computer programs are often built from many smaller, separate parts called modules. Each module can be made on its own and then put together to create the full program.

🎯 Exam Tip: Thinking of programs as collections of independent modules helps you design scalable and maintainable software.

 

Question 22. Identify which is not a module?
(a) Algorithm
(b) Procedures
(c) Subroutines
(d) Functions
Answer: (a) Algorithm
In simple words: An algorithm is a set of steps to solve a problem, not a physical code container. Procedures, subroutines, and functions are all blocks of code that can be part of a module.

🎯 Exam Tip: While algorithms are crucial for problem-solving, they are conceptual blueprints, whereas modules (containing procedures, subroutines, functions) are actual implementations.

II. Answer The Following Questions (2 And 3 Marks)

 

Question 1. Define variable.
Answer: A variable is like a named box in a computer's memory that holds a value. It's essentially an address or reference to an object stored in the memory, allowing you to store and retrieve data. You can change the value inside the box whenever needed during a program's run.
In simple words: A variable is a name given to a place in memory where you can store information, like numbers or words.

🎯 Exam Tip: Clearly state that a variable is a named storage location for data whose value can change during program execution.

 

Question 2. Define lifetime?
Answer: The lifetime of a variable refers to the period during which it exists in the computer's memory and can be accessed by the program. Once a variable's lifetime ends, the memory it occupied is freed up, and the variable can no longer be used. This helps manage memory efficiently.
In simple words: A variable's lifetime is how long it stays active and usable in a program.

🎯 Exam Tip: Link the concept of lifetime directly to memory allocation and deallocation, emphasizing that it defines when a variable is "alive."

 

Question 3. Define Modular programming.
Answer: Modular programming is a way to design computer programs by breaking them into smaller, independent parts called modules. Each module has a specific task and works on its own, making the overall program easier to understand, manage, and fix. This approach helps reduce complexity and makes code reusable.
In simple words: Modular programming is about building a program using many small, separate pieces of code called modules.

🎯 Exam Tip: Highlight that modular programming improves code organization, reusability, and maintainability by dividing a large program into logical, independent units.

 

Question 4. What is a module?
Answer: A module is a self-contained unit of code within a larger program, containing related instructions, processing logic, and data. Programs are often built from one or more such independently developed modules, which helps in organizing the code. Modules allow for better structure and easier management of complex software.
In simple words: A module is a small, complete piece of a program that has its own instructions and data, helping to organize the whole program.

🎯 Exam Tip: Define a module as a logical, reusable grouping of related code (functions, classes, variables) that helps structure a program.

 

Question 5. Define nested function.
Answer: A nested function is a function that is defined inside another function. This means the inner function is part of the outer function's definition, and it can access variables from its outer (enclosing) function. This structure helps keep related logic together and limits the scope of the inner function.
In simple words: A nested function is a function that sits inside another function.

🎯 Exam Tip: Emphasize that nested functions promote code organization and allow inner functions to access the enclosing function's scope, a concept known as closures.

 

Question 6. Write a note on module
Answer: A module is a fundamental part of a program, designed to group related code and data. Programs are typically composed of one or more independently developed modules, making them easier to manage. Each module can contain several statements that are closely related, and they work well individually while also being able to integrate with other modules. Dividing software into modules helps simplify programming and debugging tasks. This allows a program to be broken down into smaller, functional modules that work together to produce the final output. The practice of subdividing a computer program into separate subprograms is known as modular programming, which enables programmers to distribute work and manage code more efficiently. Examples of modules include procedures, subroutines, and functions.
In simple words: Modules are like separate building blocks of a program that contain related code and data, making big programs easier to build and understand.

🎯 Exam Tip: When writing about modules, clearly explain their role in code organization, reusability, and simplifying complex software development, mentioning procedures and functions as components.

 

Question 7. Write a note on modules?
Answer: A module serves as a distinct segment of a program, designed to encapsulate specific functionalities and data. Programs are constructed from one or more such modules, each developed independently to perform a particular task. These modules can house a variety of closely related statements and can function autonomously while also integrating seamlessly with other modules. This approach simplifies the overall design and debugging process of software. Modules collectively contribute to the program's output, making complex systems more manageable and efficient.
In simple words: Modules are separate parts of a program, each doing a specific job, that work together to build the whole software.

🎯 Exam Tip: A good answer on modules should cover their independent nature, ability to be integrated, and their role in making large programs more manageable.

III. Answer The Following Questions (5 Marks)

 

Question 1. Explain how Access Specifiers are activated in Python, C++, and Java
Answer:In Python, there aren't strict access specifiers like 'public' or 'private'. Instead, Python uses a naming convention:
- If a variable or method name is prefixed with a single underscore (e.g., `_myVar`), it's considered 'protected' by convention, meaning it should not be accessed directly from outside the class, but it technically can be.
- If prefixed with a double underscore (e.g., `__myVar`), it's 'private' by convention, leading to name mangling that makes it harder, but not impossible, to access from outside.
- By default, all members in a Python class are public. In C++ and Java, access specifiers are keywords that strictly control visibility:
- **`public`:** Members declared as `public` are accessible from anywhere, both inside and outside the class.
- **`private`:** Members declared as `private` can only be accessed from within the class itself. They are not visible to objects outside the class.
- **`protected`:** Members declared as `protected` can be accessed from within the class and also by any class that inherits from it.
- By default, class members in C++ and Java are `private`. This strong enforcement of private and protected access promotes robust data security and encapsulation in these languages.
In simple words: Python uses special names (like starting with an underscore) to suggest if a variable is private or protected, but all its members are public by default. C++ and Java use keywords like `public`, `private`, and `protected` to strictly control what parts of a class other code can see, and their members are private by default.

🎯 Exam Tip: When explaining access specifiers, always clearly distinguish between Python's convention-based approach and the strict keyword-based enforcement in C++ and Java, mentioning their default access levels.