इस पायथन/रूबी भाषा का निर्माण करें (फ़ंक्शन पैरामीटर को संतुष्ट करने के लिए सरणी मानों का उपयोग करके)

Question

इस भाषा का निर्माण क्या कहा जाता है?

पायथन में मैं कह सकता हूँ:

def a(b,c): return b+c 
a(*[4,5]) 

और रूबी में इसी तरह 9. मिलती है:

def a(b,c) b+c end 
a(*[4,5]) 

क्या यह कहा जाता है, जब एक एक समारोह जो अन्यथा कई की आवश्यकता के लिए एक एकल सरणी गुजरता तर्क?

* ऑपरेटर का नाम क्या है?

अन्य भाषाएं इस शांत सुविधा का समर्थन करती हैं?

Answer 1

पायथन डॉक्स इस Unpacking Argument Lists पर कॉल करें। यह एक बहुत ही आसान सुविधा है। पायथन में, आप कीवर्ड तर्कों में एक शब्दकोश (हैश) को अनपैक करने के लिए डबल तारांकन (**) का भी उपयोग कर सकते हैं। वे विपरीत में भी काम करते हैं। मैं इस तरह के एक समारोह को परिभाषित कर सकता हूं:

def sum(*args): 
    result = 0 
    for a in args: 
     result += a 
    return result 

sum(1,2) 
sum(9,5,7,8) 
sum(1.7,2.3,8.9,3.4) 

सभी तर्कों को मनमाने ढंग से आकार की सूची में पैक करने के लिए।

Answer 2

मैं इसे "सूची विस्तार" कह रहा हूं, लेकिन मुझे नहीं लगता कि यह मानक शब्दावली है (मुझे नहीं लगता कि कोई है ...)। सभी संस्करणों में लिस्प (योजना शामिल), और हास्केल और अन्य कार्यात्मक भाषाएं, इसे आसानी से पर्याप्त कर सकती हैं, लेकिन मुझे नहीं लगता कि "मुख्यधारा" भाषाओं में करना आसान है (शायद आप इसे "प्रतिबिंब" स्टंट के रूप में खींच सकते हैं कुछ में!-)।

Answer 3

रूबी में, इसे अक्सर "स्प्लट" कहा जाता है।

रूबी में भी, आप इसका उपयोग 'सूची में मौजूद सभी अन्य तत्वों' के लिए कर सकते हैं।

a, *rest = [1,2,3,4,5,6] 
a  # => 1 
rest # => [2, 3, 4, 5, 6] 

यह भी असाइनमेंट ऑपरेटर के दोनों तरफ दिखाई दे सकता है:

a = d, *e 

इस उपयोग में, यह है योजना का सीडीआर की तरह एक सा है, हालांकि यह सब लेकिन के सिर होने की जरूरत नहीं सूची।

Answer 4

इसके लिए सामान्य शब्दावली को "सूची में एक फ़ंक्शन लागू करना" कहा जाता है, या संक्षिप्त के लिए "लागू करें"।

http://en.wikipedia.org/wiki/Apply

यह लिस्प में काफी 1960 अजीब में अपनी स्थापना के बाद से किया गया वापस देखें। खुशी है कि अजगर यह फिर से खोज की: -}

लागू करें एक सूची या इस तरह के एक सरणी के रूप में एक सूची का प्रतिनिधित्व पर आम तौर पर है। हालांकि, कोई तर्क के लिए फ़ंक्शंस लागू कर सकता है कि अन्य palces जैसे structs से आते हैं। हमारी PARLANSE भाषा में निश्चित प्रकार (int, float, string, ...) और संरचनाएं हैं। विचित्र रूप से पर्याप्त, फ़ंक्शन तर्क सूची संरचना परिभाषा की तरह दिखती है, और PARLANSE में, यह एक संरचना परिभाषा है, और आप एक संगत संरचना में एक PARLANSE फ़ंक्शन "लागू" कर सकते हैं। आप "बनाने" कर सकते हैं संरचना उदाहरणों, भी, इस प्रकार:

 

(define S 
    (structure [t integer] 
       [f float] 
       [b (array boolean 1 3)] 
    )structure 
)define s 

    (= A (array boolean 1 3 ~f ~F ~f)) 

    (= s (make S -3 19.2 (make (array boolean 1 3) ~f ~t ~f)) 


    (define foo (function string S) ...) 

    (foo +17 3e-2 A) ; standard function call 

    (foo s) ; here's the "apply" 

PARLANSE तुतलाना की तरह दिखता है, लेकिन नहीं है।

Answer 5

रूबी यह कहता है सूचक, हालांकि डेविड ब्लैक भी साफ unar साथ आ गया है {, रा} y ऑपरेटर (यानी एकल unarray ऑपरेटर)

Answer 6

बहुसंख्यक प्रश्न पहले से ही किया गया है उत्तर दिया, लेकिन सवाल के रूप में "ऑपरेटर का नाम क्या है?": तकनीकी शब्द "तारांकन" है (लैटिन शब्द क्षैतिज से आता है, जिसका अर्थ है "छोटा सितारा", जो बदले में, से आता है यूनानी ἀστερίσκος)। अक्सर, हालांकि, इसे "स्टार" के रूप में जाना जाएगा, जैसा ऊपर बताया गया है, "splat"।

Answer 7

हास्केल भी (जोड़े के लिए) यह है uncurry समारोह के साथ:

ghci> let f x y = 2*x + y 
f :: (Num a) => a -> a -> a 
ghci> f 1 2 
4 
ghci> f 10 3 
23 
ghci> uncurry f (1,2) 
4 
ghci> uncurry f (10,3) 
23 

आप भी इसे एक ऑपरेटर में कर सकते हैं, तो यह अधिक सूचक की तरह है:

ghci> f `uncurry` (1,2) 
4 
ghci> let (***) = uncurry 
(***) :: (a -> b -> c) -> (a, b) -> c 
ghci> f *** (10,3) 
23 

और यद्यपि 3-ट्यूपल, 4-टुपल इत्यादि के मामलों के लिए समान कार्यों को परिभाषित करना आसान होगा, हास्केल के सख्त टाइपिंग के कारण n -टुपल्स (जैसे अन्य भाषाओं में स्प्लट काम करता है) के लिए कोई सामान्य कार्य नहीं है।