String transformation

Standardizes identifier naming conventions from CamelCase to snake_case.

API integration: converting JavaScript CamelCase response keys to Python snake_case Code refactoring: renaming imported variable names from other languages to snake_case Database schema migration: normalizing column names generated from class names

Data cleaning scripts, ORM model definitions, API integration layers, refactoring tools.

re.sub(r'(?<=\\w)([A-Z])', r'_\\1', text).lower()

re.sub(r'(?<=\\w)([A-Z])', r'_\\1', ...).lower()

text: the input string variable

• Commonly used with import re
• string stripping methods like .strip()
• and replacement methods like .replace().

• Using a loop with char.isupper() checks – more readable but slower for large strings
• using the third‑party 'regex' library for better Unicode support – adds dependency but handles complex Unicode cases.

Forgetting the lookbehind (?<=\\w) which places an underscore before the first character of PascalCase (e.g., '_UserProfile') causing a leading underscore. Omitting the .lower() call, leaving uppercase letters and producing Mixed_case output instead of snake_case. Using the pattern without the lookbehind and applying it to strings that start with an uppercase letter, resulting in an unwanted leading underscore.

str.lower() alone – only lowercases letters, does not insert underscores. re.sub(r'([a-z])([A-Z])', r'\\1_\\2', text).lower() – alternative capture‑group approach that works similarly but requires two capturing groups. re.sub(r'([A-Z]+)', r'_\\1', text).lower() – naive acronym handling that incorrectly splits each uppercase letter.

Coming from JavaScript: developers might manually split/join strings instead of using a single regex pass – leads to more verbose code and missed edge cases.

• snake_case conversion
• CamelCase splitting
• regex lookarounds

Avoid using this pattern when the input may contain consecutive uppercase letters (acronyms) because it splits each letter, producing 'x_m_l_parser' from 'XMLParser'; performance impact is negligible for typical identifier lengths but the regex scans the whole string; boundary case: strings that start with an uppercase letter will get a leading underscore if the lookbehind is omitted.

Ensures code adheres to PEP 8 naming standards automatically.

Lookbehind for word, capture Upper, prepend underscore, then lower all.

This pattern does not handle consecutive uppercase letters (acronyms) ideally; e.g., 'XMLParser' yields 'x_m_l_parser'. For better acronym handling, consider patterns that treat sequences of uppercase as a single word.

re.sub(r'(?<!^)(?=[A-Z])', '_', text).lower() for better acronym handling (though still imperfect for all cases), or using external libraries like 'inflection'.