For a small Python tool that accepts one KEY=VALUE string, use text.partition('=') to separate it at the first equals sign. The result always has three parts: the text before the separator, the separator itself, and the remaining value. Checking the middle part lets you distinguish a missing separator from a deliberately empty value.
This is useful when a value can contain more equals signs, such as a query fragment or an opaque token. It is not a complete parser for shell assignment syntax, environment files or INI configuration. Define the input contract before accepting records from another system.
Understand the three returned parts
The official Python documentation states that str.partition splits at the first occurrence of its separator. If the separator is absent, it returns the original string followed by two empty strings. That predictable tuple avoids relying on how many pieces an unrestricted split happened to produce.
For example, 'MODE=fast=verified' becomes a key of MODE, a separator of = and a value of fast=verified. Keeping the second equals sign matters: it belongs to the value under this contract. Splitting on every equals sign and then taking only one piece would silently discard information.
The separator is literal text, not a regular expression. An empty separator is not valid. This tutorial fixes it to one equals sign rather than allowing callers to invent a separator dynamically.
Define which transformations are permitted
The example below accepts a nonblank key and permits an empty value. It strips surrounding whitespace from the key only. It deliberately leaves the value unchanged, because trailing spaces or an additional equals sign may be meaningful to the receiving tool.
It does not validate a key against a particular service’s allowed names, interpret quotation marks, expand variables, remove comments or execute anything. If your application requires a restricted key alphabet or a nonempty value, add that requirement explicitly. Do not quietly trim all values just because trimming keys was useful.
Run the parser and its small fixtures
Save this self-contained example as parse_assignment.py and run it with your Python 3 launcher. It uses no external packages, reads no files and changes no environment variables. The printed representations make preserved whitespace visible.
def parse_assignment(text):
key, separator, value = text.partition('=')
if not separator:
raise ValueError('Missing equals separator')
key = key.strip()
if not key:
raise ValueError('Blank key')
return key, value
valid_cases = [
('MODE=fast=verified', ('MODE', 'fast=verified')),
('EMPTY=', ('EMPTY', '')),
(' LABEL = keep spaces ', ('LABEL', ' keep spaces ')),
]
for text, expected in valid_cases:
actual = parse_assignment(text)
assert actual == expected
print(repr(actual))
for text in ('MODE', '=value', ' =value', ''):
try:
parse_assignment(text)
except ValueError as exc:
print(f'Rejected {text!r}: {exc}')
else:
raise AssertionError(f'Unexpected acceptance: {text!r}')
The first three cases should be accepted with exactly the expected key and value. The remaining four inputs should be rejected: two lack the separator and two have a blank key after the agreed key normalisation. The assertions are demonstration checks, not a substitute for explicit runtime validation in an application. Python can disable assertions when run with optimisation; the function’s explicit exceptions do not depend on them.
Keep empty values separate from missing input
EMPTY= passes because a separator exists and this contract allows an empty value. EMPTY fails because there was no separator. Avoid a test such as ‘if not value’ when your actual question is whether the equals sign existed: it collapses different inputs into the same rejection.
That distinction resembles the difference between an absent dictionary entry and a present entry with a special value. For the latter task, see checking a missing Python dictionary key separately from None. Keep each boundary explicit instead of using a single truthiness test for every condition.
Integration checklist and common questions
- Specify whether empty values are allowed before connecting the parser to writes.
- Preserve the original input for an appropriate private diagnostic, without logging secrets.
- Validate keys against the destination’s actual schema.
- If collecting multiple assignments, decide whether repeated keys must be rejected before placing them in a dictionary.
- Use the proper format parser if the real input is JSON, CSV or INI.
Could split work instead? Yes. A split limited to one occurrence can preserve the remaining equals signs, but still requires a check for the missing-separator case. Does partition remove quotes? No. Quotes are ordinary characters here; this is not shell evaluation. Does a successful parse authorise a setting change? No. Parsing establishes structure only, not permission or semantic validity.
Source and safety
The behaviour is documented in Python’s str.partition reference. This tutorial is for educational purposes. Test carefully with non-sensitive examples before using steps in production. The site owner is not responsible for misuse, damage, data loss or production issues.
