Benchmark: Python Enum vs string compare

HTML Preparation code:

<script src='https://cdn.jsdelivr.net/pyodide/v0.26.3/full/pyodide.js'></script>

Script Preparation code:

async function globalMeasureThatScriptPrepareFunction() {
  	window.globalPyodide = await loadPyodide();
  	console.log(globalPyodide.runPython('import sys; sys.version'));
	await globalPyodide.runPython(`
		from enum import Enum, auto

		class TestEnum(Enum):
			a = auto()
			b = auto()

		a = "connected"
		b = "disconnected"
	`);    
}

Tests:

Test #1 Enum
window.globalPyodide.runPython(` c = 0 for i in range(0, 100000): v = TestEnum.a if i % 2 == 0 else TestEnum.b if v is TestEnum.a: c = c + 1 `);
String compare
window.globalPyodide.runPython(` c = 0 for i in range(0, 100000): v = "connected" if i % 2 == 0 else "disconnected" if v == "connected": c = c + 1 `);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Test #1 Enum
String compare

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one month ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36 Edg/133.0.0.0

Browser/OS: Chrome 133 on Windows

View result in a separate tab

Test name	Executions per second
Test #1 Enum	59.0 Ops/sec
String compare	73.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):

LLMs can make mistakes. Check important info.

The benchmark described in the provided JSON compares the performance of two approaches for handling enumerated values and simple string comparisons in Python code using Pyodide: using Python's `Enum` class versus using simple string values. This is useful for software engineers to understand the performance implications of different coding strategies, especially when dealing with a high volume of comparisons.

### Benchmark Overview

1. **Test #1: Enum Comparison**
   - **Benchmark Definition:**
     ```python
     c = 0
     for i in range(0, 100000):
         v = TestEnum.a if i % 2 == 0 else TestEnum.b
         if v is TestEnum.a:
             c = c + 1
     ```
   - **Description:**
     This test creates two enumerated values using Python's `Enum`: `TestEnum.a` and `TestEnum.b`, which correspond to "connected" and "disconnected". For each iteration in a loop of 100,000 runs, it assigns either `TestEnum.a` or `TestEnum.b` based on the value of `i`. The comparison checks if the selected value is `TestEnum.a` using the `is` operator, which checks for identity.

2. **Test #2: String Comparison**
   - **Benchmark Definition:**
     ```python
     c = 0
     for i in range(0, 100000):
         v = "connected" if i % 2 == 0 else "disconnected"
         if v == "connected":
             c = c + 1
     ```
   - **Description:**
     This test uses simple string comparisons, where for each iteration, it assigns either the string "connected" or "disconnected" based on the value of `i`. The condition checks equality using `==`.

### Performance Results

- **Enum Test Results:**
  - Executions per Second: 58.99

- **String Comparison Results:**
  - Executions per Second: 73.03

### Pros and Cons of Each Approach

1. **Using Python Enum:**
   - **Pros:**
     - Improved readability and maintainability: Enums provide meaningful names and can prevent hardcoding of string literals throughout code.
     - Type safety: Enums can help prevent errors associated with string literals (e.g., typos).
   - **Cons:**
     - Potentially slower performance: The `is` operator checks for object identity, which, while efficient, may be slower in this context compared to string equality checks, especially when dealing with a large number of iterations.
     - More memory overhead: While not a major downside, Enums may use more memory than simple strings due to the additional abstraction.

2. **Using Simple Strings:**
   - **Pros:**
     - Faster performance: As demonstrated in the benchmark, string comparisons have resulted in a higher number of executions per second due to their simpler nature.
     - Lower memory usage: Strings are straightforward and generally consume less memory than Enums.
   - **Cons:**
     - Less readable: The use of magic strings can lead to errors and make the code harder to understand and maintain.
     - Risk of human error: Typing string literals increases the chances of typos that can cause bugs.

### Other Considerations and Alternatives

- **Alternatives to Enums:**
  - Constants: Using constant variables for strings can provide a balance between readability and performance. This avoids magic strings while also potentially improving performance over Enums.

- **Choosing Between Approaches:**
  - The choice between using `Enum` or string comparisons largely depends on the requirements of the application. If performance is critical in sections of code run often, the string method may be preferable, while if code maintainability and clarity are prioritized, `Enum` may be the better choice.

- **Consideration of Context:**
  - The performance metrics may vary based on the execution environment (e.g., Pyodide in this case), so it is essential to consider how benchmarks may differ under different scenarios.

In conclusion, this benchmark helps clarify the trade-offs between using Python's `Enum`, which offers advantages in terms of readability and safety, and simple string comparisons, which can provide superior performance in certain iterations.

Related benchmarks:

Python Enum vs string compare (version: 1)

Comparing performance of: Test #1 Enum vs String compare

Created: one month ago by: Guest

Jump to the latest result

Test #1 Enum

String compare

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):