Unit 1: Setting up your Programming Environment; Variables, Expression and Statements - Subjective Questions

Python versions represent different releases of the Python language. Python 3 is the current and recommended major version, while Python 2 is obsolete and no longer officially supported.

• New versions introduce features, performance improvements, and security fixes.
• Code written for one version may not work identically in another version.
• The installed version can be checked from a terminal or command prompt using python --version or python3 --version.
• It can also be checked within a program using import sys followed by print(sys.version).

Programmers should confirm the required Python version before installing packages or running a project.

Python can be installed and configured on Windows through the following steps:

1. Download a current Python 3 installer from the official Python website.
2. Run the installer and select Add Python to PATH.
3. Choose Install Now or customize the installation when necessary.
4. Complete the installation and open Command Prompt or PowerShell.
5. Run python --version to verify the installation.
6. Start the interactive interpreter by entering python.
7. Optionally verify pip using pip --version.

Adding Python to PATH allows commands such as python and pip to be executed from any working directory.

The program is:

print("Hello, World!")

To run it on Windows:

1. Open a text editor or Python IDE.
2. Enter the program and save it as hello.py.
3. Open Command Prompt or PowerShell.
4. Use cd to move to the directory containing the file.
5. Execute python hello.py.

The print() function sends the string Hello, World! to standard output. The .py extension identifies the file as a Python source file.

A variable is a name that refers to a value. Python creates a variable when an assignment statement is executed.

• age = 18 assigns the integer 18 to age.
• name = "Ravi" assigns a string to name.
• age = age + 1 reads the current value, adds 1, and reassigns the result to age.
• A variable may later refer to a value of another type, as in age = "eighteen".

The = symbol is the assignment operator, not a statement of mathematical equality. The expression on its right is evaluated first, and the resulting value is assigned to the name on its left.

A NameError occurs when Python tries to use a name that has not been defined in the accessible scope.

Common causes include:

• Using a variable before assigning it, such as print(total) before defining total.
• Misspelling a variable name, for example defining score but using scroe.
• Using incorrect capitalization because Name and name are different identifiers.
• Referring to a variable outside the scope where it was created.
• Forgetting quotation marks around string text, such as city = London instead of city = "London".

A programmer can avoid this error by initializing variables before use, using consistent spelling and capitalization, quoting string literals, and choosing clear variable names.

• A value is an item of data, such as 25, 3.5, "Python", or True.
• A variable is a name that refers to a value, such as count in count = 25.
• A data type classifies a value and determines the operations that can be performed on it.

Examples include:

• 25 has type int.
• 3.5 has type float.
• "Python" has type str.
• True has type bool.

The type of a value can be inspected using type(), for example type(25) returns <class 'int'>. In language = "Python", language is the variable, "Python" is the value, and str is its type.

Common Python value types include:

• int: whole numbers, such as 12 and -4.
• float: decimal numbers, such as 2.5.
• str: textual data, such as "42".
• bool: logical values, namely True and False.
• NoneType: the absence of a value, represented by None.

Type conversion uses constructor functions:

• int("42") produces the integer 42.
• float("3.5") produces the floating-point value 3.5.
• str(100) produces the string "100".
• bool(0) produces False, while bool(1) produces True.

Conversions must be valid. For example, int("hello") raises a ValueError because the text does not represent an integer.

Python variable names must follow these rules:

• A name may contain letters, digits, and underscores.
• It must not begin with a digit.
• It must not contain spaces or symbols such as -, @, or #.
• It must not be a Python keyword.
• Names are case-sensitive, so total, Total, and TOTAL are different.

Recommended conventions include:

• Use descriptive names such as student_count rather than sc.
• Use snake_case for ordinary variable names.
• Avoid replacing built-in names such as list, str, and sum.
• Use uppercase names such as MAX_SIZE for values treated as constants.

For example, student_name is valid and clear, while 2name, student-name, and class are invalid.

Keywords are reserved words that have predefined grammatical meanings in Python. Examples include if, else, for, while, def, class, return, True, False, and None.

They cannot be used as ordinary variable names because the Python parser uses them to recognize program structure. For example, class = 10 causes a SyntaxError because class begins a class definition.

The current keyword list can be displayed with:

import keyword
print(keyword.kwlist)

The list can vary between Python versions, so the keyword module provides a reliable way to inspect it.

A statement is an instruction that Python can execute.

• An assignment statement binds a name to a value: price = 50.
• An expression statement evaluates an expression, such as a function call: len("Python").
• An output statement, commonly implemented as a function call, displays information: print(price).
• A compound statement controls or groups other statements, such as if price > 0:.

In total = price * 2, Python evaluates the expression price * 2 and then assigns its value to total. Statements usually execute sequentially unless a control-flow statement changes the order.

An operator is a symbol or keyword that specifies an operation, while an operand is a value on which the operation acts. In 8 + 2, + is the operator and 8 and 2 are operands.

Major operator categories include:

• Arithmetic: +, -, *, /, //, %, and **.
• Comparison: ==, !=, <, >, <=, and >=.
• Logical: and, or, and not.
• Assignment: =, +=, -=, and similar operators.
• Membership: in and not in.
• Identity: is and is not.

For example, 17 // 5 gives 3, 17 % 5 gives 2, and 2 ** 3 gives 8.

These arithmetic operators perform different operations:

• / performs true division. For example, 17 / 5 gives 3.4.
• // performs floor division. For example, 17 // 5 gives 3.
• % returns the remainder. For example, 17 % 5 gives 2.
• ** performs exponentiation. For example, 2 ** 4 gives 16.

Division can be described by:

Therefore, the quotient from floor division is 3 and the remainder is 2. An important detail is that // rounds down toward negative infinity, so -17 // 5 evaluates to -4, not -3.

Python generally follows this precedence order:

1. Parentheses
2. Exponentiation
3. Multiplication, division, floor division, and remainder
4. Addition and subtraction

For 2 + 3 * 4 ** 2 - 8 / 2:

• Exponentiation: .
• Multiplication: .
• Division: .
• Addition and subtraction are evaluated from left to right: .

Therefore, result is 46.0. The final value is a float because / produces a floating-point result.

Associativity determines the evaluation direction when operators have the same precedence.

• Most arithmetic operators of equal precedence are evaluated from left to right. Thus, 20 / 5 * 2 becomes (20 / 5) * 2, producing 8.0.
• Exponentiation is right-associative. Therefore, 2 ** 3 ** 2 is interpreted as 2 ** (3 ** 2).

Its evaluation is:

By contrast, (2 ** 3) ** 2 gives . Parentheses should be used whenever the intended grouping might be unclear.

Python supports several useful string operations:

• Concatenation: "Py" + "thon" produces "Python".
• Repetition: "ha" * 3 produces "hahaha".
• Indexing: "Python"[0] produces "P"; negative indexing such as "Python"[-1] produces "n".
• Slicing: "Python"[1:4] produces "yth" because the ending index is excluded.
• Membership: "th" in "Python" produces True.
• Length: len("Python") produces 6.

Strings are immutable, meaning their individual characters cannot be changed in place. An operation that appears to modify a string actually creates a new string.

The + operator behaves according to the operand types:

• With numbers, it performs arithmetic addition: 10 + 5 gives 15.
• With strings, it performs concatenation: "10" + "5" gives "105".

Python does not automatically concatenate a string and an integer. Therefore, "Age: " + 18 raises a TypeError.

The operands must be converted explicitly:

• "Age: " + str(18) produces "Age: 18".
• int("10") + int("5") produces 15.

An f-string is often clearer for formatted output: f"Age: {18}". The distinction is important because values that look similar can behave differently when their types differ.

Composition means combining smaller expressions and operations to construct a larger computation. The result of one expression can become an operand or function argument in another expression.

For example:

radius = 5
area = 3.14159 * radius ** 2
print("Area:", round(area, 2))

This code composes several elements:

• radius ** 2 calculates the square.
• The result is multiplied by 3.14159.
• round(area, 2) returns a rounded value.
• The rounded value becomes an argument to print().

Composition makes programs concise, but very long expressions should be divided into well-named intermediate variables when that improves readability.

One possible program is:

student_name = "Asha"
mark1 = 78
mark2 = 84
mark3 = 91

total = mark1 + mark2 + mark3
average = total / 3

print(f"Student: {student_name}")
print(f"Total: {total}")
print(f"Average: {average:.2f}")

Explanation:

• student_name, mark1, mark2, and mark3 store input values.
• The + operator calculates the total.
• The / operator calculates the average using .
• total / 3 composes a variable and an arithmetic operation.
• The f-strings compose labels, variables, and formatting instructions.
• :.2f displays the average with two digits after the decimal point.

A comment is explanatory text ignored by the Python interpreter. A single-line comment begins with #, as in # Calculate the final price. Inline comments may follow code, although they should be used sparingly.

A docstring is a string literal placed at the beginning of a module, class, or function to document its purpose. Unlike a comment, it is available at runtime through tools such as help() and the __doc__ attribute.

Good practices include:

• Explain why a decision was made rather than restating obvious code.
• Keep comments accurate and update them when code changes.
• Use clear variable names so fewer comments are needed.
• Avoid commented-out code in finished programs.
• Use docstrings for public modules, classes, and functions.

A corrected version is:

course_name = "Python"
score = 40
bonus = 5
total = score + bonus
print("Total: " + str(total))

Alternatively, the final line can be written as print(f"Total: {total}").

Corrections:

• class is a Python keyword, so it is replaced by course_name.
• Python must be enclosed in quotation marks because it is string data.
• 2score is invalid because a variable name cannot begin with a digit; it is replaced by score.
• bonus must be assigned before it is used, otherwise a NameError occurs.
• A string and an integer cannot be joined directly with +; total must be converted with str() or inserted into an f-string.

The corrected program displays Total: 45.