Unit 1: Python Environment Setup and Basics - Subjective Questions

Anaconda installation and Jupyter usage:

1. Download the appropriate Anaconda distribution for the operating system from the official website.
2. Run the installer and select the required installation options.
3. Add Anaconda to the system path if necessary, or use the Anaconda Navigator application.
4. Open Anaconda Navigator and launch Jupyter Notebook.
5. In Jupyter Notebook, create a new Python notebook using the Python 3 kernel.
6. Enter Python code into cells and execute a cell using Shift + Enter.
7. Save the notebook with the .ipynb extension.

Anaconda provides Python along with useful libraries and tools, while Jupyter supports interactive programming, documentation, visualization, and experimentation.

Comparison:

• Anaconda: A Python distribution that includes the interpreter, package manager, libraries, and development tools. It is especially useful for data science and scientific computing.
• Jupyter Notebook: An interactive environment where code, output, mathematical expressions, and explanatory text can be combined in notebook cells. It is suitable for learning, analysis, and demonstrations.
• Visual Studio Code: A general-purpose source-code editor that can be extended with Python extensions. It supports debugging, source control, project management, and script development.

Anaconda focuses on Python distribution and package management, Jupyter focuses on interactive execution, and VS Code focuses on structured software development.

Python syntax rules:

• Python uses indentation to define blocks of code instead of braces. Consistent spaces, commonly four, must be used.
• A comment begins with # and is ignored during execution.
• An identifier is a name given to variables, functions, or other objects. It may contain letters, digits, and underscores, but it cannot begin with a digit or be a reserved keyword.
• A statement is an instruction executed by Python, such as an assignment or function call.
• Python is case-sensitive, so value and Value are different identifiers.
• A colon : is generally placed after statements that introduce a block, such as if, for, or while.

Example:

if temperature > 30:
    print("Hot day")

The indentation determines which statement belongs to the if block.

A variable is a name that refers to a value in memory. Python variables do not require an explicit type declaration because the type is inferred from the assigned value.

Examples of common data types include:

• int: whole numbers, such as 25
• float: decimal numbers, such as 3.14
• complex: complex numbers, such as 2 + 3j
• bool: logical values, such as True and False
• str: text, such as "Python"
• list: ordered and mutable collection, such as [1, 2, 3]
• tuple: ordered and immutable collection, such as (1, 2, 3)
• set: unordered collection of unique values, such as {1, 2, 3}
• dict: collection of key-value pairs, such as {"name": "Asha"}

Example:

age = 20
name = "Asha"
marks = 85.5
passed = True

The type() function can be used to inspect the type of a value.

Python operators:

• Arithmetic operators: +, -, *, /, //, %, and ** perform calculations.
• Assignment operators: =, +=, -=, *=, and /= assign or update values.
• Comparison operators: ==, !=, >, <, >=, and <= compare values and produce Boolean results.
• Logical operators: and, or, and not combine or reverse Boolean expressions.
• Membership operators: in and not in test whether a value occurs in a sequence or collection.
• Identity operators: is and is not test whether two references point to the same object.

Example:

x = 10
print(x >= 5 and x < 20)
print(3 in [1, 2, 3])

Comparison and logical operators produce either True or False.

An expression is a combination of values, variables, operators, and function calls that Python evaluates to produce a result. The values and variables are called operands, while symbols or keywords such as + and and are called operators.

Examples:

result = 4 + 5 * 2
average = total / count
valid = age >= 18 and citizen is True

In the first expression, multiplication is performed before addition, so the result is . Parentheses can be used to specify the desired order:

result = (4 + 5) * 2

This expression produces . Expressions may produce numbers, strings, Boolean values, or other objects.

Operator precedence determines which operator is applied first, while associativity determines the evaluation direction when operators have the same precedence. A simplified order is:

1. Parentheses
2. Exponentiation **
3. Multiplication, division, floor division, and modulus
4. Addition and subtraction
5. Comparisons
6. not
7. and
8. or

For the expression:

Evaluation proceeds as follows:

• Exponentiation:
• Multiplication and division: and
• Addition and subtraction:

Therefore, the result is . Parentheses should be used when they improve clarity or alter the default order.

Python uses the input() function to accept data from the user and the print() function to display output. The value returned by input() is always a string, so it must be converted when numeric input is required.

first = float(input("Enter the first number: "))
second = float(input("Enter the second number: "))
sum_value = first + second
print("The sum is:", sum_value)

In this program:

• input() reads values from the keyboard.
• float() converts the entered text into a decimal number.
• The + operator calculates the sum.
• print() displays the result.

The print() function can also use keyword arguments such as sep and end to control formatting.

A module is a Python file containing definitions such as functions, variables, and classes. Modules support code organization and reuse.

The math module provides mathematical constants and functions. It can be imported in several ways:

import math
print(math.sqrt(25))
print(math.pi)

A specific function can be imported as follows:

from math import factorial
print(factorial(5))

An alias may also be used:

import math as m
print(m.ceil(4.2))

Common functions include sqrt(), pow(), ceil(), floor(), factorial(), and trigonometric functions. Importing modules avoids rewriting commonly used code and improves program structure.

Python represents text using the string data type, written as str. Strings are sequences of Unicode characters and can be enclosed in single quotes, double quotes, or triple quotes.

text1 = 'Python'
text2 = "Programming"
text3 = """This is a multiline string."""

Strings support indexing and slicing:

word = "Python"
print(word[0])      # P
print(word[-1])     # n
print(word[1:4])    # y thon portion: "yth"

The first character has index , and negative indices count from the end. Strings are immutable, meaning their individual characters cannot be changed directly. A new string must be created instead:

word = "Python"
word = "J" + word[1:]

Python uses Unicode, allowing strings to represent text from many languages and writing systems.

Python provides many operations and methods for processing strings.

• Concatenation joins strings using +.
• Repetition uses *.
• len() returns the number of characters.
• lower() and upper() change letter case.
• strip() removes leading and trailing whitespace.
• split() divides a string into a list.
• join() combines sequence elements.
• replace() substitutes part of a string.
• find() searches for a substring.

Example:

text = "  Python Programming  "
clean = text.strip()
print(clean.upper())
print(clean.replace("Python", "Java"))
print(clean.split())

Since strings are immutable, these methods return new strings rather than modifying the original string.

A list is an ordered, mutable collection that can store elements of different data types. Lists are created using square brackets.

items = [10, "pen", 3.5, True]

Common operations include:

• Indexing: items[0]
• Slicing: items[1:3]
• Adding an element: append()
• Inserting an element: insert()
• Removing an element: remove() or pop()
• Sorting: sort()
• Reversing: reverse()
• Finding length: len()

Example:

numbers = [3, 1, 2]
numbers.append(4)
numbers.sort()
print(numbers)  # [1, 2, 3, 4]

Lists may contain duplicate values and nested lists. Unlike strings and tuples, list elements can be changed after creation.

Python's common data types include:

• Numeric types: int, float, and complex
• Boolean type: bool
• Text type: str
• Sequence types: list, tuple, and range
• Set type: set
• Mapping type: dict
• Null value type: NoneType, represented by None

Mutable objects can be changed after creation. Examples include lists, dictionaries, and sets.

Immutable objects cannot be changed after creation. Examples include integers, floats, Boolean values, strings, and tuples.

For example, a list can be updated using numbers[0] = 10, but a string cannot be updated using text[0] = 'A'. When an immutable value appears to change, Python creates a new object rather than modifying the old one.

Type conversion changes a value from one data type to another.

Implicit conversion is performed automatically by Python when it can safely combine compatible types:

result = 5 + 2.5

Here, the integer is converted to a floating-point value, and the result is 7.5.

Explicit conversion, also called type casting, is performed by the programmer using functions such as int(), float(), str(), list(), and bool():

age = int("21")
price = float("19.50")
text = str(100)

Invalid conversions can produce errors. For example, int("hello") raises a ValueError. Conversion should therefore be applied only when the source value has a suitable format.

The binary number system uses only two digits, and , and has base . Each position represents a power of .

For example:

Python provides built-in functions for conversion:

print(bin(11))       # 0b1011
print(int("1011", 2))  # 11

The prefix 0b indicates a binary literal:

value = 0b1011

The format() function can represent a decimal number in binary form:

print(format(11, "b"))

Binary representation is important in computer memory, digital electronics, bitwise operations, and data encoding.

String formatting inserts values into a text message in a controlled and readable way.

Concatenation:

name = "Ravi"
age = 20
message = "Name: " + name + ", Age: " + str(age)

Formatted string literal, or f-string:

message = f"Name: {name}, Age: {age}"

format() method:

message = "Name: {}, Age: {}".format(name, age)

Formatting can control decimal precision and alignment:

price = 12.3456
print(f"Price: ${price:.2f}")

The .2f specification displays two digits after the decimal point. F-strings are generally preferred because they are concise, readable, and easy to maintain.

The Python shell, also called the interactive interpreter, executes commands immediately after the prompt >>>. It is useful for testing expressions and learning basic operations.

Example:

>>> 8 + 4
12
>>> 10 / 2
5.0
>>> 2 ** 3
8

To run a script:

1. Open a text editor or IDE.
2. Write Python statements in a file.
3. Save the file with a .py extension, such as welcome.py.
4. Open a terminal in the file's directory.
5. Run python welcome.py, or use python3 welcome.py on systems where that command is required.
6. Observe the program output.

For example, welcome.py may contain:

print("Welcome to Python")

The shell is best for quick experiments, while scripts are suitable for saving and reusing complete programs.

Software development best practices make programs easier to understand, test, modify, and maintain.

Important practices include:

• Use meaningful names for variables and functions.
• Keep functions small and focused on one task.
• Avoid unnecessary repetition.
• Add comments and documentation where they clarify intent.
• Validate input and handle possible errors.
• Test code using normal and unusual inputs.
• Use version control and make incremental changes.

PEP 8 is Python's official style guide. It recommends four spaces for indentation, a maximum line length commonly limited to 79 characters, clear naming conventions, appropriate blank lines, and spaces around operators.

Readable code should express its purpose clearly. For example, total_price is more informative than tp, and consistent formatting allows developers to understand code quickly.

An if-else statement performs conditional execution. Python evaluates the condition as either True or False. An elif clause allows additional conditions to be tested.

number = float(input("Enter a number: "))

if number > 0:
    print("The number is positive")
elif number < 0:
    print("The number is negative")
else:
    print("The number is zero")

The conditions are checked from top to bottom. When one condition is true, its indented block executes and the remaining branches are skipped. If no if or elif condition is true, the else block executes. Correct indentation is essential because it defines each branch.

The equality operator == compares the values of two objects, whereas the identity operator is checks whether two references point to the same object.

Example:

first = [1, 2, 3]
second = [1, 2, 3]
third = first

print(first == second)  # True: equal contents
print(first is second)  # False: different list objects
print(first is third)   # True: same object

Use == when the contents or values need to be compared. Use is mainly for identity checks, especially when testing for the singleton value None:

if result is None:
    print("No result")

Using is for general value comparison can produce incorrect or implementation-dependent results.