In the below code I am not able to understand how the variables field and value are being used because they are being assigned in the next line in the for loop.
I looked at the for in this syntax and examples but couldn't find anything useful which can explain this behaviour.
match = re.search(someregx, some_text)
current_row = {
field: value.strip() if value else '' for field, value in match.groupdict().items()
}
This is a dict comprehension. It creates a dict from the specified expressions. {...} is equivalent syntax to dict(...) in Python. (And in this particular case it's specifically creating a dict(iterable) from iterable; see bottom).
Ok so what does all this Python jargon mean? First, consider a list comprehension in Python which is an expression that creates a list from the given input, for example:
odd_numbers = [ n for n in range(100) if n%2 == 1 ]
Analogously, let's start with the most basic dict comprehension:
{ k: v for k, v in ... }
and note that the RHS match.groupdict().items() is an iterable, we're just iterating over the output from a regex match, as dictionary items. (Let's just write ... hereafter for the RHS, to minimize clutter).
Next, adding the v if v else '' is a conditional expression in Python, here it just handles the case if one of the value is None, and gives empty-string '' instead of None (which would (annoyingly) throw Exceptions if you tried to do further string-processing on it, and presumably we don't want to have to write try...except around every time we attempt to process the string value). It throws new users in Python a bit that the if in a conditional expression precedes the iterable that defines them, as you say. The first time you see it, it looks like a soup of keywords in the wrong order :)
(The combination of comprehensions, conditional expressions and combining and nesting these allows Python to be really expressive while being compact.)
Hence we're looking at:
{ k: v if v else '' for k, v in ... }
or in this particular case, and calling the key variable field:
{ field: value.strip() if value else '' for field, value in match.groupdict().items() }
Once you know that {...} is equivalent to dict(...), the help(dict) information helps you understand that this code is creating a dict(iterable) from iterable ; the 3rd case shown below in the syntax for dict(...):
class dict(object)
| dict() -> new empty dictionary
|
| dict(mapping) -> new dictionary initialized from a mapping object's
| (key, value) pairs
|
| dict(iterable) -> new dictionary initialized as if via:
| d = {}
| for k, v in iterable:
| d[k] = v
| ...
Miscellanous tips:
{...} is equivalent to dict(...). So whenever you see braces you're looking at a dict, nested dict, dict-of-list, JSON expression, etc. ...set. A set is essentially a dict that has keys but no value e.g. {'b', 'f', 'g'}. You can also have a set comprehension, except instead of { k: v for k, v ... } it's just { k for k in ... }. Here's an example: odd_numbers = { n for n in range(100) if n%2 == 1 }. In sets, order doesn't matter, unlike a tuple.[ ... ] or { ... }, but that was just for clarity in explaining the syntax. The Pythonic (PEP-8) way is not to write a space.key, value very short or one-letter names { k: v for k, v in ... }, esp. if they're complicated expressions, so you don't repeatedly waste space and need huge or wrapped lines.
It's dictionary comprehension, and it's equivalent to
current_row = {}
for field, value in match.groupdict().items():
if value:
current_row[field] = value.strip()
else:
current_row[field] = ''
