Python string handling

• Python offers versatile tools for string manipulation, conditional logic, repetition, data organization, modular programming, error handling, searching, and problem-solving.
• These features collectively enable effective computational thinking and program development.

String Handling

• Strings are sequences of characters, commonly used to store text.
• Strings are immutable, meaning their values cannot be modified after creation.
• Common string operations include:
  • Concatenation (+): Combines two or more strings.
  • Slicing ([start:end:step]): Extracts a portion of a string.
  • Length (len()): Returns the number of characters in a string.
  • Case conversion (e.g., .upper(), .lower()): Changes the case of characters.
  • Searching (e.g., .find(), .index()): Locates substrings within a string.
  • Replacement (e.g., .replace()): Substitutes substrings.
  • Splitting (e.g., .split()): Divides a string into a list of substrings based on a delimiter.
• Tip: Remember that Python string indices start at 0.
• Tip: Use string formatting (f-strings or .format()) for creating dynamic strings with variables.

Selection (if Statements)

• Selection statements control the flow of execution based on conditions.
• The if statement executes a block of code if a condition is true.
• else clause: Provides an alternative block of code to execute if the if condition is false.
• elif clause: Allows multiple conditions to be checked in sequence.
• Syntax:

  if condition:
      # Code to execute if condition is true
  elif condition2:
      # Code to execute if condition2 is true
  else:
      # Code to execute if all conditions are false
  

• Tip: Indentation is crucial in Python to define code blocks.
• Tip: Use boolean operators (and, or, not) to create complex conditions.

Iteration (for and while Loops)

• Iteration statements repeat a block of code multiple times.
• for loops: Iterate over a sequence (e.g., a list, string, or range).

  for item in sequence:
      # Code to execute for each item
  

• while loops: Repeat a block of code as long as a condition is true.

  while condition:
      # Code to execute while condition is true
  

• Key Differences
  • Use for loops when the number of iterations is known or when iterating over a sequence.
  • Use while loops when the number of iterations is unknown and depends on a condition.
• Tip: Use break to exit a loop prematurely and continue to skip to the next iteration.
• Tip: Avoid infinite loops by ensuring the loop condition eventually becomes false.

Data Structures

• Data structures are used to organize and store data.
• Common Python data structures include:
  • Lists: Ordered, mutable sequences of items.
    • Methods: .append(), .insert(), .remove(), .pop(), .sort().
    • Iteration:

      my_list = [1, 2, 3]
      for item in my_list:
          print(item)
      

  • 2D Lists: Lists of lists, representing tables or matrices.
    • Accessing elements: my_list[row_index][column_index].
  • Tuples: Ordered, immutable sequences of items.
    • Useful for representing fixed collections of data.
  • Sets: Unordered collections of unique items.
    • Methods: .add(), .remove(), .union(), .intersection().
  • Dictionaries: Collections of key-value pairs.
    • Accessing values: my_dict[key].
    • Methods: .keys(), .values(), .items().
• Tip: Choose the appropriate data structure based on the requirements of the problem (e.g., mutability, order, uniqueness).

Subroutines and Modules

• Subroutines (functions) are reusable blocks of code that perform specific tasks.
• Modules are collections of functions, classes, and variables.
• Built-in subroutines: Functions provided by Python (e.g., print(), len(), input()).
• User-defined functions: Functions created by the programmer.

  def my_function(parameter1, parameter2):
      # Code to execute
      return result
  

• time module: Provides functions for working with time (e.g., time.sleep(), time.time()).
• random module: Provides functions for generating random numbers (e.g., random.randint(), random.random()).
• Tip: Use functions to break down complex problems into smaller, manageable parts.
• Tip: Import modules using import module_name and access functions using module_name.function_name().

Making Programs Robust

• Validation: Checking user input to ensure it is valid and prevent errors.
• Regular expressions: Patterns used to match and manipulate strings.
  • Module: re.
  • Functions: re.search(), re.match(), re.findall().
• Debugging: Identifying and fixing errors in code.
  • Techniques: Print statements, debuggers (e.g., pdb).
• Exception handling: Handling errors that occur during program execution.

  try:
      # Code that may raise an exception
  except ExceptionType:
      # Code to handle the exception
  finally:
      # Code that always executes (optional)
  

• Tip: Use try-except blocks to gracefully handle potential errors and prevent program crashes.

Searching Algorithms

• Searching algorithms are used to find a specific element in a data structure.
• Linear search: Checks each element in sequence until the target is found or the end is reached.
• Binary search: Repeatedly divides the search interval in half, efficient for sorted data.
• Tip: Binary search requires the data to be sorted.
• Tip: Linear search is simpler to implement but less efficient for large datasets.

Arrays (Lists in Python)

• Arrays (implemented as lists in Python) are contiguous blocks of memory used to store collections of elements of the same data type.
• Python lists are dynamic arrays, meaning their size can change during runtime.
• Common array operations:
  • Accessing elements: my_array[index].
  • Modifying elements: my_array[index] = new_value.
  • Adding elements: my_array.append(), my_array.insert().
  • Removing elements: my_array.remove(), my_array.pop().
• Tip: Use lists to store collections of related data.

Trace Tables

• Trace tables are used to manually trace the execution of a program and track the values of variables.
• Useful for understanding program behavior and debugging.
• Steps:
  1. Create a table with columns for each variable and the line number.
  2. Execute the code line by line, updating the table with the current values of the variables.
• Tip: Use trace tables to identify errors in logic and understand how variables change over time.

Principles of Computational Thinking

• Decomposition: Breaking down complex problems into smaller, more manageable parts.
• Pattern recognition: Identifying similarities and patterns in data or problems.
• Abstraction: Focusing on relevant details and ignoring irrelevant ones.
• Algorithm design: Creating step-by-step instructions to solve a problem.
• Tip: Computational thinking skills are essential for problem-solving and software development.