क्या कोई भी पुस्तकालय है जो सहयोगी सरणी क्षमता प्रदान करता है?

Question

मैं कुछ पायथन कोड के रूपांतरण की सुविधा के लिए पायथन में "शब्दकोश" के समान एक जाने वाली भाषा क्षमता की तलाश में हूं।

संपादित करें: मानचित्र इस डी-डुप्ले एप्लिकेशन के लिए काफी अच्छा काम करते हैं। मैं केवल कुछ सेकंड में 16 बाइट स्ट्रिंग इंडेक्स वाले मानचित्र का उपयोग करके 2.5e5 अद्वितीय वस्तुओं को 1.3e6 डुप्लिकेट किए गए आइटमों को सघन करने में सक्षम था। नक्शा से संबंधित कोड सरल था इसलिए मैंने इसे नीचे शामिल किया है। टिप्पण लायक नक्शा है कि पूर्व आवंटन के साथ 1.3e6 तत्वों यह केवल कुछ प्रतिशत की तेज:

var m = make(map[string]int, 1300000) // map with initial space for 1.3e6 elements 

ct, ok := m[ax_hash] 
if ok { 
    m[ax_hash] = ct + 1 
} else { 
    m[ax_hash] = 1 
} 

Answer 1

मानचित्र का प्रकार। http://golang.org/doc/effective_go.html#maps

वहाँ कुंजी टाइप किया जा करने के लिए है कि में अजगर से कुछ अंतर है, ताकि आप सांख्यिक मिश्रण कर सकते हैं नहीं और स्ट्रिंग कुंजी (किसी कारण से मैं भूल गया था आप कर सकते हैं), लेकिन वे उपयोग करने के लिए बहुत आसान कर रहे हैं ।

dict := make(map[string]string) 
dict["user"] = "so_user" 
dict["pass"] = "l33t_pass1" 

Answer 2

आप शायद एक map के लिए देख रहे हैं।

Answer 3

जवाब पहले ही दिया पर एक छोटे से विस्तार करने के लिए:

एक जाओ नक्शा एक टाइप किए हुए हैश नक्शा डेटा संरचना है। नक्शा का प्रकार हस्ताक्षर फॉर्म map[keyType]valueType है जहां keyType और valueType क्रमशः कुंजी और मानों के प्रकार हैं।

एक मानचित्र आरंभ करने के लिए आपको make समारोह का उपयोग करना चाहिए:

m := make(map[string]int) 

एक अप्रारंभीकृत नक्शा nil के बराबर है, और अगर से पढ़ने के लिए या लिखित एक आतंक रन टाइम पर हो जाएगा।

मूल्यों के भंडारण के लिए वाक्य रचना बहुत सरणियों या स्लाइस के साथ ऐसा करने के समान ही है:

m["Alice"] = 21 
m["Bob"] = 17 

इसी तरह, एक नक्शे से मूल्यों को पुन: प्राप्त इसलिए की तरह किया जाता है:

a := m["Alice"] 
b := m["Bob"] 

आप उपयोग कर सकते हैं range कीवर्ड एक for पाश के साथ एक नक्शे पर पुनरावृति करने के लिए:

for k, v := range m { 
    fmt.Println(k, v) 
} 

इस कोड को प्रिंट होगा:

Alice 21 
Bob 17 

एक महत्वपूर्ण है कि नक्शे में नहीं है मान प्रकार का शून्य मान प्रदान करेगा के लिए एक मूल्य प्राप्त कर रहा है:

c := m["Charlie"] 
// c == 0 

मानचित्र से कई मूल्यों को पढ़ने के द्वारा, आप कर सकते हैं एक कुंजी की उपस्थिति के लिए परीक्षण।

a, ok := m["Alice"] 
// a == 21, ok == true 
c, ok := m["Charlie"] 
// c == 0, ok == false 

नक्शे से कुंजी/मान प्रविष्टि को निकालने के लिए, आपको दूसरा मूल्य के रूप में चारों ओर फ्लिप और false आवंटित: दूसरा मान एक बूलियन कुंजी की उपस्थिति का संकेत हो जाएगा

m["Bob"] = 0, false 
b, ok := m["Bob"] 
// b == 0, ok == false 

आप

n := make(map[string]interface{}) 
n["One"] = 1 
n["Two"] = "Two" 

केवल परंतुक कि जब उन मूल्यों को पुन: प्राप्त करने है: खाली इंटरफ़ेस प्रकार interface{} का उपयोग करके मानचित्र में मनमाने ढंग से प्रकार स्टोर कर सकते हैं आप उन्हें उनके मूल रूप में उपयोग करने के लिए एक प्रकार का दावा करना चाहिए:

a := n["One"].(int) 
b := n["Two"].(string) 

आप एक प्रकार स्विच का उपयोग मूल्यों तुम बाहर खींच रहे के प्रकार का निर्धारण करने के कर सकते हैं और उचित रूप से उन लोगों के साथ सौदा:

for k, v := range n { 
    switch u := v.(type) { 
     case int: 
      fmt.Printf("Key %q is an int with the value %v.\n", k, u) 
     case string: 
      fmt.Printf("Key %q is a string with the value %q.\n", k, u) 
    } 
} 

उनमें से प्रत्येक case ब्लॉक के अंदर, ucase कथन में निर्दिष्ट प्रकार का होगा; कोई स्पष्ट प्रकार का दावा जरूरी नहीं है।

इस कोड को प्रिंट होगा:

Key "One" is an int with the value 1. 
Key "Two" is a string with the value "Two". 

कुंजी किसी भी प्रकार जिसके लिए समानता ऑपरेटर इस तरह के पूर्णांक के रूप में, परिभाषित किया गया है की हो सकता है, तैरता, स्ट्रिंग्स और संकेत दिए गए। इंटरफ़ेस प्रकारों का भी उपयोग किया जा सकता है, जब तक अंतर्निहित प्रकार समानता का समर्थन करता है। , नक्शे o (Structs, सरणियों और स्लाइस नक्शा कुंजी के रूप में, क्योंकि समानता उन प्रकार पर परिभाषित नहीं है इस्तेमाल किया नहीं जा सकता है।)

उदाहरण के लिए ऊपर प्रकारों में से किसी की चाबी ले जा सकते हैं:

o := make(map[interface{}]int) 
o[1] = 1 
o["Two"] = 2 

और यह संक्षेप में नक्शे है।