Strings, Lists, Tuples, Sets, Dictionaries: Operations, Traversal & Use Cases

Core Concepts: Strings

Definition & Properties

A string is an immutable sequence of Unicode characters enclosed in single (') or double (") quotes. It supports indexing, slicing, and built-in methods.

text = "Python"
print(text[0])  # 'P' (indexing)
print(text[1:4]) # 'yth' (slicing)

Key Operations:

Visual: String Indexing

String Methods

s = "  Hello, World!  "
print(s.strip())      # "Hello, World!" (removes whitespace)
print(s.upper())      # "  HELLO, WORLD!  "
print(s.split(","))   # ["  Hello", " World!  "]

Example: Cleaning User Input

user_input = "  nepal@123  "
cleaned = user_input.strip().lower()
print(cleaned)  # "nepal@123"

Trace:

Lists: Mutable Sequences

Definition & Syntax

A list is a mutable, ordered collection of items (heterogeneous types allowed). Defined with square brackets [].

fruits = ["apple", "banana", "cherry"]
fruits[1] = "orange"  # Modifies list in-place

Key Operations:

Visual: List Insertion

flowchart LR
    A["Initial: [apple, banana, cherry]"] -->|"insert('kiwi', 1)"| B["After: [apple, kiwi, banana, cherry]"]

List Methods vs. Built-ins

Example: Daraz Order Queue

orders = ["Order123", "Order456", "Order789"]
orders.append("Order101")  # New order added to end
print(orders)  # ["Order123", "Order456", "Order789", "Order101"]

Trace:

Tuples: Immutable Sequences

Definition & Syntax

A tuple is an immutable, ordered collection defined with parentheses (). Used for fixed data (e.g., coordinates, database records).

point = (3, 5)  # Immutable: point[0] = 10 → Error

Key Operations:

Visual: Tuple vs. List

classDiagram
    class List {
        +mutable
        +ordered
        +[] brackets
    }
    class Tuple {
        +immutable
        +ordered
        +() parentheses
    }
    List --> "Inherits from" Sequence
    Tuple --> "Inherits from" Sequence

Example: NEPSE Stock Prices

stock = ("NTC", 120.50, "2023-10-01")
print(stock[1])  # 120.50 (price)

Trace:

Sets: Unordered, Unique Elements

Definition & Syntax

A set is an unordered, mutable collection of unique elements. Defined with curly braces {} or set().

unique_numbers = {1, 2, 3, 3, 4}  # {1, 2, 3, 4} (duplicates removed)

Key Operations:

Visual: Set Operations

pie
    title Set Operations
    "Union (|)" : 3
    "Intersection (&)" : 1
    "Difference (-)" : 2

Example: eSewa Transaction IDs

tx_ids = {"TX101", "TX102", "TX101"}  # {"TX101", "TX102"}
tx_ids.add("TX103")  # Adds unique ID
print(tx_ids)  # {"TX101", "TX102", "TX103"}

Trace:

Dictionaries: Key-Value Pairs

Definition & Syntax

A dictionary is a mutable, unordered collection of key-value pairs. Keys must be immutable (strings, numbers, tuples).

student = {"name": "Rama", "age": 20, "courses": ["Math", "CS"]}
print(student["name"])  # "Rama"

Key Operations:

Visual: Dictionary Hashing

graph TD
    A["Key: 'name'"] -->|"Hash"| B["Hash Value: 12345"]
    B --> C["Index in Table: 12345 % 1000 = 235"]
    C --> D["Value: 'Rama'"]

Example: Ncell Customer Data

customers = {"CUST101": {"name": "Hari", "balance": 5000},
             "CUST102": {"name": "Sita", "balance": 3000}}
customers["CUST101"]["balance"] += 1000  # Top-up
print(customers["CUST101"]["balance"])  # 6000

Trace:

In the Real World

1. eSewa Transactions

   • Data Structure Used: Dictionary
   • How: Stores user IDs ("USER123") as keys and transaction details ({"amount": 500, "status": "completed"}) as values. Fast lookup for transaction history.

2. Daraz Order Processing

   • Data Structure Used: List + Queue (FIFO)
   • How: Orders are appended to a list (orders.append("Order123")), and processed in FIFO order using orders.pop(0) for the oldest order.

3. Ncell Customer Database

   • Data Structure Used: Dictionary of Dictionaries
   • How: Outer dictionary keys are phone numbers ("98XXXXXXXX"), and values are nested dictionaries with {"name": "Ramesh", "balance": 2000} for quick balance checks.

4. Pathao Driver Routing

   • Data Structure Used: Set for Unique Locations
   • How: Avoids duplicate pickup/drop locations by storing them in a set (locations = {"KTM", "Lalitpur", "Bhaktapur"}).

5. Bank Loan Interest Calculation

   • Data Structure Used: Tuple for Fixed Loan Terms
   • How: Loan terms (principal, rate, years) are stored as tuples to ensure immutability during calculations.

Exam Tip

1. String Methods: Memorize strip(), split(), join(), and replace(). Often tested in input validation questions.
2. List vs. Tuple: Always check mutability. Lists allow modifications; tuples do not. Example:

   def process_data(data):
       data.append(10)  # Works for lists, fails for tuples
   

3. Set Operations: Practice union (|), intersection (&), and difference (-) with concrete examples (e.g., overlapping user groups).
4. Dictionary Traversal: Know how to loop through keys, values, and items:

   for key, value in student.items():
       print(f"{key}: {value}")
   

5. Common Pitfalls:
   • Key Errors: Always check if a key exists (if "key" in dict).
   • Tuple Immutability: Avoid tuple[0] = 5 (TypeError).
   • List vs. String: Strings are immutable; use lists for dynamic text manipulation.
6. Time Complexity:
   • Lists: O(n) for search (unless sorted), O(1) for append/pop (end).
   • Dictionaries: O(1) average for access/insertion (hash-based).
   • Sets: O(1) for membership tests.

Practice Questions for TU/PU Exams:

1. Write a Python function to reverse a string without using slicing ([::-1]).
2. Given a list of integers, remove duplicates and sort the result. Use a set.
3. Create a dictionary to store student grades. Add a function to calculate the average grade.
4. Explain why {"a": 1, "b": 2} == {"b": 2, "a": 1} evaluates to True in Python.
5. Trace the execution of list.pop() on [10, 20, 30] and explain the state after each step.