Built-in Methods for Data Structures

1. Strings: Working with Text

In Python, text is handled using string objects. A string is an immutable sequence of characters, meaning once it's created, it cannot be changed. Let's explore how to create and manipulate them.

Key String Concepts Recap

The video you just watched covers the essentials. Let's summarize and organize the key ideas.

• Creation: Strings can be created with single ('...'), double ("..."), or triple ("""...""") quotes. Triple quotes are especially useful for multi-line strings.
• Indexing & Slicing: You can access individual characters using an index (e.g., my_string[0]) or a range of characters using a slice (e.g., my_string[1:5]).
• F-Strings: Formatted strings (or f-strings) are the modern, preferred way to embed expressions inside strings. They are both readable and efficient.

  name = "Alex"
  task_count = 5
  print(f"Hello, {name}! You have {task_count} tasks.")
  # Output: Hello, Alex! You have 5 tasks.
  

• Common Methods: These are functions attached to string objects.

Here are some of the most useful methods:

• .strip(): Removes leading/trailing whitespace.
• .lower() / .upper(): Changes the case of the string.
• .replace('old', 'new'): Returns a copy of the string with occurrences of 'old' replaced by 'new'.
• .split('delimiter'): Breaks the string into a list of substrings based on a delimiter.
• 'delimiter'.join(list_of_strings): Joins elements of a list into a single string.

raw_data = "  task_id:001-A, title:  Refactor the user module  , status:pending   "

# 1. Split the string into parts by the comma
parts = raw_data.split(',')
# parts is now ['  task_id:001-A', ' title:  Refactor the user module  ', ' status:pending   ']

# 2. Get the part containing the title (the second element, index 1)
title_part = parts[1]
# title_part is ' title:  Refactor the user module  '

# 3. Split that part by the colon to separate "title" from the actual title
title_key_value = title_part.split(':')
# title_key_value is [' title', '  Refactor the user module  ']

# 4. Get the actual title (the second element, index 1) and strip whitespace
clean_title = title_key_value[1].strip()
# clean_title is 'Refactor the user module'

# 5. Capitalize it appropriately (e.g., first letter)
formatted_title = clean_title.capitalize()
# formatted_title is 'Refactor the user module'

print(formatted_title)

2. Lists and Tuples: Ordered Collections

Strings are sequences of characters. Lists and tuples are more general: they are sequences of any Python objects. You can have a list of numbers, a list of strings, or even a list containing other lists.

The key difference between them is mutability:

• Lists are mutable: you can change them after they are created (add, remove, or change items).
• Tuples are immutable: once created, they cannot be changed.

This distinction is important. We use lists when we need a collection that will grow, shrink, or change. We use tuples for data that we want to remain constant, like coordinates (x, y) or RGB color values.

Key List and Tuple Concepts Recap

Let's consolidate what you've learned.

Lists are your go-to for ordered collections that need to be modified.

• Creation: my_list = [1, "hello", 3.14]
• Modification:
  • my_list.append('new_item')
  • my_list.pop() (removes and returns the last item)
  • my_list[1] = "world" (replaces an item at a specific index)
• Sorting:
  • my_list.sort() modifies the list in-place.
  • new_sorted_list = sorted(my_list) returns a new, sorted list without changing the original.

Tuples are for fixed, ordered data.

• Creation: my_tuple = (1, "hello", 3.14)
• Special Case: A single-item tuple needs a trailing comma: singleton = (1,). Without the comma, (1) is just the number 1.
• Immutability: You cannot append, pop, or reassign items. my_tuple[1] = "world" will cause an error. This "write-protection" is a feature, not a limitation.

In our Task Manager project, we'll use a list to hold the collection of tasks for a user, as this list will constantly change as tasks are added, completed, and deleted.

3. Dictionaries: Key-Value Pairs

While lists are great for ordered sequences, dictionaries are optimized for a different purpose: storing data as key-value pairs. Think of a real-world dictionary where you look up a word (the key) to find its definition (the value).

Dictionaries are unordered (though in recent Python versions they remember insertion order), mutable, and incredibly fast for lookups.

Key Dictionary Concepts Recap

• Creation: Dictionaries are created with curly braces {}.

  task = {
      "title": "Learn Python Dictionaries",
      "priority": "High",
      "completed": False
  }
  

• Accessing Values: You use the key inside square brackets.

  print(task["title"])
  # Output: Learn Python Dictionaries
  

• Safe Access with .get(): If a key might not exist, using .get() avoids errors. It returns None or a specified default value if the key is not found.

  print(task.get("due_date"))  # Output: None
  print(task.get("due_date", "Not set")) # Output: Not set
  

• Modifying and Adding: You can add a new key-value pair or update an existing one with a simple assignment.

  task["completed"] = True  # Update existing value
  task["due_date"] = "2024-10-26"  # Add a new key-value pair
  

• Iterating: You can loop over keys, values, or both.

  # Loop over keys
  for key in task.keys():
      print(key)
  
  # Loop over key-value pairs
  for key, value in task.items():
      print(f"{key}: {value}")
  

Dictionaries will be central to our web application. We'll use them to represent individual objects, like a single task with all its properties (title, priority, status, etc.).

user = {"username": "jdoe", "email": "j.doe@example.com"}

# Add a new key-value pair
user["is_active"] = True

# Update an existing value
user["email"] = "jane.doe@example.com"

print(user)
# Expected output: {'username': 'jdoe', 'email': 'jane.doe@example.com', 'is_active': True}

For a comprehensive overview of all the concepts covered, this cheat sheet is an excellent resource to keep handy.

Conclusion

Great job on completing your first lesson! You've refreshed your knowledge of Python's four fundamental data structures and how to manipulate them.

Key Takeaways:

• Strings: Immutable sequences of characters for handling text. Use f-strings for formatting.
• Lists: Mutable, ordered sequences. Ideal for collections of items that will change over time.
• Tuples: Immutable, ordered sequences. Use them when you want to ensure data doesn't change.
• Dictionaries: Mutable collections of key-value pairs. Perfect for lookups and representing objects with named properties.
• Mutability is the key concept that separates these types. Mutable objects (lists, dictionaries) can be changed in-place, while immutable ones (strings, tuples) cannot.

In our next lesson, we'll build on this by learning how to organize our code into reusable blocks. You will learn to write Python functions with parameters, return values, and default arguments. This is the next crucial step toward building more complex and maintainable applications.