Menu
If you want to add a new key to the dictionary, then you can use the assignment operator with the dictionary key. This is pretty much the same as assigning a new value to the dictionary. Since Python dictionaries are mutable, when you use the assignment operator, you're simply adding new keys to the datastructure.
update() method updates the dictionary with elements from a dictionary object or an iterable object of key/value pairs.
The update() method inserts the specified items into the dictionary.
How to add or update items in a dictionary ? You can use the subscript notation, which is, accessing the key or creating a new one using square brackets [] and then providing the corresponding value. Also, you can use the dictionary method update() to add or update a key in an existing dictionary.
Could there be any problem if i replace Method-1 by Method-2?
No, just use map[key] = value. The two options are equivalent.
Regarding Dictionary<> vs. Hashtable: When you start Reflector, you see that the indexer setters of both classes call this.Insert(key, value, add: false); and the add parameter is responsible for throwing an exception, when inserting a duplicate key. So the behavior is the same for both classes.
There's no problem. I would even remove the CreateNewOrUpdateExisting from the source and use map[key] = value directly in your code, because this this idiomatic C#; C# developers would typically know that map[key] = value means add or update.
Old question but i feel i should add the following, even more because .net 4.0 had already launched at the time the question was written.
Starting with .net 4.0 there is the namespace System.Collections.Concurrent which includes collections that are thread-safe.
The collection System.Collections.Concurrent.ConcurrentDictionary<> does exactly what you want. It has the AddOrUpdate() method with the added advantage of being thread-safe.
If you're in a high-performance scenario and not handling multiple threads the already given answers of map[key] = value are faster.
In most scenarios this performance benefit is insignificant. If so i'd advise to use the ConcurrentDictionary because:
Functionally, they are equivalent.
Performance-wise map[key] = value would be quicker, as you are only making single lookup instead of two.
Style-wise, the shorter the better :)
The code will in most cases seem to work fine in multi-threaded context. It however is not thread-safe without extra synchronization.
The only problem could be if one day
map[key] = value
will transform to -
map[key]++;
and that will cause a KeyNotFoundException.
I know it is not Dictionary<TKey, TValue> class, however you can avoid KeyNotFoundException while incrementing a value like:
dictionary[key]++; // throws `KeyNotFoundException` if there is no such key
by using ConcurrentDictionary<TKey, TValue> and its really nice method AddOrUpdate()..
Let me show an example:
var str = "Hellooo!!!";
var characters = new ConcurrentDictionary<char, int>();
foreach (var ch in str)
characters.AddOrUpdate(ch, 1, (k, v) => v + 1);
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With