Samacheer Kalvi Class 12 Computer Science Solutions Chapter 14 Importing C++ Programs in Python

 

I. Choose the best answer (1 Marks)

 

Question 1. Which of the following is a scripting language?
(a) JavaScript
(b) PHP
(c) Perl
(d) HTML
Answer: (d) HTML
In simple words: The correct option from the given choices is HTML. HTML is used to structure content on the web.

🎯 Exam Tip: Remember to carefully read each option in multiple-choice questions, even if an answer seems obvious, to avoid mistakes.

 

Question 2. Importing C++ program in a Python program is called
(a) wrapping
(b) Downloading
(c) Interconnecting
(d) Parsing
Answer: (a) wrapping
In simple words: When you use a C++ program inside a Python program, this process is known as 'wrapping'. It lets different programming languages work together.

🎯 Exam Tip: Understanding key terminology like 'wrapping' is essential for topics involving language interoperability. Define it clearly in your mind.

 

Question 3. The expansion of API is
(a) Application Proc Interpreter
(b) Application Programming Interface
(c) Application Performing Interface
(d) Application Programming Interlink
Answer: (b) Application Programming Interface
In simple words: API stands for Application Programming Interface. It is a set of rules that allow different software programs to talk to each other. It helps various applications to interact.

🎯 Exam Tip: Knowing common acronyms and their full forms is crucial in computer science; practice recalling them quickly.

 

Question 4. A framework for interfacing Python and C++ is
(a) Ctypes
(b) SWIG
(c) Cython
(d) Boost
Answer: (d) Boost
In simple words: Boost.Python is a tool that helps Python and C++ programs work together smoothly. It acts like a bridge between the two languages.

🎯 Exam Tip: When listing frameworks, ensure you mention specific examples like Boost.Python that are designed for language interfacing.

 

Question 5. Which of the following is a software design technique to split your code into separate parts?
(a) Object oriented Programming
(b) Modular programming
(c) Low Level Programming
(d) Procedure oriented Programming
Answer: (b) Modular programming
In simple words: Modular programming is a way to design software where you divide the main code into smaller, separate sections. This makes the code easier to manage and understand.

🎯 Exam Tip: Clearly differentiate between programming paradigms like modular, object-oriented, and procedural programming in your answers.

 

Question 6. The module which interface with the Windows operating system is
(a) OS module
(b) sys module
(c) csv module
(d) getopt module
Answer: (a) OS module
In simple words: The OS module in Python is used to interact with the operating system, like Windows. It lets your program do things related to the system, such as managing files or folders.

🎯 Exam Tip: Always specify the exact module name, such as 'OS module', when referring to operating system interactions in Python.

 

Question 7. getopt() will return an empty array if there is no error in splitting strings to
(a) argv variable
(b) opt variable
(c) args variable
(d) ifile variable
Answer: (c) args variable
In simple words: The `getopt()` function helps break down command-line arguments. If there are no extra arguments left after processing, the 'args' part of its return value will be an empty list.

🎯 Exam Tip: Remember that `getopt()` returns two lists: `opts` for options and `args` for non-option arguments. The `args` list will be empty if all arguments are successfully parsed as options.

 

Question 8. Identify the function call statement in the following snippet.
if_name_ =='_main_':
main(sys.argv[1:])
(a) main(sys.argv[1:])
(b) _name_
(c) _main_
(d) argv
Answer: (a) main(sys.argv[1:])
In simple words: In this code, `main(sys.argv[1:])` is the part that calls a function named `main`. It passes a slice of the command-line arguments to it.

🎯 Exam Tip: A function call is identified by the function's name followed by parentheses `()` which may contain arguments.

 

Question 9. Which of the following can be used for processing text, numbers, images, and scientific data?
(a) HTMI
(b) C
(c) C++
(d) PYTHON
Answer: (d) PYTHON
In simple words: Python is a very versatile programming language that can be used for many different tasks. It is good for working with text, numbers, images, and also for scientific calculations.

🎯 Exam Tip: Highlight Python's versatility and its wide range of applications, especially in data processing and scientific computing.

 

Question 10. What does _name_ contains ?
(a) C++ filename
(b) C filename
(c) python filename
(d) os module name
Answer: (c) python filename
In simple words: In Python, the `_name_` variable holds the name of the current Python file being run. It helps the program know if it's being run directly or imported as a module.

🎯 Exam Tip: The `_name_` variable is crucial for understanding how Python modules are executed and imported. Explain its common use case with `if _name_ == '__main__':`.

 

II. Answer the following questions (2 Marks)

 

Question 1. What is the theoretical difference between Scripting language and other programming languages?
Answer: Scripting languages do not need a separate compilation step; they are typically interpreted line by line. This makes them faster to test and run changes. In contrast, other programming languages like C++ usually require compilation before they can be executed. A compiled language produces an executable file, while an interpreted language needs an interpreter to run its code. This fundamental difference affects how programs are developed and deployed.
In simple words: Scripting languages are run directly by an interpreter, while other programming languages usually need to be turned into a special file first by a compiler.

🎯 Exam Tip: Clearly state that scripting languages are interpreted, while traditional programming languages are often compiled, as this is the core difference.

 

Question 2. Differentiate compiler and interpreter.
Answer:
Compiler:
1. A compiler translates the entire program at once into machine code.
2. It generally produces faster execution speeds because the code is fully translated before running.
3. Finding errors can be difficult as it reports all errors after compiling the whole program. For example, C++ programs often use a compiler.
Interpreter:
1. An interpreter translates and executes a program line by line.
2. It typically leads to slower execution compared to compiled code because translation happens during runtime.
3. Error detection is easier as it stops at the first error found, making debugging simpler. Python is a good example of an interpreted language.
In simple words: A compiler changes the whole program at once, making it fast, but errors are found at the end. An interpreter changes the program line by line, which can be slower, but it finds errors as it goes.

🎯 Exam Tip: When differentiating, always compare corresponding points (e.g., speed of compilation vs. interpretation, error reporting) for a comprehensive answer.

 

Question 3. Write the expansion of (i) SWIG (ii) MinGW
Answer:
(i) SWIG – Simplified Wrapper Interface Generator
(ii) MINGW – Minimalist GNU for Windows
In simple words: SWIG helps connect different programming languages, and MinGW is a tool that allows you to use GNU software development tools on Windows.

🎯 Exam Tip: Always write out the full expansion for acronyms clearly, using a hyphen or dash to separate the acronym from its meaning.

 

Question 4. What is the use of modules?
Answer: Modules are used to break down large programs into smaller, more organized files. This makes the code easier to manage and understand. Modules also promote code reusability, meaning we can write functions once and then import them into different programs instead of copying their definitions everywhere. This saves time and makes development more efficient.
In simple words: Modules help split big programs into small, easy-to-manage parts. They also let us reuse code, so we don't have to write the same functions again and again.

🎯 Exam Tip: Focus on the two main benefits of modules: organization (manageability) and reusability, as these are key concepts.

 

Question 5. What is the use of cd command? Give an example.
Answer:
* The `cd` command is used to change the current directory in a command-line interface. It allows users to navigate through different folders on their computer system. An absolute path specifies the complete location from the root directory.
* The `cd` command (short for 'change directory') helps you move from one folder to another. When you use an 'absolute path', you tell the computer the exact location of the folder starting from the very beginning of the drive.
Syntax:
`cd `
Example:
`cd C:\myprogram` This command will change the current directory to the `myprogram` folder located on the C: drive.
In simple words: The `cd` command helps you go to a different folder on your computer. For example, `cd C:\games` would take you to the 'games' folder on drive C.

🎯 Exam Tip: When providing examples for commands, ensure the syntax is correct and the example clearly illustrates the command's function.

 

III. Answer the following questions (3 Marks)

 

Question 1. Differentiate PYTHON and C++
Answer:
PYTHON:
1. Python is primarily an "interpreted" language, meaning its code is executed line by line.
2. It is a dynamically-typed language, so you don't need to specify variable types beforehand.
3. Data types are not required when declaring a variable, offering more flexibility.
4. Python can function as both a scripting language and a general-purpose programming language for various tasks.
C++:
1. C++ is a "compiled" language, requiring the entire program to be translated into machine code before execution.
2. It is a statically typed language, meaning variable types must be defined before use.
3. Data types must be declared explicitly for variables, ensuring type safety.
4. C++ is predominantly a general-purpose language, often used for performance-critical applications. It generally offers more control over hardware.
In simple words: Python runs line by line and doesn't need you to tell it the type of data, while C++ is fully translated first and needs you to say what type of data each variable holds.

🎯 Exam Tip: Focus on distinguishing between interpretation/compilation and dynamic/static typing, as these are fundamental differences between Python and C++.

 

Question 2. What are the applications of a scripting language?
Answer: Scripting languages are widely used for several applications:
* They help automate routine tasks within a program or system, saving manual effort.
* Scripting languages are effective for extracting specific information from large datasets.
* They are less code-intensive compared to traditional programming languages, allowing for faster development.
* Scripting languages can integrate new functions into existing applications and connect different complex systems together. For instance, they are great for web development tasks.
In simple words: Scripting languages are good for making tasks automatic, taking out information from data, needing less code to write, and helping different computer systems work together.

🎯 Exam Tip: When discussing applications, use action verbs like 'automate', 'extract', 'integrate', and 'glue' to clearly describe the functions.

 

Question 3. What is MinGW? What is its use?
Answer: MinGW refers to a collection of runtime header files used for compiling and linking code written in C, C++, and FORTRAN. This allows these programs to run on the Windows Operating System. MinGW-W64, which is an updated version of MinGW, is considered an excellent compiler for C++ on Windows. To compile and run a C++ program, you typically need the 'g++' compiler provided by MinGW for Windows. MinGW enables C++ programs to be compiled and executed dynamically through Python, utilizing the 'g++' command. Python programs containing C++ code can be run only through the MinGW-w64 project run terminal, which opens a command-line window for executing the Python program. This tool is essential for cross-language development on Windows.
In simple words: MinGW is a set of tools that helps you compile C and C++ programs to run on Windows. It also lets Python programs run C++ code by helping to translate it.

🎯 Exam Tip: Explain both what MinGW is (a collection of tools) and its primary use (compiling C/C++/FORTRAN for Windows, especially for Python integration).

 

Question 4. Identify the definition name, dot operator, and module name for the following: welcome.display()
Answer: In the expression `welcome.display()`:
* `welcome` is the module name.
* `.` (the period) is the dot operator, used to access members of a module or object.
* `display` is the definition name (or function name), which is a function within the `welcome` module. This structure is common in object-oriented programming.
In simple words: In `welcome.display()`, 'welcome' is the module, '.' is the dot operator, and 'display' is the function being called.

🎯 Exam Tip: When analyzing such expressions, remember the standard syntax: `module_name.function_name()`, where the dot is the operator connecting them.

 

Question 5. What is sys.argv? What does it contain?
Answer: `sys.argv` is a list in Python that holds all the command-line arguments passed to a Python program. To use `sys.argv`, you must first import the `sys` module. The first item in this list, `sys.argv[0]`, always contains the name of the Python program itself, just as it was launched. The subsequent items, starting from `sys.argv[1]`, are the arguments you pass to the program. For example, if you run a Python script `myscript.py` with an argument `myfile.txt`, `sys.argv` would be `['myscript.py', 'myfile.txt']`. If `main(sys.args[1])` accepts both the Python program file and an input C++ file, then `argv[0]` would contain the Python program's name (which isn't usually needed as `_main_` points to the source code), and `argv[1]` would contain the name of the C++ file to be processed.
In simple words: `sys.argv` is a list that stores all the words you type after `python` when running a script. The first word is always the script's name, and the rest are extra pieces of information you give to the program.

🎯 Exam Tip: Clearly state that `sys.argv` is a list and explain the significance of `sys.argv[0]` (program name) and `sys.argv[1:]` (arguments passed).

 

IV. Answer the following questions (5 Marks)

 

Question 1. Write any five features of Python.
Answer: Here are five key features of Python:
* Python uses Automatic Garbage Collection, which means it automatically manages memory by deleting unused objects to free up space.
* Python is a dynamically typed language, so you do not need to declare the data type of a variable before using it.
* Python code is executed through an interpreter, translating and running the code line by line.
* Python code tends to be much shorter, often 5 to 10 times shorter, than equivalent code written in languages like C++.
* In Python, functions can accept arguments of any type and can also return multiple values without any explicit type declarations. This offers great flexibility in function design. These features make Python a popular choice for many developers.
In simple words: Python cleans up memory by itself, you don't need to state data types, it runs using an interpreter, its code is short, and functions can take any type of input and give back many results without you telling it the types.

🎯 Exam Tip: When listing features, choose distinct and impactful points that highlight Python's key advantages, such as readability, dynamic typing, and automatic memory management.

 

Question 2. Explain each word of the following command.
Python < filename.py > -i < C++ filename without cpp extension >
Answer: The command `Python < filename.py > -i < C++ filename without cpp extension >` can be broken down as follows:

In simple words: 'Python' starts the program, 'filename.py' is the Python script to run, '-i' means input mode, and 'C++ filename' is the C++ program the Python script will use.

🎯 Exam Tip: When explaining command-line arguments, always define each component (keyword, script name, options, and arguments) clearly and concisely.

 

Question 3. What is the purpose of sys, os, getopt module in Python. Explain
Answer:
Python's sys module:
The `sys` module provides access to various variables that are used by the Python interpreter itself. It also provides functions that interact strongly with the interpreter. For example, `sys.argv` (command-line arguments) and `sys.exit()` are common uses. This module is like a bridge to the internal workings of Python.
Python's OS module:
The `os` module in Python provides a way to use operating system-dependent functions. This means you can interact with the underlying operating system, like Windows, Linux, or macOS. The functions in the `os` module let you interface with the Windows operating system where Python is running, for tasks such as creating or deleting files and folders.
Python getopt module:
The `getopt` module in Python helps you parse (split) command-line options and arguments. It is especially useful for scripts that need to accept flags and options from the user when run from the terminal. This module provides two main functions, `getopt.getopt()` and `getopt.gnu_getopt()`, which enable robust command-line argument parsing. It simplifies handling user input through the command line.
In simple words: The `sys` module helps Python talk to its own system. The `os` module helps Python talk to the computer's operating system, like Windows. The `getopt` module helps Python understand special instructions given when you start a program from the command line.

🎯 Exam Tip: For each module, clearly state its primary function and give a simple example of what it does (e.g., `sys.argv` for `sys`, file operations for `os`, command-line flags for `getopt`).

 

Question 4. Write the syntax for getopt() and explain its arguments and return values
Answer:
The `getopt()` method is used to parse command-line options and arguments. Here's its syntax and an explanation of its parts:
Syntax of getopt():
`opts, args = getopt.getopt(argv, options, [long_options])`
Where:
i) `argv`: This is the list of values (arguments) that need to be parsed (split). In a Python program, the complete command-line input, excluding the script name itself, is typically passed as this list.
ii) `options`: This is a string of single-character option letters that the Python program recognizes. For options that require an argument, a colon (`:`) must follow the letter (e.g., `'i:'` for an input option that takes a value). The colon indicates that the option expects an associated value.
iii) `long_options`: This is an optional parameter, which is a list of strings. Each string represents a long-style option (e.g., `--ifile`). For long options that require an argument, an equal sign (`=`) must follow the option name (e.g., `['ifile=']`). In our program, the C++ filename would be passed as a string, and `'ifile='` would indicate it as the input file.
The `getopt()` method returns a value consisting of two elements:
* `opts` contains a list of parsed options and their arguments, such as mode or path. Each item is a `(option, value)` tuple.
* `args` contains any remaining strings that were not parsed as options because they didn't match any specified options or modes. If all strings are successfully parsed, `args` will be an empty list (`[]`). This happens when there's no error in splitting the strings by `getopt()`.

In simple words: `getopt()` takes the program's input, a list of short options (like '-i'), and a list of long options (like '--ifile='). It then gives back two lists: one with the options it found (`opts`) and another with any leftover input (`args`). If no input is left over, `args` will be empty.

🎯 Exam Tip: Clearly distinguish between `argv`, `options`, and `long_options`, and remember that `getopt()` returns a tuple of two lists: `opts` (parsed options) and `args` (remaining non-option arguments).

 

Question 5. Write a Python program to execute the following C++ coding?
#include
using namespace std;
int main()
{ cout<<"WELCOME";
return (0);
}
Answer: To execute the given C++ program, first save the C++ code in a file named `welcome.cpp`. Then, create a Python program, for example `welcome.py`, to compile and run this C++ file. This setup allows you to automate the C++ compilation and execution using a Python script, demonstrating inter-language communication.
C++ Program (`welcome.cpp`):

#include<iostream>
using namespace std;
int main()
{
    cout<<"WELCOME";
    return(0);
}

Python Program (`welcome.py`):

import sys, os, getopt

def main(argv):
    cpp_file = ""
    exe_file = ""
    try:
        opts, args = getopt.getopt(argv, "i:", ["ifile="])
    except getopt.GetoptError:
        print('Error: welcome.py -i ')
        sys.exit(2)
    for o, a in opts:
        if o in ("-i", "--ifile"):
            cpp_file = a + '.cpp'
            exe_file = a + '.exe'
    run(cpp_file, exe_file)

def run(cpp_file, exe_file):
    print("Compiling " + cpp_file)
    os.system('g++ ' + cpp_file + ' -o ' + exe_file)
    print("Running " + exe_file)
    print("....................")
    os.system(exe_file)
    print()

if __name__ == '__main__':
    main(sys.argv[1:])

To run from the command line:
`python welcome.py -i welcome`
This will compile `welcome.cpp` and then execute the resulting `welcome.exe`.
Output:

Compiling welcome.cpp
Running welcome.exe
....................
WELCOME

In simple words: First, you save the C++ code. Then, you write a Python program that uses special tools (`os.system`) to tell the computer to build and run that C++ code. When you run the Python script, it will show the message "WELCOME" from the C++ program.

🎯 Exam Tip: When providing code solutions, always include comments to explain crucial steps, especially when interfacing different programming languages, and clearly demonstrate the command-line execution and expected output.

 

12th Computer Science Guide Importing C++ Programs in Python Additional Questions and Answers

 

I. Choose the best answer (1 Marks)

 

Question 1. Which one of the following language act as both scripting and general-purpose language?
(a) python
(b) c
(c) C++
(d) html
Answer: (a) python
In simple words: Python is a unique language that can be used for simple scripts and also for building large, complex applications, making it both a scripting and general-purpose language.

🎯 Exam Tip: Remember that Python's design allows it to be used flexibly for quick scripts and robust applications, which is why it fits both categories.

 

Question 2. _________ can act both as scripting and general-purpose language.
a) Python
b) C
c) C++
d) Html
Answer: (a) Python
In simple words: Python is a flexible programming language that can be used for both small automated tasks (scripting) and for creating complete software programs (general-purpose).

🎯 Exam Tip: This question tests your knowledge of language capabilities; Python is known for its dual nature in scripting and general-purpose programming.

 

Question 3. Identify the script language from the following.
(a) Html
(b) Java
(c) Ruby
(d) C++
Answer: (c) Ruby
In simple words: Ruby is a type of programming language that is designed for running scripts. It helps with automation and making things work together.

🎯 Exam Tip: Scripting languages are often interpreted rather than compiled, making them quicker to develop with for certain tasks.

 

Question 4. language use automatic garbage collection?
(a) C++
(b) Java
(c) C
(d) Python
Answer: (d) Python
In simple words: Python automatically cleans up unused memory, a process called garbage collection. This helps the program run smoothly without manual memory management.

🎯 Exam Tip: Automatic garbage collection prevents memory leaks and simplifies memory management for programmers, making languages like Python easier to use.

 

Question 5. is required for the scripting language.
(a) Compiler
(b) Interpreter
(c) Python
(d) Modules
Answer: (b) Interpreter
In simple words: A scripting language needs an interpreter to run. The interpreter reads and carries out the code line by line, executing it directly.

🎯 Exam Tip: Remember that compiled languages use a compiler, while scripting languages typically use an interpreter, which processes code at runtime.

 

Question 6. How many values can be returned by a function in python?
(a) 1
(b) 2
(c) 3
(d) many
Answer: (d) many
In simple words: A Python function can return multiple values at once. These values are often packed together, for example, as a tuple.

🎯 Exam Tip: Python functions are very flexible; they can return multiple values, which is a feature not available in many other programming languages that only allow a single return value.

 

Question 7. is an expansion of MinGW
(a) Minimalist Graphics for windows
(b) Minimum GNU for windows
(c) Minimalist GNU for Windows
(d) Motion Graphics for windows
Answer: (c) Minimalist GNU for Windows
In simple words: MinGW stands for "Minimalist GNU for Windows". It is a collection of development tools for creating applications that run on Windows.

🎯 Exam Tip: MinGW provides a programming environment to develop applications that can run natively on the Windows operating system.

 

Question 8. is not a python module.
(a) Sys
(b) OS
(c) Getopt
(d) argv
Answer: (d) argv
In simple words: While 'sys', 'os', and 'getopt' are all built-in Python modules, 'argv' is a list of command-line arguments found within the 'sys' module, not a module itself.

🎯 Exam Tip: Remember that `sys.argv` is a *list* attribute of the `sys` module, used to access arguments passed to a script from the command line.

 

Question 9. Which of the following language codes are linked by MinGW on windows OS?
(a) C
(b) C++
(c) FORTRAN
(d) All of the options
Answer: (d) All of the options
In simple words: MinGW can link code written in C, C++, and FORTRAN so that these programs can run on the Windows operating system. It supports multiple programming languages.

🎯 Exam Tip: MinGW is a comprehensive toolchain, supporting the compilation and linking of applications written in various programming languages for Windows.

 

Question 10. is both a python-like language for writing C extensions.
(a) Boost
(b) Cython
(c) SWIG
(d) Ctypes
Answer: (b) Cython
In simple words: Cython is a programming language that looks a lot like Python but can be used to write C extensions. It helps you combine Python and C code easily.

🎯 Exam Tip: Cython makes it easier to bridge Python with C/C++ by allowing Python-like code to be compiled directly into C, improving performance.

 

Question 11. refers to a set of runtime header files used in compiling and linking the C++ code to be run or window OS.
(a) SWIG
(b) MinGW
(c) Cython
(d) Boost
Answer: (b) MinGW
In simple words: MinGW is a collection of files needed to compile and link C++ code so that it can run on Windows. It creates the environment for C++ development.

🎯 Exam Tip: Understand that MinGW provides the necessary development tools for C++ on Windows, including a compiler and libraries for building executables.

 

Question 12. Which is a software design technique to split the code into separate parts?
(a) Procedural programming
(b) Structural programming
(c) Object-Oriented Programming
(d) Modular Programming
Answer: (d) Modular Programming
In simple words: Modular programming is a way to design software by breaking down code into smaller, independent sections called modules. This makes the code easier to manage and understand.

🎯 Exam Tip: Modular programming improves code organization, enhances reusability, and simplifies debugging by isolating different functionalities into distinct parts.

 

Question 13. Which refers to a file containing python statements and definitions?
(a) Procedures
(b) Modules
(c) Structures
(d) Objects
Answer: (b) Modules
In simple words: A module in Python is simply a file that contains Python code, including statements and function definitions. It acts like a container for related code.

🎯 Exam Tip: Modules are fundamental for organizing code, preventing name clashes, and enabling code reuse across different Python programs.

 

Question 14. Which symbol in os.system() indicates that all strings are concatenated and sends that as a list.
(a) +
(b) .
(c) ,
(d) -
Answer: (a) +
In simple words: In the `os.system()` function, the plus sign (+) is used to join different string parts together. This creates a single command string for the operating system to execute.

🎯 Exam Tip: String concatenation with `+` is a common Python operation used when building command strings or dynamic output messages.

 

Question 15. The input mode in the python command is given by
(a) -i
(b) o
(c) -p
(d) -1
Answer: (a) -i
In simple words: In command-line Python, the "-i" flag is used to specify that the program should operate in input mode. This often means it expects input from a file or specific source.

🎯 Exam Tip: Command-line arguments and flags like `-i` are essential for making scripts flexible and controlling their behavior without modifying the code.

 

Question 16. the command is used to clear the screen in the command window.
(a) els
(b) Clear
(c) Clr
(d) Clrscr
Answer: (a) els
In simple words: The `els` command is used in the command window to clear everything from the screen. This gives you a clean, empty display for new commands.

🎯 Exam Tip: Familiarize yourself with basic command-line utilities like screen clear commands to maintain a tidy and efficient terminal environment.

 

Question 17. The keyword used to import the module is
(a) Include
(b) Input
(c) Import
(d) None of these
Answer: (c) Import
In simple words: To use a module in your Python program, you must use the `import` keyword. This makes the module's functions and definitions available for use in your code.

🎯 Exam Tip: The `import` statement is fundamental for code organization and reuse in Python, allowing you to leverage pre-written modules effectively.

 

Question 18. Which in os.system() indicates that all strings are concatenated?
(a) +
(b) -
(c) #
(d) *
Answer: (a) +
In simple words: When building a command string for `os.system()`, the plus sign (+) is used to combine multiple smaller strings into one longer string.

🎯 Exam Tip: String concatenation with the `+` operator is a basic yet powerful feature in Python, frequently used for constructing dynamic command-line inputs.

III. Answer the Following Questions (2 and 3 Marks)

 

Question 1. Define wrapping.
Answer: Wrapping is the process of bringing a C++ program into a Python program. This allows Python code to call and interact with C++ code seamlessly.
In simple words: Wrapping means connecting a C++ program with a Python program so they can work together.

🎯 Exam Tip: Wrapping allows developers to combine the performance benefits of C++ with the rapid development and ease of use of Python.

 

Question 2. Explain how to import C++ Files in Python.
Answer: Importing C++ programs into Python is called wrapping, and it allows Python to use C++ code. This can be done in several ways by creating Python interfaces for the C++ programs. Common interfaces include:

• Python-C-API: This is the official way to create C extensions for Python programs.
• Ctypes: This library allows Python to call functions directly from shared libraries, like DLLs.
• SWIG (Simplified Wrapper Interface Generator): This tool helps connect C/C++ programs with various scripting languages, including Python.
• Cython: This language allows you to write C extensions using Python-like code, which is then compiled into C.
• Boost.Python: This is a C++ library that helps expose C++ classes and functions to Python easily.
• MinGW (Minimalist GNU for Windows): This provides a development environment to compile C++ code on Windows, making it compatible with Python.

In simple words: To use C++ files in Python, you "wrap" them using special tools and methods. These tools build a connection so Python can talk to the C++ code and use its features.

🎯 Exam Tip: Remember these different methods as they offer various approaches depending on the project's specific needs, complexity, and desired level of integration.

 

Question 3. Define g++.
Answer: `g++` is a command-line program that is used to compile C++ source code. It calls the GNU C Compiler (GCC) and automatically links all the necessary C++ library files required to produce an executable object code.
In simple words: `g++` is a tool that compiles C++ programs. It uses the main GCC compiler and adds all necessary C++ parts to make your program ready to run.

🎯 Exam Tip: `g++` is the standard command-line compiler for C++ on Linux and many other systems, streamlining the compilation process for developers.

 

Question 4. Write a note on scripting language?
Answer: A scripting language is a type of programming language designed to integrate and communicate with other programs or operating system environments. It is often used for automating tasks, creating web applications, or connecting different software components. Popular scripting languages include JavaScript, VBScript, PHP, Perl, Python, and Ruby.
In simple words: Scripting languages are used to connect different programs or automate tasks. They often run inside another program or system.

🎯 Exam Tip: Scripting languages are typically interpreted, meaning their code is executed line by line without a separate compilation step, which speeds up development.

 

Question 5. What is garbage collection in python?
Answer: Garbage collection in Python is an automatic memory management process. It identifies and deletes objects (like built-in data types or custom class instances) that are no longer referenced or needed by the program. This frees up memory space for other operations. Python periodically reclaims blocks of memory that are no longer in use, ensuring efficient memory utilization.
In simple words: Garbage collection automatically cleans up memory by removing unused items from a program. It helps keep the computer's memory free and makes programs run better.

🎯 Exam Tip: Garbage collection is crucial for dynamic languages like Python as it prevents memory leaks and simplifies development by removing the need for manual memory deallocation.

 

Question 6. Define: GNU C compiler.
Answer: The GNU C Compiler, commonly known as GCC, is a free and open-source compiler system. It is capable of compiling programs written in various languages, including C, C++, and FORTRAN. The `g++` command specifically calls GCC to compile C++ code and automatically links the necessary C++ library files into the final program.
In simple words: GCC is a free software tool that compiles code from languages like C and C++. The `g++` command is used to make C++ programs ready to run with GCC.

🎯 Exam Tip: GCC is a widely used and powerful compiler suite, essential for open-source development and cross-platform compatibility.

 

Question 7. Explain how to execute a C++ program through python using the MinGW
Answer: To execute a C++ program through Python using MinGW, you would first compile the C++ code into an executable file using the `g++` compiler from the MinGW suite. Once the executable is created, a Python script can then be used to run this executable. This is typically achieved by using Python's `os.system()` function, which allows Python to run system commands. The Python script will call `g++` to compile the C++ file, and then call the resulting `.exe` file to run the program. This allows Python to act as an orchestrator for C++ programs.
In simple words: First, compile your C++ code with MinGW's `g++` to make a runnable file. Then, use a Python script with `os.system()` to tell your computer to run that C++ file.

🎯 Exam Tip: Interfacing C++ with Python is beneficial for tasks requiring high performance (C++) and flexible scripting (Python), effectively leveraging the strengths of both languages.

 

Question 8. Write a note on
1. cd command
2. els command
Answer:
1. **cd command:** The `cd` command, short for "change directory," is used in a command-line interface to navigate between different folders (directories) in the file system. When specifying a directory, an absolute path refers to its complete location from the root directory, which is useful for specifying locations like where Python might be installed.
2. **els command:** The `els` command is used in the command window to clear all previously displayed text and output from the screen. This action provides a clean and empty display, making it easier to view new command outputs without clutter.
In simple words: The `cd` command helps you move between folders on your computer, and the `els` command clears everything shown on your computer screen.

🎯 Exam Tip: These are fundamental command-line utilities essential for efficient navigation and management of your development environment.

 

Question 9. Define: Modular programming
Answer: Modular programming is a software design approach where a large program is divided into smaller, independent, and interchangeable parts called modules. Each module performs a specific function and is designed to have minimal dependencies on other modules. This technique enhances code organization, reusability, and maintainability, making the overall software development process more efficient.
In simple words: Modular programming is like building a toy with many blocks, where each block (module) does one job. This makes the whole toy easier to build, fix, and reuse parts.

🎯 Exam Tip: Modular design improves code reusability, simplifies debugging, and allows multiple developers to work on different parts of a project simultaneously.

 

Question 10. Define
1. sys module
2. OS module
3. getopt module
Answer:
1. **sys module:** The `sys` module in Python provides access to system-specific parameters and functions. It allows a program to interact with the Python interpreter, offering tools to manage command-line arguments, standard input/output streams, and other system-related functionalities.
2. **OS module:** The `os` module in Python offers a way for programs to interact with the operating system. It provides functions to perform tasks like managing files and directories, handling environment variables, and executing system commands, offering operating system-dependent functionality.
3. **getopt module:** The `getopt` module is a utility that helps parse command-line options and arguments. It processes input that looks like traditional Unix `getopt()` arguments, allowing a Python script to easily interpret flags and values passed to it from the command line.
In simple words: The `sys` module helps Python talk to its own system. The `os` module helps Python talk to the computer's operating system. The `getopt` module helps Python understand commands typed when running a program.

🎯 Exam Tip: These three modules are fundamental for writing Python scripts that interact effectively with the operating system and handle command-line inputs.

 

Question 11. Explain how to import modules and access the function inside the module in python?
Answer: To use functions and definitions from one module in another Python script, you must first `import` that module. The `import` keyword makes all the content of the module available in your current program. After importing, you can access any function defined within that module by using the module's name followed by a dot (`.`) and then the function's name. This dot operator helps create a clear way to call specific functions from an imported module.
For example, if you have a module named `math_operations.py` that contains a function called `add(a, b)`, you would use it like this:
`import math_operations`
`result = math_operations.add(5, 3)`
This would execute the `add` function from the `math_operations` module.
In simple words: To use code from another file (module), you type `import` and the module's name. Then, to use a specific tool (function) from it, you type the module name, a dot, and the tool's name.

🎯 Exam Tip: Proper use of `import` statements and the dot operator is crucial for writing clean, organized, and reusable Python code, enhancing readability and preventing name conflicts.

 

Question 12. Explain Module with suitable example
Answer: A module in Python is essentially a file containing Python statements, function definitions, and variables. For instance, if you create a file named `calculator.py` and write functions like `add()`, `subtract()`, etc., inside it, then `calculator` becomes a module. Modules help in organizing large programs into smaller, more manageable and reusable files. This practice allows you to define your most frequently used functions once in a module and then import them into various other programs, rather than copying the code multiple times.
**Example:**
Let's say you create a file `mymath.py` with the following content:
`def factorial(n):`
  `if n == 0 or n == 1:`
    `return 1`
  `else:`
    `f = 1`
    `for i in range(2, n + 1):`
      `f *= i`
    `return f`
To use this function in another Python script, you would do:
`import mymath`
`result = mymath.factorial(5)`
`print(result)` # Output: 120
In simple words: A module is a Python file with code inside. You can `import` this file into other programs to reuse its functions, like using a `factorial` function from a `mymath` module without writing it again.

🎯 Exam Tip: Modules are fundamental for developing scalable and maintainable Python applications by promoting code organization, reusability, and easier collaboration.

 

Question 13. Write an algorithm for executing C++ program pali_cpp.cpp using python
Answer: To execute a C++ program (e.g., `pali_cpp.cpp`) using a Python script, follow these steps:
1. **Write C++ Program:** First, create your C++ program in a text editor (like Notepad) and save it with a `.cpp` extension (e.g., `pali_cpp.cpp`). This program will perform the desired C++ logic.
2. **Write Python Program:** Next, write a Python program in a separate text editor and save it as a Python file (e.g., `pali.py`). This script will be responsible for compiling and running the C++ program.
3. **Open Terminal:** Launch your command-line terminal or command prompt.
4. **Navigate to Directory:** Use the `cd` (change directory) command to go to the folder where you saved both your C++ (`pali_cpp.cpp`) and Python (`pali.py`) files.
5. **Execute Python Script:** Type the command `python pali.py -i pali_cpp` into the terminal and press Enter. This command tells the Python interpreter to run `pali.py`, passing `pali_cpp` as an argument to indicate which C++ file to process.
In simple words: First, write your C++ code and save it. Then, write a Python code to run that C++ code. Open your computer's command line, go to your files' folder, and type a command to run the Python script, telling it which C++ file to use.

🎯 Exam Tip: This approach demonstrates how Python can act as a wrapper, orchestrating the compilation and execution of programs written in other languages, useful for automation and integration.

 

Question 14. Explain _name_ is one such special variable which by default stores the name of the file.
Answer: The special variable `__name__` in Python is a built-in variable that holds the name of the current module or file. When a Python script is executed directly (as the main program), `__name__` is automatically assigned the string value `'__main__'`. However, if the script is imported as a module into another script, `__name__` will contain the actual name of the module (which is typically its filename without the `.py` extension). This feature is commonly used to write code that runs only when the script is executed directly, not when imported.
**Example:**
`if __name__ == '__main__':`
  `print("This code runs when the script is executed directly.")`
`else:`
  `print("This code runs when the script is imported as a module.")`
In simple words: `__name__` is a special word in Python that tells you if your script is the main program running or if it's being used by another program. If it's the main program, `__name__` is `'__main__'`.

🎯 Exam Tip: Understanding `if __name__ == '__main__':` is crucial for writing Python scripts that can function both as standalone programs and as reusable modules, preventing unintended execution of code during import.

 

Question 15. How Python is handling the errors in C++.
Answer: Python itself does not directly handle compilation errors for C++ programs because they are different languages with their own compilers. However, when Python is used to execute a C++ program (typically via the `os.system()` function), it can capture and display the output generated by the C++ compiler (like `g++`). This means if the C++ compiler encounters any errors during compilation, Python can show these error messages in the terminal where the Python script is running. This allows developers to debug C++ code even when its execution is orchestrated through a Python script.
In simple words: Python doesn't fix C++ errors itself, but when it runs a C++ program, it can show you the error messages that the C++ compiler makes. This helps you find and fix problems in your C++ code.

🎯 Exam Tip: Python's ability to interface with the system's command line allows it to integrate with external tools like C++ compilers and capture their diagnostic output, which is useful for development workflows.

III. Answer the Following Questions (5 Marks)

 

Question 1. a) Write a Python code to display all the records of the following table using fetchmany().

Answer: To display all records from a SQLite database table using `fetchmany()` in Python, you first need to connect to the database, insert the data, and then execute a SELECT query. The `fetchmany()` method can then retrieve a specified number of rows from the query result. **Python Program:** python import sqlite3 # Connect to the SQLite database. If it doesn't exist, it will be created. connection = sqlite3.connect("Academy.db") cursor = connection.cursor() # Data to be inserted into the Student table. student_data = [ ('3001',"Chithirai","353"), ('3002',"Vaigasii","411"), ('3003',"Aani","374"), ('3004',"Aadi","289"), ('3005',"Aavanii","507"), ('3006',"Purattasi","521") ] # Create the Student table if it does not already exist. cursor.execute(""" CREATE TABLE IF NOT EXISTS Student ( Regno TEXT PRIMARY KEY, Name TEXT, Marks INTEGER ) """) # Insert each student's data into the table. for p in student_data: # SQL command to insert data. Note: p[2] for marks based on student_data structure. format_str = """INSERT INTO Student (Regno, Name, Marks) VALUES ("{}","{}","{}");""" sql_command = format_str.format(p[0], p[1], p[2]) cursor.execute(sql_command) # Save the changes to the database. connection.commit() # Execute a SELECT query to retrieve all records from the Student table. cursor.execute("SELECT * FROM Student") # Fetch all 6 records using fetchmany(6) and store them in 'result'. result = cursor.fetchmany(6) # Print each fetched record on a new line. print(*result,sep="\n") # Close the database connection. connection.close() **Output of the program:** ('3001', 'Chithirai', 353) ('3002', 'Vaigasii', 411) ('3003', 'Aani', 374) ('3004', 'Aadi', 289) ('3005', 'Aavanii', 507) ('3006', 'Purattasi', 521)In simple words: This Python code connects to a database, creates a table for student information, adds several student records to it, and then retrieves all these records using `fetchmany()`. Finally, it prints each student's details on a new line.

🎯 Exam Tip: The `fetchmany()` method is efficient for retrieving a specific number of rows from a query result, which is useful when processing large datasets in manageable batches.

 

Question 1. b) Write a Python Script to display the following Pie chart.

Answer: To display the given pie chart, you can use the `matplotlib.pyplot` library in Python. This library allows you to create various types of plots and charts, including pie charts, with custom labels and percentage displays. **Python Script:** python import matplotlib.pyplot as plt # Data for the pie chart slices: Tamil, English, Maths, Social, Science sizes = [89, 80, 90, 100, 75] # Labels for each slice labels = ["Tamil", "English", "Maths", "Social", "Science"] # Create the pie chart # autopct="%.2f" formats the percentage to two decimal places # startangle=90 starts the first slice from the top plt.pie(sizes, labels=labels, autopct="%.2f", startangle=90) # Ensures the pie chart is drawn as a perfect circle plt.axes().set_aspect("equal") # Display the chart plt.show()In simple words: This Python script uses a special library to draw a pie chart. It takes numbers (sizes) for each slice and names (labels) for what each slice means. It then calculates and shows the percentage for each part, making sure the chart is a perfect circle.

🎯 Exam Tip: When creating visualizations, using `matplotlib` allows for clear and customizable graphical representations of data, such as pie charts, which are effective for showing proportions.

 

Question 2. Write a C++ program to check whether the given number is palindrome or not. Write a program to execute it?
Answer: To check if a number is a palindrome (reads the same forwards and backward) using C++ and then execute this C++ program using a Python script, you would first create the C++ code and then the Python script to manage its compilation and execution. **C++ Program (e.g., `pali_cpp.cpp`):** cpp #include using namespace std; int main() { int n, num, digit, rev = 0; cout << "Enter a positive number: "; cin >> num; n = num; // Store the original number // Reverse the number while (num) { digit = num % 10; // Get the last digit rev = (rev * 10) + digit; // Add it to the reversed number num = num / 10; // Remove the last digit from the original number } cout << "The reverse of the number is: " << rev << endl; // Compare original and reversed number if (n == rev) cout << "The number is a palindrome"; else cout << "The number is not a palindrome"; return 0; } This C++ program prompts the user to enter a positive number, then it reverses the number and compares it with the original to determine if it's a palindrome. **Python Program to execute the C++ code (e.g., `pali.py`):** python import sys, os, getopt def main(argv): cpp_file_name = "" executable_file_name = "" # Parse command-line arguments using getopt # "i:" indicates -i option requires an argument # ['ifile='] indicates --ifile option also requires an argument opts, args = getopt.getopt(argv, "i:", ['ifile=']) for opt, arg in opts: if opt in ("-i", "--ifile"): # Check for -i or --ifile options cpp_file_name = arg # The argument is the base name for C++ file executable_file_name = arg + '.exe' # Create executable name # If no file name was provided, print usage and exit if not cpp_file_name: print("Usage: python pali.py -i ") sys.exit(2) run(cpp_file_name + '.cpp', executable_file_name) def run(cpp_source_file, executable_file): print("Compiling " + cpp_source_file) # Compile the C++ program using g++ compile_command = f'g++ {cpp_source_file} -o {executable_file}' os.system(compile_command) print("Running " + executable_file) print("--------------------") # Execute the compiled C++ program os.system(executable_file) print("") # Add a newline for better output separation if __name__ == '__main__': # When the script is executed directly, call main with command-line arguments main(sys.argv[1:]) This Python script uses the `getopt` module to parse command-line arguments, allowing you to specify the C++ file name without the `.cpp` extension (e.g., `pali_cpp`). The `run` function then utilizes `os.system()` to first compile the C++ source file using `g++` (part of MinGW) and then executes the resulting `.exe` program. This setup enables Python to manage the entire compilation and execution flow for your C++ code. **Example Execution Output:** Compiling c:\pyprg\pali_cpp.cpp Running c:\pyprg\pali_cpp.exe -------------------- Enter a positive number: 56765 The reverse of the number is: 56765 The number is a palindrome Compiling c:\pyprg\pali_cpp.cpp Running c:\pyprg\pali_cpp.exe -------------------- Enter a positive number: 56756 The reverse of the number is: 65765 The number is not a palindromeIn simple words: This solution provides a C++ program that checks if a number is a palindrome. It also includes a Python script that compiles this C++ program using `g++` and then runs the compiled program, showing the output directly in the terminal.

🎯 Exam Tip: Combining Python for program orchestration with C++ for computationally intensive tasks is a common and powerful approach in software development. Ensure correct paths and error handling in your scripts.

 

Question 2. Write a C++ program to check whether the given number is palindrome or not. Write a program to execute it?
Answer: To determine if a number is a palindrome, you first write the C++ program and save it as `pali_cpp.cpp`. After creating the C++ file, you then develop a Python script, named `pali.py`, which is designed to compile and run the C++ program. To execute this, you open your computer's command line, navigate to the folder containing your Python script, and run the Python script, supplying the C++ file's name as an argument. This method allows Python to efficiently manage the compilation and execution of C++ code, making it a powerful way to integrate different programming languages.

Here is the C++ program (save as `pali_cpp.cpp`):

`#include <iostream>`
`using namespace std;`
`int main()`
`{`
`    int n, num, digit, rev = 0;`
`    cout << "Enter a positive number:";`
`    cin >> num;`
`    n = num;`
`    while(num)`
`    {`
`        digit = num % 10;`
`        rev = (rev * 10) + digit;`
`        num = num / 10;`
`    }`
`    cout << "The reverse of the number is:" << rev << endl;`
`    if (n == rev)`
`    {`
`        cout << "The number is a palindrome";`
`    }`
`    else`
`    {`
`        cout << "The number is not a palindrome";`
`    }`
`    return 0;`
`}`

Next, here is the Python program (save as `pali.py`):

`import sys, os, getopt`

`def main(argv):`
`    cpp_file = ""`
`    exe_file = ""`
`    `
`    # Parse command line arguments`
`    opts, args = getopt.getopt(argv, "i:", ['ifile='])`
`    `
`    for o, a in opts:`
`        if o in ("-i", "--file"):`
`            cpp_file = a + '.cpp'`
`            exe_file = a + '.exe'`
`            run(cpp_file, exe_file)`

`def run(cpp_file, exe_file):`
`    print("Compiling " + cpp_file)`
`    # Compile the C++ program`
`    os.system('g++ ' + cpp_file + ' -o ' + exe_file)`
`    `
`    print("Running " + exe_file)`
`    print("--------------------")`
`    # Execute the compiled C++ program`
`    os.system(exe_file)`
`    print("--------------------")`

`if __name__ == '__main__':`
`    # Program starts executing from here, passing command-line arguments`
`    main(sys.argv[1:])`

To run the program, open a command window and type the following command:

`Python pali.py -i pali_cpp`

Here are examples of the program's output:

`Compiling c:\pyprg\pali_cpp.cpp`
`Running c:\pyprg\pali_cpp.exe`
`Enter a positive number: 56765`
`The reverse of the number is: 56765`
`The number is a palindrome`
`--------------------`
`C:\Program Files\OpenOffice 4\program>Python c:\pyprg\pali.py -i c:\pyprg\pali_cpp`
`Compiling c:\pyprg\pali_cpp.cpp`
`Running c:\pyprg\pali_cpp.exe`
`Enter a positive number: 56756`
`The reverse of the number is: 65765`
`The number is not a palindrome`

In simple words: You first write a C++ program to identify palindrome numbers. Then, you write a Python program that helps to compile and run the C++ program. When you execute the Python program from the command line, it processes the C++ file, asks for a number, and tells you if it's a palindrome or not.

🎯 Exam Tip: When integrating different programming languages, always ensure that all file paths are correct and that the necessary compilers and interpreters are properly set up in your system's environment variables.