6 ms·

If anything, Python encourages you to use loops because the backwards arrangement of the arguments to map and filter makes it painful to chain them.

• sgarland 2y ago
  map(function, iterable) That seems very logical to me, but then, I’m not a functional programmer, I just like map. It’s elegant, compact, and isn’t hard to understand. Not that list comps are hard to understand either, but they can sometimes get overly verbose. filter has also lost ground in favor of list comps, partially because Guido hates FP [0], and probably due to that, there has been a lot of effort towards optimizing list comps over the years, and they’re now generally faster than filter (or map, sometimes). [0]: https://www.artima.com/weblogs/viewpost.jsp?thread=98196 https://www.artima.com/weblogs/viewpost.jsp?thread=98196
  • BeetleB 2y ago
    Yes, but how do you chain them? map(func4, map(func3, map(func2, map(func1, iter)))) vs iter.map(f1).map(f2).map(f3).map(f4) I made up the syntax for the last one, but most functional languages have a nice syntax for it. Here's F#: iter |> f1 |> f2 |> f3 |> f4 Or plain shell: command | f1 | f2 | f3 | f4
    • TylerE 2y ago
      You don't. Use generator syntax, which is really the more pythonic way to it. >>> iter = [1,2,3,4] >>> f1 = lambda x: x*2 >>> f2 = lambda x: x+4 >>> f3 = lambda x: x*1.25 >>> [f3(f2(f1(x))) for x in iter] [7.5, 10.0, 12.5, 15.0]
      • BeetleB 2y ago
        First off, writing f3(f2(f1(x))) is painful - keeping track of parentheses. If you want to insert a function in the middle of the chain you have some bookkeeping to do. Second, that's all good and well if all you want to do is map. But what if you need combinations of map and filter as well? You're suddenly dealing with nested comprehensions, which few people like. In F#, it'll still be: iter |> f1 |> f2 |> f3 |> f4 Here's an example from real code I wrote: graph |> Map.filter isSubSetFunc |> Map.filter doesNotContainFunc |> Map.values |> Set.ofSeq This would not be fun to write in List Comprehensions, but you could manage (only two list comprehensions). Now here's other code: graph |> removeTerminalExerciseNodes |> Map.filter isEmpty |> Map.keys |> Seq.map LookUpFunc |> Seq.map RemoveTrivialNodes |> Seq.sortBy GetLength |> Seq.rev |> Seq.toList BTW, some of the named functions above are defined with their own chain of maps and filters.
        • Izkata 2y ago
          An alternative for python is to flip what you're iterating over at the outermost level. It's certainly not as clean as F# but neither is it as bad as the original example if there's a lot of functions: iter = [1,2,3,4] f1 = lambda x: x*2 f2 = lambda x: x+4 f3 = lambda x: x*1.25 result = iter for f in [f1, f2, f3]: result = [f(v) for v in result] Then the list comprehension can be moved up to mimic more closely what you're doing with F#, allowing for operations other than "map": result = iter for f in [ lambda a: [f1(v) for v in a], lambda a: [f2(v) for v in a], lambda a: [f3(v) for v in a], ]: result = f(result) And a step further if you don't like the "result" reassignment: from functools import reduce result = reduce(lambda step, f: f(step), [ lambda a: [f1(v) for v in a], lambda a: [f2(v) for v in a], lambda a: [f3(v) for v in a], ], iter)
          • BeetleB 2y ago
            Fair, but how would it look if you had some filters and reduces thrown in the middle? In my F# file of 300 lines[1], I do this chaining over 20 times in various functions. Would you really want to write the Python code your way every time, or wouldn't you prefer a simpler syntax? People generally don't do it your way often because it has a higher mental burden than it does with the simple syntax in F# and other languages. I don't do it 20 times because of an obsession, but because it's natural. [1] Line count is seriously inflated due to my habit of chaining across multiple lines as in my example above.
            • Izkata 2y ago
              My example was just a way to do it with plain python and nothing special. There are libraries that use operator overloading to get more F#-style syntax. For example: https://ryi.medium.com/flexible-piping-in-python-with-pipey-e8762db3a4ab https://ryi.medium.com/flexible-piping-in-python-with-pipey-... And another mentioned there: https://pypi.org/project/pipe/ https://pypi.org/project/pipe/
              • kingdomcome50 2y ago
      • Izkata 2y ago
        You're not using generator syntax anywhere in that example.
      • itishappy 2y ago
        Generators require a __next__ method, yield statement, or generator comprehension. What you've got is lambdas and a list comprehension. Rewriting using generators would look something like: items = [1,2,3,4] gen1 = (x*2 for x in items) gen2 = (x+4 for x in gen1) gen3 = (x*1.25 for x in gen2) result = list(gen3) It's nicer in a way, certainly closer to the pipe syntax the commenter your replying to is looking for, but kind of janky to have to name all the intermediate steps.
      • cma 2y ago
        f3(f2(f1 This is still backwards?
• itishappy 2y ago
  Don't Haskell and Python use the same argument order? filter(lambda x: x<5, map(lambda x: 2*x, [1,2,3,4,5])) filter (<5) . map (*2) $ [1,2,3,4,5] (Technically the Python version should be cast to a list to have identical behavior.) Same with comprehensions (although nesting comprehensions will always get weird). [x for x in [2*x for x in [1,2,3,4,5]] if x<5] [x | x <- [2*x | x <- [1,2,3,4,5]], x<5]
  • justincredible 2y ago
    [dead]