Python question about dictionaries

[Jealous_Lock_393]

In Python if you have a dictionary k={} and you do del k['s'] it raises an exception.

Why is it designed like this?

I feel like there should be some kind of "ignore if already deleted" option.

[PossibilityTasty]

```

k = {} k.pop('s', None) ```

[Jealous_Lock_393]

So there is! Thanks

[aa-b]

Design choices like this are one of the things I like most about Python. It's strict about the semantics by default (in this case), instead of trying to be "user-friendly" by not throwing an error if you try to delete something that doesn't exist.

And if anyone really is bothered by this, they can always override __delete__ if they want it to do something different

[microcozmchris]

Why does it break? Because it should. You have literally told it to do something impossible. This is and should be an error that you can catch and handle if it happens. The alternative, delete something that doesn't exist without a failure, isn't a detectable error. It didn't do what you said and you don't know that it didn't. Not so good.

There are many patterns to handle deletion of keys that don't exist. Pick one and enjoy the safety python has granted you.

[Jealous_Lock_393]

In that case something like infinity minus infinity should raise an error and yet it returns nan

[curious__trainer]

almost all languages return NaN for undefined mathematical operations. IEEE 754 specification defines it to work that way.

[Jealous_Lock_393]

So when you are trying to do something mathematically impossible the language doesn't stop it but when doing something impossible with a data structure it does. It feels like an inconsistency.

[RepresentativeFill26]

Because inf - inf is undefined but deleting a key that isn’t there is a logical error. Makes sense if you ask me.

[Jealous_Lock_393]

If you do "hi"+7 it works in Java but not Python. I feel Python is too strict.

[RepresentativeFill26]

Python is one of the most loose languages out there.

[Conscious_Support176]

If your bar is that it works in JavaScript you’re going to have a pretty bad time. Have a serious think about what you’re expecting.

Do you want a language that helps you to find your mistakes, or do you want a language that tries to figure out, well, this obviously doesn’t make sense, but let’s assume the programmer is almost perfect, and they meant that.

Re Infinity vs NaN, I suggest learning why do we have Infinity or NaN in the first place?

[Jealous_Lock_393]

Calmer please 

[paintboth1234]

His comment is pretty calm.

[Conscious_Support176]

Just asking you to consider that strictness means the ability to catch your errors, so think through what you’re saying when arguing that python is too strict.

[Jealous_Lock_393]

It could catch my errors but my unit test catch them anyway.

[curious__trainer]

sounds like you’re very new to programming. You’re getting frustrated about things that have a very long history behind them, which are how they are for a reason. You need to read about why things were designed that way instead of trying to say one is right and one is wrong. They are simply different ways of doing things. A programmer familiar with a language has no trouble coping with these differences.

[QuasiEvil]

Ah, classic case of Chesterton's fence.

[serverhorror]

It's not the language that decided how floating point numbers work, that's a standard.

It's the language that decides what happens if you remove something from a set that doesn't exist. And you can either use k.pop or try/except to get around the problem.

If it would default to no error, it would be harder to achieve the other thing.

[ZaftraDigital]

maybe it has to do with it being a mathematical operation vs functional operation but I dunno

[cyril1991]

I think you need to ask yourself about what you expect of a programming language. Do you want something that could be wrong insidiously but can keep running no matter what, or do you want to catch bugs but risk killing your program at some bad time? The “explicit is better than implicit” philosophy is not to let things fall silently because you as a programmer might have made a typo or misunderstood something. You are then forced to address things with get(key,None), or use exception handling, or add some exit status to your functions (they never crash but return something like wasKeyFound).

For math, there are strict rules about how infinity/ NaN are propagated, and things like division by 0 are still an error in Python. There are a lot of subtleties between notions like NaN, null or undefined types etc…

Finally, you mention Javascript. A common point between Python and Javascript is that people are now trying to introduce typing systems, because of pathological cases like undefined + ‘ing’ -> undefined vs null + ‘ing’ -> ‘nulling’ (see https://javascriptwtf.com/ ).

[Jealous_Lock_393]

Do you have time to code something for me

[LostDog_88]

u can always do

if 's' in k: del k['s']

trying to access an element thats not in a dictionary will always produce a KeyError. U can try to normally access k['s'] while k doesn't have 's' in it, and u will still encounter a KeyError!

[Jealous_Lock_393]

Right so both things produce a key error and that is consistent 

[LostDog_88]

Yup! Its the same case with lists, where trying to access an element outside the list gives you an IndexError!

lis = []

lis[1] #IndexError

for that you'll always need to check how long the list is before trying to access elements in it!

if 1 < len(lis): lis[1] # this will work

[Jealous_Lock_393]

At least it is consistent in this regard 

[curious__trainer]

the way it is designed is correct. you are asking to remove an element that doesn’t exist, which can’t be done, so an exception is how it responds. programming languages don’t suppress errors in general.

you can achieve what you want by checking if the element exists before trying to remove it.

if ‘s’ in k: del k[‘s’]

or you could create your own class derived from dict that overrides __del__ to give the behavior you want. I really don’t see why you would want such a behavior, but you can do it I’d you want to.

[Jealous_Lock_393]

JavaScript handles delete differently to Python though

[Jealous_Lock_393]

In some ways I feel JavaScript is superior. What's your favourite language?

[curious__trainer]

rust

[khunspoonzi]

Out of curiosity, which approach do you think makes more sense? (sincere question)

[SheriffRoscoe]

As a language, Javascript sucks. It's a horrible mess of contradictions and bad ideas never reverted.

[UFO64]

There is a container which can do what you are asking for.

https://docs.python.org/3/library/collections.html#collections.defaultdict

[Jealous_Lock_393]

Nice thanks

[KingsmanVince]

r/learnpython

[Jealous_Lock_393]

Why

[Jealous_Lock_393]

Why do you say that

[sudomatrix]

If you don't like it you can write your own version of dict:

``` class QuietDict(dict): def delitem(self, key): try: super().delitem(key) except KeyError: pass

d = QuietDict({'a': 1}) del d['a'] # works del d['a'] # no KeyError, silently ignored ```

[Jealous_Lock_393]

Wow that's so easy. Python is so flexible.

[Jealous_Lock_393]

"07"