Python Lists: Your First Data Structure That Actually Makes Sense

 1# Creating lists - it's this simple
 2shopping_list = ['apples', 'milk', 'bread', 'eggs']
 3numbers = [1, 2, 3, 4, 5]
 4mixed_bag = ['hello', 42, 3.14, True]
 5empty_list = []
 6
 7print("Shopping list:", shopping_list)
 8print("Numbers:", numbers)
 9print("Mixed bag:", mixed_bag)
10print("Empty list:", empty_list)

 1def demonstrate_list_creation():
 2    """Show different ways to create lists in Python."""
 3    
 4    # Method 1: Direct creation with square brackets
 5    fruits = ['apple', 'banana', 'orange']
 6    print(f"Direct creation: {fruits}")
 7    
 8    # Method 2: Using the list() constructor
 9    numbers = list(range(5))  # Creates [0, 1, 2, 3, 4]
10    print(f"From range: {numbers}")
11    
12    # Method 3: List comprehension (we'll cover this more later)
13    squares = [x**2 for x in range(5)]
14    print(f"List comprehension: {squares}")
15    
16    # Method 4: Converting from other types
17    word = "hello"
18    letters = list(word)  # Converts string to list of characters
19    print(f"From string: {letters}")
20    
21    # Method 5: Multiplying lists
22    zeros = [0] * 5  # Creates [0, 0, 0, 0, 0]
23    pattern = ['a', 'b'] * 3  # Creates ['a', 'b', 'a', 'b', 'a', 'b']
24    print(f"Repeated zeros: {zeros}")
25    print(f"Repeated pattern: {pattern}")
26
27demonstrate_list_creation()

 1def demonstrate_list_indexing():
 2    """Show how to access items in a list."""
 3    
 4    colors = ['red', 'green', 'blue', 'yellow', 'purple']
 5    print(f"Our colors: {colors}")
 6    print()
 7    
 8    # Positive indexing (from the beginning)
 9    print("Positive indexing:")
10    print(f"First color (index 0): {colors[0]}")
11    print(f"Second color (index 1): {colors[1]}")
12    print(f"Last color (index 4): {colors[4]}")
13    print()
14    
15    # Negative indexing (from the end)
16    print("Negative indexing:")
17    print(f"Last color (index -1): {colors[-1]}")
18    print(f"Second to last (index -2): {colors[-2]}")
19    print(f"First color (index -5): {colors[-5]}")
20    print()
21    
22    # Getting the length
23    print(f"Number of colors: {len(colors)}")
24    
25    # Safe way to get the last item
26    if colors:  # Check if list is not empty
27        last_color = colors[len(colors) - 1]  # Traditional way
28        last_color_pythonic = colors[-1]      # Pythonic way
29        print(f"Last color (traditional): {last_color}")
30        print(f"Last color (Pythonic): {last_color_pythonic}")
31
32demonstrate_list_indexing()

 1def demonstrate_list_modification():
 2    """Show how to modify lists in various ways."""
 3    
 4    # Start with a simple list
 5    tasks = ['write code', 'test code']
 6    print(f"Initial tasks: {tasks}")
 7    print()
 8    
 9    # Adding items
10    print("=== Adding Items ===")
11    
12    # append() adds to the end
13    tasks.append('deploy code')
14    print(f"After append: {tasks}")
15    
16    # insert() adds at a specific position
17    tasks.insert(1, 'review code')  # Insert at index 1
18    print(f"After insert: {tasks}")
19    
20    # extend() adds multiple items
21    new_tasks = ['document code', 'celebrate']
22    tasks.extend(new_tasks)
23    print(f"After extend: {tasks}")
24    
25    # Using + to combine lists (creates new list)
26    bonus_tasks = ['eat pizza', 'take break']
27    all_tasks = tasks + bonus_tasks
28    print(f"Combined with +: {all_tasks}")
29    print()
30    
31    # Removing items
32    print("=== Removing Items ===")
33    
34    # remove() removes first occurrence of value
35    all_tasks.remove('eat pizza')
36    print(f"After remove('eat pizza'): {all_tasks}")
37    
38    # pop() removes and returns item at index (or last if no index)
39    last_task = all_tasks.pop()  # Remove last item
40    print(f"Popped task: {last_task}")
41    print(f"After pop(): {all_tasks}")
42    
43    # pop() with index
44    second_task = all_tasks.pop(1)
45    print(f"Popped second task: {second_task}")
46    print(f"After pop(1): {all_tasks}")
47    
48    # del statement removes by index or slice
49    del all_tasks[0]  # Remove first item
50    print(f"After del all_tasks[0]: {all_tasks}")
51    print()
52    
53    # Modifying existing items
54    print("=== Modifying Items ===")
55    priorities = ['low', 'medium', 'high']
56    print(f"Original priorities: {priorities}")
57    
58    # Change a single item
59    priorities[0] = 'urgent'
60    print(f"After changing index 0: {priorities}")
61    
62    # Change multiple items with slicing
63    priorities[1:3] = ['critical', 'immediate']
64    print(f"After slice assignment: {priorities}")
65
66demonstrate_list_modification()

 1def demonstrate_essential_list_methods():
 2    """Show the most useful list methods for beginners."""
 3    
 4    # Sample data to work with
 5    numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5]
 6    print(f"Original numbers: {numbers}")
 7    print()
 8    
 9    # Searching and counting
10    print("=== Searching and Counting ===")
11    print(f"Count of 1: {numbers.count(1)}")
12    print(f"Count of 5: {numbers.count(5)}")
13    print(f"Index of first 4: {numbers.index(4)}")
14    
15    # Check if item exists (Pythonic way)
16    if 9 in numbers:
17        print("9 is in the list!")
18    
19    if 99 not in numbers:
20        print("99 is not in the list!")
21    print()
22    
23    # Sorting and reversing
24    print("=== Sorting and Reversing ===")
25    
26    # sort() modifies the original list
27    numbers_copy = numbers.copy()  # Make a copy first
28    numbers_copy.sort()
29    print(f"After sort(): {numbers_copy}")
30    
31    # sorted() returns a new sorted list
32    sorted_numbers = sorted(numbers)
33    print(f"sorted() result: {sorted_numbers}")
34    print(f"Original unchanged: {numbers}")
35    
36    # Reverse order
37    numbers_copy.reverse()
38    print(f"After reverse(): {numbers_copy}")
39    
40    # Sort in reverse order
41    reverse_sorted = sorted(numbers, reverse=True)
42    print(f"Reverse sorted: {reverse_sorted}")
43    print()
44    
45    # Working with strings
46    print("=== String Lists ===")
47    words = ['python', 'java', 'javascript', 'go', 'rust']
48    print(f"Languages: {words}")
49    
50    # Sort alphabetically
51    words.sort()
52    print(f"Alphabetical: {words}")
53    
54    # Sort by length
55    words.sort(key=len)
56    print(f"By length: {words}")
57    
58    # Sort by length, longest first
59    words.sort(key=len, reverse=True)
60    print(f"By length (reverse): {words}")
61    print()
62    
63    # List aggregation functions
64    print("=== Aggregation Functions ===")
65    scores = [85, 92, 78, 96, 88, 91]
66    print(f"Test scores: {scores}")
67    print(f"Highest score: {max(scores)}")
68    print(f"Lowest score: {min(scores)}")
69    print(f"Total points: {sum(scores)}")
70    print(f"Average score: {sum(scores) / len(scores):.1f}")
71
72demonstrate_essential_list_methods()

 1def demonstrate_list_slicing():
 2    """Show how to slice lists effectively."""
 3    
 4    alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
 5    print(f"Full alphabet: {alphabet}")
 6    print()
 7    
 8    # Basic slicing: [start:end] (end is exclusive)
 9    print("=== Basic Slicing ===")
10    print(f"First 3 letters: {alphabet[0:3]}")
11    print(f"Letters 2-5: {alphabet[2:6]}")
12    print(f"Last 3 letters: {alphabet[-3:]}")
13    print()
14    
15    # Omitting start or end
16    print("=== Omitting Start/End ===")
17    print(f"From beginning to index 4: {alphabet[:5]}")
18    print(f"From index 5 to end: {alphabet[5:]}")
19    print(f"Entire list (copy): {alphabet[:]}")
20    print()
21    
22    # Step parameter
23    print("=== Using Step Parameter ===")
24    print(f"Every other letter: {alphabet[::2]}")
25    print(f"Every third letter: {alphabet[::3]}")
26    print(f"Reverse the list: {alphabet[::-1]}")
27    print(f"Every other, backwards: {alphabet[::-2]}")
28    print()
29    
30    # Practical slicing examples
31    print("=== Practical Examples ===")
32    
33    # Split list into parts
34    first_half = alphabet[:len(alphabet)//2]
35    second_half = alphabet[len(alphabet)//2:]
36    print(f"First half: {first_half}")
37    print(f"Second half: {second_half}")
38    
39    # Remove first and last elements
40    middle_elements = alphabet[1:-1]
41    print(f"Middle elements: {middle_elements}")
42    
43    # Get every nth element starting from a position
44    every_third_from_1 = alphabet[1::3]
45    print(f"Every 3rd starting from index 1: {every_third_from_1}")
46
47demonstrate_list_slicing()

  1class SimpleTaskManager:
  2    """A simple task manager using Python lists."""
  3    
  4    def __init__(self):
  5        self.tasks = []
  6        self.completed_tasks = []
  7    
  8    def add_task(self, task):
  9        """Add a new task to the list."""
 10        if task and task.strip():  # Check if task is not empty
 11            self.tasks.append(task.strip())
 12            print(f"✓ Added task: '{task.strip()}'")
 13        else:
 14            print("❌ Cannot add empty task")
 15    
 16    def complete_task(self, task_number):
 17        """Mark a task as completed."""
 18        if 1 <= task_number <= len(self.tasks):
 19            # Move task from pending to completed
 20            completed_task = self.tasks.pop(task_number - 1)
 21            self.completed_tasks.append(completed_task)
 22            print(f"✓ Completed: '{completed_task}'")
 23        else:
 24            print("❌ Invalid task number")
 25    
 26    def remove_task(self, task_number):
 27        """Remove a task without completing it."""
 28        if 1 <= task_number <= len(self.tasks):
 29            removed_task = self.tasks.pop(task_number - 1)
 30            print(f"🗑️ Removed: '{removed_task}'")
 31        else:
 32            print("❌ Invalid task number")
 33    
 34    def show_tasks(self):
 35        """Display all pending tasks."""
 36        if not self.tasks:
 37            print("📋 No pending tasks!")
 38            return
 39        
 40        print("📋 Pending Tasks:")
 41        for i, task in enumerate(self.tasks, 1):
 42            print(f"  {i}. {task}")
 43    
 44    def show_completed(self):
 45        """Display completed tasks."""
 46        if not self.completed_tasks:
 47            print("✅ No completed tasks yet!")
 48            return
 49        
 50        print("✅ Completed Tasks:")
 51        for i, task in enumerate(self.completed_tasks, 1):
 52            print(f"  {i}. {task}")
 53    
 54    def get_summary(self):
 55        """Get a summary of all tasks."""
 56        total_tasks = len(self.tasks) + len(self.completed_tasks)
 57        completion_rate = len(self.completed_tasks) / total_tasks * 100 if total_tasks > 0 else 0
 58        
 59        print(f"📊 Task Summary:")
 60        print(f"  Pending: {len(self.tasks)}")
 61        print(f"  Completed: {len(self.completed_tasks)}")
 62        print(f"  Total: {total_tasks}")
 63        print(f"  Completion Rate: {completion_rate:.1f}%")
 64
 65def demonstrate_task_manager():
 66    """Show the task manager in action."""
 67    print("=== Simple Task Manager Demo ===")
 68    
 69    # Create task manager
 70    tm = SimpleTaskManager()
 71    
 72    # Add some tasks
 73    tm.add_task("Learn Python lists")
 74    tm.add_task("Practice list methods")
 75    tm.add_task("Build a simple project")
 76    tm.add_task("Write clean code")
 77    tm.add_task("")  # Test empty task
 78    
 79    print()
 80    tm.show_tasks()
 81    
 82    print()
 83    # Complete some tasks
 84    tm.complete_task(1)  # Complete "Learn Python lists"
 85    tm.complete_task(2)  # Complete "Practice list methods" (now at index 2)
 86    
 87    print()
 88    tm.show_tasks()
 89    
 90    print()
 91    tm.show_completed()
 92    
 93    print()
 94    # Add more tasks
 95    tm.add_task("Review code with peers")
 96    tm.add_task("Deploy application")
 97    
 98    print()
 99    # Remove a task
100    tm.remove_task(3)  # Remove "Deploy application"
101    
102    print()
103    tm.show_tasks()
104    
105    print()
106    tm.get_summary()
107
108# Run the demo
109demonstrate_task_manager()

 1def demonstrate_list_patterns():
 2    """Show common Python list patterns and idioms."""
 3    
 4    # Sample data
 5    numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 6    words = ['python', 'is', 'awesome', 'and', 'fun']
 7    
 8    print("=== Filtering Lists ===")
 9    
10    # Filter even numbers
11    evens = [x for x in numbers if x % 2 == 0]
12    print(f"Even numbers: {evens}")
13    
14    # Filter words longer than 3 characters
15    long_words = [word for word in words if len(word) > 3]
16    print(f"Long words: {long_words}")
17    
18    # Using filter() function (alternative approach)
19    evens_filter = list(filter(lambda x: x % 2 == 0, numbers))
20    print(f"Evens with filter(): {evens_filter}")
21    
22    print()
23    print("=== Transforming Lists ===")
24    
25    # Square all numbers
26    squares = [x**2 for x in numbers]
27    print(f"Squares: {squares}")
28    
29    # Uppercase all words
30    uppercase_words = [word.upper() for word in words]
31    print(f"Uppercase: {uppercase_words}")
32    
33    # Using map() function (alternative approach)
34    squares_map = list(map(lambda x: x**2, numbers))
35    print(f"Squares with map(): {squares_map}")
36    
37    print()
38    print("=== Checking Lists ===")
39    
40    # Check if all numbers are positive
41    all_positive = all(x > 0 for x in numbers)
42    print(f"All positive: {all_positive}")
43    
44    # Check if any word starts with 'p'
45    has_p_word = any(word.startswith('p') for word in words)
46    print(f"Has word starting with 'p': {has_p_word}")
47    
48    print()
49    print("=== Finding in Lists ===")
50    
51    # Find first even number
52    first_even = next((x for x in numbers if x % 2 == 0), None)
53    print(f"First even number: {first_even}")
54    
55    # Find longest word
56    longest_word = max(words, key=len)
57    print(f"Longest word: {longest_word}")
58    
59    # Find index of longest word
60    longest_index = words.index(longest_word)
61    print(f"Longest word index: {longest_index}")
62    
63    print()
64    print("=== Combining Lists ===")
65    
66    # Zip lists together
67    paired = list(zip(words, numbers[:len(words)]))
68    print(f"Paired words and numbers: {paired}")
69    
70    # Flatten nested lists
71    nested = [[1, 2], [3, 4], [5, 6]]
72    flattened = [item for sublist in nested for item in sublist]
73    print(f"Flattened: {flattened}")
74
75demonstrate_list_patterns()

 1def demonstrate_common_mistakes():
 2    """Show common list mistakes and how to avoid them."""
 3    
 4    print("=== Mistake 1: Modifying List While Iterating ===")
 5    
 6    # WRONG WAY - This skips elements!
 7    numbers = [1, 2, 3, 4, 5, 6]
 8    print(f"Original: {numbers}")
 9    
10    # Don't do this:
11    # for i, num in enumerate(numbers):
12    #     if num % 2 == 0:
13    #         numbers.pop(i)  # This changes indices while iterating!
14    
15    # RIGHT WAY 1: Create new list
16    odds_only = [num for num in numbers if num % 2 != 0]
17    print(f"Odds only (new list): {odds_only}")
18    
19    # RIGHT WAY 2: Iterate backwards
20    numbers_copy = numbers.copy()
21    for i in range(len(numbers_copy) - 1, -1, -1):
22        if numbers_copy[i] % 2 == 0:
23            numbers_copy.pop(i)
24    print(f"Odds only (backwards iteration): {numbers_copy}")
25    
26    print()
27    print("=== Mistake 2: Shallow vs Deep Copy ===")
28    
29    # Shallow copy issue with nested lists
30    original = [[1, 2], [3, 4]]
31    shallow_copy = original.copy()  # or original[:]
32    
33    # This affects both lists!
34    shallow_copy[0].append(3)
35    print(f"Original after shallow copy modification: {original}")
36    print(f"Shallow copy: {shallow_copy}")
37    
38    # Deep copy solution
39    import copy
40    original = [[1, 2], [3, 4]]
41    deep_copy = copy.deepcopy(original)
42    deep_copy[0].append(3)
43    print(f"Original after deep copy modification: {original}")
44    print(f"Deep copy: {deep_copy}")
45    
46    print()
47    print("=== Mistake 3: List Assignment vs Copy ===")
48    
49    list1 = [1, 2, 3]
50    list2 = list1  # This creates a reference, not a copy!
51    list2.append(4)
52    print(f"list1 after modifying list2: {list1}")  # Both changed!
53    
54    # Correct way to copy
55    list3 = [1, 2, 3]
56    list4 = list3.copy()  # or list3[:] or list(list3)
57    list4.append(4)
58    print(f"list3 after copying and modifying: {list3}")  # Unchanged
59    print(f"list4: {list4}")
60    
61    print()
62    print("=== Mistake 4: IndexError Handling ===")
63    
64    items = ['a', 'b', 'c']
65    
66    # Unsafe way
67    try:
68        item = items[5]  # This will raise IndexError
69    except IndexError:
70        print("Index 5 is out of range!")
71    
72    # Safe ways
73    index = 5
74    if index < len(items):
75        item = items[index]
76        print(f"Item at index {index}: {item}")
77    else:
78        print(f"Index {index} is out of range")
79    
80    # Using get-like behavior with default
81    def safe_get(lst, index, default=None):
82        return lst[index] if 0 <= index < len(lst) else default
83    
84    item = safe_get(items, 5, "Not found")
85    print(f"Safe get result: {item}")
86
87demonstrate_common_mistakes()

 1# Creating lists
 2numbers = [1, 2, 3, 4, 5]
 3empty = []
 4from_range = list(range(10))
 5repeated = [0] * 5
 6
 7# Accessing elements
 8first = numbers[0]
 9last = numbers[-1]
10length = len(numbers)
11
12# Adding elements
13numbers.append(6)           # Add to end
14numbers.insert(0, 0)        # Insert at position
15numbers.extend([7, 8, 9])   # Add multiple
16
17# Removing elements
18numbers.remove(5)           # Remove first occurrence
19last = numbers.pop()        # Remove and return last
20second = numbers.pop(1)     # Remove and return at index
21del numbers[0]              # Delete by index
22
23# Searching
24index = numbers.index(3)    # Find index of value
25count = numbers.count(2)    # Count occurrences
26exists = 4 in numbers       # Check if exists
27
28# Sorting and reversing
29numbers.sort()              # Sort in place
30sorted_nums = sorted(numbers)  # Return new sorted list
31numbers.reverse()           # Reverse in place
32
33# Slicing
34first_three = numbers[:3]   # First 3 elements
35last_two = numbers[-2:]     # Last 2 elements
36every_other = numbers[::2]  # Every other element
37reversed_list = numbers[::-1]  # Reverse copy
38
39# List comprehensions
40squares = [x**2 for x in range(5)]
41evens = [x for x in numbers if x % 2 == 0]
42
43# Useful functions
44total = sum(numbers)
45maximum = max(numbers)
46minimum = min(numbers)