False. Python uses dynamic typing — you do not need to declare variable types. The type is determined automatically based on the value assigned.

False. The // (floor division) operator returns an integer when both operands are integers. It returns a float only if at least one operand is a float. For example, 10 // 3 returns 3 (int), but 10.0 // 3 returns 3.0 (float).

True. Zero (0) is a falsy value in Python. bool(0) returns False, while bool(any non-zero number) returns True.

True. The operator with a string and an integer repeats the string. "Ha" 3 produces "HaHaHa".

True. Exponentiation is right-associative in Python. 2 3 2 is evaluated as 2 (3 2) = 2 ** 9 = 512.

False. int("hello") raises a ValueError because "hello" cannot be converted to an integer. Only strings containing numeric characters (like "5" or "-10") can be converted with int().

True. Python supports dynamic typing. A variable can hold an integer at one point and a string later:

x = 10      # x is int
x = "hello" # x is now str

Data types classify data and determine what operations can be performed on it. Python's basic data types are:

Dynamic typing means Python determines the variable type automatically based on the assigned value, and the type can change during execution. No type declaration is needed.

x = 10        # x is int
print(type(x)) # <class 'int'>

x = 3.14      # x is now float
print(type(x)) # <class 'float'>

x = "Hello"   # x is now str
print(type(x)) # <class 'str'>

Type conversion is the process of converting a value from one data type to another. It can be implicit (automatic) or explicit (manual).

# Explicit conversion (manual)
x = int("25")      # String to int: x = 25
y = float(10)      # Int to float: y = 10.0

# Implicit conversion (automatic)
z = 5 + 2.5       # int + float → Python converts 5 to 5.0
print(type(z))    # <class 'float'>, result is 7.5

Python provides the following arithmetic operators:

# Arithmetic operator examples
a = 15
b = 4

print(a + b)    # 19 (Addition)
print(a - b)    # 11 (Subtraction)
print(a * b)    # 60 (Multiplication)
print(a / b)    # 3.75 (True Division - always returns float)
print(a // b)   # 3  (Floor Division - integer quotient)
print(a % b)    # 3  (Modulo - remainder)
print(a ** b)   # 50625 (Exponentiation - 15 to the power 4)

Operator Precedence (highest to lowest):

1. Parentheses () — evaluated first, overrides all other precedence 2. Exponentiation — evaluated next 3. Unary +x, -x — unary plus and minus 4. / // % — multiplication, division, floor division, modulo (left to right) 5. + -* — addition and subtraction (left to right)

Precedence examples:

# Without parentheses
print(2 + 3 * 4)      # 14 (3*4=12, then 2+12=14)

# With parentheses
print((2 + 3) * 4)    # 20 (2+3=5, then 5*4=20)

# Exponentiation first
print(2 + 3 ** 2)     # 11 (3**2=9, then 2+9=11)

# Right-associative exponentiation
print(2 ** 3 ** 2)    # 512 (3**2=9, then 2**9=512)

# Same precedence, left to right
print(10 / 2 * 5)     # 25.0 (10/2=5.0, then 5.0*5=25.0)

Floor division with negative numbers:

print(-7 // 2)    # -4 (floors toward negative infinity, not truncation)
print(7 // -2)    # -4 (same principle)

Type conversion is the process of converting a value from one data type to another. Python supports two types of conversion:

1. Implicit Type Conversion (Automatic): Python automatically converts data types when mixing different types in an expression. It always converts to the higher/wider type to avoid data loss.

# int + float → float (Python converts int to float automatically)
a = 5       # int
b = 2.5     # float
c = a + b   # Python converts 5 to 5.0, then adds
print(c)         # 7.5
print(type(c))   # <class 'float'>

# int + complex → complex
x = 10          # int
y = 3 + 2j      # complex
z = x + y       # Python converts 10 to 10+0j
print(z)        # (13+2j)
print(type(z))  # <class 'complex'>

Conversion hierarchy (lower to higher): int → float → complex

Python always converts to the higher type. You cannot go from complex to float or int implicitly.

2. Explicit Type Conversion (Manual / Type Casting): The programmer manually converts types using built-in functions: int(), float(), str(), bool(), complex().

# int() — converts to integer
print(int(3.9))       # 3 (truncates decimal part, does NOT round)
print(int("25"))      # 25 (string to int)
print(int(True))      # 1
print(int(False))     # 0

# float() — converts to float
print(float(10))      # 10.0
print(float("3.14"))  # 3.14
print(float(True))    # 1.0

# str() — converts to string
print(str(100))       # "100"
print(str(3.14))      # "3.14"
print(str(True))      # "True"

# bool() — converts to boolean
print(bool(0))        # False (0 is falsy)
print(bool(1))        # True (non-zero is truthy)
print(bool(""))       # False (empty string is falsy)
print(bool("Hello")) # True (non-empty string is truthy)
print(bool([]))       # False (empty list is falsy)

Common errors in type conversion:

# Cannot convert non-numeric string to int/float
print(int("hello"))   # ValueError
print(int("3.14"))    # ValueError (use float() first: int(float("3.14")))

# Cannot convert complex to int or float
print(int(3+4j))      # TypeError

Proper conversion chain:

# String "3.14" → float → int
s = "3.14"
f = float(s)      # 3.14
i = int(f)        # 3
print(i)          # 3

Variables: A variable is a named memory location that stores a value. In Python, variables:

• Do not need to be declared with a type (dynamic typing)
• Can change type during execution
• Must follow naming rules

Variable Naming Rules: 1. Must start with a letter or underscore (not a number) 2. Can contain letters, digits, and underscores 3. Cannot contain spaces or special characters 4. Cannot be a Python keyword (if, for, while, etc.) 5. Case-sensitive (age and Age are different variables)

# Valid variable names
student_name = "Ravi"
_age = 16
marks123 = 95

# Invalid variable names
# 2name = "Error"    # starts with number
# my name = "Error"  # contains space
# class = "Error"    # keyword

Expressions: An expression is a combination of values, variables, operators, and function calls that evaluates to a single value.

Types of expressions:

Python Program — Expression Evaluator:

# Program to evaluate various arithmetic expressions

a = int(input("Enter value of a: "))
b = int(input("Enter value of b: "))
c = int(input("Enter value of c: "))

# Arithmetic expressions
print("a + b =", a + b)           # Addition
print("a - b =", a - b)           # Subtraction
print("a * b =", a * b)           # Multiplication
print("a / b =", a / b)           # True Division
print("a // b =", a // b)         # Floor Division
print("a % b =", a % b)           # Modulo
print("a ** b =", a ** b)         # Exponentiation

# Compound expressions (using precedence)
print("a + b * c =", a + b * c)           # Multiplication first
print("(a + b) * c =", (a + b) * c)       # Parentheses first
print("a ** b + c =", a ** b + c)         # Exponentiation first
print("a + b > c and b != 0 =", a + b > c and b != 0)  # Relational + Logical

# Type of result
x = a / b
print("Type of a/b:", type(x))    # <class 'float'>
y = a // b
print("Type of a//b:", type(y))   # <class 'int'> (if both are int)

Output: