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++.

Execution Steps:
//save above file as welcome.cpp
#Now select File -> New in Notepad and type the Python program
#save the file as fun.py
#Program that compiles and executes a .cpp file
#Python fun.py- iC: |pyprg| welcome - file.cpp
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)
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_':
main (sys.argv [1:])
Output:
welcome.

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.