পাইথন ল্যাম্বডা এক্সপ্রেশনটিতে একাধিক বক্তব্য থাকা কি সম্ভব?

Question

আমি একটি অজগর নবাগত নিম্নলিখিতটি অর্জনের চেষ্টা করছি:

আমার তালিকাগুলির একটি তালিকা রয়েছে:

lst = [[567,345,234],[253,465,756, 2345],[333,777,111, 555]]

আমি প্রতিটি সাবলিস্ট থেকে দ্বিতীয় বৃহত্তম সংখ্যার সমন্বিত অন্য তালিকায় ম্যাপটি চাই না। সুতরাং ফলাফলটি হওয়া উচিত:

[345, 465, 333]

উদাহরণস্বরূপ, যদি আমি কেবলমাত্র ক্ষুদ্রতম সংখ্যায় আগ্রহী, আমি এটি করতে পারি:

map(lambda x: min(x),lst)

আমি আশা করি আমি এটি করতে পারতাম:

map(lambda x: sort(x)[1],lst)

কিন্তু সাজানোর শৃঙ্খল হয় না। (কিছুই ফেরেনি)

উভয়ই এর মতো কিছু অনুমোদিত নয়:

map(lambda x: sort(x); x[1],lst) #hence the multiple statement question

অজগরটিতে মানচিত্র সহ এটি করার কোনও উপায় আছে তবে কোনও নামকৃত কার্যকারিতা সংজ্ঞায়িত না করে ? (উদাহরণস্বরূপ, রুবিতে বেনামে থাকা ব্লকগুলি সহ এটি সহজ)

Comments

অবশ্যই এটি সম্ভব হওয়া উচিত .. সম্ভবত কোনও নতুন সংস্করণে ...

— ZEE

আপনি বিবৃতি কার্যকর করতে পারবেন না তবে আপনি ল্যাম্বডা ফাংশনে ফাংশনগুলি কল করতে পারবেন, তাই অযথাইথনিক নোংরা হ্যাক lambda x: sort(x) OR x[1]কাজ করবে: এখানে OR তার প্রথম আর্গুমেন্টকে (রিটার্ন ভ্যালু কিছুই নয়) একটি বুল (=> মিথ্যা) হিসাবে মূল্যায়ন করে এবং সেই ক্ষেত্রে বা এটি তার দ্বিতীয় যুক্তি ফিরিয়ে দেয়। তবে উত্তর হিসাবে, ভাল ল্যাম্বডা এড়ানো ভাল।

— সর্বোচ্চ

Answer 1

আপনার নির্দিষ্ট প্রশ্ন থেকে শুরু করে আরও সাধারণ উদ্বেগের জন্য আমি এখানে বিভিন্ন রকম উত্তর দিতে পারি। সুতরাং সবচেয়ে সাধারণ থেকে সর্বাধিক নির্দিষ্ট:

প্র: আপনি একটি ল্যাম্বডায় একাধিক বিবৃতি রাখতে পারেন?

উ: না। তবে আপনার আসলে ল্যাম্বডা ব্যবহার করার দরকার নেই। আপনি বিবৃতি একটিতে রাখতে পারেনdef পরিবর্তে । অর্থাৎ,

def second_lowest(l):
    l.sort()
    return l[1]

map(second_lowest, lst)

প্র: তালিকাটি বাছাই করে আপনি কি কোনও ল্যাম্বদা থেকে দ্বিতীয় সর্বনিম্ন আইটেমটি পেতে পারেন?

উ: হ্যাঁ অ্যালেক্সের উত্তর হিসাবে পয়েন্ট আউট, sorted()যে বরং ইন-জায়গা বাছাই চেয়ে একটি নতুন তালিকা তৈরি করে, এবং শৃঙ্খলিত করা যেতে পারে সাজানোর একটি সংস্করণ। নোট করুন যে এটি সম্ভবত আপনার ব্যবহার করা উচিত - আপনার মানচিত্রের মূল তালিকার পার্শ্ব প্রতিক্রিয়া থাকা খারাপ অভ্যাস।

প্র: তালিকার ক্রমে প্রতিটি তালিকা থেকে দ্বিতীয় সর্বনিম্ন আইটেমটি কীভাবে পাব?

উ: এটির sorted(l)[1] পক্ষে আসলে সর্বোত্তম উপায় নয়। এটিতে ও (এন লগ (এন)) জটিলতা রয়েছে, যখন একটি ও (এন) সমাধান বিদ্যমান। এটি হ্যাপাক মডিউলটিতে পাওয়া যাবে।

>>> import  heapq
>>> l = [5,2,6,8,3,5]
>>> heapq.nsmallest(l, 2)
[2, 3]

সুতরাং কেবল ব্যবহার করুন:

map(lambda x: heapq.nsmallest(x,2)[1],  list_of_lists)

এটি সাধারণত তালিকা বোধগম্যতা পরিষ্কার করার জন্য বিবেচিত হয়, যা ল্যাম্বডাকে পুরোপুরি এড়িয়ে চলে:

[heapq.nsmallest(x,2)[1] for x in list_of_lists]

Comments

আমি মনে করি না যে আপনি হ্যাপেক মডিউলটিতে ও (এন) সমাধান পাওয়া যায় নি ঠিক। আপনি সেখানে যা করছেন সবগুলি হ'ল তালিকে বাছাই করা হচ্ছে যা হে (এন লগ এন) এবং তারপরে ক্ষুদ্রতম উপাদানগুলি সন্ধান করা।

— avpx

ডকুমেন্টেশন ( ডকস.পাইথন.আর. / ২ / লিবারি / হিপকি.ইচটিএমএল#heapq.nsmallest ) প্রকৃতপক্ষে সতর্ক করে দিয়েছে যে heapq.nsmallest () ব্যবহার করা কেবলমাত্র বাছাই করা () ব্যবহারের চেয়ে কম দক্ষ হতে পারে, সুতরাং কেবলমাত্র পরিমাপই বলতে পারে কোন সমাধানটি আপনার ক্ষেত্রে দ্রুততম heapq.nsmallest () তবে ও (কে * লগ (এন) + এন) এর জটিলতা রয়েছে বলে আমি মনে করি, n এর দৈর্ঘ্যের দৈর্ঘ্যের সাথে এবং কে আপনি যে ক্ষুদ্রতম আইটেমগুলি উত্তোলন করতে চান তার সংখ্যাটি সহ। O (n) তালিকাটি হিপিফায়েড করতে এবং কে আইটেমগুলি পপ করতে O (লগ (এন)) বার করুন। এটি ও (এন * লগ (এন)) এর চেয়ে ভাল, বিশেষত ছোট কে।

— ভেরটেক্সফাইভ

@ ভার্টেক্সফাইভ এবং ধ্রুবক kহিসাবে (এখানে 'দ্বিতীয় সর্বনিম্ন' হিসাবে) O(k*log(n)+n)সহজ করে তোলেO(n)

— ডানকান

প্রযুক্তিগতভাবে আপনার ওয়ান-লাইনারের জন্য ল্যাম্বডা লাগবে না তবে এটি অবশ্যই আরও সুবিধাজনক। আশা করি আরও ভাল ল্যাম্বদা সমর্থন পরে যুক্ত হবে।

— জেমস

@avpx: এটি হিপসোর্ট নয়। পুরো তালিকাটি হিপিফাই করা এবং হিপসোর্ট হিসাবে সমস্ত উপাদানকে পপ করার পরিবর্তে আমরা কেবলমাত্র 2 টি ক্ষুদ্রতম আইটেমগুলির একটি 2-উপাদান হিপ বজায় রাখি।

— ব্যবহারকারী 2357112

Answer 2

বিবৃতি একটি তালিকায় রাখা একাধিক বিবৃতি অনুকরণ করতে পারে:

উদাহরণ:

lambda x: [f1(x), f2(x), f3(x), x+1]

Comments

কেবল পরিষ্কার করার জন্য, ফাংশন কলগুলি পাইথনে স্টেটমেন্ট হিসাবে বিবেচনা করা হয় না, এগুলি হল এক্সপ্রেশন। সুতরাং এই তালিকাটি কেবলমাত্র প্রকাশের একটি তালিকা, যা সমস্ত হতে পারে None।

— ইয়াওয়ার

আমি মনে করি এটি কাজ করে কারণ ল্যাম্বডায় পাসের সংগ্রহটি যখন গতিশীলভাবে বিশ্লেষণ করা হয় তখন দোভাষী কলযোগ্য স্বাক্ষরগুলি সনাক্ত করে এবং তাদের সম্পাদন করে ... আপনি -> ল্যাম্বদা এক্স দিয়ে পরীক্ষা করতে পারেন: [মুদ্রণ (এক্স), মুদ্রণ (x + 1), মুদ্রণ (এক্স) +2)]

— ZEE

আরও ভাল: ল্যাম্বডা এক্স: [এফ 1 (এক্স), এফ 2 (এক্স)] [- 1], এটি গণনা ফলাফল ফর্মটি শেষ প্রকাশ হিসাবে প্রত্যাশিত হিসাবে প্রত্যাবর্তন করবে।

— আন্তন ওভসায়ানিকভ

Answer 3

সময় ভ্রমণকারী এখানে। যদি আপনি সাধারণত কোনও ল্যাম্বডায় একাধিক বক্তব্য রাখতে চান তবে আপনি অন্য ল্যাম্বডাসটিকে সেই ল্যাম্বডায় আর্গুমেন্ট হিসাবে পাস করতে পারেন।

(lambda x, f: list((y[1] for y in f(x))))(lst, lambda x: (sorted(y) for y in x))

আপনার আসলে একাধিক বিবৃতি থাকতে পারে না, তবে আপনি ল্যাম্বডাসকে ল্যাম্বডাসে করে তা অনুকরণ করতে পারেন।

সম্পাদনা: সময় ভ্রমণকারী ফিরে! চেইন ক্রিয়াকলাপগুলিতে আপনি বুলিয়ান এক্সপ্রেশনগুলির (সংক্ষিপ্ত-সার্কিট বিধি এবং সত্যতার কথা মাথায় রেখে) ব্যবহারের অপব্যবহার করতে পারেন। টেরিনারি অপারেটর ব্যবহার করা আপনাকে আরও বেশি শক্তি দেয়। আবার, আপনার একাধিক বিবৃতি থাকতে পারে না তবে অবশ্যই আপনার অনেক ফাংশন কল থাকতে পারে। এই উদাহরণটি একগুচ্ছ ডেটা সহ কিছুটা স্বেচ্ছাসেবী জঙ্ক করে তবে এটি দেখায় যে আপনি কিছু মজার স্টাফ করতে পারেন। মুদ্রণ বিবরণী ফাংশনগুলির উদাহরণ যা পদ্ধতি None(যেমন .sort()পদ্ধতিটি ফিরে আসে ) তবে তারা কী করছে lambdaতা দেখাতেও সহায়তা করে।

>>> (lambda x: print(x) or x+1)(10)
10
11
>>> f = (lambda x: x[::2] if print(x) or x.sort() else print(enumerate(x[::-1]) if print(x) else filter(lambda (i, y): print((i, y)) or (i % 3 and y % 2), enumerate(x[::-1]))))
>>> from random import shuffle
>>> l = list(range(100))
>>> shuffle(l)
>>> f(l)
[84, 58, 7, 99, 17, 14, 60, 35, 12, 56, 26, 48, 55, 40, 28, 52, 31, 39, 43, 96, 64, 63, 54, 37, 79, 25, 46, 72, 10, 59, 24, 68, 23, 13, 34, 41, 94, 29, 62, 2, 50, 32, 11, 97, 98, 3, 70, 93, 1, 36, 87, 47, 20, 73, 45, 0, 65, 57, 6, 76, 16, 85, 95, 61, 4, 77, 21, 81, 82, 30, 53, 51, 42, 67, 74, 8, 15, 83, 5, 9, 78, 66, 44, 27, 19, 91, 90, 18, 49, 86, 22, 75, 71, 88, 92, 33, 89, 69, 80, 38]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
(0, 99)
(1, 98)
(2, 97)
(3, 96)
(4, 95)
(5, 94)
(6, 93)
(7, 92)
(8, 91)
(9, 90)
(10, 89)
(11, 88)
(12, 87)
(13, 86)
(14, 85)
(15, 84)
(16, 83)
(17, 82)
(18, 81)
(19, 80)
(20, 79)
(21, 78)
(22, 77)
(23, 76)
(24, 75)
(25, 74)
(26, 73)
(27, 72)
(28, 71)
(29, 70)
(30, 69)
(31, 68)
(32, 67)
(33, 66)
(34, 65)
(35, 64)
(36, 63)
(37, 62)
(38, 61)
(39, 60)
(40, 59)
(41, 58)
(42, 57)
(43, 56)
(44, 55)
(45, 54)
(46, 53)
(47, 52)
(48, 51)
(49, 50)
(50, 49)
(51, 48)
(52, 47)
(53, 46)
(54, 45)
(55, 44)
(56, 43)
(57, 42)
(58, 41)
(59, 40)
(60, 39)
(61, 38)
(62, 37)
(63, 36)
(64, 35)
(65, 34)
(66, 33)
(67, 32)
(68, 31)
(69, 30)
(70, 29)
(71, 28)
(72, 27)
(73, 26)
(74, 25)
(75, 24)
(76, 23)
(77, 22)
(78, 21)
(79, 20)
(80, 19)
(81, 18)
(82, 17)
(83, 16)
(84, 15)
(85, 14)
(86, 13)
(87, 12)
(88, 11)
(89, 10)
(90, 9)
(91, 8)
(92, 7)
(93, 6)
(94, 5)
(95, 4)
(96, 3)
(97, 2)
(98, 1)
(99, 0)
[(2, 97), (4, 95), (8, 91), (10, 89), (14, 85), (16, 83), (20, 79), (22, 77), (26, 73), (28, 71), (32, 67), (34, 65), (38, 61), (40, 59), (44, 55), (46, 53), (50, 49), (52, 47), (56, 43), (58, 41), (62, 37), (64, 35), (68, 31), (70, 29), (74, 25), (76, 23), (80, 19), (82, 17), (86, 13), (88, 11), (92, 7), (94, 5), (98, 1)]

Answer 4

এই মত সাজানো ফাংশন ব্যবহার করুন :

map(lambda x: sorted(x)[1],lst)

Comments

আহ। ধন্যবাদ। (ফাংশনটির জন্য বর্ণনামূলক নাম কী!) লাম্বদা অংশের মধ্যে একাধিক বিবৃতি সম্পর্কে এখনও কৌতূহল রয়েছে। সম্ভব?

— অটোদিডাক্ট

নাহ, "ল্যাম্বদা ফর্মগুলির সাথে তৈরি ফাংশনগুলিতে বিবৃতি থাকতে পারে না"। docs.python.org/references/expressions.html#lambda

— অ্যালেক্স ভাসি

-1: লাম্বদা এবং মানচিত্রের পরিবর্তে তালিকা বোঝার জন্য? খুব অজগর নয়।

— নিকো 14'09

সাজানো (তালিকা) x এর জন্য @ নাইকো [এক্স [1]] - পাইথোনিক উপায়?

— রাগা__ এম

@ এক্সপ্লোরার_এন: তালিকাটি অবশ্যই বাছাই করা উচিত নয়, তবে তালিকার উপাদানগুলি (যা তালিকাগুলি) বর্তমান সমস্যাটিতে বাছাই করতে হবে। তাই বরং: [sorted(x)[1] for x in list_of_lists]।

— সর্বাধিক

Answer 5

পাইথনে ল্যাম্বডা এক্সপ্রেশনটিতে আপনার একাধিক বক্তব্য থাকতে পারে। এটি সম্পূর্ণ তুচ্ছ নয় তবে আপনার উদাহরণে নিম্নলিখিত কাজ করে:

map(lambda x: x.sort() or x[1],lst)

আপনাকে অবশ্যই নিশ্চিত করতে হবে যে প্রতিটি বিবৃতি কোনও কিছু ফেরত না দেয় বা এটি এতে (.. এবং মিথ্যা) মোড়কে দেয়। ফলাফলটিই শেষ মূল্যায়ন দ্বারা ফিরে আসে।

উদাহরণ:

>>> f = (lambda : (print(1) and False) or (print(2) and False) or (print(3) and False))
>>> f()
1
2
3

Answer 6

এখান থেকে শুরু () ব্যবহার করুন: http://www.reddit.com/r/Python/comments/hms4z/ask_pyreddit_if_you_were_making_your_own/c1wycci

Python 3.2 (r32:88445, Mar 25 2011, 19:28:28) 
[GCC 4.5.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> lst = [[567,345,234],[253,465,756, 2345],[333,777,111, 555]]
>>> begin = lambda *args: args[-1]
>>> list(map(lambda x: begin(x.sort(), x[1]), lst))
[345, 465, 333]

Answer 7

পাইথনের একক বিবৃতিতে একাধিক বক্তব্য একত্রিত করার একটি হ্যাকি উপায় হ'ল "এবং" কীওয়ার্ডকে শর্ট সার্কিট অপারেটর হিসাবে ব্যবহার করা। তারপরে আপনি ল্যাম্বডা এক্সপ্রেশনটির অংশ হিসাবে সরাসরি এই একক বিবৃতিটি ব্যবহার করতে পারেন।

এটি ব্যাশের মতো শেল ভাষাতে শর্ট সার্কিট অপারেটর হিসাবে "&& "ব্যবহার করার মতো।

এছাড়াও নোট করুন: ফাংশন মোড়ানো দ্বারা সত্যিকারের মান ফিরিয়ে দিতে আপনি সবসময় কোনও ফাংশন স্টেটমেন্ট ঠিক করতে পারেন।

উদাহরণ:

def p2(*args):
    print(*args)
    return 1 # a true value

junky = lambda x, y: p2('hi') and p2('there') and p2(x) and p2(y)

junky("a", "b")

দ্বিতীয় চিন্তায়, সম্ভবত অনেকগুলি ফাংশন '0' বা সাফল্যে ফিরে আসে না বলে 'বা' এর পরিবর্তে 'এবং' ব্যবহার করা ভাল। তারপরে আপনি উপরের উদাহরণে মোড়ক ফাংশন থেকে মুক্তি পেতে পারেন:

junky = lambda x, y: print('hi') or print('there') or print(x) or print(y)

junky("a", "b")

'এবং' অপারেটর প্রথম শূন্য ফেরতের মান না পাওয়া পর্যন্ত এক্সপ্রেশনগুলির মূল্যায়ন করবে। যার পরে এটি শর্ট সার্কিট। 1 এবং 1 এবং 0 এবং 1 মূল্যায়ন করে: 1 এবং 1 এবং 0, এবং ড্রপ 1

'বা' অপারেটরটি প্রথম অ-শূন্য ফেরতের মান না পাওয়া পর্যন্ত অভিব্যক্তিগুলির মূল্যায়ন করবে। যার পরে এটি শর্ট সার্কিট।

0 বা 0 বা 1 বা 0 0 বা 0 বা 1 মূল্যায়ন করে এবং 0 টি ড্রপ করে

Answer 8

বা আপনি যদি ল্যাম্বদা এড়াতে চান এবং তালিকার পরিবর্তে একটি জেনারেটর রাখতে চান:

(সাজানো (করল) [1] এলএসটিতে কর্নের জন্য)

Answer 9

আমাকে আপনার কাছে একটি গৌরবময় তবে ভয়ঙ্কর হ্যাক উপস্থাপন করুন:

import types

def _obj():
  return lambda: None

def LET(bindings, body, env=None):
  '''Introduce local bindings.
  ex: LET(('a', 1,
           'b', 2),
          lambda o: [o.a, o.b])
  gives: [1, 2]

  Bindings down the chain can depend on
  the ones above them through a lambda.
  ex: LET(('a', 1,
           'b', lambda o: o.a + 1),
          lambda o: o.b)
  gives: 2
  '''
  if len(bindings) == 0:
    return body(env)

  env = env or _obj()
  k, v = bindings[:2]
  if isinstance(v, types.FunctionType):
    v = v(env)

  setattr(env, k, v)
  return LET(bindings[2:], body, env)

আপনি এখন এই LETফর্মটি ব্যবহার করতে পারেন :

map(lambda x: LET(('_', x.sort()),
                  lambda _: x[1]),
    lst)

যা দেয়: [345, 465, 333]

Comments

মূলত এখানে পোস্ট করেছেন: gist.github.com/divs1210/d218d4b747b08751b2a232260321cdeb

— divs1210

Answer 10

আপনি এটি বা (এন) সময়ে বাছাই বা হ্যাপিকের পরিবর্তে মিনি এবং সূচক ব্যবহার করে করতে পারেন।

প্রথমে মূল তালিকার ন্যূনতম মান বাদে সমস্ত কিছুর নতুন তালিকা তৈরি করুন:

new_list = lst[:lst.index(min(lst))] + lst[lst.index(min(lst))+1:]

তারপরে নতুন তালিকার ন্যূনতম মানটি নিন:

second_smallest = min(new_list)

এখন সবাই একত্রে ল্যাম্বডায়:

map(lambda x: min(x[:x.index(min(x))] + x[x.index(min(x))+1:]), lst)

হ্যাঁ এটি সত্যিই কুরুচিপূর্ণ তবে এটি আলগোরিদিম সস্তা হওয়া উচিত। এছাড়াও যেহেতু এই থ্রেডের কিছু লোকেরা তালিকা উপলব্ধিগুলি দেখতে চান:

[min(x[:x.index(min(x))] + x[x.index(min(x))+1:]) for x in lst]

Answer 11

এটি ঠিক bindএকটি মোনাডে ফাংশনটি জন্য ব্যবহৃত হয়।

সঙ্গে bindফাংশন আপনি এক ল্যামডা, প্রতিটি ল্যামডা এক বিবৃতিতে প্রতিনিধিত্বমূলক একাধিক ল্যামডা এর একত্রিত করতে পারেন।

Answer 12

লাম্বদাতে আপনি একাধিক স্টেটমেন্ট ব্যবহার করতে পারবেন এমন একটি উপায় রয়েছে। আমার সমাধানটি এখানে:

lst = [[567,345,234],[253,465,756, 2345],[333,777,111, 555]]

x = lambda l: exec("l.sort(); return l[1]")

map(x, lst)

Comments

ভিতরে থাকা কোডটি execকোনও বুদ্ধিমান আইডিই

— জাভদ্বা

Answer 13

হ্যাঁ. আপনি এটি এটিকে সংজ্ঞায়িত করতে পারেন এবং তারপরে নিম্নলিখিতগুলির সাথে আপনার একাধিক অভিব্যক্তি মোড়ানো করতে পারেন:

প্রকল্প শুরু:

শুরু = ল্যাম্বদা * এক্স: এক্স [-1]

সাধারণ লিস্প অগ্রগতি:

প্রগন = ল্যাম্বদা * এক্স: এক্স [-1]

Answer 14

ল্যাম্বদা ফাংশনটি ব্যবহার না করে আরও ভাল সমাধান রয়েছে। তবে যদি আমরা সত্যিই ল্যাম্বদা ফাংশনটি ব্যবহার করতে চাই, তবে একাধিক বক্তব্য মোকাবেলার জন্য এখানে একটি জেনেরিক সমাধান রয়েছে: মানচিত্র (ল্যাম্বডা এক্স: এক্স [1] যদি (x.sort ()) অন্য x [1], lst)

বিবৃতিটি কী ফিরিয়ে দেয় তা আপনি সত্যিই চিন্তা করেন না।

Answer 15

হ্যা এটা সম্ভব. কোড স্নিপেট নীচে চেষ্টা করুন।

x = [('human', 1), ('i', 2), ('am', 1), ('.', 1), ('love', 1), ('python', 3), ('', 1),
  ('run', 1), ('is', 2), ('robust', 1), ('hello', 1), ('spark', 2), ('to', 1), ('analysis', 2), ('on', 1), ('big', 1), ('data', 1), ('with', 1), ('analysis', 1), ('great', 1)
]

rdd_filter = rdd1_word_cnt_sum.filter(lambda x: 'python' in x or 'human' in x or 'big' in x)
rdd_filter.collect()

Answer 16

আমি আপনাকে আরও একটি সমাধান দেব, আপনার ল্যাম্বডাকে একটি ফাংশন শুরু করুন।

def multiple_statements(x, y):
    print('hi')
    print('there')
    print(x)
    print(y)
    return 1

junky = lambda x, y: multiple_statements(x, y)

junky('a', 'b');

Comments

আরও ভাল করে: junky = multiple_statements।

— সলোমন উকো