(i) Modular programming is a software design technique to split your code into separate parts.
(ii) These parts are called modules. The focus for this separation should have modules with no or just few dependencies upon other modules.

(i) CD command: The "cd" command refers to changes directory and absolute path refers to the complete path where Python is installed.
(ii) Cls command: To clear the screen in command window use cls command.

The "cd"command refers to changes directory and absolute path refers to the complete path where Python is installed.

g++ is a program that calls GCC (GNU C Compiler) and automatically links the required C++library files to the object code

(i) Python deletes unwanted objects (built-in types or class instances) automatically to free the memory space.
(ii) The process by which Python periodically frees and reclaims blocks of memory that no longer are in use is called Garbage Collection.

(i) A static typed language like C++ requires the programmer to explicitly tell the computer what "data type" each data value is going to use.
(ii) A dynamic typed language like Python, doesn't require the data type to be given explicitly for the data. Python manipulate the variable based on the type of value.

'cd' command refers to change directory and absolute path refers to the couple path.
(Eg) "cd c:\program files\open office 4\program"

Modular programming is a software design technique to split our code into separate parts. These parts are called modules. The focus for this separation should have modules with no or just few dependencies upon other modules.

(i) SWIG - Simplified Wrapper Interface Generator
(ii) MinGW - Minimalist GNU for Windows

S.No	Compiler	Interpreter
(i)	It takes an entire Program at a time.	It takes a single line of code or instruction at a time.
(ii)	Display all errors after compilation, all at the	Displays error of each line one by one.

(i) The theoretical difference between the two is that scripting languages do not require the compilation step and are rather interpreted.
(ii) For example, normally, a C++ program needs to be compiled before running whereas, a scripting language like JavaScript or Python need not be compiled.
(iii) A scripting language requires an interpreter while a programming language requires a compiler. 

Step 1: Type the C++ program to check whether the input number is palindrome or not in notepad and save it as "pali_cpp.cpp".
Step 2: Type the Python program and save it as pali.py.
Step 3: Click the Run Terminal and open the command window
Step 4: Go to the folder of Python using cd command
Step 5: Type the command Python pali.py -i pali_cpp

(i) We can import the definitions inside a module to another module. We use the import keyword to do this.
(ii) Using the module name we can access the functions defined inside the module. The dot (.) operator is used to access the functions. The syntax for accessing the functions from the module is.
<module name>. <function name>
(iii) Example: >>> factorial.fact(5)

The commonly used interfaces are
(i) Python-C-API (API-Application Programming Interface for interfacing with C programs)
(ii) Ctypes (for interfacing with c programs)
(iii) SWIG (Simplified Wrapper Interface Generator- Both C and C++)
(iv) Cython (Cython is both a Python-like language for writing C-extensions)
(v) Boost. Python (a framework for interfacing Python and c++)
(vi) MinGW (Minimalist GNU for Windows)

(i) sys module provides access to some variables used by the interpreter and to functions that interact with the interpreter
(ii) OS module in Python provides a way of using operating system dependent functionality
(iii) The getopt module of Python helps you to parse (split) command-line options and arguments.

sys.argv is the list of command-line arguments passed to the Python program. argv contains all the items that come along via the command-line input, it's basically an array holding the command-line arguments of the program.
To use syss.argv, we will first have to import sys. The first argument, sys.argv [0], is always the name of the program as it was invoked and sys.argv [1] is the first argument we pass to the program.
Example:
main (sys.argv [1]) - Accepts the program file and the input file as a list. argv[0] contains the python program which is need not to be passed because by default _main_contains source code reference and argv[1] contains the name of the C++ file which is to be processed.

welcome → module name
      ●      →  operator name
display() → definition name

(i) MinGW refers to a set of runtime header files, used in compiling and linking the code of C, C++ and FORTRAN to be run on Windows Operating System.
(ii) MinGw- W64 (version of MinGW) is the best compiler for C++ on Windows. To compile and execute the C++ program, need 'g++' for Windows. MinGW allows to compile and execute C++ program dynamically through Python program using g++.
(iii) Python program that contains the c++ coding can be executed only through 'MinGW_w64 project' run terminal. The run terminal open the command -line window through which Python program should be executed.
(iv) g++ is a program that calls GCC (GNU C compiler) and automatically links the required C++ Library files to the object code.

(i) To automate certain tasks in a program
(ii) Extracting information from a data set
(iii) Less code intensive as compared to traditional programming language
(iv) can bring new functions to applications and glue complex systems together
(v) Conjuction with other programming languages HTML, Java, C++.

//Now select File⟶New in Notepad and type the Python program
# Save the File as transpose.py. Program that compiles and executes a .cpp file
# Python tanspose.py -i trans_cpp
Python Program:
import sys, os, getopt
def main(argv):
cpp_file = "
exe_file = "
opts,args = getopt.getopt(argv, "i:",['ifile='])
for o, a in opts:
if o in ("-i", "< -ifile"):
cpp_file = a + '.cpp'
exe_file = a + '.exe'
run(cpp_file, exe_file)
defrun( cpp _file, exe_file):
print("Compiling" + cpp_file)
'os.system ('g++' + cpp_file + '-o' + exe_file)
print("Running" + exe_file)
print(" -------------------")
print
os.system( exe_file)
print
if __name__ =='__main__"
main( sys.argv[ 1:])

#Now select File￫New in Notepad and type the Python program
# Save the File as pali.py . Program that compiles and executes a .cpp file
# Python c:\pyprg\pali.py -i c:\pyprg\pali_cpp import sys, os, getopt
def main(argv):
cpp_file ="
exe_file = "
opts, args= getopt.getopt(argv, "i:",['ifile='])
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("-----------------")
print
os.system(exe_file)
print
if __name__ =='__main__': # program starts executing from here
main(sys.argv[ 1:])

commands for wrapping C++ code:
if___name___ =='___main___':
main(sys.argv[ 1:])
_name_ (A Special variable) in Python:
(i) Since there is no main ( ) function in Python, when the command to run a Python program is given to the interpreter, the code that is at level 0 indentation is to be executed.
(ii) However, before doing that, interpreter will define a few special variables. __name___ is one such special variable which by default stores the name of the file. If the source file is executed as the main program, the interpreter sets the ___name___ variable to have a value as "___main___".
(iii) __name__ is a built-in variable which evaluates to the name of the current module. Thus it can be used to check whether the current script is being run on its own.
(iv) For example consider the following:
if ___name___ ==' ___main___':
main (sys.argv[1:])
(v) if the command line Python program itself is going to execute first, then _main_ contains the name of that Python program and the Python special variable _name_ also contain the Python program name.
(vi) If the condition is true it calls the main which is passed with C++ file as argument.

getopt() method returns value consisting of two elements. Each of these values are stored separately in two different list opts and args. opts contains list of splitted strings like made, path and args contains any string if at all not splitted because of wrong path or mode. args will be an empty array if there is no error in splitting strings by getopt().
Example:
The Python code which is going to execute the C++ file p4 in command line will have the getopt() method.
Syntax:
opts, args = getopt.getopt (argv, "i:", ['ifile ='])
where opts contains ('-i','c:\\pyprg\\p4')]]
-i:- option nothing but mode should be followed by
'c:\\pyprg\\p4' value nothing but the absolute path of C++ file,
Since the entire command-line commands are parsed and no leftover arguments, the second argunent args will be empty[].

(i) Python's Sys module:
This module provides access to some variables used by the interpreter and to functions that interact strongly with the interpreter.
Sys.argv:
(i) Sys.argv is the list of command-line arguments passed to the Python program.argv contains all the items that come along via the command-line input, it's basically an array holding the commandline arguments of the program.
(ii) To use sys.argv, we will first have to import sys. The first argument, sys.argv[O], is always the name of the program as it was invoked, and sys.argv[1] is the first argument you pass to the program (here it is the C++ file).
Example:
main (sys.argv [1]) Accepts the program file and input file as a list. argv [O] contains the Python program which is need not to be passed because bydefault_main_contains source code reference and argv [1] contains the name of the C++ file.
(ii) Python's OS module:
The OS module in Python provides a way of using operating system dependent functionality.
The functions that the OS module allows to interface with the windows operating system where Python is running on.
OS.system(): Execute the C++ compiling command in the shell.
Example:
os.system <'g++'+<variable - name 1> - '<mode>' <variable_name 2>
os.system: Function system() defined in os module. g++: General compiler to compile C++ program under
windows Operating system. Variable_name 1: Name of the C++ file without extension. cpp in string
format. Mode: To specify input or output mode. Here it is o prefixed
with hyphen. Variable_name 2: Name of the executable file without extension.exe in
string format. (iii) Python getopt module:
The getopt module of python helps to parse command-line options and arguments. This module provides two functions to enable command-line argument parsing.
getopt.getopt method:
This method parses command line options and parameter list.
Syntax:
<opts>, <args> = getopt.getopt(argv, options, [long_options])
argv - This is the argument list of values to be parsed.
options - This is string of option letters that the Python program recognize as, for input or for output with options 'i' or 'o' that followed by a colon(:).
Long- options - This parameter is passed with a list of strings. Argument of long options should be followed by an equal sign '='.

Python   < filename.py > - < i > <C++ filename without cpp extension>

Python	Keyword to execute the Python program from command-line
filename.py- i	Name of the Python program to executed input mode
C++ filename without cpp  extension	Name of C++ file to be compiled and executed

For example type Python pycpp.py - i pali in the command prompt and press enter key. If the compilation is successful we will get the desired output. Otherwise the error will be displayed. 

(i) Python uses Automatic Garbage Collection whereas C++ does not.
(ii) C++ is a statically typed language, while Python is a dynamically typed language.
(iii) Python runs through an interpreter, while C++ is pre-compiled.
(iv) Python code tends to be 5 to 10 times shorter than that written in C++.
(v) In Python, there is no need to declare types explicitly where as it should be done in C++.
(vi) In Python, a function may accept an argument of any type, and return multiple values without any kind of declaration beforehand. Whereas in C++ return statement can return only one value.