Syntax for i) remove () ii) Pop() iii) clear ()
i) remove()
Syntax:
List.remove(element) #to delete a particular element
ii) pop():
Syntax:
List.pop(index of an element)
iii) clear()
Syntax:
list.clear()
Example:
> Mylist = [12, 89, 34, 'Kannan', 'Gowri sankar', 'Lenin')
>print(Mylist)
[12, 89, 34, 'Kannan', 'Gowri sankar', 'Lenin']
>> Mylist. remove(89)
>>>print (Mylist)
[12,34, 'Kannan; 'Gowri sankar', Lenin']
In the above example, Mylist has been created with three integer and three string elements, the print statement shows all the elements available in the list. In the statement >>> Mylist. remove (89), deletes the element 89 from the list and the print statement shows the remaining elements.
Example:
>>> Mylist.pop(1)
       34
> print (Mylist)
[12, 'Kannan', 'Gowrisankar', 'Lenin']
pop() function is used to delete a particular element using its index value, as soon as the element is deleted, the pop( ) function shows the element which is deleted. pop() function is used to delele only one element from a list
Example:
> MyList. clear()
>>>print(MyList)
       [ ]
clear( ) function removes only the elements and retains the list. To print the list which is already cleared, an empty square bracket is displayed.

Using Global and Local variables in same code:
x = 8               #x is a global variable.
def loc( ):
global x
y = "local"
x = x * 2
print (x)
print (y)
loc( )
Output:
16
local
We declare x as global and y as a local variable in the function loc( )
After calling the function loc( ) , the value of x becomes 16 because we used, x = x*2.Print the value of local variable y i.e., local.
Example:
Global variable and Local variable with same name:
x = 5
def loc( ):
x = 10
print ("local x:",x)
loc( )
print ("local x:",x)
Output:
local x: 10
global x: 5
local x: 10, is called the local scope of the variable
global x: 5, is called the global scope of the variable.

#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:])

(i) Insertion sort is a simple sorting algorithm. It works by taking elements from the list one by one and inserting then in their correct position in to a new sorted list.
(ii) This algorithm builds the final sorted array at the end. This algorithm uses n-1 number of passes to get the final sorted list as per the pervious algorithm as we have discussed.
Pseudo for Insertion sort:
Step 1 - If it is the first element, it is already sorted.
Step 2 - Pick next element
Step 3 - Compare with all elements in the sorted sub-list
Step 4 - Shift all the elements in the sorted sublist that is greater than the value to be sorted Step 5 - Insert the value Step 6 - Repeat until list is sorted.

Type a Value for X : 10
The x + = 20 is = 30
The x - = 5 is = 25
The x * = 5 is = 125
The x / = 2 is = 62.5
The x % = 3 is = 2.5
The x ** = 2 is = 6.25
The x// = 3 is = 2.0

Creating database:
Sql_command = " "
CREATE TABLE Hardware (
lcode INTEGER PRIMARY KEY.
ltem_Name VARCHAR(20),
Rate DEClMAL(5,2));" "
Program: To display the records using fetchmany()
import sqlite3
connection = sqlite3.connect ("Material.db")
cursor = connection.cursor()
cursor. execute ("SELECT * FROM Hardware")
print("fetching first 5 records:")
result = cursor.fetchmany(5)
print(result)
Output:
fetching first 5 records:
[(1003, 'Scanner', "10500'), (1004, 'Speaker', '3000'), (1005, 'Printer', '8000'), (1008, 'Monitor', '15000'),
(1010, 'Mouse', '700')]

Relational Algebra is divided into various groups
Unary Relational Operations.
(i) SELECT (symbol: σ)
(ii) PROJECT ( symbol: π)
Relational Algebra Operations from Set Theory:
(i) UNION (U)
(ii) INTERSECTION (∩)
(iii) DIFFERENCE (-)
(iv) CARTESIAN PRODUCT (X)
SELECT (symbol: σ)
(i) General from σ (R) with a relation R and a condition C on the attributes of R
(ii) The SELECT operation is used for selecting a subset with tuples according to a given condition.
(iii) Select filters out all tuples that do not satisfy C
STUDENT:

σ course = "Big Data" (STUDENT) 

PROJECT (symbol: II)
(i) The projection eliminates all attributes of the input relation but those mentioned in the projection list.
(ii) The projection method defines a relation that contains a vertical subset of Relation.
Example: 1
II_course (STUDENT)
Result:

Example 2 
II_{student,course} (STUDENT)
Result:

UNION (Symbol: U)
(i) It includes all tuples that are in tables A or in B. It also eliminates duplicates. Set A Union Set B would be expressed as A U B
Example 3:

Result:

SET DIFFERENCE (Symbol: -)
(i) The result of A - B, is a relation which includes all tuples that are in A but not in B.
(ii) The attribute name of A has to match with the attribute name in B.
Example: 4
using Table B Example 3 
Result:

INTERSECTION (symbol: ∩) A ∩ B:
(i) Defines a relation consisting of a set of all tuple that are in both in A and B. However,  A and.B must be union-compatible.
Example: 5 
Using Table in Example 3
Result:

PRODUCT OR CARTESIAN PRODUCT (Symbol: X)
(i) Cross product is a way of combining two relations. The resulting relation contains, both relations being combined.
(ii) A x B means A times B, where the relation A and B have different attributes.
(iii) This type of operation is helpful to merge columns from two relations.

(i) Dynamic programming is an algorithmic design method that can be used when the solution to a problem can be viewed as the result of a sequence of decisions.
(ii) Dynamic programming approach is similar to divide and conquer. The given problem is divided into smaller and yet smaller possible sub-problems.
(iii) Dynamic programming is used whenever problems can be divided into similar subproblems. so that their results can be reused to complete the process.
(iv) Dynamic programming approaches are used to find the solution in optimized way. For every inner subproblem, dynamic algorithm will try to check the results of the previously solved sub-problems.
(v) The solutions of overlapped sub-problems are combined in order to get a better solution.
Steps to doDynamic programming :
(i) The given problem will be divided into smaller overlapping sub-problems.
(ii) An optimum solution for the given problem can be achieved by using result of smaller sub-problem.
(iii) Dynamic algorithms uses Memoization
Fibonacci Series - An example :
(i) Fibonacci series generates the subsequent number by adding two previous numbers. Fibonacci series starts from two numbers -Fib 0 & Fib 1. The initial values of Fib 0 & Fib l can be taken as 0 and 1.
(ii) Fibonacci series satisfies the following conditions:
Fibn = Fib_a-1 + Fib_a-2
(iii) Hence, a Fibonacci series for the n value 8 can look like this
Fib₈ = 0 1 1 2 3 5 8 13
Fibonaeci Iterative Algorithm with Dynamic programning approach : The following example shows a simple Dynamic programning approach for the generation ot Fibonacci series.
Initialize f0 = 0, f1 = 1.
Step- 1: Print the initial values of Fibonacci f0 and f1 
Step- 2: Calculate Fibonacci fib \(\leftarrow \) f0+ f1 
Step- 3: Assign f0 \(\leftarrow \) f1, f1 \(\leftarrow \) fib
Step- 4: Print the next consecutive value of Fibonacci fib
Step- 5: Go to step-2 and repeat until the specified number of terms generated
Example:
if we generate Fibonacci series up to 10 digits, the algorithm will generate the series as shown below:
The Fibonacci series is:
0 1 1 2 3 5 8 13 21 34 55.

Parameters and arguments:
Parameters are the variable in a function definition and arguments are the values which are passed to a function definition
(i) Parameter without Type: Let us see an example of a function,definition :
(requires: b >=0 )
(returns: a to the power of b)
let rec pow a b:=
          if b=0 then 1
          else a*powa(b-1)
(i) In the above function definition variable 'b' is the parameter and the value which is passed to the variable 'b' is the argument. The precondition (requires) and postcondition (returns) of the function is given.
(ii) Note we have not mentioned any types (data types). Some language computer solves this type (data type) inference problem algorithmically, but some require the type to be mentioned.
(iii) In, the above function deinition if expression can return 1 in the then branch, shows that as per the typing rule the entire if expression has type int
(iv) Since the if expression is of type 'int', the function's return type also be int. 'b' is compared to 0 with the equality operator. so 'b' is also a type of int: Since 'a' is multiplied with another expression using the operator, 'a' must be an int.
(ii) Parameter with Type: Now let us write the same function definition with types for some reasons:
(requires: b > 0 )
(returns: a to the power of b )
       let rec pow (a:int) (b:int): int :=
                     if b=0 then 1
 n                  else a * pow b (a-1)
(i) When we write the type annotations for ‘a’ and ‘b’ the parentheses are mandatory. Generally, we can leave out these annotations, because it's simpler to let the compiler infer them.
(ii) There are times we may want to explicitly write down types. This is useful on times when you get a type error from the compiler that doesn't make sense. Explicitly annotating the types can help with debugging such an error message.
(iii) The syntax to define functions is close to the mathematical usage: the definition is introduced by the keyword let followed by the name of the function and its arguments; then the formula that computes the image of the argumentis written atter an := sign. If you want to define a recursive function: use "let rec" instead of "let"
Syntax:The syntax for function detinitions: let irec fn al a2 ... an := k
(iv) Here the 'fn' is used as a function name. The nanmes 'a1' to 'an'are variables used as parameters. The keyword 'rec' is required if  'fn' is to be a recursive function; otherwise it may be omitted. 

The duration for which a variable is alive is called life time.

Arguments are the values which are passed to a function definition.

List is constructed by placing an expression within square brackets separated by commas. Such an expression is called a list literal.

The output of the program
7
10

To sort by more than one column you can use itemgetter with multiple indices:
operator.itemgetter 
Example:
sortedlist = sorted (data, key = operator. itemgetter(1))

Python prescribes a convention of prefixing the name of the variable or method with single or double underscore to emulate the behavior of protected and private access specifiers.
Example: self_n2 = n2

The access modifiers are private, public and protected members.
Private members of a class are denied access from the outside the class. They can be handled only within the class.
Public members are accessible from outside the class. The object of the same class is required to invoke a public method. This arrangement of private instance variables and public methods ensures the principle of data encapsulation.
Protected members of a class are accessible from within the class and are also available to its sub-classes. No other process is permitted access to it. This enables specific resources of the parent class to be inherited by the child class.

Membership Operators:
(i) The 'in' and 'not in' operators can be used with strings to determine whether a string is present in another string. Therefore, these operators are called as Membership Operators.
(ii) Example:
str1=input ("Enter a string:")
str2="chennai"
if str2 in str1:
print ("Found")
else:
print ("Not Found")
(iii) Output:1
Enter a string: Chennai GHSS, Saidapet
Found
(iv) Output:2
Enter a string: Govt GHSS, Ashok Nagar Not Found

(i) Keyword arguments will invoke the function after the parameters are recognized by their parameter names.
(ii) The value of the keyword argument is matched with the parameter name and so, one can also put arguments in improper order.
(iii) Example:
def printdata (name):
print ("Example-1 Keyword arguments")
print ("Name :",name)
return
# Now you can call printdatat() function
printdata(name = "Gshan")
When the above code is executed, it produces the following output:
Output:
Example-1 Keyword arguments
Name: Gshan

x, y = int (input("Enter Number 1:")),
int (input ("Enter Number 2:" ))
print ("X =,x", " Y =, y" )
Output:
Enter Number 1 : 30
Enter Number 2 : 50
X= 30 Y = 50

Plot:
import matplotlib.pyplot as plt
sizes =  [105, 30, 30, 195]
label= ["sleeping", "eating", "working", "playing"]
plt.pie (sizes, labels = labels, autopct = "%.2f")
plt, axes ( ). set_aspect ("equal")
plt.show ( )

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.

Output: [1,2,4,8,16]

for i in range (1, 6) :
for j in range (65, 65 + i)
         a = chr(j)
print a
print

(a) Constructors
(b) Selectors
(c) Selectors
(d) Selectors
(e) Constructors
(f) Selectors