पायथन के डिफ़ॉल्ट डिक्शनरी का एनालॉग?

Question

क्या पाइथन के defaultdict का .NET एनालॉग है? मुझे शॉर्ट कोड लिखना उपयोगी लगता है, उदाहरण के लिए। गिनती आवृत्तियों:

>>> words = "to be or not to be".split() 
>>> print words 
['to', 'be', 'or', 'not', 'to', 'be'] 
>>> from collections import defaultdict 
>>> frequencies = defaultdict(int) 
>>> for word in words: 
...  frequencies[word] += 1 
... 
>>> print frequencies 
defaultdict(<type 'int'>, {'not': 1, 'to': 2, 'or': 1, 'be': 2}) 

तो सी # में आदर्श

मैं लिख सकते हैं:

var frequencies = new DefaultDictionary<string,int>(() => 0); 
foreach(string word in words) 
{ 
    frequencies[word] += 1 
} 

Answer 1

मुझे नहीं लगता कि एक बराबर होती है, लेकिन अपने उदाहरण दिया आप LINQ के साथ ऐसा कर सकता है:

var words = new List<string>{ "One", "Two", "Three", "One" }; 
var frequencies = words.GroupBy (w => w).ToDictionary (w => w.Key, w => w.Count()); 

Answer 2

कुछ शुरू करने के लिए कुछ। मैं मूल रूप से बस this सूचकांक बदल दिया। चूंकि मुझे पायथन के defaultdict की पूरी कार्यक्षमता नहीं पता है, इसलिए मैं इसे और बेहतर नहीं कर सकता। आपका दिया गया उदाहरण काम करेगा।

public class DefaultDictionary<TKey, TValue> : IDictionary<TKey,TValue> 
{ 
    private readonly Func<TValue> _defaultSelector; 
    private readonly Dictionary<TKey, TValue> _values = new Dictionary<TKey, TValue>(); 

    public DefaultDictionary(Func<TValue> defaultSelector) 
    { 
     _defaultSelector = defaultSelector; 
    } 

    public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator() 
    { 
     return _values.GetEnumerator(); 
    } 

    IEnumerator IEnumerable.GetEnumerator() 
    { 
     return GetEnumerator(); 
    } 

    public void Add(KeyValuePair<TKey, TValue> item) 
    { 
     ((IDictionary<TKey,TValue>)_values).Add(item); 
    } 

    public void Clear() 
    { 
     _values.Clear(); 
    } 

    public bool Contains(KeyValuePair<TKey, TValue> item) 
    { 
     return ((IDictionary<TKey,TValue>)_values).Contains(item); 
    } 

    public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex) 
    { 
     ((IDictionary<TKey, TValue>)_values).CopyTo(array, arrayIndex); 
    } 

    public bool Remove(KeyValuePair<TKey, TValue> item) 
    { 
     return ((IDictionary<TKey, TValue>)_values).Remove(item); 
    } 

    public int Count { get { return _values.Count; } } 
    public bool IsReadOnly { get { return ((IDictionary<TKey, TValue>) _values).IsReadOnly; } } 
    public bool ContainsKey(TKey key) 
    { 
     return _values.ContainsKey(key); 
    } 

    public void Add(TKey key, TValue value) 
    { 
     _values.Add(key, value); 
    } 

    public bool Remove(TKey key) 
    { 
     return _values.Remove(key); 
    } 

    public bool TryGetValue(TKey key, out TValue value) 
    { 
     return _values.TryGetValue(key, out value); 
    } 

    public TValue this[TKey key] 
    { 
     get 
     { 
      if (!_values.ContainsKey(key)) 
      { 
       _values.Add(key, _defaultSelector()); 
      } 
      return _values[key]; 
     } 
     set 
     { 
      if(!_values.ContainsKey(key)) 
      { 
       _values.Add(key, _defaultSelector()); 
      } 
      _values[key] = value; 
     } 
    } 

    public ICollection<TKey> Keys { get { return _values.Keys; } } 
    public ICollection<TValue> Values { get { return _values.Values; } } 

    public Dictionary<TKey, TValue> ToDictionary() 
    { 
     return new Dictionary<TKey, TValue>(_values); 
    } 
} 

Answer 3

यहाँ एक सरल कार्यान्वयन है:

public class DefaultDictionary<TKey, TValue> : Dictionary<TKey, TValue> where TValue : new() 
{ 
    public new TValue this[TKey key] 
    { 
     get 
     { 
      TValue val; 
      if (!TryGetValue(key, out val)) 
      { 
       val = new TValue(); 
       Add(key, val); 
      } 
      return val; 
     } 
     set { base[key] = value; } 
    } 
} 

और आप इसे कैसे प्रयोग करेंगे:

var dict = new DefaultDictionary<string, int>(); 
Debug.WriteLine(dict["foo"]); // prints "0" 
dict["bar"] = 5; 
Debug.WriteLine(dict["bar"]); // prints "5" 

या इस तरह:

var dict = new DefaultDictionary<string, List<int>>(); 
dict["foo"].Add(1); 
dict["foo"].Add(2); 
dict["foo"].Add(3);