Code Execution Order and Debugging Tips in Jupyter Notebook

# 1. Understanding Code Execution Order in Jupyter Notebook

1.1 Default Rules for Code Execution Order:
- Jupyter Notebook executes code blocks from top to bottom by default.
- After each code block is executed, the output will be displayed below the code block.
1.2 Manually Adjusting Code Block Execution Order:
- You can manually execute specified code blocks using the "Run" button or shortcuts in the toolbar above.
- Numbered markers (e.g., `In[1]`, `In[2]`, etc.) are used to indicate the order of execution for code blocks.
1.3 Viewing Code Execution Status and Output Results:
- The square brackets `[]` to the left of a code block indicate that it has not been executed yet, `[*]` means it is currently executing, and `[1]` signifies it has been executed.
- If a code block encounters an error during execution, the system will display an error message and the line number where the error occurred.

With these methods, we can clearly understand the execution order and status of code in Jupyter Notebook, making debugging and viewing the results of code execution more convenient.

# 2. Debugging Code in Jupyter Notebook

Debugging is crucial during the development process as it helps us quickly discover and resolve issues within the code. Here are some commonly used techniques for debugging code in Jupyter Notebook:

#### 2.1 Inserting Breakpoints for Debugging

Inserting breakpoints is a common debugging method that allows the program to pause at a specified location, enabling us to inspect the execution process step by step.

- How to insert a breakpoint: Click on the blank space to the left of the code line, a blue circle will appear indicating that a breakpoint has been added.
- Example code:

   def calculate_sum(nums):
       total = 0
       for num in nums:
           total += num
       return total

   nums = [1, 2, 3, 4, 5]
   total_sum = calculate_sum(nums)
   print(total_sum)

#### 2.2 Single-Step Debugging

Single-step debugging allows us to execute the code line by line and view the results of each step, which helps us understand the code execution process more clearly.

- Common operations for single-step debugging: Use the "Step Execution" button in the debugging toolbar to step through the code line by line.

- Example code:

   def calculate_sum(nums):
       total = 0
       for num in nums:
           total += num
           print(f'Current total: {total}')
       return total

   nums = [1, 2, 3, 4, 5]
   total_sum = calculate_sum(nums)
   print(total_sum)

#### 2.3 Viewing Variable Values and Status

During debugging, we need to continuously monitor variable values and status to promptly identify issues and make adjustments.

- Viewing variable values: In Jupyter Notebook, you can use the print() function to output the value of variables.

- Example code:

   def calculate_sum(nums):
       total = 0
       for num in nums:
           total += num
           print(f'Current total: {total}')
       return total

   nums = [1, 2, 3, 4, 5]
   total_sum = calculate_sum(nums)
   print(total_sum)

#### Debugging Flowchart Example:

graph TB
     A(Start) --> B{Condition Check}
     B -- Yes --> C[Execute Code Block A]
     B -- No --> D[Execute Code Block B]
     C --> E{Need Debugging?}
     E -- Yes --> F[Insert Breakpoint]
     E -- No --> G[Continue Execution]
     F --> H{Single-Step Debugging}
     H -- Yes --> I[Check Variable Status]
     H -- No --> I
     I --> G
     G --> J(End)
     D --> J

With the above debugging techniques, we can more efficiently troubleshoot code issues in Jupyter Notebook, improving development efficiency.

# 3. Using Magic Commands in Jupyter Notebook to Enhance Debugging Efficiency

In Jupyter Notebook, magic commands can help us debug and optimize code performance more efficiently. Below are several commonly used magic commands and their usage methods.

#### 3.1 %debug: Enter Debug Mode When an Exception Occurs

The `%debug` magic command can be used to enter debug mode when an exception occurs in the code, allowing us to view the cause of the exception. Here is an example code:

def divide_by_zero():
    return 10 / 0

try:
    divide_by_zero()
except Exception as e:
    %debug

In the above code, if the `divide_by_zero()` function throws a division by zero exception, `%debug` will启动 the debugger, allowing us to view the current call stack and variable states.

#### 3.2 %pdb: Automatically Start the Debugger When an Exception Occurs

The `%pdb` magic command can automatically start the debugger when an exception occurs in the code, without needing to manually add a `try...except` block. For example:

%pdb on

def divide_by_zero():
    return 10 / 0

divide_by_zero()

In this example, when the `divide_by_zero()` function throws a division by zero exception, the debugger will automatically启动 for debugging purposes.

#### 3.3 %timeit: Measure Code Execution Time

The `%timeit` magic command can be used to measure the execution time of a cod