News for hackers. Stuff that matters.
Re:Introducing PyScript (summary of PyCon keynote) by matsemann on Thursday June 23, 2022 @04:46AM (#31846535)
In some ways I prefer javascript for lots of tasks. Easier to write functional style using filter and maps and lambdas, than python's weird itertools and list comprehensions.
Re:Introducing PyScript (summary of PyCon keynote) by Frotag on Thursday June 23, 2022 @06:59AM (#31847381)
Same, python is my goto language so its (minor-ish) deficiencies annoy me a lot.

- Annotating nested JSON objects is a pain in the ass. You need a bazillion intermediary classes.

- Sometimes you need a 3ish line lambda, because you have an beefy if-condition or a try-catch. Too bad multi-line lambdas aren't a thing.

- Function hoisting in JS is actually really nice, not just for the previous scenario. You can define utility functions at the bottom of a function and they'll be available to anything before that definition

- I wish python had a more succinct way to destructure dicts / objects like JS does, outside the new switch statements. (ie doesnt require imports, doesn't require typing the object name over and over.)

- Code completion doesn't work for list comprehensions because the for x in xs comes last :(

Re:Introducing PyScript (summary of PyCon keynote) by richiebful1 on Thursday June 23, 2022 @09:24AM (#31848752)
Honest question: why not name a function instead of using a multi-line lambda? I've never used a language where multi-line lambdas are common though.
Re:Introducing PyScript (summary of PyCon keynote) by Frotag on Thursday June 23, 2022 @09:37AM (#31848941)
Just readability for me. It's easier to read if the function is defined where it's used rather than before.

  apply(lst, () => {
     ...
     ...
  })
instead of

  def naming_is_hard():
      ...
      ...
  apply(lst, naming_is_hard)
Re:Introducing PyScript (summary of PyCon keynote) by zasdffaa on Thursday June 23, 2022 @11:10AM (#31850187)
Agreed with @richiebful1, multiliners are better as standlone funcs, and I'd say (personal opinion) that they'd be better here. I like functional a lot but I don't lambda up unless it's more or less a one-liner or a kind of control structure, where they can get large but that's the point.

I've had to deal with too much shit code where lambdas within lambdas are considered hot.

Added bonus, the names are useful (naming is hard because if you do it right you are adding valuable information).

I'm sure there are cases where doing it your way are better, but I can't think of them.

Re:Introducing PyScript (summary of PyCon keynote) by rjmill on Friday June 24, 2022 @09:08AM (#31861178)
If `apply` is your own code, you could refactor it to

  @apply(lst)
  def naming_is_hard():
      ...
I came to python after working in JS fulltime for years, and used to complain about the exact same thing. After I started using decorators, I stopped complaining about the single-line lambdas.

For any non-python devs looking at my example, it's equivalent to

  def naming_is_hard():
      ...

  naming_is_hard = apply(lst)(naming_is_hard)
It's a nice way to pass functions into other functions, much like how you'd do with a lambda.

edit: s/list/lst/g because autocorrect "fixed" the variable name.

Re:Introducing PyScript (summary of PyCon keynote) by zaphirplane on Monday June 27, 2022 @02:42AM (#31891332)
Kotlin JavaScript typescript anonymous functions in golang
Re:Introducing PyScript (summary of PyCon keynote) by gigatexal on Thursday June 23, 2022 @07:10AM (#31847452)
List comprehensions are one of the best features! How dare you sully the great name of the list comprehensions!

In all seriousness I do like them a lot. But like all things one can abuse them and make code unreadable.

Re:Introducing PyScript (summary of PyCon keynote) by matsemann on Thursday June 23, 2022 @08:05AM (#31847875)
Problem with list comprehensions are that it's often not easy to see what you're trying to do. Like, I have some objects I want to group by a property, and then make a map containing the sum of some other property of those groups but only if it's value is above 5.

Take Kotlin:

    result = myList
         .filter { it.myValue > 5 }
         .groupBy { it.myKey }
         .mapValues { entry -> entry.value.sumOf { it.myValue }}
In python:

    result = {
        key: sum(el["myValue"] for el in elements)
        for key, elements in groupby(
            sorted([el for el in my_list if el["myValue"] > 5], key=lambda el: el["myKey"]),
            key=lambda el: el["myKey"],
        )
    }
to me that's incomprehensible. You have to read it the wrong way, and it's not really clear what the intention behind each step is. Like, the filter is in the middle!
Re:Introducing PyScript (summary of PyCon keynote) by js2 on Thursday June 23, 2022 @10:28AM (#31849570)
Use intermediate steps:

    keyOf = itemgetter("myKey")
    valueOf = itemgetter("myValue")
    filtered = (item for item in myList if valueOf(item) > 5)
    grouped = groupby(sorted(filtered, key=keyOf), keyOf)
    result = {key: sum(valueOf(item) for item in group) for key, group in grouped}
Re:Introducing PyScript (summary of PyCon keynote) by musicale on Thursday June 23, 2022 @01:21PM (#31852285)
Could you save a line by replacing valueOf(item) with item.value?
Re:Introducing PyScript (summary of PyCon keynote) by js2 on Thursday June 23, 2022 @01:52PM (#31852745)
OP wrote the code as if the list items were dictionaries, so I just made that pythonic. If they are objects whose attributes we care about then we can get rid of the two getters altogether which are mostly there to make the code more legible but also remove duplication. You could also switch them to attrgetters.
Re:Introducing PyScript (summary of PyCon keynote) by gigatexal on Thursday June 23, 2022 @10:35AM (#31849678)
Ooh I like this. That’s about what I would do as well.
Re:Introducing PyScript (summary of PyCon keynote) by dfinninger on Thursday June 23, 2022 @10:40AM (#31849747)
Yeah that Python would not pass my code review. Rule of thumb is don’t nest list comprehensions, and if you have to try to keep it to two. Checkpoint the results info a variable. You aren’t supposed to chain like that in Python.

From https://docs.python.org/3/tutorial/datastructures.html#id2

> You might have noticed that methods like insert, remove or sort that only modify the list have no return value printed – they return the default None. [1] This is a design principle for all mutable data structures in Python.

> Footnotes > [1] Other languages may return the mutated object, which allows method chaining, such as d->insert("a")->remove("b")->sort();.

Re:Introducing PyScript (summary of PyCon keynote) by jgalt212 on Thursday June 23, 2022 @09:36AM (#31848925)
True that. That's why I prefer R, and its built-in pipes, when I'm working with relatively clean data.
Re:Introducing PyScript (summary of PyCon keynote) by gigatexal on Thursday June 23, 2022 @08:40AM (#31848203)
Yeah ... In that case I would write a function to return this result dict in a more imperative way in python -- but perhaps that's cuz i am not that great of an engineer/python dev. But what I can see is that the syntax of Kotlin (which I've never written) you've provided is a lot cleaner.
Re:Introducing PyScript (summary of PyCon keynote) by edanm on Thursday June 23, 2022 @05:25AM (#31846730)
Python also has filters maps and lambdas, and lots of third-party support for other functional ideas (e.g. the Toolz library).

Though personally I really like itertools and list comprehensions. (And list comprehensions are pretty functional as well, they were inspired by haskell I blieve.)

Re:Introducing PyScript (summary of PyCon keynote) by xnorswap on Thursday June 23, 2022 @06:28AM (#31847166)
In my experience lambdas are a lot easier to write with strong types and related tooling.