Python Variables and Operators Exercise Solutions | KalviGavani

A variable is a named location in memory that stores a value. In Python, variables are created by assignment — no type declaration is needed.

name = "Kavi"    # str variable
age = 17         # int variable
height = 5.8     # float variable
is_student = True # bool variable

Key features of Python variables:

• Dynamic typing: The type is determined by the value assigned. A variable can change type.

  x = 10       # x is int
  x = "hello"  # now x is str (type changed)

• No declaration needed: Just assign a value to create a variable.
• Case-sensitive: age and Age are different variables.

Differences from C/Java variables:

Python has several built-in data types:

Numeric types:

x = 10          # int - integer (whole number)
y = 3.14        # float - decimal number
z = 3 + 4j      # complex - complex number (real + imaginary)

Boolean type:

flag = True     # bool - either True or False

Sequence types:

# str - string (immutable sequence of characters)
name = "KalviGavani"

# list - ordered, mutable sequence
numbers = [1, 2, 3, 4, 5]
mixed = [1, "hello", 3.14, True]

# tuple - ordered, immutable sequence
coordinates = (10, 20)

Mapping type:

# dict - key-value pairs (unordered, mutable)
student = {"name": "Kavi", "age": 17, "grade": "A"}

Set types:

# set - unordered collection of unique elements
unique_numbers = {1, 2, 3, 4, 5}

Summary table:

Type conversion is the process of converting a value from one data type to another.

(i) Implicit conversion (automatic): Python automatically converts smaller types to larger types to avoid data loss.

a = 10        # int
b = 3.14      # float
c = a + b     # int + float → float
print(c)      # 13.14
print(type(c))  # <class 'float'>

(ii) Explicit conversion (manual): The programmer explicitly converts using type conversion functions.

# int() - converts to integer (truncates decimal)
x = int(3.9)      # 3
y = int("42")     # 42
z = int(True)     # 1

# float() - converts to float
a = float(5)       # 5.0
b = float("3.14")  # 3.14

# str() - converts to string
s1 = str(42)      # "42"
s2 = str(3.14)    # "3.14"
s3 = str(True)    # "True"

# bool() - converts to boolean
print(bool(0))     # False
print(bool(1))     # True
print(bool(""))    # False
print(bool("hi")) # True
print(bool([]))    # False
print(bool([1]))   # True

# list() - converts to list
print(list("abc"))    # ['a', 'b', 'c']
print(list((1, 2)))   # [1, 2]

# tuple() - converts to tuple
print(tuple([1, 2]))  # (1, 2)

# set() - converts to set (removes duplicates)
print(set([1, 2, 2, 3]))  # {1, 2, 3}

Important notes:

• int("hello") raises ValueError — only numeric strings can be converted.
• int(3.9) returns 3 (truncates, does not round).
• Values that convert to False: 0, 0.0, "", [], (), {}, None, False.

Arithmetic operators perform mathematical calculations.

Detailed examples:

# Addition
print(10 + 5)         # 15
print(3.5 + 2.1)      # 5.6
print("Hello" + " World")  # "Hello World" (string concatenation)

# Subtraction
print(10 - 5)         # 5
print(3.5 - 1.2)      # 2.3

# Multiplication
print(10 * 5)         # 50
print(3.5 * 2)        # 7.0
print("Hi" * 3)       # "HiHiHi" (string repetition)

# True division (/) — always returns float
print(7 / 2)          # 3.5
print(10 / 2)         # 5.0 (always float)

# Floor division (//) — returns integer part
print(7 // 2)         # 3
print(-7 // 2)        # -4 (rounds toward negative infinity)
print(7.0 // 2)       # 3.0 (float result when operand is float)

# Modulus (%) — remainder
print(7 % 3)          # 1
print(10 % 5)         # 0
print(-7 % 3)         # 2 (Python modulus follows divisor sign)

# Exponentiation (**)
print(2 ** 3)         # 8
print(4 ** 0.5)       # 2.0 (square root)
print(2 ** -1)         # 0.5 (1/2)

Key differences to remember:

• / always returns a float in Python 3.
• // returns an integer when both operands are integers; a float when either operand is a float.
• // rounds toward negative infinity: -7 // 2 = -4 (not -3).

Relational (comparison) operators compare two values and return True or False.

a, b = 10, 5
print(a == b)   # False
print(a != b)   # True
print(a > b)    # True
print(a < b)    # False
print(a >= 10)  # True
print(a <= b)   # False

# String comparison (lexicographic/alphabetical)
print("apple" < "banana")   # True
print("abc" == "abc")       # True

Logical operators combine boolean expressions.

# and — both must be True
print(True and True)     # True
print(True and False)    # False
print(5 > 3 and 10 > 7)   # True (both conditions True)
print(5 > 3 and 10 < 7)   # False (second condition False)

# or — at least one must be True
print(True or False)     # True
print(False or False)    # False
print(5 > 3 or 10 < 7)    # True (first condition True)

# not — reverses boolean value
print(not True)          # False
print(not False)         # True
print(not (5 > 3))       # False

# Combining relational and logical
age = 18
has_id = True
print(age >= 18 and has_id)   # True (both conditions True)
print(age >= 21 or has_id)     # True (second condition True)

Truth tables:

Bitwise operators work on integers at the binary (bit) level.

# AND (&) — 1 only if both bits are 1
#   5 = 0101
#   3 = 0011
#   -------
#   1 = 0001
print(5 & 3)   # 1

# OR (|) — 1 if at least one bit is 1
#   5 = 0101
#   3 = 0011
#   -------
#   7 = 0111
print(5 | 3)   # 7

# XOR (^) — 1 if bits are different
#   5 = 0101
#   3 = 0011
#   -------
#   6 = 0110
print(5 ^ 3)   # 6

# NOT (~) — inverts all bits (two's complement)
print(~5)      # -6

# Left shift (<<) — shifts bits left, fills with 0s
#   5 = 0101
#   5 << 1 = 1010 (multiply by 2)
print(5 << 1)  # 10

# Right shift (>>) — shifts bits right, fills with 0s
#   5 = 0101
#   5 >> 1 = 0010 (divide by 2, floor)
print(5 >> 1)  # 2

Quick formulas:

• Left shift by n: x << n = x × 2ⁿ
• Right shift by n: x >> n = x // 2ⁿ

Python provides seven arithmetic operators:

True division (/) vs Floor division (//):

# True division (/) always returns a float
print(10 / 3)    # 3.3333333333333335
print(10 / 2)    # 5.0 (always float, even when divisible)
print(7 / 2)     # 3.5

# Floor division (//) returns the integer part (floor of quotient)
print(10 // 3)   # 3
print(10 // 2)   # 5
print(7 // 2)    # 3

# With negative numbers, // rounds toward negative infinity
print(-7 // 2)   # -4 (not -3, because floor(-3.5) = -4)
print(7 // -2)   # -4
print(-7 // -2)  # 3

Modulus (%) with positive and negative numbers:

# Positive numbers
print(10 % 3)    # 1 (10 = 3*3 + 1)
print(7 % 2)    # 1 (7 = 2*3 + 1)

# Negative numbers — result has the sign of the divisor
print(-10 % 3)  # 2 (-10 = 3*(-4) + 2)
print(10 % -3)  # -2 (10 = (-3)*(-4) + (-2))
print(-10 % -3) # -1 (-10 = (-3)*3 + (-1))

Exponentiation () with different values:**

print(2 ** 3)     # 8 (2 to the power 3)
print(2 ** 0.5)   # 1.4142135623730951 (square root of 2)
print(2 ** -1)    # 0.5 (1/2)
print(3 ** 4)     # 81 (3 to the power 4)
print((-2) ** 3)  # -8 (negative base, odd exponent)
print((-2) ** 2)  # 4 (negative base, even exponent)

Mixed-type operations:

# int + float → float
print(5 + 2.5)   # 7.5

# int * float → float
print(3 * 2.0)   # 6.0

# int // float → float (but floor value)
print(7 // 2.0)  # 3.0

Relational (comparison) operators:

These compare two values and return True or False.

a, b = 10, 5
print(a == b)   # False
print(a != b)   # True
print(a > b)    # True
print(a < b)    # False
print(a >= 10)  # True
print(a <= b)   # False

# Chained comparisons
print(1 < 5 < 10)    # True (5 is between 1 and 10)
print(1 < 5 > 3)     # True (5 > 1 and 5 > 3)

# String comparison (lexicographic)
print("apple" < "banana")  # True (a comes before b)
print("abc" == "abc")      # True
print("A" < "a")            # True (ASCII: A=65, a=97)

Logical operators:

Truth table for and:

Truth table for or:

Truth table for not:

# and operator
print(True and True)      # True
print(True and False)     # False
print(5 > 3 and 10 > 7)   # True
print(5 > 3 and 10 < 7)   # False

# or operator
print(True or False)      # True
print(False or False)     # False
print(5 > 3 or 10 < 7)    # True

# not operator
print(not True)           # False
print(not False)          # True
print(not (5 > 3))        # False

# Combining operators
age = 18
has_id = True
print(age >= 18 and has_id)      # True
print(age < 18 or not has_id)    # False

# Short-circuit evaluation
# and: stops at first False
# or: stops at first True
x = 0
print(x != 0 and 10 // x > 0)   # False (second part not evaluated — no ZeroDivisionError)

Operator precedence determines the order in which operators are evaluated in an expression. Operators with higher precedence are evaluated first.

Precedence table (highest to lowest):

Examples showing precedence:

# Exponentiation before multiplication
print(2 + 3 * 4)      # 14 (3*4=12, then 2+12=14)
print(2 ** 3 ** 2)     # 512 (** is right-associative: 2**(3**2)=2**9=512)

# Parentheses override precedence
print((2 + 3) * 4)     # 20 (2+3=5, then 5*4=20)
print(2 ** (3 ** 2))   # 512 (same as without parentheses)
print((2 ** 3) ** 2)   # 64 (8**2=64)

# Multiplication/division before addition/subtraction
print(10 + 5 * 2)      # 20 (5*2=10, then 10+10=20)
print(10 - 6 / 2)      # 7.0 (6/2=3.0, then 10-3.0=7.0)

# Modulus and floor division
print(10 + 7 % 3)      # 11 (7%3=1, then 10+1=11)
print(10 // 3 * 2)     # 6 (10//3=3, then 3*2=6)

# Comparison operators
print(2 + 3 > 1 + 3)   # True (5 > 4)

# Logical operators
print(not True or True)    # True (not True=False, False or True=True)
print(not (True or True))  # False (True or True=True, not True=False)

# Combining all
print(2 + 3 * 4 > 10 and not False)  # True
# Step 1: 3 * 4 = 12
# Step 2: 2 + 12 = 14
# Step 3: 14 > 10 = True
# Step 4: not False = True
# Step 5: True and True = True

Associativity:

• Most operators are left-associative: 10 - 3 - 2 = (10 - 3) - 2 = 5
• Exponentiation is right-associative: 2 3 2 = 2 (3 2) = 512

Tip: When in doubt, use parentheses to make the order explicit. It improves readability and prevents bugs.

Python data types can be categorised as follows:

(i) Numeric types:

# int — integer (whole numbers, unlimited size)
x = 42
y = -100
big = 999999999999999999999999  # Python handles arbitrarily large integers

# float — decimal (floating-point) numbers
pi = 3.14159
temp = -10.5
sci = 2.5e10    # 25000000000.0 (scientific notation)

# complex — complex numbers (real + imaginary)
z = 3 + 4j
print(z.real)   # 3.0
print(z.imag)   # 4.0

(ii) Boolean type:

flag = True
active = False
print(type(flag))   # <class 'bool'>
print(True + True)  # 2 (True = 1, False = 0)

(iii) Sequence types:

# str — string (immutable sequence of characters)
name = "KalviGavani"
print(name[0])      # 'K'
print(name[0:4])    # 'Kalv'
# name[0] = "k"    # TypeError: strings are immutable

# list — ordered, mutable sequence
fruits = ["apple", "banana", "cherry"]
fruits.append("mango")     # Can modify
fruits[0] = "avocado"      # Can change elements
print(fruits)              # ['avocado', 'banana', 'cherry', 'mango']

# tuple — ordered, immutable sequence
point = (10, 20)
print(point[0])            # 10
# point[0] = 5            # TypeError: tuples are immutable
single = (5,)              # Single-element tuple (note the comma)

(iv) Mapping type:

# dict — key-value pairs (mutable)
student = {
    "name": "Kavi",
    "age": 17,
    "grade": "A"
}
print(student["name"])     # Kavi
student["age"] = 18        # Can modify
student["school"] = "HSC"  # Can add new key

(v) Set type:

# set — unordered collection of unique elements (mutable)
colors = {"red", "green", "blue"}
colors.add("yellow")       # Can modify
print(colors)              # Order not guaranteed
numbers = {1, 2, 2, 3, 3} # Duplicates removed
print(numbers)             # {1, 2, 3}

Mutable vs Immutable:

# Mutable — same object, content changes
a = [1, 2, 3]
b = a
a[0] = 99
print(b)    # [99, 2, 3] — b also changed (same object)

# Immutable — new object created on change
x = "hello"
y = x
x = "world"      # New string object created
print(y)         # "hello" — y still points to original

Type conversion is the process of converting a value from one data type to another.

(i) Implicit conversion (automatic / coercion): Python automatically converts smaller types to larger types to prevent data loss. This happens without programmer intervention.

# int + float → float
a = 10       # int
b = 3.5      # float
c = a + b    # int + float → float
print(c)           # 13.5
print(type(c))     # <class 'float'>

# int + bool → int (bool is subclass of int)
x = 10 + True      # 10 + 1 = 11
print(x)           # 11

# float + complex → complex
y = 2.5 + 3j
print(y)           # (2.5+3j)
print(type(y))     # <class 'complex'>

(ii) Explicit conversion (type casting): The programmer manually converts using built-in functions.

# int() — converts to integer
print(int(3.9))      # 3 (truncates, does not round)
print(int("42"))     # 42 (string to int)
print(int(True))     # 1
print(int(False))    # 0
print(int(-3.7))     # -3 (truncates toward zero)

# float() — converts to float
print(float(5))       # 5.0
print(float("3.14"))  # 3.14
print(float("5"))     # 5.0
print(float(True))    # 1.0

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

# bool() — converts to boolean
print(bool(0))       # False
print(bool(1))       # True
print(bool(-5))      # True (any non-zero number is True)
print(bool(""))      # False
print(bool("hello")) # True
print(bool([]))      # False
print(bool([1, 2]))  # True

# list() — converts to list
print(list("abc"))      # ['a', 'b', 'c']
print(list((1, 2, 3)))  # [1, 2, 3]
print(list(range(5)))    # [0, 1, 2, 3, 4]

# tuple() — converts to tuple
print(tuple([1, 2, 3]))  # (1, 2, 3)

# set() — converts to set (removes duplicates)
print(set([1, 2, 2, 3]))  # {1, 2, 3}
print(set("hello"))        # {'h', 'e', 'l', 'o'} (order not guaranteed)

Common errors during type conversion:

# ValueError — converting non-numeric string to int/float
# int("hello")      # ValueError: invalid literal for int()
# float("abc")      # ValueError: could not convert string to float

# TypeError — invalid conversion
# int([1, 2])       # TypeError: int() argument must be a string or number

# Implicit conversion does NOT work between incompatible types
# "Age: " + 18      # TypeError: can only concatenate str to str
# Fix: "Age: " + str(18)   # "Age: 18"

Summary of falsy values (convert to False):

All other values convert to True.