Scala has the apply() function.
I am new to Python and I am wondering how should I write the following one-liner:
(part_a, part_b) = (lambda x: re.search(r"(\w+)_(\d+)", x).groups())(input_string) I would feel better with something like:
(part_a, part_b) = input_string.apply(lambda x: re.search(r"(\w+)_(\d+)", x).groups()) Am I wrong from a FF viewpoint? Is there such construction in Python?
Edit: I know about the poorly picked snippet.
When writing Haskell write Haskell. When writing Python just write Python:
part_a, part_b = re.search(r"(\w+)_(\d+)", input_string).groups() If you're using a Python without apply, you could always write it yourself...
def apply(fn, args=(), kwargs=None): if kwargs is None: kwargs = {} return fn(*args, **kwargs) just because you could, doesn't mean you should..
Python does not have such a construct; what would be the point? lambda x: ... is a function, and therefore it should be used like a normal function, i.e., as (lambda x: ...)(input_string) as in your first snippet.
However, in your case, I see no reason why you should even bother with a lambda; just do:
(part_a, part_b) = re.search(r"(\w+)_(\d+)", input_string).groups() If you're concerned about re-use, you could compile the regex:
rx = re.compile(r"(\w+)_(\d+)") a, b = rx.search(input_string).groups() 
rx an informative name).Python used to have a apply function (docs), but it has been removed in python 3, since it was unnecessary and against python's principle that there should be only one way to do a particular thing.
Say, we have a function called "func", we can easily call func(*args) instead of apply(func, args).
part_a, part_b = apply(lambda ...: ..., input_string)worked.applyfunction since the beginning too, but sinceapply(fn, args, kwargs) == fn(*args, **kwargs)there is little use for it anymore..functools.partial()?re.search(r"(\w+)_(\d+)", input_string).groups()?