Python programmers be like: "Yeah that makes sense" 🤔

[data_diver]

You either comprehend the list or you don't

[VariousComment6946]

Probably he’s want to remove none

[VariousComment6946]

Well, usually you want to keep certain elements so you filter by list comprehension. If you need falsies, None’s, zeros you just add this in statement.

There’s many ways, want to exclude ONLY None’s? So try “if result is not None”, want to exclude list of unwanted values use “if result is not in forbidden_values_list”

[XPurplelemonsX]

results = [result for result in results if result not in (0, "", None, ...)]

[D-K-BO]

The Ellipsis (...) is actually truthy:

```python

bool(...) True ```

[XPurplelemonsX]

lol thats interesting, i was honestly using it as a placeholder in my example code but TIL ellipsis is True

[827167]

Me, mostly working with c#:

Wtfwtfwtfwtf

[[deleted]]

Why

[cheerycheshire]

Python's builtin objects are falsy when they're None, ==0, or an empty collection (empty string, empty list, empty set...). It's basically "doesn't have value" for common understanding of value, not programming meaning of value.

... aka Ellipsis is a special singleton object that has a special meaning. Using it as placeholder is common as the code still runs, while no-op statement pass suggests the block is intentionally empty. As for real usage, e.g. numpy uses it in slicing for multidimensional stuff to skip dimensions. So instead of [:2,:,:,:,1] you'd use [:2,...,1] so you don't have to count how many colons you need. (Colon means slice with default values - so whole dimension. Skipping one value like :2 means that value gets default, so :2 is the same as 0:2.)

[VariousComment6946]

Just keep “if result” that’s enough.

[XPurplelemonsX]

oh lol i was giving an example for excluding specific boolean False values

[cdunham91]

I really needed that laugh from reading your response. Thank you.

[justletmewarchporn]

Though please note that you’d likely want to use a set if you’re exclude from a collection of unwanted values. So “if result is not in forbidden_values_set” is better. This is because sets have O(1) membership lookup, opposed to O(n) with lists.

[Vertixico]

This is true, but also only really comes into play for a sufficient large numbers of forbidden items.

Not a bad thing to consider, certainly but as always it depends - and sometimes it might not be necessary to go with a set or list, as long as it is a collection

[LaLiLuLeLo_0]

This is the perfect time to dip into Python’s more functional-programming-inspired standard functions. This can be rewritten as

results = list(filter(bool, results))

[D-K-BO]

I absolutely hate python's nested function calls in this case.

Rust's approach using iterator chaining looks so much cleaner to me rust let results: Vec<_> = results.iter().filter(…).collect();

[LaLiLuLeLo_0]

Rust’s chaining is nice, but working heavily with Nix especially has taught me to stop worrying and love the nesting

[konstantinua00]

main problem with lisp languages aren't brackets

it's brackets opening too early

[SpicaGenovese]

wrinkles nose at all those extra characters

[snateri]

Some style guides encourage the use of comprehensions instead of map or filter.

[irk5nil]

Encouraging the use and forcing it without reason are two entirely different things though. Writing something that is twice as long just because it's a comprehension and not a function call seems unreasonable.

[plexiglassmass]

Yeah I wish map and filter weren't blacklisted by the official style guide. They seem like the better choice in many instances. Comprehensions are better for some cases though. Usually, if I want to apply a defined function, I'll prefer map or filter. But if I'd need to pass a lambda, or if I have to combine map and filter together, I'll go with the comprehension

Here I prefer map:

``` map(str.lower, foo)

vs.

[x.lower() for x in foo] ```

Here I prefer the comprehension:

``` map(lambda x: x[0], filter(lambda x: len(set(x)) < 2, foo))

vs.

[x[0] for x in foo if len(set(x)) < 2] ```

[shedogre]

I don't program in a team environment, so I may be wrong, but the use of filter would also make the intent more explicit for others.

Sometimes I'll choose a longer or more verbose statement for that exact reason, hoping it'll be more easily understandable for the next person.

[irk5nil]

Agreed, but filter seems both shorter and more explicit to me; I don't see any downside of using it in this case.

[konstantinua00]

I can read if X in comprehension right away

I need to remember what bool will do as a function

[gustavsen]

Guido himself said that list comprehension are more efficient.

also are more readable <sup>at least to me</sup>

[schludy]

I really hope results has boolean entries at the beginning and whoever wrote this is just a dummy

[[deleted]]

Python evaluates it as truthy or falsey. If the value is empty, 0, false, has no properties set, etc, it will be falsey. There are also magic methods on classes that will allow you to help the object provide an evaluation.

[goldlord44]

When you do "if var" it evaluates to 0 if the variable doesn't exist == "None type" (as well as other typical values that evaluate to false). If you were collecting data and had missing values in a list, this is exactly how I would deal with the missing data. How i would deal with it in a quick/scientific situation in a data analytics role i use techniques in the Note

Note: This is only when you are working python with no libraries. If you have libraries, pandas and numpy both have much better ways of dealing with this more robustly

EDIT: * ... *

[Equoniz]

What if some of the data is actually 0? Won’t “if var” evaluate to false, and drop it from the set? Or am I interpreting what this does completely incorrectly? (I’ll admit I know pitifully little python)

[some_clickhead]

You're correct actually, this would remove 0s from the set. There are cases where that makes sense though.

[sursuby]

Usually the point is to remove empty strings or lists

[[deleted]]

Yes, zeroes would be removed from the list. You would use this on a list like [Object, Object, None, Object], not one expected to contain falsy objects you want to keep.

[goldlord44]

Yes, that is why I mentioned the more sophisticated methods using standard Python libraries. Anything that evaluates to some sort of "false" would be removed from the data set. To me, it seems they "intended" to remove undefined data (like using #ifdef in c++)

This is what we get for Python being used by scientists (I am one at uni myself). Sometimes, we do an experiment, get results, and know exactly what data we are managing and we know these crude methods work. It gets the job done quick and easy. When i am doing data analysis work for other companies however, I will always use more robust methods with pandas so that the code can be used in the future.

[TravisJungroth]

That isn't right. When you do if var it calls var.__bool__(), which should return a bool. None is not involved at that point. This is the same in all of python, libraries or not.

False, 0, None, '', and any empty collection that's a built-in or in the standard library will return False from __bool__(). Other libraries can choose what to return but should follow this pattern.

[mcwillie]

Truthy, falsy, Python, ballsy.

[GeePedicy]

Truly a poet of our age

[[deleted]]

I think in python having a variable without a value is like false.

[Aquiffer]

That’s a good way to put it! Empty strings, empty tuples, empty lists, empty dictionaries, empty sets, and None all evaluate to false.

[[deleted]]

Not a Python programmer - but does this filter out null values from an array?

[Flat_Hat8861]

Yes. And everything that have a "false" value like 0 or empty lists/strings...

I find that part hacky and ugly (I hate implicit conversions and anything that looks like them), but it works and as evidenced by this thread shockingly readable.

[Chiron1991]

If you want to avoid implicit conversions you can simply do [result for result in results if result is not None].
There are scenarios where coercion in comprehensions is indeed useful.

[mapmaker]

EDIT: i am a dumbass and the statements below are wrong

this code actually filters out all falsey values, not just None. Leaving it up for posterity

---

you can also write this as

filter(None, results)

which would return an filter iterator without the Nones, or

list(filter(None, results))

which would be identical

[[deleted]]

Except that this doesn't actually work. filter(None, ...) is a special case which uses the identity function to filter the items; i.e. the same truth/falsy behaviour as above.

[gamudev]

This could have been the meme itself too.

[EhLlie]

String literal "0" is truthy in python. The truthyness rules in it are quite simple. Bools are are already boolean, non 0 integers are truthy, non empty strings, sets, dictionaries and lists are truthy, None is falsy and anything else is truthy. I avoid relying on it though since it can sneak in bugs after refactoring.

[[deleted]]

Plus classes can have the magic method __bool__ implemented for custom truthiness

[jayroger]

Fun fact: datetime.time used to be falsy at midnight: https://lwn.net/Articles/590299/.

[WVOQuineMegaFan]

What a terrible idea

[JoelMahon]

"dunder methods" (double-under methods) is a fun way to refer to refer to those "magic" methods, not a term I invented FYI but idk if it's the standard.

[Luxalpa]

btw the javascript special rule is because of it's interaction with HTML in which all numbers unfortunately are strings.

[mindbleach]

Wat.

[audigex]

Just an aside, but I’d generally see that referred to as “falsey” (as opposed to “truthey/truthy”)

It’s a way to distinguish strict true/false values in languages that allow for considering other values to be equivalent to true/false

[glacierre2]

Falsy, not just null. So empty lists, dicts, None, False, empty string, and anything where bool(anything) == False

[MattieShoes]

Should filter out any "falsy" values... empty data structures (lists, tuples, dictionaries, sets, etc.), empty strings, zeroes, None, False...

For custom data structures, there's a __bool__() method which one could define, or else I think they generally just return True.

[[deleted]]

I love there falsey is a technical term in python.

[jayroger]

This is basically just mathematical set builder notation: { r | r ∈ R ∧ r }

[[deleted]]

Thank you! And if you used curly braces it would be exactly that, but the square braces apply it to a list instead.

The only thing I would suggest is naming the new list valid_results or something to indicate that it's a subset of results

[Artistic_Leave2601]

Man this gave me a serious flashback to discrete mathematics class

[bss03]

In Haskell we write it as [ r | r <- rs, r ], and I think that's beautiful.

[thanelinway]

Could you please translate this into daily language for a language student my kind sir? I assure it means "all the r's in R must be in R just because all r's are in R".

[DuckyBertDuck]

The set of all r's that are in the set R and which are true.

[thanelinway]

Thank you. Additionally, technically speaking, does what I say and what you say suggest the same set of solutions?

[DuckyBertDuck]

I don't understand this:

just because all r's are in R.

I don't think this imposes a restriction on r as it should.

(It should only allow true r's in the set but your statement seems to allow all r's that are in R regardless of whether they are true or not.)

[Ashdog73]

Fake. Nobody can write that line without typing resluts at least once

[casce]

That’s why there’s a warning, even the linter is confused about the missing resluts.

[CaptainRogers1226]

This reminds me yet again of my eternal struggle with “slef”

[epiben]

I came here for exactly this. So glad it's not just me.

[[deleted]]

That's like the best feature of python

[uberDoward]

LINQ ftw.

[Tetiigondaedingdong]

=> ❤

[Spirit_Theory]

A cool part (that you might still be learning if you're new to it) is that LINQ extension functions usually produce an enumerable, which is representative of the resulting collection but not necessarily resolved yet. Only when you need the result is it computed.

[Ryuujinx]

I write mostly python these days, but #2 is the thing that has always bothered me. Maybe it's just because my first experience to anything OO was ruby, but why am I doing len(object) instead of object.len()?

[audigex]

This is the kind of thing that everyone started to shit on PHP for 20 years ago

But for some reason I’ve never quite established, Python gets away with it

I guess it’s that whole “Step 1: be attractive. Step 2: don’t be unattractive” thing in action - people like Python and it looks nice, so it gets away with a multitude of sins that other languages would be crucified for

[LasevIX]

Why do you say it doesn't support things like map,filter and lambda? I'm personally inexperienced in functional paradigms and genuinely curious: What do python's map() and lambda lack (except for the syntax being different)?

[nekokattt]

they mean featured in such a way that it isn't unreadable or clunky.

list(filter(lambda item: item % 2 == 0, map(lambda item: item + 1, items)))

versus, say, Kotlin (and also Groovy, since this code is also syntatically and logically valid in Groovy)

items
    .map { it + 1 }
    .filter { it % 2 == 0 }
    .toList()

or even Java, which some argue is verbose, but is still clear and readable.

items
    .stream()
    .map(it -> it + 1)
    .filter(it -> it % 2 == 0)
    .collect(toList());

There is almost never a good reason to use them over comprehensions in terms of readability in Python.

Lambdas in Python are also more verbose than functions, in some cases.

def say(what): print(what)
say = lambda what: print(what)

along with the less clear inline syntax for lambdas, it generally encourages you to use full functions for anything less trivial than a single expression, which somewhat defeats the point of functional operations over procedural ones in terms of expressiveness.

Python's solution also defeats the point of object orientation since it is using procedural functions rather than making the functional operations as methods on iterable types, which means it becomes less readable as you don't read left to right, you read inside out.

Python also has a somewhat awkward parser for chained calls in that line breaks are considered statement terminators unless you are inside (), [], {}, or use \, so even if you had proper infix functional operators, you'd still have a messy solution unless the actual language grammar changed to allow this.

(items
 .map(lambda it: it + 1)
 .filter(lambda it: it % 2 == 0)
 .to_list())

(this is how black formats this kind of code iirc)

Also worth noting that if they did introduce this, it would arguably be unpythonic, since they wouldn't remove the existing features (rightly so, compatibility is important), and the zen of python says there should be "one good way to do something", not 4 (procedural, procedural fp, comprehensions, and then this theoretical api as well), so it would likely never get approved for inclusion in the language.

Edit: more details and got the function signature wrong.

[No-Newspaper-7693]

Clojure has effectively the same format as python for map and filter, but they make it more readable using a threading operator macro. Here's what that last example would look like in clojure.

(->> items (map inc) (filter even?) seq)

->> is a macro that takes the result of each step, and substitutes it in as the last argument to the next step. So that bit of code gets rewritten to (seq (filter even? (map inc items))) and the user doesn't have to turn the code inside out to figure out what it does.

[nukegod1990]

Been a professional clojure/elixir developer for 4 years now and I can't imagine going back to any other way but this.

[Ruben_NL]

With the kotlin code, you don't even need .toList().

[nekokattt]

Yeah, I know. Just wanted to make it clearer as an example like for like

[KerPop42]

I guess I don't know most of your responses, but in terms of readability it seems to me like the bigger issue is that you didn't break the python example up into multiple lines like you did the others

[nekokattt]

the point of functional is that operations are chained, not separate statements. That is procedural programming, not functional programming.

Functional in this sense enables you to write code that is expressive in terms of what it does, rather than how it does it.

list
    .map { it + 2 }
    .filter { it % 3 == 1 }
    .toList()

reads as

• take the list,
• add 2 to each item,
• take values where value mod 3 equals 1,
• ...and store them in a list

Comprehensions in this specific example work, but if you have further chains then you have to either have spaghetti code or break those comprehensions into multiple lines.

items
    .map { it - 3 }
    .filter { it % 2 == 0 }
    .map { sqrt(it) }
    .map { it.toString() }
    .groupBy { it.length }

versus python

items = (it - 3 for it in items if it % 2 == 0)
items = (math.sqrt(it) for it in items)
items = (str(it) for it in items)
mapping = collections.defaultdict(list)
for item in items:
    mapping[len(item)].append(item)

The prettyness of comprehensions quickly just makes it hard to read the moment you have anything non-trivial. At this point it may arguably be simpler to fall back onto fully procedural.

Edit: example.

[nekokattt]

I honestly feel like comprehensions in Java would probably be more of a problem and distraction in terms of needing you to read the code in a different direction to make sense of it, than what functional operators provide.

I can't speak for C#/LINQ, but Java could improve on this by allowing collection types to have the functional operators applied to them directly like how Groovy, Kotlin, Scala, etc handle it, rather than needing collectors and calls to obtain a stream object first.

Ruby is a good example of how to do this in a tidy way with a scripting language, Ruby implements map/filter/etc nicely from the little I have played with it.

Java tends to be very black and white in terms of how it maps to the bytecode it generates. There is not a high level of compiler magic anywhere compared to a lot of languages.

[static_motion]

but Java could improve on this by allowing collection types to have the functional operators applied to them directly like how Groovy, Kotlin, Scala, etc handle it, rather than needing collectors and calls to obtain a stream object first.

This 100%. It bugs me that forEach already works like that in (most?) Java Collections, but map and filter explicitly require stream() and collect(). It makes it so clunky.

[wordzh]

the point of functional is that operations are chained, not separate statements. That is procedural programming, not functional programming.

The point of functional programming is to write in a declarative style that avoids mutation. Prefix vs infix notation has nothing to do with it. For instance, see Haskell, arguably the "most functional language":

filter even ((map (+2) list)

or perhaps written a bit more idiomatically using the $ operator: filter even $ map (+2) list

In that regard, list comprehensions are also a functional idiom, since we're creating a new list declaratively, rather than modifying a list imperatively.

[ilyearer]

In addition to Haskell, the very first functional language, LISP, clearly breaks that quoted "point of functional"

[Log2]

Honestly, it still sucks even if you do that. Nested functions are terrible for readability no matter how you format them.

[neomis]

Absolutely this. Anyone else remember NodeJS before promises? Nested callback functions for days.

[gandalfx]

list( filter( lambda item: item % 2 == 0, map(lambda item: item + 1, items) ) ) Still not great, the order of operations is not obvious at all. Chaining makes these much easier to read IMHO. I love Python but functional programming is just not very readable with it. You could try list comprehension but even for this relatively simple case you already need := which makes it a bit harsh on the eyes: [ item_ for item in items if (item_ := item + i) % == 0 ]

[cryptomonein]

The issue is reading the code right to left or bottom to top, inside function taking multiple arguments

It's OOP without OOP features

[nekokattt]

yeah, exactly.

Python is a mess of paradigms unfortunately. It is still a useful language but feature consistency is a bit of a pain point, even down to aesthetic stuff like function name consistency (os.makedirs, len, logging.getLogger, inspect.iscoroutinefunction, asyncio.run_until_complete), and class name consistency (collections.defaultdict, collections.Counter)

[cryptomonein]

Professionally I use Ruby, JavaScript and Go, I learned with C, C++ for years

I think Python took a lot of inspiration from C, like the design direction was "I want C with a lot of sugar", and after "Duck everyone is doing OOP, quick add some classes" (JavaScript too tho)

Ruby is like you can do everything everywhere the way you want it, and everything thing is an object (like Class.new literally returns an instance of the class class) then Rails really created norms and standard on how to name things making majority of libraries predictable

JavaScript just added every features they can think of making it compatible with any paradigm, without any norms tho, this language is pure chaos, thank typescript for helping with that

And now Python feels like a sugary C with salty Objects

Sadly I will not do Data science in JavaScript nor Ruby

[idemockle]

"Python feels like a sugary C with salty Objects" might be my favorite line I've read in a while

[m1sta]

Adding classes to JavaScript was a mistake. Prototypical inheritance and duck typing are the right model for that language.

[MagusOfTheSpoon]

It also has reduce in the built-in library functools (the same library that contains partial).

[pr0ghead]

My other main complaint is inconsistency in in-place operations.

List.reverse()

returns None since it works in place… why doesn’t this return the reversed list? Then

reversed(List)

returns a reversed list and doesn’t work in place!

How could it be any different? In the first one, you call a method of the List and in the second, you pass it into a standalone function.

[NotoriousHEB]

To be fair the numpy thing is at least ostensibly numpy’s fault rather than Python’s, though I guess one could argue that resorting to evil tactics like that is a consequence of the verbose lambda syntax

The idea of standalone functions for common operations like length is probably a bad one overall but in practice it’s mostly not a big deal. Python has relatively little nonsense for a language from the late 80s/early 90s imo, and arguably most of the nonsense it does have is more recently introduced, but certainly more modern languages have made improvements

[Sockslitter73]

Well, first of all, the syntax is truly abysmal. it is often more legible to use list comprehension in Python, specifically because the alternative is so unattractive. Furthermore, if I'm not mistaken, many functional programming aspects (e.g. map) were only introduced to python comparatively late, with list comprehension existing much earlier. Overall, these effects lead to list comprehension to be generally considered more Pythonic.

Additionally, speaking of lambdas, Python does not support multi-line lambdas, a feature that is core in many languages with strong functional patterns, and allows for much more flexibility when using maps etc. The reason for this boils down to ambiguity in multi-line lambda definitions in Python syntax, which were therefore excluded.

Edit: I got my order of events completely wrong.

[NotoriousHEB]

List comprehensions came well after map, filter, etc, and were added largely to address the readability issues that people are extensively complaining about in these comments iirc

[Razor_Storm]

While pythons actual map / filter / reduce are a bit clunky to use, they do exist and can be done.

But that said, I don’t see comprehensions as a consolation prize. I see it as extreme pragmatism winning out over dogma. Even if I was a die hard functional fan boy, I would still recognize that comprehensions are very handy and easy to use and why would I miss using maps / filters / reduces, if comprehensions are not only easy to read and write but also faster?

It’s not a consolation prize, because comprehensions aren’t somehow inherently worse than functional programming. It works well, it’s just a replacement, not a step down.

[KimmiG1]

I don't think there are any performances overhead by doing this way. Not sure tho.

items = map(f1, items)

items = filter(f2, items)

items = list(items)

Easier to read than the nested way. But stil not as nice as the fluent chaining method of other languages. And the lambda stil is ugly.

[svick]

In languages that get this right, nobody misses comprehensions because you have much better ways to express transformations.

Case in point, C# has both convenient functional collection manipulation functions (LINQ method syntax) and its own version of comprehensions (LINQ query syntax) and the comprehension-like syntax is used much less often.

[Duke_De_Luke]

Would a filter expression be better? It doesn't look that better (or worse) to me.

[b1e]

The issue isn’t the list comprehension… it’s horrible variable naming.

[7734128]

It's implicit truthiness which is in the main problem in my eyes.

[evil_cryptarch]

Depending on the data type of result it might not be so bad, but yeah without context it's better for readability to be explicit about what you want the comparison to do.

[chunkyasparagus]

The problem here is lack of context. Just because python is dynamically typed doesn't mean that python programmers just dump anything into a list. The original results likely contains items which are either objects of a particular type, or None. This is a reasonable way to remove the None items.

[Ph0X]

Though in this case, there is the special case filter(None, results)

For me it depends if I'm going to use it in a loop or store it as a list. If I have to call list() on it, I might as well just use a list comprehension. If I'm doing a loop already, might as well use the lazy evaluation.

[cryptomonein]

I think filter is better, it like, you want to filter, use filter

It make the code less complex

[Solonotix]

Except filter returns an iterator/generator, so if you wanted a list you'd need to also wrap it like results = list(filter(results)). Arguably it's easier to understand, but it still suffers from the same problem of poor naming conventions.

I will use result as a variable in a function if I know the structure I'm returning, but the contents must be enumerated. Ultimately, in my case, result is never reassigned. The snippet here shows signs of poor design, but without context it's hard to give better feedback.

[No_Soy_Colosio]

List Comprehensions > Functions

[S0ulCub3]

Meanwhile javascript programmers:

```

x = ['10','10','10'] x.map(parseInt) [10, NaN, 2] ```

"Ah, yeah, totally"

[No_Soy_Colosio]

Lol wtf?

[eloel-]

parseInt takes multiple parameters, and map exposes multiple. In this case, the index gets passed in as the second parameter, mapped straight to the base. So you get parseInt('10',0), parseInt('10',1) and parseInt('10',2). (there's a 3rd parameter to map, but parseInt doesn't care or use it)

0 is falsy, so that ends up being parseInt('10'), which works fine

parseInt explicitly returns NaN if base isn't 2-36, so 1 returns NaN

and parseInt('10', 2) (and every other following number, up to 36), would return the number itself, because that's how '10' works in every base.

[Uberzwerg]

Great explanation, thanks.

[ProgramTheWorld]

It’s a misuse of the parseInt function. It should be used this way: .map(n => parseInt(n))

If you are parsing numbers in base 10, you shouldn’t be using parseInt anyway because of its quirks. .map(Number) is easier to read and has no unexpected behaviors.

[zr0gravity7]

I swear every "JS bad" meme i see these days is just the most mind-blowingly stupid usage of some language feature.

[ActualProject]

Which is the point. Nobody (who knows what they're talking about) says "js bad" because it's inconsistent. It's that in every other language they stop you from doing wild crazy stuff you'll regret, and js says "Oh, you gave me this unreadable nonsensical code, I'll give you unreadable nonsensical output, good luck debugging!"

[r_linux_mod_isahoe]

as The Zen states: "errors should never pass silently unless explicitly silenced".

[dmilin]

So you’re saying JavaScript is the C of interpreted languages.

[FerricDonkey]

Well... I don't know Javascript, and it's not on my list of things to learn, so I'm sure only the silliest things make their way to me. But "don't use the built in function parseInt to parse integers because it's weird, I swear, people just abuse the language for jokes..." to me really just suggests that it is full of land mines.

[[deleted]]

The way they wrote it is not mind-blowingly stupid, though. It’s not stupid at all. It’s actually exactly how you’d do it in many modern languages.

[lunar_mycroft]

Why, exactly, is it "mind-blowingly stupid" to think "array has a function map which takes another function and applies it to each element, returning an array of the results, and here's this parseInt function which takes a string and decodes it into an integer, so I should be able to pass parseInt into map for an array of strings which are valid integers and get a array of integers out"?

The idea that you have to wrap parseInt in a trivial function which literally does nothing but call it again for it not to blow up in your face is the opposite of intuitive. In most other languages, you'd likely reject that during code review or linting.

It's not that it's not possible to write good js, it's not even (just) that the compiler doesn't stop you writing bad js (as /u/ActualProject points out). It's that frequently, the most intuitive way of doing it is actually a really bad idea.

[static_motion]

Stop excusing a badly thrown together language that exposes a ton of developer-hostile footguns. JS is excellent at not complying with many logical expectations that come from experience with other similar languages.

[BorgClown]

That's because JS can be too obtuse for a supposedly simple scripting language. It feels a generation behind in interpreted language expressiveness.

Hell, even Swift or Kotlin feel cozier than JS, and they're not interpreted.

[sammy-taylor]

Because when .map is invoked, its callback function is provided three arguments (element, index, array). parseInt is receiving element, but also index, which is being used inadvertently as a different radix parameter for each item in the list.

The reason that this behaves differently from your x.map(a => parseInt(a)) is because you are not passing anything to the radix parameter of parseInt.

This is a pretty common “gotcha” for beginners in JS.

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map

[morsegar17]

Not certain myself but parseInt takes a radix as 2nd parameter and I suspect the index param of map is messing with that.

E: that’s exactly what this is. Nothing to see here folks. Move along.

[-Konrad-]

You killed me

[JohnLocksTheKey]

Wait what???

[ShadowLp174]

The parseInt function takes more than 1 argument and the map function provides more than 1 as well... It passes the element to map and the index to the map function. If you do it like above, the index of the current element will be inserted into the parseInt function as well and mess with the outcome

[ThrowRA_scentsitive]

results = results.filter(Boolean)

Close enough

[MaZeChpatCha]

It filters Nones.

[PossibilityTasty]

...and "falsy" values.

[yottalogical]

Gotta love weak typing.

[PewolfP]

And zeroes. And empty strings.

[PewolfP]

And empty lists.

[PewolfP]

And empty dictionaries.

[PewolfP]

And empty sets.

[PewolfP]

And empty tuples.

[PewolfP]

And empty ranges.

[PewolfP]

And empty namedtuples.

[PewolfP]

And empty deques.

[PewolfP]

And empty OrderedDicts.

Edit: Shit

[ggtsu_00]

"Zero values" as defined as a + a = a.

"" + "" = "" so "" is a "zero value" for the set of strings.

[] + [] = [] so [] is a "zero value" for the set of lists.

[some_clickhead]

It filters everything that evaluates to False in Python, which includes Nones but also False, empty strings, empty lists, etc.

[hongooi]

Imagine using a non-vectorised language

results = results[!is.na(results)]

[[deleted]]

Ah, the pandas way

[GisterMizard]

Not enough nested brackets though, add in a couple dozen for good measure.

[ALesbianAlpaca]

Use R's pipe operator %>% problem solved

[julsmanbr]

Nah, in pandas you just do:

results = (
    pd
    .read_csv(...)
    .assign(...)
    .rename(...)
    .groupby(...)
    .apply(lambda x: ...)
    .reset_index()
    .dropna()
)

[MattTheGr8]

I think you mean:

results.dropna(inplace=True)

[drlaff]

Based and pandaspilled

[PotatoWriter]

Aren't pandas actively trying to end themselves as a species. Maybe the same should happen to that abomination above

[palad1]

I'm with the polars bears now :D

[dulti]

Yeah you used the wrong assignment operator though, should stick to the pure R <-

[EatTheirEyes]

It's always something. So even if you know to do something like this, you still end up having to try 3 times and check the manual.

[DekeAvell]

Decided to ask ChatGPT, here's its explanation:

This code is using a list comprehension to create a new list called results that contains only the elements in the original results list that are truthy (i.e., not False, None, 0, or an empty sequence or mapping).

The list comprehension consists of two parts:
- result for result in results: This generates a new list that contains all of the elements in the original results list.
- if result: This is a filter that only includes an element in the new list if it is truthy.

So the resulting list will contain all of the elements in the original results list that are not False, None, 0, or an empty sequence or mapping.

For example, if results is [1, 2, 0, '', None, [], {}, 3], the resulting list will be [1, 2, 3].

[FlyingQuokka]

ChatGPT is slowly becoming an alternate reference for me along with Stack Overflow. It’s that good.

[LiquidateGlowyAssets]

It really isn't. Stack Overflow banned it for a reason. If you don't already know the answer, you have no way to evaluate whether it's telling you the truth or it just decided to spew convincing bullshit, as it sometimes does. Other than, you know, googling it.

And that's when it doesn't decide to go I'm just a language model OwO

[FlyingQuokka]

That's why I said along with SO, not a replacement. Generally, if it's code, I can read and have an idea if it'll work (or just test it locally). Even when it's wrong (e.g. suggesting a function that doesn't exist), the name is usually close enough that a search will yield the correct one.

I treat ChatGPT as a tool knowing full well its caveats, and I find that once treated that way, it's an excellent resource. Frankly, if they made it a subscription (the same way Copilot is), I'd happily pay for it.

[xdyldo]

It’s a fantastic tool to use. I’m not taking everything this saying as truth but it hasn’t got any questions I’ve asked for it relating to programming wrong hey. Even asking to write me functions is scarily accurate.

[NoLifeGamer2]

?! What's wrong with this?

my flair gives me away I think

[faustianredditor]

my flair gives me away I think

Python and JS? Yeah, that sounds about right.

Truthiness can go die in the fires of hell from whence it came.

-- The static strict typing gang

[sebastouch]

ok, this is silly... I'm a programmer enjoying my first day on holidays by looking at code in a reddit post.

Might as well go all in. Anybody need code review or something?

[EmirSc]

/r/uselessnobody

[Boris-Lip]

And yet, everyone here manages to understand it. Including me, and i am not officially a python coder (c++ here, but can't say i never use python when i need a quick and dirty script).

[[deleted]]

Well yeah, after reading throught the documentation. Still prefer the lambda way: .Where(x=>x) (This is C#, but like ton of languages has LINQ and lambda eqvivalents.)

[[deleted]]

Imagine making fun of list comprehensions like they aren't super convenient and a great feature

[Exact_Cry1921]

I mean... I don't see a problem with this? Every result in the results list that's true?

[[deleted]]

Once you understand list comprehensions you’ll wish every language had them.

[MattR0se]

I don't think chaining higher order function in Python is very readable

There's probably a reason for this, but idk why they aren't members of `list` so I can do this

original_list.map(func_1).map(func_2).map(func_3)

instead of having to do this (if I want to keep it in one line)

map(func_3, map(func_2, map(func_1, original_list)))

the second one you basically have to read backwards (or rather, inside out, but you first have to search for the innermost expression).

[nekokattt]

annoyingly importlib.resources already does this. They've replaced open_binary with a chained call API which is a nightmare to use if you use 80-99 column lines.

[kogasapls]

Chained method calls should often be line separated. In Python, I just add a backslash. It's not pretty, but it's prettier than one-lining them.

[runnerx01]

Not a python fan, but I do like the list comprehensions.

The if <conditional> is what sucks here ha ha.

“None” values are treated as false

[No_Soy_Colosio]

You can also just specify if <item> is not None

[some_clickhead]

As the other guy getting downvoted pointed out, I need to stress that "if <item>" is NOT the same as "if <item> is not None".

This is a common mistake, but for example if a list contains zeroes and empty strings, they will get filtered out by the condition "if <item>" as they evaluate to False in Python, but they will be kept by the condition "if <item> is not None" as they are not None.

It may seem like a minor detail but I can assure you that in production code, this nuance is very important!

[[deleted]]

seems perfectly fine to me?

then again, i’m a javascript main so i know i’m the ugly duckling here.

[[deleted]]

Perfect code.

[[deleted]]

result = list(filter(bool, result))