As engineers, we should always strive to write simple code.
One common pitfall which is typical to many programming languages and not only to ...
For further actions, you may consider blocking this person and/or reporting abuse
Great tip! Thank you for sharing
If you work with python 3.10, you should check out the new pattern matching!
Yup! But, I think the main purpose of this tutorial is to highlight the power of Hash Maps over traditional conditional branching( whether using if-else or switch) given the fact that accessing key-val is O(1). Know what I am saying?
Yes, that's right. I just wanted to add another interesting and powerful alternative to whoever reads the post. Btw, isn't the access of a dictionary O(log(n)) ?
Python 3.7 and later versions introduce a major new feature when it comes to dictionaries; they are ordered in the insertion sense order by default. This means that items added to a dictionary are stored in the same order as they were added, kinda like an append function, so items can be retrieved in a predictable order. Furthermore, since Python 3.8, this order is reversible, just like with collections.OrderedDict.
The introduction of this ordering feature has sparked debates) about its implications for other features introduced since Python 3.6, such as keyword arguments (kwargs) which are now ordered, and the namespace passed to a metaclass being ordered as well.
In theory, the newer version of the dictionary improved in terms of performance because it uses two arrays, one that contains pointers for all entries of that dictionary in order (PyDictKeyEntry), and the other one acts as a hash table that contains the indices of these elements.
So, python dictionaries are ordered hash tables that take a contiguous chunk of memory, allowing for an O(1) lookup by index on average. This means that the time it takes to look up an item in a dictionary is constant, regardless of the number of items present in the dictionary. This makes dictionaries highly efficient for various tasks. However, in the worst-case scenario, the lookup is O(n). The following image illustrates the time complexity of hash tables in general.
In case of a collision occurs, the Open addressing method kicks in.
Each key-value pair entry is represented as a c struct with three fields as shown in the snippet below:
Code taken from pycore_dict.
If you are looking at how the lookup function is implemented, you can refer to the official CPython implementation.
I had no idea! Thanks for the elaborated answer!
Throwback to my early days doing Open Source. It feels like ages ago.