Python Revision

(a) The data types are as follows:

(b) No, a, b, c, and d are not storing exactly the same values. While the values of b and c look like integers (numerical 5), they are enclosed within quotes, making them strings. On the other hand, a is an integer number, and d is a floating-point number with a decimal point.

So, although they all represent the number 5, they are stored as different data types.

(c) The output of the following code will be :

False
True
True

(d) The reasons behind the output of part c are as follows:

1. print a == b

This comparison checks if the value of a is equal to the value of b. Even though the values of a and b are both 5, they are not of the same data type (int vs. str). Python strictly checks for both value and type equality in this case, so the comparison evaluates to False.

2. print b == c

This comparison checks if the value of b is equal to the value of c. Since both b and c are strings with the same content ("5"), the comparison evaluates to True.

3. print a == d

This comparison checks if the value of a is equal to the value of d. Although they have different data types (int vs. float), their numerical values are the same (both represent 5). Python performs type coercion in this case and considers them equal, so the comparison evaluates to True.

(a) The values stored in a, b, c, d are as follows:

(b) The data types of a, b, c and d are as follows:

(c) The values of 'c' and 'd' are not the same because of the difference in the division operation performed in each case:

'c' is the result of dividing two floating-point numbers, which preserves the decimal point and gives a floating-point result. 'd' is the result of dividing two integers, which truncates the fractional part and gives an integer result.

print

Reason — The print statement is used to display something on screen.

raw_input

Reason — The raw_input function is used to get value for a variable from keyboard.

NUMBER

Reason — NUMBER is not a Python data type. Numbers are stored using int, float and long data types.

string

Reason — A string literal is always enclosed in single quotes or double quotes.

True

Reason — a >= b compares a and b and returns true if a is greater than or equal to b, else returns false. Since 8 is equal to 8, the given expression results in 'true'.

8 >= 8

Reason — Since 8 >= 8 is enclosed in quotes, it is treated as a String and printed on the output terminal as it is.

True

Reason — The given expression (8 >= 8) results in true as 8 is equal to 8. Thus, 'true' is printed on the output terminal.

12

Reason — The given expression 3*2**2 is evaluated as follows:

= 3 * 2 ** 2
= 3 * 4 (Since exponentiation (**) has higher precedence than multiplication (*))
= 12

Thus, 12 is printed as output.

36

Reason — The given expression (3*2)**2 is evaluated as follows:

= (3 * 2) ** 2
= 6 ** 2 (Since parentheses has higher precedence than exponentiation (**))
= 36

Thus, 36 is printed as output.

Parenthesis (())

Reason — Parenthesis (()) has the highest precedence in an expression.

The smallest individual unit in a program is known as a Token. Python has following tokens:

1. Keywords — Examples are import, for, in, while, etc.
2. Identifiers — Examples are MyFile, DS, DATE9777, etc.
3. Literals — Examples are "abc", 5, 28.5, etc.
4. Operators — Examples are +, -, >, or, etc.
5. Punctuators — ' " # () etc.

Keywords are reserved words carrying special meaning and purpose to the language compiler/interpreter. For example, if, elif, etc. are keywords. Identifiers are user defined names for different parts of the program like variables, objects, classes, functions, etc. Identifiers are not reserved. They can have letters, digits and underscore. They must begin with either a letter or underscore. For example, _chk, chess, trail, etc.

Literals are data items that have a fixed value. The different types of literals allowed in Python are:

1. String literals
2. Numeric literals
3. Boolean literals
4. Special literal None
5. Literal collections

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 (/).

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

Data types are used to identify the type of data a memory location can hold and the associated operations of handling it.

The data that we deal with in our programs can be of many types like character, integer, real number, string, boolean, etc. hence programming languages including Python provide ways and facilities to handle all these different types of data through data types. The data types define the capabilities to handle a specific type of data such as memory space it allocates to hold a certain type of data and the range of values supported for a given data type, etc.

Two integer types are supported by Python. They are:

1. Integers (signed)
2. Booleans

Solution

n = int(input("Enter n: "))
n2, n3 = n ** 2, n ** 3
print("n =", n)
print("n^2 =", n2)
print("n^3 =", n3)

Output

Enter n: 2
n = 2
n^2 = 4
n^3 = 8

The smallest individual unit in a program is known as a Token. Python has following tokens:

1. Keywords — Examples are import, for, in, while, etc.
2. Identifiers — Examples are MyFile, DS, DATE9777, etc.
3. Literals — Examples are "abc", 5, 28.5, etc.
4. Operators — Examples are +, -, >, or, etc.
5. Punctuators — ' " # () etc.

Keywords are words having special meaning reserved by programming language.
No, keywords cannot be used as identifiers.

Identifiers are fundamental building blocks of a program and are used as the general terminology for the names given to different parts of the program viz variables, objects, classes, functions, lists, dictionaries etc. For example, Myfile, _DS, _name_01, H34CAP etc.

The identifier forming rules of Python are:

1. An identifier starts with a letter A to Z or a to z or an underscore (_) followed by zero or more letters, underscores, and digits (0 to 9).
2. Python does not allow punctuation characters such as @, $, and % within identifiers.
3. Reserved words (keywords) must not be used as identifiers.

Literals are data items that have a fixed value. The different types of literals allowed in Python are:

1. String literals
2. Numeric literals
3. Boolean literals
4. Special literal None
5. Literal collections

The types of integer literals allowed in Python are as follows:

1. Decimal form — Integers written in decimal form do not begin with a zero and contain only 0 to 9 digits.
2. Octal form — Integers written in octal form begin with a 0 and contain only 0 to 7 digits.
3. Hexadecimal form — Integers written in hexadecimal form begin with a 0x and contain only 0 to 9 digits and A to F or a to f letters.

Python allows us to have certain non-graphic characters in String values. These non-graphic characters can be represented by using escape sequences — represented by a backslash ( \ ) followed by one or more characters.

Some examples of non-graphic characters and their escape sequences are as follows:

We can form string literals by enclosing text in both forms of quotes — single quotes or double quotes. For example, 'Astha', "Rizwan", 'Hello World', "112FB0291", etc.

Python allows us to have two string types :

1. Single line Strings — These strings terminate in single line. For example, "I am a single line string" , "Hello World!"
2. Multiline Strings — These strings spread across multiple lines. These strings are created in following two ways :
   1. by adding a backslash at the end of physical line, for example,
      multiline_string_variable = "Hello \
      World !"
   2. by enclosing the multiple lines of string in triple quotes, for example,
      Str1 = ''' Hello
      World.
      There I Come ! ! !
      Cheers.
      '''

Floating point literals represent real numbers and are written with a decimal point dividing the integer and fractional parts.

Floating literals are represented in Python in two forms —

1. Fractional Form — 2.0, 17.5, -13.0, -0.00625
2. Exponent form — 152E05, 1.52E07, 0.152E08, -0.172E-3

The two Boolean literals in Python are true and false.