(i) 0
(ii) 3
(iii) -1
(iv) 3

str1 = input ("Enter a string:")
Index=-1
while index >= -(lentstrl1)):
print ("Subscript[",index,"] :" + str1 [index])
index +=-1
Output:
Enter a string: welcome
Subscript [ -1 ] : e
Subscript [ -2 ] : m
Subscript [ -3 ] : 0
Subscript [ -4 ] : c
Subscript [ -5 ] : I
Subscript [ -6 ] : e
Subscript [ -7 ] : w

(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

range (1,30,1) - will start the range of values from 1 and end at 29
range (2,30,2) - will start the range of values from 2 and end at 28
range (30,3,-3) - will start the range of values from 30 and end at 6
range (20) - will consider this value 20 as the end value(or upper limit) and starts the range count from 0 to 19 (remember always ranget) will work till stop -1 value only)

(i) Python class function or Method is very similar to ordinary function with a small difference that, the class method must have the first argument named as self.
(ii) No need to pass a value for this argument when we call the method. Python provides its value automatically.
(iii) Even if a method takes no arguments, it should be defined with the first argument called self.
(iv) If a method is defined to accept only one argument it will take it as two arguments ie. self and the defined argument.

(i) List comprehension is a simplest way of creating sequence of elements that satisfy a certain condition.
(ii) Syntax:
List = [ expression for variable in range ]
(iii) Example: Generating squares of first 10 natural numbers using the concept of List comprehension.
> > > squares = [x ** 2 for x in range(1, 11) ]
> > > print (squares)
Output:
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

The execution time that you measure in this case would depend on a number of factors such as:
(i) Speed of the machine
(ii) Compiler and other system Software tools
(iii) Operating System
(iv) Programming language used
(v) Volume of data required

(i) In Python, programs can be written in two ways namely Interactive mode and Script mode.
(ii) The Interactive mode allows us to write codes in Python command prompt >>> whereas in script mode programs can be written and stored as separate file with the extension.
(iii) py and executed. Script mode is used to create and edit python source file.

(i) A module is a part of a program. Programs are composed of one or more independently developed modules. A single module can contain one or several statements closely related each other.
(ii) Modules work perfectly on individual level and can be integrated with other modules. A software program can be divided into modules to ease the job of programming and debugging as well.
(iii) A program can be divided into small functional modules that work together to get the output. The process of subdividing a computer program into separate subprograms is called Modular programming.
(iv) Modular programming enables programmers to divide up the work and debug pieces of the program independently. The examples of modules are procedures, subroutines, and functions.

(i) Data abstraction is supported by defining an abstract data type (ADT) which is a collection of constructors and selectors.
(ii) Constructors create an object, bundling together different pieces of information, while selectors extract individual pieces of information from the object.

(i) 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 argument is written after an = sign. If you want to define a recursive function: use "let rec" instead of "let".
(ii) Syntax: The syntax for function definitions:
let rec fn a1 a2 ... an :;= k
(iii) Here the 'fn' is a variable indicating an identifier being used as a function name. The names 'a1' to 'an' are variables indicating the identifiers used as parameters. The keyword 'rec' is required if 'fn' is to be a recursive function; otherwise it may be omitted.

The WHERE clause is used to extract only those records that fulfill a specified condition. In this example we are going to display the different grades scored by male students from "student table.
import sqlite3
connection = sqlite3.connect ("Academy.db")
cursor = connection.cursor()
cursor.execute ("SELECT DISTINCT (Grade) FROM student where gender = "M")
result = cursor.fetchall()
print(* result, sep ="\n")
Output:
('B,')
('A,')
('C,')
('D,')

(i) Time Factor -Time is measured by counting the number of key operations like comparisons in the sorting algorithm.
(ii) Space Factor -Space is measured by the maximum memory space required by the algorithm.

(i) Ternary operator is also known as conditional operator that evaluate something based on a condition being true or false.
(ii) It simply allows testing a condition in a single line replacing the multiline if-else making the code compact. The syntax for conditional operator is,
Variable Name = [on_true] if [Test expression]
else [on_false]
(iii) Example:
min = 50 if 49 < 50 else 70 # min = 50
min = 50 if 49 > 50 else 70 # min = 70

Output:
Red, Blue, Green
Red, Blue
Red.
Seope f Variables :

(i) The elements of a list can be accessed in two ways. The first way is via our familiar method of multiple assignment, which unpacks a list into its elements and binds each element to a different name.
lst := [10, 20]
x, y := lst
(ii) In the above example x will become l0 andy will become 20.
(iii) A second method for accessing the elements in a list is by the element selection operator. Unlike a list literal, a square brackets  expression directly following another expression does not evaluate to a list value, but instead selects an element from the value of the preceding expression.
Ist [0]
10
lst [1]
20

 

A powerful strategy for designing programs, 'wishful thinking'. Wishful Thinking is the formation of beliefs and making decisions according to what might be pleasing to imagine instead of by appealing to reality.

The most popular groups of side effects is modifying the variable outside of function.
For example:
let y: = 0
(int) inc (int) x
y: =y+x;
return (y)
In the above example the value of y get changed inside the function definition due to which the result will change each time.

(i) Strlen is a pure function because the function takes one variable as a parameter, and accesses it to find its length.
(ii) This function reads external memory but does not change it, and the value returned derives from the external memory accessed.