4. Elements of Python: Questions and Answers

b) Guido van Rossum

Python was created by Guido van Rossum in 1991.

b) interpreted, dynamically typed

Python code is executed line by line.

b) Python prompt

It shows that Python is ready to accept commands.

a) Read-Eval-Print-Loop

a) Integrated Development and Learning Environment

c) .py

a) Run > Run Module (F5)

b) #

b) multi-line comment

Python has no separate multi-line comment symbol.

c) print

print is a built-in function, not a keyword. All keywords except None, True and False are in lowercase.

d) basic_pay

2A starts with a digit, user@name has a special character and total value has a space.

c) string

Use int() or float() to convert it to a number.

c) List

List, Set and Dictionary are mutable; numeric, string, Boolean and tuple are immutable.

c) Set

Elements of a set have no defined order and cannot be accessed by index.

d) Dictionary

c) Floor division

5 // 2 = 2 and -5 // 2 = -3.

b) 1

% gives the remainder after division.

b) 'HiHiHi'

A string can be multiplied by an integer only.

a) Parentheses ( )

c) is

Guido van Rossum (in 1991).

Shell.

Prompt.

Interactive mode.

.py

Online.

# (hash symbol).

Keyword.

Identifier.

Case-sensitive.

Dynamically typed.

type().

String.

Immutable.

Dictionary; set.

Exponentiation (power).

Membership.

print().

Python is an interpreted, dynamically-typed, easy-to-learn programming language used worldwide by beginners and experts. It was created by Guido van Rossum in 1991. Features: it is free and open-source; it is portable and platform-independent (runs on Windows, macOS and Linux); it supports procedural, object-oriented and functional programming; and code is executed line by line.

Python is used for web development, game development, data science and analysis, artificial intelligence, Internet of Things (IoT), cybersecurity, machine learning and scientific computing.

Python is free and can be installed on Windows, macOS and Linux. The latest version can be downloaded from the official website https://www.python.org. The package includes the Python interpreter and a basic code editor.

1. Interactive mode
2. Scripting mode
3. Online platform mode

The Python shell is an interactive environment where code is executed immediately after pressing Enter (REPL: Read-Eval-Print-Loop). The prompt >>> shows Python is ready. Advantage: immediate feedback, so it is good for testing single-line statements. Statements cannot be saved for future use.

IDLE (Integrated Development and Learning Environment) is Python's integrated environment containing a built-in editor, debugger and interpreter, so programs can be written, saved and run in one place. Other popular IDEs/editors are Geany, PyCharm, Jupyter Notebook, Thonny, VS Code and Spyder.

Python code is written and executed in a web-based interface with no local installation. Examples: Google Colab, Replit, Kaggle Notebooks, Deepnote, Binder.

Comments are notes written within the program code to explain it, making it easier for programmers to read and understand. They are used for internal documentation. The Python interpreter completely ignores them during execution.

• Single-line comment: begins with # and everything after it on that line is a comment. Example: # Simple program
• Multi-line comment: a string in triple single quotes (''') or triple double quotes (""") not assigned to a variable. Python has no separate multi-line comment symbol.

A keyword is a reserved word with a special meaning in Python, used to define the syntax and structure of a program. All keywords except None, True and False are in lowercase. Examples: if, else, while, for, def, class, import, return.

An identifier is a name used to define a variable, function, class or module.

• Only letters (A-Z, a-z), digits (0-9) or underscore are allowed.
• Must not start with a digit.
• Python keywords cannot be used.
• Whitespaces and special characters are not allowed.
• Identifiers are case-sensitive (Grade, grade and GRADE are different).

A variable is a symbolic name used to store data that may change value during program execution. It can store integers, floats, strings, lists, dictionaries, etc. A variable is created by assigning a value with the assignment operator (=). Example: rollno=12, name="Arun", price=85.5.

Python variables are dynamically typed: there is no need to declare them before use, and the data type changes automatically when the variable is reassigned to a different type of value. Example: n=10 (integer), then n="Hello" (string), then n=True (Boolean).

A data type is a classification of data values that specifies what kind of value a variable can hold and which operations can be performed on it. Four built-in types: int, float, str, list (others: complex, bool, tuple, set, dict, NoneType).

• Integer (int): positive or negative whole numbers without a decimal part, e.g. 27, -36, 412, 0.
• Float: numbers with a fractional part, e.g. 3.5, 0.0, -12.75.
• Complex: numbers of the form a + bj, where a is the real part and b the imaginary part. complex(2, 5) gives (2+5j).

A Boolean value is one of two logical values, True or False. It belongs to the class bool. Example: a=True; type(a) gives <class 'bool'>.

A sequence is an ordered group of values arranged one after another; each value has a fixed position (index) and is accessed using it. The three sequence types are string, list and tuple.

A string is a sequence of Unicode characters created using single or double quotes. There is no character data type; a single character is a string of length one. Characters are accessed by index, which starts from 0; a negative index counts from the end. Strings belong to the class str and are immutable. Example: s1="Programming": s1[0] is P, s1[4] is r, s1[-1] is g.

A list is an ordered sequence of items separated by commas and enclosed in square brackets [ ]. Items are accessed by index, and lists are mutable. Example: x=[10, "Delhi", 65.5, 'A2', 40]; x[0] is 10, x[3] and x[-2] are both 'A2', x[-1] is 40.

A tuple is an ordered collection of objects of any data type, separated by commas and enclosed in parentheses ( ). The only difference from a list is that tuples are immutable. Example: t1=(40, "Computer", 65.5, 'Phone'); t1[0] is 40 and t1[-1] is Phone.

None represents the absence of a value; it indicates nothing, null or an empty result. It belongs to the class NoneType. Example: x=None; print(x) displays None.

A set is a collection of unordered, unique elements, enclosed in braces { } and separated by commas. Characteristics: elements have no defined order, so they cannot be accessed by index; duplicate elements are eliminated; sets are mutable; mathematical set operations like union, intersection and difference can be performed. Example: {10,20,30,20} gives {10, 20, 30}. set() creates an empty set.

A dictionary stores data as key-value pairs inside braces { } and allows efficient lookup or modification of values using their keys. Values can be of any data type. Key-value pairs can be added and removed. It belongs to class dict and is mutable. {} creates an empty dictionary.

mark={'Diya': 70, 'Biju': 65, 'Thomas': 58}
print(mark['Biju'])      # 65
mark['Fathima']=75       # add a key-value pair
del mark['Diya']         # remove a key-value pair

Operators are special symbols that carry out operations on values or variables. Types: arithmetic, assignment, relational, logical, identity and membership operators.

Logical operators combine one or more conditions and return True or False. Assume a=20, b=10.

Identity operators check whether two variables refer to the same object in memory: is and is not.

x=[1,2,3]
y=[1,2,3]
print(x is y)       # False, different objects
z=x
print(x is z)       # True, same object
print(x is not y)   # True

Membership operators check whether a value or variable is found in a sequence: in and not in.

a=[10,20,30]
print(10 in a)         # True
print(50 in a)         # False
text='Python'
print('P' not in text) # False
print('k' not in text) # True

An expression is a combination of values, variables and operators that can be evaluated to produce another value. Operator precedence decides which operation is performed first when an expression has more than one operator.

40 + 50 * 3          # * before +
= 40 + 150 = 190

(30 - 20) * 5        # parentheses first
= 10 * 5 = 50

60 / 5 - (6 + 2)     # parentheses first, then /, then -
= 60 / 5 - 8 = 12.0 - 8 = 4.0

input() receives data from the keyboard and always returns a string value. Syntax: variable=input("Prompt message").

name=input("Enter your name : ")
print("Entered Name : " + name)

Output

Enter your name : Akhil
Entered Name : Akhil

print() displays strings, numbers or values of variables on the screen. Syntax: print("Display message").

print("Welcome to Python")
x=10
print("Value of x is", x)

input() always returns a string, so '10' + '20' would join the strings to give '1020'. int() converts the input to an integer so that the numbers are added: int('10') + int('20') = 30.

num1=int(input("Enter first number : "))
num2=int(input("Enter second number : "))
total=num1 + num2
print("Total :",total)

Output

Enter first number : 10
Enter second number : 20
Total : 30

a=int(input("Enter first number : "))
b=int(input("Enter second number : "))
c=int(input("Enter third number : "))
average=(a + b + c) / 3
print("Average :",average)

Output

Enter first number : 60
Enter second number : 70
Enter third number : 80
Average : 70.0

a=10
b=3
print("Addition       :", a + b)
print("Subtraction    :", a - b)
print("Multiplication :", a * b)
print("Division       :", a / b)
print("Floor division :", a // b)
print("Modulus        :", a % b)
print("Exponent       :", a ** b)

Output

Addition       : 13
Subtraction    : 7
Multiplication : 30
Division       : 3.3333333333333335
Floor division : 3
Modulus        : 1
Exponent       : 1000

length=float(input("Enter length : "))
breadth=float(input("Enter breadth : "))
area=length * breadth
perimeter=2 * (length + breadth)
print("Area :",area)
print("Perimeter :",perimeter)

Output

Enter length : 5
Enter breadth : 3
Area : 15.0
Perimeter : 16.0

p=float(input("Enter principal : "))
r=float(input("Enter rate : "))
t=float(input("Enter time in years : "))
si=p * r * t / 100
print("Simple interest :",si)

Output

Enter principal : 1000
Enter rate : 5
Enter time in years : 2
Simple interest : 100.0

a=int(input("Enter a : "))
b=int(input("Enter b : "))
temp=a
a=b
b=temp
print("After swapping: a =",a,", b =",b)

Output

Enter a : 4
Enter b : 9
After swapping: a = 9 , b = 4

name=input("Enter name : ")
mark=int(input("Enter mark : "))
student={name: mark}
print(student)
student["Biju"]=65
print(student)

Output

Enter name : Diya
Enter mark : 70
{'Diya': 70}
{'Diya': 70, 'Biju': 65}

a=5
b=2
print(a % b)

Output

1

5 divided by 2 leaves remainder 1.

x="Hello"
print(x * 3)

Output

HelloHelloHello

A string multiplied by an integer is repeated that many times.

print(10 > 5 and 5 < 3)

Output

False

10 > 5 is True and 5 < 3 is False. 'and' gives True only if both are True, so the result is False. (In the textbook it is printed without spaces as 10>5and5<3; write spaces in a real program.)

fruits=["apple","banana","cherry"]
print("banana" in fruits)

Output

True

'banana' is found in the list, so the membership operator 'in' gives True.

a=10
b=a
print(a is b)

Output

True

b=a makes both names refer to the same object, so 'is' gives True.

• Prompt message in input() is not in quotes. It must be a string: input("Enter your name").
• print("Hello" name) has no operator between the two items. Use + or a comma: print("Hello" + name) or print("Hello", name).

name=input("Enter your name : ")
print("Hello", name)

y="20" is a string, so x + y tries to add an integer and a string, which gives a TypeError. Convert the string to an integer, or store y as a number.

x=10
y=int("20")      # or y=20
total=x + y
print(total)       # 30

• 1stNumber is invalid because an identifier must not start with a digit.
• second number is invalid because identifiers cannot contain whitespace.

firstnumber=50
second_number=60
print(firstnumber + second_number)   # 110

• (10,20,30) with parentheses is a tuple, not a list. Tuples are immutable, so list[1]=50 gives a TypeError.
• list is also the name of a built-in type; avoid using it as a variable name. Use square brackets to make a mutable list.

numbers=[10,20,30]
numbers[1]=50
print(numbers)   # [10, 50, 30]

result is an integer (25) and "Result is " is a string; the + operator cannot join a string and an integer, so there is a TypeError. Use a comma or convert with str().

a=5
b=2
result=a ** b
print("Result is", result)        # Result is 25
print("Result is " + str(result)) # Result is 25

• Interactive mode: the Python shell (prompt >>>, REPL) executes each statement immediately and shows the output. Statements cannot be saved; used for testing single-line statements.
• Scripting mode: multiple statements are written as a program and saved as a .py file (e.g. in IDLE: File > New File, then Run > Run Module / F5). The output appears in the shell.
• Online platform mode: code is written and run in a web browser on platforms like Google Colab, Replit, Kaggle Notebooks, Deepnote and Binder. No installation needed, but internet is required, file handling is limited and it is not suitable for large projects.

Mutable types: list, set, dictionary. Immutable types: numeric, string, Boolean, tuple.

mark=60
print(type(mark))     # <class 'int'>
price=35.5
print(type(price))    # <class 'float'>
x=complex(2,5)
print(x)              # (2+5j)

An identifier is a name used to define a variable, function, class or module. It helps the programmer identify and differentiate entities, and should be short and meaningful.

• Only letters (A-Z, a-z), digits (0-9) or underscore are allowed.
• Must not start with a digit.
• Python keywords cannot be used.
• Whitespaces and special characters are not allowed.
• Identifiers are case-sensitive.

Arithmetic operators perform basic mathematical operations; assignment operators assign or update the value of a variable.

Logical operators combine one or more conditions and return True or False. 'and' is True only if both conditions are True; 'or' is True if at least one is True; 'not' reverses the result. With a=20 and b=10:

• Set: unordered collection of unique elements in { }; mutable; no indexing; removes duplicates; supports union, intersection and difference.
• Dictionary: key-value pairs in { }; values accessed by key; mutable; keys can be added or removed.

x={10,20,30,20}
print(x)              # {10, 20, 30}

mark={'Diya': 70, 'Biju': 65, 'Thomas': 58}
print(mark['Biju'])   # 65
mark['Fathima']=75    # add
del mark['Diya']      # remove
print(mark)           # {'Biju': 65, 'Thomas': 58, 'Fathima': 75}

When an expression has more than one operator, precedence decides which is performed first. Level 1 is the highest priority: ( ), then **, unary +/-, then * / // %, then + -, then relational/identity/membership operators, then not, and, or.

40 + 50 * 3       # 190  (* before +)
(30 - 20) * 5     # 50   (parentheses first)
60 / 5 - (6 + 2)  # 4.0  (parentheses, then /, then -)

• input(): receives data from the keyboard and always returns a string. Syntax: variable=input("Prompt message").
• print(): displays strings, numbers or variable values. Syntax: print("Display message").

Example: program to add two integers (int() converts the strings to integers).

num1=int(input("Enter first number : "))
num2=int(input("Enter second number : "))
total=num1 + num2
print("Total :",total)

Output

Enter first number : 10
Enter second number : 20
Total : 30

• Comments: notes ignored by the interpreter, used for internal documentation. # for single-line; triple quotes for multi-line.
• Keywords: reserved words with special meaning (if, else, while, for, def, class, import...). All lowercase except None, True and False.
• Variables: symbolic names that store data that may change. Created by assignment; dynamically typed, so the type changes when a new value is assigned.

# Simple program
n=10        # n is an integer
n="Hello"   # now n is a string
n=True      # now n is Boolean
print(n)