Python Programming Fundamentals

A is true but R is false.

Explanation
A token is the smallest element of a Python script that is meaningful to the interpreter. Each component of a programming statement is referred to as a token. Comments are not executed by the interpreter, but tokens are executed by it.

Both A and R are true and R is the correct explanation of A.

Explanation
In Python, we are not required to explicitly declare a variable with its type. Whenever we declare a variable with a value, Python automatically assigns the relevant data type to it based on the assigned value. This process is known as dynamic typing.

A is true but R is false.

Explanation
Integer represents whole numbers without any fractional part. They can be zero, positive or negative. -45, -1000 are the integer values in Python while 655.55, 55.89 are floating-point numbers.

Both A and R are true and R is the correct explanation of A.

Explanation
A sequence is an ordered collection of items in Python, and these items can have similar or different data types. They are indexed by integers. The three main types of sequence data types in Python are strings, lists, and tuples.

Both A and R are true and R is the correct explanation of A.

Explanation
Comments are statements in a script that are ignored by the Python interpreter. Comments are basically statements used to put remarks and are used to explain the code and to make it more informative for the users. They make the code more readable and understandable for human beings.

A is true but R is false.

Explanation
Character set is a set of valid characters recognized by Python. A character represents any letter, digit or any other symbol present on the keyword. On the other hand, a token is the smallest element of a Python script that is meaningful to the interpreter which includes keywords, identifiers, literals, operators and delimiters/punctuators. A character set can be used to form tokens, but not all tokens are part of the character set.

A is false but R is true.

Explanation
Python is a case-sensitive language, meaning it distinguishes between uppercase and lowercase letters. Therefore, 'Rollnumber' and 'rollnumber' are not considered the same identifiers in Python.

Both A and R are true and R is the correct explanation of A.

Explanation
In Python, the floor division operator (//) performs integer division. On the other hand, the division operator (/) performs float division. For example, the statement 10 // 3 will give the output 3, whereas 10 / 3 will give the output 3.3333333333333335.

Errors

Reason — The fundamental building blocks of a Python program include identifiers, constants, and keywords. Errors, on the other hand, are issues that arise during program execution due to mistakes in the code.

Underscore (_)

Reason — In Python, an identifier name can only be composed of letters (both uppercase and lowercase), digits, and underscores (_). Special characters like #, hyphen (-), and $\text{\textdollar}$ are not allowed in identifier names.

4

Reason — In Python, the default indentation level after a function declaration statement is 4 spaces.

#

Reason — Single line comments in Python begin with # symbol.

For example,

x = 10
y = x + 100 #value of x + 100 is assigned to variable y
print(y)

K = complex(2,3)

Reason — Complex numbers are made up of pairs of real and imaginary numbers. They take the form 'x+yj' or 'x+yi', where x is the real part and y is the imaginary part. Therefore, according to this, K = complex(2,3) is not a complex number.

1,2,3,4,5,6

Reason — The order of precedence of arithmetic operators in Python is Parenthesis (), Exponential (**), Multiplication (*), Division (/), Addition (+), Subtraction (-).

6 4

Reason — Initially, x is assigned the value 2, and y is assigned 6 using multiple assignments. Then, the expression y, x + 2 is evaluated, where y is 6, and x + 2 calculates to 4. After evaluating the right-hand side, x is reassigned to y, making x equal to 6, and y is reassigned to x + 2, making y equal to 4. Thus, when print(x, y) executes, it outputs 6 4, showing the final values after the assignments.

.py or .pyw

Reason — The extension of a Python file is given as .py or .pyw.

Keywords

Reason — Keywords are the reserved words used by Python interpreter to recognize the structure of a program.

"This is great !"

Reason — In Python, strings enclosed in either single quotes (') or double quotes (") are valid, but the entire string must be enclosed in the same type of quote and when we want to include quotes within a string, we should use one type of quote to enclose the string and the other type of quote inside the string itself. The "This is great !" string uses double quotes (") to properly enclose the entire string. The other options have mismatched and same nested quotes, which cause syntax errors in Python.

Can be of any length

Reason — In Python, identifiers can be of any length.

//

Reason — The floor division operator in Python is represented by //.

abc = 20 30 40

Reason — In Python, the statement abc = 20 30 40 is invalid because it attempts to assign multiple values (20, 30, and 40) to a single variable (abc) in a single assignment statement.

False

Reason — The expression evaluates as follows: 10 > 5 is True because 10 is greater than 5. 7 > 12 is False because 7 is not greater than 12. 18 > 3 is True because 18 is greater than 3, and not True results in False. Combining these using Python's operator precedence, 10 > 5 and 7 > 12 evaluates to False (True and False). Then, False or not True evaluates to False (False or False). Therefore, the entire expression 10 > 5 and 7 > 12 or not 18 > 3 ultimately evaluates to False.

13

Reason — The expression 6*3+4**2//5-8 follows Python's operator precedence rules, where exponentiation (4**2) is evaluated first resulting in 16. Then, floor division (16//5) is calculated as 3. Next, multiplication (6*3) gives 18. Adding these results (18 + 3) yields 21. Finally, subtracting 8 from 21 results in 13.

82

Reason — In the above code, a is assigned the floating-point number 72.55, and b is assigned the integer 10. The variable c is assigned the expression a + b resulting in 72.55 + 10 = 82.55. Then, the int() function is used to convert the result of a + b to an integer. Therefore, int(82.55) results in 82.

print("Ankita Sharma")

Ankita Sharma

print("Kendriya Vidyalaya", "11", "A", sep = "-")

Kendriya Vidyalaya-11-A

(a) (2 + 3) ** 3 - 6/2
= 5**3 - 6/2
= 125 - 6/2
= 125 - 3.0
= 122.0

(b) (2 + 3) * 5//4 + (4 + 6)/2
= 5 * 5//4 + 10/2
= 25 // 4 + 10/2
= 6 + 10/2
= 6 + 5.0
= 11.0

(c) 12 + (3 * 4 - 6)/3
= 12 + (12 - 6)/3
= 12 + 6/3
= 12 + 2.0
= 14.0

(d) 12 + (3 ** 4 - 6)//2
= 12 + (81 - 6)//2
= 12 + 75//2
= 12 + 37
= 49

(e) 12 * 3 % 5 + 2 * 6//4
= 36 % 5 + 2 * 6//4
= 1 + 2 * 6//4
= 1 + 12 // 4
= 1 + 3
= 4

(f) 12 % 5 * 3 + (2 * 6)//4
= 2 * 3 + (2 * 6)//4
= 6 + 12 // 4
= 6 + 3
= 9

(a)

>>>(2 + 3) ** 3 - 6 / 2

122.0

(b)

>>>(2 + 3) * 5 // 4 + (4 + 6) / 2

11.0

(c)

>>>12 + (3 * 4 - 6) / 3

14.0

(d)

>>>12 + (3 ** 4 - 6) // 2

49

(e)

>>>12 * 3 % 5 + 2 * 6 // 4

4

(f)

>>>12 % 5 * 3 + (2 * 6) // 4

9

Three runtime errors that occur during Python program execution are:

1. TypeError
2. ZeroDivisionError
3. IndexError

An Error is a bug in the code that causes irregular output or stops the program from executing whereas an Exception is an irregular unexpected situation occurring during runtime on which the programmer has no control.

Syntax errors are errors that occur due to incorrect format of a Python statement. They occur while the statement is being translated into machine language and before being executed. They are the most common type of errors which are easily traceable. These errors can be corrected by the user as the reason for the error and an appropriate message about what is wrong in the program is displayed.

For example, print "Hello World" has syntax error as it violates the language protocol by not giving parentheses with the print() function. So, the corrected statement should be: print("Hello World").

Runtime errors are errors that occur while a program is executing, causing it to crash or behave unexpectedly. These errors are due to invalid operations or conditions that the program encounters during execution, which were not detected during compilation or before the program ran.

For example, 10 * (1/0) will generate runtime error as division of any number by 0 is undefined.

1. Group — It is a valid variable name.
2. if — It is a reserved keyword in Python and cannot be used as a variable name.
3. total marks — It contains a space, which is not allowed in variable names.
4. S.I. — It contains a dot (.), which is not allowed in variable names.
5. volume — It is a valid variable name.
6. tot_strength — It is a valid variable name.
7. #tag — It starts with a hash (#), which is not allowed in variable names.
8. tag$\text{\textdollar}$ — It contains a dollar sign ($\text{\textdollar}$), which is not allowed in variable names.
9. 9a — It starts with a number, which is not allowed in variable names.

8 5

x = 3
y = x + 2

• x is initialized to 3.
• y is set to x + 2, which means y = 3 + 2 = 5.

x += y

The += operator adds the value of y to x and assigns the result back to x.

• Current values are:
  • x = 3
  • y = 5
• Calculation: x + y = 3 + 5 = 8
• Updating x: x += 5 means x = x + 5
• So, x = 3 + 5 = 8.

print(x, y)

The final values of the variables are:

• x = 8
• y = 5

Hence, the output of the program is:

8 5

0 2

x += y

The += operator adds the value of y to x and assigns the result back to x.

• Current values are:
  • x = -2
  • y = 2
• Calculation: x + y = -2 + 2 = 0
• Updating x: x += 2 means x = x + 2
• So, x = -2 + 2 = 0.

y -= x

The -= operator subtracts the value of x from y and assigns the result back to y.

• Current values are:
  • x = 0
  • y = 2
• Calculation: y - x = 2 - 0 = 2
• Updating y: y -= 0 means y = y - 0
• So, y = 2 - 0 = 2.

print(x, y)

The final values of the variables are:

• x = 0
• y = 2

Hence, the output of the program is:

0 2

20 300

a = 5
b = 2 * a

• a is initialized to 5.
• b is set to 2 * a, which means b = 2 * 5 = 10.

a += a + b

The += operator adds the value on the right to a and assigns the result back to a.

• Current values are:
  • a = 5
  • b = 10
• Calculation: a + b = 5 + 10 = 15
• Updating a: a += 15 means a = a + 15
• So, a = 5 + 15 = 20.

b *= a + b

The *= operator multiplies b by the value on the right and assigns the result back to b.

• Current values are:
  • a = 20
  • b = 10
• Calculation: a + b = 20 + 10 = 30
• Updating b: b *= 30 means b = b * 30
• So, b = 10 * 30 = 300.

print(a, b)

The final values of the variables are:

• a = 20
• b = 300

Hence, the output of the program is:

20 300

66.66666666666667 126.66666666666667

p *= q / 3

The *= operator multiplies p by the value on the right and assigns it to p again.

• First, compute the division: q / 3 = 20 / 3 ≈ 6.6667
• p *= 6.6667 means p = p * 6.6667
• So, p = 10 * 6.6667 = 66.6667

q += p + q * 2

The += operator adds the value on the right to q and assigns it to q again.

• First, compute q * 2 = 20 * 2 = 40
• Then add values: p + q * 2 = 66.6667 + 40
• Finally, add it to q: q += 106.6667 means q = q + 106.6667
• So, q = 20 + 106.6667 = 126.6667

print(p, q)

The variables now have these final values:

• p = 66.6667
• q = 126.6667

The precision difference is due to floating-point arithmetic. For simplicity of explanation we have taken lesser precision values.

4 -10 7

p = 5 % 2

The modulo % operator calculates the remainder of the division.

• 5 % 2 = 1
• Thus, p = 1

q = p ** 4

The exponent ** operator raises p to the power of 4.

• 1 ** 4 = 1
• Thus, q = 1

r = p // q

The floor division // operator divides and returns the integer quotient of the division.

• 1 // 1 = 1
• Thus, r = 1

p += p + q + r

The += operator adds the value on the right to the variable and assigns it to the variable again.

• Initially, p = 1
• Calculation inside the parentheses: (p + q + r) = 1 + 1 + 1 = 3
• p += 3 means p = p + 3
• So, p = 1 + 3 = 4

r += p + q + r

The += operator adds the value on the right to the variable and assigns it to the variable again.

• Initially, r = 1
• Calculation inside the parentheses: (p + q + r) = 4 + 1 + 1 = 6
• r += 6 means r = r + 6
• So, r = 1 + 6 = 7

q -= p + q * r

The -= operator subtracts the value on the right from the variable and assigns it to the variable again.

• Initially, q = 1
• Calculation inside the parentheses: (p + q * r) = 4 + 1 * 7 = 4 + 7 = 11
• q -= 11 means q = q - 11
• So, q = 1 - 11 = -10

print(p, q, r)

The variables now have these final values:

• p = 4
• q = -10
• r = 7

Hence, the output of the program is:

4 -10 7

8 8 0

p = 21 // 5

The floor division // operator divides and returns the integer quotient of the division.

• ( 21 // 5 = 4 )
• Thus, ( p = 4 )

q = p % 4

Here, the modulo % operator calculates the remainder of the division.

• ( p % 4 = 4 % 4 = 0 )
• Thus, ( q = 0 )

r = p * q

Now it performs a multiplication.

• p x q = 4 x 0 = 0
• Thus, r = 0

p += p + q - r

The += operator adds the value on the right to the variable and assigns it to the variable again.

• Initially, ( p = 4 )
• Calculation inside the parentheses: ( p + q - r = 4 + 0 - 0 = 4 )
• p += 4 means p = p + 4
• So, p = 4 + 4 = 8

r *= p - q + r

The *= operator multiplies the variable by the value on the right and assigns it to the variable again.

• Initially, ( r = 0 )
• Calculation inside the parentheses: ( p - q + r = 8 - 0 + 0 = 8 )
• r *= 8 means r = r x 8
• So, r = 0 x 8 = 0

q += p + q

The += operator adds the value on the right to the variable and assigns it to the variable again.

• Initially, q = 0
• Calculation inside the parentheses: p + q = 8 + 0 = 8
• q += 8 means q = q + 8
• So, q = 0 + 8 = 8

print(p, q, r)

The variables now have these final values:

• p = 8
• q = 8
• r = 0

Hence, the output of the program is:

8 8 0

(a) (a + b) / 2

(b) (3**2 + 9**3) / 2

(c) 3**2 + 9**3 / 5

(d) a**0.5 + (a + 2) / b

(e) 8 - 6 + 6 * sum / 7 - var**0.5

(f) u * t + 1 / 2 * a * t**2

(a) 8 * 3 + 8 % 3

(b) (8 + 43)**(1/2)

(c) 8**(1/2) + 43**(1/2)

(d) 100//32

Operators are tokens that trigger some computation/action when applied to variables and other objects in an expression. Unary plus (+), Unary minus (-), Bitwise complement (~), Logical negation (not) are a few examples of unary operators. Examples of binary operators are Addition (+), Subtraction (-), Multiplication (*), Division (/).

An expression is any legal combination of symbols that represents a value. For example, 2.9, a + 5, (3 + 5) / 4.

A statement is a programming instruction that does something i.e. some action takes place. For example:
print("Hello")
a = 15
b = a - 10

A Python program can contain various components like expressions, statements, comments, functions, blocks and indentation.

Variables are named labels whose values can be used and processed during program run. Variables are important for a program because they enable a program to process different sets of data.

A variable pointing to a value of a certain type can be made to point to a value/object of different type.This is called Dynamic Typing. For example:

x = 10
print(x)
x = "Hello World"
print(x)

The above code performs multiple assignment, where the value 70 is assigned to both variables a and b simultaneously.

The error arises because the right-hand side (RHS) has one value (6) while the left-hand side (LHS) has two variables (z, p). This mismatch causes a ValueError.

The call to print function is missing parenthesis. The correct way to call print function is this:

print(temperature)

There are two errors in this code fragment:

1. In the statement b = a+b, variable b is undefined.

2. In the statement print(a And b), And should be written as and.

There are two errors in this code fragment:

1. The line c, b, a + a, b, c attempts to unpack values but is incomplete and incorrect. It lacks a right-hand side (RHS) to assign values from.

2. In the line print(a; b; c), the print function should use commas (,) to separate arguments, not semicolons (;).

The statement

4 = x

is incorrect as 4 cannot be a Lvalue. It is a Rvalue.

There are two errors in this code fragment:

1. Variable X is undefined.

2. "X =" and X should be separated by a comma like this print("X =", X)

15
13 22

1. X = 10 ⇒ assigns an initial value of 10 to X.
2. X = X + 10 ⇒ X = 10 + 10 = 20. So value of X is now 20.
3. X = X - 5 ⇒ X = 20 - 5 = 15. X is now 15.
4. print (X) ⇒ print the value of X which is 15.
5. X, Y = X - 2, 22 ⇒ X, Y = 13, 22.
6. print (X, Y) ⇒ prints the value of X which is 13 and Y which is 22.

2 3 6
2 3 6

1. first = 2 ⇒ first is assigned the value 2.
2. second = 3 ⇒ second is assigned the value 3.
3. third = first * second ⇒ third is calculated as first * second, which is 2 * 3 = 6.
4. print(first, second, third) ⇒ The print statement outputs 2 3 6, showing the values of first, second, and third.
5. third = second * first ⇒ third is reassigned with second * first, which is 3 * 2 = 6.
6. print(first, second, third) ⇒ The second print statement outputs 2 3 6 again, reflecting the updated value of third.

side7
7 49

1. side = int(input('side') ) ⇒ This statements asks the user to enter the side. We enter 7 as the value of side.
2. area = side * side ⇒ area = 7 * 7 = 49.
3. print (side, area) ⇒ prints the value of side and area as 7 and 49 respectively.

Comments are statements in a script that are ignored by the Python interpreter and therefore, have no effect on the actual output of the code. Comments make the code more readable and understandable for human beings. This makes the revision/modification of the code easier by the original author of the code and also by some new author who has been assigned the responsibility to modify it. They are highly recommended if the script is too complex or if it is to be reviewed by multiple people over an interval of time.

For example,

# Calculate the area of a rectangle
length = 5
width = 3
# Formula: area = length * width
area = length * width
print("Area of the rectangle is:", area)

There are no errors in the above code fragment.

The error in the above code is in the print statement. We cannot concatenate a string (Name) and an integer (Age) directly using the '+' operator. The corrected code is:

Name = "Prateek"
Age = 26
print("Your name & age are", Name + str(Age))

The error in the given code fragment occurs in the Q = A / 10 line, where it attempts to divide the string "New" by the integer 10. This is not a valid operation and will raise a TypeError.

20 81

x = 40
y = x + 1

• x is initialized to 40.
• y is set to x + 1, which means y = 40 + 1 = 41.

x, y = 20, y + x

The values of x and y are updated simultaneously. This means both assignments are evaluated first and then applied.

• The left-hand side of the assignment is x, y.
• The right-hand side is 20, y + x.
• x is set to 20.
• y is set to y + x, which means y = 41 + 40 = 81.

print(x, y)

The final values of the variables are:

• x = 20
• y = 81

Hence, the output of the program is:

20 81

50 30

1. x, y = 20, 60 ⇒ assigns an initial value of 20 to x and 60 to y.
2. y, x, y = x, y - 10, x + 10 ⇒ y, x, y = 20, 60 - 10, 20 + 10 ⇒ y, x, y = 20, 50, 30 First RHS value 20 is assigned to first LHS variable y. After that second RHS value 50 is assigned to second LHS variable x. Finally third RHS value 30 is assigned to third LHS variable which is again y. After this assignment, x becomes 50 and y becomes 30.
3. print (x, y) ⇒ prints the value of x and y as 50 and 30 respectively.

12 6.0 24

1. a, b = 12, 13 ⇒ assigns an initial value of 12 to a and 13 to b.
2. c, b = a*2, a/2 ⇒ c, b = 12*2, 12/2 ⇒ c, b = 24, 6.0. So c has a value of 24 and b has a value of 6.0.
3. print (a, b, c) ⇒ prints the value of a, b, c as 12, 6.0 and 24 respectively.

25 13 16

In the given code, using multiple assignment, three variables a, b, and c are initially assigned values 10, 20, and 30 respectively and variables p, q, and r are assigned new values: p is assigned c - 5 (resulting in 25), q is assigned a + 3 (resulting in 13), and r is assigned b - 4 (resulting in 16). When print(p, q, r) is executed, it outputs 25 13 16, representing the values after the assignments.

The input value XI is not int type compatible.

The error in the above code fragment occurs when trying to perform arithmetic operation on the result of the input() function. The input() function returns a string, even if the user enters a number. Therefore, attempting to subtract 1 from cl (which is a string) will raise a TypeError. The corrected code is:

cl = int(input("Enter your class: "))
print("Last year you were in class", cl - 1)

(a)

a = 10

(b)

a = b = c = 10

(c)

x = 20
x = x - 5
y = x

True

Reason — Python supports Unicode coding standard.

False

Reason — An identifier cannot be a Python keyword. Keywords are reserved words with special meanings and cannot be used as identifiers.

True

Reason — In Python, integers and strings are immutable data types, meaning their values cannot be changed after they are created.

False

Reason — In Python, assignment statements follow the syntax variable = value, where the variable (L-value) is on the left side and the value (R-value) is on the right side of the equal sign. Therefore, 3+C = A is an invalid statement in Python because the left side (3+C) is not a valid variable name.

False

Reason — The input() method in Python returns the input from the user as a string, regardless of whether the user enters an integer, float, or any other type of input.

True

Reason — When the print() function is called without any arguments, it outputs a newline character ('\n'), which results in printing a blank line.

False

Reason — In Python, the boolean data type is distinct and represents one of the two possible values — True or False.

False

Reason — In Python, variable names cannot contain hyphens. They can only contain letters (both uppercase and lowercase), digits, and underscores, but they cannot start with a digit. Therefore, "AISSCE-2020" is invalid string variable name because it contains a hyphen.

False

Reason — In Python, the float data type represents numbers with a fractional part, while the integer data type represents whole numbers without any fractional part.

False

Reason — In Python, the absence of a value is represented by the None keyword, not "null" literal.

True

Reason — Python supports multiple assignments to multiple variables in a single line.
For example, msg, day, time = 'Meeting', 'Mon', 9