Data Types, Variables & Operators in Python

Core Concepts

1. Data Types in Python

Python has primitive and derived data types. Primitive types are the basic building blocks:

Numeric Types

• Integers (int):

  • Whole numbers (positive, negative, or zero).
  • Example: age = 25, balance = -1000.
  • Unlimited precision: Python int can handle arbitrarily large numbers (e.g., 10**1000).

• Floats (float):

  • Decimal numbers (floating-point).
  • Example: temperature = 36.6, pi = 3.14159.
  • Precision limit: ~15-17 significant digits due to IEEE 754 standard.

• Complex Numbers (complex):

  • Written as a + bj (e.g., z = 3 + 4j).
  • Used in scientific computing (e.g., signal processing).

Boolean Type (bool)

• Represents True or False.
• Used in conditions and logical operations.
• Example:

  is_raining = True
  has_permission = False
  

NoneType (None)

• Represents the absence of a value.
• Example:

  user_input = None  # No input provided yet
  

2. Variables and Assignment

• Variable: A named storage location for data.
• Assignment: Uses = to bind a value to a variable.

  x = 10          # Integer
  name = "Alice"  # String
  is_active = True  # Boolean
  

• Dynamic Typing: Python infers the type at runtime.

  var = 100      # int
  var = "Hello"  # Now a str (type changes dynamically)
  

Variable Naming Rules

3. Operators in Python

Operators perform operations on variables and values.

Arithmetic Operators

Example: Calculating Ncell Bill Suppose Ncell charges Rs. 120 for 1000 minutes and Rs. 2 per extra minute.

base_charge = 120
minutes_used = 1200
extra_minutes = minutes_used - 1000
total_cost = base_charge + (extra_minutes * 2)
print(f"Total bill: Rs. {total_cost}")  # Output: Rs. 440

Comparison Operators

Example: eSewa Transaction Validation

amount = 500
min_amount = 100
max_amount = 10000

if min_amount <= amount <= max_amount:
    print("Transaction valid!")
else:
    print("Invalid amount!")

Logical Operators

Example: Daraz Order Eligibility

has_coupon = True
order_total = 2000
min_order = 1500

if has_coupon or order_total >= min_order:
    print("Eligible for free shipping!")
else:
    print("Not eligible.")

Assignment Operators

Example: Bank Loan Interest Calculation

principal = 100000
interest_rate = 0.05  # 5%
years = 3

# Simple interest: I = P * r * t
interest = principal * interest_rate * years
total_amount = principal + interest

print(f"Total amount after {years} years: Rs. {total_amount}")

In the Real World

1. eSewa Transactions

   • Uses comparison operators (==, >=) to validate transaction amounts before processing payments.
   • Example: Checks if amount >= 100 and balance >= amount before deducting funds.

2. Ncell Billing System

   • Applies arithmetic operators (+, *) to calculate bills based on usage (e.g., total_cost = base_charge + (extra_minutes * rate)).

3. Pathao Driver App

   • Uses logical operators (and, or) to determine ride eligibility:
     • if (driver_available and ride_requested) or (emergency_ride): accept_ride()

4. NEPSE Stock Prices

   • Floating-point precision matters when calculating daily returns:

     previous_price = 100.50
     current_price = 102.75
     return_percentage = ((current_price - previous_price) / previous_price) * 100
     

4. Type Conversion

Python allows converting between types using:

• int()
• float()
• str()
• bool()

Example: Converting User Input

user_input = "100"
quantity = int(user_input)  # Convert str to int
price = 20.50
total = quantity * price
print(f"Total: Rs. {total}")  # Output: Rs. 2050.0

Common Pitfalls

5. Operator Precedence

Python evaluates operators in this order (highest to lowest priority):

flowchart TD
    A["Parentheses"] --> B["Exponentiation"]
    B --> C["Multiplication/Division/Modulus"]
    C --> D["Addition/Subtraction"]
    D --> E["Comparison"]
    E --> F["Logical NOT"]
    F --> G["Logical AND"]
    G --> H["Logical OR"]

Example: Evaluating a Complex Expression

result = 10 + 3 * 2 ** 2
# Step-by-step:
# 1. 2 ** 2 = 4
# 2. 3 * 4 = 12
# 3. 10 + 12 = 22
print(result)  # Output: 22

Visualizing Data Types and Operations

Memory Representation of Variables

Example: Variable Assignment in Memory

x = 10      # int
y = 3.14    # float
name = "Bob" # str

+------+       +------+       +------+
|   x  |------>|  10  |       +------+
+------+       +------+       | name |
| type |------>| int  |       +------+
+------+       +------+       | "Bob"|
        +------+       +------+
        |   y  |------>| 3.14 |
        +------+       +------+
        | type |------>| float|
        +------+

Step-by-Step Trace: Calculating Compound Interest

Formula: $A=P{\left(1+\frac{r}{n}\right)}^{nt}$ Where:

• $P$ = Principal (Rs. 5000)
• $r$ = Annual rate (5% = 0.05)
• $n$ = Compounding frequency (12 for monthly)
• $t$ = Time in years (2)

P = 5000
r = 0.05
n = 12
t = 2

# Step 1: Calculate r/n
r_div_n = r / n  # 0.05 / 12 ≈ 0.0041667

# Step 2: Calculate (1 + r/n)
term = 1 + r_div_n  # 1.0041667

# Step 3: Calculate nt
nt = n * t  # 12 * 2 = 24

# Step 4: Raise to power nt
amount = P * (term ** nt)  # 5000 * (1.0041667 ** 24) ≈ 5536.79

Final Output:

After 2 years, Rs. 5000 grows to Rs. 5536.79 (compounded monthly).

Common Mistakes and How to Avoid Them

Exam Tip

1. Focus on Operator Precedence:

   • Always use parentheses to clarify intent in complex expressions.
   • Example: (a + b) * c vs a + b * c.

2. Type Conversion Pitfalls:

   • int("3.5") raises ValueError. Use int(float("3.5")) if needed.
   • str(10) + 5 raises TypeError. Convert both to str: str(10) + str(5).

3. Real-World Scenarios:

   • Expect questions on billing systems (Ncell), transaction validation (eSewa), or loan calculations (banks).
   • Example:

     "A user deposits Rs. 10,000 in a bank with 6% annual interest compounded quarterly. Calculate the amount after 3 years." Solution: Use the compound interest formula with n = 4 and t = 3.

4. Tracing Variables:

   • For marks, show step-by-step variable changes in tables (like the compound interest example above).
   • Example:

     x = 5
     x += 3  # What is x now?
     

     Answer:

     Step	Operation	x Value
     1	x = 5	5
     2	x += 3	8

5. Boolean Logic:

   • Questions may ask to evaluate expressions like:

     (10 > 5) and (2 < 4) or not (3 == 3)
     

     Trace:
     1. (10 > 5) → True
     2. (2 < 4) → True
     3. and → True and True → True
     4. not (3 == 3) → not True → False
     5. or → True or False → True

Final Checklist Before Exam

• Can you list all 6 primitive data types in Python?
• Do you know the precedence of +, *, and ==?
• Can you trace a variable’s value through 3 assignment operations?
• Can you write a real-world example (e.g., Ncell bill) using arithmetic operators?
• Do you remember how to convert between int, float, and str safely?