एक लैम्ब्डा (फ़ंक्शन) क्या है?

743

कंप्यूटर विज्ञान की दुनिया में एक लैम्ब्डा के बिना एक व्यक्ति के लिए क्या है?

lambda  language-agnostic  computer-science  terminology  theory 
— ब्रायन वारशॉ
स्रोत
3
अमदा अभिव्यक्ति ने यहां खूबसूरती से समझाया ।
— जमीर मूलानी
1
यह देखने के लिए कि विभिन्न भाषाओं में लैम्ब्डा कैसे कार्य करती है, और उन भाषाओं में उन्हें किस वर्ष पेश किया गया था।
— फिलिप श्वार्ज

जवाबों:

1081

लैम्ब्डा लैम्बडा कैलकुलस से आता है और प्रोग्रामिंग में अनाम कार्यों को संदर्भित करता है।

यह शांत क्यों है? यह आपको उनका नाम लिए बिना त्वरित थ्रो फ़ंक्शंस लिखने की अनुमति देता है। यह क्लोजर लिखने का एक अच्छा तरीका भी प्रदान करता है। उस शक्ति से आप इस तरह की चीजें कर सकते हैं।

अजगर

def adder(x):
    return lambda y: x + y
add5 = adder(5)
add5(1)
6

जैसा कि आप पायथन के स्निपेट से देख सकते हैं, फ़ंक्शन एडिटर एक तर्क x में लेता है, और एक अनाम फ़ंक्शन, या लैम्ब्डा लौटाता है, जो एक और तर्क y लेता है। वह अनाम फ़ंक्शन आपको फ़ंक्शन से फ़ंक्शन बनाने की अनुमति देता है। यह एक सरल उदाहरण है, लेकिन इसे पावर लंबोदा और क्लोजर को व्यक्त करना चाहिए।

अन्य भाषाओं में उदाहरण

पर्ल ५

sub adder {
    my ($x) = @_;
    return sub {
        my ($y) = @_;
        $x + $y
    }
}

my $add5 = adder(5);
print &$add5(1) == 6 ? "ok\n" : "not ok\n";

जावास्क्रिप्ट

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

C # 3.5 या उच्चतर

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 = fn () => $a + $b;

echo $lambda();

हास्केल

(\x y -> x + y)

जावा इस पोस्ट को देखें

// 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

Kotlin

val pred = { x: Int -> x % 2 == 0 }
val result = pred(4) // true

माणिक

रूबी इसमें थोड़ा भिन्न है कि आप किसी फ़ंक्शन को कॉल करने के समान सटीक सिंटैक्स का उपयोग करके एक लैम्ब्डा को कॉल नहीं कर सकते हैं, लेकिन इसमें अभी भी लैम्बडा है।

def adder(x)
  lambda { |y| x + y }
end
add5 = adder(5)
add5[1] == 6

रूबी रूबी होने के नाते, लैम्ब्डा के लिए एक आशुलिपि है, इसलिए आप adderइस तरह से परिभाषित कर सकते हैं :

def adder(x)
  -> y { x + y }
end

आर

adder <- function(x) {
  function(y) x + y
}
add5 <- adder(5)
add5(1)
#> [1] 6
— mk।
स्रोत
3
एक लैम्ब्डा फंक्शन और एक फन्नेकार के बीच क्या अंतर है ?
— मैक्सएम
1
@Maxpm एक फ़नकार उदाहरण क्षेत्रों और फ़ंक्शंस के साथ एक मानक ऑब्जेक्ट हो सकता है, जबकि एक लंबो फ़ंक्शन आमतौर पर केवल निर्देशों की एक पंक्ति में होता है। यह पाठ्यक्रम की भाषा के आधार पर भिन्न हो सकता है।
— zdimension
1
मुझे नहीं लगता कि यह कहना सही नहीं है कि लंबोदर फ़ंक्शन अनाम फ़ंक्शन के समान हैं। जावास्क्रिप्ट की तरह कुछ भाषाओं के लिए एक लंबोदर अभिव्यक्ति एक अनाम फ़ंक्शन का एक विशिष्ट रूप है। आपके द्वारा दिया गया जावास्क्रिप्ट उदाहरण लैम्ब्डा सिंटैक्स के बिना एक अनाम फ़ंक्शन है जबकि आपके द्वारा दिया गया जावास्क्रिप्ट (ईएस 6) उदाहरण एक लैम्ब्डा अभिव्यक्ति है।
— काइल डेलाने
1
@KyleDelaney वास्तव में, अनाम एक लंबोदर होने के लिए आवश्यक शर्त नहीं है, वास्तव में लंबो फ़ंक्शन हैं जो अनाम नहीं हैं, जैसा कि आप वहां एक उदाहरण में भी इंगित करते हैं
— कारमाइन टैम्बस्किया
@ अलीअनकली या रूबेला लैम्ब्डा का उपयोग करने की आदत डालें;)
— जिमी एमजी लिम
107

एक लैम्ब्डा एक प्रकार का फ़ंक्शन है, जो परिभाषित इनलाइन है। एक लैम्ब्डा के साथ-साथ आपके पास आमतौर पर कुछ प्रकार के चर प्रकार भी होते हैं जो किसी फ़ंक्शन, लैम्ब्डा या अन्यथा के संदर्भ में पकड़ सकते हैं।

उदाहरण के लिए, यहाँ एक # कोड का टुकड़ा है जो लैम्बडा का उपयोग नहीं करता है:

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);
}

यह कैलकुलेटर कहता है, न केवल दो संख्याओं के साथ, लेकिन गणना के परिणाम प्राप्त करने के लिए कैलकुलेटर के अंदर कॉल करने की कौन सी विधि है।

C # 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;
    });
}

और फिर C # 3.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, (a, b) => a + b);
    Calculator(10, 23, (a, b) => a - b);
}
— लसे वी। कार्लसन
स्रोत
प्रतिनिधि को स्पष्ट रूप से परिभाषित करने के बजाय Op, एक का उपयोग कर सकते हैंFunc<int, int>
— मातेन उल्हाक
मैं Console.WriteLine("Calculator: op " + op.Method.Name + " (" + a + ", " + b + ") = " + op(a, b));पहले उदाहरण के लिए सुझाव दूंगा।
— Marc.2377
जैसा कि स्वीकृत उत्तर कई अलग-अलग भाषाओं में लोगों की मदद करने में अद्भुत है, मुझे ऐसा लगता है कि यह उत्तर मुझे लंबोदर के लाभ को बेहतर ढंग से समझने में मदद करता है, और वे एक मानक कार्य से अलग कैसे हैं। मैं स्पष्ट रूप से एक समान परिणाम प्राप्त करने के लिए पिछले तरीकों पर एक लंबो का लाभ देख सकता हूं।
— RTHarston
आपके उदाहरण के लिए धन्यवाद, एक अधिक जटिल कार्य होने से लैम्बदास के लाभों को सरल कार्यों की तुलना में बहुत अधिक समझने में मदद मिलती है, जहां ऐसा लगता है कि आपको बहुत अनुकूलन नहीं मिलता है
— सारा
71

"लैम्ब्डा" नाम केवल एक ऐतिहासिक कलाकृति है। हम सभी के बारे में बात कर रहे हैं एक अभिव्यक्ति है जिसका मूल्य एक फ़ंक्शन है।

एक सरल उदाहरण (अगली पंक्ति के लिए स्काला का उपयोग करना) है:

args.foreach(arg => println(arg))

जहां foreachविधि का तर्क एक अनाम फ़ंक्शन के लिए एक अभिव्यक्ति है। उपरोक्त पंक्ति कमोबेश कुछ इस तरह से लिखी जा रही है (बिल्कुल वास्तविक कोड नहीं है, लेकिन आपको यह विचार मिलेगा):

void printThat(Object that) {
  println(that)
}
...
args.foreach(printThat)

सिवाय इसके कि आपको परेशान करने की आवश्यकता नहीं है:

  1. फ़ंक्शन को कहीं और घोषित करना (और जब आप बाद में कोड को फिर से भेजते हैं तो इसे देखना होगा)।
  2. कुछ का नामकरण जो आप केवल एक बार उपयोग कर रहे हैं।

एक बार जब आप मानों का उपयोग करने के लिए उपयोग किए जाते हैं, तो उनके बिना करना हर अभिव्यक्ति को नाम देने के लिए उतना ही मूर्खतापूर्ण लगता है, जैसे कि:

int tempVar = 2 * a + b
...
println(tempVar)

इसके बजाय सिर्फ अभिव्यक्ति को लिखने के लिए जहाँ आपको इसकी आवश्यकता है:

println(2 * a + b)

सटीक अंकन भाषा से भाषा में भिन्न होता है; ग्रीक हमेशा आवश्यक नहीं है! ;-)

— joel.neely
स्रोत
62

यह लैम्ब्डा कैलकुलस को संदर्भित करता है , जो एक औपचारिक प्रणाली है जिसमें सिर्फ लैम्ब्डा अभिव्यक्ति है, जो एक फ़ंक्शन का प्रतिनिधित्व करता है जो अपने एकमात्र तर्क के लिए एक फ़ंक्शन लेता है और एक फ़ंक्शन देता है। लैम्ब्डा कैलकुलस में सभी कार्य उस प्रकार के होते हैं, अर्थात λ : λ → λ।

लिस्प ने लैम्बडा अवधारणा का उपयोग अपने अनाम फ़ंक्शन शाब्दिक नाम के लिए किया। यह लंबो एक फ़ंक्शन का प्रतिनिधित्व करता है जो दो तर्क लेता है, x और y, और उनके उत्पाद को लौटाता है:

(lambda (x y) (* x y))

इसे इस तरह लागू किया जा सकता है ( 50 का मूल्यांकन ):

((lambda (x y) (* x y)) 5 10)
— मार्क सिडेड
स्रोत
मुझे लगता है कि आपका उपयोग λ : λ -> λभ्रामक है (और वास्तव में अमान्य है)।
— einpoklum
51

लैम्ब्डा कैलकुलस प्रतिस्थापन का एक सुसंगत गणितीय सिद्धांत है। स्कूल गणित में एक उदाहरण के लिए देखता है x+y=5के साथ रखा x−y=1। व्यक्तिगत समीकरणों में हेरफेर करने के तरीकों के साथ-साथ इन दोनों की जानकारी को एक साथ रखना भी संभव है, बशर्ते कि क्रॉस-समीकरण विकल्प तार्किक रूप से किए जाएं। लैम्ब्डा कैलकुलस इन प्रतिस्थापनों को करने के लिए सही तरीके से कोड करता है।

यह देखते हुए कि y = x−1दूसरे समीकरण की एक वैध व्यवस्था है, λ y = x−1इसका मतलब है : प्रतीक के x−1लिए प्रतीकों को प्रतिस्थापित करने वाला एक फ़ंक्शन y। अब λ yपहले समीकरण में प्रत्येक पद पर आवेदन करने की कल्पना करें । यदि कोई पद है yतो प्रतिस्थापन करें; अन्यथा कुछ न करें। यदि आप इसे पेपर पर करते हैं, तो आप देखेंगे कि कैसे आवेदन करने λ yसे पहला समीकरण हल हो जाएगा।

यह किसी भी कंप्यूटर विज्ञान या प्रोग्रामिंग के बिना एक जवाब है।

सबसे सरल प्रोग्रामिंग उदाहरण मैं http://en.wikipedia.org/wiki/Joy_(programming_language)#How_it_works से आता है :

यहां बताया गया है कि स्क्वायर फ़ंक्शन को एक अनिवार्य प्रोग्रामिंग भाषा (C) में कैसे परिभाषित किया जा सकता है:

int square(int x)
{
    return x * x;
}

चर x एक औपचारिक पैरामीटर है जिसे फ़ंक्शन कहा जाने पर वास्तविक मान से बदल दिया जाता है। एक कार्यात्मक भाषा (योजना) में समान कार्य को परिभाषित किया जाएगा:

(define square
  (lambda (x) 
    (* x x)))

यह कई मायनों में अलग है, लेकिन यह अभी भी उसी तरह से औपचारिक पैरामीटर x का उपयोग करता है।

जोड़ा गया: http://imgur.com/a/XBHub

लैम्ब्डा

— isomorphismes
स्रोत
14

थोड़ा-सा ओवरसाइम्प्लिफ़ाइड: एक लैम्ब्डा फ़ंक्शन वह होता है जिसे अन्य कार्यों के लिए राउंड पास किया जा सकता है और यह लॉजिक एक्सेस होता है।

सी # में लैम्ब्डा सिंटैक्स को अक्सर उसी तरीके से सरल तरीकों से संकलित किया जाता है जैसे गुमनाम प्रतिनिधियों को, लेकिन इसे भी तोड़ा जा सकता है और इसके तर्क पढ़े जाते हैं।

उदाहरण के लिए (C # 3 में):

LinqToSqlContext.Where( 
    row => row.FieldName > 15 );

LinqToSql उस फ़ंक्शन (x> 15) को पढ़ सकता है और इसे अभिव्यक्ति ट्री का उपयोग करके निष्पादित करने के लिए वास्तविक SQL में परिवर्तित कर सकता है।

ऊपर बयान हो जाता है:

select ... from [tablename] 
where [FieldName] > 15      --this line was 'read' from the lambda function

यह सामान्य तरीकों या अनाम प्रतिनिधियों (जो वास्तव में सिर्फ संकलक जादू हैं) से अलग है क्योंकि उन्हें पढ़ा नहीं जा सकता है ।

C # में सभी तरीके नहीं जो लैम्ब्डा सिंटैक्स का उपयोग करते हैं, उन्हें अभिव्यक्ति पेड़ों (यानी वास्तविक लैम्ब्डा कार्यों) के लिए संकलित किया जा सकता है। उदाहरण के लिए:

LinqToSqlContext.Where( 
    row => SomeComplexCheck( row.FieldName ) );

अब अभिव्यक्ति ट्री को नहीं पढ़ा जा सकता है - SomeComplexCheck को तोड़ा नहीं जा सकता। एसक्यूएल स्टेटमेंट जहां के बिना निष्पादित करेगा, और डेटा में प्रत्येक पंक्ति के माध्यम से डाला जाएगा SomeComplexCheck।

अनाम विधियों के साथ लैम्ब्डा कार्यों को भ्रमित नहीं किया जाना चाहिए। उदाहरण के लिए:

LinqToSqlContext.Where( 
    delegate ( DataRow row ) { 
        return row.FieldName > 15; 
    } );

इसका एक 'इनलाइन' फ़ंक्शन भी है, लेकिन इस बार यह सिर्फ कंपाइलर मैजिक है - C # कंपाइलर इसे ऑटोजेनरेटेड नाम के साथ एक नई इंस्टेंस विधि से विभाजित करेगा।

अनाम विधियों को पढ़ा नहीं जा सकता है, और इसलिए तर्क का अनुवाद नहीं किया जा सकता क्योंकि यह लंबोदर कार्यों के लिए हो सकता है।

— कीथ
स्रोत
7

मुझे इस लेख में लैम्ब्डा की व्याख्या पसंद है: LINQ का विकास और सी # के डिजाइन पर इसका प्रभाव । यह मेरे लिए बहुत मायने रखता है क्योंकि यह लैम्ब्डा के लिए एक वास्तविक दुनिया दिखाता है और इसे एक व्यावहारिक उदाहरण के रूप में बनाता है।

उनकी त्वरित व्याख्या: लैम्ब्डा डेटा के रूप में कोड (फ़ंक्शन) का इलाज करने का एक तरीका है।

— जॉन गैलोवे
स्रोत
7

रूबी में एक मेमने का एक उदाहरण इस प्रकार है:

hello = lambda do
    puts('Hello')
    puts('I am inside a proc')
end

hello.call

निम्नलिखित आउटपुट उत्पन्न करेगा:

Hello
I am inside a proc
— CodingWithoutComments
स्रोत
5

@ ब्रायन मैं लिनक्यू और नॉन-लाइनक्यू ऑपरेटरों में सी # के सभी समय का उपयोग करता है। उदाहरण:

string[] GetCustomerNames(IEnumerable<Customer> customers)
 { return customers.Select(c=>c.Name);
 }

सी # से पहले, मैंने एजेक्स कार्यों के लिए कॉलबैक के लिए जावास्क्रिप्ट में अनाम कार्यों का उपयोग किया था, इससे पहले कि अजाक्स को भी गढ़ा गया था:

getXmlFromServer(function(result) {/*success*/}, function(error){/*fail*/});

हालांकि, सी # लैंबडा सिंटैक्स के साथ दिलचस्प बात यह है कि अपने दम पर उनके प्रकार का अनुमान नहीं लगाया जा सकता है (यानी, आप var foo = (x, y) => x * y) टाइप नहीं कर सकते हैं, लेकिन वे किस प्रकार पर निर्भर करते हैं सौंपा गया है, वे अभिव्यक्ति का प्रतिनिधित्व करने वाले प्रतिनिधियों या अमूर्त वाक्यविन्यास पेड़ों के रूप में संकलित किए जाएंगे (जो कि LINQ ऑब्जेक्ट मैपर्स उनके "भाषा-एकीकृत" जादू करते हैं)।

एलआईएसपी में लंबोदर को एक उद्धरण ऑपरेटर के पास भी भेजा जा सकता है और फिर सूची की सूची के रूप में ट्रेस किया जा सकता है। कुछ शक्तिशाली मैक्रों को इस तरह से बनाया गया है।

— मार्क सिडेड
स्रोत
5

प्रश्न का औपचारिक रूप से बहुत उत्तर दिया गया है, इसलिए मैं इस पर और अधिक जोड़ने की कोशिश नहीं करूंगा।

बहुत सरल में, अनौपचारिक शब्दों में किसी को जो गणित या प्रोग्रामिंग पर बहुत कम या कुछ भी नहीं जानता है, मैं इसे एक छोटे "मशीन" या "बॉक्स" के रूप में समझाऊंगा जो कुछ इनपुट लेता है, कुछ काम करता है और कुछ आउटपुट का उत्पादन करता है, जिसका कोई विशेष नाम नहीं है , लेकिन हम जानते हैं कि यह कहाँ है और इस ज्ञान के द्वारा, हम इसका उपयोग करते हैं।

व्यावहारिक रूप से, एक व्यक्ति के लिए जो जानता है कि एक फ़ंक्शन क्या है, मैं उन्हें बताऊंगा कि यह एक ऐसा फ़ंक्शन है जिसका कोई नाम नहीं है, आमतौर पर स्मृति में एक बिंदु पर रखा जाता है जो कि बस उस मेमोरी का संदर्भ लेकर इस्तेमाल किया जा सकता है (आमतौर पर उपयोग के माध्यम से एक चर - अगर उन्होंने फ़ंक्शन पॉइंटर्स की अवधारणा के बारे में सुना है, तो मैं उन्हें एक समान अवधारणा के रूप में उपयोग करूंगा) - यह उत्तर सुंदर मूल बातें (क्लोजर आदि का कोई उल्लेख नहीं है) को कवर करता है, लेकिन एक बिंदु आसानी से प्राप्त कर सकता है।

— निक लोलौदाकिस
स्रोत
4

सिर्फ इसलिए कि मैं यहाँ एक C ++ 11 उदाहरण नहीं देख सकता, मैं यहाँ से यह अच्छा उदाहरण पोस्ट करूँगा । खोज करने के बाद, यह सबसे स्पष्ट भाषा विशिष्ट उदाहरण है जो मुझे मिल सकता है।

हैलो, लैम्ब्डा, संस्करण 1

template<typename F>

void Eval( const F& f ) {
        f();
}
void foo() {
        Eval( []{ printf("Hello, Lambdas\n"); } );
}

हैलो, लैम्ब्डा, संस्करण 2:

void bar() {
    auto f = []{ printf("Hello, Lambdas\n"); };
    f();
}
— learnvst
स्रोत
3

मुझे लैम्बडा एक्सप्रेशंस के आसपास अपना सिर लपेटने में परेशानी होती है क्योंकि मैं विजुअल फॉक्सप्रो में काम करता हूं, जिसमें मैक्रो प्रतिस्थापन और एक्जिकस्क्रिप्ट {} और मूल्यांकन () फंक्शंस हैं, जो एक ही उद्देश्य को पूरा करते हैं।

? Calculator(10, 23, "a + b")
? Calculator(10, 23, "a - b");

FUNCTION Calculator(a, b, op)
RETURN Evaluate(op)

औपचारिक लैम्ब्डा का उपयोग करने का एक निश्चित लाभ (मुझे लगता है) संकलन-समय की जाँच है: फॉक्स को पता नहीं चलेगा कि क्या आप ऊपर दिए गए पाठ स्ट्रिंग को टाइप करते हैं जब तक कि वह इसे चलाने की कोशिश नहीं करता।

यह डेटा-संचालित कोड के लिए भी उपयोगी है: आप डेटाबेस में मेमो फ़ील्ड में संपूर्ण रूटीन संग्रहीत कर सकते हैं और फिर रन-टाइम पर उनका मूल्यांकन कर सकते हैं। यह आपको एप्लिकेशन को वास्तव में स्रोत तक पहुंच के बिना भाग का हिस्सा बनाने देता है। (लेकिन यह एक और विषय है।)

— SarekOfVulcan
स्रोत
3

कंप्यूटर विज्ञान की दुनिया में एक लैम्ब्डा के बिना एक व्यक्ति के लिए क्या है?

मैं इसे सरल और पठनीय पायथन कोड में सहज ज्ञान युक्त कदम से समझाऊंगा।

संक्षेप में, एक लंबोदर सिर्फ एक अनाम और इनलाइन फ़ंक्शन है।

चलो lambdasमूल अंकगणित की पृष्ठभूमि के साथ एक नए व्यक्ति के रूप में समझने के लिए असाइनमेंट से शुरू करते हैं।

असाइनमेंट का ब्लूप्रिंट 'नाम = मान' है, देखें:

In [1]: x = 1
   ...: y = 'value'
In [2]: x
Out[2]: 1
In [3]: y
Out[3]: 'value'

'x', '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 और 'मान') प्रकार और सरल अभिव्यक्ति (n ** 2 + 2 * n + 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 प्रकार हैं । सरल कथन - अजगर 3.6.3 प्रलेखन

कैसे यौगिक बयान के बारे में,

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' मूल्य है। :'=' का एक प्रकार है।
इसे ढूंढें, अगर सिर्फ समझ के लिए, सब कुछ असाइनमेंट से शुरू होता है और सब कुछ असाइनमेंट है।

अब लौटते हैं lambda, हमारे पास 'm' नाम का एक फंक्शन है।

प्रयत्न:

In [28]: m = m(3)
In [29]: m
Out[29]: 16

यहाँ 'एम' के दो नाम हैं, फंक्शन में mपहले से ही एक नाम है, डुप्लिकेट।

यह स्वरूपण की तरह है:

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

इसे 'अनाम फ़ंक्शन' कहा जाता है

निष्कर्ष के तौर पर,

  1. lambda इनलाइन फ़ंक्शन जो आपको गणित में एक सीधी रेखा में फ़ंक्शन लिखने में सक्षम बनाता है
  2. lambda अनाम है

उम्मीद है की यह मदद करेगा।

— गणना
स्रोत
2

यह एक ऐसा फंक्शन है जिसका कोई नाम नहीं है। उदाहरण के लिए c # में आप उपयोग कर सकते हैं

numberCollection.GetMatchingItems<int>(number => number > 5);

5 से अधिक की संख्या को वापस करने के लिए।

number => number > 5

यहाँ लंबोदर भाग है। यह एक फ़ंक्शन का प्रतिनिधित्व करता है जो एक पैरामीटर (संख्या) लेता है और एक बूलियन मान (संख्या> 5) देता है। GetMatchingItems विधि संग्रह में सभी वस्तुओं पर इस लैम्ब्डा का उपयोग करती है और मिलान वाली वस्तुओं को वापस करती है।

— सेहत ओजगेल
स्रोत
2

जावास्क्रिप्ट में, उदाहरण के लिए, कार्यों और सब कुछ के रूप में ही मिश्रित प्रकार के रूप में इलाज कर रहे हैं ( 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]()()();
— माइकल - क्ले क्ले शर्की
स्रोत
2

सीएस के संदर्भ में एक लंबोदर फ़ंक्शन एक सार गणितीय अवधारणा है जो गणितीय अभिव्यक्तियों के प्रतीकात्मक मूल्यांकन की समस्या से निपटता है। उस संदर्भ में एक लंबदा फ़ंक्शन लंबोदर शब्द के समान है ।

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

— battlmonstr
स्रोत
2

ए Lambda Function, या ए , Small Anonymous Functionकार्यक्षमता का एक आत्म-निहित ब्लॉक है जिसे आपके कोड में इधर-उधर से और पास किया जा सकता है। - Lambda अलग अलग प्रोग्रामिंग भाषाओं में नाम हैं Lambdaमें अजगर और Kotlin , Closureमें स्विफ्ट , या Blockमें सी और ऑब्जेक्टिव-सी । हालांकि लैम्बडा का अर्थ इन भाषाओं के लिए काफी समान है लेकिन इसमें कभी-कभी मामूली अंतर होता है।

आइए देखें कि लैम्पडा (क्लोजर) स्विफ्ट 4.2 में छंटनी () विधि के साथ कैसे काम करती है - सामान्य फ़ंक्शन से सबसे छोटी अभिव्यक्ति तक:

let coffee: [String] = ["Cappuccino", "Espresso", "Latte", "Ristretto"]

1. सामान्य समारोह

func backward(_ n1: String, _ n2: String) -> Bool {
    return n1 > n2
}
var reverseOrder = coffee.sorted(by: backward)


// RESULT: ["Ristretto", "Latte", "Espresso", "Cappuccino"]

2. बंद होने का भाव

reverseOrder = coffee.sorted(by: { (n1: String, n2: String) -> Bool in
    return n1 > n2
})

3. इनलाइन क्लोजर एक्सप्रेशन

reverseOrder = coffee.sorted(by: { (n1: String, n2: String) -> Bool in return n1 > n2 } )

4. प्रसंग से संदर्भ प्रकार

reverseOrder = coffee.sorted(by: { n1, n2 in return n1 > n2 } )

5. सिंगल-एक्सप्रेशन क्लोजर से इंप्लिमेंटेड रिटर्न

reverseOrder = coffee.sorted(by: { n1, n2 in n1 > n2 } )

6. आशुलिपि तर्क नाम

reverseOrder = coffee.sorted(by: { $0 > $1 } )

// $0 and $1 are closure’s first and second String arguments.

7. ऑपरेटर के तरीके

reverseOrder = coffee.sorted(by: >)

// RESULT: ["Ristretto", "Latte", "Espresso", "Cappuccino"]

उम्मीद है की यह मदद करेगा।

— एंडी
स्रोत
1

मुझे भी मिल गया। I`ve ने इसे इस एक के साथ JS में आज़माया:

var addAndMult = function(x) {
        return (function(y) {
            return (function(z) {
                return (x+y)*z; 
                });
            });
        };

यह 2 से 4 को जोड़ता है, फिर 6 से परिणाम निकालता है। हालांकि मुझे यह कभी-कभी पढ़ने में कठिन लगता है :(

इसके अलावा, मैं `एक दिलचस्प 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);

यह विधि एक सरणी को पुनरावृत्त करेगी और कंसोल में प्रिंटिंग के मामले में - एक कार्रवाई करेगी। अब मुझे भी पता चल गया है कि लैबमाडा शक्तिशाली क्यों हैं।

— इलियान जैप्रीनोव
स्रोत
1

कंप्यूटर प्रोग्रामिंग में, लैम्ब्डा कोड (स्टेटमेंट, एक्सप्रेशन या उनमें से एक समूह) का एक टुकड़ा है जो बाहरी स्रोत से कुछ तर्क लेता है। यह हमेशा एक अनाम फ़ंक्शन नहीं होना चाहिए - हमारे पास उन्हें लागू करने के कई तरीके हैं।

हमारे पास अभिव्यक्तियों, कथनों और कार्यों के बीच स्पष्ट अलगाव है, जो गणितज्ञों के पास नहीं है।

प्रोग्रामिंग में "फ़ंक्शन" शब्द भी अलग है - हमारे पास "फ़ंक्शन करने के लिए चरणों की एक श्रृंखला है" (लैटिन "प्रदर्शन" से)। गणित में यह चर के बीच संबंध के बारे में कुछ है।

कार्यात्मक भाषाएं यथासंभव गणित के सूत्रों के समान होने की कोशिश कर रही हैं, और उनके शब्दों का अर्थ लगभग समान है। लेकिन अन्य प्रोग्रामिंग भाषाओं में हमारे पास यह अलग है।

— konmik
स्रोत
0

प्रश्न का पूरी तरह से उत्तर दिया गया है, मैं विवरण में नहीं जाना चाहता। मैं जंग में संख्यात्मक गणना लिखते समय उपयोग साझा करना चाहता हूं।

एक मेमना का एक उदाहरण है (अनाम फ़ंक्शन)

let f = |x: f32| -> f32 { x * x - 2.0 };
let df = |x: f32| -> f32 { 2.0 * x };

जब मैं न्यूटन-रैपसन विधि का एक मॉड्यूल लिख रहा था, तो इसका उपयोग पहले और दूसरे क्रम के व्युत्पन्न के रूप में किया गया था। (यदि आप जानना चाहते हैं कि न्यूटन-रैपसन विधि क्या है, तो कृपया " https://en.wikipedia.org/wiki/Newton%27s_method " पर जाएं ।

निम्नलिखित के रूप में उत्पादन

println!("f={:.6}      df={:.6}", f(10.0), df(10.0))

f=98.000000       df=20.000000
— madeinQuant
स्रोत
0

कल्पना करें कि आपके पास डिलीवरी विकल्प वाला एक रेस्तरां है और आपके पास एक आदेश है जिसे 30 मिनट के भीतर करने की आवश्यकता है। बात यह है कि ग्राहक आमतौर पर परवाह नहीं करते हैं यदि आप कार या नंगे पांव बाइक से अपना भोजन भेजते हैं जब तक आप भोजन को गर्म रखते हैं और बांधते हैं। तो इस मुहावरे को गुमनाम और परिभाषित परिवहन कार्यों के साथ जावास्क्रिप्ट में परिवर्तित करें।

नीचे हमने अपने पहुंचाने के तरीके को परिभाषित किया है जिसे हम एक फ़ंक्शन के नाम से परिभाषित करते हैं:

// ES5 
var food = function withBike(kebap, coke) {
return (kebap + coke); 
};

यदि हम इस हस्तांतरण को पूरा करने के लिए तीर / लैम्ब्डा कार्यों का उपयोग करेंगे तो क्या होगा:

// ES6    
const food = (kebap, coke) => { return kebap + coke };

आप देखते हैं कि ग्राहक के लिए कोई अंतर नहीं है और यह सोचने के लिए कोई समय बर्बाद नहीं है कि भोजन कैसे भेजा जाए। बस भेज दो।

Btw, मैं कोक के साथ कबाब की सिफारिश नहीं करता हूं यही कारण है कि ऊपरी कोड आपको त्रुटियां देंगे। मज़े करो।

— akinov
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.