एक कंप-विज्ञान पृष्ठभूमि के बिना किसी व्यक्ति के लिए, कंप्यूटर विज्ञान की दुनिया में लैम्ब्डा क्या है?लैम्ब्डा (फ़ंक्शन) क्या है?
उत्तर
लैम्ब्डा Lambda Calculus से आता है और प्रोग्रामिंग में अज्ञात कार्यों को संदर्भित करता है।
यह अच्छा क्यों है? यह आपको बिना नाम दिए त्वरित फेंकने के कार्यों को लिखने की अनुमति देता है। यह बंद करने के लिए एक अच्छा तरीका भी प्रदान करता है। उस शक्ति के साथ आप इस तरह की चीजें कर सकते हैं।
अजगर
def adder(x):
return lambda y: x + y
add5 = adder(5)
add5(1)
6
आप अजगर का स्निपेट से देख सकते हैं, समारोह योजक में एक तर्क एक्स लेता है, और एक गुमनाम समारोह, या लैम्ब्डा, कि एक और तर्क y लेता देता है। वह अनाम कार्य आपको कार्यों से कार्यों को बनाने की अनुमति देता है। यह एक साधारण उदाहरण है, लेकिन इसे बिजली लैम्बडा और बंद करने के लिए व्यक्त करना चाहिए।
अन्य भाषाओं में उदाहरण
जावास्क्रिप्ट
var adder = function (x) {
return function (y) {
return x + y;
};
};
add5 = adder(5);
add5(1) == 6
जावास्क्रिप्ट (ES6)
const adder = x => y => x + y;
add5 = adder(5);
add5(1) == 6
योजना
(define adder
(lambda (x)
(lambda (y)
(+ x y))))
(define add5
(adder 5))
(add5 1)
6
Func<int, Func<int, int>> adder =
(int x) => (int y) => x + y; // `int` declarations optional
Func<int, int> add5 = adder(5);
var add6 = adder(6); // Using implicit typing
Debug.Assert(add5(1) == 6);
Debug.Assert(add6(-1) == 5);
// Closure example
int yEnclosed = 1;
Func<int, int> addWithClosure =
(x) => x + yEnclosed;
Debug.Assert(addWithClosure(2) == 3);
स्विफ्ट
func adder(x: Int) -> (Int) -> Int{
return { y in x + y }
}
let add5 = adder(5)
add5(1)
6
पीएचपी
$a = 1;
$b = 2;
$lambda = function() use (&$a, &$b) {
echo $a + $b;
};
echo $lambda();
हास्केल
(\x y -> x + y)
जावा देख this post
// The following is an example of Predicate :
// a functional interface that takes an argument
// and returns a boolean primitive type.
Predicate<Integer> pred = x -> x % 2 == 0; // Tests if the parameter is even.
boolean result = pred.test(4); // true
लुआ
adder = function(x)
return function(y)
return x + y
end
end
add5 = adder(5)
add5(1) == 6 -- true
यह lambda calculus को संदर्भित करता है, जो एक औपचारिक प्रणाली है जिसमें केवल लैम्ब्डा अभिव्यक्तियां होती हैं, जो एक ऐसे कार्य का प्रतिनिधित्व करती है जो अपने एकमात्र तर्क के लिए कार्य करती है और एक कार्य देता है। लैम्ब्डा कैलकुस में सभी फ़ंक्शंस उस प्रकार के होते हैं, यानी λ : λ → λ
।
लिस्प ने लैम्बडा अवधारणा का उपयोग अपने अज्ञात फ़ंक्शन अक्षरों को नाम देने के लिए किया था। यह लैम्ब्डा एक समारोह है कि दो तर्क, x और y लेता है प्रतिनिधित्व करता है, और अपने उत्पाद रिटर्न:
((lambda (x y) (* x y)) 5 10)
:
(lambda (x y) (* x y))
यह इस तरह इन-लाइन लागू किया जा सकता (का मूल्यांकन करता है करने के लिए) आप इसे एक अज्ञात फ़ंक्शन के रूप में सोच सकते हैं - यहां कुछ और जानकारी है: Wikipedia - Anonymous Function
एक लैम्ब्डा समारोह का एक प्रकार है, परिभाषित इनलाइन है। लैम्ब्डा के साथ-साथ आपके पास आमतौर पर कुछ प्रकार का चर प्रकार होता है जो किसी फ़ंक्शन, लैम्ब्डा या अन्यथा संदर्भ का संदर्भ रख सकता है।
public Int32 Add(Int32 a, Int32 b)
{
return a + b;
}
public Int32 Sub(Int32 a, Int32 b)
{
return a - b;
}
public delegate Int32 Op(Int32 a, Int32 b);
public void Calculator(Int32 a, Int32 b, Op op)
{
Console.WriteLine("Calculator: op(" + a + ", " + b + ") = " + op(a, b));
}
public void Test()
{
Calculator(10, 23, Add);
Calculator(10, 23, Sub);
}
यह कैलक्यूलेटर कहता है, न सिर्फ दो नंबर के साथ गुजर रहा है, लेकिन जो विधि कैलक्यूलेटर अंदर कॉल करने के लिए परिणाम प्राप्त करने के:
उदाहरण के लिए, यहाँ कोड का एक सी # टुकड़ा है कि एक लैम्ब्डा का उपयोग नहीं करता है गणना की।
सी # 2.0 में हमारे पास गुमनाम तरीकों, जो करने के लिए ऊपर दिए गए कोड को छोटा:
public delegate Int32 Op(Int32 a, Int32 b);
public void Calculator(Int32 a, Int32 b, Op op)
{
Console.WriteLine("Calculator: op(" + a + ", " + b + ") = " + op(a, b));
}
public void Test()
{
Calculator(10, 23, delegate(Int32 a, Int32 b)
{
return a + b;
});
Calculator(10, 23, delegate(Int32 a, Int32 b)
{
return a - b;
});
}
और फिर सी # 3.0 में हम lambdas जो कोड भी कम करता है मिल गया:
public delegate Int32 Op(Int32 a, Int32 b);
public void Calculator(Int32 a, Int32 b, Op op)
{
Console.WriteLine("Calculator: op(" + a + ", " + b + ") = " + op(a, b));
}
public void Test()
{
Calculator(10, 23, (a, b) => a + b);
Calculator(10, 23, (a, b) => a - b);
}
प्रतिनिधि 'ओप' को स्पष्ट रूप से परिभाषित करने के बजाय, कोई भी 'Func
का उपयोग कर सकता है, मैं सुझाव देता हूं कि' कंसोल। राइटलाइन (" कैलकुलेटर: सेशन "+ op.Method.Name +" ("+ a +", " + बी + ") =" + सेशन (ए, बी)); 'पहले उदाहरण के लिए। –
यह है एक समारोह जिसमें कोई नाम नहीं है। उदाहरण के लिए सी # में आप
numberCollection.GetMatchingItems<int>(number => number > 5);
का उपयोग नंबर दिए गए हैं कि एक से अधिक 5.
number => number > 5
यहाँ लैम्ब्डा हिस्सा है वापस जाने के लिए कर सकते हैं।यह एक फ़ंक्शन का प्रतिनिधित्व करता है जो पैरामीटर (संख्या) लेता है और एक बूलियन मान देता है (संख्या> 5)। GetMatchingItems विधि संग्रह में सभी वस्तुओं पर इस lambda का उपयोग करता है और मिलान आइटम लौटाता है।
मुझे इस आलेख में लैम्ब्डास की व्याख्या पसंद है: The Evolution Of LINQ And Its Impact On The Design Of C#। यह मुझे बहुत समझ में आया क्योंकि यह लैम्बडास के लिए एक असली दुनिया दिखाता है और इसे एक व्यावहारिक उदाहरण के रूप में बनाता है।
उनकी त्वरित व्याख्या: लैम्बडास डेटा (कोड) को डेटा के रूप में इलाज करने का एक तरीका है।
थोड़ा ओवरम्प्लिफाइड: एक लैम्ब्डा फ़ंक्शन वह है जिसे अन्य कार्यों के लिए पारित किया जा सकता है और इसका तर्क पहुंच जाता है।
सी # लैम्ब्डा सिंटैक्स में अक्सर अज्ञात प्रतिनिधियों के समान तरीके से संकलित किया जाता है, लेकिन इसे भी तोड़ दिया जा सकता है और इसका तर्क पढ़ा जा सकता है।
उदाहरण के लिए (सी में # 3):
LinqToSqlContext.Where(
row => row.FieldName > 15);
LinqToSql कि समारोह (एक्स> 15) पढ़ सकते हैं और यह वास्तविक एसक्यूएल में बदलने अभिव्यक्ति के पेड़ का उपयोग कर निष्पादित करने के लिए कर सकते हैं।
बयान से ऊपर हो जाता है:
select ... from [tablename]
where [FieldName] > 15 --this line was 'read' from the lambda function
इसका कारण यह है कि वे पढ़ नहीं किया जा सकता सामान्य तरीके या अनाम प्रतिनिधियों (जो सिर्फ संकलक जादू वास्तव में कर रहे हैं) से अलग है।
लैम्बडा सिंटैक्स का उपयोग करने वाले सी # में सभी विधियों को अभिव्यक्ति पेड़ों (यानी वास्तविक लैम्ब्डा फ़ंक्शंस) में संकलित नहीं किया जा सकता है। उदाहरण के लिए:
LinqToSqlContext.Where(
row => SomeComplexCheck(row.FieldName));
अब अभिव्यक्ति पेड़ को पढ़ा नहीं जा सकता - कुछ कॉम्प्लेक्स चेक टूटा नहीं जा सकता है। SQL कथन कहां के बिना निष्पादित होगा, और डेटा में प्रत्येक पंक्ति SomeComplexCheck
के माध्यम से रखी जाएगी।
लैम्ब्डा कार्यों को अज्ञात तरीकों से भ्रमित नहीं किया जाना चाहिए। उदाहरण के लिए:
LinqToSqlContext.Where(
delegate (DataRow row) {
return row.FieldName > 15;
});
यह भी एक 'इनलाइन' कार्य है, लेकिन इस बार यह सिर्फ संकलक जादू है - सी # संकलक एक स्वत: जनरेट नाम के साथ एक नया उदाहरण विधि के लिए बाहर इस विभाजित कर देगा।
बेनामी विधियों को पढ़ा नहीं जा सकता है, और इसलिए लॉम्बडा कार्यों के लिए तर्क का अनुवाद नहीं किया जा सकता है। LINQ और गैर में
Hello
I am inside a proc
रूबी में एक लैम्ब्डा का एक उदाहरण इस प्रकार है -LINQ ऑपरेटरों।उदाहरण:
string[] GetCustomerNames(IEnumerable<Customer> customers)
{ return customers.Select(c=>c.Name);
}
से पहले सी #, मैं अनाम प्रक्रियाएं जावास्क्रिप्ट में AJAX के कार्यों के लिए कॉलबैक के लिए इस्तेमाल किया, शब्द अजाक्स भी गढ़ा गया था से पहले:
getXmlFromServer(function(result) {/*success*/}, function(error){/*fail*/});
सी # के लैम्ब्डा सिंटैक्स के साथ दिलचस्प बात यह है, हालांकि, है कि उनके अपने प्रकार पर इनकार नहीं किया जा सकता है (यानी, आप var foo = (x, y) => x * y टाइप नहीं कर सकते हैं) लेकिन किस प्रकार के आधार पर उन्हें असाइन किया गया है, वे प्रतिनिधियों के रूप में संकलित किए जाएंगे या अभिव्यक्ति का प्रतिनिधित्व करने वाले अमूर्त वाक्यविन्यास पेड़ (इस प्रकार LINQ ऑब्जेक्ट मैपर अपने "भाषा-एकीकृत" जादू करते हैं)।
एलआईएसपी में लैम्ब्डा को भी उद्धरण ऑपरेटर को पास किया जा सकता है और फिर सूचियों की सूची के रूप में स्थानांतरित किया जा सकता है। कुछ शक्तिशाली मैक्रोज़ इस तरह से बने होते हैं।
@Brian मैं lambdas सी # में हर समय का उपयोग करें,:
hello = lambda do
puts('Hello')
puts('I am inside a proc')
end
hello.call
निम्नलिखित उत्पादन genereate होगा:
मुझे लैम्बडा एक्सप्रेशन के आसपास अपने सिर को लपेटने में परेशानी है क्योंकि मैं विजुअल फॉक्सप्रो में काम करता हूं, जिसमें मैक्रो प्रतिस्थापन और एक्सेस्क्रिप्ट {} और मूल्यांकन() फ़ंक्शन हैं, जो एक ही उद्देश्य को पूरा करने लगते हैं। औपचारिक lambdas का उपयोग करने के
? Calculator(10, 23, "a + b")
? Calculator(10, 23, "a - b");
FUNCTION Calculator(a, b, op)
RETURN Evaluate(op)
एक निश्चित लाभ (मुझे लगता है) है संकलन-समय की जाँच: फॉक्स अगर आप पाठ स्ट्रिंग ऊपर टाइपो जब तक यह इसे चलाने के लिए कोशिश करता है पता नहीं चलेगा।
यह डेटा संचालित कोड के लिए भी उपयोगी है: आप डेटाबेस में ज्ञापन फ़ील्ड में पूरे दिनचर्या स्टोर कर सकते हैं और फिर रन-टाइम पर उनका मूल्यांकन कर सकते हैं। यह आपको वास्तव में स्रोत तक पहुंच के बिना एप्लिकेशन का हिस्सा ट्विक करने देता है। (लेकिन यह एक और विषय है।)
नाम "लैम्ब्डा" सिर्फ एक ऐतिहासिक कलाकृति है। हम जिस बारे में बात कर रहे हैं वह एक अभिव्यक्ति है जिसका मूल्य एक कार्य है।
एक साधारण उदाहरण (अगली पंक्ति के लिए स्काला का उपयोग) है:
args.foreach(arg => println(arg))
जहां foreach
विधि करने के लिए तर्क एक गुमनाम समारोह के लिए एक अभिव्यक्ति है। इसके बाद के संस्करण लाइन कम या ज्यादा कुछ इस तरह लिखने के रूप में ही है (काफी वास्तविक नहीं कोड है, लेकिन आप अनुमान लगा सकेंगे कि):
void printThat(Object that) {
println(that)
}
...
args.foreach(printThat)
सिवाय इसके कि आप के साथ परेशान करने के लिए की जरूरत नहीं है
- कहीं और फ़ंक्शन घोषित करना (और जब आप कोड को बाद में संशोधित करते हैं तो इसे देखने के लिए)।
- कुछ ऐसा नामकरण जो आप केवल एक बार उपयोग कर रहे हैं।
एक बार जब आप, समारोह मूल्यों के लिए इस्तेमाल कर रहे हैं उनके बिना क्या करने वाले इस तरह के रूप के रूप में मूर्खतापूर्ण हर अभिव्यक्ति के नाम करने के लिए आवश्यक होने के रूप में लगता है,:
int tempVar = 2 * a + b
...
println(tempVar)
के बजाय सिर्फ अभिव्यक्ति जहां जरूरत लेखन यह:
println(2 * a + b)
सटीक नोटेशन भाषा से भाषा में भिन्न होता है; यूनानी हमेशा की आवश्यकता नहीं है!;-)
जावास्क्रिप्ट में, उदाहरण के लिए, कार्यों और सब कुछ (int
, string
, float
, bool
) के रूप में ही मिश्रित प्रकार के रूप में माना जाता है। इस प्रकार, आप फ्लाई पर फ़ंक्शंस बना सकते हैं, उन्हें चीजों को असाइन कर सकते हैं, और बाद में उन्हें कॉल कर सकते हैं। यह उपयोगी है, लेकिन ऐसा कुछ नहीं जिसे आप उपयोग करना चाहते हैं या आप उन सभी को भ्रमित कर देंगे जिन्हें आपके कोड को आपके पास बनाए रखना है ...
यह कुछ कोड है जो मैं यह देखने के लिए खेल रहा था कि यह खरगोश छेद कितना गहरा है:
var x = new Object;
x.thingy = new Array();
x.thingy[0] = function(){ return function(){ return function(){ alert('index 0 pressed'); }; }; }
x.thingy[1] = function(){ return function(){ return function(){ alert('index 1 pressed'); }; }; }
x.thingy[2] = function(){ return function(){ return function(){ alert('index 2 pressed'); }; }; }
for(var i=0 ;i<3; i++)
x.thingy[i]()()();
सिर्फ इसलिए कि मैं यहां एक सी ++ 11 उदाहरण नहीं देख सकता, मैं आगे बढ़ूंगा और here से यह अच्छा उदाहरण पोस्ट करूंगा। खोज के बाद, यह सबसे स्पष्ट सुस्त विशिष्ट उदाहरण है जो मुझे मिल सकता है।
हैलो, lambdas, संस्करण 1
template<typename F>
void Eval(const F& f) {
f();
}
void foo() {
Eval([]{printf("Hello, Lambdas\n");});
}
हैलो, lambdas, संस्करण 2:
void bar() {
auto f = []{printf("Hello, Lambdas\n"); };
f();
}
मैं भी मिला है। एक
var addAndMult = function(x) {
return (function(y) {
return (function(z) {
return (x+y)*z;
});
});
};
यह कहते हैं 2 से 4 तो mults 6. द्वारा परिणाम हालांकि मैं इसे खोजने के लिए कभी कभी मुश्किल पढ़ने के लिए :(को
इसके अलावा मैं `ve बनाया: मैं` ve इस एक के साथ जे एस में इसे करने की कोशिश दिलचस्प foreach समारोह:
var forEach = function(arr) {
return (function(x) {
for (var i=0; arr[i]; i++) {
x(arr[i]);
}
});
}
foreach ([1,2,3,4,5]) (console.log);
इस विधि एक सरणी पुनरावृति और एक कार्य करता है जाएगा - मामले मुद्रण में कंसोल के लिए। अब मुझे भी प्रयोगशाला क्यों मिलती है दास शक्तिशाली हैं।
लैम्ब्डा कैलकुलेशन प्रतिस्थापन का एक सतत गणितीय सिद्धांत है। स्कूल गणित में उदाहरण के लिए x+y=5
x−y=1
के साथ जोड़ा जाता है। अलग-अलग समीकरणों में हेरफेर करने के तरीकों के साथ-साथ इन दोनों को एक साथ जानकारी देना भी संभव है, बशर्ते पार-समीकरण प्रतिस्थापन तार्किक रूप से किए जाएं। लैम्ब्डा कैलकुस इन प्रतिस्थापन करने के सही तरीके को संहिताबद्ध करता है।
यह देखते हुए कि y = x−1
दूसरे समीकरण का एक मान्य पुनर्व्यवस्था है, इस: λ y = x−1
एक समारोह प्रतीक y
के लिए प्रतीकों x−1
प्रतिस्थापन का मतलब है। अब पहले समीकरण में प्रत्येक शब्द के लिए λ y
लागू करने की कल्पना करें। यदि कोई शब्द y
है तो प्रतिस्थापन करें; अन्यथा कुछ भी नहीं। यदि आप इसे कागज़ पर करते हैं तो आप देखेंगे कि λ y
लागू करने से पहले समीकरण सुलभ हो जाएगा।
यह किसी भी कंप्यूटर विज्ञान या प्रोग्रामिंग के बिना एक उत्तर है।
सरल प्रोग्रामिंग उदाहरण मैं के बारे में सोच सकते हैं http://en.wikipedia.org/wiki/Joy_(programming_language)#How_it_works से आता है:
यहाँ कैसे वर्ग समारोह एक अनिवार्य प्रोग्रामिंग भाषा (सी) में परिभाषित किया जा सकता है:
int square(int x) { return x * x; }
चर एक्स एक औपचारिक पैरामीटर है जिसे वास्तविक मान द्वारा प्रतिस्थापित किया जाता है जब फ़ंक्शन कहा जाता है। एक कार्यात्मक भाषा (योजना) में एक ही समारोह में परिभाषित किया जाएगा:
(define square (lambda (x) (* x x)))
यह कई मायनों में अलग है, लेकिन यह अभी भी उसी तरह से औपचारिक पैरामीटर एक्स उपयोग करता है।
जोड़ा गया:http://imgur.com/a/XBHub
सीएस के संदर्भ में एक लैम्ब्डा समारोह एक सार गणितीय अवधारणा है कि गणितीय अभिव्यक्ति का प्रतीक मूल्यांकन का एक समस्या tackles है। उस संदर्भ में एक लैम्ब्डा फ़ंक्शन lambda term जैसा ही होता है।
लेकिन प्रोग्रामिंग भाषाओं में यह कुछ अलग है। यह कोड का एक टुकड़ा है जिसे "जगह में" घोषित किया गया है, और इसे "प्रथम श्रेणी के नागरिक" के रूप में पारित किया जा सकता है। यह अवधारणा उपयोगी साबित हुई ताकि यह लगभग सभी लोकप्रिय आधुनिक प्रोग्रामिंग भाषाओं में आए (lambda functions everwhere पोस्ट देखें)।
प्रश्न का औपचारिक रूप से उत्तर दिया गया है, इसलिए मैं इस पर अधिक जोड़ने की कोशिश नहीं करूंगा।
बहुत सरल में, किसी को उस पर बहुत कम या गणित या प्रोग्रामिंग पर कुछ भी नहीं जानता के लिए अनौपचारिक शब्द, मैं इसे एक छोटे से "मशीन" या "बॉक्स" है कि, कुछ इनपुट लेता है बनाता है कुछ काम और कुछ का उत्पादन के रूप में समझा जाएगा आउटपुट का कोई विशेष नाम नहीं है, लेकिन हम जानते हैं कि यह कहां है और केवल इस ज्ञान से, हम इसका इस्तेमाल करते हैं।
व्यावहारिक रूप से बोलते हुए, एक व्यक्ति जो जानता है कि कोई फ़ंक्शन क्या है, मैं उन्हें बता दूंगा कि यह एक ऐसा कार्य है जिसका नाम नहीं है, आमतौर पर स्मृति में एक बिंदु पर डाल दिया जाता है जिसका उपयोग केवल उस स्मृति के संदर्भ में किया जा सकता है (आमतौर पर एक चर के उपयोग के माध्यम से - अगर उन्होंने फ़ंक्शन पॉइंटर्स की अवधारणा के बारे में सुना है, तो मैं उन्हें एक समान अवधारणा के रूप में उपयोग करूंगा) - इस उत्तर में सुंदर मूलभूत बातें (बंद करने आदि का कोई उल्लेख नहीं है) लेकिन कोई भी आसानी से बिंदु प्राप्त कर सकता है।
कंप्यूटर प्रोग्रामिंग में, लैम्ब्डा कोड का एक टुकड़ा (कथन, अभिव्यक्ति या उनमें से एक समूह) है जो बाहरी स्रोत से कुछ तर्क लेता है। यह हमेशा एक अज्ञात कार्य नहीं होना चाहिए - हमारे पास उन्हें लागू करने के कई तरीके हैं।
हमारे पास अभिव्यक्तियों, बयानों और कार्यों के बीच स्पष्ट अलगाव है, जो गणितज्ञों के पास नहीं है।
प्रोग्रामिंग में "फ़ंक्शन" शब्द भी अलग है - हमारे पास "कार्य करने के लिए चरणों की एक श्रृंखला है" (लैटिन "प्रदर्शन" से)। गणित में यह चर के बीच सहसंबंध के बारे में कुछ है।
कार्यात्मक भाषाएं संभवतः गणित सूत्रों के समान होने की कोशिश कर रही हैं, और उनके शब्दों का अर्थ लगभग समान है।लेकिन अन्य प्रोग्रामिंग भाषाओं में हमारे पास यह अलग है।
एक कंप-विज्ञान पृष्ठभूमि के बिना किसी व्यक्ति के लिए, कंप्यूटर विज्ञान की दुनिया में लैम्ब्डा क्या है?
मैं इसे सरल और पठनीय पायथन कोड में कदम से सहजता से कदम बताऊंगा।
संक्षेप में, एक लैम्ब्डा सिर्फ एक अज्ञात और इनलाइन फ़ंक्शन है।
मूल अंकगणितीय की पृष्ठभूमि के साथ ताजा व्यक्ति के रूप में lambdas
को समझने के लिए असाइनमेंट से शुरू करें।
काम का खाका 'नाम = मूल्य' है, देखें:
In [1]: x = 1
...: y = 'value'
In [2]: x
Out[2]: 1
In [3]: y
Out[3]: 'value'
'एक्स', 'y' नाम हैं और 1, 'मान' मान रहे हैं। गणित
In [4]: m = n**2 + 2*n + 1
NameError: name 'n' is not defined
त्रुटि रिपोर्ट,
आप नहीं कोड, 'एन' के रूप में सीधे एक गणित लिख सकते हैं परिभाषित किया जाना चाहिए या एक मूल्य को सौंपा जा में एक समारोह का प्रयास करें।
In [8]: n = 3.14
In [9]: m = n**2 + 2*n + 1
In [10]: m
Out[10]: 17.1396
यह अब काम करता है, यदि आप दो अलग-अलग लाइनों को एक से जोड़ने पर जोर देते हैं तो क्या होगा। वहाँ lambda
In [13]: j = lambda i: i**2 + 2*i + 1
In [14]: j
Out[14]: <function __main__.<lambda>>
कोई त्रुटि नहीं सूचना आता है।
यह lambda
पर एक नज़र है, यह आपको एक ही पंक्ति में एक फ़ंक्शन लिखने में सक्षम बनाता है जैसा कि आप सीधे कंप्यूटर में गणित में करते हैं।
हम इसे बाद में देखेंगे।
चलो 'असाइनमेंट' पर गहराई से खुदाई जारी रखें।
जैसा कि ऊपर दिखाया गया है, बराबर प्रतीक =
सरल डेटा (1 और 'मान') प्रकार और सरल अभिव्यक्ति (एन ** 2 + 2 * एन + 1) के लिए काम करता है।
इस प्रयास करें:
In [15]: x = print('This is a x')
This is a x
In [16]: x
In [17]: x = input('Enter a x: ')
Enter a x: x
यह सरल बयान के लिए काम करता है, वहाँ अजगर में उनमें से 11 प्रकार है 7. Simple statements — Python 3.6.3 documentation
कैसे यौगिक कथन के बारे में,
In [18]: m = n**2 + 2*n + 1 if n > 0
SyntaxError: invalid syntax
#or
In [19]: m = n**2 + 2*n + 1, if n > 0
SyntaxError: invalid syntax
वहाँ def
काम कर इसे सक्षम आता है
In [23]: def m(n):
...: if n > 0:
...: return n**2 + 2*n + 1
...:
In [24]: m(2)
Out[24]: 9
ताडा, इसका विश्लेषण करें, 'एम' नाम है, 'एन ** 2 + 2 * एन + 1' मूल्य है। :
'=' का एक रूप है।
इसे ढूंढें, अगर समझने के लिए, सबकुछ असाइनमेंट से शुरू होता है और सब कुछ असाइनमेंट होता है।
In [28]: m = m(3)
In [29]: m
Out[29]: 16
'मी' यहाँ, समारोह m
के दो नाम हैं पहले से ही एक नाम है, दोहराया गया:
अब हम 'm'
कोशिश नामक प्रकार्य है lambda
पर लौटने,।
ऐसा लगता है कि स्वरूपण है:
In [27]: m = def m(n):
...: if n > 0:
...: return n**2 + 2*n + 1
SyntaxError: invalid syntax
यह एक चतुर रणनीति नहीं है, तो त्रुटि की सूचना
हम उनमें से एक को हटाना होगा, किसी नाम के बिना समारोह निर्धारित किया है।
m = lambda n:n**2 + 2*n + 1
यह गुमनाम समारोह '
अंत में कहा जाता है,
- एक इनलाइन समारोह जो आपको एक सीधी रेखा में एक समारोह में लिखने के लिए गणित के क्षेत्र में करता है के रूप में सक्षम में
lambda
lambda
अज्ञात
उम्मीद है की यह मदद करेगा।
अमदा अभिव्यक्ति समझाया [यहां] (https://chaseyourjava.blogspot.in/2017/11/lamda-expression-in-java-8.html) खूबसूरती से। –