Thread by @mathsppblog

🏆 Here's a mini Python 🐍 challenge.

You have an int `value` and a dictionary `my_dict`.

`my_dict` **may** contain a key `"field"`, with an int.

If `"field"` is there, add it to `value`.

How would you solve this?

Here's a short thread 👇🧵 with a couple of solutions.

First off, this mini thread was prompted by @svpino's most recent tweet, that I include here for credit and context:

https://twitter.com/svpino/status/1445705578509058050

Like Santiago pointed out, there are two archetypes of solutions here.

The first one, is to check if the `"field"` is there, and then add to `value`.

Simple to understand, but with one “drawback” that bothers me just a little bit...

And that's the fact that we are essentially looking into the dictionary twice.

Once to check if the key is there, and then again to get the value associated with the key (when the key is there).

This is the typical “Look Before You Leap” (LBYL) coding style: check before doing.

There is another fundamentally different approach, often considered idiomatic in Python:

“Easier to Ask Forgiveness than Permission” (EAFP)

That's essentially: just do whatever you want. Say you are sorry only if it goes wrong.

In Python code, use a `try: ... except: ...` 👇

Python has great syntax to support the EAFP coding style, and there are some notorious examples of where EAFP is a better approach.

I wrote about it in this article 👇

But this thread is not about the LBYL vs EAFP discussion.

It's about something else.

mathspp.com/blog/pydonts/e…

This thread is about keeping your code simple and trying to avoid unnecessary flow control.

Both approaches 👆 have some flow control that shows in the form of indentation.

Wouldn't it be nice if you could just do the addition, regardless of whether the field is there?

Well, using the dictionary `.get` method, you can!

You can just use it to fetch the field and give a default value of `0` 👇

Why `0`? Because adding `0` does nothing!

This is a pattern that can be exploited often, but people don't use...

When you want to get something from a dictionary, and that thing may or may not be there...

And then you want to use it IF it was there...

Try using this approach.

Figure out if there is a value that would act as a “no-op”, and return it from the dictionary with `.get`.

In the case above, the “no-op” to addition (the identity element, as we call it in maths) was the 0.

Why?

Because “something plus 0” is always “something”.

Or, in other words, doing “plus 0” leaves the input unchanged.

Makes sense?

Here's the 3 approaches stacked 👇

So, of these three alternatives we looked at, which one do you think is the best?

If you come up with another alternative that you think brings something to the table, share it with us as well!